工厂模式

浅析设计模式1 —— 工厂模式

设计模式分类

创建型模式是对垒的实例化过程进行抽象，从而将对象的穿件和使用分离开，工厂模式属于创建型模式的范畴

基本概念

工厂模式的核心思想就是创建对象和使用对象的解耦，由工厂负责对象的创建，而用户只能通过接口来使用对象，这样就可以灵活应对变化的业务需求，方便代码管理，避免代码重复

简单工厂模式

顾名思义，简单工厂模式是最简单的一种工厂模式，它定义了一个负责生产对象的工厂类，使用者可以根据不同参数来创建并返回不同子类，这些子类都共用一个接口（即父类）。

结构

简单工厂模式包含三种类，分别是抽象产品类、具体产品类、工厂类，下面分别对各类及它们之间的关系作进一步说明。

使用

有了上述的基本概念，我们将简单工厂模式的使用步骤概括为：

step1: 创建抽象产品类，并为具体产品定义好一个接口
step2: 创建具体产品类，其通过接口来集成抽象产品类，同时也要定义计划生产的每一个具体产品
step3: 创建工厂类，器创建的静态方法可以对传入的不同参数做出响应
step4: 外界使用这就能调用工厂类的静态方法了，通过传入不同参数来创建不同具体产品实例

 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


//step1:创建抽象产品类，定义具体产品的公共接口
public abstract class Shirt{
    public abstract void Show();
}

//step2:创建具体产品类（继承抽象产品类），定义生产的具体产品
//具体产品类A，女款衬衫
public class WomenShirt extends Shirt{
    @Override
    public void Show(){
        System.out.println("展示女款衬衫");
    }
}
//具体产品类B，男款
public class MenShirt extends Shirt{
    @Overside
    public void Show(){
        System.out.println("展示男款衬衫")；
        }
}

//step3:创建工厂类，通过静态方法处理不同传入参数，从而创建不同具体产品类的实例
public class Factory{
    public static Shirt Exhibit(String ShirtName){
        switch(ShirtName){
            case "女款衬衫":
                return new WomenShirt();
            case "男款衬衫":
                return new MenShirt();
            default:
                return null;
        }
    }
}

//step4:外界调用工厂类的静态方法，传入不同参数创建不同具体产品类的实例
public class SimpleFactoryPattern{
    public static void main(String[] args){
        Factory exhibitFactory = new Factory();
        //用户搜索女款衬衫
        try{
            //调用工厂类的静态方法，传入参数并创建实例
            exhibitFactory.Exhibit("女款衬衫").Show();
        }catch(NullPointerException e){
            System.out.println("没有找到商品");
        }
        //用户搜索男款裤子
        try{
            exhibitFactory.Exhibit("男款裤子").Show();
        }catch(NullPointerException e){
            System.out.println("没有找到商品");
        }
        //用户搜索男款衬衫
        try{
            exhibitFactory.Exhibit("男款衬衫").Show();
        }catch(NullPointerException e){
            System.out.println("没有找到商品");
        }
    }
}

优点

将对象的使用和创建过程分离开，实现解藕。客户端不需要关注对象是谁创建的、怎么创建的，只要通过工厂中的静态方法就可以直接获取其需要的对象。
将初始化实例的工作放到工厂里执行，代码易维护，更符合面向对象的原则，做到面向接口编程，而不是面向实现编程。

缺点

工厂类中需要选择创建具体某个对象，所以一旦添加新产品则必须要对工厂中的选择逻辑进行修改，导致工厂逻辑过于复杂，违背开闭原则。
工厂类集合了所有实例（具体产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响。
静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。

场景

具体产品类比较少，使用简单工厂模式可以实现生产者与消费者的分离，而且也不会在工厂中定义太复杂的判断逻辑
使用者只需要知道工厂类的参数，不关系如何创建对象的逻辑时

工厂方法模式

工厂方法模式包含四种类，分别是抽象产品类，具体产品类，抽象工厂类，具体工厂类

使用

step1: 创建抽象工厂类，定义具体工厂的公共接口
step2: 创建抽象产品类，定义具体产品的公共接口
step3: 创建具体产品类(继承抽象产品类), 定义生产的具体产品
step4: 创建具体工厂类(集成抽象工厂类), 定义创建相应具体产品实例的方法
step5: 外界调用具体工厂类的方法，创建不同产品类的实例

 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


//step1:创建抽象工厂类，定义具体工厂的公共接口
public abstract class Factory{
    public abstract Shirt Exhibit();
}

//step2:创建抽象产品类，定义具体产品的公共接口
public abstract class Shirt{
    public abstract void Show();
}

