java user周期,一步步剖析spring bean生命周期

摘要：

serDao"id="userDao"scope="singleton"init-method="myInit"destroy-method="myDestroy">

关于spring bean的生命周期，是深入学习spring的基础，也是难点，本篇文章将采用代码+图文结论的方式来阐述spring bean的生命周期，

an生命周期第七环节，通过实现后置处理器BeanPostProcessor获取before和after,该过程是通过AOP方式实现的，在before和after之间，发生如下8，9过程。8.实现Ini

本篇文章将阐述清楚下图。

st(){//定义容器并初始化//ApplicationContextapplicationContext=newClassPathXmlApplicationContext("application

属性赋予值。2.3、线程池配置说明核心线程数：线程池创建时候初始化的线程数。当线程数超过核心线程数，则超过的线程则进入任务队列。最大线程数：只有在任务队列满了之后才会申请超过核心线程数的线程。不能小于

sException{System.out.println("=====调用postProcessBeforeInitialization()=====");returnbean;}publicObj

nc.executor.thread.max_pool_size}")privateintmaxPoolSize;@Value("${async.executor.thread.q

一  项目结构及源码

1.程序目录结构

o.dao;importorg.springframework.beans.BeansException;importorg.springframework.beans.factory.*;impor

2.applicationContext.xml

lApplicationContext("applicationContext.xml");AbstractApplicationContextapplicationContext=newClassP

3.UserDao.java

assExecutorConfig{@Value("${async.executor.thread.core_pool_size}")privateintcorePoolSize;

packagecom.demo.dao;importorg.springframework.beans.BeansException;import org.springframework.beans.factory.*;importorg.springframework.beans.factory.config.BeanPostProcessor;importorg.springframework.context.ApplicationContext;importorg.springframework.context.ApplicationContextAware;importorg.apache.log4j.Logger;public class UserDao implementsBeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean,

DisposableBean{privateString userName;private int count = 0;publicString getUserName() {returnuserName;

}//2.属性注入，注入属性为userName

public voidsetUserName(String userName) {

count++;

System.out.println(count+ "：注入属性userName="+userName);this.userName =userName;

}//1.无参构造函数，实例化时调用该构造函数

publicUserDao() {

count++;

System.out.println(count+ "：调用构造函数UserDao()");

}//3.实现BeanNameAware，获取bean id

public voidsetBeanName(String s) {

count++;

System.out.println(count+ "：调用setBeanName()获取bean id,bean id=" +s);

}//4.实现BeanFactoryAware,获取bean工厂

public void setBeanFactory(BeanFactory beanFactory) throwsBeansException {

count++;

System.out.println(count+ "：调用setBeanFactory()获取bean工厂,beanFactory=" +beanFactory);

}//5.实现ApplicationContextAware,获取bean上下文

public void setApplicationContext(ApplicationContext applicationContext) throwsBeansException {

count++;

System.out.println(count+ "：调用setApplicationContext()获取bean上下文,applicationContext=" +applicationContext);

}//6.实现InitializingBean，获取afterPropertiesSet

public void afterPropertiesSet() throwsException {

count++;

System.out.println(count+ "：调用afterPropertiesSet()");

}//7.自定义初始化方法myInit()

public voidmyInit() {

count++;

System.out.println(count+ "：调用自定义myInit()");

}//8.实现DisposableBean，获取destroy()

public void destroy() throwsException {

count++;

System.out.println(count+ "：destroy()");

}//9.自定义销毁方法myDestroy()

public voidmyDestroy() {

count++;

System.out.println(count+ "：调用自定义destroy()");

}

}

4.MyBeanPostProcessor.java

packagecom.demo.dao;importorg.springframework.beans.BeansException;importorg.springframework.beans.factory.config.BeanPostProcessor;public class MyBeanPostProcessor implementsBeanPostProcessor {public Object postProcessBeforeInitialization(Object bean, String beanName) throwsBeansException {

System.out.println("=====调用postProcessBeforeInitialization()=====");returnbean;

}public Object postProcessAfterInitialization(Object bean, String beanName) throwsBeansException {

System.out.println("=====调用postProcessAfterInitialization()=====");returnbean;

}

}

二  测试代码及测试结果

1.test.java

lt;beanclass="com.demo.dao.MyBeanPostProcessor"id="myBeanPostProcessor"/>3.UserDao.

packagecom.demo.test;importcom.demo.dao.UserDao;importorg.junit.Test;importorg.springframework.context.support.AbstractApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;public classMyTest {

@Testpublic voidtest() {//定义容器并初始化//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

applicationContext.getBean(UserDao.class);//只有关闭容器时，才会调用destroy方法

applicationContext.registerShutdownHook();

}

}

2.测试结果

的高频知识点，今天给大家分享一下使用ThreadPoolTaskExecutor来自定义线程池和实现异步调用多线程。一、ThreadPoolTaskExecutor本文采用Executors的工厂方法

三 分析

缓冲队列中线程的空闲时间async.executor.thread.keep_alive_seconds=1002、Executors的工厂配置2.1、配置详情@Configuration//@Pro

通过如上测试结果，bean生命周期流程大致如下：

)是否已满。如果不满，则创建一条线程去执行任务。如果满了，就按照策略处理无法执行的任务。二、异步调用线程通常ThreadPoolTaskExecutor是和@Async一起使用。在一个方法上添加@As

属性赋予值。2.3、线程池配置说明核心线程数：线程池创建时候初始化的线程数。当线程数超过核心线程数，则超过的线程则进入任务队列。最大线程数：只有在任务队列满了之后才会申请超过核心线程数的线程。不能小于

sException{System.out.println("=====调用postProcessBeforeInitialization()=====");returnbean;}publicObj

nc.executor.thread.max_pool_size}")privateintmaxPoolSize;@Value("${async.executor.thread.q

1.装配bean

olTaskExecutor本文采用Executors的工厂方法进行配置。1、将线程池用到的参数定义到配置文件中在项目的resources目录下创建executor.properties文件，并添加如

bean装配为bean生命周期第一环节。所谓装配bean,指将java对象转换为bean的过程。在该示例中，UserDao.jave和MyBeanPostProcessor通过xml方式转化为bean。

-2)-(8-5)>0，会出现线程拒绝。线程拒绝又分为4种策略，分别为：CallerRunsPolicy()：交由调用方线程运行，比如main线程。AbortPolicy()：直接抛出异常。Di

