Spring源码分析之@Component注解自动扫描的处理
前言
在项目中使用Spring，我们都会使用它的自动扫描Bean的功能，今天就来分析一下自动扫描的原理。
简单使用
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.stereotype.Component;
import org.springframework.util.ClassUtils;
public class TestComponentScan {
public static void main(String[] args) {
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(
beanFactory, true);
String packageName = ClassUtils.getPackageName(TestComponentScan.class);
scanner.scan(packageName);
UserService userService = (UserService) beanFactory.getBean("userService");
userService.users();
}
@Component("userService")
public static class UserService {
public void users() {
System.out.println("UserService.users()");
}
}
}
使用ClassPathBeanDefinitionScanner(扫描器)来扫描指定package下的Bean，默认会扫描包含@Component注解的Class。
根据扫描到的Class创建BeanDefinition，并注册到BeanFactory中。我们也可以自定义要扫描的条件，如扫描指定的接口的实现类。
import java.util.Map;
import java.util.Map.Entry;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.util.ClassUtils;
public class TestComponentScan2 {
public static void main(String[] args) {
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(
beanFactory, true);
//扫描类型为IService的Class
scanner.addIncludeFilter(new ClassTypeFilter(IService.class));
String packageName = ClassUtils.getPackageName(TestComponentScan2.class);
scanner.scan(packageName);
Map<String, IService> iServiceMap = beanFactory.getBeansOfType(IService.class);
for (Entry<String, IService> entry : iServiceMap.entrySet()) {
System.out.println(entry);
}
}
public static class ClassTypeFilter implements TypeFilter {
private Class<?> targetType;
public ClassTypeFilter(Class<?> targetType) {
this.targetType = targetType;
}
@Override
public boolean match(MetadataReader metadataReader,
MetadataReaderFactory metadataReaderFactory) {
try {
//获取Class
Class<?> aClass = ClassUtils
.forName(metadataReader.getClassMetadata().getClassName(),
ClassUtils.getDefaultClassLoader());
return !metadataReader.getClassMetadata().isInterface() &&
targetType.isAssignableFrom(aClass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return false;
}
}
public interface IService {
}
public static class AddressService {
}
public static class UserService implements IService {
public void users() {
System.out.println("UserService.users()");
}
}
}
扫描接口IService的实现类，只有UserService，不包含AddressService。SpringDataJPA就是通过这种方式来扫描Repository接口的。
源码分析
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
this.registry = registry;
//注册默认类型过滤器，过滤@Component注解
if (useDefaultFilters) {
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(resourceLoader);
}
开始扫描
public int scan(String... basePackages) {
int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
//实际扫描
doScan(basePackages);
//注册一些处理注解相关的BeanPostProcessor
if (this.includeAnnotationConfig) {
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}
查看自动注册了哪些BeanPostProcessor
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
//获取DefaultListableBeanFactory，这个例子中registry的实际类型就是DefaultListableBeanFactory
//如果我们是在ApplicationContext中调用此方法，registry的类型就是ApplicationContext的具体实现类
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
//处理@Value注解的属性注入
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//处理@Configuration注解，@ComponentScan注解，@Bean注解等
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//处理@Autowired注解的属性注入
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
////支持@PostConstruct(Bean初始化)和@PreDestroy(Bean销毁)
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//处理JPA相关注解
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//处理@EventListener注解相关
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
//也是事件监听相关，暂时不管
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}
真正扫描的过程
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
//保存扫描到的所有BeanDefinition
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) {
//扫描指定package下的所有class，根据类型过滤器过滤，根据Class创建BeanDefinition
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
//处理@Scope注解相关
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
//处理@Primary注解，@Lazy注解(是否懒加载)等
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
//@Scope注解可以配置对当前Bean是否创建动态代理
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//将BeanDefinition注册到BeanFactory中
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
继续跟进去findCandidateComponents()方法
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
//componentsIndex不知道是什么情况下使用，暂时不管
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
//真正扫描Class
return scanCandidateComponents(basePackage);
}
}
继续scanCandidateComponents()方法
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
//使用PathMatchingResourcePatternResolver(支持通配符)从classpath下查找所有class文件
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
//实际的查找路径为classpath*:xx/**/*.class
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
for (Resource resource : resources) {
if (resource.isReadable()) {
try {
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//根据类型过滤器判断，如我们自己定义的ClassTypeFilter，其实这里还会根据@Conditional注解来判断，但先不管
if (isCandidateComponent(metadataReader)) {
//创建BeanDefinition
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
//当前Class必须是独立的(非内部类，或者是静态内部类)
if (isCandidateComponent(sbd)) {
candidates.add(sbd);
}
}
}
}
}
}
return candidates;
}
至此就扫描完了，总结起来就是查找到所有的class，根据类型过滤器来过滤，根据class创建BeanDefinition并注册到BeanFactory(实际上是BeanDefinitionRegistry类型)中。
Spring中的使用
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan
public class BeanConfig {
}
我们使用Spring或者SpringBoot的时候，都是通过@ComponentScan注解来开启扫描的，不需要手动创建ClassPathBeanDefinitionScanner对象且调用scan()方法。
总结
@Controller注解，@Service，@Repository，这三个注解都是被@Component注解所标记的，Spring也会扫描到。
