java login jwt token filter

最新推荐文章于 2023-05-09 17:39:10 发布
最新推荐文章于 2023-05-09 17:39:10 发布
阅读量286 收藏
点赞数
分类专栏： JavaWeb 文章标签： java servlet 开发语言
人生的道路虽然漫长，但紧要处常常只有几步
本文链接：https://blog.csdn.net/qq_30512275/article/details/128520502
版权

filter

package com.cwl.userdata.filter;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.cwl.userdata.content.Constants;
import com.cwl.userdata.util.JwtTokenUtil;
import io.jsonwebtoken.Claims;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.security.auth.Subject;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;
import java.util.Map;

/**
 * @author LJQ E-mail:lijinquan@ishumei.com
 * @version 1.0
 * @date 创建时间：2018/11/12 16:36
 */
@Component
@Order(0)//指定过滤器的顺序 值越小越靠前
@WebFilter(urlPatterns = "/api/**", filterName = "tokenFilter")
public class TokenFilter extends OncePerRequestFilter {

    private final Logger logger = LoggerFactory.getLogger(TokenFilter.class);


    private final String[] noFilters = {"/api/excel", "/webdashboard/index", "doc", "/api/login","/csv/getToken",
            "/webjars/bycdao-ui/", "/swagger", "/json", ".js", ".css", ".ico", ".jpg", ".png",
            ".html", "/api/csv/download", "/api/csv/v2/download"};

    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
        String uri = httpServletRequest.getRequestURI();
        System.out.println(uri);
        for (String s : noFilters) {
            if (uri.contains(s)) {
                //uri中包含不过滤uri，则不进行过滤
                logger.info(">>>>>>>>>>>>>>>>>>>>>>>>放行url：" + uri);
                filterChain.doFilter(httpServletRequest, httpServletResponse);
                return;
            }
        }

        //获得头信息token
        String token = httpServletRequest.getHeader(Constants.JWT_HEADER);
        //如果token不为空且以特定的TOKEN_HEADER开头
        JwtTokenUtil jwtTokenUtil = new JwtTokenUtil();
        if (token != null && (!"".equals(token)) && token.startsWith(Constants.JWT_TOKEN_HEADER)) {
            //对请求进行路由
            String jwt = "";
            try {
                jwt = token.substring(Constants.JWT_TOKEN_HEADER.length());
            } catch (Exception e) {
                //不对其进行路由
                httpServletResponse.setStatus(200);
                httpServletResponse.setContentType("application/json;charset=UTF-8");
                httpServletResponse.getWriter().write("{\"code\":400,\"msg\":\"请重新登录！\",\"data\":null}");
                return;
            }

            if ("".equals(jwt)) {
                //不对其进行路由
                httpServletResponse.setStatus(200);
                httpServletResponse.setContentType("application/json;charset=UTF-8");
                httpServletResponse.getWriter().write("{\"code\":400,\"msg\":\"请重新登录！\",\"data\":null}");
                return;
            }
            Claims claims = jwtTokenUtil.parseJWT(jwt);
            //验证token是否过期
            if (claims.getExpiration().before(new Date())) {
                this.logger.info("TokenFilter：token已过期");
                httpServletResponse.setStatus(200);
                httpServletResponse.setContentType("application/json;charset=UTF-8");
                httpServletResponse.setContentType("{\"code\":300,\"msg\":\"请重新登录！\",\"data\":null}");
                return;
            }
            //验证token拥有者是否有效
            if (!claims.getIssuer().equals(Constants.JWT_ISSUSER)) {
                this.logger.info("TokenFilter：token发行者无效");
                httpServletResponse.setStatus(200);
                httpServletResponse.setContentType("application/json;charset=UTF-8");
                httpServletResponse.getWriter().write("{\"code\":300,\"msg\":\"请重新登录！\",\"data\":null}");
                return;
            }
            String subject = claims.getSubject();
            Map maps = (Map) JSON.parse(subject);
            httpServletRequest.setAttribute("user", maps.get("user"));
            httpServletRequest.setAttribute("provinceCode", maps.get("provinceId"));
            filterChain.doFilter(httpServletRequest, httpServletResponse);
        } else {
            //不对其进行路由
            httpServletResponse.setStatus(200);
            httpServletResponse.setContentType("application/json;charset=UTF-8");
            httpServletResponse.getWriter().write("{\"code\":400,\"msg\":\"请重新登录！\",\"data\":null}");
        }

    }
}

login

