开发常用的一种鉴权方案-JWT实践教程

已于 2024-06-25 09:02:28 修改
阅读量895 收藏 9
点赞数 14
分类专栏： Java篇 文章标签： java JWT Token 鉴权 权限 程序开发
于 2024-06-24 16:22:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kingsea442/article/details/139927270
版权

背景

以前我觉得鉴权就是一种前后端一种秘钥的传输，像钥匙一样。但是并没有明确的去了解相关的技术方案，这不最近项目上遇到一个问题，两个后端应用有个接口需要鉴权，该采用哪种方案呢？

  1. 最简单的就是写死一个秘钥，然后接收方进行校验就可以，但是每个用户权限还不一样，需要区分出用户的权限来。
  2. 通过一番调研，认识到JWT，使用JWT可以完美的解决我当前的问题。
    又过了一个月遇到一个小项目的前后端授权，有了使用JWT的使用经验，这次毫不犹疑就采用JWT进行鉴权的方案，如果你遇到类似的问题，希望能对你有点帮助。

本次采用小程序服务端登录鉴权流程作为案例演示，

参考文章：
https://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html
https://developer.aliyun.com/article/995894
https://www.jianshu.com/p/576dbf44b2ae

介绍

JWT（JSON Web Token）是目前最流行的跨域认证解决方案，被广泛应用于认证和授权场景，尤其是在无状态的 RESTful API 中。本文将主要介绍 JWT 的概念、原理，并通过 Java 示例展示其实际应用。
官网地址：https://jwt.io/
在这里插入图片描述
官网提供简单加解密工具：
https://jwt.io/
在这里插入图片描述

JWT原理和交互的流程

  1. 客户端发送用户名和密码到服务器。
  2. 服务器验证用户信息，验证通过后生成 JWT。
  3. 服务器将 JWT 返回给客户端。
  4. 客户端保存 JWT（通常在本地存储或 Cookie 中）。
  5. 客户端在每次请求时将 JWT 发送给服务器。
  6. 服务器验证 JWT，如果有效则处理请求，否则返回错误信息。
    在这里插入图片描述
    看完这个图是不是豁然开朗了就，市面上大部分的鉴权机制都和这个方案类似，学会这个方案，其他衍生和变种方案就很容易掌握了。

JWT的数据结构

JWT的数据结构就像下面这种图一样.
在这里插入图片描述
可以看到被符号 . 分隔成了三部分，这三部分就是:

  • Header (头)
  • Payload (负载)
  • Signature (签名)

还是使用官网这张图，可以比较明显对比出来，左边的token分成三部分后对应的右边每一步分的内容
在这里插入图片描述

Header 头部

Header 通常由两部分组成：令牌的类型和使用的签名算法，alg属性表示签名的算法： HMAC SHA256 或 RSA；type属性表示这个token令牌的类型，JWT统一写为JWT。

{
  "alg": "HS256",
  "typ": "JWT"
}

Payload 负载

Payload 是一个 JSON 对象，包含需要传输的声明。声明分为三种：注册声明（registered claims）、公共声明（public claims）和私有声明（private claims）。JWT规定了7个官方字段：

  • iss (issuer)：签发人
  • exp (expiration time)：过期时间
  • sub (subject)：主题
  • aud (audience)：受众
  • nbf (Not Before)：生效时间
  • iat (Issued At)：签发时间
  • jti (JWT ID)：编号

除了官方字段还可以定义和扩展你自己的私有字段比如：

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

注意，JWT 默认是不加密的，任何人都可以读到，所以不要把秘密信息放在这个部分。

Signature 签名

签名部分是用来对前面两部分数据的签名，防止数据篡改。用于验证消息未被篡改。通过将编码后的头部、载荷和一个密钥结合使用指定的算法生成。这块比较重要的是需要一个密钥（secret）。而且这个密钥只能服务器才知道，不能泄露，如果一旦泄露用户信息可能就会被泄露，所以公司存储这个密钥的方式非常重要。怎么存储这里不展开讲了。

