欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

后端开发面试题（八）Spring Boot篇

程序员文章站 2022-03-14 09:49:37
...

文章目录

一、概述

1.1 什么是 Spring Boot？

  Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的创建、运行、调试、部署等。使用Spring Boot可以做到专注于Spring应用的开发，而无需过多关注XML的配置。Spring Boot使用“习惯优于配置”的理念，简单来说，它提供了一堆依赖打包，并已经按照使用习惯解决了依赖问题。使用Spring Boot可以不用或者只需要很少的Spring配置就可以让企业项目快速运行起来。
  总的来说，其目的Spring Boot就是为了对Java web 的开发进行“简化”和加“快”速度，简化开发过程中引入或启动相关Spring 功能的配置。这样带来的好处就是降低开发人员对于框架的关注点，可以把更多的精力放在自己的业务代码上。

1.1.1 Spring Boot的核心功能

  • 1、独立运行的 Spring 项目
      Spring Boot 可以以 jar 包的形式独立运行，运行一个 Spring Boot 项目只需通过 java–jar xx.jar 来运行。
  • 2、内嵌 Servlet 容器
      Spring Boot 可选择内嵌 Tomcat、Jetty 或者 Undertow，这样我们无须以 war 包形式部署项目。
  • 3、提供 starter 简化 Maven 配置
      Spring 提供了一系列的 starter pom 来简化 Maven 的依赖加载。
  • 4、自动配置 Spring
      Spring Boot 会根据在类路径中的 jar 包、类，为 jar 包里的类自动配置 Bean，这样会极大地减少我们要使用的配置。当然，Spring Boot 只是考虑了大多数的开发场景，并不是所有的场景，若在实际开发中我们需要自动配置 Bean，而 Spring Boot 没有提供支持，则可以自定义自动配置。
  • 5、准生产的应用监控
      Spring Boot 提供基于 http、ssh、telnet 对运行时的项目进行监控。
  • 6、无代码生成和 xml 配置
      Spring Boot 的神奇的不是借助于代码生成来实现的，而是通过条件注解来实现的，这是 Spring 4.x 提供的新特性。Spring 4.x 提倡使用 Java 配置和注解配置组合，而 Spring Boot 不需要任何 xml 配置即可实现 Spring 的所有配置。

1.2 Spring Boot 有哪些优点？

  • 1、首先 SpringBoot可以快速一键快速搭建Spring框架，简化初始配置 ，可与主流框架集成 ；
  • 2、内置Servlet容器，无需在打War包 ；
  • 3、使用了Starter（启动器）管理依赖并版本控制；
  • 4、大量的自动配置，简化开发，方便集成第三方；
  • 5、提供准生产环境运行时的监控，如指标，健康，外部配置等；
  • 6、无需XML配置，减少冗余代码 ，开箱即用。

1.3 Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？

  启动类上面的注解是@SpringBootApplication，它也是 Spring Boot 的核心注解，主要组合包含了以下 3 个注解：

  • @SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。
  • @EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。
  • @ComponentScan：Spring组件扫描。

  对于这几个注解，更详细的解释可以参考如下文章：
  Spring Boot 核心注解与配置文件
  SpringBoot核心注解@SpringBootApplication和其他几个SpringBoot编写中常见注解

二、配置

2.1 什么是 JavaConfig？

  Spring JavaConfig 是 Spring 社区的产品，它提供了配置 Spring IoC 容器的纯Java 方法。因此它有助于避免使用 XML 配置。使用 JavaConfig 的优点在于：
   （1）面向对象的配置。由于配置被定义为 JavaConfig 中的类，因此用户可以充分利用 Java 中的面向对象功能。一个配置类可以继承另一个，重写它的@Bean 方法等。
   （2）减少或消除 XML 配置。基于依赖注入原则的外化配置的好处已被证明。但是，许多开发人员不希望在 XML 和 Java 之间来回切换。JavaConfig 为开发人员提供了一种纯 Java 方法来配置与 XML 配置概念相似的 Spring 容器。从技术角度来讲，只使用 JavaConfig 配置类来配置容器是可行的，但实际上很多人认为将JavaConfig 与 XML 混合匹配是理想的。
   （3）类型安全和重构友好。JavaConfig 提供了一种类型安全的方法来配置 Spring容器。由于 Java 5.0 对泛型的支持，现在可以按类型而不是按名称检索 bean，不需要任何强制转换或基于字符串的查找。

