简识Spring创建Bean方式和设计模式

ops/2025/2/22 19:23:11/

一、理论解释：

Spring在创建Bean时主要有四种方式，这些方式分别涉及到了不同的设计模式。以下是具体的创建方式及对应的设计模式：

  1. 通过反射调用构造方法创建Bean：

    • 方式：在Spring的配置文件中，使用<bean>标签的class属性指定要创建的Bean的完整类名。Spring容器内部会自动调用该类型的无参构造方法（或带参数的构造方法，此时需要配合<constructor-arg>标签指定参数）来创建Bean对象，并将其放在容器中以供使用。
    • 设计模式：这种方式主要使用了简单工厂模式的思想，即通过一个工厂类（在这里是Spring容器）来创建对象，但不需要显式地编写工厂类代码。不过，严格来说，由于Spring容器本身是一个复杂的框架，其内部实现可能涉及到了更多的设计模式，但在此处我们主要关注其对外提供的创建Bean的方式。

  2. 通过静态工厂方法创建Bean：

    • 方式：首先编写一个包含静态方法的工厂类，该方法返回要创建的Bean对象。然后在Spring的配置文件中，使用<bean>标签的class属性指定工厂类的完整类名，并使用factory-method属性指定静态工厂方法名。Spring容器会自动调用该静态方法来获取Bean对象。
    • 设计模式：这种方式明确使用了静态工厂模式。静态工厂模式是一种创建型设计模式，它通过一个包含静态方法的类来创建对象，而不需要将对象作为类的成员。

  3. 通过实例工厂方法创建Bean：

    • 方式：首先编写一个普通的工厂类（非静态），该类包含一个返回要创建的Bean对象的方法。然后在Spring的配置文件中，先使用<bean>标签创建一个工厂类的实例（即工厂Bean），再使用另一个<bean>标签的factory-bean属性指定工厂Bean的ID，并使用factory-method属性指定工厂方法名。Spring容器会先创建工厂Bean实例，然后调用其方法来获取Bean对象。
    • 设计模式：这种方式使用了工厂方法模式。工厂方法模式是一种创建型设计模式，它通过一个工厂类的方法来创建对象，但工厂类本身是一个普通类（非静态类）。

  4. 通过FactoryBean创建Bean：

    • 方式：编写一个实现FactoryBean接口的类，该接口包含三个方法：getObject()用于返回要创建的Bean对象，getObjectType()用于返回Bean对象的类型，isSingleton()用于指定Bean对象是否为单例。然后在Spring的配置文件中，使用<bean>标签的class属性指定FactoryBean实现类的完整类名。Spring容器会自动调用FactoryBean的getObject()方法来获取Bean对象。
    • 设计模式：这种方式虽然表面上看起来与普通的Bean创建方式类似，但实际上它利用了FactoryBean接口的特殊性质来实现了一种更灵活的Bean创建方式。这种方式可以看作是对工厂方法模式的一种扩展或变种，因为它允许在创建Bean对象时进行更多的自定义操作（如延迟加载、代理创建等）。不过，从更广泛的角度来看，它也可以被视为一种代理模式的应用，因为FactoryBean实际上是在为真正的Bean对象创建一个代理或包装器。

综上所述，Spring在创建Bean时主要使用了简单工厂模式（通过反射调用构造方法）、静态工厂模式、工厂方法模式和代理模式（通过FactoryBean）等设计模式。这些模式的应用使得Spring能够灵活地创建和管理Bean对象，从而满足了复杂应用程序的需求。

------分界线--------------------------------------------------------------------------------------------------------------

二、示例代码解释

当然，下面我将根据上面提到的几种创建Bean的方式和对应的设计模式，给出具体的示例代码，并简要说明每个示例以及需要注意的事项。

1. 通过反射调用构造方法创建Bean

示例代码：

java">// 定义一个简单的Bean类
public class MyBean {private String name;// 无参构造方法public MyBean() {}// 带参数的构造方法（虽然在这个例子中未使用，但Spring支持）public MyBean(String name) {this.name = name;}// Getter和Setter方法public String getName() {return name;}public void setName(String name) {this.name = name;}
}// Spring配置文件（applicationContext.xml）
<bean id="myBean" class="com.example.MyBean"/>

