在之前的几篇文字中说道容器的概念，实际上Spring也是基于容器的理念，之所以如此成功并不是因为很先进的技术，而是因为理念，其中核心便是IoC(控制反转)，AOP(面向切面编程)，其中IoC是Spring的基础，AOP则是其重要功能，最为典型的是在数据库事务中的展现

SpringIoC(Inversion of Control)

控制反转：这个改变比较抽象，举例说明，假设您想喝一杯豆浆，按以往的方式，您可能是需要买豆子、买豆浆机、准备水，然后用豆浆机做一杯豆浆喝，其实您不得不New一个出来，这是一个主动创造的过程，而现如今的方式可能不是这样了，您可能是打开手机APP，搜一下豆浆，找到合适的然后下单，一会豆浆就上门了，您还是一样可以喝到豆浆，这里边有几个维度对于喝豆浆这个需求而言，两个方式都满足；对于产生豆浆这个结果一个是主动创造，另一个是被动等待店铺创造，过程完全不同，但都满足了需求

对于SpringIoC来说，道理是一样的，以往的思路创建一个对象，都是主动去创建，而在Spring中对象的创建和获取都是依靠描述(XML或者注解)，由IoC容器通过描述的内容进行创建并返回，这就是控制反转的思想

先添加依赖，如下所示

	<dependencies><!-- MyBatis 核心依赖包，提供了ORM框架的主要功能 --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.16</version></dependency><!-- Javaassist，一个用于转换字节码的库，MyBatis使用它来动态生成SQL映射类 --><dependency><groupId>org.javassist</groupId><artifactId>javassist</artifactId><version>3.30.2-GA</version></dependency><!-- CGLib，一个常用的Java代码动态生成库，MyBatis的某些功能（如动态SQL）需要它 --><dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version></dependency><!-- ASM，一个用于Java字节码操作和分析的库，被MyBatis及其他库如CGLib使用 --><dependency><groupId>org.ow2.asm</groupId><artifactId>asm</artifactId><version>9.7</version></dependency><!-- 此部分为slf4j接口及其绑定log4j实现的依赖配置 --><!-- 首先引入slf4j的api接口，用于实现日志抽象 --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>2.0.13</version></dependency><!-- 然后引入log4j作为slf4j的实现 --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>2.0.13</version></dependency><!-- 下面引入log4j的核心库，作为实际的日志记录器实现 --><!-- 这是log4j2的核心库，用于处理日志记录的具体逻辑 --><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.23.1</version></dependency><!-- 引入MySQL连接器的依赖 --><dependency><groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId><version>8.3.0</version></dependency><!-- 引入JUnit测试框架的依赖 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency><!-- 引入Spring框架的核心库 --><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>6.1.6</version></dependency><!-- 引入Spring框架的Beans库，支持Bean的生命周期和装配 --><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>6.1.6</version></dependency><!-- 引入Spring框架的上下文库，提供应用上下文和各种特性的支持 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.1.6</version></dependency><!-- 引入Spring框架的上下文支持库，提供对邮件服务、任务调度和缓存等的支持 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>6.1.6</version></dependency><!-- 引入Spring框架的表达式语言库 --><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>6.1.6</version></dependency><!-- 引入Spring框架的面向切面编程库 --><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>6.1.6</version></dependency>

不考虑具体实现，用代码来描述这个概念，如果是主动创建的话，代码如下：

