Java设计模式—工厂模式-阿里云开发者社区

工厂模式主要是为创建对象提供了接口。工厂模式分为三类：1. 简单工厂模式(Simple Factory) 2. 工厂方法模式(Factory Method) 3. 抽象工厂模式(Abstract Factory)

三个设计模式名字中都含有“工厂”二字，其含义是使用工厂(一个或一系列方法)去生产产品(一个或一系列类的实例)。

另外，有时候，我们常常会将生产产品的一个或一系列方法封装到一个类中，我习惯把这个类叫做“工厂类”；而被实例化的类称作“产品类”。

下面是使用工厂模式的两种情况：1.在编码时不能预见需要创建哪种类的实例。2.系统不应依赖于产品类实例如何被创建、组合和表达的细节。

一：Simple Factory

简单工厂模式：工厂类(SimpleFactory)拥有一个工厂方法(create)，接受了一个参数，通过不同的参数实例化不同的产品类。

有4个角色

工厂类角色：是具体产品类角色直接调用者。

抽象产品角色：接口或抽象类，负责具体产品角色的定义，及与客户端的交互。

具体产品角色：被工厂类创建的对象，也是客户端实际操作对象。

客户端：调用工厂类产生实例，并调用实例的方法进行相应工作。

抽象产品接口

package cn.design.factory;
public interface DBDriver {
    public void dbConn(String ip);
    public void dbClose();
    public String dbOper();
}

View Code

具体产品接口：

package cn.design.factory;
public class MySqlDriver implements DBDriver{
    @Override
    public void dbConn(String ip) {
        // TODO Auto-generated method stub
        System.out.println("已成功连接到MySql数据库! 数据库地址为"+ip);
    }
    @Override
    public void dbClose() {
        // TODO Auto-generated method stub
        System.out.println("MySql数据库连接已关闭！");
    }
    @Override
    public String dbOper() {
        // TODO Auto-generated method stub
        String s="正在对MySql数据库进行操作";
        System.out.println("正在对MySql数据库进行操作");
        return s;
    }
}

View Code

package cn.design.factory;
public class OracleDriver implements DBDriver{
    @Override
    public void dbConn(String ip) {
        // TODO Auto-generated method stub
        System.out.println("已连接到Oracle数据库 数据库地址为 "+ip);
    }
    @Override
    public void dbClose() {
        // TODO Auto-generated method stub
        System.out.println("已关闭Oracle数据库连接");
    }
    @Override
    public String dbOper() {
        // TODO Auto-generated method stub
        String s="正在对Oracle数据库进行操作";
        System.out.println("正在对Oracle数据库进行操作");
        return s;
    }
}

View Code

package cn.design.factory;
public class DB2Driver implements DBDriver{
    @Override
    public void dbConn(String ip) {
        // TODO Auto-generated method stub
        System.out.println("准备连接DB2数据库: ip地址为："+ ip);
    }
    @Override
    public void dbClose() {
        // TODO Auto-generated method stub
        System.out.println("关闭DB2链接");
    }
    @Override
    public String dbOper() {
        // TODO Auto-generated method stub
        System.out.println("正在对DB2数据库进行操作");
        return null;
    }
}

View Code

工厂类：

package cn.design.factory;
/**
 * 联想到之前写过的多态相关代码
 * 继承关系
 * 重写父类的方法
 * 父类引用指向子类对象
 * @author 翎野君
 *
 */
public class SimpleFactory {
    public static DBDriver getDBDriver(String dbType){
        switch(dbType){
        case "oracle":
            return new OracleDriver();
        case "mysql":
            return new MySqlDriver();
        case "db2":
            return new DB2Driver();
        default:
            return new MySqlDriver();
        }
    }
    public static void main(String[] args) {
        DBDriver db=SimpleFactory.getDBDriver("db2");
        db.dbConn("127.0.0.1");
        db.dbOper();
        db.dbClose();
    }
}

View Code

优点：

(1)很明显，简单工厂的特点就是“简单粗暴”，通过一个含参的工厂方法，我们可以实例化任何产品类，上至飞机火箭，下至土豆面条，无所不能。所以简单工厂有一个别名：上帝类。

缺点：

(1)任何”东西“的子类都可以被生产，负担太重。当所要生产产品种类非常多时，工厂方法的代码量可能会很庞大。

(2)在遵循开闭原则(对拓展开放，对修改关闭)的条件下，简单工厂对于增加新的产品，无能为力。因为增加新产品只能通过修改工厂方法来实现。

二：Factory Method

工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。

工厂方法解决了上述简单工厂上述的两个缺点。

工厂方法由一下四部分组成：

1、抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

2、具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。

3、抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

4、具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

首先完全实现‘开－闭原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

package cn.design.factory;
public class FactoryMethod{
    /**
     * 工厂模式最后对外开放给使用者的就是一个一个的工厂类(Factory)
     */
    public static void main(String[] args) {
        MysqlFactory mf=new MysqlFactory();
        OracleFactory of=new OracleFactory();
        mf.getDBConn().getDriver();
        mf.getDBConn().getUrl();
        mf.getDBConn().getUP();
        mf.getDBConn().connDB();
        of.getDBConn().getDriver();
        of.getDBConn().getUrl();
        of.getDBConn().getUP();
        of.getDBConn().connDB();
    }
}
/**
 * 抽象的数据库连接角色
 * @author 翎野君
 *
 */
interface ConnDBInterface{
    public void getDriver();
    public void getUrl();
    public void getUP();
    public void connDB();
}
/**
 * 抽象工厂角色
 * @author 翎野君
 *
 */
