温度而知新，一文夯实Spring知识文集(1)

本文主要是介绍温度而知新，一文夯实Spring知识文集(1)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

🏆作者简介，普修罗双战士，一直追求不断学习和成长，在技术的道路上持续探索和实践。
🏆多年互联网行业从业经验，历任核心研发工程师，项目技术负责人。
🎉欢迎 👍点赞✍评论⭐收藏

Java知识专栏学习

Java知识云集	访问地址	备注
Java知识(1)	https://blog.csdn.net/m0_50308467/article/details/133637852	Java知识专栏
Java知识(2)	https://blog.csdn.net/m0_50308467/article/details/133646557	Java知识专栏
Java知识(3)	https://blog.csdn.net/m0_50308467/article/details/133671989	Java知识专栏
Java知识(4)	https://blog.csdn.net/m0_50308467/article/details/133680374	Java知识专栏
Java知识(5)	https://blog.csdn.net/m0_50308467/article/details/134180396	Java知识专栏
Java知识(6)	https://blog.csdn.net/m0_50308467/article/details/134207490	Java知识专栏
Java知识(7)	https://blog.csdn.net/m0_50308467/article/details/134398127	Java知识专栏
Java知识(8)	https://blog.csdn.net/m0_50308467/article/details/134449901	Java知识专栏
Java知识(9)	https://blog.csdn.net/m0_50308467/article/details/134534955	Java知识专栏
Java知识(10)	https://blog.csdn.net/m0_50308467/article/details/134835791	Java知识专栏
Java知识(11)	https://blog.csdn.net/m0_50308467/article/details/134854250	Java知识专栏

🔎一、Spring知识文集学习(1)

🍁01 SpringBoot有哪些优缺点？

Spring Boot 的优点：

1. 快速开发。Spring Boot 提供了大量的 starter 依赖，可以快速地创建项目，并集成常用的功能，如数据库连接、缓存、消息队列等。
2. 简化配置。Spring Boot 使用了约定优于配置的原则，可以通过配置文件或注解的方式来配置应用程序，不需要编写大量的 XML 配置文件。
3. 自动配置。Spring Boot 可以自动配置 Spring 的各个组件，不需要手动配置。
4. 嵌入式容器。Spring Boot 可以内嵌 Tomcat、Jetty 等容器，不需要单独部署容器。
5. 生产就绪。Spring Boot 提供了许多生产级别的特性，如日志管理、健康检查、指标监控等。

Spring Boot 的缺点：

1. 学习成本较高。Spring Boot 的功能比较多，学习成本较高。
2. 依赖较多。Spring Boot 使用了很多第三方依赖，可能会导致项目的依赖关系复杂。
3. 不够灵活。Spring Boot 的约定优于配置的原则，可能会导致项目的灵活性降低。
4. 不支持 Java EE 规范。Spring Boot 不支持 Java EE 规范，可能会导致项目在部署到生产环境时遇到问题。

🍁02 SpringBoot常用的starter有哪些？

Spring Boot 提供了大量的 starter 依赖，可以快速地创建项目，并集成常用的功能，如数据库连接、缓存、消息队列等。

以下是 Spring Boot 常用的 starter 列表：

• spring-boot-starter-web：包含了 Spring MVC 和 Tomcat 的依赖，可以快速地创建一个 Web 项目。
• spring-boot-starter-data-jpa：包含了 Spring Data JPA 和 Hibernate 的依赖，可以快速地连接数据库并进行数据库操作。
• spring-boot-starter-data-mongodb：包含了 Spring Data MongoDB 和 MongoDB 的依赖，可以快速地连接 MongoDB 并进行数据库操作。
• spring-boot-starter-cache：包含了 Spring Cache 和 Ehcache 的依赖，可以快速地使用缓存。
• spring-boot-starter-actuator：包含了 Spring Boot Actuator 的依赖，可以快速地监控应用程序的状态。
• spring-boot-starter-security：包含了 Spring Security 的依赖，可以快速地实现安全认证。
• spring-boot-starter-test：包含了 Spring Boot Test 的依赖，可以快速地进行单元测试和集成测试。

这些 starter 只是 Spring Boot 提供的众多 starter 中的一部分，更多 starter 可以参考 Spring Boot 官方文档。

🍁03 如何实现 SpringBoot 应用程序的安全性？

Spring Boot 提供了 Spring Security 来实现应用程序的安全性。Spring Security 是一个强大的安全框架，可以保护应用程序免受各种攻击。

要使用 Spring Security，只需要在 Spring Boot 项目中添加 spring-boot-starter-security 依赖即可。然后，可以通过配置 application.properties 文件来配置 Spring Security。

以下是一些常见的 Spring Security 配置：

• 配置用户名和密码：可以通过 spring.security.user.name 和 spring.security.user.password 属性来配置用户名和密码。
• 配置登录页面：可以通过 spring.security.login.page 属性来配置登录页面。
• 配置登录失败页面：可以通过 spring.security.failure.url 属性来配置登录失败页面。
• 配置权限：可以通过 spring.security.oauth2.resourceserver.access.token-uri 属性来配置权限。

更多关于 Spring Security 的配置信息，可以参考 Spring Security 官方文档。

🍁04 如何重新加载SpringBoot上的更改，而无需重新启动服务器？

在开发阶段，为了避免每次更改代码都需要重新启动服务器，可以使用 Spring Boot 的热部署功能来重新加载应用程序的更改。

以下是几种实现热部署的方式：

1. 使用开发工具支持：大多数集成开发环境（IDE）都支持 Spring Boot 的热部署。例如，使用 IntelliJ IDEA 可以在项目设置中启用 “自动编译” 选项，这样每次保存代码时，IDE 会自动重新编译并加载更改。

2. 使用 Spring Boot DevTools：Spring Boot 提供了一个名为 DevTools 的模块，可以实现热部署。只需将 spring-boot-devtools 依赖添加到项目中，然后在 IDE 中启用自动构建功能。当代码更改保存时，应用程序将自动重新加载。

3. 使用 Spring Loaded 或 JRebel：Spring Loaded 和 JRebel 是两个流行的第三方工具，可以实现更快的热部署。这些工具可以在不重新启动服务器的情况下加载更改，并且支持更广泛的代码更改。

请注意，热部署功能主要用于开发阶段，不建议在生产环境中使用。在生产环境中，建议将更改打包成可部署的文件，并重新启动服务器以加载更改。

🍁05 如何在自定义端口上运行SpringBoot应用程序？

可以通过以下几种方式在自定义端口上运行 Spring Boot 应用程序：

1. 在 application.properties 文件中配置 server.port 属性。
2. 使用 java -jar -Dserver.port=8080 myapp.jar 命令运行应用程序。
3. 使用 Spring Boot DevTools 启用热部署功能，然后在 IDE 中修改 server.port 属性。

以下是详细的说明：

1. 在 application.properties 文件中配置 server.port 属性，如下所示：

server.port=8080

2. 使用 java -jar -Dserver.port=8080 myapp.jar 命令运行应用程序，如下所示：

java -jar -Dserver.port=8080 myapp.jar

3. 使用 Spring Boot DevTools 启用热部署功能，然后在 IDE 中修改 server.port 属性。

在 IDE 中，打开 application.properties 文件，然后修改 server.port 属性的值。

保存 application.properties 文件后，IDE 会自动重新编译并启动应用程序。

注意：如果使用 Spring Boot DevTools 启用热部署功能，则不需要重新启动应用程序即可修改 server.port 属性。

🍁06 SpringBoot的核心注解是哪个？它主要由哪几个注解组成的？

Spring Boot 的核心注解是 @SpringBootApplication ，它由以下几个注解组成：

