第15章 就不能换DB吗？—抽象工厂模式

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

public class AccessUser implements IUser {

	@Override
	public void insert(User user) {
		System.out.println("AccessUser insert user");
	}

	@Override
	public void getUser(int id) {
		System.out.println("AccessUser get user");
	}

}

public interface IFactory {
	IUser createUser();
}

public class AccessFactory implements IFactory {

	@Override
	public IUser createUser() {
		// TODO Auto-generated method stub
		return new AccessUser();
	}

}

我们提出一个问题：Sqlserver和Access数据库中不可能只有User一个表，可能还有其它的表，比如增加部门表(Department)，那么我们应该怎么办呢？

我们看出我们需改动的地方如下：

1，在IFacotry接口中增加creatDepartment()方法，SqlserverFactory和AccessFactory分别实现createDepartemnt()方法。

2，增加操作部门表的抽象，IDepartment接口。

3，增加SqlserverDepparment和AccessDepartment类，分别实现IDepartment接口。

如果是增加一个对Oracle数据库的访问，改动如下：

1，增加OracleFactory类，用于生产操作oracle表的类，实现IFactory中的所有方法。

2，增加OracleUser类，用于操作user表，实现IUser中所有的方法。

3，增加OracleDepartment，用于操作department表，实现IDepartment中所有方法。

其实我们通过需求的不断的演变重构出了抽象工厂模式。只有一个IUser抽象产品和IUser具体产品的时候，是只需要工厂方法模式。但现在显然数据库中有很多表，而Sqlserver和Access又是两种不同的分类，所有涉及到多个产品系列的问题，有一个专门的工厂模式叫做抽象工厂。我们可以这么理解，只创建单一产品的工厂叫做工厂方法，可以创建多个产品系列的工厂叫做抽象工厂。举个例子：富士康和可胜科技都是IPhone的代工厂，可生产IPhone6，富士康和可胜科技都是具体的工厂，富士康的IPhone6和可胜科技的IPhone6都是具体的超，这个时候是工厂方法模式。IPhone生产让苹果公司很满意，把IPhone6s的代工也交给了富士康和可胜，这个时候就是抽象工厂模式了。富士康和可胜都在不仅可以生产IPhone6产品了，也可以生产IPhone6s。

优点

1，最大的好处就是易于交换系列产品，那我们这个例子来说就我可以很容易的切换数据库连接。

2，让具体的创建实例过程与客户端分离，客户端通过抽象来操作他们的实例。客户端代码中也不会出现具体产品类，只会出现抽象产品接口。

缺点

1，如果我们的客户端有100个地方调用了IFactory factory = new SqlserverFactory();,在切换到Access数据库时，需要改动一百个地方。这不能实现只更改一处就实现数据库切换的目的。

2，我们需要增加一张表，还需要修改SqlserverFactory、AccessFactory和IFactory类，违背了开闭原则。

去除IFactory、SqlserverFactory、AccessFactory，取而代之的是简单工厂AccessData类。代码示例中只给出了AccessData和ClientTest的代码，产品相关代码没有变化。如下：

public class DataAccess {

	private static String DB = "sqlserver";
	
	public static IUser createUser(){
		IUser user = null;
		switch (DB) {
			case "sqlserver":
				user = new SqlserverUser();
				break;
			case "access":
				user = new AccessUser();
				break;
		}
		
		return user;
	}
	
	public static IDepartment createDepartment(){
		IDepartment dep = null;
		
		switch (DB) {
			case "sqlserver":
				dep = new SqlserverDepartment();
				break;
			case "access":
				dep = new AccessDepartment();
				break;
		}
		
		return dep;
	}
	
}

public class DataAccess {

	private static String DB = "sqlserver";
	
	public static IUser createUser(){
		IUser user = null;
		switch (DB) {
			case "sqlserver":
				user = new SqlserverUser();
				break;
			case "access":
				user = new AccessUser();
				break;
		}
		
		return user;
	}
	
	public static IDepartment createDepartment(){
		IDepartment dep = null;
		
		switch (DB) {
			case "sqlserver":
				dep = new SqlserverDepartment();
				break;
			case "access":
				dep = new AccessDepartment();
				break;
		}
		
		return dep;
	}
	
}

虽然摒弃了IFactory、SqlserverFactory、AccessFactory类。但是我们在新增一个表时会在AccessData类总增加相应的方法。新增一个数据库时需要在每个方法添加case “oracle” 语句。还是没有解决抽象工厂模式的缺点2。

我们现在的的AccessData类时这样做的：使用switch case来判读，如果是sqlserver，就创建并返回sqlserver数据库相关的类，如果是access数据库，就创建并返回access数据库相关的类。如果我们能根据String类型的变量值去找数据库相关的类就好了。实现如下：

这是程序的包结构。

代码实现:

package fly.zxy.dhms.chapter15_8.factory;

import fly.zxy.dhms.chapter15_8.IDB.IDepartment;
import fly.zxy.dhms.chapter15_8.IDB.IUser;

public class DataAccess {

	private static String DB = "sqlserver";
	private static String packageBasePath = "fly.zxy.dhms.chapter15_8";
	
	public static IUser createUser(){
		String name = "User";
		IUser iu =null;
		iu = (IUser) ref( getPackagePath(name) );
		return iu;
	}
	
	public static IDepartment createDepartment(){
		String name = "Department";
		IDepartment dep = null;
		dep = (IDepartment) ref( getPackagePath(name) );
		return dep;
	}
	
	private static String getPackagePath(String className){
		//fly.zxy.dhms.chapter15_8.sqlserverDB
		//fly.zxy.dhms.chapter15_8.accessDB
		className = DB.substring(0,1).toUpperCase() + DB.substring(1, DB.length()) + className;
		String path = packageBasePath+"."+DB+"DB"+"."+className;
		return path;
	}
	
	private static Object ref(String className){
		Object obj = null;
		try {
			Class<? extends Object> cls = Class.forName(className);
			obj = cls.newInstance();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return obj;
	}
}

由于使用了反射技术，我们在增加表的时候只需要在AccessData类中增加对应的方法，而方法中没有了一堆的switch case分支判断。新增对一种数据库的访问，无需再更改每个方法增加case语句了。解决了抽象工厂模式的缺点二。其实从某种角度来说，所有在使用简单工厂的地方，都可以考虑用反射来去除switch或if。

我们发现还有点小瑕疵，我们需要修改DB变量的值类来实现数据库的切换，这样还是需要改动代码，需要重新编译。这个小瑕疵可以使用配置文件来搞定，就是讲DB变量的值从XML文件或properties文件中读取出来。