007-基于JWT实现登陆验证

已于 2023-03-15 14:45:25 修改
阅读量478 收藏 7
点赞数 1
分类专栏： # ①-JAVA脚手架 文章标签： JWT spring boot java
于 2022-08-06 03:18:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46914264/article/details/126188391
版权

🧑‍🎓 个人主页：Silence Lamb
📖 本章内容：【基于JWT实现登陆验证】

一、JWT消息构成

1.1【头部信息】

  • 头部（header)
  • 载荷（payload)
  • 签证（signature)

🌳 Jwt的头部承载两部分信息

  • 声明类型–这里是Jwt
  • 声明加密的算法–通常直接使用 HMAC SHA256

1.2【载荷信息】

🌳载荷就是存放有效信息的地方

  • 标准中注册的声明的数据
iss: jwt签发者
sub: jwt所面向的用户
aud: 接收jwt的一方
exp: jwt的过期时间，这个过期时间必须要大于签发时间
nbf: 定义在什么时间之前，该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。
  • 自定义数据
定义数据:存放我们想放在token中存放的key-value值

1.3【签证信息】

🌳 签证信息

  • base64加密后的header和base64加密后的payload连接组成的字符串
  • 然后通过header中声明的加密方式进行加盐secret组合加密
  • 然后就构成了Jwt的第三部分

二、配置Redis

2.1【引入依赖】

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    timeout: 1800000
    lettuce:
      pool:
        max-active: 20
        max-wait: -1
        max-idle: 5
        min-idle: 0

2.2【Redis配置类】

/**
 * @author Silence Lamb
 * @apiNote Redis序列化配置
 */
@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        //创建RedisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //创建JSON序列化工具
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // key 和 hashKey 采用String序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        // value 和 hashValue 采用JSON序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
}

2.3【Redis工具类】

**
 * @author Silence Lamb
 * @apiNote Redis工具类
 */
@SuppressWarnings(value = {"rawtypes" })
@Component
public class RedisUtils {

    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获取有效时间
     *
     * @param key Redis键
     * @return 有效时间
     */
    public long getExpire(final String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteObject(final Collection collection) {
        return redisTemplate.delete(collection) > 0;
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 删除Hash中的某条数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return 是否成功
     */
    public boolean deleteCacheMapValue(final String key, final String hKey) {
        return redisTemplate.opsForHash().delete(key, hKey) > 0;
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }
}

三、整合JWT

3.1【JWT配置】

  • 引入依赖
<dependency>
	<groupId>com.auth0</groupId>
	<artifactId>java-jwt</artifactId>
	<version>3.10.3</version>
</dependency>
<dependency>
   <groupId>cn.hutool</groupId>
   <artifactId>hutool-all</artifactId>
   <version>5.7.17</version>
</dependency>
  • JWT配置信息
# token配置
token:
  # 令牌自定义标识
  header: Authorization
  # 令牌密钥
  secret: K0TmVM#8O9u2end6V~QpYZ!!Xt
  # 令牌有效期（默认30分钟）
  expireTime: 3000
spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    timeout: 1800000
    lettuce:
      pool:
        max-active: 20
        max-wait: -1
        max-idle: 5
        min-idle: 0
  • 读取配置信息
/**
 * @author Silence Lamb
 * @apiNote 读取JWT配置信息
 */
@Data
@Component
@ConfigurationProperties(prefix = "token")
public class TokenProperties {

    /**
     * 令牌自定义标识
     */
    private String header;

    /**
     * 令牌秘钥
     */
    private String secret;

    /**
     * 令牌有效期（默认30分钟）
     */
    private int expireTime;
}

3.2【常量信息】

  • Resis缓存常量
/**
 * @author Silence Lamb
 * @apiNote 缓存常量
 */
public class RedisConstant {
    public static final String LOGIN_CODE_KEY= "login:code:";
    public static final Long LOGIN_CODE_TTL = 2L;
    public static final String LOGIN_TOKEN_KEY = "login:token:";
    public static final Long LOGIN_TOKEN_TTL = 36000L;
    public static final Long CACHE_NULL_TTL = 2L;
}
  • 用户实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    /**
     * 用户ID
     */
    private String userID;
    /**
     * 用户名
     */
    private String userName;
    /**
     * 账户密码
     */
    private String passWord;
    /**
     * 用户唯一标识
     */
    private String token;

    /**
     * token过期时间
     */
    private Long expireTime;
    /**
     * 登录时间
     */
    private Date loginTime;
}

3.3【Token工具类】

/**
 * @author Silence Lamb
 * @apiNote Token工具类
 */
@Component
public class TokenUtils {

