详解Spring中BeanDefinition的创建过程

最新推荐文章于 2024-04-07 15:47:57 发布

sermonlizhi

最新推荐文章于 2024-04-07 15:47:57 发布

阅读量1.1k

点赞数

分类专栏： Spring的那些事儿文章标签： spring java bean

本文链接：https://blog.csdn.net/sermonlizhi/article/details/120611484

版权

Spring的那些事儿专栏收录该内容

24 篇文章 8 订阅

订阅专栏

Spring容器在创建Bean之前，需要扫描指定包下的文件，然后生成BeanDifinition，下面将介绍Spring是如何进行扫描，然后再生成BeanDifinition

1、scan方法的入参是字符串数组,可以同时指定多个包进行扫描,调用doScan方法来进行扫描

public class ClassPathBeanDefinitionScanner{
	public int scan(String... basePackages) {
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

		doScan(basePackages);

		// Register annotation config processors, if necessary.
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
		}

		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
	}
}

2、调用findCandidateComponents方法，生成BeanDefinition

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		for (String basePackage : basePackages) {

			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            ……
        }
}

findCandidateComponents方法中，Spring支持两种获取类名的方式：

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
    if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
        // 指定的类
        return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
    }
    else {
        // 扫描指定包路径下的所有类
        return scanCandidateComponents(basePackage);
    }
}

在resources/META-INF/spring.components文件中指定

// 类名=注解名
com.lizhi.service.UserService=org.springframework.stereotype.Component

扫描指定包下面的所有类

上面两种方式只是获取类名的方式不同,根据类生成BeanDefinition的逻辑是完全相同的

3、获取指定路径下所有的.class文件

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<>();
    try {
        // 获取basePackage下所有的文件资源
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
        for (Resource resource : resources) {
				if (resource.isReadable()) {
					try {
                        // 元数据读取器
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						// 下面根据类的元数据判断是否可以生成BeanDefinition
                        ……
                    }
                }
        }
        ……
    }
}

Spring提供的元数据读取器可以获取类的元数据，比如类名、类中的方法、类上的注解，元数据读取器的默认实现为SimpleMetadataReader

Spring中元数据读取器解析类时使用的是ASM技术,并不需要将class文件都加载进内存进行解析;JVM规范对class文件的加载是按需加载,不能违背该规范

4、ComponentScan注解可以指定排除过滤器和包含过滤器，根据注册的过滤器判断是否需要生成BeanDefinition

// excludeFilters、includeFilters判断
if (isCandidateComponent(metadataReader)) {
    …………
}

首先判断当前类是否被排除，如果与某个排除过滤器匹配则不能生成BeanDefinition，然后再判断是否能匹配到包含过滤器

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
    for (TypeFilter tf : this.excludeFilters) {
        if (tf.match(metadataReader, getMetadataReaderFactory())) {
            return false;
        }
    }

    // 符合includeFilters的会进行条件匹配，也就是先看有没有@Component，再看是否符合@Conditional
    for (TypeFilter tf : this.includeFilters) {
        if (tf.match(metadataReader, getMetadataReaderFactory())) {
            return isConditionMatch(metadataReader);
        }
    }
    return false;
}

以AnnotationConfigApplicationContext为例,Spring容器在启动的时候,会创建BeanDefinitionScanner扫描器,在创建Scnner的时候会注册一个Component的默认包含过滤器

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean 			        useDefaultFilters, Environment environment, @Nullable ResourceLoader                      resourceLoader) {
    // 注册默认包含过滤器
    if (useDefaultFilters) {
        registerDefaultFilters();
    }
}

protected void registerDefaultFilters() {

    // 注册@Component对应的AnnotationTypeFilter
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
}

5、条件匹配

如果一个类有对应的包含过滤器它可能还不能生成BeanDefinition，还需要判断条件注解是否满足

for (TypeFilter tf : this.includeFilters) {
    if (tf.match(metadataReader, getMetadataReaderFactory())) {
        return isConditionMatch(metadataReader);
    }
}

条件鉴定器根据类上的注解来进行匹配

private boolean isConditionMatch(MetadataReader metadataReader) {
    if (this.conditionEvaluator == null) {
        this.conditionEvaluator =
            new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver);
    }
    // 参数为该类的所有注解
    return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
}

如果没有Conditional注解返回false，isConditionMatch将返回true，如果有Conditional注解则判断是否满足条件

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
        return false;
    }
    …………
}

6、生成BeanDefinition

经过了过滤器和条件鉴定器之后，生成BeanDefinition，这个时候BeanDefinition的beanClass属性是beanClassName，而不是Class对象，因为此时只是扫描，还没进行加载

还需要判断这个BeanDefinition是否可以实例化成一个对象

if (isCandidateComponent(metadataReader)) {
    ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
    sbd.setSource(resource);

    if (isCandidateComponent(sbd)) {
        candidates.add(sbd);
    }
}

