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

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

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

两个关键的角色&＃xff1a;产品和工厂

两个角色的几种关系&＃xff1a;

&＃xff08;1&＃xff09;单一产品系

&＃xff08;2&＃xff09;多产品系&＃xff0c;特征相同

 &＃xff08;3&＃xff09;多产品系&＃xff0c;部分特征相同

&＃xff08;4&＃xff09;多产品系&＃xff0c;无特征相同

简单工厂模式功能类编制步骤&＃xff1a;

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

对于工厂类 create() 方法的理解&＃xff1a;

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

&＃xff08;1&＃xff09;小汽车接口

public interface ICar {
}

&＃xff08;2&＃xff09;定义高、中、低档具体的汽车

public class UpCar implements ICar{
}

public class MidCar implements ICar{
}


public class DnCar implements ICar{
}


&＃xff08;3&＃xff09;简单工厂

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

&＃xff08;4&＃xff09;测试

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

新的需求&＃xff1a;

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

&＃xff08;1&＃xff09;新增ICar的子类SuperCar

&＃xff08;2&＃xff09;修改工厂类 SimpleCarFactory 中的create方法&＃xff0c;增加SuperCar对象的判断选择分支。

能否不修改工厂类&＃xff0c;就能完成所需功能呢&＃xff1f;可以 使用工厂模式。

工厂模式功能类编制步骤&＃xff1a;

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

&＃xff08;1&＃xff09;定义小汽车接口

public interface ICar {
}

&＃xff08;2&＃xff09;定义高、中、低档具体的小汽车

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

&＃xff08;3&＃xff09;定义抽象工厂

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

&＃xff08;4&＃xff09;定义高档小汽车工厂

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


&＃xff08;5&＃xff09;定义中档小汽车工厂

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

&＃xff08;6&＃xff09;定义低档小汽车工厂

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


&＃xff08;7&＃xff09;测试类

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

工厂模式和简单工厂模式的区别&＃xff1a;

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

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

public class SuperCar implements ICar{
}

public class SuperFactory extends AbstractFactory{&＃64;Overridepublic ICar create() {return new SuperCar();}
}
4. 抽象工厂

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

抽象工厂模式功能类编制步骤如下&＃xff1a;

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

&＃xff08;1&＃xff09; 定义小汽车接口

public interface ICar {
}

定义高、中、低档小汽车

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

&＃xff08;2&＃xff09;定义公共汽车接口

public interface IBus {
}

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

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


&＃xff08;3&＃xff09;定义抽象工厂

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


&＃xff08;4&＃xff09;定义高档、中档、低档工厂

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

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


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

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

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

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

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

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

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

对于BeanFactory:

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

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

在 Spring Boot 中&＃xff0c;我们通常使用如下方式来获取 BeanFactory 的实例&＃xff1a;

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 &＃61; new ClassPathResource("applicationContext.xml");// 创建 XmlBeanFactory 实例BeanFactory factory &＃61; new XmlBeanFactory(resource);// 通过 BeanFactory 获取指定名称的 Bean 实例MyBean myBean &＃61; (MyBean)factory.getBean("myBean");myBean.sayHello();}
}


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

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