GoF之工厂模式

GoF之工厂模式

@
目录

• GoF之工厂模式
  
• 每博一文案
  
• 1. 简单说明“23种设计模式”
  
  
  
  • 1.2 介绍工厂模式的三种形态
    
  • 1.3 简单工厂模式（静态工厂模式）
    
    
    
    • 1.3.1 简单工厂模式的优缺点:
      
    
    
  • 1.4 工厂方法模式
    
    
    
    • 1.4.1 工厂方法模式的优缺点:
      
    
    
  • 1.5 抽象工厂模式
    
    
    
    • 1.6 抽象工厂模式的优缺点：
      
    
    
  
  
• 2. 总结:
  
• 3. 最后:
  

每博一文案

1.         苏东波苏轼《望江南 超然台作》
2. 休对故人思故国，且将薪火试新茶，诗酒趁年华
3. 休对故人思故国：它告诉我们应当忘记过去。
4. 且将薪火试新茶：又告诉我们要活好当下。
5. 诗酒趁年华：更告诉我们既要面对未来，又要及时努力

复制代码

1. 简单说明“23种设计模式”

设计模式：一种可以被重复利用的解决方案。
GoF（Gang of Four），中文名——四人组。
《Design Patterns: Elements of Reusable Object-Oriented Software》（即《设计模式》一书），1995年由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著。这几位作者常被称为"四人组（Gang of Four）"。
该书中描述了23种设计模式。我们平常所说的设计模式就是指这23种设计模式。
不过除了GoF23种设计模式之外，还有其它的设计模式，比如：JavaEE的设计模式（DAO模式、MVC模式等）。
GoF23种设计模式可分为三大类：
一. 创建型（5个）：解决对象创建问题。

• 单例模式
  
• 工厂方法模式
  
• 抽象工厂模式
  
• 建造者模式
  
• 原型模式
  

二. 结构型 (7个)：一些类或对象组合在一起的经典结构

• 代理模式
  
• 装饰模式
  
• 适配器模式
  
• 组合模式
  
• 享元模式
  
• 外观模式
  
• 桥接模式
  

三. 行为型 (11个)：解决类或对象之间的交互问题。

• 策略模式
  
• 模板方法模式
  
• 责任链模式
  
• 观察者模式
  
• 迭代子模式
  
• 命令模式
  
• 备忘录模式
  
• 状态模式
  
• 访问者模式
  
• 中介者模式
  
• 解释器模式
  

而这里我们该篇的主角“工厂模式” 是解决对象创建问题的，所以工厂模式可以归属于创造型设计模式当中。
这里说明一下，为什么我们学习 Spring框架，突然就跑过来学习，工厂模式呢？

原因是：在Spring框架底层当中，使用了大量的工厂模式，而学习工厂模式，有利于我们更加透彻的学习Spring，更加了解Spring框架的底层原理，从而肆无忌惮的使用Spring。

1.2 介绍工厂模式的三种形态

工厂模式通常有三种形态：

• 第一种：简单工厂模式（Simple Factory）：不属于23种设计模式之一。简单工厂模式又叫做：静态工厂方法模式（原因是其中定义的是一个static 静态的方法，进行工厂处理生产的）。简单工厂模式是工厂方法模式的一种特殊实现。
  
• 第二种：工厂方法模式（Factory Method）：是23种设计模式之一。
  
• 第三种：抽象工厂模式（Abstract Factory）：是23种设计模式之一。
  

1.3 简单工厂模式（静态工厂模式）

简单工厂模式的角色包括三个：

• 抽象产品角色
  
• 具体产品角色
  
• 工厂类角色
  

简单工厂模式的代码如下：
抽象产品角色：

抽象产品角色：武器产品，抽象的，自然就是抽象类了 abstract
作用： 用来定义武器的统一的所具备的功能（这里我们给予上）——攻击（武器都具备攻击的功能）

1. /**
2. * 抽象产品角色：武器产品
3. * 抽象的，自然就是 抽象类了 abstract
4. */
5. public abstract class Weapon {
6.     /**
7.      * 所以的武器都要具备攻击
8.      */
9.     public abstract void attack();
10. }