package com.cwl.userdata.controller;

import com.cwl.userdata.aspect.OperatorType;
import com.cwl.userdata.aspect.OperatorLog;
import com.cwl.userdata.aspect.TabType;
import com.cwl.userdata.content.Constants;
import com.cwl.userdata.entity.Account;
import com.cwl.userdata.service.AccountService;
import com.cwl.userdata.service.ProvinceService;
import com.cwl.userdata.util.JwtTokenUtil;
import com.cwl.userdata.vo.ResponseBean;
import com.cwl.userdata.vo.login.LoginVo;
import com.cwl.userdata.vo.login.UpdateUserVo;
import com.cwl.userdata.vo.login.UserVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * @author ljq
 * @date 2020-01-11 11:50
 * @describe
 */
@RestController
@RequestMapping("/api")
@Api(tags = "登录接口")
public class LoginController {
    @Resource
    private AccountService accountService;
    @Resource
    private ProvinceService provinceService;

    @PostMapping("/login")
    @ApiOperation(value = "登录接口")
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "success", response = UserVo.class),
            @ApiResponse(code = 501, message = "用户名或密码错误!"),
            @ApiResponse(code = 502, message = "验证码输入错误!"),
            @ApiResponse(code = 503, message = "未知错误!")
    })
    @OperatorLog(value = OperatorType.LOGIN, operatorModel = TabType.LOGIN)
    public ResponseBean login(@RequestBody LoginVo loginVo,
                              HttpServletRequest request) {
        String userAccount = loginVo.getUsername();
        String validCode = loginVo.getValidCode();
        try {
            HttpSession session = request.getSession(true);
            //检查验证码
            String sessionValidCode = (String) session.getAttribute(Constants.RAND_VALID_CODE);
            if (!StringUtils.isEmpty(validCode) && validCode.equalsIgnoreCase(sessionValidCode)) {
                Account a = new Account();
                a.setPassword(loginVo.getPassword());
                a.setUsername(loginVo.getUsername());
                Account account = accountService.login(a);
                if (null != account) {
                    //生成token
                    JwtTokenUtil jwtTokenUtil = new JwtTokenUtil();
                    String subject = JwtTokenUtil.generalSubject(account.getUsername(), account.getProvinceId());
                    String token = jwtTokenUtil.createJWT(userAccount, subject, Constants.JWT_TTL);
                    //将token返回
                    UserVo userVo = new UserVo();
                    userVo.setAccount(account);
                    userVo.setToken(token);
                    userVo.setProvinces(provinceService.getProvinces(account.getProvinceId()));
                    return ResponseBean.builder().code(200).data(userVo).msg("OK").build();
                }
                return ResponseBean.builder().code(501).data(false).msg("用户名或密码错误").build();
            } else {
                return ResponseBean.builder().code(502).msg("验证码输入错误!").data(false).build();
            }
        } catch (Exception e) {
            return ResponseBean.builder().code(503).msg("未知错误!").build();
        }
    }

    @PostMapping("/csv/getToken")
    @OperatorLog(value = OperatorType.LOGIN, operatorModel = TabType.LOGIN)
    public ResponseBean getToken(@RequestBody LoginVo loginVo,HttpServletRequest request) {
        String userAccount = loginVo.getUsername();
        try {
            Account a = new Account();
            a.setPassword(loginVo.getPassword());
            a.setUsername(loginVo.getUsername());
            Account account = accountService.login(a);
            if (null != account) {
                //生成token
                JwtTokenUtil jwtTokenUtil = new JwtTokenUtil();
                String subject = JwtTokenUtil.generalSubject(account.getUsername(), account.getProvinceId());
                String token = jwtTokenUtil.createJWT(userAccount, subject, Constants.JWT_TTL);
                //将token返回
                Map<String, String> map = new HashMap<>(1);
                map.put("token", token);
                return ResponseBean.builder().code(200).data(map).msg("OK").build();
            }
            return ResponseBean.builder().code(501).data(false).msg("用户名或密码错误").build();
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseBean.builder().code(503).msg("未知错误!").build();
        }

    }


    @GetMapping("/login/validcode")
    @ApiOperation(value = "获取验证码")
    public ResponseBean validcode(HttpServletRequest request) {

        Random random = new Random();
        StringBuilder sRand = new StringBuilder();
        for (int i = 0; i < 4; i++) {
            String rand = String.valueOf(random.nextInt(10));
            sRand.append(rand);
        }
        // 将认证码存入SESSION
        request.getSession().setAttribute(Constants.RAND_VALID_CODE, sRand.toString());
        return ResponseBean.builder().code(200).msg("OK").data(sRand.toString()).build();
    }

    private Account getAccount(UpdateUserVo updateUserVo) {
        Account account = new Account();
        account.setUsername(updateUserVo.getUsername());
        account.setPassword(updateUserVo.getOldPassword());
        return account;
    }

    @ApiOperation(value = "验证旧密码正确")
    @PostMapping("/login/password")
    public ResponseBean getAccountByPassword(@RequestBody UpdateUserVo updateUserVo) {
        Account account = getAccount(updateUserVo);
        Account a = accountService.login(account);
        if (a == null) {
            return ResponseBean.builder().code(200).data(false).msg("旧密码错误").build();
        }
        return ResponseBean.builder().code(200).data(true).msg("旧密码正确").build();
    }

    @ApiOperation(value = "修改密码")
    @PostMapping("/login/password/update")
    @OperatorLog(value = OperatorType.UPDATE_PASSWORD, operatorModel = TabType.UPDATE_PASSWORD)
    public ResponseBean updatePassword(@RequestBody UpdateUserVo updateUserVo, HttpServletRequest request) {
        if (!updateUserVo.getNewPassword().equals(updateUserVo.getReNewPassword())) {
            return ResponseBean.builder().code(503).msg("重复输入密码不一致").build();
        }
        Account account = getAccount(updateUserVo);
        Account a = accountService.login(account);
        if (a == null) {
            return ResponseBean.builder().code(502).data(false).msg("旧密码错误").build();
        }
        a.setPassword(updateUserVo.getNewPassword());
        if (accountService.updatePassword(a)) {

            //修改操作录入数据库操作日志
            return ResponseBean.builder().code(200).msg("OK").build();
        }
        return ResponseBean.builder().code(501).msg("修改密码失败").build();
    }


    @PostMapping("/login/cz")
    @ApiOperation(value = "财政登录接口")
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "success", response = UserVo.class),
            @ApiResponse(code = 501, message = "用户名或密码错误!"),
            @ApiResponse(code = 502, message = "验证码输入错误!"),
            @ApiResponse(code = 503, message = "未知错误!")
    })
    public ResponseBean czLogin(@RequestBody LoginVo loginVo,
                              HttpServletRequest request) {
        String userAccount = loginVo.getUsername();
        String validCode = loginVo.getValidCode();
        try {
            HttpSession session = request.getSession(true);
            //检查验证码
            String sessionValidCode = (String) session.getAttribute(Constants.RAND_VALID_CODE);
            if (!StringUtils.isEmpty(validCode) && validCode.equalsIgnoreCase(sessionValidCode)) {
                Account a = new Account();
                a.setPassword(loginVo.getPassword());
                a.setUsername(loginVo.getUsername());
                Account account = accountService.loginCz(a);
                if (null != account) {
                    //生成token
                    JwtTokenUtil jwtTokenUtil = new JwtTokenUtil();
                    String subject = JwtTokenUtil.generalSubject(account.getUsername(), account.getProvinceId());
                    String token = jwtTokenUtil.createJWT(userAccount, subject, Constants.JWT_TTL);
                    //将token返回
                    UserVo userVo = new UserVo();
                    userVo.setAccount(account);
                    userVo.setToken(token);
                    userVo.setProvinces(provinceService.getProvinces(account.getProvinceId()));
                    return ResponseBean.builder().code(200).data(userVo).msg("OK").build();
                }
                return ResponseBean.builder().code(501).data(false).msg("用户名或密码错误").build();
            } else {
                return ResponseBean.builder().code(502).msg("验证码输入错误!").data(false).build();
            }
        } catch (Exception e) {
            return ResponseBean.builder().code(503).msg("未知错误!").build();
        }
    }


}

