JWT的token过期自动续期（无redis）

最新推荐文章于 2025-04-16 13:52:44 发布
最新推荐文章于 2025-04-16 13:52:44 发布
阅读量8.8k 收藏 34
点赞数 6
分类专栏： java技术 springBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40058629/article/details/112845280
版权

思路：

由于jwt中的token过期时间是打包在token中的，用户登录以后发送给客户端以后token不能变化，那么要在用户无感知的情况下刷新token，就要在符合过期条件的情况下，在缓存一个新的token，作为续命token，再次解析不要解析客户端发送的token，要解析自己缓存的续命token

主要逻辑：

如果当前token没有超过过期时间的两倍，续期，超过了重新登录

主要代码如下：

package com.hongseng.app.config.jwtfilter;

import com.hongseng.app.config.exception.RefreshTokenException;
import enums.TokenEnum;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.security.SignatureException;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import utils.JwtTokenUtils;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Objects;

/**
 * @program: spring-security
 * @description: 验证成功当然就是进行鉴权了，每一次需要权限的请求都需要检查该用户是否有该权限去操作该资源，当然这也是框架帮我们做的，那么我们需要做什么呢？
 * 很简单，只要告诉spring-security该用户是否已登录，是什么角色，拥有什么权限就可以了。
 * @author: fbl
 * @create: 2020-12-02 14:25
 **/
public class JWTAuthorizationFilter extends BasicAuthenticationFilter {
    private static final String LOGIN_URL = "/login";
    /**
     * 为每一个用户准备续命token
     */
    public static HashMap<String,String> TOKEN = new HashMap<>();

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

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws IOException, ServletException {

        String tokenHeader = request.getHeader(TokenEnum.TOKEN_HEADER.getValue());

        // 如果请求头中没有Authorization信息或者是登录接口直接放行了
        if (tokenHeader == null || !tokenHeader.startsWith(TokenEnum.TOKEN_PREFIX.getValue()) || request.getRequestURL().toString().contains(LOGIN_URL)) {
            chain.doFilter(request, response);
            return;
        }
        // 如果请求头中有token，则进行解析，并且设置认证信息
        String token = tokenHeader.replace(TokenEnum.TOKEN_PREFIX.getValue(), "");
        String userName = JwtTokenUtils.getUsername(token);

        try {
            if (JWTAuthorizationFilter.TOKEN.get(userName) != null) {
                refreshToken(TOKEN.get(userName));
                SecurityContextHolder.getContext().setAuthentication(getAuthentication(TOKEN.get(userName)));
            } else {
                refreshToken(tokenHeader);
                SecurityContextHolder.getContext().setAuthentication(getAuthentication(tokenHeader));
            }
        } catch (RefreshTokenException | ExpiredJwtException e) {
            // 异常捕获，发送到expiredJwtException
            request.setAttribute("expiredJwtException", e);
            //将异常分发到/expiredJwtException控制器
            request.getRequestDispatcher("/expiredJwtException").forward(request, response);
        } catch (SignatureException | AccessDeniedException e) {
            // 异常捕获，发送到signatureException
            request.setAttribute("signatureException", e);
            //将异常分发到/signatureException控制器
            request.getRequestDispatcher("/signatureException").forward(request, response);
        }
        super.doFilterInternal(request, response, chain);
    }

    /**
     * 这里从token中获取用户信息并新建一个token
     */
    private UsernamePasswordAuthenticationToken getAuthentication(String tokenHeader) {
        String token = tokenHeader.replace(TokenEnum.TOKEN_PREFIX.getValue(), "");

        String username = JwtTokenUtils.getUsername(token);
        String permission = JwtTokenUtils.getUserPermission(token);
        ArrayList<SimpleGrantedAuthority> simpleGrantedAuthorities = new ArrayList<>();
        for (String p : Arrays.asList(permission.split(","))) {
            simpleGrantedAuthorities.add(new SimpleGrantedAuthority(p));
        }
        if (username != null) {
            return new UsernamePasswordAuthenticationToken(username, null, simpleGrantedAuthorities);
        }
        return null;
    }

    /**
     * token刷新
     *
     * @param tokenHeader
     */
    private void refreshToken(String tokenHeader) throws RefreshTokenException {
        String token = tokenHeader.replace(TokenEnum.TOKEN_PREFIX.getValue(), "");
        // 客户端token有没有过期
        boolean expiration = JwtTokenUtils.isExpiration(token);
        // 是否过期时间已将超出两倍
        if (expiration) {
            boolean twoTimesTokenExpiration = JwtTokenUtils.isTwoTimesTokenExpiration(token);
            // 没有，续期，否则抛出自定义异常
            if (!twoTimesTokenExpiration) {
                String username = JwtTokenUtils.getUsername(token);
                String permission = JwtTokenUtils.getUserPermission(token);
                JWTAuthorizationFilter.TOKEN.put(JwtTokenUtils.getUsername(token),JwtTokenUtils.createToken(username, permission, false));
            } else {
                throw new RefreshTokenException();
            }
        }
    }
}

