目录
1. SpringBoot 2.X有哪些新特性？与1.X有什么区别？
3. Spring Boot的核心注解是哪些？他由哪几个注解组成的？
5. 比较一下Spring Security和Shiro各自的优缺点？
7. 什么是Swagger？你用Spring Boot实现了吗？
8. 如何使用配置文件通过 Spring Boot 配置特定环境的配置？
9. 如何使用 Spring Boot 部署到不同的服务器？
10. 如何在 Spring Boot 中添加通用的 JS 代码？
11. 什么是嵌入式服务器？我们为什么要使用嵌入式服务器呢?
12. 为什么我们需要 spring-boot-maven-plugin?
13. Spring Initializr是创建 SpringBoot Projects的唯一方法吗？
14. 怎么使用 Maven 来构建一个 SpringBoot 程序？
15. 如何在 Spring Boot 中禁用 Actuator 端点安全性？
17. 如何重新加载 SpringBoot 上的更改，而无需重新启动服务器？
20. Spring 和 SpringBoot 有什么不同？
21. 创建一个 Spring Boot Project 的最简单的方法是什么？
【写在前面】
此文题目和答案都非原创。
是搜集了网络上分享的关于Spring面试常见问题汇总，然后又逐个搜寻了答案，整理于此。
供自学，感谢相关题目和答案的原创分享者。
1. SpringBoot 2.X有哪些新特性？与1.X有什么区别？
（1）Spring Boot 2.0 需要 Java 8 作为最低版本。
2.x 里面的许多方法应用了 JDK 8 的许多高级新特性， 所以你要升级到 2.0 版本， 先确认你的应用必须兼容 JDK 8
许多现有的 API 已经更新，以利用 Java 8 的功能， 例如： 接口上的默认方法， 功能回调和新的 API， 如javax.time
如果您当前使用的是 Java 7 或更早版本， 那么在开发 Spring Boot2.0 应用程序之前， 您需要升级 JDK，Spring Boot 2.0 也运行良好， 并且已经过 JDK 9 的测试。 我们所有的jar 都在模块系统兼容性的清单中附带自动模块名称条目
（2）第三方类库的依赖升级
2.x 对第三方类库升级了所有能升级的稳定版本， 列举出几个“
Spring Framework 5+
Tomcat 8.5+
Flyway 5+
Hibernate 5.2+
Thymeleaf 3+
依赖 JDK 版本升级
（3）配置属性绑定区别
在1.x 中，配置绑定是通过注解@ConfigurationProperties 来注入到Spring环境变量中的。
在 2.x 中， 配置绑定功能有了些改造， 在调整了 1.x 中许多不一致地方之外， 还提供了独立于注解之外的 API 来装配配置属性。 并增加了属性来源， 这样你就能知道这些属性是从哪个配置文件中加载进来的
2. 保护SpringBoot应用有哪些方法？
（1）在生产中使用HTTPS
（2）使用Snyk检查你的依赖关系
（3）升级到最新版本
（4）启用CSRF保护
（5）使用内容安全策略防止XSS攻击
（6）使用OpenID Connect进行身份验
（7）管理密码？使用密码哈希！
（8）安全地存储秘密
（9）使用OWASP的ZAP测试您的应用程序
（10）让你的安全团队进行代码审查
3. Spring Boot的核心注解是哪些？他由哪几个注解组成的？
启动类上面的注解是@SpringBootApplication，它是 Spring Boot 的核心注解。
主要组合包含了以下 3 个注解：
（1）@SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。
@EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能：
（2）@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。
（3）@ComponentScan：Spring组件扫描。
4. Spring Boot中如何解决跨域问题？
（1）什么是源和跨域
源（origin）：就是协议、域名和端口号。
跨域：URL由协议、域名、端口和路径组成，如果两个URL的协议、域名和端口全部相同，则表示他们同源。否则，只要协议、域名、端口有任何一个不同，就是跨域。
（2）什么是同源策略？
同源策略（Same origin policy）：是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能都会受到影响。
可以说Web是构建在同源策略基础之上的，浏览器只是针对同源策略的一种实现。
同源策略又分为以下两种：
1）DOM同源策略：禁止对不同源页面DOM进行操作。这里主要场景是iframe跨域的情况，不同域名的iframe是限制互相访问的。
2）XMLHttpRequest同源策略：禁止使用XHR对象向不同源的服务器地址发起HTTP请求。
（3）Spring Boot 中如何解决跨域问题
1）方式一：在后端通过 （CORS，Cross-origin resource sharing）来解决
跨域可以在前端通过 JSONP 来解决，但是 JSONP 只可以发送 GET 请求，无法发送其他类型的请求，在 RESTful 风格的应用中，就显得非常鸡肋，因此我们推荐在后端通过 （CORS，Cross-origin resource sharing） 来解决跨域问题。
这种解决方案并非 Spring Boot 特有的，在传统的 SSM 框架中，就可以通过 CORS 来解决跨域问题，只不过之前我们是在 XML 文件中配置 CORS ，现在可以通过实现WebMvcConfigurer接口然后重写addCorsMappings方法解决跨域问题。
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("*")
.allowCredentials(true)
.allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
.maxAge(3600);
}
}
项目中前后端分离部署，所以需要解决跨域的问题。
我们使用cookie存放用户登录的信息，在spring拦截器进行权限控制，当权限不符合时，直接返回给用户固定的json结果。
当用户登录以后，正常使用；当用户退出登录状态时或者token过期时，由于拦截器和跨域的顺序有问题，出现了跨域的现象。
我们知道一个http请求，先走filter，到达servlet后才进行拦截器的处理，如果我们把cors放在filter里，就可以优先于权限拦截器执行。
@Configuration
public class CorsConfig {
@Bean
public CorsFilter corsFilter() {
CorsConfiguration corsConfiguration = new CorsConfiguration();
corsConfiguration.addAllowedOrigin("*");
corsConfiguration.addAllowedHeader("*");
corsConfiguration.addAllowedMethod("*");
corsConfiguration.setAllowCredentials(true);
UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
urlBasedCorsConfigurationSource.registerCorsConfiguration("/**", corsConfiguration);
return new CorsFilter(urlBasedCorsConfigurationSource);
}
}
2）方式二：
public class CorsConfig extends WebMvcConfigurerAdapter {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("*")
.allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")
.maxAge(3600)
.allowCredentials(true);
}
}
yml文件：
server:
port: 8988
# context-path: /rms
5. 比较一下Spring Security和Shiro各自的优缺点？
（1）由于 Spring Boot 官方提供了大量的非常方便的开箱即用的 Starter ，包括 Spring Security 的 Starter ，使得在 Spring Boot 中使用 Spring Security 变得更加容易，甚至只需要添加一个依赖就可以保护所有的接口，所以，如果是 Spring Boot 项目，一般选择 Spring Security 。
当然这只是一个建议的组合，单纯从技术上来说，无论怎么组合，都是没有问题的。
（2）Shiro 和 Spring Security 相比，主要有如下一些特点：
1）Spring Security 是一个重量级的安全管理框架；Shiro 则是一个轻量级的安全管理框架。
2）Spring Security 概念复杂，配置繁琐；Shiro 概念简单、配置简单。
3）Spring Security 功能强大；Shiro 功能简单。
6. 如何实现Spring Boot应用程序的安全性？
为了实现 Spring Boot 的安全性，我们使用 spring-boot-starter-security 依赖项，并且必须添加安全配置。它只需要很少的代码。配置类将必须扩展 WebSecurityConfigurerAdapter 并覆盖其方法。
7. 什么是Swagger？你用Spring Boot实现了吗？
Swagger广泛用于可视化 API，使用 Swagger UI 为前端开发人员提供在线沙箱。
Swagger是用于生成 RESTful Web 服务的可视化表示的工具，规范和完整框架实现。
它使文档能够以与服务器相同的速度更新。当通过 Swagger 正确定义时，消费者可以使用最少量的实现逻辑来理解远程服务并与其进行交互。
因此，Swagger消除了调用服务时的猜测。
8. 如何使用配置文件通过 Spring Boot 配置特定环境的配置？
如何使用配置文件通过 Spring Boot 配置特定环境的配置？_Redhur-的博客-CSDN博客
9. 如何使用 Spring Boot 部署到不同的服务器？
（1）jar包(官方推荐)
jar包方式启动，也就是使用spring boot内置的tomcat运行。服务器上面只要你配置了jdk1.8及以上，就ok。不需要外置tomcat
1）打成jar包
2）将jar包放到任意目录，执行下面的命令：nohup java -jar demo.jar
3）阿里云服务器需要放开对应的端口
添加安全组：我的项目中配置的启动端口是18080，故这里需要放开18080端口，才能访问
（2）war包
传统的部署方式：将项目打成war包，放入tomcat 的webapps目录下面，启动tomcat，即可访问。
开发环境：jdk1.8 + IDEA
下面搭建一个demo演示如何打war包部署并且如何访问：spring boot + maven
（3）小结
1）对比两种打包方式，jar更加简单，方便。具体使用哪种方式，应视应用场景而定。
2）再说一次，将项目打成war包，部署到外部的tomcat中，这个时候，不能直接访问spring boot 项目中配置文件配置的端口。application.yml中配置的server.port配置的是spring boot内置的tomcat的端口号, 打成war包部署在独立的tomcat上之后, 你配置的server.port是不起作用的。一定要注意这一点！！
10. 如何在 Spring Boot 中添加通用的 JS 代码？
在源文件夹下，创建一个名为 static 的文件夹。然后，你可以把你的静态的内容放在这里面。 例如，myapp.js 的路径是 resources\static\js\myapp.js
你可以参考它在 jsp 中的使用方法：
错误：HAL browser gives me unauthorized error – Full authenticaition is required to access this resource.
该如何来修复这个错误呢？
两种方法：
方法 1：关闭安全验证 application.properties
management.security.enabled:FALSECOPY
方法二：在日志中搜索密码并传递至请求标头中
11. 什么是嵌入式服务器？我们为什么要使用嵌入式服务器呢?
（1）通常，虚拟机上部署应用程序需要些什么
第一步：安装 Java
第二部：安装 Web 或者是应用程序的服务器（Tomat/Wbesphere/Weblogic 等等）
第三部：部署应用程序 war 包
如果想简化这些步骤，应该如何做呢？
答：使服务器成为应用程序的一部分？只需要一个安装了 Java 的虚拟机，就可以直接在上面部署应用程序了。这个想法是嵌入式服务器的起源。
当我们创建一个可以部署的应用程序的时候，我们将会把服务器（例如，tomcat）嵌入到可部署的服务器中。
例如，对于一个 Spring Boot 应用程序来说，你可以生成一个包含 Embedded Tomcat 的应用程序 jar。你就可以像运行正常 Java 应用程序一样来运行 web 应用程序了。
嵌入式服务器就是我们的可执行单元包含服务器的二进制文件（例如，tomcat.jar）。
（2）传统的web项目都是需要部署到服务容器上，例如tomcat、weblogic，然后启动容器运行应用程序。
而springboot应用程序只需要运行**application中的main方法，原因是springboot封装了web容器，启动时会根据配置启动相应的容器，默认是tomcat。
SpringBoot这种设计在微服务架构下有明显的优点（为什么要使用嵌入式服务器）：
- 可以创建独立、自启动的应用容器
- 不需要构建War包并发布到容器中，构建和维护War包、容器的配置和管理也是需要成本和精力的
- 通过Maven的定制化标签，可以快速创建SpringBoot的应用程序
- 可以最大化地自动化配置Spring，而不需要人工配置各项参数
- 提供了产品化特点，例如：性能分析、健康检查和外部化配置
- 全程没有XML配置，也不需要代码生成
12. 为什么我们需要 spring-boot-maven-plugin?
要记住：spring-boot-maven-plugin插件在打Jar包时会引入依赖包
（1）可以打成直接运行的Jar包
maven项目的pom.xml中，添加了org.springframework.boot:spring-boot-maven-plugin
插件，当运行“mvn package”进行打包时，会打包成一个可以直接运行的 JAR 文件，使用“Java -jar”命令就可以直接运行。
（2）可以引入依赖包
一般的maven项目的打包命令，不会把依赖的jar包也打包进去的，只是会放在jar包的同目录下，能够引用就可以了，但是spring-boot-maven-plugin插件，会将依赖的jar包全部打包进去。
比如下面这个jar包的BOOT/INF/lib目录下面就包含了所有依赖的jar包：
比较这两次打包的区别：
1）在使用spring-boot-maven-plugin插件时，打包后的目录包括三个，BOOT-INF,META-INF,org.springframework.boot.loader，在lib目录里包含了我自己的项目的代码目录；
2）在没有使用spring-boot-maven-plugin插件时，打包的目录只有两个，META-INF和我自己的项目代码的目录。
（3）可以指定默认执行类
1）如果使用插件，不指定子目录的话，它的默认执行的类是
Main-Class: org.springframework.boot.loader.JarLauncher
2）如果使用spring-boot-maven-plugin插件还想要自定义执行的类的话，可以用下面三个方法：（前两个未验证，应该没问题）
方法一：如果POM继承spring-boot-starter-parent
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.2.RELEASE</version>
<relativePath/>
</parent>
<properties>
<!-- The main class to start by executing java -jar -->
<start-class>com.mycorp.starter.HelloWorldApplication</start-class>
</properties>
方法二：如果你的POM不是继承spring-boot-starter-parent的话，需要下面的指定。
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>1.3.5.RELEASE</version>
<configuration>
<mainClass>${start-class}</mainClass>
<layout>ZIP</layout>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
方法三：POM不是继承spring-boot-starter-paren，并且使用maven-jar-plugin插件来指定执行的类
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<useUniqueVersions>false</useUniqueVersions>
<classpathPrefix>lib/</classpathPrefix>
<mainClass>cn.com.dataocean.ddts.cli.DDTSCliApplication</mainClass>
</manifest>
<manifestEntries>
<version>${project.version}</version>
<!--<Class-Path>/home/jiashubing/myfile/ddts/cli/plugins/ddts.core-0.0.1-SNAPSHOT.jar</Class-Path>-->
</manifestEntries>
</archive>
</configuration>
</plugin>
13. Spring Initializr是创建 SpringBoot Projects的唯一方法吗？
不是。
（1）可以直接到官网创建项目，会生成一个zip包。
（2）也可以直接使用maven项目，引入继承spring boot的依赖，引入需要的依赖等。比如：
2）在项目的标题为“Basic Web Application”处进行手动设置。手动设置一个 maven 项目这里有几个重要的步骤：
---在 Eclipse 中，使用文件 - 新建 Maven 项目来创建一个新项目。
---添加依赖项。
---添加 maven 插件。
---添加 Spring Boot 应用程序类。
14. 怎么使用 Maven 来构建一个 SpringBoot 程序？
(1条消息) Java练习（十二）：Win10系统中，Sping Boot工程的创建步骤 （Spring Tools4 中 + IDEA中）_sulia1234567890的博客-CSDN博客
15. 如何在 Spring Boot 中禁用 Actuator 端点安全性？
默认情况下，所有敏感的HTTP端点都是安全的，只有具有ACTUATOR角色的用户才能访问它们。
安全性是使用标准的HttpServletRequest.isUserInRole方法实施的。 我们可以使用management.security.enabled = false 来禁用安全性。只有在执行机构端点在防火墙后访问时，才建议禁用安全性。
如何在自定义端口上运行Spring Boot应用程序？ 为了在自定义端口上运行Spring Boot应用程序，您可以在application.properties中指定端口。 server.port = 8090
16. Spring Boot 中的监视器是什么？
Spring boot actuator是spring启动框架中的重要功能之一。
Spring boot监视器可帮助您访问生产环境中正在运行的应用程序的当前状态。
有几个指标必须在生产环境中进行检查和监控。即使一些外部应用程序可能正在使用这些服务来向相关人员触发警报消息。
监视器模块公开了一组可直接作为HTTP URL访问的REST端点来检查状态。
17. 如何重新加载 SpringBoot 上的更改，而无需重新启动服务器？
这可以使用DEV工具来实现。通过这种依赖关系，您可以节省任何更改，嵌入式tomcat将重新启动。
Spring Boot有一个开发工具（DevTools）模块，它有助于提高开发人员的生产力。Java开发人员面临的一个主要挑战是将文件更改自动部署到服务器并自动重启服务器。
开发人员可以重新加载Spring Boot上的更改，而无需重新启动服务器。这将消除每次手动部署更改的需要。Spring Boot在发布它的第一个版本时没有这个功能。
这是开发人员最需要的功能。DevTools模块完全满足开发人员的需求。该模块将在生产环境中被禁用。它还提供H2数据库控制台以更好地测试应用程序。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
18. 什么是springboot
（1）什么是Spring
简而言之，Spring框架为开发Java应用程序提供了全面的基础架构支持。
它包含一些很好的功能，如依赖注入和开箱即用的模块，如：Spring JDBC 、Spring MVC 、Spring Security、 Spring AOP 、Spring ORM 、Spring Test。
这些模块缩短应用程序的开发时间，提高了应用开发的效率。例如，在Java Web开发的早期阶段，我们需要编写大量的代码来将记录插入到数据库中。但是通过使用Spring JDBC模块的JDBCTemplate，我们可以将操作简化为几行代码。
（2）什么是Spring Boot
Spring Boot基本上是Spring框架的扩展，它消除了设置Spring应用程序所需的XML配置，为更快，更高效的开发生态系统铺平了道路。
（3）Spring Boot中的一些特征：
- 创建独立的Spring应用。
- 嵌入式Tomcat、Jetty、 Undertow容器（无需部署war文件）。
- 提供的starters 简化构建配置
- 尽可能自动配置spring应用。
- 提供生产指标,例如指标、健壮检查和外部化配置
- 完全没有代码生成和XML配置要求
19. Spring Boot 有哪些优点？
1）优点
- 快速构建项目。
- 对主流开发框架的无配置集成。
- 项目可独立运行，无须外部依赖Servlet容器。
- 提供运行时的应用监控。
- 极大地提高了开发、部署效率。
- 与云计算的天然集成。
2）缺点
- 版本迭代速度很快，一些模块改动很大。
- 由于不用自己做配置，报错时很难定位。
- 网上现成的解决方案比较少。
20. Spring 和 SpringBoot 有什么不同？
先逐步熟悉这两个框架
（1）Maven依赖
1）首先，让我们看一下使用Spring创建Web应用程序所需的最小依赖项
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
2）与Spring不同，Spring Boot只需要一个依赖项来启动和运行Web应用程序：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.0.6.RELEASE</version> </dependency>
在进行构建期间，所有其他依赖项将自动添加到项目中。
另一个很好的例子就是测试库。我们通常使用Spring Test，JUnit，Hamcrest和Mockito库。在Spring项目中，我们应该将所有这些库添加为依赖项。但是在Spring Boot中，我们只需要添加spring-boot-starter-test依赖项来自动包含这些库。
Spring Boot为不同的Spring模块提供了许多依赖项。一些最常用的是：
spring-boot-starter-data-jpa
spring-boot-starter-security
spring-boot-starter-test
spring-boot-starter-web
spring-boot-starter-thymeleaf
（2）MVC配置
让我们来看一下Spring和Spring Boot创建JSP Web应用程序所需的配置。
1）Spring需要定义调度程序servlet，映射和其他支持配置。我们可以使用 web.xml 文件或Initializer类来完成此操作：
public class MyWebAppInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext container) {
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
context.setConfigLocation("com.pingfangushi");
container.addListener(new ContextLoaderListener(context));
ServletRegistration.Dynamic dispatcher = container
.addServlet("dispatcher", new DispatcherServlet(context));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
}
}
还需要将@EnableWebMvc注释添加到@Configuration类，并定义一个视图解析器来解析从控制器返回的视图：
@EnableWebMvc
@Configuration
public class ClientWebConfig implements WebMvcConfigurer {
@Bean
public ViewResolver viewResolver() {
InternalResourceViewResolver bean
= new InternalResourceViewResolver();
bean.setViewClass(JstlView.class);
bean.setPrefix("/WEB-INF/view/");
bean.setSuffix(".jsp");
return bean;
}
}
2）和上述操作一比，一旦我们添加了Web启动程序，Spring Boot只需要在application配置文件中配置几个属性来完成如上操作：
spring.mvc.view.prefix=/WEB-INF/jsp/ spring.mvc.view.suffix=.jsp
上面的所有Spring配置都是通过一个名为auto-configuration的过程添加Boot web starter来自动包含的。
这意味着Spring Boot将查看应用程序中存在的依赖项，属性和bean，并根据这些依赖项，对属性和bean进行配置。当然，如果我们想要添加自己的自定义配置，那么Spring Boot自动配置将会退回。
（3）配置模板引擎
现在我们来看下如何在Spring和Spring Boot中配置Thymeleaf模板引擎。
在Spring中，我们需要为视图解析器添加thymeleaf-spring5依赖项和一些配置：
@Configuration
@EnableWebMvc
public class MvcWebConfig implements WebMvcConfigurer {
@Autowired
private ApplicationContext applicationContext;
@Bean
public SpringResourceTemplateResolver templateResolver() {
SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver();
templateResolver.setApplicationContext(applicationContext);
templateResolver.setPrefix("/WEB-INF/views/");
templateResolver.setSuffix(".html");
return templateResolver;
}
@Bean
public SpringTemplateEngine templateEngine() {
SpringTemplateEngine templateEngine = new SpringTemplateEngine();
templateEngine.setTemplateResolver(templateResolver());
templateEngine.setEnableSpringELCompiler(true);
return templateEngine;
}
@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
ThymeleafViewResolver resolver = new ThymeleafViewResolver();
resolver.setTemplateEngine(templateEngine());
registry.viewResolver(resolver);
}
}
SpringBoot1X只需要spring-boot-starter-thymeleaf的依赖 项 来启用Web应用程序中的 Thymeleaf支持。
但是由于Thymeleaf3.0中的新功能， 我们必须将thymeleaf-layout-dialect 添加为SpringBoot2XWeb应用程序中的依赖项。
一旦依赖关系到位，我们就可以将模板添加到src/main/resources/templates文件夹中，SpringBoot将自动显示它们。
（4）Spring Security 配置
为简单起见，我们使用框架默认的HTTP Basic身份验证。
1）让我们首先看一下使用Spring启用Security所需的依赖关系和配置。
Spring首先需要依赖 spring-security-web和spring-security-config 模块。
接下来， 我们需要添加一个扩展WebSecurityConfigurerAdapter的类，并使用@EnableWebSecurity注解：
@Configuration
@EnableWebSecurity
public class CustomWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication()
.withUser("admin")
.password(passwordEncoder()
.encode("password"))
.authorities("ROLE_ADMIN");
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.anyRequest().authenticated()
.and()
.httpBasic();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
这里我们使用inMemoryAuthentication来设置身份验证。
2）同样，Spring Boot也需要这些依赖项才能使其工作。
但是我们只需要定义spring-boot-starter-security的依赖关系，因为这会自动将所有相关的依赖项添加到类路径中。
Spring Boot中的安全配置与上面的相同。
（5）应用程序引导配置
Spring和Spring Boot中应用程序引导的基本区别在于servlet。
Spring使用web.xml 或SpringServletContainerInitializer作为其引导入口点。
Spring Boot仅使用Servlet 3功能来引导应用程序，下面让我们详细来了解下
1）Spring 是怎样引导配置的呢？
Spring支持传统的web.xml引导方式以及最新的Servlet 3+方法。
配置web.xml方法启动的步骤
Servlet容器（服务器）读取web.xmlweb.xml中定义的DispatcherServlet由容器实例化DispatcherServlet通过读取WEB-INF / {servletName} -servlet.xml来创建WebApplicationContext。最后，DispatcherServlet注册在应用程序上下文中定义的bean
使用Servlet 3+方法的Spring启动步骤
容器搜索实现ServletContainerInitializer的类，并执行SpringServletContainerInitializer，找到实现所有类WebApplicationInitializer`，`WebApplicationInitializer创建具有XML或上下文@Configuration类，WebApplicationInitializer创建DispatcherServlet与先前创建的上下文。
2）SpringBoot 有是如何配置的呢？
Spring Boot应用程序的入口点是使用@SpringBootApplication注释的类：
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
默认情况下，Spring Boot使用嵌入式容器来运行应用程序。
在这种情况下，Spring Boot使用public static void main入口点来启动嵌入式Web服务器。
此外，它还负责将Servlet，Filter和ServletContextInitializer bean从应用程序上下文绑定到嵌入式servlet容器。
Spring Boot的另一个特性是它会自动扫描同一个包中的所有类或Main类的子包中的组件。
Spring Boot提供了将其部署到外部容器的方式。在这种情况下，我们必须扩展SpringBootServletInitializer：
/** * War部署 * * @author SanLi * Created by [email protected] on 2018/4/15 */ public class ServletInitializer extends SpringBootServletInitializer { @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { return application.sources(Application.class); } @Override public void onStartup(ServletContext servletContext) throws ServletException { super.onStartup(servletContext); servletContext.addListener(new HttpSessionEventPublisher()); } }
这里外部servlet容器查找在war包下的META-INF文件夹下MANIFEST.MF文件中定义的Main-class，SpringBootServletInitializer将负责绑定Servlet，Filter和ServletContextInitializer。
（6）打包和部署
最后，让我们看看如何打包和部署应用程序。
这两个框架都支持Maven和Gradle等通用包管理技术。但是在部署方面，这些框架差异很大。
例如，Spring Boot Maven插件在Maven中提供Spring Boot支持。它还允许打包可执行jar或war包并就地运行应用程序。
在部署环境中Spring Boot 对比Spring的一些优点包括：
提供嵌入式容器支持
使用命令java -jar独立运行jar
在外部容器中部署时，可以选择排除依赖关系以避免潜在的jar冲突
部署时灵活指定配置文件的选项
用于集成测试的随机端口生成
结论
简而言之，我们可以说Spring Boot只是Spring本身的扩展，使开发，测试和部署更加方便。
21. 创建一个 Spring Boot Project 的最简单的方法是什么？
可以官方下载启动包，Spring Initializr。