学习笔记之设计模式学习（二）：工厂模式的三种实现方式

工厂模式简介

（1）工厂模式：

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

（2）详细分类：

• 简单工厂模式
  用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）。

• 工厂方法模式
  用来生产同一等级结构中的固定产品。（支持增加任意产品）。

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

（3）核心本质：
– 实例化对象，用工厂方法代替new操作。
– 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

面向对象设计的基本原则

面向对象设计的基本原则，这里介绍以下三种：

• OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。
  注意：当要对项目增加新的功能，就增加一个类，而不要在原类上修改。

• DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。依赖于抽象，不要依赖于具体，
  注意：比如说我要调用一个类的时候，这个类实现了一个接口，那么我们就去与接口扯上关系，不要去与实现扯上关系。

• LoD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。
  注意：以上原则的意思是我这个类尽量少和其他类扯上关系，尽量少依赖其他类，实现解耦。

工厂模式要点

• 简单工厂模式(静态工厂模式)
  虽然某种程度不符合设计原则，但实际使用最多。

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

• 抽象工厂模式
  不可以增加产品，可以增加产品族！

工厂模式的应用场景

• JDK中Calendar的getInstance方法
• JDBC中Connection对象的获取
• Hibernate中SessionFactory创建Session
• spring中IOC容器创建管理bean对象
• XML解析时的DocumentBuilderFactory创建解析器对象
• 反射中Class对象的newInstance()
• …

一、工厂模式的实现方式

（1）新建一个Car接口：

 public interface Car {
    void run();
}

（2）新建两个接口的实现类：

public class Byd implements Car {
   @Override
   public void run() {
       System.out.println("比亚迪在跑。。。");
   }
}

 public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪在跑！！");
    }
}

没有工厂模式的时候

（3）创建调用者进行测试

public class Client01 { //调用者
    public static void main(String[] args) {
        Car c1 = new Audi();
        Car c2 = new Byd();

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

    }
}

（4）输出：

（5）UML类图

（6）问题：

• Client01相当于调用者，调用者知道的信息太多了，既要知道接口还要知道实体类；
• 具体类的创建都暴露出来了，如果创建实体类非常复杂，还需要准备很多参数；

实现方式一：简单工厂模式（使用较多）

要点：

• 简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，
• 通过接收的参数的不同来返回不同的对象实例。
• 对于增加新产品无能为力！不修改代码的话，是无法扩展的。

（1）还是使用Car接口和两个实现类Audi和Byd
（2）新建一个工厂类（方式一）

/**
 * 简单工厂模式
 * 缺点：违反了开闭原则
 */
public class CarFactory { //创建者

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

}

（3）新建一个工厂类（方式二）更推荐

public  class CarFactory02 { //创建者

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

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

（4）创建测试代码（调用者）

public class Client02 { //调用者
    public static void main(String[] args) {
        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");

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

    }
}

通过新增加了一个工厂类，实现了更加详细的分工，CarFactory类专门用于创建Car接口的实现类实例，相当于创建者，而调用者只需要和创建者打交道就可以了，使用工厂模式使得代码较之前更加容易扩展。
（5）简单工厂模式UML类图

（6）缺点
如果我们还需要新增新的功能，那么还需要再CarFactory类中去修改代码，因此违反了当需要新增一个功能的时候，去新增一个类，而不是去修改源代码这一条开闭原则，因此简单工厂是有这么一个小问题的。

实现方式二：工厂方法模式

• 为了避免简单工厂模式的缺点，使代码更符合设计原则，现在介绍以下工厂方法模式。
• 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个
  （对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

（1）首先还是使用Car接口还有两个实现类Audi、Byd进行测试。
（2）创建一个CarFactory接口

public interface CarFactory {
    Car createCar();
}

（3）新建一个AudiFactory类，去实现CarFactory接口

public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Audi();
    }
}

（4）新建一个BydFactory类，去实现CarFactory接口：

 public class BydFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Byd();
    }
}

（5）编写调用者

public class Client {

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

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

输出：

现在如果需要新增一个新的功能，只需要新增一个车的类和这个车的工厂类就可以了，不需要修改业务代码，解决了简单工厂模式的缺点，符合了开闭原则，但是缺点就是新增的类会比较多。

（6）工厂方法模式UML类图

（7）总结
根据UML类图可以知道，我们的调用者如果需要创建某个车的实例，只需要调用相应的工厂类就行了，调用者就直接和工厂打交道，而不会和子类打交道，虽然说满足了开闭原则，但是变得更加复杂了，所以还是使用简单工厂模式比较多。

实现方式三：抽象工厂模式（多个接口）

当一个产品需要创建多个接口的情况下，简单工厂模式和工厂方法模式就无能无力了，这个时候就使用抽象方法模式。

• 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
• 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，
• 通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
  
