spring 基础知识

一.什么是spring(对spring的理解)

spring是企业级开源开发框架，是一个轻量级AOP与IOC容器，为Java应用程序提供了基础性服务，简化了企业级应用程序开发。也有粘合剂的作用，实现了不同框架的整合。

二.spring的有点有哪些(项目使用spring的原因)

轻量级

控制反转：通过控制反转实现松耦合，对象们给出他们的依赖，而不是创建或查找依赖的对象们

面向切面编程：面向切面编程，将业务逻辑与系统服务分离

容器：spring包含并管理应用中对象的生命周期和配置

事务管理：spring提供了一个持续的事务管理接口，可扩展至上至本地事务下至全局事务。

mvc框架

异常处理：spring提供了方便的API,将具体的技术异常统一转换为unchecked异常

三.springIOC(控制反转)

什么是IOC或对IOC的了解

IOC是控制反转，将创建对象的控制权转移，之前对象创建的权限和时机是由我们自己把控，现在交给spring容器，容器依据配置文件管理对象的创建以及对象之间依赖关系。并且实现了对象之间的松耦合。IOC和DI依赖可以看作同一件事情的不同角度，应用在运行时通过IOC容器来实现对象需要的外部资源的注入。

1.@Autowired 与 @Resource

        共同点

                都是作为注入对象时的注解使用

                都可以注解在字段、set方法上

        不同点

               @Resource不是spring自己的注解， 使用需要导入包javax.annotation.Resource包

                @Autowired是spring提供的注解，使用需要导入org.springframework.beans.factory.annotation.Autowired包

                @Resource默认使用byName自动注入，有name、type两个属性，使用name属性就是通过byName自动注入，使用type就是使用byType自动注入

                @Autowired是使用类型(byType)装配依赖对象，要求依赖对象必须存在，如果允许为空则需要设置属性required=false,想要使用byName注入方式则需要与@Qualifier注解一起使用

2.依赖注入的方式有哪几种

        构造器注入

                优点：对象初始化完成后便可使用

                缺点：注入对象较多或不确定的情况构造函数的参数过长或需要重载

        set注入

                优点：注入灵活，可选择性的注入需要对象

                缺点：对象初始化完成后，依赖尚未注入不可使用

        注解注入

                优点：实现简单，使用方便

                缺点：无法实现final修饰的变量注入

        接口注入

        依赖类必须实现指定接口，并实现接口的一个函数，在函数中实现注入，侵入行太强不建议使用

3.循环依赖怎么解决（三级缓存、提前曝光）

        什么是循环依赖

        两个及两个以上对象相互持有对方（A依赖B,B依赖C,C又依赖A）,有属性循环依赖(可以解决)，构造器循环依赖(无法解决)

        属性循环依赖解决方案

        A完成初始化的第一步是将自身提前曝光(通过ObjectFactory)，并存放到缓存中(一般为三级缓存)，发现需要依赖B而B还未被创建，则B开始初始化，B发现依赖C,C也没被创建，则C开始初始化，C发现依赖A，而A已经在缓存中可以获取到。C拿到对象完成初始化将自己放在一级缓存中。

四.springAOP(面向切面)

1.什么是AOP

AOP是面向切面编程，他的将程序中那些与业无关却被业务模块共同调用的逻辑或责任封装起来，减少系统的重复代码，降低模块之间的耦合度，提高代码的可扩展性和可维护性。

2.AOP的原理是什么

AOP是基于动态代理的，如果要代理的对象实现了某个接口则使用JDK实现代理，如果没有实现某个接口，则由CGlib进行动态代理

3.spring AOP 与 AspectJ AOP

       AspectJ AOP是目前最完整的AOP框架

        spring AOP 已经集成了  AspectJ AOP

        spring AOP 是运行时增强 AspectJ AOP 是编译时增强

         spring AOP 时基于代理 AspectJ AOP时基于字节码

        当切面较少时两者性能差不多，当切面较多时 AspectJ AOP 性能更好

4.AOP核心概念

5.AOP通知（方法执行前或执行后要做的动作）

6.织入时期

五.springMVC

1.什么是MVC

        MVC是一种设计模式

        M -model 模型（完成业务逻辑，由javabean构成，service + dao + entity）

        V -view 试图

        C -controler 控制器（接收请求-》调用模型-》返回试图）