• @SpringBootConfiguration ：标注这个类是一个 Spring Boot 的配置类。
• @EnableAutoConfiguration ：开启 Spring Boot 的自动配置功能。
• @ComponentScan ：扫描这个类所在的包及其子包，找到所有符合条件的组件并注册到 Spring 容器中。

@SpringBootApplication 注解是 Spring Boot 的核心注解，它可以让你快速地创建一个 Spring Boot 项目。当你在一个类上使用 @SpringBootApplication 注解时，Spring Boot 会自动为你做以下几件事：

• 扫描这个类所在的包及其子包，找到所有符合条件的组件并注册到 Spring 容器中。
• 自动配置 Spring 容器，包括数据源、缓存、消息队列等。
• 启动 Spring Boot 的 Actuator 功能，提供健康检查、指标监控等功能。

如果你想了解更多关于 @SpringBootApplication 注解的信息，可以参考 Spring Boot 官方文档。

🍁07 什么是Spring Actuator？它有什么优势？

Spring Boot Actuator 是 Spring Boot 提供的一个功能强大的模块，用于监控和管理应用程序的运行时状态。它提供了许多有用的特性，可以帮助开发人员更好地了解和管理应用程序。

Spring Boot Actuator 的优势包括：

1. 健康检查：Actuator 可以提供应用程序的健康状态，包括检查数据库连接、缓存是否可用等。这对于监控应用程序的运行状态和故障排查非常有帮助。

2. 指标监控：Actuator 可以提供应用程序的各种指标，如 CPU 使用率、内存使用情况、请求数量等。这些指标可以帮助开发人员了解应用程序的性能和资源利用情况。

3. 环境信息：Actuator 可以提供应用程序的环境信息，如操作系统、Java 版本、配置属性等。这对于了解应用程序运行环境非常有帮助。

4. 远程管理：Actuator 支持通过 HTTP 端点进行远程管理，可以通过发送 HTTP 请求来获取应用程序的状态信息、执行操作，如重新加载配置、关闭应用程序等。

5. 自定义端点：Actuator 允许开发人员自定义端点，可以根据需求添加自定义的监控和管理功能。

总之，Spring Boot Actuator 提供了丰富的功能和端点，可以帮助开发人员更好地了解和管理应用程序的运行时状态，提供了方便的监控和管理工具。

🍁08 Spring框架的事务管理有哪些优点？

Spring 框架的事务管理有以下优点：

1. 透明性。Spring 的事务管理是透明的，开发人员不需要编写大量的代码来管理事务。
2. 灵活性。Spring 的事务管理非常灵活，可以支持各种类型的事务管理策略。
3. 可扩展性。Spring 的事务管理可以扩展到其他框架，如 Hibernate 和 JTA。
4. 性能。Spring 的事务管理具有良好的性能，不会影响应用程序的性能。

总之，Spring 框架的事务管理是一个非常优秀的事务管理框架，它具有透明性、灵活性、可扩展性和性能等优点。

🍁09 使用Spring框架的好处是什么？

Spring 框架是一款非常优秀的 Java 框架，它提供了许多功能，可以帮助开发人员快速、简单地开发 Java 应用程序。Spring 框架的好处包括：

• 开箱即用。Spring 框架提供了许多常用的功能，开发人员可以直接使用，而不需要自己编写代码。
• 高度可配置。Spring 框架的配置非常灵活，开发人员可以根据自己的需要进行配置。
• 面向切面。Spring 框架支持面向切面编程，可以将业务逻辑和系统功能分离，提高代码的可维护性。
• 容器化。Spring 框架支持容器化，可以将应用程序部署到容器中，提高应用程序的可移植性。
• 测试驱动开发。Spring 框架支持测试驱动开发，可以帮助开发人员快速、简单地编写测试用例。

总之，Spring 框架是一款非常优秀的 Java 框架，它提供了许多功能，可以帮助开发人员快速、简单地开发 Java 应用程序。

🍁10 SpringBoot、Spring MVC 和 Spring 有什么区别？

Spring Boot、Spring MVC 和 Spring 是三个不同的框架，它们各有自己的特点。

• Spring Boot 是一个快速、简单、易于使用的框架，它提供了许多开箱即用的功能，可以帮助开发人员快速构建 Spring 应用程序。Spring Boot 还提供了许多生产级别的特性，如日志管理、健康检查、指标监控等。
• Spring MVC 是一个基于 MVC 设计模式的框架，它可以帮助开发人员构建灵活、可扩展的 Web 应用程序。Spring MVC 提供了许多功能，如视图层、控制器层、模型层等。
• Spring 是一个面向对象的框架，它提供了许多功能，如依赖注入、事务管理、安全管理等。Spring 可以用于构建各种类型的应用程序，包括 Web 应用程序、企业应用程序等。

以下是三者之间的对比：

特性	Spring Boot	Spring MVC	Spring
易用性	易用	中等	中等
功能	丰富	中等	丰富
生产级别特性	丰富	中等	中等
适用场景	快速构建 Spring 应用程序	构建灵活、可扩展的 Web 应用程序	构建各种类型的应用程序

总之，Spring Boot 是一个快速、简单、易于使用的框架，它提供了许多开箱即用的功能，可以帮助开发人员快速构建 Spring 应用程序。Spring MVC 是一个基于 MVC 设计模式的框架，它可以帮助开发人员构建灵活、可扩展的 Web 应用程序。Spring 是一个面向对象的框架，它提供了许多功能，如依赖注入、事务管理、安全管理等。Spring 可以用于构建各种类型的应用程序，包括 Web 应用程序、企业应用程序等。

🍁11 Async异步调用方法如何实现的？

Spring 提供了 @Async 注解来实现异步调用方法。使用 @Async 注解的方法会在单独的线程中执行，不会阻塞当前线程。

以下是一个使用 @Async 注解实现异步调用方法的例子：

@Service
public class HelloService {@Asyncpublic void hello(String name) {System.out.println("Hello, " + name);}}

在使用 @Async 注解时，需要注意以下几点：

• 方法必须是 public 方法。
• 方法必须没有返回值。
• 方法必须没有任何参数。
• 方法必须在 @Service 或 @Component 注解的类中。

如果需要在异步方法中返回结果，可以使用 CompletableFuture 对象。 CompletableFuture 对象是一个异步计算的容器，可以用于异步计算的结果。

以下是一个使用 CompletableFuture 对象实现异步调用方法的例子：

@Service
public class HelloService {@Asyncpublic CompletableFuture<String> hello(String name) {return CompletableFuture.supplyAsync(() -> {System.out.println("Hello, " + name);return "Hello, " + name;});}}

在使用 CompletableFuture 对象时，需要注意以下几点：

• CompletableFuture 对象必须是 public 方法。
• CompletableFuture 对象必须没有返回值。
• CompletableFuture 对象必须没有任何参数。
• CompletableFuture 对象必须在 @Service 或 @Component 注解的类中。

CompletableFuture 对象提供了 get() 方法来获取异步计算的结果。 get() 方法会阻塞当前线程，直到异步计算完成。

以下是一个使用 CompletableFuture 对象获取异步计算结果的例子：

@Service
public class HelloService {@Asyncpublic CompletableFuture<String> hello(String name) {return CompletableFuture.supplyAsync(() -> {System.out.println("Hello, " + name);return "Hello, " + name;});}public String helloSync(String name) {return hello(name).get();}}

在使用 CompletableFuture 对象时，还可以使用 thenApply() 方法来对异步计算的结果进行处理。 thenApply() 方法会在异步计算完成后，对结果进行处理，并返回一个新的 CompletableFuture 对象。

以下是一个使用 CompletableFuture 对象对异步计算的结果进行处理的例子：

