Java 设计模式~工厂模式

在java开发，工厂模式应用场景有哪些？在Spring boot原码中 有哪些工厂类，并做相应的代码介绍。

工厂模式

工厂模式（Factory Pattern）是Java中一种常用的创建型设计模式，它提供了一种创建对象的最佳方式。此模式定义一个用于创建对象的接口，但让子类决定实例化哪一个类。工厂模式让一个类的实例化延迟到其子类。

工厂模式的分类

1. 简单工厂模式（Simple Factory Pattern）：
   • 又称静态工厂方法模式，它不属于GOF的23种设计模式之一，但在实际开发中经常使用。
   • 通过一个工厂类来创建对象，客户端不需要直接实例化对象，而是通过调用工厂类的方法来获取对象实例。
2. 工厂方法模式（Factory Method Pattern）：
   • 定义一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。
   • 工厂方法让一个类的实例化延迟到其子类，子类可以重写父类的工厂方法来指定实例化哪一个类。
3. 抽象工厂模式（Abstract Factory Pattern）：
   • 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
   • 抽象工厂模式使得客户端可以独立于它的产品的具体类变化，客户端通过它们的抽象接口操纵实例。

工厂模式的优缺点

优点：

• 封装性：使用工厂模式可以将对象的创建过程封装起来，使得客户端代码与具体实现类解耦，降低了代码的耦合度。
• 可扩展性：当需要添加新的产品时，只需要在工厂类中添加相应的创建逻辑即可，不需要修改客户端代码，符合开闭原则。
• 灵活性：工厂模式可以灵活地创建对象，可以通过不同的工厂类来创建不同的对象实例。

缺点：

• 复杂性：增加了系统的复杂性，因为需要引入工厂类和抽象类或接口。
• 性能开销：在创建对象时，需要调用工厂类的方法，可能会增加一些性能开销。

工厂模式的实现示例

以下是简单工厂模式的实现示例：

java复制代码

	// 产品接口
	public interface Product {
	void use();
	}
	// 具体产品类A
	public class ProductA implements Product {
	@Override
	public void use() {
	System.out.println("使用产品A");
	}
	}
	// 具体产品类B
	public class ProductB implements Product {
	@Override
	public void use() {
	System.out.println("使用产品B");
	}
	}
	// 工厂类
	public class SimpleFactory {
	public static Product createProduct(String type) {
	Product product = null;
	switch (type) {
	case "A":
	product = new ProductA();
	break;
	case "B":
	product = new ProductB();
	break;
	default:
	throw new IllegalArgumentException("未知的产品类型");
	}
	return product;
	}
	}
	// 客户端代码
	public class Client {
	public static void main(String[] args) {
	Product productA = SimpleFactory.createProduct("A");
	productA.use();
	Product productB = SimpleFactory.createProduct("B");
	productB.use();
	}
	}

在上面的示例中，SimpleFactory是一个简单工厂类，它有一个静态方法createProduct，根据传入的类型参数来创建不同的Product对象。客户端代码通过调用SimpleFactory.createProduct方法来获取产品对象，并调用其use方法。

通义灵码

在Java开发中，工厂模式有多种应用场景，主要集中在以下几个方面：

工厂模式的应用场景

1. 解耦对象的创建和使用：通过工厂模式，客户端不需要知道对象的具体创建细节，只需要通过工厂获取对象即可。
2. 动态选择对象的创建：可以根据不同的条件动态选择创建不同类型的对象。
3. 集中管理对象的创建：适用于需要集中管理对象创建逻辑的场景。
4. 简化复杂对象的创建过程：对于复杂的对象创建过程，可以使用工厂模式封装创建逻辑，简化客户端代码。
5. 提高系统的可扩展性：新增产品类时，只需添加对应的工厂方法或工厂类，而不需要修改现有代码。

Spring Boot中的工厂类及其应用场景

1. BeanFactory

• 应用场景：BeanFactory是Spring框架的核心接口之一，负责管理和配置应用程序中的bean。它是Spring容器的基础，提供了基本的依赖注入功能。
• 代码示例：

  java

  // 获取BeanFactory实例 ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); MyBean myBean = (MyBean) context.getBean("myBean");

2. ApplicationContext

• 应用场景：ApplicationContext是BeanFactory的一个子接口，提供了更多的企业级功能，如国际化支持、事件传播机制等。它是Spring Boot中最常用的容器。
• 代码示例：

  java

  // 获取ApplicationContext实例 ApplicationContext context = SpringApplication.run(MyApplication.class, args); MyService myService = context.getBean(MyService.class);

3. ObjectFactory

