深入Spring:自定义IOC

前言

上一篇文章讲了如何自定义注解，注解的加载和使用，这篇讲一下Spring的IOC过程，并通过自定义注解来实现IOC。

自定义注解

还是先看一下个最简单的例子，源码同样放在了Github。
先定义自己的注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyInject {
}

注入AutowiredAnnotationBeanPostProcessor，并设置自己定义的注解类

@Configuration
public class CustomizeAutowiredTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
        annotationConfigApplicationContext.register(CustomizeAutowiredTest.class);
        annotationConfigApplicationContext.refresh();
        BeanClass beanClass = annotationConfigApplicationContext.getBean(BeanClass.class);
        beanClass.print();
    }
    @Component
    public static class BeanClass {
        @MyInject
        private FieldClass fieldClass;
        public void print() {
            fieldClass.print();
        }
    }
    @Component
    public static class FieldClass {
        public void print() {
            System.out.println("hello world");
        }
    }
    @Bean
    public AutowiredAnnotationBeanPostProcessor getAutowiredAnnotationBeanPostProcessor() {
        AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor = new AutowiredAnnotationBeanPostProcessor();
        autowiredAnnotationBeanPostProcessor.setAutowiredAnnotationType(MyInject.class);
        return autowiredAnnotationBeanPostProcessor;
    }

}

运行代码就会发现被@MyInject修饰的fieldClass被注入进去了。这个功能是借用了Spring内置的AutowiredAnnotationBeanPostProcessor类来实现的。
Spring的IOC主要是通过@Resource，@Autowired和@Inject等注解来实现的，Spring会扫描Bean的类信息，读取并设置带有这些注解的属性。查看Spring的源代码，就会发现其中@Resource是由CommonAnnotationBeanPostProcessor解析并注入的。具体的逻辑是嵌入在代码中的，没法进行定制。
而@Autowired，@Inject是由AutowiredAnnotationBeanPostProcessor解析并注入,观察这个类就会发现，解析注解是放在autowiredAnnotationTypes里面的，所以初始化完成后，调用setAutowiredAnnotationType(MyInject.class) 设置自定义的注解。

    public AutowiredAnnotationBeanPostProcessor() {
        this.autowiredAnnotationTypes.add(Autowired.class);
        this.autowiredAnnotationTypes.add(Value.class);
        try {
            this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
                    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.
        }
    }
    public void setAutowiredAnnotationType(Class<? extends Annotation> autowiredAnnotationType) {
        Assert.notNull(autowiredAnnotationType, "'autowiredAnnotationType' must not be null");
        this.autowiredAnnotationTypes.clear();
        this.autowiredAnnotationTypes.add(autowiredAnnotationType);
    }

同时，这个类实现了InstantiationAwareBeanPostProcessor接口，Spring会在初始化Bean的时候查找实现InstantiationAwareBeanPostProcessor的Bean，并调用接口定义的方法,具体实现的逻辑在AbstractAutowireCapableBeanFactory的populateBean方法中。
AutowiredAnnotationBeanPostProcessor实现了这个接口的postProcessPropertyValues方法。这个方法里，扫描了带有注解的字段和方法，并注入到Bean。

    public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass());
        try {
            metadata.inject(bean, beanName, pvs);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
        }
        return pvs;
    }

扫描的方法如下

    private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
        LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();
        Class<?> targetClass = clazz;
        do {
            LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>();
            for (Field field : targetClass.getDeclaredFields()) {
                Annotation annotation = findAutowiredAnnotation(field);
                if (annotation != null) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        if (logger.isWarnEnabled()) {
                            logger.warn("Autowired annotation is not supported on static fields: " + field);
                        }
                        continue;
                    }
                    boolean required = determineRequiredStatus(annotation);
                    currElements.add(new AutowiredFieldElement(field, required));
                }
            }
            for (Method method : targetClass.getDeclaredMethods()) {
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                Annotation annotation = BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod) ?
                        findAutowiredAnnotation(bridgedMethod) : findAutowiredAnnotation(method);
                if (annotation != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        if (logger.isWarnEnabled()) {
                            logger.warn("Autowired annotation is not supported on static methods: " + method);
                        }
                        continue;
                    }
                    if (method.getParameterTypes().length == 0) {
                        if (logger.isWarnEnabled()) {
                            logger.warn("Autowired annotation should be used on methods with actual parameters: " + method);
                        }
                    }
                    boolean required = determineRequiredStatus(annotation);
                    PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method);
                    currElements.add(new AutowiredMethodElement(method, required, pd));
                }
            }
            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        }
        while (targetClass != null && targetClass != Object.class);
        return new InjectionMetadata(clazz, elements);
    }