注意：spring框架支持四种方式装配bean：xml方式，java代码方式，自动装配和混合装配方式

ngbean的生命周期，是深入学习spring的基础，也是难点，本篇文章将采用代码+图文结论的方式来阐述springbean的生命周期，本篇文章将阐述清楚下图。  一 项

2.加载applicationContext.xml并实例化

tProcessorimplementsBeanPostProcessor{publicObjectpostProcessBeforeInitialization(Objectbean,Stringb

加载并实例化bean为bean生命周期的第二环节。本文示例通过ClassPathXmlApplicationContext()来加载并，当bean为singleton时，该过程就实例化对象，而不需要等待

2098469527 一对一技术辅导QQ：2098469527多线程一直是工作或面试过程中的高频知识点，今天给大家分享一下使用ThreadPoolTaskExecutor来自定义线程池和实现

调用applicationContext.getBean()获取bean时才实例化对象，这与prototype是不一样的。

时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。拒绝策略：如果(总任务数-核心线程数-任务队列数)-(最大线程数-核心线程数)>0的话

3.属性注入

下8，9过程。8.实现InitializingBean的afterPropertiesSet(),获取初始化方法该过程为bean生命周期第八环节，通过实现InitializingBean，获取afte

bean属性注入为bean生命周期第三环节，采用反射方式注入bean.

rintln(count+"：destroy()");}//9.自定义销毁方法myDestroy()publicvoidmyDestroy(){count++;System.out.println(c

属性赋予值。2.3、线程池配置说明核心线程数：线程池创建时候初始化的线程数。当线程数超过核心线程数，则超过的线程则进入任务队列。最大线程数：只有在任务队列满了之后才会申请超过核心线程数的线程。不能小于

sException{System.out.println("=====调用postProcessBeforeInitialization()=====");returnbean;}publicObj

nc.executor.thread.max_pool_size}")privateintmaxPoolSize;@Value("${async.executor.thread.q

4.实现BeanNameAware,获取bean id

，而不会再额外地创建线程。举例：如果有20个任务要执行，核心线程数：10，最大线程数：20，任务队列大小：2。则系统会创建18个线程。这18个线程有执行完任务的，再执行任务队列中的任务。线程的空闲时间

该过程为bean生命周期的第四环节，实现该接口，可以获取bean的id

AutowiredprivateThreadTestt;@Testpublicvoidthread1(){for(inti=1;i<=10;i++){t.ceshi4();}}}@Compone

