SpringBoot面试题

1、什么是 Spring Boot ?

        Spring Boot 是一个开源框架，它可以用来构建基于 Spring 框架的应用程序。它的主要目的是简化 Spring 应用程序的搭建和开发过程。Spring Boot 提供了一种快速、敏捷、便捷的方式来配置和搭建 Spring 应用程序，使开发者可以更加专注于业务逻辑的实现，而不需要关心底层的配置和依赖。Spring Boot 还提供了许多便捷的工具和功能，如自动配置、嵌入式服务器、监控、度量、日志记录、安全等，来简化开发过程。

2、Spring Boot 中如何实现定时任务 

        在 Spring Boot 中，可以使用 Spring 自带的定时任务框架实现定时任务，具体步骤如下：

• 在pom.xml中添加以下依赖：

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

• 创建一个定时任务类，使用 @Component 注解将其加入 Spring 容器中。

@Component
public class MyScheduler {
 
    @Scheduled(cron="0 0/5 * 1/1 * ?") //每5分钟执行一次
    public void process() {
        // 定时任务执行的逻辑
    }
 
}

• 配置定时任务线程池。

spring:
  quartz:
    job-store-type: memory # 存储类型
    properties:
      org:
        quartz:
          scheduler:
            instanceName: quartzScheduler
          threadPool:
            threadCount: 10 # 线程数
            threadPriority: 5 # 线程优先级
            threadsInheritContextClassLoaderOfInitializingThread: true # 类加载器

其中，threadCount 表示线程池中线程数，threadPriority 表示线程优先级，threadsInheritContextClassLoaderOfInitializingThread 表示线程是否继承初始化线程的类加载器。

• 启动定时任务。

在启动类中添加 @EnableScheduling 注解启用定时任务。

@SpringBootApplication
@EnableScheduling
public class Application {
 
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
 
}

3、Spring Boot 中如何解决跨域问题 

1. 使用 @CrossOrigin 注解，在 Spring Controller 类或方法上使用 @CrossOrigin 注解可以允许来自指定域的请求访问该 API。
2. 使用 WebMvcConfigurer，可以通过实现 WebMvcConfigurer 接口来配置全局的跨域支持。

4、SpringBoot中怎样实现依赖注入

在Spring Boot中，可以使用`@Autowired`注解来实现依赖注入。依赖注入是指通过自动装配的方式将一个类的实例注入到另一个类中，从而实现它们之间的依赖关系。

以下是在Spring Boot中实现依赖注入的几种常见方式：

1. 构造器注入：通过在目标类的构造器上使用`@Autowired`注解，将依赖的实例作为构造器的参数进行注入。

   @Service
   public class UserService {
       private final UserRepository userRepository;
   
       @Autowired
       public UserService(UserRepository userRepository) {
           this.userRepository = userRepository;
       }
   
       // ...
   }

2. 属性注入：通过在目标类的属性上使用`@Autowired`注解，将依赖的实例直接注入到属性中。
 

   @Service
   public class UserService {
       @Autowired
       private UserRepository userRepository;
   
       // ...
   }

3. Setter方法注入：通过在目标类的Setter方法上使用`@Autowired`注解，将依赖的实例注入到Setter方法中。

   @Service
   public class UserService {
       private UserRepository userRepository;
   
       @Autowired
       public void setUserRepository(UserRepository userRepository) {
           this.userRepository = userRepository;
       }
   
       // ...
   }

除了`@Autowired`注解外，还可以使用`@Inject`注解来实现依赖注入，它们的使用方式类似。

需要注意的是，为了使依赖注入生效，还需要在Spring Boot应用程序的配置类上添加`@EnableAutoConfiguration`注解或使用`@SpringBootApplication`注解，以启用自动配置和组件扫描。

5、运行SpringBoot项目有几种方式

运行Spring Boot项目有三种方式：

1. 用Maven插件运行，在命令行中使用mvn spring-boot:run命令运行。

2. 在IDE中运行。可以在Eclipse或者IntelliJ IDEA中打开项目，选择主类，右键点击运行即可。

3. 打包成Jar包并在命令行中运行。可以使用mvn clean package命令将Spring Boot项目打包成Jar包，然后使用java -jar命令在命令行中运行。例如：java -jar project.jar。

6、Spring Boot 如何简化传统的 Spring 开发？

        Spring Boot 真正简化了传统的 Spring 开发，主要有以下几个方面：

1. 自动配置：Spring Boot 通过自动配置，可以使大部分应用无需手动配置，只需要加上相应的依赖即可。

