Spring 框架基础(02)：Bean的生命周期，作用域，装配总结

本文源码：GitHub·点这里 || GitEE·点这里

一、装配方式

Bean的概念：Spring框架管理的应用程序中，由Spring容器负责创建，装配，设置属性，进而管理整个生命周期的对象，称为Bean对象。

1、XML格式装配

Spring最传统的Bean的管理方式。

  • 配置方式

    <bean id="userInfo" class="com.spring.mvc.entity.UserInfo">
<property name="name" value="cicada" />
</bean>
  • 测试代码 
    ApplicationContext context01 = new ClassPathXmlApplicationContext("/bean-scan-02.xml");
UserInfo userInfo = (UserInfo)context01.getBean("userInfo") ;
System.out.println(userInfo.getName());

2、注解扫描

在实际开发中：通常使用注解 取代 xml配置文件。

  • 常见注解

    @Component <==> <bean class="Class">
@Component("id") <==> <bean id="id" class="Class">
@Repository ：Mvc架构中Dao层Bean的注解
@Service：Mvc架构中Service层Bean的注解
@Controller：Mvc架构中Controller层Bean的注解
  • 使用案例
// 1、注解代码块
@Component("infoService")
public class InfoServiceImpl implements InfoService {
    @Override
    public void printName(String name) {
        System.out.println("Name："+name);
    }
}

// 2、配置代码块
@ComponentScan // 组件扫描注解
public class BeanConfig {

}
  • 测试代码

    @RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(classes = BeanConfig.class)
public class Test01 {
@Autowired
private InfoService infoService ;
@Test
public void test1 (){
    infoService.printName("cicada");
    System.out.println(infoService==infoService);
}
}

3、XML配置扫描

上面使用 ComponentScan 注解，也可在配置文件进行统一的配置，效果相同，还简化代码。

<context:component-scan base-package="com.spring.mvc" />

4、Java代码装配

这种基于Configuration注解，管理Bean的创建，在SpringBoot和SpringCloud的框架中，十分常见。

  • 配置类代码

    @Configuration // 配置类注解
public class UserConfig {
@Bean
public UserInfo userInfo (){
    System.out.println("userInfo...");
    return new UserInfo() ;
}
}
  • 测试代码 
    @RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(classes = UserConfig.class)
public class Test03 {
@Autowired
private UserInfo userInfo ;
@Autowired
private UserInfo userInfo1 ;
@Test
public void test1 (){
    /*
     * userInfo...
     * true
     */
    System.out.println(userInfo==userInfo1);
}
}

二、属性值设置

上面是Bean的装配几种常见方式，下面来看看Bean属性值设置，这里就基于Xml配置的方式。

1、基础类型和集合

  • 配置代码

    <!-- 配置Employee公共属性 -->
<bean id="emp1" class="com.spring.mvc.entity.Employee">
<property name="name" value="cicada" />
<property name="id" value="1" />
</bean>
<bean id="emp2" class="com.spring.mvc.entity.Employee">
<property name="name" value="smile" />
<property name="id" value="2" />
</bean>
<!-- 配置Department属性 -->
<bean id="department" class="com.spring.mvc.entity.Department">
<!-- 普通属性值的注入 -->
<property name="name" value="IT部门" />
<!-- 给数组注入值 -->
<property name="empName">
    <list>
        <value>empName1</value>
        <value>empName2</value>
        <value>empName3</value>
    </list>
</property>
<!-- 给List注入值：可以存放相同的值 -->
<property name="empList">
    <list>
        <ref bean="emp1"/>
        <ref bean="emp2"/>
        <ref bean="emp1"/>
    </list>
</property>
<!-- 配置Set属性，相同的对象会被覆盖 -->
<property name="empSet">
    <set>
        <ref bean="emp1"/>
        <ref bean="emp2"/>
        <ref bean="emp1"/>
    </set>
</property>
<!-- 配置Map属性,key相同的话，后面的值会覆盖前面的 -->
<property name="empMap">
    <map>
        <entry key="1" value-ref="emp1" />
        <entry key="2" value-ref="emp2" />
        <entry key="2" value-ref="emp1" />
    </map>
</property>
<!-- 配置属性集合 -->
<property name="pp">
    <props>
        <prop key="pp1">Hello</prop>
        <prop key="pp2">World</prop>
    </props>
</property>
</bean>
  • 测试代码 
    public class Test05 {
@Test
public void test01 (){
    ApplicationContext context = new ClassPathXmlApplicationContext("/bean-value-03.xml");
    Department department = (Department) context.getBean("department");
    System.out.println(department.getName());
    System.out.println("--------------------->String数组");
    for (String str : department.getEmpName()){
        System.out.println(str);
    }
    System.out.println("--------------------->List集合");
    for (Employee smp : department.getEmpList()){
        System.out.println(smp.getId()+":"+smp.getName());
    }
    System.out.println("--------------------->Set集合");
    for (Employee emp : department.getEmpSet()){
        System.out.println(emp.getId()+":"+emp.getName());
    }
    System.out.println("--------------------->Map集合");
    for (Map.Entry<String, Employee> entry : department.getEmpMap().entrySet()){
        System.out.println(entry.getKey()+":"+entry.getValue().getName());
    }
    System.out.println("--------------------->Properties");
    Properties pp = department.getPp();
    System.out.println(pp.get("pp1"));
    System.out.println(pp.get("pp2"));
}
}

