设计模式 - 学习笔记 - 工厂模式Factory Pattern

谁践踏了优雅 2023-05-21 12:57 44阅读 0赞

### 设计模式 - 学习笔记 - 工厂模式Factory Pattern ###

*  1. 简单工厂
 *   *  1.1 应用场景
     *  1.2 UML
     *  1.3 优劣分析
     *   *  好处
         *  缺点
     *  1.4 代码示例
     *   *  抽象产品 AbstractProduct（米粉）
         *  具体产品类（牛肉粉、酸辣粉）
         *  工厂类 Factory （米粉店）
         *  客户端 SimpleFactoryPatternTest
 *  2. 工厂方法模式
 *   *  2.1 应用场景
     *  2.2 UML
     *  2.3 优劣分析
     *   *  好处
         *  缺点
     *  2.4 代码示例
     *   *  抽象产品 AbstractProduct（米粉）
         *  具体产品类（牛肉粉、酸辣粉）
         *  抽象工厂 AbstractProduct（米粉店）
         *  具产工厂（牛肉粉店、酸辣粉店）
         *  客户端 FactoryMethodPatternTest
 *  3 抽象工厂模式
 *   *  3.1 应用场景
     *  3.2 UML
     *  3.3 优劣分析
     *   *  好处
         *  缺点
     *  3.4 代码示例
     *   *  抽象产品
         *  具体产品类
         *  抽象工厂 AbstractFactory （米粉店）
         *  具体产品
         *  客户端 AbstractFactoryPatternTest
 *  总结
 *  参考资料

# 1. 简单工厂 #

## 1.1 应用场景 ##

当创建一个对象A的过程比较复杂时，为了把业务逻辑解耦出来，我们封装类B来实现这个创建过程，这个类A就好比产品，创建它的类B就好比工厂。  
简单工厂就是 `if...else` \+ `接口` 的基本用法。根据条件判断返回实现类的实例，然后用个接口引用接收。

## 1.2 UML ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p4NTIw_size_16_color_FFFFFF_t_70]

## 1.3 优劣分析 ##

### 好处 ###

*  将创建`产品`的工作封装在一个`工厂`中，与`客户端`解耦。
 *  实现原理简单： `if...else` \+ `多态` 的应用。

### 缺点 ###

*  客户端需要知道所有策略。（实际应用中可以考虑与其它模式相结合）
 *  添加or修改任意一个产品就需要修改工厂类。（违反开闭原则、单一职责原则）

## 1.4 代码示例 ##

### 抽象产品 AbstractProduct（米粉） ###

public interface AbstractProduct { 
        void show();
    }

### 具体产品类（牛肉粉、酸辣粉） ###

public class 牛肉粉Impl implements AbstractProduct { 
        public void show() { 
            System.out.println("这是一碗：牛肉粉");
        }
    }
    
    public class 酸辣粉Impl implements AbstractProduct { 
        public void show() { 
            System.out.println("这是一碗：酸辣粉");
        }
    }

### 工厂类 Factory （米粉店） ###

/** * 米粉店 (工厂类) */
    public class Factory { 
        /** 方便客户端使用，把所有产品列出来。（其实搞个枚举也不错） */
        public static final String 牛肉粉 = "牛肉粉";
        public static final String 酸辣粉 = "酸辣粉";
    
        /** * 使用 下粉 方法获取产品 * @param 米粉名字 * @return */
        public AbstractProduct 下粉(String 米粉名字){ 
            if(Factory.牛肉粉.equalsIgnoreCase(米粉名字)){ 
                return new 牛肉粉Impl();
            } else if(Factory.酸辣粉.equalsIgnoreCase(米粉名字)){ 
                return new 酸辣粉Impl();
            }
            return null;
        }
    }

### 客户端 SimpleFactoryPatternTest ###

public class SimpleFactoryPatternTest { 
        public static void main(String[] args) { 
            Factory 粉店 = new Factory();
    
            AbstractProduct 牛肉粉 = 粉店.下粉(Factory.牛肉粉);
            AbstractProduct 酸辣粉 = 粉店.下粉(Factory.酸辣粉);
    
            牛肉粉.show();
            酸辣粉.show();
        }
    }

--------------------

