设计模式之抽象工厂模式

抽象工厂的定义

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

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

抽象工厂的角色 

 

抽象产品（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