首先，需要指定一个密钥（secret）。这个密钥只有服务器才知道，不能泄露给用户。然后，使用 Header 里面指定的签名算法（默认是 HMAC SHA256），按照下面的公式产生签名。

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（.）分隔，就可以返回给用户。

JWT的使用方式

当客户端收到服务端返回的JWT token之后，可以将token存储在Cookie里，也可以存储在localStorage里面，之后客户端每次请求接口的时候，将token携带上。你可以把它放在 Cookie 里面自动发送，但是这样不能跨域，所以更好的做法是放在 HTTP 请求的头信息Authorization字段里面。

Authorization: Bearer <token>

JWT的生成和验证

@Component
@Slf4j
public class AuthTokenHelper {
    @Value("${aibx.auth.token.secret}")
    private String secret;

    /**
     * iss (issuer)：签发人
     * exp (expiration time)：过期时间
     * sub (subject)：主题
     * aud (audience)：受众
     * nbf (Not Before)：生效时间
     * iat (Issued At)：签发时间
     * jti (JWT ID)：编号
     * @return
     */
    public String generateToken(AuthUser authUser) {
        String authInfo = JSON.toJSONString(authUser);
        return JWT.create()
                .withIssuer("xxxxx")
                .withSubject(authUser.getId())
                .withIssuedAt(Instant.now())
                .withClaim("user", authInfo)
                .sign(Algorithm.HMAC256(secret));
    }

    public String generateAdminToken(AuthUser authUser) {
        DateTime now = DateTime.now();
        DateTime expireDateTime = now.plusHours(1);

        String authInfo = JSON.toJSONString(authUser);
        return JWT.create()
                .withIssuer("aibx")
                .withSubject(authUser.getId())
                .withIssuedAt(Instant.now())
                .withExpiresAt(expireDateTime.toDate())
                .withClaim("user", authInfo)
                .sign(Algorithm.HMAC256(secret));
    }

    public TokenVerifyResult verifyToken(String token) {
        TokenVerifyResult result = new TokenVerifyResult();
        result.setCode(0);
        result.setMsg("success");
        try {
            JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(secret))
                    .withIssuer("xxxxxx")
                    .build();
            DecodedJWT decodedJWT = jwtVerifier.verify(token);
            String userJsonStr = decodedJWT.getClaim("user").asString();
            AuthUser authUser = JSON.parseObject(userJsonStr, AuthUser.class);
            result.setAuthUser(authUser);
        } catch (SignatureVerificationException e) {
            result.setCode(1);
            result.setMsg("签名无效");
        } catch (AlgorithmMismatchException e) {
            result.setCode(2);
            result.setMsg("签名算法不匹配");
        } catch (TokenExpiredException e) {
            result.setCode(3);
            result.setMsg("token过期");
        } catch (Exception e) {
            log.error("failed parse token, error: ", e);
            result.setCode(100);
            result.setMsg("无法解析token");
        }

        return result;
    }
}

JWT登录鉴权方案参考-微信小程序登录

这块以一个简单的鉴权的场景，场景是微信小程序的开发，获取后端接口的鉴权机制。

小程序登录

这块不是重点，也不展开讲，只简单介绍下，下面这张图是小程序官方的登录流程时序图，这个案例会展开详细讲述图中红框部分。
在这里插入图片描述

定义颁发JWT的接口

配置jar包依赖
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>4.4.0</version>
        </dependency>
step 1: 定义登录的数据结构
@Data
public class TokenGetRequest {
    /**
     * 小程序端生成的code
     */
    private String wxCode;
}
step2: 定义接口，小程序授权完成之后在小程序端获取到wxCode（小程序登录的识别码），拿到wxCode请求后端服务器进行鉴权
	@ApiOperation("获取token")
    @PostMapping(value = "/token")
    public ApiResult<TokenGetResp> token(@RequestBody TokenGetRequest request) throws ThirdException {
        String token = authService.generateAndCacheToken(request.getWxCode());
        TokenGetResp resp = new TokenGetResp();
        resp.setToken(token);
        return ApiResult.success(resp);
    }
