【设计模式系列】简单工厂模式

时间:2024-10-23 17:34:10

一、什么是简单工厂模式

简单工厂模式(Simple Factory Pattern)是一种设计模式,其中包含一个工厂类,根据传入的参数不同,返回不同类的实例。这个工厂类封装了对象的创建逻辑,使得客户端代码可以从直接创建对象的复杂性中解放出来。

二、简单工厂模式的角色

  1. 抽象产品(Product)

    • 定义了产品的接口或者抽象类,所有的具体产品类都应该实现这个接口或继承这个抽象类。
    • 它规定了具体产品对象必须实现的接口。
  2. 具体产品(Concrete Product)

    • 实现了抽象产品接口的具体产品类。
    • 工厂模式创建的最终对象,是具体产品类的实例。
  3. 抽象工厂(Creator)

    • 提供了一个创建产品的接口,用于创建和返回一个产品实例。
    • 它可能包含一个或多个创建产品对象的方法。
  4. 具体工厂(Concrete Creator)

    • 实现了抽象工厂接口的具体工厂类。
    • 它负责实例化具体的产品对象,并且返回一个产品实例。

三、简单工厂模式的典型应用场景

  1. 对象的创建需要灵活性: 当对象的创建依赖于多个条件,或者需要根据不同的输入参数来创建不同类型的对象时,工厂模式提供了一种灵活的方式来处理这些情况。

  2. 创建对象成本较高: 当对象的创建过程中涉及到复杂的逻辑或者资源消耗较大时,使用工厂模式可以封装这些复杂的创建过程,使得客户端代码更加简洁。

  3. 数据库连接池: 在需要创建数据库连接时,可以使用工厂模式来封装创建连接的过程,同时可以管理连接的生命周期。

四、简单工厂模式在StaticListableBeanFactory中的应用

StaticListableBeanFactory 是 Spring 框架中 BeanFactory 接口的一个具体实现,它是一种特殊类型的工厂,用于存储和管理 bean 的实例。在工厂模式中,工厂类负责创建对象,而在 StaticListableBeanFactory 中,这个对象就是 Spring 容器管理的 bean。这个工厂是一个静态的工厂,意味着它不基于 bean 的定义来动态创建 bean,而是在工厂初始化时就添加了所有 bean 的实例。

在工厂模式的应用中,StaticListableBeanFactory 扮演了以下几个角色:

  1. 抽象工厂(Factory):提供了一个接口或抽象类,定义了创建对象的方法。在 StaticListableBeanFactory 中,这个接口是由 BeanFactory 提供的,它定义了 getBean 等方法来获取 bean 实例。

  2. 具体工厂(Concrete Factory):实现了工厂接口的具体类,负责创建具体产品的对象。StaticListableBeanFactory 就是具体工厂的实现,它通过 addBean 方法静态地添加 bean 实例。

  3. 抽象产品(Product):工厂模式中创建的对象。在 Spring 中,这些对象就是由 StaticListableBeanFactory 管理的 bean。

  4. 具体产品(Concrete Product):实现了产品接口的具体类。在 Spring 的上下文中,这些是由 StaticListableBeanFactory 管理的具体 bean 实例。

StaticListableBeanFactory 在工厂模式中的应用特点如下:

  • 静态实例管理StaticListableBeanFactory 存储的是 bean 的实例,而不是基于 bean 定义来动态创建实例。这意味着所有的 bean 必须在工厂初始化时就已经存在。

  • 单例管理StaticListableBeanFactory 只支持单例 bean,不支持原型(prototype)bean。这是因为它在初始化时就已经创建了 bean 的实例,并且存储起来供后续使用。

  • 列表功能:由于实现了 ListableBeanFactory 接口,StaticListableBeanFactory 支持通过类型来检索 bean,这允许客户端代码可以通过类型来获取所有匹配的 bean 列表。

  • 简单性StaticListableBeanFactory 是一个简化版的 bean 工厂,它不支持 bean 的生命周期管理、依赖注入、bean 后处理等高级功能,因此适用于简单的应用场景。

下面是一个简单的示例,展示了如何使用 StaticListableBeanFactory 来实现工厂模式:

//抽象工厂
public interface BeanFactory {

	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

}

//具体工厂
public class StaticListableBeanFactory implements BeanFactory {

	@Override
	public Object getBean(String name) throws BeansException {
		String beanName = BeanFactoryUtils.transformedBeanName(name);
		Object bean = this.beans.get(beanName);

		if (bean == null) {
			throw new NoSuchBeanDefinitionException(beanName,
					"Defined beans are [" + StringUtils.collectionToCommaDelimitedString(this.beans.keySet()) + "]");
		}

		if (BeanFactoryUtils.isFactoryDereference(name) && !(bean instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(beanName, bean.getClass());
		}

		if (bean instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
			try {
				return ((FactoryBean<?>) bean).getObject();
			}
			catch (Exception ex) {
				throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
			}
		}
		else {
			return bean;
		}
	}

	public void addBean(String name, Object bean) {
		this.beans.put(name, bean);
	}

}

// 具体产品
class MyBean {
    public void doSomething() {
        System.out.println("Doing something");
    }
}

//客户端
public class StaticListableBeanFactoryExample {

    public static void main(String[] args) {
        // 创建 StaticListableBeanFactory 实例
        StaticListableBeanFactory beanFactory = new StaticListableBeanFactory();

        // 创建一个具体的产品实例
        MyBean myBean = new MyBean();

        // 将产品实例添加到工厂中,关联一个名称
        beanFactory.addBean("myBeanName", myBean);

        // 从工厂中获取产品实例
        MyBean bean = beanFactory.getBean("myBeanName", MyBean.class);

        // 使用产品
        bean.doSomething();
    }
}

在这个示例中,MyBean 是具体产品,我们创建了它的一个实例,并将其添加到 StaticListableBeanFactory 中。然后,我们可以通过工厂的 getBean 方法来获取这个 bean 并使用它。这个过程展示了工厂模式的典型应用,即通过工厂来封装对象的创建过程,使得客户端代码更加简洁,并且解耦了对象的创建和使用。