GOF23设计模式之工厂模式（factory）

Love The Way You Lie 2023-10-06 09:44 4阅读 0赞

#### 一、工厂模式概述 ####

实现了创建者和调用者的分离

（1）分类

①简单工厂模式

虽然某种程度不符合设计原则，但实际使用最多。

②工厂方法模式

不修改已有类的前提下，通过增加新的工厂类实现扩展。

③抽象工厂模式

不可以增加产品，可以增加产品族。

#### 二、不使用工厂模式时 ####

1.创建一个汽车的接口

1 public interface Car {
    2     void run();
    3 }

2.创建两个实现汽车接口的类：

1 public class Audi implements Car {
    2 
    3     public void run() {
    4         System.out.println("奥迪在跑...");
    5     }
    6     
    7 }

1 public class Byd implements Car {
    2 
    3     public void run() {
    4         System.out.println("比亚迪在跑...");
    5     }
    6     
    7 }

3.客户端创建实例：

1 public class Client {
     2     
     3     public static void main(String[] args) {
     4         Car c1 = new Audi();
     5         Car c2 = new Byd();
     6         
     7         c1.run();
     8         c2.run();
     9     }
    10     
    11 }

控制台输出：

奥迪在跑...
    比亚迪在跑...

当客户没有需求改动时，完全可以不使用工厂模式。但是当需要创建更多实例或者需要频繁更改时，只需要引入工厂或者更改工厂类中的代码就可以了，这样就实现了解耦，是工厂模式的一大好处。

#### 三、简单工厂（simplefactory） ####

简单工厂模式也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数的不同来返回不同的对象实例。

缺点：对于增加新产品无能为力！不修改代码的话，是无法扩展的。

1.创建接口和实现类

1 public interface Car {
    2     void run();
    3 }

1 public class Audi implements Car {
    2 
    3     public void run() {
    4         System.out.println("奥迪在跑...");
    5     }
    6     
    7 }

1 public class Byd implements Car {
    2 
    3     public void run() {
    4         System.out.println("比亚迪在跑...");
    5     }
    6     
    7 }

2.创建简单工厂类

1 public class CarFactory {
     2     
     3     public static Car creatCar(String type) {
     4         if (type.equals("奥迪")) {
     5             return new Audi();
     6         } else if (type.equals("比亚迪")){
     7             return new Byd();
     8         }
     9         return null;
    10     }
    11 
    12 }

3.测试

1 public class Client {
     2 
     3     public static void main(String[] args) {
     4         Car c1 = CarFactory.creatCar("奥迪");
     5         Car c2 = CarFactory.creatCar("比亚迪");
     6         
     7         c1.run();
     8         c2.run();
     9 
    10     }
    11 }

控制台输出：

奥迪在跑...
    比亚迪在跑...

4.或者创建另一种简单（静态）工厂类

1 public class CarFactory {
     2     
     3     public static Car creatAudi() {
     4         return new Audi();
     5     }
     6     
     7     public static Car creatByd() {
     8         return new Byd();
     9     }
    10 }

5.测试

1 public class Client {
     2 
     3     public static void main(String[] args) {
     4         Car c1 = CarFactory.creatAudi();
     5         Car c2 = CarFactory.creatByd();
     6         
     7         c1.run();
     8         c2.run();
     9     }
    10 }

控制台输出：

奥迪在跑...
    比亚迪在跑...

通过工厂类创建实例，实现解耦。

#### 四、工厂方法（factorymethod） ####

一个类对应一个工厂实现类，避免了开闭原则的弊端，更容易扩展代码。但是从复杂度来分析，简单工厂模式更优，因为对客户而言，简单工厂更简单。

1.创建汽车接口和汽车工厂接口

1 public interface Car {
    2     void run();
    3 }

1 public interface CarFactory {
    2     Car createCar();
    3 }

2.创建汽车的接口和汽车工厂方法的实现类

1 public class Audi implements Car {
    2 
    3     public void run() {
    4         System.out.println("奥迪在跑...");
    5     }
    6     
    7 }

1 public class AudiFactory implements CarFactory {
    2 
    3     public Car createCar() {
    4         return new Audi();
    5     }
    6 
    7 }

1 public class Byd implements Car {
    2 
    3     public void run() {
    4         System.out.println("比亚迪在跑...");
    5     }
    6     
    7 }

1 public class BydFactory implements CarFactory {
    2 
    3     public Car createCar() {
    4         return new Byd();
    5     }
    6 
    7 }

3.测试

1 public class Client {
     2     
     3     public static void main(String[] args) {
     4         Car c1 = new AudiFactory().createCar();
     5         Car c2 = new BydFactory().createCar();
     6         
     7         c1.run();
     8         c2.run();
     9     }
    10 
    11 }

控制台输出：

奥迪在跑...
    比亚迪在跑...

不再与实际类打交道，而通过工厂来创建对象，实现解耦。增加新的产品也更加方便。

4.增加新的产品

1 public class Benz implements Car {
    2 
    3     public void run() {
    4         System.out.println("奔驰在跑...");
    5     }
    6 
    7 }

1 public class BenzFactory implements CarFactory {
    2 
    3     public Car createCar() {
    4         return new Benz();
    5     }
    6     
    7 
    8 }

5.测试