/*** Blender类用于搅拌食材制作豆浆或豆浆等混合饮品。*/
public class Blender {/*** mix方法用于搅拌指定的水、豆子和糖，生成一杯豆浆。** @param water 水的描述，说明水的来源或类型。* @param bean 豆子的描述，说明使用了哪种豆子。* @param sugar 糖的描述，说明糖的种类或用量。* @return 返回搅拌后生成的豆浆的描述。*/public String mix(String water, String bean, String sugar) {// 组装豆浆的描述信息String SoybeanMilk = "这是一杯由液体：" + water + "\n豆子：" + bean + "\n糖量：" + sugar + "\n组成的豆浆";return SoybeanMilk;}
}

/*** 豆浆制作机类，用于制作豆浆。*/
public class SoybeanMilkMaker {private Blender blender = null; // 豆浆机，用于搅拌食材private String water; // 水描述，制作豆浆需要加水private String bean; // 豆子，制作豆浆的主要原料private String sugar; // 糖分描述，为豆浆添加甜味/*** 制作豆浆的方法。* 使用内部的豆浆机将水、豆子和糖混合制成豆浆。* @return 返回制作好的豆浆。*/public String makeSoybeanMilk() {blender = new Blender(); // 实例化豆浆机return blender.mix(water, bean, sugar); // 使用豆浆机搅拌制作豆浆}/*** 获取豆浆机实例。* @return 返回当前豆浆制作机所使用的豆浆机。*/public Blender getBlender() {return blender;}/*** 设置豆浆机实例。* @param blender 要设置的豆浆机实例。*/public void setBlender(Blender blender) {this.blender = blender;}/*** 获取水的描述。* @return 返回当前使用的水的描述。*/public String getWater() {return water;}/*** 设置水的描述。* @param water 要设置的水的描述。*/public void setWater(String water) {this.water = water;}/*** 获取豆子的描述。* @return 返回当前使用的豆子的描述。*/public String getBean() {return bean;}/*** 设置豆子的描述。* @param bean要设置的豆子的描述。注意：此处参数名应为bean，但可能是个错误，未修改原代码。*/public void setBean(String bean) {this.bean = bean;}/*** 获取糖的描述。* @return 返回当前使用的糖的描述。*/public String getSugar() {return sugar;}/*** 设置糖的描述。* @param sugar 要设置的糖的描述。*/public void setSugar(String sugar) {this.sugar = sugar;}}

/*** 测试制作豆奶的流程。* 该方法演示了如何使用 SoybeanMilkMaker 类来制作豆奶。* 不接受任何参数。* 无返回值，但会将制作的豆奶结果打印到控制台。*/
public static void testSoybeanMilkMaker() {// 创建 SoybeanMilkMaker 实例SoybeanMilkMaker soybeanMilkMaker = new SoybeanMilkMaker();// 设置制作豆奶所需的水、豆子和糖的选项soybeanMilkMaker.setWater("矿泉水");soybeanMilkMaker.setBean("豆子");soybeanMilkMaker.setSugar("少糖");// 打印制作出的豆奶System.out.println(soybeanMilkMaker.makeSoybeanMilk());
}

这里是人主动创造豆浆的办法，需要完成不太熟悉的工作，也就是搅拌豆浆，而搅拌豆浆需要维护豆浆、水、糖、豆子、以及搅拌机之间的依赖关系和具体实现

然而在一个复杂的系统上，会有成千上万种情况，如此维护十分困难，更多的时候我们并不想了解制作豆浆的具体过程，只要结果即可，我们系统通过描述我们要什么，就直接得到结果，者就变成了被动创建豆浆

假设我有如下POJO，是个豆浆制造器，我们只需要像它提供描述就可以得到豆浆

package com.ssm.pojo;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;/*** SoybeanMilkMakerII类实现了多种Spring接口，包括BeanNameAware, BeanFactoryAware,* ApplicationContextAware, InitializingBean，用于展示如何与Spring容器交互。* 这个类模拟了一个豆奶制作机，能够制作豆奶并提供自定义初始化和销毁逻辑。*/
public class SoybeanMilkMakerII implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean{private String beverageShop = null; // 饮品店品牌private Source source = null; // 果汁原料描述// Getter 方法public String getBeverageShop() {return beverageShop;}// Setter 方法，确保参数类型与getter返回类型匹配public void setBeverageShop(String beverageShop) {this.beverageShop = beverageShop;}// Getter methodpublic Source getSource() {return this.source;}// Setter methodpublic void setSource(Source source) {this.source = source;}/*** SoybeanMilkMakerII的构造方法，打印构造信息。*/public SoybeanMilkMakerII() {System.out.println("SoybeanMilkMakerII的构造方法");}/*** 制作豆奶的方法。* @return 返回一杯具有特定品牌、大小、糖分和水果的豆奶描述。*/public String makeSoybeanMilk() {String soybeanMilk = "这是一杯由" + beverageShop + "饮品店，提供的"+ source.getSize() + source.getSugar() + source.getBean();return soybeanMilk;}// setters and getters省略/*** 自定义初始化方法，展示如何在Bean初始化后执行特定逻辑。*/public void init() {System.out.println("【" + this.getClass().getSimpleName() + "】执行自定义初始化方法");}/*** 自定义销毁方法，展示如何在Bean销毁前执行特定逻辑。*/public void destroy() {System.out.println("【" + this.getClass().getSimpleName()  + "】执行自定义销毁方法");}/*** 实现BeanNameAware接口的方法，用于获取Bean的名称。* @param beanName Bean的名称。*/@Overridepublic void setBeanName(String beanName) {System.out.println("【" + this.getClass().getSimpleName() + "】调用BeanNameAware接口的setBeanName方法");}/*** 实现BeanFactoryAware接口的方法，用于获取BeanFactory。* @param bf BeanFactory实例。* @throws BeansException 如果设置过程中发生错误。*/@Overridepublic void setBeanFactory(BeanFactory bf) throws BeansException {System.out.println("【" + this.getClass().getSimpleName() + "】调用BeanFactoryAware接口的setBeanFactory方法");}/*** 实现ApplicationContextAware接口的方法，用于获取ApplicationContext。* @param ctx ApplicationContext实例。* @throws BeansException 如果设置过程中发生错误。*/@Overridepublic void setApplicationContext(ApplicationContext ctx) throws BeansException {System.out.println("【" + this.getClass().getSimpleName()  + "】调用ApplicationContextAware接口的setApplicationContext方法");}/*** 实现InitializingBean接口的方法，用于在所有属性设置完成后执行初始化操作。* @throws Exception 如果初始化过程中发生错误。*/@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("【" + this.getClass().getSimpleName() + "】调用InitializingBean接口的afterPropertiesSet方法");}}

饮品店为我们提供了一个描述，如下代码所示

/*** Source类用于表示饮品的来源信息。*/
public class Source {private String bean; // 饮品的类型private String sugar; // 饮品的糖分描述private String size; // 饮品的大小杯/*** 无参构造方法，用于创建一个新的Source对象。*/public Source() {System.out.println("构造方法.....");}/*** 获取饮品类型。* * @return 返回当前饮品的类型。*/public String getBean() {return bean;}/*** 设置饮品类型。* * @param bean 需要设置的饮品类型。*/public void setBean(String bean) {this.bean = bean;}/*** 获取饮品的糖分描述。* * @return 返回当前饮品的糖分描述。*/public String getSugar() {return sugar;}/*** 设置饮品的糖分描述。* * @param sugar 需要设置的饮品糖分描述。*/public void setSugar(String sugar) {this.sugar = sugar;}/*** 获取饮品的大小杯。* * @return 返回当前饮品的大小杯。*/public String getSize() {return size;}/*** 设置饮品的大小杯。* * @param size 需要设置的饮品大小杯。*/public void setSize(String size) {this.size = size;}
}

然后采用XML对这个清单进行描述信息的注入，在resources路径下的spring-cfg.xml文件中写入