复制代码

具体产品角色：

这里我们定义两个具体产品角色（有关武器的具体产品：Dagger 匕首，Tank 坦克）
同时具体产品角色都 extends继承了 抽象产品角色Weapon，统一上，武器都具备攻击 attack()

1. /**
2. * 具体产品: 匕首
3. * 同样继承 Weapon 抽象武器产品，保持同性
4. */
5. public class Dagger extends Weapon{
6.     @Override
7.     public void attack() {
8.         System.out.println("Dagger 匕首攻击");
9.     }
10. }

复制代码

1. /**
2. * 具体产品角色：坦克
3. * 同时具体产品要继承 抽象武器产品，保持武器的同性
4. */
5. public class Tank extends Weapon {
7.     @Override
8.     public void attack() {
9.         System.out.println("Tank 坦克攻击");
10.     }
11. }

复制代码

工厂类角色：

抽象工厂类角色：根据不同的武器类型生产武器
注意： 该获取武器的方法是——静态方法(static)，要获取什么产品，就看你传什么参数，传Tank获取坦克，传Dagger获取匕首，
简单工厂模式中是通过定义一个静态方法——获取的，所以又被称为：静态工厂方法模式。

1. /**
2. * 抽象工厂类角色：
3. * 根据不同的武器类型生产武器
4. */
5. public class WeaponFactory {
7.     /*
8.     静态方法，要获取什么产品，就看你传什么参数，传Tank获取坦克，传Dagger获取匕首，
9.     简单工厂模式中有一个静态方法，所以被称为：静态工厂方法模式。
10.      */
11.     public static Weapon get(String type) {
13.         // 参数不对，返回 null
14.         if (null == type || type.length() == 0) {
15.             return null;
16.         }
18.         // 要匕首产品，给匕首
19.         if ("DAGGER".equals(type)) {
20.             return new Dagger();
21.         } else if ("TANK".equals(type)) {  // 要坦克给产品，给坦克
22.             return new Tank();
23.         } else {
24.             throw new RuntimeException("暂时不支持该武器的生产制造");
25.         }
27.     }
28. }

复制代码

测试程序（客户端程序）：

1. package com.rainbowsea.test;
3. import com.rainbowsea.bean.Weapon;
4. import com.rainbowsea.bean.WeaponFactory;
6. public class Test {
7.     public static void main(String[] args) {
8.         // 我们要坦克
9.         Weapon tank = WeaponFactory.get("TANK");
10.         tank.attack();  // 坦克攻击
13.         // 我们要匕首，拜托武器工厂给我们制造
14.         Weapon dagger = WeaponFactory.get("DAGGER");
15.         dagger.attack(); // 匕首攻击
17.     }
18. }

复制代码

1.3.1 简单工厂模式的优缺点:

简单工厂模式的优点：

客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。客户端只负责“消费”，工厂负责“生产”。生产和消费分离。

简单工厂模式的缺点：

• 缺点1：工厂类集中了所有产品的创造逻辑，形成一个无所不知的全能类，有人把它叫做上帝类。显然工厂类非常关键，不能出问题，一旦出问题，整个系统瘫痪。
  
• 缺点2：不符合OCP开闭原则，在进行系统扩展时，需要修改工厂类。
  

说明一下：Spring中的BeanFactory就使用了简单工厂模式。关于这一点，我们后面会详细说明
1.4 工厂方法模式

工厂方法模式既保留了简单工厂模式的优点，同时又解决了简单工厂模式的缺点。
工厂方法模式的角色包括：

• 抽象工厂角色
  
• 具体工厂角色
  
• 抽象产品角色
  
• 具体产品角色
  

简单的说：就是一个产品，会对应着一个工厂。

首先，定义好，抽象产品角色，用于统一产品的功能。这里我们还是以武器 为例子，武器统一都具有攻击的作用。

1. /**
2. * 武器的抽象产品，
3. * 同样是统一武器，武器都具备攻击的功能
4. */
5. public abstract class Weapon {
7.     //
8.     public abstract void attack();
9. }

