Spring、SpringMVC、SpringBoot面试题

主要参考以下资料并加入一些平时学习时的问题做整理！！！ 如果版权问题，立刻删除！

参考资料：
尚硅谷2023新版Spring零基础入门到进阶，一套搞定spring6全套视频教程（源码级讲解）_哔哩哔哩_bilibili

【尚硅谷】SpringMVC教程丨一套快速上手spring mvc_哔哩哔哩_bilibili

新版Java面试专题视频教程，java八股文面试全套真题+深度详解（含大厂高频面试真题）_哔哩哔哩_bilibili

黑马程序员2023新版JavaWeb开发教程，实现javaweb企业开发全流程（涵盖Spring+MyBatis+SpringMVC+SpringBoot等）_哔哩哔哩_bilibili

Spring常见面试题总结

Spring

1、Spring中bean的生命周期有哪些阶段？

①通过BeanDefinition获取bean的定义信息（这里面就封装了bean的所有信息，比如，类的全路径，是否是延迟加载，是否是单例等等这些信息）

②调用构造函数实例化bean

③bean的依赖注入（像平时开发用的 @Autowire都是这一步完成）

④处理Aware接口（注入一些与容器相关信息）(BeanNameAware、BeanFactoryAware、ApplicationContextAware)

⑤Bean的后置处理器BeanPostProcessor的postProcessBeforeInitialization方法

⑥初始化方法(InitializingBean、init-method)

⑦Bean的后置处理器BeanPostProcessor的postProcessAfterInitialization方法

⑧销毁bean

2、什么是控制反转？

• 将对象的创建权利交出去，交给Spring框架管理。
• 将对象和对象之间关系的维护权交出去，交给Spring框架管理。

3、有那两种常见的依赖注入的实现方式？

• 第一种：set注入
• 第二种：构造注入

4、将一个类声明为Bean的注解有哪些？

• @Component：通用的注解，可标注任意类为 Spring 组件。如果一个 Bean 不知道属于哪个层，可以使用@Component 注解标注。
• @Repository : 对应持久层即 Dao 层，主要用于数据库相关操作。
• @Service : 对应服务层，主要涉及一些复杂的逻辑，需要用到 Dao 层。
• @Controller : 对应 Spring MVC 控制层，主要用于接受用户请求并调用 Service 层返回数据给前端页面。

5、@Component 和 @Bean 的区别是什么？

• @Component 注解作用于类，而@Bean注解作用于方法。

• @Component通常是通过类路径扫描来自动侦测以及自动装配到 Spring 容器中（我们可以使用 @ComponentScan 注解定义要扫描的路径从中找出标识了需要装配的类自动装配到 Spring 的 bean 容器中）。@Bean 注解通常是我们在标有该注解的方法中定义产生这个 bean,@Bean告诉了 Spring 这是某个类的实例，当我需要用它的时候还给我。

• @Bean 注解比 @Component 注解的自定义性更强，而且很多地方我们只能通过 @Bean 注解来注册 bean。比如当我们引用第三方库中的类需要装配到 Spring容器时，则只能通过 @Bean来实现

  @Configuration
  public class AppConfig {
      @Bean
      public TransferService transferService() {
          return new TransferServiceImpl();
      }
  
  }
  
  //等同于
  <beans>
      <bean id="transferService" class="com.acme.TransferServiceImpl"/>
  </beans>
  
  // 下面这个例子无法通过@Component实现
  @Bean
  public OneService getService(status) {
      case (status)  {
          when 1:
                  return new serviceImpl1();
          when 2:
                  return new serviceImpl2();
          when 3:
                  return new serviceImpl3();
      }
  }
  

6、说说@Autowired的注入方式以及@Resource ？