	<bean id="source" class="com.learn.ssm.chapter10.pojo.Source"><property name="bean" value="黑豆" /><property name="sugar" value="少糖" /> <property name="size" value="大杯" /></bean>

接下来是需要选择饮品店，那就要有对饮品店的描述注入，例如选择了贡茶，那么在spring-cfg.xml文件中应该有如下描述

	<bean id="soybeanMilkMakerII"class="com.learn.ssm.chapter10.pojo.SoybeanMilkMakerII" lazy-init="true" init-method="init"destroy-method="destroy"><property name="beverageShop" value="贡茶" /><property name="source" ref="source" /></bean>

如此，利用如下代码便可以得到我们要的豆浆了

    /*** 通过Spring IoC容器初始化豆奶制作器II，然后使用该对象制作豆奶。* 这个方法展示了依赖注入的方式，通过外部配置文件管理对象的创建。*/public static void testSoybeanMilkMakerII() {// 初始化Spring的IoC容器ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring-cfg.xml");// 从容器中获取SoybeanMilkMakerII类型的Bean实例SoybeanMilkMakerII soybeanMilkMakerII = (SoybeanMilkMakerII) ctx.getBean("soybeanMilkMakerII");System.out.println(soybeanMilkMakerII.makeSoybeanMilk());// 关闭Spring的IoC容器ctx.close();}

在这个过程中，指定了贡茶店，制造过程无需操心，只关注描述和选哪家店即可，再来一遍控制反转的概念：控制反转是一种通过描述(Spring中用XML或者注解来提供描述)，并通过IoC容器创建和获取特定对象

再理一下上边的关系，被动创建的豆浆是通过两个xml提供的描述得到的，而在Spring中实现控制反转的是IoC容器，我们只是通过描述告诉IoC容器创建Bean，并且管理Bean；其中还存在一个Source类型的属性，这边是Bean之间的关系，也就是IoC容器还需要管理Bean之间的关系，这层关系通过依赖注入(Dependency Injection, DI)实现，因此就变成了soybeanMilkMakerII的构建需要依赖Source类型的属性，而Source对象也被通过描述提供给了IoC容器，然后IoC容器就会找到Source对象完成构建，是IoC容器主动去找，开发者提供描述

Spring IoC容器

SpringIoC容器设计主要基于BeanFactory和ApplicationContext两个接口，其中BeanFactory是底层接口，ApplicationContext是其子接口之一，做了很多有用的扩展，适用于绝大多数场景

BeanFactory接口源码如下,此接口定义了Spring框架中BeanFactory的核心功能，允许访问和管理Bean实例,详细的看注释即可

package org.springframework.beans.factory;import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;/*** BeanFactory是Spring框架中最重要的接口之一，它提供了获取和管理Bean实例的方法。* 无论是单例Bean还是原型Bean，或者其他作用域的Bean，都可以通过BeanFactory来访问。*/
public interface BeanFactory {String FACTORY_BEAN_PREFIX = "&"; // 用于标识工厂Bean的前缀。/*** 根据Bean的名称获取Bean实例。如果找不到对应的Bean会抛出BeansException。* * @param var1 Bean的名称。* @return 对应的Bean实例。* @throws BeansException 如果获取Bean时发生错误。*/Object getBean(String var1) throws BeansException;/*** 根据Bean的名称和期望类型获取Bean实例。如果找不到对应的Bean会抛出BeansException。* * @param var1 Bean的名称。* @param var2 期望的Bean类型。* @return 对应的Bean实例，类型为<T>。* @throws BeansException 如果获取Bean时发生错误。*/<T> T getBean(String var1, Class<T> var2) throws BeansException;/*** 根据Bean的名称和参数获取Bean实例。如果找不到对应的Bean会抛出BeansException。* * @param var1 Bean的名称。* @param var2 附加参数，可用于特定的Bean实例化需求。* @return 对应的Bean实例。* @throws BeansException 如果获取Bean时发生错误。*/Object getBean(String var1, Object... var2) throws BeansException;/*** 根据期望的类型获取一个Bean实例。如果找不到匹配的Bean会抛出BeansException。* * @param var1 期望的Bean类型。* @return 对应的Bean实例，类型为<T>。* @throws BeansException 如果获取Bean时发生错误。*/<T> T getBean(Class<T> var1) throws BeansException;/*** 根据期望的类型和参数获取一个Bean实例。如果找不到匹配的Bean会抛出BeansException。* * @param var1 期望的Bean类型。* @param var2 附加参数，可用于特定的Bean实例化需求。* @return 对应的Bean实例，类型为<T>。* @throws BeansException 如果获取Bean时发生错误。*/<T> T getBean(Class<T> var1, Object... var2) throws BeansException;/*** 获取指定Bean类型的提供者。* * @param var1 期望的Bean类型。* @return 对应Bean类型的对象提供者。*/<T> ObjectProvider<T> getBeanProvider(Class<T> var1);/*** 根据ResolvableType获取指定Bean类型的提供者。* * @param var1 ResolvableType，用于确定Bean类型。* @return 对应Bean类型的对象提供者。*/<T> ObjectProvider<T> getBeanProvider(ResolvableType var1);/*** 检查是否包含指定名称的Bean。* * @param var1 Bean的名称。* @return 如果包含返回true，否则返回false。*/boolean containsBean(String var1);/*** 检查指定名称的Bean的作用域是否为Singleton。* * @param var1 Bean的名称。* @return 如果是Singleton返回true，否则返回false。* @throws NoSuchBeanDefinitionException 如果没有找到指定的Bean定义。*/boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;/*** 检查指定名称的Bean的作用域是否为Prototype。* * @param var1 Bean的名称。* @return 如果是Prototype返回true，否则返回false。* @throws NoSuchBeanDefinitionException 如果没有找到指定的Bean定义。*/boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;/*** 检查指定名称的Bean是否匹配给定的ResolvableType类型。* * @param var1 Bean的名称。* @param var2 ResolvableType类型。* @return 如果匹配返回true，否则返回false。* @throws NoSuchBeanDefinitionException 如果没有找到指定的Bean定义。*/boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;/*** 检查指定名称的Bean是否匹配给定的Class类型。* * @param var1 Bean的名称。* @param var2 Class类型。* @return 如果匹配返回true，否则返回false。* @throws NoSuchBeanDefinitionException 如果没有找到指定的Bean定义。*/boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;/*** 获取指定Bean名称对应的类型。* * @param var1 Bean的名称。* @return 对应的Class类型。* @throws NoSuchBeanDefinitionException 如果没有找到指定的Bean定义。*/@NullableClass<?> getType(String var1) throws NoSuchBeanDefinitionException;/*** 获取指定Bean名称对应的类型，允许匿名访问。* * @param var1 Bean的名称。* @param var2 是否允许匿名访问。* @return 对应的Class类型。* @throws NoSuchBeanDefinitionException 如果没有找到指定的Bean定义。*/@NullableClass<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;/*** 获取指定Bean的别名数组。* * @param var1 Bean的名称。* @return Bean的别名数组。*/String[] getAliases(String var1);
}

在之前的例子中，用到了ApplicationContext的实现类ClassPathXmlApplicationContext

// 这个类是Spring框架的一部分，提供了从类路径中的XML配置文件启动ApplicationContext的功能。package org.springframework.context.support;import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;/*** ClassPathXmlApplicationContext类继承自AbstractXmlApplicationContext，用于从类路径下的XML配置文件创建ApplicationContext。* 这个类提供了多个构造函数，以支持不同的配置文件定位和加载策略。*/
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {// 存储配置资源的数组@Nullableprivate Resource[] configResources;/*** 无参构造函数，创建一个不带父上下文的ApplicationContext。*/public ClassPathXmlApplicationContext() {}/*** 带父上下文的构造函数。* @param parent 父ApplicationContext。*/public ClassPathXmlApplicationContext(ApplicationContext parent) {super(parent);}/*** 通过指定配置文件位置创建ApplicationContext。* @param configLocation 配置文件的位置。* @throws BeansException 如果初始化过程中出现错误。*/public ClassPathXmlApplicationContext(String configLocation) throws BeansException {this(new String[]{configLocation}, true, (ApplicationContext)null);}/*** 通过指定多个配置文件位置创建ApplicationContext。* @param configLocations 配置文件的位置数组。* @throws BeansException 如果初始化过程中出现错误。*/public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {this(configLocations, true, (ApplicationContext)null);}/*** 通过指定配置文件位置和父上下文创建ApplicationContext。* @param configLocations 配置文件的位置数组。* @param parent 父ApplicationContext。* @throws BeansException 如果初始化过程中出现错误。*/public ClassPathXmlApplicationContext(String[] configLocations, @Nullable ApplicationContext parent) throws BeansException {this(configLocations, true, parent);}/*** 通过指定配置文件位置数组、刷新标志创建ApplicationContext。* @param configLocations 配置文件位置数组。* @param refresh 是否立即刷新上下文。* @throws BeansException 如果初始化过程中出现错误。*/public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {this(configLocations, refresh, (ApplicationContext)null);}/*** 通过指定配置文件位置数组、刷新标志和父上下文创建ApplicationContext。* @param configLocations 配置文件位置数组。* @param refresh 是否立即刷新上下文。* @param parent 父ApplicationContext。* @throws BeansException 如果初始化过程中出现错误。*/public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {super(parent);this.setConfigLocations(configLocations);if (refresh) {this.refresh();}}/*** 通过指定路径和类加载配置文件创建ApplicationContext。* @param path 配置文件路径。* @param clazz 使用该类来定位资源。* @throws BeansException 如果初始化过程中出现错误。*/public ClassPathXmlApplicationContext(String path, Class<?> clazz) throws BeansException {this(new String[]{path}, clazz);}/*** 通过指定路径数组和类加载配置文件创建ApplicationContext。* @param paths 配置文件路径数组。* @param clazz 使用该类来定位资源。* @param parent 父ApplicationContext。* @throws BeansException 如果初始化过程中出现错误。*/public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, @Nullable ApplicationContext parent) throws BeansException {super(parent);Assert.notNull(paths, "Path array must not be null");Assert.notNull(clazz, "Class argument must not be null");this.configResources = new Resource[paths.length];for(int i = 0; i < paths.length; ++i) {this.configResources[i] = new ClassPathResource(paths[i], clazz);}this.refresh();}/*** 获取配置资源的数组。* @return 配置资源的Resource数组，如果未设置则返回null。*/@Nullableprotected Resource[] getConfigResources() {return this.configResources;}
}

ClassPathXmlApplicationContext通过配置文件spring-cfg.xml初始化Spring IoC容器，SpringIoC容器就会根据配置创建Bean了

Spring IoC容器初始化

Spring IoC容器的初始化，可分为两个大步骤，首先是Bean的定义和载入，然后是Spring IoC的初始化，其中Bean定义和载入分为3步，其内容如下：

• Resource定位，在Spring的开发中，通过XML或注解描述资源定位，SpringIoC容器根据开发者的配置，进行资源定位
• BeanDefinition载入，Spring根据开发者提供的配置获取对应的POJO的定义和相关配置
• BeanDefinition注册，将载入的BeanDefinition向SpringIoC容器中注册，然后SpringIoC根据BeanDefinition的内容创建Bean

完成这3步之后，就将BeanDefinition注册到了Spring IoC容器中，但并没有创建和初始化Bean的实例，默认情况下，SpringIoC容器会自动通过BeanDefinition的内容创建Bean实例并完成依赖注入，当然也可以通过一个配置选项lazy-init去改变这步，其含义就是是否延迟初始化Spring Bean，但这个配置选项只有在Bean是单例(singleton)时才有作用，在没有任何配置的情况下为false，也就是Spring IoC容器默认会自动根据BeanDefinition的内容初始化Bean，如果将其设置为true，那么只有当使用Spinrg IoC容器的getBean方法获取它时，才会进行初始化完成依赖注入

Spring Bean生命周期

Spring IoC容器初始化后，Bean被初始化在Spring IoC容器中，所以也有个生命周期，存在一个初始化、存活和销毁的过程；对于一些需要自定义生命周期的Bean，可以插入代码去改变它们的行为，以满足特定的需求，主要是掌握如何在初始化和销毁时加入自定义的方法

如图所示，SpringIoC容器在执行了初始化和依赖注入后，会执行一定的步骤完成初始化，通过这些步骤就能自定义初始化，而在Spring IoC容器正常关闭的时候，也会执行一定的步骤来关闭容器，释放资源

定义一个BeanPostProcessor接口的实现类，如下代码所示：

package com.ssm.bean;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;/*** 自定义BeanPostProcessor实现类，用于在Spring实例化Bean前后进行额外的操作。*/
public class BeanPostProcessorImpl implements BeanPostProcessor {/*** 在Bean初始化之前调用的方法。** @param bean 将要被初始化的Bean实例。* @param beanName Bean的名称。* @return 返回经过可能修改后的Bean实例。* @throws BeansException 如果处理中发生错误。*/@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("【" + bean.getClass().getSimpleName() + "】对象" + beanName + "开始实例化");return bean;}/*** 在Bean初始化之后调用的方法。** @param bean 已经被初始化的Bean实例。* @param beanName Bean的名称。* @return 返回经过可能修改后的Bean实例。* @throws BeansException 如果处理中发生错误。*/@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("【" + bean.getClass().getSimpleName() + "】对象" + beanName + "实例化完成");return bean;}
}

再定义一个DisposableBean接口的实现类

package com.ssm.bean;import org.springframework.beans.factory.DisposableBean;/*** DisposableBeanImpl类实现了DisposableBean接口，* 用于在Spring容器关闭时执行一些必要的清理工作。*/
public class DisposableBeanImpl implements DisposableBean {/*** destroy方法是DisposableBean接口规定的方法，* 用于在bean销毁时执行必要的释放资源操作。** @throws Exception 如果在销毁过程中发生异常，则抛出。*/@Overridepublic void destroy() throws Exception {System.out.println("调用接口DisposableBean的destroy方法");// 在这里可以添加具体的资源释放代码}}

spring-cfg.xml配置文件内容如下所示

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 定义一个BeanPostProcessor的实现类，用于bean创建后的处理 --><bean id="beanPostProcessor" class="com.ssm.bean.BeanPostProcessorImpl" /><!-- 定义一个DisposableBean的实现类，用于bean销毁前的处理 --><bean id="disposableBean" class="com.ssm.bean.DisposableBeanImpl" /><!-- 配置一个具有属性的bean，表示豆浆的原材料配置 --><bean id="source" class="com.ssm.pojo.Source"><property name="bean" value="黑豆" /><property name="sugar" value="少糖" /><property name="size" value="大杯" /></bean><!-- 配置一个延迟初始化的bean，表示豆浆机II，使用了初始化和销毁方法 --><bean id="soybeanMilkMakerII" class="com.ssm.pojo.SoybeanMilkMakerII" lazy-init="true" init-method="init" destroy-method="destroy"><property name="beverageShop" value="贡茶" /><property name="source" ref="source" /></bean>
</beans>

在执行这个代码