2.1.1 常见的注解和xml的对应关系

  java config是指基于java配置的spring。传统的Spring一般都是基本xml配置的，后来spring3.0新增了许多java config的注解，特别是spring boot，基本都是清一色的java config。

  • @Configuration
      在类上打上这一标签，表示这个类是配置类。
  • @ComponentScan
      相当于xml的<context:componentscan basepakage=>。
  • @Bean
      bean的定义，相当于xml的
     <bean id="objectMapper" class="org.codehaus.jackson.map.ObjectMapper" />
  • @EnableWebMvc
      相当于xml的< mvc:annotation-driven>。
  • @ImportResource
      相当于xml的 < import resource=“applicationContext-cache.xml”>。
  • @PropertySource
      spring 3.1开始引入，它是基于java config的注解，用于读取properties文件。

2.2 Spring Boot 自动配置原理是什么？

  Spring Boot的出现，得益于“习惯优于配置”的理念，没有繁琐的配置、难以集成的内容（大多数流行第三方技术都被集成），这是基于Spring 4.x提供的按条件配置Bean的能力。
  Spring Boot有一个全局配置文件：application.properties或application.yml。我们的各种属性都可以在这个文件中进行配置，最常配置的比如：server.port、logging.level.* 等等。

2.2.1 工作原理剖析

  Spring Boot关于自动配置的源码在spring-boot-autoconfigure-x.x.x.x.jar中，我们先看下源码中的@SpringBootApplication：
后端开发面试题（八）Spring Boot篇
  @SpringBootApplication是一个复合注解或派生注解，在@SpringBootApplication中有一个注解@EnableAutoConfiguration，该注解的作用是开启自动配置，其定义如下：
后端开发面试题（八）Spring Boot篇
  而这个注解也是一个派生注解，其中的关键功能由@Import提供，其导入的AutoConfigurationImportSelector的selectImports()方法通过SpringFactoriesLoader.loadFactoryNames()扫描所有具有META-INF/spring.factories的jar包。spring-boot-autoconfigure-x.x.x.x.jar里就有一个这样的spring.factories文件。
  这个spring.factories文件也是一组一组的key=value的形式，其中一个key是EnableAutoConfiguration类的全类名，而它的value是一个xxxxAutoConfiguration的类名的列表，这些类名以逗号分隔，如下图所示：
后端开发面试题（八）Spring Boot篇
  这个@EnableAutoConfiguration注解通过@SpringBootApplication被间接的标记在了Spring Boot的启动类上。在SpringApplication.run(…)的内部就会执行selectImports()方法，找到所有JavaConfig自动配置类的全限定名对应的class，然后将所有自动配置类加载到Spring容器中。

2.2.2 自动配置生效

  每一个XxxxAutoConfiguration自动配置类都是在某些条件之下才会生效的，这些条件的限制在Spring Boot中以注解的形式体现，常见的条件注解有如下几项：

@ConditionalOnBean：当容器里有指定的bean的条件下。
@ConditionalOnMissingBean：当容器里不存在指定bean的条件下。
@ConditionalOnClass：当类路径下有指定类的条件下。
@ConditionalOnMissingClass：当类路径下不存在指定类的条件下。
@ConditionalOnProperty：指定的属性是否有指定的值，比如@ConditionalOnProperties(prefix=”xxx.xxx”, value=”enable”, matchIfMissing=true)，代表当xxx.xxx为enable时条件的布尔值为true，如果没有设置的情况下也为true。

  以ServletWebServerFactoryAutoConfiguration配置类为例，解释一下全局配置文件中的属性如何生效，比如：server.port=8081，是如何生效的（当然不配置也会有默认值，这个默认值来自于org.apache.catalina.startup.Tomcat）。
后端开发面试题（八）Spring Boot篇
  在ServletWebServerFactoryAutoConfiguration类上，有一个@EnableConfigurationProperties注解：开启配置属性，而它后面的参数是一个ServerProperties类，这就是习惯优于配置的最终落地点。
后端开发面试题（八）Spring Boot篇
  在这个类上，我们看到了一个非常熟悉的注解：@ConfigurationProperties，它的作用就是从配置文件中绑定属性到对应的bean上，而@EnableConfigurationProperties负责导入这个已经绑定了属性的bean到spring容器中（见上面截图）。那么所有其他的和这个类相关的属性都可以在全局配置文件中定义，也就是说，真正“限制”我们可以在全局配置文件中配置哪些属性的类就是这些XxxxProperties类，它与配置文件中定义的prefix关键字开头的一组属性是唯一对应的。
  至此，我们大致可以了解。在全局配置的属性如：server.port等，通过@ConfigurationProperties注解，绑定到对应的XxxxProperties配置实体类上封装为一个bean，然后再通过@EnableConfigurationProperties注解导入到Spring容器中。
  而诸多的XxxxAutoConfiguration自动配置类，就是Spring容器的JavaConfig形式，作用就是为Spring 容器导入bean，而所有导入的bean所需要的属性都通过xxxxProperties的bean来获得。
  可能到目前为止还是有所疑惑，但面试的时候，其实远远不需要回答的这么具体，你只需要这样回答：