2、配置构造函数

根据配置的参数个数和类型，去映射并加载Bean的构造方法。

  • 配置代码

    <!-- 这里配置2个参数，所有调用2个参数的构造函数 -->
<bean id="employee" class="com.spring.mvc.entity.Employee">
<constructor-arg index="0" type="java.lang.String" value="cicada"/>
<constructor-arg index="1" type="int" value="1"/>
</bean>
  • 测试代码 
    public class Test06 {
@Test
public void test01 (){
    ApplicationContext context = new ClassPathXmlApplicationContext("/bean-value-04.xml");
    Employee employee = (Employee) context.getBean("employee");
    System.out.println(employee.getId()+":"+employee.getName());
}
}

3、配置继承关系

  • 配置代码

    <!-- 配置父类信息 -->
<bean id="student" class="com.spring.mvc.entity.Student">
<property name="name" value="Spring" />
<property name="age" value="22" />
</bean>
<!-- 配置子类信息 -->
<bean id="grade" class="com.spring.mvc.entity.Grade">
<!-- 覆盖 -->
<property name="name" value="Summer" />
<property name="degree" value="大学" />
</bean>
  • 测试代码 
    public class Test07 {
@Test
public void test01 (){
    ApplicationContext context = new ClassPathXmlApplicationContext("/bean-value-05.xml");
    Grade grade = (Grade) context.getBean("grade");
    /* Summer;0;大学  */
    System.out.println(grade.getName()+";"+grade.getAge()+";"+grade.getDegree());
}
}

三、作用域

作用域：用于确定spring创建bean实例个数，比如单例Bean,原型Bean,等等。

类型 说明
singleton IOC容器仅创建一个Bean实例，IOC容器每次返回的是同一个单例Bean实例，默认配置。
prototype IOC容器可以创建多个Bean实例，每次返回的Bean都是新的实例。
request 每次HTTP请求都会创建一个新的Bean，适用于WebApplicationContext环境。
session 同一个HTTP Session共享一个Bean实例。不同HTTP Session使用不同的实例。
global-session 同session作用域不同的是，所有的Session共享一个Bean实例。

四、生命周期

在Spring框架中Bean的生命周期非常复杂，过程大致如下：实例化，属性加载，初始化前后管理，销毁等。下面基于一个案例配置，会更加的清楚。

1、编写BeanLife类

public class BeanLife implements BeanNameAware {
    private String name ;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("设置名称："+name);
        this.name = name;
    }
    @Override
    public void setBeanName(String value) {
        System.out.println("BeanNameAware..SetName："+value);
    }
    public void initBean() {
        System.out.println("初始化Bean..");
    }
    public void destroyBean() {
        System.out.println("销毁Bean..");
    }
    public void useBean() {
        System.out.println("使用Bean..");
    }
    @Override
    public String toString() {
        return "BeanLife [name = " + name + "]";
    }
}

2、定制加载过程

实现BeanPostProcessor接口。

public class BeanLifePostProcessor implements BeanPostProcessor {
    // 初始化之前对bean进行增强处理
    @Override
    public Object postProcessBeforeInitialization(Object obj, String beanName) throws BeansException {
        System.out.println("初始化之前..."+beanName);
        return obj ;
    }
    // 初始化之后对bean进行增强处理
    @Override
    public Object postProcessAfterInitialization(Object obj, String beanName) throws BeansException {
        System.out.println("初始化之后..."+beanName);
        // 改写Bean的名称
        if (obj instanceof BeanLife){
            BeanLife beanLife = (BeanLife)obj ;
            beanLife.setBeanName("myBeanLifeTwo");
            return beanLife ;
        }
        return obj ;
    }
}

3、配置文件

<!-- 加载Bean的处理器 -->
<bean class="com.spring.mvc.BeanLifePostProcessor" />
<!-- 指定初始化和销毁方法 -->
<bean id="beanLife" class="com.spring.mvc.entity.BeanLife"
    init-method="initBean" destroy-method="destroyBean">
    <property name="name" value="myBeanLifeOne" />
</bean>

4、测试过程

  • 测试代码

    public class Test08 {
@Test
public void test01 (){
    ApplicationContext context = new ClassPathXmlApplicationContext("/bean-value-06.xml");
    BeanLife beanLife = (BeanLife) context.getBean("beanLife");
    System.out.println("测试结果BeanLife："+beanLife.getName()) ;
    beanLife.useBean();
    // 关闭容器
    ((AbstractApplicationContext) context).close();
}
}
  • 输出结果 
    1、设置名称：myBeanLifeOne