• Autowired 属于 Spring 内置的注解，默认的注入方式为byType（根据类型进行匹配）
• 当一个接口存在多个实现类的话，注入方式会变为 byName（根据名称进行匹配），这个名称通常就是类名（首字母小写）。建议通过 @Qualifier 注解来显式指定名称而不是依赖变量的名称。
• @Resource 是 JDK 提供的注解，默认注入方式为 byName（根据名称进行匹配），@Resource可以通过 name 属性来显式指定名称。@Resource注解只能用在属性上、setter方法上。

7、Bean 的作用域有哪些?

Spring 中 Bean 的作用域通常有下面几种：

• singleton : IoC 容器中只有唯一的 bean 实例。Spring 中的 bean 默认都是单例的，是对单例设计模式的应用。
• prototype : 每次获取都会创建一个新的 bean 实例。也就是说，连续 getBean() 两次，得到的是不同的 Bean 实例。
• request （仅 Web 应用可用）: 每一次 HTTP 请求都会产生一个新的 bean（请求 bean），该 bean 仅在当前 HTTP request 内有效。
• session （仅 Web 应用可用） : 每一次来自新 session 的 HTTP 请求都会产生一个新的 bean（会话 bean），该 bean 仅在当前 HTTP session 内有效。
• application/global-session （仅 Web 应用可用）：每个 Web 应用在启动时创建一个 Bean（应用 Bean），该 bean 仅在当前应用启动时间内有效。
• websocket （仅 Web 应用可用）：每一次 WebSocket 会话产生一个新的 bean。

8、单例 Bean 存在线程安全问题吗？

• 大部分 Bean 实际都是无状态，所以是线程安全的。
• 有状态（成员变量）的bean会存在线程安全问题，解决方法有两种：
  • 在 Bean 中尽量避免定义可变的成员变量。
  • 在类中定义一个 ThreadLocal 成员变量，将需要的可变成员变量保存在 ThreadLocal 中（推荐的一种方式）。
  • 将多态bean的作用由singleton变更为 prototype。

9、Spring如何整合第三方框架？

• FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。

10、@Autowired可以标注在哪里？

• 构造方法
• set方法
• 构造函数的形参上
• 属性上
• @Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。

11、什么是Spring中的循环引用问题？怎么解决？

• 循环依赖：循环依赖其实就是循环引用,也就是两个或两个以上的bean互相持有对方,最终形成闭环。比如A依赖于B,B依赖于A
• 循环依赖在spring中是允许存在，spring框架依据三级缓存已经解决了大部分的循环依赖（set注入）

  • ①一级缓存：单例池，缓存已经经历了完整的生命周期，已经初始化完成的 bean对象

  • ②二级缓存：缓存早期的bean对象（生命周期还没走完）

  • ③三级缓存：缓存的是ObjectFactory，表示对象工厂，用来创建某个对象的

  • 具体流程：
    

    • 先实例A对象，同时会创建ObjectFactory对象存入三级缓存 singletonFactories
    • B实例化完成，也会创建ObjectFactory对象存入三级缓存 singletonFactories
    • B需要注入A，通过三级缓存中获取ObjectFactory来生成一个A的对象，同时存入二级缓存，这个是有两种情况，一个是可能是A的普通对象，另外一个是A的代理对象，都可以让ObjectFactory来生产对应的对象，这也是三级缓存的关键
    • B通过从二级缓存earlySingletonObjects 获得到A的对象后可以正常注入，B创建成功，存入一级缓存singletonObjects
    • 回到A对象初始化，因为B对象已经创建完成，则可以直接注入B，A 创建成功存入一次缓存singletonObjects
    • 二级缓存中的临时对象A清除
• 探究：构造方法出现循环依赖怎么解决？
  • 由于bean的生命周期中构造函数是第一个执行的，spring框架并不能解决构造函数的的依赖注入，可以使用**@Lazy懒加载**，什么时候需要对象再进行 bean对象的创建。

12、什么是AOP？AOP的原理是什么？