说明：

  • 在Spring配置文件中，通过<bean>标签的class属性指定了要创建的Bean类。
  • Spring容器会调用该类的无参构造方法来创建Bean实例。

注意事项：

  • 确保Bean类有一个可访问的无参构造方法。
  • 如果需要注入依赖，可以使用<property>或<constructor-arg>标签。

2. 通过静态工厂方法创建Bean

示例代码：

java">// 静态工厂类
public class MyBeanFactory {// 静态工厂方法public static MyBean createMyBean() {return new MyBean();}
}// Spring配置文件（applicationContext.xml）
<bean id="myBean" class="com.example.MyBeanFactory" factory-method="createMyBean"/>

说明：

  • 在Spring配置文件中，通过<bean>标签的class属性指定了工厂类，并通过factory-method属性指定了静态工厂方法。
  • Spring容器会调用该静态方法来创建Bean实例。

注意事项：

  • 确保工厂方法是静态的。
  • 工厂方法返回的对象类型应与配置文件中声明的Bean类型一致。

3. 通过实例工厂方法创建Bean

示例代码：

java">// 实例工厂类
public class MyInstanceFactory {// 实例工厂方法public MyBean createMyBean() {return new MyBean();}
}// Spring配置文件（applicationContext.xml）
<!-- 首先创建工厂Bean实例 -->
<bean id="myInstanceFactory" class="com.example.MyInstanceFactory"/>
<!-- 然后通过工厂Bean实例创建目标Bean -->
<bean id="myBean" factory-bean="myInstanceFactory" factory-method="createMyBean"/>

说明：

  • 在Spring配置文件中，首先通过<bean>标签创建了一个工厂Bean实例。
  • 然后通过另一个<bean>标签的factory-bean属性指定了工厂Bean的ID，并通过factory-method属性指定了工厂方法。
  • Spring容器会先创建工厂Bean实例，然后调用其方法来创建目标Bean实例。

注意事项：

  • 确保工厂方法是实例方法（非静态）。
  • 工厂Bean实例和目标Bean实例的生命周期是独立的。

4. 通过FactoryBean创建Bean

示例代码：

java">// 实现FactoryBean接口的类
public class MyFactoryBean implements FactoryBean<MyBean> {@Overridepublic MyBean getObject() throws Exception {// 这里可以执行一些自定义逻辑，如创建代理、延迟加载等return new MyBean();}@Overridepublic Class<?> getObjectType() {return MyBean.class;}@Overridepublic boolean isSingleton() {// 指定Bean是否为单例return true;}
}// Spring配置文件（applicationContext.xml）
<bean id="myFactoryBean" class="com.example.MyFactoryBean"/>
// 注意：这里实际上获取的是FactoryBean的getObject()方法返回的对象，而不是FactoryBean本身
// 因此，在获取Bean时，不需要指定FactoryBean的ID，而是直接获取目标Bean的ID（尽管这里我们没有直接定义目标Bean的ID）
// 但由于我们使用了FactoryBean，我们通常不会这样做。在实际应用中，我们可能会通过其他方式（如依赖注入）来使用这个Bean。
// 如果确实需要通过ID获取，可以这样做（但这不是FactoryBean的典型用法）：
// <bean id="myBean" factory-bean="myFactoryBean" factory-method="getObject"/>
// 但通常，我们只需要配置FactoryBean，然后在需要MyBean的地方让Spring自动注入即可。

注意：上面的配置文件中关于myBean的声明是不典型的，因为当你配置了一个FactoryBean后，你通常不会再去显式地通过factory-bean和factory-method去获取它产生的对象。相反，Spring会在你需要注入MyBean类型的地方自动使用MyFactoryBean来产生对象。因此，在实际应用中，你可能不会看到像上面那样的myBean声明。

典型用法：

在需要使用MyBean的地方，你只需声明一个依赖，Spring会自动使用MyFactoryBean来提供这个依赖。例如：

java">@Component
public class SomeService {// Spring会自动注入MyFactoryBean产生的MyBean实例private final MyBean myBean;@Autowiredpublic SomeService(MyBean myBean) {this.myBean = myBean;}// ... 使用myBean的方法 ...
}

在这个例子中，SomeService类依赖于MyBean类型，而Spring会自动使用MyFactoryBean来创建并注入这个依赖。

说明：