2、BeanNameAware..SetName：beanLife
3、初始化之前...beanLife
4、初始化Bean..
5、初始化之后...beanLife
6、BeanNameAware..SetName：myBeanLifeTwo
7、测试结果BeanLife：myBeanLifeOne
8、使用Bean..
9、销毁Bean..

    这里梳理Bean的生命周期，过程十分清晰。

五、源代码地址

GitHub·地址
https://github.com/cicadasmile/spring-mvc-parent
GitEE·地址
https://gitee.com/cicadasmile/spring-mvc-parent

原文地址：https://blog.51cto.com/14439672/2446350

时间： 2024-08-26 02:32:57

Spring 框架基础(02)：Bean的生命周期，作用域，装配总结的相关文章

Spring基础14——Bean的生命周期

1.IOC容器中的Bean的生命周期方法 SpringIOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务.SpringIOC容器对Bean的生命周期进行管理的过程: 1)通过构造器或工厂方法创建Bean实例 2)为bean的属性设置值和对其他bean的引用 3)调用Bean的初始化方法 4)Bean可以使用了 5)当容器关闭时,调用Bean的销毁方法 2.验证bean的生命周期 我们可以在Spring的配置文件中声明init-method属性和dest

8、spring注解学习（bean的生命周期）——让Bean实现InitializingBean,DisposableBean这两个接口进而实现初始和销毁方法

1.创建Tiger类实现InitializingBean,DisposableBean接口,并通过@Component将该组件注入 @Component public class Tiger implements InitializingBean,DisposableBean{ public Tiger() { System.out.println("Tiger的构造方法执行了..."); } /** * 此方法就是在调用构造方法之后属性都赋完值就执行 */ @Override pub

MyEclipse Spring 学习总结二 Bean的生命周期

文件结构可以参考上一节 Bean的生命周期有方法有:init-method,destroy-method ApplicationContext.xml 文件配置如下: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/

spring IOC 容器中 Bean 的生命周期

IOC 容器中 Bean 的生命周期: 1.通过构造器或工厂方法创建 Bean 实例2.为 Bean 的属性设置值和对其他 Bean 的引用3.调用 Bean 后置处理器接口(BeanPostProcessor),进行初始化前处理4.调用 Bean 的初始化方法5.调用 Bean 后置处理器接口(BeanPostProcessor),进行初始化后处理6.Bean 可以使用了7.当容器关闭时, 调用 Bean 的销毁方法8.在 Bean 的声明里设置 init-method 和 destroy-m

Spring应用上下文中Bean的生命周期

Bean装载到Spring应用上下文的生命周期,如图: Bean在Spring容器中从创建到销毁经历了若干个阶段,每一阶段都可以对Spring如何管理Bean进行个性化定制,以下我们通过代码去验证生命周期以及个性化定制方法: BeanLife实现Aware接口.InitializingBean.DisposableBean接口,自定义生命周期中的方法. /** * @name Bean生命周期 */ public class BeanLife implements BeanNameAware,B

详解spring——IOC之分析Bean的生命周期

https://www.jianshu.com/p/f968bf1a1892 在分析 Spring Bean 实例化过程中提到 Spring 并不是一启动容器就开启 bean 的实例化进程,只有当客户端通过显示或者隐式的方式调用 BeanFactory 的 getBean() 方法来请求某个实例对象的时候,它才会触发相应 bean 的实例化进程,当然也可以选择直接使用 ApplicationContext 容器,因为该容器启动的时候会立刻调用注册到该容器所有 bean 定义的实例化方法.当然对于

Spring学习笔记3 - Bean的生命周期

当一个bean被实例化时,它可能需要执行一些初始化使它转换成可用状态. 当bean不再需要,并且从容器中移除是,可能需要做一些清除工作. 为了定义安装和拆卸一个bean,我们只要声明带有init-method和/或destroy-method参数 init-method属性指定一个方法,在实例化bean时,立即调用该方法. destroy-method指定一个方法,只有从容器中移除bean之后,才能调用该方法. 示例: beans.xml <?xml version="1.0"

Spring《二》 Bean的生命周期

Bean初始化 1.bean中实现public void init():方法,config.xml中增加init-method="init" 属性. 2.bean实现接口InitializingBean,实现方法afterPropertiesSet,配置文件无需改动. Bean的使用 1. HelloWorld helloWorld=new HelloWorld(); BeanWrapper bw=new BeanWrapperImpl(helloWorld); bw.setPrope

Spring的Bean的生命周期以及Bean的后置处理器

Bean的生命周期: Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务. Spring IOC 容器对 Bean 的生命周期进行管理的过程: 1通过构造器或工厂方法创建 Bean 实例 2为 Bean 的属性设置值和对其他 Bean 的引用 3调用 Bean 的初始化方法(可以人为指定,利用Bean标签的inti-method属性指定初始化方法,不指定就默认忽略这步骤) Bean 可以使用了 4当容器关闭时, 调用 Bea