• AOP是一种设计思想，面向切面编程。
• Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么 Spring AOP 会使用 JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会使用 Cglib 生成一个被代理对象的子类来作为代理。
• 作用：
  • 简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。
  • 代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。

13、AOP中有哪些通知类型？

• Before（前置通知）：目标对象的方法调用之前触发
• After （后置通知）：目标对象的方法调用之后触发
• AfterReturning（返回通知）：目标对象的方法调用完成，在返回结果值之后触发
• AfterThrowing（异常通知）：目标对象的方法运行中抛出 / 触发异常后触发。AfterReturning 和 AfterThrowing 两者互斥。如果方法调用成功无异常，则会有返回值；如果方法抛出了异常，则不会有返回值。
• Around （环绕通知）：编程式控制目标对象的方法调用。环绕通知是所有通知类型中可操作范围最大的一种，因为它可以直接拿到目标对象，以及要执行的方法，所以环绕通知可以任意的在目标对象的方法调用前后搞事，甚至不调用目标对象的方法

14、切面的优先级你知道吗？

• 相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。
  • 优先级高的切面：外面
  • 优先级低的切面：里面
• 使用@Order注解可以控制切面的优先级：
  • @Order(较小的数)：优先级高
  • @Order(较大的数)：优先级低

15、介绍一下编程式事务的缺点以及如何改进？

• 编程式事务：需使用TransactionTemplate来进行实现，对业务代码有侵入性，项目中很少使用
• 编程式事务缺点：
  • 细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。
  • 代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。
• 应该启用声明式事务，也是一种AOP的应用，使用注解@Transactional。本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

16、事务有哪几种属性？

• 只读@Transactional(readOnly = true)：对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这样数据库就能够针对查询操作来进行优化；对增删改操作设置只读会抛出下面异常。

• 超时@Transactional(timeout = 3)：超时回滚，释放资源。

• 回滚策略@Transactional(noRollbackFor = ArithmeticException.class)，可以通过@Transactional中相关属性设置回滚策略

  • rollbackFor属性：需要设置一个Class类型的对象
  • rollbackForClassName属性：需要设置一个字符串类型的全类名
  • noRollbackFor属性：需要设置一个Class类型的对象
  • rollbackFor属性：需要设置一个字符串类型的全类名

• 设置隔离级别

  @Transactional(isolation = Isolation.DEFAULT)//使用数据库默认的隔离级别
  @Transactional(isolation = Isolation.READ_UNCOMMITTED)//读未提交
  @Transactional(isolation = Isolation.READ_COMMITTED)//读已提交
  @Transactional(isolation = Isolation.REPEATABLE_READ)//可重复读
  @Transactional(isolation = Isolation.SERIALIZABLE)//串行化
  

• 传播行为

  • REQUIRED：支持当前事务，如果不存在就新建一个(默认) 【没有就新建，有就加入】
  • REQUIRES_NEW：开启一个新的事务，如果一个事务已经存在，则将这个存在的事务挂起 【不管有没有，直接开启一个新事务，开启的新事务和之前的事务不存在嵌套关系，之前事务被挂起】
  • SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行 【有就加入，没有就不管了】
  • MANDATORY：必须运行在一个事务中，如果当前没有事务正在发生，将抛出一个异常 【有就加入，没有就抛异常】
  • NOT_SUPPORTED：以非事务方式运行，如果有事务存在，挂起当前事务 【不支持事务，存在就挂起】
  • NEVER：以非事务方式运行，如果有事务存在，抛出异常 【不支持事务，存在就抛异常】
  • NESTED：如果当前正有一个事务在进行中，则该方法应当运行在一个嵌套式事务中。被嵌套的事务可以独立于外层事务进行提交或回滚。如果外层事务不存在，行为就像REQUIRED一样。【有事务的话，就在这个事务里再嵌套一个完全独立的事务，嵌套的事务可以独立的提交和回滚。没有事务就和REQUIRED一样。】

17、Spring中事务失效的场景有哪些？