5.实现BeanFactoryAware,获取bean 工厂

onContext.registerShutDownHook()该环节为bean生命周期第十一环节，关闭容器  12.调用DisposableBean的destroy()该过程为b

该过程为bean生命周期第五环节，通过实现BeanFactoryAware获取bean工厂

，则自定义配置文件中的属性值被覆盖，加载的是application.properties文件中的配置属性。@Slf4j：lombok的日志输出工具，加上此注解后，可直接调用log输出各个级别的日志。@

6.实现ApplicationContextAware,获取运用上下文

<=3;i++){log.info("ceshi2");}}}4、测试类@RunWith(SpringRunner.class)@SpringBootTestpubliccl

该过程为bean生命周期第六环节，通过实现ApplicationContextAware接口，获取bean上下文

nt++;System.out.println(count+"：调用afterPropertiesSet()");}//7.自定义初始化方法myInit()publicvoidmyInit(){cou

7.调用Bean后置处理器,before

加载的文件找不到，程序是否忽略它。默认为false。如果为true，则代表加载的配置文件不存在，程序不报错。在实际项目开发中，最好设置为false。如果application.properties文件

该过程为bean生命周期第七环节，通过实现后置处理器BeanPostProcessor获取before和after,该过程是通过AOP方式实现的，在before和after之间，发生如下8，9过程。

异步调用多线程：@RestController@RequestMapping("thread")publicclassListennerTest2{@Autowiredprivat

8.实现InitializingBean的afterPropertiesSet(),获取初始化方法

an生命周期第六环节，通过实现ApplicationContextAware接口，获取bean上下文 7.调用Bean后置处理器,before该过程为bean生命周期第七环节，通过实现后置处

该过程为bean生命周期第八环节，通过实现InitializingBean，获取afterPropertiesSet()

olExecutor.CallerRunsPolicy());//线程初始化executor.initialize();returnexecutor;}}2.2、注解说明@Configuration：

9.调用自定义初始化方法,init-method

hreadTest{@Async("asyncTaskExecutor")publicvoidceshi(){log.info("ceshi");}}3、定义一

该过程为bean生命周期第九环节，实现自定义初始化方法

ount++;System.out.println(count+"：调用setBeanFactory()获取bean工厂,beanFactory="+beanFactory);}//5.实现Appli

10.调用Bean后置处理器after

Prefix);//线程的空闲时间executor.setKeepAliveSeconds(keepAliveSeconds);//拒绝策略executor.setRejectedExecutionH

该过程为bean生命周期第十环节，后置处理器最后环节

.sleep(2000*5);}catch(InterruptedExceptione){e.printStackTrace();}}}}2、程序一启动就异步执行多线程通过继承CommandLineR

11.关闭容器AbstractApplicationContext.registerShutDownHook()

nid,beanid="+s);}//4.实现BeanFactoryAware,获取bean工厂publicvoidsetBeanFactory(BeanFactorybeanFactory)thro

该环节为bean生命周期第十一环节，关闭容器

。3.属性注入bean属性注入为bean生命周期第三环节，采用反射方式注入bean. 4.实现BeanNameAware,获取beanid该过程为bean生命周期的第四环节，实现该接口，可以

12.调用DisposableBean的destroy()

ringframework.context.ApplicationContext;importorg.springframework.context.ApplicationContextAware;i

该过程为bean生命周期第十二环节，实现DisposableBean接口，调用destroy()

c("asyncTaskExecutor")publicvoidceshi3(){for(inti=0;i<=10;i++){log.info("ceshi3:&q

13.调用定制化销毁方法destroy-method

tBean(UserDao.class);//只有关闭容器时，才会调用destroy方法applicationContext.registerShutdownHook();}}2.测试结果

该过程为bean生命周期最后环节，调用自定义销毁方法destroy-method

换为bean的过程。在该示例中，UserDao.jave和MyBeanPostProcessor通过xml方式转化为bean。注意：spring框架支持四种方式装配bean：xml方式，java代码方

三  版权区

转载博客，必须注明博客出处

博主网址：http://www.cnblogs.com/wangjiming/

如您有新想法，欢迎提出，邮箱：[email protected]

专业.NET之家技术QQ群：490539956

专业化Java之家QQ群：924412846

有问必答QQ群：2098469527

一对一技术辅导QQ：2098469527