Spring高频面试题

（一些来源于GitCode AI）

1. 什么是Spring框架？ Spring是一个开源的Java平台，它简化了企业级应用的开发。它提供了IOC（Inversion of Control）/DI（Dependency Injection）容器，AOP（Aspect-Oriented Programming）支持，数据访问，事务管理，MVC（Model-View-Controller）框架等功能。

2. 解释一下Spring的IOC（Inversion of Control）和DI（Dependency Injection）? IOC是指将对象的控制权交由容器来管理，而不是对象自身。DI则是IOC的一个具体实现，通过外部配置文件或注解方式，将依赖的对象传入，而不是由对象自己创建，从而解耦合。

3. Spring的AOP是什么？ AOP（Aspect-Oriented Programming）面向切面编程，允许程序员定义“横切关注点”，并将它们模块化为单独的称为“切面”的代码单元，可以跨多个对象进行拦截操作，例如日志记录、事务管理等。

4. Spring MVC工作原理是什么？ Spring MVC模式包括 DispatcherServlet、Controller、Model、View 和 HandlerMapping 等部分。请求到达 DispatcherServlet，它根据HandlerMapping找到合适的Controller处理，Controller处理完业务逻辑后，返回ModelAndView，最后由DispatcherServlet根据ViewResolvers解析出具体的视图。

5. Spring JDBC模板怎么使用？ Spring JDBC提供了一个JdbcTemplate类，可以帮助开发者避免编写大量的样板代码，用于执行SQL查询和更新。它可以处理连接的打开和关闭，结果集的映射，异常处理等工作。

SpringBoot启动流程详解

Spring Boot的启动流程主要分为以下几个步骤：

1. 主类执行: 主类通常包含@SpringBootApplication注解，该注解是@Configuration，@EnableAutoConfiguration，@ComponentScan三个注解的组合体。

2. 组件扫描: Spring会扫描主类所在的包以及子包下的所有@Component类型的注解，如@Service, @Repository, @Controller等，并将这些组件注册到IoC容器中。

3. 自动配置: @EnableAutoConfiguration开启自动配置功能，Spring Boot会根据已引入的依赖自动配置相关的bean。比如，如果项目中有Web开发相关的依赖，Spring Boot就会自动配置一些与Web相关的bean，如Tomcat服务器，DispatcherServlet等。

4. 配置加载: Spring Boot读取应用的配置文件（默认是application.properties或application.yml），并将配置属性注入到对应的bean中。

5. SpringApplication.run: 当调用SpringApplication.run()方法时，Spring Boot开始初始化并启动ApplicationContext，创建bean实例。

6. 监听器初始化: 包含web环境的话，初始化ServletContext，并注册各种监听器，如HttpSessionListener、ContextLoaderListener等。

7. Spring容器初始化Bean: 根据扫描到的@Component以及自动配置的@Bean定义，初始化所有的bean并进行依赖注入。

8. 应用启动完成: 所有bean初始化完成后，Spring Boot打印Banner信息，并调用ApplicationRunner或CommandLineRunner接口的run方法（如果有实现）。

什么是Spring Boot，并对比Spring框架有何优势？

Spring Boot概述： Spring Boot是由Pivotal团队提供的全新框架，主要用于简化Spring应用的初始搭建以及开发过程。它集成了大量常用的第三方库配置，如 JDBC、MongoDB、Quartz 等，极大地提高了设置和运行应用的效率。Spring Boot的核心特性包括自动配置、起步依赖和内嵌服务器等。

与Spring框架相比的优势：

1. 快速启动和运行：Spring Boot项目不需要复杂的XML配置，启动速度更快，且内置了Tomcat或Jetty等服务器，可以直接运行主类启动应用。

2. 自动配置：基于条件注解的自动配置功能使得开发者无需手动配置大部分Bean，只需要添加相应的starter即可。

3. 简化Maven配置：通过“起步依赖”(Starter POMs)，开发者可以轻松地导入需要的库和功能，而不需要显式地指定版本号。

