Spring面试题/SpringBoot面试题

Spring

面试时，最好能结合底层代码说出IOC，AOP或Spring MVC的流程，能说出拦截器的底层。
如果看过Spring的源码，并能结合设计模式表达，是很大的加分项。

IOC

Q:讲一下IOC
IOC是"控制反转"。IOC将对象的控制权进行分离，交由第三方进行控制。
IOC容器负责创建对象，管理对象.
详情参见： https://blog.csdn.net/love_everybody/article/details/79836136
Q:为什么要用IOC？IOC有哪些优点？
代码量少。IOC或依赖注入把应用的代码量降到最低，它使应用容易测试。
松耦合。单例和JNDI查找机制，最小的代价和最小的侵入性使松耦合得以实现。
懒加载。IOC容器支持加载服务时的饿汉式初始化和懒加载。
Q:IOC和DI有什么区别？
IOC是控制反转，DI是依赖注入。
IOC通过DI实现。
控制反转是就是应用本身不负责依赖对象的创建和维护,依赖对象的创建及维护是由外部容器负责的,这样控制权就有应用转移到了外部容器,控制权的转移就是控制反转。
依赖注入是指:在程序运行期间,由外部容器动态地将依赖对象注入到组件中 如：一般，通过构造函数注入或者setter注入。

AOP

Q:讲一下AOP
面向切面编程。可以使用一个切面，作用于切点，然后添加前置通知、后置通知、异常通知。
简单点说，就是可以在代码前后添加固定的逻辑。
切面编程包括切面(Aspect)，连接点(Joinpoint)、通知(Advice)、切入点(Pointcut)、引入(Introduction)
通知(Advice)又分为前置通知，后置通知，最终通知，环绕通知，异常通知等。
@Aspect表明整个类是一个切面。
@Component标记该类是一个组件，spring扫描注解配置时，会标记这些类要生成bean
@Pointcut注解声明对应的方法为切入点。
AOP详情及示例见： https://www.cnblogs.com/expiator/p/8872479.html
Q:AOP的底层是怎么实现的？
动态代理。代理对象可以帮真实对象完成功能。
动态代理是通过反射实现的。
Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理。
JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。
JDK动态代理的核心是InvocationHandler接口和Proxy类。
如果目标类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成某个类的子类，CGLIB是通过继承的方式做的动态代理。
详情示例见： https://www.cnblogs.com/expiator/p/8394893.html
Q:你在实践中，使用aop做过哪些功能？
拦截器就是通过aop实现的。
使用aop，还可以实现自动切换数据源，还可以过滤日志。
Q:Aop，同一个类下的方法A和方法B作用于同一个切点，都是AOP前置通知，在A方法里面调用B，那么执行A方法的时候，会出现什么结果？会执行B的结果吗？

拦截器

Q:拦截器跟过滤器有什么区别？
过滤器基于Servlet的，而拦截器是基于Spring的。
拦截器还可以使用异常拦截，而过滤器只能是前后过滤。
Q:拦截器可以完成什么功能？
可以拦截特定的url、过滤日志
Q:讲一下拦截器的底层源码

注解

Q:@Compenent有什么用？
@Component标记该类是一个组件，spring扫描注解配置时，会标记这些类要生成bean
Q:@AutoWired和@Resource有什么区别？
@Autowired默认按类型匹配注入Bean。@Resource默认按名称匹配注入Bean

Q:注解的作用是什么？为什么要使用注解？
注解只能是被看作元数据，它不包含任何业务逻辑。注解更像是一个标签，一个声明，表面被注释的这个地方，将具有某种特定的逻辑。

Q:注解在Spring中的作用是什么？

(1)利用反射机制获取一个类的Class对象;
(2)通过这个class对象可以去获取他的每一个方法method，或字段Field等等;
(3)Method，Field等类提供了类似于getAnnotation()的方法来获取这一个字段的所有注解;
(4)拿到注解之后，我们可以判断这个注解是否是我们要实现的注解，如果是则实现注解逻辑。

Q:@AutoWired是怎么实现的？
通过反射实例化对象。

详情参考： https://blog.csdn.net/topdeveloperr/article/details/87971446?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.channel_param

Spring事务

Q:在Spring中怎么使用事务？
可以使用声明式事务，@Transactional 注解。
使用声明式事务，获取连接，关闭连接、事务提交、回滚、异常处理等这些操作都不用我们处理了，Spring都会帮我们处理。
也可以使用编程式事务，TransactionTemplate类。

Q:@Transactional是怎么实现的？
事务的过程为，打开事务，连接事务，然后进行业务逻辑操作，最后关闭事务。
@Transactional是通过AOP实现的。在业务操作的前面加入打开连接事务的代码，在业务操作的后面加入关闭事务的代码。

