Spring、Springmvc、Springboot、mybatis常见面试题收集（1）_spring和springboot面试题

Spring、Springmvc、Springboot、mybatis常见面试题收集（1）

1、说说springboot跟spring相比有什么优点？

典型回答

作为 Java 开发人员对 Spring 框架都很熟悉，Spring 为 Java 程序提供了全面的基础架构支持，包含了很多非常实用的功能，如 Spring JDBC、Spring AOP、Spring ORM、Spring Test 等，这些模块的出现，大大的缩短了应用程序的开发时间，同时提高了应用开发的效率。

Spring Boot 本质上是 Spring 框架的延伸和扩展，它的诞生是为了简化 Spring 框架初始搭建以及开发的过程，使用它可以不再依赖 Spring 应用程序中的 XML 配置，为更快、更高效的开发 Spring 提供更加有力的支持。Spring Boot 具体的特性如下。

Spring Boot 特性一：更快速的构建能力

Spring Boot 提供了更多的 Starters 用于快速构建业务框架，Starters 可以理解为启动器，它包含了一系列可以集成到应用里面的依赖包，你可以一站式集成 Spring 及其他技术，而不需要到处找依赖包。
例如在 Spring 中如果要创建 Web 应用程序的最小依赖项为：

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-web</artifactId>

    <version>xxx</version>

</dependency>

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-webmvc</artifactId>

    <version>xxx</version>

</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

而 Spring Boot 只需要一个依赖项就可以来启动和运行 Web 应用程序，如下所示：

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-web</artifactId>

</dependency>
1
2
3
4
5
6
7

当我们添加了 Starter 模块支持之后，在项目的构建期，它就会把所有其他依赖项将自动添加到项目中。
这样的例子还有很多，比如测试库，如果是 Spring 项目我们通常要添加 Spring Test、JUnit、Hamcrest 和 Mockito 库；而如果是 Spring Boot 项目的话，只需要添加 spring-boot-starter-test 即可，它会自动帮我们把其他的依赖项添加到项目中。

常见的 Starters 有以下几个：
●spring-boot-starter-test
●spring-boot-starter-web
●spring-boot-starter-data-jpa
●spring-boot-starter-thymeleaf
1
2
3
4
5

Spring Boot 特性二：起步依赖

Spring Boot 提供了起步依赖，也就是在创建 Spring Boot 时可以直接勾选依赖模块，这样在项目初始化时就会把相关依赖直接添加到项目中，大大缩短了查询并添加依赖的时间，

Spring Boot 特性三：内嵌容器支持

Spring Boot 内嵌了 Tomcat、Jetty、Undertow 三种容器，其默认嵌入的容器是 Tomcat，这个在我们启动 Spring Boot 项目的时候，在控制台上就能看到
可以看出 Spring Boot 默认使用的是 Tomcat 容器启动的。
我们可以通过修改 pom.xml 来移除内嵌的 Tomcat 更换为其他的容器，比如更换为 Jetty 容器，配置如下：

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

<!-- 移处 Tomcat -->

<exclusions>

    <exclusion>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-tomcat</artifactId>

    </exclusion>

</exclusions>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-jetty</artifactId>
1
2
3

当我们添加完成之后，再重新生成 pom.xml 文件，然后再启动 Spring Boot 项目容器信息就变了
比如 Spring Boot 的启动流程是怎么样的？
知识扩展
Spring Boot 启动源码分析
我们知道 Spring Boot 程序的入口是 SpringApplication.run(Application.class, args) 方法，那么就从 run() 方法开始分析吧，它的源码如下：