interface FactoryMethodInterface{
    public ConnDBInterface getDBConn();
}
/**
 * 专门连接Mysql的工厂
 * @author 翎野君
 *
 */
class MysqlFactory implements FactoryMethodInterface{
    @Override
    public ConnDBInterface getDBConn() {
        // TODO Auto-generated method stub
        return new ConnMysql();
    }
}
/**
 * 专门连接Oracle的工厂
 */
class OracleFactory implements FactoryMethodInterface{
    @Override
    public ConnDBInterface getDBConn() {
        // TODO Auto-generated method stub
        return new ConnOracle();
    }
}
/**
 * 具体的连接Mysql的实现类
 * @author 翎野君
 *
 */
class ConnMysql implements ConnDBInterface{
    @Override
    public void getDriver() {
        // TODO Auto-generated method stub
        System.out.println("加载mysql数据库驱动");
    }
    @Override
    public void getUrl() {
        // TODO Auto-generated method stub
        System.out.println("获取mysql连接地址127.0.0.1");
    }
    @Override
    public void getUP() {
        // TODO Auto-generated method stub
        System.out.println("获取mysql的用户名:root 密码：password");
    }
    @Override
    public void connDB() {
        // TODO Auto-generated method stub
        System.out.println("成功连接到mysql数据库");
    }
}
/**
 * 具体的连接Oracle的实现类
 * @author 翎野君
 *
 */
class ConnOracle implements ConnDBInterface{
    @Override
    public void getDriver() {
        // TODO Auto-generated method stub
        System.out.println("加载oracle数据库驱动");
    }
    @Override
    public void getUrl() {
        // TODO Auto-generated method stub
        System.out.println("获取oracle连接地址127.0.0.1");
    }
    @Override
    public void getUP() {
        // TODO Auto-generated method stub
        System.out.println("获取oracle的用户名:root 密码：password");
    }
    @Override
    public void connDB() {
        // TODO Auto-generated method stub
        System.out.println("成功连接到oracle数据库");
    }
}

View Code

优点：

(1)工厂方法模式就很好的减轻了工厂类的负担，把某一类/某一种东西交由一个工厂生产；(对应简单工厂的缺点1)

(2)同时增加某一类”东西“并不需要修改工厂类，只需要添加生产这类”东西“的工厂即可，使得工厂类符合开放-封闭原则。

缺点：

(1)相比简单工厂，实现略复杂。

(2)对于某些可以形成产品族的情况处理比较复杂。

对于缺点(2)，我们可以借用抽象工厂来实现。

三：Abstract Factory

抽象工厂是应对产品族概念的

例如，汽车可以分为轿车、SUV、MPV等，也分为奔驰、宝马等。我们可以将奔驰的所有车看作是一个产品族，而将宝马的所有车看作是另一个产品族。分别对应两个工厂，一个是奔驰的工厂，另一个是宝马的工厂。与工厂方法不同，奔驰的工厂不只是生产具体的某一个产品，而是一族产品(奔驰轿车、奔驰SUV、奔驰MPV)。“抽象工厂”的“抽象”指的是就是这个意思。

上边的工厂方法模式是一种极端情况的抽象工厂模式(即只生产一种产品的抽象工厂模式)，而抽象工厂模式可以看成是工厂方法模式的一种推广。

来看看抽象工厂模式的各个角色(和工厂方法的一样)

抽象类

package cn.design.factory;
public abstract class AbstractBenz {
    public abstract void start();
    public abstract void run();
    public abstract void stop();
}

View Code

具体类

package cn.design.factory;
public class BenzSport extends AbstractBenz{
    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("奔驰跑车启动");
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("奔驰跑车行驶");
    }
    @Override
    public void stop() {
        // TODO Auto-generated method stub
        System.out.println("奔驰跑车熄火");
    }
    public void game(){
        System.out.println("纽伯格林赛道比赛！！！");
    }
}

View Code

package cn.design.factory;
public class BenzMpv extends AbstractBenz{
    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("奔驰保姆车启动");
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("奔驰保姆车行驶");
    }
    @Override
    public void stop() {
        // TODO Auto-generated method stub
        System.out.println("奔驰保姆车熄火");
    }
    public void sleep(){
        System.out.println("在保姆车中睡觉");
    }
}

View Code

抽象工厂类

package cn.design.factory;
public abstract class AbstractFactory {
    public abstract AbstractBenz getBenzSport();
    public abstract AbstractBenz getBenzMpv();
}

View Code

具体工厂类

package cn.design.factory;
public class BenzFactory extends AbstractFactory{
    @Override
    public BenzSport getBenzSport() {
        // TODO Auto-generated method stub
        return new BenzSport();
    }
    @Override
    public BenzMpv getBenzMpv() {
        // TODO Auto-generated method stub
        return new BenzMpv();
    }
    public static void main(String[] args) {
        BenzFactory bf=new BenzFactory();
        bf.getBenzSport().game();
        bf.getBenzMpv().run();
    }
}

View Code

优点：针对产品族；

缺点：针对产品族。

所以，只有对应产品族的情况下，才需要使用抽象工厂模式。

区别

简单工厂：用来生产同一等级结构中的任意产品。(不支持拓展增加产品)

工厂方法：用来生产同一等级结构中的固定产品。(支持拓展增加产品)

抽象工厂：用来生产不同产品族的全部产品。(不支持拓展增加产品；支持增加产品族)

Java设计模式—工厂模式

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Java设计模式—工厂模式

热门文章

最新文章

相关课程

相关电子书