设计模式之抽象工厂模式

抽象工厂的定义

抽象工厂模式提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。

抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要关联实际产出的具体产品是什么。这样一来，客户就可以从具体的产品被解耦。

抽象工厂的角色 

 

抽象产品（Product）

所有的产品必须实现这个共同的接口，具体产品引用这个接口或者继承抽象类。

具体产品（ConcreteProduct）

具体产品继承或实现抽象产品。

抽象工厂（AbstractFactory）

抽象工厂定义一个接口，所有具体的工厂必须实现此接口。

具体工厂 (ConcreteFactory)

具体工厂是用于生产不同产品族。要创建一个产品，客户只需要使用其中一个工厂完全不需要实例化任何产品对象。

 

抽象工厂类图

 

代码实现

情景再现

小明所在的公司数据库要进行更换，要把原有的SQLServer数据库更换成MySQL 接下来我们来看一下是他们是如何更换数据库的。

 

创建一个用户类

public class User {

    private int id;

    private String name;
    // 省略set()get()方法

}

SQLServer操作类

public class SqlServerUser {

    private User user;

    /**
     * 插入数据
     * @param user
     */
    public void insert(User user) {
        this.user = user;
        System.out.println("在Sql Server 中User表新增一条数据");
    }

    /**
     * 获取数据
     * @return
     */
    public User getUser() {
        return user;
    }


}

MySQLServer操作类

public class MySQLUser {

    private User user;

    /**
     * 插入数据
     * @param user
     */
    public void insert(User user) {
        this.user = user;
        System.out.println("在MySQL 中User表新增一条数据");
    }

    /**
     * 获取数据
     * @return
     */
    public User getUser() {
        return user;
    }
}

测试类

public class Test {

    public static void main(String[] args) {
        // SQLServer 插入数据库
        SqlServerUser sqlServerUser = new SqlServerUser();
        User user = new User();
        user.setId(1);
        user.setName("测试");
        sqlServerUser.insert(user);
        System.out.println("==========Sql Server获取数据==============");
        System.out.println(sqlServerUser.getUser().getId());
        System.out.println(sqlServerUser.getUser().getName());

        // MySQL 插入数据库
        MySQLUser mySQLUser = new MySQLUser();
        mySQLUser.insert(user);
        System.out.println("==========MySQL获取数据==============");
        System.out.println(mySQLUser.getUser().getId());
        System.out.println(mySQLUser.getUser().getName());
    }
}

测试结果

在Sql Server 中User表新增一条数据
==========Sql Server获取数据==============
1
测试
在MySQL 中User表新增一条数据
==========MySQL获取数据==============
1
测试

不使用模式我们可以发现代码需要频繁的创建对象，每次更换数据，就需要写大量的代码，此时我们可以考虑用工厂方法模式创建对象的接口，让子类决定实例化哪一个类，那就让我们来试试吧。

创建抽象工厂

public interface IFactory {

    IUser createUser();

    IDepartment createDepartment();
}

创建具体工厂

// MySQL
public class MySQLFactory implements  IFactory {
    @Override
    public IUser createUser() {
        return new MySQLUser();
    }

    @Override
    public IDepartment createDepartment() {
        return new MySQLDepartment();
    }
}
// SQLServer
public class SqlServerFactory implements IFactory {

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

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

创建抽象产品

public interface IUser {

    void insert(User user);

    User getUser();
}

创建具体产品

// MySQL
public class MySQLUser implements  IUser {

    private User user;

    @Override
    public void insert(User user) {
        this.user = user;
        System.out.println("在MySQL 中User表新增一条数据");
    }

    @Override
    public User getUser() {
        return user;
    }
}
// SQLServer
public class SqlServerUser implements  IUser {

    private User user;

    /**
     * 插入数据
     * @param user
     */
    @Override
    public void insert(User user) {
        this.user = user;
        System.out.println("在Sql Server 中User表新增一条数据");
    }