• 如果方法上异常捕获处理，自己处理了异常，没有抛出，就会导致 事务失效，所以一般处理了异常以后，别忘了跑出去就行了
• 如果方法抛出检查异常，如果报错也会导致事务失效，最后在 spring事务的注解上，就是@Transactional上配置rollbackFor属性为 Exception，这样别管是什么异常，都会回滚事务
• 果方法上不是public修饰的，也会导致事务 失效。原因：Spring 为方法创建代理、添加事务通知、前提条件都是该方法是 public 的。

18、Spring整合Junit5有什么好处？怎么使用？

• 整合JUnit的好处是直接使用Bean，不用从配置文件中读取

  @SpringJUnitConfig(locations = "classpath:beans.xml")
  public class SpringJUnit5Test {
  
      @Autowired
      private User user;
  
      @Test
      public void testUser(){
          System.out.println(user);
      }
  }
  

19、Spring框架下的常见注解有哪些？

• Spring

  注解	说明
  @Component、@Controller、@Service、@Repository	使用在类上用于实例化Bean
  @Autowired	使用在字段上用于根据类型依赖注入
  @Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
  @Scope	标注Bean的作用范围
  @Configuration	指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解
  @ComponentScan	用于指定 Spring 在初始化容器时要扫描的包
  @Bean	使用在方法上，标注将该方法的返回值存储到Spring容器中
  @Import	使用@Import导入的类会被Spring加载到IOC容器中
  @Aspect、@Before、@After、@Around、@Pointcut	用于切面编程（AOP）

• SpringMVC

  注解	说明
  @RequestMapping	用于映射请求路径，可以定义在类上和方法上。用于类上，则表示类中的所有的方法都是以该地址作为父路径
  @RequestBody	注解实现接收http请求的json数据，将json转换为java对象
  @RequestParam	指定请求参数的名称
  @PathViriable	从请求路径下中获取请求参数(/user/{id})，传递给方法的形式参数
  @ResponseBody	注解实现将controller方法返回对象转化为json对象响应给客户端
  @RequestHeader	获取指定的请求头数据
  @RestController	@Controller + @ResponseBody

• SpringBoot

  注解	说明
  @SpringBootConfiguration	组合了- @Configuration注解，实现配置文件的功能
  @EnableAutoConfiguration	打开自动配置的功能，也可以关闭某个自动配置的选
  @ComponentScan	Spring组件扫描

20、Spring中ApplicationContext和BeanFactory的区别？

• Spring中的ApplicationContext和BeanFactory都是IOC容器，负责管理和创建Bean实例。

不同点：

1. ApplicationContext是BeanFactory的子接口，它提供了更多的功能，例如国际化、事件驱动等
2. ApplicationContext会在启动时预先实例化所有的单例Bean，而BeanFactory则是按需创建Bean
3. ApplicationContext支持Bean的自动装配、AOP等功能，而BeanFactory需要手动配置
4. ApplicationContext支持多种资源加载方式，例如XML、注解、属性文件等，而BeanFactory只支持XML格式的配置文件
5. ApplicationContext提供了更多的扩展点，例如BeanPostProcessor、ApplicationListener等，可以对Bean的生命周期和时间进行监听和处理

SpringMVC

1、什么是MVC？MVC的工作流程是什么？

• M：Model，模型层，指工程中的JavaBean，作用是处理数据
  • 一类称为实体类Bean：专门存储业务数据的，如 Student、User 等 一类称为业务处理 Bean：
  • 指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。
• V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
• C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器
• 工作流程：用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller 调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果 找到相应的View视图，渲染数据后最终响应给浏览器

2、SpringMVC有什么特点？

• 基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一 处理

