第五章 spring-connet之bean生命周期与bean监控

时间 2019-11-11

标签第五 spring connet bean 生命周期监控栏目 Spring 繁體版

原文原文链接

前言

javaBean

javaBean是java公共组件的标准。起源于Java GUI的可视化编程实现的，全部的组件都须要支持拖拉，那么全部的组件的行为都是一致的。当拖拉组件的时候，就会建立一个改组件的对象，而后进行参数赋值改变组件的属性。拖拉一个组件等于建立了这个组件的一个对象，在拖拉的时候是没法提供参数的。拖拉以后才能给组件赋值，怎么赋值。java

实例化

实例化那么必须是一个类，不是接口，也不能是抽象类程序员

无条件实例化

拖拉完成才能获得真正的坐标，你们不会拖拉以前就设定属性，而是按照原型图，先拖拉在设定属性。因此实例化在前，属性设置在后。若是定义了有参构造函数，那么须要提供参数才能实例化，等于先设定属性，不符合Java GUI的可视化编程中拖拉的规则。组件必需要有一个无参构造方法，能够无条件实例化。spring

无条件实例化必定有一个无参构造方法，不须要关注其余细节，拉来就可使用。编程

变量私有化

其实这个并非Java GUI的可视化编程里面必须条件，可是由于面向对象设计与面向对象提供封装这个特性，并且变量私有化和封装带来了不少好处，变量私有化成为了javaBean中一个重要的特性app

私有化变量经过get/set方法进行操做

当一个组件有不少属性，多个不一样属性能够组成一个行为，多个属性出现N中排列组合，是否须要各类排列组合的有参构造方法。框架

随着时间的推进，需求发生变化，须要添加一个属性，是否出现大量的新的排列组合，须要修改和添加大量的有参构造方法ide

因此经过get/set的方式，提升了很大的灵活度，扩展度，方便维护函数

若是某个属性不是提供对外负责，只提供本类或者子类，同包使用，不用与数据传递，能够不提供get/set方法。post

总结

Java GUI的可视化编程对组件的定义，对维护，扩展等方面十分友好，很大程度提升了可视化编程效率。等到不少程序员的承认，普及率高，普遍。慢慢成为了javaBean规范。ui

javaBean规范是整个java体系的基石

规范细节

普通类，才能实例化。不是接口，也不是抽象类
无参构造方法。若是没有定义无参构造方法，在没有任何其余有参构造方法的状况下，javac会在class文件中生产无参构造方法。这点是Javabean最重要的特性，是不可缺乏的。
变量私有化
提供变量操做方法get/set, boolean可使用前缀未is
变量与方法的命令按照驼峰命名法

public class userInfo{
	
	private long uiId;
	
	private String uiName;
	
	public void setUiId(long uiId){
	 this.uiId = uiId;
	}
	
	public long getUiId(){
		return this.uiId;
	}
	
	public void setUiName(long uiName){
	 this.uiName = uiName;
	}
	
	public long getUiName(){
		return this.uiName;
	}
}

看看这个类

public class niaocai{

	private  int ctl = 1;
	
}

这样也是一个javabean，只是没有set/get。可是由于ctl只是给本身用的

spring的bean

spring的bean其实就参照的ejb的bean，二者从出发点，实现等基本一致，因此占同称bean。已经有了javaBean，为何还要bean了。在企业需求愈来愈复杂，形成工程愈来愈庞大，复杂，脓肿。现有的javabean没法解决问题。因此提出了依赖注入，反转控制的概念。bean是解决依赖注入，反转控制中。

一个框架实现ioc，那么必须提供一个容器，否者没法实现ioc 有容器了，非容器的bean如何想到容器自己的一些bean

看下面有什么问题

public class Niaocai{

	private Niao niao;
	
	private Cai cai;
	
	private String daSshen;
	
	public Niaocai(){
		init();
	}

