Spring Security自定义认证异常与全局异常处理方案

更新时间：2026年07月08日 11:20:56 作者：知远漫谈

在Spring Security中,自定义认证异常和全局异常处理是常见的需求,特别是在构建安全的应用时,本文给大家介绍Spring Security自定义认证异常与全局异常处理,感兴趣的朋友跟随小编一起看看吧

在现代 Java Web 应用开发中，安全机制是系统架构中不可或缺的一环。Spring Security 作为 Spring 生态中最主流的安全框架，提供了强大的身份认证（Authentication）和授权（Authorization）能力。然而，其默认的异常处理机制往往无法满足实际项目中对错误信息格式化、日志记录、前端友好提示等需求。

本文将深入探讨如何在 Spring Boot + Spring Security 架构中实现自定义认证异常以及构建统一的全局异常处理机制，帮助你打造更健壮、可维护性更强的安全系统。我们将从基础概念讲起，逐步过渡到实战编码，并结合 @ControllerAdvice、自定义异常类、认证过滤器扩展等内容，为你呈现一套完整的解决方案。

💡 提示： 如果你是第一次接触 Spring Security，建议先阅读 Spring 官方文档 - Security 模块介绍来建立基本认知。

🔐 一、Spring Security 默认异常机制分析

Spring Security 在执行认证流程时，会抛出多种预定义的异常，这些异常都继承自 AuthenticationException 抽象类。例如：

BadCredentialsException：用户名或密码错误
DisabledException：账户被禁用
AccountExpiredException：账户已过期
LockedException：账户被锁定
CredentialsExpiredException：凭证过期
UsernameNotFoundException：用户不存在

这些异常由 Spring Security 内部自动抛出，并通过默认的异常处理器进行响应。通常情况下，它们会被封装成 HTTP 401（Unauthorized）状态码返回给客户端。

但问题在于：

错误信息通常是英文且技术性强，不适合直接展示给最终用户；
缺乏结构化的 JSON 响应体，不利于前端解析；
不便于集中记录日志或触发告警；
无法根据不同客户端（如移动端、Web 端）返回差异化内容。

因此，我们需要对这一过程进行“拦截”并“重写”，实现更优雅的异常管理。

🧱 二、统一响应结构设计 ✨

为了实现前后端分离架构下的良好协作，我们首先需要定义一个通用的 API 响应格式。这不仅适用于安全异常，也适用于业务异常和其他系统级错误。

public class ApiResponse<T> {
    private int code;
    private String message;
    private T data;
    private long timestamp;
    public ApiResponse(int code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
        this.timestamp = System.currentTimeMillis();
    }
    // 静态工厂方法
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "操作成功", data);
    }
    public static <T> ApiResponse<T> error(int code, String message) {
        return new ApiResponse<>(code, message, null);
    }
    // getter and setter ...
}

这个 ApiResponse 类使用泛型支持任意数据返回，包含标准字段：状态码、消息、数据体和时间戳。它将成为我们所有接口返回的基础结构。

比如登录成功返回：

{
  "code": 200,
  "message": "操作成功",
  "data": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
  },
  "timestamp": 1715000000000
}

而认证失败则可能返回：

{
  "code": 401,
  "message": "用户名或密码错误",
  "data": null,
  "timestamp": 1715000000000
}

这样的结构清晰、易于解析，极大提升了前后端协作效率。

🚨 三、自定义认证异常类 💥

虽然 Spring Security 提供了丰富的异常类型，但我们希望在捕获这些异常后，能将其转化为我们自己定义的、更具语义化的异常，以便于后续统一处理。

3.1 创建自定义异常基类

public class BaseException extends RuntimeException {
    protected int code;
    protected String errorMessage;
    public BaseException(int code, String message) {
        super(message);
        this.code = code;
        this.errorMessage = message;
    }
    // getter methods
    public int getCode() { return code; }
    public String getErrorMessage() { return errorMessage; }
}

3.2 定义具体的安全相关异常

