Bean的生成过程

生成BeanDefinition

Spring启动时会先扫描，先调用 org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandid ateComponents(String basePackage) 扫描某个包路径，并得到BeanDefinition的Set集合。

Spring扫描底层流程

首先，通过ResourcePatternResolver获得指定包路径下的所有.class文件(源码中将此文件包装成了Resource对象)
遍历每个Resource对象
利用MetadataReaderFactory解析Resource对象得到MetadataReader(源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory， MetadataReader的具体实现类为SimpleMetadataReader)
利用MetadataReader进行excluderFilters和includeFilters,以及条件注解@Conditional的筛选(条件注解并不能理解：某个类上是否存在@Conditional注解，如果存在则调用注解中所指定的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉)
筛选通过后，基于metadataReader生成ScannedGeneriBeanDefiniton
再基于metadataReader判断是不是对应的类是不是接口或抽象类
如果筛选通过，那么就表示扫描到了一个Bean，将ScannedGenericBeanDefinition加入结果集

MetadataReader表示类的元数据读取器，主要包含了一个AnnotationMetadata,功能有

获取类的名字
获取父类的名字
获取所实现的所有接口名
获取所有内部类的名字
判断是不是抽象类
判断是不是接口
判断是不是一个注解
获取拥有某个注解的方法集合
获取类上添加的所有注解信息
获取类上添加的所有注解类型集合

值得注意的是，CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象时利用的ASM技术，并没有加载这个类到JVM。并且，最终得到的ScannedGeneriBeanDefinition对象，beanClass属性存储的是当前类的名字，而不是class对象。(beanClass属性的类型是Object，它即可以存储类的名字，也可以存储class对象)

最后，通过扫描得到BeanDefinition对象，还可以通过直接定义BeanDefinition，或解析spring.xml文件的,或者@Bean注解得到BeanDefinition对象。

合并BeanDefinition

通过扫描得到所有BeanDefinition之后，就可以根据BeanDefinition创建Bean对象了，但是在Spring中支持父子BeanDefinition，和java父子类类似，但是完全不是一回事。

父子BeanDefinition实际用的比较少，示例：

<bean id="parent" class="com.zxzg.service.Parent" scope="prototype"/>
<bean id="child" class="com.zxzg.service.Child"/>

这种定义，child是单例Bean

<bean id="parent" class="com.zxzg.service.Parent" scope="prototype"/>
<bean id="child" class="com.zxzg.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()锁返回的类加载器来加载

ClassUtils.getDefaultClassLoader()

有限返回当前线程中的ClassLoader
线程中类加载器为null的情况下，返回ClassUtils类的类加载器
如果ClassUtils类的类加载器为空，那么则表示是Bootstrap类加载器加载的ClassUtils类，那么则返回系统类加载器

实例化前

当前Beandifinition对应的类成功加载后，就可以实例化对象了，但在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制是否在某个或某些Bean实例化之前做一些启动动作。这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。比如：

@Component
public class ZxzgBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
throws BeansException {
if ("userService".equals(beanName)) {
System.out.println("实例化前");
}
return null;
}
}

如上代码会导致，在userService这个Bean实例化前，会进行打印。 userService这个Bean，在实例化前会直接返回一个所定义的UserService对象。如果是这样，表示不需要Spring来实例化了，并且后续的Spring依赖注入也不会进行了，会跳过一些步骤，直接执行初始化后这一步。

实例化

在这个步骤中就会根据BeanDefinition去创建一个对象了。

Supplier创建对象

首先判断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.zxzg.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.zxzg.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， Apconfig对象就是factoryBean。如果@Bean所注解的方法是static的，那么对应的就是方式一。

Bean的生命周期