-
Spring的出现就是为了更好的管理Bean，而IOC/DI/DL又是Spirng的核心，IOC在Spring中可以简单的理解为一个Map容器，帮我们管理控制着Bean的生命周期。
-
IOC -Inversion of control：控制反转，不是什么技术，而是一种设计思想，把对象的使用和创建分开了。
1、理解IOC/DI/DL
一切从Bean开始，IOC其实就是对我们的Bean进行管理；例如Bean加载，实例化，注册和管理。
例如，拿我们的SpringMVC为例，spring MVC本质上就是一个servlet，遵循了servlet的规范；在启动tomcat的时候，init()方法会完成以下工作：
-
第一步：JVM会扫描我们的jar或者war包，读取加载配置class文件，进行环境等变量的准备配置；
-
第二步：继续扫描业务字节码文件，包括相关的类，注解等class文件的全路径；
-
第三步：把第二步扫描出来的类通过反射进行实例化instance，然后注册到 IOC容器Map中；
-
第四步：完成 依赖查找注入DL 和 DI,实例化之后bean与bean之间的关系；例如加了@Resource @Autowire等注解的变量关系；
-
第五步：完成HandlerMapping的初始化，将加了@Controller和@RequestMapping的注解的url和method关系缓存到Map容器中；
-
第六步：容器启动完成，可以使用；
其中的3-4-5步骤都是在进行IOC的实现，将bean交给Spring容器托管。
继续理解什么是IOC/ID/DL，通过一段经常见的小代码来简单解释分析一下：
常见的Bean配置类：
@Configuration //配置类
public class AutowiredPersonConfig {
@Bean
public Person person(){
return new Person();
}
}功能代码实现的：IOC ，依赖注入和依赖查找。
@SpringBootApplication
public class SpringBootMainApp {
@Resource //DI 依赖注入
private Person person;
public static void main(String[] args) {
//IOC,所谓的控制反转，容器载入类，将Bean实例化，然后交给spring容器Map托管；
ApplicationContext app = new AnnotationConfigApplicationContext(AutowiredPersonConfig.class);
//DL 依赖查找，在容器中查找id=person的Bean实例对象；
Person person = (Person) app.getBean("person");
// TODO HERE
}
}
分析：容器启动载入类AnnotaionConfigApplicationContext完成Bean的装载和注册，@Resource里面就简单的实现了bean的依赖查找和注入。
1.1、IOC -(Inversion Of Control)
IOC-控制反转， 简单理解就是一个大的Map集合，主要用来存放Bean对象，new Person(); 根据容器载入类来加载Bean对象；
Spring的IOC有很多的Map容器。例如上面的代码，当服务在启动的时候，JVM会扫描我们的jar包，找到class文件中的配置类AutowiredPersonConfig.class，然后将相关加了@Configuratio和@Bean注解的实例Bean Person加入到容器map中，实际等价于做了如下操作：
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
singletonObjects.put("person",new Person());没有IOC之前，我们要使用对象的时候就需要自己先创建一个对象，自己控制对象的生产，获取相应的资源，另外每次产生一个对象就会往JVM内存中写入一些数据，占用了内存，也增加垃圾回收的行能消耗；
但是有了IOC之后，管理和控制就发生了反转：
-
控制了什么？对象的new创建和生命周期，相关的依赖资源获取；
-
反转给谁？管理权反转给Spring，由Spring的 ioc容器来控制Bean生命周期；
这个简单的过程其实就是IOC的过程，
1.2、DL-(Dependency looking )
DI-依赖查找。完成了Bean的加载，实例化和注册后，当我们要使用的时候，也就是依赖查找与注入的过程：
@Resource //DI&DL 依赖查找&注入
private Person person;实际上等价于执行了下面代码：
第一步：判断是否加了相关的注解信息：
先判断如果变量加了@Resource注解
if (field.isAnnotationPresent(Resource.class)) {
//todo 进行属性赋值；
}第二步：完成DL-依赖查找，从容器map中获取实例Bean Person:
Person person = singletonObjects.get("person");1.3、DI-(Dependency injection )
第三步：完成DI-依赖注入，通过反射将第一步从容器map中取到的person值设置到 private Person person; 这个变量中。
从MAP容器中获取Person对应的bean实例，并注入到变量person中，完成依赖注入：
field.setAccessible(true);
field.set(personInstance, person));
其实这也就是完成了person实例变量的依赖查找和注入过程。
2、Spring容器启动流程
下面来看一下Spring容器启动的主要流程：
ioc容器的初始化与Bean的创建：
-
第一步： refresh，容器刷新启动的时候，读取扫描jar／war包中的启动类配置文件bean.xml，载入类和application.properties文件；
-
第二步： 实例化BeanFactory这个Spring的最顶层的容器接口,创建完beanFactory，Spring就有了生产和获取getBean()的能力;另外，BeanFactory还提供一些后置处理器来保证我们的单实例非懒加载的业务bean正确创建；声明顶层map容器，初始化BeanFactory，使容器有getBean的能力；
-
第三步： finishBeanFactoryInitialization，对剩下的非懒加载单实例业务Bean进行实例化，继续扫描我们的jar或者war包，class文件，得到加了@Controller/@Component/@Service/@Repository等注解的所有要实例化的Bean的全路径名beanDefinationName；
-
第四步：通过BeanName开始从缓存也就是ioc容器map中直接获取bean实例：通过getBean()-doGetBean() ->getSingleton("beanName") —> map.getBean ("beanName")，先看IOC容器map缓存中是否有我们的singletonBean，有就 直接return，流程结束；
如果map缓存中没已实例化的Bean，则进行创建：
-
第一步：创建对象 ， createBean (),拿到class类对象，通过反射得到构造函数， 创建对象，new Person();
-
第二步：属性赋值 ； populateBean()：person. setName("king")
-
第三步：执行初始化方法 initializeBean ，代理对象通过applyBeanPostProcessorsBeforeInitializatio n和applyBeanPostProcessorsAfterInitialization进行增强bean的初始化前后增强 ；
-
至此，bean的创建完成，将单实例bean注册到ioc容器map中；
-
finishRefresh();Spring发送容器事件消息，我启动完成了，你可以做事情了；
3、Spring容器启动源码分析
下面通过源码具体分析一下Spring容器启动的主流程，从容器刷新开始：
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh(); //统一入口
}
refresh() 刷新开始：
@Override //容器刷新入口：
public void refresh() throws BeansException, IllegalStateException {
//调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
//1、告诉子类启动refreshBeanFactory()方法，实例化创建BeanFactory，用来获取和创建Bean；
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
//为BeanFactory配置容器特性，例如类加载器、事件处理器等
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
//aop相关bean的创建
//为BeanFactory注册BeanPost事件处理器.和业务bean执行的时机不一样而已，其他都一样；
//BeanPostProcessor是Bean后置处理器的创建，用于监听容器触发的事件
registerBeanPostProcessors(beanFactory);
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
//2、初始化所有剩余的非懒加载的单实例 — 业务Bean—也就是java中写的Bean文件；
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
//容器创建完成，为什么是finish，因为spring中有很多的事件监听机制，告诉监听者我启动完了，你可以做一些事情了；
finishRefresh();
}开始创建非懒加载的单实例业务Bean：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
//实例化所有剩下的非懒加载单实例业务Bean
beanFactory.preInstantiateSingletons();
}得到所有需要实例化的单实例Bean的全路径名，bean信息的定义 -用来生成这个bean的，然后挨个循环实例化：
@Override
public void preInstantiateSingletons() throws BeansException {
String FACTORY_BEAN_PREFIX = "&";
//得到所有的需要实例化的Bean的名字
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans…
//挨个循环获取或者创建这个beanName;
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {//获取或者创建这个bean
getBean(beanName);
}
}
}在创建一个bean之前，先到ioc容器map中去获取相关的bean，如果该bean已经创建，则直接获取返回，不再创建，如果容器map中没有，则进行创建。这也是单例的体现，只创建一次，每次获取的对象都是同一个，可以验证打印它的地址是相同的。
@Override //获取bean信息
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
继续获取bean：
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
//将bean标记为已创建
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
// Eagerly check singleton cache for manually registered singletons.
//通过bean的名字到我们的 IOC大map-其实就是一个缓存 中获取 bean；
Object sharedInstance = getSingleton(beanName);
//如果缓存中有这个bean，则直接返回；
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
//如果缓存中没有这个bean，则直接开始创建这个bean；
else {
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}从缓存容器map中获取bean单实例；
//private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//直接在map中get
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) { //同步获取；
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
//如果容器中有bean，则直接返回；
return singletonObject;
}如果容器中有这个单实例bean则直接返回创建的流程结束；如果缓存中还没有我们需要的实例Bean，这时候就会开始创建我们的Bean实例：
创建createBean实例的具体步骤：
-
第一步：通过反射创建对象，new Person();
-
第二步：属性赋值；person.set("king")
-
第三步：执行Bean初始化方法，对于动态代理的对象Bean进行init前后拦截增强；
具体实现如下：
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//给个机会返回一个代理对象，这里什么都没做，因为aop的bean是普通的bean的创建过程；
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
try {
//开始创建
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}创建bean，这里已经有内存地址了，也就是完成了对象的实例化：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//这里bean先创建对象，已经有内存地址；相当于Person person = new Person();
instanceWrapper = createBeanInstance(beanName, mbd, args);
}Spring是通过反射来创建对象，通过createBeanInstance()发现具体创建对象步骤如下：
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
//反射获取构造函数
constructorToUse = clazz.getDeclaredConstructor();
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
//第一步：反射创建实例完成 等价于Person person = new Person();
return BeanUtils.instantiateClass(constructorToUse);
}
Object exposedObject = bean;
try {
//第二步：属性的赋值和初始化，等价于 person.setName("king");
populateBean(beanName, mbd, instanceWrapper);
//第三步：bean的初始化
exposedObject = initializeBean(beanName, exposedObject, mbd);
}initializedBean主要是对bean完成一些初始化工作，比如在做动态代理的时候，这里就用到了，对当前的Bean初始化执行前和执行后做一些增强的处理工作，
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {//对bean的初始化
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//对bean出世化的前置处理器
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//对bean初始化的后置处理器
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}至此，一个业务bean的实例化就完成了，结束之后，将这个bean放入到我们的IOC容器map中去，供后期业务 DI/DL使用；
4、小结
IOC的主要任务就是创建对象Bean，同时通过DL和DI处理Bean之间的关联关系，创建的这些单例对象，所有线程共享，一次创建，到处使用。集中管理，统一分配，减少内存开销。
水滴石穿，积少成多。学习笔记，内容简单，用于复习，梳理巩固。
参考资料：
447
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