step3: 校验wxCode是否合法，获取用户userOpenId：
    @Override
    public String generateAndCacheToken(String wxCode) throws ThirdException {
        String userOpenId = weiXinService.getUserOpenId(wxCode);
        if (StringUtils.isBlank(userOpenId)) {
            throw new ThirdException("调用微信服务出错，无法获取到用户openId");
        }

        AuthUser authUser = new AuthUser();
        authUser.setWxId(userOpenId);
        User user = userService.createOrGetUser(authUser);
        authUser.setId(user.getId());
        String token = authTokenHelper.generateToken(authUser);

        // 将token放入缓存
        stringRedisTemplate.opsForValue().set(token, "", Duration.ofSeconds(TOKEN_EXPIRE_TIMEOUT_SECONDS));
        return token;
    }

如果wxCode是合法的，就能顺利拿到userOpenId，然后将userOpenId和自己服务的用户表进行关联，后续接口鉴权会用到。

step4：生成JWT

这里需要服务端保存一个secret，这个secre非常重要，妥善保管。

/**
     * iss (issuer)：签发人
     * exp (expiration time)：过期时间
     * sub (subject)：主题
     * aud (audience)：受众
     * nbf (Not Before)：生效时间
     * iat (Issued At)：签发时间
     * jti (JWT ID)：编号
     * @return
     */
    public String generateToken(AuthUser authUser) {
        String authInfo = JSON.toJSONString(authUser);
        return JWT.create()
                .withIssuer("xxxxx")
                .withSubject(authUser.getId())
                .withIssuedAt(Instant.now())
                .withClaim("user", authInfo)
                .sign(Algorithm.HMAC256(secret));
    }
step 5: 服务端对Token使用鉴权

这里使用了Spring种Filter的概念，定制一个AuthFilter，会对所有的接口进行拦截鉴权。

@Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        // 判断如果是不需要验证接口，直接放行
        if (authProperties.getExcludeUrlPaths().stream()
                .anyMatch(e -> pathMatcher.match(e, ((HttpServletRequest) req).getServletPath()))) {
            chain.doFilter(req, resp);
            return;
        }

        try {
            if (!filterParam(req, resp)) {
                return;
            }
            chain.doFilter(req, resp);
        } finally {
            ThreadParamUtil.remove();
        }
    }

    private boolean filterParam(ServletRequest req, ServletResponse resp) {
        if (req instanceof HttpServletRequest) {
            HttpServletRequest httpServletRequest = ((HttpServletRequest) req);
            String auth = httpServletRequest.getHeader(AuthConstants.HTTP_HEADER_AUTHORIZATION);
            log.info("AUTH={} path={}", auth, httpServletRequest.getServletPath());

            if (StringUtils.isBlank(auth)) {
                forbid(resp, ApiResult.state(AUTH_TOKEN_INVALID_CODE, "Authorization is required in HEADER", null));
                return false;
            }

            // 校验token是否合法，不合法直接禁止访问
            String token = StringUtils.replace(auth, "Bearer ", "");
            TokenVerifyResult result = authService.verifyToken(token);
            if (!result.isValidToken()) {
                // token不合法，直接禁止访问
                forbid(resp, ApiResult.state(AUTH_TOKEN_INVALID_CODE, "Authorization is invalid", null));
                return false;
            }

            AuthUser authUser = result.getAuthUser();
            //如果是管理员接口路径&&token是管理员的token，走到这一步，就已经通过token验证，这里直接返回就行了
            if (StringUtils.containsIgnoreCase(httpServletRequest.getServletPath(), ApiConstant.BASE_API_V1_ADMIN)) {
                if (authUser.isIfAdmin()) {
                    return true;
                } else {
                    forbid(resp, ApiResult.state(AUTH_TOKEN_INVALID_CODE, "非法的token", null));
                }
            }

            // 校验token是否过期，考虑这一步是否需要放到redis，保证活跃用户不用频繁登录，长时间不登录的用户token才会过期
            boolean checkResult = authService.checkIfTokenExistAndExtension(token);
            if (!checkResult) {
                forbid(resp, ApiResult.state(AUTH_TOKEN_INVALID_CODE, "Token is expired", null));
                return false;
            }

            // saveUser 如果不存在，创建一个, 理论上都存在，因为在登陆过程就已经创建完用户了
            if (StringUtils.isBlank(authUser.getWxId())) {
                forbid(resp, ApiResult.state(AUTH_TOKEN_INVALID_CODE, "未获取到用户微信id", null));
            }
            User user = userService.createOrGetUser(authUser);
            Assert.state(null != user);
            authUser.setUserName(user.getUsername());
            ThreadParamUtil.setLocalKeyValue(AuthConstants.THREAD_LOCAL_AUTH_USER, authUser);
            log.info("[TRACK] user:{}, operate:{}", user.getUsername(), httpServletRequest.getServletPath());
        }
        return true;
    }

    public void forbid(ServletResponse resp, Object result) {
        if (!resp.isCommitted()) {
            if (resp instanceof HttpServletResponse) {
                ((HttpServletResponse) resp).setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            }
            resp.setCharacterEncoding("UTF-8");
            resp.setContentType("application/json; charset=utf-8");

            try (Writer writer = resp.getWriter()) {
                writer.append(JSON.toJSONString(result));
                writer.flush();
            } catch (IOException e) {
                log.warn("", e);
            }
        }
    }