1 public class Client {
     2     
     3     public static void main(String[] args) {
     4         Car c1 = new AudiFactory().createCar();
     5         Car c2 = new BydFactory().createCar();
     6         Car c3 = new BenzFactory().createCar();
     7         
     8         c1.run();
     9         c2.run();
    10         c3.run();
    11     }
    12 
    13 }

控制台输出：

奥迪在跑...
    比亚迪在跑...
    奔驰在跑...

#### 五、抽象工厂 ####

抽象工厂模式用来生产不同产品族的全部产品。（对于新增加某一个完整的产品，无能为力；仅支持增加产品族；）

产品族： 发动机 座椅 轮胎 是汽车的一个产品族

抽象工厂模式是工厂模式的一种特殊版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

1.创建高低端产品族的接口和实现类

1 /**
     2  * 创建汽车产品族中的发动机接口
     3  * @author CL
     4  *
     5  */
     6 public interface Engine {
     7     void run();
     8     void start();
     9 }
    10 
    11 /**
    12  * 高端发动机实现类
    13  */
    14 class LuxuryEngine implements Engine {
    15 
    16     public void run() {
    17         System.out.println("转速高!");
    18     }
    19 
    20     public void start() {
    21         System.out.println("可以自动启停！");        
    22     }
    23     
    24 }
    25 
    26 /**
    27  * 低端发动机实现类
    28  */
    29 class LowEngine implements Engine {
    30     public void run() {
    31         System.out.println("转速慢!");
    32     }
    33 
    34     public void start() {
    35         System.out.println("不可以自动启停！");        
    36     }
    37     
    38 }

1 /**
     2  * 创建汽车产品族中的座椅接口
     3  * @author CL
     4  *
     5  */
     6 public interface Seat {
     7     void massage();
     8 }
     9 
    10 /**
    11  * 高端座椅的实现类
    12  */
    13 class LuxurySeat implements Seat {
    14 
    15     public void massage() {
    16         System.out.println("可以按摩！");
    17     }
    18     
    19 }
    20 
    21 /**
    22  * 低端座椅的实现类
    23  */
    24 class LowSeat implements Seat {
    25 
    26     public void massage() {
    27         System.out.println("不可以按摩！");
    28     }
    29     
    30 }

1 /**
     2  * 创建汽车产品族的轮胎接口
     3  * @author CL
     4  *
     5  */
     6 public interface Tyre {
     7     void abrasion();
     8 }
     9 
    10 /**
    11  * 高端轮胎的实现类
    12  */
    13 class LuxuryTyre implements Tyre {
    14 
    15     public void abrasion() {
    16         System.out.println("磨损慢！");
    17     }
    18     
    19 }
    20 
    21 /**
    22  * 低端轮胎的实现类
    23  */
    24 class LowTyre implements Tyre {
    25 
    26     public void abrasion() {
    27         System.out.println("磨损快！");
    28     }
    29     
    30 }

2.创建高端汽车工厂和低端汽车工厂

1 /**
     2  * 创建高端汽车的实现类工厂
     3  * @author CL
     4  *
     5  */
     6 public class LuxuryCarFactory implements CarFactory {
     7 
     8     /**
     9      * 制造高端发动机
    10      */
    11     public Engine creatEngine() {
    12         return new LuxuryEngine();
    13     }
    14 
    15     /**
    16      * 制造高端座椅
    17      */
    18     public Seat creatSeat() {
    19         return new LuxurySeat();
    20     }
    21 
    22     /**
    23      * 制造高端轮胎
    24      */
    25     public Tyre creatTyre() {
    26         return new LuxuryTyre();
    27     }
    28     
    29 }

1 /**
     2  * 创建低端汽车的实现类工厂
     3  * @author CL
     4  *
     5  */
     6 public class LowCarFactory implements CarFactory {
     7 
     8     /**
     9      * 制造低端发动机
    10      */
    11     public Engine creatEngine() {
    12         return new LowEngine();
    13     }
    14 
    15     /**
    16      * 制造低端座椅
    17      */
    18     public Seat creatSeat() {
    19         return new LowSeat();
    20     }
    21 
    22     /**
    23      * 制造低端轮胎
    24      */
    25     public Tyre creatTyre() {
    26         return new LowTyre();
    27     }
    28     
    29 }

3.测试

1 /**
     2  * 使用抽象工厂模式创建高端汽车发动机
     3  * 　　　　　　　　创建低端汽车轮胎
     4  * @author CL
     5  *
     6  */
     7 public class Client {
     8     
     9     public static void main(String[] args) {
    10         //需要低端发动机
    11         CarFactory factory = new LowCarFactory();
    12         Engine e = factory.creatEngine();
    13         e.run();
    14         e.start();
    15         
    16         System.out.println("----------------");
    17         
    18         //需要高端轮胎
    19         CarFactory carFactory = new LuxuryCarFactory();
    20         Tyre t = carFactory.creatTyre();
    21         t.abrasion();
    22     }
    23 
    24 }

控制台输出：

转速慢!
    不可以自动启停！
    ----------------
    磨损慢！

#### 六、如何选择工厂模式 ####

实际应用：简单工厂模式

增加产品：工厂方法模式

增加产品族：抽象工厂模式

#### 七、工厂模式常见应用场景 ####

（1）JDK中Calendar的getInstance方法；

（2）JDBC中Connection对象的获取；

（3）Hibernate中sessionFactory创建Session；

（4）Spring中IOC容器创建管理bean对象；

（5）XML解析时的DocumentBuilderFactory创建解析器对象；