@Service
public class HelloService {@Asyncpublic CompletableFuture<String> hello(String name) {return CompletableFuture.supplyAsync(() -> {System.out.println("Hello, " + name);return "Hello, " + name;});}public String helloSync(String name) {return hello(name).thenApply(result -> {System.out.println("Hello, " + result);return result;}).get();}}

CompletableFuture 对象还提供了许多其他方法，可以用于对异步计算的结果进行处理。

🍁12 什么是AOP代理？

AOP 代理是 Spring AOP 框架中的一个重要概念。AOP 代理是指在目标对象的基础上创建一个代理对象，并在代理对象中添加横切关注点的对象。

AOP 代理可以分为静态代理和动态代理。静态代理是指在编译期创建代理对象，动态代理是指在运行期创建代理对象。

Spring AOP 框架支持动态代理，可以通过 ProxyFactoryBean 类来创建代理对象。 ProxyFactoryBean 类提供了一个 setInterfaces() 方法，可以指定目标对象的接口。Spring AOP 框架会根据目标对象的接口创建代理对象。

Spring AOP 框架还提供了一个 setTarget() 方法，可以指定目标对象。Spring AOP 框架会在代理对象中调用目标对象的方法。

Spring AOP 框架还提供了一个 addAdvice() 方法，可以添加横切关注点的对象。Spring AOP 框架会在代理对象中调用横切关注点的对象的方法。

以下是一个使用 Spring AOP 框架创建代理对象的例子：

@Component
public class HelloService {public void hello(String name) {System.out.println("Hello, " + name);}}@Component
public class HelloServiceAdvice {public void before(String name) {System.out.println("Before hello, " + name);}public void after(String name) {System.out.println("After hello, " + name);}}@Configuration
public class AopConfig {@Beanpublic ProxyFactoryBean helloServiceProxy() {ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();proxyFactoryBean.setTarget(new HelloService());proxyFactoryBean.addAdvice(new HelloServiceAdvice());return proxyFactoryBean;}}public class AopTest {@Testpublic void test() {HelloService helloService = (HelloService) applicationContext.getBean("helloServiceProxy");helloService.hello("World");}}

在上述例子中，我们创建了一个 HelloService 类，该类有一个 hello() 方法。我们还创建了一个 HelloServiceAdvice 类，该类有一个 before() 方法和一个 after() 方法。

我们在 AopConfig 类中创建了一个 ProxyFactoryBean 对象，并将 HelloService 类作为目标对象。我们还将 HelloServiceAdvice 类作为横切关注点的对象。

我们在 AopTest 类中通过 applicationContext 获取 helloServiceProxy 对象，并调用 hello() 方法。

当我们调用 hello() 方法时，Spring AOP 框架会创建一个代理对象，并在代理对象中调用 HelloServiceAdvice 类的 before() 方法和 after() 方法。

🍁13 在Spring MVC应用程序中使用WebMvcTest注释有什么用处？

在 Spring MVC 应用程序中，使用 @WebMvcTest 注解可以进行针对控制器层的单元测试。它的作用是模拟 HTTP 请求，测试控制器的行为和返回结果，而无需启动完整的应用程序。

@WebMvcTest 注解会自动配置 Spring MVC 相关的组件，如控制器、视图解析器、消息转换器等，以便进行控制器的单元测试。

使用 @WebMvcTest 注解时，通常需要指定要测试的控制器类。例如， @WebMvcTest(MyController.class) 将只加载 MyController 类及其相关的组件，而不会加载其他不相关的组件。

以下是一个使用 @WebMvcTest 注解进行控制器单元测试的示例：

@RunWith(SpringRunner.class)
@WebMvcTest(MyController.class)
public class MyControllerTest {@Autowiredprivate MockMvc mockMvc;@Testpublic void testGetUser() throws Exception {mockMvc.perform(get("/user/{id}", 1)).andExpect(status().isOk()).andExpect(jsonPath("$.name").value("John")).andExpect(jsonPath("$.age").value(30));}}

在上述示例中，我们使用 @WebMvcTest 注解指定要测试的控制器类 MyController 。然后，我们使用 MockMvc 对象模拟 HTTP 请求，并使用 perform() 方法发起 GET 请求。最后，我们使用断言方法 andExpect() 验证响应的状态码和返回的 JSON 数据。

通过使用 @WebMvcTest 注解，我们可以专注于测试控制器的行为，而无需启动整个应用程序和依赖的组件，这样可以提高测试的速度和效率。

🍁14 SpringBoot配置文件的加载顺序？

在 Spring Boot 中，配置文件的加载顺序如下：

1. 命令行参数：通过命令行参数传递的配置会覆盖其他配置。例如，使用 --spring.config.name 和 --spring.config.location 参数指定配置文件的名称和位置。

2. 操作系统环境变量：Spring Boot 会自动加载操作系统环境变量中以 SPRING_ 开头的配置。

3. JVM 系统属性：Spring Boot 会自动加载 JVM 系统属性中以 spring. 开头的配置。

4. 配置文件：Spring Boot 会按照以下顺序加载配置文件：

   • classpath:/config/ 目录下的 application.properties 或 application.yml 文件。
   • classpath:/ 根目录下的 application.properties 或 application.yml 文件。
   • classpath:/config/ 目录下的 application-{profile}.properties 或 application-{profile}.yml 文件。
   • classpath:/ 根目录下的 application-{profile}.properties 或 application-{profile}.yml 文件。

其中， {profile} 是激活的配置文件的名称，例如 dev 、 prod 等。

1. 默认设置：Spring Boot 会使用内置的默认设置作为最后的备选项。

如果存在多个配置文件，后面加载的配置文件会覆盖前面加载的配置。例如，命令行参数中的配置会覆盖配置文件中的配置。

通过以上加载顺序，可以灵活地配置和管理 Spring Boot 应用程序的配置文件。

🍁15 介绍一下WebApplicationContext？

WebApplicationContext 是 Spring 框架中的一个接口，它是 ApplicationContext 的子接口，专门用于 Web 应用程序的上下文管理。

WebApplicationContext 提供了与 Web 相关的功能和特性，如处理 Servlet、监听 Web 事件、管理 Web 资源等。它可以与 Web 容器（如 Tomcat）集成，使得 Spring 应用程序能够更好地与 Web 环境进行交互。

WebApplicationContext 的主要特点和功能包括：

1. Web 环境集成：WebApplicationContext 可以与 Servlet 容器进行集成，提供与 Web 相关的功能，如处理 HTTP 请求、响应、会话管理等。

2. Web 作用域：WebApplicationContext 支持与 Web 相关的作用域，如 Request、Session、Application 等作用域。这使得在 Web 应用程序中可以方便地管理和共享数据。

3. Web 事件监听：WebApplicationContext 可以监听 Web 相关的事件，如 Servlet 生命周期事件、会话事件等。这使得在应用程序中可以对这些事件做出相应的处理。

4. Web 资源管理：WebApplicationContext 可以管理 Web 资源，如静态文件、模板文件、国际化资源等。这使得在应用程序中可以方便地访问和使用这些资源。

WebApplicationContext 可以通过不同的方式进行配置和创建，如在 web.xml 文件中配置、使用注解配置等。它是构建 Web 应用程序的关键组件之一，提供了与 Web 相关的功能和特性，使得 Spring 应用程序能够更好地与 Web 环境进行交互。

🍁16 什么是Spring的内部bean？

在 Spring 中，内部 bean（Inner Bean）是指在另一个 bean 的属性中定义的匿名 bean。与常规的 bean 不同，内部 bean 没有自己的 ID 或名称，它完全依赖于包含它的外部 bean。

内部 bean 的定义通常在外部 bean 的属性中使用 <bean> 元素进行嵌套。这样可以将内部 bean 的生命周期与外部 bean 相关联，当外部 bean 被销毁时，内部 bean 也会被销毁。

