记录spring容器初始化过程笔记（一）

记录 spring容器初始化过程

下面是一个spring单元测试类

public class Test{
    @Test
    public void test(){
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
        ac.register(AppConfig.class);
        ac.refresh();
        Object x = ac.getBean("xx");
    }
}

1. new AnnotationConfigApplicationContext () 构造方法

public AnnotationConfigApplicationContext() {
  // 为给的registry 创造一个 AnnotatedBeanDefinitionReader对象
  // 实例化 注解beanDefinition读取器
   this.reader = new AnnotatedBeanDefinitionReader(this);
   // 实例化扫描器
   this.scanner = new ClassPathBeanDefinitionScanner(this);
}

1.1 AnnotatedBeanDefinitionReader 读取器实例

AnnotatedBeanDefinitionReader(this)构造方法

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    // 调用 其他构造方法  AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment)
   this(registry, getOrCreateEnvironment(registry));
}

AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) 构造方法

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

AnnotationConfigUtils 静态方法

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
   registerAnnotationConfigProcessors(registry, null);
}

AnnotationConfigUtils registerAnnotationConfigProcessors 方法 节选

// 判断是否有内置的管理配置注解 处理器 ，没有的话创建   RootBeanDefinition  ,设置BeanClass为ConfigurationClassPostProcessor 
// 判断是否有  The bean name of the internally managed Configuration annotation processor. 
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    // 创建RootBeanDefinition  设置BeanClass为 ConfigurationClassPostProcessor
   RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    // 给根BeanDefiniton 设置source
   def.setSource(source);
    // 
   beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}

if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
   RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
   def.setSource(source);
   beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}

// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
   RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
   def.setSource(source);
   beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}

1.2 ClassPathBeanDefinitionScanner扫描器初始化

AnnotationConfigApplicationContext 无参构造方法代码

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
    //..........中间部分省略
    public AnnotationConfigApplicationContext() {
        // 实例化 注解beanDefinition读取器
        this.reader = new AnnotatedBeanDefinitionReader(this);
        // 实例化扫描器
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
    // .......代码省略
}

*** new ClassPathBeanDefinitionScanner(this); 构造执行的逻辑 ***

public class ClassPathBeanDefinitionScanner  extends ClassPathScanningCandidateComponentProvider {
    
    /*********  省略    ***/

    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
        // 使用默认的过滤器
        this(registry, true);
    }
    
    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
        this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
    }


    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
                                          Environment environment) {

        this(registry, useDefaultFilters, environment,
                (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
    }
    
    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 class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {
    
    //  @Component 注解作用在类上，可以将该类添加进spring容器。但少有人知，@ManagedBean、@Named 也能有同样的效果。
    //注册默认的过滤器
    protected void registerDefaultFilters() {
        // 扫描所有的@Component 类
        this.includeFilters.add(new AnnotationTypeFilter(Component.class));
        ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
        try {
            // 过滤器类型添加  ManagedBean注解类型  , 扫描所有@ManageBean的类
            this.includeFilters.add(new AnnotationTypeFilter(
                    ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
            logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
        } catch (ClassNotFoundException ex) {
            // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
        }
        try {
            //  过滤器类型添加  @Named 注解  
            this.includeFilters.add(new AnnotationTypeFilter(
                    ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
            logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
        } catch (ClassNotFoundException ex) {
            // JSR-330 API not available - simply skip.
        }
    }

}

2. ac.register(AppConfig.class) 方法

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
    private final AnnotatedBeanDefinitionReader reader;  // 实例化AnnotationConfigApplicationContext 赋值
    ..........................省略
    // 重写 AnnotationConfigRegistry接口方法
    @Override
	public void register(Class<?>... componentClasses) {
		Assert.notEmpty(componentClasses, "At least one component class must be specified");
		this.reader.register(componentClasses);
	}
	
    ..........................省略
}

public class AnnotatedBeanDefinitionReader {
     ...............省略
    
    // 
    public void register(Class<?>... componentClasses) {
        for (Class<?> componentClass : componentClasses) {// 遍历 传过来的java  Config类
            registerBean(componentClass); 
        }
    }

    // 从给的bean class 拿到注解元数据  去注册一个bean
    public void registerBean(Class<?> beanClass) {
        doRegisterBean(beanClass, null, null, null, null);
    }
    
    
    private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
                                    @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
                                    @Nullable BeanDefinitionCustomizer[] customizers) {
        // 给java Config 类 创造一个AnnotatedGenericBeanDefinition 类
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
        // 判断 java Config 类是否有 @Conditional 注解      是否跳过一个条目
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }
        // 设置实例供应商  该条线supplier 为null
        abd.setInstanceSupplier(supplier); 
        // 解析域 元数据
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName()); // 设置bean scope
        // 获取BeanName 如果没有设置bean名称 spring提供默认的Bean名称 ， 默认为beanClass 简写名称 如果第二个字母为大写 返回BeanClass 简写类名 ，否则 BeanName 为首字母小写的简写类名
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

        // 处理公共的BeanDefinition注解
         AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        /**
         * 大致的逻辑是：
          判断javaConfig 配置类是否有 @Lazy 、 @Primary  @DependsOn 、@Role 、@Description 注解 获取对应的值 
     static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
         AnnotationAttributes lazy = attributesFor(metadata, Lazy.class); 
         if (lazy != null) {// 判断是不是延迟加载 是否有Lazy注解 获取注解Value值
            abd.setLazyInit(lazy.getBoolean("value"));
         }
         else if (abd.getMetadata() != metadata) { // AnnotatedBeanDefinition 的元数据和 方法传过来的元数据不一样 走这个逻辑
            lazy = attributesFor(abd.getMetadata(), Lazy.class);
             if (lazy != null) {
                abd.setLazyInit(lazy.getBoolean("value"));
             }
         }
         // {@Primary注解(解决匹配引入一个接口多个实现   )： 具体百度}    
         if (metadata.isAnnotated(Primary.class.getName())) { //  如果有Primary注解的话 BeanDefinition Primary值为true ，Primary注解是   
            abd.setPrimary(true);
         }
        AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
         if (dependsOn != null) {
             abd.setDependsOn(dependsOn.getStringArray("value"));
         }
         AnnotationAttributes role = attributesFor(metadata, Role.class);
         if (role != null) {
             abd.setRole(role.getNumber("value").intValue());
         }
         AnnotationAttributes description = attributesFor(metadata, Description.class);
         if (description != null) {
             abd.setDescription(description.getString("value"));
         }
     }
         */
       
        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));
                }
            }
        }
        if (customizers != null) {
            for (BeanDefinitionCustomizer customizer : customizers) {
                customizer.customize(abd);
            }
        }

        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }
    
     ...............省略
}

后续会补充ac.refresh（）方法