2.springMVC 调用逻辑

        用户发送请求至前端控制器DispatcherServlet 。

        DispatcherServlet收到请求调用 HandlerMapping 处理器映射器。

        处理器映射器找到具体的处理器( 可以根据 xml 配置、注解进行查找 ) ，生成处理器对象及处理器拦截器(如果有则生成 ) 一并返回给 DispatcherServlet 。

        DispatcherServlet调用 HandlerAdapter 处理器适配器。

        HandlerAdapter经过适配调用具体的处理器 (Controller ，也叫后端控制器 ) 。

         Controller执行完成返回 ModelAndView 。

        HandlerAdapter将 controller 执行结果 ModelAndView 返回给 DispatcherServlet 。

        DispatcherServlet将 ModelAndView 传给 ViewReslover 视图解析器。

         ViewReslover解析后返回具体 View 。

        DispatcherServlet根据 View 进行渲染视图（即将模型数据填充至视图中）。

        DispatcherServlet响应用户。

六.spring Bean

1.bean的生命周期

（ 1 ）实例化 Bean ：

对于 BeanFactory 容器，当客户向容器请求一个尚未初始化的 bean 时，或初始化 bean 的时候需要注

入另一个尚未初始化的依赖时，容器就会调用 createBean 进行实例化。对于 ApplicationContext 容

器，当容器启动结束后，通过获取 BeanDefinition 对象中的信息，实例化所有的 bean 。 （ 2 ）设置对象属性（依赖注入）：

实例化后的对象被封装在 BeanWrapper 对象中，紧接着， Spring 根据 BeanDefinition 中的信息 以

及 通过 BeanWrapper 提供的设置属性的接口完成依赖注入。

（ 3 ）处理 Aware 接口：

接着， Spring 会检测该对象是否实现了 xxxAware 接口，并将相关的 xxxAware 实例注入给 Bean ：

①如果这个 Bean 已经实现了 BeanNameAware 接口，会调用它实现的 setBeanName(String

beanId) 方法，此处传递的就是 Spring 配置文件中 Bean 的 id 值；

②如果这个 Bean 已经实现了 BeanFactoryAware 接口，会调用它实现的 setBeanFactory() 方法，传

递的是 Spring 工厂自身。

③如果这个 Bean 已经实现了 ApplicationContextAware 接口，会调用

setApplicationContext(ApplicationContext) 方法，传入 Spring 上下文；

（ 4 ） BeanPostProcessor ：

如果想对 Bean 进行一些自定义的处理，那么可以让 Bean 实现了 BeanPostProcessor 接口，那将会

调用 postProcessBeforeInitialization(Object obj, String s) 方法。

（ 5 ） InitializingBean 与 init-method ：

如果 Bean 在 Spring 配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。

（ 6 ）如果这个 Bean 实现了 BeanPostProcessor 接口，将会调用

postProcessAfterInitialization(Object obj, String s) 方法；由于这个方法是在 Bean 初始化结束时调

用的，所以可以被应用于内存或缓存技术；

以上几个步骤完成后， Bean 就已经被正确创建了，之后就可以使用这个 Bean 了。

（ 7 ） DisposableBean ：

当 Bean 不再需要时，会经过清理阶段，如果 Bean 实现了 DisposableBean 这个接口，会调用其实现

的 destroy() 方法；

（ 8 ） destroy-method ：

最后，如果这个 Bean 的 Spring 配置中配置了 destroy-method 属性，会自动调用其配置的销毁方

法。

2.bean的作用域

（ 1 ） singleton ：默认，每个容器中只有一个 bean 的实例，单例的模式由 BeanFactory 自身来维

护。

（ 2 ） prototype ：为每一个 bean 请求提供一个实例。

（ 3 ） request ：为每一个网络请求创建一个实例，在请求完成以后， bean 会失效并被垃圾回收器回

收。

（ 4 ） session ：与 request 范围类似，确保每个 session 中有一个 bean 的实例，在 session 过期后，

bean 会随之失效。

（ 5 ） global-session ：全局作用域， global-session 和 Portlet 应用相关。当你的应用部署在 Portlet

容器中工作时，它包含很多 portlet 。如果你想要声明让所有的 portlet 共用全局的存储变量的话，那

么这全局变量需要存储在 global-session 中。全局作用域与 Servlet 中的 session 作用域效果相同。

七.spring的事务管理

1.事务的隔离级别      

2.事务的传播级别

         ‌‌REQUIRED‌：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认的传播级别，适用于大多数场景。

        ‌‌SUPPORTS‌：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行。

        ‌‌MANDATORY‌：必须在事务中执行。如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

        ‌‌REQUIRES_NEW‌：创建一个新的事务，如果当前存在事务，则把当前事务挂起。适用于需要完全独立的事务执行的场景。

        ‌‌NOT_SUPPORTED‌：以非事务方式执行操作，如果当前存在事务，则把当前事务挂起。适用于不需要事务支持的场景。

        ‌‌NEVER‌：不能在事务中执行，如果当前存在事务，则抛出异常。适用于明确要求不在任何事务中执行的操作。

        ‌‌NESTED‌：如果当前存在事务，则创建一个嵌套事务作为当前事务的子事务；如果当前没有事务，则表现为REQUIRED行为。适用于需要嵌套事务的场景

