前言
上一篇文章讲了如何自定义注解，注解的加载和使用，这篇讲一下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的初始化过程中。
- BeanPostProcessor会嵌入到Bean的初始化前后
- InstantiationAwareBeanPostProcessor继承自BeanPostProcessor,增加了实例化前后等方法
第二个例子就是实现BeanPostProcessor接口，嵌入到Bean的初始化过程中，来完成自定义注入的，完整的例子同样放在Github，第二个例子实现了两种注入模式，第一种是单个字段的注入，用@MyInject注解字段。第二种是使用@FullInject注解，会扫描整理类的所有字段，进行注入。这里主要说明一下@FullInject的实现方法。
- 定义FullInject
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FullInject {
}
- 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();
}
}
- 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;
}
}
- 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的构造过程中，他们的子类还会有更多更精细的控制。
