设计模式【2】------>工厂模式

一、什么是工厂模式

　　它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式

二、工厂模式好处

1. 工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。
2. 利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。
3. 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

三、为什么要学习工厂设计模式

• 不知道你们面试题问到过源码没有，你知道Spring的源码吗，MyBatis的源码吗，等等等
• 如果你想学习很多框架的源码，或者你想自己开发自己的框架，就必须先掌握设计模式（工厂设计模式用的是非常非常广泛的）

四、Spring开发中的工厂设计模式

1、Spring IOC

• 看过Spring源码就知道，在Spring IOC容器创建bean的过程是使用了工厂设计模式
• Spring中无论是通过xml配置还是通过配置类还是注解进行创建bean，大部分都是通过简单工厂来进行创建的。
• 当容器拿到了beanName和class类型后，动态的通过反射创建具体的某个对象，最后将创建的对象放到Map中。

2、为什么Spring IOC要使用工厂设计模式创建Bean呢

• 在实际开发中，如果我们A对象调用B，B调用C，C调用D的话我们程序的耦合性就会变高。（耦合大致分为类与类之间的依赖，方法与方法之间的依赖。）
• 在很久以前的三层架构编程时，都是控制层调用业务层，业务层调用数据访问层时，都是直接new对象，耦合性大大提升，代码重复量很高，对象满天飞
• 为了避免这种情况，Spring使用工厂模式编程，写一个工厂，由工厂创建Bean，以后我们如果要对象就直接管工厂要就可以，剩下的事情不归我们管了。Spring IOC容器的工厂中有个静态的Map集合，是为了让工厂符合单例设计模式，即每个对象只生产一次，生产出对象后就存入到Map集合中，保证了实例不会重复影响程序效率。

五、工厂模式分类

工厂模式分为简单工厂、工厂方法、抽象工厂模式

• 简单工厂 ：用来生产同一等级结构中的任意产品。（不支持拓展增加产品）
• 工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）
• 抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

1、简单工厂模式

什么是简单工厂模式

• 简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可。但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护。

结构图

代码演示：

（1）创建工厂

public interface Car {
    public void run();
}

（2）创建工厂的产品（宝马）

public class Bmw implements Car {
    @Override
    public void run() {
        System.out.println("我是宝马汽车------>");
    }
}

（3）创建工厂的另一种产品（奔驰）

public class Benci implements Car {
    @Override
    public void run() {
        System.out.println("我是奔驰汽车------->");
    }
}

（4）创建核心工厂类，由他决定具体调用哪产品

public class CarFactory {
    public static Car createCar(String name){
        if ("".equals(name)) {
            return null;
        }
        if("奔驰".equals(name)){
            return new Benci();
        }
        if("宝马".equals(name)){
            return new Bmw();
        }
        return null;
    }
}

（5）演示创建工厂的具体实例

public class Client {
    public static void main(String[] args){
        Car benci = CarFactory.createCar("奔驰");
        Car bmw = CarFactory.createCar("宝马");
        benci.run();
        bmw.run();
    }
}

简单工厂的优点/缺点

• 优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
• 缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

应用场景

• 对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

2、工厂方法模式

什么是工厂方法模式

• 工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节

结构图

（1）创建工厂

public interface Car {
    public void run();
}

（2）创建工厂方法调用接口（所有的产品需要new出来必须继承他来实现方法）

public interface CarFactory {
    Car createCar();
}

（3）创建工厂的产品（宝马）

public class Bmw implements Car {
    @Override
    public void run() {
        System.out.println("我是宝马汽车------>");
    }
}

（4）创建工厂的另一种产品（奔驰）

public class Benci implements Car {
    @Override
    public void run() {
        System.out.println("我是奔驰汽车------->");
    }
}

（5）创建工厂方法调用接口的实例（宝马）

public class BmwFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Bmw();
    }
}

（6）创建工厂方法调用接口的实例（奔驰）

public class BenciFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benci();
    }
}

（7）演示创建工厂的具体实例

public class Client {
    public static void main(String[] args){
        Car bmw = new BmwFactory().createCar();
        Car benci = new BenciFactory().createCar();
        bmw.run();
        benci.run();
    }
}

工厂方法优缺点

优点：

1. 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
2. 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
3. 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

1. 类的个数容易过多，增加复杂度
2. 增加了系统的抽象性和理解难度
3. 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

应用场景

• 客户只知道创建产品的工厂名，而不知道具体的产品名。如宝马工厂、奔驰工厂等。
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
• 客户不关心创建产品的细节，只关心产品的品牌

3 、抽象工厂模式

什么是抽象工厂模式

• 抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。

结构图

代码演示

（1）创建第一个子工厂，及实现类

/**
 * 汽车
 */
public interface Car {
    void run();
}

class CarA implements Car {

    @Override
    public void run() {
        System.out.println("宝马");
    }

}

class CarB implements Car {

    @Override
    public void run() {
        System.out.println("奔驰");
    }

}

（2）创建第二个子工厂，及实现类

/**
 * 发动机
 */
public interface Engine {

    void run();
}

class EngineA implements Engine {

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

}

class EngineB implements Engine {

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

}

（3）创建一个总工厂，及实现类（由总工厂的实现类决定调用那个工厂的那个实例）

/**
 * 总工厂及实现类
 */
public interface TotalFactory {
    // 创建汽车
    Car createChair();
    // 创建发动机
    Engine createEngine();
}

//总工厂实现类，由他决定调用哪个工厂的那个实例
class TotalFactoryReally implements TotalFactory {

    @Override
    public Engine createEngine() {

        return new EngineA();
    }

    @Override
    public Car createChair() {

        return new CarA();
    }
}

（4）运行测试

public class Client {
    public static void main(String[] args) {
        TotalFactory totalFactory2 = new TotalFactoryReally();
        Car car = totalFactory2.createChair();
        car.run();

        TotalFactory totalFactory = new TotalFactoryReally();
        Engine engine = totalFactory.createEngine();
        engine.run();
    }
}

打印结果：

宝马
转得快！

应用场景

• 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
• 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
• 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。