下面代码的isIndependent()判断当前类是否是独立的，对于一个普通的内部类来说，编译后它也是一个独立的class文件，但它的实例化依赖顶级类，而顶级类和静态内部类可以直接实例化

isConcrete()判断该类是否是接口或抽象类，接口和抽象类编译后也是一个class文件，但它们都不能进行实例化

如果该类是一个抽象类，但是有Lookup注解定义的方法，那么也可以进行实例化

protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
    AnnotationMetadata metadata = beanDefinition.getMetadata();
    return (metadata.isIndependent() && (metadata.isConcrete() ||
                                         (metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
}

Lookup注解的用途：

@Component(value = "prototype")
public class User {
	
}

@Component
public class UserService {

	@Autowired
	User user;

	public void test() {
		System.out.println(user);
	}

}

上面的代码，虽然User是一个原型Bean，但是每次调用UserService的test()，打印的都是同一个User对象，因为UserService是单例的，但经过下面Lookup注解，就可以得到不同的User对象

@Component
public class UserService {

	@Autowired
	User user;

	public void test() {
		System.out.println(createUser());
	}

	@Lookup("user")
	public User createUser(){
		return null;
	}
}

7、填充扫描生成BeanDefinition的各个属性

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    //扫描生成BeanDefinition
    Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
    for (BeanDefinition candidate : candidates) {
        //填充Scope属性值,如果注解Scope有值,用该值填充
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
        candidate.setScope(scopeMetadata.getScopeName());
		
        //生成beanName
        String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);

        //设置默认值以及是否可以作为依赖注入
        if (candidate instanceof AbstractBeanDefinition) {
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
        }
        if (candidate instanceof AnnotatedBeanDefinition) {
            // 解析@Lazy、@Primary、@DependsOn、@Role、@Description
            AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
        }

        // 检查Spring容器中是否已经存在该beanName
        if (checkCandidate(beanName, candidate)) {
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            definitionHolder =
                AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            beanDefinitions.add(definitionHolder);

            // 注册
            registerBeanDefinition(definitionHolder, this.registry);
        }
    }
    return beanDefinitions;
}

获取beanName

调用AnnotationBeanNameGenerator的generateBeanName()方法来生成beanName，如果是扫描生成的BeanDefinition，则判断注解有没有指定beanName

public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
    if (definition instanceof AnnotatedBeanDefinition) {
        // 获取注解所指定的beanName
        String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
        if (StringUtils.hasText(beanName)) {
            // Explicit bean name found.
            return beanName;
        }
    }
    // Fallback: generate a unique default bean name.
    return buildDefaultBeanName(definition, registry);
}

如果注解没有指定，则调用buildDefaultBeanName()生成默认的beanName

protected String buildDefaultBeanName(BeanDefinition definition) {
    //扫描的时候如果没有指定className,将会抛出异常
    String beanClassName = definition.getBeanClassName();
    Assert.state(beanClassName != null, "No bean class name set");
    String shortClassName = ClassUtils.getShortName(beanClassName);
    return Introspector.decapitalize(shortClassName);
}

如果类名的前两个字符都是大写，则直接将类名作为beanName，否则将类名首字符变成小写后将作为beanName

public static String decapitalize(String name) {
    if (name == null || name.length() == 0) {
        return name;
    }
    if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
        Character.isUpperCase(name.charAt(0))){
        return name;
    }
    char chars[] = name.toCharArray();
    chars[0] = Character.toLowerCase(chars[0]);
    return new String(chars);
}

设置默认值

if (candidate instanceof AbstractBeanDefinition) {
    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}

protected void postProcessBeanDefinition(AbstractBeanDefinition beanDefinition, String beanName) {
    // 设置BeanDefinition的默认值
    beanDefinition.applyDefaults(this.beanDefinitionDefaults);

    // AutowireCandidate表示某个Bean能否被用来做依赖注入
    if (this.autowireCandidatePatterns != null) {
        beanDefinition.setAutowireCandidate(PatternMatchUtils.simpleMatch(this.autowireCandidatePatterns, beanName));
    }
}

设置默认值

public void applyDefaults(BeanDefinitionDefaults defaults) {
    Boolean lazyInit = defaults.getLazyInit();
    if (lazyInit != null) {
        setLazyInit(lazyInit);
    }
    setAutowireMode(defaults.getAutowireMode());
    setDependencyCheck(defaults.getDependencyCheck());
    setInitMethodName(defaults.getInitMethodName());
    setEnforceInitMethod(false);
    setDestroyMethodName(defaults.getDestroyMethodName());
    setEnforceDestroyMethod(false);
}

检查Spring容器是否已经有该beanName