step 6: 验证JWT是否合法

使用同一个secret进行解密

public TokenVerifyResult verifyToken(String token) {
        TokenVerifyResult result = new TokenVerifyResult();
        result.setCode(0);
        result.setMsg("success");
        try {
            JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(secret))
                    .withIssuer("xxxxxx")
                    .build();
            DecodedJWT decodedJWT = jwtVerifier.verify(token);
            String userJsonStr = decodedJWT.getClaim("user").asString();
            AuthUser authUser = JSON.parseObject(userJsonStr, AuthUser.class);
            result.setAuthUser(authUser);
        } catch (SignatureVerificationException e) {
            result.setCode(1);
            result.setMsg("签名无效");
        } catch (AlgorithmMismatchException e) {
            result.setCode(2);
            result.setMsg("签名算法不匹配");
        } catch (TokenExpiredException e) {
            result.setCode(3);
            result.setMsg("token过期");
        } catch (Exception e) {
            log.error("failed parse token, error: ", e);
            result.setCode(100);
            result.setMsg("无法解析token");
        }

        return result;
    }

以上就能搭建一个完整的前后端鉴权机制了，以及后端鉴权的方案架构设计也都非常值得参考。

使用JWT需要注意的问题

此处参考：https://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html
（1）JWT 默认是不加密，但也是可以加密的。生成原始 Token 以后，可以用密钥再加密一次。
（2）JWT 不加密的情况下，不能将秘密数据写入 JWT。
（3）JWT 不仅可以用于认证，也可以用于交换信息。有效使用 JWT，可以降低服务器查询数据库的次数。
（4）JWT 的最大缺点是，由于服务器不保存 session 状态，因此无法在使用过程中废止某个 token，或者更改 token 的权限。也就是说，一旦 JWT 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。
（5）JWT 本身包含了认证信息，一旦泄露，任何人都可以获得该令牌的所有权限。为了减少盗用，JWT 的有效期应该设置得比较短。对于一些比较重要的权限，使用时应该再次对用户进行认证。
（6）为了减少盗用，JWT 不应该使用 HTTP 协议明码传输，要使用 HTTPS 协议传输。

总结

JWT的整体使用是非常简单的，但是也要注意使用的过程中防止信息泄露，比如payload部分不存储敏感信息以及secret的保存都非常重要。

