Spring 扩展接口 InstantiationAwareBeanPostProcessor 实例化对象处理
上篇文章介绍了spring的后置处理器，然后查了相关资料，发现它还有一个子接口
InstantiationAwareBeanPostProcessor，后置处理器主要负责对象的初始化，因为对象肯定是先要实例化再去初始化，这个类就变得额外的重要了，负责对象的创建。InstantiationAwareBeanPostProcessor的
public Object postProcessBeforeInstantiation(Class aClass, String s)方法，这个方法是这个实例化的核心他决定实例化哪一个，根据我们返回的值，它实例化的对象不同，如果返回的对象它本身，那么会后面的方法初始化会继续初始化它对象本身，如果返回的是一个代理对象，那么后续的实例化方法不会被执行，只会继续执行初始化方法，去初始化这个代理对象。详细的解释再下面的类里面的注释里。这里的代理方式我选用了Cglib的代理方式
基本实现如下：
package com.gysoft.spring.beanpost.proxy;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @Description
* @Author DJZ-WWS
* @Date 2019/4/8 16:02
*/
public class CglibProxy implements MethodInterceptor {
private Object target;
public CglibProxy(Object target) {
this.target = target;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("### before invocation");
Object result = method.invoke(target, objects);
System.out.println("### end invocation");
return result;
}
public static Object getProxy(Object target) {
Enhancer enhancer = new Enhancer();
// 设置需要代理的对象
enhancer.setSuperclass(target.getClass());
// 设置代理人
enhancer.setCallback(new CglibProxy(target));
return enhancer.create();
}
}
这个代理产生类使用起来很简单，
只需要如下操作：
Object proxy = CglibProxy.getProxy(new OneBean());核心代码如下：
依赖的xml配置
基本bean
package com.gysoft.spring.beanpost;
import lombok.Data;
/**
* @Description
* @Author DJZ-WWS
* @Date 2019/5/6 20:52
*/
@Data
public class OneBean {
private String name;
private int age;
private String email;
public OneBean() {
System.out.println("调用了无参构造器");
}
public OneBean(String name) {
this.name = name;
System.out.println("调用了有参构造器");
}
public void doSomeThing(){
System.out.println("OneBean的 doSomeThing方法");
}
}
实例化的接口实现
package com.gysoft.spring.beanpost;
import com.gysoft.spring.beanpost.proxy.CglibProxy;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import java.beans.PropertyDescriptor;
/**
* @Description 这个借口主要作用在于目标对象的实例化过程中需要处理的事情，包括实例化前后过程中以及实例属性的设置
*
* 1、实例化—-实例化的过程是一个创建Bean的过程，即调用Bean的构造函数，单例的Bean放入单例池中
*
* 2、初始化—-初始化的过程是一个赋值的过程，即调用Bean的setter，设置Bean的属性
*
* @Author DJZ-WWS
* @Date 2019/5/7 11:37
*/
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class aClass, String s) throws BeansException {
/**
* 这个方法是最先执行的，它在目标对象实例化之前调用，返回的值是Object，我们可以返回任何类型的值。
* 这个时候目标对象还没有被实例化，所以这个返回值可以用来代替原本该生成的目标对象的实例（比如代理对象）。
* 如果该方法的返回值代替原本该生成的目标对象，后续只有postProcessorAfterInitialization方法会调用，其他方法不会再调用，否则按照正常的流程走
*/
//在这里返回一个代理对象测试 使用cglib代理
/*if(aClass== OneBean.class){
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(aClass);
enhancer.setCallback(new MyMethodInterceptor());
OneBean proxy = (OneBean)enhancer.create();
System.out.print("返回动态代理\n");
return proxy;
}*/
/**
* 当返回的是代理对象的时候，最后获得是代理对象，所以后面的对原本对象的实例化就没有必要执行，后面的对象的初始化就是对代理对象的初始化。
*/
if(aClass==OneBean.class){
Object proxy = CglibProxy.getProxy(new OneBean());
return proxy;
}
System.out.println("实例化之前 postProcessBeforeInstantiation 方法调用"+s);
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object o, String s) throws BeansException {
/**
* 这个方法在目标方法实例化之后调用，这个时候目标对象已经被实例化，但是该实例的属性还没有被设置，都是null.
* 它的返回值是决定要不要调用postProcessValues方法的其中一个因素（因为还有一个因素是mbd.getDependencyCheck())；
* 如果该方法返回false，并且不需要check，那么postProcessPropertyValues就不会被忽略不执行，；如果返回true，postProcessPropertyValues就会被执行
*/
System.out.println("实例化之后 postProcessAfterInstantiation 方法调用"+s);
return false;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues propertyValues, PropertyDescriptor[] propertyDescriptors, Object o, String s) throws BeansException {
/**
* 这个方法对属性值的修改（这个时候属性值没有被设置，但是我们可以修改原本该设置进去的属性值）
* 如果postProcessAfterInstantiation方法返回false,该方法可能不会被调用。可以在该方法内对属性值进行修改
*/
System.out.println("调用 InstantiationAwareBeanPostProcessor 的 postProcessPropertyValues 方法");
return null;
}
@Override
public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
System.out.println("初始化之前 postProcessBeforeInitialization 调用"+s);
return o;
}
@Override
public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
System.out.println("初始化之后 postProcessAfterInitialization 方法调用"+s);
return o;
}
}
测试方法如下：
package com.gysoft.spring.beanpost;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @Description
* @Author DJZ-WWS
* @Date 2019/5/7 14:02
*/
public class InstantionAwaredBeanPostTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("instantionAwareBeanPostProcessor.xml");
// OneBean oneBean = app.getBean("$oneBean", OneBean.class);
OneBean oneBean = app.getBean(OneBean.class);
oneBean.doSomeThing();
System.out.println(oneBean); //由于打印对象的时候会默认走toString方法，所以也会走那个方法拦截器。
}
}
对测试里面的一些关键的东西进行简单说明：
1.
postProcessBeforeInstantiation方法里返回的如果是代理对象那么这个对象就是代理对象，如果是正常返回，那么返回的就是spring管理的正常bean，代理对象也会被spring管理。2.在
oneBean.doSomeThing();里面通过代理对方法进行了增强，3.打印对象的时候发现只要对象一旦被打印就会调用增强的方法，这个问题也困扰了自己一段时间，其实很简单，
MethodInterceptor类似方法拦截器，看名也会看出来，结合结果可知，我推测应该是调用了对象的toString方法。才会有这个效果。结果：
调用了无参构造器
调用了无参构造器
初始化之后 postProcessAfterInitialization 方法调用oneBean
### before invocation
OneBean的 doSomeThing方法
### end invocation
### before invocation
### end invocation
OneBean(name=null, age=0, email=null)
在这里我还有个小小的疑问不是很确定
无参构造器被调用了两次，我在创建代理类的时候是new了一次，这个可以理解，但是多出来一次我始终不是就很理解，我推测可能是在代理里面执行的时候又创建了一次，这个问题不是很确定，有知道的可以告知一下。