本文是通过AnnotationConfigApplicationContext读取配置类来一步一步去了解Spring的启动过程。
在看源码之前，我们要知道某些类的作用，这样更方便后续的了解。
1、BeanDefinition
BeanDefinition就是Bean的定义，它是用来形貌Bean的，里面存放着关于Bean的一系列信息，好比Bean的作用域，Bean所对应的Class，是否懒加载等等，BeanDfinition与Bean的关系可以看作是类和class的关系，那么有人说，有class对象就好啦，但是Class不能完完全全的抽象出Bean，好比说，Bean的注入模子，是否懒加载，是否是工厂bean等等，这些是class无法去抽象出来的，以是必要BeanDefinition来形貌Bean，在Spring中，我们可以通过、@Component、BeanDefinition来定义Bean
//定义一个BeanDefinitionAbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();//设置当前bean的class 1、通过class获取 2、通过类的全限定类名获取//beanDefinition.setBeanClass(Testt.class);beanDefinition.setBeanClassName("com.beans.Testt");//将beanDefinition注册到BeanFactory中DefaultListableBeanFactory factory = new DefaultListableBeanFactory();factory.registerBeanDefinition("BEAN",beanDefinition);//获取Beanfactory.getBean("BEAN");还可以直接使用RootBeanDefinition来获取BeanDefinition
//定义一个BeanDefinitionAbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();//设置当前bean的class 1、通过class获取 2、通过类的全限定类名获取//beanDefinition.setBeanClass(Testt.class);beanDefinition.setBeanClassName("com.beans.Testt");//将beanDefinition注册到BeanFactory中DefaultListableBeanFactory factory = new DefaultListableBeanFactory();factory.registerBeanDefinition("BEAN",beanDefinition);//获取Beanfactory.getBean("BEAN");通过上述三种方式我们就可以定义一个Bean。
假设我们有一个实体类Testt
public class Testt { public String name; public void sayHello(){ System.out.println("Hello World!"); } public void setName(String name){ this.name = name; } public String getName(){ return name; }}我们还可以通过beanDefinition来给name属性赋值
//生成一个BeanDefinitionRootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Testt.class);//赋值属性name为123rootBeanDefinition.getPropertyValues().addPropertyValue("name","123");//获取name的值Object name = rootBeanDefinition.getPropertyValues().getPropertyValue("name").getValue();DefaultListableBeanFactory factory = new DefaultListableBeanFactory();factory.registerBeanDefinition("tt",rootBeanDefinition);Testt tt = (Testt) factory.getBean("tt");System.out.println(tt);//通过实例获取name的值String name1 = tt.getName();System.out.println(name1); //123System.out.println(name);//123BeanDefinition还可以
beanDefinition.setScope("prototype"); // 设置作用域beanDefinition.setInitMethodName("init"); // 设置初始化方法beanDefinition.setAutowireMode(0); // 设置自动装配模子 0默认装配模式不自动注入，1 ByName 2 ByType 3 构造器注入 ......BeanDefinition另有许多功能，在这里就不一一去说明了，感爱好的读者可以通过检察beanDefinition的接口和实现类对其一一了解。
无论通过哪种方式来定义Bean，都会被解析为BeanDefinition对象，总之，Bean与BeanDefinition之间的关系你是可以看作是类和class的关系，这样就很容易去理解它了。
这里有一个mergedBeanDefinitions，我们来说一下它是做什么的，mergedBeanDefinitions是存储合并后的BeanDefinition的ConcurrentHashMap,Spring会对BeanDefinition进行合并，基于合并后的BeanDefinition去创建Bean
private final Map mergedBeanDefinitions = new ConcurrentHashMap(256);那么，什么时候beanDefinition会进行合并呢？我们举出下列的一个例子，来带各人一探毕竟
起首写一个Spring.xml，我们通过xml文件去声明bean
这里，我们指将parent的scope设置为prototype，而children并没有去设置他的scope属性，默认就是单例的，我们通过下面方式去调试，看看mergedBeanDefinitions中到底存的是什么
public class mainT { public static void main(String[] args) { ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Spring.xml"); classPathXmlApplicationContext.getBean("children"); }}我们通过在getBean上打上断点，进行调试后，我们可以看到FactoryBean中的mergedBeanDefinitions存的参数如下图所示
children的scope属性也成为了prototype，这就是合并后的BeanDefinition。着实就相当于子类继续父类的时候包罗父类的属性
这里还要记载一下RootBeanDefinition和GenericBeanDefinition的显在区别
可以发现GenericBeanDefinition的SetParentName是正常的，可以添加
public void setParentName(@Nullable String parentName) { this.parentName = parentName; }而RootBeanDefinition是会报错的，也会直接返回null
@Override public String getParentName() { return null; } @Override public void setParentName(@Nullable String parentName) { if (parentName != null) { throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference"); } }2、beanFactory
从名字来看，这是一个工厂类，它负责生产和管理bean，在Spring中，BeanFactory是IOC容器的核心接口，他有许多职责和功能，它的核心实现类是DefaultListableBeanefauFactory类。下图是DefaultListableBeanefauFactory类的UML图。
DefaultListableBeanefauFactory实现了许多接口，也说明了DefaultListableBeanefauFactory类继续了许多功能
我们可以通过beanfactory做许多事，例如：
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition.setBeanClass(Testt.class);DefaultListableBeanFactory factory = new DefaultListableBeanFactory();//注册BeanDefinitionfactory.registerBeanDefinition("Testt",beanDefinition);//注册别名factory.registerAlias("Testt","T");//获取beanObject alias = factory.getBean("T");System.out.println(alias);//com.beans.Testt@6b1274d2//通过类型获取BeanString[] beanNamesForType = factory.getBeanNamesForType(Testt.class);System.out.println(beanNamesForType[0]);//Testt//获取BeanDefinitionBeanDefinition testt = factory.getBeanDefinition("Testt");System.out.println(testt);//Generic bean: class [com.beans.Testt]; scope=; abstract=false; lazyInit=null; autowireMode=0; //dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=null; factoryMethodName=null; //initMethodName=null; destroyMethodName=null//获取BeanDefinition个数int beanDefinitionCount = factory.getBeanDefinitionCount();System.out.println(beanDefinitionCount);//获取Bean的提供者ObjectProvider beanProvider = factory.getBeanProvider(Testt.class); System.out.println(beanProvider);//org.springframework.beans.factory.support.DefaultListableBeanFactory$1@6a472554等等。
ApplicationContext继续BeanFactory接口，它是Spring的一种更更高级的容器，提供了更多有效的功能，我们可以看到ApplicationContext的实现类GenericApplicationContext中有一个属性
private final DefaultListableBeanFactory beanFactory;那么他既然已经继续了BeanFactory接口，为什么又要增加一个DefaultListableBeanFactory属性呢，可以从上面看到DefaultListableBeanFactory实现了许多接口，拥有许多功能，这么做的目的就是，使GenericApplicationContext通过DefaultListableBeanFactory间接拥有了DefaultListableBeanFactory继续的那些功能，而无需在去继续或者实现。o
这里要说明一下别名和beanName的存储，也是通过map去存储的，{aliasname:beanname}，key为别名，value为bean的名字
3、BeanDefinitionReader
可以直接把某个类转换为BeanDefinition，而且会解析该类上的注解，
它能解析的注解是：@Conditional，@Scope、@Lazy、@Primary、@DependsOn、@Role、@Description
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();AnnotatedBeanDefinitionReader Reader = new AnnotatedBeanDefinitionReader(factory);/*** 也可以使用registerBean(Testt.class) 或者 registerBean(Testt.class,"指定Bean名字")**/Reader.register(Testt.class);Object testt = factory.getBean("testt");System.out.println(testt);4、ClassPathBeanDefinitionScanner
这个并不是BeanDefinitionReader，但是它的作用和BeanDefinitionReader类似，它可以进行扫描，扫描某个包路径，对扫描到的类进行解析，好比，扫描到的类上如果存在@Component注解，那么就会把这个类解析为一个BeanDefinition
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();ClassPathBeanDefinitionScanner classPathBeanDefinitionScanner = new ClassPathBeanDefinitionScanner(factory);//得到该包下类的个数// int scan = classPathBeanDefinitionScanner.scan("com.beans");// System.out.println(scan);//6//扫描没有加@Componment注解的类，并注册到容器中，未通过注解或其他方式定义Bean的类也不会添加到容器中//classPathBeanDefinitionScanner.addExcludeFilter(new AnnotationTypeFilter(Component.class));//扫描加了@Componment注解的类，并注册到容器中classPathBeanDefinitionScanner.addIncludeFilter(new AnnotationTypeFilter(Component.class));//获取beanObject bean = factory.getBean(BeanTest.class);System.out.println(bean);//com.beans.BeanTest@5ccddd205、ConditionEvaluator
ConditionEvaluator是一个Spring中的内部类，他提供了@Condition注解的判断条件作用，具体可以看它的shouldSkip方法。
6、Aware
Aware翻译过来是感知的意思，他的用意是用来让用户感知到一些信息，好比说BeanNameAware
@Componentpublic class User implements BeanNameAware { private String awareName; @Override public void setBeanName(String name) { this.awareName = name; } public String getAwareName(){ return awareName; }}我们写一个User类来实现BeanNameAware，重写它的方法setBeanName，并将其赋值给我们的awareName
@ComponentScan("com.beans")public class mainT { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(mainT.class); User bean = context.getBean(User.class); System.out.println(bean.getAwareName()); }}
结果表现，得到的bean的名字。 |
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
千斤顶
显身卡