# 2. 工厂方法模式 #

## 2.1 应用场景 ##

`工厂方法模式`可以弥补`简单工厂`存在的问题（开闭原则、单一职责原则）

## 2.2 UML ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p4NTIw_size_16_color_FFFFFF_t_70 1]

## 2.3 优劣分析 ##

### 好处 ###

*  提取出工厂接口，每个具体工厂专心生产一种产品。
    
     *  新增产品时不需要修改原有的工厂类
     *  修改指定产品时，也不用动其它的工厂和产品

### 缺点 ###

*  `一个工厂`只能生产`一个产品`，新增产品时需要成对的添加`工厂`和`产品`。
 *  引入了`AbstractFactory`加大了理解难度。

## 2.4 代码示例 ##

### 抽象产品 AbstractProduct（米粉） ###

public interface AbstractProduct { 
        void show();
    }

### 具体产品类（牛肉粉、酸辣粉） ###

public class 牛肉粉Impl implements AbstractProduct { 
        public void show() { 
            System.out.println("这是一碗：牛肉粉");
        }
    }
    public class 酸辣粉Impl implements AbstractProduct { 
        public void show() { 
            System.out.println("这是一碗：酸辣粉");
        }
    }

### 抽象工厂 AbstractProduct（米粉店） ###

public interface AbstractFactory { 
        AbstractProduct 下粉();
    }

### 具产工厂（牛肉粉店、酸辣粉店） ###

public class 牛肉粉店Impl implements AbstractFactory { 
        @Override
        public AbstractProduct 下粉() { 
            System.out.println("下了一碗牛肉粉");
            return new 牛肉粉Impl();
        }
    }
    
    public class 酸辣粉店Impl implements AbstractFactory { 
        @Override
        public AbstractProduct 下粉() { 
            System.out.println("下了一碗酸辣粉");
            return new 酸辣粉Impl();
        }
    }

### 客户端 FactoryMethodPatternTest ###

public class FactoryMethodPatternTest { 
        public static void main(String[] args) { 
            //客人想吃牛肉粉，找牛肉粉店
            AbstractFactory 牛肉粉店 = new 牛肉粉店Impl();
            AbstractProduct product牛肉粉 = 牛肉粉店.下粉();
            product牛肉粉.show();
    
            //客人想吃酸辣粉，找酸辣粉店
            AbstractFactory 酸辣粉店 = new 酸辣粉店Impl();
            AbstractProduct product酸辣粉= 酸辣粉店.下粉();
            product酸辣粉.show();
        }
    }

--------------------

# 3 抽象工厂模式 #

## 3.1 应用场景 ##

上面说的是一个工厂只生产一个产品。现实中肯定要推出尽可能多的品种来满足食客的需求。所以`一家粉店`，会做N`多种米粉`。  
![在这里插入图片描述][2020041921494738.png]

*  **横向是产品簇**：一家粉店为了竞争会生产很多粉（毕竟KFC都卖油条嘛），可以理解为一个品牌的N种产品。
 *  **纵向是产品等级** ：牛肉粉是种产品。只要复合标准规范，谁家都能生产。只是口味各不相同。
 *  **抽象产品**：对应标准规范，定义产品应该具备的能力或条件。（比如：每碗牛肉占比>= 7.5%的才能称为牛肉粉）
 *  **产品实现**：对应具体的产品（比如：一碗牛肉占比>= 7.5%的米粉）
 *  **抽象工厂**：定义品牌有生产哪些抽象产品的能力（比如一个合格的粉店最少能能生产2种以上米粉）
 *  **具体工厂**：张、王、李、赵的粉店

## 3.2 UML ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p4NTIw_size_16_color_FFFFFF_t_70 2]

## 3.3 优劣分析 ##

### 好处 ###

*  同事们拼单点一家店的米粉，就不用每个米粉创建个工厂了。共用一个`XX粉店`即可。
 *  如果还有`煎蛋、酸笋、牛肉`等加码需求，也可以在一个工厂里搞定。（不至于点了张记的米粉，又点了王记的煎蛋。现实中这两样是无法组合的。）

### 缺点 ###