    /**
     * 获取数据
     * @return
     */
    @Override
    public User getUser() {
        return user;
    }
}

测试类

public class Test {

    public static void main(String[] args) {
        User user = new User();
        user.setId(2);
        user.setName("工厂方法模式");
        // 若要改成MySQL 只需要更改这一句就可以啦
        IFactory factory = new SqlServerFactory();
        // IFactory factory = new MySQLFactory();
        IUser iu = factory.createUser();

        iu.insert(user);
        User user2 =  iu.getUser();
        System.out.println(" id:"+user2.getId()+" name:"+user2.getName());
    }
}

测试结果

在Sql Server 中User表新增一条数据
 id:2 name:工厂方法模式

通过工厂方法模式我们发现把newSqlServerFactory()更改成new MySQLFactory来解决代码的冗余，这就把业务逻辑和数据访问的解耦，如果增加其他表还会增加很多类，接下来我们来看一下抽象工厂模式。

现在增加需求

需要新增部门的实体类。

部门实体类

public class Department {

    private int id;

    private String name;
    // 省略set()get()方法
}

创建抽象产品 

public interface IDepartment {
    // 插入部门表数据
    void insert(Department department);
    // 获取部门表数据
    Department getDepartment();
}

创建具体产品 

public class MySQLDepartment implements IDepartment {

    private Department department;


    @Override
    public void insert(Department department) {
        this.department = department;
        System.out.println("在Mysql 中department表新增一条数据");
    }

    @Override
    public Department getDepartment() {
        return department;
    }
}

public class SqlServerDepartment implements IDepartment {

    private Department department;

    @Override
    public void insert(Department department) {
        this.department = department;
        System.out.println("在Sql Server 中department表新增一条数据");
    }

    @Override
    public Department getDepartment() {
        return department;
    }
}

测试类

public class Test {

    public static void main(String[] args) {
        User user = new User();
        user.setId(2);
        user.setName("抽象工厂模式");
        Department department = new Department();
        department.setId(3);
        department.setName("抽象工厂部门");

        // 若要改成MySQL 只需要更改这一句就可以啦
        IFactory factory = new SqlServerFactory();
        // IFactory factory = new MySQLFactory();
        IUser iu = factory.createUser();

        iu.insert(user);
        User user2 =  iu.getUser();
        System.out.println(" id:"+user2.getId()+" name:"+user2.getName());

        IDepartment im = factory.createDepartment();
        im.insert(department);
        Department de = im.getDepartment();
        System.out.println("id:"+de.getId()+" name: "+de.getName());

    }
}

测试结果

在Sql Server 中User表新增一条数据
 id:2 name:抽象工厂模式
在Sql Server 中department表新增一条数据
id:3 name: 抽象工厂部门

大家是不是想说这就是工厂方法模式？

只有一个User类和User操作类的时候，是只需要工厂方法模式的，现在你数据库中有很多表，而SQLServer 与MySQL又是不同的分类，所以解决这种涉及到多个产品系列的问题，这个模式就叫做抽象工厂模式。

抽象工厂模式的优缺点

优点

1、  抽象工厂隔离了具体类的生成，是的客户端不需要知道什么被创建。所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。           

2、  当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。

 

缺点

 添加新的行为时比较麻烦。如果需要添加一个新产品族对象时，需要更改接口及其下所有子类，这必然会带来很大的麻烦（这个缺点是工厂模式也有的一个缺点，但是我们不能只关注缺点，因为抽象工厂模式，更多的是为了扩展我们的产品等级结构）。

 

使用场景

 

1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。 

2.  系统中有多于一个的产品族，而每次只使用其中某一产品族。        

3.  属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。        

4.  系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

 

总结

 

抽象工厂模式中主要的优点在于具体类的隔离，是的客户端不需要知道什么被创建了。其缺点在于增加新的产品族比较复杂，需要修改接口及其所有子类。

 

本文中源码：

https://github.com/xiaonongOne/abstract-factory