Spring Boot启动的时候会通过@EnableAutoConfiguration注解找到META-INF/spring.factories配置文件中的所有自动配置类，并对其进行加载，而这些自动配置类都是以AutoConfiguration结尾来命名的，它实际上就是一个JavaConfig形式的Spring容器配置类，它能通过以Properties结尾命名的类中取得在全局配置文件中配置的属性如：server.port，而XxxxProperties类是通过@ConfigurationProperties注解与全局配置文件中对应的属性进行绑定的。

  一定要记得XxxxProperties类的含义是：封装配置文件中相关属性；XxxxAutoConfiguration类的含义是：自动配置类，目的是给容器中添加组件。而其他的主方法启动，则是为了加载这些五花八门的XxxxAutoConfiguration类。
  该答案来自：
  Spring Boot面试杀手锏————自动配置原理

2.3 你如何理解 Spring Boot 配置加载顺序？

  使用 Spring Boot 会涉及到各种各样的配置，如开发、测试、线上就至少 3 套配置信息了。Spring Boot 可以轻松的帮助我们使用相同的代码就能使开发、测试、线上环境使用不同的配置。
  在 Spring Boot 里面，可以使用以下几种方式来加载配置。本章内容基于 Spring Boot 2.0 进行详解。
   1、properties文件；
   2、YAML文件；
   3、系统环境变量；
   4、命令行参数；
   等等……
  我们可以在 Spring Beans 里面直接使用这些配置文件中加载的值，如：
   1、使用 @Value 注解直接注入对应的值，这能获取到 Spring 中 Environment 的值；
   2、使用 @ConfigurationProperties 注解把对应的值绑定到一个对象；
   3、直接获取注入 Environment 进行获取；
  配置属性的方式很多，Spring boot使用了一种独有的 PropertySource 可以很方便的覆盖属性的值。

  • 1、配置属性加载的顺序
       1、开发者工具 Devtools 全局配置参数；
       2、单元测试上的 @TestPropertySource 注解指定的参数；
       3、单元测试上的 @SpringBootTest 注解指定的参数；
       4、命令行指定的参数，如 java -jar springboot.jar --name="Java技术栈"；
       5、命令行中的 SPRING_APPLICATION_JSONJSON 指定参数, 如 java -Dspring.application.json='{"name":"Java技术栈"}' -jar springboot.jar
       6、ServletConfig 初始化参数；
       7、ServletContext 初始化参数；
       8、JNDI参数（如 java:comp/env/spring.application.json）；
       9、Java系统参数（来源：System.getProperties()）；
       10、操作系统环境变量参数；
       11、RandomValuePropertySource 随机数，仅匹配：ramdom.*；
       12、JAR包外面的配置文件参数（application-{profile}.properties（YAML））
       13、JAR包里面的配置文件参数（application-{profile}.properties（YAML））
       14、JAR包外面的配置文件参数（application.properties（YAML））
       15、JAR包里面的配置文件参数（application.properties（YAML））
       16、@Configuration配置文件上 @PropertySource 注解加载的参数；
       17、默认参数（通过 SpringApplication.setDefaultProperties 指定）；
      数字小的优先级越高，即数字小的会覆盖数字大的参数值。
  • 2、springboot属性加载顺序
      优先级按照顺序由高到低，数字越小优先级越高。
  1. 在命令行中传入的参数。类似于java -jar -Dspring.profiles.active之类。
  2. SPRING_APPLICATION_JSON属性，该属性以JSON形式存储在系统环境变量中。
  3. java:comp/env中JNDI属性。
  4. Java的系统的属性，可通过System.getProperties()获得相关内容。
  5. 操作系统中的环境变量。
  6. 通过random.*配置的随机属性。
  7. 位于当前应用jar包外，针对不同{profile}环境的配置文件内容。
  8. 位于当前应用jar包内，针对不同{profile}环境的配置文件内容。
  9. 位于当前应用jar包外的application.properties或application.yml配置内容。
  10. 位于当前应用jar包内的application.properties或application.yml配置内容。
  11. 在@Configuration注解修改的类中，通过@PropertySource注解定义的属性。
  12. 应用默认属性，使用SpringApplication.setDefaultProperties定义的属性内容。