    @Resource
    public TokenProperties tokenProperties;

    protected static final long MILLIS_SECOND = 1000;

    protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND;

    private static final Long MILLIS_MINUTE_TEN = 20 * 60 * 1000L;

     /**
     * 从数据生成令牌
     *
     * @param claims 数据
     * @return token
     */
    public String createToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .signWith(SignatureAlgorithm.HS512, tokenProperties.getSecret())
                .compact();
    }

    /**
     * 从令牌中获取数据
     *
     * @param token 令牌
     * @return 数据声明
     */
    public Claims parseToken(String token) {
        return Jwts.parser()
                .setSigningKey(tokenProperties.getSecret())
                .parseClaimsJws(token)
                .getBody();
    }
    
    /**
     * 获取缓存的token键值
     *
     * @param uuid 唯一标识
     * @return 缓存的token键值
     */
    public String getTokenKey(String uuid) {
        return RedisConstant.LOGIN_TOKEN_KEY + uuid;
    }

    /**
     * 获取缓存的code键值
     *
     * @param phone 手机号
     * @return 缓存的验证码键值
     */
    public String getCodeKey(String phone) {
        return RedisConstant.LOGIN_CODE_KEY + phone;
    }
}

1【创建Token令牌】

/**
 * 创建令牌
 *
 * @param user 用户信息
 * @return 令牌
 */
public String createToken(User user) {
    //生成uuid作为存储在redis中token的键值
    String uuid = UUID.randomUUID().toString();
    //将生成的token存储起来
    user.setToken(uuid);
    //将用户信息放进JWT中
    setUserAgent(user);
    // 并记录重置token有效期
    refreshToken(user);
    Map<String, Object> claims = new HashMap<>();
    claims.put(RedisConstant.LOGIN_TOKEN_KEY, uuid);
    return createToken(claims);
}

2【刷新令牌有效期】

/**
 * 刷新令牌有效期
 * @param user 用户信息
 */
private void refreshToken(User user) {
    user.setLoginTime(new Date());
    long time = user.getLoginTime().getTime();
    user.setExpireTime(time + tokenProperties.getExpireTime() * MILLIS_MINUTE);
    // 根据uuid将loginUser缓存
    String userKey = getTokenKey(user.getToken());
    redisUtils.setCacheObject(userKey, user, tokenProperties.getExpireTime(), TimeUnit.MINUTES);
}

3【从请求中获取token】

/**
 * 从请求中获取token
 *
 * @param request 请求域
 * @return token
 */
public String getToken(HttpServletRequest request) {
    String token = request.getHeader(tokenProperties.getHeader());
    if (StringUtils.isNotEmpty(token) && token.startsWith(RedisConstant.TOKEN_PREFIX)) {
        token = token.replace(RedisConstant.TOKEN_PREFIX, "");
    }
    return token;
}

4【超时刷新令牌有效期】

/**
 * 验证令牌有效期，相差不足20分钟，自动刷新缓存
 *
 * @param user 用户信息
 */
public void verifyToken(User user) {
    long expireTime = user.getExpireTime();
    long currentTime = System.currentTimeMillis();
    if (expireTime - currentTime <= MILLIS_MINUTE_TEN) {
        refreshToken(user);
    }
}

5【从令牌中获取用户名】

/**
 * 从请求中获取用户身份信息
 *
 * @return 用户信息
 */