public class InvalidCredentialException extends BaseException {
    public InvalidCredentialException() {
        super(401, "用户名或密码错误");
    }
}
public class AccountLockedException extends BaseException {
    public AccountLockedException() {
        super(401, "账户已被锁定，请联系管理员");
    }
}
public class AccountDisabledException extends BaseException {
    public AccountDisabledException() {
        super(401, "账户已被禁用");
    }
}
public class AccountExpiredException extends BaseException {
    public AccountExpiredException() {
        super(401, "账户已过期");
    }
}
public class CredentialExpiredException extends BaseException {
    public CredentialExpiredException() {
        super(401, "密码已过期，请重新设置");
    }
}

这些自定义异常不仅携带了中文提示信息，还明确了 HTTP 状态语义（此处统一为 401），方便前端根据 code 字段做不同处理。

🔄 四、异常转换：将 Security 异常映射为自定义异常 ⚙️

Spring Security 的异常是在认证过程中由 AuthenticationManager 抛出的，我们需要在某个环节将其“翻译”为我们自己的异常。

最合适的切入点是 认证失败处理器（AuthenticationFailureHandler）。

4.1 实现自定义失败处理器

@Component
public class CustomAuthenticationFailureHandler implements AuthenticationFailureHandler {
    private final ObjectMapper objectMapper = new ObjectMapper();
    @Override
    public void onAuthenticationFailure(
            HttpServletRequest request,
            HttpServletResponse response,
            AuthenticationException exception) throws IOException {
        response.setStatus(HttpStatus.UNAUTHORIZED.value());
        response.setContentType("application/json;charset=UTF-8");
        String message = "认证失败";
        int code = 401;
        if (exception instanceof BadCredentialsException || 
            exception instanceof UsernameNotFoundException) {
            message = "用户名或密码错误";
            code = 401;
        } else if (exception instanceof DisabledException) {
            message = "账户已被禁用";
            code = 401;
        } else if (exception instanceof LockedException) {
            message = "账户已被锁定";
            code = 401;
        } else if (exception instanceof AccountExpiredException) {
            message = "账户已过期";
            code = 401;
        } else if (exception instanceof CredentialsExpiredException) {
            message = "密码已过期";
            code = 401;
        }
        ApiResponse<Object> apiResponse = ApiResponse.error(code, message);
        String jsonResponse = objectMapper.writeValueAsString(apiResponse);
        response.getWriter().write(jsonResponse);
    }
}

该处理器会在每次登录失败时被调用，根据不同的 AuthenticationException 子类生成对应的错误提示，并以 JSON 格式写入响应流。

4.2 配置到 SecurityFilterChain 中

接下来我们需要将这个处理器注册进 Spring Security 的认证流程中。

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Autowired
    private CustomAuthenticationFailureHandler failureHandler;
    @Autowired
    private UserDetailsService userDetailsService;
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/login").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .loginProcessingUrl("/doLogin") // 登录提交地址
                .failureHandler(failureHandler) // 注册失败处理器
                .permitAll()
            )
            .logout(logout -> logout.permitAll())
            .csrf(csrf -> csrf.disable()) // 前后端分离可关闭
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            );
        return http.build();
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Bean
    public AuthenticationManager authenticationManager(
            HttpSecurity http) throws Exception {
        return http.getSharedObject(AuthenticationManagerBuilder.class)
                   .userDetailsService(userDetailsService)
                   .passwordEncoder(passwordEncoder())
                   .build();
    }
}

此时，当用户输入错误密码时，浏览器将收到如下 JSON 响应：

{
  "code": 401,
  "message": "用户名或密码错误",
  "data": null,
  "timestamp": 1715000000000
}

而不是跳转到 /login?error 页面。

🌐 五、全局异常处理：@ControllerAdvice 统一拦截 🧩

尽管我们在认证阶段已经处理了大部分异常，但在其他控制器中仍可能发生未预期的异常（如空指针、数据库异常等）。为了保证整个系统的稳定性与一致性，必须引入全局异常处理机制。

Spring 提供了 @ControllerAdvice 注解，可以全局捕获控制器层抛出的异常。