2.4 什么是 YAML？

  YAML 是一种人类可读的数据序列化语言。它通常用于配置文件。与属性文件相比，如果我们想要在配置文件中添加复杂的属性，YAML 文件就更加结构化，而且更少混淆。可以看出 YAML 具有分层配置数据。
  YAML是一种直观的能够被电脑识别的数据序列化格式，是一个可读性高并且容易被人类阅读，容易和脚本语言交互，用来表达资料序列的编程语言。

2.4.1 YAML 语法

  YAML 中可以允许表示三种格式，分别是常量值，对象和数组。它的语法结构是 key: value（注意，冒号后面必须有一个空格）。

  • 1、常量
name: 李某某 
flag: true
num: 56

  字符串不用加引号，如果加双引号不会把转义的符号给输出，单引号则相反，例如：

 name: "李\n某"   输出 ：
  李   
  某
-----------------------------
 name: '李\n某'   输出 ：
 李\n某
  • 2、数组
pets:
   - dog
   - cat
   - pig
# 或者
pets: [dog,cat,pig]
# 冒号和 - 后面的空格不能少
  • 3、对象
students:
   name: 李某某
   age: 18
   sex: 男
  # 或者
students: {name: 李某某,age: 18,sex: 男}

2.4.2 SpringBoot 配置文件

  SpringBoot 默认的配置文件是 properties 而，我们可以使用 yml 来实现配置文件的功能（更好用）。

2.5 YAML 配置的优势在哪里 ?

  YAML 现在可以算是非常流行的一种配置文件格式了，无论是前端还是后端，都可以见到 YAML 配置。那么 YAML 配置和传统的 properties 配置相比到底有哪些优势呢？
   1、配置有序，在一些特殊的场景下，配置有序很关键
   2、支持数组，数组中的元素可以是基本数据类型也可以是对象
   3、简洁
  相比 properties 配置文件，YAML 还有一个缺点，就是不支持 @PropertySource 注解导入自定义的 YAML 配置。

2.6 Spring Boot 是否可以使用 XML 配置 ?

  Spring Boot 推荐使用 Java 配置而非 XML 配置，但是 Spring Boot 中也可以使用 XML 配置，通过 @ImportResource 注解可以引入一个 XML 配置。

2.7 spring boot 核心配置文件是什么？bootstrap.properties 和 application.properties 有何区别 ?

  在 Spring Boot 中有以下两种配置文件：
   bootstrap (.yml 或者 .properties)
   application (.yml 或者 .properties)

2.7.1 bootstrap/ application 的区别

  Spring Cloud 构建于 Spring Boot 之上，在 Spring Boot 中有两种上下文，一种是 bootstrap, 另外一种是 application, bootstrap 是应用程序的父上下文，也就是说 bootstrap 加载优先于 applicaton。bootstrap 主要用于从额外的资源来加载配置信息，还可以在本地外部配置文件中解密属性。这两个上下文共用一个环境，它是任何Spring应用程序的外部属性的来源。bootstrap 里面的属性会优先加载，它们默认也不能被本地相同配置覆盖。
  因此，对比 application 配置文件，bootstrap 配置文件具有以下几个特性：

  • boostrap 由父 ApplicationContext 加载，比 applicaton 优先加载；
  • boostrap 里面的属性不能被覆盖。

2.7.2 bootstrap/ application 的应用场景

  application 配置文件这个容易理解，主要用于 Spring Boot 项目的自动化配置。
  bootstrap 配置文件有以下几个应用场景：

  • 使用 Spring Cloud Config 配置中心时，这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息；
  • 一些固定的不能被覆盖的属性；
  • 一些加密/解密的场景。

2.8 什么是 Spring Profiles？

  Spring Profiles 允许用户根据配置文件（dev，test，prod 等）来注册 bean。因此，当应用程序在开发中运行时，只有某些 bean 可以加载，而在 PRODUCTION中，某些其他 bean 可以加载。假设我们的要求是 Swagger 文档仅适用于 QA 环境，并且禁用所有其他文档。这可以使用配置文件来完成。Spring Boot 使得使用配置文件非常简单。

2.9 如何在自定义端口上运行 Spring Boot 应用程序？

  默认情况下，Spring Boot应用程序通过端口8080，在其内置的Tomcat服务器上提供服务。如果要更改默认端口，你只需修改Spring Boot应用程序在运行时自动读取的server.port属性。
  修改server.port属性值的3种常用方法：

  • 1、修改配置文件 application.properties
      在src / main / resources下创建application.properties文件，并在其中定义server.port属性，如：