public User getLoginUser(HttpServletRequest request) {
    // 获取请求携带的令牌
    String token = getToken(request);
    if (StringUtils.isNotEmpty(token)) {
        try {
            Claims claims = parseToken(token);
            // 解析对应的权限以及用户信息
            String uuid = (String) claims.get(RedisConstant.LOGIN_TOKEN_KEY);
            return redisUtils.getCacheObject(getTokenKey(uuid));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return null;
}

/**
 * 从令牌中获取用户名
 *
 * @param token 令牌
 * @return 用户名
 */
public String getUsernameFromToken(String token) {
    Claims claims = parseToken(token);
    return claims.getSubject();
}

6【设置用户身份信息】

/**
 * 设置用户身份信息
 */
public void setLoginUser(User user) {
    if (StringUtils.isNotNull(user) && StringUtils.isNotEmpty(user.getToken())) {
        refreshToken(user);
    }
}

7【删除用户身份信息】

/**
 * 删除用户身份信息
 */
public void deleteLoginUser(String token) {
    if (StringUtils.isNotEmpty(token)) {
        String userKey = getTokenKey(token);
        redisUtils.deleteObject(userKey);
    }
}

四、登录拦截器

  • 用户首先进入token拦截器-判断是否携带token

    • true：进入登陆检验用户信息拦截器

  • 登录拦截器-判断用户是否存在，账户密码是否正确

    • true：放行-可以访问其他服务
    • false：直接拦截用户请求

创建ThreadLocal保存用户信息

/**
 * @author Silence Lamb
 * @apiNote 创建ThreadLocal保存用户信息
 */
public class UserContext {
    private static final ThreadLocal<User> contextHolder = new ThreadLocal<>();

    //从线程获取用户信息
    public static User getContext() {
        return contextHolder.get();
    }
    //设置用户信息到线程中
    public static void setContext(User user) {
        contextHolder.set(user);
    }
    //防止线程泄露
    public static void clearContext() {
        contextHolder.remove();
    }
}

4.1【Token拦截器】

/**
 * @author Silence Lamb
 * @apiNote 刷新Token拦截器
 */
public class RefreshTokenInterceptor implements HandlerInterceptor {

    private final TokenUtils tokenUtils;

    public RefreshTokenInterceptor(TokenUtils tokenUtils) {
        this.tokenUtils = tokenUtils;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        User loginUser = tokenUtils.getLoginUser(request);
        //3.判断用户是否存在
        if (StringUtils.isNull(loginUser)) {
            //4.不存在，拦截，返回 401 状态码
            response.setStatus(401);
            return true;
        }
        //5.存在，保存用户信息到Thread-local
        tokenUtils.verifyToken(loginUser);
        UserContext.setContext(loginUser);
        //6.放行
        return true;
    }


    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserContext.clearContext();
    }
}

4.2【登录拦截器】

/**
 * @author Sience Lamb
 * @apiNote 登录拦截器
 */
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.判断Thread-local是否有用户
        if (UserContext.getContext() == null) {
            //4.没有用户则进行拦截，返回 401 状态码
            response.setStatus(401);
            return false;
        }
        //6.放行
        return true;
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserContext.clearContext();
    }
}

4.3【注册拦截器】

/**
 * @author Silence Lamb
 * @apiNote 配置拦截规则
 */
@Configuration
public class MyMvcConfigurer implements WebMvcConfigurer {
    @Resource
    private TokenUtils tokenUtils;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 登录拦截器
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/user/code",
                        "/user/login"
                ).order(1);
        // token刷新的拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(tokenUtils)).addPathPatterns("/**").order(0);
    }
}

4.4【测试登录拦截】

  • 生成验证码
@Override
public AjaxResult sendCode(String phone) {
    //1.校验手机号
    if (RegexUtils.isPhoneInvalid(phone)) {
        //2.手机不符合，返回错误信息
        AjaxResult.error("手机格式错误");
    }
    //3.符合，生成验证码
    String code = RandomUtil.randomNumbers(6);
    //4.保存验证码到session
    log.debug("发送短信验证码成功，验证码：{}", code);
    //5.返回OK
    return AjaxResult.success().put("code", code);
}
  • 收到验证码，用户进行登录
/**
 * 用户登录
 *
 * @param loginBody 登录信息
 */
@Override
public AjaxResult login(LoginBody loginBody) {
    //1.校验手机号
    String phone = loginBody.getPhone();
    if (RegexUtils.isPhoneInvalid(phone)) {
        return AjaxResult.error("手机格式错误");
    }
    //2.校验验证码
    String cacheCode = stringRedisTemplate.opsForValue().get(tokenUtils.getCodeKey(phone));
    String code = loginBody.getCode();
    if (cacheCode == null || !cacheCode.equals(code)) {
        //3.验证码不一致：报错
        return AjaxResult.error("验证码错误");
    }
    //4.验证码一致：根据手机号查找用户信息（从数据库中查询）
    //5.用户不存在：不存在则创建新用户并保存到数据库中
    User user = createUserWithPhone(phone);
    //6.生成Token
    user.setLoginTime(new Date());
    String token = tokenUtils.createToken(user);
    return AjaxResult.success(token);
}