2. 微服务支持：Spring Boot 对于微服务架构提供了更好的支持，开发人员可以更加简单地创建和部署微服务。

3. 嵌入式服务器：Spring Boot 内置了 Tomcat、Jetty 等嵌入式服务器，使得开发人员无需手动安装和配置服务器，可以快速搭建服务器。

4. 简化配置：Spring Boot 配置文件采用 properties 或 YAML 格式，易于编写和维护。

5. 简化依赖管理：Spring Boot 使用 Maven 或 Gradle 进行依赖管理，简化了依赖管理的复杂性。

        总之，Spring Boot 真正实现了开箱即用，大大简化了开发和部署的复杂度，让开发人员能够更加专注于业务逻辑的实现。

7、Spring Boot 的核心配置文件是什么？它的作用是什么？

        Spring Boot 的核心配置文件是 application.properties 或 application.yml（二者选一），一般放置在 src/main/resources 目录下，用于配置应用程序的属性和参数。

        它的主要作用是：

1. 配置应用程序参数：可以通过配置文件来指定应用程序的端口号、日志级别、数据库连接等参数。
2. 简化开发过程：在 Spring Boot 中，很多参数都有默认值，不需要手动去配置，使得开发过程更加简单。
3. 环境切换：在不同的环境下（如开发、测试、生产），配置文件可以根据不同的环境提供不同的配置。
4. 外部化配置：配置文件可以被外部化，这意味着可以将配置文件从应用程序中分离出来，使得应用程序更易于管理和维护。

8、Spring Boot Starter 是什么？

        Spring Boot Starter 是一种特殊的依赖关系，它可以将一组相关的依赖项打包到一起，并提供了一种简单的方式来自动配置 Spring 应用程序。Spring Boot Starter 通常以“spring-boot-starter-xxxx”命名。

9、Spring Boot 自动配置是如何工作的？

        Spring Boot 自动配置是通过查找类路径和已知的依赖项来完成的。当Spring Boot应用程序启动时，Spring Boot会扫描类路径，查找自动配置类，这些类可以配置应用程序中的许多常见功能。这些自动配置类通常使用条件化配置来确保只有在正确的条件下才会被启用，例如检查是否存在相应的bean，或者是否存在特定的类。

        自动配置类可以通过 @EnableAutoConfiguration 注解来启用。 Spring Boot默认提供了很多自动配置类，也允许开发者自己编写自动配置类来自定义应用程序的行为。

        自动配置的优点是让开发人员省去了大量的配置，减少了出现错误的机会，并且能够提供许多常见功能的快速启用，例如数据库连接池、Web 安全等等，从而加快了开发过程。

10、如何在 Spring Boot 中配置数据源和使用数据库？

在 Spring Boot 中配置数据源和使用数据库主要包含以下几个步骤：

• 添加相关依赖：在 pom.xml 文件中添加 spring-boot-starter-jdbc 或 spring-boot-starter-data-jpa 依赖。
• 配置数据源：在 application.properties 文件中添加数据库连接信息，如下：

spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

• 使用数据库：通过使用 Spring Boot 自带的 JdbcTemplate 或使用 JPA 等持久化框架，来对数据库进行增删改查等操作。

举个例子，在使用 JdbcTemplate 时，需要先在类中注入 JdbcTemplate 对象，如下：

@Autowired
private JdbcTemplate jdbcTemplate;

然后可以使用 jdbcTemplate 对象来执行 SQL 语句，例如：

jdbcTemplate.update("insert into users(name, age) values (?, ?)", "张三", 20);
List<Users> users = jdbcTemplate.query("select * from users", new BeanPropertyRowMapper<>(Users.class));

以上就是在 Spring Boot 中配置数据源和使用数据库的基本步骤，具体细节还需根据实际情况进行调整。

11、Spring Boot 中的 AOP（面向切面编程）是什么？如何使用 AOP？

        AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它可以在不修改原有代码的情况下，通过对系统进行切面的增强来实现特定的功能。在 Spring Boot 中，AOP 可以帮助开发者处理一些通用的业务逻辑，比如日志记录、性能监控、安全控制等。

@Aspect
@Component
public class LogAspect {
 
    @Pointcut("execution(public * com.example.demo.controller..*.*(..))")
    public void controllerLog() {}
 