server.port=9090
  • 2、通过 EmbeddedServletContainerCustomizer 接口
      可以通过实现EmbeddedServletContainerCustomizer接口，自定义默认servlet容器的属性，CustomContainer 内部定义的端口会覆盖 application.properties 中定义的值。
  • 3、命令行
      第三种方法是通过命令行，在启动应用程序时明确设置端口，可以通过两种不同的方式来实现：

java -Dserver.port = 9090 -jar executable.jar
java -jar executable.jar -server.port = 9090

  注意，使用这种方式定义的端口将覆盖通过其他方式定义的端口配置值。
 小结
  更改默认端口，通过启动命令参数方式，灵活，而且优先级最高，通过 EmbeddedServletContainerCustomizer 接口的方式次之，application.properties文件配置方式都会被前两种方式覆盖。
  一般来说，生产环境下，application.properties文件配置方式最为常用。

三、安全

3.1 如何实现 Spring Boot 应用程序的安全性？

  为了实现 Spring Boot 的安全性，我们使用 spring-boot-starter-security 依赖项，并且必须添加安全配置。它只需要很少的代码。配置类将必须扩展WebSecurityConfigurerAdapter 并覆盖其方法。

3.2 比较一下 Spring Security 和 Shiro 各自的优缺点 ?

  Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
  Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于Spring的应用程序的实际标准。Spring Security致力于为Java应用程序提供身份验证和授权。与所有Spring项目一样，Spring Security的真正强大之处在于可以轻松扩展以满足自定义要求。
  两者相同点：
   1、认证功能
   2、授权功能
   3、加密功能
   4、会话管理
   5、缓存支持
   6、rememberMe功能
   … …
 两者不同点（总结一）
  1、Spring Security 基于Spring 开发，项目若使用 Spring 作为基础，配合 Spring Security 做权限更加方便，而 Shiro 需要和 Spring 进行整合开发；
  2、Spring Security 功能比 Shiro 更加丰富些，例如安全维护方面；
  3、Spring Security 社区资源相对比 Shiro 更加丰富；
  4、Shiro 的配置和使用比较简单，Spring Security 上手复杂些；
  5、Shiro 依赖性低，不需要任何框架和容器，可以独立运行.Spring Security 依赖Spring容器；
  6、shiro 不仅仅可以使用在web中，它可以工作在任何应用环境中。在集群会话时Shiro最重要的一个好处或许就是它的会话是独立于容器的。
 两者不同点（总结二）

  • Spring Security 是一个重量级的安全管理框架；Shiro是一个轻量级的安全管理框架。
  • Spring Security概念复杂，配置繁琐；Shiro概念简单，配置简单。
  • Spring Security功能强大，Shiro功能简单。

3.3 Spring Boot 中如何解决跨域问题 ?

  同源策略是由 网景通信公司(Netscape) 提出的一个著名的安全策略，它是浏览器最核心也最基本的安全功能，现在所有支持 JavaScript 的浏览器都会使用这个策略。所谓同源是指协议、域名以及端口要相同。
  在我们Web开发过程中，经常会遇到跨域问题，就是因为浏览器受到同源策略的限制，对于非同源，Cookie、LocalStorage 和 IndexDB 无法读取； DOM 无法获得；AJAX 请求不能发送。
  解决跨域问题方法有三种：

  • 第一种办法
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
                .allowCredentials(true)
                .maxAge(3600)
                .allowedHeaders("*");
    }
}

  这种方式是全局配置的，但是很多都是基于旧的spring版本。

  • 第二种办法
import org.springframework.context.annotation.Configuration;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter(filterName = "CorsFilter ")
@Configuration
public class CorsFilter implements Filter {
    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        response.setHeader("Access-Control-Allow-Origin","*");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, PATCH, DELETE, PUT");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
        chain.doFilter(req, res);
    }
}

  这种办法，是基于过滤器的方式，方式简单明了，就是在response中写入这些响应头。

  • 第三种办法
public class GoodsController {

    @CrossOrigin(origins = "http://localhost:4000")
    @GetMapping("goods-url")
    public Response queryGoodsWithGoodsUrl(@RequestParam String goodsUrl) throws Exception {}
}

  就是@CrossOrigin注解，这个是最小粒度的cors控制办法了，精确到单个请求级别。

