springboot前后端分离如何实现jwt单点登录

在Spring Boot前后端分离的项目中，可以使用JWT（JSON Web Token）来实现单点登录。JWT是一种轻量级的身份验证和授权机制，可以在不同的系统之间安全地传递用户信息。

一般来说，JWT实现单点登录需要以下几个步骤：

1. 用户登录时，前端将用户的账号密码发送给后端，后端验证成功后生成JWT，将JWT返回给前端。

2. 前端将JWT保存在本地，每次向后端发送请求时，在请求头中添加JWT。

3. 后端对每次请求进行拦截，验证JWT是否有效，如果有效则返回数据，无效则返回未登录或者权限不足等信息。

下面是具体实现步骤：

1. 引入相关依赖

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2. 创建JWT工具类

JWT工具类用于生成和验证JWT，需要设置过期时间、签名密钥等信息。

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Component
public class JwtUtils {

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.expiration}")
    private Long expiration;

    /**
     * 生成JWT
     *
     * @param claims 用户信息
     * @return JWT
     */
    public String generateToken(Map<String, Object> claims) {
        Date expirationDate = new Date(System.currentTimeMillis() + expiration);
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(expirationDate)
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 验证JWT是否有效
     *
     * @param token JWT
     * @return 是否有效
     */
    public Boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 获取JWT中的用户信息
     *
     * @param token JWT
     * @return 用户信息
     */
    public Map<String, Object> getClaimsFromToken(String token) {
        try {
            Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
            return new HashMap<>(claims);
        } catch (Exception e) {
            return null;
        }
    }
}

3. 创建登录接口

登录接口用于验证用户信息，并生成JWT。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
public class LoginController {

    @Autowired
    private JwtUtils jwtUtils;

    @PostMapping("/login")
    public Result login(@RequestBody Map<String, String> params) {
        // 验证用户信息，如果成功则生成JWT
        Map<String, Object> claims = new HashMap<>();
        claims.put("username", params.get("username"));
        String token = jwtUtils.generateToken(claims);
        return Result.success(token);
    }
}

4. 创建拦截器

拦截器用于验证请求头中的JWT是否有效。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class JwtInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtUtils jwtUtils;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("Authorization");
        if (token != null && jwtUtils.validateToken(token)) {
            return true;
        } else {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }
    }
}

5. 配置拦截器

在WebMvcConfigurer中添加拦截器配置。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private JwtInterceptor jwtInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }
}

至此，我们就成功实现了使用JWT实现Spring Boot前后端分离的单点登录功能。