Spring源码(1)

 1 @org.junit.Test
 2     public void test01(){
 3         //把spring所有环境准备好
 4         // 1.准备好DefaultListableBeanFactory
 5         //   实例化一个bdReader和一个Scanner
 6         AnnotationConfigApplicationContext applicationContext =
 7                 new AnnotationConfigApplicationContext();
 8 
 9         //把一个class转成bd,最后put到map
10         applicationContext.register(AppConfig.class);
15 
16         //初始化spring的环境
17         applicationContext.refresh();
18 
19 
20     }

1 //new一个工厂DefaultListableBeanFactory
2     public GenericApplicationContext() {
3         this.beanFactory = new DefaultListableBeanFactory();
4     }

 1 public AnnotationConfigApplicationContext() {
 2         /**
 3          * 父类的构造方法
 4          * 创建一个读取注解的BeanDefinition读取器
 5          * 什么是bean定义？BeanDefinition
 6          */
 7         //reader能够读取被加了注解的类      this是一个注册器，用来将BeanDefinition转为工厂中的map
 8         this.reader = new AnnotatedBeanDefinitionReader(this);
 9         //可以用来扫描包或者类，继而转换成bd
10         //但是实际上我们扫描包工作不是scanner这个对象来完成的
11         //是spring自己new的一个ClassPathBeanDefinitionScanner
12         //这里的scanner仅仅是为了程序员能够在外部调用AnnotationConfigApplicationContext对象的scan方法
13         this.scanner = new ClassPathBeanDefinitionScanner(this);
14     }

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
            BeanDefinitionRegistry registry, @Nullable Object source)

 1 <T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
 2             @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
 3 
 4         /**
 5          * 根据指定的bean创建一个AnnotatedGenericBeanDefinition
 6          * 这个AnnotatedGenericBeanDefinition可以理解为一个数据结构
 7          * AnnotatedGenericBeanDefinition包含了类的其他信息,比如一些元信息
 8          * scope，lazy等等
 9          */
10         AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
11 
12         /**
13          * 判断这个类是否需要跳过解析
14          * 通过代码可以知道spring判断是否跳过解析，主要判断类有没有加注解
15          */
16         if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
17             return;
18         }
19 
20         //不知道
21         abd.setInstanceSupplier(instanceSupplier);
22         /**
23          * 得到类的作用域
24          */
25         ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
26         /**
27          * 把类的作用域添加到数据结构结构中
28          */
29         abd.setScope(scopeMetadata.getScopeName());
30         /**
31          * 生成类的名字通过beanNameGenerator
32          */
33         String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
34 
35         /**
36          * 处理类当中的通用注解
37          * 分析源码可以知道他主要处理
38          * Lazy DependsOn Primary Role等等注解
39          * 处理完成之后processCommonDefinitionAnnotations中依然是把他添加到数据结构当中
40          *
41          */
42         AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
43         //这里qualifiers传过来是null
44         /**
45          * 如果在向容器注册注解Bean定义时，使用了额外的限定符注解则解析
46          * 关于Qualifier和Primary前面的课当中讲过，主要涉及到spring的自动装配
47          * 这里需要注意的
48          * byName和qualifiers这个变量是Annotation类型的数组，里面存不仅仅是Qualifier注解
49          * 理论上里面里面存的是一切注解，所以可以看到下面的代码spring去循环了这个数组
50          * 然后依次判断了注解当中是否包含了Primary，是否包含了Lazyd
51          */
52         if (qualifiers != null) {
53             for (Class<? extends Annotation> qualifier : qualifiers) {
54                 ////如果配置了@Primary注解，如果加了则作为首选
55                 if (Primary.class == qualifier) {
56                     abd.setPrimary(true);
57                 }
58                 //懒加载，前面加过
59                 else if (Lazy.class == qualifier) {
60                     abd.setLazyInit(true);
61                 }
62                 else {
63                     //如果使用了除@Primary和@Lazy以外的其他注解，则为该Bean添加一个根据名字自动装配的限定符
64                     //这里难以理解，后面会详细介绍
65                     abd.addQualifier(new AutowireCandidateQualifier(qualifier));
66                 }
67             }
68         }
69         for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
70             customizer.customize(abd);
71         }
72 
73         /**
74          * 这个BeanDefinitionHolder也是一个数据结构
75          */
76         BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
77         /**
78          * ScopedProxyMode需要结合web去理解
79          * 

81          */
82         definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
83 
84         /**
85          * 把上述的这个数据结构注册给registry
86          * registy就是AnnotatonConfigApplicationContext
87          * AnnotatonConfigApplicationContext在初始化的時候通過調用父類的構造方法
88          * 實例化了一个DefaultListableBeanFactory
89          * *registerBeanDefinition里面就是把definitionHolder这个数据结构包含的信息注册到
90          * DefaultListableBeanFactory这个工厂
91          */
92         BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
93     }