3.4 什么是 CSRF 攻击？如何防范？

  CSRF（Cross-site request forgery）也被称为 one-click attack或者 session riding，中文全称是叫跨站请求伪造。
  一般来说，攻击者通过伪造用户的浏览器的请求，向访问一个用户自己曾经认证访问过的网站发送出去，使目标网站接收并误以为是用户的真实操作而去执行命令。常用于盗取账号、转账、发送虚假消息等。攻击者利用网站对请求的验证漏洞而实现这样的攻击行为，网站能够确认请求来源于用户的浏览器，却不能验证请求是否源于用户的真实意愿下的操作行为。
 如何防范

  • 1、验证 HTTP Referer 字段
      HTTP头中的Referer字段记录了该 HTTP 请求的来源地址。在通常情况下，访问一个安全受限页面的请求来自于同一个网站，而如果黑客要对其实施 CSRF攻击，他一般只能在他自己的网站构造请求。因此，可以通过验证Referer值来防御CSRF 攻击。
  • 2、使用验证码
      关键操作页面加上验证码，后台收到请求后通过判断验证码可以防御CSRF。但这种方法对用户不太友好。
  • 3、在请求地址中添加token并验证
      CSRF 攻击之所以能够成功，是因为黑客可以完全伪造用户的请求，该请求中所有的用户验证信息都是存在于cookie中，因此黑客可以在不知道这些验证信息的情况下直接利用用户自己的cookie 来通过安全验证。要抵御 CSRF，关键在于在请求中放入黑客所不能伪造的信息，并且该信息不存在于 cookie 之中。可以在 HTTP 请求中以参数的形式加入一个随机产生的 token，并在服务器端建立一个拦截器来验证这个 token，如果请求中没有token或者 token 内容不正确，则认为可能是 CSRF 攻击而拒绝该请求。这种方法要比检查 Referer 要安全一些，token 可以在用户登陆后产生并放于session之中，然后在每次请求时把token 从 session 中拿出，与请求中的 token 进行比对，但这种方法的难点在于如何把 token 以参数的形式加入请求。
      对于 GET 请求，token 将附在请求地址之后，这样 URL 就变成 http://url?csrftoken=tokenvalue。
      而对于 POST 请求来说，要在 form 的最后加上 < input type=“hidden” name=“csrftoken” value=“tokenvalue”/>，这样就把token以参数的形式加入请求了。
  • 4、在HTTP 头中自定义属性并验证
      这种方法也是使用 token 并进行验证，和上一种方法不同的是，这里并不是把 token 以参数的形式置于 HTTP 请求之中，而是把它放到 HTTP 头中自定义的属性里。通过 XMLHttpRequest 这个类，可以一次性给所有该类请求加上 csrftoken 这个 HTTP 头属性，并把 token 值放入其中。这样解决了上种方法在请求中加入 token 的不便，同时，通过 XMLHttpRequest 请求的地址不会被记录到浏览器的地址栏，也不用担心 token 会透过 Referer 泄露到其他网站中去。

四、监视器

4.1 Spring Boot 中的监视器是什么？

  Spring boot actuator 是 spring 启动框架中的重要功能之一。Spring boot 监视器可帮助您访问生产环境中正在运行的应用程序的当前状态。有几个指标必须在生产环境中进行检查和监控。即使一些外部应用程序可能正在使用这些服务来向相关人员触发警报消息。监视器模块公开了一组可直接作为 HTTP URL 访问的REST 端点来检查状态。

4.2 如何在 Spring Boot 中禁用 Actuator 端点安全性？

  默认情况下，所有敏感的 HTTP 端点都是安全的，只有具有 ACTUATOR 角色的用户才能访问它们。安全性是使用标准的 HttpServletRequest.isUserInRole 方法实施的。 我们可以使用来禁用安全性。只有在执行机构端点在防火墙后访问时，才建议禁用安全性。

4.3 我们如何监视所有 Spring Boot 微服务？

  Spring Boot 提供监视器端点以监控各个微服务的度量。这些端点对于获取有关应用程序的信息（如它们是否已启动）以及它们的组件（如数据库等）是否正常运行很有帮助。但是，使用监视器的一个主要缺点或困难是，我们必须单独打开应用程序的知识点以了解其状态或健康状况。想象一下涉及 50 个应用程序的微服务，管理员将不得不击中所有 50 个应用程序的执行终端。为了帮助我们处理这种情况，我们将使用位于的开源项目。 它建立在 Spring Boot Actuator 之上，它提供了一个 Web UI，使我们能够可视化多个应用程序的度量。

五、整合第三方项目

5.1 什么是 WebSockets？

  WebSocket 是一种计算机通信协议，通过单个 TCP 连接提供全双工通信信道。
  1、WebSocket 是双向的 -使用 WebSocket 客户端或服务器可以发起消息发送。
  2、WebSocket 是全双工的 -客户端和服务器通信是相互独立的。
  3、单个 TCP 连接 -初始连接使用 HTTP，然后将此连接升级到基于套接字的连接。然后这个单一连接用于所有未来的通信
  4、Light -与 http 相比，WebSocket 消息数据交换要轻得多。

