1.扫描生成BeanDefinition

在创建bean之前，要进行扫描，扫描的主要目的是确定哪些对象可以被创建成bean。
扫描的主要步骤：
1.通过ResourcePatternResolver扫描classPath下面的所有class文件对象，注意是文件对象而不是class对象，在spring中扫描的 .class文件被封装成Resource对象
2.扫描到的Resource对象要进行解析，解析主要是通过MetadataReaderFactory进行解析，解析得到类元数据信息。
类元数据信息包括：类的名字，父类及父类的名字，实现的接口的名字，内部类的名字，判断是否是接口，判断是否是抽象类，判断是否是一个注解，获取类上添加的注解信息，获取方法上的注解信息，获取集合上的注解信息等。
3.扫描得到类的元数据之后，就要判断这些元数据信息能不能成为Bean。先进行一次基础判断，判断范围，该类有没有在excludeFilters配置的排除范围内，有的话就跳过。在判断类上是否存在@Conditional注解，如果存在则调用注解中所指定的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉。
4.范围满足之后，在判断类元数据中是否是一个内部类，是否是一个抽象类，是否是一个接口是的话过滤掉。
5.判断都满足之后，就会生成对应的BeanDefinition对象，就是对Bean进行定义的一个对象，告诉你这个对象是名称是什么，是单例还是原型，是不是primary等信息。
6.BeanDefinition生成之后其实有一些信息只是初始化状态，接下来还要生成BeanName，赋默认值，是否有@Lazy，@Primay等注解并进行赋值。
7.BeanDefinition就绪之后，会去容器里面判断，beanName是否存在，存在就抛出bean已存在异常，不存在BeanDefinition就注册到容器的BeanDefinitionMap中。
以上就是扫描的大致流程，扫描的目的就是的到BeanDefinition。
扫描的主要代码如下：

// ClassPathBeanDefinitionScanner.doScan()
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
        for (String basePackage : basePackages) {
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            for (BeanDefinition candidate : candidates) {
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                if (candidate instanceof AbstractBeanDefinition) {
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                if (candidate instanceof AnnotatedBeanDefinition) {
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }
                if (checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder =
                            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }

2.合并BeanDefinition

合并BeanDefinition现在应该是很少会碰到，早期xml方式的配置可能会出现这一步。如果BeanDefinition出现父子关系，spring就会进行合并生成一个新的BeanDefinition，而不是去修改他们，毕竟可能存在其他的BeanDefinition也继承该BeanDefinition。

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

上面就是bean的两个定义，并且具有父子关系。因为child的父BeanDefinition是parent，所以会继承parent上所定义的scope属性。而在根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition。主要逻辑如下：

// AbstractBeanFactory.getMergedLocalBeanDefinition()
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        // Quick check on the concurrent map first, with minimal locking.
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
        if (mbd != null) {
            return mbd;
        }
        return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    }

3.加载类

BeanDefinition就绪之后就会去实例化对象，但是在实例化对象之前就得先加载类。加载类就是读取BeanDefinition中所对应的class。如果beanClass属性的类型是Class，那么就直接返回，如果不是，则会根据类名进行加载。

// AbstractBeanFactory.resolveBeanClass()
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
            throws CannotLoadBeanClassException {
        try {
            if (mbd.hasBeanClass()) {
                return mbd.getBeanClass();
            }
            if (System.getSecurityManager() != null) {
                return AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>() {
                    @Override
                    public Class<?> run() throws Exception {
                        return doResolveBeanClass(mbd, typesToMatch);
                    }
                }, getAccessControlContext());
            }
            else {
                return doResolveBeanClass(mbd, typesToMatch);
            }
        }
        catch (PrivilegedActionException pae) {
            ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
            throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
        }
        catch (ClassNotFoundException ex) {
            throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
        }
        catch (LinkageError err) {
            throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
        }
    }

4.实例化前

BeanDefinition类加载成功之后，就可以开始着手实例化bean，但是spring实例化bean之前可以做一些自己的动作，这个事spring提供的一个扩展点。实现BeanPostProcessor接口可以在某个bean创建前做一些业务处理。

@Component
public class TestBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

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

5.实例化

实例化就是去创建一个对象，一般有几种方式
1.Supplier创建对象
首先判断BeanDefinition中是否设置了Supplier，如果设置了则调用Supplier的get()得到对象。
得直接使用BeanDefinition对象来设置Supplier，比如：

bstractBeanDefinition beanDefinition =
BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setInstanceSupplier(new Supplier<Object>() {
@Override
public Object get() {
return new UserService();
}
});
context.registerBeanDefinition("userService", beanDefinition);

2.工厂方法创建对象
如果没有设置Supplier，则检查BeanDefinition中是否设置了factoryMethod，也就是工厂方法，有
两种方式可以设置factoryMethod，比如：
方式一

<bean id="userService" class="com.testspring.service.UserService" factory-method="createUserService" />
// 对应代码
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.testspring.service.CommonService"/>
<bean id="userService1" factory‐bean="commonService" factory‐method="createUserService"/>
// 对应的CommonService的类为：
public class CommonService {
public UserService createUserService() {
return new UserService();
}
}

3.推断构造方法
当没有工厂方法的时候，就用构造函数来实例化，默认是用无参构造函数，多个构造函数就用无参的那个，只有一个的情况就用当前这个，多个且不包含无参需要指定，否则spring不知道用哪个构造函数。

6.实例化后

实例化后也是以扩展点的方式提供。和实例化前类似

@Component
public class TestInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("实例化后");
        }
        return true;
    }
}

7.自动注入

完成了对象实例化后，以及实例化前后的操作，就要开始对属性进行依赖注入，依赖注入是spring识别对应的@Autowired、@Resource、@Value等注解或构造函数进行注入。自动注入的逻辑还比较多，后面看下单独说，简单的说就是属性注入。

8.Aware执行

完成了属性赋值之后，Spring会执行一些回调，包括： 1. BeanNameAware：回传beanName给bean对象。 2. BeanClassLoaderAware：回传classLoader给bean对象。 3. BeanFactoryAware：回传beanFactory给对象。

9.初始化前

初始化前，也是Spring提供的一个扩展点： BeanPostProcessor.postProcessBeforeInitialization()

@Component 
public class TestBeanPostProcessor implements BeanPostProcessor { 
       @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
            if ("userService".equals(beanName)) { 
                System.out.println("初始化前"); 
            }
            return bean;
        }
} 

利用初始化可以对进行了依赖注入的Bean进行处理。
另外， InitDestroyAnnotationBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的 方法。

10.初始化

1. 查看当前Bean对象是否实现了InitializingBean接口，如果实现了就调用其afterPropertiesSet() 方法
2. 执行BeanDefinition中指定的初始化方法

11.初始化后

这也是Bean创建生命周期中的最后一个步骤，也是Spring提供的一个扩展点： BeanPostProcessor.postProcessAfterInitialization()，如：

@Component 
public class TestBeanPostProcessor 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对象。
AOP和上面提到的依赖注入 都是一个比较长的逻辑，后续考虑找个时间在单独梳理一下。

总结

通过上面几个步骤分解
大体可以知道bean的生成有这么几个步骤

大致流程

通过这样的梳理，希望能够彻底理解spring的bean是如何生成的，bean是什么样的存在。