设计模式3---抽象工厂模式

public interface IFactory {
IUser CreateUser();
IDepartment CreateDepartment();
}

在工厂模式中，每个工厂类会为特定的操作类型产生操作对象类。

但是如果有产品系列的话，工厂模式就不太适用。

考虑一个数据库的问题。

1.数据库可能有替换

2.每个数据库可以修改多个表，比如user，department。

抽象工厂类就是对于工厂类产生的对象，我其实不需要得到具体的类，只要抽象类（接口）就可以了。

main方法：

public class AbstractFactoryMain extends BasicExample {

@Override
public void startDemo() {
// TODO Auto-generated method stub
User user = new User();
Department department = new Department();
IFactory factory = new AccessFactory();
IUser iu = factory.CreateUser();
iu.insertUser(user);
iu.getUser(1);

IDepartment id = factory.CreateDepartment();
id.insertDepartment(department);
id.getDepartment(1);
}

}

IFactory 是工厂方法接口

IUser 和IDepartment 是对于User和Department的操作接口，具体是access还是SQLserver其实客户端不关心。

其他类具体实现：

public interface IFactory {
IUser CreateUser();
IDepartment CreateDepartment();
}

//封装对User表的操作
public interface IUser {
void insertUser(User user);
User getUser(int id);
}

//封装对Department表的操作
public interface IDepartment {
void insertDepartment(Department department);
Department getDepartment(int id);
}

SQLserver工厂类：

public class SqlServerFactory implements IFactory {

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

@Override
public IDepartment CreateDepartment() {
// TODO Auto-generated method stub
return new SqlserverDepartment();
}

}

Access工厂类：

public class AccessFactory implements IFactory {

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

@Override
public IDepartment CreateDepartment() {
// TODO Auto-generated method stub
return new AccessDepartment();
}

}

具体操作类：

public class SqlserverUser implements IUser {

@Override
public void insertUser(User user) {
System.out.println("在SQLserver 中给user表添加一条记录");
}

@Override
public User getUser(int id) {
System.out.println("在SQLserver 中根据ID得到user表一条记录");
return null;
}

}

public class SqlserverDepartment implements IDepartment {

@Override
public void insertDepartment(Department department) {
System.out.println("在SQLserver 中给Department表添加一条记录");
}

@Override
public Department getDepartment(int id) {
System.out.println("在SQLserver 中根据ID得到Department表一条记录");
return null;
}

}

public class AccessDepartment implements IDepartment {

@Override
public void insertDepartment(Department department) {
// TODO Auto-generated method stub
System.out.println("在Access 中给Department表添加一条记录");
}

@Override
public Department getDepartment(int id) {
System.out.println("在Access 中根据ID得到Department表一条记录");
return null;
}

}

public class AccessUser implements IUser {

@Override
public void insertUser(User user) {
System.out.println("在Access 中给user表添加一条记录");
}

@Override
public User getUser(int id) {
System.out.println("在Access 中根据ID得到user表一条记录");
return null;
}

}

public class User {

private int _id;
private String _name;

public int getID() {
return _id;
}
public void setID(int _id) {
this._id = _id;
}
public String getName() {
return _name;
}
public void setName(String _name) {
this._name = _name;
}

}

public class Department {
private int _id;
private String _name;

public int getID() {
return _id;
}
public void setID(int _id) {
this._id = _id;
}
public String getName() {
return _name;
}
public void setName(String _name) {
this._name = _name;
}
}

如果需要添加Oracle 数据库，那只要添加 工厂生成类OracleFactory,以及操作OracleUser 和OracleDepartment类。
这样就不会改动原有代码，可以快速替换数据库。
抽象工厂模型：
优点：　1.可以方便的交换产品系列，只需在初始化的地方出现一次，就可以应用一个具体工厂。　　
　　　　2.具体实现隔离客户端，客户端通过抽象接口来操作具体实例。

简单工厂模型优化抽象工厂模型。
把AccessFactory 和SqlserverFactory可以合并成DataAccess方法来处理。

问题：如果上述“ IFactory factory = new AccessFactory();” 有还多处地方，甚至好几百处，这样就需要做大量的修改。
把AccessFactory用DataAccess来代替，客户端彻底杜绝出现数据库字段。

public class DataAccess {
//    private static final String db = "Sqlserver";
private static final String db = "Access";

public static IUser CreateUser()
{
IUser result = null;
switch(db)
{
case "Sqlserver":
result = new SqlserverUser();
break;
case "Access":
result = new AccessUser();
break;
}
return result;
}

public static IDepartment CreateDepartment()
{
IDepartment result = null;
switch(db)
{
case "Sqlserver":
result = new SqlserverDepartment();
break;
case "Access":
result = new AccessDepartment();
break;
}
return result;
}
}

main方法修改为：

public class AbstractFactoryMain extends BasicExample {

@Override
public void startDemo() {
// TODO Auto-generated method stub
User user = new User();
Department department = new Department();
//        IFactory factory = new AccessFactory();
IUser iu = DataAccess.CreateUser();
iu.insertUser(user);
iu.getUser(1);

IDepartment id = DataAccess.CreateDepartment();
id.insertDepartment(department);
id.getDepartment(1);
}

}

　　从main方法看，根本看不到任何SQL和Access的字段，也就是客户端与业务逻辑隔离了！

　　但是，如果新增一个Oracle数据库，需要修改DataAccess的switch--case，如何彻底不用switch语句呢？

利用反射，把类对象反射出来，这样只需要添加工厂类定义就可以了。

package com.jayfulmath.designpattern.abstractfactory;

import java.lang.reflect.*;
public class DataAccessReflection {

private static final String AssemblyName = "com.jayfulmath.designpattern.abstractfactory";
private static final String db = "Access";

public static IUser CreateUser()
{
String className =AssemblyName+"."+db+"User";
IUser  result = null;
try {
Class<?> c = Class.forName(className);
Constructor<?> ct = c.getConstructor();
result = (IUser) (ct.newInstance());
} catch (NoSuchMethodException |ClassNotFoundException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return result;
}

public static IDepartment CreateDepartment()
{
String className = AssemblyName+"."+db+"Department";
IDepartment  result = null;
try {
Class<?> c = Class.forName(className);
Constructor<?> ct = c.getConstructor();
result = (IDepartment) (ct.newInstance());
} catch (NoSuchMethodException |ClassNotFoundException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return result;
}
}

自此，完美的解决了switch---case的问题。如果使用配置文件的话，可以彻底不用修改代码，而达到更换数据库的问题。