5.2 什么是 Spring Data ?

  Spring Data 是 Spring 的一个子项目。用于简化数据库访问，支持NoSQL 和 关系数据存储。其主要目标是使数据库的访问变得方便快捷。Spring Data 具有如下特点：

  • 1、SpringData 项目支持 NoSQL 存储：
      MongoDB （文档数据库）
      Neo4j（图形数据库）
      Redis（键/值存储）
      Hbase（列族数据库）
  • 2、SpringData 项目所支持的关系数据存储技术：
      JDBC
      JPA

  Spring Data Jpa 致力于减少数据访问层 (DAO) 的开发量. 开发者唯一要做的，就是声明持久层的接口，其他都交给 Spring Data JPA 来帮你完成！Spring Data JPA 通过规范方法的名字，根据符合规范的名字来确定方法需要实现什么样的逻辑。

5.3 什么是 Spring Batch？

  Spring Boot Batch 提供可重用的函数，这些函数在处理大量记录时非常重要，包括日志/跟踪，事务管理，作业处理统计信息，作业重新启动，跳过和资源管理。它还提供了更先进的技术服务和功能，通过优化和分区技术，可以实现极高批量和高性能批处理作业。简单以及复杂的大批量批处理作业可以高度可扩展的方式利用框架处理重要大量的信息。

5.4 什么是 FreeMarker 模板？

  FreeMarker 是一个基于 Java 的模板引擎，最初专注于使用 MVC 软件架构进行动态网页生成。使用 Freemarker 的主要优点是表示层和业务层的完全分离。程序员可以处理应用程序代码，而设计人员可以处理 html 页面设计。最后使用freemarker 可以将这些结合起来，给出最终的输出页面。

5.5 如何集成 Spring Boot 和 ActiveMQ？

  对于集成 Spring Boot 和 ActiveMQ，我们使用依赖关系。 它只需要很少的配置，并且不需要样板代码。

5.6 什么是 Apache Kafka？

  Apache Kafka 是一个分布式发布 - 订阅消息系统。它是一个可扩展的，容错的发布 - 订阅消息系统，它使我们能够构建分布式应用程序。这是一个 Apache *项目。Kafka 适合离线和在线消息消费。

5.7 什么是 Swagger？你用 Spring Boot 实现了它吗？

  Swagger 广泛用于可视化 API，使用 Swagger UI 为前端开发人员提供在线沙箱。Swagger 是用于生成 RESTful Web 服务的可视化表示的工具，规范和完整框架实现。它使文档能够以与服务器相同的速度更新。当通过 Swagger 正确定义时，消费者可以使用最少量的实现逻辑来理解远程服务并与其进行交互。因此，Swagger消除了调用服务时的猜测。

5.8 前后端分离，如何维护接口文档 ?

  前后端分离开发日益流行，大部分情况下，我们都是通过 Spring Boot 做前后端分离开发，前后端分离一定会有接口文档，不然会前后端会深深陷入到扯皮中。一个比较笨的方法就是使用 word 或者 md 来维护接口文档，但是效率太低，接口一变，所有人手上的文档都得变。在 Spring Boot 中，这个问题常见的解决方案是 Swagger ，使用 Swagger 我们可以快速生成一个接口文档网站，接口一旦发生变化，文档就会自动更新，所有开发工程师访问这一个在线网站就可以获取到最新的接口文档，非常方便。

六、其他

6.1 如何重新加载 Spring Boot 上的更改，而无需重新启动服务器？Spring Boot项目如何热部署？

  这可以使用 DEV 工具来实现。通过这种依赖关系，您可以节省任何更改，嵌入式tomcat 将重新启动。Spring Boot 有一个开发工具（DevTools）模块，它有助于提高开发人员的生产力。Java 开发人员面临的一个主要挑战是将文件更改自动部署到服务器并自动重启服务器。开发人员可以重新加载 Spring Boot 上的更改，而无需重新启动服务器。这将消除每次手动部署更改的需要。Spring Boot 在发布它的第一个版本时没有这个功能。这是开发人员最需要的功能。DevTools 模块完全满足开发人员的需求。该模块将在生产环境中被禁用。它还提供 H2 数据库控制台以更好地测试应用程序。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

6.2 您使用了哪些 starter maven 依赖项？

  使用了下面的一些依赖项：
   spring-boot-starter-activemq
   spring-boot-starter-security
  这有助于增加更少的依赖关系，并减少版本的冲突。