//step3:创建具体产品类（继承抽象产品类），定义生产的具体产品
//具体产品类A，女款衬衫
public class WomenShirt extends Shirt{
    @Override
    public void Show(){
        System.out.println("展示女款衬衫");
    }
}
//具体产品类B，男款衬衫
public class MenShirt extends Shirt{
    @Overside
    public void Show(){
        System.out.println("展示男款衬衫")；
    }
}

//step4:创建具体工厂类，定义创建具体产品实例的方法
//具体工厂类A，展示女款衬衫类商品  
public class WomenShirtFactory extends Factory{
   @Overside
    public Shirt Exhibit(){
        return new WomenShirt()；
    }
}
//具体工厂类B，展示男款衬衫类商品
public class MenShirtFactory extends Factory{
   @Overside
    public Shirt Exhibit(){
        return new MenShirt()；
    }
}

//step5:外界调用具体工厂类的方法，创建不同具体产品类的实例
public class FactoryPattern{
    public static void main(String[] args){
        //用户在店铺搜索女款衬衫
        Factory exhibitWomenShirtFactory = new WomenShirtFactory();
        exhibitWomenShirtFactory.Exhibit().Show();
        
        //用户在店铺搜索男款衬衫
        Factory exhibitMenShirtFactory = new MenShirtFactory();
        exhibitMenShirtFactory.Exhibit().Show();       
    }
}

ps: 其实把if else 判断具体创建哪种产品交给了外部调用者来区分

优点

符合开闭原则，新增一种产品时，只需要增加相应的具体产品类和工厂子类即可，可发方便的生产或者切换产品
符合单一原则，每个具体工厂类只负责创建对应的具体产品，而简单工厂中工厂类可能存在比较复杂的逻辑
相对于简单工厂模式，可形成基于继承的等级结构

缺点

一个具体工厂只能创建一种具体产品，添加新产品的时, 除增加新产品类外，还要提供与之对应的工厂类，类的个数成对增加，在一定程度是哪个增加了系统的复杂度，同时有更多的类需要加载与编译，给系统带来了额外的开销
由于考虑到系统的可扩展行，引入了抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，增加了系统的实现难度
虽然保证了工厂方法内的对修改的关闭，但对于使用工厂的类，如果需要更改另一种产品，仍需要修改实例化的具体工厂类
难以对于父类接口进行修改，因为一旦修改接口，就必须要对众多的子类进行修改

适用场景

一个类不确定他所必须创建的对象的类，在工厂方法模式长胖呢个，客户端不需要知道具体产品类的类名，只需要知道对应的工厂即可
你期望获得较高的扩展性
一个类希望由它的子类来指定它所创建的对象。在工厂方法模式中，对于抽象工厂类只需提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏替换原则，在程序运行时，子类对象将覆盖父类对象，从而使系统更容易扩展
当类将创建对象的职责委托给多个工厂子类中的一个，而且用户知道要使用那个一个子类(判断放在了客户端这里)

抽象工厂模式

抽象工厂模式，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个具体工厂可以创建多类具体产品；而工厂方法每个具体工厂只能创建一类具体产品。

结构

抽象工厂模式包含五种类，分别是抽象产品族类、抽象产品类、具体产品类、抽象工厂类、具体工厂类感觉就是又增加了一层抽象层抽象产品族

使用

step1：创建抽象工厂类，定义具体工厂的公共接口；
step2：创建抽象产品族类，定义抽象产品的公共接口；
step3：创建抽象产品类（继承抽象产品族类），定义具体产品的公共接口；
step4：创建具体产品类（继承抽象产品类），定义生产的具体产品；
step5：创建具体工厂类（继承抽象工厂类），定义创建相应具体产品实例的方法；
step6：外界调用具体工厂类的方法，创建不同具体产品类的实例。

 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


//step1:创建抽象工厂类，定义具体工厂的公共接口
public abstract class Factory{
    public abstract Clothing ExhibitShirt();
    public abstract Clothing ExhibitTrousers();
}

//step2:创建抽象产品族类，定义抽象产品的公共接口
public abstract class Clothing{
    public abstract void Show();
}

//step3:创建抽象产品类，定义具体产品的公共接口
// 短袖抽象类
public abstract class Shirt extends Clothing{
    @Override
    public abstract void Show();
}
// 裤子抽象类
public abstract class Trousers extends Clothing{
    @Override
    public abstract void Show();
}

