工厂模式【简单工厂+工厂+抽象工厂】总结

一、简单工厂模式

1. 描述
   • 简单工厂模式是属于创建型模式，又叫做静态工厂方法模式，但不属于23种GOF设计模式之一。
   • 简单工厂模式中专门定义一个简单工厂类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
   • 简单工厂类根据传入的参数，动态决定应该实例哪一个类。这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。
2. UML 类图
   
3. 优点
   • 对象的创建和对象本身业务分离，降低系统的耦合度。
   • 客户类不需要知道所创建的具体产品类的类名以及创建过程，只需要知道具体产品类所对应的参数即可。
   • 简单工厂可以动态实例对象，灵活性高。
4. 缺点
   • 不符合开闭原则，每次添加新对象就需要修改工厂类的判断逻辑。
   • 在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展维护，并且工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。

二、工厂方法模式

1. 描述
   • 工厂方法模式又称为工厂模式，也叫多态工厂模式，它属于类创建型模式。
   • 工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
2. UML 类图
   
3. 优点
   • 符合了开闭原则，扩展时不必去修改原来的代码。
   • 符合单⼀职责原则，每个⼯⼚只负责⽣产对应的产品。
   • 一个调用者想创建一个对象，只要知道其名称就可以了。
   • 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。
4. 缺点
   • 每加一个产品，都需要加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
   • 抽象产品只能生产一种产品。
5. 简单工厂模式与工厂方法模式区别：
   • 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。
   • 工厂方法模式加入了“开放-封闭原则”（软件实体类、模块或者函数等等，应该可以扩展，但是不可以修改），将简单工厂的内部判断逻辑，移动到了客户端代码来进行，在扩展新功能的时候，简单工厂模式要修改工厂类，工厂方法模式要修改客户端。
   • ⼯⼚⽅法模式引⼊⼯⼚等级结构，解决了简单⼯⼚模式中⼯⼚类职责过重的问题。

三、抽象工厂模式

1. 描述
   • 抽象工厂模式又称为Kit模式，属于对象创建型模式。
   • 抽象工厂模式：提供一个接口，用于创建一系列相关或相互依赖对象的家族，而无需指定它们具体的类。
2. 产品族和产品等级
   • 产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品；
     • 如比亚迪生产电动车、燃油车和混动车，则比亚迪电动车位于电动车产品族中。
   • 产品等级：产品等级结构指的是产品的继承结构；
     • 如一个抽象类是电动车，其子类有比亚迪电动车、五菱电动车、长安电动车等一系列的子类，则抽象类汽车和他的具体品牌子类就构成了一个产品等级结构。

产品等级结构和产品族结构示意图如下：

3. UML 类图
   
4. 优点
   • 易于交换产品系列，只需要改变具体工厂即可使用不同的产品配置。
   • 让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离。
   • 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
   • 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
5. 缺点
   • 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）
6. 工厂方法模式与抽象工厂模式的区别在于：
   • 工厂方法只有一个抽象产品类和一个抽象工厂类，但可以派生出多个具体产品类和具体工厂类，每个具体工厂类只能创建一个具体产品类的实例。
   • 抽象工厂模式拥有多个抽象产品类（产品族）和一个抽象工厂类，每个抽象产品类可以派生出多个具体产品类；抽象工厂类也可以派生出多个具体工厂类，同时每个具体工厂类可以创建多个具体产品类的实例
7. 代码实现
   实体层

//user表
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;
    }
}

//department表
public class Department {
    private int id;
    private String department_name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getDepartment_name() {
        return department_name;
    }

    public void setDepartment_name(String department_name) {
        this.department_name = department_name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

定义AbstractProductA和 AbstractProductB

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

public interface IDepartment {
    void insert(Department department);
    }
1
2
3
4
5
6
7
8

创建具体类

//sql
class SQLServerUser implements IUser {

    @Override
    public void insert(User user) {
        System.out.println("在SQL Server中给User表加一条记录");
    }
}
class AccessUser implements IUser{

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

    }
}


class SQLServerDepartment implements IDepartment {

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

class AccessDepartment implements IDepartment{

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

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

创建抽象⼯⼚接⼝

public interface IFactory {
    IUser createUser();
    IDepartment createDepartment();
}
1
2
3
4

具体工厂

class SQLServerFactory implements IFactory{

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

    @Override
    public IDepartment createDepartment() {
        return new SQLServerDepartment();
    }
}
class AccessFactory implements IFactory{

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

    @Override
    public IDepartment createDepartment() {
        return new AccessDepartment();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

 public static void main(String[] args) {
	User user = new User();
	IFactory factory = new SQLServerFactory();
    IUser iu = factory.createUser();
    iu.insert(user);
}
1
2
3
4
5
6

用反射+抽象工厂的数据访问程序

public class DataAccess {
 public static IUser getUser(String server) {
        try {
            //获取Class对象
            Class<?> sql_server = Class.forName("设计模式.抽象工厂与反射." + server +"User");
            //new SQLServerUser();
            Constructor<?> con = sql_server.getDeclaredConstructor();
            return (IUser) con.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    public static IDepartment getDepartment(String server){
        try {
            //获取Class对象
            Class<?> sql_server = Class.forName("设计模式.抽象工厂与反射." + server +"Department");
            //new SQLServerUser();
            Constructor<?> con = sql_server.getDeclaredConstructor();
            return (IDepartment) con.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public static void main(String[] args) {
 	    User user = new User();
	    Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据库：");
        String server = sc.next();
        IUser iUser = DataAccess.getUser(server);
         iUser.insert(user);
}
1
2
3
4
5
6
7
8