jwt (json web token) + springboot

最新推荐文章于 2024-06-19 10:23:57 发布
最新推荐文章于 2024-06-19 10:23:57 发布
阅读量813 收藏 1
点赞数
文章标签： json http restful boot jwt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45812181/article/details/120094961
版权

jwt官网 ：https://jwt.io/

jwt 官网介绍

jwt就是一json串，且该串不需要服务器保存，一旦生成 不可撤销、不可删除，在到达设置的过期时间之前一直都有效。
在这里插入图片描述

jwt的作用

一言以蔽之：作为数据安全校验，且该条数据不是完全加密，而是采用的部分加密。
没有加密的部分是用来做传递信息的（如允许被外界识别的用户类型、用户名），加密的那部分才是用来做校验的。
可以把token放在请求头中或者cookie中。
在这里插入图片描述

认证流程

在这里插入图片描述

  1. 首先，前端通过Web表单将用户名和密码发送到后端的接口。这一过程一般是一个HTTPPOST请求。建议的方式是通过SSL加密的传输(https协议)，从而避免敏感信息被嗅探。
  2. 后端核对用戶名和密码成功后，将用戶的id等其他信息作为JWT Payload(负载)，将其与头部分别进行Base64编码拼接后签名，形成一个JWT(Token)。形成的JWT就是一个形同xxx . zzz.xxx的字符串。tokenhead.payload.signature
  3. 后端将JWT字符串作为登录成功的返回结果返回给前端。 前端可以将返回的结果保存在 localStorage或sessionStorage上， 退出登录时前端删除保存的JWT即可。
  4. 前端在每次请求时将JWT放⼊HTTP Header中的Authorization位。 (解决XSS和XSRF问题)
  5. 后端检查是否存在，如存在验证JWT的有效性。
    检查签名是否正确;
    检查Token是否过期
    检查Token的接收方是否是自己(可选)
  6. .验证通过后后端使用JWT中包含的用戶信息进行其他逻辑操作，返回相应结果

优势

  1. 简洁(Compact):可以通过URL，POST参数或者在HTTPheader发送，数据量小，传输速度快
  2. .自包含(Self-contained):负载中包含了所有用戶所需要的信息，避免了多次查询数据库
  3. .因为Token是以JSON加密的形式保存在客戶端的，所以JWT是跨语言的，原则上任何web形式都支持。
  4. 不需要在服务端保存会话信息，特别适用于分布式微服务

jwt的数据结构

在这里插入图片描述

标题 : Header base64编码可以被外界解析出来
有效载荷:Payload  base64编码可以被外界解析出来
签名:Signature  签名算法加密，作为真伪的鉴别工具

token最终是形如 xxx.yyy.xxx 形式的。
所以 token=Header(base64编码).Payload(base64编码).Signature(签名算法加密)

Header 标题

在这里插入图片描述

{
  "alg": "HS256", ：所使用的签名算法，例如HMAC、SHA256或RSA。
  "typ": "JWT" ：类型 固定写法
}

Payload 有效负载

在这里插入图片描述
有效负载示例： 上面的信息都是可以向外界提供的(被解析),甚至实体类都可以写在这里。
它会使⽤Base64 编码组成JWT结构的第⼆部分


{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

signature 签名

在这里插入图片描述
header和payload都是结果Base64编码过的，中间用点.隔开，第三部分就是前两部分合起来做签 名，密钥绝对自己保管好，签名值同样做Base64编码拼接在JWT后面。（签名并编码）

生成的token

在这里插入图片描述
把token解析出来
在这里插入图片描述

生成token

package com.li;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;

@SpringBootTest
class StudyJwtApplicationTests {
    private final String SECRET="我是签名,实际开发时设置复杂点";
    @Test
    void contextLoads() {
    }

    @Test
    public void getToken(){
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND, 30); //设置过期时间
//        System.out.println(instance.getTime().getTime());
//        System.out.println(new Date().getTime());
        HashMap<String, Object> map = new HashMap<>();
        map.put("alg", "HS256");
        map.put("typ", "JWT");
        //header通常由两部分组成：令牌的类型（即JWT）和所使用的签名算法，例如HMAC SHA256或RSA等等。
        String token = JWT.create()
                .withHeader(map)//设置标题,如果为null，则会使用默认值
                .withClaim("username", "我自横刀向天笑")//有效负载 可设置多个
                .withClaim("usertype", "保洁员")
                .withExpiresAt(instance.getTime())//设置过期时间
                .sign(Algorithm.HMAC256(SECRET));//签名加密
        System.out.println(token);


    }
}