	public init(){
		if(niao.getxxx == xxxx && cai.getXXXX ==xxxx){
			daSshen = "dashen"
		}else{
			daSshen = "cainiao"
		}
	}

}

上面是否是在实例化的时候会报错。由于调用init比注入要优选。这个问题怎么解决，你们都给下面的解决方案

public class Niaocai{

	private Niao niao;
	
	private Cai cai;
	
	private String daSshen;
	
	public Niaocai(Niao niao , Cai cai){
		this.niao = niao;
		this.cai  = cai;
		if(niao.getxxx == xxxx && cai.getXXXX ==xxxx){
			daSshen = "dashen"
		}else{
			daSshen = "cainiao"
		}
	}
}

解决了在实例化的时候，回答javabean的定义中，分析了构造方法弊端。因此须要另外的解决方法

public class Niaocai{

	private Niao niao;
	
	private Cai cai;
	
	private String daSshen;
	
	@PostConstruct
	public init(){
		if(niao.getxxx == xxxx && cai.getXXXX ==xxxx){
			daSshen = "dashen"
		}else{
			daSshen = "cainiao"
		}
	}
	... get/set方法
}

Niaocai niaocai = new Niaocai();
niaocai.setNaio(niao);
niaocai.setCai(cai);
niaocai.init();

从上面的代码，分析到依赖注入与Aware接口参数注入以后会调用初始化方法。当初始化方法执行完，才标识这个bean完成。实例化完成只是javabean完成的标识。

真确理解bean的生命周期

实例化
依赖注入
Aware接口参数注入
初始化
销毁

读者会问，bean的生命周期，怎么仅仅有这些啊。不是还有不少接口。深刻了解下什么是生命周期。生命周期是指一个个体的生老病死。那些接口只是对bean进行监控而已。好比单一个生命以前，会进行检测，出生以后会进行户口登记，死亡会注销户口。这些与我的的生命周期没有关系啊。

bean处理体系

bean处理体系是bean最重要的模块之一，本节只是大概，简单让你们了解bean处理系统。在第五章有专门的章节消息的讲述

@Component
public class NiaoCaiBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor ,MergedBeanDefinitionPostProcessor ,DestructionAwareBeanPostProcessor{

    public NiaoCaiBeanPostProcessor() {
		System.out.println("NiaoCaiBeanPostProcessor ");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("BeanPostProcessor.postProcessBeforeInitialization   " +  beanName);
	return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("BeanPostProcessor.postProcessAfterInitialization   "  +  beanName);
	return null;
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		// 返回非null，退出链式执行，只会调用beanProcessor.postProcessAfterInitialization方法
		// 当 beanProcessor.postProcessAfterInitialization方法返回非null  会中止接下来的流程。构造调用，依赖注入，初始化等等都不会执行
		System.out.println("InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation   "  +  beanName);
	return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		// 返回false，退出链式执行，会中止依赖注入
		System.out.println("InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation   " +  beanName);
	return true;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,String beanName) throws BeansException {
		System.out.println("InstantiationAwareBeanPostProcessor.postProcessPropertyValues   " + beanName+ "   pvs : " + pvs.toString() + " pds : " + pds.toString());
	return pvs;
    }

    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		System.out.println("MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition   "  +  beanName);
	
    }

    @Override
    public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
		//System.out.println("SmartInstantiationAwareBeanPostProcessor.predictBeanType   " +    beanName);
		return null;
    }

    @Override
    public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
	System.out.println("SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors  "  +  beanName);
	return null;
    }

    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
		System.out.println("SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference   "  +  beanName);
	return null;
    }

    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
		System.out.println("DestructionAwareBeanPostProcessor.postProcessBeforeDestruction  "  +  beanName);
	
    }

    @Override
    public boolean requiresDestruction(Object bean) {
		System.out.println("DestructionAwareBeanPostProcessor.requiresDestruction  " + bean.toString());
	return true;
    }
}

