基础spring面试，简单学些面试技巧

spring 最好可以多看些源码，debug一下。

1、谈谈spring ioc的理解，原理与实现？

答：

控制反转：理论思想，原来的对象是由使用者来进行控制，有了spring之后，可以把整个对象交给spring来帮我们进行管理。

DI：依赖注入，把对应的属性的值注入到具体的对象中，@autowired 完成属性值的注入。

容器：存储对象，使用map结构来存储，在spring中一般存在三级缓存，singletonObjects存放完整的bean对象，整个bean的生命周期，从创建到使用到销毁的过程全部都是由容器来管理（bean的生命周期）

1、一般聊ioc容器的时候要涉及到容器的创建过程（beanFactory DefaultListableBeanFactory）向bean工厂中设置一些参数（BeanPostProcessor，Aware接口的子类）等等属性

2、加载解析bean对象，准备要创建的bean对象的定义对象beanDefinition，（xml或者注解的解析过程）

3、beanFactoryPostProcessor 的处理，此处是扩展点，PlaceHolderConfigurSupport，configurationClassPostProcessor

4、BeanPostProcessor 的注册功能，方便后续对bean对象完成具体的扩展功能

5、通过反射的方式将BeanDefinition 对象实例化成具体的bean对象。

6、bean对象的初始化过程（填充属性，调用aware子类的方法，调用BeanPostProcessor前置处理方法，调用init-mehtod方法，调用BeanPostProcessor后置处理方法）

7、生成完整的bean对象，通过getBean方法可以直接获取

8、调用destroy方法来销毁。

上面还有好多的可以面试的点。

如果你记不住，那么可以说，具体细节我记不太清楚，但是springz中的bean都是通过反射的方式生成的，同时包含了很多的扩展点，比如最常用的对BeanFactory的扩展，对bean的扩展（对占位符的处理），我们公司对这方面的使用是比较多的，除此之外，ioc最核心的就是填充属性。不到万不得已，最好把上面的记住。
 

2、谈一下spring ioc的底层实现。

你对他的理解，和你了解过的实现过程

反射，工厂，设计模式（会的说，不会的不说），关键的几个方法。

createBeanFactory，getBean，doGetBean，createBean，doCreateBean，

（加do的才是干活的，不加do的都是监工）

1、先通过createBeanFactory创建出一个Bean工厂（DefaultListableBeanFactory）

2、开始循环创建对象，因为容器中的bean默认都是单例的，所以优先通过getBean，doGetBean从容器中进行查找，若找不到

3、通过createBean，doCreateBean方法，以反射的方式来创建对象，一般情况下使用的是无参的构造方法(getDeclaredConstructor,newInstance)

4、进行对象属性的填充 populateBean

5、进行其他的初始化操作initializingBean

3、描述bean的生命周期

1、实例化Bean对象 （反射的方式生成对象）

       调用createBean进行实例化，通过获取BeanDefinition对象中的信息，实例化所有的bean，

2、设置Bean属性 （populateBean（），循环依赖问题（三级缓存））

       实例化的Bean被封装在BeanWrapper对象中，然后Spring根据BeanDefinition中的信息以及通过BeanWrapper提供的设置属性接口完成依赖注入。

3、如果通过各种Aware 接口声明了依赖关系，则会注入Bean对容器基础设施层面的依赖。

       Aware 包括，BeanNameAware、BeanFactoryAware、和ApplicationContextAware

注入 Bean Id；Bean Factory; ApplicationContext

4、如果实现BeanPostProcesser  调用其前置初始方法 postProcessBeforeInitialization

5、如果实现 InitializingBean 接口，调用afterPropertiesSet方法

6、调用Bean自身定义的init方法

7、调用BeanPostProcesser  的后置方法 postProcessAfterInitialization

创建完毕

销毁

8、调用DisposableBean 的destroy 或者自身的 destroy 方法

4、spring 是如何解决循环依赖的问题？

        三级缓存，提前暴露对象，aop

什么是循环依赖

1、先创建A对象，实例化A对象，此时A对象中的B属性为空

2、从容器中查找B对象，如果找到了，直接赋值不存在循环依赖问题（如果存在这不就是没有问题了么），找不到直接创建B对象。

3、实例化B对象，此时B对象中的A属性为空，填充属性A

4、从容器中查找A对象，找不到，直接创建。

形成闭环的原因。

        A对象是存在的，只不过此时的A对象不是一个完整的状态，只完成了实例化但是未完成初始化。如果在程序调用过程中，拥有了某个对象的引用，能否在后期给他完成赋值操作，可以优先把非完整状态的对象优先赋值，等待后续操作来完成赋值，相当于提前暴露了某个不完整对象的引用，所以解决问题的核心在于实例化和初始化分开操作，这也是解决循环依赖问题的关键。

        当所有的对象都完成实例化和初始化操作之后，还要把完整对象放在容器中，此时在容器中存在对象的几个状态，完成实例化-但未完成初始化，完整状态，因为都在容器中，所以要使用不同的map结构来进行存储，此时就引来一级缓存和二级缓存。

        如果一级缓存中有了，那么二级缓存中就不会存在同名的对象，因为他们的查找顺序是1，2，3这样的方式来查找的。一级缓存中放的是完整对象，二级缓存中存放的是非完整对象。

        为什么需要三级缓存？三级缓存的value类型是objectFactory，是一个函数式接口，存在的意义是保证在整个容器的运行过程中同名的bean对象只能有一个。

        如果一个对象需要被代理，或者说需要生成代理对象，那么要不要优先生成一个普通对象?

        普通对象和代理对象是不能同时出现在容器中的，因此当一个对象需要被代理的时候，就要使用代理对象覆盖掉之前的普通对象，在实际的调用过程中，是没有办法确定什么时候对象被使用，所以就要求当某个对象被调用的时候，优先判断是对象是否需要被代理，类似于一种回调机制的实现，因此传入lambda表达式的时候，可以通过lambda表达式来执行对象的覆盖过程，getEarlyBeanReference()

        因此，所有的bean对象在创建的时候都要优先放到三级缓存中，在后续的使用过程中，如果需要被代理则返回代理对象，如果不需要被代理，则直接返回普通对象。

能力有限，未完待续。。