Spring学习

1,你对Spring了解多少? (面试官问这个问题,我就想骂娘)
Spring是一个开源容器框架，它集成各类型的工具，
通过核心的Bean factory实现了底层的类的实例化和生命周期的管理。
在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，
包括动态加载和切面编程 ----- by百度百科

参考:
https://zhuanlan.zhihu.com/p/44630574
http://c.biancheng.net/view/4248.html

Spring有7个模块:
https://pic1.zhimg.com/80/v2-ac382952d4f122f7d7d50d81950586f0_720w.jpg

1、核心容器: 核心容器主要组件时BeanFactory,使用工厂模式它实现,BeanFactory使用控制反转(IOC)将配置和依赖于实际应用程序分开;
2、Spring 上下文：Spring 上下文是一个配置文件，向 Spring框架提供上下文信息。Spring 上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化、校验和调度功能。
3、Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
4、Spring DAO：JDBCDAO抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
5、Spring ORM：Spring 框架插入了若干个ORM框架，从而提供了 ORM 的对象关系工具，其中包括JDO、Hibernate和iBatisSQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
6、Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
7、Spring MVC 框架：MVC框架是一个全功能的构建 Web应用程序的 MVC 实现。通过策略接口，MVC框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。模型由javabean构成，存放于Map；视图是一个接口，负责显示模型；控制器表示逻辑代码，是Controller的实现。Spring框架的功能可以用在任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE 环境（Web 或EJB）、独立应用程序、测试环境之间重用。
----摘自 https://www.cnblogs.com/ysocean/p/7466191.html#_label0

Spring中的一些常用名词:
AOP: 切面编程 ,是一种思想,把一样的功能给抽取出来,具体应用有异常拦截,事务控制等
IOC: 反转控制,也是一种思想,简单得来说就是以前我们使用对象,是自己创建的, 现在直接向Spring容器(BeanFactory)要,
DI: 依赖注入,是实现IOC的一种常用方式, 还有一种实现方式叫依赖查找 参考: https://www.jianshu.com/p/c915ab6096d1

Spring源码过于庞大,我不知道从哪看?
所以找了一些关于Spring的一些面试题,目前的动机就是可以通过面试
一: Spring 框架中都用到了哪些设计模式？
工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例；
单例模式：Bean默认为单例模式。
代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；
模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。
观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，
所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–ApplicationListener。

二:Spring如何实现IOC的:
Spring 中的 IoC 的实现原理就是工厂模式加反射机制。

三:@Autowired和@Resource之间的区别
@Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false）。
@Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入。

下面一些问题.参考:https://blog.csdn.net/qq_36520235/article/details/88257749
四: Spring中bean的循环依赖怎么解决？
(1)什么是循环依赖?
循环依赖根据注入的时机分成两种类型：
构造器循环依赖:无解
设值循环依赖。Spring 框架只支持单例下的设值循环依赖
参考：https://www.jianshu.com/p/9ea61d204559
其实就是在进行getBean的时候，A对象中去依赖B对象，而B对象又依赖C对象，但是对象C又去依赖A对象，
出现了循环依赖,造成无法实例化，最终导致内存溢出的错误。

(2),Spring是如何解决循环依赖的? (只有在是单例的情况下才会去解决循环依赖问题)
参考:https://blog.csdn.net/lkforce/article/details/97183065
基本思路,虽然要初始化一个bean,必须要注入Bean里的依赖，才算初始化成功,
但并不要求此时依赖的依赖也都注入成功,只要依赖对象的构造方法执行完了，这个依赖对象就算存在了，
注入就算成功了，至于依赖的依赖，以后再初始化也来得及
因此，我们初始化一个Bean时，先调用Bean的构造方法，这个对象就在内存中存在了（对象里面的依赖还没有被注入），
然后把这个对象保存下来，当循环依赖产生时，直接拿到之前保存的对象，
于是循环依赖就被终止了，依赖注入也就顺利完成了。

为什么能解决循环依赖,看那个的三级缓存:
singletonObjects指单例对象的cache （一级缓存）
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
singletonFactories指单例对象工厂的cache（三级缓存）
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap

核心源码

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
 从一级缓存获取
   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);
            }
         }
      }
   }
   return (singletonObject != NULL_OBJECT ? singletonObject : null);}

解决循环依赖的过程:
步骤1: A首先完成了初始化的第一步，并且将自己提前曝光到 singletonFactories(三级缓存中) 中
步骤2: A开始获取自己的依赖对象B,发现B还没有被create，所以走create流程;
步骤3: B在初始化第一步的时候发现自己依赖了对象A，于是尝试get(A)，
尝试一级缓存 singletonObjects(肯定没有，因为A还没初始化完全)，
尝试二级缓存earlySingletonObjects（也没有），尝试三级缓存 singletonFactories，
由于A通过ObjectFactory将自己提前曝光了，所以B能够通过ObjectFactory.getObject拿到A对象(虽然还是个半成品)
步骤4: B拿到A对象后完成初始化,将自己放在 singletonObjects(一级缓存)中,
步骤5: A拿到依赖对象B之后,初始化完成

五: Spring中bean的加载过程？
①: 读取配置或者注解,获取Bean的配置信息
②: 对获取到的配置信息进行处理检验
③: 处理包装资源
④: 解析处理包装后的资源
⑤: 加载提取Bean并注册(添加到beanDefinitionMap中)

六: getBean方法的实现流程
直接看这里吧:https://blog.csdn.net/weixin_38278878/article/details/81408403

七: BeanFactory和FactoryBean的区别
参考:https://www.cnblogs.com/aspirant/p/9082858.html
BeanFactory:是一个工厂类接口,管理Bean的一个工厂,在Spring中BeanFactory是IOC容器的核心接口,主要职责:它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖
实现类有: DefaultListableBeanFactory,XmlBeanFactory,ApplicatiocContext
常用的是XmlBeanFactory,该实现将以XML方式描述组成应用的对象及对象间的依赖关系。
ApplicationContext不仅包含BeanFactory的作用,还加载其他功能,例如
• MessageSource, 提供国际化的消息访问
• 资源访问，如URL和文件
• 事件传播
• 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层;

FactoryBean : 参考 https://www.cnblogs.com/guitu18/p/11284894.html
FactoryBean是一个能生产或修饰对象生成的工厂Bean。一个Bean如果实现了FactoryBean接口，
那么根据该Bean的名称获取到的实际上是getObject()返回的对象，而不是这个Bean自身实例，
如果要获取这个Bean自身实例，那么需要在名称前面加上’&'符号。