• 应用场景：ObjectFactory通常用于延迟初始化对象，当需要时才创建对象。它常用于复杂的依赖关系中，以提高性能。
• 代码示例：

  java

  @Component public class MyComponent { private final ObjectFactory<MyDependency> myDependencyFactory; @Autowired public MyComponent(ObjectFactory<MyDependency> myDependencyFactory) { this.myDependencyFactory = myDependencyFactory; } public void doSomething() { MyDependency myDependency = myDependencyFactory.getObject(); // 使用myDependency } }

4. FactoryBean

• 应用场景：FactoryBean接口允许自定义bean的创建逻辑。当你需要复杂的bean初始化过程时，可以实现这个接口。
• 代码示例：

  java

  @Component public class MyFactoryBean implements FactoryBean<MyBean> { @Override public MyBean getObject() throws Exception { return new MyBean(); // 自定义创建逻辑 } @Override public Class<?> getObjectType() { return MyBean.class; } }

5. SmartFactoryBean

• 应用场景：SmartFactoryBean是FactoryBean的一个扩展接口，提供了更多的控制选项，如是否单例、是否需要运行时检查等。
• 代码示例：

  java

  @Component public class MySmartFactoryBean implements SmartFactoryBean<MyBean> { @Override public MyBean getObject() throws Exception { return new MyBean(); // 自定义创建逻辑 } @Override public Class<?> getObjectType() { return MyBean.class; } @Override public boolean isSingleton() { return true; // 是否为单例 } }

Spring Boot源码中的工厂类示例

DefaultListableBeanFactory

• 应用场景：DefaultListableBeanFactory是BeanFactory的一个实现类，提供了对bean定义的注册和管理功能。
• 代码示例：

  java

  DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); BeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory); reader.loadBeanDefinitions(new FileSystemResource("beans.xml")); MyBean myBean = (MyBean) beanFactory.getBean("myBean");

AnnotationConfigApplicationContext

• 应用场景：AnnotationConfigApplicationContext是ApplicationContext的一个实现类，用于从Java配置类中加载bean定义。
• 代码示例：

  java

  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); MyService myService = context.getBean(MyService.class);

SimpleObjectFactory

• 应用场景：SimpleObjectFactory是Spring内部使用的简单对象工厂，用于创建对象实例。
• 代码示例：

  java

  SimpleObjectFactory factory = new SimpleObjectFactory(); MyBean myBean = factory.createObjectInstance(MyBean.class);

AutowireCapableBeanFactory

• 应用场景：AutowireCapableBeanFactory是BeanFactory的一个扩展接口，提供了自动装配功能。
• 代码示例：

  java

  AutowireCapableBeanFactory beanFactory = new DefaultListableBeanFactory(); MyBean myBean = beanFactory.createBean(MyBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);

这些工厂类在Spring Boot中扮演着重要的角色，帮助开发者更高效地管理和创建对象。根据具体的应用场景，可以选择合适的工厂类来实现需求。

文兴一言

Java开发中工厂模式的应用场景

工厂模式在Java开发中具有广泛的应用场景，主要包括以下几个方面：

1. 对象创建复杂：当对象的创建过程涉及多个步骤或需要复杂的配置时，可以使用工厂模式来封装这些创建逻辑，简化客户端代码。
2. 需要创建的对象类型较多：如果系统中需要根据不同的条件创建不同类型的对象，使用工厂模式可以避免大量的if-else或switch-case语句，使代码更加清晰和易于维护。
3. 提高代码的可测试性：在单元测试时，工厂模式允许创建模拟（mock）对象，以便在不依赖实际对象的情况下测试代码。
4. 遵循开闭原则：工厂模式使得系统能够在不修改现有代码的情况下添加新的产品类型或创建逻辑，符合开闭原则（对扩展开放，对修改关闭）。

Spring Boot源码中的工厂类

在Spring Boot源码中，工厂模式得到了广泛的应用。以下是一些常见的工厂类及其代码介绍：

1. SpringFactoriesLoader

   SpringFactoriesLoader是Spring Boot用于加载工厂类的关键类。它负责从类路径中的META-INF/spring.factories文件中加载工厂类的名称，并实例化这些工厂类。这个文件以键值对的形式存在，键是接口类的全限定名，值是用逗号隔开的多个实现类的全限定名。

   java复制代码

   	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
   	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
   	// Use names and ensure unique to protect against duplicates
   	Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
   	List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
   	AnnotationAwareOrderComparator.sort(instances);
   	return instances;
   	}

   在上面的代码中，getSpringFactoriesInstances方法负责加载和实例化spring.factories文件中指定的工厂类。

2. ApplicationContextInitializer工厂

   ApplicationContextInitializer是Spring Boot用于初始化ApplicationContext的接口。Spring Boot在启动时会加载并调用这些初始化器来配置ApplicationContext。这些初始化器通常通过@Configuration注解定义的配置类来创建。

   java复制代码

   	@Configuration
   	public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
   	@Override
   	public void initialize(ConfigurableApplicationContext applicationContext) {
   	// 初始化逻辑
   	}
   	}

   在spring.factories文件中，可以通过指定org.springframework.context.ApplicationContextInitializer的键来注册这些初始化器。

3. ApplicationListener工厂

   ApplicationListener是Spring框架中的事件监听器接口。在Spring Boot中，可以通过实现这个接口来监听特定的事件，并在事件发生时执行相应的逻辑。这些监听器通常也是通过@Configuration注解定义的配置类来创建的。

   java复制代码

   	@Component
   	public class MyApplicationListener implements ApplicationListener<ApplicationReadyEvent> {
   	@Override
   	public void onApplicationEvent(ApplicationReadyEvent event) {
   	// 事件处理逻辑
   	}
   	}

   与ApplicationContextInitializer类似，ApplicationListener也可以通过在spring.factories文件中指定相应的键来注册。

4. 自定义工厂类

   除了Spring Boot自带的工厂类外，开发者还可以根据自己的需求创建自定义的工厂类。这些工厂类通常用于封装复杂的对象创建逻辑，以便在需要时轻松地创建对象实例。

   java复制代码

   	@Configuration
   	public class MyFactoryConfig {
   	@Bean
   	public MyService myService() {
   	return new MyServiceImpl();
   	}
   	}
   	public interface MyService {
   	void performService();
   	}
   	public class MyServiceImpl implements MyService {
   	@Override
   	public void performService() {
   	// 服务实现逻辑
   	}
   	}

   在上面的代码中，MyFactoryConfig是一个配置类，它定义了一个工厂方法myService来创建MyService接口的实现类MyServiceImpl的实例。这样，当需要MyService类型的对象时，Spring容器会自动调用这个工厂方法来创建实例。

综上所述，工厂模式在Java开发和Spring Boot源码中都具有广泛的应用。通过合理地使用工厂模式，可以简化对象创建逻辑、提高代码的可读性和可维护性，并遵循开闭原则以支持系统的扩展性。