简说设计模式——抽象工厂模式

一、什么是抽象工厂模式

       抽象工厂模式其实就是多个工厂方法模式，比如前面工厂方法模式中，我们创建多个不同类型的数据库，有MySQL、SQLServer等等，就是用工厂方法模式来实现的，但此时我们只能实现一个表（具体内容见下方工厂模式的实现），我们数据库中当然不可能只有一个表呀，所以抽象工厂模式就来了。

　　抽象工厂模式（Abstract Factory），提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。UML结构图如下：

       其中，AbstractFactory是抽象工厂接口，里面包含所有的产品创建的抽象方法；ConcreteFactory则是具体的工厂，创建具有特定实现的产品对象；AbstractProduct是抽象产品，有可能由两种不同的实现；ConcreteProduct则是对于抽象产品的具体分类的实现。

       抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。下面是抽象工厂模式的通用源代码类图：

    1. AbstractFactory类

       下述代码是一个抽象工厂类，它的职责是定义每个工厂要实现的功能，有n个产品族，在抽象工厂类中就应该有n个创建方法。这里按上述类图，给出A、B两个产品族，即构造两个方法。

public abstract class AbstractFactory {

    //创建A产品家族
    public abstract AbstractProductA createProductA();
    //创建B产品家族
    public abstract AbstractProductB createProductB();
    
}

    2. AbstractProduct类

       抽象产品类，两个抽象产品类可以有关系，例如共同继承或实现一个抽象类或接口。这里给出A产品的抽象类，产品类B类似，不再赘述。

public abstract class AbstractProductA {

    //每个产品共有的方法
    public void shareMethod() {}
    //每个产品相同方法，不同实现
    public abstract void doSomething();
    
}

    3. ConcreteFactory类

       具体工厂实现类，如何创建一个产品是由具体的实现类来完成的。下方给出产品等级1的实现类，等级2同理。

public class ConcreteFactory1 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }

}

    4. ConcreteProduct类

        两个具体产品的实现类，这里只给出A的两个具体产品类，B与此类似。

public class ProductA1 extends AbstractProductA {

    @Override
    public void doSomething() {
        System.out.println("产品A1实现方法");
    }
    
}

public class ProductA2 extends AbstractProductA {
 
     @Override
     public void doSomething() {
         System.out.println("产品A2实现方法");
     }
 
 }

　　5. Client客户端

       在客户端中，没有任何一个方法与实现类有关系，对于一个产品来说，我们只需要知道它的工厂方法就可以直接产生一个产品对象，没必要关心他的实现类。

public class Client {

    public static void main(String[] args) {
        //定义两个工厂
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();
        
        //产生A1对象
        AbstractProductA a1 = new ProductA1();
        //产生A2对象
        AbstractProductA a2 = new ProductA2();
        //产生B1对象
        AbstractProductB b1 = new ProductB1();
        //产生B2对象
        AbstractProductB b2 = new ProductB2();
        
        //....
    }
    
}

 二、抽象工厂模式的应用

    1. 何时使用

• 系统的产品有多于一个的产品族，而系统只消费其中某一族的产品时。

    2. 优点

• 封装性，易于产品交换。由于具体工厂类在一个应用中只需在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，只需改变具体工程即可使用不同的产品配置。
• 创建实例过程与客户端分离。

    3. 缺点

• 产品族扩展非常困难，改动或增加一个产品需同时改动多个类。

    4. 使用场景

• 一个对象族（或一组没有任何关系的对象）都有相同的约束。

    5. 应用实例

• 生成不同操作系统的程序。
• QQ换皮肤，一整套一起换。
• 更换数据库。

三、工厂方法模式的实现

       在看抽象工厂模式之前，我们先用工厂方法模式试一下。

       以模拟更换数据库为例，UML图如下：

       这里我们先只对User表进行操作，所以工厂方法只有CreateUser()。

    1. IFactory接口

       定义一个创建访问User表对象的抽象的工厂接口。

public interface IFactory {

    IUser createUser();
    
}

    2. IUser接口

       用于客户端访问，解除与具体数据库访问的耦合。模拟插入方法insert。

public interface IUser {
    
    public void insert(User user);
    public User getUser(int id);

}

    3. SqlserverUser类

       用于访问SQLServer的User。

public class SqlserverUser implements IUser {

    @Override
    public void insert(User user) {
        System.out.println("insert info into user with sqlserver");
    }

    @Override
    public User getUser(int id) {
        System.out.println("get info from user by id with sqlserver");
        return null;
    }

}

    4. AccessUser类

       用于访问Access的User。

public class AccessUser implements IUser {

    @Override
    public void insert(User user) {
        System.out.println("insert info into user with access");
    }

    @Override
    public User getUser(int id) {
        System.out.println("get info from user by id with access");
        return null;
    }

}

    5. SqlserverFactory类

       实现IFactory接口，实例化SqlserverFactory。

public class SqlserverFactory implements IFactory {

    @Override
    public IUser createUser() {
        return new SqlserverUser();
    }

}

    6. AccessFactory类

       实现IFactory接口，实例化AccessFactory。

public class AccessFactory implements IFactory {

    @Override
    public IUser createUser() {
        return new AccessUser();
    }

}

    7. Client客户端

