Java设计模式（二）——工厂模式

        当用户需要一个类的子类实例，且不希望与该类的子类形成耦合或者不知道该类有哪些子类可用时，可采用工厂模式；当用户需要系统提供多个对象，且希望和创建对象的类解耦时，可采用抽象工厂模式。

        工厂模式一般分为简单工厂、工厂、抽象工厂三种情况，属于创建型设计模式。

1. 关键角色

两个关键的角色：产品和工厂

两个角色的几种关系：

（1）单一产品系

	高档	中档	低档
小汽车	√	√	√

（2）多产品系，特征相同

	高档	中档	低档
小汽车	√	√	√
公共汽车	√	√	√

 （3）多产品系，部分特征相同

	高档	中档	低档
小汽车	√	√	√
公共汽车	√	√

（4）多产品系，无特征相同

	高档	中档	低档
小汽车	√	√
公共汽车			√

2. 简单工厂

简单工厂模式功能类编制步骤：

• 定制抽象产品接口：ICar
• 定制具体产品子类：UpCar MidCar DnCar
• 定制工厂类：CarSimpleFactory

对于工厂类 create() 方法的理解：

         使用简单工厂的时候，通常不用创建简单工厂类的类实例，没有创建实例的必要，因此可以把简单工厂类实现成一个工具类，直接使用静态方法就可以了。也就是说，简单工厂的方法通常都是静态的，所以也被称为静态工厂。

（1）小汽车接口

public interface ICar {
}

（2）定义高、中、低档具体的汽车

public class UpCar implements ICar{
}

public class MidCar implements ICar{
}

public class DnCar implements ICar{
}

（3）简单工厂

public class CarSimpleFactory {public static final String UPTYPR = "uptype";public static final String MIDTYPR = "midtype";public static final String DNTYPR = "dntype";public static ICar create(String mark) {ICar obj = null;if (mark.equals(UPTYPR)) {obj = new UpCar();}else if (mark.equals(MIDTYPR)) {obj = new MidCar();}else if (mark.equals(DNTYPR)) {obj = new DnCar();}return obj;}
}

（4）测试

public class CarTest {public static void main(String[] args) {ICar obj = CarSimpleFactory.create("UPCAR");}
}

新的需求：

如果现在又新增加了一个超高档类型的汽车，在简单工厂模式下，需要做的工作有：

（1）新增ICar的子类SuperCar

（2）修改工厂类 SimpleCarFactory 中的create方法，增加SuperCar对象的判断选择分支。

能否不修改工厂类，就能完成所需功能呢？可以 使用工厂模式。

3. 工厂模式

工厂模式功能类编制步骤：

• 定义抽象产品接口
• 定义具体产品子类
• 定义抽象工厂类  AbstractFactory，有一个重要的create抽象方法
• 定义具体工厂子类

（1）定义小汽车接口

public interface ICar {
}

（2）定义高、中、低档具体的小汽车

public class UpCar implements ICar{
}public class MidCar implements ICar {
}public class DnCar implements ICar {
}

（3）定义抽象工厂

public abstract class AbstractFactory {public abstract ICar create();
}

（4）定义高档小汽车工厂

public class UpFactory extends AbstractFactory{@Overridepublic ICar create() {return new UpCar();}
}

（5）定义中档小汽车工厂

public class MidFactory extends AbstractFactory{@Overridepublic ICar create() {return new MidCar();}
}

（6）定义低档小汽车工厂

public class DnFactory extends AbstractFactory{@Overridepublic ICar create() {return new DnCar();}
}

（7）测试类

public class CarTest {public static void main(String[] args) {AbstractFactory obj = new UpFactory(); //多态创建高档工厂System.out.println(obj);ICar car = obj.create();}
}

工厂模式和简单工厂模式的区别：

• 工厂模式把简单工厂中的具体工厂类划分成两层，抽象工厂层和具体工厂子类层。
• create方法参数的理解，在简单工厂模式中，create(String mark) 是成员方法，表名在该方法中管理多个产品，根据mark的值产生并返回ICar对象；在工厂模式中，create是抽象方法，无参数，表名在具体的子类工厂中创建某个具体的产品。
• 工厂方法更易于软件的二次开发和维护，主要特征是：当需求分析发生变化时，只需要增加、删除相应的类，而不是修改已有的类。

例如，又生产了一种超高档的小汽车，只需要增加SuperCar及SuperFactory两个类即可：

public class SuperCar implements ICar{
}

public class SuperFactory extends AbstractFactory{@Overridepublic ICar create() {return new SuperCar();}
}

4. 抽象工厂

