Java23种设计模式（GOF）——工厂模式

实现了创建者和调用者的分离。
详细分类：简单工厂模式、工厂方法模式、抽象工厂模式。

核心本质

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

• 简单工厂模式
  用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
• 工厂方法模式
  用来生产同一等级结构中的固定产品。（支持增加任意产品）
• 抽象工厂模式
  用来生产不同产品族的全部产品。（对于增加新的产品，无能为力，支持增加产品族）

分类

1、简单工厂模式

要点

也叫静态工厂模式，一般使用静态方法，通过接收的参数的不同来返回不同的对象实例。
对于增加新产品无能为力，不修改代码的话，是无法扩展的
主要用来生产同一等级结构中的任意产品

案例

/**
 * @author huangyzh
 * @create 2020-05-13 23:15
 */
public interface Car {
    void run();
}

/**
 * @author huangyzh
 * @create 2020-05-13 23:16
 */
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("我是奥迪，正在路上跑……");
    }
}

/**
 * @author huangyzh
 * @create 2020-05-13 23:16
 */
public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("我是比亚迪，正在出发！");
    }
}

/**
 * 测试没有工厂模式的情况下
 * @author huangyzh
 * @create 2020-05-13 23:19
 */
public class Test01 {
    public static void main(String[] args) {
        Car c1 = new Audi();
        Car c2 = new Byd();

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

/**
 * 简单工厂模式1
 * @author huangyzh
 * @create 2020-05-13 23:22
 */
public class CarFactory01 {

    public static Car createCar(String type){
        if("ad".equals(type)){
            return new Audi();
        }else if("byd".equals(type)){
            return new Byd();
        }
        return null;
    }
}

/**
 * 简单工厂模式2
 * @author huangyzh
 * @create 2020-05-13 23:22
 */
public class CarFactory02 {

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

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

/**
 * 简单工厂模式的情况下
 * @author huangyzh
 * @create 2020-05-13 23:19
 */
public class Test02 {
    public static void main(String[] args) {
        Car ad = CarFactory01.createCar("ad");
        ad.run();
        Car byd = CarFactory01.createCar("byd");
        byd.run();
    }
}

2、工厂方法模式

要点

为了避免简单工厂模式的缺点→不完全满足OCP
工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或一个独立模块而言）工厂类，而工厂方法模式有一组实现了系统接口的工厂类
用来生产同一等级结构中的固定产品。（支持增加任意产品）

案例

/**
 * @author huangyzh
 * @create 2020-05-13 23:15
 */
public interface Car {
    void run();
}

/**
 * @author huangyzh
 * @create 2020-05-13 23:16
 */
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("我是奥迪，正在路上跑……");
    }
}

/**
 * @author huangyzh
 * @create 2020-05-13 23:16
 */
public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("我是比亚迪，正在出发！");
    }
}

/**
 * @author huangyzh
 * @create 2020-05-14 0:08
 */
public interface CarFactory {
    Car createCar();
}

/**
 * @author huangyzh
 * @create 2020-05-14 0:09
 */
public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Audi();
    }
}

/**
 * @author huangyzh
 * @create 2020-05-14 0:09
 */
public class BydFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Byd();
    }
}

/**
 * 工厂方法模式测试
 * @author huangyzh
 * @create 2020-05-13 23:19
 */
public class Test01 {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();
        c1.run();
        c2.run();
    }
}

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

• 结构复杂度
  简单工厂模式占优，简单工厂模式只需要一个工厂类，而工厂方法模式随着产品类个数增加而增加，会使类的个数越来越多，从而增加了结构的复杂程度。
• 代码复杂度
  与结构复杂度是相互矛盾，简单工厂模式代码方面比工厂方法复杂，简单工厂模式工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。
• 客户端编码难度
  工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是一个优点。
• 管理上难度
  工厂方法模式完全满足OCP，使用它有非常良好的扩展性。但并不意味着简单工厂模式就没有扩展性，简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码就可以满足扩展性的要求了，尽管没有完全满足OCP,但是要知道，就是在sun提供的java官方工具包中也有相当多没有满足OCP的例子。
  从维护性的角度考虑，假定某个具体的产品类需要进行一定的修改，很可能需要修改对于的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦。反而简单工厂没有这些麻烦，当多个产品类需要修改时，简单工厂模式仍然仅仅需要修改唯一的工厂类。
  根据设计理念建议：工厂方法模式。但实际上，一般使用简单工厂模式的情况居多。

3、抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力，支持增加产品族）
抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

案例

/**
 * 座椅
 * @author huangyzh
 * @create 2020-05-14 0:41
 */
public interface Seat {
    void message();
}

/**
 * 轮胎
 * @author huangyzh
 * @create 2020-05-14 0:43
 */
public interface Tyre {
    void revolve();
}

/**
 * 发动机接口
 * @author huangyzh
 * @create 2020-05-14 0:38
 */
public interface Engine {
    void run();
    void start();
}

/**
 * @author huangyzh
 * @create 2020-05-14 0:40
 */
public class LowEngine implements Engine {
    @Override
    public void run() {
        System.out.println("转的慢……");
    }

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

/**
 * @author huangyzh
 * @create 2020-05-14 0:39
 */
public class LuxuryEngine implements Engine {
    @Override
    public void run() {
        System.out.println("转的快……");
    }

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

//依次创建LuxurySeat、LowSeat实现Seat接口
//依次创建LowTyre、LuxuryTyre实现Tyre接口

/**
 * @author huangyzh
 * @create 2020-05-14 0:45
 */
public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

/**
 * @author huangyzh
 * @create 2020-05-14 0:47
 */
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();
    }
}

/**
 * @author huangyzh
 * @create 2020-05-14 0:46
 */
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();
    }
}

/**
 * @author huangyzh
 * @create 2020-05-14 0:48
 */
public class Test01 {
    public static void main(String[] args) {
        CarFactory factory = new LuxuryCarFactory();
        Engine engine = factory.createEngine();
        engine.run();
        engine.start();
    }
}

总结

• 1、简单工厂模式：虽然某种程度不满足设计原则，但实际使用最多。
• 2、工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展。
• 3、抽象工厂模式：不可以增加产品，可以增加产品族。

应用场景:

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