此外在Login登录时要清除该登录用户的续命token,在loginService中添加以下代码

 // 重新登录清除相关用户token
        if(Objects.nonNull(JWTAuthorizationFilter.TOKEN.get(userName))){
            JWTAuthorizationFilter.TOKEN.put(userName,null);
        }

自定义异常代码

package com.hongseng.app.config.exception;

/**
 * @program: fire_control
 * @description:
 * @author: fbl
 * @create: 2021-01-20 08:37
 **/
public class RefreshTokenException extends RuntimeException {
}

全局异常代码捕获需要修改 RefreshTokenException 自定义异常也需要捕获

package com.hongseng.app.config.exception;

import enums.ErrorCodeEnum;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.security.SignatureException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import result.Result;


/**
 * @program: fire_control
 * @description: 处理自定义的业务异常
 * @author: fbl
 * @create: 2021-01-15 16:21
 **/
@ControllerAdvice
public class GlobalExceptionHandler {

    /**
     * token过期
     *
     * @return
     */
    @ExceptionHandler(value = {ExpiredJwtException.class, RefreshTokenException.class})
    @ResponseBody
    public Result expiredJwtException() {
        return Result.failure(ErrorCodeEnum.SYS_ERR_TOKEN_EXPIRED);
    }


    /**
     * token错误
     *
     * @return
     */
    @ExceptionHandler(value = SignatureException.class)
    @ResponseBody
    public Result signatureException() {
        return Result.failure(ErrorCodeEnum.SYS_ERR_TOKEN_SIGNATURE);
    }

}

重定向异常发出controller也需要修改

package com.hongseng.app.controller;

import com.hongseng.app.config.exception.RefreshTokenException;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.security.SignatureException;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * @program: fire_control
 * @description:
 * @author: fbl
 * @create: 2021-01-18 07:54
 **/
@RestController
public class JwtExceptionController {

    /**
     * 重新抛出异常
     */
    @RequestMapping("/expiredJwtException")
    public void expiredJwtException(HttpServletRequest request) throws ExpiredJwtException, RefreshTokenException {
        if (request.getAttribute("expiredJwtException") instanceof ExpiredJwtException) {
            throw ((ExpiredJwtException) request.getAttribute("expiredJwtException"));
        } else {
            throw new RefreshTokenException();
        }
    }

    @RequestMapping("/signatureException")
    public void signatureException(HttpServletRequest request) throws SignatureException {
        throw ((SignatureException) request.getAttribute("signatureException"));
    }


}

自身缓存的续命token，默认为null，需要续期时赋值，再次解析解析此token,此处使用ThreadLocal，为每一个线程分配一个token，防止并发修改

private static ThreadLocal<String> token = null;

token工具类

package utils;

import enums.TokenEnum;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;

import java.security.Key;
import java.util.Date;
import java.util.HashMap;

/**
 * @program: spring-security
 * @description:
 * @author: fbl
 * @create: 2020-12-02 14:08
 **/