//step4:创建具体产品类（继承抽象产品类），定义生产的具体产品
//衬衫产品类A，淘宝衬衫
public class TBShirt extends Shirt{
    @Override
    public void Show(){
        System.out.println("展示淘宝店铺衬衫");
    
}
//衬衫产品类B，淘特衬衫
public class TTShirt extends Shirt{
    @Overside
    public void Show(){
        System.out.println("展示淘特店铺衬衫")；
    }
}
//裤子产品类A，淘宝裤子
public class TBTrousers extends Trousers{
    @Override
    public void Show(){
        System.out.println("展示淘宝店铺裤子");
    }
}
//裤子产品类B，淘特裤子
public class TTTrousers extends Trousers{
    @Overside
    public void Show(){
        System.out.println("展示陶特店铺裤子")；
    }
}

//step5:创建具体工厂类，定义创建具体产品实例的方法
//淘宝工厂类A，展示衬衫+裤子  
public class TBFactory extends Factory{
    @Overside
    public Clothing ExhibitShirt(){
        return new TBShirt()；
    }
    @Overside
    public Clothing ExhibitTrousers(){
        return new TBTrousers()；
    }
}
//淘特工厂类B，展示裤子+衬衫
public class TTFactory extends Factory{
    @Overside
    public Clothing ExhibitShirt(){
        return new TTShirt()；
    }
    @Overside
    public Clothing ExhibitTrousers(){
        return new TTTrousers()；
    }
}

//step6:外界实例化具体工厂类，调用工厂类中创建不同目标产品的方法，创建不同具体产品类的实例
public class AbstractFactoryPattern{
    public static void main(String[] args){
        TBFactory exhibitTBFactory = new TBFactory();
        TTFactory exhibitTTFactory = new TTFactory();
        //淘宝用户搜索衬衫
        exhibitTBFactory.ExhibitShirt().Show();
        //淘宝用户搜索衬衫
        exhibitTBFactory.ExhibitTrousers().Show();
        //淘特用户搜索衬衫
        exhibitTTFactory.ExhibitShirt().Show();
        //淘特用户搜索衬衫
        exhibitTTFactory.ExhibitTrousers().Show();     
    }
}

优点

降低耦合度。抽象工厂模式将具体产品的创建延迟到具体工厂类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而降低系统耦合度，有利于后期的维护和扩展。
符合开闭原则。新增一种产品类时，只需增加相应的具体产品类和工厂子类即可，简单工厂模式需要修改工厂类的判断逻辑。
符合单一职责原则。每个具体工厂类只负责创建对应的产品，简单工厂模式中的工厂类需要进行复杂的 switch 逻辑判断。
不使用静态工厂方法，可以形成基于继承的等级结构。
便于添加更换产品族。因为具体产品都是由具体工厂创建的，所以在更换产品族的时候只要简单修改具体工厂即可。
具体产品的创建过程和客户端隔离。客户端通过操作抽象产品接口实现操作具体产品实例，具体产品的类名不会出现在客户端中。

缺点

难以支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可被创建的产品集合，如果需要添加新产品，此时就必须去添加抽象产品接口，还要在抽象工厂接口中添加新方法，并在所有具体工厂中实现该新方法。这样就会改变抽象工厂类以及所有具体工厂子类的改变，违背开闭原则。
类图有点复杂，可读性没有工厂方法模式高。

场景

系统不要求依赖产品类实例如何被创建、组合和表达，这点也是所有工厂模式应用的前提。
系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。
系统中有多个产品族，但每次只使用其中某一族产品。（切换产品族只需修改具体工厂对象即可）

总结

简单工厂模式：让一个工厂类负责创建所有对象；但没有考虑后期扩展和维护，修改违背开闭原则，静态方法不能被继承。
工厂方法模式：主要思想是继承，修改符合开闭原则；但每个工厂只能创建一种类型的产品。
抽象工厂模式：主要思想是组合，本质是产品族，实际包含了很多工厂方法，修改符合开闭原则；但只适用于增加同类工厂这种横向扩展需求，不适合新增功能方法这种纵向扩展。

其实这三种工厂模式在形式和特点上都非常相似，甚至存在一定的内在联系，而且最终目的都是解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为它们之间也是可以灵活转变的。比如你原本使用的是工厂方法模式，加入一个新方法后就可能会让具体产品类构成不同等级结构中的产品族，代码结构就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个或多个具体产品类时，使原有产品族只剩下一个产品后，代码结构也就转变成了工厂方法模式。

工厂模式#

设计模式分类#

基本概念#

简单工厂模式#

结构#

使用#

优点#

缺点#

场景#

工厂方法模式#

使用#

优点#

缺点#

适用场景#

抽象工厂模式#

结构#

使用#

优点#

缺点#

场景#

总结#