Spring中Bean的作用域和生命周期

目录

Bean的作用域

singleton 

prototype

request

session

application

websocket

单例作用域和全局作用域的区别

Bean的生命周期

---

Bean的作用域

Bean的作用域是指Bean在Spring整个框架中的某种行为模式，比如singleton单例作用域，就表示Bean在整个Spring中只有一份，它是全局共享的，当其他人修改了这个值后，另一个人读取到的就是被修改的值.

Spring容器在初始化一个Bean的实例时，同时会指定该实例的作用域.Spring有六种作用域，最后四种基于Spring MVC生效

· singleton：单例作用域

· prototype：原型作用域

· request：请求作用域

· session：会话作用域

· application：全局作用域

· websocket：HTTP WebSocket作用域

singleton 

该作用域下的Bean在IoC容器中只存在一个实例：获取Bean（即通过applicationContext.getBean等方法获取）及装配Bean（通过@Autowired注入）都是同一个对象。

场景：通常无状态的Bean使用该作用域，无状态表示Bean对象的属性状态不需要更新

Spring默认选择该作用域

prototype

每次对该作用域下的Bean的请求都会创建新的实例：获取Bean（即通过applicationContext.getBean等方法获取）及装配（通过@Autowired注入）都是新的对象实例。

通常有状态的Bean使用该作用域

request

每次HTTP请求都会创建新的Bean实例，类似于prototype

一次http的请求和响应的共享bean，限定在Spring MVC中使用

session

在一个http session中，定义一个Bean实例

用户会话的共享bean，比如记录一个用户的登录信息，限定在Spring MVC中使用

application

在一个http servlet Context中定义一个Bean实例

Web应用的上下文信息，比如记录一个应用的共享信息，限定在Spring MVC中使用

websocket

在一个HTTP WebSocket的生命周期中，定义一个Bean实例

单例作用域和全局作用域的区别

· singleton是Spring Core的作用域；application是Spring MVC中的作用域

· singleton作用于IoC容器，而application作用于Servlet容器

Bean的生命周期

1、实例化Bean（为Bean分配内存空间），类似于new对象

2、设置属性（Bean注入和装配）

3、Bean初始化（表示Bean要初始化很多内容才能使用）

      · 实现了各种Aware通知的方法，如BeanNameAware、BeanFactoryAware、ApplicationContextAware的接口方法；bean实现这些通知接口后，在这个时机就会依次执行Aware通知接口的方法

      · 执行BeanPostProcessor初始化前置方法；BeanPostProcessor接口中的一个方法(XXXbeforeXXX)

       · 执行@PostConstruct初始化方法，依赖注入操作之后被执行；

       · 执行自己制定的init-method方法

       · 执行BeanPostProcessor初始化后置方法；BeanPostProcessor接口中的一个方法(XXXafterXXX)

4、使用Bean

5、销毁Bean

代码示例 

 

LifecycleConfig类

package org.lifecycle.config;
 
import org.lifecycle.model.MyBean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class LifestyleConfig implements BeanPostProcessor {
    //如果MyBean类去掉@Service注解，就需要这么写
    @Bean(initMethod = "myInitMethod", destroyMethod = "destroy2")//initMethod的值，是对象中方法的名称
    public MyBean bean() {
        return new MyBean();
    }
 
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor生命周期初始化前置方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor生命周期初始化后置方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

 MyBean类

package org.lifecycle.model;
 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class MyBean implements BeanNameAware,
        BeanFactoryAware,
        ApplicationContextAware,
        InitializingBean,
        DisposableBean {
 
    public MyBean() {
        System.out.println("Bean对象实例化");
    }
 
    @Override
    public void setBeanName(String s) {
        System.out.println("BeanNameAware生命周期方法");
    }
 
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware生命周期方法");
    }
 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware生命周期方法");
    }
 
    @PostConstruct
    public void init() {
        System.out.println("Bean的初始化方法：@PostConstruct");
    }
 
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Bean的初始化方法：InitializingBean接口实现");
    }
 
    //初始化方法2
    public void myInitMethod() {
        System.out.println("Bean的初始化方法：@Bean(initMethod=本方法名)来制定的初始化");
    }
 
    //销毁方法1
    @PreDestroy
    public void destroy1() {
        System.out.println("Bean的销毁方法，@PreDestroy");
    }
 
    //销毁方法2
    @Override
    public void destroy() throws Exception {
        System.out.println("Bean的销毁方法，DisposableBean接口实现");
    }
 
    //销毁方法3
    public void destroy2() {
        System.out.println("Bean的销毁方法，@Bean(destroyMethod=本方法名)");
    }
}

启动类

package org.lifecycle;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("org.lifecycle");
        //销毁容器，就会执行bean的销毁方法
        context.close();
    }
}

 通过输出结果，可以完整的观察到Bean对象的生命周期