Spring启动的时候会进行扫描，会先调用
org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage)
扫描某个包路径，并得到BeanDefinition的Set集合。
?
关于Spring启动流程，后续会单独的课详细讲，这里先讲一下Spring扫描的底层实现：
?
Spring扫描底层流程：Spring扫描底层流程| ProcessOn免费在线作图,在线流程图,在线思维导图
?
.class文件（Spring源码中将此文件包装成了Resource对象）?
MetadataReader表示类的元数据读取器，主要包含了一个AnnotationMetadata，功能有
值得注意的是，CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是利用的ASM技术，并没有加载这个类到JVM。并且，最终得到的ScannedGenericBeanDefinition对象，beanClass属性存储的是当前类的名字，而不是class对象。（beanClass属性的类型是Object，它即可以存储类的名字，也可以存储class对象）
?
最后，上面是说的通过扫描得到BeanDefinition对象，我们还可以通过直接定义BeanDefinition，或解析spring.xml文件的<bean/>，或者@Bean注解得到BeanDefinition对象。（后续课程会分析@Bean注解是怎么生成BeanDefinition的）。
?
通过扫描得到所有BeanDefinition之后，就可以根据BeanDefinition创建Bean对象了，但是在Spring中支持父子BeanDefinition，和Java父子类类似，但是完全不是一回事。
父子BeanDefinition实际用的比较少，使用是这样的，比如：
<bean id="parent"?class="com.memory.service.Parent"?scope="prototype"/>
<bean id="child"?class="com.memory.service.Child"/>
这么定义的情况下，child是单例Bean。
<bean id="parent"?class="com.memory.service.Parent"?scope="prototype"/>
<bean id="child"?class="com.memory.service.Child"?parent="parent"/>
但是这么定义的情况下，child就是原型Bean了。
?
因为child的父BeanDefinition是parent，所以会继承parent上所定义的scope属性。
?
而在根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition。
?
BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就必须先加载当前BeanDefinition所对应的class，在AbstractAutowireCapableBeanFactory类的createBean()方法中，一开始就会调用：
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
这行代码就是去加载类，该方法是这么实现的：
if?(mbd.hasBeanClass()) {
?return?mbd.getBeanClass();
}
if?(System.getSecurityManager() !=?null) {
?return?AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
??doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
?}
else?{
?return?doResolveBeanClass(mbd, typesToMatch);
}
public?boolean?hasBeanClass()?{
?return?(this.beanClass?instanceof?Class);
}
如果beanClass属性的类型是Class，那么就直接返回，如果不是，则会根据类名进行加载（doResolveBeanClass方法所做的事情）
会利用BeanFactory所设置的类加载器来加载类，如果没有设置，则默认使用**ClassUtils.getDefaultClassLoader()**所返回的类加载器来加载。
当前BeanDefinition对应的类成功加载后，就可以实例化对象了，但是...
?
在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制是否在某个或某些Bean实例化之前做一些启动动作。这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。比如：
?
@Component
public?class?MemoryBeanPostProcessor?implements?InstantiationAwareBeanPostProcessor?{
?@Override
?public?Object?postProcessBeforeInstantiation(Class<?> beanClass, String beanName)?throws?BeansException {
??if?("userService".equals(beanName)) {
???System.out.println("实例化前");
??}
??return?null;
?}
}
如上代码会导致，在userService这个Bean实例化前，会进行打印。
?
值得注意的是，postProcessBeforeInstantiation()是有返回值的，如果这么实现：
@Component
public?class?MemoryBeanPostProcessor?implements?InstantiationAwareBeanPostProcessor?{
?@Override
?public?Object?postProcessBeforeInstantiation(Class<?> beanClass, String beanName)?throws?BeansException {
??if?("userService".equals(beanName)) {
???System.out.println("实例化前");
???return?new?UserService();
??}
??return?null;
?}
}
?
userService这个Bean，在实例化前会直接返回一个由我们所定义的UserService对象。如果是这样，表示不需要Spring来实例化了，并且后续的Spring依赖注入也不会进行了，会跳过一些步骤，直接执行初始化后这一步。
在这个步骤中就会根据BeanDefinition去创建一个对象了。
首先判断BeanDefinition中是否设置了Supplier，如果设置了则调用Supplier的get()得到对象。
?
得直接使用BeanDefinition对象来设置Supplier，比如：
AbstractBeanDefinition?beanDefinition?=?BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setInstanceSupplier(new?Supplier<Object>() {
?@Override
?public?Object?get()?{
??return?new?UserService();
?}
});
context.registerBeanDefinition("userService", beanDefinition);
如果没有设置Supplier，则检查BeanDefinition中是否设置了factoryMethod，也就是工厂方法，有两种方式可以设置factoryMethod，比如：
?
方式一：
<bean id="userService"?class="com.memory.service.UserService"?factory-method="createUserService"?/>
对应的UserService类为：
public?class?UserService?{
?public?static?UserService?createUserService()?{
??System.out.println("执行createUserService()");
??UserService?userService?=?new?UserService();
??return?userService;
?}
?public?void?test()?{
??System.out.println("test");
?}
}
方式二：
<bean id="commonService"?class="com.Memory.service.CommonService"/>
<bean id="userService1"?factory-bean="commonService"?factory-method="createUserService"?/>
对应的CommonService的类为：
public?class?CommonService?{
?public?UserService?createUserService()?{
??return?new?UserService();
?}
}
?
Spring发现当前BeanDefinition方法设置了工厂方法后，就会区分这两种方式，然后调用工厂方法得到对象。
?
值得注意的是，我们通过@Bean所定义的BeanDefinition，是存在factoryMethod和factoryBean的，也就是和上面的方式二非常类似，@Bean所注解的方法就是factoryMethod，AppConfig对象就是factoryBean。如果@Bean所所注解的方法是static的，那么对应的就是方式一。
第一节已经讲过一遍大概原理了，后面有一节课单独分析源码实现。推断完构造方法后，就会使用构造方法来进行实例化了。
?
额外的，在推断构造方法逻辑中除开会去选择构造方法以及查找入参对象意外，会还判断是否在对应的类中是否存在使用**@Lookup注解**了方法。如果存在则把该方法封装为LookupOverride对象并添加到BeanDefinition中。
?
在实例化时，如果判断出来当前BeanDefinition中没有LookupOverride，那就直接用构造方法反射得到一个实例对象。如果存在LookupOverride对象，也就是类中存在@Lookup注解了的方法，那就会生成一个代理对象。
?
@Lookup注解就是方法注入，使用demo如下：
@Component
public?class?UserService?{
?private?OrderService orderService;
?public?void?test()?{
??OrderService?orderService?=?createOrderService();
??System.out.println(orderService);
?}
?@Lookup("orderService")
?public?OrderService?createOrderService()?{
??return?null;
?}
}
Bean对象实例化出来之后，接下来就应该给对象的属性赋值了。在真正给属性赋值之前，Spring又提供了一个扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()，可以对此时的BeanDefinition进行加工，比如：
@Component
public?class?MemoryMergedBeanDefinitionPostProcessor?implements?MergedBeanDefinitionPostProcessor?{
?@Override
?public?void?postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)?{
??if?("userService".equals(beanName)) {
???beanDefinition.getPropertyValues().add("orderService",?new?OrderService());
??}
?}
}
?
在Spring源码中，AutowiredAnnotationBeanPostProcessor就是一个MergedBeanDefinitionPostProcessor，它的postProcessMergedBeanDefinition()中会去查找注入点，并缓存在AutowiredAnnotationBeanPostProcessor对象的一个Map中（injectionMetadataCache）。
在处理完BeanDefinition后，Spring又设计了一个扩展点：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()，比如：
?
@Component
public?class?MemoryInstantiationAwareBeanPostProcessor?implements?InstantiationAwareBeanPostProcessor?{
?@Override
?public?boolean?postProcessAfterInstantiation(Object bean, String beanName)?throws?BeansException {
??if?("userService".equals(beanName)) {
???UserService?userService?=?(UserService) bean;
???userService.test();
??}
??return?true;
?}
}
上述代码就是对userService所实例化出来的对象进行处理。
?
这个扩展点，在Spring源码中基本没有怎么使用。
这里的自动注入指的是Spring的自动注入，后续依赖注入课程中单独讲
?
这个步骤中，就会处理@Autowired、@Resource、@Value等注解，也是通过**InstantiationAwareBeanPostProcessor.postProcessProperties()**扩展点来实现的，比如我们甚至可以实现一个自己的自动注入功能，比如：
@Component
public?class?MemoryInstantiationAwareBeanPostProcessor?implements?InstantiationAwareBeanPostProcessor?{
?@Override
?public?PropertyValues?postProcessProperties(PropertyValues pvs, Object bean, String beanName)?throws?BeansException {
??if?("userService".equals(beanName)) {
???for?(Field field : bean.getClass().getFields()) {
????if?(field.isAnnotationPresent(MemoryInject.class)) {
?????field.setAccessible(true);
?????try?{
??????field.set(bean,?"123");
?????}?catch?(IllegalAccessException e) {
??????e.printStackTrace();
?????}
????}
???}
??}
??return?pvs;
?}
}
关于@Autowired、@Resource、@Value的底层源码，会在后续的依赖注入课程中详解。
完成了属性赋值之后，Spring会执行一些回调，包括：
初始化前，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessBeforeInitialization()，比如
@Component
public?class?MemoryBeanPostProcessor?implements?BeanPostProcessor?{
?@Override
?public?Object?postProcessBeforeInitialization(Object bean, String beanName)?throws?BeansException {
??if?("userService".equals(beanName)) {
???System.out.println("初始化前");
??}
??return?bean;
?}
}
利用初始化前，可以对进行了依赖注入的Bean进行处理。
?
在Spring源码中：
这是Bean创建生命周期中的最后一个步骤，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessAfterInitialization()，比如：
@Component
public?class?MemoryBeanPostProcessor?implements?BeanPostProcessor?{
?@Override
?public?Object?postProcessAfterInitialization(Object bean, String beanName)?throws?BeansException {
??if?("userService".equals(beanName)) {
???System.out.println("初始化后");
??}
??return?bean;
?}
}
可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。