4. 健康检查和监控：Spring Boot Actuator 提供了一组端点，可以用来监控和管理应用的状态，包括内存、线程、日志、配置等信息。

5. 开箱即用：Spring Boot集成了许多常用组件，如数据源、缓存、消息队列等，减少了额外的集成工作。

Spring Boot自动配置是如何识别并加载相关的配置类的？

Spring Boot的自动配置通过@EnableAutoConfiguration注解启动，通常在主应用类上使用。这个注解会触发Spring Boot的自动配置过程，下面是具体步骤：

1. 找到所有的@Configuration注解的类：Spring Boot会扫描包路径下所有带有@Configuration注解的类。

2. 查找META-INF/spring.factories文件：每一个Spring Boot的模块都会在它的jar包中包含一个名为META-INF/spring.factories的文件。这个文件列出了一系列可以被Spring Boot自动配置的类，键值对的形式，键是org.springframework.boot.autoconfigure.EnableAutoConfiguration，值是一系列类名。

3. 加载@EnableAutoConfiguration指定的配置：主应用类上的@EnableAutoConfiguration注解可以通过value或exclude属性来指定要启用或排除的自动配置类。

4. 确定是否启用自动配置：对于每个类，Spring Boot会检查当前环境条件，如果满足条件，就会将这个类作为配置导入到Bean定义中。环境条件通常是通过@Conditional注解指定的，例如@ConditionalOnClass表示只有当特定类存在时才启用配置，@ConditionalOnProperty则是基于特定属性值。

5. 注册Bean：符合条件的自动配置类会被处理成Spring的Bean，然后这些Bean会参与到Spring容器的依赖注入中。

Spring Boot自动配置与传统XML配置相比有哪些优势？

Spring Boot自动配置相比于传统的XML配置有以下优势：

1. 简化配置：Spring Boot自动配置可以基于当前项目中的类和jar依赖，自动为应用程序提供相关的bean配置，减少了手动编写大量XML配置的工作量。

2. 约定优于配置：Spring Boot遵循一些默认的规范，如数据源、日志框架等，开发者不需要额外的配置，就可以按预期工作。如果需要自定义，也可以轻松覆盖默认设置。

3. 内嵌服务器：Spring Boot可直接内嵌Tomcat、Jetty等服务器，无需部署war包到外部服务器，简化了开发和部署流程。

4. 快速起步：通过spring-boot-starter模块，可以快速引入所需功能，如web、data、security等，避免了繁琐的依赖管理和版本冲突。

5. 健康检查和Actuator：Spring Boot提供了Actuator组件，方便进行系统监控和健康检查，比如查看应用指标、内存状态等。

6. 更好的测试支持：Spring Boot提供了易于使用的测试框架，能够快速构建和运行集成测试，且支持Spring Boot应用的独立测试。

7. 增强的环境感知：通过spring.profiles.active属性，可以在不同环境中切换不同的配置，实现环境之间的差异化配置。

Spring框架作为Java领域的重要组成部分，其面试题涵盖了许多方面。这里列举一些常见的Spring面试题目，并提供简短的回答：

1. 什么是Spring框架？ Spring是一个开源的Java/Java EE全功能栈的应用框架，它主要由IoC/DI（控制反转/依赖注入）、AOP（面向切面编程）和MVC（模型-视图-控制器）等核心特性组成。

2. 解释一下Spring框架中的IOC/DI概念。 IOC（Inversion of Control）即控制反转，意味着对象的创建和管理交给了容器。DI（Dependency Injection）是IOC的一种实现方式，通过容器将对象的依赖关系以参数的形式注入到目标对象中，降低了对象间的耦合性。

3. Spring AOP是什么，有哪些使用场景？ AOP（Aspect Oriented Programming）面向切面编程，用于处理系统级关注点，如日志、事务管理等，与业务逻辑解耦。通常应用于跨层的方法拦截。

