springboot用jwt实现token退出登录的代码

可以参考下面的代码实现：public void logout(HttpServletRequest request) {
String token = request.getHeader("Authorization");
if (StringUtils.isNotBlank(token)) {
String jwtToken = token.replace("Bearer ","");
// 创建默认的JwtParser
JwtParser jwtParser = Jwts.parser();
Jws<Claims> claimsJws = jwtParser.parseClaimsJws(jwtToken);
// 拿到载荷
Claims claims = claimsJws.getBody();
// 获取用户名
String username = claims.getSubject();
// 删除redis中的token
redisTemplate.delete(username);
}
}

相关问题

springboot使用jwt缓存token的后台，如何缓存用户信息

Spring Boot 使用 JWT 缓存 Token 的后台，可以使用 Redis 进行缓存用户信息。具体实现可以参考以下步骤：

1. 在 Spring Boot 项目中引入 Redis 相关依赖，如 jedis、spring-boot-starter-data-redis 等。

2. 在项目中配置 Redis 相关参数，如 Redis 的 IP、端口、密码等。

3. 在用户登录成功后，生成 JWT Token，并将用户信息存储到 Redis 中，以 Token 为 Key，用户信息为 Value。

4. 在用户请求需要验证 Token 的接口时，从请求头中获取 Token，并从 Redis 中获取对应的用户信息进行验证。

5. 在 Token 过期或用户退出登录时，从 Redis 中删除对应的 Token 和用户信息。

以上是一种简单的实现方式，具体实现可以根据项目需求进行调整。

springboot使用token实现登录验证及退出

好的，我可以为你提供关于 Spring Boot 使用 Token 实现登录验证和退出的方法。

1. 登录验证

在用户登录成功后，服务器端生成一个 Token，并将 Token 返回给客户端。客户端在之后的请求中携带 Token，服务器端通过解析 Token 来验证用户的身份。

具体实现如下：

1.1 在用户登录成功后，生成 Token 并将 Token 返回给客户端

可以使用 JWT（JSON Web Token）生成 Token。JWT 由三部分组成：Header、Payload 和 Signature。Header 和 Payload 中存储用户信息，Signature 用于验证 Token 的合法性。

生成 Token 的代码如下：

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;

public class JwtUtils {
    private static final long EXPIRATION_TIME = 3600000; // Token 过期时间，这里设置为 1 小时
    private static final String SECRET_KEY = "secret"; // 加密密钥，可以自定义

    // 生成 Token
    public static String generateToken(String username) {
        Date now = new Date();
        Date expiration = new Date(now.getTime() + EXPIRATION_TIME);

        String token = Jwts.builder()
                .setSubject(username)
                .setIssuedAt(now)
                .setExpiration(expiration)
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();

        return token;
    }
}

1.2 在之后的请求中携带 Token

可以在请求的 Header 中添加 Authorization 字段，将 Token 的值设置为其 value。例如：

Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VybmFtZSIsImlhdCI6MTYyMDE4NzY5MywiZXhwIjoxNjIwMTkxMjkzfQ.GgO3x8D6R2pZahVn0v6zv9vKW9VlLDhUSJ5sCwGqjyQ

1.3 在服务器端验证 Token

可以使用 Spring Security 的 JwtAuthenticationFilter 过滤器来验证 Token。JwtAuthenticationFilter 继承自 OncePerRequestFilter，每个请求只会被该过滤器执行一次。

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
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.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.util.StringUtils;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtAuthenticationFilter extends BasicAuthenticationFilter {
    private static final String HEADER_AUTHORIZATION = "Authorization";
    private static final String TOKEN_PREFIX = "Bearer ";
    private static final String SECRET_KEY = "secret"; // 加密密钥，需要与生成 Token 的密钥一致

    public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        String authorizationHeader = request.getHeader(HEADER_AUTHORIZATION);

        if (StringUtils.hasText(authorizationHeader) && authorizationHeader.startsWith(TOKEN_PREFIX)) {
            String token = authorizationHeader.substring(TOKEN_PREFIX.length());

            try {
                Claims claims = Jwts.parser()
                        .setSigningKey(SECRET_KEY)
                        .parseClaimsJws(token)
                        .getBody();

                String username = claims.getSubject();

                Authentication authentication = new UsernamePasswordAuthenticationToken(username, null, null);
                SecurityContextHolder.getContext().setAuthentication(authentication);
            } catch (Exception e) {
                // Token 验证失败，可以根据具体情况进行处理
            }
        }

        chain.doFilter(request, response);
    }
}

2. 退出登录

在用户退出登录时，服务器端需要删除 Token。

具体实现如下：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;

public class JwtUtils {
    private static final String HEADER_AUTHORIZATION = "Authorization";
    private static final String TOKEN_PREFIX = "Bearer ";
    private static final String SECRET_KEY = "secret"; // 加密密钥，需要与生成 Token 的密钥一致

    // 获取当前用户的用户名
    public static String getCurrentUsername() {
        return SecurityContextHolder.getContext().getAuthentication().getName();
    }

    // 从请求中获取 Token
    public static String getTokenFromRequest(HttpServletRequest request) {
        String authorizationHeader = request.getHeader(HEADER_AUTHORIZATION);

        if (StringUtils.hasText(authorizationHeader) && authorizationHeader.startsWith(TOKEN_PREFIX)) {
            return authorizationHeader.substring(TOKEN_PREFIX.length());
        }

        return null;
    }

    // 验证 Token 是否有效
    public static boolean validateToken(String token) {
        try {
            Jwts.parser()
                    .setSigningKey(SECRET_KEY)
                    .parseClaimsJws(token);

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    // 删除 Token
    public static void deleteToken(String token) {
        // 可以将 Token 存储到数据库或 Redis 中，然后在这里进行删除
    }
}

在用户退出登录时，调用 deleteToken 方法即可删除 Token。

希望这些信息对你有所帮助，如果还有其他问题，欢迎随时提出。