public class JwtTokenUtils {
    // 创建token
    public static String createToken(String username, String permission, boolean isRememberMe) {
        byte[] keyBytes = Decoders.BASE64.decode(TokenEnum.SECRET.getValue());
        Key key = Keys.hmacShaKeyFor(keyBytes);

        long expiration = isRememberMe ? TokenEnum.EXPIRATION_REMEMBER.getTime() : TokenEnum.EXPIRATION.getTime();
        HashMap<String, Object> map = new HashMap<>();
        map.put(TokenEnum.ROLE_CLAIMS.getValue(), permission);
        return Jwts.builder()
                .signWith(key, SignatureAlgorithm.HS512)
                // 这里要早set一点，放到后面会覆盖别的字段
                .setClaims(map)
                .setIssuer(TokenEnum.ISS.getValue())
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + expiration * 1000))
                .compact();
    }

    // 从token中获取用户名
    public static String getUsername(String token) {
        try {
            return  getTokenBody(token).getSubject();
        }catch (ExpiredJwtException e){
            return e.getClaims().getSubject();
        }

    }

   // 是否已过期
    public static boolean isExpiration(String token) {
        try {
            return getTokenBody(token).getExpiration().before(new Date());
        }catch (ExpiredJwtException e){
            return  e.getClaims().getExpiration().before(new Date());
        }
    }

    private static Claims getTokenBody(String token) {
        return Jwts.parser()
                .setSigningKey(TokenEnum.SECRET.getValue())
                .parseClaimsJws(token)
                .getBody();
    }

    public static String getUserPermission(String token) {
        try {
            return (String) getTokenBody(token).get(TokenEnum.ROLE_CLAIMS.getValue());
        }catch (ExpiredJwtException e){
            return (String) e.getClaims().get(TokenEnum.ROLE_CLAIMS.getValue());
        }

    }

    /**
     * token时间没有超过期时间的两倍，续期，否则重新登录
     *
     * @param token
     * @return
     */
    public static boolean isTwoTimesTokenExpiration(String token) {
       try {
            Claims tokenBody = getTokenBody(token);
            Date expiration = tokenBody.getExpiration();
            return expiration.getTime() + TokenEnum.EXPIRATION.getTime() * 1000 * 2   < System.currentTimeMillis();
        }catch (ExpiredJwtException e){
            long expirationTime = e.getClaims().getExpiration().getTime() + TokenEnum.EXPIRATION.getTime() * 1000 * 2  ;
            return expirationTime < System.currentTimeMillis();
        }
    }
}

在使用工具类的时候有一个小问题
如果token已经过期，我们拿着过期的token去使用工具类解析，会报ExpiredJwtException
但是我的需求就是获取到过期token的过期时间加上配置的过期毫秒数乘以2与当前时间做对比来判断要不要续命。此时尴尬的一笔

不过没得关系，我们try-catch,通过源码发现ExpiredJwtException 中有我们需要的信息

 public static boolean isTwoTimesTokenExpiration(String token) {
       try {
            Claims tokenBody = getTokenBody(token);
            Date expiration = tokenBody.getExpiration();
            return expiration.getTime() + TokenEnum.EXPIRATION.getTime() * 1000 * 2   < System.currentTimeMillis();
        }catch (ExpiredJwtException e){
            long expirationTime = e.getClaims().getExpiration().getTime() + TokenEnum.EXPIRATION.getTime() * 1000 * 2  ;
            return expirationTime < System.currentTimeMillis();
        }
    }

同样在jwt解析过期的token获取用户名，权限的时候也要如此，catch掉ExpiredJwtException

