16.Spring创建Bean源码-注册配置类,非常细!

---

highlight: arduino-light

源码断点示例代码

AOP切面类

```java package orange; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.core.PriorityOrdered; import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component;

@Aspect @Component public class Aop implements PriorityOrdered {

   //指定切入点表达式，拦截那些方法，即为那些类生成代理对象    //@Pointcut("execution(* com.bie.aop.UserDao.save(..))") ..代表所有参数    //@Pointcut("execution(* com.bie.aop.UserDao.())") 指定所有的方法    //@Pointcut("execution( com.bie.aop.UserDao.save())") 指定save方法

   @Pointcut("execution(* tyrant.*.log(..))")    public void pointCut(){

  }

   @Before("pointCut()")    public void Before(){        System.out.println("Before");   }

   @After("pointCut()")    public void After(){        System.out.println("After");   }

   @AfterThrowing("pointCut()") public void AfterThrowing(){ System.out.println("AfterThrowing"); }

@AfterReturning("pointCut()")
public void AfterReturning(){
    System.out.println("AfterReturning");
}

@Around("execution(* tyrant.*.log(..))")
public void Around(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("Around Before");
    joinPoint.proceed();
    System.out.println("Around After");
}

@Override
public int getOrder() {
    return 1;
}

}

```

事务管理器

```java package orange; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.stereotype.Component; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.TransactionException; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.support.DefaultTransactionStatus; import org.springframework.transaction.support.SimpleTransactionStatus;

@Configuration("transactionManager") public class MyPlatformTransactionManager implements PlatformTransactionManager { @Override public TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException { System.out.println("getTransaction"); return new SimpleTransactionStatus(); }

@Override
public void commit(TransactionStatus status) throws TransactionException {
        System.out.println("commit");
}

@Override
public void rollback(TransactionStatus status) throws TransactionException {
        System.out.println("rollback");
}

} ```

启动配置类

```java package orange; import org.springframework.context.annotation.*; import org.springframework.transaction.annotation.EnableTransactionManagement; import tyrant.Config;

@ComponentScan() @EnableAspectJAutoProxy(proxyTargetClass = true) @EnableTransactionManagement(mode = AdviceMode.PROXY) @Configuration public class BeanConfig { } ```

Bean

```java package orange; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional;

@Component public class AopLog { @Transactional("transactionManager") public String log() { System.out.println("----切面----"); return "1"; } } ```

启动类

```java package orange;

import org.springframework.context.annotation.AnnotatedBeanDefinitionReader; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import java.util.Map;

public class TestOrangeCondition { public static void main(String[] args) { /* * 创建一个BeanDefinition读取器 根据注解读取 * 创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd */ AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); //注册配置类 context.register(BeanConfig.class); context.refresh(); Class>[] interfaces = AopLog.class.getInterfaces(); AopLog aopLog = context.getBean("aopLog",AopLog.class); aopLog.log(); } } ```

1.new AnnotationConfigApplicationContext()

java public AnnotationConfigApplicationContext() { //java 用class描述类 //spring 用BeanDefinition 描述bean //调用构造方法时需要首先调用父类GenericApplicationContext的构造方法 //在父类的构造方法里会初始化一个DefaultListableBeanFactory //this.beanFactory = new DefaultListableBeanFactory(); // this 代表的是AnnotationConfigApplicationContext /* 注册了5个RootBeanDefinition RootBeanDefinition df = new RootBeanDefinition(ConfigurationClassPostProcessor.class); RootBeanDefinition df = newRootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); RootBeanDefinition df = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); RootBeanDefinition df = new RootBeanDefinition(EventListenerMethodProcessor.class); RootBeanDefinition df = new RootBeanDefinition(DefaultEventListenerFactory.class); */ //创建一个BeanDefinition读取器 可以根据注解读取 BeanDefinition this.reader = new AnnotatedBeanDefinitionReader(this); //创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd this.scanner = new ClassPathBeanDefinitionScanner(this); }

1.1调用父类构造,创建DefaultListableBeanFactory

调用构造方法时需要首先调用父类GenericApplicationContext的构造方法,在父类GenericApplicationContext的构造方法里会初始化一个DefaultListableBeanFactory。

java this.beanFactory = new DefaultListableBeanFactory();

1.2.new AnnotatedBeanDefinitionReader(this)

创建一个BeanDefinition读取器 可以根据注解读取BeanDefinition

java public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) { //registry 代表的是AnnotationConfigApplicationContext this(registry, getOrCreateEnvironment(registry)); }

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); Assert.notNull(environment, "Environment must not be null"); this.registry = registry; this.conditionEvaluator = new ConditionEvaluator(registry, environment, null); AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); }

