SpringBoot安全深度防护：OAuth2+JWT实现分布式鉴权

fanxbl957

于 2025-03-11 10:57:14 发布

阅读量974

点赞数 27

分类专栏： Web 文章标签： spring boot 安全分布式

本文链接：https://blog.youkuaiyun.com/ashyyyy/article/details/146173168

版权

Web 专栏收录该内容

215 篇文章

订阅专栏

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

SpringBoot安全深度防护：OAuth2+JWT实现分布式鉴权

一、引言

在当今的分布式系统架构中，安全问题一直是至关重要的。随着微服务架构的广泛应用，系统的鉴权和授权变得更加复杂。传统的基于会话的认证方式在分布式环境下存在诸多挑战，如会话共享、单点登录等问题。OAuth2 和 JWT（JSON Web Token）为我们提供了一种高效、安全的分布式鉴权解决方案。本文将深入探讨如何在 Spring Boot 项目中结合 OAuth2 和 JWT 实现分布式鉴权。

二、OAuth2 与 JWT 基础概念

2.1 OAuth2 简介

OAuth2 是一种开放标准的授权协议，它允许用户授权第三方应用访问他们在另一个服务提供商上的资源，而无需将用户名和密码提供给第三方应用。OAuth2 定义了四种授权模式：授权码模式、简化模式、密码模式和客户端模式。在分布式系统中，授权码模式是最常用的模式，它通过授权码来换取访问令牌，保证了用户信息的安全性。

2.2 JWT 简介

JWT 是一种用于在网络应用间安全传递声明的开放标准（RFC 7519）。JWT 由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。头部包含了令牌的类型和使用的签名算法；载荷包含了声明信息，如用户 ID、角色等；签名用于验证消息在传递过程中没有被篡改。JWT 的优点是无状态、可扩展性强，适合在分布式系统中使用。

三、Spring Boot 集成 OAuth2 和 JWT

3.1 项目初始化

首先，我们需要创建一个 Spring Boot 项目。可以使用 Spring Initializr（https://start.spring.io/）来快速生成项目骨架，添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.oauth</groupId>
        <artifactId>spring-security-oauth2</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
</dependencies>

3.2 配置 OAuth2 授权服务器

创建一个授权服务器配置类，继承 AuthorizationServerConfigurerAdapter：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey("your-signing-key");
        return converter;
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
               .withClient("client-id")
               .secret("client-secret")
               .authorizedGrantTypes("password", "refresh_token")
               .scopes("read", "write")
               .accessTokenValiditySeconds(3600)
               .refreshTokenValiditySeconds(86400);
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authenticationManager(authenticationManager)
                 .tokenStore(tokenStore())
                 .accessTokenConverter(jwtAccessTokenConverter());
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.tokenKeyAccess("permitAll()")
                .checkTokenAccess("isAuthenticated()");
    }
}

3.3 配置资源服务器

创建一个资源服务器配置类，继承 ResourceServerConfigurerAdapter：

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/public/**").permitAll()
            .anyRequest().authenticated();
    }
}

3.4 配置 Spring Security

创建一个 Spring Security 配置类，继承 WebSecurityConfigurerAdapter：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();
    }
}

四、实现分布式鉴权

4.1 生成和验证 JWT

在授权服务器中，我们已经配置了 JWT 的生成和验证。当用户登录时，授权服务器会生成一个 JWT 作为访问令牌返回给客户端。客户端在后续的请求中需要将 JWT 放在请求头的 Authorization 字段中，格式为 Bearer <token>。资源服务器在接收到请求后，会验证 JWT 的签名和有效性。

4.2 单点登录（SSO）

在分布式系统中，单点登录是一个重要的需求。通过 OAuth2 和 JWT，我们可以实现单点登录。用户在一个服务中登录后，授权服务器会生成一个 JWT，用户可以使用这个 JWT 访问其他相关的服务，而无需再次登录。

4.3 跨服务鉴权

在微服务架构中，不同的服务可能需要不同的权限。我们可以在 JWT 的载荷中添加用户的角色和权限信息，资源服务器在接收到请求后，根据 JWT 中的信息进行鉴权。例如：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class JwtUtils {

    private static final String SECRET_KEY = "your-signing-key";

    public Claims extractClaims(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody();
    }

    public boolean isTokenValid(String token) {
        try {
            Claims claims = extractClaims(token);
            Date expiration = claims.getExpiration();
            return new Date().before(expiration);
        } catch (Exception e) {
            return false;
        }
    }
}

在资源服务器的控制器中，可以使用 JwtUtils 来验证 JWT 和获取用户信息：

import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ResourceController {

    @Autowired
    private JwtUtils jwtUtils;

    @GetMapping("/protected")
    public String protectedResource(@RequestHeader("Authorization") String authorizationHeader) {
        String token = authorizationHeader.replace("Bearer ", "");
        if (jwtUtils.isTokenValid(token)) {
            Claims claims = jwtUtils.extractClaims(token);
            String username = claims.getSubject();
            return "Hello, " + username + ". This is a protected resource.";
        } else {
            return "Invalid token";
        }
    }
}