前后端分离 JWT令牌

已于 2023-09-27 15:59:42 修改
阅读量37 收藏
点赞数
文章标签： java
于 2023-09-08 16:05:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hello19960721/article/details/132759837
版权

pom依赖

        <!--  JWT  -->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.18.3</version>
        </dependency>
        <!--SpringBoot Security-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

JWT工具类

package com.auo.Utils;


import com.auo.Pojo.UacUser;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import lombok.extern.slf4j.Slf4j;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;


/**
 * @Program: configplus
 * @Description: Token 工具类
 * @Author: YangHuHC
 * @Create: 2023/7/27 9:50
 */
@Slf4j
public class TokenUtils {

    private final static String tokenHeader = "Authorization";


    /**
     * 过期时间2个小时，
     * TODO 正式运行时修改为15分钟
     */
    private static final long EXPIRE_TIME = 2 * 60 * 60 * 1000;
    /**
     * token私钥
     */
    private static final String TOKEN_SECRET = "auo";

    /**
     * 校验 token是否正确
     *
     * @param token  密钥
     * @return 是否正确
     */
    public static boolean verify(String token, String username,String dept,String userId) throws Exception {
        try {
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
            JWTVerifier verifier = JWT.require(algorithm)
                    .withClaim("username", username)
                    .withClaim("dept", dept)
                    .withClaim("userId", userId)
                    .build();
            verifier.verify(token);
            log.info("token is valid");
            return true;
        } catch (TokenExpiredException e) {
            throw new TokenExpiredException("登录过期，请重新登录");
        } catch (Exception e) {
            log.info("token is invalid {}", e.getMessage());
            throw new Exception(e.getMessage());
        }
    }
    /**
     * 获得token中的信息无需secret解密也能获得
     *
     * @return token中包含的用户登录信息
     */
    public static UacUser getUacUser(String token) {
        try {
            UacUser uacUser = new UacUser();
            DecodedJWT jwt = JWT.decode(token);
            uacUser.setDeptNo(jwt.getClaim("dept").asString());
            uacUser.setName(jwt.getClaim("username").asString());
            uacUser.setId(jwt.getClaim("userId").asString());

            return uacUser;
        } catch (JWTDecodeException e) {
            log.error("error：{}", e.getMessage());
            throw new JWTDecodeException(e.getMessage());
        }
    }


    /**
     * 获得token中的信息无需secret解密也能获得
     *
     * @return token中包含的用户登录信息
     */
    public static String getUsername(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            log.error("error：{}", e.getMessage());
            throw new JWTDecodeException(e.getMessage());
        }
    }
    /**
     * 获得token中的信息无需secret解密也能获得
     *
     * @return token中包含的用户登录信息
     */
    public static String getUserId(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("userId").asString();
        } catch (JWTDecodeException e) {
            log.error("error：{}", e.getMessage());
            throw new JWTDecodeException(e.getMessage());
        }
    }
    /**
     * 获得token中的信息无需secret解密也能获得
     *
     * @return token中包含的用户登录信息
     */
    public static String getUserDept(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("dept").asString();
        } catch (JWTDecodeException e) {
            log.error("error：{}", e.getMessage());
            throw new JWTDecodeException(e.getMessage());
        }
    }

    /**
     * 生成签名,15min后过期
     *
     * @param username 用户名
     * @return 加密的token
     */
    public static String sign(String username,String dept,String userId) throws Exception {

        try {
            username = username.toLowerCase();
            Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
            return JWT.create()
                    .withClaim("username", username)
                    .withClaim("dept", dept)
                    .withClaim("userId", userId)
                    .withExpiresAt(date)
                    .sign(algorithm);

        } catch (Exception e) {
            log.error("error：", e);
            throw new Exception(e.getMessage());
        }

    }
    /**
     * 获取请求token
     *
     * @param request
     * @return token
     */
    public static String getToken(HttpServletRequest request) {
        String requestHeader = request.getHeader(tokenHeader);
        String token = "";
        if (requestHeader != null && requestHeader.startsWith("Bearer ")) {
            token = requestHeader.substring(7);
        }
        return token;
    }
}

请求拦截类

package com.auo.config;

import com.auo.Pojo.UacUser;
import com.auo.Utils.TokenUtils;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
/**
 * 该类为接受authKey的类，若访问时带上UAC的authKey会自动登陆并跳转至首页
 * 若该系统挂在一个使用uac验证的系统时，只要在请求时带上authKey就不需要二次登陆
 * zhi.li 2021.04.16
 */

@Component
public class AuthKeyFilter extends OncePerRequestFilter {