Q:@Transactioal有哪些属性参数？
value 和 transactionManager 属性：指定事务管理器。
propagation 属性：指定事务传播行为。
isolation 属性：指定事务的隔离级别，默认值为 Isolation.DEFAULT。
timeout 属性：事务超时时间。
readOnly 属性：指定事务是否为只读事务，默认值为 false；
rollbackFor 属性：用于指定能够触发事务回滚的异常类型。

Q: 讲一下@Transactional 注解失效的几种情况。
第一种：
Transactional注解标注方法修饰符为非public时，@Transactional注解将会不起作用。

第二种：
在类内部调用调用类内部@Transactional标注的方法。这种情况下也会导致事务不开启。
既然事务管理是基于动态代理对象的代理逻辑实现的，那么如果在类内部调用类内部的事务方法，这 个调用事务方法的过程并不是通过代理对象来调用的，而是直接通过this对象来调用方法，绕过的代理对 象，肯定就是没有代理逻辑了。

解决方法：
1.可以在service层 注入自己 用自己调用方法
2.新建一个service 通过注入新建的service调用方法
3.可以通过编程式事务管理 TransactionTemplate
参考资料： https://blog.csdn.net/xzx19930928/article/details/124247711

Q:服务层在方法A里面调用方法B，@Transactional注解修饰方法A，会出现哪些情况？怎么处理？

Q:spring 事务处理中，同一个类中，方法A（无事务）调用方法B（有事务）,事务会不会生效，为什么？有什么解决方法？

事务不会生效。

在一个Service内部，事务方法之间的嵌套调用，普通方法和事务方法之间的嵌套调用，都不会开启新的事务.

是因为spring采用动态代理机制来实现事务控制，而动态代理最终都是要调用原始对象的，而原始对象在去调用方法时，是不会再触发代理了。

详情见：https://blog.csdn.net/nextyu/article/details/78669997

解决方法：可以把方法B放到另外一个service或者dao，然后把这个server或者dao通过@Autowired注入到方法A的bean里面，这样即使方法A没用事务，方法B也可以执行自己的事务了。

Q:Spring 的不同事务传播行为有哪些，干什么用的？
当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行. 事务的传播行为可以由传播属性指定.
Spring 定义了7 种类传播行为.（一二两种最常用）

PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务，如果没有事务则开启。

PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务，如果一个事务已经存在，则将这个存在的事务挂起。

PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。

PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。

PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常。

PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。

Spring设计模式

Q:有没有了解过Spring是怎么设计，怎么实现的？

Q:在Spring中使用了哪些设计模式？
工厂模式。BeanFactory用来创建对象的实例。

单例模式。在Spring配置文件中定义的bean默认为单例模式。

代理模式。比如AOP基于动态代理。拦截器中也使用了代理ProxyFactoryBean。

策略模式。比如AOP中有两种策略，JDK动态代理，以及CgLib动态代理。

Spring Bean

Q:一个Spring Bean定义包含什么？
一个SpringBean 的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的生命周期详情及它的依赖。

Q:Spring Bean的生命周期是怎样的？

具体过程：启动容器 --> 通过getBean()调用某一个bean --> 实例化 --> 设置属性setter --> 设置 ApplicationContext --> 初始化方法 --> 判断Bean的作用域并调用 --> 销毁容器destroy

更详情的讲解参见： https://www.cnblogs.com/javazhiyin/p/10905294.html

Q:解释Spring支持的几种Bean的作用域(Score)。
Spring框架支持以下五种bean的作用域：

• singleton(单例) : bean在每个Spring ioc 容器中只有一个实例。
• prototype：一个bean的定义可以有多个实例。
• request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
• session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
• global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
  默认的Spring bean 的作用域是Singleton(单例)。

Q: Spring使用单例模式，有哪些优劣势？

优势：

单例的bean只有第一次创建新的bean 后面都会复用该bean，所以不会频繁创建对象。

可以快速获取到bean，因为单例的获取bean操作除了第一次生成之外其余的都是从缓存里获取的所以很快。

单例模式因为大大节省了实例的创建和销毁，有利于提高性能。

劣势：

单例的bean一个很大的劣势就是不能做到线程安全。

Q:Spring如何处理线程并发？
ThreadLocal。

而ThreadLocal用来保证线程安全性。

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？

实现的思路：在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。

Q:BeanFactory是什么？
BeanFactory是个Factory，也就是IOC容器或对象工厂。在Spring内部，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的，BeanFactory可以创建和管理各种类的对象。

Q:FactoryBean是什么？
Spring是通过反射机制利用Bean的class属性指定实现类实例化Bean。
Spring提供了FactoryBea工厂类接口，可以通过实现该工厂接口定制实例化Bean的逻辑。

