设计模式二：工厂模式

什么是工厂模式

大家在开发中应该都使用过或者看到过SqlSessionFactory或者BeanFactory，这就是使用工厂模式来生产对象。工厂模式用于封装和管理对象的创建，分离对象的创建者和调用者，实现与对象解耦的目的。

工厂模式可以分为：

• 简单工厂
• 工厂方法
• 抽象工厂

实现方式

简单工厂

简单工厂通过接收的参数的不同来返回不同的对象实例，涉及到的角色有：

• 抽象产品
• 具体产品
• 具体工厂
• 调用者

代码如下：

// 抽象产品
public interface Car {
    void run();
}

// 具体产品1
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("audi run");
    }
}

// 具体产品2
public class Benz implements Car{
    @Override
    public void run() {
        System.out.println("benz run");
    }
}

// 具体工厂，用于生成产品
public class SimpleFactory {
    // 方式1，根据传入的参数生成对应的产品对象
    public static Car getCar(String type){
        if ("audi".equals(type)){
            return new Audi();
        } else if ("benz".equals(type)){
            return new Benz();
        } else {
            return null;
        }
    }

    // 方式2，直接调用生成对应的产品对象的方法
    public static Car getAudi(){
        return new Audi();
    }

    public static Car getBenz(){
        return new Benz();
    }
}

// 调用者
public class SimpleFactoryTest {
    public static void main(String[] args) {
        // 没有使用简单工厂，那么客户端就需要和接口Car以及其实现类打交道
//        Car audi = new Audi();
//        Car benz = new Benz();
//        audi.run();
//        benz.run();

        // 使用简单工厂，方式1
        Car audi = SimpleFactory.getCar("audi");
        Car benz = SimpleFactory.getCar("benz");
        audi.run();
        benz.run();
        System.out.println("============");

        // 使用简单工厂，方式2
        Car audi1 = SimpleFactory.getAudi();
        Car benz1 = SimpleFactory.getBenz();
        audi1.run();
        benz1.run();
    }
}

类图如下：

可以看到，如果再增加一种产品，则需要修改工厂类，故这种工厂模式适用于产品对象较少，且产品固定的需求 。其实我们在一般的项目中使用简单工厂就足够了。

工厂方法

为了避免简单工厂不满足开闭原则的缺点，增加产品而不需要去修改工厂类，可以使用工厂方法模式，增加产品的同时通过增加一个对应的工厂类来生产对应的产品，涉及的角色有：

• 抽象产品
• 具体产品
• 抽象工厂
• 具体工厂
• 调用者

代码如下：

// 抽象产品
public interface Car {
    void run();
}

// 具体产品1
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("audi run");
    }
}

// 具体产品2
public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("benz run");
    }
}

// 抽象工厂
public interface CarFactory {
    Car createCar();
}

// 具体工厂1
public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Audi();
    }
}

// 具体工厂2
public class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}

// 调用者
public class FactoryMethodTest {
    public static void main(String[] args) {
        Car audi = new AudiFactory().createCar();
        Car benz = new BenzFactory().createCar();
        audi.run();
        benz.run();
    }
}

类图如下：

可以看到，如果新增加一种具体产品，就需要为其增加一个具体工厂类用于生产该产品。

抽象工厂

抽象工厂用于生产一族产品。涉及的角色有：

• 抽象产品
• 具体产品
• 抽象工厂
• 具体工厂
• 调用者

代码如下：

// 抽象产品A
public interface Engine {
    void autoStart();
}

// 具体产品A1
public class HighEngine implements Engine {
    @Override
    public void autoStart() {
        System.out.println("高端发动机有自动启停功能");
    }
}

// 具体产品A2
public class LowEngine implements Engine {
    @Override
    public void autoStart() {
        System.out.println("低端发动机没有自动启停功能");
    }
}

// 抽象产品B
public interface Tyre {
    void monitor();
}

// 具体产品B1
public class HighTyre implements Tyre {
    @Override
    public void monitor() {
        System.out.println("高端轮胎有胎压监控功能");
    }
}

// 具体产品B2
public class LowTyre implements Tyre {
    @Override
    public void monitor() {
        System.out.println("低端轮胎无监控胎压功能");
    }
}

// 抽象工厂
public interface CarFactory {
    Engine createEngine();
    Tyre createTyre();
}

// 具体工厂A1B1
public class HighCarFactory implements CarFactory {
    @Override
    public HighEngine createEngine() {
        return new HighEngine();
    }

    @Override
    public HighTyre createTyre() {
        return new HighTyre();
    }
}

// 具体工厂A2B2
public class LowCarFactory implements CarFactory {
    @Override
    public LowEngine createEngine() {
        return new LowEngine();
    }

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

// 调用者
public class AbstractFactoryTest {
    public static void main(String[] args) {
        CarFactory highCar = new HighCarFactory();
        highCar.createEngine().autoStart();
        highCar.createTyre().monitor();
    }
}

类图如下：

可以看到通过具体工厂A1B1和A2B2可以生产出不同的产品族，在产品固定的情况下，可以通过新增具体工厂类，来组合生成不同的产品族，比如A1B2或者A2B1。但是如果要增加新的产品的话，比如增加产品C，那就需要去修改抽象工厂和具体工厂，就不适合了。

欢迎关注我的公众号，一起学习技术。