一、什么是简单工厂模式

简单工厂模式（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 并使用它。这个过程展示了工厂模式的典型应用，即通过工厂来封装对象的创建过程，使得客户端代码更加简洁，并且解耦了对象的创建和使用。