token

package com.cwl.userdata.controller;

import com.cwl.userdata.content.Constants;
import com.cwl.userdata.util.JwtTokenUtil;
import com.cwl.userdata.vo.ResponseBean;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * @author ljq
 * @date 2019-10-15 11:03
 * @describe
 */
@RestController
@RequestMapping("/api/token")
@Api(tags = "token验证")
public class TokenController {

    @ApiOperation(value = "token验证", notes = "大监控所有接口的有效性验证，通过登录时返回的'token'值进行权限验证")
    @GetMapping
    public ResponseBean testToken(HttpServletRequest httpServletRequest) {
        //获得头信息token
        String token = httpServletRequest.getHeader(Constants.JWT_HEADER);
        //如果token不为空且以特定的TOKEN_HEADER开头
        JwtTokenUtil jwtTokenUtil = new JwtTokenUtil();
        if (token != null && (!"".equals(token)) && token.startsWith(Constants.JWT_TOKEN_HEADER)) {
            //对请求进行路由
            String jwt = token.substring(Constants.JWT_TOKEN_HEADER.length());
            System.out.println(jwt);
            return ResponseBean.builder().code(200).msg("OK").data(jwt).build();
        }
        return ResponseBean.builder().code(500).msg("token验证失败").build();
    }

}

