第15章 抽象工厂模式 Abstract Factory

1.用工厂方法模式的数据访问程序

工厂模式创建用户类

用户JavaBean和service类

@Data
class User {
    private String id;
    private String name;
}


interface UserService {
    int insert(User user);
    User getById(String id);
}

class SQLServerUserServiceImpl implements UserService {
    public int insert(User user) {
        System.out.println("在SQLServer中給用戶表增加一條記錄");
        return 0;
    }
    public User getById(String id) {
        System.out.println("在SQLServer中根据用戶id获取一个用户记录");
        return null;
    }
}
class MySQLUserServiceImpl implements UserService {
    public int insert(User user) {
        System.out.println("在MySQL中給用戶表增加一條記錄");
        return 0;
    }
    public User getById(String id) {
        System.out.println("在MySQL中根据用戶id获取一个用户记录");
        return null;
    }
}

工厂方法的实现

interface IFactory {
    UserService createUserService();
}

class SQLServerFactory implements IFactory {
    public UserService createUserService() {
        return new SQLServerUserServiceImpl();
    }
}
class MySQLFactory implements IFactory {
    public UserService createUserService() {
        return new MySQLUserServiceImpl();
    }
}

客户端调用

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        User user = new User();
        user.setId("1");
        user.setName("张三");
        IFactory factory = new MySQLFactory();
        
        UserService userService = factory.createUserService();
        userService.insert(user);
        userService.getById("1");
    }
}

新增部门的业务

增加了部门的处理

新增了业务部门的代码

@Data
class Department {
    private String id;
    private String name;
}

interface DepartmentService {
    int insert(Department user);
    Department getById(String id);
}

class SQLServerDepartmentServiceImpl implements DepartmentService {
    public int insert(Department user) {
        System.out.println("在SQLServer中給部门表增加一條記錄");
        return 0;
    }
    public Department getById(String id) {
        System.out.println("在SQLServer中根据部门id获取一个部门记录");
        return null;
    }
}

class MySQLDepartmentServiceImpl implements DepartmentService {
    public int insert(Department user) {
        System.out.println("在MySQL中給部门表增加一條記錄");
        return 0;
    }
    public Department getById(String id) {
        System.out.println("在MySQL中根据部门id获取一个部门记录");
        return null;
    }
}

工厂类的变动

interface IFactory {
    UserService createUserService();
    DepartmentService createDepartmentService();
}

class SQLServerFactory implements IFactory {
    public UserService createUserService() {
        return new SQLServerUserServiceImpl();
    }
    public DepartmentService createDepartmentService() {
        return new SQLServerDepartmentServiceImpl();
    }
}

class MySQLFactory implements IFactory {
    public UserService createUserService() {
        return new MySQLUserServiceImpl();
    }
    public DepartmentService createDepartmentService() {
        return new MySQLDepartmentServiceImpl();
    }
}

客户端代码

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        IFactory factory = new MySQLFactory();
//      IFactory factory = new SQLServerFactory();
        UserService userService = factory.createUserService();
        userService.insert(new User("1","张三"));
        userService.getById("1");
        
        DepartmentService dService = factory.createDepartmentService();
        dService.insert(new Department("1","财务部"));
        dService.getById("1");
    }
}

抽象工厂（Abstract Factory）模式

---

提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。

抽象工厂模式架构图

用简单工厂改进抽象工厂

用简单工厂改进抽象工厂代码结构图

package study.factory;

public class DataAccess {
    
    private final static String db = "SqlServer";
    
//  private final static String db = "MySql";
    
    public static IUserService createUserService(){
        IUser result = null;
        switch(db) {
            case "SqlServer" :
                result = new SQlServerUserImpl();
                break;
            case "MySql" :
                result = new MySQlUserImpl();
                break;
        }
        return result;
    }
    
    public static IDepartmentService createDepartmentService() {
        IDepartmenServicet result = null;
        switch(db) {
            case "SqlServer" :
                result = new SQlServerDepartmentImpl();
                break;
            case "MySql" :
                result = new MySQlDepartmentImpl();
                break;
        }
        return result;
    }
}

class client {
    public static void main(String[] args) {
        User user = new User();
        Department dept = new Department();
        
        IUserService iu = DataAccess.createUserService();
        iu.insert(user);
        iu.getUser("1");
        
        IDepartmentService deptService = DataAccess.createDepartmentService();
        deptService.insert(dept);
        deptService.getById("1");
    }
}

反射 + 抽象工厂设计模式，去掉switch分支

可参考马老师教学代码