复制代码

定义具体产品角色，这里，我们还是以有关武器的具体产品：Dagger 匕首，Tank 坦克）
同时具体产品角色都 extends继承了 抽象产品角色Weapon，统一上，武器都具备攻击 attack() 。这一点和简单工厂模式一致。

1. /**
2. * 具体工厂角色（武器匕首）
3. */
4. public class Dagger extends Weapon{
5.     @Override
6.     public void attack() {
7.         System.out.println("Dagger 匕首攻击");
8.     }
9. }

复制代码

1. /**
2. * 具体工厂角色（武器坦克）
3. */
4. public class Tank extends Weapon{
6.     @Override
7.     public void attack() {
8.         System.out.println("Tank 坦克攻击");
9.     }
10. }

复制代码

抽象工厂角色
这里我们定义一个接口，作为抽象工厂角色，用于约束，生产类的工厂的角色的。都要进行一个生产get() 。需要注意的是：这个方法不是静态的，是实例方法，这是与简单工厂模式的一大区别 。

1. /**
2. * 武器工厂的接口
3. * 统一武器工厂的生产
4. */
5. public interface WeaponFactory {
6.     /**
7.      * 这个方法不是静态的，是实例方法,
8.      * 这里是简单工厂模式的最大的区别
9.      */
10.     Weapon get();
11. }

复制代码

具体工厂角色 ：
这里是两个分别为了，生产（Dagger 匕首，Tank 坦克）的具体工厂

• public class DaggerFactory implements WeaponFactory
  
• public class TankFactory implements WeaponFactory
  

1. /**
2. * 具体工厂角色
3. * 生产匕首的工厂
4. */
5. public class DaggerFactory implements WeaponFactory{
6.     @Override
7.     public Weapon get() {
8.         return new Dagger();
9.     }
10. }

复制代码

1. /**
2. * 坦克的具体工厂角色：
3. * 专门生产坦克的工厂
4. */
5. public class TankFactory implements WeaponFactory{
6.     @Override
7.     public Weapon get() {
8.         return new Tank();
9.     }
10. }

复制代码

客户端测试

1. package com.rainbowsea.test;
3. import com.rainbowsea.bean.DaggerFactory;
4. import com.rainbowsea.bean.TankFactory;
5. import com.rainbowsea.bean.Weapon;
6. import com.rainbowsea.bean.WeaponFactory;
8. public class Test {
9.     public static void main(String[] args) {
10.         // 我们需要匕首
11.         // 调用匕首的工厂，进行生产
12.         WeaponFactory weaponFactory = new DaggerFactory();
13.         Weapon weapon = weaponFactory.get();
14.         weapon.attack();  // 匕首攻击
17.         // 我们需要坦克
18.         // 调用坦克的工厂，进行生产
19.         WeaponFactory weaponFactory2 = new TankFactory();
20.         Weapon weapon2 = weaponFactory2.get();
21.         weapon2.attack();  // 坦克攻击
24.     }
25. }

复制代码

这种简单工厂模式，如果想扩展一个新的产品，只要新增一个产品类，再新增一个该产品对应的工厂即可，例如新增：战斗机

从中，我们可以看出，在进行功能扩展的时候，不需要修改之前的源代码（仅仅是添加了，扩展的类，对象而已，并没有修改），显然工厂方法模式符合OCP原则(修改关闭，扩展打开)。

1.4.1 工厂方法模式的优缺点:

工厂方法模式的优点:

• 
  
  • 一个调用者想创建一个对象，只要知道其名称就可以了。
    
  • 扩展性高，如果想要增加一个产品，只需要扩展该产品的一个工厂类就可以了
    
  • 同时屏幕产品的具体实现(运用多态机理)，调用者只关心产品的接口
    
  
  

工厂方法模式的缺点：

每次增加一个新产品时，都需要增加一个具体类和对象实现工厂，使得系统种类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事情。

1.5 抽象工厂模式