程序开发小黑
关注
  • 14
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
open-api-project:基于反射实现，高效 java版开放接口统一网关鉴权demo项目
05-10
【标题】"基于反射实现，高效 Java版开放接口统一网关鉴权demo项目"揭示了这个开源项目的主要特性，即使用反射技术来提高性能，并且是针对Java开发者的开放接口鉴权解决方案。该项目旨在为Java开发者提供一个统一的...
JWT使用
pscool的博客
11-02 3014
jjwt <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.6.0</version> </dependency> Base64加密、解密 @Test public void testGenJwt() { JwtBuilder jwtBuilder =
常见登录鉴权方案
360技术
11-09 1121
奇技 · 指南说起鉴权大家应该都很熟悉，不过作为前端开发来讲，鉴权的流程大头都在后端小哥那边，本文的目的就是为了让大家了解一下常见的鉴权的方式和原理。认知：HTTP 是一个无状态协议，所...
ThinkJS JWT 鉴权实践
weixin_34220623的博客
07-30 1014
编者注：我相信鉴权应该是大部分 Web 服务必备的基础功能之一。实现权限验证的方式有很多种，其中 JSON Web Token（即JWT）这种使用 Token 验证的方式受到了越来越多开发者的喜爱。其相对于传统的验证方式来说会更为安全一点，而且相对而言由于加密串中就包含了权限信息，所以不需要额外的数据库查询。今天我们请来了 ThinkJS 的开发人员卢士杰同学给我们实战讲解下载 ThinkJS 中...
微服务鉴权-spring cloud Alibaba + Oauth2 + Zuul OAuth2 SSO + JWT
qq_38053426的博客
07-14 4890
前言 本文主要介绍一个搭建的过程 笔者在基于《重新定义SpringCloud开发》这本书的zuul集成Oauth2的章节例子上扩展了一些东西出来 其中踩了不少的坑 过程也十分艰辛。。 背景: 在第一代微服务框架体系下 我们以前做过使用 Spring Session + Redis cluster 做过一个在线教育项目的用户的认证和登录 实践中发现了一些不足 ： 流量过于...
手把手教大家在 gRPC 中使用 JWT 完成身份校验
江南一点雨的专栏
02-22 1707
有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如 Tomcat 中的 Session。例如登录：用户登录后，我们把用户的信息保存在服务端 session 中，并且给用户一个 cookie 值，记录对应的 session，然后下次请求，用户携带 cookie 值来（这一步有浏览器自动完成），我们就能识别到对应 session，从而找到用户的信息。服务端保存大量数据，增加服务端压力服务端保存用户状态，不支持集群化部署。
jwt token 过期刷新_如何在SpringBoot中集成JWT(JSON Web Token)鉴权
weixin_39705931的博客
11-21 739
这篇博客主要是简单介绍了一下什么是JWT，以及如何在Spring Boot项目中使用JWT(JSON Web Token)。1.关于JWT1.1 什么是JWT老生常谈的开头，我们要用这样一种工具，首先得知道以下几个问题。 - 这个工具是什么，这个工具解决了什么问题 - 是否适用于当前我们所处得业务场景 - 用了之后是否会带来任何其他问题 - 怎么用才是最佳实践那什么是JWT呢？以下是我对jwt官网...
GoWeb 项目实战：使用 Iris 框架构建一个安全可靠的 API 服务（附 JWT 认证实现）
蜗牛的博客
12-07 1311
GoWeb 进阶的实战项目，基于 Iris 框架实现 JWT 认证（附案例全代码）
JWT-Token验证
qq_42382634的博客
06-20 2338
摘自原文：https://blog.csdn.net/hanpenghu/article/details/83539034 通常情况下，把API直接暴露出去是风险很大的，不说别的，直接被机器攻击就喝一壶的。那么一般来说，对API要划分出一定的权限级别，然后做一个用户的鉴权，依据鉴权结果给予用户开放对应的API。目前，比较主流的方案有几种: 用户名和密码鉴权，使用Session保存用户鉴权...
java jwt payload_如何在SpringBoot中集成JWT鉴权（附代码）
weixin_39805539的博客
02-16 286
本篇文章给大家带来的内容是关于如何在SpringBoot中集成JWT鉴权(附代码)，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。1、关于JWT1.1 什么是JWT老生常谈的开头，我们要用这样一种工具，首先得知道以下几个问题。这个工具是什么，这个工具解决了什么问题是否适用于当前我们所处得业务场景用了之后是否会带来任何其他问题怎么用才是最佳实践那什么是JWT呢？以下是我对jwt官网上...
.NET6平台开发WebApi-使用JWT进行用户鉴权和测试源码
02-21
JWT是一种轻量级的身份验证标准，它允许服务端为客户端颁发一个令牌，该令牌包含了用户的相关信息，且在后续的请求中，客户端只需要携带这个令牌，无需再次发送用户名和密码，从而简化了身份验证流程。 标题中的...
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制
10-17
JWT是一种开放标准（RFC 7519），用于在各方之间安全地传输信息作为一个 JSON 对象。这个信息可以被验证和信任，因为它是数字签名的。在本项目中，当用户通过Shiro验证后，系统不再创建传统的Session，而是生成一个...
SpringBoot+shiro+redis+jwt .zip
01-03
本项目通过`SpringBoot`整合`Shiro`和`Redis`，利用`JWT`来实现用户鉴权，旨在提供一种简洁、高效的解决方案。 首先，`SpringBoot`简化了传统`Spring`项目的配置和依赖管理，通过自动配置特性，开发者可以快速构建...
vue-expres-login:vue + express关于session鉴权的小项目
03-09
7. **JWT（JSON Web Tokens）**：虽然项目主要依赖session进行鉴权，但现代Web应用也经常使用JWT作为替代方案，因为JWT可以在多个服务间共享用户身份信息，无需服务器存储session。不过，这可能不在本项目的范围内。...
了解＜![CDATA[ ]]＞的使用
分享Java知识，记录思考和感悟
01-16 3930
通过使用CDATA标签，我们可以在XML文档中包含不需要解析的文本数据，确保其中的特殊字符或大段文本得到正确处理。这是XML中一个强大且常用的特性，对于处理各种类型的数据都非常有帮助。
IntelliJ IDEA 如何编译 Maven 工程项目
分享Java知识，记录思考和感悟
01-08 2735
通过这篇文章，你不仅学会了如何在IntelliJ IDEA中基本地编译Maven项目，还了解了一些高级技巧。IntelliJ IDEA为Maven项目提供了强大而灵活的支持，让Java开发者能够更加高效地构建和管理项目。希望这些指南能够帮助你更好地利用IntelliJ IDEA进行Java项目的开发和构建。
建议收藏，Java Optional如何使用的最佳实践
最新发布
分享Java知识，记录思考和感悟
02-01 1964
Optional是Java8提供的为了解决null安全问题的一个API。善用Optional可以使我们代码中很多繁琐、丑陋的设计就可以变得十分优雅。本篇文章还介绍了如何使用Optional，以及推荐的方法。
日期处理第三篇：Hutool的日期时间工具-DateUtil使用
分享Java知识，记录思考和感悟
01-19 1892
Hutool中的日期和时间API大量考虑中国时间格式，有着方便的方法可以直接使用，提高了我们的开发效率。如果你要处理农历时间，推荐直接使用hutool这个就行了，但是鉴于Java8中的API其实已经很方便了，所以尽量使用jdk8内置的即可。毕竟额外的包也会带来额外的负担，大家可以按需选择。
十次方微服务开发v1.0--第6章1
08-03
接着，文章提到了JWT（JSON Web Token），它是一种用于认证的开放标准。JWT由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。头部包含了对JWT的描述信息，载荷包含了需要传递的信息，签名用于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值