*  添加产品簇好办，添加产品等级结构，就要破坏开闭原则了。
    
     *  比如竞争激烈，这条街又开了一家`湖北粉店`店好办，它家一样是卖`牛肉粉、酸辣粉、螺丝粉、三鲜粉`。大家一点都不慌。
     *  但如果最近`拉面`比较火爆，这些店家也想卖`拉面`。原来的厨子不会做这就麻烦了，换厨子或让厨子去现学，就要`修改`原来的`工厂类`了

## 3.4 代码示例 ##

### 抽象产品 ###

两种大家熟悉的米粉：`牛肉粉 、酸辣粉`

public interface I牛肉粉 { 
        void 吃粉();
    }
    
    public interface I酸辣粉 { 
        void 吃粉();
    }

### 具体产品类 ###

`张记、王记`两家不同粉店做的：`牛肉粉 、酸辣粉`

public class 张记牛肉粉Impl implements I牛肉粉 { 
        @Override
        public void 吃粉() { 
            System.out.println("这是一碗：张记牛肉粉");
        }
    }
    
    public class 张记酸辣粉Impl implements I酸辣粉 { 
        @Override
        public void 吃粉() { 
            System.out.println("这是一碗：张记酸辣粉");
        }
    }
    
    public class 王记牛肉粉Impl implements I牛肉粉 { 
        @Override
        public void 吃粉() { 
            System.out.println("这是一碗：王记牛肉粉");
        }
    }
    
    public class 王记酸辣粉Impl implements I酸辣粉 { 
        @Override
        public void 吃粉() { 
            System.out.println("这是一碗：王记酸辣粉");
        }
    }

### 抽象工厂 AbstractFactory （米粉店） ###

所有的米粉店会卖：`牛肉粉 、酸辣粉`

public interface AbstractFactory { 
        I牛肉粉 下牛肉粉();
        I酸辣粉 下酸辣粉();
    }

### 具体产品 ###

`张记、王记`两家的`牛肉粉 、酸辣粉`口味可是不同。

/** * 张记米粉店 (具体工厂) */
    public class 张记米粉店Impl implements AbstractFactory { 
        @Override
        public I牛肉粉 下牛肉粉() { 
            System.out.println("下了一碗张记牛肉粉");
            return new 张记牛肉粉Impl();
        }
        @Override
        public I酸辣粉 下酸辣粉() { 
            System.out.println("下了一碗张记酸辣粉");
            return new 张记酸辣粉Impl();
        }
    }
    
    /** * 王记米粉店 (具体工厂) */
    public class 王记米粉店Impl implements AbstractFactory { 
        @Override
        public I牛肉粉 下牛肉粉() { 
            System.out.println("下了一碗王记牛肉粉");
            return new 王记牛肉粉Impl();
        }
    
        @Override
        public I酸辣粉 下酸辣粉() { 
            System.out.println("下了一碗王记酸辣粉");
            return new 王记酸辣粉Impl();
        }
    }

### 客户端 AbstractFactoryPatternTest ###

public class AbstractFactoryPatternTest { 
        public static void main(String[] args) { 
            AbstractFactory 米粉店 = null;
    
            米粉店 = new 张记米粉店Impl();
            米粉店.下牛肉粉().吃粉();
            米粉店.下酸辣粉().吃粉();
    
            米粉店 = new 王记米粉店Impl();
            米粉店.下牛肉粉().吃粉();
            米粉店.下酸辣粉().吃粉();
        }
    }

# 总结 #

*  三个工厂并不是升级关系，而是适应不同的业务场景。
 *  如果后续才品很多，就难免会有一堆工厂。
 *  现实要与其他模式组合使用才靠谱。

# 参考资料 #

[图说设计模式：工厂模式][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p4NTIw_size_16_color_FFFFFF_t_70]: /images/20230521/da5f3f8e0a2d43afa9afdc676abe1798.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p4NTIw_size_16_color_FFFFFF_t_70 1]: /images/20230521/c7da5605d0d04608a4d3229bbd7eebb9.png
[2020041921494738.png]: /images/20230521/7e993aee56a8414e8681fe6fece9ea76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p4NTIw_size_16_color_FFFFFF_t_70 2]: /images/20230521/7e21276ea4c942b69d7e42ffdf9a30a2.png
[Link 1]: https://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/simple_factory.html