public ConfigurableApplicationContext run(String... args) {

    // 1.创建并启动计时监控类

    StopWatch stopWatch = new StopWatch();

    stopWatch.start();

    // 2.声明应用上下文对象和异常报告集合

    ConfigurableApplicationContext context = null;

    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();

    // 3.设置系统属性 headless 的值

    this.configureHeadlessProperty();

    // 4.创建所有 Spring 运行监听器并发布应用启动事件

    SpringApplicationRunListeners listeners = this.getRunListeners(args);

    listeners.starting();

    Collection exceptionReporters;

    try {

        // 5.处理 args 参数

        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

        // 6.准备环境

        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);

        this.configureIgnoreBeanInfo(environment);

        // 7.创建 Banner 的打印类

        Banner printedBanner = this.printBanner(environment);

        // 8.创建应用上下文

        context = this.createApplicationContext();

        // 9.实例化异常报告器

        exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);

        // 10.准备应用上下文

        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);

        // 11.刷新应用上下文

        this.refreshContext(context);

        // 12.应用上下文刷新之后的事件的处理

        this.afterRefresh(context, applicationArguments);

        // 13.停止计时监控类

        stopWatch.stop();

        // 14.输出日志记录执行主类名、时间信息

        if (this.logStartupInfo) {

            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);

        }

        // 15.发布应用上下文启动完成事件

        listeners.started(context);

        // 16.执行所有 Runner 运行器

        this.callRunners(context, applicationArguments);

    } catch (Throwable var10) {

        this.handleRunFailure(context, var10, exceptionReporters, listeners);

        throw new IllegalStateException(var10);

    }

    try {

        // 17.发布应用上下文就绪事件

        listeners.running(context);

        // 18.返回应用上下文对象

        return context;

    } catch (Throwable var9) {

        this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);

        throw new IllegalStateException(var9);

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

从以上源码可以看出 Spring Boot 的启动总共分为以下 18 个步骤。

Spring Boot 的启动流程
1.创建并启动计时监控类
此计时器是为了监控并记录 Spring Boot 应用启动的时间的，它会记录当前任务的名称，然后开启计时器。

2.声明应用上下文对象和异常报告集合
此过程声明了应用上下文对象和一个异常报告的 ArrayList 集合。

3.设置系统属性 headless 的值
设置 Java.awt.headless = true，其中 awt（Abstract Window Toolkit）的含义是抽象窗口工具集。设置为 true 表示运行一个 headless 服务器，可以用它来作一些简单的图像处理。

4.创建所有 Spring 运行监听器并发布应用启动事件
此过程用于获取配置的监听器名称并实例化所有的类。

5.初始化默认应用的参数类
也就是说声明并创建一个应用参数对象。

6.准备环境
创建配置并且绑定环境（通过 property sources 和 profiles 等配置文件）。

7.创建 Banner 的打印类
Spring Boot 启动时会打印 Banner 图片，如下图所示：

此 banner 信息是在 SpringBootBanner 类中定义的，我们可以通过实现 Banner 接口来自定义 banner 信息，然后通过代码 setBanner() 方法设置 Spring Boot 项目使用自己自定义 Banner 信息，或者是在 resources 下添加一个 banner.txt，把 banner 信息添加到此文件中，就可以实现自定义 banner 的功能了。

8.创建应用上下文
根据不同的应用类型来创建不同的 ApplicationContext 上下文对象。

9.实例化异常报告器
它调用的是 getSpringFactoriesInstances() 方法来获取配置异常类的名称，并实例化所有的异常处理类。

10.准备应用上下文
此方法的主要作用是把上面已经创建好的对象，传递给 prepareContext 来准备上下文，例如将环境变量 environment 对象绑定到上下文中、配置 bean 生成器以及资源加载器、记录启动日志等操作。

11.刷新应用上下文
此方法用于解析配置文件，加载 bean 对象，并且启动内置的 web 容器等操作。

12.应用上下文刷新之后的事件处理
这个方法的源码是空的，可以做一些自定义的后置处理操作。

13.停止计时监控类
停止此过程第一步中的程序计时器，并统计任务的执行信息。

14.输出日志信息
把相关的记录信息，如类名、时间等信息进行控制台输出。

15.发布应用上下文启动完成事件
触发所有 SpringApplicationRunListener 监听器的 started 事件方法。

16.执行所有 Runner 运行器
执行所有的 ApplicationRunner 和 CommandLineRunner 运行器。

17.发布应用上下文就绪事件
触发所有的 SpringApplicationRunListener 监听器的 running 事件。

18.返回应用上下文对象
到此为止 Spring Boot 的启动程序就结束了，我们就可以正常来使用 Spring Boot 框架了。

