JWT + Spring Security / OAuth2.0:微服务统一登录、鉴权、单点登录全解析

{
  "alg": "HS256", // 签名算法
  "typ": "JWT" // 令牌类型
}

{ "userId": 1, // 自定义声明：用户ID "userName": "admin", // 自定义声明：用户名 "role": "ADMIN", // 自定义声明：角色 "exp": 1715287600, // 标准声明：过期时间 "iat": 1715284000 // 标准声明：签发时间 }

<!-- Spring Boot Web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Security -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- JWT依赖 -->
<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>
<!-- 数据库依赖（模拟用户数据，可替换为MySQL） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

import io.jsonwebtoken.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
@Component
public class JwtTokenUtil {
    // JWT签名密钥（生产环境需配置在配置中心，如Nacos，严禁硬编码）
    @Value("${jwt.secret}")
    private String secret;
    // JWT过期时间（单位：毫秒，此处配置1小时）
    @Value("${jwt.expiration}")
    private long expiration;
    // 从令牌中获取用户名
    public String getUsernameFromToken(String token) {
        return getClaimFromToken(token, Claims::getSubject);
    }
    // 从令牌中获取过期时间
    public Date getExpirationDateFromToken(String token) {
        return getClaimFromToken(token, Claims::getExpiration);
    }
    // 从令牌中获取自定义声明
    public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = getAllClaimsFromToken(token);
        return claimsResolver.apply(claims);
    }
    // 解析令牌，获取所有声明（需验证签名）
    private Claims getAllClaimsFromToken(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(secret.getBytes())
                .build()
                .parseClaimsJws(token)
                .getBody();
    }
    // 判断令牌是否过期
    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }
    // 生成JWT令牌（基于用户信息）
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        // 自定义声明：添加用户角色（可根据需求添加更多信息）
        claims.put("roles", userDetails.getAuthorities());
        return doGenerateToken(claims, userDetails.getUsername());
    }
    // 生成令牌核心方法
    private String doGenerateToken(Map<String, Object> claims, String subject) {
        return Jwts.builder()
                .setClaims(claims) // 自定义声明
                .setSubject(subject) // 用户名（唯一标识）
                .setIssuedAt(new Date(System.currentTimeMillis())) // 签发时间
                .setExpiration(new Date(System.currentTimeMillis() + expiration)) // 过期时间
                .signWith(SignatureAlgorithm.HS256, secret.getBytes()) // 签名算法+密钥
                .compact();
    }
    // 验证令牌（验证签名、过期时间、用户名匹配）
    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = getUsernameFromToken(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
}

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.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
@EnableWebSecurity // 启用Spring Security
@EnableGlobalMethodSecurity(prePostEnabled = true) // 启用方法级别的权限控制
public class SecurityConfig {
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;
    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    // 密码加密器（BCrypt加密，不可逆，安全性高）
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    // 认证提供者（关联UserDetailsService和PasswordEncoder）
    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userDetailsService);
        authProvider.setPasswordEncoder(passwordEncoder());
        return authProvider;
    }
    // 认证管理器（核心认证组件）
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration authConfig) throws Exception {
        return authConfig.getAuthenticationManager();
    }
    // 核心安全配置（配置授权规则、过滤器、会话管理等）
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                // 关闭CSRF防护（微服务中JWT无状态，无需CSRF）
                .csrf().disable()
                // 配置未认证请求的处理方式（返回401）
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and()
                // 配置会话管理：无状态（不创建Session）
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                // 配置授权规则
                .authorizeRequests()
                // 登录接口、注册接口允许匿名访问
                .antMatchers("/api/auth/login", "/api/auth/register").permitAll()
                // 静态资源允许匿名访问
                .antMatchers("/static/**", "/swagger-ui/**").permitAll()
                // 管理员接口仅允许ADMIN角色访问
                .antMatchers("/api/admin/**").hasRole("ADMIN")
                // 普通用户接口允许USER或ADMIN角色访问
                .antMatchers("/api/user/**").hasAnyRole("USER", "ADMIN")
                // 其他所有请求都需要认证
                .anyRequest().authenticated();
        // 注册认证提供者
        http.authenticationProvider(authenticationProvider());
        // 添加JWT过滤器（在用户名密码过滤器之前执行，先验证令牌）
        http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
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 {
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Autowired
    private UserDetailsService userDetailsService;
    // 拦截请求，验证JWT令牌
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        try {
            // 1. 从请求头中提取JWT令牌（请求头格式：Authorization: Bearer <token>）
            String jwt = getJwtFromRequest(request);
            // 2. 验证令牌是否存在且有效
            if (jwt != null && !jwt.isEmpty() && jwtTokenUtil.validateToken(jwt, userDetailsService.loadUserByUsername(jwtTokenUtil.getUsernameFromToken(jwt)))) {
                // 3. 从令牌中获取用户名，加载用户信息
                String username = jwtTokenUtil.getUsernameFromToken(jwt);
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                // 4. 创建认证对象，存入SecurityContext
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        } catch (Exception e) {
            logger.error("无法设置用户认证信息: {}", e);
        }
        // 继续执行过滤器链
        filterChain.doFilter(request, response);
    }
    // 从请求头中提取JWT令牌
    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7); // 截取Bearer后面的令牌部分
        }
        return null;
    }
}

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
    // 未认证请求的处理逻辑
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException)
            throws IOException, ServletException {
        // 设置响应状态码401，返回JSON格式的错误信息
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.setContentType("application/json");
        response.getWriter().write("{\"code\":401,\"message\":\"未认证，请先登录获取令牌\"}");
    }
}