三、JWT类型token自动续期
zcccc_的博客
01-15 842
每次访问接口经过过滤器的时候去判断是否过期、是否需要延期，我们拟定一个“允许过期时间”，跟据过期时间去判断。（如果有好办法欢迎留言，共同学习。2.在 AuthorizeFilter 过滤器判断（拦截token验证的方法）1.在 JwtUtil 类加入新字段。
Token 过期后，如何自动续期？
拥有必珍惜
07-24 2687
JWT（JSON Web Tokens）是一种开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在网络应用环境间安全地传输信息。这些信息通过数字签名的方式进行编码和验证，以确保信息的真实性和完整性。JWT可以在两个实体之间安全地传输信息，通常用于在用户和服务器之间传输认证和会话信息。JWT 的优点无状态：JWT允许服务器无状态地验证用户的身份，因为JWT本身包含了所有必要的验证信息。易于使用：JWT易于在多种语言和平台之间传输，因为它只是一个JSON对象。安全性。
关于JWT Token 自动续期的解决方案
weixin_44742132的博客
09-28 5980
前言在前后端分离的开发模式下，前端用户登录成功后后端服务会给用户颁发一个jwt token。前端(如vue)在接收到jwt token后会将token存储到LocalStorage中。后...
jwt实现永不过期的token，可实现固定token值或者动态token值的方法（自己写的demo代码备忘而已）
最新发布
zy103118的博客
04-16 678
signWith(SignatureAlgorithm.HS256, dynamicSalt.getBytes()) // 使用动态盐值作为密钥。.setSigningKey(SECRET_KEY_BYTES) // 设置用于验证的密钥。.setSigningKey(salt.getBytes()) // 设置用于验证的盐值。
jwt的token自动续约_关于JWTToken自动续期的解决方案
weixin_39811101的博客
12-21 583
Apple iPhone 11 (A2223) 128GB 黑色 移动联通电信4G手机 双卡双待4999元包邮去购买 >前言在前后端分离的开发模式下，前端用户登录成功后后端服务会给用户颁发一个jwt token。前端(如vue)在接收到jwt token后会将token存储到LocalStorage中。后续每次请求都会将此token放在请求头中传递到后端服务，后端服务会有一个过滤器对toke...
JWT生成token及过期处理方案
weixin_34111819的博客
08-01 5986
2019独角兽企业重金招聘Python工程师标准>>> ...
JWT 讲解与 token 过期自动续期解决方案
热门推荐
weixin_43249535的博客
01-09 3万+
JWT 讲解 与 token 过期自动续期解决方案1.什么是token2.什么是JWT3.token过期自动续费方案3.1 token过期3.2 解决方案 1.什么是token Token是服务端生成的一串字符串，以作客户端进行请求的一个令牌，当第一次登录后，服务器生成一个Token便将此Token返回给客户端，以后客户端只需带上这个Token前来请求数据即可，无需再次带上用户名和密码。token其实说的更通俗点可以叫暗号，在一些数据传输之前，要先进行暗号的核对，不同的暗号被授权不同的数据操作。 使用tok
使用JWT实现的登录控制，如何给token自动续期？
m0_54187478的博客
01-24 1615
在使用JWT（JSON Web Tokens）进行身份验证时，自动续期通常是指在当前令牌即将过期时自动发放一个新的令牌。
关于 JWT Token 自动续期的解决（根据其他文献参考写的）
qq_40095187的博客
04-22 1316
关于 JWT Token 自动续期的解决 关于 JWT Token 自动续期的解决方案 在前后端分离的开发模式下，前端用户登录成功后后端服务会给用户颁发一个 jwt token。前端(如 vue)在接收到 jwt token 后会将 token 存储到 LocalStorage 中。 后续每次请求都会将此 token 放在请求头中传递到后端服务，后端服务会有一个过滤器对 token 进行拦截校验，校验 token 是否过期，如果 token 过期则会让前端跳转到登录页面重新登录。 因为 jwt token
springboot整和jwt、shiro、redis实现token自动刷新
08-19
接着，我们需要创建一个JWTToken Realm，实现Shiro的AuthenticationInfo接口，处理JWT的验证。在Realm中，我们可以解析JWT，获取用户信息，并与数据库进行比对，完成身份验证。 对于Redis的使用，我们需要配置一个...
怎么使用jwt，token以及redis进行续期？
ShiYueMemo37329的博客
04-07 895
如果续期，则生成一个新的 JWT，更新 Redis 中的相关信息，并将新的 JWT 返回给客户端。方法接受一个 JWT，并返回一个布尔值，指示该 JWT 是否有效。如果 JWT 有效，则返回。如果 JWT 即将过期，服务器可以发出一个新的 JWT，并更新 Redis 中的对应信息。客户端收到新的 JWT 后，将其替换掉旧的 JWT，并更新本地存储中的 Token。方法用新的 JWT 替换旧的 JWT，并更新本地存储中的 Token。服务器收到请求后，验证 JWT 的签名和有效期等信息，以确认其有效性。
JWT 实现登录认证 + Token 自动续期方案！
m0_73311735的博客
11-06 231
过去这段时间主要负责了项目中的用户管理模块，用户管理模块会涉及到加密及认证流程，加密已经在前面的文章中介绍了，可以阅读用户管理模块：如何保证用户数据安全。今天就来讲讲认证功能的技术选型及实现。技术上没啥难度当然也没啥挑战，但是对一个原先没写过认证功能的菜鸡甜来说也是一种锻炼吧。
每天一小步-JWT Token自动续期
qq_53924122的博客
07-24 1506
实现JWT（JSONWeb Tokens）生成Token的自动续期
JWT下token过期的处理策略
weixin_43993064的博客
05-28 3320
最简单最直接的方式用户再次输入他们的登录凭证，如用户名和密码，得到一个新的token。
浅析JWT中token过期后解析报错ExpiredJwtException的解决及过期之后如何进行后续业务处理
DN金猿的博客
12-10 1361
保存在redis中的 key 是用户名， 但是我需要把 jwt token 转化后从 claims 中取出这个用户名，一开始我直接转化，进行debug的时候发现如果token超时了，jwt 没有返回转化结果， 而是直接抛出了异常，我查看JWT所有的转化方法，发现Jwt所有的转化最终处理都是parse(claimJws)这个方法，而这个方法正是我一开始用的解析方法。原本是调用jwtUtil（jwt的工具类），传入一个token，判断是否过期，然而却莫名其妙得抛异常了，而业务中还需要根据是否过期进行后续逻辑！
如何实现JWT Token的自动续期
m0_54187478的博客
03-23 2743
访问令牌通常有较短的有效期，而刷新令牌有较长的有效期。当访问令牌接近过期时，可以使用刷新令牌来获取一个新的访问令牌，而不需要用户重新登录。
JWT的Token自动续期和主动终止
desky的专栏
03-10 1万+
（1）JWT的续签问题和终止问题 JWT的优势在于无状态，也就是生成的Token中本身有存储信息（payload），所以不需要依赖Redis和DB。JWT本身也有有效期参与签名，问题在于这个有效期不能更改，也很好理解如果参与签名的参数（有效期）发生变化，Token也就不一样了。如果有效期不能改变，即便时间设计的再长，也会有到期的时候，而且Token这种设计初衷也不能有效期很长，导致用户在操作过程中Token到期授权失败，这种情况根本是无法接受的。 另外，JWT的Token签发之后，理论上在到
JWT 实现登录认证 + Token 自动续期方案，这才是正确的使用姿势！
emprere的博客
11-15 3243
因公众号更改推送规则，请点“在看”并加“星标”第一时间获取精彩技术分享点击关注#互联网架构师公众号，领取架构师全套资料 都在这里0、2T架构师学习资料干货分上一篇：SpringBoot 还在用 if 校验参数？那你真的太low了，老司机都是这么玩的大家好，我是互联网架构师！过去这段时间主要负责了项目中的用户管理模块，用户管理模块会涉及到加密及认证流程，加密已经在前面的文章中介绍了。今天就来讲讲认证...
JWT过期处理——单token方案
weixin_44347271的博客
12-04 1万+
前后端分离的项目中采用jwt作为接口的安全机制会遇到jwt过期的问题。 jwt中可以设置过期时间，即使是设置成一个月，但可能用户正上一秒还在使用，下一秒jwt过期被叫去重新登录，这是不能接受的，所以需要有处理jwt过期的机制。 在这个问题上比较常用的做法是采用双token——access token和refresh token来处理，access token用户授权，refresh token用于前者过期后获取新的access token。 这里。 我在这里记录我单token方案的思路。 用户登录时生成t
报错jwt 的token过期时间
03-29
### 如何设置或延长 JWT Token 的过期时间 JWT（JSON Web Token）是一种广泛使用的身份验证机制，但由于其不可变性，一旦签发便无法修改或撤销。因此，处理 JWT 过期问题通常需要引入额外的技术手段。 #### 使用 Refresh Tokens 延长认证生命周期 Refresh Tokens 是一种常见的解决方案，用于在 Access Token 到期后重新获取新的有效令牌。这种方式通过分离短期有效的 Access Token 和长期有效的 Refresh Token 来增强安全性[^1]。Access Token 负责日常的身份验证请求，而 Refresh Token 仅用于安全环境下换取新令牌。 #### Redis 缓存 Token 实现动态管理 另一种方式是利用 Redis 缓存来管理和延长 JWT 的过期时间。Redis 提供高效的键值存储功能，可以通过设定 TTL（Time To Live）属性控制每个 Token 的有效期。每当用户携带合法的 Token 访问服务端时，都可以触发逻辑更新该 Token 对应的 Redis 键的有效期限[^3]。 以下是基于 Redis 动态调整 JWT 生命周期的一个简单实现： ```python import redis from datetime import timedelta, datetime # 初始化 Redis 客户端 r = redis.Redis(host='localhost', port=6379, db=0) def update_token_expiration(token: str): """ 更新指定 Token 在 Redis 中的过期时间 """ key = f'token:{token}' if r.exists(key): # 如果存在，则更新过期时间 new_expiry_time = datetime.now() + timedelta(minutes=30) r.expireat(key, int(new_expiry_time.timestamp())) return True return False def authenticate_and_update(user_id: str, password: str) -> str: """ 验证用户名密码并生成/更新 Token """ if verify_credentials(user_id, password): # 自定义函数验证凭证 token = generate_jwt(user_id) # 自定义函数生成 JWT r.set(f'token:{token}', user_id, ex=timedelta(minutes=30)) return token raise ValueError('Invalid credentials') def check_token_validity(token: str) -> bool: """ 检查 Token 是否仍然有效 """ return r.exists(f'token:{token}') ``` 上述代码展示了如何结合 Redis 存储和操作 Token 数据，并允许每次成功调用 API 后刷新 Token 的存活周期[^4]。 #### 不依赖外部库的手动续约方案 如果不想借助第三方工具或者框架支持自动续期的功能，也可以手动编写类似的续约流程。例如，在 Java 应用程序中，可以在每次接收到客户端发送过来的有效 Token 请求之后立即重建一个新的带有更晚截止日期的新实例返回给前端应用继续使用直到再次接近结束为止[^5]。 总之，无论是采用 refresh tokens 方法还是依靠内存数据库像 Redis 来辅助完成这项工作都各有优劣需视具体场景需求决定最佳实践路径。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值