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

一、工厂模式概述

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

　　（1）分类

　　　　①简单工厂模式

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

　　　　②工厂方法模式

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

　　　　③抽象工厂模式

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

二、不使用工厂模式时

　　1.创建一个汽车的接口

 public interface Car {
     void run();
 }

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

 public class Audi implements Car {

     public void run() {
         System.out.println("奥迪在跑...");
     }

 }

 public class Byd implements Car {

     public void run() {
         System.out.println("比亚迪在跑...");
     }

 }

　　3.客户端创建实例：

 public class Client {

     public static void main(String[] args) {
         Car c1 = new Audi();
         Car c2 = new Byd();

         c1.run();
         c2.run();
     }

 }

　　控制台输出：

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

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

三、简单工厂（simplefactory）

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

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

　　1.创建接口和实现类

 public interface Car {
     void run();
 }

 public class Audi implements Car {

     public void run() {
         System.out.println("奥迪在跑...");
     }

 }

 public class Byd implements Car {

     public void run() {
         System.out.println("比亚迪在跑...");
     }

 }

　　2.创建简单工厂类

 public class CarFactory {

     public static Car creatCar(String type) {
         if (type.equals("奥迪")) {
             return new Audi();
         } else if (type.equals("比亚迪")){
             return new Byd();
         }
         return null;
     }

 }

　　3.测试

 public class Client {

     public static void main(String[] args) {
         Car c1 = CarFactory.creatCar("奥迪");
         Car c2 = CarFactory.creatCar("比亚迪");

         c1.run();
         c2.run();

     }
 }

　　控制台输出：

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

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

 public class CarFactory {

     public static Car creatAudi() {
         return new Audi();
     }

     public static Car creatByd() {
         return new Byd();
     }
 }

　　5.测试

 public class Client {

     public static void main(String[] args) {
         Car c1 = CarFactory.creatAudi();
         Car c2 = CarFactory.creatByd();

         c1.run();
         c2.run();
     }
 }

　　控制台输出：

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

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

四、工厂方法（factorymethod）

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

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

 public interface Car {
     void run();
 }

 public interface CarFactory {
     Car createCar();
 }

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

 public class Audi implements Car {

     public void run() {
         System.out.println("奥迪在跑...");
     }

 }

 public class AudiFactory implements CarFactory {

     public Car createCar() {
         return new Audi();
     }

 }

 public class Byd implements Car {

     public void run() {
         System.out.println("比亚迪在跑...");
     }

 }

 public class BydFactory implements CarFactory {

     public Car createCar() {
         return new Byd();
     }

 }

　　3.测试

 public class Client {

     public static void main(String[] args) {
         Car c1 = new AudiFactory().createCar();
         Car c2 = new BydFactory().createCar();

         c1.run();
         c2.run();
     }

 }

　　控制台输出：

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

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

　　4.增加新的产品

 public class Benz implements Car {

     public void run() {
         System.out.println("奔驰在跑...");
     }

 }

 public class BenzFactory implements CarFactory {

     public Car createCar() {
         return new Benz();
     }

 }

　　5.测试

 public class Client {

     public static void main(String[] args) {
         Car c1 = new AudiFactory().createCar();
         Car c2 = new BydFactory().createCar();
         Car c3 = new BenzFactory().createCar();

         c1.run();
         c2.run();
         c3.run();
     }

 }

　　控制台输出：

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

五、抽象工厂

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

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

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

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

 /**
  * 创建汽车产品族中的发动机接口
  * @author CL
  *
  */
 public interface Engine {
     void run();
     void start();
 }

 /**
  * 高端发动机实现类
  */
 class LuxuryEngine implements Engine {

     public void run() {
         System.out.println("转速高!");
     }

     public void start() {
         System.out.println("可以自动启停！");
     }

 }

 /**
  * 低端发动机实现类
  */
 class LowEngine implements Engine {
     public void run() {
         System.out.println("转速慢!");
     }

     public void start() {
         System.out.println("不可以自动启停！");
     }

 }

 /**
  * 创建汽车产品族中的座椅接口
  * @author CL
  *
  */
 public interface Seat {
     void massage();
 }

 /**
  * 高端座椅的实现类
  */
 class LuxurySeat implements Seat {

     public void massage() {
         System.out.println("可以按摩！");
     }

 }

 /**
  * 低端座椅的实现类
  */
 class LowSeat implements Seat {

     public void massage() {
         System.out.println("不可以按摩！");
     }

 }

 /**
  * 创建汽车产品族的轮胎接口
  * @author CL
  *
  */
 public interface Tyre {
     void abrasion();
 }

 /**
  * 高端轮胎的实现类
  */
 class LuxuryTyre implements Tyre {

     public void abrasion() {
         System.out.println("磨损慢！");
     }

 }

 /**
  * 低端轮胎的实现类
  */
 class LowTyre implements Tyre {

     public void abrasion() {
         System.out.println("磨损快！");
     }

 }

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

 /**
  * 创建高端汽车的实现类工厂
  * @author CL
  *
  */
 public class LuxuryCarFactory implements CarFactory {

     /**
      * 制造高端发动机
      */
     public Engine creatEngine() {
         return new LuxuryEngine();
     }

     /**
      * 制造高端座椅
      */
     public Seat creatSeat() {
         return new LuxurySeat();
     }

     /**
      * 制造高端轮胎
      */
     public Tyre creatTyre() {
         return new LuxuryTyre();
     }

 }

 /**
  * 创建低端汽车的实现类工厂
  * @author CL
  *
  */
 public class LowCarFactory implements CarFactory {

     /**
      * 制造低端发动机
      */
     public Engine creatEngine() {
         return new LowEngine();
     }

     /**
      * 制造低端座椅
      */
     public Seat creatSeat() {
         return new LowSeat();
     }

     /**
      * 制造低端轮胎
      */
     public Tyre creatTyre() {
         return new LowTyre();
     }

 }

　　3.测试

 /**
  * 使用抽象工厂模式创建高端汽车发动机
  * 　　　　　　　　创建低端汽车轮胎
  * @author CL
  *
  */
 public class Client {

     public static void main(String[] args) {
         //需要低端发动机
         CarFactory factory = new LowCarFactory();
         Engine e = factory.creatEngine();
         e.run();
         e.start();

         System.out.println("----------------");

         //需要高端轮胎
         CarFactory carFactory = new LuxuryCarFactory();
         Tyre t = carFactory.creatTyre();
         t.abrasion();
     }

 }

　　控制台输出：

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

六、如何选择工厂模式

　　实际应用：简单工厂模式　　

　　增加产品：工厂方法模式

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

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

　　（1）JDK中Calendar的getInstance方法；

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

　　（3）Hibernate中sessionFactory创建Session；

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

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

　　（6）反射中Class对象的newInstance()；

　　（7）………………