1.2.1获取StandardEnvironment

java private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) { //获取StandardEnvironment Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); if (registry instanceof EnvironmentCapable) { //获取 systemProperties 放入StandardEnvironment //获取 systemEnvironment 放入StandardEnvironment return ((EnvironmentCapable) registry).getEnvironment(); } return new StandardEnvironment(); }

1.2.2注册5个ConfigProcessors的Definition

注册了5个RootBeanDefinition,添加到Set\

java //这个ConfigurationClassPostProcessor非常非常非常重要 RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class); RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);

1.2.2.1ConfigurationClassPostProcessor

贴了2个比较重要的方法:

java //BeanDefinitionRegistryPostProcessor: //postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)

java //BeanFactoryPostProcessor: //postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

java @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { System.out.println("tyrant ConfigurationClassPostProcessor"); int registryId = System.identityHashCode(registry); if (this.registriesPostProcessed.contains(registryId)) { throw new IllegalStateException( "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry); } if (this.factoriesPostProcessed.contains(registryId)) { throw new IllegalStateException( "postProcessBeanFactory already called on this post-processor against " + registry); } this.registriesPostProcessed.add(registryId); //处理配置类的bean定义信息 processConfigBeanDefinitions(registry); } ​ /** * Prepare the Configuration classes for servicing bean requests at runtime * by replacing them with CGLIB-enhanced subclasses. */ @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { System.out.println("tyrant postProcessBeanFactory"); int factoryId = System.identityHashCode(beanFactory); if (this.factoriesPostProcessed.contains(factoryId)) { throw new IllegalStateException               ("postProcessBeanFactory already called on                                       this post-processor against " + beanFactory); } this.factoriesPostProcessed.add(factoryId); if (!this.registriesPostProcessed.contains(factoryId)) { // BeanDefinitionRegistryPostProcessor hook apparently not supported... // Simply call processConfigurationClasses lazily at this point then. processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory); } //用于增强配置类 给FULL类型的配置类增加2个增强回调 enhanceConfigurationClasses(beanFactory); //这里还注册了一个ImportAwareBeanPostProcessor 是一个BeanPostProcessor //用于处理增强配置类 beanFactory.addBeanPostProcessor(new                                         ImportAwareBeanPostProcessor(beanFactory)); } ​

★1.2.2.2AutowiredAnnotationBeanPostProcessor

@AutoWired 和 @Value

java @SuppressWarnings("unchecked") public AutowiredAnnotationBeanPostProcessor() { this.autowiredAnnotationTypes.add(Autowired.class); this.autowiredAnnotationTypes.add(Value.class); try { this.autowiredAnnotationTypes.add((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader())); } catch (ClassNotFoundException ex) { // JSR-330 API not available - simply skip. } }

★1.2.2.3CommonAnnotationBeanPostProcessor

@PostConstruct和@PreDestroy

java public CommonAnnotationBeanPostProcessor() { setOrder(Ordered.LOWEST_PRECEDENCE - 3); setInitAnnotationType(PostConstruct.class); setDestroyAnnotationType(PreDestroy.class); ignoreResourceType("javax.xml.ws.WebServiceContext"); }

1.2.2.4EventListenerMethodProcessor

1.2.2.5DefaultEventListenerFactory

1.3.new ClassPathBeanDefinitionScanner(this)

创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd

java public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {   //默认是true代表的是useDefaultFilters this(registry, true); }

java public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) { this(registry, useDefaultFilters, getOrCreateEnvironment(registry)); }

java public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,Environment environment) { this(registry, useDefaultFilters, environment, (registry instanceof ResourceLoader ? (ResourceLoader) registry : null)); }

★1.3.1includeFilters注册:@Component

@Controller @Repository @Service

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,Environment environment, @Nullable ResourceLoader resourceLoader) { ​ Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); this.registry = registry; /* 注册了3个类型过滤器 这也是为什么可以扫描到下面这些注解的原因 其中 @Component 包含 @Controller @Repository @Service this.includeFilters.add(new AnnotationTypeFilter(Component.class)); 下面2个如果没有相关依赖 就不会加入对应的filter this.includeFilters.add(javax.inject.ManagedBean) this.includeFilters.add(javax.inject.Named) */ if (useDefaultFilters) { registerDefaultFilters(); } setEnvironment(environment); setResourceLoader(resourceLoader); }

``` protected void registerDefaultFilters() {   //其中 @Component 包含 @Controller @Repository @Service this.includeFilters.add(new AnnotationTypeFilter(Component.class)); ClassLoader cl = ClassPathScanningCandidateComponentProvider           .class.getClassLoader(); try { this.includeFilters               .add(new AnnotationTypeFilter(   ((Class extends Annotation>)                     ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));

} catch (ClassNotFoundException ex) { } try { this.includeFilters               .add(new AnnotationTypeFilter( ((Class extends Annotation>)                     ClassUtils.forName("javax.inject.Named", cl)), false)); } catch (ClassNotFoundException ex) {

}
}

```

2.new AnnotatedBeanDefinitionReader(this)

创建一个BeanDefinition读取器 可以根据注解读取BeanDefinition

java public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment){ Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); Assert.notNull(environment, "Environment must not be null"); this.registry = registry; this.conditionEvaluator = new ConditionEvaluator(registry, environment, null); /* 注册了5个 RootBeanDefinition df = new RootBeanDefinition(ConfigurationClassPostProcessor.class); RootBeanDefinition df = newRootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); RootBeanDefinition df = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); RootBeanDefinition df = new RootBeanDefinition(EventListenerMethodProcessor.class); RootBeanDefinition df = new RootBeanDefinition(DefaultEventListenerFactory.class); */ AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); }