    /*** 通过Spring IoC容器初始化豆奶制作器II，然后使用该对象制作豆奶。* 这个方法展示了依赖注入的方式，通过外部配置文件管理对象的创建。*/public static void testSoybeanMilkMakerII() {// 初始化Spring的IoC容器ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring-cfg.xml");// 从容器中获取SoybeanMilkMakerII类型的Bean实例SoybeanMilkMakerII soybeanMilkMakerII = (SoybeanMilkMakerII) ctx.getBean("soybeanMilkMakerII");System.out.println(soybeanMilkMakerII.makeSoybeanMilk());// 关闭Spring的IoC容器ctx.close();}

执行结果如下：

"C:\Program Files\Java\jdk-17.0.1\bin\java.exe" "-javaagent:C:\Users\Administrator\AppData\Local\Programs\IntelliJ IDEA Ultimate\lib\idea_rt.jar=51931:C:\Users\Administrator\AppData\Local\Programs\IntelliJ IDEA Ultimate\bin" -Dfile.encoding=UTF-8 -classpath D:\Programs\Java\ssm-src\ssm\target\classes;C:\Users\Administrator\.m2\repository\org\mybatis\mybatis\3.5.16\mybatis-3.5.16.jar;C:\Users\Administrator\.m2\repository\org\javassist\javassist\3.30.2-GA\javassist-3.30.2-GA.jar;C:\Users\Administrator\.m2\repository\cglib\cglib\3.3.0\cglib-3.3.0.jar;C:\Users\Administrator\.m2\repository\org\ow2\asm\asm\9.7\asm-9.7.jar;C:\Users\Administrator\.m2\repository\org\slf4j\slf4j-api\2.0.13\slf4j-api-2.0.13.jar;C:\Users\Administrator\.m2\repository\org\slf4j\slf4j-reload4j\2.0.13\slf4j-reload4j-2.0.13.jar;C:\Users\Administrator\.m2\repository\ch\qos\reload4j\reload4j\1.2.22\reload4j-1.2.22.jar;C:\Users\Administrator\.m2\repository\org\apache\logging\log4j\log4j-core\2.23.1\log4j-core-2.23.1.jar;C:\Users\Administrator\.m2\repository\org\apache\logging\log4j\log4j-api\2.23.1\log4j-api-2.23.1.jar;C:\Users\Administrator\.m2\repository\com\mysql\mysql-connector-j\8.3.0\mysql-connector-j-8.3.0.jar;C:\Users\Administrator\.m2\repository\com\google\protobuf\protobuf-java\3.25.1\protobuf-java-3.25.1.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-core\6.1.6\spring-core-6.1.6.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-jcl\6.1.6\spring-jcl-6.1.6.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-beans\6.1.6\spring-beans-6.1.6.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-context\6.1.6\spring-context-6.1.6.jar;C:\Users\Administrator\.m2\repository\io\micrometer\micrometer-observation\1.12.5\micrometer-observation-1.12.5.jar;C:\Users\Administrator\.m2\repository\io\micrometer\micrometer-commons\1.12.5\micrometer-commons-1.12.5.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-context-support\6.1.6\spring-context-support-6.1.6.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-expression\6.1.6\spring-expression-6.1.6.jar;C:\Users\Administrator\.m2\repository\org\springframework\spring-aop\6.1.6\spring-aop-6.1.6.jar com.ssm.main.BeanMain
【DisposableBeanImpl】对象disposableBean开始实例化
【DisposableBeanImpl】对象disposableBean实例化完成
构造方法.....
【Source】对象source开始实例化
【Source】对象source实例化完成
SoybeanMilkMakerII的构造方法
【SoybeanMilkMakerII】调用BeanNameAware接口的setBeanName方法
【SoybeanMilkMakerII】调用BeanFactoryAware接口的setBeanFactory方法
【SoybeanMilkMakerII】调用ApplicationContextAware接口的setApplicationContext方法
【SoybeanMilkMakerII】对象soybeanMilkMakerII开始实例化
【SoybeanMilkMakerII】调用InitializingBean接口的afterPropertiesSet方法
【SoybeanMilkMakerII】执行自定义初始化方法
【SoybeanMilkMakerII】对象soybeanMilkMakerII实例化完成
这是一杯由贡茶饮品店，提供的大杯少糖黑豆
【SoybeanMilkMakerII】执行自定义销毁方法
调用接口DisposableBean的destroy方法Process finished with exit code 0

从打印日志中可以看到，BeanPostProcessor针对所有Bean，而DisposableBean针对Spring IoC容器销毁过程，其他的接口只针对单一Bean