抽象工厂模式+反射+配置文件



配置文件+抽象工厂+反射

定义：

抽象工厂模式：提供一个常创建一系列相关或相相互依赖对象的接口，而无需指定他们具体的实现类

3 代码:

//user类接口
interface IUser{
    void  insert(User user);
    User getUser(int id);
}
//用sqlserver访问user表
class SqlserverUser implements IUser{

    @Override
    public void insert(User user) {
        System.out.println("在user表中插入一条数据");
    }

    @Override
    public User getUser(int id) {
        System.out.println("从user表中获得一条数据");
        return null;
    }
}
//用access访问user表
class AccessUser implements IUser{

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

    @Override
    public User getUser(int id) {
        System.out.println("在user表中获得一条记录");
        return null;
    }
}
//定义工厂接口
interface IFactory{
    IUser createUser();
    IDepartment createDepartment();
}
//sqlserver工厂
class sqlServiceFactory implements IFactory{

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

    @Override
    public IDepartment createDepartment() {
        return new SqlservcerDepartment();
    }
}
//access工厂
class AccessFactory implements IFactory{

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

    @Override
    public IDepartment createDepartment() {
        return new AccessDepartment();
    }
}
//部门类
interface IDepartment{
    void Insert(Department department);

    Department getDepartment(int id);
}
//sqlserver访问部门类表
class SqlservcerDepartment implements IDepartment{

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

    @Override
    public Department getDepartment(int id) {
        System.out.println("在sqlserver表中获得一条记录");
        return null;
    }
}
//access访问部门类表
class AccessDepartment implements IDepartment{

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

    @Override
    public Department getDepartment(int id) {
        System.out.println("在access表中获得一条记录");
        return null;
    }
}
//实现客户端
public class model_1 {

    public static void  main(String[] args){
        //创建两个实体
        User user=new User();
        Department dept=new Department();
        //创建access生产工厂
        IFactory factory=new AccessFactory();
        //access访问user类方法
        IUser iu=factory.createUser();
        iu.insert(user);
        iu.getUser(1);
        //access访问部门类方法
        IDepartment id=factory.createDepartment();
        id.Insert(dept);
        id.getDepartment(1);
    }
}

分析：上方代码可以看出，抽象工厂模式其实是在工厂方法的基础上演变的，如果先开始是一个IUser接口以及接口下实现的两个sqlserver实现类以及accessuser实现类，对应的工厂IFactory实现类为分别创造两个实现类的SqlserverFactory以及AccessFactory工厂类。这样的一个操作类接口与对应的工厂组合，形成抽象工厂。然后再加上IDepartment操作类接口以及其实现类以后，对应IFactory接口需要添加新的生产方法，需要新的生产IDepartment相关类的生产工厂。所以这种涉及到多个操作类生产的工厂方法，成为工厂方法。从上述代码实现，我们可以看出，抽线工厂一个很大的缺点，就是实现类太多，每增加一个操作类，就需要写很多类以及修改IFactory。

4 总结：

抽象工厂：

优点：

（1）抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。

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

（3）增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点：

增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则” 的支持呈现倾斜性。而且需要写很多的类。

反射跟配置文件：

Assembly.Load("程序集名称").CreateInstance("命名空间.类名称")，用反射的方法，只要给发起人类一个字符串，反射就可以根据字符串从命名空间里面查找相应的名称的类名，从而创建相应对象并返回。提高了扩展性。然而这样，接受字串还是要更该的，就不免需要改程序，不能完全符合程序的开放封闭原则，所以再使用配置文件，将传入字符串写在配置文件中，这样只需要修改配置文件就可以了，完美实现开放封闭！