    private final Logger LOGGER = LoggerFactory.getLogger(AuthKeyFilter.class);

    //前台的首页地址
    @Value("${index-url}")
    private String indexUrl;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取Authentication对象
        //Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        //获取token令牌
        String token = TokenUtils.getToken(request);
        if (!StringUtils.isEmpty(token)) {
            boolean tokenPass = false;
            try {
                UacUser uacUser = TokenUtils.getUacUser(token);
                //校验令牌
                if (TokenUtils.verify(token,uacUser.getName(),uacUser.getDeptNo(),uacUser.getId())){
                    List<GrantedAuthority> authorities = new ArrayList<>();
                    authorities.add(new SimpleGrantedAuthority("user"));
                    UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(uacUser.getId(), uacUser, authorities);
                    SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
                    tokenPass = true;
                }
            } catch (TokenExpiredException e) {
                response.setStatus(HttpStatus.BAD_REQUEST.value());
                response.setCharacterEncoding(StandardCharsets.UTF_8.name());
                response.getWriter().write("token expire");
            } catch (SignatureVerificationException e) {
                response.setStatus(HttpStatus.BAD_REQUEST.value());
                response.setCharacterEncoding(StandardCharsets.UTF_8.name());
                response.getWriter().write("sign invalid");
            } catch (Exception e) {
                LOGGER.error("AuthKeyFilter  doFilterInternal Exception  {}",e.toString());
                response.setStatus(HttpStatus.BAD_REQUEST.value());
                response.setCharacterEncoding(StandardCharsets.UTF_8.name());
                response.getWriter().write("token error");
            }
            if (!tokenPass) {
                return;
            }
        }
        filterChain.doFilter(request, response);
    }
}

spring security核心配置类 配置过滤器

package com.auo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final UserDetailsService userDetailsService;

    private final AuthKeyFilter authKeyFilter;

    public SecurityConfig(UserDetailsService userDetailsService, AuthKeyFilter authKeyFilter) {
        this.userDetailsService = userDetailsService;
        this.authKeyFilter = authKeyFilter;
    }

    @Override
    public UserDetailsService userDetailsService() {
        return userDetailsService;
    }

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity
                .csrf().disable().cors().and().addFilterBefore(authKeyFilter, UsernamePasswordAuthenticationFilter.class)
                .authorizeRequests()
                .antMatchers("/login/info").authenticated()
                .antMatchers("/login/**").permitAll()
                .antMatchers("/api/**").permitAll();
                
    }
        //禁用session
        httpSecurity.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
}

判断是否登录 tempPage为主页面 /index 跳转主页面

    @GetMapping("/oneData/checkLoginStatus")
    public void checkLoginStatus(HttpServletRequest request, HttpServletResponse response) throws IOException {
        LOGGER.info("PostMapping /login/checkLoginStatus start");
        try {
            String authkey = request.getParameter("authkey");
            if (StringUtil.isNotEmpty(authkey)) {
                UacClientBean uacClientBean = new UacClientBean();
                uacClientBean.initial();
                auo.cim.uac.cli.bean.UacAuthority authority = uacClientBean.getFunctions("US", authkey);
                if (!authority.isPass()){
                    throw new Exception("login error");
                }
                LOGGER.info("authority : {},{},{}",authority.getUserName(),authority.getInputAccount(),authority.getDeptNo());
                UacUser uacUser = new UacUser();
                uacUser.setName(authority.getUserName());
                uacUser.setId(authority.getInputAccount());
                uacUser.setDeptNo(authority.getDeptNo());
                List<GrantedAuthority> authorities = new ArrayList<>();
                authorities.add(new SimpleGrantedAuthority("user"));
                Authentication token = new UsernamePasswordAuthenticationToken(authority.getInputAccount(), uacUser, authorities);
                SecurityContextHolder.getContext().setAuthentication(token);
                //创建令牌
                String jwt = TokenUtils.sign(uacUser.getName(), uacUser.getDeptNo(),uacUser.getId());
                LOGGER.info("jwt: {}",jwt);
                String queryString = request.getQueryString();
                String[] queryArr = queryString.split("&");
                StringBuilder urlBuild = new StringBuilder();
                for (String query : queryArr) {
                    if (!query.contains("tempPage")) {
                        urlBuild.append("&").append(URLEncoder.encode(query, "UTF-8"));
                    }
                }
                urlBuild.append("&token=").append(jwt);
                urlBuild.deleteCharAt(0);
                response.sendRedirect( indexUrl + "?" + urlBuild.toString());
                LOGGER.info("/login/checkLoginStatus sendRedirect success, token:{}",urlBuild.toString());
            }
        } catch (Exception e) {
            LOGGER.error("", e);
            //ExceptionHandler(request, response, tempPage, session);
        }
    }