3.事务的三要素

        数据源：表示具体的事务性资源，是事务的真正处理者，如 MySQL 等。

        事务管理器：像一个大管家，从整体上管理事务的处理过程，如打开、提交、回滚等。

        事务应用和属性配置：像一个标识符，表明哪些方法要参与事务，如何参与事务，以及一些相关属性如隔离级别、超时时间等。

        

4.spring的事务实现方式

        编程式事务管理：这意味着你可以通过编程的方式管理事务，这种方式带来了很大的灵活性，但很难维护。

        声明式事务管理：这种方式意味着你可以将事务管理和业务代码分离。你只需要通过注解或者XML配置管理事务。

5.spring的事务管理优点

        它为不同的事务API( 如 JTA, JDBC, Hibernate, JPA, 和 JDO) 提供了统一的编程模型。它为编程式事务管理提供了一个简单的API 而非一系列复杂的事务 API( 如 JTA). 它支持声明式事务管理。它可以和Spring 的多种数据访问技术很好的融合。

6.事务注解的本质

        @Transactional 这个注解仅仅是一些（和事务相关的）元数据，在运行时被事务基础设施读取消 费，并使用这些元数据来配置 bean 的事务行为 。 大致来说具有两方面功能， 一是表明该方法要参 与事务，二是配置相关属性来定制事务的参与方式和运行行为

        声明式事务主要是得益于Spring AOP 。使用一个事务拦截器，在方法调用的前后 / 周围进行事务性增强（advice ），来驱动事务完成。

        @Transactional注解既可以标注在类上，也可以标注在方法上。当在类上时，默认应用到类里的所有方法。如果此时方法上也标注了，则方法上的优先级高。 另外注意方法一定要是public 的。

八.spring用到的设计模式

简单工厂模式 ： Spring 中的 BeanFactory 就是简单工厂模式的体现。根据传入一个唯一的标识来获

得 Bean 对象，但是在传入参数后创建还是传入参数前创建，要根据具体情况来定。

工厂模式 ： Spring 中的 FactoryBean 就是典型的工厂方法模式，实现了 FactoryBean 接口的 bean

是一类叫做 factory 的 bean 。其特点是， spring 在使用 getBean() 调用获得该 bean 时，会自动调

用该 bean 的 getObject() 方法，所以返回的不是 factory 这个 bean ，而是这个 bean.getOjbect()

方法的返回值。

单例模式 ：在 spring 中用到的单例模式有： scope="singleton" ，注册式单例模式， bean 存放于

Map 中。 bean name 当做 key ， bean 当做 value 。

原型模式 ：在 spring 中用到的原型模式有： scope="prototype" ，每次获取的是通过克隆生成的新

实例，对其进行修改时对原有实例对象不造成任何影响。

迭代器模式 ：在 Spring 中有个 CompositeIterator 实现了 Iterator ， Iterable 接口和 Iterator 接

口，这两个都是迭代相关的接口。可以这么认为，实现了 Iterable 接口，则表示某个对象是可被迭

代的。 Iterator 接口相当于是一个迭代器，实现了 Iterator 接口，等于具体定义了这个可被迭代的

对象时如何进行迭代的。

代理模式 ： Spring 中经典的 AOP ，就是使用动态代理实现的，分 JDK 和 CGlib 动态代理。

适配器模式 ： Spring 中的 AOP 中 AdvisorAdapter 类，它有三个实现：

MethodBeforAdviceAdapter 、 AfterReturnningAdviceAdapter 、 ThrowsAdviceAdapter 。 Spring

会根据不同的 AOP 配置来使用对应的 Advice ，与策略模式不同的是，一个方法可以同时拥有多个

Advice 。 Spring 存在很多以 Adapter 结尾的，大多数都是适配器模式。

观察者模式 ： Spring 中的 Event 和 Listener 。 spring 事件： ApplicationEvent ，该抽象类继承了

EventObject 类， JDK 建议所有的事件都应该继承自 EventObject 。 spring 事件监听器：

ApplicationListener ，该接口继承了 EventListener 接口， JDK 建议所有的事件监听器都应该继承

EventListener 。

模板模式 ： Spring 中的 org.springframework.jdbc.core.JdbcTemplate 就是非常经典的模板模式

的应用，里面的 execute 方法，把整个算法步骤都定义好了。 责任链模式 ： DispatcherServlet 中的 doDispatch() 方法中获取与请求匹配的处理器

HandlerExecutionChain ， this.getHandler() 方法的处理使用到了责任链模式。