4. Spring MVC的工作原理是怎样的？ Spring MVC模式接收请求，分发到Controller，Controller调用Service层方法，Service层处理业务逻辑并返回Model数据，然后View Resolver解析视图，最后响应给客户端。

5. 谈谈Spring Boot的特点和优点。 参见上文的回答，强调了简化配置、内嵌服务器、快速起步等优点。

6. Spring中是如何实现事务管理的？ Spring提供了编程式和声明式两种事务管理方式。声明式事务管理基于@Transactional注解，简单易用；编程式事务管理则通过TransactionTemplate或者PlatformTransactionManager接口进行手动控制。

7. Spring Security是什么，主要负责什么？ Spring Security是一个强大的安全框架，用于保护Web应用免受常见的攻击，包括身份验证、授权、CSRF防护等功能。

8. Spring Cloud是做什么的？ Spring Cloud是基于Spring Boot实现的一系列微服务开发工具集，包括服务注册与发现、负载均衡、熔断器、配置中心等组件。

9. Spring Data JPA与MyBatis的区别是什么？ Spring Data JPA是Spring对JPA规范的封装，提供了ORM操作，适合ORM映射较复杂的情况；MyBatis则是轻量级的持久化框架，更接近SQL，适用于自由度较高的查询需求。

10. 如何在Spring Boot中配置日志？ Spring Boot默认支持Logback和Log4j2，可以通过application.properties或yml文件配置日志级别、路径等相关属性。

Spring框架中有哪些重要的注解？

在Spring框架中，有许多重要的注解，它们用于不同的目的，包括依赖注入、组件扫描、配置、AOP等方面。以下是部分常用的Spring注解：

1. @Component: 声明一个bean组件的基础注解，可以被@Component的派生注解@Service、@Repository和@Controller替换，以表示特定类型的组件。

2. @Service: 通常用于业务逻辑层，是@Component的一个特殊形式，添加更多的语义。

3. @Repository: 用于数据访问层，例如DAO类，同样也是@Component的扩展。

4. @Controller: 用于表示Web层的控制器。

5. @Autowired: 实现依赖注入，自动将Bean实例注入到需要的地方。

6. @Qualifier: 当有多个相同类型的Bean时，通过此注解指定要注入的特定Bean。

7. @Value: 用于注入基本类型值或从properties文件中读取值。

8. @Scope: 控制Bean的作用域，如singleton（单例）或prototype（原型）。

9. @Configuration: 表示这是一个配置类，可以替代XML配置。

10. @Bean: 在@Configuration类中定义Bean的方法上使用，告诉Spring该方法会返回一个应注册为Bean的对象。

11. @EnableAutoConfiguration: 启用Spring Boot的自动配置。

12. @RequestMapping, @GetMapping, @PostMapping: Web层的路由注解，用于映射HTTP请求。

13. @Transactional: 用于标记事务边界，实现声明式事务管理。

14. @Aspect: 面向切面编程（AOP）中的注解，定义一个切面。

15. @After, @Before, @Around: AOP中的通知注解，分别表示后置、前置和环绕通知。