Q:BeanFactory 和 FactoryBean的区别？
BeanFactory是个Factory，也就是IOC容器或对象工厂，在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的，提供了实例化对象和拿对象的功能。
FactoryBean是个Bean，是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似。

ApplicationContext

Q:ApplicationContext是什么？
应用上下文。

获取ApplicationContext接口后，就可以通过getBean()得到bean了。
ApplicationContext的实现类有ClassPathXmlApplicationContext和FileSystemXmlApplicationContext。

Q:BeanFactory和ApplicationContext的区别是什么？
1.从使用的角度看:

BeanFactory是Spring内部的IOC容器。而ApplicationContext是Spring框架提供给外部的。

2.两者装载bean的区别：

BeanFactory：在启动的时候不会去实例化Bean，只有从容器中拿Bean的时候才会去实例化；

ApplicationContext：在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化，懒加载；

详情参考： https://blog.csdn.net/csdnliuxin123524/article/details/78440168
Q:ApplicationContextAware的作用
实现ApplicationContextAware接口后，可以重写setApplicationContext(ApplicationContext applicationContext)方法,得到上下文环境对象applicationContext，再通过getBean()得到Spring容器中的Bean 。
代码详情见： https://www.cnblogs.com/expiator/p/15457830.html

Spring其他内容

Q:Spring有哪些注入方式 ？
构造器注入，getter/setter注入，工厂方法注入(包括静态工厂和非静态工厂)

Q:SpringSpring如何解决循环依赖？
通过构造器注入构成的循环依赖无法解决，通过setter注入可以解决循环依赖。
Spring是先将Bean对象实例化【依赖无参构造函数】--->再设置对象属性的。
具体过程：Spring先用无参的构造器实例化Bean对象----->将实例化结束的对象放到一个Map中，并且Spring提供获取这个未设置属性的实例化对象的引用方法。当Spring实例化了A、B、C对象后，紧接着会去设置对象的属性，此时对象A依赖对象B，就会去Map中取出存在里面的单例 B对象，以此类推，不会出来循环的问题喽。

Spring为了解决单例的循环依赖问题，使用了三级缓存。
singletonObjects：第一级缓存，里面放置的是实例化好的单例对象；
earlySingletonObjects：第二级缓存，里面存放的是提前曝光的单例对象；
singletonFactories：第三级缓存，里面存放的是要被实例化的代理的对象工厂（代理的Bean）。
创建bean的时候Spring首先从一级缓存singletonObjects中获取。如果获取不到，并且对象正在创建中，就再从二级缓存earlySingletonObjects中获取，如果还是获取不到就从三级缓存singletonFactories中取（Bean调用构造函数进行实例化后，即使属性还未填充，就可以通过三级缓存向外提前暴露依赖的引用值（提前曝光），根据对象引用能定位到堆中的对象，其原理是基于Java的引用传递），取到后从三级缓存移动到了二级缓存完全初始化之后将自己放入到一级缓存中供其他使用，
因为加入singletonFactories三级缓存的前提是执行了构造器，所以构造器的循环依赖没法解决。

详情见： https://blog.csdn.net/a745233700/article/details/110914620
参考资料： https://blog.csdn.net/qq_36381855/article/details/79752689

Q:为什么Spring解决循环依赖，需要三级缓存？
第三级缓存是用来存储代理Bean。
当调用getBean()方法时，如果发现目标Bean需要通过代理工厂来创建，此时会将创建好的实例保存到三级缓存，最终也会将赋值好的Bean同步到一级缓存中。
换个说法，就是如果对象需要通过代理工厂来创建，比如AOP，需要代理对象，而注入到其他bean的时候，并不是最终的代理对象，而是原始的对象。这时就需要通过三级缓存的ObjectFactory才能提前产生最终的需要代理的对象。

SpringMvc

Q:SpringMvc的底层原理是什么？
Spring的MVC框架是围绕DispatcherServlet来设计的，它用来处理HTTP请求和响应。

1.客户端请求提交到DispatcherServlet;

2.由DispatcherServlet控制器查询HandlerMapping，找到并分发到指定的Controller中。

3.Controller调用业务逻辑处理后，返回ModelAndView;

4.DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图;

5.视图负责将结果显示到客户端。

更具体的springMVC流程如下：

（1）：用户请求发送给DispatcherServlet，DispatcherServlet调用HandlerMapping处理器映射器；

（2）：HandlerMapping根据xml或注解找到对应的处理器，生成处理器对象返回给DispatcherServlet；

（3）：DispatcherServlet会调用相应的HandlerAdapter；

（4）：HandlerAdapter经过适配调用具体的处理器去处理请求，生成ModelAndView返回给DispatcherServlet

