Spring后置处理器之-BeanPostProcessor

Myth丶恋晨 2022-04-18 06:23 265阅读 0赞

**在bean初始化前后进行一些处理工作；**

BeanPostProcessor【interface】：bean的后置处理器；  
               方法postProcessBeforeInitialization（）:在初始化之前工作  
               方法postProcessAfterInitialization（）:在初始化之后工作

--------------------

### \*BeanPostProcessor原理 ###

spring源码中的执行顺序：

\* populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值  
 \* initializeBean  
 \* \{  
 \* applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
 \* invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化  
 \* applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
 \*\}

###  \* Spring底层对 BeanPostProcessor 的使用 ###

bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx;

--------------------

###  一、自定义后置处理器 ###

import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.stereotype.Component;
    
    /**
     * 后置处理器：初始化前后进行处理工作
     * 将后置处理器加入到容器中
     * @author lfy
     */
    @Component
    public class MyBeanPostProcessor implements BeanPostProcessor {
    
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
    		return bean;
    	}
    
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    		// TODO Auto-generated method stub
    		System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
    		return bean;
    	}
    
    }

### 二、定义Bean类 ###

1、Bean实现InitializingBean（定义初始化逻辑）， DisposableBean（定义销毁逻辑）接口

import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Cat implements InitializingBean,DisposableBean {
    	
    	public Cat(){
    		System.out.println("cat constructor...");
    	}
    
    	@Override
    	public void destroy() throws Exception {
    		// TODO Auto-generated method stub
    		System.out.println("cat...destroy...");
    	}
    
    	@Override
    	public void afterPropertiesSet() throws Exception {
    		// TODO Auto-generated method stub
    		System.out.println("cat...afterPropertiesSet...");
    	}
    
    }

2、 自定义init(),destory()方法，@Bean配置@Bean(initMethod="init",destroyMethod="detory")

package com.atguigu.bean;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class Car {
    	
    	public Car(){
    		System.out.println("car constructor...");
    	}
    	
    	public void init(){
    		System.out.println("car ... init...");
    	}
    	
    	public void detory(){
    		System.out.println("car ... detory...");
    	}
    
    }

3、 在初始化方法上面添加：@PostConstruct注解；在销毁方法上面添加： @PreDestroy注解；

import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Dog {
    	
    	public Dog(){
    		System.out.println("dog constructor...");
    	}
    	
    	//对象创建并赋值之后调用
    	@PostConstruct
    	public void init(){
    		System.out.println("Dog....@PostConstruct...");
    	}
    	
    	//容器移除对象之前
    	@PreDestroy
    	public void detory(){
    		System.out.println("Dog....@PreDestroy...");
    	}
    	
    }

### 三、配置类 ###

@ComponentScan("com.atguigu.bean")
    @Configuration
    public class MainConfigOfLifeCycle {
    	
    	//@Scope("prototype")
    	@Bean(initMethod="init",destroyMethod="detory")
    	public Car car(){
    		return new Car();
    	}
    
    }

### 四、测试 ###

import org.junit.Test;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import com.atguigu.config.MainConfigOfLifeCycle;
    
    public class IOCTest_LifeCycle {
    	
    	@Test
    	public void test01(){
    		//1、创建ioc容器
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    		System.out.println("容器创建完成...");
    		
    		//applicationContext.getBean("car");
    		//关闭容器
    		applicationContext.close();
    	}
    
    }

测试结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppbmhhaWppbmc_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppbmhhaWppbmc_size_16_color_FFFFFF_t_70 1][]

**说明**：单例模式下，在容器通过

**【    方法一**、通过@Bean指定init-method和destroy-method；

**       方法二**、通过让Bean实现InitializingBean（定义初始化逻辑）， DisposableBean（定义销毁逻辑）;

**       方法三**、可以使用JSR250；】

定义对象的初始化和销毁方法时，定义了Bean的后置处理器，在Bean初始化前后执行这两个方法。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppbmhhaWppbmc_size_16_color_FFFFFF_t_70]: /images/20220418/e617304dec724b6ca0f18dc2078d88f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppbmhhaWppbmc_size_16_color_FFFFFF_t_70 1]: /images/20220418/6fd85abb0c34442e9f2f076fe6442c53.png