前端请求拦截

main.js
import Vue from 'vue'
import App from './App.vue'
import router from './router'
import * as echarts from 'echarts'
import './errorSolve'
import ElementUI from 'element-ui';
import 'babel-polyfill'
import 'element-ui/lib/theme-chalk/index.css';
import 'element-ui/lib/theme-chalk/base.css';
import "./assets/css/common.css";

// 引入 axios
import axios from 'axios'
//import echarts from 'echarts'

Vue.prototype.$echarts = echarts

Vue.directive('loadmore', {
  bind(el, binding) {
    const selectWrap = el.querySelector('.el-table__body-wrapper')
    selectWrap.addEventListener('scroll', function () {
      let sign = 3
      const scrollDistance = this.scrollHeight - this.scrollTop - this.clientHeight
      if (Math.ceil(scrollDistance) <= sign) {
        binding.value()
      }
    })
  },
})

// 挂载一个自定义属性$http
Vue.prototype.$axios = axios
// 全局配置axios请求根路径(axios.默认配置.请求根路径)
axios.defaults.headers.post['Content-Type'] = 'multipart/form-data';
axios.defaults.baseURL = window.g.ServerUrl 

const service = axios.create({
  baseURL: window.g.ServerUrl , // api的base_url
  timeout: 3000000, // 请求超时时间
  withCredentials: true
})

//请求接口携带jwt令牌
service.interceptors.request.use( 
  config => {  
      if (localStorage.getItem('token')) {  
         console.log("找到token")
            config.headers.Authorization = `Bearer ` + localStorage.getItem('token') ;
              }
              else{
                console.log("没有找到token")
                config.headers.Authorization = "" ;  
              }      
            return config;  
        },error => {    
            return Promise.reject(error) ;
  });

//响应接口异常 调用登录接口
service.interceptors.response.use(
  response => {

    console.log(response);

      return response;
  }, error => {
      if (error.response) {
          //let message = JSON.stringify(error.response.data);
          let encodeTempPage =encodeURIComponent(`${window.location.origin}/oneData/#/index`);
          
          // let encodeTempPage =encodeURIComponent(`${window.location.origin}/onedatatest/#/index`);
          let targetAddress = `${axios.defaults.baseURL}/login/uacLogin?tempPage=${encodeTempPage}`;
          let redirectPage = encodeURIComponent(window.location.href);
           targetAddress=targetAddress+`&redirectPage=${redirectPage}`;
            console.log(`targetAddress `,targetAddress);
          switch (error.response.status) {
              case 403:
                window.location.href = targetAddress;
                  break;
              case 500:
                //this.$message.error("系统异常")
                  break;
              case 400:
                console.log("token expired")
                //this.$message.error("token expired")
                window.location.href = targetAddress;
                  break;
              default:
                this.$message.error("错误状态不是403,400,500");
          }
          return error.response;
      }
  }
)
Vue.prototype.$axios = service

Vue.use(ElementUI);
Vue.config.productionTip = false

new Vue({
  router,
  render: h => h(App)
}).$mount('#app')

处理返回值 将token放入本地内存

    handleToken(){
          console.log("212123123")
          const NEW_TOKEN = this.$route.query.token;
          console.log(`token `,NEW_TOKEN)
          let NEW_ADDRESS = window.location.href;
          if(NEW_TOKEN){
            localStorage.setItem("token", NEW_TOKEN);
          if (NEW_ADDRESS.indexOf('redirectPage') !== -1) {

            let handleAddress = decodeURIComponent(NEW_ADDRESS);
            let splice1 = handleAddress.split('redirectPage=')[1];
            let splice2 = splice1.split('&')[0];
            let result = splice2;
            localStorage.setItem("token", NEW_TOKEN);
            setTimeout(() => {  
              //  window.location.href = decodeURIComponent(result);
              //  this.$router.push({ path: '/index' })
            }, 200);
          } else {

            setTimeout(() => {
              localStorage.setItem("token", NEW_TOKEN);
              this.$router.push({ path: '/index' })
            }, 200);
          }
      }
    }