public class Client {
    
    public static void main(String[] args) {
        User user = new User();
        
        IFactory factory = new SqlserverFactory();
//        IFactory factory = new AccessFactory();
        
        IUser iUser = factory.createUser();
        iUser.insert(user);
        iUser.getUser(1);
    }

}

       这就是工厂方法模式的实现，现在只需把new SqlserverFactory()改成下方注释那样的new AccessFactory()就可以实现更换数据库了，此时由于多态的关系，使得声明IUser接口的对象iUser事先根本不知道是在访问哪个数据库，却可以在运行时很好地完成工作，这就是所谓的业务逻辑与数据访问的解耦。

       具体工厂方法模式可参考之前的文章：简说设计模式——工厂方法模式。

四、抽象工厂模式的实现

       上面用工厂方法模式实现了模拟更换数据库，但数据库中不可能只存在一个表，如果有多个表的情况又该如何呢？我们试着再增加一个表，比如增加一个部门表（Department表）。UML图如下：

    1. IFactory接口

       先更改一下IFactory接口，增加一个创建访问Department表对象的抽象的工厂接口。

public interface IFactory {

    IUser createUser();
    IDepartment createDepartment();
    
}

    2. IDepartment接口

       增加一个IDepartment接口，用于客户端访问。

public interface IDepartment {
    
    public void insert(Department department);
    public Department getDepartment(int id);

}

    3. 数据库工厂

       在sqlserver数据库工厂中实例化SqlserverDepartment，Access同理。

public class SqlserverFactory implements IFactory {

    @Override
    public IUser createUser() {
        return new SqlserverUser();
    }

    @Override
    public IDepartment createDepartment() {
        return new SqlserverDepartment();
    }

}

    4. IDepartment接口的实现类

       增加SqlserverDepartment及AccessDepartment。

public class SqlserverDepartment implements IDepartment {

    @Override
    public void insert(Department department) {
        System.out.println("insert info into department with sqlserver");
    }

    @Override
    public Department getDepartment(int id) {
        System.out.println("get info from department by id with sqlserver");
        return null;
    }

}

    5. Client客户端

       在客户端中增加department的实现。

public class Client {
    
    public static void main(String[] args) {
        User user = new User();
        Department department = new Department();
        
        IFactory factory = new SqlserverFactory();
//        IFactory factory = new AccessFactory();
        
        IUser iUser = factory.createUser();
        iUser.insert(user);
        iUser.getUser(1);
        
        IDepartment iDepartment = factory.createDepartment();
        iDepartment.insert(department);
        iDepartment.getDepartment(1);
    }

}

       如上述代码，运行sqlserver数据库的结果如下：

       若更换为access数据库，运行结果如下：

       刚才我们只有一个User类和User操作类的时候，只需要工厂方法模式即可，但现在显然数据库中有许多的表，而SQLServer和Access又是两个不同的分类，解决这种涉及到多个产品系列的问题，就用到了抽象工厂模式。

五、利用反射实现数据访问程序

       在上述的两种模式中，我们是有多少个数据库就要创建多少个数据库工厂，而我们数据库工厂中的代码基本上是相同的，这时就可以使用简单工厂模式+抽象工厂模式来简化操作，也即将工厂类及工厂接口抛弃，取而代之的是DataAccess类，由于实现设置了db的值（Sqlserver或Access），所以简单工厂的方法都不需要输入参数，这样客户端可以直接生成具体的数据库访问类实例，且没有出现任何一个SQLServer或Access的字样，达到解耦的目的。可以看一下UML图：

       但此时还有一个问题就是，因为DataAccess中创建实例的过程使用的是switch语句，所以如果此时要增加一个数据库，比如Oracle数据库，就需要修改每个switch的case了，违背了开闭原则。对于这种情况，工厂方法模式里有提到过，就是使用反射机制，或者这里应该更确切的说是依赖注入（DI），spring的IoC中有遇到这个概念。

       这里我们可以直接使用反射来利用字符串去实例化对象，这样变量就是可更换的了，换句话说就是将程序由编译时转为运行时，如下：

public class DataAccess {

    private static final String name = "com.adamjwh.gofex.abstract_factory";
    private static final String db = "Access";
    
    public static IUser createUser() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        String className = name + "." + db + "User";
        return (IUser) Class.forName(className).newInstance();
    }

    public static IDepartment createDepartment() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        String className = name + "." + db + "Department";
        return (IDepartment) Class.forName(className).newInstance();
    }
    
}

       这里字符串name为包名，db为要查询的数据库名，我们要更换数据库只需将Access修改成我们需要的数据库名即可，这时只需修改DataAccess类即可，然后我们再在Client中对DataAccess类实例化。

DataAccess factory = new DataAccess();

       当然我们还可以利用配置文件来解决更改DataAccess的问题，此时就连DataAccess类都不用更改了，如下：

<?xml version="1.0 encoding="utf-8" ?>
<configuration>
    <appSettings>
        <add key="DB" value="Oracle" />
    </appSettings>
</configuration>

       所以，所有在用简单工厂的地方，都可以考虑用反射技术来去除swithc或if，解除分支判断带来的耦合。

 

       源码地址：https://gitee.com/adamjiangwh/GoF