抽象工厂模式相对于工厂方法模式来说，就是工厂方法模式是针对一个产品系列的，而抽象工厂模式是针对多个产品系列的，即工厂方法模式是一个产品系列一个工厂类，而抽象工厂模式是多个产品系列一个工厂类。
抽象工厂模式特点：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。它有多个抽象产品类，每个抽象产品类可以派生出多个具体产品类，一个抽象工厂类，可以派生出多个具体工厂类，每个具体工厂类可以创建多个具体产品类的实例。每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果。
抽象工厂中包含4个角色：

• 
  
  
  
  • 抽象工厂角色
    
  
  
• 
  
  
  
  • 具体工厂角色
    
  
  
• 
  
  
  
  • 抽象产品角色
    
  
  
• 
  
  
  
  • 具体产品角色
    
  
  

抽象工厂模式的类图如下：

抽象工厂模式代码如下：
第一部分：武器产品族

1. package com.powernode.product;
3. /**
4. * 武器产品族
5. * @author 动力节点
6. * @version 1.0
7. * @className Weapon
8. * @since 1.0
9. **/
10. public abstract class Weapon {
11.     public abstract void attack();
12. }

复制代码

1. package com.powernode.product;
3. /**
4. * 武器产品族中的产品等级1
5. * @author 动力节点
6. * @version 1.0
7. * @className Gun
8. * @since 1.0
9. **/
10. public class Gun extends Weapon{
11.     @Override
12.     public void attack() {
13.         System.out.println("开枪射击！");
14.     }
15. }

复制代码

1. package com.powernode.product;
3. /**
4. * 武器产品族中的产品等级2
5. * @author 动力节点
6. * @version 1.0
7. * @className Dagger
8. * @since 1.0
9. **/
10. public class Dagger extends Weapon{
11.     @Override
12.     public void attack() {
13.         System.out.println("砍丫的！");
14.     }
15. }

复制代码

第二部分：水果产品族

1. package com.powernode.product;
3. /**
4. * 水果产品族
5. * @author 动力节点
6. * @version 1.0
7. * @className Fruit
8. * @since 1.0
9. **/
10. public abstract class Fruit {
11.     /**
12.      * 所有果实都有一个成熟周期。
13.      */
14.     public abstract void ripeCycle();
15. }

复制代码

1. package com.powernode.product;
3. /**
4. * 水果产品族中的产品等级1
5. * @author 动力节点
6. * @version 1.0
7. * @className Orange
8. * @since 1.0
9. **/
10. public class Orange extends Fruit{
11.     @Override
12.     public void ripeCycle() {
13.         System.out.println("橘子的成熟周期是10个月");
14.     }
15. }

复制代码

1. package com.powernode.product;
3. /**
4. * 水果产品族中的产品等级2
5. * @author 动力节点
6. * @version 1.0
7. * @className Apple
8. * @since 1.0
9. **/
10. public class Apple extends Fruit{
11.     @Override
12.     public void ripeCycle() {
13.         System.out.println("苹果的成熟周期是8个月");
14.     }
15. }

复制代码

第三部分：抽象工厂类

1. package com.powernode.factory;
3. import com.powernode.product.Fruit;
4. import com.powernode.product.Weapon;
6. /**
7. * 抽象工厂
8. * @author 动力节点
9. * @version 1.0
10. * @className AbstractFactory
11. * @since 1.0
12. **/
13. public abstract class AbstractFactory {
14.     public abstract Weapon getWeapon(String type);
15.     public abstract Fruit getFruit(String type);
16. }

复制代码

第四部分：具体工厂类

1. package com.powernode.factory;
3. import com.powernode.product.Dagger;
4. import com.powernode.product.Fruit;
5. import com.powernode.product.Gun;
6. import com.powernode.product.Weapon;
8. /**
9. * 武器族工厂
10. * @author 动力节点
11. * @version 1.0
12. * @className WeaponFactory
13. * @since 1.0
14. **/
15. public class WeaponFactory extends AbstractFactory{
17.     public Weapon getWeapon(String type){
18.         if (type == null || type.trim().length() == 0) {
19.             return null;
20.         }
21.         if ("Gun".equals(type)) {
22.             return new Gun();
23.         } else if ("Dagger".equals(type)) {
24.             return new Dagger();
25.         } else {
26.             throw new RuntimeException("无法生产该武器");
27.         }
28.     }
30.     @Override
31.     public Fruit getFruit(String type) {
32.         return null;
33.     }
34. }