  • FactoryBean接口允许你自定义Bean的创建逻辑。
  • getObject()方法返回实际要注入的Bean实例。
  • getObjectType()方法返回Bean实例的类型。
  • isSingleton()方法指定Bean是否为单例。

注意事项：

  • FactoryBean通常用于创建复杂的Bean实例，如代理对象、延迟加载对象等。
  • 确保getObject()方法返回的对象类型与FactoryBean接口中声明的泛型类型一致。
  • 当使用FactoryBean时，通常不需要在配置文件中显式地声明目标Bean的ID，因为Spring会自动处理这部分逻辑。

------分界线--------------------------------------------------------------------------------------------------------------

三、饿汉模式、饱汉模式

在您之前提到的Spring Bean创建方式中，并没有直接包含饿汉模式（Eager Initialization）和饱汉模式（Lazy Initialization）这两种单例模式的实现。饿汉模式和饱汉模式是单例模式在Java中的两种常见实现方式，它们主要用于确保一个类只有一个实例，并提供一个全局访问点来获取该实例。

1、饿汉模式（Eager Initialization）

饿汉模式在类加载时就完成了实例的创建。因此，它是线程安全的，因为JVM在加载类时只会创建一个类实例。但是，如果实例从未被使用过，那么这种提前创建实例的方式可能会浪费资源。

示例代码：

java">public class EagerSingleton {// 在类加载时就创建实例private static final EagerSingleton INSTANCE = new EagerSingleton();// 私有构造方法防止外部实例化private EagerSingleton() {}// 提供全局访问点public static EagerSingleton getInstance() {return INSTANCE;}
}


2、饱汉模式（Lazy Initialization）

饱汉模式在第一次调用getInstance()方法时才创建实例。这种方式节省了资源，但如果多个线程同时调用该方法，则可能会导致多个实例被创建（即不是线程安全的）。为了解决这个问题，通常需要使用同步机制。

示例代码（非线程安全版本）：

java">public class LazySingleton {// 声明实例变量但不立即初始化private static LazySingleton instance;// 私有构造方法防止外部实例化private LazySingleton() {}// 提供全局访问点（非线程安全）public static LazySingleton getInstance() {if (instance == null) {instance = new LazySingleton();}return instance;}
}


示例代码（线程安全版本，使用同步方法）：

java">public class ThreadSafeLazySingleton {// 声明实例变量但不立即初始化private static ThreadSafeLazySingleton instance;// 私有构造方法防止外部实例化private ThreadSafeLazySingleton() {}// 提供全局访问点（线程安全，使用同步方法）public static synchronized ThreadSafeLazySingleton getInstance() {if (instance == null) {instance = new ThreadSafeLazySingleton();}return instance;}
}

或者，使用双重检查锁定（Double-Checked Locking）来优化性能：

java">public class DoubleCheckedLockingSingleton {// 使用volatile关键字确保instance变量的可见性private static volatile DoubleCheckedLockingSingleton instance;// 私有构造方法防止外部实例化private DoubleCheckedLockingSingleton() {}// 提供全局访问点（线程安全，使用双重检查锁定）public static DoubleCheckedLockingSingleton getInstance() {if (instance == null) {synchronized (DoubleCheckedLockingSingleton.class) {if (instance == null) {instance = new DoubleCheckedLockingSingleton();}}}return instance;}
}


3、异同点

  • 相同点：
    • 两者都是单例模式的实现方式。
    • 都提供了全局访问点来获取类的唯一实例。
  • 不同点：
    • 实例创建时机：饿汉模式在类加载时就创建实例，而饱汉模式在第一次调用getInstance()方法时才创建实例。
    • 资源消耗：饿汉模式可能会浪费资源（如果实例从未被使用过），而饱汉模式节省了资源。
    • 线程安全性：饿汉模式是线程安全的（因为实例在类加载时就创建了），而未经同步处理的饱汉模式不是线程安全的（可能会导致多个实例被创建）。但是，通过添加同步机制或使用双重检查锁定，可以使饱汉模式变得线程安全。

在Spring框架中，单例Bean的创建通常是由Spring容器管理的，而不是通过饿汉模式或饱汉模式来实现的。Spring容器负责确保每个单例Bean在容器中只有一个实例，并提供依赖注入机制来访问这些Bean。然而，Spring也支持懒加载（Lazy Initialization），这类似于饱汉模式中的延迟创建实例的概念，但它是通过Spring的配置来实现的，而不是通过单例模式本身的实现方式。