（5）：DispatcherServlet将ModelAndView传给ViewReslover解析生成View返回给DispatcherServlet；

（6）：DispatcherServlet根据View进行渲染视图；

->DispatcherServlet->HandlerMapping->Handler ->DispatcherServlet->HandlerAdapter处理handler->ModelAndView ->DispatcherServlet->ModelAndView->ViewReslover->View ->DispatcherServlet->返回给客户

Mybatis

Q:讲一下Mybatis的动态sql?

Q:讲一下Mybatis的缓存机制？
Mybatis存在一级缓存、二级缓存。默认的是一级缓存。
在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，SqlSession都会取出当前缓存的数据，而不会再次发送SQL到数据库。
二级缓存的开启需要进行配置，实现二级缓存的时候，配置方法很简单，只需要在映射XML文件配置就可以开启缓存了，指定缓存策略、超时时间、是否只读。

一级缓存是指 SqlSession 级别的缓存 原理：使用的数据结构是一个 map，如果两次中间出现 commit 操作 （修改、添加、删除），本 sqlsession 中的一级缓存区域全部清空

二级缓存是指可以跨 SqlSession 的缓存。是 mapper 级别的缓存； 原理： 是通过 CacheExecutor 实现的。CacheExecutor其实是 Executor 的代理对象

Q:Mybatis中用到了哪些设计模式？
代理模式。

Q:讲一下Jpa和Mybatis的区别。
jpa只能单表查询。mybatis可以手写sql进行多表查询。

jpa通过方法名就可以确定对应的sql。

SpringBoot面试题

Q:SpringBoot有哪些特点？
约定大于配置。内置依赖。自动配置
Q:SpringBoot的内置依赖是怎么实现的？
Q:SpringBoot的自动配置，是怎么实现的？

• 通过@EnableAutoConfiguration注解开启自动配置（@SpringBootApplication注解默认已包含@EnableAutoConfiguration）
• 会自动加载类路径下META-INF/spring.factories文件，读取以EnableAutoConfiguration的全限定类名对应的值，作为候选配置类。这里默认给出了很多组件的自动配置类。
• 自动配置类可能会再导入一些依赖（比如@Import），或者给出一些配置条件，并且会通过@Bean注解把该组件所包含的组件注入到spring容器中以供使用。
• （最后这一点比较绕，可以忽略不讲）自动配置类还可能会绑定xxxProperties配置文件类，该类又会和应用程序中的application.properties中的指定前缀绑定。第3步注入组件的时候，组件可能还会获取配置文件类中的内容，所以用户可以在application.properties修改指定配置，来制定自己的个性化服务。

注：自己打开一个SpringBoot项目，通过@SpringBootApplication注解点进去看一下源码，就基本会明白了。
详情见： https://blog.csdn.net/oldcunzhang/article/details/106529403

Q:SpringBoot怎么自定义一个starter?
(1)新建maven模块：
用SpringBoot新建一个Maven模块，指定Maven的pom.xml文件的goupid、artifactId。

(2)编写Properties类并配置(这一步感觉不是很重要)
写一个MyProperties的类，并用注解 @ConfigurationProperties(prefix = "myservice") 在类上面表示这是一个配置文件，
其中的属性字段可以在 application.properties中指定。prefix = "myservice"表示匹配 myservice前缀。

(3)编写一个自动配置类，以AutoConfiguration结尾
比如：MyServiceAutoConfiguration，绑定我们的配置文件、并将我们的服务注入到spring容器。
用@Configuration指明这是一个配置类，用@Bean注入。
用@EnableConfigurationProperties(MyProperties.class)绑定我们的配置文件类

(3)在META-INF/spring.factories新建文件，指定自动配置类的路径。
Spring Boot就能自动扫描到我们这个配置类并加载了。
比如：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
cn.test.starter.MyServiceAutoConfiguration

(4)把模块打包发布到maven仓库。
(5)新建一个Maven模块，就可以在pom.xml中导入我们打包好的 starter 依赖。

详情见： https://blog.csdn.net/oldcunzhang/article/details/106534500
重点关注小标题，通过小标题弄清楚具体的步骤。

Q:怎么替换SpringBoot中自带的Tomcat？
pom.xml文件中，在spring-boot-starter-web里面有tomcat的依赖，可以使用 exclusions 将 tomcat移除。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

再用 dependency添加其他的服务器，比如 undertow：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>
 
<dependency>
    <groupId>io.undertow</groupId>
    <artifactId>undertow-servlet</artifactId>
</dependency>

参考资料：

Spring常见的一些面试题
Spring面试题整理
最全Spring面试题总结
《精通Spring4.x企业应用开发实战》