if (checkCandidate(beanName, candidate)) {
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
    definitionHolder =
        AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    beanDefinitions.add(definitionHolder);

    // 注册 --放入到registry的BeanfinitionMap中
    registerBeanDefinition(definitionHolder, this.registry);
}

如果BeanfinitionMap中不存在当前beanName，则返回True，生成一个新的Beanfinition注册到BeanfinitionMap

如果存在beanName，则从BeanfinitionMap中根据beanName取出Beanfinition，与当前的Beanfinition比较，判断是否相等，如果相等说明同一个类被扫描了两次，无需再向BeanfinitionMap中添加，如果不相等，则直接抛出异常

protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {
    if (!this.registry.containsBeanDefinition(beanName)) {
        return true;
    }
    BeanDefinition existingDef = this.registry.getBeanDefinition(beanName);
    BeanDefinition originatingDef = existingDef.getOriginatingBeanDefinition();
    if (originatingDef != null) {
        existingDef = originatingDef;
    }
    // 是否兼容，如果兼容返回false表示不会重新注册到Spring容器中，如果不冲突则会抛异常。
    if (isCompatible(beanDefinition, existingDef)) {
        return false;
    }
    throw new ConflictingBeanDefinitionException("Annotation-specified bean name '" + beanName +
                                                 "' for bean class [" + beanDefinition.getBeanClassName() + "] conflicts with existing, " +
                                                 "non-compatible bean definition of same name and class [" + existingDef.getBeanClassName() + "]");
}

8、spring.components

前面提到过调用findCandidateComponents()生成BeanDefinition的时候，Spring提供了两种方式，前面介绍的方式是扫描整个包路径下的文件，Spring还提供了配置文件的方式，直接在META-INF/spring.components中指定哪些类需要生成Bean

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
	//根据spring.components生成BeanDefinition
    if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
        return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
    }
    else {
        return scanCandidateComponents(basePackage);
    }
}

spring.components文件配置：

// 类名=注解名 结构
com.lizhi.service.UserService=org.springframework.stereotype.Component

在Spring容器启动创建扫描器的时候，ClassPathBeanDefinitionScanner类的ClassPathBeanDefinitionScanner()就会加载spring.components文件信息

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
                                      Environment environment, @Nullable ResourceLoader resourceLoader) {

    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    this.registry = registry;

    if (useDefaultFilters) {
        registerDefaultFilters();
    }
    setEnvironment(environment);
    //加载资源
    setResourceLoader(resourceLoader);
}

public void setResourceLoader(@Nullable ResourceLoader resourceLoader) {
    this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
    this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
    //加载spring.components文件信息
    this.componentsIndex = CandidateComponentsIndexLoader.loadIndex(this.resourcePatternResolver.getClassLoader());
}

扫描spring.components生成的原始数据存放在CandidateComponentsIndex.index中，index是Spring实现的一个MultiValueMap,MultiValueMap的key,可以对应多个value值.index的key为注解名称,value为类名,也就是在spring.components文件中,相同注解的类名存放在一个list里面

addCandidateComponentsFromIndex()实现

extractStereotype()方法获取包含过滤器指定的注解名称，可以是Comopnent注解，也可以是其他注解

private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<>();
    try {
        //类名
        Set<String> types = new HashSet<>();
        for (TypeFilter filter : this.includeFilters) {
            // Component注解
            String stereotype = extractStereotype(filter);
            if (stereotype == null) {
                throw new IllegalArgumentException("Failed to extract stereotype from " + filter);
            }
            types.addAll(index.getCandidateTypes(basePackage, stereotype));
        }
        //后面的代码同全包扫描一样，遍历类名，生成满足条件的BeanDefinition
        ……
}

根据注解的名称从CandidateComponentsIndex中取出与当前包名匹配的类名，放入到types中，types中存放的是类的完整名称(包含路径)

// stereotype=注解名
public Set<String> getCandidateTypes(String basePackage, String stereotype) {
    //根据注解取出所有定义该注解的实体(包含包名和类名)
    List<Entry> candidates = this.index.get(stereotype);
    if (candidates != null) {
        //匹配包名,返回类名的集合
        return candidates.parallelStream()
            .filter(t -> t.match(basePackage))
            .map(t -> t.type)
            .collect(Collectors.toSet());
    }
    return Collections.emptySet();
}

private static class Entry {

    private final String type;

    private final String packageName;
    ……
}

sermonlizhi

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
详解Spring中BeanDefinition的创建过程

Spring容器在创建Bean之前，需要扫描指定包下的文件，然后生成BeanDifinition，下面将介绍Spring是如何进行扫描，然后再生成BeanDifinition1、scan方法的入参是字符串数组,可以同时指定多个包进行扫描,调用doScan方法来进行扫描public class ClassPathBeanDefinitionScanner{ public int scan(String... basePackages) { int beanCountAtScanStart = thi
复制链接

扫一扫