（抱歉，最近在面试，粗糙了些。）

（望各位潘安、各位子健/各位彦祖、于晏不吝赐教！多多指正！🙏）


http://www.ppmy.cn/ops/160579.html

相关文章

深入理解WebSocket接口：如何使用C++实现行情接口

深入理解WebSocket接口：如何使用C++实现行情接口

在现代网络应用中&#xff0c;实时数据传输变得越来越重要。通过WebSocket&#xff0c;我们可以建立一个持久连接&#xff0c;让服务器和客户端之间进行双向通信。这种技术不仅可以提供更快的响应速度&#xff0c;还可以减少不必要的网络流量。本文将详细介绍如何使用C来实现We…
阅读更多...
中文Build a Large Language Model (From Scratch) 免费获取全文

中文Build a Large Language Model (From Scratch) 免费获取全文

中文pdf下载地址&#xff1a;https://pan.baidu.com/s/1aq2aBcWt9vYagT2-HuxdWA?pwdlshj 提取码&#xff1a;lshj 原文、代码、视频项目地址&#xff1a;https://github.com/rasbt/LLMs-from-scratch 翻译工具&#xff1a;沉浸式翻译&#xff08;https://app.immersivetrans…
阅读更多...
DeepSeek、Kimi、文心一言、通义千问：AI 大语言模型的对比分析

DeepSeek、Kimi、文心一言、通义千问：AI 大语言模型的对比分析

在人工智能领域&#xff0c;DeepSeek、Kimi、文心一言和通义千问作为国内领先的 AI 大语言模型&#xff0c;各自展现出了独特的特点和优势。本文将从技术基础、应用场景、用户体验和价格与性价比等方面对这四个模型进行对比分析&#xff0c;帮助您更好地了解它们的特点和优势。…
阅读更多...
量子计算的威胁，以及企业可以采取的措施

量子计算的威胁，以及企业可以采取的措施

当谷歌、IBM、Honeywell和微软等科技巨头纷纷投身量子计算领域时&#xff0c;一场技术军备竞赛已然拉开帷幕。 量子计算虽能为全球数字经济带来巨大价值&#xff0c;但也有可能对相互关联的系统、设备和数据造成损害。这一潜在影响在全球网络安全领域引起了强烈关注。也正因如…
阅读更多...
认识HTML的标签结构

认识HTML的标签结构

一、HTML的基本概念 1.什么是HTML&#xff1f; ①HTML是描述网页的一种标记语言&#xff0c;也被称为超文本标记语言【并不是一种编程语言】 ②HTML包含了HTML标签和文本内容 ③HTML文档也称为web页面 2.HTML的标签 HTML的标签通常成对出现&#xff0c;HTML文档由标签和受…
阅读更多...
MySQL（1）基础篇

MySQL（1）基础篇

执行一条 select 语句&#xff0c;期间发生了什么&#xff1f; | 小林coding 目录 1、连接MySQL服务器 2、查询缓存 3、解析SQL语句 4、执行SQL语句 5、MySQL一行记录的存储结构 Server 层负责建立连接、分析和执行 SQL存储引擎层负责数据的存储和提取。支持InnoDB、MyIS…
阅读更多...
芯谷D2038：高集成度六通道电子音量控制电路的音频解决方案

芯谷D2038：高集成度六通道电子音量控制电路的音频解决方案

在多通道音频系统中&#xff0c;音量控制的便捷性和精准性是提升用户体验的关键。芯谷科技推出的D2038是一款专为六通道音频功放设计的电子音量控制电路&#xff0c;凭借其高集成度和简单易用的特性&#xff0c;成为音频设备设计中的理想选择。 一、D2038的核心特性 1. 高集成…
阅读更多...
【WPS+VBA】表格中重复表头与页码的批量删除

【WPS+VBA】表格中重复表头与页码的批量删除

向豆包对话可以死磕的&#xff0c;以前问问题我只是根据第一条给出的答案使用。AI还有个优点&#xff0c;不会烦你&#xff0c;只要有问题就接着问&#xff0c;一直问到解决好问题。小编对豆包的连环提问&#xff0c;最终解决了批量删表头页面的问题。 1、豆包对话过程 开始问…
阅读更多...
最新文章

Copyright @ 2022~2023