工厂设计模式

1、一个具体需求

一个披萨的项目：要便于披萨种类的扩展，要便于维护。

1）披萨的种类很多（比如GreekPizz、CheesePizz等）

2）披萨的制作有prepare，bake，cut，box

3）完成披萨店订购功能。

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
// 将Pizza类做成抽象类
public abstract class Pizza {
    protected String name;
    // 准备原材料，不同pizza是不一样的
    public abstract void prepare();
    public void bake() {
        System.out.println(name + "baking;");
    }
    public void cut() {
        System.out.println(name + "cutting;");
    }
    public void box() {
        System.out.println(name + "boxing");
    }
    public void setName(String name) {
        this.name = name;
    }
}

// 奶酪pizza
public class CheesePizza extends Pizza {
    public CheesePizza(){
        setName("奶酪披萨");
    }
    
    @Override
    public void prepare() {
        // 制作奶酪原材料
        System.out.println("为制作奶酪披萨准备原材料");
    }
}

// 希腊pizza
public class GreekPizza extends Pizza {
    public GreekPizza(){
        setName("希腊披萨");
    }
    
    @Override
    public void prepare() {
        System.out.println("为制作希腊披萨准备原材料");
    }
}

// 订购pizza
public class OrderPizza {
    // 构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨的类型
        do {
            orderType = getType();
            if ("greek".equals(orderType)) {
                pizza = new GreekPizza();
            } else if ("cheese".equals(orderType)) {
                pizza = new CheesePizza();
            } else {
                break;
            }
            // 输出pizza制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while(true);
    }
    
    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

5）以上传统编码方式的优缺点

① 优点是比较好理解，简单易操作。

② 缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。

③ 比如我们这时要新增一个Pizza的种类（胡椒pizza），我们需要做如下修改。

1
2
3
4
5
6
7
8
9
10
11
12
if ("greek".equals(orderType)) {
    pizza = new GreekPizza();
    pizza.setName("希腊披萨");
} else if ("cheese".equals(orderType)) {
    pizza = new CheesePizza();
    pizza.setName("奶酪披萨");
} else if ("pepper".equals(orderType)) {
    pizza = new PepperPizza();
    pizza.setName("胡椒披萨");
} else {
    break;
}

6）改进的思路分析

分析：修改代码可以接受，但是如果我们在其它的地方也有创建Pizza的代码，就意味着也需要修改，而创建Pizza的代码，往往有多处。

思路：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类即可，其他有创建Pizza对象的代码就不需要修改了——>简单工厂模式。


2、简单工厂模式

1）简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。

2）简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为（代码）。

3）在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

4）工厂模式最大的优点就是：解耦

简单工厂包含如下角色：

  • 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品：实现或者继承抽象产品的子类。
  • 具体工厂 ：提供了创建产品的方法，调用者通过该方法来创建产品。
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
44
45
46
47
48
49
50
51
52
53
54
55
56
// 简单工厂类
public class SimpleFactory {
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if ("greek".equals(orderType)) {
            pizza = new GreekPizza();
        } else if ("cheese".equals(orderType)) {
            pizza = new CheesePizza();
        } else if ("pepper".equals(orderType)) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
    }
}

// 订购pizza
public class OrderPizza {
	// 定义一个简单工厂对象
    private static final SimpleFactory simpleFactory = new SimpleFactory();
    
