SpringSecurity整合JWT和Redis

    Spring Security的整合JWT和Redis是一个强大的方式来实现用户身份验证和授权，以及提供令牌的生成和验证。下面是一个基本的示例，演示如何在Spring Security中整合JWT和Redis进行用户登录操作。

1. 添加依赖: 确保您的项目中包含Spring Security、Spring Boot、Spring Data Redis以及JWT相关的依赖。 

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

2. 配置JWT: 配置JWT生成和验证的相关信息，包括密钥、过期时间等。可以创建一个JwtUtil类来处理JWT操作。

@Configuration
public class JwtConfig {
    @Value("${jwt.secret}")
    private String jwtSecret;
    @Value("${jwt.expiration}")
    private long jwtExpiration;

    @Bean
    public JwtUtil jwtUtil() {
        return new JwtUtil(jwtSecret, jwtExpiration);
    }
}

3. 配置Spring Security: 配置Spring Security来启用JWT身份验证，并指定哪些端点需要进行身份验证。可以创建一个SecurityConfig类。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationEntryPoint unauthorizedHandler;
    @Autowired
    private JwtTokenFilter jwtTokenFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/api/auth/**").permitAll() // 公开访问的端点
            .anyRequest().authenticated();

        // 异常处理 (未授权处理)
        http.exceptionHandling().authenticationEntryPoint(unauthorizedHandler);

        // 添加JWT过滤器
        http.addFilterBefore(jwtTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

4. 创建一个登录端点: 在你的应用中创建一个登录端点，接受用户的身份验证凭证（通常是用户名和密码）。在登录成功后，生成JWT令牌并将其存储到Redis中。

@RestController
@RequestMapping("/api/auth")
public class AuthController {
    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private UserDetailsServiceImpl userDetailsService;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @PostMapping("/login")
    public ResponseEntity<?> authenticateUser(@RequestBody LoginRequest loginRequest) {
        // 使用Spring Security的AuthenticationManager来验证用户身份
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword())
        );

        SecurityContextHolder.getContext().setAuthentication(authentication);

        // 生成JWT令牌
        UserDetails userDetails = userDetailsService.loadUserByUsername(loginRequest.getUsername());
        String jwt = jwtUtil.generateToken(userDetails);

        // 将JWT令牌存储到Redis，以便后续验证
        redisTemplate.opsForValue().set("jwt:" + userDetails.getUsername(), jwt);

        return ResponseEntity.ok(new JwtResponse(jwt));
    }
}

5. 创建一个JWT Token Filter: 创建一个JWT Token过滤器，该过滤器负责解析和验证JWT令牌，然后将用户信息添加到Spring Security上下文。

@Component
public class JwtTokenFilter extends OncePerRequestFilter {
    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private UserDetailsServiceImpl userDetailsService;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        String jwt = getJwtFromRequest(request);
        if (StringUtils.hasText(jwt) && jwtUtil.validateToken(jwt)) {
            String username = jwtUtil.getUsernameFromToken(jwt);
            // 检查Redis中是否存在该令牌，以确保令牌没有被注销
            if (redisTemplate.hasKey("jwt:" + username)) {
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities()
                );
                SecurityContextHolder.getContext().setAuthentication(authenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
    
    // Helper method to extract JWT from the request
    private String getJwtFromRequest(HttpServletRequest request) {
        // Implement this method based on your token placement (e.g., in the Authorization header)
    }
}

6. 用户认证服务: 实现用户认证服务（UserDetailsService）以便加载用户信息和检查密码。这是您应用程序的特定部分，可能需要与数据库或其他数据存储进行交互。

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found with username: " + username);
        }
        return new UserPrincipal(user);
    }
}

    在整合Spring Security、JWT和Redis的应用中，创建其他操作接口（如添加操作）通常需要以下步骤：

1. 创建相应的控制器（Controller）： 首先，你需要创建一个控制器类，用于处理添加操作的HTTP请求。这个控制器类将包含一个或多个方法，用于处理不同的API端点。

@RestController
@RequestMapping("/api")
public class YourEntityController {

    @Autowired
    private YourEntityService entityService;

    @PostMapping("/add")
    public ResponseEntity<?> addEntity(@RequestBody YourEntityRequest entityRequest) {
        // 在这里实现添加操作
        YourEntity entity = entityService.addEntity(entityRequest);
        return ResponseEntity.ok(entity);
    }
    
    // 其他接口和操作
}

2. 创建相应的请求和响应类： 创建用于接收请求和发送响应的数据传输对象（DTO）。这些类可以包含与操作相关的数据字段。

public class YourEntityRequest {
    private String name;
    // 其他字段
    // getter 和 setter 方法
}

public class YourEntityResponse {
    private Long id;
    private String name;
    // 其他字段
    // getter 和 setter 方法
}

3. 创建相应的服务（Service）类： 创建一个服务类，用于实现添加操作以及其他相关的业务逻辑。

@Service
public class YourEntityService {

    @Autowired
    private YourEntityRepository entityRepository;

    public YourEntity addEntity(YourEntityRequest entityRequest) {
        YourEntity entity = new YourEntity();
        entity.setName(entityRequest.getName());
        // 设置其他字段

        YourEntity savedEntity = entityRepository.save(entity);
        return savedEntity;
    }
    
    // 其他服务方法
}

4. 配置访问控制： 如果你希望某些接口需要授权访问，你可以使用Spring Security的配置来定义访问控制规则。例如，你可以使用@PreAuthorize注解来定义访问要求。

@PreAuthorize("hasRole('ROLE_ADMIN')") // 示例：只有具有ROLE_ADMIN角色的用户可以访问
@PostMapping("/add")
public ResponseEntity<?> addEntity(@RequestBody YourEntityRequest entityRequest) {
    // 添加操作
}