深入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 {
}

1. 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();
		}
	}

1. 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;
		}
	}

1. 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的构造过程中，他们的子类还会有更多更精细的控制。