这篇我们将介绍最后一种工厂模式，抽象工厂模式
0.抛出问题
很多博客和书都喜欢用很生活化的例子来实现设计模式的代码，例如造车、做奶茶什么的，不过笔者反而认为那会使得难以理解，难以和实际开发联系起来，所以我更喜欢举一些实际开发中的例子
业务需求：
1.使用MySQL数据库设计DAO层对user表的查询和添加
2.在未来或许会更换数据库
3.在未来或许会添加表
首先用工厂方法模式
//一个User表的DAO接口
public interface UserDAO {
User queryById(String id);
void insert(User user);
}
//基于MySQL的实现类
public class MySQLUserDAOImpl implements UserDAO {
@Override
public User queryById(String id) {
System.out.println("在MySQL中查询到一条user数据");
return null;
}
@Override
public void insert(User user) {
System.out.println("在MySQL中插入一条user数据");
}
}
//创建各种DAO对象的工厂接口
public interface DAOFactory {
UserDAO createUserDAO();
}
//创建基于实现的MySQL的DAO的工厂
public class MySQLFactory implements DAOFactory {
@Override
public UserDAO createUserDAO() {
return new MySQLUserDAOImpl();
}
}
//测试代码
public class Main {
public static void main(String[] args)
{
DAOFactory daoFactory = new MySQLFactory();
UserDAO userDAO = daoFactory.createUserDAO();
userDAO.insert(new User());
userDAO.queryById("");
}
}
//运行结果
在MySQL中插入一条user数据
在MySQL中查询到一条user数据
Process finished with exit code 0
熟悉工厂方法模式的朋友们很快就可以写出上面的代码，我们现在来看第二个业务需求，如果需要更换数据库。
假设我们更换为Oracle
//UserDAO基于Oracle的实现类
public class OracleUserDAOImpl implements UserDAO {
@Override
public User queryById(String id) {
System.out.println("在Oracle中查询到一条user数据");
return null;
}
@Override
public void insert(User user) {
System.out.println("在Oracle中添加一条user数据");
}
}
//创建基于实现的 Oracle的DAO的工厂
public class OracleFactory implements DAOFactory {
@Override
public UserDAO createUserDAO() {
return new OracleUserDAOImpl();
}
}
public class Main {
public static void main(String[] args)
{
//修改客户端代码
DAOFactory daoFactory = new OracleFactory();
UserDAO userDAO = daoFactory.createUserDAO();
userDAO.insert(new User());
userDAO.queryById("");
}
}
//运行结果
在Oracle中添加一条user数据
在Oracle中查询到一条user数据
Process finished with exit code 0
似乎一切依旧很顺利，不过在添加Oracle的代码后，我们需要修改主函数里的代码，要是只有一两处还好办，不过DAO层的操作在工程中通常是很多的，也就是说可能在代码中有很多地方都用到了最初的 DAOFactory daoFactory = MysqlFactory(); 如果直接更改为 DAOFactory daoFactory = new OracleFactory(); 那所牵涉的修改一定不止一处。这个地方有bad small，需要斟酌。
上面的问题先放着，我们继续看第三个需求，如果需要添加表，例如部门表（dept）
//一个Dept表的DAO接口
public interface DeptDAO {
Dept queryById(String id);
void insert(Dept user);
}
//基于MySQL的实现类
public class MySQLDeptDAOImpl implements DeptDAO {
@Override
public Dept queryById(String id) {
System.out.println("在MySQL中查询到一条Dept数据");
return null;
}
@Override
public void insert(Dept user) {
System.out.println("在MySQL中插入一条Dept数据");
}
}
//基于Oracle的实现类
public class OracleDeptDAOImpl implements DeptDAO {
@Override
public Dept queryById(String id) {
System.out.println("在Oracle中查询到一条Dept数据");
return null;
}
@Override
public void insert(Dept user) {
System.out.println("在Oracle中插入一条Dept数据");
}
}
public interface DAOFactory {
UserDAO createUserDAO();
DeptDAO createDeptDAO();//添加接口方法
}
public class MySQLFactory implements DAOFactory {
@Override
public UserDAO createUserDAO() {
return new MySQLUserDAOImpl();
}
//增加创建MySQLdept的工厂方法
@Override
public DeptDAO createDeptDAO() {
return new MySQLDeptDAOImpl();
}
}
public class OracleFactory implements DAOFactory {
@Override
public UserDAO createUserDAO() {
return new OracleUserDAOImpl();
}
//增加创建Oracledept的工厂方法
@Override
public DeptDAO createDeptDAO() {
return new OracleDeptDAOImpl();
}
}
//修改客户端
public class Main {
public static void main(String[] args)
{
DAOFactory daoFactory = new OracleFactory();
UserDAO userDAO = daoFactory.createUserDAO();
userDAO.insert(new User());
userDAO.queryById("");
DeptDAO deptDAO = daoFactory.createDeptDAO();
deptDAO.insert(new Dept());
deptDAO.queryById("");
}
}
\\测试结果
在Oracle中添加一条user数据
在Oracle中查询到一条user数据
在Oracle中插入一条Dept数据
在Oracle中查询到一条Dept数据
Process finished with exit code 0
其实在上面一步一步的改动中，已经渐渐出现了抽象设计模式的概念。只有一个User类和User操作类的时候，是只需要工厂方法模式的，但现在数据库有多张表，而MySQL和Oracle又是两大分类，这种有多个维度来影响具体产品的问题，我们就使用抽象模式。
1.抽象工厂模式
（图有点丑，大家将就看一下= =）我觉得比UML图要好理解一丢丢。我们来思考一下这样设计的优点是什么，上面的程序中，有MySQL和Oracle两种数据库，在项目中通常我们只会使用其中一种。当一个产品族（数据库）中的多个对象（多个表）被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。如上图最后的主函数代码，如果更换数据库为MySQL，只需要把DAOFactory daoFactory = new OracleFactory()换成DAOFactory daoFactory = new MySQLFactory()，而后面的UserDAO类和DeptDAO类并不需要改变，他们也无需关心背后是由MySQL还是Oracle实现。
其实这种思想在软件设计中随处可见，如手机QQ中的个性主题，当我们更换主题后，很多图标、聊天框等样式都会随之改变。这就是在换掉产品工厂（主题）以后，所有的产品组中的对象（各种图标）直接就被更换了。再举一个生活中的例子，日本在更换首相以后，通常都会组建新内阁，把首相比作工厂的话，那内阁成员都是产品组里的成员。
不过该模式有什么缺点呢？其实在上面的代码已经体现得很明显了，当我们加入Dept表的时候，除了增加两个类，我们还修改了三处源码，DAOFactory、 OracleFactory、MySQLFactory，这是极其不符合开放封闭原则的。
2.用反射+配置文件+单例设计模式来改进抽象工厂
谈谈为什么需要单例设计模式。在单例模式的文章中我们提到，如果功能重复且不变的情况下，我们可以使用一个对象而非重复的new对象，在web开发的service层，我们往往会用到dao层的方法，而一张表仅仅对应一个dao对象的，所以只需要一个dao对象对相应的表进行操作即可。
//代码如下
public class MySQLDeptDAOImpl implements DeptDAO {
volatile private static MySQLDeptDAOImpl mySQLDeptDAO = null;
private MySQLDeptDAOImpl(){
}
public static MySQLDeptDAOImpl getMySQLDeptDAO(){
if (mySQLDeptDAO == null)
synchronized (MySQLDeptDAOImpl.class) {
if (mySQLDeptDAO == null)
mySQLDeptDAO = new MySQLDeptDAOImpl();
}
return mySQLDeptDAO;
}
@Override
public Dept queryById(String id) {
System.out.println("在MySQL中查询到一条Dept数据");
return null;
}
@Override
public void insert(Dept user) {
System.out.println("在MySQL中插入一条Dept数据");
}
}
public class MySQLUserDAOImpl implements UserDAO {
volatile private static MySQLUserDAOImpl mySQLUserDAO = null;
private MySQLUserDAOImpl(){
}
public static MySQLUserDAOImpl getMySQLUserDAO(){
if (mySQLUserDAO == null)
synchronized (MySQLUserDAOImpl.class) {
if (mySQLUserDAO == null)
mySQLUserDAO = new MySQLUserDAOImpl();
}
return mySQLUserDAO;
}
@Override
public User queryById(String id) {
System.out.println("在MySQL中查询到一条user数据");
return null;
}
@Override
public void insert(User user) {
System.out.println("在MySQL中插入一条user数据");
}
}
由于篇幅，笔者只更换了MySQL的实现类。
在上面我们提到了如果需要更换数据库，其实依然需要指明具体的工厂，如果我们能把这种不确定放在运行时而不是编译时，通过外部配置文件决定数据库的类别，就可以大大的降低耦合性，使得在更换数据库的时候十分简单。
现在开始动手，先写一个配置文件config.properties
databaseName=MySQL
上面的DAOFactory以及它的实现类我们都可以删掉了。上新的DAOFactory代码
public class DAOFactory {
private static String database;
static {
try {
Properties properties = new Properties();
InputStream inputStream = DAOFactory.class.getClassLoader().getResourceAsStream("config.properties");
properties.load(inputStream);
database = properties.getProperty("databaseName");//根据配置文件确定数据库类别
} catch (IOException e) {
e.printStackTrace();
}
}
public static UserDAO createUser() {
String className = "com.ironman.dao." + database + "UserDAOImpl";
try {
Class<UserDAO> userDAOClass = (Class<UserDAO>) Class.forName(className);//根据数据库类别决定使用哪种产品类
Method newInstanceMethod = userDAOClass.getMethod("getMySQLUserDAO");//返回得到实例对象的方法对象
return (UserDAO)newInstanceMethod.invoke(userDAOClass);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static DeptDAO createDept(){
String className = "com.ironman.dao." + database + "DeptDAOImpl";
try {
Class<DeptDAO> deptDAOClass = (Class<DeptDAO>) Class.forName(className);//根据数据库类别决定使用哪种产品类
Method newInstanceMethod = deptDAOClass.getMethod("getMySQLDeptDAO");//返回得到实例对象的方法对象
return (DeptDAO) newInstanceMethod.invoke(deptDAOClass);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
public class Main {
public static void main(String[] args)
{
UserDAO userDAO = DAOFactory.createUser();
userDAO.queryById("");
userDAO.insert(new User());
DeptDAO deptDAO = DAOFactory.createDept();
deptDAO.queryById("");
deptDAO.insert(new Dept());
}
}
//运行结果
在MySQL中查询到一条user数据
在MySQL中插入一条user数据
在MySQL中查询到一条Dept数据
在MySQL中插入一条Dept数据
Process finished with exit code 0
这样设计，当我们更换数据库的时候，如现在需要更换SQL Server，我们只需要根据命名规范写出DeptDAO和UserDAO的SQL Server实现类，然后再修改配置文件，这样就对源码无需任何修改。也算是把抽象工厂模式发挥到极致了~~~~~~
前面的简单工厂也可以用反射改造，这里就不举例说明了。将编译时依赖转为运行时依赖真的是一个很重要的思想，有一种展望未来的感觉~希望大家在写代码的时候也可以多加思考，写出优雅的代码