以下是一个使用内部 bean 的示例：

<bean id="outerBean" class="com.example.OuterBean"><property name="innerBean"><bean class="com.example.InnerBean"><!-- 内部 bean 的属性设置 --></bean></property>
</bean>

在上述示例中， outerBean 是一个外部 bean，它包含一个名为 innerBean 的内部 bean。内部 bean 的定义嵌套在外部 bean 的属性中。

使用内部 bean 的好处是可以将相关的 bean 组织在一起，并且内部 bean 的作用范围仅限于外部 bean，不会对其他组件产生影响。此外，内部 bean 的定义也可以更加简洁和清晰。

需要注意的是，由于内部 bean 没有自己的 ID 或名称，因此无法在容器中直接引用它。如果需要在其他地方引用内部 bean，可以使用外部 bean 的属性来传递引用。

🍁17 什么是Aspect切面？

Aspect（切面）是面向切面编程（AOP）中的一个重要概念。它用于描述横切关注点（Cross-cutting Concerns），即在应用程序中多个不同模块或类中共享的功能或行为。

横切关注点是与应用程序核心业务逻辑无关的功能，例如日志记录、事务管理、安全性检查等。通过使用切面，可以将这些横切关注点从核心业务逻辑中分离出来，提高代码的可维护性和重用性。

切面由切点（Pointcut）和通知（Advice）组成。

• 切点：切点是指在应用程序中选择特定连接点（Join Point）的表达式或规则。连接点是在应用程序执行过程中可以插入切面的特定位置，例如方法调用、方法执行、异常抛出等。切点定义了切面将在哪些连接点上执行。

• 通知：通知是切面在切点上执行的具体操作。通知可以在切点之前、之后或周围执行。常见的通知类型包括前置通知（Before）、后置通知（After）、返回通知（After Returning）和异常通知（After Throwing）。

通过将切面应用于切点，可以在应用程序的不同位置和阶段插入特定的功能，而无需修改核心业务逻辑。这样可以实现横切关注点的集中管理和复用。

Spring 框架提供了强大的 AOP 支持，可以使用注解或 XML 配置来定义切面和切点，并将切面应用于应用程序中的连接点。这样可以轻松实现日志记录、事务管理、安全性检查等功能，提高应用程序的可维护性和灵活性。

🍁18 SpringBoot集成mybatis的过程？

集成 MyBatis 到 Spring Boot 项目中的过程如下：

1. 添加依赖：在项目的 pom.xml 文件中添加 MyBatis 和 MyBatis-Spring 的依赖。

<dependencies><!-- MyBatis --><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.2.0</version></dependency><!-- 数据库驱动 --><dependency><groupId>com.h2database</groupId><artifactId>h2</artifactId><scope>runtime</scope></dependency>
</dependencies>

2. 配置数据源：在 application.properties 或 application.yml 文件中配置数据库连接信息。

properties
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.username=sa
spring.datasource.password=
spring.datasource.driver-class-name=org.h2.Driver

3. 创建实体类和 Mapper 接口：创建对应的实体类和 Mapper 接口，用于定义数据库表和操作。

public class User {private Long id;private String name;// getters and setters
}public interface UserMapper {List<User> getAllUsers();void insertUser(User user);// other methods
}

4. 创建 Mapper XML 文件：在 resources 目录下创建与 Mapper 接口对应的 XML 文件，用于编写 SQL 查询语句。

<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper"><select id="getAllUsers" resultType="com.example.entity.User">SELECT * FROM users</select><insert id="insertUser" parameterType="com.example.entity.User">INSERT INTO users (id, name) VALUES (#{id}, #{name})</insert><!-- other SQL statements -->
</mapper>

5. 注册 Mapper 接口：在 Spring Boot 的配置类中，使用 @MapperScan 注解扫描 Mapper 接口所在的包，并将其注册到 Spring 容器中。

@Configuration
@MapperScan("com.example.mapper")
public class MyBatisConfig {// additional configuration if needed
}

6. 使用 Mapper 接口：在需要使用 Mapper 接口的地方，通过依赖注入的方式使用它。

@Service
public class UserService {private final UserMapper userMapper;public UserService(UserMapper userMapper) {this.userMapper = userMapper;}public List<User> getAllUsers() {return userMapper.getAllUsers();}public void insertUser(User user) {userMapper.insertUser(user);}// other methods
}

以上是将 MyBatis 集成到 Spring Boot 项目中的基本步骤。根据实际需求，还可以进行更多的配置和扩展。

🍁19 SpringBoot的配置文件有哪几种格式？它们有什么区别？

Spring Boot 支持以下几种常见的配置文件格式：

1. Properties 格式：使用 .properties 文件作为配置文件，采用键值对的形式进行配置。每一行表示一个配置项，使用 = 或 : 分隔键和值。例如：

properties
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb

2. YAML 格式：使用 .yml 或 .yaml 文件作为配置文件，采用缩进和冒号的方式进行配置。使用层级结构表示不同的配置项。例如：

server:port: 8080
spring:datasource:url: jdbc:mysql://localhost:3306/mydb

3. JSON 格式：使用 .json 文件作为配置文件，采用 JSON 格式进行配置。与 YAML 类似，使用层级结构表示不同的配置项。例如：

{"server": {"port": 8080},"spring": {"datasource": {"url": "jdbc:mysql://localhost:3306/mydb"}}
}

这些配置文件格式在语法上有一些区别，但功能上是等效的。使用哪种格式取决于个人喜好和项目需求。一般来说，Properties 格式比较简单直观，适合简单的配置项；而 YAML 和 JSON 格式更适合复杂的配置项，具有更好的可读性和可维护性。在实际使用中，可以根据项目的需求选择合适的配置文件格式。

🍁20 如何重新加载 SpringBoot上的更改，而无需重新启动服务器？

在开发阶段，为了避免每次更改代码都需要重新启动服务器，可以使用 Spring Boot 的热部署功能来重新加载应用程序的更改。

以下是几种实现热部署的方式：

1. 使用开发工具支持：大多数集成开发环境（IDE）都支持 Spring Boot 的热部署。例如，使用 IntelliJ IDEA 可以在项目设置中启用 “自动编译” 选项，这样每次保存代码时，IDE 会自动重新编译并加载更改。

2. 使用 Spring Boot DevTools：Spring Boot 提供了一个名为 DevTools 的模块，可以实现热部署。只需将 spring-boot-devtools 依赖添加到项目中，然后在 IDE 中启用自动构建功能。当代码更改保存时，应用程序将自动重新加载。

3. 使用 Spring Loaded 或 JRebel：Spring Loaded 和 JRebel 是两个流行的第三方工具，可以实现更快的热部署。这些工具可以在不重新启动服务器的情况下加载更改，并且支持更广泛的代码更改。

请注意，热部署功能主要用于开发阶段，不建议在生产环境中使用。在生产环境中，建议将更改打包成可部署的文件，并重新启动服务器以加载更改。

🍁21 有哪些不同类型的IOC（依赖注入）方式？

有三种常见的依赖注入（IOC）方式：

1. 构造函数注入：通过构造函数将依赖项传递给类。在类的构造函数中声明依赖项，并在创建类的实例时将其传递给构造函数。这种方式可以保证依赖项的强制性，并且在创建对象时就能够满足依赖关系。

2. Setter 方法注入：通过 setter 方法将依赖项注入到类中。在类中声明依赖项的私有字段，并提供公共的 setter 方法来设置依赖项。在创建类的实例后，使用 setter 方法将依赖项注入到类中。这种方式相对灵活，可以在任何时候更改依赖项。