2.1获取StandardEnvironment

java private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) { //获取StandardEnvironment Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); if (registry instanceof EnvironmentCapable) { //获取 systemProperties 放入StandardEnvironment //获取 systemEnvironment 放入StandardEnvironment return ((EnvironmentCapable) registry).getEnvironment(); } return new StandardEnvironment(); }

2.2注册5个ConfigProcessors的Definition

注册了5个RootBeanDefinition。

然后添加到Set\ beanDefs = new LinkedHashSet<>(8);

java //这个ConfigurationClassPostProcessor非常非常非常重要 //这个ConfigurationClassPostProcessor非常非常非常重要 RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class); RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);

2.2.1ConfigurationClassPostProcessor

贴2个比较重要的方法: //BeanDefinitionRegistryPostProcessor: //postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)

//BeanFactoryPostProcessor: //postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

java @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { System.out.println("tyrant ConfigurationClassPostProcessor"); int registryId = System.identityHashCode(registry); if (this.registriesPostProcessed.contains(registryId)) { throw new IllegalStateException( "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry); } if (this.factoriesPostProcessed.contains(registryId)) { throw new IllegalStateException ("postProcessBeanFactory already called on this post-processor against " + registry); } this.registriesPostProcessed.add(registryId); //处理配置类的bean定义信息 processConfigBeanDefinitions(registry); }

java @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { System.out.println("tyrant postProcessBeanFactory"); int factoryId = System.identityHashCode(beanFactory); if (this.factoriesPostProcessed.contains(factoryId)) { throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + beanFactory); } this.factoriesPostProcessed.add(factoryId); if (!this.registriesPostProcessed.contains(factoryId)) { // BeanDefinitionRegistryPostProcessor hook apparently not supported... // Simply call processConfigurationClasses lazily at this point then. processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory); } //用于增强配置类 给FULL类型的配置类增加2个增强回调 enhanceConfigurationClasses(beanFactory); //这里还注册了一个ImportAwareBeanPostProcessor 是一个BeanPostProcessor //用于处理增强配置类 beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory)); }

2.2.2AutowiredAnnotationBeanPostProcessor:处理@Auowired@Value

主要用于处理@AutoWired和@Value

java @SuppressWarnings("unchecked") public AutowiredAnnotationBeanPostProcessor() { this.autowiredAnnotationTypes.add(Autowired.class); this.autowiredAnnotationTypes.add(Value.class); try { this.autowiredAnnotationTypes .add((Class<? extends Annotation>)ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader())); }catch (ClassNotFoundException ex) { } }

2.2.3CommonAnnotationBeanPostProcessor

@PostConstruct

@PreDestroy

java public CommonAnnotationBeanPostProcessor() { setOrder(Ordered.LOWEST_PRECEDENCE - 3); setInitAnnotationType(PostConstruct.class); setDestroyAnnotationType(PreDestroy.class); ignoreResourceType("javax.xml.ws.WebServiceContext"); }

2.2.4EventListenerMethodProcessor

2.2.5DefaultEventListenerFactory

3.new ClassPathBeanDefinitionScanner(this)

创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd

3.1includeFilters注册:@Component

java //@Component 包含 @Controller @Repository @Service @Configuration this.includeFilters.add(new AnnotationTypeFilter(Component.class)); this.includeFilters.add(javax.inject.ManagedBean) this.includeFilters.add(javax.inject.Named)

4.context.register(BeanConfig.class);

for循环遍历注册配置类: 由register---->registerBean---->doRegisterBean

4.1用AnnotatedBeanDefinitionReader注册配置类BD

```java public void doRegisterBean(Class beanClass, @Nullable Supplier instanceSupplier, @Nullable String name,@Nullable Class extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

//beanClass是配置类 且使用reader处理 所以使用AnnotatedGenericBeanDefinition
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);

//判断是否需要跳过
//如果没有加@Conditional注解需要解析。
//反之需要执行@Conditional注解指定类的match方法来判断是否需要解析
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
    return;
}

//instanceSupplier 是 null
abd.setInstanceSupplier(instanceSupplier);

//解析@Scope注解 判断单例&多例
ScopeMetadata scopeMetadata =           
                this.scopeMetadataResolver.resolveScopeMetadata(abd);

//获取类的作用域 getScopeName --->singleton 即单例
abd.setScope(scopeMetadata.getScopeName());

//生成beanName,默认的beanName是null  
//判断有没有指定name,如果没有指定name,那么使用驼峰首字母小写的方式作为命名
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

//解析配置类Appconfig上的@LazyInit @Primary @DependsOn @Role @Description 等注解
//并设置到 AnnotatedGenericBeanDefinition的属性里
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

//qualifiers限定符 是传入进来的参数null
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));
        }
    }
}

//此处没细看 跳过
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
    customizer.customize(abd);
}

//BeanDefinitionHolder 是一个数据结构 封装了 bd 以及bd的额外信息
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

//ScopedProxyMode Springmvc
//多例代理模式？ 此处是ScopedProxyMode.NO
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode
                                (scopeMetadata, definitionHolder, this.registry);

//同名beanName通过isAllowBeanDefinitionOverriding判断是否可以覆盖
//注册配置类到BeanDefinitionMap
//此时有6个beanDefinition
//5个ConfigProcessors的Definition + 1个BeanConfig的BeanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

} ```