5.1 编写全局异常处理器

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    /**
     * 处理自定义业务异常
     */
    @ExceptionHandler(BaseException.class)
    public ResponseEntity<ApiResponse<Object>> handleBaseException(BaseException e) {
        log.warn("业务异常：{}", e.getMessage());
        ApiResponse<Object> response = ApiResponse.error(e.getCode(), e.getErrorMessage());
        return ResponseEntity.status(e.getCode()).body(response);
    }
    /**
     * 处理参数绑定异常（如 @Valid 失败）
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiResponse<Object>> handleBindException(MethodArgumentNotValidException e) {
        BindingResult result = e.getBindingResult();
        StringBuilder sb = new StringBuilder();
        result.getFieldErrors().forEach(error -> 
            sb.append(error.getField()).append(": ").append(error.getDefaultMessage()).append("; ")
        );
        String message = sb.toString();
        log.warn("参数校验失败：{}", message);
        ApiResponse<Object> response = ApiResponse.error(400, "请求参数无效：" + message);
        return ResponseEntity.badRequest().body(response);
    }
    /**
     * 处理访问拒绝异常（权限不足）
     */
    @ExceptionHandler(AccessDeniedException.class)
    public ResponseEntity<ApiResponse<Object>> handleAccessDenied(AccessDeniedException e) {
        log.warn("权限不足：{}", e.getMessage());
        ApiResponse<Object> response = ApiResponse.error(403, "您没有权限执行此操作");
        return ResponseEntity.status(403).body(response);
    }
    /**
     * 处理未经认证的请求（未登录访问受保护资源）
     */
    @ExceptionHandler(AuthenticationCredentialsNotFoundException.class)
    public ResponseEntity<ApiResponse<Object>> handleUnauthenticated(AuthenticationCredentialsNotFoundException e) {
        log.warn("未认证访问：{}", e.getMessage());
        ApiResponse<Object> response = ApiResponse.error(401, "请先登录");
        return ResponseEntity.status(401).body(response);
    }
    /**
     * 处理服务器内部错误
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<Object>> handleUnexpectedException(Exception e) {
        log.error("服务器内部错误", e);
        ApiResponse<Object> response = ApiResponse.error(500, "服务器开小差了，请稍后再试");
        return ResponseEntity.status(500).body(response);
    }
}

📚 更多关于 @ControllerAdvice 的使用说明，可参考 Baeldung - Guide to @ControllerAdvice

该处理器覆盖了从客户端参数错误到服务端崩溃的各种场景，确保任何异常都不会以原始堆栈形式暴露给前端。

🔁 六、认证流程中的异常流转图示 🎯

下面通过一个 Mermaid 流程图来直观展示用户登录失败时的异常处理路径：

该图展示了从用户行为到最终响应输出的完整链路。可以看到，所有的认证失败都被集中在一个处理器中完成格式化输出，避免了分散处理带来的维护难题。

再来看一下全局异常处理的拦截范围：

这张图揭示了 Spring MVC 异常处理的核心机制：无论哪个 Controller 抛出了异常，都会被 @ControllerAdvice 拦截并按规则处理，从而实现真正的“全局”控制。

🔐 七、JWT 场景下的认证异常处理 🛡️

在无状态（stateless）架构中，越来越多的项目采用 JWT（JSON Web Token）作为认证方式。此时传统的 formLogin() 已不再适用，我们需要自定义过滤器来解析 Token 并处理异常。

7.1 自定义 JWT 认证过滤器

@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private final UserDetailsService userDetailsService;
    private final JwtUtil jwtUtil;
    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain chain) throws ServletException, IOException {
        final String authorizationHeader = request.getHeader("Authorization");
        String username = null;
        String jwt = null;
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            try {
                username = jwtUtil.extractUsername(jwt);
            } catch (ExpiredJwtException e) {
                sendErrorResponse(response, 401, "令牌已过期");
                return;
            } catch (MalformedJwtException | SignatureException e) {
                sendErrorResponse(response, 401, "无效的令牌");
                return;
            } catch (Exception e) {
                sendErrorResponse(response, 401, "令牌解析失败");
                return;
            }
        }
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            if (jwtUtil.validateToken(jwt, userDetails)) {
                UsernamePasswordAuthenticationToken authToken =
                    new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }
        chain.doFilter(request, response);
    }
    private void sendErrorResponse(HttpServletResponse response, int status, String message) throws IOException {
        response.setStatus(status);
        response.setContentType("application/json;charset=UTF-8");
        ApiResponse<Object> apiResponse = ApiResponse.error(status, message);
        String json = new ObjectMapper().writeValueAsString(apiResponse);
        response.getWriter().write(json);
    }
}

在这个过滤器中，我们手动解析 Authorization 头中的 JWT，并在出现各种 JWT 相关异常时立即返回结构化错误信息。

7.2 注册过滤器到 Security 链

@Bean
public SecurityFilterChain jwtSecurityFilterChain(HttpSecurity http) throws Exception {
    http
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(authz -> authz
            .requestMatchers("/auth/login", "/auth/register").permitAll()
            .anyRequest().authenticated()
        )
        .sessionManagement(session -> 
            session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
        .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    return http.build();
}

这样就实现了基于 JWT 的全链路异常控制。

🧪 八、测试验证：模拟各种异常场景 🔬

下面我们编写几个测试用例来验证异常处理是否生效。

8.1 控制器示例

@RestController
@RequestMapping("/api/user")
public class UserController {
    @GetMapping("/profile")
    public ApiResponse<UserDTO> getProfile() {
        // 模拟业务逻辑
        throw new NullPointerException("模拟空指针异常");
    }
    @PostMapping("/update")
    public ApiResponse<String> update(@Valid @RequestBody UserForm form) {
        return ApiResponse.success("更新成功");
    }
    @GetMapping("/admin")
    @PreAuthorize("hasRole('ADMIN')")
    public ApiResponse<String> adminOnly() {
        return ApiResponse.success("欢迎进入管理员页面");
    }
}

8.2 测试结果验证

场景一：参数校验失败

发送请求：

POST /api/user/update
Content-Type: application/json
{
  "name": "",
  "email": "not-an-email"
}

预期响应：

{
  "code": 400,
  "message": "请求参数无效：name: 不能为空; email: 必须是合法邮箱; ",
  "data": null,
  "timestamp": 1715000000000
}

✅ 由 MethodArgumentNotValidException 触发，被全局处理器捕获。

场景二：无权限访问

当前用户角色为 USER，访问 /api/user/admin。

预期响应：

{
  "code": 403,
  "message": "您没有权限执行此操作",
  "data": null,
  "timestamp": 1715000000000
}

✅ 由 AccessDeniedException 触发，被 @ControllerAdvice 捕获。

圐景三：服务器内部错误

访问 /api/user/profile，触发 NPE。

预期响应：

{
  "code": 500,
  "message": "服务器开小差了，请稍后再试",
  "data": null,
  "timestamp": 1715000000000
}

同时日志中应记录完整堆栈：

ERROR 12345 --- [nio-8080-exec-1] c.e.h.GlobalExceptionHandler : 服务器内部错误
java.lang.NullPointerException: 模拟空指针异常
    at com.example.controller.UserController.getProfile(UserController.java:15)
    ...

✅ 全局兜底异常生效。

🛠️ 九、最佳实践建议 💡

在实际项目中，除了技术实现外，还需注意以下几点以提升系统的可维护性和安全性：

9.1 错误码规范化管理

不要在代码中硬编码错误码，建议使用枚举统一管理：

public enum ErrorCode {
    SUCCESS(200, "操作成功"),
    UNAUTHORIZED(401, "请先登录"),
    FORBIDDEN(403, "权限不足"),
    NOT_FOUND(404, "资源不存在"),
    SERVER_ERROR(500, "服务器内部错误"),
    INVALID_CREDENTIAL(401, "用户名或密码错误"),
    ACCOUNT_LOCKED(401, "账户被锁定");
    private final int code;
    private final String message;
    ErrorCode(int code, String message) {
        this.code = code;
        this.message = message;
    }
    // getter...
}

然后在异常中引用：

throw new BaseException(ErrorCode.INVALID_CREDENTIAL.getCode(), 
                       ErrorCode.INVALID_CREDENTIAL.getMessage());

这有助于后期国际化或多语言支持。

9.2 日志脱敏处理

在记录异常日志时，务必注意不要泄露敏感信息，如密码、身份证号、银行卡等。可以使用日志框架的掩码功能或自定义序列化器。

9.3 前后端约定错误码范围

建议划分错误码区间，例如：

2xx: 成功
4xx: 客户端错误（参数、认证、权限）
5xx: 服务端错误
10xxx+: 业务特定错误码

便于定位问题来源。

9.4 支持多语言错误提示（可选）

对于国际化应用，可通过 MessageSource 动态读取本地化消息：

@Autowired
private MessageSource messageSource;
String msg = messageSource.getMessage("error.login.failed", null, Locale.CHINA);

配合 .properties 文件实现多语言切换。

🔄 十、扩展思考：异步任务中的异常处理 ❓

需要注意的是，@ControllerAdvice 只能拦截主线程中的异常。如果在 @Async 异步方法中抛出异常，将不会被其捕获。

解决办法有两种：

方案一：使用AsyncConfigurer全局配置

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) -> {
            log.error("异步方法 {} 执行出错，参数：{}", method.getName(), Arrays.toString(params), ex);
        };
    }
}

方案二：手动 try-catch 并抛出运行时异常

@Async
public void asyncTask() {
    try {
        // 业务逻辑
    } catch (Exception e) {
        throw new RuntimeException("异步任务失败", e);
    }
}

然后在调用处捕获。

🌈 结语：构建健壮安全体系的最后一步 🏁

通过本文的讲解，你应该已经掌握了如何在 Spring Security 项目中实现：

✅ 自定义认证异常类
✅ 使用 AuthenticationFailureHandler 统一处理登录失败
✅ 设计通用 API 响应结构
✅ 利用 @ControllerAdvice 实现全局异常拦截
✅ 结合 JWT 实现无状态认证异常控制
✅ 编写可测试的异常处理逻辑

📘 若想进一步深入 Spring Security 原理，推荐阅读 Spring Security 官方架构指南

安全不仅是功能，更是一种责任。一个良好的异常处理机制不仅能提升用户体验，还能有效防止信息泄露、增强系统可观测性。希望本文能为你在构建企业级应用的路上提供有力支持。

到此这篇关于Spring Security自定义认证异常与全局异常处理的文章就介绍到这了,更多相关Spring Security自定义认证异常内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java中equals()方法实例详解
equals方法是java.lang.Object类的方法,下面这篇文章主要给大家介绍了关于Java中equals()方法的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
2021-12-12
教你如何轻松学会Java快慢指针法
要想把搬砖的效率提高,我们肯定是逃不掉数据结构和算法知识的,这不,可爱的小编今天就和大家一起学习来了,今天给大家分享的是快慢指针,那啥是快慢指针呢,文中有非常详细的解释,需要的朋友可以参考下
2021-06-06
java并发之AtomicInteger源码分析
AtomicInteger是java并发包下面提供的原子类，主要操作的是int类型的整型，通过调用底层Unsafe的CAS等方法实现原子操作。下面小编和大家一起学习一下
2019-05-05
Java 进程执行外部程序造成阻塞的一种原因
前一阵子在研究文档展示时使用了java进程直接调用外部程序,其中遇到一个问题花了好长时间才解决,这个问题就是外部程序直接执行没什么问题，但是当使用Java进程执行时外部程序就阻塞在那儿不动了。而且这个外部程序在处理某些文件时使用Java进程执行是没问题的
2014-03-03
JAVA覆盖和重写的区别及说明
非静态方法的覆盖即重写,具有多态性；静态方法无法被覆盖,但可被重写（仅通过类名调用）,二者区别在于绑定时机与引用类型关联性
2025-07-07
SpringBoot响应Json数据乱码通过配置的解决
这篇文章主要介绍了SpringBoot响应Json数据乱码通过配置的解决，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-11-11
Java实现二维码功能的实例代码
今天这篇文章，主要是利用Java实现二维码功能，本文思路清晰，需要的朋友参考下
2017-02-02
java实现获取安卓设备里已安装的软件包
本文给大家介绍的是如何获取设备中已经安装的应用软件包的代码，其核心方法原理很简单，我们通过Android中提供的PackageManager类，来获取手机中安装的应用程序信息
2015-10-10
如何使用Spring Boot实现接口时间戳鉴权
这篇文章主要为大家详细介绍了如何使用Spring Boot实现接口时间戳鉴权,文中的示例代码讲解详细,具有一定的借鉴价值,感兴趣的小伙伴要了解下
2025-06-06
Hibernate hql查询代码实例
这篇文章主要介绍了Hibernate hql查询代码实例，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
2018-02-02