设计模式之———工厂模式

1. 工厂模式介绍

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

1.1 核心本质
- 实例化对象，用工厂方法代替new操作
- 将选择实现类和创建对象统一管理和控制，从而将调用者跟实现类解耦

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

1.3 应用场景
- JDK 中Calendar的getInstance()方法
- JDBC 中Connection对象的获取
- Hibernate 中SessionFactory创建Session
- Spring 中IOC容器创建管理Bean对象
- XML 解析时的DocumentBuilderFactory创建解析器对象
- 反射 Class对象的newInstance()方法

2. 无工厂模式

2.1 定义接口及实现类

// Car接口
public interface Car {
    public void run();
}

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

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

2.2 没有使用工厂模式的调用情况

/**
 * 没有使用工厂模式的情况(调用和创建在一个类，且和接口及其实现类都关联)
 * @author lyyao09 2016-9-30 16:42:27
 */
public class Client1 {
    public static void main(String[] args) {
        Car car1 = new Audi();
        Car car2 = new Byd();

        car1.run();
        car2.run();
    }
}

2.3 无工厂模式的类关系调用图

3. 简单工厂模式

3.1 定义接口及实现类（同上）

3.2 添加工厂方法

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

    // 写法2
    /*public static Car createAudi() {
        return new Audi();
    }

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

3.3 简单工厂的调用

/**
 * 简单工厂模式(调用跟创建分离，仅跟工厂类和接口关联)
 * @author lyyao09 2016-9-30 16:42:27
 */
public class Client2 {
    public static void main(String[] args) {
        Car car1 = SimpleFactory.createCar("奥迪");
        Car car2 = SimpleFactory.createCar("比亚迪");

        car1.run();
        car2.run();
    }
}

3.4 简单工厂的类关系调用图

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

2. 对增加新产品无能为力，不修改代码的话，是不能扩展的。

4. 工厂方法模式

4.1 定义接口及实现类（同上）

4.2 工厂接口及实现类

// Car工厂接口
public interface CarFactory {
    public Car createCar();
}

// 工厂接口的奥迪实现类
public class AudiFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Audi();
    }
}

// 工厂接口的比亚迪实现类
public class BydFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Byd();
    }
}

4.3 工厂方法的调用

public class Client1 {
    public static void main(String[] args) {
        Car car1 = new AudiFactory().createCar();
        Car car2 = new BydFactory().createCar();

        car1.run();
        car2.run();
    }
}

4.4 工厂方法的类关系调用图

1. 避免了简单工厂模式的缺点（不完全满足OCP原则）

2. 和简单工厂模式的不同：简单工厂模式只有一个工厂类（对于一个项目或一个独立模块），而工厂方法模式有一组实现了相同接口的工厂类。

5. 抽象工厂模式

5.1 接口及其实现类

// 发动机接口
public interface Engine {
    void run();
}

// 高端发动机实现类
class LuxuryEngine implements Engine{
    @Override
    public void run() {
        System.out.println("跑得快");
    }
}

// 低端发动机实现类
class LowerEngine implements Engine{
    @Override
    public void run() {
        System.out.println("跑得慢");
    }
}

// 座椅接口
public interface Seat {
    void massage();
}

// 高端座椅实现类
class LuxurySeat implements Seat{
    @Override
    public void massage() {
        System.out.println("可以按摩");
    }
}

// 低端座椅实现类
class LowerSeat implements Seat{
    @Override
    public void massage() {
        System.out.println("不可以按摩");
    }
}

5.2 工厂类接口及其实现

// 汽车工厂类
public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
}

// 高端汽车工厂实现类
public class LuxturyCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

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

// 低端汽车工厂实现类
public class LowerCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LowerEngine();
    }

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

5.3 抽象工厂的调用

public class Client {

    public static void main(String[] args) {
        Engine e1 = new LuxturyCarFactory().createEngine();
        Seat s1 = new LuxturyCarFactory().createSeat();
        e1.run();
        s1.massage();

        Engine e2 = new LowerCarFactory().createEngine();
        Seat s2 = new LowerCarFactory().createSeat();
        e2.run();
        s2.massage();
    }
}

5.4 抽象工厂的类关系调用图

6. 总结

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

• 工厂方法模式

• • 不修改已有类的前提下，通过增加新的工厂扩展功能

• 抽象工厂模式

• • 不可用增加产品，可以增加产品族