工厂模式

工厂模式

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

详细分类

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

核心本质

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

简单工厂

要点

• 简单工厂也称静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数不同，来返回不同的对象实例。
• 不符合开闭原则，当要增加新产品时，不得不修改内部代码。

类图：

image

代码实现：

用简单工厂模式模拟一个自动生产奥迪和比亚迪的车厂，创建奥迪和比亚迪实例。

/*
 * 车辆类的接口
 */
public interface Car {
    void run();
}
/*
 * 奥迪车
 */
public class Aodi implements Car{

    @Override
    public void run() {
        System.out.println("开奥迪！");
    }

}
/*
 * 比亚迪车
 */
public class Byd implements Car{

    @Override
    public void run() {
        System.out.println("开比亚迪！");
    }

}
/*
 * 简单工厂
 */
public class CarFactory {
    public static Car createCar(String type) {
        if(type.equals("Aodi")) 
            return new Aodi();
        else if(type.equals("Byd"))
            return new Byd();
        else
            return null;
    }
}
/*
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        //生产一辆奥迪
        Car aodi = CarFactory.createCar("Aodi");
        //生产一辆比亚迪
        Car byd = CarFactory.createCar("Byd");
        
        aodi.run();
        byd.run();
    } 
}

工厂方法

要点

• 为了避免简单工厂的缺点（无法增加新产品），不完全满足OCP（开闭原则）。
• 工厂方法模式和简单工厂模式的最大不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

类图

image

代码实现

创建一个工厂接口，用来扩展工厂类。下面将工厂分为了奥迪工厂和比亚迪工厂两个分工厂，分别用来生产奥迪车和比亚迪车。

/*
 * 车辆类的接口
 */
public interface Car {
    void run();
}
/*
 * 奥迪车
 */
public class Aodi implements Car{

    @Override
    public void run() {
        System.out.println("开奥迪！");
    }

}
/*
 * 比亚迪车
 */
public class Byd implements Car{

    @Override
    public void run() {
        System.out.println("开比亚迪！");
    }

}
/*
 * 工厂类接口
 */
public interface Factory {
    Car createCar();
}
/*
 * 生产奥迪车的分工厂
 */
public class AudiFactory implements Factory{

    @Override
    public Car createCar() {
        return new Audi();
    }

}
/*
 * 生产比亚迪的分工厂
 */
public class BydFactory implements Factory{

    @Override
    public Car createCar() {
        return new Byd();
    }

}
/*
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        //创建奥迪车
        Car audi = new AudiFactory().createCar();
        
        audi.run();
    }
}

抽象工厂

要点

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

类图：

image

代码实现：

/*
 * 发动机产品类的接口
 */
public interface Engine {
    void run();
    void start();
}
/*
 * 高配的发动机
 */
public class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("转的快！");
    }

    @Override
    public void start() {
        System.out.println("启动快！");
    }
    
}
/*
 * 低配的发动机
 */
public class LowEngine implements Engine{

    @Override
    public void run() {
        System.out.println("转的慢！");
    }
    @Override
    public void start() {
        System.out.println("启动慢！");
    }
    
}
/*
 * 座椅类产品的接口
 */
public interface Seat {
    void massage();
}
/*
 * 高配真皮座椅
 */
public class LuxurySeat implements Seat{

    @Override
    public void massage() {
        System.out.print("可以自动按摩");
    }
    
}
/*
 * 低配普通座椅
 */
public class LowSeat implements Seat{

    @Override
    public void massage() {
        System.out.print("不可以自动按摩");
    }
}
/*
 * 工厂类接口
 */
public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
}
/*
 * 高配车工厂
 */
public class LuxuryCarFactory implements CarFactory{
    public Engine createEngine() {
        return new LuxuryEngine();
    }
    public Seat createSeat() {
        return new LuxurySeat();
    }
}
/*
 * 低配车工厂
 */
public class LowCarFactory implements CarFactory{
    public Engine createEngine() {
        return new LowEngine();
    }
    public Seat createSeat() {
        return new LowSeat();
    }
}
/*
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        //高配汽车
        CarFactory factory1 = new LuxuryCarFactory();
        Engine e = factory1.createEngine();
        e.run();
        e.start();
        System.out.println("---------------------");
        //低配汽车
        CarFactory factory2 = new LowCarFactory();
        Engine e2 = factory2.createEngine();
        e2.run();
        e2.start();
    }
    
}

总结

工厂模式要点

• 简单工厂模式（静态工厂模式）

虽然某种程度不符合设计原则，但实际却使用最多。

• 工厂方法模式

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

• 抽象工厂模式

不可以增加产品，可以增加产品族。

应用场景：

1. JDK的Calendar的getInstance方法
2. JDBC中的Connection对象的获取
3. Hibernate中SessionFactory创建Session
4. Spring中的IOC容器创建管理bean对象
5. XML解析时的DocumentBuilderFactory创建解析器对象
6. 反射中Class对象的newInstance()