注入的方法在AutowiredMethodElement和AutowiredFieldElement的inject()方法中。

自定义注解注入

AutowiredAnnotationBeanPostProcessor是利用特定的接口来实现依赖注入的。所以自定义的注解注入，也可以通过实现相应的接口来嵌入到Bean的初始化过程中。

1. BeanPostProcessor会嵌入到Bean的初始化前后
2. InstantiationAwareBeanPostProcessor继承自BeanPostProcessor,增加了实例化前后等方法

第二个例子就是实现BeanPostProcessor接口，嵌入到Bean的初始化过程中，来完成自定义注入的，完整的例子同样放在Github，第二个例子实现了两种注入模式，第一种是单个字段的注入，用@MyInject注解字段。第二种是使用@FullInject注解，会扫描整理类的所有字段，进行注入。这里主要说明一下@FullInject的实现方法。

1. 定义FullInject

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FullInject {
}

2. JavaBean

    public static class FullInjectSuperBeanClass {
        private FieldClass superFieldClass;
        public void superPrint() {
            superFieldClass.print();
        }
    }
    @Component
    @FullInject
    public static class FullInjectBeanClass extends FullInjectSuperBeanClass {
        private FieldClass fieldClass;
        public void print() {
            fieldClass.print();
        }
    }

3. BeanPostProcessor的实现类

    @Component
    public static class MyInjectBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {
        private ApplicationContext applicationContext;
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if (hasAnnotation(bean.getClass().getAnnotations(), FullInject.class.getName())) {
                Class beanClass = bean.getClass();
                do {
                    Field[] fields = beanClass.getDeclaredFields();
                    for (Field field : fields) {
                        setField(bean, field);
                    }
                } while ((beanClass = beanClass.getSuperclass()) != null);
            } else {
                processMyInject(bean);
            }
            return bean;
        }
        private void processMyInject(Object bean) {
            Class beanClass = bean.getClass();
            do {
                Field[] fields = beanClass.getDeclaredFields();
                for (Field field : fields) {
                    if (!hasAnnotation(field.getAnnotations(), MyInject.class.getName())) {
                        continue;
                    }
                    setField(bean, field);
                }
            } while ((beanClass = beanClass.getSuperclass()) != null);
        }
        private void setField(Object bean, Field field) {
            if (!field.isAccessible()) {
                field.setAccessible(true);
            }
            try {
                field.set(bean, applicationContext.getBean(field.getType()));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        private boolean hasAnnotation(Annotation[] annotations, String annotationName) {
            if (annotations == null) {
                return false;
            }
            for (Annotation annotation : annotations) {
                if (annotation.annotationType().getName().equals(annotationName)) {
                    return true;
                }
            }
            return false;
        }
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            return bean;
        }
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
        }
    }

4. main 方法

@Configuration
public class CustomizeInjectTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
        annotationConfigApplicationContext.register(CustomizeInjectTest.class);
        annotationConfigApplicationContext.refresh();
        FullInjectBeanClass fullInjectBeanClass = annotationConfigApplicationContext.getBean(FullInjectBeanClass.class);
        fullInjectBeanClass.print();
        fullInjectBeanClass.superPrint();
    }
}

这里把处理逻辑放在了postProcessBeforeInitialization方法中，是在Bean实例化完成，初始化之前调用的。这里查找类带有的注解信息，如果带有@FullInject，就查找类的所有字段，并从applicationContext取出对应的bean注入到这些字段中。

结语

Spring提供了很多接口来实现自定义功能，就像这两篇用到的BeanFactoryPostProcessor和BeanPostProcessor，这两个主要是嵌入到BeanFactory和Bean的构造过程中，他们的子类还会有更多更精细的控制。