6.3 Spring Boot 中的 starter 到底是什么 ?

  首先，这个 Starter 并非什么新的技术点，基本上还是基于 Spring 已有功能来实现的。首先它提供了一个自动化配置类，一般命名为 XXXAutoConfiguration ，在这个配置类中通过条件注解来决定一个配置是否生效（条件注解就是 Spring 中原本就有的），然后它还会提供一系列的默认配置，也允许开发者根据实际情况自定义相关配置，然后通过类型安全的属性注入将这些配置属性注入进来，新注入的属性会代替掉默认属性。正因为如此，很多第三方框架，我们只需要引入依赖就可以直接使用了。当然，开发者也可以自定义 Starter 。

6.4 spring-boot-starter-parent 有什么用 ?

  新创建一个 Spring Boot 项目，默认都是有 parent 的，这个 parent 就是 spring-boot-starter-parent ，spring-boot-starter-parent 主要有如下作用：

  • 1、定义了 Java 编译版本为 1.8 。
  • 2、使用 UTF-8 格式编码。
  • 3、继承自 spring-boot-dependencies，这个里边定义了依赖的版本，也正是因为继承了这个依赖，所以我们在写依赖时才不需要写版本号。
  • 4、执行打包操作的配置。
  • 5、自动化的资源过滤。
  • 6、自动化的插件配置。
  • 7、针对 application.properties 和 application.yml 的资源过滤，包括通过 profile 定义的不同环境的配置文件，例如 application-dev.properties 和 application-dev.yml。

6.5 Spring Boot 打成的 jar 和普通的 jar 有什么区别 ?

  Spring Boot 项目最终打包成的 jar 是可执行 jar ，这种 jar 可以直接通过 java -jar xxx.jar 命令来运行，这种 jar 不可以作为普通的 jar 被其他项目依赖，即使依赖了也无法使用其中的类。
  Spring Boot 的 jar 无法被其他项目依赖，主要还是他和普通 jar 的结构不同。普通的 jar 包，解压后直接就是包名，包里就是我们的代码，而 Spring Boot 打包成的可执行 jar 解压后，在 \BOOT-INF\classes 目录下才是我们的代码，因此无法被直接引用。如果非要引用，可以在 pom.xml 文件中增加配置，将 Spring Boot 项目打包成两个 jar ，一个可执行，一个可引用。

6.6 运行 Spring Boot 有哪几种方式？

  1）打包用命令或者放到容器中运行
  2）用 Maven/ Gradle 插件运行
  3）直接执行 main 方法运行

6.7 Spring Boot 需要独立的容器运行吗？

  可以不需要，内置了 Tomcat/ Jetty 等容器。

6.8 开启 Spring Boot 特性有哪几种方式？

  1）继承spring-boot-starter-parent项目
  2）导入spring-boot-dependencies项目依赖

6.9 如何使用 Spring Boot 实现异常处理？

  Spring 提供了一种使用 ControllerAdvice 处理异常的非常有用的方法。 我们通过实现一个 ControlerAdvice 类，来处理控制器类抛出的所有异常。

6.10 如何使用 Spring Boot 实现分页和排序？

  使用 Spring Boot 实现分页非常简单。使用 Spring Data-JPA 可以实现将可分页的传递给存储库方法。

6.11 微服务中如何实现 session 共享 ?

  在微服务中，一个完整的项目被拆分成多个不相同的独立的服务，各个服务独立部署在不同的服务器上，各自的 session 被从物理空间上隔离开了，但是经常，我们需要在不同微服务之间共享 session ，常见的方案就是 Spring Session + Redis 来实现 session 共享。将所有微服务的 session 统一保存在 Redis 上，当各个微服务对 session 有相关的读写操作时，都去操作 Redis 上的 session 。这样就实现了 session 共享，Spring Session 基于 Spring 中的代理过滤器实现，使得 session 的同步操作对开发人员而言是透明的，非常简便。

6.12 Spring Boot 中如何实现定时任务 ?

  定时任务也是一个常见的需求，Spring Boot 中对于定时任务的支持主要还是来自 Spring 框架。
  在 Spring Boot 中使用定时任务主要有两种不同的方式，一个就是使用 Spring 中的 @Scheduled 注解，另一个则是使用第三方框架 Quartz。
  使用 Spring 中的 @Scheduled 的方式主要通过 @Scheduled 注解来实现。
  使用 Quartz ，则按照 Quartz 的方式，定义 Job 和 Trigger 即可。

  
  参考链接：
  Spring Boot面试题（2020最新版）

相关标签： # Java后端开发面试题 java spring boot

上一篇： SpringCloud之注册中心Eureka

下一篇： Word 自动生成目录及目录手动更新的方法

推荐阅读