    @Around("controllerLog()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前置通知
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String requestURI = request.getRequestURI();
        String remoteAddr = request.getRemoteAddr();
        String method = request.getMethod();
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        log.info("请求开始：[{}] [{}] [{}] [{}] [{}] [{}]", requestURI, remoteAddr, method, className, methodName, args);
        
        // 执行方法
        Object result = joinPoint.proceed();
        
        // 后置通知
        log.info("返回结果：{}", result);
        
        return result;
    }
}
 

        示例定义了一个切面，对所有 Controller 层的公共方法进行日志记录。

        首先使用 @Pointcut 注解定义了一个切入点，然后使用 @Around 注解将切入点和通知绑定在一起，通知中包含了前置通知和后置通知。在前置通知中，记录了请求的相关信息；在后置通知中，记录了返回结果。

        需要注意的是，使用 AOP 时需要将切面加入 Spring 容器中，可以使用 @Component 注解或者配置文件进行定义。同时，注意 AOP 的执行顺序，可以使用 @Order 注解进行控制。

12、Spring Boot 如何处理异常和错误？

Spring Boot 提供了多种方式来处理异常和错误，以下是一些常见的方式：

1. @ExceptionHandler 注解：可以在 Controller 中使用该注解来处理指定异常类型的异常。

2. @ControllerAdvice 注解：可以在全局范围内使用该注解来处理多个 Controller 中的异常，相当于一个全局异常处理器。

3. ErrorController：Spring Boot 提供了一个默认实现的 ErrorController 接口，可以使用它来处理 HTTP 请求中的错误，例如 404 错误等。

4. 自定义异常处理器：可以自定义实现异常处理器来处理程序中的异常，例如使用 AOP 面向切面编程来捕获异常并进行统一处理。

总之，Spring Boot 提供了多种处理异常和错误的方式，开发者可以根据具体需求选择合适的方式进行处理。

13、如何进行单元测试和集成测试？

Spring Boot 提供了很多方便的工具和注解来进行单元测试和集成测试。

• 单元测试：单元测试是针对单独的类或方法进行测试，可以使用 JUnit 或者 Spring Boot 自带的测试框架来进行单元测试。Spring Boot 自带的测试框架可以使用 @RunWith(SpringRunner.class) 和 @SpringBootTest 注解来开启 Spring 上下文，例如：

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {

    @Autowired
    private DemoService demoService;

    @Test
    public void testDemo() {
        String result = demoService.sayHello();
        assertEquals("Hello, World!", result);
    }
}

• 集成测试：集成测试是测试多个模块之间的交互，可以使用 Spring Boot 提供的 TestRestTemplate 来模拟 HTTP 请求和响应，例如：

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class DemoApplicationTests {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testDemo() {
        ResponseEntity<String> response = restTemplate.getForEntity("/hello", String.class);
        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertEquals("Hello, World!", response.getBody());
    }
}

        此外，Spring Boot 还提供了很多其他的工具和注解来方便开发者进行单元测试和集成测试，例如 @MockBean、@AutoConfigureMockMvc、@DataJpaTest、@RestClientTest 等等。开发者可以根据具体需求选择合适的方式进行测试。

14、Spring Boot 中的事务管理是如何实现的？

        Spring Boot 中的事务管理是基于 Spring Framework 中的事务管理机制实现的。Spring Boot 提供了对 Spring Framework 中事务管理的自动配置和简化配置的支持。

在 Spring Boot 中，事务管理的实现主要分为两种方式：

1. 基于注解的事务管理：通过在方法上添加 @Transactional 注解来开启事务，实现对方法执行过程中的数据库操作进行事务管理。

2. 编程式事务管理：通过编写代码的方式来实现事务管理，开发人员可以自己控制事务的提交或回滚。

        Spring Boot 默认使用基于注解的事务管理方式，并提供了与许多流行的数据访问框架结合使用的支持，如 Spring Data JPA、MyBatis 等等。

15、如何部署一个 Spring Boot 应用？

使用内置的 Tomcat 部署：

• 在你的 Spring Boot 项目中，确保在 pom.xml 文件中添加了 spring-boot-starter-web 或 spring-boot-starter-webflux 依赖。
• 在主类中添加 @SpringBootApplication 注解，它会自动配置嵌入式 Tomcat 服务器。
• 打包你的应用：在命令行中进入项目根目录，执行 mvn package 命令，生成可执行的 JAR 文件。
• 在目标文件夹中找到生成的 JAR 文件，然后在命令行中执行 java -jar your-application.jar 来启动应用。Spring Boot 会自动启动嵌入式的 Tomcat 服务器，并将应用部署在默认的端口上。