  现在通过代码来实现上图中的产品概念。
  代码：
  （1）首先新建一个Engine接口，发动机接口，在解决中有run()和start()两个方法。

 public interface Engine {
    void run(); //发动机的运行
       void start(); //发动机的启动
}

（2）编写一个高级发动机LuxuryEngine类，并且实现发动机接口。

 public class LuxuryEngine implements Engine{
    @Override
    public void run() {
        System.out.println("转得快..");
    }

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

（3）编写一个低级发动机LowEngine类，并且实现发动机接口。

 public class LowEngine implements Engine{
    @Override
    public void run() {
        System.out.println("转得慢..");
    }

    @Override
    public void start() {
        System.out.println("启动慢..");
    }
}

（4）新增一个座椅接口Seat，并且编写一个按摩方法。

 public interface Seat {
    void massage(); //按摩方法
}

（5）编写一个高端座椅LuxurySeat类，并且实现座椅接口

 public class LuxurySeat implements Seat{
    @Override
    public void massage() {
        System.out.println("高端按摩椅--可以自动按摩。。");
    }
}

（6）编写一个低端座椅LowSeat类，并且实现座椅接口

 public class LowSeat implements Seat{
    @Override
    public void massage() {
        System.out.println("低端按摩椅--不可以按摩。。");
    }
}

（7）新增一个轮胎接口Tyre，并且编写一个revolve方法。

 public interface Tyre {
    void revolve();//转速
}

（8）编写一个高端座椅LuxuryTyre类，并且实现轮胎接口

 public class LuxuryTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("高端轮胎——————旋转磨损小。。");
    }
}

（9）编写一个低端座椅LowTyre类，并且实现轮胎接口

 public class LowTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("低端轮胎——————旋转磨损大。。");
    }
}

（10）新建一个CarFactory工厂接口，并且里面有创建发动机、座椅、轮胎的方法。

 public interface CarFactory {
    Engine createEngine();//创建发动机的方法
    Seat createSeat();//创建座椅的方法
    Tyre createTyre();//创建轮胎的方法
}

（11）编写一个创建高端汽车的方法LuxuryCarFactory，并且实现CarFactory接口

 public class LuxuryCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

（12）再创建一个低端汽车工厂方法LowCarFactory，并且实现CarFactory接口

 public class LowCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

（13）编写调用者测试

 public class Client {
    public static void main(String[] args) {
        CarFactory carFactory = new LuxuryCarFactory();
        Engine e = carFactory.createEngine();
        e.run();
        e.start();
    }
}

输出：

（14）UML类图

测试代码中的调用者，去创建了一个高端汽车，并且各个组件之间可以搭配组合，这样就实现了产品族的概念，实际生活中使用抽象工厂模式比较少，但是在一些开源的产品项目中可能遇见的比较多，这里理解这个思想即可。

总结

简单工厂模式和工厂方法模式PK:

• 结构复杂度
  从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。

• 代码复杂度
  代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。

• 客户端编程难度
  工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。

• 管理上的难度
  这是个关键的问题。
  我们先谈扩展。众所周知，工厂方法模式完全满足OCP，即它有非常良好的扩展性。那是否就说明了简单工厂模式就没有扩展性呢？答案是否定的。简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码（修改工厂类的代码）就可以满足扩展性的要求了。尽管这没有完全满足OCP，但我们不需要太拘泥于设计理论，要知道，sun提供的java官方工具包中也有想到多没有满足OCP的例子啊。然后我们从维护性的角度分析下。假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦（对号入座已经是个问题了）。反而简单工厂没有这些麻烦，当多个产品类需要修改是，简单工厂模式仍然仅仅需要修改唯一的工厂类（无论怎样都能改到满足要求吧？大不了把这个类重写）。

• 工厂模式一般会和其他设计模式搭配使用。

• 如果以后遇见后缀是factory结尾的，基本上是使用工厂模式来设计的。

• 根据设计理论建议：工厂方法模式。但实际上，我们一般都用简单工厂模式。

学习工厂模式时，多去手动敲代码是必不可少的，同时多去画一下UML类图以理解它们之间的关系，同时锻炼自己的能力。