SpringBoot面试题
- SpringBoot最新2022年面试题，高级面试题(29)
- 1、spring boot 核心的两个配置文件：
- 2、是否可以在Spring boot中更改嵌入式Tomcat服务器的端口
- 3、如何在 SpringBoot 启动的时候运行一些特定的代码？
- 4、什么是 CSRF 攻击？
- 5、bootstrap.yml和application.yml有什么区别?
- 6、SpringBoot的缺点
- 7、SpringBoot 的核心注解是哪个？它主要由哪几个注解组成的？
- 8、什么是嵌入式服务器？我们为什么要使用嵌入式服务器呢?
- 9、SpringBoot 的自动配置是如何实现的？
- 10、什么是FreeMarker模板？
- 11、如何在 SpringBoot 启动的时候运行一些特定的代码？
- 12、SpringBoot 还提供了其它的哪些 Starter Project Options？
- 13、什么是 SpringBoot？
- 14、什么是执行器停机？
- 15、什么是JavaConfig？
- 16、SpringBoot 中如何实现定时任务 ?
- 17、Spring 、SpringBoot 和 Spring Cloud 的关系?
- 18、什么是 FreeMarker 模板？
- 19、RequestMapping 和 GetMapping 的不同之处在哪里？
- 20、如何使用 SpringBoot 实现全局异常处理？
- 21、我们如何监视所有SpringBoot微服务？
- 22、SpringBoot 自动配置原理是什么？
- 23、SpringBoot的核心注解是哪个？它主要由哪几个注解组成的？
- 24、SpringBoot的启动器有哪几种?
- 25、YAML 配置的优势在哪里 ?
- 26、如何重新加载 SpringBoot上的更改，而无需重新启动服务器？
- 27、SpringBoot 支持哪些日志框架？推荐和默认的日志框架是哪个？
- 28、SpringBoot 的配置文件有哪几种格式？它们有什么区别？
- 29、SpringBoot 实现热部署有哪几种方式？
- SpringBoot最新面试题汇总版(30)
- 1、SpringBoot有哪些优点？
- 2、如何使用SpringBoot实现分页和排序？
- 3、能否举一个例子来解释更多 Staters 的内容？
- 4、如何使用 SpringBoot 自动重装我的应用程序？
- 5、创建一个 SpringBoot Project 的最简单的方法是什么？
- 6、Spring Cache 三种常用的缓存注解和意义？
- 7、什么是Spring Actuator？它有什么优势？
- 8、什么是 Spring Profiles？
- 9、如何使用 SpringBoot 部署到不同的服务器？
- 10、如何重新加载SpringBoot上的更改，而无需重新启动服务器？
- 11、SpringBoot 日志框架：
- 12、什么是Apache Kafka？
- 14、开启 SpringBoot 特性有哪几种方式？
- 15、什么是 Spring Data ?
- 16、可以在SpringBoot application中禁用默认的Web服务器吗？
- 17、SpringBoot中的监视器是什么？
- 18、如何使用SpringBoot实现异常处理？
- 19、SpringBoot 可以兼容老 Spring 项目吗，如何做？
- 20、如何使用SpringBoot实现异常处理?
- 21、什么是 SpringBoot 启动类注解?
- 22、为什么要用SpringBoot?
- 23、开启SpringBoot特性有哪几种方式？（创建SpringBoot项目的两种方式）
- 24、如何启用/禁用执行器？
- 25、SpringBoot 2、X 有什么新特性？与 1、X 有什么区别？
- 26、我们如何监视所有 SpringBoot 微服务？
- 27、怎么设计无状态服务？
- 28、SpringBoot 实现热部署有哪几种方式？
- 29、SpringBoot 的核心注解是哪个？它主要由哪几个注解组成的？
- 30、使用 SpringBoot 启动连接到内存数据库 H2 的 JPA 应用程序需要哪些依赖项？
- SpringBoot最新2022年面试题大汇总(22)
- 1、SpringBoot 配置加载顺序?
- 2、spring boot初始化环境变量流程?
- 3、SpringBoot 中如何解决跨域问题 ?
- 4、SpringBoot如何配置log4j？
- 5、SpringBoot运行项目的几种方式？
- 6、SpringBoot与SpringCloud 区别
- 7、如何集成SpringBoot和ActiveMQ？
- 8、SpringBoot 有哪几种读取配置的方式？
- 9、SpringData 项目所支持的关系数据存储技术
- 10、如何在自定义端口上运行SpringBoot应用程序？
- 11、SpringBoot默认支持的日志框架有哪些？可以进行哪些设置？
- 12、Spring Initializr 是创建 SpringBoot Projects 的唯一方法吗？
- 13、Async异步调用方法
- 14、您使用了哪些starter maven依赖项？
- 15、SpringBoot、Spring MVC 和 Spring 有什么区别？
- 16、如何给静态变量赋值？
- 17、我们如何监视所有 SpringBoot 微服务？
- 18、如何实现SpringBoot应用程序的安全性？
- 19、SpringBoot微服务中如何实现 session 共享 ?
- 20、SpringBoot 中的监视器是什么？
- 21、如何禁用特定的自动配置类？
- 22、什么是 WebSockets？
- SpringBoot最新2022年面试题(18)
- 1、在 Spring Initializer 中，如何改变一个项目的包名字？
- 2、SpringBoot 的配置文件有哪几种格式？它们有什么区别？
- 3、什么是 Swagger？你用 SpringBoot 实现了它吗？
- 4、spring boot 核心配置文件是什么？bootstrap、properties 和 application、properties 有何区别 ?
- 5、什么是Spring Initializer?
- 6、SpringBoot Starter 的工作原理是什么？
- 7、SpringBoot 中的 starter 到底是什么 ?
- 8、SpringBoot 最大的优势是什么呢？
- 9、SpringBoot集成mybatis的过程
- 10、如何在SpringBoot中禁用Actuator端点安全性？
- 11、什么是 Spring Profiles？
- 12、spring-boot-starter-parent有什么用？
- 13、SpringBoot 怎么用好自动配置
- 14、SpringBoot需要独立的容器运行？
- 15、什么是Spring Batch？
- 16、@RestController和@Controller的区别
- 17、JPA 和 Hibernate 有哪些区别？JPA 可以支持动态 SQL 吗？
- 18、path=”users”, collectionResourceRel=”users” 如何与 Spring Data Rest 一起使用？
- SpringBoot最新2022年面试题(12)
- 1、shiro和oauth还有cas他们之间的关系是什么？问下您公司权限是如何设计，还有就是这几个概念的区别。
- 2、开启 SpringBoot 特性有哪几种方式？
- 3、什么是YAML?
- 4、如何在 SpringBoot 中添加通用的 JS代码？
- 5、SpringBoot 是否可以使用 XML 配置 ?
- 6、什么是 Spring Data REST?
- 7、我们如何连接一个像 MySQL 或者Orcale 一样的外部数据库？
- 8、保护 SpringBoot 应用有哪些方法？
- 9、创建一个 SpringBoot Project 的最简单的方法是什么？
- 10、SpringBoot 打成的 jar 和普通的 jar 有什么区别 ?
- 11、SpringBoot 支持哪些日志框架？推荐和默认的日志框架是哪个？
- 12、SpringBoot性能如何优化
- SpringBoot最新面试题(11)
- **1、什么是 SpringBoot Stater ？**
- 2、SpringBoot多数据源事务如何管理
- 3、spring boot扫描流程?
- 4、如何使用 SpringBoot 生成一个 WAR 文件？
- 5、JPA 和 Hibernate 有哪些区别？
- 6、当 SpringBoot 应用程序作为 Java 应用程序运行时，后台会发生什么？
- 7、你能否举一个以 ReadOnly 为事务管理的例子？
- 8、spring boot监听器流程?
- 9、SpringBoot常用的starter有哪些？
- 10、为什么我们不建议在实际的应用程序中使用 Spring Data Rest?
- 11、SpringBoot支持什么前端模板
- SpringBoot最新面试题(10)
- SpringBoot最新面试题(12)
- 1、如何在不使用BasePackage过滤器的情况下排除程序包？
- 2、微服务中如何实现 session 共享 ?
- 3、如何实现 SpringBoot应用程序的安全性?
- 4、是否可以在SpringBoot中覆盖或替换嵌入式Tomcat？
- 5、项目中前后端分离部署，所以需要解决跨域的问题。
- 6、SpringBoot读取配置文件的方式
- 7、SpringBoot Starter的工作原理
- 8、什么是嵌入式服务器？我们为什么要使用嵌入式服务器呢?
- 9、SpringBoot 需要独立的容器运行吗？
- 10、SpringBoot事务的使用
- 11、SpringBoot 提供了哪些核心功能？
- 12、微服务同时调用多个接口，怎么支持事务的啊？
SpringBoot最新2022年面试题，高级面试题(29)
1、spring boot 核心的两个配置文件：
Spring Boot 核心的两个配置文件是：
-
application.properties：
常见的Spring Boot配置文件，使用简单的键值对格式来配置你的应用程序。这个文件通常位于src/main/resources目录下。它可以用来配置数据库连接、服务器端口、自定义属性等。示例：
server.port=8080 spring.datasource.url=jdbc:mysql://localhost/test spring.datasource.username=dbuser spring.datasource.password=dbpass -
application.yml（或application.yaml）：
另一种配置文件格式，提供了更多的结构和灵活性。YAML是以数据为中心的语言，它使用缩进风格更易于阅读和书写。与.properties文件相比，.yml文件可以更容易地表示层次性结构。示例：
server: port: 8080 spring: datasource: url: jdbc:mysql://localhost/test username: dbuser password: dbpass
Spring Boot 可以无缝地读取这两种格式的文件，开发者可以根据自己的喜好和需求选择使用。配置文件可以根据不同的环境（如开发、测试、生产）进行配置，例如，你可以拥有 application-dev.properties 和 application-prod.properties 以区分不同环境的配置。
启动时，Spring Boot 会自动加载这些配置文件，并根据这些配置启动和运行应用程序。开发者还可以通过命令行参数、环境变量等其他方式来覆盖这些配置。这种外部化配置的方法极大地简化了在不同环境（开发、生产等）中部署同一个应用程序的过程。
2、是否可以在Spring boot中更改嵌入式Tomcat服务器的端口
是的，在 Spring Boot 中更改嵌入式 Tomcat 服务器的端口是非常常见且简单的。有多种方法可以实现这一点：
1. 在 application.properties 或 application.yml 文件中设置
Spring Boot 允许你在 application.properties 文件中指定服务器的端口，这是最常用的方法之一。
你可以在项目的 src/main/resources/application.properties 文件中增加以下行：
server.port=8081
或者在 YAML 格式的 application.yml 文件中设置：
server:
port: 8081
2. 在程序运行时通过命令行参数设置
你也可以在启动 Spring Boot 应用时通过传递命令行参数来指定端口，如下所示：
java -jar myapp.jar --server.port=8081
3. 在 IDE 运行配置中设置
如果你在 IDE（如 IntelliJ IDEA、Eclipse 等）中开发，你可以在运行配置（Run Configuration）中指定端口。添加环境变量或程序参数（Program arguments）：
--server.port=8081
4. 在 SpringApplication 代码中设置
你可以在 Java 代码中通过编程的方式设置端口，如下所示：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import java.util.Collections;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication app = new SpringApplication(MyApplication.class);
app.setDefaultProperties(Collections
.singletonMap("server.port", "8081"));
app.run(args);
}
}
5. 使用环境变量
你还可以通过设置环境变量 SERVER_PORT 来更改端口：
export SERVER_PORT=8081
然后启动你的应用程序。Spring Boot 会读取设置的环境变量。
这些是更改 Spring Boot 应用中嵌入式 Tomcat 服务器端口的常用方法。通常选择哪一种方式取决于你希望更改的方式是临时的、开发时的还是生产部署时的。如果你有进一步的问题，请随时提问。
3、如何在 SpringBoot 启动的时候运行一些特定的代码？
在Spring Boot应用中，如果你需要在启动时运行一些特定的代码，可以通过下面几种方式：
- 实现CommandLineRunner或ApplicationRunner接口：
这两个接口都有一个运行方法，在Spring Boot应用启动完成后立即执行。它们提供了一种简单的方式来执行初始化逻辑。
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class MyStartupRunner implements CommandLineRunner {
@Override
public void run(String...args) throws Exception {
// 在这里编写你需要执行的代码
System.out.println("The application just started");
}
}
- 使用@PostConstruct注解：
在需要执行初始化代码的类中使用@PostConstruct注解来标注一个方法。相应的方法会在DI容器完成实例的初始化之后调用。
import javax.annotation.PostConstruct;
@Component
public class MyBean {
@PostConstruct
public void init() {
// 在这里编写初始化逻辑
System.out.println("Bean initialization logic");
}
}
- 注册ApplicationListener接口的实现：
Spring框架提供了多个事件，你可以通过实现ApplicationListener接口来创建事件监听器，以执行某个特定事件发生后的代码。
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
@Component
public class MyApplicationReadyEventListener implements ApplicationListener<ApplicationReadyEvent> {
@Override
public void onApplicationEvent(ApplicationReadyEvent event) {
// 应用已就绪，可以执行代码
System.out.println("Application ready event is fired");
}
}
-
使用ApplicationEventPublisher发布自定义事件：
你可以定义自己的事件，并在启动时发布这些事件，然后编写监听器来处理这些事件。 -
通过自定义SpringBoot启动类来初始化：
在你的SpringBoot启动类中，可以在main函数中添加任何启动前的初始化代码。
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
// 在这里可以执行任何Java代码
SpringApplication.run(MyApplication.class, args);
}
}
使用以上任何一种方法，都可以在Spring Boot应用启动时执行特定的代码。通常选择哪种方法取决于你需要执行的任务的性质，以及你希望代码在启动流程的哪一步执行。
4、什么是 CSRF 攻击？
CSRF（Cross-Site Request Forgery，跨站请求伪造）攻击是一种常见的网络应用安全漏洞。这种攻击利用了网站对用户的信任，诱使用户在当前已登录的会话中执行非预期的操作。
攻击原理：
一个用户在网站（如银行网站）登录后，CSRF 攻击会导致用户在不知情的情况下发送一个诸如转账请求的 HTTP 请求到那个网站。这通常来自一个第三方网站，该网站包含了一个对目标网站有副作用的请求（如一个隐藏的图片或表单）。当用户浏览这个第三方网站时，由于浏览器自动附带对目标网站的认证信息（如 Cookies），这个请求伪装成了用户有意的操作。
攻击示例：
- 用户在银行网站
bank.com登录，认证过程中 Cookie 被浏览器存储。 - 不登出银行网站，用户新开一个标签页访问了一个恶意网站
evil.com。 - 恶意网站包含一个向
bank.com发送请求的图片或表单，例如：<img src="http://bank.com/transfer?amount=1000&to=attacker">。 - 用户浏览器由于之前已登录
bank.com，会与请求一起发送用户的 Cookie 至bank.com。 bank.com服务器接收到请求，在不知情的情况下处理了转账操作。
防御措施：
-
使用 Anti-CSRF Token：
服务器为每个用户会话生成一个唯一的令牌（Anti-CSRF Token），并嵌入在表单中。令牌被发送到客户端，并在下一次请求中返回服务器验证。 -
检查 Referer Header：
检查 HTTP 请求的Referer头，以确保请求是从受信任的网站发起的。 -
SameSite Cookie 属性：
使用SameSite属性设置 Cookie，可以告诉浏览器阻止跨站请求携带此 Cookie。 -
验证用户请求：
对于敏感操作，要求用户进行额外的身份验证或确认步骤（如输入密码、发送验证码等）。 -
使用自定义 HTTP 头：
在客户端请求中添加自定义 HTTP 头，服务器检查这个头是否存在以确定是否安全。
防御 CSRF 攻击的关键在于确保网络请求是由用户自愿发起的，而不是由第三方网站伪造的。通过认证、令牌和验证等综合措施，可以有效地预防这类攻击。在开发 Web 应用程序时，应时刻注意保护用户免受 CSRF 攻击。
5、bootstrap.yml和application.yml有什么区别?
在Spring Boot和Spring Cloud项目中，bootstrap.yml和application.yml是用来配置应用的两个不同的YAML文件。它们有着不同的加载时机和用途。
bootstrap.yml
bootstrap.yml是Spring Cloud应用在application.yml之前加载的配置文件。- 它用于应用程序的引导阶段，主要用来配置Spring Cloud的系统相关的属性，比如配置服务器（Spring Cloud Config Server）的位置和访问信息。
- 在引导上下文（Bootstrap Context）中使用，此上下文比主应用程序上下文先行启动，用来拉取外部配置并解密外部配置属性等。
bootstrap.yml里配置的属性较少，通常包括外部配置源（如Config Server），Service Discovery（如Eureka），和一些框架级别的设置。
application.yml
application.yml是Spring Boot的主要配置文件，应用启动时被加载用来配置应用程序的各种自定义和外部属性，例如数据库配置、消息代理、web服务器属性等。- 这个文件中的配置信息用来配置整个应用程序的运行环境及其各种自定义属性。
- 这个文件功能更为强大和全面，几乎所有与应用程序相关的外部化配置都可以在这里声明。
区别总结
- 加载顺序：
bootstrap.yml的加载时机早于application.yml，它在更早的引导阶段做一些先决配置，比如配置服务的获取，而application.yml则用于配置主应用程序。 - 功能范围：
bootstrap.yml主要用于Spring Cloud相关配置，而application.yml用于整个Spring Boot应用程序的其他配置。 - 上下文环境：在引导阶段，创建的是一个独立的
Bootstrap Context，旨在提供一种方式引导外部属性，而主应用程序上下文则是由application.yml配置的。
如果你的项目不是Spring Cloud项目，通常你仅需要使用application.yml。当你在使用Spring Cloud和需要拉取外部配置或连接到服务发现时，会用到bootstrap.yml。
从Spring Boot 2.4开始，引入了新的配置文件处理方式，允许配置文件的分组和层叠。因此，在一些场景下，你可能不再需要bootstrap.yml来引导外部配置，而是通过spring.config.import属性在application.yml文件中引入。
6、SpringBoot的缺点
Spring Boot 是一种流行的 Java 应用程序框架，旨在简化创建独立的、生产级别的 Spring 应用程序的过程。虽然它提供了许多优点，比如快速启动、约定优于配置的理念、内建的应用监控等，但并不意味着没有缺点。以下是 Spring Boot 的一些潜在缺点：
-
自动配置的"黑盒"：
Spring Boot 的自动配置可以大大简化开发，但它也像一个黑盒。如果自动配置没有按预期工作，开发者可能需要花费时间来理解和调试背后的自动配置逻辑。 -
内存占用：
对于包含许多依赖的 Spring Boot 应用程序，内存占用和启动时间可能会比轻量级框架更多，特别是在微服务架构中。 -
过度依赖 Spring 生态系统：
Spring Boot 高度依赖 Spring 生态系统，这可能导致若开发者不熟悉 Spring 框架本身，就很难深入理解应用程序的工作原理。 -
易于过度配置：
Spring Boot 使得引入额外的依赖变得容易，但这也可能导致应用程序变得臃肿，如果没有严格管控依赖。 -
学习曲线：
对于新手，特别是那些没有 Spring 背景的人来说，Spring Boot 的学习曲线可能相对陡峭。虽然快速启动很容易，但要高效地使用它和理解其背后的原理，则需要对 Spring 框架有深入的了解。 -
版本依赖：
Spring Boot 要求依赖项与其版本保持严格兼容，这有时会导致依赖地狱，特别是当你需要使用非 Spring Boot 支持的库版本时。 -
部署和集成问题：
Spring Boot 应用程序通常作为独立的 JAR 文件运行，包含了内嵌的 Tomcat、Jetty 或 Undertow 服务器。这可能导致与传统部署模式的集成问题。 -
产生过多配置：
Spring Boot 启动时会生成大量的配置，这些配置分散在各个地方（properties文件、YAML文件、环境变量、命令行参数等），有时会导致管理和跟踪配置的困难。
开发者在选择使用 Spring Boot 时需要权衡这些利弊，根据项目的具体需求做出决策。在某些应用场合，Spring Boot 提供的快速开发和大量的特性可能非常有价值；然而在其他场景下，这些特性可能并不必要，甚至会带来负担。如果您有其他问题或者对 Spring Boot 有疑问，请随时提问。
7、SpringBoot 的核心注解是哪个？它主要由哪几个注解组成的？
Spring Boot 的核心注解是 @SpringBootApplication。这是一个方便的注解，它是包含了以下三个注解的组合：
-
@EnableAutoConfiguration：
- Spring Boot的自动配置机制利用这个注解来猜测和配置你可能需要的Bean。具体行为是通过classpath下存在的类判断出你可能需要的配置。
-
@ComponentScan：
- 该注解告诉Spring在哪些包中查找带有
@Component、@Service、@Repository、@Controller等注解的类，并注册为Spring上下文中的Bean。
- 该注解告诉Spring在哪些包中查找带有
-
@Configuration：
- 该注解表明该类使用Spring基于Java的配置。类中通常会包含一些@Bean注解的方法，这些方法定义了应用程序上下文中将要注册的Bean。
例如，在一个典型的Spring Boot应用程序中，你可以在启动类上使用@SpringBootApplication注解：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // 核心注解
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args); // 启动应用程序
}
}
当你使用@SpringBootApplication时，实际上你默认启动了这三个注解的功能，这简化了Spring Boot应用程序的初始设置。使用这个注解可以让用户更加方便快捷地开发Spring应用，这也是Spring Boot推崇的“约定优于配置”原则。
8、什么是嵌入式服务器？我们为什么要使用嵌入式服务器呢?
嵌入式服务器（Embedded Server）是指服务器软件组件可以嵌入到应用程序中的服务器，从而使应用程序能够独立运行，无需依赖外部的运行时容器或服务器环境。嵌入式服务器一般指的是 Web 服务器或应用服务器，常见于微服务架构、云服务和容器化部署中。
为什么使用嵌入式服务器？
-
独立部署：
应用程序可以打包为一个单一的可执行 JAR 或 WAR 文件，其中包含了嵌入式服务器，简化了部署和启动过程。 -
简化开发和测试流程：
开发者可以直接在 IDE 中启动应用，不需要单独安装和运行外部服务器或容器，提高了开发和测试的效率。 -
一致性：
嵌入式服务器确保了开发、测试和生产环境中的服务器配置和行为保持一致，减少了环境差异导致的问题。 -
容器化和微服务友好：
嵌入式服务器非常适合构建成微服务架构的应用程序。它们易于与 Docker 等容器技术集成，并可轻松部署在各种云平台上。 -
资源和性能优化：
嵌入式服务器通常占用更少的资源，并在性能上进行了优化，以更好地适应不同的应用需求和缩放限制。 -
更好的控制和定制性：
开发者可以更方便地配置和定制服务器的行为和参数，以最大化地满足应用程序的特定需求。 -
减少外部依赖：
由于没有额外的服务器安装和配置，管理和维护应用程序变得更加简单，这有助于降低系统的复杂性和提高可靠性。
示例：
在 Java 生态系统中，一些流行的嵌入式 HTTP 服务器/Servlet 容器包括：
- Tomcat：通过 Spring Boot，可以嵌入 Apache Tomcat 作为默认的 Web 服务器。
- Jetty：同样可以通过 Spring Boot 或其他框架嵌入 Jetty 服务器。
- Undertow：一个轻量级的嵌入式 Java Web 服务器，也可以通过 Spring Boot 集成。
- Netty：用于网络应用程序开发的异步事件驱动网络应用框架，通常用于构建基于 HTTP/2 的服务。
随着微服务和云原生应用的兴起，嵌入式服务器变得越来越流行。开发者可以利用嵌入式服务器来构建轻量级、高性能且易于部署的应用程序。
9、SpringBoot 的自动配置是如何实现的？
Spring Boot的自动配置是通过一系列的"条件化配置"实现的。它利用Spring Framework的条件注解来在运行时检查和应用配置。为了实现这种自动配置，Spring Boot使用了以下关键机制：
1. @EnableAutoConfiguration注解：
这个核心注解通常与@SpringBootApplication一起使用，它触发了Spring Boot自动配置的过程。
2. spring.factories文件：
自动配置的实现依赖于spring.factories文件，该文件位于Spring Boot自动配置模块（spring-boot-autoconfigure）的META-INF目录下。spring.factories文件列出了所有可用的自动配置类（比如数据库、JPA、消息队列等），这些类通过EnableAutoConfiguration键进行配置。
3. @Conditional相关注解：
自动配置类使用了Spring Framework中的条件注解（@Conditional），如@ConditionalOnClass、@ConditionalOnMissingBean、@ConditionalOnProperty等，来确定在给定的条件满足时才激活相应的自动配置。
例如，如果spring-jdbc库在classpath中，那么与数据库有关的自动配置就会被触发。如果有一个或多个DataSource Beans已存在，则可能不会激活数据库连接池的自动配置。
4. 自动配置类：
自动配置类是普通的Spring配置类，用@Configuration注解，但它们通过上述@Conditional注解进行条件化。这些类使用@Bean、@Import和@Service等标准Spring注解声明容器应该创建的bean。
自动配置的过程如下：
-
应用启动并使用
@SpringBootApplication或@EnableAutoConfiguration注解（后者通常是前者的一部分）。 -
Spring Boot应用程序上下文加载
spring.factories中列出的自动配置类。 -
每个自动配置类通过
@Conditional相关注解来检查条件，根据环境（如类路径、存在的beans、环境变量和系统属性）决定是否应用配置。 -
当所有条件匹配时，自动配置类应用其配置，这可能涉及到为数据源、MVC控制器、视图解析器等创建默认beans。
-
如果应用程序开发人员显示声明了相同类型的bean或通过配置属性表明不想使用默认配置，那么自动配置可以后退或完全替换。
这种强大的自动配置机制大大简化了Spring应用程序的配置过程，让开发者可以专注于他们的应用程序逻辑，而不是花太多的时间去配置Spring的特性。
开发者也可以创建自己的自动配置，并通过在自己的spring.factories文件中添加相应的条目来实现。这使得Spring Boot非常灵活，可以适应各种不同环境下的需求。
10、什么是FreeMarker模板？
FreeMarker 是一个 Java 模板引擎库，用于基于模板和数据模型通过预定义的模板语言生成文本输出，特别是用于生成 HTML 片段和页面。FreeMarker 广泛用于 Web 应用程序中，允许应用逻辑和页面设计的分离，从而促进 Web 开发人员与页面设计师之间的协同工作。
FreeMarker 主要特点包括：
-
灵活性：FreeMarker 可以用于不同类型的模板任务，不仅限于 HTML 页面，还包括配置文件、代码生成等。
-
强类型：FreeMarker 模型是强类型的，模板在访问数据模型结构时非常明确。
-
可嵌套的数据模型：FreeMarker 支持复杂的数据模型，例如可以处理列表、哈希表（map）、对象等。
-
模板继承和模块化：支持模板包含和继承，允许创建模块化和可重用的模板组件。
-
自定义标签：支持创建自定义 “指令” （用户定义的标签），从而提高模板的复用性和清晰度。
FreeMarker 的模板语法非常直观，它使用了特殊标签，例如 <#list> 用于列表迭代，${} 用来插入数据模型中的值。以下是一个简单的 FreeMarker 模板示例：
<html>
<body>
<h1>Welcome ${user}!</h1>
<#list users as user>
<p>User: ${user.name} - ${user.email}</p>
</#list>
</body>
</html>
在上面的示例中，${user} 会被替换成实际传递给模板的 user 对象的值，而 <#list> 标签则用于遍历 users 列表。
FreeMarker 通常可以与多个 Java Web 框架（如 Spring MVC）一起使用，它会结合控制器（Controller）传递给视图（View）的模型数据来渲染页面。当模板被加载和解析后，FreeMarker 引擎就会生成最终的输出，通常是 HTML 页面，但同样可以输出其他格式的内容。
FreeMarker 是一种流行和高效的模板引擎，许多现代 Web 应用程序都在使用它来生成动态内容。如果你有任何关于 FreeMarker 模板引擎或相关话题的进一步问题，欢迎随时提问。
11、如何在 SpringBoot 启动的时候运行一些特定的代码？
在Spring Boot中，如果你想要在应用启动的时候运行一些特定的代码，有几种方式可以做到这一点：
- 实现
ApplicationRunner或CommandLineRunner接口：
这些接口提供了一个run方法，它将在SpringApplication类完成启动后被调用。两者的主要区别在于接受参数的方法不同。
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
@Component
public class MyApplicationRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
// 在这里执行你的代码
System.out.println("Spring Boot启动后执行...");
}
}
或者：
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class MyCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
// 在这里执行你的代码
System.out.println("Spring Boot启动后执行...");
}
}
- 使用
@PostConstruct注解：
将@PostConstruct注解添加到一个方法上，该方法会在对象的依赖注入完成后被自动调用。
import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;
@Component
public class MyClass {
@PostConstruct
public void init() {
// 在这里执行你的代码
System.out.println("依赖注入完毕后执行...");
}
}
- 利用
ApplicationReadyEvent：
通过创建一个事件监听器，监听ApplicationReadyEvent，处理完事件以后就可以执行你的代码。
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
@Component
public class MyApplicationEventListener {
@EventListener(ApplicationReadyEvent.class)
public void onApplicationReady() {
// 在这里执行你的代码
System.out.println("Spring Boot应用准备完成时执行...");
}
}
- 注册
SmartLifecycle接口的实现：
借助SmartLifecycle接口，你可以更精细地控制在Spring Boot生命周期的特定点上执行代码。
import org.springframework.context.SmartLifecycle;
import org.springframework.stereotype.Component;
@Component
public class MySmartLifecycleBean implements SmartLifecycle {
@Override
public void start() {
// 在这里执行你的代码
System.out.println("在SmartLifecycle生命周期的start方法中执行...");
}
@Override
public boolean isAutoStartup() {
return true;
}
// 实现其他必需的方法...
}
使用上述任一方式，都可以确保你的代码能在Spring Boot应用启动的特定时刻运行。选择哪种方式取决于你的具体需求和偏好。
12、SpringBoot 还提供了其它的哪些 Starter Project Options？
Spring Boot Starter 是一组便捷的依赖描述符，可以添加到你的应用中，它为应用程序提供了一个快速的运行起步。每个 Starter 都旨在简化对技术栈的依赖管理，你只需要提供所需功能的 starter，相关库及其依赖将自动引入。Spring Boot 提供了多种 Starter 用于不同的开发场景，以下是一些常用的：
-
spring-boot-starter：
核心 Starter，包括自动配置支持、日志库，以及 YML 配置文件的支持。 -
spring-boot-starter-web：
用于构建 Web、包括 RESTful 应用的 Starter，它使用 Tomcat 作为默认的嵌入式容器。 -
spring-boot-starter-data-jpa：
包含 Spring Data JPA、Hibernate 和相关依赖的 Starter。 -
spring-boot-starter-security：
包含 Spring Security 的 Starter。 -
spring-boot-starter-test：
包含用于测试 Spring Boot 应用的 Starter，如 JUnit、Spring Test、Hamcrest 和 Mockito。 -
spring-boot-starter-thymeleaf：
包含 Thymeleaf 模板引擎的 Starter。 -
spring-boot-starter-data-rest：
通过自动配置将你的项目变成一个 REST 应用。 -
spring-boot-starter-batch：
支持 Spring Batch，包括 HSQLDB。 -
spring-boot-starter-actuator：
提供生产准备功能，帮助你监控和管理应用。 -
spring-boot-starter-mail：
包含发送邮件的功能。 -
spring-boot-starter-cache：
通过spring-cache模块带来了缓存支持的功能。 -
spring-boot-starter-quartz：
提供了对 Quartz 调度器的支持。 -
spring-boot-starter-websocket：
为 WebSockets 通讯提供支持。 -
spring-boot-starter-integration：
为 Spring Integration 提供支持。 -
spring-boot-starter-jdbc：
支持使用 JDBC 访问数据库。 -
spring-boot-starter-amqp：
为 Spring AMQP 和 Rabbit MQ 提供支持。 -
spring-boot-starter-aop：
包括 spring-aop 和 AspectJ 来完成面向方面的编程。
这只是部分可用的 starters，Spring Boot 还提供了其他针对不同技术栈的 starters，例如针对消息传递、数据访问、服务发现、配置客户端、监控、日志分析等。Starters 极大地简化了项目的初始化和配置过程，让你能够迅速地搭建起项目并开始编码。
13、什么是 SpringBoot？
Spring Boot 是一个开源的 Java 基础框架，它是 Spring 框架的一个扩展，旨在简化新Spring应用的初始搭建以及开发过程。Spring Boot 通过提供默认配置和自动配置的功能使得应用程序开发变得快速而简便。
Spring Boot 的关键特性包括：
-
独立运行：构建的Spring Boot应用可以打包成一个独立的、可执行的JAR或WAR文件，这些文件包括嵌入式的Web服务器（如Tomcat、Jetty或Undertow），你可以通过简单地运行JAR文件来启动你的应用。
-
意见化配置（Opinionated Configuration）：Spring Boot 提供了大量默认设置（默认配置），以减少必要的配置和代码编写。
-
自动配置：Spring Boot 能自动配置许多Spring应用程序上下文所必需的Bean，减轻了手动配置的负担。
-
简化Maven配置：Spring Boot提供了一组Starter POMs，用于在Maven或Gradle项目中简化依赖配置。
-
监控：提供了一组工具来帮忙监控应用的各个方面，包括通过Spring Boot Actuator来检查应用的运行时状态和内部工作。
-
非功能性特性：如内置的健康检查、外部化配置、日志记录和安全性设置。
-
项目和代码生成：可以使用Spring Initializr来生成基础构建配置和基本的项目结构。
使用 Spring Boot 的优点：
- 快速启动和运行Spring应用程序。
- 减少了项目中的配置和Boilerplate代码（模板代码）。
- 开箱即用，但又不失灵活性。
- 通过运行环境的配置，易于在不同环境下部署。
- 社区支持和持续更新。
Spring Boot 不是：
- 一个应用服务器或Web服务器。
- 一个代码生成工具，它不会为你的应用程序生成业务逻辑代码。
- 有锁的平台，你可以随时脱离Spring Boot回到Spring框架。
Spring Boot 旨在充分利用Spring平台的功能，同时允许开发者以最少的努力快速高效地创建独立的、生产级的Spring基础的应用。
14、什么是执行器停机？
执行器停机（Executor Shutdown）是 Java 并发编程中的一个概念，它指的是当不再需要 Executor 框架中的 ExecutorService 时，如何正确地关闭 ExecutorService 的过程。这个步骤很重要，因为如果执行器不被正确停止，那么它内部维护的线程会继续运行，这可能会导致 Java 应用无法正常终止。
ExecutorService 提供了两个方法来开始安全地关闭执行器：
-
shutdown()：
- 这个方法会平滑地关闭 ExecutorService，不再接受新任务，但会将已经提交的任务执行完毕。
- 已经在执行的任务会继续执行到完成，而队列中等待的任务将会被移除并正常执行。
-
shutdownNow()：
- 这个方法试图立即关闭 ExecutorService，它会尝试终止正在执行的任务，停止等待任务的处理，并返回那些等待被执行的任务列表。
- 注意，这种立即终止的做法无法保证正在执行的任务能够安全停止，且有可能导致运行中的任务被中断。使用时需要小心。
通常，shutdown() 被宣推荐用于执行器的停机，因为它对正在执行的任务更为温和。在调用 shutdown() 或 shutdownNow() 方法后，可以调用 awaitTermination() 方法等待 ExecutorService 的终止，例如：
ExecutorService executor = Executors.newFixedThreadPool(10);
// ... 提交运行的任务 ...
// 关闭 ExecutorService
executor.shutdown();
try {
// 等待执行器的终止
if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
// 超时后尝试强制停止
executor.shutdownNow();
}
} catch (InterruptedException ie) {
// 如果当前线程也被中断，则再次尝试强制停止
executor.shutdownNow();
}
正确地关闭执行器对于资源的释放和应用程序的正常结束至关重要。如果你有任何关于执行器停机或并发编程的问题，欢迎随时提问。
15、什么是JavaConfig？
JavaConfig是Spring框架的一个特性，它允许开发者通过Java类而非传统的XML文件来进行Spring的配置。这样的配置类通常用@Configuration注解来标记，以表明这个类包含了Spring容器的Bean定义信息。
在配置类中，可以使用@Bean注解标记在方法上，以声明Spring容器管理的Bean。这个方法返回一个对象，该对象在初始化Spring应用上下文时会作为一个Spring Bean被注册。这种方法提供了一种类型安全、可重构、简洁的方式来定义和维护应用程序的配置，从而替代XML或其他配置形式。
以下是一个简单的例子展现JavaConfig的使用：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
在上面的例子中，AppConfig类用@Configuration注解标注，表示它是一个Spring配置类。在其中定义了一个myService方法，该方法用@Bean注解来标记，该方法返回的MyServiceImpl对象会作为一个Bean被Spring容器管理。
JavaConfig的优点包括：
- 类型安全：Java类型系统的使用减少了配置错误，如提供了不正确的Bean类型。
- 易于重构：改动类名或方法名时，IDE可以自动更新这些引用的地方，减少了出错的可能。
- 简洁清晰：与充满文本的XML相比，Java代码更为简洁，且IDE友好。
- 集成：容易与Spring的其他特性和Java语言本身的特性（如注解、泛型等）集成。
随着Spring Boot的流行，JavaConfig几乎成了Spring应用的标准配置方式，因为它与Spring Boot推崇的“约定优于配置”的原则相吻合。Spring Boot应用通常会结合自动配置（@EnableAutoConfiguration）来进一步减少开发者的配置负担。
16、SpringBoot 中如何实现定时任务 ?
在 Spring Boot 中，可以通过使用 @Scheduled 注解以及 @EnableScheduling 注解来实现定时任务。
以下为实现定时任务的一般步骤：
-
添加
@EnableScheduling注解：
在你的 Spring Boot 应用的配置类上添加@EnableScheduling注解来启用 Spring 的任务调度功能。import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableScheduling; @Configuration @EnableScheduling public class SchedulerConfig { // 定时任务配置 } -
添加
@Scheduled注解：
在你想要运行定时任务的方法上添加@Scheduled注解，并配置所需的任务调度信息。import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; @Component public class ScheduledTasks { @Scheduled(fixedRate = 5000) // 每 5 秒执行一次 public void reportCurrentTime() { System.out.println("当前时间：" + System.currentTimeMillis() / 1000); } }
@Scheduled 注解支持以下参数：
fixedRate: 在固定的周期内运行，无论前次任务是否完成。fixedDelay: 在任务执行完成后一定的延迟后再次执行任务。initialDelay: 在首次调度任务时，延迟一段时间再开始。cron: 通过 CRON 表达式定义任务的执行时间。
示例：使用 CRON 表达式的定时任务
@Scheduled(cron = "0 * * * * ?") // 每分钟的 0 秒的时候执行
public void scheduleTaskWithCronExpression() {
// 执行任务的逻辑
}
如果 @Scheduled 注解的任务较为复杂或需要较长时间执行，则推荐使用异步执行来避免调度器的阻塞。可以通过以下方法来实现异步的定时任务：
-
在配置类中添加
@EnableAsync开启异步执行功能：@EnableAsync @Configuration public class AppConfig { // ... 其他配置 } -
在执行定时任务的方法上添加
@Async注解以异步执行：@Async @Scheduled(fixedRate = 5000) public void asyncScheduledTask() { // 执行任务的异步逻辑 } -
创建
ExecutorBean 来提供自定义的异步执行器：@Bean public Executor taskExecutor() { // 创建并配置一个线程池 return Executors.newScheduledThreadPool(5); }
通过使用 Spring Boot 中的 @Scheduled 注解，你可以轻松添加并运行定时任务，而无需手动管理线程或定时器。
17、Spring 、SpringBoot 和 Spring Cloud 的关系?
Spring、Spring Boot和Spring Cloud是构建现代Java应用程序的相关技术和框架，它们之间有密切的联系但各自扮演不同的角色：
Spring
- 核心框架：Spring是一个开源的Java平台，最初由Rod Johnson创建，并在2003年首次发布。它为构建Java应用程序提供了全面的编程和配置模型。
- 依赖注入：Spring的核心特性包括依赖注入（DI）和面向切面编程（AOP）。
- 企业支持：它还提供了许多企业级服务，包括数据访问、事务管理、Web应用程序开发、以及消息传递等。
Spring Boot
- 微服务开发：Spring Boot是一种基于Spring的约定优于配置的产物，它旨在简化Spring应用程序的创建和开发过程。
- 独立运行：Spring Boot支持创建独立的生产环境级别的Spring应用程序，可以 “just run”。
- 内置服务：通过提供内置的服务器、监控工具，以及大量的Starter POMs以简化Maven配置。
- 自动配置：Spring Boot通过自动配置的方式极大减少了项目的搭建和开发时间。
Spring Cloud
- 云端协作：Spring Cloud是在Spring Boot的基础上构建的，它用于简化分布式系统中的常见模式的开发，例如配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策议程、分布式会话等。
- 分布式系统的简化：Spring Cloud让开发人员很容易快速搭建一些常用的分布式系统模式的实现，而无需关心分布式系统的复杂性。
- 云平台整合：它与云平台和其他Spring项目整合，例如Spring Batch、Spring Data、Spring Security等，以提供一种声明式的方式来注册和调用微服务。
它们的关系：
- 基石：Spring作为基石，提供了依赖注入和模块化的支持。
- 简化：Spring Boot在此基础上，添加了自动配置和简化的部署方式，使得快速搭建和开发Spring应用程序成为可能。
- 微服务：Spring Cloud进一步在Spring Boot的基础上封装了对微服务架构支持的模式和配置，使得构建在云环境下面的分布式系统变得容易。
简单来说，Spring 提供了框架的基础设施，Spring Boot 基于Spring提供了快速开发单体应用的能力，Spring Cloud 基于Spring Boot支持了微服务架构的实现。这三者共同组成了为小型到大型企业级应用服务的全栈解决方案。
18、什么是 FreeMarker 模板？
FreeMarker 是一个基于 Java 的模板引擎，主要用于生成文本输出，最常见的用途是生成 HTML Web 页面。然而，FreeMarker 不限于 HTML，也可以用于生成任何基于文本格式的输出，比如配置文件、源代码、电子邮件等。
作为一个模板引擎，FreeMarker 的目标是将模板设计与业务逻辑分开，模板中定义了静态文本（在 Web 应用中就是 HTML）和动态内容的组合部分。动态部分由插值表达式和各种指令（如条件语句、循环等）来表示，当模板与数据模型结合时，FreeMarker 替换掉所有的动态部分以生成最终的文本。
FreeMarker 模板的例子：
<html>
<head>
<title>Welcome</title>
</head>
<body>
<h1>Welcome ${user}!</h1>
<#list items as item>
<p>${item.name} - ${item.price}</p>
</#list>
</body>
</html>
上面的例子中，${user} 是一个插值表达式，它会被数据模型中 user 变量的值所替换。<#list> 指令用于迭代 items 集合中的每个项目（item），其中每个项目的 name 和 price 属性也会被相应地替换。
在 Java 应用程序中使用 FreeMarker 的大致步骤如下：
- 创建并配置
freemarker.template.Configuration实例。 - 根据模板文件创建模板对象（
freemarker.template.Template）。 - 准备与模板相对应的数据模型（通常是一个 Map，但也可以是更复杂的对象模型）。
- 将模板与数据模型结合，在
Writer对象中生成最终文本。 - 关闭
Writer对象，完成文本输出的流程。
FreeMarker 强大而灵活，适合于需要在服务器端动态生成内容的各种应用场景。如果你有关于 FreeMarker 或其他模板引擎的问题，欢迎提出交流。
19、RequestMapping 和 GetMapping 的不同之处在哪里？
@RequestMapping 和 @GetMapping 是Spring MVC框架中用于处理HTTP请求的两个注解。虽然它们有类似的作用，但在用法和特性上有一些区别：
-
@RequestMapping：
@RequestMapping是一个通用请求处理注解，它可以映射HTTP请求到指定的处理方法上。@RequestMapping可以用于映射所有的HTTP方法，例如GET、POST、PUT、DELETE等，但是如果你想明确指定它只处理某一种HTTP方法，你需要使用method属性。
示例代码：
@RequestMapping(value = "/example", method = RequestMethod.GET) public String getExample() { // 处理GET请求 return "example"; } -
@GetMapping：
@GetMapping是一个组合注解，它是@RequestMapping的一个快捷方式，专门用来处理HTTP GET请求。使用它时，你不需要指定method属性，因为它默认就是映射GET请求。
示例代码：
@GetMapping("/example") public String getExample() { // 处理GET请求 return "example"; }
不同之处：
- 专用性：
@GetMapping是一个专门处理GET请求的专用注解，而@RequestMapping是一个更通用的注解，可以处理所有类型的HTTP请求。 - 简洁性：
@GetMapping简化了GET请求的映射，避免了使用method属性来指定请求类型。 - 清晰性：使用
@GetMapping可以提高代码的可读性和清晰性，因为它明确表示只处理GET请求。
总的来说，@GetMapping 是在Spring 4.3版中引入的一个较新的注解，它提供了一种简洁、清晰的方式来处理GET请求。当你知道映射的方法只需要响应GET请求时，推荐使用 @GetMapping。对于需要更复杂的请求映射，可能包括其他HTTP方法或其他特殊配置，应该使用更通用的 @RequestMapping。
20、如何使用 SpringBoot 实现全局异常处理？
在 Spring Boot 应用程序中实现全局异常处理可以通过使用 @ControllerAdvice 注解结合 @ExceptionHandler 注解来完成。这种方式可以对所有控制器（Controller）抛出的异常进行集中处理。
以下是实现全局异常处理的一般步骤：
-
定义一个类，并添加
@ControllerAdvice注解。此注解允许您通过类路径扫描自动检测实现。 -
在该类中定义方法，为特定异常添加
@ExceptionHandler注解。这个方法将处理所有控制器抛出的相应异常。 -
在方法参数中，可以包括异常对象，这样可以在方法实现中对异常进行处理。
-
方法体可以返回一个适当的
ResponseEntity对象，包含了错误信息和 HTTP 状态码，也可以返回一个视图名称（如果使用 Thymeleaf 或者 JSP 等模板）。
以下是一个简单的全局异常处理器示例：
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(Exception.class) // 我们可以为特定异常定义处理方法
public ResponseEntity<?> handleGlobalException(Exception ex, WebRequest request) {
ErrorDetails errorDetails = new ErrorDetails(
HttpStatus.INTERNAL_SERVER_ERROR, ex.getMessage(), request.getDescription(false));
return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR);
}
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<?> resourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
ErrorDetails errorDetails = new ErrorDetails(
HttpStatus.NOT_FOUND, ex.getMessage(), request.getDescription(false));
return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND);
}
// 可以根据需要添加更多的异常处理方法...
// 定义 ErrorDetails 类来结构化错误信息
static class ErrorDetails {
private HttpStatus status;
private String message;
private String details;
public ErrorDetails(HttpStatus status, String message, String details) {
this.status = status;
this.message = message;
this.details = details;
}
// getter and setter 方法...
}
}
在这个例子中，对于所有异常我们返回 INTERNAL_SERVER_ERROR（500），对于资源未找到异常，我们返回 NOT_FOUND（404）。
此外，通过 @RestControllerAdvice 注解，您还可以处理全局异常，该注解适用于 RESTful API，相当于 @ControllerAdvice 标注的类同时拥有 @ResponseBody 功能。
通过这种方法，您可以将异常处理从业务逻辑中分离出来，集中管理，使得代码更加简洁且易于维护。同时，这也提供了返回给客户端结构化且一致性的错误信息的可能。
21、我们如何监视所有SpringBoot微服务？
监控Spring Boot微服务可以通过多种技术和工具实现，它们提供了性能指标、应用数据和运行状况检查的可视化。以下是一些用于监控微服务的常用工具和方法：
1. Spring Boot Actuator
Spring Boot Actuator是一个Spring Boot子项目，为应用程序提供了多种监控和管理特性。Actuator带有一系列内置端点，如/health、/info、/metrics等，用于检查应用程序的当前状态和内部工作。这些端点可以通过HTTP暴露，并且可以与外部监控系统集成。
2. Micrometer
Micrometer提供了一个度量收集库，可以作为应用级"仪表盘"来集成各种监控系统。它支持多种监控系统，包括但不限于Prometheus、Datadog、InfluxDB、Graphite等。
3. Prometheus与Grafana
Prometheus是一个开源监控系统，它通过HTTP端点收集指标，支持实时警报。Grafana是一个开源分析平台，可以用于可视化来自Prometheus的数据，用图形和仪表盘显示详细信息。
4. Spring Cloud Sleuth
Spring Cloud Sleuth提供了分布式追踪的解决方案，非常适合在微服务架构中追踪请求。它可以和Zipkin或其他追踪系统一起使用来收集和查看追踪数据。
5. ELK Stack
ELK Stack（Elasticsearch、Logstash、Kibana）是解决日志数据聚合、搜索和可视化的常见选择。可以结合Spring Boot应用使用，对日志数据进行深入分析。
6. Spring Cloud Admin
Spring Cloud Admin是一个用于管理和监控的开源项目，允许你查看每个应用程序的详细信息，包括日志、JVM状态、环境属性等。
实现监控的步骤可以包括：
- 集成：在微服务应用中集成所需的库（例如Spring Boot Actuator、Micrometer）。
- 配置：配置应用程序来暴露相关的度量和信息端点。
- 运行监控工具：部署和配置Prometheus、Grafana、Zipkin等工具。
- 数据收集：开始从应用程序收集数据。
- 数据可视化：在监控工具（如Grafana）中设置仪表盘，以可视化和分析数据。
通过这些工具和实践，你可以有效地监控Spring Boot基础的微服务应用，从而能够更好地理解它们的实时表现和健康状况，以及在问题出现时及早做出响应。
22、SpringBoot 自动配置原理是什么？
Spring Boot 自动配置是一个强大的特性，它使得开发者能够快速且自动地配置Spring应用程序。自动配置的原理是基于 Spring Framework 的条件注解（如 @Conditional）和Spring Boot的自动配置元数据来实现的。
以下是 Spring Boot 自动配置的一些关键点：
-
@EnableAutoConfiguration：
- Spring Boot 通过
@SpringBootApplication注解启用自动配置，而@SpringBootApplication包含了@EnableAutoConfiguration注解。 @EnableAutoConfiguration告诉 Spring Boot 根据类路径上的 jar 依赖、bean 的定义以及各种属性设置自动配置应用。
- Spring Boot 通过
-
条件注解（Conditional Annotations）：
- Spring Boot 的自动配置是由条件注解控制的。这些注解取决于 classpath 上的类存在、某个 bean 的存在、或某些属性的值等条件。
- 比如
@ConditionalOnClass、@ConditionalOnBean、@ConditionalOnMissingBean、@ConditionalOnProperty等。
-
自动配置类：
- Spring Boot 使用一系列自动配置的类，这些类通常以
xxxAutoConfiguration的模式命名。 - 每个自动配置类可以设置或者提供一个或多个 bean，以及配置bean的行为。
- 这些自动配置类中的
@Bean方法同样会使用条件注解，确保只在满足特定条件时才创建。
- Spring Boot 使用一系列自动配置的类，这些类通常以
-
spring-boot-autoconfigure：
- Spring Boot 自带的
spring-boot-autoconfigure模块提供了大量自动配置类。 - 这些类设计得尽可能智能，以减少需要被开发人员手动声明的配置。
- Spring Boot 自带的
-
自动配置顺序：
- 部分自动配置类可能需要在其他之前或之后配置。Spring Boot 使用了
@AutoConfigureAfter和@AutoConfigureBefore注解来管理配置间的先后顺序。
- 部分自动配置类可能需要在其他之前或之后配置。Spring Boot 使用了
-
配置文件（application.properties 或 application.yml）：
- 开发者可以通过
application.properties或application.yml文件覆盖自动配置的属性，以调整自动配置的默认设置。
- 开发者可以通过
例如，在 Spring 应用中，若 spring-boot-starter-web 依赖存在于 classpath 上，Spring Boot会自动配置相应的Tomcat和Spring MVC。如果开发者没有定义自己的 DispatcherServlet，一个默认的会被自动配置。
自动配置大大简化了初始化设置和引导应用程序的过程。不过，开发者也可以通过排除特定的自动配置类或使用条件注解指定的各种方式来完全控制自动配置。此外，Spring Boot 提供了不同的调试方法，如 --debug 标志，可以用来查看哪些自动配置被应用哪些没有。
理解 Spring Boot 自动配置如何工作，以及如何根据自己的需要调整自动配置，对于高效地使用Spring Boot并构建可维护的应用程序非常重要。如果你有更多的问题或需要深入了解 Spring Boot，欢迎随时提问。
23、SpringBoot的核心注解是哪个？它主要由哪几个注解组成的？
Spring Boot 的核心注解是 @SpringBootApplication。这是一个组合注解，它整合了以下三个注解，使得Spring Boot应用的配置更加简洁：
-
@SpringBootConfiguration：
- 表示该类提供了Spring Boot应用程序的配置。它是
@Configuration的特殊形式，后者标记类作为bean定义的源。
- 表示该类提供了Spring Boot应用程序的配置。它是
-
@EnableAutoConfiguration：
- 告诉Spring Boot基于类路径设置、其他bean以及各种属性设置自动配置应用程序。这样做会尝试猜测并配置你可能需要的bean。
-
@ComponentScan：
- 它告诉Spring在包含配置类的包以及它们的子包下查找bean。这样你可以在应用程序的任何部分添加组件（如
@Component,@Service,@Repository,@Controller等），Spring Boot会自动发现它们并注册为应用程序上下文中的bean。
- 它告诉Spring在包含配置类的包以及它们的子包下查找bean。这样你可以在应用程序的任何部分添加组件（如
@SpringBootApplication 注解通常放在你的主应用程序类上，比如：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // 核心注解
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args); // 启动Spring Boot应用
}
}
当你使用 @SpringBootApplication 注解时，就等同于开启了 Spring 的组件扫描和Spring Boot的自动配置，是开发Spring Boot应用程序的最佳起点。
24、SpringBoot的启动器有哪几种?
Spring Boot 提供了许多“启动器”（Starters），这些启动器是预先打包好的依赖集合，旨在简化 Maven 或 Gradle 构建文件的依赖管理。它们可以自动配置 Spring 和相关技术栈的项目基础。以下是一些常见的 Spring Boot Starters：
-
spring-boot-starter：核心 starter，包括自动配置支持、日志库和 YAML。
-
spring-boot-starter-web：用于构建 Web 应用包括 RESTful 应用的 starter，包含 Tomcat 和 spring-webmvc。
-
spring-boot-starter-data-jpa：用于 Spring Data JPA 与 Hibernate 的 starter。
-
spring-boot-starter-test：用于测试 Spring Boot 应用的 starter，包括 JUnit、Spring Test、AssertJ 等。
-
spring-boot-starter-thymeleaf：用于构建 MVC web 应用的 Thymeleaf 模板引擎的 starter。
-
spring-boot-starter-security：用于使用 Spring Security 的 starter。
-
spring-boot-starter-jdbc：用于使用 JDBC 的 starter。
-
spring-boot-starter-cache：用于支持 Spring Framework 的缓存抽象的 starter。
-
spring-boot-starter-actuator：用于添加应用的生产环境特性，比如监控和指标。
-
spring-boot-starter-mail：用于支持 javax.mail 的 starter。
-
spring-boot-starter-aop：用于添加面向切面编程（AOP）支持（包括 spring-aop 和 AspectJ）的 starter。
-
spring-boot-starter-data-mongodb：用于 Spring Data MongoDB 的 starter。
-
spring-boot-starter-data-redis：用于 Spring Data Redis 的 starter。
-
spring-boot-starter-batch：用于支持 Spring Batch 的 starter。
以上只是部分常用的 Starters。这些Spring Boot Starter 项目包含在项目构建配置（如pom.xml或build.gradle文件）中，让你能够快速搭建新的 Spring 应用。使用这些 Starters 能减少构建配置的复杂性，因为每个 Starter 都会根据约定配置和启用大部分需要的依赖。实际在实际开发中，你可以根据应用的需要选择适当的种类和数量的 Starters。
25、YAML 配置的优势在哪里 ?
YAML（YAML Ain’t Markup Language）是一种用于数据序列化的可读配置文件格式。在许多现代的应用程序和工具（比如 Kubernetes、Ansible 和 Spring Boot）中，它用于配置文件的编写和信息的传递。相较于其他数据序列化格式如JSON和XML，YAML配置文件有一系列优势：
可读性：
- YAML使用了非常直观的块格式和缩进风格，类似于我们阅读普通文本的方式，所以它非常易于理解和阅读。
易于编写：
- 缩进和无需大量的引号或括号，使得YAML配置文件比例如JSON或XML更易于手动编写和维护。
支持注释：
- 可以在YAML中使用
#来添加注释，这有助于解释代码的部分细节或标注配置选项的原因，而JSON不支持注释。
数据结构丰富：
- 它支持列表（数组）、散列表（字典/映射）、标量（如字符串、整数和浮点数）等数据结构。
层次结构：
- YAML的缩进表示层次结构，这样可以清晰地表示配置项之间的父子关系和所属关系。
支持复杂数据类型：
- 它还支持复杂的数据类型，如对象引用、数据合并和其它扩展类型。
跨语言解析：
- 多种编程语言都有解析YAML的库（如Python的PyYAML、Java的snakeyaml、JavaScript的js-yaml等），这意味着不同语言编写的程序都可以使用YAML表示和交换数据。
IDE支持：
- 大多数现代IDE都对YAML文件有很好的支持，包括语法高亮、格式校验、自动格式化等。
尽管YAML有如上优势，它也有一些需要注意的地方，比如缩进必须准确、特殊字符前需要转义等。当配置数据结构过于复杂时，YAML文件的可读性可能受到影响。因此，开发者在实际使用中需要根据具体情况选择合适的配置文件格式。
26、如何重新加载 SpringBoot上的更改，而无需重新启动服务器？
在 Spring Boot 应用中，为了开发效率，通常需要在更改代码后立即看到结果，而无需重新启动服务器。这可以通过以下几种方法实现：
-
Spring Boot DevTools：
Spring Boot 提供了一个 DevTools 模块，它可以在开发期间加速应用的迭代周期。当检测到代码更改时，DevTools 会自动触发应用的重启。DevTools 利用两个类加载器来实现快速重启，只有更改的类会被重新加载，而不影响没有变化的类。要使用 DevTools，只需要将
spring-boot-devtools添加到项目的依赖中：<!-- Maven dependency --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> <optional>true</optional> </dependency>使用 Gradle 时，添加以下依赖到
build.gradle文件：dependencies { runtimeOnly 'org.springframework.boot:spring-boot-devtools' }并确保启用自动构建项目文件的功能（在IDE中）。当保存文件时，DevTools 将自动重新启动应用。
-
热部署（Hot Swapping）：
开发 IDEs（如 IntelliJ IDEA 或 Eclipse）通常提供了热部署或热交换（Hot Swap）的功能。这允许在不重启服务器的情况下替换类和资源文件。这种方法在方法体内的代码更改时很有用，但它的能力有限，如果是对类结构（如增加方法、类成员）的修改，则不能正确热替换。
-
JRebel：
JRebel 是一个商业产品，它提供广泛的重新加载功能，超出了 Java HotSwap VM 的能力。它能够在不重新启动容器的情况下立即反映代码改动，包括对类结构的改变。尽管 JRebel 非常强大，但请注意它是一个付费工具，并且需要安装和配置额外的插件。
-
Spring Loaded（已弃用）：
Spring Loaded 是一个 JVM 代理，用于在不重新启动的情况下重新加载类。由于它已经不再维护，而且与新版本的 Spring Boot 不兼容，这里只做推荐而已。
为了最佳的开发体验，推荐使用 Spring Boot DevTools，它不仅支持自动重启，还支持模板引擎缓存关闭等其他开发期间有用的特性，如禁用静态资源的缓存。如果你有更多问题，请随时提问。
27、SpringBoot 支持哪些日志框架？推荐和默认的日志框架是哪个？
Spring Boot 支持多种日志框架，但是内部主要是通过Apache Commons Logging来提供日志抽象。除了这个抽象层以外，Spring Boot还提供了对具体日志实现的自动配置支持，主要包括：
- Logback：Spring Boot的默认日志框架，以高性能为特性，在配置文件
application.properties或application.yml中进行配置，或通过更详细的logback.xml配置文件来进行配置。 - Log4j2：另一个流行的日志框架，比Logback相对年轻，相比Logback提供了更高的吞吐量和更快的并发性能，通过在class path中引入合适的Log4j2依赖项以及相应配置文件（如
log4j2.xml或log4j2.properties）来启用。 - JUL (Java Util Logging)：这是Java标准库提供的日志框架，不过通常在Spring Boot应用中是不推荐使用的，因为它的功能比较有限。
- SLF4J：SLF4J不是日志实现，而是Java的一个日志门面，它允许用户在底层实现不同的日志框架。
推荐使用的是Logback，它是Spring Boot的默认日志框架。Logback是由Log4j的创始人设计的，被认为是Log4j的一个更强大和灵活的替代品。Spring Boot为Logback提供了默认的基本配置，但是也支持通过配置文件进行高度自定义。
如果你想使用Log4j2，只需要将适当的spring-boot-starter-log4j2’Starter’加入依赖，并排除默认的Logback依赖即可。Spring Boot会自动配置Log4j2并使用任何在classpath路径上可见的Log4j2配置文件。
Spring Boot选择Logback作为默认实现，没有错误，但提供了足够的灵活性来自由选择其他实现，只要满足应用的实际需求。需要注意的是，无论选择哪个日志框架，使用SLF4J作为应用程序中的接口都是一个好的实践，因为它可以让你在必要时更容易地切换到另一个日志框架。
28、SpringBoot 的配置文件有哪几种格式？它们有什么区别？
Spring Boot 支持两种主要的配置文件格式：
-
属性文件（.properties）：
-
属性文件是一种传统的 Java 配置文件格式，键和值之间用等号
=分隔。 -
示例配置项：
server.port=8080 spring.datasource.url=jdbc:mysql://localhost/test -
属性文件简单易读，被广泛用于 Java 应用程序配置。
-
-
YAML文件（.yml 或 .yaml）：
-
YAML 是一种数据序列化语言，用于配置文件，以数据层级和缩进风格而闻名。
-
示例配置项：
server: port: 8080 spring: datasource: url: jdbc:mysql://localhost/test -
YAML 文件更适用于表示层次结构的配置数据，易于人类阅读和编辑。
-
它们的区别主要包括：
-
格式：
.properties文件使用平面结构，每行一个属性，通常需要使用点（.）符号来表示层级结构。.yml文件使用缩进来表示层级结构，对缩进敏感，支持列表和复杂结构。
-
易读性：
- YAML 文件的易读性通常比属性文件好，因为属性文件可能会有很多重复的键前缀，更复杂的配置可能会造成视觉上的混乱。
- YAML 支持多行字符串、注释等特性，可使配置更整洁、易于管理。
-
编辑友好：
- YAML 文件由于其结构化特点，往往更适合编辑复杂的嵌套配置。
- 需要注意缩进和格式，错误的缩进可能会导致配置错误。
-
用例和习惯：
- 如果团队习惯了使用
.properties，那么迁移到.yml可能需要一点学习和适应时间。 - YAML 在现代应用（特别是在涉及到 Docker、Kubernetes 这样的容器技术）中越来越流行。
- 如果团队习惯了使用
Spring Boot 使得两种格式可以无缝交换使用，甚至可以在同一个应用中同时使用 .properties 和 .yml 配置文件。开发人员可以根据团队习惯和配置复杂性的需求，选择适合的配置格式。在 Spring Boot 中，通常以 application.yml（或 application.yaml）或 application.properties 的形式存储配置文件，默认的配置文件名称为 application，且可以通过环境、激活的配置文件（profile）来区分和覆盖配置。
29、SpringBoot 实现热部署有哪几种方式？
在 Spring Boot 中实现热部署（热重载）可以大幅提高开发效率，因为它允许开发者在修改代码后无需重启服务器就能立即看到改动的效果。以下是在 Spring Boot 中实现热部署的几种方式：
1. Spring Boot DevTools
Spring Boot 的 DevTools 模块是实现热部署的最简单方式。DevTools 可以自动检测类路径上文件的变化，并重新加载应用。
要启用 DevTools，需要在项目构建文件中添加依赖：
-
对于 Maven，在
pom.xml中添加：<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> <optional>true</optional> </dependency> </dependencies> -
对于 Gradle，在
build.gradle中添加：dependencies { developmentOnly 'org.springframework.boot:spring-boot-devtools' }
2. JRebel
JRebel 是一个商业 Java 插件，可以实现快速热部署。它监视项目中的变化，并在服务器上实时地将变化部署，无需重启 JVM。JRebel 集成了多种 IDE，虽然它是收费软件，但通常用于大型企业级项目。
要使用 JRebel，需要注册、下载并安装 JRebel 插件，并在 IDE 中进行相应配置。
3. Spring Loaded
Spring Loaded 是一个开源 Java 类加载器，它可以在不重启 JVM 的情况下重新加载类。尽管它在 Spring Boot 2.0 以后版本不再被推荐使用（因为 DevTools 的引入），但它仍然可以用于旧版本的 Spring Boot 或其他 Java 项目。
Spring Loaded 可以作为 JVM 的一个参数添加，例如：
-javaagent:path/to/springloaded-{version}.jar -noverify
4. HotSwapAgent 和 DCEVM
DCEVM 是一个修改过的 JVM，允许更广泛的类重新定义，而 HotSwapAgent 是基于 DCEVM 的一个运行时插件，可以扩展 Java 的热部署能力。这个工具组合可以重新定义加载过的类，并具有高级的重新加载功能，比如静态字段的修改或者添加新方法。
要使用这些工具，需要安装 DCEVM 并设置 HotSwapAgent 作为 JVM 参数。
总结
DevTools 是最简单且通常适用的选择，而 JRebel 提供了更高级的功能，适用于大型企业级项目。Spring Loaded、HotSwapAgent 和 DCEVM 提供了更多技术选项，但可能需要更多的配置。开发者可以根据自己的项目需求和预算选择最合适的工具。在选择时，应考量开发流程的方便性、兼容性和稳定性。
SpringBoot最新面试题汇总版(30)
1、SpringBoot有哪些优点？
Spring Boot 是基于 Spring 框架的，用于简化 Spring 应用程序创建和开发过程的工具。它的主要优点包括：
-
快速启动和构建应用：
Spring Boot 提供了大量的“Starter”依赖项，这些依赖项可以轻松地集成和自动配置 Spring 或第三方库。 -
自动配置：
Spring Boot 尝试根据添加的依赖项自动配置应用程序。例如，如果你的classpath中有H2数据库的依赖项，Spring Boot 会自动配置内存数据库。 -
独立运行：
生成的Spring Boot应用程序是独立的，可打包成单一的JAR或WAR文件，并且包含内嵌的Web服务器，如Tomcat、Jetty或Undertow。 -
无需配置XML：
Spring Boot不需要使用大量的XML配置；它利用Java基于注解的配置以及强大的类型安全的配置属性机制。 -
操作简便：
Spring Boot Actuator提供了用于监控和管理生产环境的应用程序的端点。 -
开箱即用：
Spring Boot提供了开箱即用的功能，例如安全性、度量标准和健康检查，让你能够更快地构建应用程序而无需手动设置这些特性。 -
简化部署：
Spring Boot 支持内嵌服务器和云部署，这使得部署应用程序更加简便。 -
与微服务架构兼容：
它与Spring Cloud紧密集成，提供了开发分布式系统（例如微服务架构）所需的支持。 -
社区和文档支持：
Spring Boot 有一个非常强大的社区，提供了很多教程、指南和最佳实践。 -
开朗的错误提示：
在启动过程中和运行时出现的错误会有有用的提示，以减少对配置问题和环境问题的调试时间。
总而言之，Spring Boot 的目标是提供一个简单、快速、见效的方法来创建一个零配置或最小配置的Spring应用程序，尤其是在微服务架构、云计算和基于容器的部署越来越普及的今天，Spring Boot证明了它的价值。
2、如何使用SpringBoot实现分页和排序？
在 Spring Boot 应用中实现分页和排序功能通常涉及到 Spring Data JPA 或 Spring Data MongoDB 等 Spring Data 项目。Spring Data 提供了 PagingAndSortingRepository 和 Pageable 接口，可以用来简化对数据访问层的分页和排序操作。
以下是使用 Spring Data JPA 实现分页和排序的一些基本步骤：
第一步：定义 Repository
确保你的 Repository 扩展 JpaRepository 或 PagingAndSortingRepository，它们都继承了分页和排序的方法。
public interface UserRepository extends JpaRepository<User, Long> {
// 这里可以定义额外的查询方法，JpaRepository 已包含了分页和排序的方法
}
第二步：在 Service 中使用 Pageable
在你的 Service 方法中，接受 Pageable 作为参数以用于分页和排序。PageRequest 类可以用来创建 Pageable 的实现实例。
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public Page<User> getUsers(Pageable pageable) {
return userRepository.findAll(pageable);
}
// 通过传递分页和排序参数创建 Pageable
public Page<User> getUsers(int pageNumber, int pageSize, String sortBy) {
Pageable pageable = PageRequest.of(pageNumber, pageSize, Sort.by(sortBy));
return userRepository.findAll(pageable);
}
}
第三步：在 Controller 中处理分页请求
在你的 Controller 方法中，可以接受页码、页大小和排序参数，然后调用 Service 方法。
@RestController
@RequestMapping("/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
public ResponseEntity<Page<User>> getUsers(
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "10") int size,
@RequestParam(defaultValue = "id") String sortBy) {
Page<User> users = userService.getUsers(page, size, sortBy);
return new ResponseEntity<>(users, HttpStatus.OK);
}
}
当请求到达时，Controller 会根据提供的页码、页大小和排序字段创建 Pageable 对象，然后使用它从 Repository 检索数据。返回的 Page<T> 对象包含当前页的数据，总记录数和其他分页相关的信息。
第四步：处理排序方向
如果还需要处理排序方向（升序或降序），可以在 Sort.by() 方法中使用 Sort.Order 类。
Sort sort = Sort.by(new Sort.Order(Sort.Direction.ASC, "name"), new Sort.Order(Sort.Direction.DESC, "email"));
Pageable pageable = PageRequest.of(pageNumber, pageSize, sort);
以上步骤展示了在 Spring Boot 中如何使用 Spring Data JPA 来实现数据的分页和排序。你可以根据自己的具体业务需求定制排序的逻辑和分页的参数。如果你使用的是其他类型的数据库，如 MongoDB、Cassandra 等，Spring Data 为这些数据库也提供了类似的抽象和接口来支持分页和排序。
请注意，为了保证 API 的可用性和性能，你可能还需要为分页增加合理的限制，例如对 pageSize 参数设置最大值。如果你有关于 Spring Boot 中分页和排序或者其他相关问题，请随时提问。
3、能否举一个例子来解释更多 Staters 的内容？
在Spring Boot中，Starters是一组便利的依赖描述符，你可以在项目的pom.xml文件中包含这些描述符来获得Spring Boot应用所需的依赖。Starters包含了许多自动配置的库，使得开发者几乎可以不做其他配置就能快速开始编程。
Starters涵盖了很多领域，包括Web开发、数据访问、消息传递、安全、测试和许多其他方面的需求。以下是一些常用的Spring Boot Starter示例，以及对它们内容的描述：
-
spring-boot-starter-web：
用于构建Web应用程序，包括RESTful应用程序。它使用Spring MVC、Tomcat作为默认的嵌入式容器。 -
spring-boot-starter-data-jpa：
提供对Spring Data JPA的支持，使得可以很方便地通过JPA来访问数据库。这个Starter包括了与Hibernate的整合，只需要最少的配置。 -
spring-boot-starter-thymeleaf：
用于支持Thymeleaf模板引擎的Spring Boot应用程序，适合构建动态Web页面。 -
spring-boot-starter-security：
提供了Spring Security的自动配置能力，用于构建安全的Web应用程序。 -
spring-boot-starter-test：
包括JUnit、Spring Test & Spring Boot Test、AssertJ、Hamcrest、Mockito等测试库，适用于单元测试和集成测试。 -
spring-boot-starter-actuator：
提供了生产级别的功能，比如监控和管理应用程序。
举一个具体的例子，如果你正在创建一个Web应用程序，并且希望使用Spring Boot支持的默认设置，你的pom.xml可能包含以下的Starter：
<dependencies>
<!-- Web Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Security Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- JPA Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- Testing Starter，通常用于test scope -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
使用这些Starters后，你的项目将自动配置那些复杂的依赖项，你几乎可以立即开始创建你的业务逻辑。
这些Starters抽象了很多复杂的配置工作，有助于快速启动新项目，让你专注于应用程序的核心功能。同时，Spring Boot也允许你添加其他的依赖项或覆盖Starter中提供的默认配置，以匹配特定的需求。
4、如何使用 SpringBoot 自动重装我的应用程序？
在 Spring Boot 应用中实现自动重装（或称之为热加载、热部署），最简单的方法是使用 Spring Boot 的开发者工具：Spring Boot DevTools。
Spring Boot DevTools 是一个为开发过程中提供额外功能的模块，比如自动重新启动。当你对代码做出更改并保存时，DevTools 会自动触发应用重启。
以下是使用 DevTools 的步骤：
-
将 DevTools 添加到项目依赖：
-
如果你的项目是 Maven 工程，在
pom.xml中添加：<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> <optional>true</optional> </dependency> </dependencies> -
如果你的项目是 Gradle 工程，在
build.gradle中添加：dependencies { developmentOnly 'org.springframework.boot:spring-boot-devtools' }
-
-
重新构建项目：
你需要重新构建项目以便 DevTools 能够生效。如果是用 IDE 的话，大多数情况下 IDE 会帮你自动完成这一步。 -
启动应用程序：
以普通方式启动你的应用。如果在支持的 IDE （如 IntelliJ IDEA、Eclipse）中，DevTools 将自动启用。 -
修改代码：
当你修改了代码并保存之后，DevTools 会检测到变更，并自动进行重新加载或者重启。 -
访问你的应用程序：
使用浏览器访问你的应用程序，你应该能看到最新的更改内容。
注意事项：
- DevTools 默认依赖于
classpath的变更来触发重装。如果你的 IDE 不是自动编译更改的文件，你可能需要手动触发编译。 - DevTools 在生产环境下默认禁用，所以它仅适用于开发环境。
- 为了更好地利用 DevTools，你还可以在
application.properties或application.yml文件中添加额外的配置以自定义它的行为。 - 如果 DevTools 没有如预期工作，可以检查
spring.devtools.restart.enabled属性是否被设置为true。 - DevTools 还提供了其他功能，例如模板缓存的禁用、自动配置的低级性能优化等。
- 请注意，在使用 JAR 打包的 Spring Boot 应用程序中，任何静态资源的变化都无法触发重启，但会触发自动重载。
5、创建一个 SpringBoot Project 的最简单的方法是什么？
创建一个 Spring Boot 项目的最简单方法通常是使用 Spring Initializr，这是一个在线工具，可以生成一个基本的 Spring Boot 项目结构和配置，你可以根据自己的需要选择依赖和其他选项。
以下是使用 Spring Initializr 创建一个 Spring Boot 项目的步骤：
-
打开 Spring Initializr 网站：https://start.spring.io/
-
选择项目的属性：
- 项目类型（Maven Project 或 Gradle Project）
- 所使用的语言（Java、Kotlin 或 Groovy）
- Spring Boot 版本
- 项目元数据（Group、Artifact、Name、Description、Package name等）
-
选择项目依赖：
你可以根据需要添加的功能搜索并添加特定的“Starters”。一些常见的 starters 包括“Web”、“Security”、“Data JPA”、“Thymeleaf”等。 -
生成项目：
填好所有选项后，点击“Generate”按钮，这将下载一个包含所选依赖的项目ZIP文件。 -
解压缩生成的 ZIP 文件，并用你选择的IDE（例如 IntelliJ IDEA、Eclipse、VS Code 等）打开。
-
开始开发：
解压缩之后，你会得到一个具有初始结构的项目，包含了一个主应用程序类和一个application.properties或application.yml配置文件。你可以通过编写控制器、服务和其他组件开始你的项目开发。
使用 Spring Initializr 的好处是你可以快速生成一个项目，并立即开始编码，而无需手动创建项目结构和配置文件。这个方法适用于所有经验级别的开发人员，并广泛被用于快速启动新的 Spring Boot 项目。
6、Spring Cache 三种常用的缓存注解和意义？
在 Spring Framework 中，Spring Cache 提供了一套声明式缓存抽象，让开发者通过注解的方式轻松地在应用中加入缓存功能。三种常用的缓存注解包括：
-
@Cacheable：-
该注解用于标记在方法上，当方法被调用时，Spring 先在缓存中查找方法的返回值是否已经存在，如果存在直接返回缓存的值，否则执行方法，并将结果存入缓存。
@Cacheable可以有效减少不必要的方法执行，加快系统的响应速度。 -
示例：
@Cacheable(value = "books", key = "#isbn") public Book findBook(ISBN isbn) { // 方法实现，如果缓存不存在，执行业务逻辑 }其中，
value是缓存名称，key是缓存的键。
-
-
@CachePut：-
该注解用于标记在方法上，无论如何都会执行方法，并将结果放入指定的缓存中。
@CachePut是用来更新缓存数据的，适用于更新操作。 -
示例：
@CachePut(value = "books", key = "#isbn") public Book updateBook(ISBN isbn, BookDescriptor descriptor) { // 方法实现，执行业务逻辑并更新缓存 }在执行
updateBook方法时，无论缓存中是否存在数据，都会执行方法并更新相关缓存。
-
-
@CacheEvict：-
该注解用于标记在方法上，用来从缓存中移除相应数据。
@CacheEvict可以指定在方法执行之前或之后将数据从缓存中移除，常用于删除操作。 -
示例：
@CacheEvict(value = "books", key = "#isbn") public void deleteBook(ISBN isbn) { // 方法实现，执行业务逻辑并从缓存中移除项 }在执行
deleteBook方法时，会将缓存中key对应的数据移除。
-
这些注解都接受以下公共参数：
value或cacheNames：指定缓存名称，对应缓存管理器管理的缓存。key：缓存项的键，用于在缓存中查找值。condition：缓存条件，只有满足条件的情况下才进行缓存相关的操作。
除了上述注解之外，@Caching 是一个组合注解，可以同时应用多个缓存操作。
使用 Spring 缓存注解，可以大大简化应用程序中的缓存管理，避免手动在代码中控制缓存逻辑，使得业务代码更加简洁和清晰。需要注意的是，为了使缓存注解正常工作，还需要在配置文件或配置类中启用缓存支持（比如通过 @EnableCaching 注解）。如果有进一步的问题，请随时提问。
7、什么是Spring Actuator？它有什么优势？
Spring Actuator是Spring Boot的一个子项目，它使得可以通过多种HTTP或JMX端点来监控和管理应用程序。Actuator端点让你可以访问应用程序的内部状态和指标，例如应用程序的健康状况、当前配置属性、内部运行指标、堆栈跟踪以及其他一些信息。
Spring Actuator拥有以下几个优势：
-
应用监控：
- Actuator提供了可实时监控应用状态的端点，比如
/health、/metrics、/audit等。
- Actuator提供了可实时监控应用状态的端点，比如
-
生产准备特性：
- 它提供了开箱即用的生产级特性来帮助监控和管理应用，而不需要开发者对现有应用做大量修改。
-
可定制性和扩展性：
- 端点可以被自定义和扩展。你可以根据需要开启或关闭特定的端点，甚至可以添加自己的端点。
-
应用管理：
- 它支持对应用进行管理操作，如关闭(
/shutdown—需明确开启此端点才有效)和更改日志级别。
- 它支持对应用进行管理操作，如关闭(
-
安全集成：
- 与Spring Security集成，确保敏感端点的访问权限得到控制。
-
HTTP和JMX支持：
- Actuator端点支持通过HTTP和JMX访问，增加了管理和监控的灵活性。
下面是启用Spring Boot Actuator的简单步骤：
- 加入spring-boot-starter-actuator依赖到你的Spring Boot项目中：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
- 应用中的Actuator端点可通过配置文件修改其行为，例如可以指定端点的可访问性或是否暴露敏感信息。以下是
application.properties的一个配置示例：
management.endpoints.web.exposure.include=info,health,metrics
- 访问Actuator端点，大多数端点默认是开放的。比如，要获取应用的健康信息，你可以访问
/actuator/health端点。
通过Spring Actuator，你可以方便地检查和管理生产环境中的Spring Boot应用程序。它是Spring生态系统中对于构建现代微服务架构应用非常重要的工具之一。
8、什么是 Spring Profiles？
Spring Profiles 是 Spring Framework 提供的一种特性，它允许开发者定义多种配置环境，以便于在不同环境下部署和管理应用程序。通过使用 Spring Profiles，可以在开发、测试和生产等环境中使用不同的配置。
使用场景
- 环境区分：在开发、测试、生产环境中使用不同的配置，如数据库连接、外部服务URL和特性标志等。
- 功能开关：在某特定环境中开启或关闭应用的特定功能。
- 调试配置：暂时性启用某些配置用于调试目的，而不影响正常配置。
定义 Profiles
在 Spring 应用中，可以使用 @Profile 注解来标记配置类或组件只在特定的 Profile 激活时才生效。
@Configuration
@Profile("development")
public class DevelopmentConfig {
// ... 针对开发环境的 Bean 定义和配置
}
激活 Profiles
Profiles 可以通过多种方式进行激活：
-
通过 Spring Boot 的 application.properties 或 application.yml：
# application.properties spring.profiles.active=development,test# application.yml spring: profiles: active: - development - test -
通过 JVM 参数：
java -jar -Dspring.profiles.active=production myapp.jar -
通过环境变量：
export SPRING_PROFILES_ACTIVE=development,test -
在代码中：
可以在 Spring Boot 应用的main函数中使用SpringApplicationBuilder来激活 Profiles：public static void main(String[] args) { new SpringApplicationBuilder(Application.class) .profiles("production", "aws") .run(args); }
Profile 组
从 Spring 5.1 版本开始，可以将多个相关的 Profile 组合成一个组，在应用中通过激活或禁用一个组的名字来同时切换这组 Profiles。
注意事项
- Profiles 应谨慎使用，确保不会引入复杂性和混乱性，尤其是当配置变多时。
- 相关的 Profile 不应该有太多的重复配置，考虑使用配置文件的继承特性来优化维护性。
- 当需要支持更多灵活配置时，可以结合 Spring Cloud Config 等外部配置中心来更好地管理配置和 Profiles。
通过使用 Spring Profiles，我们能够灵活管理应用在不同环境下的行为，从而降低环境配置导致的风险和复杂性。
9、如何使用 SpringBoot 部署到不同的服务器？
使用Spring Boot将应用部署到不同服务器的过程通常包括创建可执行的JAR或WAR文件，然后在目标服务器上运行它。下面是使用Spring Boot部署到不同服务器的基本步骤：
部署至内嵌服务器
Spring Boot的一个优势是它可以嵌入Web服务器（如Tomcat、Jetty或Undertow），使之无需额外的服务器安装即可直接运行。
-
创建可执行JAR/WAR：使用Maven或Gradle构建工具，将应用打包成包含所有依赖项的JAR或WAR文件。
Maven:
mvn clean packageGradle:
gradle build -
运行JAR/WAR：直接使用Java命令运行JAR或WAR文件。
java -jar target/yourapplication-0.0.1-SNAPSHOT.jar -
配置外部属性：如果需要，可以通过命令行参数、环境变量、外部配置文件等方式修改应用的配置。
部署至外部服务器
如果要部署到独立的外部应用服务器（如独立Tomcat服务器），通常需要：
-
创建WAR文件：修改
pom.xml以打包为WAR文件，并可能需要排除内嵌服务器依赖。在
pom.xml中，确保设置了正确的打包方式：<packaging>war</packaging> -
构建WAR文件：使用Maven或Gradle执行构建命令创建WAR文件。
-
将WAR部署到服务器：将生成的WAR文件复制到目标服务器的部署目录，如
webapps目录。 -
启动/重启服务器：启动或重启Web服务器来完成部署。
部署到云服务（如AWS、Azure、GCP等）
使用Spring Boot部署到云服务可能有它们自己特别的工具和方式，但基本概念与上述类似。
-
创建JAR/WAR文件：按照云服务的要求打包你的应用。
-
使用云服务工具：用特定于云服务的命令行工具或控制台上传并管理应用。
-
配置：配置云服务环境，包括与数据库、消息队列等其他云资源的连接。
-
部署和监控：一旦应用部署成功，使用云平台提供的工具来监控应用的状态和性能。
不同服务器和环境可能要求不同的部署策略，因此部署之前需要仔细阅读和遵循目标环境或服务器的官方文档。此外，现代CI/CD（持续集成和持续部署）实践可能涉及到更自动化和集成化的部署流程。
10、如何重新加载SpringBoot上的更改，而无需重新启动服务器？
为了在 Spring Boot 应用程序中进行更改并立即看到效果，而不用重启服务器，你可以使用以下几种方法：
-
Spring Boot DevTools：
-
Spring Boot DevTools 是一个为开发环境设计的依赖库，它可以使得应用程序在检测到类文件变更时自动重启。
-
要使用 DevTools，你需要将其作为依赖项添加到你的项目中：
<!-- 添加到 Maven pom.xml 文件中 --> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> <optional>true</optional> </dependency> </dependencies> -
添加完成后，当你在 IDE 中保存更改或者编译了项目，Spring Boot 应用就会自动重启。请注意，DevTools 通过一个 ‘类加载器’ 来重新加载类，因此它不能处理更复杂的改变（比如添加新的方法）。
-
-
LiveReload：
- DevTools 库包含了一个内嵌的 LiveReload 服务器。如果你在浏览器上安装了 LiveReload 插件，那么每次应用重启的时候，页面也会自动刷新。
-
JRebel：
- JRebel 是一个商业的 Java 插件，它可以在不重启服务器的情况下实时重新加载代码和资源的改变。JRebel 支持更复杂的更改，并且与多种 Java 应用服务器和框架兼容，但需要付费使用。
-
Spring Loaded（已淘汰）：
- Spring Loaded 曾是一个用来实现热加载的工具，但现在已经不再维护，并且不推荐用于最新版本的 Spring Boot。
-
IDE 插件：
- 一些 IDE 插件，比如 IntelliJ IDEA 的 HotSwap 功能，也可以在一定程度上实现热部署。
-
远程更新：
- 对于某些支持远程更新的 Spring 模块（如 Spring Cloud Config），你可以配置服务来从远程配置中心加载配置，并且可以在发生更改时自动刷新配置。
使用 DevTools 是在 Spring Boot 开发过程中重新加载更改的最简单方式，因为它易于配置且性能表现良好。它也是由 Spring 团队官方支持的方法。如果你有更多关于 Spring Boot 或其他相关的问题，欢迎随时提问。
11、SpringBoot 日志框架：
Spring Boot支持多种日志框架，但默认配置为使用SLF4J（Simple Logging Facade for Java）作为日志门面和Logback作为日志实现。
这里是Spring Boot支持的主要日志框架简介及其配合SLF4J的使用方式：
1. Logback
Logback是Spring Boot默认的日志框架，它是由log4j创始人设计的一个Java日志库。Logback提供了快速的实现，广泛的日志级别，并且非常易于通过XML或Groovy语言进行配置。Spring Boot自动配置Logback，只要你在classpath中添加了spring-boot-starter-logging starter（默认情况下包括在大多数Spring Boot starters中）。
2. Log4j2
Log4j2也是一种流行的日志框架，有优越的吞吐量和更低的延迟，但在某些情况下配置比Logback要复杂。要在Spring Boot中使用Log4j2，你需要排除默认的Logback依赖，然后引入spring-boot-starter-log4j2之类的依赖。
3. JUL (Java Util Logging)
Java的内置日志框架，Spring Boot支持，但由于其局限性无法利用Spring Boot的高级日志配置特性。大多数情况下不推荐使用。
使用SLF4J
SLF4J作为一个日志门面，允许用户在底层使用不同的日志框架。Spring Boot的默认配置已经设定好了SLF4J与Logback的组合，所以开发者通常只需使用SLF4J提供的日志接口来记录日志。
例如，使用SLF4J可以这样创建和使用Logger对象：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyBean {
private static final Logger logger = LoggerFactory.getLogger(MyBean.class);
public void doSomething() {
logger.info("Doing something");
}
}
在Spring Boot中，如果你希望使用不同于Logback的日志框架，你需要修改依赖并适当配置，以确保日志门面SLF4J背后的实现是你选定的框架。例如，如果选择使用Log4j2，你需要在pom.xml文件中做出相关更改，并可能需要添加一个log4j2-spring.xml或类似的配置文件来指定日志配置。
12、什么是Apache Kafka？
Apache Kafka 是一个分布式流数据平台，它被广泛用于构建实时数据流处理系统。由 LinkedIn 开发并于 2011 年开源，现由 Apache Software Foundation 管理。
核心概念
Kafka 的核心概念包括：
- 生产者（Producer）：负责发布消息到 Kafka 集群中的主题（Topics）。
- 消费者（Consumer）：订阅主题并处理其接收到的消息。
- 主题（Topic）：消息的分类，在 Kafka 内部是消息存储和发布的逻辑单元。
- 分区（Partition）：主题在物理上的分割，可以分布在多个服务器上，每个分区是一个有序的不可变消息序列。
- 副本（Replica）：分区的副本，可以在节点故障时提供数据的冗余和可用性。
- 偏移量（Offset）：在每个分区中，每条消息被分配的唯一序号。
- 消费者群组（Consumer Group）：一组消费者共同读取一个主题，每个消费者读取其中的不同分区以实现负载均衡。
功能与特性
Kafka 具有以下重要特性：
- 高吞吐量：与传统的消息系统相比，Kafka 在保证可靠性的同时提供了很高的吞吐量。
- 可扩展性：Kafka 可以横向扩展，处理更多的消息负载并保持低延迟。
- 持久性：Kafka 使用磁盘存储，并且具有消息持久性的能力。
- 可靠性：分区和副本机制确保系统的可用性和数据的不丢失。
- 容错性：节点故障不会造成数据丢失，可自动进行故障转移恢复。
- 实时处理：支持实时的消息发布和消费。
应用场景
Kafka 常用于以下场景：
- 日志收集：将不同系统或组件的日志集中存储。
- 流式数据处理：结合 Kafka Streams 或其他流处理框架进行实时数据处理。
- 事件源（Event Sourcing）：用于记录事件的时间序列。
- 消息系统：作为传统消息系统的替代或升级。
- 网站活动跟踪：跟踪用户行为或系统事件。
Kafka 可以被用作大数据生态系统中的数据集成平台，它可以与 Hadoop、Spark 等系统协同工作，用于构建大规模的数据分析管道和实时的数据流处理应用。由于其高效、可靠、可伸缩的特点，Kafka 已被许多大型互联网公司和企业应用在生产环境中。
14、开启 SpringBoot 特性有哪几种方式？
在Spring Boot中，有几种方式可以启用其特性，包括自动配置、自定义配置和各种组件的集成。以下是启用Spring Boot特性的一些主要方式：
1. 使用 @SpringBootApplication 注解
这是启用Spring Boot主要特性的最简单方式。@SpringBootApplication是一个方便的注解，它封装了以下组合注解：
@SpringBootConfiguration：标记为Spring Boot的配置类。@EnableAutoConfiguration：启用Spring Boot的自动配置机制。@ComponentScan：启用@Component注解的类的自动扫描和注册。
将此注解添加到Spring Boot应用程序的主类上将激活自动配置和组件扫描。
2. 使用 @EnableAutoConfiguration 注解
如果你需要更精细地控制配置而不使用@SpringBootApplication，可以单独使用@EnableAutoConfiguration注解。这样做会启用自动配置，但没有进行组件扫描。
3. 配置 application.properties 或 application.yaml
这两个文件作为应用程序的主要配置文件，用于配置Spring Boot应用程序的各种参数和自定义行为。在这些文件中，可以设置数据库连接、服务器端口、日志级别等。
4. 使用 Spring Beans 和 @Configuration 注解
构建自定义的配置类，使用@Configuration标记，并使用@Bean定义单个bean，可以启动自定义Java配置。
5. 使用 Spring Boot Starters
Spring Boot提供了大量的Starters POMs，它们包含了启用各种功能（如Web开发、数据访问、消息服务等）所需的依赖项。
6. 使用 @Conditional 注解
使用@Conditional及其子注解（如@ConditionalOnClass、@ConditionalOnMissingBean等），可以根据特定条件启用不同的配置。
7. 使用 Spring Boot Actuator
Spring Boot Actuator提供了多个监控和管理生产级应用程序的端点。添加actuator starter依赖可以启用这些端点。
8. 使用外部化配置
Spring Boot支持在运行时读取外部配置，如环境变量、系统属性、命令行参数等。这可以覆盖或扩展应用程序的配置。
9. 使用 Profile-specific Properties
使用不同的配置文件（如application-dev.properties、application-test.properties）定义不同环境的配置，并通过激活特定profiles来启用它们。
10. 自定义自动配置类
通过创建自己的@Configuration类，并对其中使用@Conditional注解，可以实现自定义的自动配置。
以上这些方式可以帮助开发者充分利用Spring Boot的强大特性，减少初始搭建和开发Spring应用程序的时间，并且提供易于维护、测试和部署的代码。
15、什么是 Spring Data ?
Spring Data 是一个用于简化数据库访问的开源框架，它是 Spring 生态系统的一部分。Spring Data 提供了一套统一的数据访问层（Data Access Layer，DAL）的 API，用来操作各种数据存储技术，如关系数据库、NoSQL 数据库、Map-Reduce 框架、云数据服务等。
Spring Data 的主要特点和优势包括：
-
一致的数据访问模式：不论是哪种数据库或存储技术，Spring Data 都提供了一致的编程模型，使得开发者能够使用相似的方式来访问和操纵数据。
-
存储特定的实现：Spring Data 提供了多个子项目，这些子项目针对不同的数据存储技术实现了专有的扩展，如 Spring Data JPA、Spring Data MongoDB、Spring Data Redis 等。
-
强大的查询抽象：Spring Data 支持基于方法名、注解查询和 Querydsl 等多种查询方式，它可以根据你定义的接口方法名自动生成查询实现。
-
传统或反应式编程：除了支持传统的同步数据访问方式，Spring Data 还提供了反应式编程模型的支持，能够提高数据操作的效率和可伸缩性。
-
持久层和域类逻辑分离：Spring Data 促进了持久层和业务逻辑层的分离，你可以集中精力在业务逻辑上，而不是数据访问细节。
-
简化的 CRUD 操作：Spring Data Repositories 提供了轻松的 CRUD 操作，并有可能扩展特定的数据访问功能。
-
声明式事务管理：Spring Data 支持声明式事务管理，允许开发者通过注解或配置方式来控制事务的边界和规则。
-
跨存储持续性：通过 Spring Data REST，你可以轻松地将存储库公开为 RESTful 资源，这适用于快速构建数据驱动的 REST API。
例如，使用 Spring Data JPA，你可以定义一个领域类 Person 和一个 DAO 接口 PersonRepository，而无需编写具体的实现：
public interface PersonRepository extends CrudRepository<Person, Long> {
List<Person> findByLastName(String lastName);
}
Spring Data 将为这个接口生成一个代理类，并实现所有的 CRUD 操作，包括根据方法命名约定或注解定义自定义的查询。
Spring Data 成功地简化了数据访问层的开发工作量，并提供了一种更加灵活、高效的方式来操作不同种类的数据源。如果你有进一步的问题，请随时提问。
16、可以在SpringBoot application中禁用默认的Web服务器吗？
是的，在Spring Boot应用中，你可以禁用默认的Web服务器。Spring Boot默认是自带了Web服务器Tomcat的，可以通过设置spring.main.web-application-type属性为none来禁用它。这允许运行一个不需要Web服务器的Spring Boot应用，即所谓的“非web应用”。
在application.properties或application.yml配置文件中可以通过以下方式设置：
application.properties:
spring.main.web-application-type=none
application.yml:
spring:
main:
web-application-type: none
或者在Spring Boot应用的主类中也可以通过编程的方式来设置：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.WebApplicationType;
@SpringBootApplication
public class SpringBootConsoleApplication {
public static void main(String[] args) {
SpringApplication application = new SpringApplication(SpringBootConsoleApplication.class);
application.setWebApplicationType(WebApplicationType.NONE); // Set Web application type to NONE
application.run(args);
}
}
当将WebApplicationType设置为NONE时，Spring Boot将不会启动内嵌的Tomcat，Jetty或Undertow服务器，应用将作为一个常规的Spring应用启动，可以用来开发命令行应用等非web环境下的用途。
通过禁用默认的Web服务器，Spring Boot应用可以作为一个简单的Java应用来运行，这在创建一些批处理或后台任务应用时特别有用。这种运行方式也便于集成到各类不需要提供HTTP服务的具体场景和系统中，比如消费者应用或数据处理应用。
17、SpringBoot中的监视器是什么？
在 Spring Boot 中，监视器通常指的是 Spring Boot Actuator 的一部分，Actuator 是 Spring Boot 的一个子项目。它提供一系列生产级的端点（Endpoints）来帮助你监控和管理应用程序。
Spring Boot Actuator 的端点可以提供各种信息，如应用程序的健康状态、度量信息、配置属性、日志级别、环境信息以及线程状态等。这些端点可以通过 HTTP、JMX 或其他远程管理方式来访问。
以下是 Spring Boot Actuator 中一些重要的内置端点的示例：
- /actuator/health：显示应用程序的健康状态，比如数据库是否运行正常，磁盘空间是否足够等。
- /actuator/info：显示任意的应用信息，如版本、描述、自定义元数据等，通常这些信息是在
application.properties或application.yml文件中配置的。 - /actuator/metrics：提供详细的度量信息，例如 JVM 内存使用、线程统计、垃圾收集周期等。
- /actuator/env：显示当前的环境属性，包括配置文件里的属性以及系统环境变量等。
- /actuator/loggers：允许你查看和修改日志级别（比如为 DEBUG、INFO 等）。
启用 Actuator
为了使用 Spring Boot Actuator，需要在项目的依赖管理文件中添加 Actuator 依赖。
对于 Maven，你需要添加：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
对于 Gradle，则是：
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-actuator'
}
配置 Actuator
Actuator 默认不会开放所有端点，出于安全考虑，某些端点可能被限制访问。你可以使用 application.properties 或 application.yml 文件来配置 Actuator 的行为，例如，开放特定端点或修改端点路径。
# application.properties
management.endpoints.web.exposure.include=health,info
Spring Boot Actuator 是企业应用开发中的一个重要工具，可以帮助开发人员和运维团队更方便地监控和管理应用程序，同时实现自动化操作和远程故障排查。在部署到生产环境时，合理地配置和使用 Actuator 端点有助于维持应用的健壮性和高可用性。
18、如何使用SpringBoot实现异常处理？
在Spring Boot中，异常处理通常是结合Spring MVC功能实现的。可以通过以下几种方式来处理异常：
使用 @ControllerAdvice 和 @ExceptionHandler
@ControllerAdvice是一个组件注解，它允许你跨多个@Controller类全局地处理异常。当将其与@ExceptionHandler结合使用时，可以创建一个中央异常处理器。
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(CustomException.class)
public ResponseEntity<String> handleCustomException(CustomException ex) {
// 处理自定义异常
return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
}
@ExceptionHandler(Exception.class)
public ResponseEntity<String> handleGeneralException(Exception ex) {
// 处理通用异常
return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
}
}
使用 ResponseStatusException
从Spring 5开始，你可以在控制器方法中使用ResponseStatusException来直接处理异常。这种方式的好处是直接且容易使用，但控制较少。
@RestController
public class MyController {
@GetMapping("/someApi")
public String someApiMethod() {
if (someErrorCondition) {
throw new ResponseStatusException(
HttpStatus.BAD_REQUEST, "Custom Message");
}
return "result";
}
}
使用 @RestControllerAdvice
对于RESTful服务，使用@RestControllerAdvice是处理异常的好方法。这与@ControllerAdvice类似，但它默认为异常处理方法添加了@ResponseBody，所以它总是返回一个响应体。
@RestControllerAdvice
public class RestResponseEntityExceptionHandler {
@ExceptionHandler(CustomException.class)
public ResponseEntity<CustomErrorResponse> handleCustomException(CustomException ex) {
// 返回自定义的响应实体
CustomErrorResponse errorResponse = new CustomErrorResponse(...);
return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
}
}
自定义 Error Controller
Spring Boot 默认提供了/error映射，用于处理所有未被应用程序处理的错误。你可以通过实现ErrorController接口来自定义这个行为。
@Controller
public class CustomErrorController implements ErrorController {
@RequestMapping("/error")
public String handleError(HttpServletRequest request) {
// 自定义处理逻辑
return "error";
}
@Override
public String getErrorPath() {
return "/error";
}
}
使用 BindingResult
在使用Spring MVC进行表单验证时，方法参数中的BindingResult可以用来处理与验证失败相关的异常。
@PostMapping("/user")
public ResponseEntity<String> saveUser(@Valid @RequestBody User user, BindingResult result) {
if (result.hasErrors()) {
// 处理校验错误
}
// 保存用户
}
使用Spring Boot进行异常处理时，你可以根据需要结合上述不同的策略。全局异常处理器@ControllerAdvice或@RestControllerAdvice可以为整个应用程序提供一致的异常处理策略。而ResponseStatusException和自定义ErrorController可以为特定情况提供更直接的处理方式。
19、SpringBoot 可以兼容老 Spring 项目吗，如何做？
是的，Spring Boot 与旧版的 Spring 项目是兼容的，可以将传统的 Spring 应用迁移到 Spring Boot。这使得开发者能够从 Spring Boot 的便利性和自动配置特性中受益。以下是整合老 Spring 项目到 Spring Boot 的一般步骤：
-
创建基础 Spring Boot 项目结构：
- 使用 Spring Initializr 或其他工具创建一个新的 Spring Boot 项目结构。
- 可以选择相应的起始依赖（Starter Dependencies）来匹配旧项目中使用的功能。
-
依赖管理：
- 移除旧项目中的
spring-context、spring-webmvc等依赖，替换为 Spring Boot 的起始依赖，比如spring-boot-starter-web。 - 确保移除所有对版本管理的
<version>标签，因为 Spring Boot 的 Starter 依赖会管理合适的版本。
- 移除旧项目中的
-
调整配置：
- 移动和更新旧项目中的 XML 配置文件到基于 Java 的配置格式（如果还没这么做的话），并确保用
@Configuration注解标记。 - 将属性文件（如
application.properties或application.yml）移到src/main/resources目录。
- 移动和更新旧项目中的 XML 配置文件到基于 Java 的配置格式（如果还没这么做的话），并确保用
-
主应用类：
- 创建一个带有
@SpringBootApplication注解的主应用类。这个注解包含了@Configuration、@EnableAutoConfiguration和@ComponentScan，会触发 Spring Boot 的自动配置。
- 创建一个带有
-
代码迁移：
- 将你的业务逻辑、控制器、服务等类文件移动到新项目中的相应位置。
- 完成对服务层、数据层（比如基于 Spring Data 的 Repository）等组件的迁移。
-
修改 Web.xml：
- 如果旧项目中使用了 web.xml，分析其中的 Servlets 和 Listeners 并将其配置移动到主应用类或配置类中。
-
测试、调试和调优：
- 运行新的 Spring Boot 应用并执行深入的测试。
- 根据需要对日志、数据源、事务管理等进行调整。
-
并发升级：
- 如果旧项目中使用的库版本和 Spring Boot 中的起始依赖版本不匹配，可能需要进行库版本的升级。
-
数据迁移：
- 如果项目涉及数据库，确保正确地迁移并配置数据源和任何特定的数据库初始化操作。
上述过程可能会因为项目具体情况而有所不同，迁移复杂度取决于原始 Spring 应用的规模和复杂性。进行迁移时，建议逐步进行，每次只迁移一部分功能，并经常测试以确保每个步骤的改动都是正确的。如果你遇到具体的问题，请随时提问，我将尽力协助解决。
20、如何使用SpringBoot实现异常处理?
在Spring Boot中，异常处理通常采用以下几种方法：
- Controller层的异常处理（使用
@ExceptionHandler）：
在Controller中，你可以使用@ExceptionHandler注解来处理特定的异常。这种方法仅适用于单个Controller内部。
@Controller
public class MyController {
@RequestMapping("/example")
public String handleRequest() {
// some logic here
throw new RuntimeException("Exception in handleRequest");
}
@ExceptionHandler(RuntimeException.class)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
public String handleException(RuntimeException ex) {
// 处理异常，返回错误视图或响应
return "errorView";
}
}
- 全局异常处理（使用
@ControllerAdvice和@ExceptionHandler）：
通过创建一个@ControllerAdvice类，你可以编写全局的异常处理代码，它将应用于所有的Controller。
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(NullPointerException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public ResponseEntity<String> handleNullPointerException(NullPointerException ex) {
// 提供一个错误的响应实体
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body("NullPointer Exception was thrown!");
}
}
- 使用
ResponseEntityExceptionHandler：
为了更细粒度的控制响应，可以扩展ResponseEntityExceptionHandler。这也是一个使用@ControllerAdvice进行全局异常处理的有效方法。
@ControllerAdvice
public class CustomGlobalExceptionHandler extends ResponseEntityExceptionHandler {
@Override
protected ResponseEntity<Object> handleMethodArgumentNotValid(
MethodArgumentNotValidException ex,
HttpHeaders headers,
HttpStatus status,
WebRequest request) {
// 自定义响应体
Map<String, Object> body = new LinkedHashMap<>();
body.put("status", status.value());
// 添加错误详情等
return new ResponseEntity<>(body, headers, status);
}
// ...实现其他异常处理方法...
}
- 自定义错误控制器（实现
ErrorController接口）：
你可以实现ErrorController接口并添加对/error路径的映射来提供自定义的错误处理页面。
@Controller
public class CustomErrorController implements ErrorController {
@RequestMapping("/error")
public String handleError() {
// 提供自定义的错误信息
return "customError";
}
@Override
public String getErrorPath() {
return "/error";
}
}
- 使用
ResponseStatusException（自从Spring 5和Spring Boot 2开始）：
直接在你的Controller中抛出ResponseStatusException，可以同时提供HTTP状态码和异常信息。
@GetMapping("/item")
public String getItem() {
// some logic that throws an error
throw new ResponseStatusException(
HttpStatus.NOT_FOUND, "Item Not Found", new RuntimeException());
}
需要注意的是，好的异常处理不仅涉及到恰当地捕获和处理异常，还包括提供有用的反馈给客户端，以及确保敏感信息不被泄露。在设计你的异常处理策略时，务必兼顾以上几点。通过上述方法，Spring Boot提供了灵活的方式来应对各种异常处理的需求。
21、什么是 SpringBoot 启动类注解?
Spring Boot 启动类注解是指用于配置和启动 Spring Boot 应用程序的一组特殊注解。最核心的启动类注解是 @SpringBootApplication，它是一个方便的注解，组合了三个常用的注解：
-
@SpringBootConfiguration：
- 声明当前类为配置类，等价于 Spring 的
@Configuration注解，用于定义配置信息。 - 是 Spring Framework 中注解驱动配置的体现，并且允许注册额外的 beans 到 container 或导入其他配置类。
- 声明当前类为配置类，等价于 Spring 的
-
@EnableAutoConfiguration：
- 告诉 Spring Boot 根据添加的 jar 依赖自动配置项目。例如，如果
spring-webmvc在类路径上，那么就会自动添加 Web MVC 配置。 - 是利用 Spring Boot 特性的核心，用于自动配置 Spring 应用程序的上下文，减少开发者需要编写的配置。
- 告诉 Spring Boot 根据添加的 jar 依赖自动配置项目。例如，如果
-
@ComponentScan：
- 自动扫描并加载符合条件的组件或bean定义，通常用于标记在配置类上。
- 默认情况下，它会扫描当前类所在的 package 及其子 package。
这三个注解结合在一起的 @SpringBootApplication 注解通常用于你的 Spring Boot 应用程序的主类上，如下例所示：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // 核心的启动类注解
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
在这个主类中，main() 方法使用了 SpringApplication.run() 来启动 Spring 应用程序。这个主类相当于是启动引导类，是整个应用开始运行的地方。
当使用 @SpringBootApplication 注解时，Spring Boot 会启动自动配置，启用组件扫描，并准备应用程序上下文。开发者可以在这个注解上添加额外的配置或覆盖自动配置规则。@SpringBootApplication 注解非常简化了 Spring 应用的初始创建和运行过程，并且使得你的 Spring 应用具备了可运行的特性，可以快速独立地部署。
22、为什么要用SpringBoot?
使用Spring Boot有很多好处，它是当今Java社区最受欢迎的企业级应用程序开发框架之一。以下是选择使用Spring Boot的一些主要原因：
-
快速开发和启动：
Spring Boot具备快速启动和运行应用程序的能力，通过大量提供的starters可以立即集成和自动配置常见的开发组件（如数据库连接、消息队列、Web服务、安全和监控功能等）。 -
约定优于配置：
Spring Boot提供了很多默认的配置，这意味着可以不需要过多的配置就能快速启动和开发。 -
独立性：
Spring Boot应用是独立的，包含内嵌的Web服务器（例如Tomcat、Jetty或Undertow），可以直接打包成一个可执行的JAR或WAR文件。 -
易于生产部署：
Spring Boot应用便于在生产环境中部署，例如通过内嵌服务器或者结合容器技术（如Docker）。 -
可观性和监控：
Spring Boot Actuator模块提供了准生产功能，让你可以监控和管理应用程序，包括健康检查、度量信息、环境信息等。 -
简化外部配置：
通过使用profiles和配置文件，Spring Boot使得应用的外部化配置变得非常简单。 -
大型社区和项目支持：
Spring Boot拥有一个庞大且活跃的开发社区，为解决问题、最佳实践和快速迭代提供了良好的支持基础。 -
与Spring生态系统的集成：
Spring Boot与Spring框架其他项目（如Spring Data, Spring Security, Spring Cloud）无缝地集成，提供了全面的解决方案。 -
为微服务架构而生：
Spring Boot天然支持微服务架构，是创建微服务应用的理想选择，同时与Spring Cloud兼容。 -
敏捷和DevOps友好：
配合现代的CI/CD工具，Spring Boot非常适合敏捷开发流程和DevOps文化。
使用Spring Boot可以显著提高开发者的生产力，减少项目的启动和开发时间，同时它的灵活性和强大功能为创建高可用和可维护的应用程序提供了坚实基础。
23、开启SpringBoot特性有哪几种方式？（创建SpringBoot项目的两种方式）
创建 Spring Boot 项目并开启其特性主要有以下两种方式：
-
使用 Spring Initializr:
Spring Initializr 是一个在线工具，用于生成 Spring Boot 项目的基本结构和 Maven/Gradle 构建文件。它提供了一个简单的 Web 界面，通过选择需要的依赖、项目元数据（比如工程名、组织 ID）和构建工具来配置新项目。访问 start.spring.io，然后按照以下步骤操作：
- 选择开发工具（Maven 或 Gradle）和语言（Java、Kotlin 或 Groovy）。
- 设置项目元数据（Group、Artifact、Name、Description 等）。
- 选择 Spring Boot 版本。
- 添加需要的依赖（例如 Web、JPA、Thymeleaf、Security 等）。
- 点击 “Generate” 按钮下载项目压缩包，然后解压并导入到你的 IDE。
-
通过 IDE 创建新项目:
大多数现代 IDE，如 IntelliJ IDEA、Eclipse、Visual Studio Code 等支持集成 Spring Initializr，允许你直接在 IDE 中创建一个新的 Spring Boot 项目。创建过程通常如下：- 在 IDE 中选择创建新项目，并找到 Spring Boot 项目的设置项。
- 填写项目的 Group、Artifact 和其他元数据信息。
- 选择需要的 Spring Boot Starter 依赖。
- 配置项目的其他细节（项目位置、基础包名等）。
- 完成项目创建向导，IDE 会自动生成项目结构和配置文件。
无论你选择哪种方式，创建完成后，你会得到一个包含 pom.xml（对于 Maven 项目）或 build.gradle（对于 Gradle 项目）、应用程序入口类（带有 @SpringBootApplication 注解）和其他配置文件（比如 application.properties 或 application.yml）的项目。
请注意，上面提到的两种方式都启用了 Spring Boot 的约定大于配置的原则，创建出来的是一个有清晰目录结构和预置依赖的项目骨架。开发者可以在此基础上快速地添加业务逻辑和其他特性。
除了这两种最常见的方法，如果你更倾向于手动操作，也可以从头开始创建一个空的项目，然后手动添加 spring-boot-starter-parent 作为父项目，并逐个添加所需的起始依赖来构建 Spring Boot 应用。但这种方式比较繁琐，一般不推荐。
如果你有任何关于创建 Spring Boot 项目或者其他相关问题，请随时提问。
24、如何启用/禁用执行器？
在Spring Boot中，执行器（Actuators）是一组用于监控和管理应用程序的工具集，可通过HTTP端点暴露应用程序的内部信息。默认情况下，部分执行器端点是启用的，但你可能想要根据安全或其他考虑启用或禁用特定的端点。以下是如何启用和禁用执行器端点的方法：
启用执行器端点
要启用执行器端点，你可以在application.properties或application.yml配置文件中指定：
application.properties
management.endpoint.<endpointName>.enabled=true
application.yml
management:
endpoint:
<endpointName>:
enabled: true
替换<endpointName>为你想要启用的端点的名字。例如，要启用shutdown端点：
application.properties
management.endpoint.shutdown.enabled=true
application.yml
management:
endpoints:
web:
exposure:
include: shutdown
禁用执行器端点
类似地，要禁用端点，可以设置enabled属性为false：
application.properties
management.endpoint.<endpointName>.enabled=false
application.yml
management:
endpoint:
<endpointName>:
enabled: false
例如，要禁用info端点：
application.properties
management.endpoint.info.enabled=false
application.yml
management:
endpoints:
web:
exposure:
exclude: info
控制端点暴露
你还可以控制哪些端点会被暴露出来，无论它们是否被启用：
application.properties
management.endpoints.web.exposure.include=health,info
management.endpoints.web.exposure.exclude=env,beans
application.yml
management:
endpoints:
web:
exposure:
include: health,info
exclude: env,beans
这些配置可以让你精细地控制哪些执行器端点可被访问，有利于强化应用程序的安全性。
注意：在实际应用中，为了安全起见，应谨慎暴露能够改变应用状态或访问敏感信息的端点（如shutdown和env等）。在生产环境中，建议对执行器端点做好安全措施，如使用Spring Security或其他安全框架。
25、SpringBoot 2、X 有什么新特性？与 1、X 有什么区别？
Spring Boot 2.x 相较于 1.x 引入了一系列新特性和重要更新，同时也对底层框架和第三方库做了升级，提供了性能上的改进，下面列出了一些显著的特性和区别：
核心框架升级
- Spring Framework：Spring Boot 2.x 使用了 Spring Framework 5.x，而 1.x 使用的是 4.x 版本。Spring Framework 5 带来了对 Reactive 编程的支持，以及许多对 JDK 8 和 JDK 9+ 特性的优化和改进。
Reactive Programming
- Reactive Spring：Spring Framework 5 引入了对 Reactive Streams 的支持，即 Spring WebFlux。Spring Boot 2.x 支持创建 Reactive 应用，允许你使用非阻塞式编程模型开发高效的异步应用。
性能改进
- 响应式编程模型：Spring Boot 2.x 支持新的响应式编程模型，更好地利用多核处理器，提高应用的吞吐量和可伸缩性。
- 服务器支持：Spring Boot 2.x 新增了对响应式服务器 Netty 的支持，以及对传统的 Servlet 容器如 Tomcat、Jetty、Undertow 的升级。
安全性增强
- Spring Security：Spring Security 的配置发生了变化，更加注重约定优于配置的原则，提供了更为简洁的安全配置方式。
- OAuth2：Spring Boot 2.x 自带了对 OAuth2 客户端和资源服务器的支持。
端点管理
- Actuator 端点：Spring Boot 2.x 重构了 Actuator 端点，大多数端点的默认路径发生了变化，更多的端点暴露了细粒度的信息，并支持了 Health Indicator 的分组功能。
YML 和属性配置
- 绑定属性：Spring Boot 2.x 引入了全新的绑定和参数类型转换，提供了更多的灵活性和强大的类型安全属性绑定。
- 配置属性：配置属性的元数据支持了集合和数组类型，提供了更精细的类型信息。
数据访问
- 数据访问：与 JPA、MongoDB、Redis 等数据访问技术集成的大量改进。
- 支持新数据访问技术：比如对 Spring Data Reactive MongoDB、Cassandra 的支持。
模块整合
- Kafka：Spring Boot 2.x 提供了对 Apache Kafka 的自动配置和高级功能。
- 测试：2.x 对测试模块进行了改进，引入了更多的测试工具和注解来简化测试过程。
新的配置属性
- 新增配置属性：Spring Boot 2.x 加入了大量新的配置属性用于细节配置，比如服务器的压缩配置、HTTP/2 协议配置等。
Spring Boot 2.x 相较于 1.x 引入了一系列新特性和重要更新，同时也对底层框架和第三方库做了升级，提供了性能上的改进，下面列出了一些显著的特性和区别：
核心框架升级
- Spring Framework：Spring Boot 2.x 使用了 Spring Framework 5.x，而 1.x 使用的是 4.x 版本。Spring Framework 5 带来了对 Reactive 编程的支持，以及许多对 JDK 8 和 JDK 9+ 特性的优化和改进。
Reactive Programming
- Reactive Spring：Spring Framework 5 引入了对 Reactive Streams 的支持，即 Spring WebFlux。Spring Boot 2.x 支持创建 Reactive 应用，允许你使用非阻塞式编程模型开发高效的异步应用。
性能改进
- 响应式编程模型：Spring Boot 2.x 支持新的响应式编程模型，更好地利用多核处理器，提高应用的吞吐量和可伸缩性。
- 服务器支持：Spring Boot 2.x 新增了对响应式服务器 Netty 的支持，以及对传统的 Servlet 容器如 Tomcat、Jetty、Undertow 的升级。
安全性增强
- Spring Security：Spring Security 的配置发生了变化，更加注重约定优于配置的原则，提供了更为简洁的安全配置方式。
- OAuth2：Spring Boot 2.x 自带了对 OAuth2 客户端和资源服务器的支持。
端点管理
- Actuator 端点：Spring Boot 2.x 重构了 Actuator 端点，大多数端点的默认路径发生了变化，更多的端点暴露了细粒度的信息，并支持了 Health Indicator 的分组功能。
YML 和属性配置
- 绑定属性：Spring Boot 2.x 引入了全新的绑定和参数类型转换，提供了更多的灵活性和强大的类型安全属性绑定。
- 配置属性：配置属性的元数据支持了集合和数组类型，提供了更精细的类型信息。
数据访问
- 数据访问：与 JPA、MongoDB、Redis 等数据访问技术集成的大量改进。
- 支持新数据访问技术：比如对 Spring Data Reactive MongoDB、Cassandra 的支持。
模块整合
- Kafka：Spring Boot 2.x 提供了对 Apache Kafka 的自动配置和高级功能。
- 测试：2.x 对测试模块进行了改进，引入了更多的测试工具和注解来简化测试过程。
新的配置属性
- 新增配置属性：Spring Boot 2.x 加入了大量新的配置属性用于细节配置，比如服务器的压缩配置、HTTP/2 协议配置等。
JDK 版本
- Java 版本：Spring Boot 2.x 要求至少使用 Java 8，也支持 Java 9 及以上版本，而 Spring Boot 1.x 最低支持到 Java 6。
此外，Spring Boot 2.x 还提供了日志级别群组特性、参数验证增强、更多的第三方库起步依赖等。
升级到 Spring Boot 2.x 是为了利用最新和最优的 Spring 相关项目特性，同时也需要适配一些潜在的破坏性变更。对于已有的 Spring Boot 1.x 应用，如果计划升级到 2.x，建议详细评估和测试，因为可能涉及代码变更和配置调整。
- Java 版本：Spring Boot 2.x 要求至少使用 Java 8，也支持 Java 9 及以上版本，而 Spring Boot 1.x 最低支持到 Java 6。
此外，Spring Boot 2.x 还提供了日志级别群组特性、参数验证增强、更多的第三方库起步依赖等。
升级到 Spring Boot 2.x 是为了利用最新和最优的 Spring 相关项目特性，同时也需要适配一些潜在的破坏性变更。对于已有的 Spring Boot 1.x 应用，如果计划升级到 2.x，建议详细评估和测试，因为可能涉及代码变更和配置调整。
26、我们如何监视所有 SpringBoot 微服务？
监控Spring Boot微服务可以通过多种工具和技术来实现，这些工具和技术提供了性能指标、应用数据以及运行状况检查的可视化界面。以下是用于监控微服务的一些常用方法：
Spring Boot Actuator：
Actuator是Spring Boot的一个子项目，提供了生产级的监控特性。它提供了若干内置的端点，比如/health, /info, /metrics, /trace, /dump 等，这些端点可以通过HTTP暴露出来，并且可以与外部监控系统集成。
Micrometer：
它是一个度量（测量）库，提供了一种在Spring Boot应用中收集各种指标的方法。Micrometer工作类似于应用级别的仪表板，支持多种监控系统，如 Prometheus, Graphite, DataDog, InfluxDB 等。
Prometheus 和 Grafana：
Prometheus是一个开源监控解决方案，用于收集和存储指标数据，同时支持实时警报。Grafana是一个开源的数据可视化工具，常常与Prometheus配合使用，用来展示指标数据。
ELK Stack：
ELK Stack（Elasticsearch, Logstash, Kibana）主要用来收集、搜索、存储和可视化日志数据。通过集成这些工具，你可以对日志数据进行搜索和分析，以补充监控方面的信息。
Zipkin 和 Sleuth：
Zipkin是一个分布式追踪系统，用来帮助收集微服务架构中延迟数据，可以帮助定位微服务中的性能瓶颈。Spring Cloud Sleuth与Zipkin集成，为Spring Cloud应用添加了分布式追踪的功能。
Spring Cloud Admin：
这是一个独立的应用，提供了对基于Spring Boot建立的微服务的管理和监控，能够实时地查看应用的健康状态、环境参数、日志文件等。
设置监控的步骤：
- 在微服务应用中集成所需的库（例如Spring Boot Actuator、Micrometer）。
- 配置应用程序以暴露相关端点或发送指标到监控系统。
- 部署Prometheus、Grafana、Zipkin等工具，并进行配置以收集和可视化指标。
- 开始监控你的微服务应用，设置告警规则和触发条件。
通过这些工具和实践，你可以有效地监控基于Spring Boot的微服务，清楚地了解它们的性能状况、健康状况以及在问题发生时迅速做出响应。
27、怎么设计无状态服务？
设计无状态服务是为了确保服务的每个实例在任何时候都可以相互替代，从而提高服务的可扩展性、可靠性和简易性。以下是设计无状态服务的一些关键点：
-
避免服务实例本地状态：
- 服务不应该有本地状态，即不要在服务实例中存储任何会话信息、配置或者临时数据。所有状态都应该存储在外部的、中心化的存储系统中，比如数据库、缓存或分布式存储系统。
-
使用外部持久存储：
- 任何需要保存的数据都应该持久化在外部存储中，比如 SQL 或 NoSQL 数据库、对象存储、持久化缓存等。
-
无会话（Sessionless）：
- 服务不应依赖于会话信息。对于Web应用来说，可以使用如 JSON Web Tokens（JWT）等无状态身份验证机制来代替传统的会话。
-
无上下文依赖：
- 服务的每个请求都应该携带完整的上下文信息。这意味着请求在不需要服务实例之间共享上下文的情况下可以被独立处理。
-
幂等性（Idempotency）：
- 设计服务操作时应确保幂等性，即执行多次和执行一次的效果相同。这有助于处理重复的请求和网络故障时的重试。
-
水平扩展：
- 服务应该能够通过简单地增加更多的实例来扩展，任何实例都可以响应来自负载均衡器的请求。
-
客户端通信：
- 客户端与服务交互时不依赖特定的服务实例。通过负载均衡和服务发现机制，客户端可以连接到任一可用的服务实例。
-
负载均衡器：
- 使用负载均衡器来分配请求给后端服务实例，以均匀地分配负载。
-
最终一致性：
- 若使用外部服务或数据库进行数据同步，可以采纳最终一致性原则，即让系统最终达到一致状态，而不是在每个操作后立即保持一致。
-
去中心化：
- 服务不应依赖中心化的单点决策系统。相反，应该采取分布式的方式，让服务实例能够独立作出判断和响应。
实践上，状态存储和管理是云原生应用关注的核心，无状态服务的设计理念非常适合在容器化和微服务架构中使用。设计无状态服务需要细心规划，可能涉及到身份认证、授权、数据持久性和共享存储等方面的决策。如果你有更多关于无状态服务设计或相关问题，请随时提问。
28、SpringBoot 实现热部署有哪几种方式？
Spring Boot支持多种热部署（即在不重启服务器的情况下更新应用程序代码）的方式，以下是几种常用的热部署实现策略：
- Spring Boot DevTools：
spring-boot-devtools是一个官方提供的Spring Boot模块，它可以添加到依赖中用以支持热部署。这个库提供了额外的开发时特性，如自动重启。- 要使用它，只需将以下依赖添加到你的Maven
pom.xml或 Gradle 构建文件中：
<!-- Maven -->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
// Gradle
dependencies {
developmentOnly 'org.springframework.boot:spring-boot-devtools'
}
-
JRebel：
- JRebel是一个Java插件，支持热部署。它可以让开发人员在不重启容器的情况下实时地更改类和资源文件。
- JRebel不是免费的，但它提供了对诸如Spring Framework等技术的更强的支持。使用它，你只需配置插件和它的许可证，就可以开始使用了。
-
Spring Loaded：
- Spring Loaded是Spring的一个开源项目，用法类似于JRebel。然而，Spring Loaded并没有得到Spring Boot 1.3以后版本的官方支持。
- 虽然Spring Loaded在GitHub上仍然可用，但它并不是Spring官方推荐的方法。
-
HotSwapAgent 和 DCEVM：
- DCEVM (Dynamic Code Evolution VM) 是一个修改过的JVM版本，它扩展了Java类的重新加载特性，并被HotSwapAgent使用。
- HotSwapAgent是一个运行时重新定义Java类和资源文件的框架。它比JVM标准的HotSwap提供了更广泛的类重新定义，并支持静态字段和方法的重新加载。
标准的Java HotSwap机制由 JVM 提供支持，但它只支持有限的类重新加载。上述工具和插件是尝试解决这个限制并提供更全面的解决方案，其中spring-boot-devtools是最简单和被官方推荐的方式，特别是对于较小的项目和需要快速迭代的场景。
无论选择哪种热部署方法，都需要了解其限制和对开发工作流的影响，并根据项目需求和团队的开发习惯做出选择。在配置热部署工具时也需要检查文档及社区的最佳实践建议，以避免常见的问题和陷阱。
29、SpringBoot 的核心注解是哪个？它主要由哪几个注解组成的？
Spring Boot 的核心注解是 @SpringBootApplication，它是一个方便的组合注解。@SpringBootApplication 由以下三个主要注解组成：
-
@SpringBootConfiguration：
- 该注解表明该类是一个配置类，等同于
@Configuration注解。它允许在这个类中定义额外的 Bean 或者导入其他配置类。
- 该注解表明该类是一个配置类，等同于
-
@EnableAutoConfiguration：
- 这个注解告诉 Spring Boot 根据添加的依赖自动配置应用程序。例如，如果添加了
spring-boot-starter-web依赖，则自动配置将假设你正在开发一个 Web 应用，并相应地设置 Spring。 - 这是 Spring Boot 自动配置的关键，自动配置尝试根据在类路径上的 jar 包和定义的 Bean 来配置你的 Spring 应用。
- 这个注解告诉 Spring Boot 根据添加的依赖自动配置应用程序。例如，如果添加了
-
@ComponentScan：
- 它启用
@Component、@Service、@Repository、@Controller等注解的组件扫描。默认会从声明@SpringBootApplication的类的包开始扫描，并且注册为 Spring Bean。
- 它启用
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
在上面的例子中，@SpringBootApplication 组合注解的使用，使得 MyApplication 类成为了 Spring Boot 应用程序的入口点。这个类定义了主方法，它使用 SpringApplication.run() 来启动应用程序。当使用 @SpringBootApplication 注解时，Spring Boot 会自动应用上述提到的配置、自动配置和组件扫描。
因此，@SpringBootApplication 是创建 Spring Boot 应用时常用的核心注解，结合了配置的方便性和自动化的强大功能。
30、使用 SpringBoot 启动连接到内存数据库 H2 的 JPA 应用程序需要哪些依赖项？
要使用 Spring Boot 启动一个连接到内存数据库 H2 的 JPA 应用程序，您至少需要以下两个依赖项：
-
Spring Boot Starter Data JPA：这个 starter 包含了使用 Spring Data JPA 进行数据访问所需的所有依赖项，包括 JPA 提供者 Hibernate。
-
H2 Database Engine：作为内存数据库，H2 是开发和测试 JPA 应用程序时常用的数据库，它可以嵌入 Java 应用程序中，也可以作为一个服务器来运行。
以下为 Maven pom.xml 和 Gradle build.gradle 配置文件中包含这些依赖项的示例：
对于 Maven，在 pom.xml 中添加：
<dependencies>
<!-- Spring Boot Starter Data JPA -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- H2 Database Engine -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
对于 Gradle，在 build.gradle 中添加：
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
runtimeOnly 'com.h2database:h2'
}
除了上述依赖项外，还需要在 application.properties 或 application.yml 文件中配置 H2 数据库的连接信息。但是由于 H2 是一个嵌入式内存数据库，Spring Boot 能够自动配置 H2 数据库而无需提供额外配置，除非你需要自定义配置，如下所示：
# application.properties
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=true # 如果你需要使用 H2 控制台进行数据库访问和管理
一旦添加了必要的依赖项和任何所需的配置，您就可以开始定义实体和存储库接口，并使用 Spring Data JPA 与 H2 数据库进行交互了。spring-boot-starter-data-jpa 提供的自动配置功能让你无需太多的配置，即可开始构建 JPA 应用程序。
SpringBoot最新2022年面试题大汇总(22)
1、SpringBoot 配置加载顺序?
Spring Boot 提供了非常灵活的配置加载顺序，它允许你以多种方式定义配置属性，然后根据优先级级联地应用这些配置。以下是Spring Boot配置加载的常见顺序：
- 开发者工具（开发中使用的默认属性）
- 命令行参数
- 来自
java:comp/env的JNDI属性 - Java系统属性（
System.getProperties()） - 操作系统环境变量
RandomValuePropertySource，只有在application.properties中使用random.*时存在- 包含在JAR包外部的
application-{profile}.properties/yml文件 - 包含在JAR包外部的
application.properties/yml文件 - 包含在JAR包内部的
application-{profile}.properties/yml文件 - 包含在JAR包内部的
application.properties/yml文件 - 在
@Configuration注解类中的@PropertySource - 默认属性
配置属性是通过使用一个PropertySource抽象来加载的，而PropertySources则是在Spring’s Environment中管理这些PropertySource实例的。Spring Boot会在启动时按照上述顺序遍历PropertySources，加载和合并配置。如果相同的属性在多个配置源里被定义，则优先级高的配置源将覆盖优先级低的配置源的属性值。
配置优先级顺序使得开发者可以通过在更具体的位置定义配置属性来覆盖更通用的配置。比如命令行参数可以覆盖application.properties文件中的属性，外部化配置可以覆盖JAR包内的配置等。
此加载顺序确保了在不同环境下（开发、测试、生产）的灵活性和更易于运维的配置管理，同时也支持基于配置文件的不同环境"profile"，比如application-dev.properties、application-prod.properties等。
2、spring boot初始化环境变量流程?
Spring Boot 在启动过程中初始化环境变量的流程涉及从不同资源加载配置属性，并将这些属性绑定到 Spring 环境中。Spring 环境是跨整个应用持有属性的容器，包括配置参数和环境变量。这个过程通常是通过 Environment 抽象来进行的。
Spring Boot 在初始化过程中采纳了「约定大于配置」的原则，其环境变量的初始化流程通常如下：
-
加载
bootstrap配置（如果使用了 Spring Cloud）：- 对于 Spring Cloud 应用，首先从
bootstrap.properties（或bootstrap.yml）中加载配置，这些配置用于应用的引导环境，通常包括连接到配置服务器或解密属性的配置。
- 对于 Spring Cloud 应用，首先从
-
加载
application配置：- 然后从
application.properties或application.yml文件中加载配置，这些文件通常位于 classpath 的根路径、config子目录或者外部配置位置。
- 然后从
-
加载系统和命令行属性：
- 加载传递给 JVM 的系统属性（
-Dproperty=value）和应用命令行参数（--property=value），命令行属性的优先级高于系统属性。
- 加载传递给 JVM 的系统属性（
-
激活特定的环境：
- 根据 Spring profiles（
spring.profiles.active或通过 SpringConfigAPI 设置的值）加载特定环境的配置。
- 根据 Spring profiles（
-
使用
PropertySource接口：- Spring Boot 使用
PropertySource抽象用来寻找和加载配置资源，不同的PropertySource可以代表属性文件、系统变量、环境变量等。
- Spring Boot 使用
-
引入外部配置：
- 再引入外部配置，比如数据库、消息中间件等系统的配置文件。
-
属性覆盖：
- 在整个过程中，来自不同源的配置属性将根据优先级进行覆盖，例如环境变量中的属性会覆盖
application.properties中的同名属性。
- 在整个过程中，来自不同源的配置属性将根据优先级进行覆盖，例如环境变量中的属性会覆盖
-
最终绑定到
Environment：- 所有的属性最终都会被绑定到
Environment对象中，可通过@Value注解、EnvironmentAPI 或配置类的属性绑定等机制在应用中使用。
- 所有的属性最终都会被绑定到
Spring Boot 提供了大量定制化的选项，还支持 .yaml、.properties 和 .profile 文件，亦支持 @ConfigurationProperties 注解用于类型安全的配置绑定。此外，开发者可以通过实现 EnvironmentPostProcessor 来自定义属性源的加载逻辑。
这个机制确保了 Spring Boot 应用的配置项可以灵活地从众多来源接收，并且可以基于运行时环境或开发环境轻易地进行切换。如果你有任何关于 Spring Boot 环境变量初始化流程或相关问题，请随时提问。
3、SpringBoot 中如何解决跨域问题 ?
在Spring Boot中解决跨域问题通常可以通过以下几种方式：
- @CrossOrigin 注解：
在Controller或者某个特定方法上使用@CrossOrigin注解，来允许跨域请求。
@CrossOrigin(origins = "http://example.com")
@RestController
public class MyController {
// 方法体
}
或者在特定的方法上使用：
@RestController
public class MyController {
@CrossOrigin(origins = "http://example.com")
@GetMapping("/endpoint")
public String myEndpoint() {
// 方法体
}
}
这个注解提供了多种选项来定制哪些域被允许、哪些HTTP方法和头部可以使用等。
- 全局跨域配置：
定义一个WebMvcConfigurer并重写addCorsMappings方法来设置全局跨域配置。
@Configuration
public class MyGlobalCorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("http://example.com")
.allowedMethods("GET", "POST", "PUT", "DELETE")
.allowedHeaders("*")
.allowCredentials(true);
}
}
这个方法允许对所有的endpoints使用统一的跨域配置。
- CORS过滤器：
创建一个Filter来设置HTTP响应的CORS头。这可以用来精细控制响应，并可以在其他不支持@CrossOrigin和WebMvcConfigurer的场景下使用。
@Bean
public FilterRegistrationBean<CorsFilter> simpleCorsFilter() {
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
CorsConfiguration config = new CorsConfiguration();
config.setAllowCredentials(true);
// *** URL below needs to match the Vue client URL and port ***
config.setAllowedOrigins(Collections.singletonList("http://example.com"));
config.setAllowedMethods(Collections.singletonList("*"));
config.setAllowedHeaders(Collections.singletonList("*"));
source.registerCorsConfiguration("/**", config);
FilterRegistrationBean<CorsFilter> bean = new FilterRegistrationBean<>(new CorsFilter(source));
bean.setOrder(Ordered.HIGHEST_PRECEDENCE);
return bean;
}
通过以上任意一种方法，都可以在Spring Boot应用中管理和解决CORS（Cross-Origin Resource Sharing，跨源资源共享）的问题。这些方法的选择取决于你想要解决的跨域问题的范围、特定的配置需求以及个人偏好。通常情况下，@CrossOrigin注解和全局跨域配置是最简单、最常用的解决方法。
4、SpringBoot如何配置log4j？
在 Spring Boot 应用程序中配置 Log4j 通常包括以下步骤：
-
添加 Log4j 依赖：
Spring Boot 默认使用 Logback 进行日志记录，因此首先要排除掉 Logback 默认的依赖，并添加 Log4j2 的依赖。对于 Maven，在
pom.xml中添加以下依赖：<dependencies> <!--排除 Spring Boot 的默认日志框架 Logback--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-logging</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-logging</artifactId> </exclusion> </exclusions> </dependency> <!--添加 Log4j2 依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-log4j2</artifactId> </dependency> </dependencies>对于 Gradle，在
build.gradle中添加以下依赖：dependencies { // 排除 Spring Boot 的默认日志框架 Logback configurations { all { exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging' } } // 添加 Log4j2 依赖 implementation 'org.springframework.boot:spring-boot-starter-log4j2' } -
配置 Log4j2：
接下来需要在项目的src/main/resources目录下创建 Log4j2 的配置文件。根据你的需求，可以是log4j2.xml、log4j2.json、log4j2.yaml或log4j2.properties。最常见的是 XML 配置文件，如下例：log4j2.xml示例：<?xml version="1.0" encoding="UTF-8"?> <Configuration> <Appenders> <Console name="Console" target="SYSTEM_OUT"> <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n"/> </Console> </Appenders> <Loggers> <Root level="info"> <AppenderRef ref="Console"/> </Root> </Loggers> </Configuration> -
启动类上添加注解：
无需在启动类上添加任何特定的注解，只要 Log4j2 的依赖和配置文件已经合适地添加到您的项目中，Spring Boot 会自动配置 Log4j2。
通过以上步骤，你的 Spring Boot 应用程序应该能够使用 Log4j2 进行日志记录了。你可以在 log4j2.xml 配置文件中根据需要设置日志的级别、模式、文件输出位置等属性。
5、SpringBoot运行项目的几种方式？
在Spring Boot中，有几种方法可以运行项目，包括使用命令行工具、开发集成环境（IDE）或构建工具。以下是一些常用的运行Spring Boot项目的方式：
1. 使用Maven或Gradle插件
Spring Boot提供了用于Maven和Gradle的插件，可直接从命令行运行应用程序。
对于Maven项目：
mvn spring-boot:run
对于Gradle项目：
gradle bootRun
这些插件会自动编译应用程序的代码、启动Spring Boot项目以及运行嵌入式Web服务器。
2. 执行JAR或WAR文件
首先，你需要生成项目的JAR或WAR文件。
使用Maven：
mvn clean package
使用Gradle：
gradle build
然后，你可以使用Java命令行工具来运行打包好的文件：
java -jar target/yourapplication.jar
如果是WAR文件，也同样使用java命令运行它：
java -jar target/yourapplication.war
3. 通过IDE运行
在集成开发环境（如IntelliJ IDEA、Eclipse、VS Code等）中，通常有内建支持或插件可以方便地运行Spring Boot应用。通常只需点击运行按钮或者找到主类后右键选择运行。
4. Docker容器
如果你的应用已经容器化，那么你也可以通过Docker来运行它。构建Docker镜像后，通过以下命令运行：
docker run -d -p 8080:8080 yourapplication
确保你的Docker镜像有正确的ENTRYPOINT或CMD指令来启动Spring Boot应用。
5. 云服务
Spring Boot应用也可以部署到各种云服务平台上，如AWS Elastic Beanstalk、Azure App Service、Google App Engine或其他支持Java的PaaS解决方案。这通常涉及到配置云服务提供商的命令行工具或Web界面，并上传JAR或WAR文件。
选择哪种方式运行Spring Boot项目取决于你的具体场景和需求。在开发和测试阶段，直接在IDE或使用Maven/Gradle插件运行通常较为方便。而在生产环境，通常会选择打包为JAR/WAR文件、使用容器、云服务等方式来实现自动化和灵活的部署。
6、SpringBoot与SpringCloud 区别
Spring Boot 和 Spring Cloud 是 Spring 生态系统中的两个项目，它们的目标和使用场景不同，但又互相协作，共同简化了分布式系统开发。
Spring Boot
Spring Boot 是为单体应用程序或微服务架构中的独立服务设计的，其主要目标是简化 Spring 应用的创建和开发流程：
- 简化配置：通过约定优于配置的原则，自动配置 Spring 和第三方库。
- 独立运行：生成可以独立运行的 Spring 应用，内嵌了 Tomcat、Jetty 或 Undertow，无需部署 WAR 文件。
- 生产就绪：提供了监控、健康检查和外部化配置的现成特性。
- 非侵入性：不需要修改已有的代码结构，就可快速升级现有的 Spring 应用。
- 插件支持：提供了大量的起步依赖（starters），以简化开发者引入和管理依赖的工作。
- 微服务架构：适合于构建微服务架构的单个服务。
Spring Cloud
Spring Cloud 基于 Spring Boot，提供了在分布式系统中常见模式的实现，如配置管理、服务发现、熔断器、智能路由、微代理、控制总线、全局锁和领导选举等：
- 分布式系统的简化：通过提供经过验证的模式来简化分布式系统开发。
- 服务发现：集成像 Eureka 这样的服务发现组件。
- 负载均衡：集成了 Ribbon 或 Spring Cloud LoadBalancer 来实现客户端负载均衡。
- 服务网关：通过 Zuul 或 Spring Cloud Gateway 提供动态路由、监控、弹性和安全性等功能。
- 配置服务：配置中心支持像 Spring Cloud Config Server 这样的服务，用于管理不同环境中的配置。
- 断路器：Hystrix 或 Resilience4j 等断路器模式的实现，以提高系统的弹性。
- 分布式跟踪：整合了 Zipkin 和 Sleuth 来提供对分布式请求跟踪的支持。
- 分布式消息：通过集成 Spring Cloud Stream 来使用消息驱动的微服务。
简而言之，Spring Boot 专注于快速开发单个微服务和单体应用，而 Spring Cloud 关注全局的服务治理和微服务架构支持。它们一起工作，可以提供构建、部署和管理云端微服务架构的一站式解决方案。
可以将 Spring Boot 视为构建单个微服务的基础，而 Spring Cloud 提供了构建整个微服务架构所需的工具和框架。如果你有任何其他关于 Spring Boot、Spring Cloud 或相关主题的问题，请随时提问。
7、如何集成SpringBoot和ActiveMQ？
集成Spring Boot和ActiveMQ通常涉及以下几个步骤：
-
添加依赖：
在项目的pom.xml文件（如果是Maven工程）或build.gradle文件（如果是Gradle工程）中添加ActiveMQ的Starter依赖。对于Maven：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency>对于Gradle：
implementation 'org.springframework.boot:spring-boot-starter-activemq' -
配置连接：
在application.properties或application.yml中配置ActiveMQ的连接属性。例子（application.properties）：
spring.activemq.broker-url=tcp://localhost:61616 spring.activemq.user=admin spring.activemq.password=secret例子（application.yml）：
spring: activemq: broker-url: tcp://localhost:61616 user: admin password: secret这里的URL和凭证需要替换为你自己的ActiveMQ服务器地址和访问凭证。
-
使用
JmsTemplate发送消息：
在你的Service类或其它Bean中注入JmsTemplate并使用它发送消息。import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jms.core.JmsTemplate; import org.springframework.stereotype.Service; @Service public class MyService { @Autowired private JmsTemplate jmsTemplate; public void sendMessage(String destination, String message) { jmsTemplate.send(destination, session -> session.createTextMessage(message)); } } -
监听消息：
创建一个消息监听器组件，来接受并处理消息。import org.springframework.jms.annotation.JmsListener; import org.springframework.stereotype.Component; @Component public class MyMessageListener { @JmsListener(destination = "someQueue") public void receiveMessage(String message) { System.out.println("Received <" + message + ">"); } } -
启动应用和测试：
启动Spring Boot应用，它将自动配置ActiveMQ连接，并且你可以开始发送和接收消息了。import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }
以上便是集成Spring Boot和ActiveMQ的基本步骤。你应根据你的ActiveMQ的实例具体情况（比如，在本地或云服务）配置适当的参数。如果你的ActiveMQ运行在嵌入模式，Spring Boot会自动使用它，无需任何配置。对于更高级的配置，如事务或持久化，ActiveMQ Starter支持多种自定义配置选项。
8、SpringBoot 有哪几种读取配置的方式？
Spring Boot 提供了多种灵活的方式来读取配置，以下是其中的一些常用方法：
1. application.properties 或 application.yml 文件
Spring Boot 会自动从 application.properties 或 application.yml 文件中加载配置。这些文件通常位于项目的 src/main/resources 目录下。例如：
# application.properties
server.port=8080
myapp.welcome-message=Hello, World!
或者：
# application.yml
server:
port: 8080
myapp:
welcome-message: Hello, World!
2. 命令行参数
可以在运行应用程序时通过命令行参数指定配置，Spring Boot 会自动解析这些参数。例如：
java -jar myapp.jar --server.port=8080 --myapp.welcome-message="Hello, World via Command Line!"
3. 环境变量
Spring Boot 可以读取环境变量作为配置参数。
export SERVER_PORT=8080
export MYAPP_WELCOME_MESSAGE="Hello, World via Environment Variables!"
4. 配置类使用 @Value
可以在 Spring 的 @Component 类中使用 @Value 注解直接读取配置值。
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class MyComponent {
@Value("${myapp.welcome-message}")
private String welcomeMessage;
// getters and setters
}
5. @ConfigurationProperties
通过创建一个配置绑定类和 @ConfigurationProperties 注解，可以将配置属性绑定到一个或多个对象。例如：
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
private String welcomeMessage;
// getters and setters
}
然后在配置文件中定义对应的属性：
myapp.welcome-message=Hello, World via ConfigurationProperties!
6. @PropertySource
如果需要加载不在默认位置的配置文件，可以使用 @PropertySource 注解指定位置并加载。
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@Configuration
@PropertySource("classpath:myapp-properties.properties")
public class MyAppConfiguration {
// ...
}
7. Environment 接口
注入 Environment 接口来动态读取配置。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
@Component
public class MyComponent {
@Autowired
private Environment env;
public String getWelcomeMessage() {
return env.getProperty("myapp.welcome-message");
}
}
以上是 Spring Boot 读取配置的几种常用方式。由于 Spring Boot 的自动配置特性，通常推荐使用 application.properties 或 application.yml 文件来进行配置。这些文件的简单格式和方便的级联配置特性使得它们是管理应用配置的理想选择。
9、SpringData 项目所支持的关系数据存储技术
Spring Data项目旨在简化基于Spring框架的关系和非关系数据库数据访问技术的开发。对于关系型数据库存储技术，Spring Data提供了多种模块来支持包括但不限于以下技术：
Spring Data JPA
Spring Data JPA（Java Persistence API）模块为JPA提供了简洁的库，用于访问和操作关系数据库。它在JPA之上提供了更高级别的抽象，并消除了很多样板代码。
Spring Data JDBC
Spring Data JDBC专注于使用JDBC来访问关系数据库，而不是提供完整的ORM解决方案。它用于那些需要JDBC的直接和低级访问，同时又想利用Spring Data的方便之处的用户。
Spring Data R2DBC
R2DBC（Reactive Relational Database Connectivity）是一个因应响应式编程对数据库访问的需求而创建的API。Spring Data R2DBC模块集成了该API，提供对关系数据库的响应式访问支持。
Spring Data JDBCTemplate
虽然并不直接是Spring Data的一部分，JDBCTemplate是Spring框架的一项核心功能，也是访问关系数据存储的常见方式。Spring Data中的许多思想都来源于JDBCTemplate提供的模板化和回调方法。
这些技术对于开发者而言降低了操作关系数据库的复杂性，并提供了与Spring生态系统协同工作的可靠方法，例如声明式事务管理、数据访问异常层次结构等功能，而无需与底层技术直接交互。通过选择正确的Spring Data模块，开发者能够高效地开发能够适应同步或异步访问模式的数据库应用程序。
Spring Data也支持多种非关系型数据存储技术，如Spring Data MongoDB、Spring Data Redis、Spring Data Elasticsearch、Spring Data Cassandra等，为更广泛的数据访问案例提供支持。
10、如何在自定义端口上运行SpringBoot应用程序？
在 Spring Boot 中，你可以通过多种方式在自定义端口上运行应用程序。以下是设置自定义端口的几种常见方法：
1. 在 application.properties 或 application.yml 配置文件中设置
你可以在项目的 src/main/resources/application.properties 文件中指定端口号:
# application.properties
server.port=8082
或者如果你使用 YAML 格式的配置文件 application.yml，则类似地设置：
# application.yml
server:
port: 8082
2. 通过命令行参数
在启动 Spring Boot 应用程序时，你可以通过命令行参数覆盖 server.port 属性:
java -jar myapp.jar --server.port=8082
如果你在 IDE 中运行 Spring Boot 应用程序，也可以在 IDE 的运行配置中添加程序参数（program arguments）。
3. 在主类中以编程方式设置
在你的 Spring Boot 主类中，你可以编程方式地设置端口号：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication app = new SpringApplication(MyApplication.class);
app.setDefaultProperties(Collections.singletonMap("server.port", "8082"));
app.run(args);
}
}
4. 系统环境变量
可以通过设置系统环境变量 SERVER_PORT 来覆盖端口号:
在 Windows 系统下：
set SERVER_PORT=8082
在 Unix/Linux 系统下：
export SERVER_PORT=8082
然后启动你的 Spring Boot 应用程序，系统将使用 SERVER_PORT 环境变量指定的自定义端口。
5. 在 Maven 或 Gradle 中设置
如果使用 Maven spring-boot:run 目标运行应用程序，可以在 pom.xml 中或命令行通过 -D 选项设置端口。
<!-- 在 pom.xml 的 properties 标签中设置 -->
<properties>
<server.port>8082</server.port>
</properties>
或通过命令行：
mvn spring-boot:run -Dserver.port=8082
对于 Gradle，则使用类似的方法:
gradle bootRun -Pserver.port=8082
上述任何一种方式都可以帮助你在自定义端口上运行 Spring Boot 应用程序。如果你有更多关于 Spring Boot 或其他相关问题，请随时提问。
11、SpringBoot默认支持的日志框架有哪些？可以进行哪些设置？
Spring Boot默认支持的日志框架是SLF4J（Simple Logging Facade for Java）作为日志抽象层，以及Logback作为默认的日志实现。事实上，Spring Boot采用了SLF4J和Logback的组合，以提供灵活且强大的日志功能。
Spring Boot的自动配置特性将配置这些日志框架，无需额外设置。但是，如果需要，你可以在application.properties或application.yml文件中进行自定义配置，调整日志级别，模式，颜色输出等：
application.properties 示例
# 设置日志级别
logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.com.example=INFO
# 定义日志文件
logging.file.name=app.log
# 定义日志文件的路径
logging.file.path=/var/logs
# 控制台日志输出格式
logging.pattern.console=%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
# 文件日志输出格式
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
application.yml 示例
logging:
level:
root: WARN
org.springframework.web: DEBUG
com.example: INFO
file:
name: app.log
path: /var/logs
pattern:
console: "%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
此外，Spring Boot也提供了对常用的Java日志框架的整合支持，如Log4j2和Java Util Logging，你只需要添加对应框架的Spring Boot启动器依赖并相应配置即可使用。
例如，如果要使用Log4j2作为日志框架，需要排除默认的日志框架依赖并添加Log4j2的依赖：
Maven 的 pom.xml 示例
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>
一旦添加了对应的依赖，Spring Boot将自动配置Log4j2，并读取classpath下的log4j2.xml或其他Log4j2配置文件。
通过这些设置，开发者可以灵活地控制Spring Boot中的日志行为，以满足不同的应用程序需求和偏好。
12、Spring Initializr 是创建 SpringBoot Projects 的唯一方法吗？
不，Spring Initializr 并不是创建 Spring Boot 项目的唯一方法，但它是一个便利的工具，特别是对于初学者和希望快速启动项目的开发者。
除了 Spring Initializr，以下是创建 Spring Boot 项目的其他常见方法：
手动创建
你可以手动创建一个 Spring Boot 项目，只需创建一个新的 Maven 或 Gradle 项目，并添加相应的 Spring Boot 依赖。你还需要添加 Spring Boot 的主类，使用 @SpringBootApplication 注解，以及 main() 方法，来运行你的应用程序。
IDE 支持
一些集成开发环境（IDE）提供了自己的工具和插件来创建 Spring Boot 项目：
- IntelliJ IDEA：具有自动集成的 Spring Initializr 支持，只要选择“New Project”，然后选择 Spring Initializr，即可从 IDE 内部配置用于创建项目的设置。
- Eclipse/STS（Spring Tool Suite）：提供了一个内置于 IDE 的工具，启动一个弹窗和表单，也能够使用 Spring Initializr。
Spring Boot CLI
Spring Boot CLI（命令行界面）是一个命令行工具，你可以通过它来运行和测试 Spring Boot 应用程序，或使用 Groovy 脚本进行快速原型设计。你可以用 CLI 快速生成一个新的项目结构。
spring init --dependencies=web,data-jpa,thymeleaf --build=maven my-project
基于已有项目
你也可以通过复制现有的 Spring Boot 项目并修改成自己的需要来开始新的项目。
即使有以上多种创建 Spring Boot 项目的方式，Spring Initializr 仍然是其中最受欢迎的一种，因为它简单易用、定制化强、易于集成，并且它也是官方推荐的方式。但最终选哪种方式来创建项目，取决于你自己的偏好、项目需求和你正在使用的工具。
13、Async异步调用方法
在Java中，异步调用通常是指在背景执行任务以避免阻塞当前线程的方法。Spring框架通过@Async注解提供了对异步执行的支持。以下是如何使用@Async进行异步调用的步骤：
1. 开启 @Async 支持
要使用@Async注解，首先需要在配置类上使用@EnableAsync来开启异步执行的支持。
@Configuration
@EnableAsync
public class SpringAsyncConfig {
// 配置类
}
2. 创建异步方法
在服务类中，你可以通过在方法上添加@Async注解来标记它为异步方法。Spring会自动运行这些方法在一个单独的线程中。
@Service
public class MyAsyncService {
@Async
public void performAsyncTask() {
// 你的异步代码逻辑
}
}
3. 返回 Future 或 CompletableFuture
若异步方法需要返回一个值，你可以返回一个Future或CompletableFuture实例。
@Async
public Future<String> returnAsyncData() {
// 你的异步代码逻辑
return new AsyncResult<>("Returned Data");
}
或者使用CompletableFuture：
@Async
public CompletableFuture<String> returnAsyncData() {
// 异步操作，计算结果
CompletableFuture<String> future = CompletableFuture.completedFuture("Returned Data");
return future;
}
4. 异常处理
对于抛出异常的异步方法，可以使用@Async注解标记一个返回CompletableFuture类型的方法，并在其中适当地处理异常。
@Async
public CompletableFuture<String> handleAsyncError() {
try {
// 可能抛出异常的代码
} catch (Exception e) {
CompletableFuture<String> future = new CompletableFuture<>();
future.completeExceptionally(e);
return future;
}
}
5. 使用自定义 Executor
如果你需要更多的控制，比如想要定义线程池的特性，可以在配置类中定义一个Executor Bean，并在@Async注解中指定使用它。
@Bean(name = "taskExecutor")
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(2);
executor.setMaxPoolSize(10);
executor.setQueueCapacity(50);
executor.initialize();
return executor;
}
@Async("taskExecutor")
public void performAsyncTaskWithCustomExecutor() {
// 异步任务代码
}
注意：
- 使用
@Async的方法不能在同一个类中被同步调用，否则异步调用不会生效，因为它无法被AOP代理截获。 - 默认情况下，Spring使用一个简单的
ThreadPoolTaskExecutor作为执行器，但你可以自定义执行器以满足特定的需求。 - 通常，
@Async异步方法应该是无状态的，以避免因并发访问共享状态而导致的线程安全问题。
异步方法实现了更好的响应性和并发性能，并使长时间运行的操作不会阻塞用户界面或服务请求。正确使用@Async可以显著提升应用程序的性能和用户体验。
14、您使用了哪些starter maven依赖项？
在 Spring Boot 中，Starter Maven 依赖项是一组便利的依赖描述符，可以拉取多个相关库去减少单个依赖项的配置。每个 starter 都包含了一组为特定用途优化的自动配置的库。以下是一些常用的 Starter Maven 依赖项：
-
Spring Boot Starter Web：
用于构建 web 应用程序，包括 RESTful 应用程序，使用 Spring MVC。它使用 Tomcat 作为默认嵌入式容器。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> -
Spring Boot Starter Data JPA：
包含了与数据访问相关的所有库，使得可以通过 JPA 快速地访问关系型数据库。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> -
Spring Boot Starter Security：
添加了 Spring Security 的依赖项用于保护应用。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> -
Spring Boot Starter Test：
提供了测试 Spring Boot 应用程序所需的常用库，包括 JUnit、Spring Test 和 Mockito。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> -
Spring Boot Starter Actuator：
提供生产就绪特性，以帮助你监控和管理应用程序。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> -
Spring Boot Starter Thymeleaf：
用于整合 Thymeleaf 模板引擎的 starter。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> -
Spring Boot Starter Batch：
用于执行批处理任务的 starter。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-batch</artifactId> </dependency> -
Spring Boot Starter Data MongoDB：
支持使用 MongoDB 数据库，并提供了相关的库。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> -
Spring Boot Starter Data Redis：
用于与 Redis 进行交互的 starter。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> -
Spring Boot Starter Mail：
支持发送邮件的 starter。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-mail</artifactId> </dependency>
每个 starter 都是为某个特定的场景或需求量身定制，通过在项目的 pom.xml 文件中添加上述依赖中的一个或多个，可以快速地以依赖注入的方式开始工作。如果您有任何关于 Spring Boot starter 或其他相关问题，请随时提问。
15、SpringBoot、Spring MVC 和 Spring 有什么区别？
Spring Boot、Spring MVC和Spring是构建现代Java应用程序的常用技术，但它们在作用和用途上有所不同。以下是它们之间的主要区别：
Spring
- Spring Framework 是一个全面的编程和配置模型，它提供了构建企业级应用的基础设施支持。它是一个开放源代码的轻量级框架，用于简化企业Java开发。
- 它的核心特性主要包括依赖注入（Dependency Injection, DI）容器、事务管理、Web应用开发、数据访问等。
- Spring提供了用于快速开发任何Java应用的综合编程和配置模型。
Spring MVC
- Spring MVC 是基于Spring Framework构建的Web框架，它实现了模型-视图-控制器（Model-View-Controller, MVC）设计模式。
- 它是Spring的一个模块，提供了一个分层架构，其中"模型"代表应用程序数据，"视图"代表模型的展示，"控制器"处理用户的请求并将模型数据返回给视图。
- 使用Spring MVC可以轻松创建动态Web应用，它支持如RESTful服务等多种Web技术。
Spring Boot
- Spring Boot 是从Spring框架中分离出来的项目，旨在简化Spring应用的创建和开发过程。它不是替代Spring的框架，而是提供了一个快速启动和运行Spring应用程序的方式。
- 它通过约定优于配置的原则，自动配置Spring和第三方库，从而减少了项目搭建的复杂性和开发者的工作量。
- Spring Boot使得构建独立的、生产级别的、基于Spring框架的应用变得非常容易。它还内嵌了多种服务器选择，如Tomcat、Jetty和Undertow。
总结来说：
- Spring是一整套解决方案，包含了多种特性和模块（包括Spring MVC），可用于构建各种类型的Java应用。
- Spring MVC是Spring的一个模块，专门用于构建Web应用。
- Spring Boot是一个独立的项目，提供约定优于配置的快速开发方式，并使得运行和部署Spring应用变得更加容易。
你可以将Spring Boot视为Spring生态系统中的一个加速器，它利用了Spring Framework的能力并为开发和运行Spring应用程序提供了简化的流程。而Spring MVC则是利用Spring的一部分，特定于Web应用程序的开发。
16、如何给静态变量赋值？
在 Java 中，给静态变量赋值通常有几种不同的方式，可以在类初始化时赋值，也可以在应用运行时动态赋值。以下是一些常见的方法：
在声明时直接赋值
可以在声明静态变量时直接初始化。
public class MyClass {
public static int MY_STATIC_VARIABLE = 10;
}
通过静态初始化块
静态变量也可以在静态初始化块中赋值，这个块只会在类被加载时执行一次。
public class MyClass {
public static int MY_STATIC_VARIABLE;
static {
MY_STATIC_VARIABLE = 10;
}
}
在静态方法中赋值
你可以通过静态方法给静态变量赋值，通常这种方法用于需要进行一些初始化计算或逻辑处理才能赋值的场景。
public class MyClass {
public static int MY_STATIC_VARIABLE;
public static void initializeStaticVariable() {
MY_STATIC_VARIABLE = 10;
}
}
通过构造函数赋值（非标准做法）
尽管不推荐这么做，因为静态变量和实例变量的生命周期不同，但技术上可以在构造函数中给静态变量赋值。值得注意的是，每次创建类实例时，构造函数都会被调用，这可能会覆盖之前的赋值。
public class MyClass {
public static int MY_STATIC_VARIABLE;
public MyClass() {
MY_STATIC_VARIABLE = 10;
}
}
在通常情况下，应该避免在构造函数中对静态变量进行赋值，因为这违背了静态变量的设计初衷。
使用依赖注入（Spring框架等）
如果你使用 Spring 框架，可以通过依赖注入给静态变量赋值。因为标准的 @Autowired 注解不能直接用于静态变量，需要一些额外步骤，例如使用一个非静态 setter 方法和 @PostConstruct 注解。
@Component
public class MyComponent {
private static int MY_STATIC_VARIABLE;
@Value("${my.static.variable:10}")
public void setMyStaticVariable(int value) {
MyComponent.MY_STATIC_VARIABLE = value;
}
}
在这个例子中，@Value 注解用于指定应该从属性文件中读取的值，如果没有找到这个属性，则使用默认值 10。然后，这个值被赋值给静态变量。
选择给静态变量赋值的方式应根据具体场景和编程习惯而定。通常来说，直接在声明时给静态变量赋值，或者在静态初始化块中赋值是最简单直接的方式。如果使用 Spring 或类似的框架，依赖注入可能是更好的选择，尤其是当赋值需要从配置文件或外部系统读取值时。
17、我们如何监视所有 SpringBoot 微服务？
监控Spring Boot微服务可以通过以下多种工具和方法来实现，每种都提供了不同程度的监控、度量、日志和健康检查功能。
Spring Boot Actuator
Spring Boot Actuator提供了一系列内置端点，如/health, /info, /metrics, /trace, 等等，这些端点提供了有关应用程序的运行时信息。
Micrometer
Micrometer是一个度量标准库，为Spring Boot应用提供了一种方法，以便将度量标准导出到不同的监控系统，如Prometheus, InfluxDB, Datadog, etc.
Prometheus & Grafana
Prometheus是一个监控和警报工具集，它收集和存储时间序列数据。Grafana是一个跨平台的开源可视化工具，可以用来创建仪表盘并展示Prometheus收集的度量数据。
Spring Cloud Sleuth & Zipkin
Spring Cloud Sleuth是一个分布式跟踪系统，可以跟踪请求通过微服务架构的路径。集成Zipkin可以可视化跟踪。
ELK Stack
ELK Stack（Elasticsearch, Logstash, Kibana）是一个日志集中管理解决方案，可以用来收集和分析来自微服务的日志数据。
Spring Cloud Admin
Spring Cloud Admin是一个可以用来管理和监控基于Spring Boot的应用程序的UI工具。它提供了健康检查、日志查看、指标监控等功能。
Consul, Eureka等服务发现工具
服务发现工具可以为微服务提供健康检查和服务状态，能在实例不健康时移除实例等。
在实现微服务监控时，通常需要配置和启用以上所提及的某几种工具，收集所需的数据，并在适当的监控界面（如Grafana）中创建和配置仪表盘，以得到一个全面的系统监控视图。此外，配置警报规则可以帮助及时响应潜在的系统问题。
18、如何实现SpringBoot应用程序的安全性？
在 Spring Boot 中实现应用程序的安全性主要涉及认证（Authentication）、授权（Authorization）、保护数据以及 HTTP 安全。Spring Security 是一种在 Spring 框架上构建安全性的强大和可定制的方式。以下是使用 Spring Security 实现 Spring Boot 应用程序安全性的步骤：
-
添加 Spring Security 依赖：
通过添加 Spring Boot Starter Security 依赖来集成 Spring Security。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> -
创建安全配置类：
创建一个继承自WebSecurityConfigurerAdapter的 Java 配置类，并加上@EnableWebSecurity注解。@EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http .authorizeRequests() // 开始请求的授权配置 .antMatchers("/", "/home").permitAll() // 定义不需要认证即可访问的 URL 模式 .anyRequest().authenticated() // 其他任何请求都要求用户认证 .and() .formLogin() // 开始配置登录 .loginPage("/login") // 定义自定义的登录页面 URL .permitAll() // 允许所有用户访问定义好的登录页面路径 .and() .logout() // 配置登出 .permitAll(); // 允许所有用户登出 } @Bean @Override public UserDetailsService userDetailsService() { // 定义临时的内存用户存储 UserDetails user = User.withDefaultPasswordEncoder() .username("user") .password("password") .roles("USER") .build(); return new InMemoryUserDetailsManager(user); } } -
配置用户存储：
实现或定义一个UserDetailsService来从数据库或其他存储机制中检索用户信息。@Service public class MyUserDetailsService implements UserDetailsService { // 注入用户存储仓库 @Autowired private UserRepository userRepository; @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { User user = userRepository.findByUsername(username); if (user == null) { throw new UsernameNotFoundException("User not found"); } // 将自定义 User 对象转换为 Spring Security UserDetails 对象 return new MyUserPrincipal(user); } } -
密码编码：
使用密码编码器来加密存储的密码，常用的是BCryptPasswordEncoder。@Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } -
保护静态资源：
也需要配置对静态资源的访问进行保护，防止未经授权的访问。 -
配置 HTTPS：
尽可能使应用程序通过 HTTPS 运行，为了配合这一点，可以通过配置文件配置 SSL。# application.properties server.port=8443 server.ssl.key-store-type=PKCS12 server.ssl.key-store=classpath:keystore.p12 server.ssl.key-store-password=yourpassword server.ssl.key-alias=tomcat -
增强方法安全性：
使用@PreAuthorize、@PostAuthorize、@PreFilter和@PostFilter注解在方法级别进行安全性检查。 -
控制会话管理：
设置会话固定保护、无状态会话或会话超时等，根据应用需求对会话生命周期进行管理。 -
审计和日志：
记录审计日志，跟踪和存储用户活动，这对于监控和追踪安全事件非常关键。
这些安全性措施结合起来可以为 Spring Boot 应用程序创建一个坚实的安全基础。根据应用程序的具体需求和安全标准，可能还需要做进一步的定制和配置。如果有关于 Spring Boot 安全性实现或其他相关问题，请随时提问。
19、SpringBoot微服务中如何实现 session 共享 ?
在基于Spring Boot构建的微服务架构中，由于请求可能被路由到集群中的任何一个服务实例，传统的基于单个应用服务器的session管理方式将不再适用。因此，实现session共享需要采用集中式存储来维护session数据，以便于所有服务实例都可以访问和修改相同的session信息。
以下是几种在Spring Boot微服务中实现session共享的策略：
- Spring Session：
- Spring Session提供了一种集中式session管理方案。它可以将session存储在外部存储系统中，如Redis、Hazelcast、MongoDB或者JDBC兼容的数据库。
- 要使用Spring Session，首先需要在微服务中添加Spring Session的依赖和配置对应的存储类型。例如，使用Redis作为session存储，可以通过以下依赖和配置来设置：
<!-- pom.xml中添加Spring Session依赖 -->
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
</dependency>
# application.properties中配置Redis
spring.redis.host=redis-server
spring.redis.port=6379
# 开启Spring Session的Redis支持
spring.session.store-type=redis
将相同的配置应用于微服务架构中的所有服务，这样它们都可以共享同一个存储的session数据。
-
Cookie-based Session：
- 对于无状态的RESTful服务，可以使用JWT（JSON Web Tokens）或其他令牌机制来替代传统的session机制。这些令牌可以存放用户凭据，并在每次请求时由客户端发送。
-
Sticky Sessions：
- Sticky Sessions即会话粘滞，通过负载均衡器来实现。它保证来自同一客户端的所有请求都被路由到同一服务实例。
- 这种方法不太适用于微服务架构，因为它违背了微服务的无状态和可伸缩性原则。
-
分布式缓存：
- 类似于Spring Session，使用分布式缓存（如Redis、Memcached等）直接存储和检索session数据也是一种方案。
-
Client-side Storage：
- 将session数据加密存储在客户端（如浏览器）。每个请求都将这些数据传递回服务端进行验证和解密。这种方式可以减少服务端的存储压力，但增加了数据在客户端和服务端的传输压力。
在选择session共享方案时，需要考虑安全性、性能、可用性和复杂性。对于大部分微服务架构，推荐使用Spring Session结合外部持久化存储，如Redis，这种方式灵活且易于扩展，能够更好地满足微服务环境的需求。
20、SpringBoot 中的监视器是什么？
在 Spring Boot 中，监视器通常指的是 Actuator 提供的一系列管理和监控功能。Spring Boot Actuator 是 Spring Boot 的一个子项目，它提供了多个内置的端点（endpoints），允许开发者监控和管理应用程序，比如检查应用的健康状况、审计、统计和 HTTP 跟踪。
Actuator 端点可通过 HTTP 或 JMX 访问，并可以提供如下信息：
- health：显示应用的健康状况，包括数据库连接、磁盘空间等信息。
- metrics：显示可用的各种应用度量指标，如内存使用、HTTP 请求计数、垃圾回收次数等。
- env：显示当前环境属性的详细信息。
- info：显示任意的应用信息。
- loggers：查看和修改日志级别。
- httptrace：查看最近的 HTTP 请求跟踪。
- auditevents：查看应用的审核事件信息。
这些端点对于检查生产环境中应用程序的状态非常有用，并因其丰富的功能成为开发和运维人员的重要工具。它们还可以与外部系统如 Prometheus 和 Grafana 集成，以提供实时监控和可视化的能力。
要启用 Actuator，需要在项目的依赖管理文件中加入 Actuator 的依赖。以下是在 Maven 的 pom.xml 中加入 Spring Boot Actuator 依赖的例子：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
在添加了 Actuator 依赖后，大部分端点默认是关闭的。你可以通过配置文件 application.properties 或 application.yml，设置 management.endpoints.web.exposure.include 属性来启用需要的端点。例如：
management.endpoints.web.exposure.include=health,info,metrics
通过 Actuator，Spring Boot 提供了开箱即用的管理和监控功能，以帮助开发者更有效地管理和监控应用程序。
21、如何禁用特定的自动配置类？
在Spring Boot中，如果想要禁用特定的自动配置类，可以使用@EnableAutoConfiguration注解的exclude属性或spring.autoconfigure.exclude属性来排除这些自动配置类。
下面是如何实现的两种方法：
方法1：使用 @EnableAutoConfiguration 注解
在你的Spring Boot应用的主类或者任何一个配置类上，你可以使用@EnableAutoConfiguration注解并设置exclude属性来指定需要排除的自动配置类。
import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;
@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
// 你的Bean定义
}
上面的例子中，DataSourceAutoConfiguration被排除了，它通常负责自动配置数据库数据源。
方法2：在 application.properties 或 application.yml 文件中设置
在你的application.properties文件中，可以指定需要排除的自动配置类列表：
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
如果你更倾向于使用YAML文件，可以在你的application.yml文件中设置：
spring:
autoconfigure:
exclude: org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
以上两种方式都可以用来禁用特定的自动配置类。记住，如果你排除某个自动配置类，那么你可能需要手动配置那部分功能，否则可能会因缺少必要的配置而导致应用启动失败或行为异常。
如果需要禁用多个自动配置类，可以通过逗号分隔类名的方式来定义排除列表。
需要注意的是，@SpringBootApplication注解隐含了@EnableAutoConfiguration，所以你也可以在@SpringBootApplication注解上使用exclude属性。
22、什么是 WebSockets？
WebSockets 是一种网络通信协议，提供了在单个 TCP 连接上进行全双工通信的能力。它允许客户端和服务器之间建立持久的连接，并在任何一方发送或接收数据时立即将数据推送到另一方。这在创建实时应用程序（如在线游戏、聊天应用、实时数据表现等）方面非常有用。
在传统的 HTTP 请求-响应模型中，客户端发起请求，服务器响应请求，通信是单向的。而 WebSocket 协议允许打开一个持久化的连接进行实时通信，客户端和服务器可以在任何时间发送消息，而不必等待对方的请求，这极大地减少了延迟，提高了互动性。
WebSocket 再交互上提供了几个关键优势：
-
实时双向通信：
WebSocket 提供全双工通信，客户端和服务器可以同时发送和接收消息。 -
减少网络流量和延迟：
由于 WebSocket 使用一条持久连接，降低了需要发送的 HTTP 头部信息并减少连接开销，从而减少了网络流量和延迟。 -
支持文本和二进制数据：
WebSocket 协议支持发送文本和二进制数据如 Blob 或 ArrayBuffer 。 -
无需轮询：
不必像在 HTTP 中那样使用轮询或长轮询就能实现服务器向客户端的即时推送。
在 HTML5 开始由全面支持，可以通过简单的 JavaScript API 与 WebSocket 服务器通信：
var socket = new WebSocket('ws://example.com');
socket.onopen = function(event) {
// When the connection is open, send some data to the server
socket.send('Hello Server!');
};
socket.onmessage = function(event) {
var serverMessage = event.data;
console.log(serverMessage);
};
socket.onclose = function(event) {
// When the connection is closed
console.log('Connection Closed');
};
socket.onerror = function(error) {
// When an error occurs
console.log('WebSocket Error: ', error);
};
在服务端，各种编程语言和框架也提供了 WebSocket 支持。例如，在 Java 中，Spring Framework 提供了 WebSocket API 和对 STOMP 消息代理的支持。
需要注意的是，尽管 WebSocket 在典型场景下非常有用，但它并不是万能的。在应用它之前，你应评估应用程序的需求，并考虑某些情况下可能更适合使用的其他技术（如 HTTP/2、Server-Sent Events 等）。如果你对 WebSockets 或相关技术有任何疑问，请随时提问。
SpringBoot最新2022年面试题(18)
1、在 Spring Initializer 中，如何改变一个项目的包名字？
在Spring Initializr中更改项目的包名很简单。当你在Spring Initializr的网页界面（start.spring.io）创建项目时，会有一个用于设置项目属性的表单。其中，“Group”和“Artifact”字段将决定包名的基础部分。
步骤来更改包名：
-
打开Spring Initializr网页：start.spring.io.
-
在“Group”字段中输入你的组织或公司的反向域名，例如：“com.example”。
-
在“Artifact”字段中输入你的项目名或应用名，例如：“myservice”。
-
这两个字段会合成项目的基础包名，如上例中的包名将会是：“com.example.myservice”。
-
填写完其他必要的项目信息（如项目类型、Spring Boot版本、依赖项等）后，点击“Generate”生成你的项目。
-
下载并解压缩生成的项目包，你会发现
src/main/java下的目录结构与填写的包名匹配。 -
使用IDE打开项目，如果需要修改包名中的任何部分，你可以在你的IDE中重构目录结构。
在使用IDE开发过程中，你可以随时重构修改包名。在大多数IDE中，你只需要右键点击包名，选择“Refactor”然后选择“Rename”，并遵循IDE提供的指示来更改包名。记得在改变包结构后，更新任何已经使用旧包路径的代码引用，以确保所有引用都是最新的和一致的。
2、SpringBoot 的配置文件有哪几种格式？它们有什么区别？
在 Spring Boot 中，配置文件主要有两种格式：
-
Properties 格式：
-
使用
.properties扩展名。 -
属性文件是名称-值对的列表，其中每一行包含一个属性，格式为
key=value。 -
支持分层配置，层次通过点（
.）分隔。 -
示例：
server.port=8080 spring.datasource.username=user spring.datasource.password=pass
-
-
YAML（YAML Ain’t Markup Language）格式：
-
使用
.yml或.yaml扩展名。 -
YAML 是一种数据序列化格式，它更加易读，并且可以表示列表和映射（属性和它们的值）。
-
支持多层嵌套结构，层次通过缩进表示。
-
示例：
server: port: 8080 spring: datasource: username: user password: pass
-
区别：
虽然这两种格式都用于配置 Spring Boot 应用程序，但它们具有一些关键的不同：
-
语法简洁性：
YAML 文件更简洁，可以通过缩进表达层次结构而无需重复前缀。 -
数据类型表示：
YAML 原生支持数据类型，如字符串、布尔值、整数、浮点数、映射（键值对）、列表（序列）和集合等数据结构。 -
列表和复杂结构：
YAML 本质上可以更容易地表示列表和更复杂的结构（比如包含其他映射或列表的映射）。 -
配置文件合并：
YAML 文件支持多个配置块（使用---分隔），可以在不同的配置块中定义不同环境的配置。 -
配置覆盖：
在 YAML 中，更深层次的属性定义可以直接覆盖前面的定义，在 Properties 文件中则需要完整地指定长的键名称。 -
注释：
Properties 文件使用#或!进行注释，而 YAML 使用#。 -
编辑器支持：
虽然大多数现代编辑器都支持这两种格式的高亮显示和自动缩进，但 YAML 格式的错误（如缩进错误）可能更难以被发现，因为空格数量会影响结构。
在选择配置文件格式时，通常更推荐 YAML 格式，因为它的可读性更高，特别是对于复杂的配置结构。然而，properties 格式在历史上广泛使用，并且可能更适合某些简单的配置需求。
最终选择哪种格式取决于你的具体需求和首选，Spring Boot 都提供了对这两种格式的全面支持。如果你还有其他关于 Spring Boot 配置文件或其他相关问题，请随时提问。
3、什么是 Swagger？你用 SpringBoot 实现了它吗？
Swagger是一个规范和一个完整的框架，用于生成、描述、调用和可视化RESTful风格的Web服务。核心Swagger规范名为OpenAPI，它定义了一个标准的、语言无关的接口，使人和计算机能够发现和理解Web服务的功能而无需访问源代码、文档或通过网络流量检测。
Swagger主要组件：
- Swagger tools：各种与Swagger集成的工具和库，用于API的设计、构建、文档生成和测试。
- Swagger UI：将OpenAPI规范视觉化的一套HTML、JavaScript和CSS资源。它可以将文档化的API表示为交互式的API文档，用户可以直接通过界面发送API请求。
- Swagger Editor：开源的编辑器，用来设计Swagger规范描述的RESTful API。
在Spring Boot项目中使用Swagger可以实现自动的API文档生成以及提供一个探索和测试API的用户界面。下面是使用Swagger构建API文档的基本步骤：
- 添加Swagger依赖：
你需要向你的Spring Boot应用添加Swagger库相关的依赖。对于Maven项目，你需要添加以下依赖：
<dependencies>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>3.0.0</version>
</dependency>
</dependencies>
对于Gradle项目，添加以下依赖：
implementation 'io.springfox:springfox-swagger2:3.0.0'
implementation 'io.springfox:springfox-swagger-ui:3.0.0'
- 配置Swagger：
通过添加一个配置类来启用Swagger。使用@EnableSwagger2（Swagger 2.x版本）或@EnableOpenApi（Swagger 3.x版本）注解。在这个类中，你可以配置DocketBean，定制如何生成和显示API文档。
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Bean
public Docket api() {
return new Docket(DocumentationType.SWAGGER_2)
.select()
.apis(RequestHandlerSelectors.any())
.paths(PathSelectors.any())
.build();
}
}
- 访问Swagger UI：
一旦应用启动，你可以通过访问http://localhost:<port>/swagger-ui/来查看和使用Swagger UI。注意端口号要与你的Spring Boot应用配置一致。
通过集成Swagger，开发者和API用户可以轻松查看所有API端点的明细，并可以直接在UI中进行API调用测试。这个工具极大地简化了API的文档化和前后端分离开发的工作。
4、spring boot 核心配置文件是什么？bootstrap、properties 和 application、properties 有何区别 ?
Spring Boot 核心配置文件通常是 application.properties 或 application.yml。这些配置文件用于定义 Spring Boot 应用程序的不同配置选项，如服务器端口、数据库连接和应用自定义属性等。Spring Boot 会在启动时自动加载这些配置文件。
application.properties / application.yml
- 这些文件存储应用程序级别的配置。
- 默认情况下，Spring Boot 会从四个位置加载
application.properties或application.yml文件，优先级由高到低分别是：- 当前目录下的
/config子目录。 - 当前目录。
- 类路径下的
/config包。 - 类路径的根（
resources目录）。
- 当前目录下的
- 你可以通过设置
spring.config.name和spring.config.location来改变默认的文件名和位置。
bootstrap.properties / bootstrap.yml
- 用于 Spring Cloud 应用程序的配置，属于外部配置的一部分。
bootstrap.properties或bootstrap.yml文件在application.properties/application.yml之前加载，因为它们被用于配置一些先于应用程序配置加载的属性值，例如在 Spring Cloud Config Server 上的属性源配置。- 这些文件主要用于应用程序的引导阶段（Bootstrap Phase）、配置客户端行为以及一些先于应用程序上下文创建的设置。
区别
- 简而言之，
application.*文件是用于 Spring Boot 应用程序的主要配置文件，而bootstrap.*文件是用在基于 Spring Cloud 的微服务场景，用来配置一些在应用程序上下文之前就需要读取的值。 - 因此，对于不使用 Spring Cloud Config Server 或特定于 Spring Cloud 的功能的普通 Spring Boot 应用程序来说，通常不需要
bootstrap.*配置文件。
总结来说，application.properties 或 application.yml 是你定义基础和应用级别配置的地方，而 bootstrap.properties 或 bootstrap.yml 主要在 Spring Cloud 微服务环境中使用。在不需要微服务特征的简单应用程序中，你可能只会与 application.* 文件打交道。
5、什么是Spring Initializer?
Spring Initializr是一个工具，提供了快速生成Spring Boot项目的脚手架。通过简单的Web UI或者集成到现代开发工具（如 IntelliJ IDEA、Eclipse、VS Code 等）的接口，它使用户能够快速启动并配置一个新的Spring项目。
Spring Initializr 的主要特点：
-
Web界面：通过访问 start.spring.io，用户可以方便地选择各种配置来定制其Spring Boot项目。
-
自定义项目结构：用户可以选择构建系统（例如 Maven 或 Gradle）、Spring Boot 版本、编程语言（Java、Kotlin、Groovy）、项目元数据（如包名、工件ID等）以及项目依赖。
-
项目依赖管理：Spring Initializr 提供了一系列Spring Boot“Starters”和其他库的依赖，用户可以根据需要选择添加到项目中，如网页服务、数据访问、安全、消息传递等。
-
生成项目文件：用户完成所需配置后，Spring Initializr 会生成一个包含基本脚手架和配置的项目压缩包。该包能够被任何支持Java的IDE导入。
-
命令行支持: 对于喜欢使用命令行的开发者，Spring Initializr还提供了使用HTTP服务直接启动一个新项目的支持，使用 curl 或 Spring Boot CLI。
-
集成开发环境（IDE）支持：Spring Initializr集成到了主流的Java开发工具中，允许你在IDE中直接创建和导入项目。
-
扩展性：开发者可以自己托管并定制Spring Initializr实例，用于适应组织的标准和惯例。
使用Spring Initializr开始新项目的过程非常直接，只需要选择你的定制化设置，它会为你创建一个项目结构，然后你可以立即开始编码。这种方式为开发者节省了时间，并确保了项目的结构和配置符合Spring Boot应用的最佳实践。
6、SpringBoot Starter 的工作原理是什么？
Spring Boot Starter 是一组便利的依赖描述符，可以在项目中包含一个 starter 以获得 Spring Boot 应用开发所需的依赖。Starters 包含了许多自动配置的 Spring Boot 库，旨在简化 Maven 配置并提供快速入门到 Spring Boot。
Starter 的工作原理基于以下几个核心特性和概念：
-
自动配置（
@EnableAutoConfiguration）：- Spring Boot Starter 依赖通常会自动引入
spring-boot-autoconfigure模块，它含有@EnableAutoConfiguration注解。此注解告诉 Spring Boot 尝试根据添加的类库自动配置应用。
- Spring Boot Starter 依赖通常会自动引入
-
条件化配置（
@Conditional相关注解族）：- 自动配置的框架基于多个
@Conditional配置，这些配置确保只有在满足特定条件时才执行某些配置，比如某个类存在于类路径中，或者某个 bean 尚未定义，等等。
- 自动配置的框架基于多个
-
依赖管理和 “Starter POMs”：
- Spring Boot Starter POM（项目对象模型）预定义了与特定功能相关的依赖及其版本，这样可以保证引入的库之间的兼容性。
- 使用 Spring Boot Starter 的项目之间可以轻松保持依赖版本一致性。
-
起步依赖（
Starters）：- Starter 是一种特殊的 Maven 项目依赖，它包括了用于特定类型开发的所需的依赖库集合，例如
spring-boot-starter-web为开发 web 应用提供所需的库。
- Starter 是一种特殊的 Maven 项目依赖，它包括了用于特定类型开发的所需的依赖库集合，例如
-
避免版本冲突：
- Starter 继承自
spring-boot-starter-parentPOM，该 POM 提供了默认的依赖管理，包含 Spring Boot 支持库的版本，避免了常见的版本冲突问题。
- Starter 继承自
通过使用 Starter，你可以通过添加一行依赖来开始构建应用，并且可以避免手动引入和管理特定类库以及设置版本。Spring Boot 提供了许多标准的 Starters，如官方的 spring-boot-starter-web、spring-boot-starter-data-jpa、spring-boot-starter-security 等，同时也允许社区提供自己的自定义 Starter。
一个简单的 Spring Starter 依赖引入例子如下：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
此依赖将引入 Spring MVC、Tomcat、Jackson (用于 JSON 处理)等相关库，开发者无需关心具体的库版本，因为它们由 Spring Boot Starter Parent 管理。
总之，Spring Boot Starter 的工作原理是基于一套约定、依赖管理和自动配置的机制，以简化 Spring Boot 应用程序的依赖声明和配置。如果您有关于 Spring Boot 或其他相关问题，请随时提问。
7、SpringBoot 中的 starter 到底是什么 ?
在Spring Boot中，"starter"是一种特殊类型的依赖项描述符，旨在简化构建配置过程。一个starter是一个Maven或Gradle项目中的依赖项，它包含了一组自动配置的库，这些库通常被用来提供某个特定功能。使用starter可以减少所需的配置和依赖管理，使得可以通过添加一个starter便轻松引入所需的所有依赖项。
Starter的主要特点和优势：
-
简化依赖管理：通过一个starter，你可以引入所有相关的依赖项，而不需要单独导入多个库。
-
自动配置：Starter通常包含自动配置代码，这些代码会根据classpath和已定义的beans自动配置应用。
-
约定优于配置：Starter提供了基于“约定优于配置”的原则的默认行为，从而减少了配置的工作量。
-
快速启动项目：能够迅速启动新的项目，几乎不用担心项目初始配置工作。
-
统一版本管理：Starter根据Spring Boot的版本提供兼容依赖，确保所有库能够很好地工作在一起，避免了版本冲突。
示例：
spring-boot-starter-web是一个常用的starter，它包括了构建Web应用所需的所有依赖（如Spring MVC，Tomcat，JACKSON等）：
Maven 中的使用示例：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
Gradle 中的使用示例：
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
}
常见的Spring Boot Starter：
- spring-boot-starter：Spring Boot的核心starter，包括自动配置支持、日志库和YAML。
- spring-boot-starter-web：用于构建Web应用，包括RESTful applications使用Spring MVC。
- spring-boot-starter-data-jpa：包含Spring Data JPA和Hibernate，用于数据库访问。
- spring-boot-starter-security：提供Spring Security的自动配置，用于保护Web应用。
- spring-boot-starter-test：提供测试需要的库，如JUnit、Spring Test和Mockito。
使用Spring Boot starter是构建基于Spring Boot应用的最佳实践，它大大简化了项目配置和启动流程。通过官方提供或自定义的starter，开发者可以选择适合的依赖配置以快速启动和开发Spring Boot应用。
8、SpringBoot 最大的优势是什么呢？
Spring Boot 是一个基于 Spring 框架的开源 Java 基础项目，旨在简化新 Spring 应用的初始搭建与开发过程。其主要优势包括：
-
自动配置：Spring Boot 可以自动为项目配置 Spring。它根据项目中添加的依赖自动配置 Spring 框架和第三方库，减少了大量手动配置代码的需要。
-
快速启动：Spring Boot 提供了快速启动和运行 Spring 应用程序的方式。处理了底层基础设施的许多细节，因此开发者可以迅速进入业务逻辑编码。
-
非代码配置：Spring Boot 支持易于理解的配置项，允许通过属性文件、YAML 文件、环境变量和命令行参数等方式对应用进行细粒度的配置。
-
内置服务器：Spring Boot 应用可以打包成独立的 JAR 文件，其中包含内置的服务器（如 Tomcat、Jetty 或 Undertow），不需要额外的服务器部署。
-
微服务架构支持：Spring Boot 配合 Spring Cloud，为构建微服务应用提供了强大的支持，使微服务的创建与管理变得更加容易。
-
开箱即用的特性：Spring Boot 提供多种“起步依赖”，使应用获得诸多即插即用的功能，如安全性、监控、健康检查等。
-
社区和生态系统：由于 Spring 框架受到自身强大社区的广泛支持，Spring Boot 利用了这一点，提供了可靠的、经过测试的解决方案，以及广泛的文档资源。
-
扩展性和定制化：尽管 Spring Boot 提供了许多默认配置，但它依然支持定制和扩展，允许开发者根据需要调整自动配置的内容。
Spring Boot 的目标是简化 Spring 应用的开发、部署和管理，特别是消除了那些繁重、常常重复的配置工作，使开发人员可以专注于业务逻辑，加快应用开发周期。这些优势使得 Spring Boot 成为 Java 开发者中非常受欢迎的技术选择。
9、SpringBoot集成mybatis的过程
在Spring Boot中集成MyBatis可以通过以下几个简单的步骤来完成：
1. 添加依赖
首先，在你的pom.xml（对于Maven项目）或build.gradle（对于Gradle项目）文件中添加Spring Boot和MyBatis的起始依赖（starter dependency）。
对于Maven，添加以下依赖：
<dependencies>
<!-- MyBatis Starter -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version>
</dependency>
<!-- Spring Boot Web Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- MySQL Driver -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
对于Gradle，添加以下依赖：
dependencies {
implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.1.4'
implementation 'org.springframework.boot:spring-boot-starter-web'
runtimeOnly 'mysql:mysql-connector-java'
}
确保版本号与你的Spring Boot版本兼容。
2. 配置数据源
在application.properties或application.yml中配置数据源属性，指定数据库的连接信息。
# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/yourdatabase
spring.datasource.username=yourusername
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
3. 创建实体类
根据你的数据库表创建实体（Entity）类。
public class User {
private Long id;
private String name;
private String email;
// Getters and Setters ...
}
4. 创建映射文件
创建MyBatis的XML映射文件，将SQL查询与Java方法相关联。文件位置默认应该在src/main/resources/mapper目录中。例如，UserMapper.xml：
<mapper namespace="com.example.mapper.UserMapper">
<select id="findUserById" resultType="com.example.model.User">
SELECT id, name, email FROM users WHERE id = #{id}
</select>
</mapper>
5. 创建Mapper接口
创建对应的Mapper接口，并使用@Mapper注解标记。
@Mapper
public interface UserMapper {
User findUserById(Long id);
}
6. Service层和Controller层
编写Service层来处理业务逻辑，并创建Controller层暴露REST API。
@Service
public class UserService {
private final UserMapper userMapper;
@Autowired
public UserService(UserMapper userMapper) {
this.userMapper = userMapper;
}
public User findUserById(Long id) {
return userMapper.findUserById(id);
}
}
@RestController
@RequestMapping("/users")
public class UserController {
private final UserService userService;
@Autowired
public UserController(UserService userService) {
this.userService = userService;
}
@GetMapping("/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
User user = userService.findUserById(id);
return ResponseEntity.ok(user);
}
}
7. 运行应用程序
编译并运行你的Spring Boot应用程序，它将自动配置MyBatis，并与数据库连接。
以上步骤概述了在Spring Boot应用中集成和使用MyBatis的基本过程。你可以根据需要添加更多的Mapper和Service，或使用Spring Boot的其他功能来扩展你的应用。
10、如何在SpringBoot中禁用Actuator端点安全性？
在 Spring Boot 中，默认情况下，Actuator 端点是受 Spring Security 保护的，如果你启用了 Spring Security。这意味着，为了访问这些端点，你需要提供适当的认证凭证。但在某些情况下，特别是在开发或测试环境中，你可能想要禁用对某些或所有 Actuator 端点的安全性。
在 Spring Boot 2.x 中，可以通过在 application.properties 或 application.yml 配置文件中设置相应属性来实现这一点：
application.properties
# 禁用所有端点的安全性
management.security.enabled=false
# Spring Boot 2.0 之前的版本可以使用这个属性，但已经不推荐使用
management.security.enable=false
application.yml
management:
security:
enabled: false
这些设置会禁用 Actuator 端点的安全性检查，使得它们可以在不进行任何身份验证的情况下被访问。但是，这种做法存在安全风险，因为它可能使你的应用程序面临未经授权访问的风险。
从 Spring Boot 2.0 开始，Actuator 的安全配置建议通过 Spring Security 的配置来进行。因此，你可以创建一个 WebSecurityConfigurerAdapter 配置类来自定义端点的安全行为：
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
public class ActuatorSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/actuator/**").permitAll() // 允许所有对 Actuator 端点的请求
.anyRequest().authenticated()
.and()
.httpBasic(); // 使用基本认证
}
}
这种方式比全局禁用安全性更灵活，也更推荐使用，特别是在生产环境中。你仍然能够保持对应用程序其他部分的安全性，同时根据需要放宽对 Actuator 端点的保护。
要注意的是，无论哪种方法，都需要谨慎考虑安全性影响。特别是在生产环境中，应遵循 “最少权限原则”，只对必要的角色和用户公开 Actuator 端点，并始终需要认证和加密（例如，使用 HTTPS）来保护敏感的行动端点。如果您有关于 Spring Boot Actuator 安全性的其他问题，请随时提问。
11、什么是 Spring Profiles？
Spring Profiles提供了一种方式来对应用配置环境进行分段，允许根据不同环境（如开发、测试和生产环境）来注册bean。通过定义多个profile，你可以控制哪些组件在某个给定的环境下被创建以及应用程序如何配置。
每个profile相当于一组特定的配置，能够在应用启动时激活。你可以根据需要定义任意数量的profile，并在JVM启动参数、环境变量、YAML或properties配置文件等地方指定活跃profile。
以下是几种设置Spring profiles的方法：
-
在@Configuration类上使用
@Profile注解：@Configuration @Profile("development") public class DevelopmentConfig { // 仅当 'development' profile激活时才应用的Bean @Bean public DataSource dataSource() { // ... 创建数据源 } } -
在
application.properties或application.yml中指定激活的profile：application.properties:
spring.profiles.active=developmentapplication.yml:
spring: profiles: active: development -
在启动过程中通过一个命令行参数指定 profile：
java -jar -Dspring.profiles.active=production myapp.jar -
在Web应用的Servlet初始化参数中设置：
如果你在Servlet容器中运行Spring应用，可以在web.xml中或利用Servlet 3.0配置API设置profile。 -
通过Spring Boot的
spring.profiles.active环境变量：SPRING_PROFILES_ACTIVE=development
使用profiles可以达到如下目的：
- 针对不同环境使用不同的配置值，例如数据库连接信息。
- 根据环境开启或关闭某些特性。
- 避免在源代码中硬编码环境特定值。
- 使得单元测试运行时可以根据测试条件来选择配置。
正确使用Spring Profiles是构建易于管理和可扩展Spring应用的关键技巧之一。它们使得开发者可以轻松地在各种不同的环境之间切换和管理配置信息，而不需要更改代码。
12、spring-boot-starter-parent有什么用？
spring-boot-starter-parent 是一个特殊的 Starter，它是用于 Spring Boot 应用程序的 Maven 项目的父 POM（Project Object Model）。这个 starter 提供了以下功能和好处：
- 默认配置：
spring-boot-starter-parent 提供了一些有用的 Maven 默认设置，这些设置包括了资源过滤、插件配置等。它默认为你的项目配置了合适的资源过滤，以及合适的插件版本号。
2. 管理依赖版本：
通过 <dependencyManagement> 部分，它提供了依赖版本管理。这意味着你可以在项目中包含依赖而不用指定版本号，Spring Boot 父 POM 已经预定义了大量常用库的版本，确保这些库之间的兼容性。
3. Java 版本和编码设置：
spring-boot-starter-parent 设置了 Java 版本和项目编码为 UTF-8，使其符合 Spring Boot 应用程序的推荐做法。
4. 插件配置：
它预配置了 Maven 插件，如 Maven Compiler Plugin、Maven WAR Plugin 等，这样它们就可以与 Spring Boot 协同工作。例如，它配置了 Maven Compiler Plugin 和 Maven Surefire Plugin 来使用 Java 8。
5. 插件管理：
除了常用的 Maven 插件，spring-boot-starter-parent 还管理了 Spring Boot 特定插件，如 spring-boot-maven-plugin，它允许你打包可执行的 jar 或 war 文件，并在 Maven 命令行中运行你的 Spring Boot 应用程序。
使用 spring-boot-starter-parent 作为父 POM 时，它简化了项目的 Maven 配置，并提供了许多默认行为，让开发者可以更容易地开始一个新的 Spring Boot 应用程序。
示例：
在 Maven pom.xml 文件中使用 spring-boot-starter-parent：
<project>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.0</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!-- Your own project configuration -->
</project>
spring-boot-starter-parent 对于想要快速启动和减少配置的 Spring Boot 项目非常有用。但是，如果需要自定义这些默认配置，或者你已经有别的父 POM，那么可以选择不使用spring-boot-starter-parent，而是使用 Spring Boot 的 dependency-management-plugin 来更加灵活地进行依赖管理。
13、SpringBoot 怎么用好自动配置
Spring Boot的主要卖点之一是其“约定优于配置”的原则，提供自动配置的能力，以简化Spring应用开发。以下是几个实践建议，帮你更好地使用Spring Boot的自动配置：
1. 利用启动器（starters）
Spring Boot提供了一系列的起始依赖（starters），它们包含了许多自动配置的默认行为。例如，要为你的应用添加WEB支持，只需包含spring-boot-starter-web依赖而无须额外配置。
2. 正确理解自动配置原理
Spring Boot自动配置是通过@Conditional注解来实现的，这些条件基于classpath的内容、定义的beans以及各种属性的值。阅读Spring Boot文档和相关源码有助于理解这些条件是如何工作的。
3. 遵循Spring Boot约定
Spring Boot推荐的目录结构、配置文件命名和beans管理约定都是自动配置正确工作的基础。确保你遵循这些约定，以利用自动配置带来的好处。
4. 利用配置属性
Spring Boot通过application.properties或application.yml文件提供了丰富的可配置属性。通过设置这些属性值，你可以控制和调整自动配置提供的默认行为。
5. 使用 @SpringBootApplication 注解
@SpringBootApplication注解是一个方便的复合注解，整合了@Configuration、@EnableAutoConfiguration和@ComponentScan。它会触发自动配置并扫描同目录及子目录下的components。
6. 分析自动配置报告
Spring Boot Actuator的/autoconfig端点可以提供自动配置的报告，详细列出哪些自动配置是匹配的或未匹配的，并解释为什么。利用这个报告来理解应用的配置情况。
7. 排除不需要的自动配置
如果自动配置的默认行为不是你想要的，你可以通过设置@EnableAutoConfiguration或@SpringBootApplication注解的exclude参数来禁用特定的自动配置类。
8. 再次检查自定义beans
如果你的应用定义了与自动配置提供的beans同名的bean，自动配置的bean就不会被创建。确保你的自定义beans不会不小心阻碍自动配置。
9. 避免过度配置
首先依靠Spring Boot的自动配置。除非有明确的需要，避免过多手动配置，这样可以更好地保持Spring Boot的简洁性。
10. 保持依赖更新
定期更新Spring Boot和其他依赖项的版本可以确保你利用的是最新的自动配置特性和改进。
合理使用Spring Boot的自动配置可节省大量的配置工作，让你更专注于业务逻辑，并促进快速开发。
14、SpringBoot需要独立的容器运行？
不，Spring Boot 不需要独立的容器来运行。Spring Boot 旨在简化 Spring 应用程序的创建和部署过程，它提供了内嵌的 HTTP 服务器（比如 Tomcat、Jetty 或 Undertow），这意味着 Spring Boot 应用程序可以作为独立的 Java 应用程序运行，而不需要一个外部的容器。
要启动一个 Spring Boot 应用，你通常会创建一个具有 main() 方法的类，并使用 SpringApplication.run() 静态方法来启动应用程序。例如：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
当运行这个 main() 方法时，Spring Boot 会自动配置和启动嵌入式 HTTP 服务器，提供全功能的 web 环境。这一切都在创建的可执行 JAR 文件内完成，该 JAR 文件包含应用程序的编译代码、相关的依赖库以及嵌入式服务器。
尽管 Spring Boot 能够运行独立的 HTTP 服务器，你仍然可以选择将 Spring Boot 应用部署到外部的容器中。如果这样做，你需要构建一个 WAR 文件并进行适当配置，以便在 Servlet 容器（例如 Apache Tomcat 或者 Jetty）中运行。这种部署方式在需要整合到现有应用服务器环境中的情况下非常有用。
总的来说，Spring Boot 提供了灵活的部署选项，无论是作为独立的应用程序运行，还是在现有应用服务器环境中作为传统的 WAR 项目部署，都提供了全面的支持。如果你有其他问题或疑问，请随时提出。
15、什么是Spring Batch？
Spring Batch是一个轻量级、综合性的批处理框架，它是Spring框架的一个扩展，用于开发企业级的高性能批处理应用程序。Spring Batch提供了大量的"读-处理-写"类型的批处理作业的典型编程模型以及广泛的功能集合，并且可以用来处理大量数据。
Spring Batch的关键特性包括：
-
强大的批处理策略：包括事务管理、作业处理统计、作业重启、跳过策略以及资源管理。
-
丰富的I/O功能：提供大量用于读取和写入不同数据源的API，包括数据库、文件、消息队列以及其他企业服务。
-
可重用的功能：提供了用于转换数据、日志记录、追踪和其他重复性任务的业务服务。
-
定制化特性：Spring Batch可以很容易地通过自定义的读取、处理、写入步骤来适应任何复杂的业务场景。
-
优化和性能：针对大量数据进行优化，提供扩展性和并发的处理步骤。
Spring Batch的架构分为三个主要层次：
- 应用层(Application)：包含所有批处理作业以及用于依赖注入、生命周期管理和作业处理的自定义代码。
- 核心层(Core)：包括控制批处理作业的执行以及运行时服务的接口，比如事务管理、作业启动和控制等。
- 基础设施层(Infrastructure)：提供一组公共的读取器、处理器和写入器等服务。
举例来说，一个Spring Batch的批处理作业通常由一个或多个步骤（Step）组成，每个步骤包括一个读取器（ItemReader）、一个处理器（ItemProcessor）和一个写入器（ItemWriter）。一个简单的批处理作业定义可能如下：
@Configuration
@EnableBatchProcessing
public class BatchConfig {
@Autowired
private JobBuilderFactory jobs;
@Autowired
private StepBuilderFactory steps;
// 定义一个ItemReader...
// 定义一个ItemProcessor...
// 定义一个ItemWriter...
@Bean
public Step step1() {
return steps.get("step1")
.<InputDataType, OutputDataType> chunk(10)
.reader(reader())
.processor(processor())
.writer(writer())
.build();
}
@Bean
public Job helloWorldJob() {
return jobs.get("helloWorldJob")
.start(step1())
.build();
}
}
在这段代码中，我们定义了一个批处理作业，该作业只包含一个步骤，这个步骤每次处理10个记录的块（chunk）。作业会顺序执行读取、处理和写入操作，以完成批处理任务。
Spring Batch是处理大规模数据处理任务的理想选择，并且与Spring框架的其他项目（如Spring Data、Spring Integration等）很好地集成在一起，为批处理应用提供了一套完整的解决方案。
16、@RestController和@Controller的区别
在 Spring 框架中，@RestController 和 @Controller 注解被用于标记一个控制器类，这两个注解在作用上有相似之处，但也有显著的不同：
@Controller
@Controller是一个常用的 Spring 注解，用于标记类作为 Spring MVC 的控制器（Web 控制器）。@Controller注解的控制器通常需要配合@RequestMapping（或其变体，如@GetMapping、@PostMapping等）注解一起使用，以映射 URL 路径到控制器方法。- 当使用
@Controller时，方法可以返回一个视图（例如 JSP 页面的名称），该视图将被视图解析器（View Resolver）解析以生成最终的页面。 - 如果
@Controller注解的方法返回对象或其他数据，需要配合@ResponseBody注解将返回结果直接写入 HTTP 响应正文（Body），这主要用于返回数据，例如 JSON 或 XML。
@RestController
@RestController是 Spring 4 引入的注解，是@Controller和@ResponseBody注解的组合，所以它不仅使用了@Controller的功能，同时也将@ResponseBody应用到了整个控制器类的所有方法上。- 使用
@RestController注解，表明该控制器的所有方法都默认返回 JSON/XML 或其他媒体类型，并将其写入 HTTP 响应正文中。 @RestController通常用于编写 RESTful API，其中控制器都是以 API 接口的形式提供服务的，并返回数据而不是视图。
总结区别
-
@Controller：
- 需要与
@ResponseBody结合使用来提供 JSON/XML 响应。 - 常用于传统的 Web 应用程序，属于 Spring MVC 的范畴。
- 方法可以返回视图（如 HTML 页面）。
- 需要与
-
@RestController：
- 默认类中的方法都会返回 JSON/XML 或其他媒体类型。
- 专为 REST API 设计，适合构建 Web 服务。
- 不需要
@ResponseBody配合，简化了 RESTful 服务方法的书写。
通常选择使用哪种注解，取决于你的应用程序需要提供的是传统的 MVC 功能（如访问页面、表单提交等），还是提供 RESTful Web 服务（如资源的增删改查操作）。在现代 Web 应用开发中，@RestController 的使用更为频繁，因为 JSON 和 RESTful API 已成为与前端或移动客户端进行通信的主要方式。
17、JPA 和 Hibernate 有哪些区别？JPA 可以支持动态 SQL 吗？
JPA（Java Persistence API）和Hibernate都与Java应用程序中的持久性和ORM（对象关系映射）有关，但它们在概念和实现上有所区别：
JPA（Java Persistence API）
- 规范：JPA 是 Java EE 和Java SE 中用于对象-关系映射的API的规范。它定义了一组管理关系数据的标准Java ORM方法。
- 实现无关性：JPA提供了一组接口和注解，供不同的ORM提供者（如Hibernate、EclipseLink、OpenJPA等）实现。
- 查询语言：JPA 规范包括一个查询语言（JPQL - Java Persistence Query Language），用于对数据库执行查询和CRUD操作。
Hibernate
- JPA实现：Hibernate 是 JPA 规范的一个流行实现，但它预先于 JPA 存在并拥有其自己的API和特性。
- 功能丰富：Hibernate 作为一个成熟的ORM框架，它提供了一些超出 JPA 规范的附加特性，比如懒加载、二级缓存、自然ID、批量操作等。
- 查询语言：Hibernate 有自己的查询语言（HQL - Hibernate Query Language），但同时也支持 JPQL。
简而言之，JPA是一种ORM规范，定义了Java对象和数据库表之间映射的系统标准；Hibernate是这一规范的老牌实现之一，提供了完整的ORM解决方案。
JPA对动态SQL的支持
尽管JPA主要侧重于静态查询（如JPQL和Criteria API），但它确实支持动态查询，这可以通过几种方式实现：
-
原生SQL：JPA
EntityManager接口允许执行原生SQL查询。这样你就可以创建完全定制的SQL语句来满足特定需要。Query nativeQuery = entityManager.createNativeQuery("SELECT * FROM my_table WHERE my_column = :value"); nativeQuery.setParameter("value", someValue); List<Object[]> resultList = nativeQuery.getResultList(); -
Criteria API：这是一种更为动态且类型安全的构建SQL查询的方法。能够以编程方式构建查询条件，并生成JPQL。
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder(); CriteriaQuery<MyEntity> criteriaQuery = criteriaBuilder.createQuery(MyEntity.class); Root<MyEntity> root = criteriaQuery.from(MyEntity.class); criteriaQuery.select(root).where(criteriaBuilder.equal(root.get("myColumn"), "someValue")); List<MyEntity> result = entityManager.createQuery(criteriaQuery).getResultList(); -
QueryDSL：虽然不是JPA规范的一部分，但QueryDSL是一个流行的第三方库，可用于构建类型安全的SQL查询。它适合用于构建复杂且动态的查询。
通过使用这些方法，JPA可以灵活处理多样化的查询需求，包括动态创建和执行SQL语句。
18、path=”users”, collectionResourceRel=”users” 如何与 Spring Data Rest 一起使用？
在 Spring Data REST 中，@RepositoryRestResource 注解是用来自定义资源公开的方式。它允许你指定路径和 rel（关系名），这些信息会在生成的 HAL（Hypertext Application Language）响应中使用。HAL 是一种将 API 资源和关联资源链接在一起的标准格式。
举个例子，如果你有一个处理用户数据的 JPA repository，你可能会这样使用 @RepositoryRestResource 注解：
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;
import org.example.domain.User;
@RepositoryRestResource(path = "users", collectionResourceRel = "users")
public interface UserRepository extends JpaRepository<User, Long> {
// 默认情况下，这会创建路径 "/users" 来访问 User 实体
}
在这个例子中，path 属性用于定义基 URI 的访问路径。当你使用 path = "users" 时，意味着 Spring Data REST 会在 URI /users 下创建该资源的端点。例如，通过获取 /users 可以得到所有 User 实体的集合。
同样，collectionResourceRel 属性用于定义该资源在 _links 部分展示的 rel 来标识整个资源集合。例如，在 HAL 响应中，用户资源集合的链接可能像这样：
"_links": {
"users": {
"href": "http://localhost:8080/users{?page,size,sort}",
"templated": true
}
}
collectionResourceRel 的值 users 将用来嵌入返回的 JSON 中的用户集合。同样地，itemResourceRel 可以用来定义单个资源的 rel。
通过这样自定义，Spring Data REST 会自动处理 CRUD（创建/读取/更新/删除）操作，并将它们公开为 RESTful 端点。客户端可以通过 HTTP 方法（GET、POST、PUT、PATCH、DELETE ）与这些端点交互。
总的来说，@RepositoryRestResource 注解给你提供了一个简便的方式来定制 Spring Data REST 的行为，同时保持了 Spring Data 的强大功能，使得你可以很容易地创建和定制 RESTful 服务。
SpringBoot最新2022年面试题(12)
1、shiro和oauth还有cas他们之间的关系是什么？问下您公司权限是如何设计，还有就是这几个概念的区别。
Shiro、OAuth和CAS（Central Authentication Service）是在软件安全领域常见的三个不同的技术和协议，它们分别有不同的用途和实现方式。
Apache Shiro
- 访问控制框架：Apache Shiro是一个强大易用的Java安全框架，提供了身份验证、授权、加密和会话管理。
- 应用级别：Shiro旨在为应用程序提供安全性控制，适用于单个应用程序的安全性需求。
OAuth
- 授权框架：OAuth是一个授权框架，允许第三方应用代表用户访问另一个HTTP服务的资源，而无需暴露用户的凭证（通常是用户名和密码）。
- 跨应用程序：OAuth通常用于多个应用或服务之间的授权，例如，允许用户使用Google账号登录其他服务。
CAS
- 单点登录解决方案：CAS是针对Web应用的企业级单点登录（SSO）解决方案，支持多种客户端协议，包括HTTP和REST等。
- 集中式身份验证：CAS作为一个中央安全服务器，处理应用集群中所有应用的认证请求，这使得用户在一个地方登录后可以访问多个应用。
他们之间的关系：
- Shiro通常用于为应用程序内部提供完整的安全性功能，而OAuth和CAS通常处理与其他服务或应用的集成和交互。
- OAuth专注于跨应用程序的授权，而不一定提供身份验证（这通常交由“身份提供者”如Facebook、Google等来实现）。
- CAS更专注于身份验证和SSO，允许用户在一组相互信任的应用程序中无缝访问。
权限设计：
公司的权限设计会根据实际的业务需要和安全要求来定。一种常见的设计包括以下几个层面：
- 身份验证：使用OAuth、CAS或Shiro等技术验证用户身份。
- 授权：确定验证后的用户有权访问的资源和操作（例如，ACLs、角色、权限、策略等）。
- 会话管理：跟踪认证用户的会话和状态。
- 加密：对敏感数据和通信进行加密保护。
现实世界中，上述技术可能会组合使用。例如，使用CAS实现SSO，同时使用OAuth来与其他服务交互，并结合Shiro在应用程序内部执行细粒度的权限控制。每一种技术及其实现都应该针对具体的业务场景和安全要求进行选择和定制。
在多服务或分布式系统的环境中，设计权限系统时还需要考虑到服务之间的安全通信、凭据的传递方式，以及统一的认证和授权服务如何集成到整个架构中。
2、开启 SpringBoot 特性有哪几种方式？
在 Spring Boot 中启用和使用其特性通常是通过添加依赖、配置属性、编写代码和使用注解等方式来完成的，并不依赖特定的启用方式。以下是启用和使用 Spring Boot 特性的一些常见手段：
-
添加启动器依赖（Starters）:
Spring Boot 提供了一系列 “starter” 依赖，它们是预先配置的依赖描述符，旨在简化构建配置过程。通过在项目中添加一个或多个 starter 依赖，可以轻松启用各种功能，如 web 服务、数据访问、安全性和测试支持。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> -
使用注解:
Spring Boot 使用诸如@SpringBootApplication和@EnableAutoConfiguration,@EntityScan,@ComponentScan等注解，这些注解会启动自动配置和应用上下文的组件扫描。 -
属性和配置文件:
通过application.properties或application.yml文件来配置应用程序。这些文件位于项目的src/main/resources目录下，Spring Boot会自动加载配置文件中的属性。server.port=8080 spring.datasource.url=jdbc:postgresql://localhost/db -
命令行参数:
运行打包好的 Spring Boot 应用程序时，可以传递命令行参数来覆盖配置文件中的属性。java -jar myapp.jar --server.port=8081 -
Java配置类:
实现配置类并使用@Configuration,@Bean,@Value,@PropertySource等注解来自定义配置和 Bean 的创建。 -
外部化配置:
利用 Spring Boot 外部化配置的特性，可以从环境变量、JVM 系统属性、命令行参数、云配置服务以及应用外的配置文件来配置应用。 -
开发工具（DevTools）:
添加spring-boot-devtools依赖，可以使得应用支持热部署和其他开发时优化的功能。 -
激活 Spring Profiles:
使用spring.profiles.active属性激活特定的配置文件，根据不同环境应用不同的配置。
通过这些方法配置和定制 Spring Boot 应用程序，你可以充分利用 Spring Boot 提供的快速开发和零配置部署特性，并构建强大、易于维护的 Spring 应用程序。如果你还有其他问题或需要更多关于 Spring Boot 的详细信息，请随时提问。
3、什么是YAML?
YAML（YAML Ain’t Markup Language，递归的缩写，表明YAML不是一种标记语言）是一种直观的数据序列化格式，它可以被人类轻松阅读。它常常被用作配置文件，也可以在数据交换中使用，类似于JSON和XML，但它的语法更为简洁和可读。
YAML的一些关键特性如下：
-
易于阅读：YAML使用了缩进式的层级结构，这使得它非常易于阅读。
-
数据类型丰富：支持标量类型（如字符串、整数、浮点数）、结构类型（如映射/散列表、列表/数组）以及复合类型的数据结构。
-
无需引号：在大多数情况下，你不需要使用引号来标识字符串，除非字符串中包含特殊字符。
-
可继承和可扩展：可以通过文档中的锚点（&）和别名（*）进行值的复用。同时，支持复杂的数据结构嵌套。
YAML文件示例：
person:
name: John Doe
age: 30
married: true
children:
- name: Jane Doe
age: 10
- name: Jim Doe
age: 7
address:
street: 123 Main St
city: Anytown
zip: 12345
在Spring Boot中，.yml文件通常用于配置应用程序的属性，替换了传统的.properties文件。YAML提供了一种更为丰富且易于管理的方式来组织复杂的配置数据。
例如，以下是一个典型的Spring Boot application.yml 文件：
server:
port: 8080
context-path: /api
spring:
datasource:
url: jdbc:mysql://localhost/test
username: user
password: pass
jpa:
hibernate:
ddl-auto: update
profiles:
active:
- dev
- prod
custom:
config:
setting1: "Value 1"
setting2: "Value 2"
要读取YAML文件，你需要一个解析库，如Jackson YAML、SnakeYAML或任何支持YAML解析的库。Spring Boot已经内置了对YAML的支持，使其成为在Spring Boot中进行配置管理的推荐选择。
4、如何在 SpringBoot 中添加通用的 JS代码？
在 Spring Boot 中添加通用的 JavaScript (JS) 代码，主要依赖于项目所使用的模板引擎（如 Thymeleaf、Freemarker、JSP 等）。以下是几种常见的方法来组织和引入通用 JavaScript 代码：
1. 创建通用的 JS 文件
在 src/main/resources/static 目录中创建一个或多个通用的 JS 文件。
src
|-- main
|-- java
|-- resources
|-- static
|-- js
|-- common.js
然后可以在 HTML 模板中使用 <script> 标签引入这个通用 JS 文件。
<!DOCTYPE html>
<html>
<head>
<!-- 其他头部信息 -->
<script src="/js/common.js"></script>
</head>
<body>
<!-- 页面内容 -->
</body>
</html>
2. 使用模板布局
使用模板引擎的布局功能，创建一个布局模板（layout template），它包含了通用的头部、底部和 JS 引入代码。然后让所有页面都继承自这个布局模板。
例如 Thymeleaf 中可以使用 th:fragment 创建可复用的片段：
layout.html
<!DOCTYPE html>
<html>
<head>
<!-- 头部信息和样式 -->
<script src="/js/common.js"></script>
</head>
<body>
<header>Header content...</header>
<div th:replace="${content}"></div>
<footer>Footer content...</footer>
<!-- 页面特有的 JS 可以放在这里 -->
</body>
</html>
每个页面都可以继承并替换内容区域：
index.html
<div th:replace="~{layout :: content}">
<!-- 页面内容 -->
</div>
3. 使用 WebJars
WebJars 是将客户端库（如 jQuery、Bootstrap）打包成 JAR 文件的项目，可以通过 Maven 或 Gradle 管理这些包。
要使用 WebJars，首先需要添加依赖到 pom.xml 文件中：
<dependency>
<groupId>org.webjars</groupId>
<artifactId>jquery</artifactId>
<version>3.6.0</version>
</dependency>
然后在 HTML 中引入 WebJars 资源：
<script src="/webjars/jquery/3.6.0/jquery.min.js"></script>
4. 使用 CDN
若要确保通用 JavaScript 代码的加载速度最优化，可以从 Content Delivery Network (CDN) 引入。
<script src="https://cdn.jsdelivr.net/npm/jquery@3.6.0/dist/jquery.min.js"></script>
使用 CDN 还可以减少自己服务器的带宽消耗。
总结来说，在 Spring Boot 中添加通用 JavaScript 代码可以通过多种方式实现。关键是组织代码的方式使其易于维护，并在所有页面中统一引入。通过合适的模板布局和资源组织，可以方便地在全局范围内使用 JavaScript 代码。
5、SpringBoot 是否可以使用 XML 配置 ?
是的，即使Spring Boot强调使用约定优于配置的方法，并且鼓励使用基于Java的配置，但它仍然支持使用XML配置。如果你有现有的Spring项目想要迁移到Spring Boot，或者因为某些原因（例如，遗留代码或团队喜好）需要使用XML配置，Spring Boot都可以适应。
在Spring Boot中使用XML配置的步骤如下：
-
创建XML配置文件：
- 在Spring Boot项目的
src/main/resources目录下创建一个或多个XML配置文件。例如，可以创建一个名为spring-context.xml的文件。
- 在Spring Boot项目的
-
在XML文件中配置Beans：
- 在XML文件中，可以像传统Spring应用那样定义beans、注入依赖等。
<!-- Example of spring-context.xml --> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="exampleBean" class="com.example.ExampleBean"/> </beans> -
导入XML配置：
- 然后在主配置类（通常是带有
@SpringBootApplication注解的类）或任何@Configuration注解的类中，使用@ImportResource注解指定XML配置文件的路径。
import org.springframework.context.annotation.ImportResource; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication @ImportResource("classpath:spring-context.xml") public class MySpringBootApplication { public static void main(String[] args) { SpringApplication.run(MySpringBootApplication.class, args); } } - 然后在主配置类（通常是带有
-
运行Spring Boot应用：
- 当你运行Spring Boot应用时，它将加载和使用这个XML配置文件中定义的beans。
虽然这种方式可以正确工作，但它没有利用到Spring Boot的自动配置能力。Spring Boot团队建议尽可能使用Java配置方法，并逐步将XML配置迁移至基于Java的配置，这样可以更充分地利用Spring Boot提供的简洁性和优势。
总的来说，虽然Spring Boot支持XML配置，但鼓励使用基于Java的配置方法以获得更直接、清晰和灵活的配置方式，并更好地整合Spring Boot的功能。如果需要使用XML配置来保持向后兼容性或其他原因，Spring Boot同样支持这一方式。
6、什么是 Spring Data REST?
Spring Data REST 是基于 Spring Data 的库，它能够将存储库自动输出为 RESTful 资源。典型的使用场景包括，将数据访问层（repository）直接映射为 HTTP 访问端点，从而使你能够通过网络接口对数据进行操作，而不必编写大量的控制器代码。
Spring Data REST 的工作方式是通过分析你的 Spring Data 存储库，并为存储库中每个实体及其相关的 CRUD 操作自动创建相应的 REST 端点。此外，Spring Data REST 还支持分页、排序、事务和资源关联等特性。
主要特点包括：
-
自动端点映射：
为 Spring Data 存储库中的实体自动创建 RESTful 端点，例如/people或/orders。 -
HAL 格式的响应：
默认使用 Hypermedia Application Language (HAL) 格式响应，为记录和关联增加了超媒体链接（即_links部分）。 -
基于 CRUD 存储库：
自动映射 CRUD 存储库的操作为 HTTP 方法，如GET、POST、PUT、PATCH和DELETE。 -
基于搜索的资源发现：
支持搜索终端的自动注册，以便根据查询方法暴露自定义查找逻辑。 -
分页和排序：
支持集合资源的分页和排序，客户端可以通过查询参数来请求不同页和排序顺序。 -
验证和事件处理：
集成了 Spring Validation 用于验证，同时通过为资源生命周期事件发布 Spring 应用程序事件进行事件处理。 -
扩展性：
支持通过自定义控制器或存储库事件处理程序扩展或自定义 API。
一个基本的 Spring Data REST 应用通常包含以下内容：
- Spring Data 存储库接口，如
PagingAndSortingRepository或JpaRepository。 - 实体类，标记为
@Entity，作为数据的模型。 - 可选的存储库接口自定义方法，它们被自动导出为 REST 资源的搜索端点。
作为一个例子，以下是如何使用 Spring Data REST：
@Entity
public class Person {
@Id @GeneratedValue
private Long id;
private String firstName;
private String lastName;
// getters and setters...
}
@RepositoryRestResource(collectionResourceRel = "people", path = "people")
public interface PersonRepository extends PagingAndSortingRepository<Person, Long> {
List<Person> findByLastName(@Param("name") String name);
}
在上面的代码中，PersonRepository 使用 @RepositoryRestResource 自定义其导出的端点，而 findByLastName 方法将作为 /people/search/findByLastName?name= 的 HTTP GET 请求进行访问。
Spring Data REST 是一种快捷、便利的方式，用于快速搭建和拓展 REST 级的数据访问接口。如果你有更多问题或想深入了解 Spring Data REST，欢迎随时提问。
7、我们如何连接一个像 MySQL 或者Orcale 一样的外部数据库？
在Spring Boot应用中连接外部数据库（如MySQL或Oracle）通常需要以下步骤：
-
添加数据库驱动依赖：
首先，在项目的构建配置文件中（例如Maven的pom.xml或Gradle的build.gradle）添加相应的数据库驱动依赖。对于MySQL，Maven依赖如下：
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.23</version> </dependency>对于Oracle，Maven依赖如下：（注意Oracle驱动可能需要从Oracle的官方网站下载或者添加到私有仓库）
<dependency> <groupId>com.oracle</groupId> <artifactId>ojdbc8</artifactId> <version>19.3.0.0</version> </dependency> -
配置数据源：
接下来，需要在application.properties或application.yml配置文件中配置数据库连接的相关信息。对于MySQL，配置可能如下：
spring.datasource.url=jdbc:mysql://<host>:<port>/<database> spring.datasource.username=<username> spring.datasource.password=<password> spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver对于Oracle，配置可能如下：
spring.datasource.url=jdbc:oracle:thin:@<host>:<port>:<database> spring.datasource.username=<username> spring.datasource.password=<password> spring.datasource.driver-class-name=oracle.jdbc.OracleDriver -
自动配置或自定义配置：
这些配置信息使得Spring Boot可以自动配置数据源。如果需要，你也可以进一步自定义配置dataSource Bean，并设置连接池等参数。 -
使用JPA / Hibernate：
如果使用Spring Data JPA和Hibernate，通常还需要一些额外的配置。例如，如果使用Hibernate，则可以选择自动创建或更新Schema配置：spring.jpa.hibernate.ddl-auto=update -
启动类加上
@SpringBootApplication注解：
你的应用启动类应有@SpringBootApplication注解，它会触发自动配置，包括数据源配置等。@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } -
运行应用程序：
当应用启动时，Spring Boot 使用这些属性启动默认的数据源，并配置JdbcTemplate,EntityManagerFactory,TransactionManager等 bean，可以开始编写处理数据库交互的Repository接口或者使用JdbcTemplate。
这些步骤所示的配置和组件为Spring Boot应用程序的数据库交云提供了基础。
需要注意的是，对于商业数据库（如Oracle）, JDBC驱动可能不在公共Maven仓库中可用，可能需要手动安装到本地仓库或者添加到企业的私有仓库中。此外，确保遵守数据库驱动的许可协议，并正确配置连接池和事务管理以确保良好的性能和数据一致性。
8、保护 SpringBoot 应用有哪些方法？
保护 Spring Boot 应用程序涉及多个层面，包括代码安全、依赖管理、配置安全以及运行时的安全监控。以下是一些用于提高 Spring Boot 安全性的措施：
1. 使用 Spring Security
利用 Spring Boot 启动器 spring-boot-starter-security 集成 Spring Security，用于保护 Web 应用程序免受常见的安全威胁，如 XSS、CSRF、SQL 注入等。Spring Security 提供了一系列的安全特性，包括身份验证和授权、密码编码、会话管理等。
2. 限制访问
对应用程序的敏感内容和操作设置访问权限，确保只有认证并授权的用户才能访问。定义安全的角色和权限模型，限制对 API 和服务端点的访问。
3. 输入校验和数据清理
在应用级别进行输入校验，确保所有输入数据都经过验证，不含有潜在的恶意内容。使用强类型而非原始数据类型，并考虑采用白名单而不是黑名单进行有效性验证。
4. 安全的配置
- 不在代码或配置文件中硬编码敏感信息，如密码和私钥，而是使用环境变量或密钥管理服务。
- 正确配置
application.properties或application.yml文件中的参数，比如关闭应用程序的调试模式、生产环境中不使用默认端口、设置 HTTPS 等。
5. 保持依赖更新
使用像 Spring Boot Maven Plugin 这样的工具来保持应用程序使用的依赖是最新的，因为它们可能包含已经修复的安全漏洞。
6. 日志和审计
配置 Spring Boot 的日志记录以监控和记录所有重要操作和异常。考虑使用审计日志来跟踪用户活动和关键业务逻辑的执行。
7. 异常处理和错误页面
自定义错误响应和错误页面，不向用户暴露过多的系统信息，并准备好合适的异常处理逻辑。
8. 限制资源使用
设置合理的资源限制和配额来预防拒绝服务（DoS）攻击，比如限制上传文件的大小或表单提交的大小。
9. 评估安全工具和服务
考虑使用一些安全评估工具和服务，如 OWASP 依赖检查、SonarQube 或 Snyk，以帮助发现和修复潜在漏洞。
10. HTTPS 配置
通过 SSL/TLS 加密所有传入和传出的数据，配置 HTTPS 来加强数据传输安全。
11. 数据库安全
使用强密码、数据库加密和最小权限策略，预防数据库安全漏洞的出现。
12. 更新及补丁管理
定期更新系统和第三方库补丁，及时修复安全缺陷。
以上措施彼此并不独立，而是要整体考虑，以实现全面的安全策略。安全是一个持续的过程，需要定期复审和更新策略和实践方法，以保护应用程序和用户数据的安全。
9、创建一个 SpringBoot Project 的最简单的方法是什么？
创建一个Spring Boot项目的最简单和最快捷的方法通常是使用Spring Initializr工具。Spring Initializr是一个在线平台，它提供了一个简单的界面来快速生成Spring Boot项目的基本框架和配置。
以下是使用Spring Initializr创建Spring Boot项目的步骤：
-
打开Spring Initializr网站：start.spring.io
-
选择项目生成的一些基本选项，比如：
- 项目类型（Maven或Gradle）
- 所使用的语言（Java、Kotlin或Groovy）
- Spring Boot版本
- 项目的Group和Artifact ID
-
根据需要添加依赖 - Spring Initializr提供一个搜索框，您可以输入和选择不同的Spring Boot Starters和其他库，如Web、Security、Data JPA、Thymeleaf等。
-
点击“Generate”按钮，将会下载一个包含基础项目结构的ZIP文件。
-
解压ZIP文件，并使用您选择的Integrated Development Environment（IDE），例如IntelliJ IDEA、Eclipse或Visual Studio Code来导入项目。
-
开始编码 - 解压后的项目包含有Spring Boot应用程序的主类，以及
application.properties或application.yml配置文件。您可以开始添加Controller、Service、Repository等组件。
使用Spring Initializr的优点包括能够自定义项目配置、快速生成项目框架、自动添加依赖管理，并且支持集成到多种IDE及构建工具中。这种方法可以帮您节省配置Spring Boot项目所需的时间，并确保项目结构符合Spring Boot的最佳实践。
10、SpringBoot 打成的 jar 和普通的 jar 有什么区别 ?
Spring Boot 的 JAR 文件（通常称为 “可执行 JAR” 或 “独立 JAR”）与普通的 Java JAR 文件在结构和用途上有一些关键区别：
Spring Boot JAR:
-
独立运行：
Spring Boot JAR 文件是独立的，这意味着它们包含了运行 Spring Boot 应用程序所需的所有依赖项，包括内嵌的 Servlet 容器（如 Tomcat、Jetty 或 Undertow）。 -
特殊的布局：
可执行 JAR 遵循 Spring Boot 的特定布局，它们有一个内嵌的 JAR 加载器和一个 ‘lib/’ 文件夹，用于存储应用程序的所有库依赖。 -
启动器类：
通常包含一个带有main()方法的启动器类，该类被标记为@SpringBootApplication，以便作为独立应用程序的入口点。 -
使用 Spring Boot Maven 或 Gradle 插件创建：
可执行 JAR 通常是使用 Spring Boot Maven 插件或 Gradle 插件来构建的，这两个插件会自动处理包含依赖项和配置内嵌容器的任务。 -
扩展性：
可执行 JAR 可以通过命令行参数、外部配置文件或环境变量传递的配置进行自定义。
普通 JAR:
-
库依赖：
普通的 JAR 文件可能只包含通用的 Java 类库，通常不包含运行应用程序所需的所有依赖。 -
标准布局：
遵循 Maven 或 Gradle 的标准 JAR 布局，通常没有内嵌的 JAR 加载器。 -
非独立运行：
为了运行普通的 JAR 文件，你通常需要设置类路径（classpath）并包含所有必要的依赖库。 -
不包含内嵌容器：
普通的 JAR 文件通常不包括内嵌的 Servlet 容器，它们通常需要部署到 Java EE 应用服务器（如 Tomcat、WebLogic 或 JBoss）中。 -
通用构建工具创建：
使用标准的 Mavenjar插件或 Gradlejar任务生成，没有特别为独立运行配置。
总结来说，Spring Boot 的 JAR 文件是专门设计为 “即开即用” 的，它可以简化部署和开发流程。你可以直接使用 java -jar 命令运行应用程序，而无需额外的应用服务器。而普通的 JAR 文件则可能只是类库集合或需要额外步骤来执行。如果您有关于 Spring Boot JAR 文件或其他相关问题，请随时提问。
11、SpringBoot 支持哪些日志框架？推荐和默认的日志框架是哪个？
Spring Boot 支持多种日志框架，并提供了自动配置来简化这些框架的使用。Spring Boot 的推荐和默认日志框架是以下组合：
-
SLF4J（Simple Logging Facade for Java）：它不是日志实现，而是一个抽象层（门面），允许开发者在后端使用不同的日志框架。
-
Logback：由SLF4J的创造者创建的日志框架，提供了快速的日志记录实现。Spring Boot 使用Logback作为默认日志实现，并且已经为其提供了基本配置。
虽然Spring Boot 推荐使用SLF4J与Logback的组合，但你可以根据需求替换成其他日志库，如 Log4j2 或 Java Util Logging (JUL)。下面是Spring Boot支持的部分日志框架：
-
Logback：默认日志框架，包含在
spring-boot-starter-logging中，Spring Boot为其提供了默认配置。 -
Log4j2：使用Log4j2也很流行，这需要排除Logback并添加Log4j2依赖。
-
Java Util Logging (JUL)：虽然没有像Logback和Log4j2那样流行，但如果你想使用它，同样可以通过依赖配置和Spring Boot的日志框架抽象来实现。
要切换到其他日志框架，通常你需要做以下操作：
-
排除
spring-boot-starter-logging依赖。 -
添加对应的Spring Boot starter（例如
spring-boot-starter-log4j2），以及日志框架依赖。 -
在你的
application.properties或application.yml中配置日志框架的设置。
例如，如果选择使用 Log4j2 作为日志框架，你会在pom.xml中进行类似如下的配置：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<!-- 排除Logback，因为要用Log4j2 -->
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- 添加Log4j2 starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>
</dependencies>
选择使用哪个日志框架，主要取决于个人或团队的喜好、项目的要求，以及是否需要框架特定的高级功能。
12、SpringBoot性能如何优化
Spring Boot 应用的性能优化涉及到多个方面，包括代码级别的调整、系统配置和外部依赖的优化等。以下是一些可以提高 Spring Boot 应用性能的策略：
1. 代码优化
- 合理使用Bean的作用域：例如，减少
prototype作用域 Bean 的使用，因为每次注入时都会创建一个新实例。 - 减少自动装配的复杂性：尽量减少
@Autowired使用数量，使用构造器注入而不是字段注入。 - 优化算法和逻辑：使用更高效的数据结构与算法，并尽量减少不必要的计算。
2. 数据访问与数据库优化
- 数据库连接池调优：合理配置连接池参数，比如
maximumPoolSize、minimumIdle等。 - 使用 JPA/Hibernate 性能最佳实践：使用
Lazy加载策略、合理使用缓存、使用批处理操作等。 - 优化数据库查询：确保妥善使用索引以减少查询时间，避免 N+1 查询问题。
3. 应用配置
- 异步处理：使用异步方法处理耗时的操作，如使用
@Async注解。 - 调整线程池：定制
TaskExecutor或 Servlet 容器的线程池，调整线程数量根据系统能力合理分配。 - 缓存应用：利用缓存机制如
@Cacheable以存储常用数据。
4. 响应式编程
- 使用响应式框架：对于 I/O 密集型操作或高并发场景，使用响应式编程模型 (如 WebFlux) 替代传统的 Servlet 模型。
5. HTTP 请求优化
- 压缩HTTP响应：启用 GZIP 压缩来减小传送数据的大小。
- 使用Web包的最佳实践：使用 RESTful 标准、无状态的应用设计。
6. 应用服务器调优
- 调整 Java 虚拟机（JVM）设置：优化 JVM 启动参数，比如堆大小 (
-Xmx/-Xms)，垃圾回收器选择和配置。 - 服务器配置：根据需要调整内嵌服务器的配置，比如 Tomcat、Jetty 或 Undertow。
7. 资源压缩和合并
- 静态资源处理：压缩、合并 JS、CSS 文件，并实现版本控制策略。
8. 性能监控和分析
- 监控应用性能：利用 Actuator、Micrometer 以及外部监控系统如 Prometheus、Graphana。
- 应用分析：使用 JProfiler、VisualVM、YourKit 等工具定期进行性能分析。
9. 微服务和分布式系统
- 服务拆分：使用微服务架构分离关注点，提供更好的服务水平目标。
- 负载均衡：提供负载均衡来分散请求压力。
10. 安全优化
- 减少安全检查的复杂性：为不同的端点灵活配置安全层级，避免过度的安全机制影响性能。
通过以上多维度的优化策略，可以显著提升 Spring Boot 应用的性能。需要注意的是，性能优化应该根据实际的性能指标和需求来进行，不必过早优化，避免引入不必要的复杂性。性能测试和监控对于发现性能瓶颈和优化点至关重要。
SpringBoot最新面试题(11)
1、什么是 SpringBoot Stater ？
Spring Boot Starter是Spring Boot的一组便利的依赖描述符，可以用于应用程序中，以确保需要的依赖关系被统一管理和自动配置。每个Starter POM（Project Object Model）都旨在简化Maven配置并提供必要的库来开发特定类型的应用程序。
Starter通常遵循spring-boot-starter-*命名模式，它们帮助自动配置Spring上下文，并将与特定技术（如数据库、安全、消息传递等）相关的所有依赖项组合在一起。使用Starter可以大大简化添加和管理项目依赖项的过程。
一些常用的Spring Boot Starter包括：
- spring-boot-starter：核心Starter，包括自动配置支持、日志和YAML加载功能。
- spring-boot-starter-web：用于构建Web应用的Starter，包括Spring MVC、REST以及默认的Tomcat容器。
- spring-boot-starter-data-jpa：包括使用Spring Data JPA访问数据库的必要依赖项。
- spring-boot-starter-security：提供Spring Security的依赖，用于认证和授权。
- spring-boot-starter-test：测试相关的依赖，包括JUnit、Spring Test & MockMvc、AssertJ等。
使用Spring Boot Starter时，基本上只需要在build.gradle或pom.xml中添加对应的Starter依赖项，无需担心其中具体的库的版本。Spring Boot的自动配置机制会处理其余的配置和设置。
例如，在Maven项目中添加Spring Boot web支持的dependency代码如下所示：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
通过使用这种方式，Spring Boot降低了初始学习曲线，并使基于Spring的开发变得更加容易和快捷。开发人员可以专注于他们的应用逻辑而不是花费太多时间在配置和管理项目依赖项上。
2、SpringBoot多数据源事务如何管理
在 Spring Boot 中管理多数据源事务通常涉及配置多个数据源和对应的事务管理器，并在业务逻辑中使用正确的事务管理器来确保事务的一致性。这里是如何设置和使用多数据源事务的概述：
配置多个数据源
首先，你需要在你的配置类中设置多个数据源。你可以为每个数据源定义一个 @Bean，并且可能需要为主数据源使用 @Primary 注解。例如：
@Configuration
public class DataSourceConfig {
@Bean
@Primary
@ConfigurationProperties("app.datasource.primary")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties("app.datasource.secondary")
public DataSource secondaryDataSource() {
return DataSourceBuilder.create().build();
}
}
创建相应的事务管理器
为每个数据源创建一个 PlatformTransactionManager 的 @Bean。你可能需要为主数据源的事务管理器使用 @Primary 注解。例如：
@Configuration
@EnableTransactionManagement
public class TransactionManagerConfig {
@Bean
@Primary
public PlatformTransactionManager primaryTransactionManager(
@Qualifier("primaryDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
@Bean
public PlatformTransactionManager secondaryTransactionManager(
@Qualifier("secondaryDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
}
在服务中指定事务管理器
当你调用涉及数据库操作的服务方法时，如果这些方法需要事务支持，你可以通过 @Transactional 注解指定要使用的事务管理器。例如：
@Service
public class MyService {
@Transactional(transactionManager = "primaryTransactionManager")
public void somePrimaryDbOperation() {
// 逻辑代码，使用主数据源
}
@Transactional(transactionManager = "secondaryTransactionManager")
public void someSecondaryDbOperation() {
// 逻辑代码，使用次要数据源
}
}
注意事项
-
分布式事务：如果一个业务方法中涉及到多个数据库资源的操作，并且需要它们处于同一个事务中，你可能需要使用分布式事务。这通常涉及到 JTA 事务管理器的使用，这在 Spring Boot 项目中可通过集成像 Atomikos 或 Narayana 这样的事务管理器实现。
-
事务传播行为：在使用
@Transactional注解时，要注意事务的传播行为，特别是当在事务方法中调用其他事务方法时。 -
基于 JPA 使用事务管理器：如果你使用 JPA，为每个
EntityManagerFactory创建对应的JpaTransactionManager。 -
本地事务 vs 分布式事务：对于本地事务来说，使用多个单独的
DataSourceTransactionManager通常足够。对于分布式事务则需要使用 JTA 事务管理器。 -
性能和复杂性：分布式事务相对于本地事务更加复杂，也可能引入性能开销。特别在微服务架构中，它可能造成管理上的困难，这时候可以考虑使用 Saga 模式来管理分布式业务流程。
使用 Spring Boot 管理多数据源事务需要注意确保配置正确，同时遵守事务管理的最佳实践，确保数据的一致性和完整性。如果有任何疑问或困难，请随时提出。
3、spring boot扫描流程?
Spring Boot的扫描流程主要涉及两个方面：类路径扫描和自动配置。下面是基本扫描流程的步骤概述：
-
启动类注解:
Spring Boot应用通常有一个带有@SpringBootApplication注解的启动类。这个注解是一个方便的注解，它结合了以下三个注解的功能：@SpringBootConfiguration：标记主配置类，别名为@Configuration。@EnableAutoConfiguration：启动Spring Boot的自动配置机制。@ComponentScan：指定Spring去哪些包下寻找带@Component及其衍生注解如@Service,@Controller,@Repository的类。
-
类路径扫描:
启动过程中，Spring Boot使用@ComponentScan注解来查找所有标记为@Component的类，包括@Service,@Controller,@Repository等，然后注册它们作为ApplicationContext中的Bean。@ComponentScan默认扫描启动类所在的包以及它的子包。 -
自动配置:
@EnableAutoConfiguration告诉Spring Boot根据类路径中的jar依赖项、已定义的Bean以及各种属性设置来猜测需要什么配置并执行配置。这是通过@Import(EnableAutoConfigurationImportSelector.class)实现的，Spring Boot会评估META-INF/spring.factories中列出的配置类。 -
条件注解:
自动配置类使用条件注解如@ConditionalOnClass,@ConditionalOnMissingBean来确定何时启用。如果条件满足，则自动配置类中声明的Bean被添加到上下文中。 -
配置属性:
自动配置类还可以使用@ConfigurationProperties注解映射配置文件（如application.properties或application.yml）里的属性到Bean的字段上。 -
外部文件:
Spring Boot配置也可以从命令行参数、系统属性、环境变量、YAML、properties文件等地方获取。这些外部配置属性在决定自动配置的行为时也会被考虑。 -
ApplicationContext初始化:
最后，上下文初始化完成后，所有的单例Bean被预实例化。在这个阶段，如果有任何Bean创建失败，错误会导致应用启动失败。成功的话，Spring Boot应用就准备好了响应请求。
以上就是Spring Boot启动时进行类路径扫描和自动配置的简化流程。除了上述默认的类路径扫描和自动配置之外，Spring Boot还允许开发者通过自定义@Import注解导入额外的配置类，或者显示声明需要注册的Bean来进一步控制配置过程。
4、如何使用 SpringBoot 生成一个 WAR 文件？
要使用 Spring Boot 生成一个可部署的 WAR 文件，主要分为以下几个步骤：
1. 更新 pom.xml 配置
首先，需要更改你的 Maven pom.xml 文件以包含 WAR 包的打包方式，并添加合适的依赖项。
- 将
<packaging>元素的值从jar更改为war：
<packaging>war</packaging>
- 排除 Spring Boot 的内置 Tomcat 服务器依赖，因为你将使用外部的 Servlet 容器或应用服务器：
<dependencies>
<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>
<!-- 添加提供 API 依赖，用于编译时提供 Servlet、JSP 等 Java EE API -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
2. 修改 Spring Boot 启动类
更新你的 Spring Boot 启动类来扩展 SpringBootServletInitializer，这将允许 Spring Boot 应用程序在外部的 Servlet 容器中启动。
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
public class MyApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(MyApplication.class);
}
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
3. 构建 WAR 文件
使用 Maven 命令行工具构建项目，并生成 WAR 文件：
mvn clean package
或如果使用 Gradle，则运行：
gradle clean build
构建完成后，你会在 target 目录（Maven）或 build/libs 目录（Gradle）下找到生成的 WAR 文件。
4. 部署 WAR 文件
将生成的 WAR 文件部署到你的 Servlet 容器或应用服务器中（例如 Tomcat、Jetty、WildFly 等）。
这些步骤完成了 Spring Boot 应用转变为 WAR 文件的过程，使得你可以将其部署到任何遵循 Servlet 规范的外部容器中。使用 WAR 文件部署是传统 Java EE 应用的常用方法，即使在容器和云原生时代，它依然适用于某些需要部署到外部服务器的场景。
5、JPA 和 Hibernate 有哪些区别？
JPA（Java Persistence API）和Hibernate之间的主要区别在于他们各自所处的层面和提供的功能。以下详细解释了他们之间的区别：
JPA：
- 规范：JPA是Java持久化的规范，它定义了对象关系映射（ORM）和数据持久化的标准API。它是一种规范，意味着它提供了一套标准的接口、注解和XML配置。
- 实现独立性：JPA作为规范，需要有具体实现。这意味着，任何符合JPA规范的ORM框架都可以使用这个API。
- Query Language：JPA包括一个查询语言，称为JPQL（Java Persistence Query Language），用于处理数据库的CRUD操作。
- 交互性：JPA规范实现了与不同数据库供应商的交互性，这让开发者可以切换底层数据库而不需要修改数据访问代码。
Hibernate：
- 某一个JPA的实现：Hibernate是JPA规范的一个实现。提供了JPA中描述的所有功能及额外的特性。
- 独立框架：尽管Hibernate实现了JPA规范，但它是在JPA出现前已经存在的，并且不仅仅局限于JPA规范所定义的范围内。
- 丰富的功能：Hibernate提供比JPA规范更丰富的功能，如方言支持、二级缓存、提供了独特的Criteria/Example查询、过滤器以及拦截器特性等。
- Query Language：Hibernate有自己的查询语言叫HQL（Hibernate Query Language）。同时Hibernate也支持原生SQL和JPQL。
总结来说，JPA为ORM提供了一种标准化的方法，而Hibernate是这一规范的具体实现，并提供了超出标准的额外特性。使用JPA可以让你的应用程序更容易迁移到不同的JPA实现（Hibernate只是其中之一），而Hibernate则是一个成熟且功能丰富的ORM解决方案。在决定哪一个使用时，通常考虑到应用程序特定需求、团队熟悉度以及项目对ORM功能的特定要求。
6、当 SpringBoot 应用程序作为 Java 应用程序运行时，后台会发生什么？
当一个 Spring Boot 应用程序作为 Java 应用程序运行时，会经历一个启动和初始化的过程，期间执行了一系列操作，确保了应用程序的依赖注入、配置和启动。以下是从命令行（或通过 IDE）使用 java -jar 命令运行 Spring Boot JAR 文件时会发生的主要步骤：
-
启动 JVM：
使用指定的 JAR 文件和其他 JVM 参数，JVM 被启动。 -
加载主类和启动器：
JAR 文件的META-INF/MANIFEST.MF中指定了主类（Main-Class），JVM 加载并执行主类中的main()方法。 -
启动 Spring 应用上下文：
Spring Boot 的SpringApplication.run()方法被调用，创建一个 Spring 应用上下文（ApplicationContext）。 -
应用自动配置：
Spring Boot 自动配置机制被触发。根据类路径中的类、Bean 定义、配置文件中的属性来自动配置 Bean。 -
初始化嵌入式 Web 服务器：
如果是 Web 应用，内嵌的 Web 服务器（如 Tomcat、Jetty 或 Undertow）被初始化。 -
环境准备：
Environment相关的 Bean 被准备好，并且被用于读取应用配置。 -
注册和执行 Bean：
配置类、组件（@Component）、服务（@Service）、存储库（@Repository）等注册为 Spring Beans，并根据依赖注入的需要进行初始化。 -
执行数据库迁移（如有配置）：
如果配置了数据库、并且集成了诸如 Flyway 或 Liquibase 之类的数据库迁移工具，相关迁移脚本会被执行。 -
处理额外配置：
执行任何CommandLineRunner或ApplicationRunnerbeans，它们提供了运行初始化逻辑的方式。 -
初始化应用监听器和事件：
处理各种 Spring 事件，包括ApplicationStartedEvent、ApplicationReadyEvent等。 -
应用准备就绪：
一旦完成上述所有步骤，应用进入服务状态，等待接受请求或进行任务处理。 -
健康检查：
一些监控系统可能已启动并开始运行，如 Spring Boot Actuator 提供的健康检查。
在整个过程中，Spring Boot 使用了 “约定优于配置” 的策略来减少必要的配置，同时仍然提供了丰富的扩展和定制选项。开发者可以通过添加自定义配置或代码来更改和增强启动过程的任何部分。
这就是 Spring Boot 应用程序作为 Java 应用程序运行时后台所发生的事情的概览。如果您对这个过程有任何疑问或需要更详细的解释，请随时提问。
7、你能否举一个以 ReadOnly 为事务管理的例子？
在Spring框架中，你可以通过@Transactional注解来声明事务管理。设置readOnly属性为true时，你可以表示一个事务只读，这个特性通常用于优化查询操作。以下是一个使用readOnly=true的@Transactional例子：
首先，确保你的Spring Boot项目具备Spring Data和数据库相关的依赖，如JPA或MyBatis。
以下是一个使用Spring Data JPA的例子：
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface MyDataRepository extends JpaRepository<MyEntity, Long> {
// 省略其他方法声明
}
在你的服务层（Service Layer），指定一个方法为只读事务：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class MyDataService {
private final MyDataRepository repository;
@Autowired
public MyDataService(MyDataRepository repository) {
this.repository = repository;
}
@Transactional(readOnly = true) // 声明这是只读事务
public List<MyEntity> findAll() {
// 这里的操作应只涉及到数据读取，没有修改
return repository.findAll();
}
}
readOnly = true属性对于告诉数据库这个事务不会进行任何修改是有好处的，数据库可以利用这一点进行性能优化，如减少锁的使用。数据库和ORM框架可能会采取额外措施，提供更快的查询速度。
对于其他操作，比如添加、更新或删除数据，你应使用默认的readOnly = false属性：
@Transactional
public void save(MyEntity newData) {
repository.save(newData);
}
请注意，@Transactional注解可以用于服务层类的方法，也可以直接用于类本身。在类层级使用会应用于类中的所有公共方法。可以通过方法层级的@Transactional注解来覆盖类层级的设置。
确保你已经在你的配置中启用了事务管理，对于Spring Boot来说通常会自动配置，如果使用Java配置则可能看起来像这样：
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@EnableTransactionManagement
public class DataServiceConfig {
// 你的配置细节，如DataSource、EntityManagerFactory、TransactionManager等
}
在Spring Boot项目中，如果添加了如spring-boot-starter-data-jpa等启动器，通常会自动启用JPA事务管理。
8、spring boot监听器流程?
Spring Boot 中的监听器是指那些监听和响应应用生命周期事件的组件。这些监听器可以基于 Spring Framework 的事件发布和订阅模式来实现。
Spring 应用上下文的刷新和启动过程中会发布多个核心事件，监听器可以在这些关键时刻执行自定义逻辑。Spring Boot 使得监听和处理这些事件变得更加容易。
以下是 Spring Boot 应用中常见的事件监听器及其流程：
1. 实现事件监听器
监听器可以实现 ApplicationListener 接口或使用 @EventListener 注解来定义。
使用 ApplicationListener 接口：
import org.springframework.context.ApplicationListener;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.stereotype.Component;
@Component
public class MyApplicationListener implements ApplicationListener<ApplicationReadyEvent> {
@Override
public void onApplicationEvent(ApplicationReadyEvent event) {
// 应用已准备好且处于运行状态时的逻辑
}
}
使用 @EventListener 注解：
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
@Component
public class MyEventHandler {
@EventListener
public void handleEvent(ApplicationReadyEvent event) {
// 应用已准备好且处于运行状态时的逻辑
}
}
2. Spring Boot 事件流程
Spring Boot 应用在启动过程中按顺序触发了多个事件：
ApplicationStartingEvent：在运行SpringApplication.run()时尽早发布。ApplicationEnvironmentPreparedEvent：当已知SpringApplication要使用的Environment时发布，但在创建ApplicationContext之前。ApplicationContextInitializedEvent：在ApplicationContext已准备并且ApplicationContextInitializers已调用但在加载任何 bean 之前发布。ApplicationPreparedEvent：在刷新ApplicationContext之前但在加载 bean 定义之后发布。ApplicationStartedEvent：在ApplicationContext刷新且所有应用和命令行运行监听器被调用之后发布。ApplicationReadyEvent：在任何应用程序和命令行运行器调用之后，表示应用已准备好接收请求。ApplicationFailedEvent：在启动时发生异常时发布。
3. 使用 Spring Boot 应用事件
你可以使用这些事件来执行自定义的启动逻辑，清理资源，或者检查应用配置。事件监听器也用于处理非核心业务逻辑，比如发送通知、收集统计数据等。
总的来说，Spring Boot 的监听器机制提供了一种高效且解耦的方式来监听和响应应用程序生命期的关键事件。通过实现 ApplicationListener 接口或使用 @EventListener 注解，你可以在 Spring Boot 应用的生命周期内的任何点做出反应，并且执行所需的逻辑处理。
9、SpringBoot常用的starter有哪些？
Spring Boot提供了许多“starter”依赖项来简化构建配置和自动配置应用程序所需的库。每个starter都是一个预先配置的集合，包含了所有必须的依赖项，让开发者可以很容易地添加所需的功能。以下是一些常用的Spring Boot Stater：
核心Starters：
- spring-boot-starter：核心starter，包括自动配置支持、日志库和YAML。
- spring-boot-starter-logging：日志starter，包含对常见日志框架的支持。
Web应用相关Starters：
- spring-boot-starter-web：用于构建基于Spring MVC的web应用程序，包括RESTful应用程序，使用Tomcat作为默认的嵌入式容器。
- spring-boot-starter-websocket：用于构建WebSocket交互的web应用程序。
数据访问Starters：
- spring-boot-starter-data-jpa：包含Spring Data JPA，使用Hibernate作为默认JPA提供者。
- spring-boot-starter-jdbc：使用Spring JDBC访问数据库的starter。
- spring-boot-starter-data-redis：用于访问redis键-值存储的starter。
- spring-boot-starter-data-mongodb：用于访问MongoDB NoSQL数据库的starter。
- spring-boot-starter-data-elasticsearch：用于连接Elasticsearch搜索引擎的starter。
技术整合Starters：
- spring-boot-starter-security：包含Spring Security。
- spring-boot-starter-cache：提供缓存支持，包括使用JCache的实现。
- spring-boot-starter-actuator：包含Spring Boot的Actuator模块，用于应用监控和管理。
- spring-boot-starter-mail：用于支持发送电子邮件。
测试Starters：
- spring-boot-starter-test：包括常用的测试依赖，如JUnit、Spring Test、AssertJ、Hamcrest和Mockito。
消息传递Starters：
- spring-boot-starter-amqp：通过RabbitMQ提供的高级消息队列协议（AMQP）支持消息传递。
- spring-boot-starter-kafka：包含访问Apache Kafka消息代理的库。
除了这些普遍使用的Starters，Spring Boot还提供了许多特定于技术的starter（如Batch、Integration、Cloud等），以及其他Starters，对于特定需求可能也很有用。这些预置的配置大大简化了依赖项管理并加速了开发过程。
10、为什么我们不建议在实际的应用程序中使用 Spring Data Rest?
Spring Data REST 是一个强大的库，它自动将 Spring Data 存储库公开为 RESTful API。虽然这在快速原型开发和简单应用中非常有用，但在实际应用程序中可能不建议使用 Spring Data REST 的原因如下：
-
细粒度控制缺失：
自动暴露的端点可能不会符合你对 API 设计的具体要求。你可能需要更多控制来定义 URI 结构、HTTP 状态代码和响应格式。 -
业务逻辑限制：
Spring Data REST 主要是为 CRUD 操作设计。实际应用通常包含复杂的业务逻辑，这些逻辑可能需要自定义控制器层来管理。 -
安全性缺陷：
如果不当配置，Spring Data REST 可能会无意中暴露敏感数据或者关联，导致安全漏洞。 -
缺乏 API 版本控制：
对于需要维护 API 版本的应用程序，Spring Data REST 不提供内建的版本控制支持。 -
定制化限制：
虽然 Spring Data REST 提供了一些定制化的钩子，但定制化能力有限，特别是与请求前后处理，以及细粒度风险控制相关时。 -
API 文档与测试：
对于自动生成的端点，可能需要手动编写额外的文档和测试，这增加了工作量。 -
性能问题：
自动生成的请求处理流程可能不是针对性能优化的。在高性能要求下，自定义的解决方案可能更合适。 -
客户端依赖性：
使用 Spring Data REST 可能意味着前端需要依赖特定的 API 结构和行为。随着业务需求的变化，这种紧密耦合可能变得难以维护。
在决定是否在生产应用中使用 Spring Data REST 之前，重要的是要评估应用中的具体场景和约束。你可能会发现，编写自定义的 REST 控制器层能够为你提供更多的灵活性，允许你精细地控制数据的输入和输出以及相应的处理逻辑。
在包含敏感数据、复杂业务逻辑或高性能要求的实际应用程序中特别需要慎重使用 Spring Data REST。如果你有关于 Spring Data REST 或构建 RESTful API 的其他问题，请随时提问。
11、SpringBoot支持什么前端模板
Spring Boot支持多种前端模板引擎，可帮助在服务器端生成HTML格式的内容。以下是Spring Boot支持的一些常见前端模板引擎：
-
Thymeleaf：
- Thymeleaf是与Spring集成度极高的现代服务器端Java模板引擎，非常适合Web应用。它提供了Spring标准方言和Spring数据绑定支持，并且可以与Spring Security集成。
-
Mustache：
- Mustache是一个逻辑-less模板引擎，意味着模板本身不包含逻辑，它避免了混入太多逻辑可能引起的复杂性。在Spring Boot中使用Mustache是通过添加对应的Starter实现的。
-
FreeMarker：
- FreeMarker是一种模板引擎，它基于模板来生成文本输出，常用于生成HTML网页。除HTML格式外，FreeMarker也可以输出任意基于文本的格式。
-
Groovy Templates：
- Groovy模板引擎是一种基于Apache Groovy语言的替代方案。它非常灵活，并且由于是基于Groovy的，因此对于Groovy语言很友好。
-
JSP：
- Java Server Pages（JSP）曾是传统的Java EE应用中常用的模板技术，但在Spring Boot中，建议使用Thymeleaf而不是JSP，因为Spring Boot对JSP支持有限，并且在嵌入式Servlet容器中使用JSP可能会出现问题。
为了使用这些模板引擎，你需要在Spring Boot项目的pom.xml文件中添加相应的依赖。以Thymeleaf为例，相应的Starter依赖如下：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
添加依赖后，你可以创建模板文件（例如，Thymeleaf的.html），然后在控制器中使用它们，如下所示：
@Controller
public class MyController {
@GetMapping("/")
public String index(Model model) {
model.addAttribute("message", "Hello, Thymeleaf!");
return "index";
}
}
在前端模板引擎选择上，建议根据你团队的技能、偏好和项目需求来选择最适合的方案。Thymeleaf因为其与Spring的紧密集成和天然的支持，通常是Spring Boot项目的首选模板引擎。
SpringBoot最新面试题(10)
1、SpringBoot多数据源拆分的思路
在Spring Boot应用程序中使用多数据源通常意味着你需要配置并管理超过一个数据库连接。这在一些场景下是必要的，例如，当你的应用需要访问两个完全不同的数据库，或者你需要将读操作和写操作分离到不同的数据源时。
以下是实现Spring Boot多数据源拆分的一般思路：
1. 定义多个数据源配置
首先，你需要在application.properties或application.yml文件中定义两个或更多不同的数据源配置。
spring:
datasource:
primary:
url: jdbc:mysql://localhost:3306/db_primary
username: user_primary
password: pass_primary
driver-class-name: com.mysql.cj.jdbc.Driver
secondary:
url: jdbc:mysql://localhost:3306/db_secondary
username: user_secondary
password: pass_secondary
driver-class-name: com.mysql.cj.jdbc.Driver
2. 创建数据源配置Beans
在你的配置类中，你需要为每个数据源创建一个DataSource类型的Bean，并使用@Configuration和@Primary（对主要数据源）注解。
@Configuration
public class DataSourceConfig {
@Bean
@Primary
@ConfigurationProperties("spring.datasource.primary")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties("spring.datasource.secondary")
public DataSource secondaryDataSource() {
return DataSourceBuilder.create().build();
}
}
你还可能需要创建特定的EntityManagerFactory和TransactionManager。
3. 配置JPA或MyBatis等ORM框架
你需要为每个数据源配置适当的ORM框架支持。以JPA为例，这可能意味着为每个数据源创建不同的EntityManagerFactory和TransactionManagerBeans，并将它们指向相对应的数据源。
@Bean
@Primary
public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(
EntityManagerFactoryBuilder builder, @Qualifier("primaryDataSource") DataSource dataSource) {
return builder
.dataSource(dataSource)
.packages("com.example.domain.primary")
.build();
}
@Bean
public LocalContainerEntityManagerFactoryBean secondaryEntityManagerFactory(
EntityManagerFactoryBuilder builder, @Qualifier("secondaryDataSource") DataSource dataSource) {
return builder
.dataSource(dataSource)
.packages("com.example.domain.secondary")
.build();
}
4. 分离Repositories
你可能需要区分用于每个数据源的Repositories或DAOs。你可以使用@Repository并指定使用的EntityManager。
5. 使用@Qualifier注解
在服务层，使用@Qualifier注解确保正确注入对应数据源的Repository或Service。
6. 控制事务
你可能需要定义事务配置以确保事务是在正确的数据源上进行管理。可以使用@Transactional注解并指定管理事务的TransactionManager。
通过以上步骤，你可以搭建一个多数据源的Spring Boot应用，允许你按需访问不同的数据库实例或集群。这种多数据源的配置高度灵活但也较为复杂，因此要仔细测试以确保配置正确并且彼此隔离。
2、前后端分离，如何维护接口文档 ?
在前后端分离的架构中，维护 API 文档是确保前后端开发者有效沟通的关键。以下是维护接口文档的一些常用方法：
-
Swagger/OpenAPI：
OpenAPI（原称 Swagger）规范是一种在整个 API 生命周期中设计、构建、测试和文档化 RESTful API 的标准方式。- 使用 Swagger UI，可以提供一个交互性的文档，使得开发者可以探索、测试 API。
- Spring Boot 应用中可用 Springfox 或 Springdoc OpenAPI 集成 OpenAPI 3，以自动生成并提供 API 文档。
-
Apiary：
Apiary 提供了一个在线平台，能帮助设计文档并提供 API 交互界面，通常是基于 API Blueprint 或 Swagger。 -
Postman：
Postman 是一个 API 开发工具，它允许开发者创建和保存简单到复杂的 HTTP/s 请求，并查看响应。它也提供了 API 文档功能，可以分享和发布 API 文档。 -
Read the Docs：
Read the Docs 允许你利用 Sphinx 自动生成文档。你可以在源代码旁写文档，并通过 Git 钩子自动更新文档。 -
Markdown/AsciiDoc：
对于简单的 API 或小型项目，手动编写文档（使用 Markdown 或 AsciiDoc）是一个简单的解决方案，但需要人工维护以保持最新状态。 -
Git 版本控制：
使用版本控制系统（如 Git）来维护和追踪 API 文档的变更历史。文档可以和代码在同一仓库中管理，以确保文档和实际代码的一致性。 -
自动化测试生成文档：
通过自动测试（比如使用 Dredd、Spring REST Docs）来确保文档与实际 API 行为一致，有的工具可以直接从测试用例生成文档。 -
公司内网/知识库平台：
企业内部可能拥有文档管理系统或内部知识库平台，也可以用来编写和分享 API 文档。 -
版本控制文档：
每当 API 更改时，应该更新文档，并明确标注 API 的当前版本和变更历史。 -
团队协作工具：
结合使用像 Confluence 这样的团队协作工具，确保文档的实时共享和团队成员之间的交流。 -
API 管理平台：
使用像 Azure API Management、Amazon API Gateway 或 Google Cloud Endpoints 这样的云平台服务来托管和维护 API 文档。
确保 API 文档的准确性和及时更新是非常重要的，它可以促进前后端的协作，并防止潜在的误解和错误。如果你有更多关于 API 文档或相关问题，请随时提问。
3、什么是 Spring Data？
Spring Data是Spring框架下的一个子项目，目的在于简化数据访问层（Data Access Layer）的代码。Spring Data提供了一个统一的编程模型，用于支持对不同种类数据访问技术的处理，包括关系型数据库和非关系型数据库。
Spring Data的一些主要功能和特性包括：
-
统一的数据访问模型：
提供了一组与数据访问技术无关的编程抽象，让你可以使用一致的方法来访问不同的数据源。 -
减少样板代码：
Spring Data的核心是其Repository接口，它可以自动实现对数据库的基础CRUD（创建、读取、更新、删除）操作，减少重复和样板代码。 -
查询派生：
支持从方法名自动派生查询，只需按一定的命名规则编写接口方法，Spring Data就可以自动创建查询实现。 -
自定义查询方法：
提供了使用@Query注解来定义自定义查询的能力，使得可以编写JPQL、JPA Criteria API 或特定数据库的原生SQL查询。 -
声明式事务管理：
通过@Transaction注解提供声明式事务支持，使事务管理变得更为简单。 -
多种数据库支持：
Spring Data为多种数据库提供了专门的支持，包括但不限于：- Spring Data JPA：用于支持JPA的关系型数据库。
- Spring Data MongoDB：用于文档数据库MongoDB。
- Spring Data Redis：用于键值存储Redis。
- Spring Data Cassandra：用于列式存储Cassandra。
- Spring Data Elasticsearch：用于搜索引擎Elasticsearch。
下面是一个使用Spring Data JPA创建Repository接口的例子：
public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByLastName(String lastName); // 从方法名派生查询
@Query("from User u where u.emailAddress = ?1") // 定义使用JPQL的自定义查询
User findByEmailAddress(String emailAddress);
}
使用Spring Data可以大大简化数据访问层的开发工作，提高开发效率并减少出错的可能性。它与Spring框架的其它项目（如Spring MVC、Spring Security等）无缝整合，使得开发者可以更加专注于业务逻辑的实现。
4、SpringBoot如何实现打包
在 Spring Boot 中打包应用程序通常是指将应用程序构建为一个可执行的 JAR 或 WAR 文件，以便可以容易地分发和部署。Spring Boot 使用 Maven 或 Gradle 作为其构建工具，并且利用 Spring Boot Maven 插件或 Spring Boot Gradle 插件来简化打包流程。
以下是使用 Maven 和 Gradle 分别实现 Spring Boot 应用程序打包的步骤：
使用 Maven 打包
- 确保
pom.xml中包含 Spring Boot Maven 插件：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
- 执行 Maven 打包命令：
mvn package
Maven 将在 target 目录下生成一个可执行的 JAR 文件，包含了所有必要的依赖项和资源。
如果你需要打包为 WAR 文件，需要设置 pom.xml 中的 <packaging> 为 war。
使用 Gradle 打包
- 在
build.gradle中应用 Spring Boot Gradle 插件：
plugins {
id 'org.springframework.boot' version '2.3.1.RELEASE'
id 'io.spring.dependency-management' version '1.0.9.RELEASE'
}
- 执行 Gradle 打包命令：
gradle build
或者，如果你使用的是 Gradle Wrapper：
./gradlew build
Gradle 将在 build/libs 目录下生成一个包含应用所需一切的 JAR 文件。
同样，如果是打包为 WAR 文件，在 build.gradle 中如下设置即可：
plugins {
id 'war'
}
其它注意事项
- 选择 JAR 或 WAR：默认情况下，Spring Boot 推荐使用 JAR 打包方式，因为它支持嵌入式服务器和简易部署。如果你的应用程序需要部署到外部的 Servlet 容器中，才选择 WAR 文件格式。
- 生产环境配置：在执行打包操作之前，确保你的应用配置适合生产环境使用，比如日志级别、数据库连接、外部服务地址等。
- 激活特定的 Profile：可以在打包时激活特定的 Spring Profile，以包含特定环境的配置。
这样打包之后的 Spring Boot 应用可以直接运行，不需要单独的服务器或容器。这使得 Spring Boot 应用特别适合于微服务架构和云环境部署。
5、如何使用 SpringBoot 实现异常处理？
在 Spring Boot 中，实现异常处理通常使用 Spring MVC 提供的 @ControllerAdvice 注解来创建一个全局异常处理器，以及使用 @ExceptionHandler 注解在控制器级别处理异常。以下是使用 Spring Boot 实现异常处理的步骤：
1. 创建全局异常处理类
使用 @ControllerAdvice 注解来定义一个全局的异常处理类，这个类可以捕获并处理所有控制器抛出的异常。
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(Exception.class)
@ResponseBody
public ResponseEntity<?> handleException(Exception e) {
// 处理异常，返回适当的 HTTP 响应
return new ResponseEntity<>(e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
}
@ExceptionHandler(ResourceNotFoundException.class)
@ResponseBody
public ResponseEntity<?> handleResourceNotFoundException(ResourceNotFoundException e) {
// 处理特定异常，返回适当的 HTTP 响应
return new ResponseEntity<>(e.getMessage(), HttpStatus.NOT_FOUND);
}
// 更多的异常处理方法...
}
2. 在控制器中使用 @ExceptionHandler
如果你想对特定控制器的异常进行特别处理，可以在控制器内部使用 @ExceptionHandler 注解。
@RestController
public class MyController {
@ExceptionHandler(SpecificException.class)
public ResponseEntity<?> handleSpecificException(SpecificException e) {
// 处理异常，返回适当的 HTTP 响应
return new ResponseEntity<>(e.getMessage(), HttpStatus.BAD_REQUEST);
}
// 控制器的其他处理方法...
}
3. 自定义错误响应
你可能想要创建一个自定义的错误响应格式来统一你的 API。可以创建一个错误详情对象，用于在捕获异常时封装错误信息。
public class ApiError {
private int status;
private String message;
private long timestamp;
// 构造方法、Getters 和 Setters...
}
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(Exception.class)
@ResponseBody
public ResponseEntity<ApiError> handleException(Exception e) {
ApiError error = new ApiError(HttpStatus.INTERNAL_SERVER_ERROR.value(), e.getMessage(), System.currentTimeMillis());
return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
}
// 其他异常处理...
}
4. 扩展 ResponseEntityExceptionHandler
如果你想复用 Spring 默认的错误处理机制，可以扩展 ResponseEntityExceptionHandler 类，并在其中添加使用 @ExceptionHandler 注解的方法。
@ControllerAdvice
public class CustomResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
@ResponseBody
public ResponseEntity<Object> handleResourceNotFound(ResourceNotFoundException e, WebRequest request) {
String bodyOfResponse = "Resource Not Found";
return handleExceptionInternal(e, bodyOfResponse, new HttpHeaders(), HttpStatus.NOT_FOUND, request);
}
// 覆写 ResponseEntityExceptionHandler 中的方法...
}
这个扩展还允许你覆写 Spring 提供的默认异常处理方法，比如处理 MethodArgumentNotValidException 异常等。
使用这些方法，你可以为 Spring Boot 应用程序实现一个强大、灵活的异常处理机制，允许你根据业务需求进行定制化处理异常的逻辑。如果你有任何进一步的问题，请随时提问。
6、什么是starter?
在Spring Boot的上下文中，"starter"是预先配置的依赖集合，旨在简化构建和配置Spring应用程序的过程。每个starter都是设计来满足特定开发需求的，比如构建一个web应用或者访问数据源等。使用starter时，通常只需添加单个依赖到项目构建配置中，相关的类库、默认配置和自动配置就都已包括在内。
Starter依赖通常遵循spring-boot-starter-*的命名模式，其中*是指代Starter的类型。例如，spring-boot-starter-web是用于构建web应用的Starter，包括了Spring MVC、Tomcat容器等依赖。它可以使你构建RESTful应用或者传统的Servlet应用。
使用starter的优点包括：
- 简化配置：自动配置大部分所需组件，降低显式配置的需求。
- 快速启动新项目：快速搭建项目，专注于业务逻辑。
- 依赖管理：统一管理项目依赖的版本，减少依赖版本冲突的可能性。
- 避免库遗漏：确保所需技术栈的重要库都被包括在内。
- 模块化设计：提供了模块化的开发方式，根据需求选择合适的Starter。
下面是一个将spring-boot-starter-webStarter添加到Maven项目的pom.xml文件中的例子：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
同样的，对于Gradle项目，则添加如下依赖：
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
}
Spring Boot提供了多种Starter，包括但不限于web开发、数据访问、消息服务、安全、测试等。使用Spring Boot的Starter可以使开发者更容易开始构建Spring应用程序，无需深入了解所需技术栈的详细依赖关系。
7、如何不通过任何配置来选择 Hibernate 作为 JPA 的默认实现？
在 Spring Boot 中，默认情况下，如果项目的类路径下存在 Hibernate 相关的依赖，Spring Boot 会自动配置 Hibernate 作为 JPA 实现。这实际上是因为 Spring Boot 自动配置机制的功劳，并不需要开发者提供任何额外配置。
为了确保 Hibernate 被自动选择为 JPA 的默认实现，你应该在项目的构建文件（如 pom.xml 或 build.gradle）中包含 spring-boot-starter-data-jpa 并确保 Hibernate 的依赖是存在的。例如，在 Maven 的 pom.xml 文件中，你可以像这样配置：
<dependencies>
<!-- 添加 spring-boot-starter-data-jpa 启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- Hibernate 作为 JPA 的实现，通常会被自动包含在上面的 starter 中 -->
<!-- 此处没有显式列出 Hibernate 的依赖，因为它是 starter 的传递依赖 -->
</dependencies>
由于 spring-boot-starter-data-jpa 依赖包括了 Hibernate，以及作为 JPA 规范的一部分的 API，所以没有其他配置步骤是必要的。Spring Boot 会负责自动配置 DataSource，EntityManagerFactory，以及 TransactionManager。
如果需要自定义 Hibernate 的配置，可以通过 application.properties 或 application.yml 文件来实现。例如，你可以设置 Hibernate 的 DDL 自动生成属性或方言属性：
# application.properties
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
如果项目类路径上存在其他 JPA 的实现，且你想确保 Hibernate 被选择为默认实现，可以通过排除其他启动器依赖或通过 Maven/Gradle 配置的依赖管理功能来排除其他 JPA 实现。但通常情况下，由于 Hibernate 的广泛使用，Spring Boot 会首先选择 Hibernate 作为默认的 JPA 提供者。
8、各服务之间通信，对Restful和Rpc这2种方式如何做选择？
在微服务架构中，服务通常需要相互通信以合作完成业务功能。选择RESTful API还是RPC（远程过程调用）取决于多个因素，下面是一些决策因素和两种方式的基本区别：
RESTful API：
- 基于HTTP和标准化：RESTful APIs遵循HTTP协议和REST原则，使用标准HTTP方法（如GET、POST、PUT、DELETE）。
- 无状态：RESTful API设计为无状态的，这有利于可伸缩性。
- 文本通信：数据格式通常是JSON或XML，易于不同语言和平台之间通信。
- 自描述性：RESTful API通常包括超媒体链接，可以自描述和发现其他相关资源。
- 适用场景：当你需要构建对外或者面向用户的API，或者在不同的系统间进行通信时。
RPC：
- 紧凑、高效：RPC框架（如gRPC）通过使用二进制格式和持久连接，能够提供高效的数据传输。
- 强类型：RPC通常提供更严格的API约定，可生成客户端和服务器端的代码。
- 实时、流通信：某些RPC框架支持流式传输和实时通信。
- 适用场景：当你需要优化内部服务之间的通信，如需要高吞吐量或低延迟时。
如何做选择：
-
性能需求：RPC（如gRPC）在性能上可能优于RESTful API，特别是二进制协议在网络传输和序列化/反序列化性能上的优势。
-
易用性和兼容性：RESTful API基于普遍支持的HTTP，易于理解和使用。它对于Web浏览器和大多数HTTP客户端都是兼容的。
-
特定语言和平台支持：RPC框架通常提供特定语言的库，可生成Stub代码，而RESTful API要求你手动处理HTTP请求和解析响应。
-
API演化和维护：RESTful API的文本格式使得它对于API演化更为灵活。RPC协议可能需要更小心地版本控制。
-
互操作性：如果服务被不同技术栈的客户端或服务消费，RESTful API因其标准化和广泛支持通常是更好的选择。
-
流数据和复杂交互：如果你的应用涉及到服务间复杂的流数据交互，RPC框架可能提供更好的支持。
-
团队熟悉度：你的团队对两种技术的熟悉程度和偏好也是选择的一个重要因素。
总的来说，没有所谓的最佳解决方案，每种方法都有其优势和使用场景。通常，RESTful API适用于公共API或服务间关系不那么紧密的情况，而RPC适用于性能敏感以及需要强类型、流通信等的内部服务通信。有时，一个系统内部不同服务之间通信的选择还可能是一个混合的解决方案。
9、@SpringBootApplication注释在内部有什么用处?
在 Spring Boot 应用程序中，@SpringBootApplication 注解是一个方便的注解，它包含了一系列其他注解，提供了常用的默认行为。这个注解的内部主要包含以下三个核心注解：
-
@SpringBootConfiguration：
- 标识该类为配置类，并且是应用程序上下文的来源。它本质上是特殊的
@Configuration注解，表明该类中可能存在一些使用@Bean注解定义的 Bean。
- 标识该类为配置类，并且是应用程序上下文的来源。它本质上是特殊的
-
@EnableAutoConfiguration：
- 启动 Spring Boot 的自动配置机制，它会尝试根据 classpath 中存在的类、定义的 Bean 以及各种属性设置来配置你的应用程序。
- 自动配置尝试基于添加的依赖智能配置你的 Spring 应用。例如，如果
spring-webmvc在 classpath 中，它会自动添加DispatcherServlet和WebMvcConfigurerAdapter来启动一个 Web 应用程序。
-
@ComponentScan：
- 启用组件扫描，这样你可以通过注解（如
@Component,@Service,@Repository,@Controller等）自动注册在该类所在包和子包中的 Spring 组件。 - 默认情况下，注解会扫描与配置类在相同的包或子包中的所有类。
- 启用组件扫描，这样你可以通过注解（如
除了这些核心注解，@SpringBootApplication 还可以结合其他参数和注解来进一步自定义自动配置行为。例如，你可以使用 exclude 和 excludeName 属性来关闭特定的自动配置项，或使用 scanBasePackages 来定义需要扫描的包。
一个典型的主应用程序类通常像这样：
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
当你使用 @SpringBootApplication 注解和运行主应用程序类的 main() 方法时，Spring Boot 应用程序就会启动并进行自动配置、组件扫描、以及自动启动内嵌的服务器（如果是一个 Web 应用）。
通过这个注解，Spring Boot 提供了一个非常简洁且强大的方法来准备和运行你的应用程序。如果你有任何关于 @SpringBootApplication 注解或 Spring Boot 的问题，请随时提问。
10、为什么我们需要 spring-boot-maven-plugin?
spring-boot-maven-plugin是一个Spring Boot的Maven插件，它提供了几个重要的功能，以支持打包和运行Spring Boot应用程序。以下是为什么我们需要这个插件的原因：
-
打包为可执行Jar/War文件：这个插件能够创建一个包含所有必要依赖的‘超级’JAR文件，称之为可执行JAR，也常称为‘Fat Jar’或‘Uber Jar’。这个JAR文件内嵌了Servlet容器（比如Tomcat），使你能够直接运行你的应用，不需要部署到一个独立的Servlet容器中。
-
简化项目启动：插件提供了Maven的
spring-boot:run目标，使得可以直接从Maven命令行启动应用程序，简化了本地开发和测试流程。 -
支持分层Jar：该插件支持为Docker构建分层的JAR文件，可以更好地利用Docker的缓存机制，较少构建时间和镜像大小。
-
支持应用启动前/后运行特定代码：可以在应用运行之前或之后执行特定的Maven目标。
-
支持自定义JAR/WAR属性：插件允许自定义生成的JAR或WAR文件的属性，包括最终名称、主类和其他布局选项。
-
内置应用类加载器设置：该插件会自动配置Spring Boot专用的类加载器，它能够正确地处理JAR文件中的类和资源文件。
为了将spring-boot-maven-plugin添加到项目中，你需要在项目的pom.xml文件中的<build>部分添加以下配置：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
这个插件是Spring Boot的核心组成部分之一，它在构建和打包Spring Boot应用程序时扮演了关键角色。通过使用这个插件，开发者可以便捷地创建用于生产的Spring Boot应用程序。
SpringBoot最新面试题(12)
1、如何在不使用BasePackage过滤器的情况下排除程序包？
在Spring中，如果您想排除特定的包（而不是使用ComponentScan的basePackages或basePackageClasses属性指定扫描的包），可以使用ComponentScan的excludeFilters属性。excludeFilters属性允许您定义一组过滤条件，用于排除特定的组件。
以下是一个例子，演示了如何使用@ComponentScan和@Configuration注解排除一个包：
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
@Configuration
@ComponentScan(
basePackages = "com.example", // 指定要扫描的基础包
excludeFilters = @ComponentScan.Filter(
type = FilterType.REGEX,
pattern = "com\\.example\\.excluded.*" // 使用正则表达式排除包
)
)
public class AppConfig {
// ...
}
在上面的示例中，所有com.example.excluded包下的组件都会被排除，不会被Spring容器注册。
使用 FilterType
excludeFilters接受一个或多个@Filter，您可以设置筛选器的type，比如：
FilterType.ANNOTATION：基于注解排除。FilterType.ASSIGNABLE_TYPE：基于指定的类型排除。FilterType.REGEX：使用正则表达式来匹配类路径名称。FilterType.CUSTOM：提供自定义的TypeFilter实现。
更进一步，如果你使用的是自动配置的Spring Boot应用程序，你可以利用@SpringBootApplication注解（它包含@ComponentScan）来实现相同的目标：
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;
@SpringBootApplication
@ComponentScan(
excludeFilters = @ComponentScan.Filter(
type = FilterType.REGEX,
pattern = "com\\.example\\.excluded.*"
)
)
public class MySpringBootApplication {
// ... 应用程序的主类
}
请注意，使用excludeFilters实现包排除的时候，需要谨慎处理，以确保不会意外排除掉必要的bean，这可能导致应用程序运行时出现未预期的行为。如果有疑问，请仔细测试您的配置以确保所需的组件都被正确地注册到了Spring上下文中。
2、微服务中如何实现 session 共享 ?
在微服务架构中，实现会话（session）共享的目标是允许不同的服务实例访问和修改同一个会话状态。由于微服务通常相互独立部署，每个服务都有自己的负载均衡器和会话存储，因此实现会话共享需要一些特殊的考虑。下面是一些实现会话共享的策略：
-
中心化会话存储：
使用共享的数据存储系统存放会话数据，如 Redis、Memcached、数据库等。各个服务实例可以读写统一的会话存储，从而实现会话共享。 -
JWT（JSON Web Tokens）：
对客户端进行无状态身份验证。JSON Web Tokens 包含了会话需要的所有用户信息，并且可以在服务之间传递和验证。这样，不同的服务实例无需共享会话数据就能独立验证用户会话。 -
Spring Session：
Spring Session 提供了一个透明的方式来管理用户会话，支持跨多个实例的会话集中化。Spring Session 与中心化数据存储结合使用（比如 Redis），将会话数据集中存储。 -
客户端存储：
将会话数据存储在客户端（如浏览器的 Cookies 或 Local Storage）。这样，每次请求时客户端都会发送会话数据，降低了服务端存储的需要。 -
会话复制：
如果使用应用服务器集群，可以配置会话复制功能。这种方法确保了用户的会话在集群中的多个实例间保持同步。例如，Tomcat 提供了会话复制的功能，但这通常仅限于使用同构服务实例的情况。 -
负载均衡器的粘性会话（Sticky Sessions）：
配置负载均衡器以将来自同一用户的请求总是转发到相同的服务实例。这种方式可以确保会话数据的一致性，但可能限制了扩展性和容错能力。
需要注意的是，会话共享可能与微服务架构的初衷相悖，即构建松耦合、自治和无状态的服务。为了充分利用微服务的优势，建议采用无状态服务和基于令牌的身份验证机制，如 JWT。这样，每个服务可以独立于其他服务运行，更有助于扩展和维护。
如果你考虑在微服务中实现会话共享，请谨慎选择方案并评估其对系统扩展性、安全性和复杂度的影响。如果你有更多问题或需要具体建议，请随时提问。
3、如何实现 SpringBoot应用程序的安全性?
要实现Spring Boot应用程序的安全性，你可以使用Spring Security框架。Spring Security是一个强大的和高度可定制的认证和访问控制框架。它是保护基于Spring的应用程序的事实上的标准选择。
以下是实现Spring Boot应用程序安全性的基本步骤：
- 添加依赖：
在你的Spring Boot项目中添加spring-boot-starter-security依赖项。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
- 创建配置类：
创建一个继承自WebSecurityConfigurerAdapter的Java配置类，并重写configure方法来定义自定义的安全策略。
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/", "/home").permitAll()
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login").permitAll()
.and()
.logout()
.permitAll();
}
}
- 添加用户详细信息服务：
实现UserDetailsService以从数据库或其他存储加载用户详情。
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Service;
@Service
public class MyUserDetailsService implements UserDetailsService {
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
// Load the user from the database (or any other source)
// Return the user object if found
}
}
- 密码编码：
在Spring Security 5中需要定义PasswordEncoder的Bean。推荐使用BCryptPasswordEncoder。
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
@Bean
public BCryptPasswordEncoder bCryptPasswordEncoder() {
return new BCryptPasswordEncoder();
}
- 启用方法级安全性：
如果需要，添加@EnableGlobalMethodSecurity注解到配置类，以启用基于注解的安全性。
@EnableGlobalMethodSecurity(prePostEnabled = true)
- 安全性忽略：
对于静态资源等不需要保护的HTTP请求，你可以在配置中说明。
@Override
public void configure(WebSecurity web) throws Exception {
web
.ignoring()
.antMatchers("/js/**", "/css/**", "/images/**", "/webjars/**");
}
- 运行与测试：
运行应用程序，访问不同的URL确保安全策略的正确性，比如未认证用户只能访问公共页面，而必需认证后才能访问受保护的资源。
Spring Security的学习曲线比较陡峭，但它提供了一系列高级特性，如OAuth2、CSRF保护、CORS策略等，可以帮助保护你的Spring Boot应用程序。通过适当配置，Spring Boot与Spring Security框架集成可以为你的应用提供强大的安全防护。
4、是否可以在SpringBoot中覆盖或替换嵌入式Tomcat？
是的，在 Spring Boot 中，你可以覆盖或替换内嵌的 Tomcat 服务器。Spring Boot 支持几种内嵌的 Servlet 容器，包括 Tomcat、Jetty、Undertow 等。可以通过修改 pom.xml 文件中的依赖来更换默认的内嵌 Servlet 容器。
替换 Tomcat 为 Jetty 或 Undertow
如果希望使用除 Tomcat 以外的其他内嵌服务器，如 Jetty 或 Undertow，你需要做以下操作：
- 排除
spring-boot-starter-web中的spring-boot-starter-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>
- 添加想要使用的 Servlet 容器的 starter。例如，使用 Jetty：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
或者使用 Undertow：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-undertow</artifactId>
</dependency>
使用外部 Servlet 容器
如果你希望部署到外部的 Servlet 容器中，比如独立的 Tomcat 服务器：
- 将打包类型改为 WAR：
<packaging>war</packaging>
- 修改 Spring Boot 应用的入口类，让它继承
SpringBootServletInitializer并重写configure()方法：
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
public class MySpringBootApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(MySpringBootApplication.class);
}
public static void main(String[] args) {
SpringApplication.run(MySpringBootApplication.class, args);
}
}
- 修改
pom.xml文件，排除内嵌的 Tomcat 并将 Tomcat 的 scope 设为provided：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
完成以上步骤后，你的 Spring Boot 应用就可以打包成 WAR 文件，并部署到外部的 Servlet 容器上了。
Spring Boot 为相互切换内嵌的 Servlet 容器提供了灵活性，并能够轻松部署到外部容器中。无论是使用内嵌的轻量级容器还是传统的 WAR 文件部署，都可以根据实际需求和部署环境来选择。
5、项目中前后端分离部署，所以需要解决跨域的问题。
在前后端分离的架构中，前端应用通常会部署在一个域名（或端口）上，而后端API则部署在另一个域名（或端口）上。由于浏览器的同源策略，默认情况下，不允许前端从一个源（源包括协议、域名和端口）发起的请求访问另一个源的资源。这就是跨域资源共享（CORS）问题。
在Spring Boot应用中解决跨域问题，有几种不同的方法：
1. 控制器层解决CORS
在你的@RestController或@Controller的方法上使用@CrossOrigin注解来允许CORS请求：
@CrossOrigin(origins = "http://yourfrontenddomain.com")
@RestController
public class MyController {
@GetMapping("/api/data")
public List<Data> getData() {
// ...
return dataList;
}
}
你也可以在类级别使用@CrossOrigin注解来为该控制器的所有请求方法启用CORS。
2. 全局CORS配置
可以在配置类中使用WebMvcConfigurer来添加全局CORS配置：
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("http://yourfrontenddomain.com")
.allowedMethods("GET", "POST", "PUT", "DELETE")
.allowedHeaders("*")
.allowCredentials(true)
.maxAge(3600); // 1 hour
}
}
这种方法可以让你针对所有控制器和请求方法定义CORS配置。
3. 使用Filter处理CORS
另一种选择是创建一个自定义的过滤器(Filter)来处理CORS请求。在这个过滤器中，你可以添加相应的HTTP头到响应中，如Access-Control-Allow-Origin:
@Component
public class CorsFilter implements Filter {
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
HttpServletResponse response = (HttpServletResponse) res;
HttpServletRequest request = (HttpServletRequest) req;
response.setHeader("Access-Control-Allow-Origin", "http://yourfrontenddomain.com");
response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
response.setHeader("Access-Control-Allow-Headers", "Origin, Content-Type, Accept");
response.setHeader("Access-Control-Allow-Credentials", "true");
chain.doFilter(request, response);
}
}
当使用Spring Security时，应确保CORS配置在Spring Security的CORS配置之前。
每种解决方案的适用场景可能不同。如果只需要为几个特定的端点解决CORS，可以考虑使用@CrossOrigin注解。如果希望应用一致的CORS策略到所有的后端API，那么全局CORS配置或自定义过滤器将会是更好的解决方案。请根据您项目的需求和安全策略来选择最合适的方法。
6、SpringBoot读取配置文件的方式
Spring Boot 提供了多种灵活的方式来读取配置文件，以适应不同的需求和场景。以下是 Spring Boot 读取配置文件的一些常用方式：
-
application.properties 或 application.yml：
- Spring Boot 默认在
src/main/resources目录中查找名为application.properties或application.yml的配置文件。这些文件中的属性可以直接在应用中通过@Value注解或者配置类绑定来使用。
- Spring Boot 默认在
-
命名参数：
- 在运行应用程序时，可以通过命令行参数传递配置属性。例如，您可以使用
--property.name=value的格式在启动命令中指定属性。
- 在运行应用程序时，可以通过命令行参数传递配置属性。例如，您可以使用
-
环境变量：
- Spring Boot 可以从操作系统环境变量中读取配置属性。这对于云环境和容器化环境中的配置非常有用。
-
JVM 系统属性：
- 可以通过 JVM 参数
-Dproperty.name=value的方式传递系统属性。
- 可以通过 JVM 参数
-
Spring Profiles：
- 使用 Spring Profiles 可以为不同环境维护不同的配置文件，如
application-dev.properties、application-prod.properties等。可以通过设置spring.profiles.active属性来激活特定的配置。
- 使用 Spring Profiles 可以为不同环境维护不同的配置文件，如
-
@PropertySource 注解：
- 在
@Configuration类中使用@PropertySource注解可以指定自定义属性文件。
- 在
-
命令行运行器：
- 实现
CommandLineRunner或ApplicationRunner接口的组件可以访问命令行参数。
- 实现
-
配置类绑定：
- 使用
@ConfigurationProperties注解，可以将配置属性绑定到一个类的字段上，然后在应用中注入这个类的实例。
- 使用
-
云配置服务器：
- 如果你在云环境中，可以使用 Spring Cloud Config Server 从中心配置仓库获取配置。
-
覆盖配置：
- 当你有多个配置文件时，Spring Boot 会根据特定的顺序进行解析，并允许属性覆盖。这可以实现默认值与特定环境配置的结合。
这些不同方式可根据不同的部署环境和开发需求组合使用，为了保持配置的可维护性和灵活性。Spring Boot 的灵活性使得您可以很容易地调整应用程序配置以适应不同的环境和场景。如果你有关于如何读取配置文件或相关的问题，欢迎随时提出。
7、SpringBoot Starter的工作原理
在Spring Boot中，Starter是一组方便的依赖描述符，可以添加到应用的构建配置中。它们存在的目的是为了减少对启动一个项目所必需的配置和依赖项的复杂性。Spring Boot Starter包含了自动配置逻辑，这些逻辑是通过约定优于配置的原则来实现的，以及所需的任何库来支持开始编码定制的功能。
Spring Boot Starter的工作原理主要可以分为以下几个方面：
-
方便的依赖管理：
Starter是预先定义的依赖集合。例如，如果你想要开发一个web应用程序，你可以包含spring-boot-starter-web依赖。这个starter会提供所有必需的依赖，如Spring MVC, Jackson (用于JSON), Hibernate Validator, Tomcat等，而你不需要单独包含它们。 -
自动配置：
Starter依赖提供了自动配置类，这些类会在Spring Boot应用启动时自动进行配置。它们利用@Conditional注解来判断某个自动配置类或者bean是否应该在应用的当前上下文中被创建。 -
无需额外配置：
自动配置逻辑会尝试根据你添加到项目中的库、Spring Boot属性文件中的值和其他因素来猜测你可能需要的配置，并将这些配置应用到应用程序上下文中。 -
定制与覆盖：
对于大部分的自动配置，如果你不喜欢默认配置，你可以通过创建自己的配置bean来覆盖它们，或者在application.properties或application.yml文件中进行设定，来改变自动配置的行为。
例如，使用spring-boot-starter-web的示例pom.xml配置如下：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
这个配置会在背景中做很多工作：
- 拉取了构建基于Spring MVC的web应用程序所需的所有依赖。
- 自动配置了Spring和Spring MVC相关的事项，包括消息转换器，视图解析器等。
- 内嵌了Tomcat作为默认的Servlet容器。
Starter极大地简化了新Spring Boot项目的创建和维护过程，提供了一种极为快速的革命性方法，以最小的前置工作来构建Spring应用程序。
8、什么是嵌入式服务器？我们为什么要使用嵌入式服务器呢?
嵌入式服务器（Embedded Server）是指服务器软件组件可以嵌入到应用程序中的服务器，从而使应用程序能够独立运行，无需依赖外部的运行时容器或服务器环境。嵌入式服务器一般指的是 Web 服务器或应用服务器，常见于微服务架构、云服务和容器化部署中。
使用嵌入式服务器的原因包括：
-
简化部署过程：
嵌入式服务器允许应用程序作为独立的可执行程序运行，无需单独安装和配置外部服务器。这简化了部署和分发过程，尤其是在微服务架构和持续集成/持续部署（CI/CD）流程中。 -
快速启动和开发效率：
嵌入式服务器的引入使得开发和测试过程更简单。开发人员可以直接从 IDE 启动应用程序，这加速了开发周期并提高了效率。 -
减少外部依赖：
由于不必依赖外部应用服务器，应用程序容易配置和管理，降低了维护和升级的复杂度。 -
便于容器化：
容器化应用程序趋势的兴起使得轻量级、独立运行的嵌入式服务器显得更加有用。嵌入式服务器与 Docker 和 Kubernetes 等容器技术配合得很好，有助于构建和部署微服务。 -
环境一致性：
应用程序的开发、测试和生产环境可以保证更高的一致性，因为所有环境都使用相同的嵌入式服务器。 -
资源利用优化：
特别是对于微服务架构，许多小型服务不需要完整的应用服务器的所有功能，使用嵌入式服务器可以减少资源浪费。
示例：
在 Java 生态系统中，一些流行的嵌入式 HTTP 服务器/Servlet 容器包括：
- Tomcat：通过 Spring Boot，可以嵌入 Apache Tomcat 作为默认的 Web 服务器。
- Jetty：同样可以通过 Spring Boot 或其他框架嵌入 Jetty 服务器。
- Undertow：一个轻量级的嵌入式 Java Web 服务器，也可以通过 Spring Boot 集成。
- Netty：用于网络应用程序开发的异步事件驱动网络应用框架，通常用于构建基于 HTTP/2 的服务。
随着微服务和云原生应用的兴起，嵌入式服务器变得越来越流行。开发者可以利用嵌入式服务器来构建轻量级、高性能且易于部署的应用程序。
9、SpringBoot 需要独立的容器运行吗？
不，Spring Boot 不需要独立的应用程序容器来运行。Spring Boot具有内嵌的应用服务器，最常见的是Apache Tomcat，但也支持其他服务器，如Jetty和Undertow。这意味着你可以创建一个自包含的JAR（Java ARchive）文件，该JAR文件包括你的应用代码、Spring Boot框架的库和应用服务器，所有这些都在一个可执行的JAR中打包完毕。这个JAR文件包含了运行应用所需的一切，不依赖于外部的Servlet容器。
要创建一个自包含的JAR文件，你应在项目的pom.xml（对Maven项目）或build.gradle（对Gradle项目）中添加相关的Spring Boot starter和插件。例如，在Maven项目中，你可以添加spring-boot-starter-web依赖来获取Tomcat，并加入spring-boot-maven-plugin来构建可执行的JAR：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- (其他依赖项) -->
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<!-- (其他插件) -->
</plugins>
</build>
在Spring Boot应用中，main方法会调用SpringApplication.run()，这会引导Spring应用程序上下文并启动内嵌的应用服务器：
@SpringBootApplication
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
}
当然，如果你的需求或环境策略要求使用传统的War文件部署到外部的Servlet容器或Java EE应用服务器（比如Tomcat，Jetty，WebLogic，或者WildFly等），Spring Boot也支持这种部署方式。哪种部署方式更适合取决于你的应用特性、部署环境和团队策略。内嵌的服务器适合微服务、云部署和快速启动的独立应用，而外部容器部署则适用于传统的企业环境或需要特定应用服务器功能的场景。
10、SpringBoot事务的使用
在 Spring Boot 中，事务管理通常是通过 Spring 的声明式事务管理机制来实现的，它允许你通过注解或配置声明一个方法应该在事务的上下文中运行。以下是在 Spring Boot 中使用事务的一些关键步骤和概念：
1. 启用声明式事务管理
在 Spring Boot 应用程序中，声明式事务管理通常是默认启用的，特别是当你使用 spring-boot-starter-data-jpa 或spring-boot-starter-data-mongodb 这样的启动器时。但如果需要，你可以通过在配置类上添加 @EnableTransactionManagement 注解来显式启用它：
@Configuration
@EnableTransactionManagement
public class TransactionConfig {
// ...
}
2. 配置数据源和事务管理器
确保你的应用程序有一个数据源和事务管理器配置。在 Spring Boot 中，如果你使用了支持的数据访问技术，相应的事务管理器通常会自动配置好。例如，使用 JPA 的话会配置 JpaTransactionManager。
3. 使用 @Transactional 注解
在服务层，你可以通过在类或方法上添加 @Transactional 注解来指示 Spring 在方法调用时开启一个事务。如果方法完成执行且没有异常抛出，Spring 则提交事务；如果方法执行中抛出了异常，则回滚事务：
@Service
public class MyService {
@Transactional
public void performTransactionalOperation() {
// 需要在事务中执行的代码
}
}
4. 事务的传播行为
@Transactional 注解允许你定义事务的传播行为。默认的传播行为是 REQUIRED，这意味着如果当前存在一个事务，则加入该事务；如果不存在，则创建一个新的事务。
@Transactional(propagation = Propagation.REQUIRED)
public void performTransationalOperation() {
// 需要在事务中执行的代码
}
5. 事务的隔离级别
你也可以指定事务的隔离级别，这是关于并发访问数据库时可见性和效果的规则：
@Transactional(isolation = Isolation.SERIALIZABLE)
public void performTransationalOperation() {
// 需要在事务中执行的代码
}
6. 只读事务
如果你的事务是只读的，即你只是从数据库中查询数据，那么你可以设置 readOnly 标志：
@Transactional(readOnly = true)
public List<MyEntity> findAllEntities() {
// 只进行数据读取的代码
}
7. 回滚规则
你可以指定哪些异常类型会触发事务回滚。默认情况下，运行时异常（RuntimeException）和错误（Error）会导致回滚，但检查型异常（Exception 的其他子类）不会：
@Transactional(rollbackFor = Exception.class)
public void performTransationalOperation() {
// 需要在事务中执行的代码
}
8. 超时
你还可以为事务指定一个超时期限，超过了这个时间限制如果事务还没有完成，则自动回滚：
@Transactional(timeout = 30) // 30秒
public void performTransationalOperation() {
// 需要在事务中执行的代码
}
使用声明式事务管理简化了事务的使用，提供了很大的灵活性，并降低了编写正确事务代码的复杂性。正确地使用声明式事务管理是确保数据完整性和一致性的关键因素。如果你有关于 Spring Boot 中事务使用或其他相关问题，请随时提问。
11、SpringBoot 提供了哪些核心功能？
Spring Boot是一个开源的Java基础框架，旨在简化Spring应用的创建和开发过程。它利用"约定优于配置"的原则，提供了一套大量默认配置，以此实现快速和简洁的开发体验。Spring Boot提供的核心功能包括：
-
自动配置（Auto-configuration）：
Spring Boot可以根据类路径下的jar包、bean的存在性及各种配置属性来猜测你可能需要的配置项，并自动对Spring应用进行配置。 -
独立运行（Standalone）：
Spring Boot应用包含内嵌的Servlet容器（如Tomcat、Jetty或Undertow），允许应用作为独立应用运行，不需要外部的Servlet容器。 -
Startup是starter：
Starter依赖项描述了一系列用于特定类型应用的默认的依赖关系，通过简单地添加Starter，可以让相应的模块和自动配置生效。 -
生产准备指标（Production-ready features）：
比如健康检查、度量收集、外部化配置等功能，通过Actuator模块提供，以支持应用的监控和管理。 -
无代码生成和XML配置（No code generation and no XML configuration）：
Spring Boot设计上不需要生成代码，也不使用XML配置文件。所有的配置都是用Java配置和属性文件实现的。 -
Spring应用快速启动（Quick Start）：
Spring Boot提供了快速启动新Spring应用的功能，只需几行代码和几分钟配置时间。 -
外部化配置（Externalized Configuration）：
提供了一种方法来配置应用的所有环境，通常使用application.properties或application.yml文件。 -
简化Maven配置（Simplified Maven Configuration）：
提供了Spring Boot maven插件来简化构建和运行Spring应用的过程。 -
微服务支持（Microservice support）：
Spring Boot天然支持微服务架构，使得创建独立的、分布式和可扩展的微服务变得简单。 -
健全的社区和强大的Spring生态系统（Strong community and Spring ecosystem）：
Spring Boot得益于Spring Platform强大的生态系统和活跃的社区支持。 -
快速试验开发（Rapid prototyping）：
允许开发者快速进行原型设计和开发，快速验证概念或API。 -
与Spring Cloud的集成（Integration with Spring Cloud）：
简化了在云环境中开发分布式系统的过程。
Spring Boot的这些核心功能，特别是自动配置和Starter依赖，极大简化了Spring应用的开发和发布过程，赋予了开发者快速启动和部署应用程序的能力。
12、微服务同时调用多个接口，怎么支持事务的啊？
在微服务架构中，因为服务通常是分布在不同的系统或者不同的节点上的，所以不能使用传统的单体应用中的分布式事务来解决问题。分布式系统中事务的一致性常常是通过所谓的弱一致性来实现的，其中一种方法是使用“最终一致性（Eventual Consistency）”模型。
以下是在微服务中处理分布式事务和支持事务一致性的几种常见策略：
1. 分布式事务模式 - 两阶段提交（2PC）
两阶段提交是一种经典的分布式事务协议，但由于其性能、可扩展性和复杂性等问题，并不适合云原生微服务应用。因此，在微服务架构中，这种模式不太常用。
2. 补偿事务（SAGA 模式）
SAGA 是一种将长期事务分解为多个小事务，每个小事务都拥有相应的补偿（回滚）操作。当一个服务操作失败时，会依次调用之前成功操作的补偿事务，以此来保证数据一致性。
SAGA 可以通过事件驱动或者请求/回复的方式实现。在事件驱动方式中，每个服务操作完成后都会发布一个事件，其他服务可以订阅这些事件并作出相应的动作。
3. 分布式事务框架
如 Seata、Atomikos 等框架提供了对分布式事务的支持，但是它们对系统的侵入性较强，需要适当的架构设计和编程模型来集成。
4. 基于消息的最终一致性
可以通过可靠的消息服务（如 Apache Kafka、RabbitMQ等）来保证事务的最终一致性。每个微服务独立管理自己的数据和事务，通过同步消息来确保一致性。
5. 基于 REST 或 gRPC 的服务重试机制
通过 HTTP REST 或 gRPC 调用其他服务时，可以结合熔断器和重试机制，例如 Spring Cloud Hystrix、Resilience4j。
6. 本地事务 + 补偿操作
每个服务使用本地事务来确保自身数据的一致性。在进行跨服务调用时，如果后续有任何失败，将通过补偿操作来尝试恢复到一致状态。
7. 最终一致性的工具和中间件
使用像 Apache Camel、Spring Integration 这样的集成框架来管理分布式系统的事务和数据流转。
分布式事务的管理是微服务架构中一个复杂且难以解决的挑战。SAGA 模式和事件驱动架构提供了一种更灵活和对业务友好的事务管理方法，常被视为微服务中处理跨服务数据一致性的最佳实践。在任何选择分布式事务解决方案的时候，都需要权衡业务需求、性能开销以及系统的复杂性。
1347
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