        一般来说，简单工厂、工厂模式是单产品系的，而抽象工厂是多产品系得。从本质上讲，抽象工厂、工厂模式是统一得。

抽象工厂模式功能类编制步骤如下：

• 定制抽象产品接口 如 ICar IBus
• 定制具体产品子类  如 UpCar MidCar DnCar UpBus MidBus
• 定制抽象工厂类   如 AbstractFactory 有两个create方法，分别返回ICar 和 IBus对象
• 定制具体工厂子类

（1） 定义小汽车接口

public interface ICar {
}

定义高、中、低档小汽车

public class UpCar implements ICar {
}public class MidCar implements ICar {
}public class DnCar implements ICar {
}

（2）定义公共汽车接口

public interface IBus {
}

定义高、中、低档公共汽车

public class UpBus implements IBus{
}public class MidBus implements IBus{
}public class DnBus implements IBus{
}

（3）定义抽象工厂

public abstract class AbstractFactory {public abstract ICar createCar();public abstract IBus createBus();
}

（4）定义高档、中档、低档工厂

public class UpFactory extends AbstractFactory{@Overridepublic ICar createCar() {return new UpCar();}@Overridepublic IBus createBus() {return new UpBus();}
}

public class MidFactory extends AbstractFactory{@Overridepublic ICar createCar() {return new MidCar();}@Overridepublic IBus createBus() {return new MidBus();}
}

public class DnFactory extends AbstractFactory{@Overridepublic ICar createCar() {return new DnCar();}@Overridepublic IBus createBus() {return new DnBus();}
}

在Spring Boot框架中并不是哪里都使用了工厂模式，但是工厂模式确实被广泛地应用在Spring Boot中的一些关键组件中。以下是一些常见的使用工厂模式的Spring Boot组件：

1. BeanFactory和ApplicationContext接口：Spring Boot中的BeanFactory和ApplicationContext接口都是使用工厂模式的典型例子。它们充当了对象工厂的角色，负责创建和管理Bean实例。

2. RestTemplate类：RestTemplate类是一个非常流行的Spring Boot组件，它用于发送HTTP请求。RestTemplate使用工厂方法模式创建HTTP请求工厂实例，以便根据请求类型和其他配置创建合适的请求实例。

3. JdbcTemplate类：JdbcTemplate类是一个用于执行SQL查询和更新的Spring Boot组件。它使用工厂方法模式创建数据源和JDBC连接实例。

4. DispatcherServlet类：DispatcherServlet类是Spring Boot中的核心组件之一，用于处理HTTP请求和响应。它使用工厂方法模式创建HandlerMapping和HandlerAdapter实例，以便将请求路由到正确的处理程序方法并执行请求。

总之，Spring Boot框架中的许多组件都使用了工厂模式来创建和管理对象。这些组件可以更好地实现松耦合和可维护性，使得应用程序更加灵活和可扩展。

对于BeanFactory:

BeanFactory 是 Spring 框架中的一个关键接口，它使用工厂模式来创建和管理 Bean 实例。在 Spring Boot 中，BeanFactory 是 ApplicationContext 接口的父接口，也就是 ApplicationContext 继承了 BeanFactory 接口，因此 ApplicationContext 也是一个工厂模式的实现。

在使用 Spring Boot 框架时，我们通常会通过配置文件（比如 XML 配置文件、Java 配置类等）来定义 Bean，然后通过 BeanFactory 来获取 Bean 的实例。BeanFactory 的实现类可以根据配置文件中定义的信息创建对应的 Bean 实例，而且还可以对 Bean 的生命周期进行管理。

在 Spring Boot 中，我们通常使用如下方式来获取 BeanFactory 的实例：

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;public class MyBeanFactoryExample {public static void main(String[] args) {// 通过 ClassPathResource 加载配置文件ClassPathResource resource = new ClassPathResource("applicationContext.xml");// 创建 XmlBeanFactory 实例BeanFactory factory = new XmlBeanFactory(resource);// 通过 BeanFactory 获取指定名称的 Bean 实例MyBean myBean = (MyBean)factory.getBean("myBean");myBean.sayHello();}
}

在上面的代码中，我们首先使用 ClassPathResource 类加载了一个名为 applicationContext.xml 的配置文件，然后创建了一个 XmlBeanFactory 实例，最后通过 getBean() 方法获取了一个名为 myBean 的 Bean 实例，并调用了它的 sayHello() 方法。

总的来说，BeanFactory 接口是 Spring 框架中最基本的工厂模式实现，它用于创建和管理 Bean 实例，而且非常灵活、可扩展。如果需要更高级的功能（比如自动注入、AOP 等），可以使用 ApplicationContext 接口，它是 BeanFactory 接口的扩展，同时也是一个更加高级的工厂模式实现。