复制代码

1. package com.powernode.factory;
3. import com.powernode.product.*;
5. /**
6. * 水果族工厂
7. * @author 动力节点
8. * @version 1.0
9. * @className FruitFactory
10. * @since 1.0
11. **/
12. public class FruitFactory extends AbstractFactory{
13.     @Override
14.     public Weapon getWeapon(String type) {
15.         return null;
16.     }
18.     public Fruit getFruit(String type){
19.         if (type == null || type.trim().length() == 0) {
20.             return null;
21.         }
22.         if ("Orange".equals(type)) {
23.             return new Orange();
24.         } else if ("Apple".equals(type)) {
25.             return new Apple();
26.         } else {
27.             throw new RuntimeException("我家果园不产这种水果");
28.         }
29.     }
30. }

复制代码

第五部分：客户端程序

1. package com.powernode.client;
3. import com.powernode.factory.AbstractFactory;
4. import com.powernode.factory.FruitFactory;
5. import com.powernode.factory.WeaponFactory;
6. import com.powernode.product.Fruit;
7. import com.powernode.product.Weapon;
9. /**
10. * @author 动力节点
11. * @version 1.0
12. * @className Client
13. * @since 1.0
14. **/
15. public class Client {
16.     public static void main(String[] args) {
17.         // 客户端调用方法时只面向AbstractFactory调用方法。
18.         AbstractFactory factory = new WeaponFactory(); // 注意：这里的new WeaponFactory()可以采用 简单工厂模式 进行隐藏。
19.         Weapon gun = factory.getWeapon("Gun");
20.         Weapon dagger = factory.getWeapon("Dagger");
22.         gun.attack();
23.         dagger.attack();
25.         AbstractFactory factory1 = new FruitFactory(); // 注意：这里的new FruitFactory()可以采用 简单工厂模式 进行隐藏。
26.         Fruit orange = factory1.getFruit("Orange");
27.         Fruit apple = factory1.getFruit("Apple");
29.         orange.ripeCycle();
30.         apple.ripeCycle();
31.     }
32. }

复制代码

执行结果：

1.6 抽象工厂模式的优缺点：

• 
  
  
  
  • 优点： 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
    
  
  
• 
  
  
  
  • 缺点： 产品族扩展非常困难，要增加一个系列的某一产品，既要在AbstractFactory里加代码，又要在具体的里面加代码。
    
  
  

2. 总结:

• 23种设计模式：
  
  
  
  • 创建型（5个）：解决对象创建问题。
    
  • 结构型 (7个)：一些类或对象组合在一起的经典结构
    
  • 行为型 (11个)：解决类或对象之间的交互问题。
    
  
  
• 简单工厂模式（静态工厂模式），需要注意是：一个静态方法，所以被称之为”静态工厂模式“，不属于23种设计模式。同时需要注意：简单工厂的一个上帝类和(违背了OCP原则（修改关闭，苦扩展打开）) 的问题。注意其中的优点和缺点，灵活使用。
  
• 工厂方法模式既保留了简单工厂模式的优点，同时又解决了简单工厂模式的缺点（类爆炸问题）。工厂方法模式（不是静态方法了，是实例方法）。同时其中的优点和缺点，灵活使用。
  
• 抽象工厂模式（解决了工厂方法模式的，类爆炸问题）抽象工厂模式相对于工厂方法模式来说，就是工厂方法模式是针对一个产品系列的，而抽象工厂模式是针对多个产品系列的，即工厂方法模式是一个产品系列一个工厂类，而抽象工厂模式是多个产品系列一个工厂类。其中的优点和缺点，灵活使用。
  
• 灵活使用工厂模式的三种形态，处理现实当中的业务需求。
  

3. 最后:

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！