3. 接口注入：通过接口将依赖项注入到类中。在类中声明一个接口类型的字段，并提供一个公共的方法来设置依赖项。在创建类的实例后，通过调用该方法将依赖项注入到类中。这种方式可以实现更松散的耦合，允许在运行时更换依赖项的实现。

这些依赖注入方式的选择取决于具体的场景和需求。构造函数注入适用于必须满足依赖关系的情况，setter 方法注入适用于可选的依赖项或需要在运行时更改依赖项的情况，接口注入适用于需要实现依赖项替换的情况。

有三种常见的依赖注入（IOC）方式：构造函数注入、Setter 方法注入和接口注入。以下是每种方式的示例说明：

1. 构造函数注入：

public class UserService {private UserRepository userRepository;public UserService(UserRepository userRepository) {this.userRepository = userRepository;}// 方法使用userRepository进行操作
}

在上述示例中， UserService 类通过构造函数接收一个 UserRepository 对象作为依赖项。通过构造函数注入， UserService 类可以使用传递的 UserRepository 对象进行操作。

2. Setter 方法注入：

public class UserService {private UserRepository userRepository;public void setUserRepository(UserRepository userRepository) {this.userRepository = userRepository;}// 方法使用userRepository进行操作
}

在上述示例中， UserService 类提供了一个公共的 setUserRepository 方法，用于设置 UserRepository 对象作为依赖项。通过调用该方法，可以将 UserRepository 对象注入到 UserService 类中。

3. 接口注入：