    public OrderPizza() {
        do {
            String orderType = getType();  // 订购披萨的类型
            // 输出pizza制作过程
            Pizza pizza = simpleFactory.createPizza(orderType);
            if (pizza == null) {
                System.out.println("订购披萨失败");
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while(true);
    }
    
    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

/*
	简单工厂模式也叫静态工厂模式。
	将SimpleFactory类的createPizza方法变为静态方法，使用更方便，但是考虑到工厂也有不同形式的，所以使用对象的方式更加灵活。
*/

5）在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 静态工厂
public class SimpleFactory {
    public static Pizza createPizza(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if ("greek".equals(orderType)) {
            pizza = new GreekPizza();
        } else if ("cheese".equals(orderType)) {
            pizza = new CheesePizza();
        } else if ("pepper".equals(orderType)) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
    }
}

3、工厂方法模式

1）新需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、北京的胡椒pizza或者是伦敦的奶酪pizza、伦敦的胡椒pizza。

2）思路1：使用简单工厂模式，创建不同的简单工厂类，比如BJPizzaSimpleFactory、LDPizzaSimpleFactory等等。从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好。

3）思路2：使用工厂方法模式。


【1】工厂方法模式介绍

工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到工厂的子类。


【3】工厂方法模式应用至以上新需求
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
// 将Pizza类做成抽象类
public abstract class Pizza {
    protected String name;
    // 准备原材料，不同pizza是不一样的
    public abstract void prepare();
    public void bake() {
        System.out.println(name + "baking;");
    }
    public void cut() {
        System.out.println(name + "cutting;");
    }
    public void box() {
        System.out.println(name + "boxing");
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class BJCheesePizza extends Pizza {
    public BJCheesePizza(){
        setName("北京的奶酪披萨");
    }
    
    @Override
    public void prepare() {
        // 制作奶酪原材料
        System.out.println("为制作北京奶酪披萨准备原材料");
        
    }
}

public class BJPepperPizza extends Pizza {
    public BJPepperPizza(){
        setName("北京的胡椒披萨");
    }
    
    @Override
    public void prepare() {
        System.out.println("为制作北京胡椒披萨准备原材料");
    }
}

public class LDPepperPizza extends Pizza {
    public LDPepperPizza(){
        setName("伦敦的胡椒披萨");
    }
    
    @Override
    public void prepare() {
        System.out.println("为制作伦敦胡椒披萨准备原材料");
    }
}

public class LDCheesePizza extends Pizza {
    public LDCheesePizza(){
        setName("伦敦的奶酪披萨");
    }
    
    @Override
    public void prepare() {
        System.out.println("为制作伦敦奶酪披萨准备原材料");
    }
}

// 订购pizza
public abstract class OrderPizza {
	// 定义一个抽象方法，createPizza，让各个工厂子类自己实现
	public abstract Pizza createPizza(String orderType);
    
    public OrderPizza() {
        do {
            String orderType = getType();  // 订购披萨的类型
            // 抽象方法，由工厂子类完成
            Pizza pizza = createPizza(orderType);
            if (pizza == null) {
                System.out.println("订购披萨失败");
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while(true);
    }
    
    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

public BJOrderPizza extends OrderPizza {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if ("BJCheese".equals(orderType)) {
            pizza = new BJCheesePizza();
        } else if ("BJPepper".equals(orderType)) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

public LDOrderPizza extends OrderPizza {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if ("LDCheese".equals(orderType)) {
            pizza = new LDCheesePizza();
        } else if ("LDPepper".equals(orderType)) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}


4、抽象工厂模式

1）抽象工厂模式：定义了一个Interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。

2）抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

3）从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）。

4）将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个简单工厂类变成了工厂簇，更利于代码的维护和扩展。

抽象工厂模式结构角色：

  • 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
  • 具体工厂（Concrete Factory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品（Concrete Product）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
// 一个抽象工厂模式的抽象层（接口）
public interface AbsFactory {
     Pizza createPizza(String orderType);
    
    // 可以包含多个创建产品的方法，可以创建多个不同等级的产品。比如除了创建披萨，还能创建面包、汉堡、咖啡等
    
    // 因此如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他类。
    // 但是比如产品族中需要增加一个新的产品时，所有的工厂类都要进行修改，因为多了一个抽象方法。
    
    // 使用场景：
    // 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的 电视机、洗衣机、空调等。
    // 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
    // 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。
    // 如：输入法换皮肤，一整套一起换。生成不同操作系统的程序。
}

// BJ工厂子类
public BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if ("BJCheese".equals(orderType)) {
            pizza = new BJCheesePizza();
        } else if ("BJPepper".equals(orderType)) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

// LD工厂子类
public LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if ("LDCheese".equals(orderType)) {
            pizza = new LDCheesePizza();
        } else if ("LDPepper".equals(orderType)) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

// 将Pizza类做成抽象类
public abstract class Pizza {
    protected String name;
    // 准备原材料，不同pizza是不一样的
    public abstract void prepare();
    public void bake() {
        System.out.println(name + "baking;");
    }
    public void cut() {
        System.out.println(name + "cutting;");
    }
    public void box() {
        System.out.println(name + "boxing");
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class BJCheesePizza extends Pizza {
    public BJCheesePizza(){
        setName("北京的奶酪披萨");
    }
    
    @Override
    public void prepare() {
        // 制作奶酪原材料
        System.out.println("为制作北京奶酪披萨准备原材料");
        
    }
}

public class BJPepperPizza extends Pizza {
    public BJPepperPizza(){
        setName("北京的胡椒披萨");
    }
    
    @Override
    public void prepare() {
        System.out.println("为制作北京胡椒披萨准备原材料");
    }
}

public class LDPepperPizza extends Pizza {
    public LDPepperPizza(){
        setName("伦敦的胡椒披萨");
    }
    
    @Override
    public void prepare() {
        System.out.println("为制作伦敦胡椒披萨准备原材料");
    }
}

public class LDCheesePizza extends Pizza {
    public LDCheesePizza(){
        setName("伦敦的奶酪披萨");
    }
    
    @Override
    public void prepare() {
        System.out.println("为制作伦敦奶酪披萨准备原材料");
    }
}

// 订购pizza
public class OrderPizza {
	// 组合/聚合一个抽象工厂
	public AbsFactory absFactory = new DefaultFactory();
    
    public void setFactory(AbsFactory factory) {
        this.absFactory = factory;
    }
    
    public OrderPizza() {
        do {
            String orderType = getType();  // 订购披萨的类型
            // 抽象工厂来调用子类方法
            Pizza pizza = absFactory.createPizza(orderType);
            if (pizza == null) {
                System.out.println("订购披萨失败");
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while(true);
    }
    
    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

5）优缺点

用户只需要知道具体工厂的名称就可得到所要的产品，无需知道产品的具体创建过程。

在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则。

但每增加一种产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。


5、模式扩展

【1】简单工厂+配置文件解除耦合

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。

第一步：定义配置文件

为了演示方便，我们使用properties文件作为配置文件，名称为bean.properties。

1
2
american=com.itheima.pattern.factory.config_factory.AmericanCoffee
latte=com.itheima.pattern.factory.config_factory.LatteCoffee

第二步：改进工厂类

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
public class CoffeeFactory {
    
    // 加载配置文件，获取配置文件中配置的全类名，并创建该类的对象进行存储
    // 1，定义容器对象存储咖啡对象
    private static Map<String, Coffee> map = new HashMap();
    
    // 2，加载配置文件，只需要加载一次
    static {
        // 2.1 创建Properties对象
        Properties p = new Properties();
        // 2.2 调用p对象中的load方法进行配置文件的加载
        InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        try {
            p.load(is);
            // 从p集合中获取全类名并创建对象
            Set<Object> keys = p.keySet();
            for (Object key: keys) {
                String className = p.getProperty((String) key);
                // 通过反射技术创建对象
                Class clazz = Class.forName(className);
                Coffee coffee = (Coffee) class.newInstance();
                map.put((String)key, coffee);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    // 根据名称获取对象
    public static Coffee createCoffee(String name) {
        return map.get(name);
    }
}

6、JDK源码解析-Collection.iterator方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("令狐冲");
        list.add("风清扬");
        list.add("任我行");
        
        // 获取迭代器对象
        Iterator<String> it = list.iterator();
        // 使用迭代器遍历
        while(it.hasNext()) {
            String ele = it.next();
            System.out.println(ele);
        }
    }
}

对上面的代码大家应该很熟，使用迭代器遍历集合，获取集合中的元素。而单列集合获取迭代器的方法就使用到了工厂方法模式，我们看通过类图看看结构：

image-20230617004433222

Collection接口是抽象工厂类，ArrayList是具体的工厂类；Iterator接口是抽象商品类，ArrayList类中的Iter内部类是具体商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象。

1，DateFormat类中的getInstance()方法作用是工厂模式。

2，Calendar类中的getInstance()方法使用的是工厂模式。


7、工厂模式小结

1）工厂模式的意义

将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目依赖关系的解耦。从而提高项目的可扩展和维护性。

2）三种工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）

3）设计模式的依赖抽象原则

创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。

不要让类继承具体类，而是继承抽象类或者是实现interface（接口）

不要覆盖基类中已经实现的方法。