util

package com.cwl.userdata.util;

import com.alibaba.fastjson.JSONObject;
import com.cwl.userdata.content.Constants;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.commons.codec.binary.Base64;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Date;

/**
 * @author LJQ E-mail:lijinquan@ishumei.com
 * @version 1.0
 * @date 创建时间：2018/11/12 17:12
 * @parameter
 * @return
 * @since
 */
public class JwtTokenUtil {

    public SecretKey generalKey() {
        String stringKey = Constants.JWT_SECERT;
        byte[] encodedKey = Base64.decodeBase64(stringKey);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }

    /**
     * 创建jwt
     *
     * @param id
     * @param subject
     * @param ttlMillis
     * @return
     */
    public String createJWT(String id, String subject, long ttlMillis) {

        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        SecretKey key = generalKey();
        JwtBuilder builder = Jwts.builder()
                .setId(id)
                .setIssuedAt(now)
                .setSubject(subject)
                .signWith(signatureAlgorithm, key)
                .setIssuer(Constants.JWT_ISSUSER);
        if (ttlMillis >= 0) {
            long expMillis = nowMillis + ttlMillis;
            Date exp = new Date(expMillis);
            builder.setExpiration(exp);
        }
        return builder.compact();
    }

    /**
     * 解密jwt
     *
     * @param jwt
     * @return
     */
    public Claims parseJWT(String jwt) {
        SecretKey key = generalKey();
        Claims claims = Jwts.parser()
                .setSigningKey(key)
                .parseClaimsJws(jwt).getBody();
        return claims;
    }

