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）………………