用springboot+JWT+Redis实现单点登录

单点登录（Single Sign-On，简称SSO）是一种身份验证技术，可以让用户只需一次登录，就可以访问多个应用程序。在实际开发中，我们可以使用Spring Boot、JWT和Redis来实现单点登录功能。

下面是实现单点登录的步骤：

1. 创建Spring Boot项目并引入所需依赖：spring-boot-starter-web、spring-boot-starter-data-redis和jjwt。

2. 创建一个User实体类，包含用户名和密码等信息。

3. 创建一个UserService，实现对用户信息的操作，包括注册、登录等。

4. 引入JWT依赖后，我们需要创建一个JWTUtil类，实现token的生成和解析。

5. 创建一个LoginController，用于处理用户的登录请求。在登录成功后，生成token并将其存储到Redis中。

6. 创建一个AuthController，用于验证用户的token是否有效。在验证成功后，可以获取用户信息并返回。

7. 在需要进行单点登录验证的应用程序中，只需要在请求中携带token，并调用AuthController进行验证即可。

具体实现细节可以参考以下代码示例：

User实体类：

public class User {
    private String username;
    private String password;
    // 省略setter和getter方法
}

UserService接口：

public interface UserService {
    void register(User user);
    String login(String username, String password);
}

UserService实现类：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Override
    public void register(User user) {
        // 省略用户注册逻辑
    }

    @Override
    public String login(String username, String password) {
        // 省略用户登录逻辑
        // 登录成功后生成token并存储到Redis中
        String token = JWTUtil.generateToken(username);
        redisTemplate.opsForValue().set(username, token, 30, TimeUnit.MINUTES);
        return token;
    }
}

JWTUtil类：

public class JWTUtil {
    private static final String SECRET_KEY = "my_secret_key";
    private static final long EXPIRATION_TIME = 3600000;

    public static String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .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();
    }
}

LoginController：

@RestController
public class LoginController {

    @Autowired
    private UserService userService;

    @PostMapping("/login")
    public ResponseEntity<String> login(@RequestBody User user) {
        String token = userService.login(user.getUsername(), user.getPassword());
        return ResponseEntity.ok(token);
    }
}

AuthController：

@RestController
public class AuthController {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @GetMapping("/auth")
    public ResponseEntity<User> auth(@RequestHeader("Authorization") String token) {
        String username = JWTUtil.getUsernameFromToken(token);
        if (StringUtils.isEmpty(username)) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
        String redisToken = redisTemplate.opsForValue().get(username);
        if (!token.equals(redisToken)) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
        User user = new User();
        user.setUsername(username);
        return ResponseEntity.ok(user);
    }
}

在请求中携带token的示例：

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setInterceptors(Collections.singletonList((request, body, execution) -> {
            String token = // 从Redis中获取token
            request.getHeaders().add("Authorization", token);
            return execution.execute(request, body);
        }));
        return restTemplate;
    }
}

以上就是使用Spring Boot、JWT和Redis实现单点登录的步骤和示例代码。