小结

首先讲了 Spring 和 Spring Boot 的区别，Spring Boot 本质上是 Spring 的延伸，它是基于 Spring 的，它为快速构建和开发 Spring 提供了有力的支撑；接着介绍了 Spring Boot 的四大特性：更快速的构建能力、起步依赖、内嵌容器支持、Actuator 监控支持等，最后 还介绍了 Spring Boot 启动的 18 个步骤。

2、说说springboot或者springMVC的执行流程？

1. 一个请求匹配前端控制器 DispatcherServlet 的请求映射路径(在 web.xml中指定), WEB 容器将该请求转交给DispatcherServlet 处理
2. DispatcherServlet 接收到请求后, 将根据请求信息交给处理器映射器 （HandlerMapping）
3. HandlerMapping 根据用户的url请求 查找匹配该url的 Handler，并返回一个执行链
4. DispatcherServlet 再请求 处理器适配器(HandlerAdapter) 调用相应的 Handler 进行处理并返回
   ModelAndView 给 DispatcherServlet
5. DispatcherServlet 将 ModelAndView 请求 ViewReslover（视图解析器）解析，返回具体 View
6. DispatcherServlet 对 View 进行渲染视图（即将模型数据填充至视图中）
7. DispatcherServlet 将页面响应给用户

3、运行springboot的main方法，发生了什么？

第一步：创建SpringApplication对象

执行initialize方法

第二步：运行run方法

三、自定义事件监听机制，判断执行顺利是否正确

ApplicationContextInitializer：
1.用于在spring容器刷新之前初始化Spring ConfigurableApplicationContext的回调接口。（剪短说就是在容器刷新之前调用该类的 initialize 方法。并将 ConfigurableApplicationContext 类的实例传递给该方法）
2.通常用于需要对应用程序上下文进行编程初始化的web应用程序中。例如，根据上下文环境注册属性源或激活配置文件等。
3.可排序的（实现Ordered接口，或者添加@Order注解）

SpringApplicationRunListener
作用主要就是在Spring Boot 启动初始化的过程中可以通过SpringApplicationRunListener接口回调来让用户在启动的各个流程中可以加入自己的逻辑


CommandLineRunner、ApplicationRunner
作用：需要在容器启动的时候执行一些内容。比如读取配置文件，数据库连接之类的，执行时机为容器启动完成的时候.

四、总结
1.启动时，首先创建SpringApplication对象，接着启动run方法。
2.run方法首先会从下META‐INF/spring.factories下获取有ApplicationContextInitializer（保存起来），和SpringApplicationRunListeners，并执行starting方法。
3.执行environmentPrepared表示环境准备完成，之后建ApplicationContext，决定创建web的ioc还是普通的ioc，回调ApplicationContextInitializer的initialize方法和SpringApplicationRunListener的contextPrepared方法。
4.执行SpringApplicationRunListener的contextLoaded方法：刷新容器，IOC容器初始化，同时扫描，创建，加载所有组件和自动配置。
5.SpringApplicationRunListener回调finished方法，这样整个SpringBoot应用启动完成以后,返回启动的IOC容器。

Springboot拦截器 过滤器 了解吗？

mybatis里#{}和${}有什么区别

#{}是预编译处理，
$ {}是字符串替换。
Mybatis在处理#{}时，会将sql中的#{}替换为？号，调用PreparedStatement的set方法来赋值；
Mybatis在处理$ {}时，就是把${}替换成变量的值。
使用#{}可以有效的防止SQL注入，提高系统安全性

Spring的IOC、Aop理解吗？

AOP

1.我所知道的aop
　　初看aop,上来就是一大堆术语，而且还有个拉风的名字，面向切面编程，都说是OOP的一种有益补充等等。一下子让你不知所措，心想着：怪不得很多人都和我说aop多难多难。当我看进去以后，我才发现：它就是一些java基础上的朴实无华的应用，包括ioc，包括许许多多这样的名词，都是万变不离其宗而已。

2.为什么用aop
　　1就是为了方便，看一个国外很有名的大师说，编程的人都是“懒人”，因为他把自己做的事情都让程序做了。用了aop能让你少写很多代码，这点就够充分了吧

