0
点赞
收藏
分享

微信扫一扫

互联网轻量级框架整合之SpringIoC概念详解


在之前的几篇文字中说道容器的概念,实际上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 method
    public Source getSource() {
        return this.source;
    }

    // Setter method
    public 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的名称。
     */
    @Override
    public void setBeanName(String beanName) {
        System.out.println("【" + this.getClass().getSimpleName() + "】调用BeanNameAware接口的setBeanName方法");
    }

    /**
     * 实现BeanFactoryAware接口的方法,用于获取BeanFactory。
     * @param bf BeanFactory实例。
     * @throws BeansException 如果设置过程中发生错误。
     */
    @Override
    public void setBeanFactory(BeanFactory bf) throws BeansException {
        System.out.println("【" + this.getClass().getSimpleName() + "】调用BeanFactoryAware接口的setBeanFactory方法");
    }

    /**
     * 实现ApplicationContextAware接口的方法,用于获取ApplicationContext。
     * @param ctx ApplicationContext实例。
     * @throws BeansException 如果设置过程中发生错误。
     */
    @Override
    public void setApplicationContext(ApplicationContext ctx) throws BeansException {
        System.out.println("【" + this.getClass().getSimpleName()  + "】调用ApplicationContextAware接口的setApplicationContext方法");
    }

    /**
     * 实现InitializingBean接口的方法,用于在所有属性设置完成后执行初始化操作。
     * @throws Exception 如果初始化过程中发生错误。
     */
    @Override
    public 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是其子接口之一,做了很多有用的扩展,适用于绝大多数场景

互联网轻量级框架整合之SpringIoC概念详解_spring


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定义。
     */
    @Nullable
    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;

    /**
     * 获取指定Bean名称对应的类型,允许匿名访问。
     * 
     * @param var1 Bean的名称。
     * @param var2 是否允许匿名访问。
     * @return 对应的Class类型。
     * @throws NoSuchBeanDefinitionException 如果没有找到指定的Bean定义。
     */
    @Nullable
    Class<?> 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 {
    // 存储配置资源的数组
    @Nullable
    private 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。
     */
    @Nullable
    protected 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_02


如图所示,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 如果处理中发生错误。
     */
    @Override
    public 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 如果处理中发生错误。
     */
    @Override
    public 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 如果在销毁过程中发生异常,则抛出。
     */
    @Override
    public 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


举报

相关推荐

0 条评论