详解Spring中BeanDefinition的创建过程

冷不防 2023-10-02 10:54 12阅读 0赞

*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的默认包含过滤器`

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;
            ……
        }