SpringBoot安全三板斧：整合SpringSecurity+JWT+OAuth2

最新推荐文章于 2025-08-14 18:00:00 发布

原创最新推荐文章于 2025-08-14 18:00:00 发布 · 475 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#spring boot #安全 #后端

Web 专栏收录该内容

583 篇文章

订阅专栏

🎓博主介绍：Java、Python、js全栈开发 “多面手”，精通多种编程语言和技术，痴迷于人工智能领域。秉持着对技术的热爱与执着，持续探索创新，愿在此分享交流和学习，与大家共进步。
📖DeepSeek-行业融合之万象视界(附实战案例详解100+)
📖全栈开发环境搭建运行攻略：多语言一站式指南(环境搭建+运行+调试+发布+保姆级详解)
👉感兴趣的可以先收藏起来，希望帮助更多的人

SpringBoot安全三板斧：整合SpringSecurity+JWT+OAuth2

一、引言

在当今数字化时代，Web应用程序的安全性至关重要。Spring Boot作为一款广泛使用的Java开发框架，为开发者提供了便捷的开发体验。而Spring Security、JWT（JSON Web Token）和OAuth 2.0则是保障Spring Boot应用安全的三把利器。本文将详细介绍如何将这三者整合到Spring Boot项目中，为你的应用构建一个强大的安全体系。

二、Spring Security基础

2.1 Spring Security简介

Spring Security是Spring家族中的一个强大的安全框架，它提供了全面的安全解决方案，包括认证和授权。通过简单的配置，就可以为Web应用添加基本的安全功能。

2.2 简单的Spring Security配置示例

首先，我们创建一个简单的Spring Boot项目，并添加Spring Security依赖：

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

然后，创建一个配置类来配置Spring Security：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
           .authorizeRequests()
               .anyRequest().authenticated()
               .and()
           .formLogin();
        return http.build();
    }
}

在上述配置中，我们要求所有请求都需要进行身份验证，并使用表单登录。

三、JWT基础

3.1 JWT简介

JWT是一种用于在网络应用间安全传递信息的开放标准（RFC 7519）。它由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。JWT通常用于身份验证和信息交换。

3.2 JWT的生成和验证

我们可以使用Java的JJWT库来生成和验证JWT。首先，添加JJWT依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>

然后，创建一个JWT工具类：

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;

public class JwtUtils {

    private static final String SECRET_KEY = "yourSecretKey";
    private static final long EXPIRATION_TIME = 86400000; // 24 hours

    public static String generateToken(String username) {
        return Jwts.builder()
               .setSubject(username)
               .setIssuedAt(new Date(System.currentTimeMillis()))
               .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
               .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
               .compact();
    }

    public static String getUsernameFromToken(String token) {
        return Jwts.parser()
               .setSigningKey(SECRET_KEY)
               .parseClaimsJws(token)
               .getBody()
               .getSubject();
    }

    public static boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

四、OAuth 2.0基础

4.1 OAuth 2.0简介

OAuth 2.0是一种授权框架，它允许用户授予第三方应用访问其受保护资源的权限，而无需共享用户名和密码。OAuth 2.0定义了四种授权类型：授权码模式、隐式模式、密码模式和客户端凭证模式。

4.2 Spring Boot中使用OAuth 2.0

在Spring Boot中，我们可以使用Spring Security OAuth 2.0来实现OAuth 2.0的功能。首先，添加依赖：

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

然后，配置OAuth 2.0客户端：

spring:
  security:
    oauth2:
      client:
        registration:
          github:
            client-id: your-client-id
            client-secret: your-client-secret
            scope: read:user
        provider:
          github:
            authorization-uri: https://github.com/login/oauth/authorize
            token-uri: https://github.com/login/oauth/access_token
            user-info-uri: https://api.github.com/user

在上述配置中，我们配置了一个GitHub的OAuth 2.0客户端。

五、整合Spring Security、JWT和OAuth 2.0

5.1 配置Spring Security使用JWT

我们需要创建一个JWT过滤器来验证请求中的JWT。首先，创建一个JwtAuthenticationFilter类：

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = getJwtFromRequest(request);

        if (token != null && JwtUtils.validateToken(token)) {
            String username = JwtUtils.getUsernameFromToken(token);

            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                    username, null, null);
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

            SecurityContextHolder.getContext().setAuthentication(authentication);
        }

        filterChain.doFilter(request, response);
    }

    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

然后，在SecurityConfig类中配置该过滤器：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
public class SecurityConfig {

    private final JwtAuthenticationFilter jwtAuthenticationFilter;

    public SecurityConfig(JwtAuthenticationFilter jwtAuthenticationFilter) {
        this.jwtAuthenticationFilter = jwtAuthenticationFilter;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
           .csrf().disable()
           .authorizeRequests()
               .antMatchers("/api/auth/**").permitAll()
               .anyRequest().authenticated()
               .and()
           .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}

5.2 整合OAuth 2.0和JWT

当用户通过OAuth 2.0进行授权后，我们可以生成一个JWT并返回给客户端。以下是一个简单的示例：

import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OAuth2Controller {

    @GetMapping("/oauth2/callback")
    public String oauth2Callback(OAuth2AuthenticationToken authentication) {
        String username = authentication.getName();
        String token = JwtUtils.generateToken(username);
        return "Your JWT token: " + token;
    }
}

六、总结

通过整合Spring Security、JWT和OAuth 2.0，我们可以为Spring Boot应用构建一个强大的安全体系。Spring Security提供了基本的认证和授权功能，JWT用于在客户端和服务器之间安全传递身份信息，OAuth 2.0则允许用户授权第三方应用访问其受保护资源。希望本文能够帮助你更好地理解和应用这三个安全技术。