验证token

    @Test
    public void verifier(){
        //解密token成一个DecodedJWT对象  ，具体的信息可从该对象中继续获取
        String token ="eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MzA3MjA3MzMsInVzZXJuYW1lIjoi5oiR6Ieq5qiq5YiA5ZCR5aSp56yRIn0.Ch33IR53bmGkaFUJN24oiRykp3xJva4oDwZcEuh1lCo";

        /**
         * 验证token  如果token过期或错误 都会抛出相应的异常，可通过捕获异常来设置返回信息
         */
        DecodedJWT verify = JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
        //继续获取信息 还有很多api
        System.out.println(verify.getClaim("username").asString());
        System.out.println(verify.getClaim("age").asInt());
        System.out.println();
    }

异常类型

 
 	异常处理方法/验证token方法{
        try {
            验证token的方法代码;
            return true;
        } catch (SignatureVerificationException e) {
            e.printStackTrace();
            map.put("msg", "签名不一致");
        } catch (TokenExpiredException e) {
            e.printStackTrace();
            map.put("msg", "令牌过期");
        } catch (AlgorithmMismatchException e) {
            e.printStackTrace();
            map.put("msg", "算法不匹配");
        } catch (InvalidClaimException e) {
            e.printStackTrace();
            map.put("msg", "失效的payload");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "token无效");
        }

        map.put("status", false);

        //响应到前台: 将map转为json
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }

springboot + jwt

pom


        <!-- https://mvnrepository.com/artifact/com.auth0/java-jwt -->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.18.1</version>
        </dependency>

获取token的登录接口并设置成cookie

package com.li.controller;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import java.util.Calendar;
import java.util.HashMap;

/**
 * @author liql
 * @date 2021/9/4
 */
@Controller
public class TestController {
    private final String SECRET="我是签名";
    @GetMapping("/login")
    @ResponseBody
    public String getToken(String uername,String password,HttpServletResponse response){

        //参数校验 数据库校验用户名和密码 略

        //生成token
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND, 30); //默认3天过期
        HashMap<String, Object> map = new HashMap<>();
        map.put("alg", "HS256");
        map.put("typ", "JWT");
        //header通常由两部分组成：令牌的类型（即JWT）和所使用的签名算法，例如HMAC SHA256或RSA等等。
        String token = JWT.create().withHeader(map)
                .withClaim("username", uername)
                .withExpiresAt(instance.getTime())
                .sign(Algorithm.HMAC256(SECRET));

        //设置成cookie
        Cookie cookie = new Cookie("token",token);
        response.addCookie(cookie);

        return "登录成功";
    }
}

需要验证的业务型接口

为了不用每个接口都写验证的代码，所以采用拦截器的方式进行拦截

package com.li.interceptor;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.InvalidClaimException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

/**
 * @author liql
 * @date 2021/9/4
 */
public class JWTInterceptor implements HandlerInterceptor {
    private final String SECRET="我是签名";
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Cookie[] cookies = request.getCookies();
        String token=null;
        for (Cookie cookie : cookies) {
            if ("token".equals(cookie.getName())){
                token=cookie.getValue();
            }
        }

        Map<String, Object> map = new HashMap<>();
        try {
            JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
            return true;
        } catch (SignatureVerificationException e) {
            e.printStackTrace();
            map.put("msg", "签名不一致");
        } catch (TokenExpiredException e) {
            e.printStackTrace();
            map.put("msg", "令牌过期");
        } catch (AlgorithmMismatchException e) {
            e.printStackTrace();
            map.put("msg", "算法不匹配");
        } catch (InvalidClaimException e) {
            e.printStackTrace();
            map.put("msg", "失效的payload");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "token无效");
        }

        map.put("status", false);

        //响应到前台: 将map转为json
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);

        return false;
    }
}

