Spring Bean 的生命周期

1.实现了BeanPostProcessor接口，可先看这个接口 ApplicationContext可以在自动检测BeanPostProcessor bean，在它创建完后可以创建任何的bean。

BeanPostProcessor 接口方法

public interface BeanPostProcessor {    /*可以在bean实例化之前调用这个方法，类似init-method,    *这个方法可以对bean进行操作    */    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;    /**可以在bean实例化之后调用这个方法，类似init-method,    *这个方法可以对bean进行操作     */    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;}

自定义的BeanProcessor 实现

public class MyBeanPostProcessor implements BeanPostProcessor {    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        System.out.println("MyBeanPostProcessor before->"+beanName);        return bean;    }    @Override    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        System.out.println("MyBeanPostProcessor after -> "+beanName);        return bean;    }}

spring-beans.xml

运行结果：

MyBeanPostProcessor before->student MyBeanPostProcessor after -> student org.lzyer.test.Student@4d826d77

2.AutowiredAnnotationBeanPostProcessor

BeanPostProcessor的实现类,实现了自动注入属性、方法，可以使用jdk5的注解，默认使用spring的@Autowried和@Value注解。可以在spring配置文件中添加context:annotation-config和context:component-scan来注入AutowiredAnnotationBeanPostProcessor，另外注解的注入在xml配置文件注入之前。

3.spring在哪里注入了BeanPostProcessor

spring容器调用refresh方法中的

// Register bean processors that intercept bean creation.registerBeanPostProcessors(beanFactory);

/**     * Instantiate and invoke all registered BeanPostProcessor beans,     * respecting explicit order if given.     * 
Must be called before any instantiation of application beans.     实例化并注入所有BeanPostProcessor,必须在bean实例化之前调用。     */    protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);    }

4.回归到AutowiredAnnotationBeanPostProcessor

构造方法

public AutowiredAnnotationBeanPostProcessor() {        this.autowiredAnnotationTypes.add(Autowired.class);        this.autowiredAnnotationTypes.add(Value.class);        try {            this.autowiredAnnotationTypes.add((Class
    )                    ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));            logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");        }        catch (ClassNotFoundException ex) {            // JSR-330 API not available - simply skip.        }}

构造方法中初始化注解的类型是@Autowried,@Value以及Annotation的子类

里面包含2个内部类AutowiredFieldElement和AutowiredMethodElement分别处理字段和方法的注解。

先看AutowiredFieldElement中inject方法

protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {            Field field = (Field) this.member;            try {                Object value;                if (this.cached) {//属性有缓存                    value = resolvedCachedArgument(beanName, this.cachedFieldValue);                }                else {                    DependencyDescriptor desc = new DependencyDescriptor(field, this.required);                    desc.setContainingClass(bean.getClass());                    Set
    
      autowiredBeanNames = new LinkedHashSet
     
      (1);                    TypeConverter typeConverter = beanFactory.getTypeConverter();                    value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);                    synchronized (this) {                        if (!this.cached) {//没有缓存                            if (value != null || this.required) {                                this.cachedFieldValue = desc;                                registerDependentBeans(beanName, autowiredBeanNames);//注入依赖                                if (autowiredBeanNames.size() == 1) {                                    String autowiredBeanName = autowiredBeanNames.iterator().next();                                    if (beanFactory.containsBean(autowiredBeanName)) {                                        //对字段进行类型匹配                                        if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {                                            this.cachedFieldValue = new RuntimeBeanReference(autowiredBeanName);                                        }                                    }                                }                            }                            else {                                this.cachedFieldValue = null;                            }                            this.cached = true;                        }                    }                }                if (value != null) {                    ReflectionUtils.makeAccessible(field);                    field.set(bean, value);//反射注入值                }            }            catch (Throwable ex) {                throw new BeanCreationException("Could not autowire field: " + field, ex);            }        }    }
     
    

AutowiredMethodElement的inject方法

protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {            if (checkPropertySkipping(pvs)) {                return;            }            Method method = (Method) this.member;            try {                Object[] arguments;                if (this.cached) {//缓存方法参数                    // Shortcut for avoiding synchronization...                    arguments = resolveCachedArguments(beanName);                }                else {                //获取方法的所有参数                    Class
    [] paramTypes = method.getParameterTypes();                    arguments = new Object[paramTypes.length];                    DependencyDescriptor[] descriptors = new DependencyDescriptor[paramTypes.length];                    Set
    
      autowiredBeanNames = new LinkedHashSet
     
      (paramTypes.length);                    TypeConverter typeConverter = beanFactory.getTypeConverter();                    //参数处理                    for (int i = 0; i < arguments.length; i++) {                        MethodParameter methodParam = new MethodParameter(method, i);                        DependencyDescriptor desc = new DependencyDescriptor(methodParam, this.required);                        desc.setContainingClass(bean.getClass());                        descriptors[i] = desc;                        Object arg = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);                        if (arg == null && !this.required) {                            arguments = null;                            break;                        }                        arguments[i] = arg;                    }                    synchronized (this) {                        if (!this.cached) {                            if (arguments != null) {                                this.cachedMethodArguments = new Object[arguments.length];                                for (int i = 0; i < arguments.length; i++) {                                    this.cachedMethodArguments[i] = descriptors[i];                                }                                registerDependentBeans(beanName, autowiredBeanNames);                                if (autowiredBeanNames.size() == paramTypes.length) {                                    Iterator
      
        it = autowiredBeanNames.iterator();                                    for (int i = 0; i < paramTypes.length; i++) {                                        String autowiredBeanName = it.next();                                        if (beanFactory.containsBean(autowiredBeanName)) {                                            if (beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) {                                                this.cachedMethodArguments[i] = new RuntimeBeanReference(autowiredBeanName);                                            }                                        }                                    }                                }                            }                            else {                                this.cachedMethodArguments = null;                            }                            this.cached = true;                        }                    }                }                if (arguments != null) {                    ReflectionUtils.makeAccessible(method);                    method.invoke(bean, arguments);//反射调用方法                }            }            catch (InvocationTargetException ex) {                throw ex.getTargetException();            }            catch (Throwable ex) {                throw new BeanCreationException("Could not autowire method: " + method, ex);            }        }
      
     
    

查找注解

private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {        for (Class
     type : this.autowiredAnnotationTypes) {            AnnotationAttributes ann = AnnotatedElementUtils.getAnnotationAttributes(ao, type.getName());            if (ann != null) {                return ann;            }        }        return null;    }