@Autowired`注入失败时会有哪些可能的原因？

@Autowired 注入失败通常有以下几个常见原因：

1. 缺失匹配的 Bean: 要注入的类型没有在 Spring 容器中找到对应的 Bean。确保已创建并正确配置了所需类型的 Bean。

2. 类型不匹配: 声明的注入类型与 Spring 容器中存在的 Bean 类型不一致。检查类型是否正确，或者是否有 @Qualifier 或其他方式来指定正确的 Bean。

3. 未启用自动装配: 在 Spring XML 配置或 Spring Boot 中，需要启用自动装配 (@ EnableAutoConfiguration) 来让 @Autowired 工作。

4. 注解位置不当: @Autowired 应用在字段、setter 方法或构造函数上。如果放在了其他地方，可能会导致注入失败。

5. 默认唯一性要求: 默认情况下，Spring 需要找到一个且仅一个符合类型的 Bean 进行注入。如果有多个相同类型的 Bean，需要使用 @Qualifier 或 @Primary 解决。

6. 非 Singleton：对于 prototype 或其他作用域的 Bean，Spring 不会在每个请求时都注入同一个实例，可能导致意外的行为。

7. 延迟初始化: 如果配置了 Bean 的 lazy-init 属性，那么只有在真正被使用时才会初始化，可能导致 @Autowired 失败。

8. 静态字段: @Autowired 不能用于静态字段，因为静态字段在类加载时初始化，而那时 Spring 容器还没有准备好。

什么是 Spring 中的 `@Primary` 注解，并如何使用？

@Primary 是 Spring 提供的一个注解，用于在存在多个相同类型的候选 Bean 时，默认选择其中一个进行自动装配。当 Spring 遇到多个符合条件的 Bean 实例并且没有明确的 @Qualifier 指示时，会优先选择标注了 @Primary 的 Bean。

如何使用：

1. 将 @Primary 注解添加到你想作为默认 Bean 的类上的 @Component、@Service、@Repository 或 @Controller 等 Spring 组件注解之上。
2. 或者，将 @Primary 添加到 Bean 的配置方法上（如果使用的是基于 Java 的配置）。

例子：

// 使用 @Primary 注解
@Service
@Primary // 这是关键，声明这个实现为默认首选
public class PrimaryServiceImpl implements MyService {// ...
}@Service
public class SecondaryServiceImpl implements MyService {// ...
}

在这个例子中，如果我们有一个依赖于 MyService 类型的字段，Spring 将默认注入 PrimaryServiceImpl，即使还有 SecondaryServiceImpl 存在。

Spring 框架是非常广泛使用的 Java 应用开发框架，其面试中常见的问题涵盖了很多方面。这里列出一些基础和进阶的 Spring 面试题：

1. 简述Spring框架的核心组件。

   • Spring的主要组件包括IoC容器（控制反转）、AOP（面向切面编程）、MVC（模型-视图-控制器）、数据访问/集成、事务管理等。

2. 什么是IoC（Inversion of Control），它在Spring中的作用是什么？

   • IoC是将对象创建和对象间的依赖关系交由外部容器控制，而不是类内部。Spring通过IoC实现组件的松耦合。

3. 解释一下Spring的AOP。

   • AOP允许在程序执行期间，在不修改源代码的情况下添加新的行为（如日志记录、权限检查）。Spring支持面向切面编程，提供动态代理和通知（advises）机制。

4. Spring的Bean生命周期包括哪些阶段？

   • 包括实例化、属性注入、初始化回调、正常使用、销毁回调以及销毁。

5. Spring MVC工作原理是什么？

   • 用户请求到达DispatcherServlet，DispatcherServlet将请求分发给相应的Controller，Controller处理业务逻辑后返回ModelAndView，ViewResolver解析视图，最后渲染结果。

6. Spring有哪几种事务管理方式？

   • 基于编程式的事务管理（手动调用begin/commit/rollback）；基于声明式事务管理（使用@Transactional注解）。

7. Spring Data JPA如何简化数据库操作？

   • 它提供了方便的DAO层接口生成和查询构造器，减少了手写SQL和JDBC代码的需求。

8. Spring Security能用来做什么？

   • Spring Security是一个全面的安全框架，用于处理身份验证、授权、CSRF保护等安全问题。

9. 如何在Spring Boot中启用和配置WebSocket？

   • 可以通过引入spring-boot-starter-websocket依赖并在配置文件中设置WebSocket的相关配置。

10. Spring Cloud提供哪些微服务治理功能？

    • 负载均衡（Ribbon）、服务发现（Eureka）、熔断（Hystrix）、配置中心（Config Server）、API网关（Zuul）等。

您正在准备哪种级别的Spring面试（初级、中级、高级）？

回答： 我可以帮助准备各级别的Spring面试，包括初级、中级和高级。具体取决于您的需求和所关注的Spring技术领域。对于不同级别的面试，通常会涉及以下内容：

初级面试：

1. Spring基本概念理解，如IoC和AOP。
2. Spring Bean的生命周期。
3. Spring MVC的基本工作流程。
4. 声明式事务管理的使用。
5. 利用JdbcTemplate进行简单数据库操作。

中级面试：

1. Spring Boot的特性与优点。
2. 自动配置的工作原理。
3. Spring Data JPA或MyBatis集成与使用。
4. Spring Security的基础配置与认证原理。
5. 微服务架构中的Spring Cloud组件。

高级面试：

1. Spring AOP的自定义切面实现。
2. Spring Boot Actuator监控与健康检查。
3. Spring Cloud Stream与消息队列集成。
4. 整合Docker、Kubernetes进行部署。
5. Spring Profile的应用场景和配置。

Spring Security的基础配置与认证原理

Spring Security基础配置与认证原理

Spring Security是一个强大的安全框架，用于保护基于Spring的应用程序。以下是其基础配置和认证原理：

1. 添加依赖: 首先，在Spring Boot项目中引入Spring Security的依赖，通常是通过Spring Boot的起步依赖spring-boot-starter-security来完成。

2. 自动配置: Spring Boot会尝试自动配置Spring Security。默认情况下，所有HTTP请求都是受保护的，需要身份验证才能访问。

3. WebSecurityConfigurerAdapter配置: 创建一个类，继承WebSecurityConfigurerAdapter，覆盖configure(HttpSecurity http)方法来自定义安全规则。例如，设置允许匿名访问的部分路径：

   @Override
   protected void configure(HttpSecurity http) throws Exception {http.authorizeRequests().antMatchers("/public/**").permitAll() // 允许访问公共URL.anyRequest().authenticated(); // 其他所有请求都需要认证
   }
   

4. 身份验证配置: 在上面的配置中，我们指定了所有非公共请求需要认证。Spring Security提供了多种认证方式，例如基于表单的登录（Form Login）和基于JWT的认证等。

5. UserDetailsService: 实现UserDetailsService接口，提供用户详细信息的服务。例如：

   @Service
   public class CustomUserDetailsService implements UserDetailsService {@Overridepublic UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {// 从数据库或其他来源获取用户信息}
   }
   

   然后在WebSecurityConfigurerAdapter中注册这个服务。

6. 密码编码器PasswordEncoder: 根据实际情况选择合适的密码编码器，例如BCryptPasswordEncoder，以加密存储的密码。

7. 启用安全配置: 使用@EnableWebSecurity注解启用配置，如果在Spring Boot应用中，则不需要这个注解，因为已经默认启用。

8. 登录和权限控制: 默认情况下，Spring Security创建了一个 /login 路径处理登录请求。可以自定义登录页面和逻辑。另外，可以使用hasRole或hasAuthority进行角色或权限控制。

怎么配置Spring Security以支持JWT认证？

要配置Spring Security支持JSON Web Token (JWT)认证，你需要遵循以下步骤：

1. 添加依赖: 添加Spring Security和JWT库的依赖，如spring-security-oauth2-jose、jjwt或nimbus-jose-jwt。

2. 创建JWT工具类: 创建一个工具类用于生成和解析JWT，例如：

   public class JwtUtils {private static final String SECRET_KEY = "your_secret_key";private static final long EXPIRATION_TIME = 86400000L;public String generateToken(UserDetails userDetails) {// 生成JWT令牌}public boolean validateToken(String token) {// 验证JWT令牌}public UserPrincipal getUserFromToken(String token) {// 获取JWT令牌中的用户信息}
   }
   

3. 实现UserDetailsService: 如之前所述，提供用户详细信息的服务，包括用户名和角色。

4. 配置JWT Filter: 创建一个实现了Filter接口的类，比如JwtAuthenticationFilter，它负责解析JWT，验证它，然后将用户信息放入SecurityContextHolder。

5. 重写configure(HttpSecurity): 在你的安全配置类中，替换默认的安全行为，设置过滤器链：

   @Override
   protected void configure(HttpSecurity http) throws Exception {http.csrf().disable() // 因为JWT不使用CSRF token.authorizeRequests().antMatchers(HttpMethod.GET, "/api/public/**").permitAll().anyRequest().authenticated().and().addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class).sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
   }
   

6. 配置JWT资源服务器: 如果你有OAuth2资源服务器，可以配置ResourceServerConfigurerAdapter以支持JWT：

   @Configuration
   @EnableResourceServer
   public class ResourceServerConfig extends ResourceServerConfigurerAdapter {@Overridepublic void configure(ResourceServerSecurityConfigurer resources) {resources.resourceId("resource_id");}@Overridepublic void configure(HttpSecurity http) {http.authorizeRequests().anyRequest().authenticated();}
   }
   

7. 创建JWT授权中心: 如果你需要在客户端发送JWT，还需要创建一个授权端点，生成JWT令牌。

自动配置的工作原理

自动配置是Spring Boot的一大特色，它通过@SpringBootApplication注解启动。其工作原理大致分为以下几个步骤：

1. 扫描组件: Spring Boot会扫描指定包及其子包下的所有类，包括@Configuration、@Component、@Service等标记的bean。

2. 读取配置元数据: Spring Boot会查找META-INF/spring.factories文件，该文件包含了所有可用的自动配置类（@AutoConfigureBefore、@AutoConfigureAfter、@EnableAutoConfiguration等标注的类）。

3. 条件化配置: 自动配置类中的@Bean方法并不是都会被调用。每个@Bean都有一个可选的@Conditional注解，这些注解决定了在什么条件下这个@Bean才会被实例化。例如，只有当某个特定的类存在或者环境变量满足某些条件时，对应的Bean才被创建。

4. 自动配置 bean: 根据应用的类路径和属性配置，Spring Boot会选择合适的自动配置类，并创建它们声明的bean。这些bean通常是其他bean的依赖。

5. 主配置的合并: 用户自定义的配置会和自动配置进行合并，用户的配置优先级更高。

6. 启动应用: 完成所有bean的创建和依赖注入后，Spring Boot应用正式开始运行。

Spring AOP的自定义切面实现

回答：

在Spring AOP中，自定义切面通常需要创建一个带有注解@Aspect的类，其中定义了切入点表达式(@Pointcut)以及通知(前置、后置、环绕、异常、最终)。以下是实现步骤：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Throw;
import org.aspectj.lang.annotation.After;
import org.springframework.stereotype.Component;@Aspect // 标记为切面
@Component // 将切面注册为Spring bean
public class CustomAspect {// 定义切入点表达式，匹配执行的方法@Pointcut("execution(* com.example.service.*.*(..))") // 匹配com.example.service包下所有方法public void businessMethods() {// 点切面不需要有实际逻辑，仅用于定义切入点}// 前置通知，在目标方法前执行@Before("businessMethods()")public void beforeAdvice() {System.out.println("前置通知：方法开始之前");}// 后置通知（返回通知），在目标方法成功返回后执行@AfterReturning(pointcut = "businessMethods()", returning = "result")public void afterReturningAdvice(Object result) {System.out.println("后置返回通知：方法结束后，返回值为：" + result);}// 异常通知，在目标方法抛出异常后执行@Throw(value = Exception.class)public void exceptionAdvice(Exception ex) {System.out.println("异常通知：捕获到的异常：" + ex.getMessage());}// 最终通知，在目标方法无论是正常执行还是抛出异常之后执行@After("businessMethods()")public void afterAdvice() {System.out.println("最终通知：无论是否抛出异常，方法结束后");}// 环绕通知，使用ProceedingJoinPoint参数控制方法的执行@Around("businessMethods()")public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {long startTime = System.currentTimeMillis();System.out.println("环绕通知：方法开始前");// 执行目标方法Object result = joinPoint.proceed();long endTime = System.currentTimeMillis();System.out.println("环绕通知：方法结束后，耗时：" + (endTime - startTime) + "ms");return result;}
}