2就是为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，这些其他的事情包括：安全，事物，日志等。

3.那些aop的术语
　　初看这么多术语，一下子都不好接受，慢慢来，很快就会搞懂。

1.通知（Advice）
1

就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下。

2.连接点（JoinPoint）
1

这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。

3.切入点（Pointcut）
1

上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。

4.切面（Aspect）
1

切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

5.引入（introduction）
1

允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

6.目标（target）
1

引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。

7.代理(proxy)
1

怎么实现整套aop机制的，都是通过代理，这个一会给细说。

8.织入(weaving)
1

把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时，为什么是运行时，后面解释。

关键就是：切点定义了哪些连接点会得到通知

4.我所理解的aop原理
　　spring用代理类包裹切面，把他们织入到Spring管理的bean中。也就是说代理类伪装成目标类，它会截取对目标类中方法的调用，让调用者对目标类的调用都先变成调用伪装类，伪装类中就先执行了切面，再把调用转发给真正的目标bean。

现在可以自己想一想，怎么搞出来这个伪装类，才不会被调用者发现（过JVM的检查，JAVA是强类型检查，哪里都要检查类型）。

1.实现和目标类相同的接口，我也实现和你一样的接口，反正上层都是接口级别的调用，这样我就伪装成了和目标类一样的类（实现了同一接口，咱是兄弟了），也就逃过了类型检查，到java运行期的时候，利用多态的后期绑定（所以spring采用运行时），伪装类（代理类）就变成了接口的真正实现，而他里面包裹了真实的那个目标类，最后实现具体功能的还是目标类，只不过伪装类在之前干了点事情（写日志，安全检查，事物等）。

这就好比，一个人让你办件事，每次这个时候，你弟弟就会先出来，当然他分不出来了，以为是你，你这个弟弟虽然办不了这事，但是他知道你能办，所以就答应下来了，并且收了点礼物（写日志），收完礼物了，给把事给人家办了啊，所以你弟弟又找你这个哥哥来了，最后把这是办了的还是你自己。但是你自己并不知道你弟弟已经收礼物了，你只是专心把这件事情做好。

顺着这个思路想，要是本身这个类就没实现一个接口呢，你怎么伪装我，我就压根没有机会让你搞出这个双胞胎的弟弟，那么就用第2种代理方式，创建一个目标类的子类，生个儿子，让儿子伪装我

2.生成子类调用，这次用子类来做为伪装类，当然这样也能逃过JVM的强类型检查，我继承的吗，当然查不出来了，子类重写了目标类的所有方法，当然在这些重写的方法中，不仅实现了目标类的功能，还在这些功能之前，实现了一些其他的（写日志，安全检查，事物等）。

这次的对比就是，儿子先从爸爸那把本事都学会了，所有人都找儿子办事情，但是儿子每次办和爸爸同样的事之前，都要收点小礼物（写日志），然后才去办真正的事。当然爸爸是不知道儿子这么干的了。这里就有件事情要说，某些本事是爸爸独有的(final的)，儿子学不了，学不了就办不了这件事，办不了这个事情，自然就不能收人家礼了。

前一种兄弟模式，spring会使用JDK的java.lang.reflect.Proxy类，它允许Spring动态生成一个新类来实现必要的接口，织入通知，并且把对这些接口的任何调用都转发到目标类。

后一种父子模式，spring使用CGLIB库生成目标类的一个子类，在创建这个子类的时候，spring织入通知，并且把对这个子类的调用委托到目标类。

相比之下，还是兄弟模式好些，他能更好的实现松耦合，尤其在今天都高喊着面向接口编程的情况下，父子模式只是在没有实现接口的时候，也能织入通知，应当做一种例外。

Spring的两种动态代理实现

一、原理区别：

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

如何强制使用CGLIB实现AOP？
（1）添加CGLIB库，SPRING_HOME/cglib/*.jar
（2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class=“true”/>

JDK动态代理和CGLIB字节码生成的区别？
（1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
（2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
因为是继承，所以该类或方法最好不要声明成final

IOC

这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。

那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。