/**
 * 根据手机号创建新用户
 *
 * @param phone 手机号
 * @return 新用户
 */
private User createUserWithPhone(String phone) {
    User user = new User();
    user.setPassWord(phone);
    user.setUserName("silencelamb" + RandomUtil.randomNumbers(6));
    return user;
}

  • 收到验证码之后进行登录：http://localhost:80/user/login

    {
    "phone":13781570487,
    "code":"070793"
}

    {
    "msg": "操作成功",
    "code": 200,
    "token": "eyJhbGciOiJIUzUxMiJ9.eyJsb2dpbjp0b2tlbjoiOiJiNDNlYzBlNC1lNWI4LTRjYzEtODFhMC1iNGViOTVmZTg5Y2UifQ.HbwZ7VEqyn8Hk1sxib--EWB5NFMhdyi_YmaPEPoQpIwLLWXBdE50czcwnFitcn99iBWyr6LXkD6g7YZMuJWVKQ"
}

五、自定义注解

5.1【自定义注解】

  • 自定义注解：用来跳过验证的PassToken
/**
 * @author Silence Lamb
 * @apiNote 用来跳过验证的PassToken
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface PassToken {
}

5.2【修改拦截器】

  • 修改登录拦截器
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();

        //检查是否有passToken注释，有则跳过认证
        if (method.isAnnotationPresent(PassToken.class)) {
            PassToken passToken = method.getAnnotation(PassToken.class);
            if (passToken.required()) {
                return true;
            }
        }
        if (UserContext.getContext() == null) {
            //4.没有用户则进行拦截，返回 401 状态码
            response.setStatus(401);
            return false;
        }
        //6.放行
        return true;
    }
  • 创建Controller
    @PassToken
    @PostMapping("/PassToken")
    public AjaxResult testPassToken(@RequestParam("id") String id) {
        return AjaxResult.success("您已通过验证");
    }
🏅 项目地址：📢💨基于JWT实现登陆验证
Silence Lamb
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Security+jwt+验证码实现验证和授权
爱哭的毛毛虫的博客
11-26 4553
微服务Security+jwt+验证码实现认证和授权简要介绍基本流程核心代码测试 简要介绍 本次博客采用Spring Security、jwt、验证码的形式实现登录验证，项目本上是一个前后端分离项目。如果你的项目在登陆时不需要验证码，你只需要在后续的代码中，将有关验证码的过滤器删除。 基本流程 1、前端请求后端"/captcha"验证码接口，后端生成验证码文本及编码并将其存入redis缓存，然后返回验证码文本(五个字符)和验证码base64编码给前端。 2、前端显示验证码图片，用户输入用户名、密码、验证码
SpringSecurity+JWT自定义用户认证服务
遭不住啊
08-23 783
一、导入依赖 <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> </dependency> <dependency> <groupId>org.springframework.boot&lt
Java基于JWT实现Token登录验证
HRSR1314的博客
11-18 1148
Java基于JWT实现Toekn登录验证，内部有自定义注解，HandlerInterceptor、WebMvcConfigurer用法。
Java工具类03: 使用JWT实现用户登录认证
mongo1944的博客
05-25 456
使用JWT实现用户登录认证
springboot项目中登录校验
最新发布
qq_58216887的博客
05-09 2029
​ 1.定义拦截器，实现HandlerInterceptor接口，并重写其所有方法。方案一：在Controller的方法中进行try…catch处理（代码臃肿，不推荐）方案二：全局异常处理器（简单，优雅，推荐）程序开发过程中不可避免的会遇到的异常现象。优点：HTTP协议中支持的技术。优点：存储在服务器，安全。出现异常该如何处理？
基于JWT实现简单的用户登陆验证（超详细）
weixin_47025166的博客
06-20 9366
基于JWT实现简单的用户登陆验证
SpringBoot使用JWT实现登录验证的方法示例
08-25
通过以上步骤，SpringBoot应用就可以实现基于JWT的登录验证。当用户通过身份验证后，服务器返回JWT，之后客户端在每次请求时都将JWT放入请求头，服务器验证JWT的有效性，从而确认用户身份，实现无状态的身份验证。...
lua-resty-jwt：JWT为伟大的Openresty
02-03
标题"lua-resty-jwt：JWT为伟大的Openresty"表明了本文将探讨如何使用lua-resty-jwt库在Openresty（一个基于Nginx和Lua的高性能Web平台）中处理JSON Web Tokens (JWT)。JWT是一种安全的身份验证和授权机制，常用于...
Spring Security基于JWT实现SSO单点登录详解
08-25
Spring Security 基于 JWT 实现 SSO 单点登录详解 基于 Spring Security 框架和 JWT（JSON Web Token）技术，可以实现 SSO（Single Sign-On）单点登录系统。SSO 是一种常见的身份验证机制，允许用户使用同一个...
基于JWT实现SSO单点登录流程图解
08-18
基于JWT实现SSO单点登录流程图解 基于JWT实现SSO单点登录流程图解是指使用JSON Web Token（JWT）来实现单点登录（SSO）的机制。在这种机制中，用户只需要登录一次，就可以访问多个应用服务器上的资源，而不需要再次...
tomcat-jwt-security:基于JWT令牌实现安全阀
05-10
该项目旨在将JWT令牌身份验证功能引入Tomcat 8 ，从而将身份验证过滤器实现为Tomcat Valve。 JWT操作基于项目。 对于Tomcat 7，请使用或克隆。 基于Valve的身份验证应该可以与放置在web.xml文件中的Java标准安全...
JWT Token生成及验证
11-03
请参考博客：http://www.cnblogs.com/chenwolong/p/Token.html
SpringBoot SpringSecurity JWT+Redis+RSA授权登录登出 验证码 前后端分离 分布式
qq_50909707的博客
10-08 3872
对于微服务来说，私钥放在认证服务上，其他服务只需要存公钥即可。因为其他服务只做校验，不加密JWT。私钥加密，公钥解密。公钥和私钥放到服务器上，私钥用于授权服务器授权token时加密，其他服务器仅需要通过公钥便可对加密内容进行解析了。服务器通过用户输入的验证码结果和redis中的缓存进行比较得出是否验证码正确。只要安装了JDK，就有这个工具。携带错误的token测试：可以看到错误的token会被服务器警告。退出登录后，redis中缓存的用户信息将被删除。这里我们便实现了登录逻辑。复制文本，重命名文件。
若依分离版 设置账号只能同时在线一个用户
小汪同学
12-07 1034
若依分离版 设置账号只能同时在线一个用户
SpringBoot集成JWT的工具类与拦截器实现
热门推荐
lixianhe的博客
06-28 1万+
SpringBoot集成JWT的工具类与拦截器实现
JWT授权为啥要在 Authorization标头里加个Bearer 呢
Java__EE小白成长之路
07-16 9726
JWT授权为啥要在 Authorization标头里加个Bearer 呢
jwt可以作为请求的authorization的token吗
m0_57236802的博客
03-17 419
是的，JWT（JSON Web Tokens）非常适合用作请求的头部中的令牌。实际上，这是 JWT 最常见的使用场景之一。使用 JWT 作为授权令牌可以让服务器验证请求者的身份，并确认他们是否有权限执行特定的操作，而无需每次请求都查询数据库或执行复杂的身份验证逻辑。
JWT生成token模板及对接短信
weixin_45565886的博客
10-16 495
JWT生成token模板
后端开发Springboot个人使用最小应用-jwt通过配置完成登录验证
qq_44606649的博客
03-21 203
1. application配置属性 #安全验证jwt jwt.header=Authorization #令牌前缀,前后端发送token添加上此令牌 jwt.token-start-with=Bearer #令牌签名 jwt.sing=!@#$/*-QRIU234^&^Y* 2. 获取属性的实体对象 import lombok.Data; import org.springframework.beans.factory.annotation.Value; import org.springfra
使用jwt实现登录验证
08-22
- *1* *2* [基于JWT实现简单的用户登陆验证（超详细）](https://blog.csdn.net/weixin_47025166/article/details/125373122)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Silence Lamb

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值