hello19960721
关注
spring security Jwt令牌 （前后端分离）
l1306395862的博客
09-10 661
详细流程和想了解源码 请跳转,大神写的很详细 (https://blog.csdn.net/yuanlaijike/article/details/80249235) 需要的依赖包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency&gt
SpringBoot+Shiro+JWT+Jedis+MybatisPlus+前后端分离+基于url通用权限管理系统
01-25
在这里，Jedis被用来配合Shiro存储和验证JWT令牌，提高系统的响应速度和效率。通过将令牌存储在Redis中，可以实现分布式环境下的会话共享，增强了系统的扩展性。 MybatisPlus是在Mybatis基础上的扩展，它简化了...
jwt身份令牌数据处理 前后端分离式开发
Bugxiu_fu的博客
10-15 2233
jwt入门 jwt的理解 和基本使用控制用户登陆后台与前台分离部分实例
前后端分离，简单JWT登录实现
幻雨的博客
04-27 896
JWT登录 文章目录JWT登录JWT登录流程1. 用户认证处理2. 前端登录3. 前端请求处理4. 后端请求处理5. 前端页面跳转处理6. 退出登录7. 本文关联代码7.1 前端7.2 后端 JWT登录流程 前端vue+axios+router 后端springboot+mybatisplus 1. 用户认证处理 @Service @Transactional public class AdminServiceImpl implements AdminService { @Autowired
SpringBoot项目——jwt 登录验证与编写前后端分离API
敲代码的小李同学的博客
08-06 1732
SpringBoot项目中，编写后端API，前端调用API，实现前后端分离方式 jwt 注册登录验证。
前后端分离之JWT用户认证
weixin_43372749的博客
03-01 615
在前后端分离开发时为什么需要用户认证呢？原因是由于HTTP协定是不储存状态的(stateless)，这意味着当我们透过帐号密码验证一个使用者时，当下一个request请求时它就把刚刚的资料忘了。于是我们的程序就不知道谁是谁，就要再验证一次。所以为了保证系统安全，我们就需要验证用户否处于登录状态。 传统方式 前后端分离通过Restful API进行数据交互时，如何验证用户的登录信息及权限。在原来的项目中，使用的是最传统也是最简单的方式，前端登录，后端根据用户信息生成一个token，并保存这个 token
前后端分离式开发 jwt的使用
qq_62898618的博客
10-05 1683
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。JSON Web Token（JWT）是目前最流行的跨域身份验证解决方案。
前后端分离开发—JWT令牌生成器
qq_50804645的博客
11-27 761
如果按照上一篇文章的规则生成token： 按照 Base64 加密和解密 存在问题： 简易的token生成规则安全性较差，如果要生成安全性很高的token，要对加密算法有一定的要求。 时效性较差，因为token一直存在cookie中，要有登录过期的校验； 所以使用JWT算法来实现 一 .什么是JWT？ JWT : JSON Web Token 是一个专门用于生成令牌的一种算法，是一种规则。 官网：https://jwt.io JWT 生成token的结构：三种颜色，三部分组成， 分别是头信息、包含
使用JWT的SpringSecurity实现前后端分离
qq_59099003的博客
07-30 1042
JWT，前后端分离，SpringSecurity
全网最详细教程:前后端分离项目JWT解决方案
qq_14853853的博客
12-30 2011
目录前言：1.JWT介绍1.1什么是JWT1.2结构解析headerpayloadSignature1.3小结2.环境搭建2.1引入依赖2.2工具类2.3后端主要代码讲解2.4前端主要代码3.总结 前言： 本文主要讲解谷歌浏览器80版本session不一致问题的解决方案二，方案一大家可以看看这篇文章，是基于session的方式传送门。 提示：这里简述项目相关背景： 例如：项目场景：示例:通过蓝牙芯片(HC-05)与手机 APP 通信，每隔 5s 传输一批传感器数据(不是很大) 1.JWT介绍 1.1什么是
SpringSecurity+JWT前后端分离架构登录认证！
01-20
在构建现代化的Web应用时，前后端分离架构已经成为标准实践，它允许前端和后端以独立的方式进行开发和部署。Spring Security 和 JSON Web Token (JWT) 是实现这种架构中的关键组件，特别是在用户身份验证和授权方面...
SpringBoot2.2.6 整合Jwt实现前后端分离
04-23
本篇文章将详细讲解如何在SpringBoot 2.2.6版本中整合MyBatis 3.5.4，并利用JWT技术实现前后端分离。 首先，我们需要了解SpringBoot 2.2.6的核心特性。这一版本提供了许多改进，包括更好的错误处理、自动配置优化...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 664
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 612
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 466
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 704
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 298
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1093
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
springboot jwt token前后端分离_前后端分离之JWT用户认证
05-20
在前后端分离的项目中，使用 JWT 进行用户认证可以方便地处理用户登录和权限控制。 以下是使用 Spring Boot 和 JWT 实现前后端分离的用户认证示例： 1. 添加依赖 在 pom.xml 中添加以下依赖： ```xml <!-- JWT -...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值