public interface Notifier {void sendNotification(String message);
}public class EmailNotifier implements Notifier {public void sendNotification(String message) {// 发送电子邮件通知}
}public class UserService {private Notifier notifier;public void setNotifier(Notifier notifier) {this.notifier = notifier;}// 方法使用notifier进行操作
}

在上述示例中， UserService 类依赖于一个实现了 Notifier 接口的对象。通过提供一个公共的 setNotifier 方法，可以将实现了 Notifier 接口的对象注入到 UserService 类中。这样，可以在运行时更换不同的 Notifier 实现，例如使用 EmailNotifier 或者其他实现。

这些示例展示了不同的依赖注入方式，每种方式都适用于不同的场景和需求。构造函数注入适用于必需的依赖关系，Setter 方法注入适用于可选的依赖关系或需要在运行时更改依赖项的情况，接口注入适用于需要实现依赖项替换的情况。

🍁22 如何在自定义端口上运行SpringBoot应用程序？

要在自定义端口上运行 Spring Boot 应用程序，可以通过在配置文件中设置端口号或在启动命令中指定端口号来实现。

以下是两种常用的方法：

1. 在配置文件中设置端口号：在 application.properties 或 application.yml 配置文件中添加以下属性，并将端口号替换为所需的端口号。

- 使用  `application.properties`  文件：propertiesserver.port=8081- 使用  `application.yml`  文件：server:port: 8081

将端口号设置为所需的自定义端口号后，启动应用程序时将在该端口上运行。

2. 在启动命令中指定端口号：通过在启动命令中使用 --server.port 参数来指定端口号。

- 使用 Maven 插件启动应用程序：shellmvn spring-boot:run -Dspring-boot.run.arguments=--server.port=8081- 使用 Java 命令启动应用程序：shelljava -jar your-application.jar --server.port=8081

通过在启动命令中指定 --server.port 参数，并将端口号设置为所需的自定义端口号，应用程序将在指定的端口上运行。

使用上述方法之一，您可以在自定义端口上运行 Spring Boot 应用程序。确保选择一个未被其他进程占用的端口号。

🍁23 什么是JavaConfig？

JavaConfig 是一种用于配置 Java 应用程序的方法，它是通过 Java 代码而不是 XML 文件来定义和配置应用程序的组件和依赖关系。

JavaConfig 可以替代传统的 XML 配置方式，提供了更直观和类型安全的配置方式。它使用纯 Java 代码来定义和组织应用程序的配置信息，包括创建和初始化 Bean、配置属性、设置依赖关系等。

使用 JavaConfig 的好处包括：

1. 类型安全：JavaConfig 使用 Java 代码，可以在编译时进行类型检查，减少配置错误的可能性。

2. 可读性：JavaConfig 使用纯 Java 代码，可以更直观地理解和阅读应用程序的配置信息。

3. 可重构性：JavaConfig 可以通过重构工具进行重构，方便地修改和维护配置代码。

4. 集成开发环境支持：JavaConfig 可以与集成开发环境（IDE）集成，提供代码补全、语法高亮和重构等功能。

以下是一个使用 JavaConfig 的示例：

@Configuration
public class AppConfig {@Beanpublic UserService userService() {return new UserServiceImpl();}@Beanpublic UserRepository userRepository() {return new UserRepositoryImpl();}@Beanpublic UserController userController(UserService userService) {return new UserController(userService);}
}

在上述示例中， AppConfig 类使用 @Configuration 注解标记为配置类。通过 @Bean 注解定义了多个 Bean，包括 userService 、 userRepository 和 userController 。这些 Bean 可以通过依赖注入的方式在应用程序中使用。

通过使用 JavaConfig，可以更直观和类型安全地配置 Java 应用程序，提高可读性和可维护性。它是一种现代化的配置方式，逐渐取代了传统的 XML 配置方式。

🍁24 什么是REST/RESTful以及它的用途是什么？

REST（Representational State Transfer）是一种软件架构风格，用于设计网络应用程序的分布式系统。它是一种基于 HTTP 协议的通信方式，通过使用统一的接口和无状态的通信方式来实现系统间的交互。

RESTful 是符合 REST 原则的 Web 服务的称呼。它是一种设计和实现 Web API 的方式，提供了一组规范和约束，使得 Web 服务可以更加简单、可扩展和易于理解。

RESTful Web 服务的特点包括：

1. 资源导向：RESTful Web 服务将系统中的各种资源（如用户、订单、文章等）作为 Web 资源进行建模，并通过 URI（统一资源标识符）来标识和访问这些资源。

2. 无状态：RESTful Web 服务是无状态的，即服务器不会保存客户端的状态信息。每个请求都包含了足够的信息来处理请求，并且服务器不会在请求之间保留任何状态。

3. 统一接口：RESTful Web 服务使用统一的接口进行通信，通常使用 HTTP 协议的 GET、POST、PUT、DELETE 等方法来操作资源。

4. 可缓存：RESTful Web 服务支持缓存机制，可以缓存响应结果，提高性能和可伸缩性。

RESTful Web 服务的用途包括：

1. 构建 Web API：RESTful Web 服务可以用于构建 Web API，提供给其他应用程序或客户端进行访问和使用。

2. 移动应用后端：RESTful Web 服务可以作为移动应用的后端，提供数据和功能的访问接口。

3. 微服务架构：RESTful Web 服务可以作为微服务架构中的一个服务单元，实现各个微服务之间的通信和协调。

4. 分布式系统：RESTful Web 服务可以用于构建分布式系统，实现不同系统之间的集成和交互。

总之，REST/RESTful 是一种基于 HTTP 协议的软件架构风格，用于设计和实现分布式系统和 Web 服务。它提供了一种简单、可扩展和易于理解的方式来构建和使用 Web API。

🍁25 如何在SpringBoot中禁用Actuator端点安全性？

在 Spring Boot 中，可以通过配置来禁用 Actuator 端点的安全性。Actuator 端点的安全性是通过 Spring Security 进行管理的。

要禁用 Actuator 端点的安全性，可以在 application.properties 或 application.yml 文件中添加以下配置：

properties
management.endpoints.web.exposure.include=*或management:endpoints:web:exposure:include: "*"

以上配置将包含所有 Actuator 端点，并且不需要进行身份验证或授权即可访问。

请注意，禁用 Actuator 端点的安全性可能会带来安全风险，因为任何人都可以访问敏感信息或执行敏感操作。因此，在生产环境中，建议仅允许受信任的用户或服务访问 Actuator 端点，并配置适当的身份验证和授权机制。

🍁26 SpringBoot自动配置原理是什么？

Spring Boot 的自动配置是通过条件化配置和自动装配机制实现的。

自动配置的原理如下：

1. 条件化配置：Spring Boot 使用条件化配置来根据当前应用程序的环境和配置属性决定是否应该应用某个配置。条件化配置使用 @Conditional 注解来标记，可以根据条件返回一个 boolean 值，决定是否应用该配置。

2. 自动装配：Spring Boot 使用自动装配来自动配置应用程序的各个组件。自动装配是通过 @EnableAutoConfiguration 注解实现的，它会根据类路径上的依赖和条件化配置来自动配置应用程序的组件。

3. 自动配置类：Spring Boot 提供了许多自动配置类，这些类用于自动配置应用程序的各个组件，如数据库连接、缓存、消息队列等。自动配置类通常使用条件化配置来决定是否应用某个配置。

4. 配置属性：Spring Boot 使用配置属性来配置应用程序的各个组件。配置属性可以通过 application.properties 或 application.yml 文件中的键值对来设置，也可以通过自定义的配置类来定义。

总体来说，Spring Boot 的自动配置是通过条件化配置和自动装配机制来实现的。它通过判断条件和配置属性来决定是否应用某个配置，并自动配置应用程序的各个组件，使开发人员能够快速、简单地构建应用程序。

🍁27 SpringBoot如何设置支持跨域请求？

在 Spring Boot 中，可以通过配置来支持跨域请求。跨域请求是指在浏览器中发起的跨域（不同域名、端口或协议）的 HTTP 请求。

以下是几种常见的设置支持跨域请求的方法：

1. 使用 @CrossOrigin 注解：可以在控制器的方法上使用 @CrossOrigin 注解来指定允许跨域请求的来源、方法和头信息。

@RestController
public class MyController {@CrossOrigin(origins = "http://example.com")@GetMapping("/api/data")public String getData() {// 处理请求}}

2. 使用 WebMvcConfigurer 配置：可以创建一个实现 WebMvcConfigurer 接口的配置类，并重写 addCorsMappings 方法来配置跨域请求。

@Configuration
public class WebConfig implements WebMvcConfigurer {@Overridepublic void addCorsMappings(CorsRegistry registry) {registry.addMapping("/api/**").allowedOrigins("http://example.com").allowedMethods("GET", "POST").allowedHeaders("header1", "header2").exposedHeaders("header3").allowCredentials(true).maxAge(3600);}}

3. 使用 Filter 进行全局配置：可以创建一个 Filter 类来处理跨域请求，并在 Filter 中设置响应头信息。

@Component
public class CorsFilter implements Filter {@Overridepublic void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {HttpServletResponse response = (HttpServletResponse) res;response.setHeader("Access-Control-Allow-Origin", "http://example.com");response.setHeader("Access-Control-Allow-Methods", "GET, POST");response.setHeader("Access-Control-Allow-Headers", "header1, header2");response.setHeader("Access-Control-Expose-Headers", "header3");response.setHeader("Access-Control-Allow-Credentials", "true");response.setHeader("Access-Control-Max-Age", "3600");chain.doFilter(req, res);}}

以上方法可以根据具体需求选择适合的方式来设置支持跨域请求。通过配置跨域请求，可以允许浏览器发起跨域的 HTTP 请求，并处理相应的跨域请求。

🍁28 解释Spring框架中bean的生命周期？

在 Spring 框架中，bean 的生命周期包括以下几个阶段：

1. 实例化：在 Spring 容器启动时，根据配置信息实例化 bean 对象。这通常是通过调用构造函数来创建 bean 的实例。

2. 属性注入：在实例化之后，Spring 容器会通过依赖注入（Dependency Injection）的方式将属性值注入到 bean 中。这可以通过构造函数注入、Setter 方法注入或字段注入来实现。

3. 初始化：在属性注入完成后，Spring 容器会调用 bean 的初始化方法。可以通过在 bean 上使用 @PostConstruct 注解或实现 InitializingBean 接口来指定初始化方法。

4. 使用：在初始化完成后，bean 可以被应用程序使用。在这个阶段，bean 可以响应应用程序的请求和调用。

5. 销毁：在应用程序关闭或 Spring 容器销毁时，会调用 bean 的销毁方法。可以通过在 bean 上使用 @PreDestroy 注解或实现 DisposableBean 接口来指定销毁方法。

在整个生命周期中，Spring 容器负责管理 bean 的创建、属性注入、初始化和销毁过程。通过配置和注解，可以灵活地控制 bean 的生命周期，并在需要的时候执行特定的操作。这样可以确保 bean 在正确的时间点进行初始化和销毁，以满足应用程序的需求。

🍁29 spring 提供了哪些配置方式？

Spring 提供了多种配置方式，以适应不同的需求和偏好：

1. XML 配置：使用 XML 文件进行配置是传统的方式，在 XML 文件中定义 bean、依赖关系和配置属性。可以使用 Spring 的命名空间和标签来简化配置。

2. 基于注解的配置：使用注解来配置 bean、依赖关系和配置属性，可以通过在类或方法上添加注解来实现。常用的注解包括 @Component 、 @Autowired 、 @Value 等。

3. 基于 Java 的配置：使用 Java 代码来配置 bean、依赖关系和配置属性，可以通过编写配置类和方法来实现。常用的配置注解包括 @Configuration 、 @Bean 、 @Import 等。

4. 属性文件配置：使用属性文件（如 .properties 或 .yml ）来配置 bean 的属性值，可以通过占位符和 SpEL 表达式来引用属性值。

5. 注解扫描：使用 @ComponentScan 注解来自动扫描指定包下的组件，并将其注册为 bean，无需显式配置每个 bean。

6. 外部化配置：将配置信息从代码中分离出来，可以使用属性文件、环境变量、命令行参数等来配置应用程序的行为。

7. 条件化配置：根据条件来决定是否加载特定的 bean 或配置，可以使用 @Conditional 注解来实现。

这些配置方式可以单独使用，也可以组合使用，以满足不同场景的需求。根据项目的需求和个人偏好，选择适合的配置方式。

🍁30 如何在 SpringBoot 启动的时候运行一些特定的代码？

在 Spring Boot 启动时运行特定的代码，可以使用 CommandLineRunner 或 ApplicationRunner 接口。

1. CommandLineRunner ：实现 CommandLineRunner 接口的类可以在 Spring Boot 应用程序启动后执行特定的代码。该接口定义了一个 run() 方法，可以在其中编写需要在启动时执行的逻辑。

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;@Component
public class MyCommandLineRunner implements CommandLineRunner {@Overridepublic void run(String... args) throws Exception {// 在启动时执行的代码}
}

2. ApplicationRunner ：与 CommandLineRunner 类似，实现 ApplicationRunner 接口的类也可以在 Spring Boot 应用程序启动后执行特定的代码。该接口定义了一个 run() 方法，可以在其中编写需要在启动时执行的逻辑。

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;@Component
public class MyApplicationRunner implements ApplicationRunner {@Overridepublic void run(ApplicationArguments args) throws Exception {// 在启动时执行的代码}
}

这两种方式都可以用来在 Spring Boot 启动时执行一些特定的代码，例如初始化数据库连接、加载配置文件、执行定时任务等。只需将实现了相应接口的类标记为 @Component 或注册为 Bean，Spring Boot 就会自动执行对应的代码。

🍁31 为什么我们不建议在实际的应用程序中使用 Spring Data Rest?

在实际的应用程序中，使用 Spring Data REST 可能不适合所有的需求，因此不建议在所有情况下使用它。以下是一些原因：

1. 灵活性受限：Spring Data REST 提供了一种自动化的方式来将 RESTful API 暴露给客户端，但它的功能和自定义能力相对有限。如果应用程序需要更复杂的业务逻辑或自定义的 API 行为，可能需要使用其他方式来实现。

2. 安全性限制：Spring Data REST 提供了一些基本的安全性功能，如基于角色的访问控制，但对于更复杂的安全性需求，可能需要使用其他安全性框架或自定义解决方案。

3. 性能考虑：使用 Spring Data REST 可能会引入一些性能开销，特别是在处理大量数据或复杂查询时。对于对性能要求较高的应用程序，可能需要使用更直接的方式来处理数据访问。

4. 过度暴露数据：Spring Data REST 的主要目标是通过自动化方式暴露数据，但有时候我们可能需要更细粒度地控制数据的暴露程度，以保护敏感数据或遵守特定的业务规则。

尽管 Spring Data REST 提供了一种方便的方式来快速创建 RESTful API，但在实际的应用程序中，我们需要根据具体的需求和要求来评估是否使用它。对于简单的 CRUD 操作，Spring Data REST 可能是一个不错的选择，但对于更复杂的业务逻辑和需求，可能需要使用其他方式来实现更灵活和定制化的解决方案。

🍁32 spring支持集中bean scope？

是的，Spring 框架支持多种不同的 Bean 作用域（Scope），可以根据应用程序的需求选择合适的作用域。

以下是 Spring 框架支持的一些常见的 Bean 作用域：

1. Singleton：默认的作用域，每个容器中只有一个实例，所有对该 Bean 的请求都返回同一个实例。

2. Prototype：每次请求都创建一个新的实例。

3. Request：每个 HTTP 请求创建一个新的实例，适用于 Web 应用程序。

4. Session：每个用户会话创建一个新的实例，适用于 Web 应用程序。

5. Global Session：每个全局会话创建一个新的实例，适用于 Web 应用程序。

6. Application：整个应用程序生命周期内只创建一个实例。

7. Websocket：每个 Websocket 连接创建一个新的实例。

可以使用 @Scope 注解或 XML 配置文件来指定 Bean 的作用域。例如，在使用 @Scope 注解时，可以将其应用于类级别或方法级别，指定所需的作用域。

@Component
@Scope("prototype")
public class MyBean {// Bean 的定义
}

在 XML 配置文件中，可以使用 <bean> 元素的 scope 属性来指定作用域。

<bean id="myBean" class="com.example.MyBean" scope="prototype"><!-- Bean 的定义 -->
</bean>

选择合适的 Bean 作用域可以帮助管理和控制对象的生命周期和资源消耗。根据应用程序的需求，可以根据不同的场景选择适当的作用域。

🍁33 SpringBoot打成的jar和普通的jar有什么区别？

Spring Boot 打成的 JAR 和普通的 JAR 之间有一些区别。

1. 可执行性：Spring Boot 打成的 JAR 是可执行的，可以直接通过 java -jar 命令来运行。它内嵌了一个嵌入式的 Web 服务器（通常是 Tomcat），可以直接运行 Spring Boot 应用程序。

2. 自包含性：Spring Boot 打成的 JAR 是自包含的，它包含了应用程序的所有依赖关系，不需要额外的部署步骤。这样可以简化部署过程，减少对环境的依赖。

3. 约定优于配置：Spring Boot 打成的 JAR 遵循了 Spring Boot 的约定优于配置的原则，通过自动配置和默认值，减少了开发人员的配置工作。只需提供必要的配置，即可快速启动应用程序。

4. 内置功能：Spring Boot 打成的 JAR 内置了许多常用的功能，如健康检查、指标监控、配置管理等。这些功能可以通过配置文件进行自定义和扩展。

普通的 JAR 文件则没有上述特点。它通常是一个包含类文件和资源文件的归档文件，需要在运行时手动配置和部署。

总之，Spring Boot 打成的 JAR 具有可执行性、自包含性、约定优于配置和内置功能等特点，使得应用程序的部署和运行更加简单和高效。

🍁34 SpringBoot2.X有什么新特性？与1.X有什么区别？

Spring Boot 2.x 相对于 1.x 版本带来了许多新特性和改进。以下是 Spring Boot 2.x 的一些主要新特性和与 1.x 版本的区别：

1. 对 Java 8 的支持：Spring Boot 2.x 对 Java 8 的支持更加完善，可以充分利用 Java 8 的新特性，如函数式编程、Stream API 等。

2. 升级了依赖：Spring Boot 2.x 升级了许多依赖的版本，如 Spring Framework 5.x、Spring Data 2.x、Hibernate 5.x 等，以提供更好的性能和功能。

3. 全面支持响应式编程：Spring Boot 2.x 引入了对响应式编程的全面支持，包括对 Reactor、WebFlux 和 WebClient 的集成，使得构建响应式应用程序更加简单和高效。

4. 自动配置改进：Spring Boot 2.x 对自动配置进行了改进，提供了更精确的条件匹配和更细粒度的配置选项，以满足不同场景下的需求。

5. 监控和管理功能增强：Spring Boot 2.x 引入了更多的监控和管理功能，如健康检查、指标监控、远程 shell 等，使得应用程序的监控和管理更加便捷。

6. 对安全性的增强：Spring Boot 2.x 引入了更多的安全特性和改进，如 OAuth 2.0 的支持、JWT 的集成、安全事件的发布等，提供了更强大的安全性能和功能。

7. 性能优化和稳定性改进：Spring Boot 2.x 进行了许多性能优化和稳定性改进，提供了更高的性能和更可靠的运行环境。

总之，Spring Boot 2.x 相对于 1.x 版本带来了许多新特性和改进，包括对 Java 8 的支持、响应式编程的全面支持、自动配置的改进、监控和管理功能的增强、安全性的增强、性能优化和稳定性改进等。这些改进使得 Spring Boot 2.x 更加强大、高效和易用。

以下是 Spring Boot 2.x 相对于 1.x 版本的一些主要新特性和区别的对比表格：

特性/区别	Spring Boot 1.x	Spring Boot 2.x
Java 版本	支持 Java 6+	支持 Java 8+
Spring 版本	Spring Framework 4.x	Spring Framework 5.x
响应式编程	不支持响应式编程	支持响应式编程，引入 Reactor、WebFlux 和 WebClient
自动配置	自动配置相对简单	自动配置更精确，条件匹配更准确
安全性	基本的安全功能	增强的安全特性，如 OAuth 2.0 支持、JWT 集成等
监控和管理	基本的监控和管理功能	更多的监控和管理功能，如健康检查、指标监控、远程 shell 等
性能优化	一些性能优化	更多的性能优化和稳定性改进
数据库支持	支持传统的关系型数据库	支持传统的关系型数据库，同时增加对 NoSQL 数据库的支持
日志	默认使用 Logback	默认使用 Logback，同时支持其他日志框架
异步编程	支持异步编程	支持异步编程，提供更好的性能和可伸缩性
测试	基本的测试支持	增强的测试支持，如 WebTestClient、MockMvc 等
Actuator	基本的监控和管理功能	更多的监控和管理功能，如新的端点、自定义端点等

需要注意的是，上述表格只列出了一些主要的新特性和区别，实际上 Spring Boot 2.x 相对于 1.x 版本带来了更多的改进和功能增强。具体选择使用哪个版本取决于项目需求和实际场景。

🍁35 什么是Spring配置文件？

Spring 配置文件是用于配置和定义 Spring 框架中的组件、依赖关系和行为的文件。它们用于描述应用程序的结构和配置选项，以及与其他组件的交互方式。

Spring 配置文件可以使用多种格式，包括 XML、Java 注解和 Java 配置类。以下是几种常见的 Spring 配置文件格式：

1. XML 配置：使用 XML 格式的配置文件，例如 applicationContext.xml 。在 XML 文件中，可以定义 bean、依赖关系、切面、拦截器等。

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="userService" class="com.example.UserService"><property name="userRepository" ref="userRepository" /></bean><bean id="userRepository" class="com.example.UserRepository" /></beans>

2. Java 注解配置：使用 Java 注解来配置组件和依赖关系，例如使用 @Component 、 @Autowired 、 @Configuration 等注解。

@Configuration
public class AppConfig {@Beanpublic UserService userService(UserRepository userRepository) {return new UserService(userRepository);}@Beanpublic UserRepository userRepository() {return new UserRepository();}}

3. Java 配置类：使用专门的 Java 配置类来配置应用程序的组件和依赖关系。

@Configuration
public class AppConfig {@Beanpublic UserService userService(UserRepository userRepository) {return new UserService(userRepository);}@Beanpublic UserRepository userRepository() {return new UserRepository();}}

Spring 配置文件允许开发人员定义应用程序的结构和行为，以及配置各种组件之间的依赖关系。通过使用适当的配置文件格式，可以轻松地配置和管理 Spring 应用程序的各个方面。

🍁36 解释不同方式的自动装配？

在 Spring 框架中，有三种主要的自动装配方式：

1. 按名称自动装配（byName）：通过 bean 的名称来自动装配依赖。Spring 容器会根据属性的名称与容器中的 bean 名称进行匹配，如果找到匹配的 bean，则自动将其注入。

<bean id="userService" class="com.example.UserService"><property name="userRepository" ref="userRepository" />
</bean><bean id="userRepository" class="com.example.UserRepository" />

2. 按类型自动装配（byType）：通过属性的类型来自动装配依赖。Spring 容器会根据属性的类型与容器中的 bean 类型进行匹配，如果找到唯一匹配的 bean，则自动将其注入。

<bean id="userService" class="com.example.UserService"><property name="userRepository" />
</bean><bean id="userRepository" class="com.example.UserRepository" />

3. 构造函数自动装配（constructor）：通过构造函数来自动装配依赖。Spring 容器会根据构造函数的参数类型与容器中的 bean 类型进行匹配，如果找到匹配的 bean，则自动通过构造函数注入。

<bean id="userService" class="com.example.UserService"><constructor-arg ref="userRepository" />
</bean><bean id="userRepository" class="com.example.UserRepository" />

这些自动装配方式可以在 XML 配置文件中使用，也可以使用注解方式实现。例如，使用 @Autowired 注解来标记需要自动装配的属性。

自动装配可以简化 Spring 应用程序中的依赖注入，减少手动配置的工作量。根据具体的场景和需求，可以选择适合的自动装配方式。

🍁37 SpringBoot实现热部署有哪几种方式？

在 Spring Boot 中，可以使用以下几种方式实现热部署：

1. 使用 Spring Boot DevTools：Spring Boot DevTools 是一个开发工具包，可以实现热部署。它提供了自动重启应用程序的功能，当代码发生变化时，应用程序会自动重新启动。只需在项目的依赖中添加 spring-boot-devtools ，并启用自动构建功能。

2. 使用 Spring Loaded 或 JRebel：Spring Loaded 和 JRebel 是两个第三方工具，可以实现更快的热部署。它们可以在不重新启动服务器的情况下加载代码变化，并支持更广泛的代码更改。

3. 使用触发器（Trigger）：可以使用文件触发器或目录触发器来监视文件或目录的变化，并在变化发生时重新加载应用程序。这可以通过使用 Spring Boot Actuator 的 /actuator/restart 端点来实现。

需要注意的是，热部署功能主要用于开发阶段，不建议在生产环境中使用。在生产环境中，通常会将更改打包成可部署的文件，并重新启动服务器以加载更改。

🍁38 spring中有多少种IOC容器？

在 Spring 框架中，有两种常见的 IOC（控制反转）容器：

1. BeanFactory：BeanFactory 是 Spring 框架最基本的 IOC 容器。它是一个工厂模式的实现，负责创建和管理对象（Bean）。BeanFactory 提供了依赖注入（DI）和生命周期管理等核心功能。它是 Spring 框架的核心接口，提供了很多实现类，如 XmlBeanFactory、AnnotationConfigApplicationContext 等。

2. ApplicationContext：ApplicationContext 是 BeanFactory 的子接口，它在 BeanFactory 的基础上提供了更多的功能和特性。ApplicationContext 是 Spring 框架中更高级、更强大的 IOC 容器。它除了提供 BeanFactory 的核心功能外，还提供了国际化支持、事件传播、资源管理、AOP（面向切面编程）等扩展功能。ApplicationContext 的常见实现类有 ClassPathXmlApplicationContext、AnnotationConfigApplicationContext 等。

这两种 IOC 容器都可以用于管理和注入对象，但 ApplicationContext 是更常用和推荐的容器，因为它提供了更多的功能和便利性。ApplicationContext 可以通过配置文件（如 XML 配置文件或 Java 配置类）来创建和配置，也可以通过注解来自动扫描和注册 Bean。

总之，Spring 框架中有两种常见的 IOC 容器，即 BeanFactory 和 ApplicationContext。ApplicationContext 是 BeanFactory 的子接口，提供了更多的功能和特性，是更常用和推荐的 IOC 容器。

🍁39 @SpringBootApplication注释在内部有什么用处?

@SpringBootApplication 注解是一个组合注解，它包含了多个注解的功能，方便快速配置和启动 Spring Boot 应用程序。

@SpringBootApplication 注解在内部包含了以下三个注解：

1. @Configuration ：表示该类是一个配置类，用于定义和配置 Spring Bean。

2. @EnableAutoConfiguration ：启用 Spring Boot 的自动配置功能，根据项目的依赖和配置，自动配置 Spring 应用程序的各种组件。

3. @ComponentScan ：扫描指定包及其子包，将符合条件的组件自动注册到 Spring 容器中。

通过使用 @SpringBootApplication 注解，可以简化配置和启动 Spring Boot 应用程序的过程。它提供了自动配置、组件扫描和 Bean 注册等功能，减少了开发人员的工作量。

在使用 @SpringBootApplication 注解时，通常将它放在应用程序的入口类上，即包含 main 方法的类。这样可以确保在启动应用程序时自动完成配置和初始化工作。

总之， @SpringBootApplication 注解的作用是简化配置和启动 Spring Boot 应用程序的过程，同时提供自动配置、组件扫描和 Bean 注册等功能。

🍁40 如何在 SpringBoot 中禁用 Actuator 端点安全性？

在 Spring Boot 中，可以通过配置来禁用 Actuator 端点的安全性。默认情况下，Actuator 端点是需要进行安全认证的，但可以根据需要进行配置以禁用安全性。

要禁用 Actuator 端点的安全性，可以按照以下步骤进行操作：

1. 在 application.properties 或 application.yml 文件中添加以下配置：

propertiesmanagement.endpoints.web.exposure.include=*management.security.enabled=false

上述配置将启用所有 Actuator 端点，并禁用安全性。

2. 如果只想禁用特定的 Actuator 端点，可以在上述配置中指定要禁用的端点，例如：

propertiesmanagement.endpoints.web.exposure.include=health,infomanagement.security.enabled=false

上述配置将只启用 health 和 info 两个端点，并禁用安全性。

请注意，禁用 Actuator 端点的安全性可能会导致安全风险，因为这些端点通常包含有关应用程序的敏感信息。在生产环境中，建议仅将必要的端点暴露出去，并进行适当的安全配置。

这篇关于温度而知新，一文夯实Spring知识文集(1)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---