注册拦截器

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("/**")//添加拦截地址 拦截所有
                .excludePathPatterns("/login");//排除掉登录接口
        
    }
}

业务接口

    @GetMapping("/service")
    @ResponseBody
    public String service(){
        return "处理业务成功";
    }
既来之...
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JWT介绍
weixin_44195615的博客
06-01 2351
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519)，该token被设计为紧凑且安全的， 特别适用于分布式站点的单点登录（SSO）场景。 JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息， 以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 JWT官网：https://jwt.io/ 一、JWT的构成 header 头部 payl.
JWTUtils工具
weixin_64443786的博客
07-13 4718
JWT
SpringBoot整合JWT(JSON Web Token)生成token与验证
最新发布
小hui的博客
06-19 2246
JWT（JSON Web Token）是是目前最流行的跨域认证解决方案。它通常被用于对用户进行身份验证和授权。这篇文章是springboot对jwt的整合实例
JWT(Json Web Token)介绍
mijichui2153的博客
04-25 1673
前言：JWT（JSON Web token）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。JWT是REST API中经常使用的一种机制。 JWT是一种由Header、PayLoad和Key计算并组合得到的数字令牌。简单点说就是一个字符串，由三部分组成，分别是：头部(Header)、载荷(PayLoad)、签名(sign)。 一、各部分介绍及使用体验 Header： Header为JSON格式，用于描述关于该JWT的最基本的信息，例如类型以及签名采用的算法.
JWT官网中文简介
weixin_41905047的博客
02-25 794
jwt全称是JSON WEB TOKEN：JSON Web TOKEN（JWT）是一种开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间安全地传输JSON对象信息。此信息可以被验证和信任，因为它是数字签名的。JWT可以使用秘钥（如：使用HMAC算法）或公钥/私钥对（如：使用RSA或ECDSA）进行签名。
jwt超详细配置和教程
欲买桂花同载酒,终不似少年游
07-03 3263
认证方式传统使用session就是前端cookie保存一个sessionid,下次发送请求会自动携带认证流程暴露问题session保存在内存中,用户越多,内存负载越大分布式应用的话限制了负载均衡能力cookie被截获容易收到跨站请求伪造攻击在前后端分离系统中更加痛苦也就是说前后端分离在应用解耦后增加了部署的复杂性。通常用户一次请求就要转发多次。如果用session 每次携带sessionid到服务器，服务器还要查询用户信息。同时如果用户很多。
Vue+Jwt+SpringBoot+Ldap完成登录认证的示例代码
08-27
解决这个问题的方法是使用Jwt（Json Web Token）。Jwt是一个规范，各种语言都有其实现。Jwt的工作流程是：首先，用户输入用户名和密码，认证服务将这些信息判断认证是否成功，如果成功则查询出一些用户的信息...
springboot + jwt + websocket + 拦截
09-02
在IT行业中，Spring Boot、JWT（JSON Web Token）和WebSocket是三个非常重要的技术概念，而“拦截”通常指的是在系统中实现的一种中间件机制，用于处理请求或响应。结合提供的标题和描述，我们可以深入探讨这四个...
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制
10-17
本项目结合了Apache Shiro、JSON Web Token (JWT)、SpringBoot、MySQL数据库以及Redis缓存技术（通过Jedis客户端）来实现这一机制。下面我们将详细探讨这些组件在实现无状态鉴权中的作用。 **Apache Shiro** Apache...
springboot整和jwt、shiro、redis实现token自动刷新
08-19
结合JWT（JSON Web Token）和Shiro，我们可以构建一个高效的身份验证和授权系统，同时利用Redis缓存来提高性能和用户体验。下面将详细介绍如何在Spring Boot中整合JWT、Shiro和Redis实现Token自动刷新。 JWT是一种...
IDEA+Springboot+Mybatis+MySql+Swagger3.0+JWT权限验证 的实现 增、删、改、查
09-03
6. JWT（JSON Web Tokens）：JWT是一种安全的身份验证和授权机制，通过在客户端和服务器之间传递加密的Token来实现无状态认证。在Spring Boot项目中，JWT可以用来验证用户身份，控制访问权限，确保API的安全性。每个...
JWT简介
Lyndon的专栏
09-21 238
JWT简介
一起重新全面认识JWT-Json Web Token
谙忆-陈浩翔
02-20 1344
一起重新全面认识JWT-Json Web Token 文章目录概述应用场景JWT认证过程JWT的数据结构headerpayloadsignatureJWT的用法JWT的优缺点最后 概述 最近学习了一下JWT，全名为Json Web Token，是一种自包含令牌。 在这里，我整理了一下网上资源。在文章最后，有一个使用Java实现JWT生成和验证的完整案例。 简单的说，就是基于JSON，在web环境下传输一个规定格式的字符串令牌。 广义上讲JWT，这是一个Web安全传输信息方式。狭义上来说，直接指传递的令牌字符
JWT详解
A_finder的博客
12-08 461
1、JWT介绍 定义：JSON Web Token（缩写 JWT）是目前最流行的跨域认证解决方案 JWT官网：https://jwt.io/ 由于HTTP协议是无状态的，如果想判定一个接口是否被认证后访问，就需要借助cookie或者session会话机制进行判定，但是由于现在的系统架构不止一台服务器，此时要借助数据库或者全局缓存做存储，这种方案受限太多。 JWT提供提供了一种更好的方案，由令牌发布...
jwt教程学习
QQwli的博客
05-26 678
JWT 1、什么是JWT 官网：https://jwt.io/ 学习资料：https://baobao555.tech/archives/40 JSON Web Token(JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑且自包含的方式，用于作为JSON对象在各方之间安全地传输信息。可以验证和信任该信息，因为它是数字签名的。jwt可以使用一个秘密(使用HMAC算法)或使用RSA或ECDSA的公钥/私钥对进行签名。 简单来说，就是通过JSON形式作为Web应用中的令牌，用于在各方面之间安全的将
JWT（json web token）
努力学习，努力爱你！
07-22 1138
JWT，全称是JsonWebToken，是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；https//jwt.iohttps我们最终可以利用jwt实现无状态登录在Web应用中，别再把JWT当做session使用，绝大多数情况下，传统的cookie-session机制工作得更好。...
JWT令牌基础教程 全方位带你剖析JWT令牌，在Springboot中使用JWT技术体系，完成拦截器的实现 Interceptor （后附源码）
dream_ready的博客
10-18 382
此处只是定义，若想定义的拦截器发挥功能，需注册拦截器定义一个类，实现接口，并重写对应方法一般来说preHandle是必须要重写的，因为它在请求到达目标资源方法前期执行，是拦截器的核心在preHandle中进行JWT令牌的校验，并根据校验结果选择放行或拦截/*** 校验jwt* @return*/// 该方法在请求处理方法之前被自动调用System.out.println("当前线程的id：" + Thread.currentThread().getId());
JWT令牌以及登录拦截
m0_61591135的博客
01-21 1177
JWT令牌以及登录拦截
shiro+springboot+jwt项目
05-23
Shiro是一个Java安全框架，可以提供身份验证、授权、加密和会话管理等功能，Spring Boot是一个快速开发框架，可以帮助开发人员更快地构建和部署应用程序，JWT（JSON Web Token）是一种轻量级的身份验证和授权机制。将这三个框架结合起来，可以构建一个安全的Web应用程序。 以下是一个简单的Shiro+Spring Boot+JWT项目的实现步骤： 1.创建一个Spring Boot项目，并添加Shiro和JWT依赖项： ``` <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.7.1</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.10.7</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>0.10.7</version> <scope>runtime</scope> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>0.10.7</version> <scope>runtime</scope> </dependency> ``` 2.创建一个Shiro配置类，配置Shiro的安全策略和过滤器链： ``` @Configuration public class ShiroConfig { @Bean public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) { ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean(); shiroFilterFactoryBean.setSecurityManager(securityManager); shiroFilterFactoryBean.setLoginUrl("/login"); shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized"); Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>(); filterChainDefinitionMap.put("/login", "anon"); filterChainDefinitionMap.put("/**", "jwt"); shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap); return shiroFilterFactoryBean; } @Bean public DefaultWebSecurityManager securityManager(Realm realm) { DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(); securityManager.setRealm(realm); return securityManager; } @Bean public Realm realm() { return new UserRealm(); } @Bean public JwtFilter jwtFilter() { return new JwtFilter(); } } ``` 3.创建一个自定义Realm类，实现Shiro的认证和授权逻辑： ``` public class UserRealm extends AuthorizingRealm { @Autowired private UserService userService; @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo(); User user = (User) principals.getPrimaryPrincipal(); authorizationInfo.addRole(user.getRole()); return authorizationInfo; } @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { String username = (String) token.getPrincipal(); User user = userService.findByUsername(username); if (user == null) { throw new UnknownAccountException(); } return new SimpleAuthenticationInfo(user, user.getPassword(), getName()); } } ``` 4.创建一个JwtFilter类，实现JWT的认证逻辑： ``` public class JwtFilter extends AuthenticatingFilter { @Autowired private UserService userService; @Override protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception { HttpServletRequest httpServletRequest = (HttpServletRequest) request; String token = httpServletRequest.getHeader("Authorization"); if (StringUtils.isEmpty(token)) { throw new UnauthorizedException(); } JwtToken jwtToken = new JwtToken(token); try { getSubject(request, response).login(jwtToken); } catch (AuthenticationException e) { throw new UnauthorizedException(); } return true; } @Override protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) { return false; } } ``` 5.创建一个JwtToken类，实现JWT的Token逻辑： ``` public class JwtToken implements AuthenticationToken { private String token; public JwtToken(String token) { this.token = token; } @Override public Object getPrincipal() { return JwtUtils.getSubject(token); } @Override public Object getCredentials() { return token; } } ``` 6.创建一个UserController类，实现用户登录和获取用户信息的逻辑： ``` @RestController public class UserController { @Autowired private UserService userService; @PostMapping("/login") public Result login(@RequestBody User user) { String token = userService.login(user); return Result.success(token); } @GetMapping("/user") public Result getUserInfo() { User user = (User) SecurityUtils.getSubject().getPrincipal(); return Result.success(user); } } ``` 7.创建一个UserService类，实现用户登录和生成JWT Token的逻辑： ``` @Service public class UserService { @Autowired private UserMapper userMapper; public User findByUsername(String username) { return userMapper.findByUsername(username); } public String login(User user) { User realUser = findByUsername(user.getUsername()); if (realUser == null || !realUser.getPassword().equals(user.getPassword())) { throw new UnauthorizedException(); } return JwtUtils.generateToken(realUser.getId(), realUser.getUsername(), realUser.getRole()); } } ``` 8.创建一个JwtUtils类，实现JWT的Token生成和解析逻辑： ``` public class JwtUtils { private static final String SECRET = "secret"; private static final long EXPIRATION_TIME = 86400000; // 24 hours public static String generateToken(String id, String username, String role) { Date now = new Date(); Date expirationDate = new Date(now.getTime() + EXPIRATION_TIME); return Jwts.builder() .setId(id) .setSubject(username) .claim("role", role) .setIssuedAt(now) .setExpiration(expirationDate) .signWith(SignatureAlgorithm.HS512, SECRET) .compact(); } public static String getSubject(String token) { return Jwts.parser() .setSigningKey(SECRET) .parseClaimsJws(token) .getBody() .getSubject(); } } ``` 这样，就可以使用Shiro+Spring Boot+JWT构建一个安全的Web应用程序了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值