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组件：
-
BeanFactory和ApplicationContext接口：Spring Boot中的BeanFactory和ApplicationContext接口都是使用工厂模式的典型例子。它们充当了对象工厂的角色，负责创建和管理Bean实例。
-
RestTemplate类：RestTemplate类是一个非常流行的Spring Boot组件，它用于发送HTTP请求。RestTemplate使用工厂方法模式创建HTTP请求工厂实例，以便根据请求类型和其他配置创建合适的请求实例。
-
JdbcTemplate类：JdbcTemplate类是一个用于执行SQL查询和更新的Spring Boot组件。它使用工厂方法模式创建数据源和JDBC连接实例。
-
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 接口的扩展，同时也是一个更加高级的工厂模式实现。