import lombok.Data;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@Data
@Entity
@Table(name = "sys_user")
public class User implements UserDetails {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(unique = true, nullable = false)
    private String username; // 用户名（唯一）
    @Column(nullable = false)
    private String password; // 加密后的密码
    private String role; // 角色（如ADMIN、USER）
    // 实现UserDetails接口方法：获取用户权限
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<GrantedAuthority> authorities = new ArrayList<>();
        // 将角色转换为Spring Security认可的权限格式（ROLE_前缀）
        authorities.add(new SimpleGrantedAuthority("ROLE_" + role));
        return authorities;
    }
    // 实现UserDetails接口方法：账号是否未过期（默认true）
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    // 实现UserDetails接口方法：账号是否未锁定（默认true）
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
    // 实现UserDetails接口方法：凭证是否未过期（默认true）
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    // 实现UserDetails接口方法：账号是否启用（默认true）
    @Override
    public boolean isEnabled() {
        return true;
    }
}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 根据用户名查询用户（Spring Security认证核心方法）
    Optional<User> findByUsername(String username);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
@Service
public class CustomUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    // 加载用户信息（根据用户名）
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 从数据库查询用户，若不存在则抛出异常
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("用户不存在：" + username));
        // 返回User对象（已实现UserDetails接口）
        return user;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
