SpringBoot 整合 Spring Security 、JWT 实现认证、权限控制

博客主页: 南来_北往

系列专栏：Spring Boot实战

前言

Spring Security 和 JWT 实现认证、权限控制是一种在Web应用中保障安全的重要手段。

Spring Security是一个功能强大的身份验证和访问控制框架，它提供了完善的认证机制和方法级的授权功能。JWT（JSON Web Token）则是一种基于Token的认证方案，用于在通信双方之间传递安全信息。将Spring Security与JWT整合，可以实现有效的认证和权限管理，提升系统的安全性。

Spring Security的核心是一系列过滤器链，不同的功能经由不同的过滤器实现。例如，UsernamePasswordAuthenticationFilter负责登录认证处理，而FilterSecurityInterceptor则用于权限授权判断。这些过滤器形成了一道安全屏障，确保只有经过身份验证的用户才能访问应用程序的特定部分。

JWT在这种体系结构中扮演了重要角色。它是一种简洁且URL安全的方式，用于传递声明性陈述。一个JWT实际上就是一个字符串，由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。头部一般包含令牌的类型（例如JWT）和所使用的加密算法（如HMAC SHA256或RSA）；载荷则包含了声明信息，例如用户ID、用户名和其他属性；签名则用于验证令牌的合法性，确保令牌在传输过程中未被篡改。

在生成JWT令牌时，可以使用对称加密（例如HMAC）或非对称加密（例如RSA）。对称加密使用相同的密钥进行加密和解密，而非对称加密则使用一对公钥和私钥。公钥加密的内容只能通过私钥解密，反之亦然。为了增加安全性，许多应用采用非对称加密算法，将公钥放在客户端，而将私钥保存在服务器端。

当用户成功登录后，服务器会生成一个JWT令牌并返回给客户端。客户端将该令牌存储在本地（例如浏览器的Local Storage），并在随后的请求中将其放在HTTP请求头的Authorization字段中发送给服务器。服务器接收到带有JWT的请求后，会通过一系列的过滤器来验证令牌的有效性。如果令牌有效且用户拥有相应的权限，请求将继续执行；否则，请求将被拒绝。

使用Spring Security和JWT进行认证及权限控制的优势在于其灵活性和扩展性。Spring Security提供了丰富的定制化选项，可以根据具体需求配置所需的过滤器和认证流程。同时，JWT的无状态特性使得系统易于扩展，特别是在微服务架构中，无需在不同服务间同步用户的会话信息。

综上所述，Spring Security结合JWT提供了一种高效且安全的认证和权限控制方案。通过理解其核心原理和正确配置相关组件，开发者可以构建出既安全又易维护的Web应用。

案例

要在SpringBoot中整合Spring Security和JWT实现认证和权限控制，你需要按照以下步骤进行：

1、在你的pom.xml文件中添加以下依赖：

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

2、创建一个名为JwtUtil的工具类，用于生成和解析JWT令牌。

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public class JwtUtil {
    private static final String SECRET_KEY = "your_secret_key";
    private static final long EXPIRATION_TIME = 86400000L; // 1 day in milliseconds

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

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

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

3、创建一个实现UserDetailsService接口的类，用于加载用户信息。

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 {
    // Load user from database or other data source
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // Implement your logic to load user details by username
        // For example, you can fetch user details from the database and return a UserDetails object
    }
}

4、创建一个名为SecurityConfig的配置类，继承WebSecurityConfigurerAdapter，并覆盖相应的方法。

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.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private CustomUserDetailsService userDetailsService;

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated()
                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

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

5、创建一个名为JwtRequestFilter的过滤器类，继承OncePerRequestFilter，并覆盖doFilterInternal方法。

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
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;

public class JwtRequestFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) 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);
            username = JwtUtil.getUsernameFromToken(jwt);
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            if (JwtUtil.validateToken(jwt)) {
                Authentication authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        filterChain.doFilter(request, response);
    }
}

现在，你已经成功地在SpringBoot项目中整合了Spring Security和JWT，可以实现认证和权限控制。