3、标签中使用/和/*的区别？

• /所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请 求 因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面
• /*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用

4、SpringMVC的执行流程知道嘛？

1、用户发送出请求到前端控制器DispatcherServlet，这是一个调度中心。

2、DispatcherServlet收到请求调用HandlerMapping（处理器映射器）。

3、HandlerMapping找到具体的处理器(可查找xml配置或注解配置)，生成处理器对象及处理器拦截器(如果有)，再一起返回给DispatcherServlet。

4、DispatcherServlet调用HandlerAdapter（处理器适配器）。

5、HandlerAdapter经过适配调用具体的处理器（Handler/Controller）。

6、Controller执行完成返回ModelAndView对象。

7、HandlerAdapter将Controller执行结果ModelAndView返回给 DispatcherServlet。

8、DispatcherServlet将ModelAndView传给ViewReslover（视图解析器）。

9、ViewReslover解析后返回具体View（视图）。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图 中）。

11、DispatcherServlet响应用户。

注：当然现在的开发，基本都是前后端分离的开发的，并没有视图这些，一般都 是handler中使用Response直接结果返回。

5、@RequestBody、@RequestParam、@PathVariable区别？

• @RequestBody接收的是请求体里面的json数据，一般和@PostMapping结合

• @RequestParam接收的是key-value里面的参数

• 用@RequestParam请求接口时,URL是: http://localhost:8080/test?id=2

  @GetMapping(value="/test")
  public void test(@RequestParam(value="id",required=false,defaultValue="0")String id)
  

• 用@PathVariable请求接口时,URL是: http://localhost:8080/test/2

  @GetMapping(value="/test/{id}")
  publicResulttest(@PathVariable("id")String id) 
  

SpringBoot

1、SpringBoot有哪些优点？

1. 独立运行：SpringBoot内嵌了各种servlet容器，如Tomcat、Jetty等，现在不再需要打成war包部署到容器中，SpringBoot只要打成一个可执行的jar包就能独立运行，所有的依赖包都在一个jar包内。
2. 简化配置：SpringBoot提供了很多starter依赖，可以快速集成其他框架和组件，大大简化了配置过程。
3. 自动配置：SpringBoot的自动配置非常强大，可以根据类路径下的jar包、类文件和注解来自动配置bean，减少了手动配置的工作量。
4. 无代码生成和XML配置：SpringBoot使用条件注解和自动配置来完成所有的配置工作，避免了代码生成和繁琐的XML配置文件，让开发更加简洁、清晰。
5. 应用监控：SpringBoot提供了很多有用的端点和指标，可以用来监控和管理应用程序，包括健康检查、性能监控、日志查看等。此外，SpringBoot还可以与Actuator集成，提供更加丰富的监控功能。

2、介绍一下SpringBoot的自动配置原理?

• 在Spring Boot项目中的引导类上有一个注解@SpringBootApplication，这个注解是对三个注解进行了封装，分别是： @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan
• 其中 @EnableAutoConfiguration 是实现自动化配置的核心注解。 该注解通过 @Import 注解导入对应的配置选择器。关键的是内部就是读取了 该项目和该项目引用的Jar包的的classpath路径下META-INF/spring.factories文件中的所配置的类的全类名。 在这些配置类中所定义的Bean会根据条件注解所指定的条件来决定是否需要将其导入到Spring容器中。 一般条件判断会有像 @ConditionalOnClass 这样的注解，判断是否有对应的 class文件，如果有则加载该类，把这个配置类的所有的Bean放入spring容器 中使用。

3、运行SpringBoot应用程序有哪几种方式？

1. 在IDE中运行：在集成开发环境(IDE)中，可以通过直接运行应用程序的主类来启动SpringBoot程序(main方法)。

2. 打包成可执行JAR包运行：SpringBoot提供了一种将应用程序打包成可执行的JAR包的方式，例如使用Maven插件，可以轻松将应用程序打包成一个单独的JAR文件，然后在命令行中运行该JAR文件即可启动应用程序。

   java -jar xxx.jar
   

3. 在容器中运行：可以将SpringBoot应用程序部署到Web容器中，如Tomcat、Jetty等，然后启动容器即可运行应用程序。在部署时需要将应用程序打成WAR包，并将WAR包部署到相应的容器中。

4、如何在SpringBoot启动时运行一些特定的代码？

• 在SpringBoot启动时，可以通过实现ApplicationRunner或CommandLineRunner接口来运行一些特定的代码。这两个接口都是SpringBoot提供的回调接口，它们的作用是在SpringBoot应用程序启动完成之后，自动回调其中的run方法。在这个方法中可以编写一些初始化代码，如加载配置文件、初始化缓存等
  • ApplicationRunner接口的run方法中传入了一个ApplicationArguments对象，可以用来获取命令行参数和选项等信息
  • CommandLineRunner接口的run方法中传入一个String数组，可以用来获取命令行参数

@Component //表示它是一个Spring的组件，可以被自动扫描并注册到Spring容器中。
public class MyRunner implements ApplicationRunner, CommandLineRunner {
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 在此编写初始化代码，可以使用args获取命令行参数和选项等信息
    }

    @Override
    public void run(String... args) throws Exception {
        // 在此编写初始化代码，可以使用args获取命令行参数
    }
}

5、SpringBoot需要独立的容器运行吗？

• 不需要。SpringBoot应用程序已经被打包成可执行的jar文件，可以独立完成，不需要外部容器。在启动应用程序时，SpringBoot会内嵌一个Tomcat、Jetty或Undertow等Servlet容器，从而可以直接运行Web应用程序，而不需要单独安装和配置外部的Servlet容器。这种方式成为嵌入式Servlet容器。
• 当然，如果需要在生产环境中部署SpringBoot应用程序，可以将其打包成war包，然后部署到外部的Servlet容器中，如Tomcat、Jetty、WebSphere等，但这种部署方式失去了SpringBoot嵌入式容器的优势。

6、SpringBoot中的监视器是什么？

• SpringBoot中的监视器(monitor)是一个内置的功能，它可以让开发者实时监控应用程序的运行状况和性能指标。监视器是基于SpringBootActuator模块实现的，可以通过HTTP接口或JMX访问。
• 监视器可以提供一下几个功能
  1. 健康检查：通过访问/actuator/health接口，可以获取应用程序的健康状况。如果应用程序正常运行，会返回一个HTTP 200 OK响应；如果应用程序异常，会返回一个HTTP 503 Service Unavailable响应
  2. 指标监控：通过访问/actuator/metrics接口，可以获取应用程序的各种指标，如内存使用情况、CPU占用率、HTTP请求数等
  3. 环境信息：通过访问/actuator/env接口，可以获取应用程序的环境信息，如操作系统、Java版本、系统属性等
  4. 配置信息：通过访问/actuator/configprops接口，可以获取应用程序的配置信息，包括SpringBoot自动配置的所有Bean和其属性
  5. 执行器端点：除了以上几个端点，SpringBoot还提供了一系列执行器端点，可以访问应用程序内部状态和功能，如/actuator/beans、/actuator/mappings、/actuator/trace等
• 监视器功能可以通过在pom.xml文件中引入spring-boot-starter-actuator依赖实现，该依赖会自动配置Actuator模块，并启用所有的端点。可以通过配置文件或@Endpoint注解对端点进行自定义配置。

7、如何使用SpringBoot实现异常处理？

• 使用@ControllerAdvice注解定义一个全局异常处理器，来统一处理应用程序中的异常。步骤如下：

  • 定义一个异常处理类，并使用@ControllerAdvice注解来标注。

    @ControllerAdvice
    public class GlobalExceptionHandler {
    
        @ExceptionHanlder(value = Exception.class)
        public ResponseEntity<String> handleException(Exception e){
            // 处理异常，并返回合适的HTTP响应
        }
    }
    

  • 在处理方法中定义@ExceptionHandler注解，指定需要处理的异常类型。可以使用多个@ExceptionHandler注解定义不同的处理方法来处理不同类型的异常。

  • 处理异常，并返回合适的HTTP响应，可以返回一个自定义的错误信息、一个HTTP错误码，或者其他合适的响应。

8、SpringBoot中常用的starter有哪些？

1. spring-boot-starter-web：用于构建Web应用程序，包括Spring MVC、Tomcat容器等。
2. spring-boot-starter-data-jpa：用于使用JPA和Hibernate进行持久化操作。
3. spring-boot-starter-data-redis：用于使用Redis进行数据缓存和持久化操作。
4. spring-boot-starter-security：用于构建安全的Web应用程序，包括Spring Security、OAuth2等。
5. spring-boot-starter-actuator：用于监视应用程序的运行状况和性能指标，包括健康检查、指标监控、环境信息、配置信息等。
6. spring-boot-starter-test：用于构建测试应用程序，包括JUnit、Mockito、Hamcrest等。
7. spring-boot-starter-log4j2：用于使用Log4j2进行日志记录。
8. spring-boot-starter-logging：用于使用SLF4J和Logback进行日志记录。
9. spring-boot-starter-amqp：用于使用AMQP进行消息队列和消息总线操作。

9、SpringBoot实现热部署有哪几种方式？

1. 使用SpringBoot DevTools：SpringBoot DevTools提供了许多开发工具，包括自动重启、热部署等功能。只需将spring-boot-devtools依赖添加到项目中即可启用该功能。
2. 使用Spring Loaded：Spring Loaded是一个轻量级的Java类热部署工具，可以让开发者在不停止和重新启动应用程序的情况下更新Java类，只需将spring-loaded依赖添加到项目中即可启用该功能。
3. 使用JRebel：JRebel是一款商业化的Java类热部署工具，需要将JRebel插件集成到开发环境中才能使用。

注：热部署：应用正在运行的时候升级软件,却不需要重新启动应用。

10、Spring Boot的配置加载顺序的优先级是什么样子的？

1. 命令行参数：Spring Boot可以通过命令行参数来动态地修改配置。例如，可以使用-server.port=8080来指定应用程序的端口号。
2. Java系统属性：可以通过-D参数设置Java系统属性，这些属性可以在Spring Boot应用程序中直接使用。例如，可以使用Dapp.version=1.0.0来设置应用程序版本号。
3. OS环境变量：Spring Boot可以读取操作系统的环境变量，这些环境变量可以在应用程序中直接使用。例如，可以使用export APP_NAME=myapp来设置应用程序名称。
4. application.properties或application.yml文件：Spring Boot会自动加载application.properties或application.yml文件中的配置。其中，application.properties文件使用key=value的格式，application.yml文件使用YAML格式。这些配置文件可以放置在src/main/resources目录下或classpath的根目录下。
5. 指定的配置文件：可以通过spring.config.name和spring.config.location属性来指定要加载的配置文件。例如，可以使用-spring.config.name=myconfig、-spring.config.location=/etc/myapp/来加载指定的配置文件。
6. 通过@ConfigurationProperties注解加载配置：可以使用@ConfigurationProperties注解来将配置文件中的属性映射到Java类中。

11、SpringBoot的核心配置文件有哪几个？他们的区别是什么？

• application.yml：这是SpringBoot应用程序的主要配置文件，其中包含了应用程序中的各种配置属性，如数据库连接、端口号等
• bootstrap.yml：它的主要应用场景是当应用程序需要连接到外部服务时，可以将连接属性(如用户名、密码、端口等)配置在bootstrap文件中，以便在应用程序启动时就能够加载这些属性。这样做可以避免将敏感信息直接暴露在应用程序的配置文件中，提高应用程序的安全性。例如我们使用SpringCloud Config作为应用程序的配置服务器，那么我们需要在bootstrap中配置如下属性。