@RestController
@RequestMapping("/api/auth")
public class AuthController {
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private PasswordEncoder passwordEncoder;
    // 登录接口：接收账号密码，返回JWT令牌
    @PostMapping("/login")
    public ResponseEntity<Map<String, String>> login(@RequestBody LoginRequest loginRequest) {
        // 1. 执行认证（验证账号密码）
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                        loginRequest.getUsername(),
                        loginRequest.getPassword()
                )
        );
        // 2. 认证通过，将认证信息存入SecurityContext
        SecurityContextHolder.getContext().setAuthentication(authentication);
        // 3. 加载用户信息，生成JWT令牌
        UserDetails userDetails = userDetailsService.loadUserByUsername(loginRequest.getUsername());
        String jwt = jwtTokenUtil.generateToken(userDetails);
        // 4. 返回令牌和用户信息
        Map<String, String> response = new HashMap<>();
        response.put("token", jwt);
        response.put("username", userDetails.getUsername());
        response.put("role", userDetails.getAuthorities().iterator().next().getAuthority().replace("ROLE_", ""));
        return ResponseEntity.ok(response);
    }
    // 注册接口（可选，用于测试）
    @PostMapping("/register")
    public ResponseEntity<String> register(@RequestBody RegisterRequest registerRequest) {
        // 检查用户名是否已存在
        if (userRepository.findByUsername(registerRequest.getUsername()).isPresent()) {
            return ResponseEntity.badRequest().body("用户名已存在");
        }
        // 创建用户，加密密码
        User user = new User();
        user.setUsername(registerRequest.getUsername());
        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
        user.setRole(registerRequest.getRole()); // 如"USER"、"ADMIN"
        userRepository.save(user);
        return ResponseEntity.ok("注册成功");
    }
    // 登录请求参数封装
    public static class LoginRequest {
        private String username;
        private String password;
        // getter/setter
        public String getUsername() { return username; }
        public void setUsername(String username) { this.username = username; }
        public String getPassword() { return password; }
        public void setPassword(String password) { this.password = password; }
    }
    // 注册请求参数封装
    public static class RegisterRequest {
        private String username;
        private String password;
        private String role;
        // getter/setter
        public String getUsername() { return username; }
        public void setUsername(String username) { this.username = username; }
        public String getPassword() { return password; }
        public void setPassword(String password) { this.password = password; }
        public String getRole() { return role; }
        public void setRole(String role) { this.role = role; }
    }
}

spring:
  # 数据库配置（H2内存数据库，用于测试）
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password: 123456
  # JPA配置
  jpa:
    hibernate:
      ddl-auto: update # 自动创建表结构
    show-sql: true
    properties:
      hibernate:
        format_sql: true
  # H2控制台配置（访问：http://localhost:8080/h2-console）
  h2:
    console:
      enabled: true
      path: /h2-console
# JWT配置
jwt:
  secret: abc1234567890abc1234567890abc1234 # 签名密钥（生产环境需修改，建议至少32位）
  expiration: 3600000 # 过期时间（1小时，单位：毫秒）
# 服务器端口
server:
  port: 8080

