Spring核心类 - AnnotationConfigApplicationContext

Spring源码走读

1. AnnotationConfigApplicationContext

由Spring3.0引入，用于处理Spring注解。

org.springframework.context.annotation.AnnotationConfigApplicationContext

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
    private final AnnotatedBeanDefinitionReader reader;
    private final ClassPathBeanDefinitionScanner scanner;
    public AnnotationConfigApplicationContext() {
        //创建Bean定义读取器
        this.reader = new AnnotatedBeanDefinitionReader(this);
        //创建Bean定义扫描器
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
    public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
        super(beanFactory);
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
    public AnnotationConfigApplicationContext(Class... annotatedClasses) {
        this();
        this.register(annotatedClasses);
        this.refresh();
    }
    public AnnotationConfigApplicationContext(String... basePackages) {
        this();
        this.scan(basePackages);
        this.refresh();
    }
    public void setEnvironment(ConfigurableEnvironment environment) {
        super.setEnvironment(environment);
        this.reader.setEnvironment(environment);
        this.scanner.setEnvironment(environment);
    }
    public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
        this.reader.setBeanNameGenerator(beanNameGenerator);
        this.scanner.setBeanNameGenerator(beanNameGenerator);
        this.getBeanFactory().registerSingleton("org.springframework.context.annotation.internalConfigurationBeanNameGenerator", beanNameGenerator);
    }
    public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver) {
        this.reader.setScopeMetadataResolver(scopeMetadataResolver);
        this.scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }
    protected void prepareRefresh() {
        this.scanner.clearCache();
        super.prepareRefresh();
    }
    //新注册Bean.需调用refresh()刷新，触发容器对新注册Bean的处理。
    public void register(Class... annotatedClasses) {
        Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
        this.reader.register(annotatedClasses);
    }
    public void scan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        this.scanner.scan(basePackages);
    }
}

2. 解析

• AnnotatedBeanDefinitionReader //注解Bean定义读取器
• ClassPathBeanDefinitionScanner //Bean定义扫描器

2.1 Spring对于类级别注解和类内部注解的处理方式？

• 类级别注解：@Service、@Component、@Repository、@Controller以及J2EE6.0的@ManageBean、@Named等注解。
  
  • Spring容器根据过滤规则扫描读取Bean定义，并注册到容器中.
• 类内部注解：@Autowire、@Value、@Resource等注解。
  
  • Spring容器根据Bean后置注解处理器 解析Bean内部的注解.

2.2 注解Bean定义读取器 AnnotatedBeanDefinitionReader

public class AnnotatedBeanDefinitionReader {
    ......
    public void register(Class<?>... annotatedClasses) {
        for (Class<?> annotatedClass : annotatedClasses) {
            registerBean(annotatedClass);
        }
    }
    public void registerBean(Class<?> annotatedClass) {
        registerBean(annotatedClass, null, (Class<? extends Annotation>[]) null);
    }
    public void registerBean(Class<?> annotatedClass, Class<? extends Annotation>... qualifiers) {
        registerBean(annotatedClass, null, qualifiers);
    }
    public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        if (qualifiers != null) {
            for (Class<? extends Annotation> qualifier : qualifiers) {
                if (Primary.class == qualifier) {
                    abd.setPrimary(true);
                }
                else if (Lazy.class == qualifier) {
                    abd.setLazyInit(true);
                }
                else {
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        //
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }
}

2.3 类路径Bean定义扫描器 ClassPathBeanDefinitionScanner

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
    ...
    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) {
        // 调用父类的构造方法，设置过滤规则  
        super(useDefaultFilters, environment);
        // 为容器设置Bean定义的注册器
        this.registry = registry;
        // 如果注册器是资源加载器，则为容器设置资源加载器
        if (this.registry instanceof ResourceLoader) {
            setResourceLoader((ResourceLoader) this.registry);
        }
    }
    public int scan(String... basePackages) {
        //获取已注册的Bean个数
        int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
        //启动扫描器 扫描指定package
        doScan(basePackages);
        // 注册注解配置处理器
        if (this.includeAnnotationConfig) {
            AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
        }
        //返回新注册的Bean个数
        return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
    }
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        //创建一个集合，存放扫描到Bean定义的封装类  
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
        for (String basePackage : basePackages) {
            //获取符合条件的BeanDefinition
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            for (BeanDefinition candidate : candidates) {
                //获取Bean的作用域
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                //为Bean设置注解配置的作用域
                candidate.setScope(scopeMetadata.getScopeName());
                //为Bean设置名字
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                //【重要】 如果扫描到的不是注解的Bean
                if (candidate instanceof AbstractBeanDefinition) {
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                //【重要】 如果扫描到的是注解的Bean，调用工具类处理通用的注解
                if (candidate instanceof AnnotatedBeanDefinition) {
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }
                //根据Bean名称，检查Bean是否需要在容器中注册。
                if (checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    //根据注解中配置的作用域，为Bean设置相应的代理模式
                    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    //向容器中注册扫描到的Bean
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }
    ....
}

3. 实践：如何实现自定义Spring注解？

1、定制注册表

public class CustomBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(beanDefinitionRegistry);
        // 指定include注解
        AnnotationTypeFilter includeFiliter = new AnnotationTypeFilter(CustomComponent.class);
        scanner.addIncludeFilter(includeFiliter);
        // 指定扫描包
        String[] basePackages = {"win.yulongsun.demo.spring.di.scan"};
        scanner.scan(basePackages);
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
    }
}

2、自定义注解

public @interface CustomComponent {
}

3、使用注解

@CustomComponent
public class Foo {
    public void say() {
        System.out.println("i am class");
    }
}

4、测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {CustomBeanDefinitionRegistry.class})
public class CustomBeanDefinitionRegistryTest {
    @Autowired
    private ApplicationContext applicationContext;
    @Test
    public void testAssertBean() {
        Assert.notNull(applicationContext.getBean(Foo.class));
        Foo bean = applicationContext.getBean(Foo.class);
        bean.say();
    }
}

4. 参考

1、Spring对注解(Annotation)处理源码分析1——扫描和读取Bean定义
2、Spring（25）——ClassPathBeanDefinitionScanner