继上篇postProcessBeanDefinitionRegistry方法的续集
站长
· 阅读数 26
-
-
-
- 看到没它是通过@Import注解将注册类MapperSacnnerRegistrar注册进去了，然后我们进去到
-
-
-
-
-
- 它会去调用registerBeanDefinitons方法对当前的BD进行注册。好的回过头来看，processConfigBeanDefinitions方法
-
-
-
-
-
- 现在明白为什么对于mybatis来说，它的配置类，也可以这么早就被扫描并且注册到spring容器中了嘛。
- 然后真正spring处理@Import注解的时机是在ConfigurationClassParser的doProcessConfigurationClass方法中：
-
-
-
-
-
- 进去看看
-
-
-
-
-
- 然后再processConfigBeanDefinitions方法中调用this.reader.loadBeanDefinitions(configClasses);方法将配置类中的configClass拿出来进注册。
-
-
-
-
-
- 所以总结一下为什么mybatis提供的@MapperScan的注册时机基本和spring的内置bean的执行时机差不多，就是因为该注解上面@Import(MapperScannerRegistrar.class)，然后MapperScannerRegistrar类上面又实现了ImportBeanDefinitionRegistrar，再扫描阶段spring就将@MapperScan中想要扫描的东西扫描进去了。
-
-
- 下面我们说一下spring中对于@Value注解获取到配置文件的是怎么做到的，其实方法还是在这一系列的方法中：
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass,
SourceClass sourceClass,
Predicate<String> filter) throws IOException {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
// 首先递归处理任何成员（嵌套）类
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @PropertySource annotations
// 处理任何@PropertySource注释
Set<AnnotationAttributes> annotationAttributes = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(),
org.springframework.context.annotation.PropertySources.class,
org.springframework.context.annotation.PropertySource.class
);
for (AnnotationAttributes propertySource : annotationAttributes) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info(
"Ignoring @PropertySource annotation on ["
+
sourceClass.getMetadata().getClassName()
+
"]. Reason: Environment must implement ConfigurableEnvironment"
);
}
}
// Process any @ComponentScan annotations 处理任何@ComponentScan注释
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(),
ComponentScans.class,
ComponentScan.class
);
if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately 配置类用 @ComponentScan -> 立即执行扫描进行注释
// 在这里就是将前面实例化好的beanNameGenerator获取到
Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
// 检查扫描的定义集是否有任何进一步的配置类，并在需要时递归解析
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations 处理任何@Import注释
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// Process any @ImportResource annotations 处理任何@ImportResource注释
AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// Process individual @Bean methods 处理单个@Bean方法
// 找到当前的配置类中所有的@Bean方法，获取一个集合beanMethods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
// 并且遍历这个集合
for (MethodMetadata methodMetadata : beanMethods) {
// 将这些标注有@Bean的类包装为一个BeanMethod对象，存入到configClass中，对configClass的beanMethod集合进行填充
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces 处理接口上的默认方法
processInterfaces(configClass, sourceClass);
// Process superclass, if any 进程超类（如果有）
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse 找到超类，返回其注释元数据并递归
return sourceClass.getSuperClass();
}
}
// No superclass -> processing is complete 没有超类 -> 处理完成
return null;
}
- 在这个方法上有处理各种不同类型注解需要处理的对应的方法：
- processMemberClasses：判断如果有@Component注解，则说明该类是一个配置类，调用该方法对他进行递归调用，直到处理到没有子类为止。
- processPropertySource：判断当前源上有@PropertySource或者是@PropertySources这两个注解的话使用该方法对该源上的注解值进行解析，并且读到环境变量中。
- parse：判断如果该源上有@ComponentScans或者@ComponentScan两个注解就会对该源进行解析，调用当前方法对其进行解析，其实也就是调用了扫描方法，将指定的basePages下的类扫描成为beanDefinition。
- processImports：处理任何@Import注释。
- resolveRequiredPlaceholders：处理@ImportResource注解上。
- processInterfaces：处理接口上的默认方法。
- 好的我们现在说回来@PropertySource注解上来，我们进入到第19行的代码的方法看看：
private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
String name = propertySource.getString("name");
if (!StringUtils.hasLength(name)) {
name = null;
}
String encoding = propertySource.getString("encoding");
if (!StringUtils.hasLength(encoding)) {
encoding = null;
}
String[] locations = propertySource.getStringArray("value");
Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");
Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));
for (String location : locations) {
try {
String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
Resource resource = this.resourceLoader.getResource(resolvedLocation);
addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
}
catch (IllegalArgumentException | FileNotFoundException | UnknownHostException | SocketException ex) {
// Placeholders not resolvable or resource not found when trying to open it
if (ignoreResourceNotFound) {
if (logger.isInfoEnabled()) {
logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
}
}
else {
throw ex;
}
}
}
}
- 那我们现在有这样一段代码：
kp.face=equals Wu Yan Zhu
kp.salary=month/5K
@Component
@PropertySource("classpath:application.properties")
public class I {
// 通过自动注入的形式来获取到environment对象
@Autowired
private Environment environment;
private String face;
private String salary;
@Value("${kp.face}")
public void setFace(String face) {
this.face = face;
System.out.println("lkp is face=" + face);
}
@Value("${kp.salary}")
public void setSalary(String salary) {
this.salary = salary;
System.out.println("lkp is salary=" + salary);
}
/**
* 通过环境变量将注入进去的值取出来
**/
public void aa() {
String salary1 = environment.getProperty("kp.salary");
System.out.println("salary: " + salary1);
String face1 = environment.getProperty("kp.face");
System.out.println("face: " + face1);
}
}
public class Application {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(Config.class);
I bean = context.getBean(I.class);
bean.aa();
}
}
- 从上面我们可以看到的是，在spring容器完成实例化之后，我们所指定的配置文件也被读取到spring容器中，并且是在一个environment对象中，通过getProperty()方法来获取对应的值。
- 咱们进到这个getProperty方法中看看：
/**
* Return the property value associated with the given key,
* or {@code null} if the key cannot be resolved.
* @param key the property name to resolve
* @see #getProperty(String, String)
* @see #getProperty(String, Class)
* @see #getRequiredProperty(String)
*/
@Nullable
String getProperty(String key);
@Override
@Nullable
public String getProperty(String key) {
return getProperty(key, String.class, true);
}
@Nullable
protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
if (this.propertySources != null) {
for (PropertySource<?> propertySource : this.propertySources) {
if (logger.isTraceEnabled()) {
logger.trace("Searching for key '" + key + "' in PropertySource '" + propertySource.getName() + "'");
}
Object value = propertySource.getProperty(key);
if (value != null) {
if (resolveNestedPlaceholders && value instanceof String) {
value = resolveNestedPlaceholders((String) value);
}
logKeyFound(key, propertySource, value);
return convertValueIfNecessary(value, targetValueType);
}
}
}
if (logger.isTraceEnabled()) {
logger.trace("Could not find key '" + key + "' in any property source");
}
return null;
}
@Nullable
private final PropertySources propertySources;
public interface PropertySources extends Iterable<PropertySource<?>> {
/**
* Return a sequential {@link Stream} containing the property sources.
* @since 5.1
*/
default Stream<PropertySource<?>> stream() {
return StreamSupport.stream(spliterator(), false);
}
/**
* Return whether a property source with the given name is contained.
* @param name the {@linkplain PropertySource#getName() name of the property source} to find
*/
boolean contains(String name);
/**
* Return the property source with the given name, {@code null} if not found.
* @param name the {@linkplain PropertySource#getName() name of the property source} to find
*/
@Nullable
PropertySource<?> get(String name);
}
- 可以看到在PropertySources类实现了Iterable接口并且指定了泛型为PropertySource，所以该类有迭代器的功能也就是可以对多个PropertySource对象进行迭代遍历。
- 下面我们来断点看看，它是如何从配environment中找到对应的key的。
下面重点来了：
- 在上面通过断点得出的信息来看，在当前的ProperSources中有一个元素为：propertySoureList集合，该集合中有三个元素：
-
- systemProperties(程序运行配置信息)
- systemEnvironment(系统环境配置信息)
- application.properties(这个是我们自己配置spring扫描出来的)
- 我们在细致的看一下上面的三个环境变量中的东西：
- systemProperties(程序运行配置信息)
- systemEnvironment(系统环境配置信息)
- application.properties(这个是我们自己配置spring扫描出来的)
- 说了这么多其实就是你想要通过这种方式来获取到在spring的环境变量中的配置信息，只需要将你的配置信息，丢到MutablePropertySources类中的propertySourceList集合：
可以看到，该类的父类是PropertySources。
- 那我们再走一遍，加载配置文件的流程：
private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
String name = propertySource.getString("name");
if (!StringUtils.hasLength(name)) {
name = null;
}
String encoding = propertySource.getString("encoding");
if (!StringUtils.hasLength(encoding)) {
encoding = null;
}
String[] locations = propertySource.getStringArray("value");
Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");
Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
PropertySourceFactory factory = (
factoryClass == PropertySourceFactory.class ?
DEFAULT_PROPERTY_SOURCE_FACTORY
:
BeanUtils.instantiateClass(factoryClass)
);
for (String location : locations) {
try {
String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
Resource resource = this.resourceLoader.getResource(resolvedLocation);
addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
} catch (IllegalArgumentException | FileNotFoundException | UnknownHostException | SocketException ex) {
// Placeholders not resolvable or resource not found when trying to open it
if (ignoreResourceNotFound) {
if (logger.isInfoEnabled()) {
logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
}
} else {
throw ex;
}
}
}
}
private void addPropertySource(PropertySource<?> propertySource) {
String name = propertySource.getName();
MutablePropertySources propertySources = ((ConfigurableEnvironment) this.environment).getPropertySources();
if (this.propertySourceNames.contains(name)) {
// We've already added a version, we need to extend it
PropertySource<?> existing = propertySources.get(name);
if (existing != null) {
PropertySource<?> newSource = (
propertySource instanceof ResourcePropertySource ?
((ResourcePropertySource) propertySource).withResourceName()
:
propertySource
);
if (existing instanceof CompositePropertySource) {
((CompositePropertySource) existing).addFirstPropertySource(newSource);
} else {
if (existing instanceof ResourcePropertySource) {
existing = ((ResourcePropertySource) existing).withResourceName();
}
CompositePropertySource composite = new CompositePropertySource(name);
composite.addPropertySource(newSource);
composite.addPropertySource(existing);
propertySources.replace(name, composite);
}
return;
}
}
if (this.propertySourceNames.isEmpty()) {
propertySources.addLast(propertySource);
} else {
String firstProcessed = this.propertySourceNames.get(this.propertySourceNames.size() - 1);
propertySources.addBefore(firstProcessed, propertySource);
}
this.propertySourceNames.add(name);
}
- 在第一段代码中通过addPropertySource来解析配置文件，然后再在addPropertySource方法第三行创建一个MutablePropertySources对象
- 到这里spring只是将配置文件的源添加到了当前environment字段的propertySources集合中的propertySourceList集合
- 下面我们要讨论一下前面的systemProperties、systemEnvirpment是啥时候被加入到propertySource中的呢？
- 首先我们要理解的是@Value是一种属性填充，是一种属性注入，所以对于@Value中对于配置文件中的取值其实也就是属性赋值，那么和我们平时所见到的Bean的自动注入道理是一样的，都是初始化bean的时候将bean的属性填充。
- 整体的大致逻辑就是先将读取到资源文件，转换为一个PropertySource对象，然后再通过，getProperty()方法通过key将对应value获取到，并且这里要说一点的是，在spring中有systemProperties、systemEnvironment、这两个的配置级别要比我们自己外部配置的级别高，所以如果说你要配置文件上编写的配置名不能和系统配置名相冲突不然的话你会发现，无论你怎么改，都会拿到和你预期不一样的值，这里再提一下就是通过getProperty()方法获取对应的key的value的话，由于有先后顺序，所以如果在上次有对应的key并且获取到了就直接退出了，所以导致你配置的环境变量不生效。
说到这里咱们再回顾一下BeanName的生成策略的问题，来一次详细的流程：
- context.setBeanNameGenerator();通过该方法想spring容器中传入一个beanName的生成策略。
- 这里是直接向spring容器中注入当前的BeanNameGenerator，然后在processConfigBeanDefinitions方法中被获取：
- 并且将其赋值。然后再parse方法判断当前是否有用户自定义了BeanNameGenerator策略。
- 完成，这样子通过扫描器的扫描就会将当前你设置的BeanName的生成策略设置给spring，并且我们也可以通过注解的方式来设置，通过@ComponentScan：
- 可以看到这个注解上有一个nameGenerator字段，默认的属性为BeanNameGenerator.class，也就是我们平时所说类名首字母小写。
- 那么同样的该注解会再parse方法中再解析@ComponentScan注解的时候被扫描出来。
- 后面同样也是走componentScanParser方法的parse方法进行扫描和通过setBeanNameGenerator()方法是一样的，但是执行的时机不太一样，是通过注解指定BeanNameGenerato方式为最终结果。
- 再说一下spring对于bean的两种注入方式一种是 context.registerBean(); 另一种是：context.getBeanFactory().registerSingleton(); ， 这两方式，原因是spring内部整体来说是有9个bean要再spring容器启动的时候被注入，并且这些bean对于spring来说是根基，其他bean你随便玩都行，但是对于我spring的根基你不行，就比如我们上面说的BeanNameGenerator策略，对于spring容器来说你把这些根基Bean的BeanName改了行吗？肯定是不行的，所以spring在这里直接通过context.getBeanFactory().registerSingleton();的方式来向单例池中放入，原因就是防止你瞎搞，并且这样的Bean是没有生命周期，也就不会受到外部的干扰！
下面我们来根据上面的流程图来解析像@Bean注解、@Component、@ComponentScan等等注解的解析过程：
@Bean：
- 还是在ConfigurationClassParser类中，中的doProcessorConfigurationClass方法中进行的，如下图：
- 调用retriveBeanMethodMetadata方法，将当前的sourceClass传进去进行解析，其实呢这个sourceClass对象可以理解为Spring为了更好的去描述一个类做的抽象工作。
- retrieveBeanMethodMetadatas：
/**
* Retrieve the metadata for all <code>@Bean</code> methods.
* 检索所有元数据 @Bean 方法
*/
private Set<MethodMetadata> retrieveBeanMethodMetadata(SourceClass sourceClass) {
AnnotationMetadata original = sourceClass.getMetadata();
Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName());
if (beanMethods.size() > 1 && original instanceof StandardAnnotationMetadata) {
// Try reading the class file via ASM for deterministic declaration order...
// Unfortunately, the JVM's standard reflection returns methods in arbitrary
// order, even between different runs of the same application on the same JVM.
// 尝试通过 ASM 读取类文件以获得确定性声明顺序...遗憾的是，JVM 的标准反射以任意顺序返回方法，即使在同一 JVM 上同一应用程序的不同运行之间也是如此。
try {
AnnotationMetadata asm = this.metadataReaderFactory.getMetadataReader(original.getClassName()).getAnnotationMetadata();
Set<MethodMetadata> asmMethods = asm.getAnnotatedMethods(Bean.class.getName());
if (asmMethods.size() >= beanMethods.size()) {
Set<MethodMetadata> selectedMethods = new LinkedHashSet<>(asmMethods.size());
for (MethodMetadata asmMethod : asmMethods) {
for (MethodMetadata beanMethod : beanMethods) {
if (beanMethod.getMethodName().equals(asmMethod.getMethodName())) {
selectedMethods.add(beanMethod);
break;
}
}
}
if (selectedMethods.size() == beanMethods.size()) {
// All reflection-detected methods found in ASM method set -> proceed
// 在ASM方法集中找到的所有反射检测到的方法 ->继续
beanMethods = selectedMethods;
}
}
} catch (IOException ex) {
logger.debug("Failed to read class file via ASM for determining @Bean method order", ex);
// No worries, let's continue with the reflection metadata we started with...
}
}
return beanMethods;
}
- 可以看到在第六行获取到sourceClass中的Metadata，然后再调用getAnnotationMethods方法来该sourceClass中所有的@Bean方法....后续详细咱就不看了，但是最后返回到doProcessConfigurationClass方法中返回的是一个MethodMetadata的set集合。
- 再到下一步就是进行循环该set集合，将当前循环的methodMetadata包装为一个BeanMethod对象存放到BeanMethod集合中。
- 和我们上面的流程图画的差不多就也就是调用addBeanMethod()方法，将当前的method add()到beanMethods集合中：
- 再看他添加的是beanMethods集合
- 还记得咱们在上述流程图中画的嘛，现在添加的集合就是在处理@Bean注解之后需要被添加到ConfigurationClass类中的beanMethods。
- 下面再比如处理接口上的东西：
@ComponentScan(value = "com.lukp.beanDefinitionRegistryPostProcessor")
public class Config implements J {
@Bean
public F h(){
System.out.println("Config init F");
return new F();
}
}
public interface J {
@Bean
default F f(){
System.out.println("f invoke...");
return new F();
}
}
public class F {
}
public class Application {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(Config.class);
context.refresh();
}
}
- 结果：
- 我们来看再doProcessConfigurationClass方法对于interface接口类型的配置类是如何解析的：
- 我们进入processInterfaces方法中：
/**
* Register default methods on interfaces implemented by the configuration class.
* 在配置类实现的接口上注册默认方法。
*/
private void processInterfaces(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
for (SourceClass ifc : sourceClass.getInterfaces()) {
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(ifc);
for (MethodMetadata methodMetadata : beanMethods) {
if (!methodMetadata.isAbstract()) {
// A default method or other concrete method on a Java 8+ interface...
// Java 8+ 接口上的默认方法或其他具体方法...
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
}
processInterfaces(configClass, ifc);
}
}
- 可以看到在第7行调用了刚刚咱们在看解析@Bean注解时看到的retrieveBeanMethodMetadata()方法，对的其实interface类型也会调用他对当前的interface进行解析。
- 可以看到再第15行递归调用processorInterfaces方法对当前的配置类进行处理，为什么要递归呢，很简单，万一你接口继承另一个类，而且该类实现了某个接口呢.....所以要进行递归调用。
- 最后我们可以看到在12行也会将当前解析出来的methodMetadata包装成为一个BeanMethod对象，加入到beanMethods集合中，因为走的是一个解析方法嘛。
- 然后下面开始判断当前的配置类是否有父类：
@Import
- 我们现在说一个难一点的注解解析@Import注解。
@ComponentScan(value = "com.lukp.beanDefinitionRegistryPostProcessor")
@Import(value = H.class)
public class Config implements J {
@Bean
public F h() {
System.out.println("Config init F");
return new F();
}
}
public class H implements ImportSelector {
public H(){
System.out.println("H init ...");
}
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.lukp.beanDefinitionRegistryPostProcessor.F"};
}
}
public class F {
}
- 针对于spring对于@Import注解的两种处理方式，一种是普通类一种是如上面所说的F中可能会别的一些操作，ok下面我们先看普通类spring是如何处理的。
- 首先我们来看运行的结果：
- 然后我们再看，spring是如何处理的：
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
private void processImports(
ConfigurationClass configClass,
SourceClass currentSourceClass,
Collection<SourceClass> importCandidates,
Predicate<String> exclusionFilter,
boolean checkForCircularImports) {
if (importCandidates.isEmpty()) {
return;
}
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
} else {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports 候选类是一个 ImportSelector ->委托给它以确定导入
Class<?> candidateClass = candidate.loadClass();
ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class, this.environment, this.resourceLoader, this.registry);
Predicate<String> selectorFilter = selector.getExclusionFilter();
if (selectorFilter != null) {
exclusionFilter = exclusionFilter.or(selectorFilter);
}
if (selector instanceof DeferredImportSelector) {
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
} else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
} else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// Candidate class is an ImportBeanDefinitionRegistrar ->
// delegate to it to register additional bean definitions
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
ParserStrategyUtils.instantiateClass(
candidateClass, ImportBeanDefinitionRegistrar.class,
this.environment, this.resourceLoader, this.registry
);
// 将当前的registrar存放到configClass集合但是并没有立马执行
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
} else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
// 候选类不是 ImportSelector 或 ImportBeanDefinitionRegistrar - >将其作为@Configuration类进行处理
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
} catch (BeanDefinitionStoreException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configClass.getMetadata().getClassName() + "]", ex);
} finally {
this.importStack.pop();
}
}
}
- 首先判断你当前是否有@Import注解进来的类，如果没有就直接退出：
- 那么当前是有的，就是H，所以不会进入到if代码中，直接跳到下面的if判断中：将当前的添加了@Import直接的类加入到importStack中：
- 那么在我们在上面的流程图中表述了@Import会有三种情况：实现的是ImportSelector接口，普通类，实现了importBeanDefinitonRegistry接口。
- 当前案例中我们在Import的是H类，H类是不是第一种情况，他实现了ImportSelector接口，所以他会进入到16~31行。
- 然后在19行开始实例化：
- 接下来走到24~26行判断是要进行延迟执行，但是这里没有所以直接到下面的else代码块中：
- 上图的解析是对于递归的时候，那些类都是实现了ImportSelector接口的，但是我们现在的F类是一个普通类，他啥也没有实现就只是一个类，那么他就会进入到42~49行代码中，进行普通类的处理过程：
this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
- 先将当前sourceClass和他的className放入到importStack(LinkedHashMap)中。然后再调用我们的老朋友processConfigurationClass方法来处理这种普通的类。
- 然后我们看这段代码，有个疑问三种类型的Import，为什么只有第一种实现了ImportSelector接口的会进行内部的递归处理？？而其他两种情况都没有这样的处理？？
- 原因是这样的，由于我们导入一个类的时候，如果你是后面两种的话，对于类型都是确定的，什么意思呢？
- 比如说我现在实现的是ImportBeanDefinitionRegistrar接口：
- 他都是直接向BeanDefinitionMap中添加就结束了。
- 那普通类被导入进来的话更加没啥花头，因为就他一个。
- 但是对于ImportSelector接口来说，情况却是略显不同：
public class H implements ImportSelector {
public H() {
System.out.println(" init h ...");
}
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.lukp.beanDefinitionRegistryPostProcessor.F"};
}
}
- 咱们看这个H类，实现了ImportSelector接口并且实现了selectImport方法，返回的是一个数组，该数组中存放着多个要被导入到Spring-context的类，到这里问题都没有显现，但是在下一步到咱们的对其进行解析的时候，是不是就会出现问题了，啥问题，你不知道当前这次的导入的比如说F类，这个类上面是不是还实现了ImportSelector接口，或者ImportBeanDefinitionRegistrar，所以只能进行递归操作，直到他没有后续需要进行导入的类就结束。
- 好的下面咱们再来讨论一个问题，就是当我们再扫描到最后为一个普通类的时候，他直接调用processConfigurationClass方法，把当前的普通类当成了一个配置类来做，这是不是有问题，咱们说对于配置类，我们可以分为full和litf两种，但是假如我现在就是一个真的非常普通的类，只有一个类名和构造方法，啥也没有，那你spring也把我这个普通类当成配置类，进行处理？这是不是有很大的问题，是不是spring这里的处理有BUG？并且站在给一个默认值的角度来说也不对呀，因为我要是再这个普通类上加了一个@Configuration注解，但是你默认普通类为半配置类，这和使用者的角度不是不一样了吗？所以默认值的方式也是不可取的并且spring也没有这么去做。
- spring在这里也是有考虑到这个问题，我们先来看现象昂：
@ComponentScan(
value = "com.lukp.beanDefinitionRegistryPostProcessor",
excludeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = F.class)}
)
public class Config {
}
public class F {
public F() {
System.out.println(" init f ...");
}
@Bean
public O1 o1() {
return new O1();
}
@Bean
public O2 o2() {
o1();
return new O2();
}
}
public class O1 {
public O1(){
System.out.println("o1 init ...");
}
}
public class Application {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(Config.class);
context.refresh();
F bean1 = context.getBean(F.class);
}
}
- 事实也是如此spring的报错信息说没找到F这个Bean。
- 好的下面我们来做一些改变，
- 我们现在在Config类上添加@Import注解，并且导入的类是H：
public class H implements ImportSelector {
public H() {
System.out.println(" init h ...");
}
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.lukp.beanDefinitionRegistryPostProcessor.F"};
}
}
- 其他我都不做变化，再看运行的结果：
- 他居然没有报错，并且也确实按照我的想法输出了我想要的内容，两点：
-
- 我在Config类上添加了@Component注解并且过滤掉了F类。
- 我在F类上没有加如何的注解，也就是spring标志一个类到底是全配置类还是半配置类的依据。
- 他是如何能够做到按照我的要求输出的？
- ok，下面我们再来验证一下，如果我现在在F类上添加了@Configuration注解，按照之前的结论来说，由于我们在F类中有两个实例化方法，分别实例化两个类O1和O2，但是如果我加@Configuration注解，spring就会做CGLib代理，那么还是保证Bean的单例性特。
- 来看结果：
- 看见没他真的输出了一次，说明spring是做到之前他要保证的东西。
- 好的，现在咱们面临着两个问题：
-
- 一个是spring是如何做到我在@Component注解中过滤掉F类之后，还能通过@Import注解被spring解析到的？
- 二在被解析的时候定义为一个普通类，spring是如何能够做到分辨他是一个全配置类还是一个半配置类的？
- 先回答为什么第一个问题原因，因为我们的F类并不是通过scan扫描的时候，被spring通过注解扫描出来，并且在下面processImports中不是会进行递归调用嘛，那么你递归调用对于spring进不进行过滤这个bean是没有直接联系的，他是通过在processImports方法中被扫描出来的
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports 候选类是一个 ImportSelector ->委托给它以确定导入
Class<?> candidateClass = candidate.loadClass();
// 实例化
ImportSelector selector = ParserStrategyUtils.instantiateClass(
candidateClass, ImportSelector.class, this.environment, this.resourceLoader, this.registry
);
Predicate<String> selectorFilter = selector.getExclusionFilter();// 进行过滤(可以在这行配置你想要的过滤条件)
if (selectorFilter != null) {
exclusionFilter = exclusionFilter.or(selectorFilter);
}
if (selector instanceof DeferredImportSelector) {
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
} else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
}
- 那么对于当前的加了@Import注解的类来说，他是不生效的，因为你并没有通过@Import注解来进行过滤，你看在第8行他是自己去拿到程序员在@Import注解指定要过滤那些类的集合。
- 所以你通过@Component注解进行过滤的类在全局中是会被spring进行过滤，但是在这里进行@Import注解的扫描中是不会进行过滤的，那么站在spring的角度来说，他认为你在全局要进行过滤的类，对于@Import注解的要求可能不一样，那我是不能一概而论的，并且我们大部分的"外部类"，都是通过@Import的方法被加入到BeanDefintionMap中，那假如说我现在有一个类，需要被导入类用到，你把他过滤了，我后续的流程不就断点了嘛....所以这里那种注解所使用的ExclusionFilter不是同一个。
- 然后咱们再解答第二个问题：他是直接走了解析配置类的方法他没有被检查，他是如何做到标记当前的类是否为配置类，或者说到底是什么类型的配置类(full or lite)。
- 其实我们之前一直在将processConfigBeanDefinitions方法，将他咋处理咋扫描啥的，但是一直都是讲他前面的代码，但是最后的代码我们没有看到，那么现在我们就看看到底是咋回事：
/**
* Build and validate a configuration model based on the registry of
* 基于注册表构建和验证配置模型
* {@link Configuration} classes.
*/
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
// 1.存储配置类的集合
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 2.获取所有的BD的Name:正常情况如果你不提供自定义的BD就五个spring内置的
String[] candidateNames = registry.getBeanDefinitionNames();
/**
* 下面的循环开始spring就要对配置类进行解析了
*/
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
/**
* 在这里你获取到BD之后是可以执行你自己想要执行的自定义操作的，
* 如何实现，每个BD都实现了一个接口AttributeAccessor，
* 这个接口有一个方法getAttribute，这个方法的在一个叫做AttributeAccessorSupport类中的实现：
* public Object getAttribute(String name) {
* Assert.notNull(name, "Name must not be null");
* return this.attributes.get(name);
* }
* 其中的this.attributes是一个Map，所以spring是允许你自己在针对于spring给你定义的BD不满足的时候，
* 还可以向这个Map中丢你想要定义的一些规则(其实spring中对于Bean的执行顺序就是这么实现的)
*/
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {//判断当前beanDef是否是配置类
if (logger.isDebugEnabled()) {
// log:Bean 定义已作为配置类进行处理
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
/**
* ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)
* 该方法为spring判断当前是否要关心它，并且判断它是否是一个配置类？
* BeanFactoryPostProcessor
* BeanPostProcessor
* AopInfrastructureBean
* EventListenerFactory
* 但是前提是spring内置的配置类会被筛选掉，原因：
* 1、没有满足实现那五个注解的要求
* 2、spring自己把他过滤掉了(通过类型将其过滤掉)，但是不代表以后会被过滤掉！
*/
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
// 加入到配置类集合中
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
// 如果未找到@Configuration类，请立即返回
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
// 按先前确定的@Order值排序（如果适用）
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// Detect any custom bean name generation strategy supplied through the enclosing application context
// 检测通过封闭应用程序上下文提供的任何自定义 Bean 名称生成策略
// 看一下当前的spring环境中有没有生成默认的BeanNameGenerator
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
// localBeanNameGeneratorSet默认为false,那么表示在spring第一次实例化的时候,为true
// spring会从单例池中获取到对应的beanNameGenerator
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
// 并且如果beanNameGenerator不为null的话就会将它赋值给componentScanBeanNameGenerator和importBeanNameGenerator
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// Parse each @Configuration class
// 分析每个@Configuration类
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory,
this.problemReporter,
this.environment,
this.resourceLoader,
this.componentScanBeanNameGenerator,
registry
);
// 将上述为配置类的集合copy到candidates集合中
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
// 开始解析全部的配置类
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
// 读取模型并根据其内容创建 Bean 定义
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry,
this.sourceExtractor,
this.resourceLoader,
this.environment,
this.importBeanNameGenerator,
parser.getImportRegistry()
);
}
/**
* 开始真正的处理上述通过parse解析出来的配置类,解析成为一个配置类
*/
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory)
&&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
} while (!candidates.isEmpty());
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
// 将 ImportRegistry 注册为 Bean 以支持 ImportAware @Configuration类
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext.
// 清除外部提供的元数据读取器工厂中的缓存;这是共享缓存的无操作，因为它将被应用程序上下文清除。
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
- 上面的代码就是之前咱们一直在聊的东西，现在我们看上述代码高光的地方第117~135行。
- 这段代码在干啥？我们来分析分析：
到这里我们的将的postProcessorBeanDefinitionRegistry方法差不多了，但是还有一点需要咱们讨论一下的就是，spring是在什么时候将我们通过Import的类解析之后内部还有类，将这些类注册到BDMap中的呢？说的有点迷糊我画个图解释一下：
大致的问题描述在上���的这张图中，我们来看一下代码解析上述问题：
- 首先我们确定一点就是parser方法中都是解析，并没有做什么实例化操作，并且像上述的B类解析完成后也只是会被放入到configurationClasses集合中。
/**
* configurationClasses：该map缓存所有ConfigurationClass方便将来进行处理，注意：configuration是解析得到，并且得到之后不做处理
*/
private final Map<ConfigurationClass, ConfigurationClass> configurationClasses = new LinkedHashMap<>();
- 然后返回到processConfigBeanDefinitions方法中在parser方法解析完成后，在下面通过loadBeanDefinitions方法来继续解析这些configClasses类，因为我们都是ConfigurationClass类是对配置类的一种高度抽象嘛，在当前我们讨论的问题就涉及到这个配置类其中的一个属性
/**
* 当前配置类导入了那些类(普通类)
* 被谁导入的
*/
private final Set<ConfigurationClass> importedBy = new LinkedHashSet<>(1);
- 然后会将这些信息在loadBeanDefinitions方法中进行下一步的解析工作：
/**
* Read {@code configurationModel}, registering bean definitions
* with the registry based on its contents.
* 读取 {@code 配置模型}，根据其内容向注册表注册 Bean 定义。
*/
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
- 你看spring官网给出的解析也十分的明确就是将上述解析出来的configClasses类注册到BDMap中。
- 我们进入loadBeanDefinitionsForConfigurationClass方法中看看：
/**
* Read a particular {@link ConfigurationClass}, registering bean definitions
* for the class itself and all of its {@link Bean} methods.
*/
private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
- 上述代码的第14~16行就是判断当前的ConfigClasses配置类是否有Import那些类，然后调用registerBeanDefinitionForImportedConfigurationClass方法去解析当前的configClass
/**
* Register the {@link Configuration} class itself as a bean definition. 将 {@link 配置} 类本身注册为 Bean 定义。
*/
private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
AnnotationMetadata metadata = configClass.getMetadata();
AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);
ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
configBeanDef.setScope(scopeMetadata.getScopeName());
String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);
AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());
configClass.setBeanName(configBeanName);
if (logger.isTraceEnabled()) {
logger.trace("Registered bean definition for imported class '" + configBeanName + "'");
}
}
- 在最后的解析完成后就将当前的BD注册到BDMap中。
下面再聊一下@Bean方法是怎么被处理的：
- 其实@Bean方法被注入到spring容器中的时机就是在上面的loadBeanDefinitions方法中：
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
if (configClass.isImported()) { // 这里是处理被Import的配置类
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
for (BeanMethod beanMethod : configClass.getBeanMethods()) { // 这里是处理@Bean方法
loadBeanDefinitionsForBeanMethod(beanMethod);
}
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
- 让我们进入到loadBeanDefinitionsForBeanMethod方法中：
/**
* Read the given {@link BeanMethod}, registering bean definitions
* with the BeanDefinitionRegistry based on its contents.
* 读取给定的 {@link BeanMethod}，根据其内容向 BeanDefinitionRegistry 注册 Bean 定义。
*/
@SuppressWarnings("deprecation") // for RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
ConfigurationClass configClass = beanMethod.getConfigurationClass();
MethodMetadata metadata = beanMethod.getMetadata();
String methodName = metadata.getMethodName();
// Do we need to mark the bean as skipped by its condition?
if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
configClass.skippedBeanMethods.add(methodName);
return;
}
if (configClass.skippedBeanMethods.contains(methodName)) {
return;
}
AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
Assert.state(bean != null, "No @Bean annotation attributes");
// Consider name and any aliases
List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
String beanName = (!names.isEmpty() ? names.remove(0) : methodName);
// Register aliases even when overridden
for (String alias : names) {
this.registry.registerAlias(beanName, alias);
}
// Has this effectively been overridden before (e.g. via XML)?
if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
"' clashes with bean name for containing configuration class; please make those names unique!");
}
return;
}
ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata, beanName);
beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
// 如果是静态类
if (metadata.isStatic()) {
// static @Bean method
if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
} else {
beanDef.setBeanClassName(configClass.getMetadata().getClassName());
}
beanDef.setUniqueFactoryMethodName(methodName);
} else {
// instance @Bean method ,注意这里的FactoryBeanName其实是当前对象，由于我们通过return的方式返回对应的类，那么这里就可以用Object来代表所有的Bean
beanDef.setFactoryBeanName(configClass.getBeanName());
beanDef.setUniqueFactoryMethodName(methodName);
}
if (metadata instanceof StandardMethodMetadata) {
beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());
}
beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
// 判断是否有@AutoWire注解
Autowire autowire = bean.getEnum("autowire");
if (autowire.isAutowire()) {
beanDef.setAutowireMode(autowire.value());
}
boolean autowireCandidate = bean.getBoolean("autowireCandidate");
if (!autowireCandidate) {
beanDef.setAutowireCandidate(false);
}
// 判断是否有初始化方法
String initMethodName = bean.getString("initMethod");
if (StringUtils.hasText(initMethodName)) {
beanDef.setInitMethodName(initMethodName);
}
String destroyMethodName = bean.getString("destroyMethod");
beanDef.setDestroyMethodName(destroyMethodName);
// Consider scoping
ScopedProxyMode proxyMode = ScopedProxyMode.NO;
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
if (attributes != null) {
beanDef.setScope(attributes.getString("value"));
proxyMode = attributes.getEnum("proxyMode");
if (proxyMode == ScopedProxyMode.DEFAULT) {
proxyMode = ScopedProxyMode.NO;
}
}
// Replace the original bean definition with the target one, if necessary
BeanDefinition beanDefToRegister = beanDef;
if (proxyMode != ScopedProxyMode.NO) {
BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
new BeanDefinitionHolder(beanDef, beanName),
this.registry,
proxyMode == ScopedProxyMode.TARGET_CLASS
);
beanDefToRegister = new ConfigurationClassBeanDefinition((RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata, beanName);
}
if (logger.isTraceEnabled()) {
logger.trace(String.format("Registering bean definition for @Bean method %s.%s()", configClass.getMetadata().getClassName(), beanName));
}
this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}
转载自:https://juejin.cn/post/7383054105613549577