<!-- 新增OAuth2.0授权服务器依赖 -->
<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.8.RELEASE</version>
</dependency>
<!-- 其他依赖（Spring Boot Web、Spring Security、JWT、数据库）同上 -->

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.password.PasswordEncoder;
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 {
    // 客户端ID（提前注册，用于客户端身份验证）
    private static final String CLIENT_ID = "client1";
    // 客户端密钥（加密存储，密码：123456）
    private static final String CLIENT_SECRET = "$2a$10$EixZaYbB.rK4fl8x2q7Meu6Q6D2V4Xw6Q6D2V4Xw6Q6D2V4Xw6Q6";
    // 授权范围
    private static final String SCOPE = "all";
    // 授权码模式
    private static final String GRANT_TYPE_AUTHORIZATION_CODE = "authorization_code";
    // 密码模式
    private static final String GRANT_TYPE_PASSWORD = "password";
    // 刷新令牌模式
    private static final String GRANT_TYPE_REFRESH_TOKEN = "refresh_token";
    // 令牌有效期（1小时）
    private static final int ACCESS_TOKEN_VALIDITY_SECONDS = 3600;
    // 刷新令牌有效期（7天）
    private static final int REFRESH_TOKEN_VALIDITY_SECONDS = 604800;
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private PasswordEncoder passwordEncoder;
    // JWT签名密钥（与资源服务器、JWT工具类一致，生产环境配置在配置中心）
    private static final String JWT_SECRET = "abc1234567890abc1234567890abc1234";
    // 配置令牌存储（JWT），用于存储和解析JWT令牌
    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(accessTokenConverter());
    }
    // 配置JWT令牌转换器（设置签名密钥，确保令牌生成和验证的一致性）
    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey(JWT_SECRET); // 与JWT工具类的密钥完全一致
        return converter;
    }
    // 配置客户端信息（客户端在授权服务器注册的核心信息，用于客户端身份校验）
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                // 客户端ID（唯一标识，客户端需携带此ID请求授权）
                .withClient(CLIENT_ID)
                // 客户端密钥（加密存储，客户端请求时需携带加密前的密钥进行校验）
                .secret(CLIENT_SECRET)
                // 授权范围，用于限制客户端可访问的资源范围
                .scopes(SCOPE)
                // 支持的授权模式，此处兼容授权码模式（SSO核心）、密码模式（内部系统）、刷新令牌模式
                .authorizedGrantTypes(GRANT_TYPE_AUTHORIZATION_CODE, GRANT_TYPE_PASSWORD, GRANT_TYPE_REFRESH_TOKEN)
                // 访问令牌有效期（1小时，避免令牌长期有效带来的安全风险）
                .accessTokenValiditySeconds(ACCESS_TOKEN_VALIDITY_SECONDS)
                // 刷新令牌有效期（7天，用户无需频繁登录，提升体验）
                .refreshTokenValiditySeconds(REFRESH_TOKEN_VALIDITY_SECONDS)
                // 回调地址（授权码模式必填，授权服务器颁发授权码后，跳转至此地址传递授权码）
                .redirectUris("http://localhost:8081/callback");
    }
    // 配置授权服务器端点（核心组件关联，确保认证和令牌生成流程正常）
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
                // 关联认证管理器（用于密码模式，验证用户账号密码合法性）
                .authenticationManager(authenticationManager)
                // 关联令牌存储（JWT），用于存储和读取令牌信息
                .tokenStore(tokenStore())
                // 关联令牌转换器（JWT），用于生成和解析JWT令牌
                .accessTokenConverter(accessTokenConverter());
    }
    // 配置授权服务器安全规则（控制授权服务器端点的访问权限）
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security
                // 允许所有客户端访问token_key端点（获取JWT签名公钥，用于资源服务器验证令牌）
                .tokenKeyAccess("permitAll()")
                // 允许所有客户端访问check_token端点（验证令牌的合法性，资源服务器会调用此端点）
                .checkTokenAccess("permitAll()")
                // 允许客户端通过表单认证（用于客户端身份校验，简化客户端请求流程）
                .allowFormAuthenticationForClients();
    }
}

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.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Autowired
    private UserDetailsService userDetailsService;
    // 密码加密器（与前文一致，BCrypt不可逆加密，确保密码安全）
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    // 认证提供者（关联UserDetailsService和PasswordEncoder，用于加载用户信息并校验密码）
    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userDetailsService);
        authProvider.setPasswordEncoder(passwordEncoder());
        return authProvider;
    }
    // 认证管理器（核心认证组件，授权服务器密码模式需依赖此组件）
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration authConfig) throws Exception {
        return authConfig.getAuthenticationManager();
    }
    // 安全过滤器链配置（关闭Session，允许授权相关端点匿名访问）
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                // 关闭CSRF防护（授权服务器无状态，无需CSRF）
                .csrf().disable()
                // 关闭Session（授权服务器无需存储用户会话，适配微服务无状态架构）
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                // 授权规则配置
                .authorizeRequests()
                // 授权服务器核心端点允许匿名访问（客户端请求授权、获取令牌需访问这些端点）
                .antMatchers("/oauth/authorize", "/oauth/token", "/oauth/check_token", "/oauth/token_key").permitAll()
                // 登录接口、注册接口允许匿名访问（用于用户注册和登录验证）
                .antMatchers("/api/auth/login", "/api/auth/register").permitAll()
                // 其他所有请求需认证（避免未授权访问）
                .anyRequest().authenticated();
        // 注册认证提供者
        http.authenticationProvider(authenticationProvider());
        return http.build();
    }
}

spring:
  # 数据库配置（H2内存数据库，用于测试，生产环境替换为MySQL）
  datasource:
    url: jdbc:h2:mem:authdb
    driver-class-name: org.h2.Driver
    username: sa
    password: 123456
  # JPA配置（自动创建表结构，简化测试）
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true
  # H2控制台配置（访问：http://localhost:8080/h2-console，用于插入测试用户）
  h2:
    console:
      enabled: true
      path: /h2-console