    /**
     * 生成subject信息
     *
     * @param
     * @return
     */
    public static String generalSubject(String user, String provinceCode) {
        JSONObject jo = new JSONObject();
        jo.put("user", user);
        jo.put("provinceId", provinceCode);
        return jo.toJSONString();
    }


}
尝＆试
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JWT 生成 token 与 fliter 过滤器的简单应用
qq_42649533的博客
05-31 233
这是一个比较简单易行的方式去实现token验证，不用将token放入session。
基于Java验证jwt token代码实例
08-25
主要介绍了基于Java验证jwt token代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
jwt+token验证
qq_51127361的博客
09-19 1788
导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId
Jwt加filter实现app认证
我的博客
07-19 667
导入jwt依赖 <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.11.2</version> </dependency> token实体类 @Data public class TokenDto implements Serializable { /
使用shiro/spring security拦截器Filter，整合jwt，token进行校验【shiro/spring security 拦截token】
世上哪有什么岁月静好,不过是有人替你负重前行
05-18 1731
默认的拦截器 下面的代码为请求声明其拦截器的类型 filterChainDefinitionMap.put("/login/index","anon"); filterChainDefinitionMap.put("/**","authc"); 整合了shiro安全框架后，当运行一个Web应用程序时，Shiro将会创建一些有用的默认 Filter 实例，并自动地将它们置为可用，而这些默认的 Filter 实例是被 DefaultFilter 枚举类定义的，当然我们也可以自定义 Filter 实例 常用的主
SpringSecurity+JWT认证流程解析 | CSDN新人第一弹
和耳朵
07-07 1763
纸上得来终觉浅，觉知此事要躬行。 楔子 本文适合： 对Spring Security有一点了解或者跑过简单demo但是对整体运行流程不明白的同学，对SpringSecurity有兴趣的也可以当作你们的入门教程，示例代码中也有很多注释。本文代码： 码云地址 GitHub地址 大家在做系统的时候，一般做的第一个模块就是认证与授权模块，因为这是一个系统的入口，也是一个系统最重要最基础的一环，在认证与授权服务设计搭建好了之后，剩下的模块才得以安全访问。 市面上一般做认证授权的框架就是shiro和Spring.
JWT Token实现方法及步骤详解
09-07
主要介绍了JWT Token实现方法及步骤详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JWT Token生成及验证
07-16
JWT Token生成及验证:JSON WEB TOKEN，简单谈谈TOKEN的使用及在C#中的实现
JWT(java web Token)
01-22
token 去访问实现了jwt认证的web服务器。 token 可保存自定义信息，如用户基本信息， web服务器用解析token，解决跨域授权的问题
SpringSecurity JwtAuthenticationTokenFilter过滤器
weixin_46256404的博客
11-15 3575
SpringSecurity JwtAuthenticationTokenFilter过滤器
加密解密JwtToken过滤器校验
香辣小鸡翅膀的博客
03-04 552
需求: 原接口返回的直接是用户信息json串 现在要改成jwt进行加密 获取信息接口放行 其他接口拦截校验jwtToken是否有效 jwtTokenUtil package com.hzt.intellect.utils; import cn.hutool.json.JSONObject; import cn.hutool.json.JSONUtil; import io.jsonwebtoken.Claims; import io.jsonwebtoken.JwtBuilder; import io.j
Jwt认证过滤器实现
qq_58137891的博客
05-09 1091
定义Jwt过滤器后，当用户是已登录状态时，在请求头中携带token便可访问相关网页。
springsecurity集成jwt时JwtTokenFilter的位置
qq_35772435的博客
12-31 1094
网上很多Spring Security集成jwt的配置教程, 有一些配置的filter位置是错的. 这个是对的: https://cloud.tencent.com/developer/article/1555599 内容: .addFilterBefore(new JwtLoginFilter("/login",authenticationManager()),UsernamePasswordAuthenticationFilter.class) .addFilterBefore(new JwtFilte
【第十一篇】SpringSecurity基于JWT实现Token的处理
波波烤鸭的博客
05-26 3198
SpringSecurity基于JWT实现Token的处理   前面介绍了手写单点登录和JWT的应用，本文结合SpringSecurity来介绍下在SpringBoot项目中基于SpringSecurity作为认证授权框架的情况下如何整合JWT来实现Token的处理。 一、认证思路分析   SpringSecurity主要是通过过滤器来实现功能的！我们要找到SpringSecurity实现认证和校验身份的过滤器！ 1.回顾集中式认证流程 用户认证：   使用 UsernamePasswordAuthent
前后端分离架构 -- SpringSecurity用法+自定义token校验
weixin_44795847的博客
02-11 3926
前后端分离架构 -- SpringSecurity用法+自定义token校验
登录拦截器LoginFilter正确打开方式（Token验证、将统一参数放入ServletRequest中）
weixin_45100257的博客
04-28 729
登录拦截器LoginFilter正确打开方式（Token验证、将统一参数放入ServletRequest中）
认证过滤器
Leon_Jinhai_Sun的博客
06-05 1962
认证
过滤器filter实现token拦截解析（亲测）
qq_53314126的博客
02-27 1330
1、什么是token？ token令牌：是服务端生成的一串随机生成字符串（我们的例子用UUID生成），放在请求头作为客户端进行请求的一个标识。 当用户第一次登录，服务器生成一个token并将此token返回给客户端，以后客户端只需带上这个token前来请求数据即可判断是谁在调用接口，无需再要用户名和密码。 最近有一个需求是权限系统对另一个系统进行token验证权限管理。子系统并未引入权限框架。目前实现思路是前端将token传入子系统。通过共享redis去解决权限问题。故此子系统只
WebJars简介 —— 前端资源的jar包形式（以后接触到再深入总结）
kaige8312的博客
12-04 408
对于日常的web开发而言，像css、js、images、font等静态资源文件管理是非常的混乱的、比如jQuery、Bootstrap、Vue.js等，可能每个框架使用的版本都不一样、一不注意就会出现版本冲突或者重复添加的问题。所以找到了一个叫做WebJars的技术，下面我将介绍如何将静态资源打包成jar。 什么是WebJars WebJars是将客户端（浏览器）资源（JavaScript，Css等）打成jar包文件，以对资源进行统一依赖管理。WebJars的jar包部署在Maven中央仓库上。 .
spring security校验jwt token的代码
最新发布
05-26
Spring Security校验JWT Token的代码可以参考如下： 首先，需要创建JWT Token的验证过滤器类。该类继承自OncePerRequestFilter，并在doFilterInternal()方法中实现了JWT Token的校验逻辑： ```java public class ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值