@Comonent
public class ProcessorObject implements InitializingBean , DisposableBean, BeanNameAware{

   // @Autowired
    private Rely rely;
    
    public ProcessorObject() {
	System.out.println("ProcessorObject structure");
    }

    @PostConstruct
    public void postConstruct(){
	System.out.println("javax.annotation.postConstruct  "  + this.getClass().getName());
    }
    
    @PostConstruct
    public void postConstructTwo(){
	System.out.println("javax.annotation.postConstructTwo  "  + this.getClass().getName());
    }
    
    @PreDestroy
    public void preDestroy(){
	System.out.println("javax.annotation.preDestroy  "  + this.getClass().getName());
    }
    
    @Override
    public void destroy() throws Exception {
	System.out.println("DisposableBean destroy  "  + this.getClass().getName());
	
    }

    @Override
    public void afterPropertiesSet() throws Exception {
	System.out.println("InitializingBean.afterPropertiesSet  "  + this.getClass().getName());
    }

    @Override
    public void setBeanName(String name) {
	System.out.println("BeanNameAware : " + name);
	
    }
    
}

public class BeanPostProcessorTest extends SpringContext{
    
    @Test
    public void beanPostProcessorTest(){
	
	this.application.refresh();
	this.application.close();
    }

}

实例化以前

InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 执行标志着一个对象生命周期的开始

InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation processorObject
SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors processorObject

实例化与实例化以后

执行构造方法，实例化对象 ProcessorObject structure（）
执行MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition processorObject
执行MergedBeanDefinitionPostProcessor.postProcessAfterInstantiation 标识对象实例化操做结束 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation processorObject

参数注入 6. InstantiationAwareBeanPostProcessor.postProcessPropertyValues processorObject pvs : PropertyValues: length=0 pds : 参数注入

基本Awate对象注入，详情请看关于Awate深刻解读章节 BeanNameAware : processorObject

初始化

先执行@PostConstruct javax.annotation.postConstruct com.niaocaia.blog.spring.connet.beanLife.ProcessorObject javax.annotation.postConstructTwo com.niaocaia.blog.spring.connet.beanLife.ProcessorObject
在执行BeanPostProcessor.postProcessBeforeInitialization BeanPostProcessor.postProcessBeforeInitialization processorObject
而后执行InitializingBean的afterPropertiesSet InitializingBean.afterPropertiesSet com.niaocaia.blog.spring.connet.beanLife.ProcessorObject
在执行BeanPostProcessor.postProcessAfterInitialization BeanPostProcessor.postProcessAfterInitialization processorObject
最后执行DestructionAwareBeanPostProcessor.requiresDestruction ，执行以后，才能使用。 DestructionAwareBeanPostProcessor.requiresDestruction com.niaocaia.blog.spring.connet.beanLife.ProcessorObject@769e7ee8

销毁

先执行执行@preDestroy javax.annotation.preDestroy com.niaocaia.blog.spring.connet.beanLife.ProcessorObject

在执行DestructionAwareBeanPostProcessor 对象的postProcessBeforeDestruction DestructionAwareBeanPostProcessor.postProcessBeforeDestruction processorObject

最后执行 DisposableBean接口的destroy实现方法，整个baen生命周期结束 DisposableBean destroy com.niaocaia.blog.spring.connet.beanLife.ProcessorObject

总结

@PostConstruct与@preDestroy的执行优先DisposableBean与InitializingBean
@PostConstruct在BeanPostProcessor.postProcessBeforeInitialization以前执行，而InitializingBean在BeanPostProcessor.postProcessBeforeInitialization以后执行
@preDestroy在DestructionAwareBeanPostProcessor.postProcessBeforeDestruction以前执行，而DisposableBean在DestructionAwareBeanPostProcessor.postProcessBeforeDestruction以后执行
@PostConstruct与@preDestroy在一个类里面，能够标识在多个方法上。