# JWT配置（与资源服务器、令牌转换器一致）
jwt:
  secret: abc1234567890abc1234567890abc1234 # 签名密钥，生产环境需修改并配置在配置中心
  expiration: 3600000 # 访问令牌有效期（1小时，与授权服务器配置一致）
# 服务器端口（授权服务器独立部署，端口设为8080，避免与资源服务器冲突）
server:
  port: 8080

<!-- Spring Boot Web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Security -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- OAuth2.0资源服务器依赖 -->
<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.8.RELEASE</version>
</dependency>
<!-- JWT依赖（与授权服务器一致） -->
<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>

import org.springframework.context.annotation.Configuration;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
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
@EnableResourceServer // 启用资源服务器
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    // 资源ID（唯一标识，与授权服务器客户端配置的资源范围对应）
    private static final String RESOURCE_ID = "all";
    // JWT签名密钥（与授权服务器完全一致，否则无法验证令牌）
    private static final String JWT_SECRET = "abc1234567890abc1234567890abc1234";
    // 配置令牌存储（JWT），与授权服务器一致
    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(accessTokenConverter());
    }
    // 配置JWT令牌转换器（设置签名密钥，用于验证令牌签名）
    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey(JWT_SECRET);
        return converter;
    }
    // 配置资源服务器核心信息（令牌存储、资源ID）
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources
                // 关联资源ID（与授权服务器客户端的scope对应）
                .resourceId(RESOURCE_ID)
                // 关联令牌存储（用于验证令牌合法性）
                .tokenStore(tokenStore())
                // 令牌验证失败时，返回401未授权响应
                .stateless(true);
    }
    // 配置资源访问权限规则（根据用户角色控制资源访问）
    @Override
    public void configure(org.springframework.security.config.annotation.web.builders.HttpSecurity http) throws Exception {
        http
                // 关闭CSRF防护（资源服务器无状态，无需CSRF）
                .csrf().disable()
                // 关闭Session（适配微服务无状态架构）
                .sessionManagement().sessionCreationPolicy(org.springframework.security.config.http.SessionCreationPolicy.STATELESS).and()
                // 授权规则配置
                .authorizeRequests()
                // 公开接口允许匿名访问（如健康检查接口）
                .antMatchers("/health/**").permitAll()
                // 管理员接口仅允许ADMIN角色访问
                .antMatchers("/api/admin/**").hasRole("ADMIN")
                // 普通用户接口允许USER或ADMIN角色访问
                .antMatchers("/api/user/**").hasAnyRole("USER", "ADMIN")
                // 其他所有资源需携带合法令牌才能访问
                .anyRequest().authenticated();
    }
}

# 服务器端口（资源服务器独立部署，设为8081，与授权服务器8080区分）
server:
  port: 8081
# JWT配置（与授权服务器完全一致）
jwt:
  secret: abc1234567890abc1234567890abc1234
  expiration: 3600000
# OAuth2.0资源服务器配置
security:
  oauth2:
    resource:
      # 令牌验证端点（授权服务器的check_token端点，用于验证令牌合法性）
      token-info-uri: http://localhost:8080/oauth/check_token
      # 资源ID（与资源服务器配置的RESOURCE_ID一致）
      id: all

import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class TestController {
    // 普通用户接口（USER、ADMIN角色可访问）
    @GetMapping("/user/test")
    public String userTest() {
        // 获取当前登录用户信息
        UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        return "普通用户接口访问成功！当前登录用户：" + userDetails.getUsername() + "，角色：" + userDetails.getAuthorities();
    }
    // 管理员接口（仅ADMIN角色可访问）
    @GetMapping("/admin/test")
    public String adminTest() {
        UserDetails userDetails = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        return "管理员接口访问成功！当前登录用户：" + userDetails.getUsername() + "，角色：" + userDetails.getAuthorities();
    }
    // 回调接口（用于接收授权服务器颁发的授权码，仅授权码模式使用）
    @GetMapping("/callback")
    public String callback(String code) {
        // 此处可接收授权码，后续可结合客户端逻辑获取access_token（实际场景中由客户端处理）
        return "授权码接收成功！code：" + code;
    }
}