JWT技术验证登录

已于 2024-03-08 21:17:19 修改
阅读量678 收藏 22
点赞数 24
文章标签： java spring spring boot mybatis
于 2024-03-08 16:16:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72015215/article/details/136547825
版权

Cookie 

cookie 是客户端会话跟踪技术，它是存储在客户端浏览器的，我们使用 cookie 来跟踪会话，我们就可以在浏览器第一次发起请求来请求服务器的时候，我们在服务器端来设置一个cookie。

为什么这一切都是自动化进行的？

是因为 cookie 它是 HTP 协议当中所支持的技术，而各大浏览器厂商都支持了这一标准。在 HTTP 协议官方给我们提供了一个响应头和请求头：

  • 响应头 Set-Cookie ：服务器端给浏览器端设置Cookie数据的

  • 请求头 Cookie：携带Cookie数据的

 cookie代码测试

Result实体类 

Result.java

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result {
    private Integer code;//响应码，1 代表成功; 0 代表失败
    private String msg;  //响应信息 描述字符串
    private Object data; //返回的数据

    //增删改 成功响应
    public static Result success(){
        return new Result(1,"success",null);
    }
    //查询 成功响应
    public static Result success(Object data){
        return new Result(1,"success",data);
    }
    //失败响应
    public static Result error(String msg){
        return new Result(0,msg,null);
    }
}

@Slf4j
@RestController
public class SessionController {

    //设置Cookie
    @GetMapping("/c1")
    public Result cookie1(HttpServletResponse response){
        response.addCookie(new Cookie("login_username","itheima")); //设置Cookie/响应Cookie
        return Result.success();
    }
	
    //获取Cookie
    @GetMapping("/c2")
    public Result cookie2(HttpServletRequest request){
        Cookie[] cookies = request.getCookies();
        for (Cookie cookie : cookies) {
            if(cookie.getName().equals("login_username")){
                System.out.println("login_username: "+cookie.getValue()); //输出name为login_username的cookie
            }
        }
        return Result.success();
    }
}

 Cookie的优缺点

  • 优点：HTTP协议中支持的技术（像Set-Cookie 响应头的解析以及 Cookie 请求头数据的携带，都是浏览器自动进行的，是无需我们手动操作的）

  • 缺点：

    • 移动端APP(Android、IOS)中无法使用Cookie

    • 不安全，用户可以自己禁用Cookie

    • Cookie不能跨域 

 跨域介绍：

  • 现在的项目，大部分都是前后端分离的，前后端最终也会分开部署，前端部署在服务器 192.168.150.200 上，端口 80，后端部署在 192.168.150.100上，端口 8080

  • 我们打开浏览器直接访问前端工程，访问url：http://192.168.150.200/login.html

  • 然后在该页面发起请求到服务端，而服务端所在地址不再是localhost，而是服务器的IP地址192.168.150.100，假设访问接口地址为：http://192.168.150.100:8080/login

  • 那此时就存在跨域操作了，因为我们是在 http://192.168.150.200/login.html 这个页面上访问了http://192.168.150.100:8080/login 接口

  • 此时如果服务器设置了一个Cookie，这个Cookie是不能使用的，因为Cookie无法跨域

Session

 前面介绍的时候，我们提到Session，它是服务器端会话跟踪技术，所以它是存储在服务器端的。而 Session 的底层其实就是基于我们刚才所介绍的 Cookie 来实现的。

获取Session  

 如果我们现在要基于 Session 来进行会话跟踪，浏览器在第一次请求服务器的时候，我们就可以直接在服务器当中来获取到会话对象Session。如果是第一次请求Session ，会话对象是不存在的，这个时候服务器会自动的创建一个会话对象Session 。而每一个会话对象Session ，它都有一个ID（示意图中Session后面括号中的1，就表示ID），我们称之为 Session 的ID。    

 响应Cookie (JSESSIONID) 

接下来，服务器端在给浏览器响应数据的时候，它会将 Session 的 ID 通过 Cookie 响应给浏览器。其实在响应头当中增加了一个 Set-Cookie 响应头。这个 Set-Cookie 响应头对应的值是不是cookie？ cookie 的名字是固定的 JSESSIONID 代表的服务器端会话对象 Session 的 ID。浏览器会自动识别这个响应头，然后自动将Cookie存储在浏览器本地。  

 查找Session

接下来，在后续的每一次请求当中，都会将 Cookie 的数据获取出来，并且携带到服务端。接下来服务器拿到JSESSIONID这个 Cookie 的值，也就是 Session 的ID。拿到 ID 之后，就会从众多的 Session 当中来找到当前请求对应的会话对象Session。

令牌技术 

JWT令牌

前面我们介绍了基于令牌技术来实现会话追踪。这里所提到的令牌就是用户身份的标识，其本质就是一个字符串。令牌的形式有很多，我们使用的是功能强大的 JWT令牌。

介绍

 

JWT的组成： （JWT令牌由三个部分组成，三个部分之间使用英文的点来分割）

  • 第一部分：Header(头）， 记录令牌类型、签名算法等。 例如：{"alg":"HS256","type":"JWT"}

  • 第二部分：Payload(有效载荷），携带一些自定义信息、默认信息等。 例如：{"id":"1","username":"Tom"}

  • 第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来。

    签名的目的就是为了防jwt令牌被篡改，而正是因为jwt令牌最后一个部分数字签名的存在，所以整个jwt 令牌是非常安全可靠的。一旦jwt令牌当中任何一个部分、任何一个字符被篡改了，整个令牌在校验的时候都会失败，所以它是非常安全可靠的。

 JWT令牌的生成

JWT令牌最典型的应用场景就是登录认证：

  1. 在浏览器发起请求来执行登录操作，此时会访问登录的接口，如果登录成功之后，我们需要生成一个jwt令牌，将生成的 jwt令牌返回给前端。

  2. 前端拿到jwt令牌之后，会将jwt令牌存储起来。在后续的每一次请求中都会将jwt令牌携带到服务端。

  3. 服务端统一拦截请求之后，先来判断一下这次请求有没有把令牌带过来，如果没有带过来，直接拒绝访问，如果带过来了，还要校验一下令牌是否是有效。如果有效，就直接放行进行请求的处理。 

在JWT登录认证的场景中我们发现，整个流程当中涉及到两步操作：

  1. 在登录成功之后，要生成令牌。

  2. 每一次请求当中，要接收令牌并对令牌进行校验。

稍后我们再来学习如何来生成jwt令牌，以及如何来校验jwt令牌。

生成和校验

 <!-- JWT依赖-->
<dependency>    
<groupId>io.jsonwebtoken</groupId>    
<artifactId>jjwt</artifactId>    
<version>0.9.1</version>
</dependency>

JWT工具类

JwtUtils.java
public class JwtUtils {

    private static String signKey = "itheima";
    private static Long expire = 43200000L;  //  12h

    /**
     * 生成JWT令牌
     * @param claims JWT第二部分负载 payload 中存储的内容
     * @return
     */
    public static String generateJwt(Map<String, Object> claims){
        String jwt = Jwts.builder()
                .addClaims(claims)
                .signWith(SignatureAlgorithm.HS256, signKey)
                .setExpiration(new Date(System.currentTimeMillis() + expire))
                .compact();
        return jwt;
    }

    /**
     * 解析JWT令牌
     * @param jwt JWT令牌
     * @return JWT第二部分负载 payload 中存储的内容
     */
    public static Claims parseJWT(String jwt){
        Claims claims = Jwts.parser()
                .setSigningKey(signKey)
                .parseClaimsJws(jwt)
                .getBody();
        return claims;
    }
}

生成JWT代码实现：

   //  生成jwt令牌
    @Test
    public void testJWT() {
        HashMap<String, Object> claims = new HashMap<>();
        claims.put("id", 1);
        claims.put("name", "tom");
        //  jwt 令牌的生成，以及相应的生成算法  itheima为生成密钥  claims设置自定义部分
        String jwt = Jwts.builder()
                .signWith(SignatureAlgorithm.HS256, "itheima") //签名算法
                .setClaims(claims) //  自定义内容
                .setExpiration(new Date(System.currentTimeMillis() + 3600 * 1000)) // 设置有效时间 为一个1h
                .compact();//  拿到字符串的令牌返回值
        System.out.println(jwt);
    }

运行测试方法：

eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjcyNzI5NzMwfQ.fHi0Ub8npbyt71UqLXDdLyipptLgxBUg_mSuGJtXtBk

Jwt令牌的解析

@Test
    void contextLoads() {
        //  parser()解析
        Claims claims = Jwts.parser()
                .setSigningKey("itheima")  //  setSigningKey根据密钥解析
                .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoidG9tIiwiaWQiOjEsImV4cCI6MTcwOTg3MTYzMX0.ivqdcaOxoh0R9qlOe7nDjQxSbZCA-jMv4tEeqsL6upQ")
                .getBody();//  拿到了自定义的内容
        System.out.println(claims);
    }

 过滤器

下面我们通过Filter快速入门程序掌握过滤器的基本使用操作：

  • 第1步，定义过滤器 ：1.定义一个类，实现 Filter 接口，并重写其所有方法。

  • 第2步，配置过滤器：Filter类上加 @WebFilter 注解，配置拦截资源的路径。引导类上加 @ServletComponentScan 开启Servlet组件支持。

 定义过滤器

//定义一个类，实现一个标准的Filter过滤器的接口
public class DemoFilter implements Filter {
    @Override //初始化方法, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");
    }

    @Override //拦截到请求之后调用, 调用多次
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Demo 拦截到了请求...放行前逻辑");
        //放行
        chain.doFilter(request,response);
    }

    @Override //销毁方法, 只调用一次
    public void destroy() {
        System.out.println("destroy 销毁方法执行了");
    }
}

  • init方法：过滤器的初始化方法。在web服务器启动的时候会自动的创建Filter过滤器对象，在创建过滤器对象的时候会自动调用init初始化方法，这个方法只会被调用一次。

  • doFilter方法：这个方法是在每一次拦截到请求之后都会被调用，所以这个方法是会被调用多次的，每拦截到一次请求就会调用一次doFilter()方法。

  • destroy方法： 是销毁的方法。当我们关闭服务器的时候，它会自动的调用销毁方法destroy，而这个销毁方法也只会被调用一次。

@WebFilter(urlPatterns = "/*") //配置过滤器要拦截的请求路径（ /* 表示拦截浏览器的所有请求 ）
public class DemoFilter implements Filter {
    @Override //初始化方法, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");
    }

    @Override //拦截到请求之后调用, 调用多次
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Demo 拦截到了请求...放行前逻辑");
        //放行
        chain.doFilter(request,response);
    }

    @Override //销毁方法, 只调用一次
    public void destroy() {
        System.out.println("destroy 销毁方法执行了");
    }
}

当我们在Filter类上面加了@WebFilter注解之后，接下来我们还需要在启动类上面加上一个注解@ServletComponentScan，通过这个@ServletComponentScan注解来开启SpringBoot项目对于Servlet组件的支持。

Filter的拦截路径

过滤器链

 过滤器链指的是在一个web应用程序当中，可以配置多个过滤器，多个过滤器就形成了一个过滤器链。

在我们web服务器当中，定义了两个过滤器，这两个过滤器就形成了一个过滤器链。

而这个链上的过滤器在执行的时候会一个一个的执行，会先执行第一个Filter，放行之后再来执行第二个Filter，如果执行到了最后一个过滤器放行之后，才会访问对应的web资源。

访问完web资源之后，按照我们刚才所介绍的过滤器的执行流程，还会回到过滤器当中来执行过滤器放行后的逻辑，而在执行放行后的逻辑的时候，顺序是反着的。

先要执行过滤器2放行之后的逻辑，再来执行过滤器1放行之后的逻辑，最后在给浏览器响应数据。

以上就是当我们在web应用当中配置了多个过滤器，形成了这样一个过滤器链以及过滤器链的执行顺序。下面我们通过idea来验证下过滤器链。

AbcFilter过滤器  

@WebFilter(urlPatterns = "/*")
public class AbcFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Abc 拦截到了请求... 放行前逻辑");

        //放行
        chain.doFilter(request,response);

        System.out.println("Abc 拦截到了请求... 放行后逻辑");
    }
}

 DemoFilter过滤器

@WebFilter(urlPatterns = "/*") 
public class DemoFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("DemoFilter   放行前逻辑.....");

        //放行请求
        filterChain.doFilter(servletRequest,servletResponse);

        System.out.println("DemoFilter   放行后逻辑.....");
    }
}

AbcFilter先执行DemoFilter后执行，这是为什么呢？

AbcFilter先执行DemoFilter后执行

假如我们想让DemoFilter先执行，怎么办呢？答案就是修改类名。

测试：修改AbcFilter类名为XbcFilter，运行程序查看控制台日志  

此时 DemoFilter会先被执行，第二个是XbcFilter过滤器，当值习惯最后的一个过滤器时就会访问web资源中。

登录校验-Filter

我们先来回顾下前面分析过的登录校验的基本流程：

  • 要进入到后台管理系统，我们必须先完成登录操作，此时就需要访问登录接口login。

  • 登录成功之后，我们会在服务端生成一个JWT令牌，并且把JWT令牌返回给前端，前端会将JWT令牌存储下来。

  • 在后续的每一次请求当中，都会将JWT令牌携带到服务端，请求到达服务端之后，要想去访问对应的业务功能，此时我们必须先要校验令牌的有效性。

  • 对于校验令牌的这一块操作，我们使用登录校验的过滤器，在过滤器当中来校验令牌的有效性。如果令牌是无效的，就响应一个错误的信息，也不会再去放行访问对应的资源了。如果令牌存在，并且它是有效的，此时就会放行去访问对应的web资源，

  • 执行相应的业务操作我们要完成登录校验，主要是利用Filter过滤器实现，而Filter过滤器的流程步骤：

  1. 获取请求url

  2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行

  3. 获取请求头中的令牌（token）

  4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）

  5. 解析token，如果解析失败，返回错误结果（未登录）

  6. 放行

实现代码 

package com.example.zaixianxuexi.filter;

import com.alibaba.fastjson2.JSONObject;
import com.example.zaixianxuexi.pojo.Result;
import com.example.zaixianxuexi.util.JwtUtils;
import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;

@Slf4j
@WebFilter(urlPatterns = "/*")
public class LoginCheckFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //         获取请求对象和相应对象
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse rep = (HttpServletResponse) response;

        //        1. 获取请求url
        String url = req.getRequestURL().toString();
        log.info("请求url:-------{}", url);

        //        2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行
        if (url.contains("/login")) {
            log.info("登录操作");
            chain.doFilter(request, response);
            return; //结束当前方法的执行
        }

        //        3. 获取请求头中的令牌（token）
        String jwt = req.getHeader("token");
        log.info("从请求头中获取的令牌：{}", jwt);

        //        4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）
        //  StringUtils.hasLength(jwt)判断jwt是否有长度,即即使jwt是否为空
        if (jwt == null) {
            log.info("请求token为空，返回未登陆信息");
            Result not_login = Result.error("NOT_LOGIN");
            //  手动转化对象为json格式
            String s = JSONObject.toJSONString(not_login);
            response.setContentType("application/json;charset=utf-8");

            //   将所得到的结果相应给浏览器
            rep.getWriter().write(s);
            return;
        }
        //        5. 解析token，如果解析失败，返回错误结果（未登录）
        try {
            JwtUtils.parseJWT(jwt);
        } catch (Exception e) {
            log.info("解析令牌失败，返回未登录的信息");
            Result not_login1 = Result.error("NOT_LOGIN");
            //  手动转化对象为json格式
            String s = JSONObject.toJSONString(not_login1);
            response.setContentType("application/json;charset=utf-8");
            //   将所得到的结果相应给浏览器
            rep.getWriter().write(s);
            return;
        }
        //        6. 放行
        log.info("令牌合法，放行");
        chain.doFilter(request, response);
    }
}

啟王朝
关注
  • 24
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JWT校验
Monster
03-08 2123
1. 什么是JWT Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 通俗说：\color{#FF3030}{通俗说：}通俗说： 在数据传输过程中还可
jwt(JSON Web Token)做登陆校验
m0_64224130的博客
09-22 524
1、客户端使用用户名和密码请求登录2、服务端收到请求，验证用户名和密码3、验证成功后，服务端会签发一个token，再把这个token返回给客户端4、客户端收到token后可以把它存储起来，比如放到cookie中5、客户端每次向服务端请求资源时需要携带服务端签发的token，可以在cookie或者header中携带6、服务端收到请求，然后去验证客户端请求里面带着的token，如果验证成功，就向客户端返回请求数据。
JWT登录校验
在这个地方会介绍一些前端和后端的开发内容，暂时以JavaEE和Vue为主。
06-06 796
springboot，登录，jwt，jwt解析，token，拦截器Interceptor
过滤器与拦截器 - 登录校验与登录认证（JWT令牌技术）
weixin_51351637的博客
05-17 2280
会话：用户打开浏览器，访问web服务器资源，会话建立，直到有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应。比如我们打开浏览器与Web服务器建立连接。首先访问login接口，再访问depts接口，最后访问emps接口。只要浏览器和服务器都没有关闭，那么这三次请求都是在一次会话中完成的。关闭服务器，所有的会话都会关闭关闭当前浏览器，当前会话结束会话跟踪：一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。
请求鉴权检验JWT和Token
ili_ii的博客
05-29 758
前端鉴权方式 JWT
java基于springBoot和jwt实现用户登录功能
06-07
在使用Spring Boot框架和JWT技术实现用户登录功能时，需要在pom.xml文件中添加相关的依赖。例如，添加jwt（JSON Web Token）依赖，版本号为0.9.1；添加java-jwt依赖，版本号为3.10.3。 知识点4：实体类设计 在实现...
JWT-Authentication:实现了JWT身份验证的API
03-28
用TypeScript编写的API，已实现JWT身份验证。 所用技术 打字稿 表达 蒙多数据库 猫鼬 设置 数据库URL和客户端URL等的配置位于app.json 。 已安装并正在运行mongoDB服务器，或者具有可以连接到的URL。 npm i touch...
c#关于JWT跨域身份验证解决方案.docx
10-26
c#关于JWT跨域身份验证解决方案.docx
Perfect-JWTAuth:单一登录身份验证模块
05-08
请注意本函数库已经停止技术支持，因为新的Perfect JWT认证管理系统正在开发中。 PLEASE FOLLOW FOR MORE INFORMATION. Perfect JWT Based Authentication Module This project is a new candidate feature of ...
express-jwt-auth:Express.js JWT身份验证
04-18
RESTful API，具有使用Express.js和JWT的基于角色的身份验证。 特征 用户CRUD 用户认证 基于角色的身份验证中间件 要求 $ git clone https://github.com/GoldB/express-jwt-auth $ cd express-jwt-auth $ npm ...
JWT令牌生成与校验
赵广陆
02-08 2354
目录1 JWT介绍1.1 什么是JWT？1.2 JWT令牌结构2 配置JWT令牌服务3 生成JWT令牌4 校验JWT令牌5 JWT整合Spring Security5.1 创建表6 配置授权服务6.1 测试 1 JWT介绍 通过上边的测试我们发现，当资源服务和授权服务不在一起时资源服务使用RemoteTokenServices 远程请求授权服务验证token，如果访问量较大将会影响系统的性能 。 解决上边问题： 令牌采用JWT格式即可解决上边的问题，用户认证通过会得到一个JWT令牌，JWT令牌中已经包括了
JWT的登录认证与自校验原理分析
最新发布
qq_66013742的博客
10-25 320
JWT是一个含签名并且携带用户相关信息的加密串，用户输入相关信息进行登录的时候，如果信息验证成功，会生成一个JWT(Token令牌)，并且将这个token返回给前端保存到本地，当进行其他的请求api的时候，将这个Token带给后端，并且拦截器对请求进行拦截，验证这个Token,如果验证Token无误则放行这个请求，进行相应的业务逻辑处理，显示数据；有误则返回错误信息，跳转登陆界面。
Java实现Token登录验证(基于JWT的token认证实现)
热门推荐
shuux666的博客
03-12 2万+
文章目录 一、JWT是什么？ 二、使用步骤 1.项目结构 2.相关依赖 3.数据库 4.相关代码 三、测试结果 一、JWT是什么？ 在介绍JWT之前，我们先来回顾一下利用token进行用户身份验证的流程： 1、客户端使用用户名和密码请求登录 2、服务端收到请求，验证用户名和密码 3、验证成功后，服务端会签发一个token，再把这个token返回给客户端 4、客户端收到token后可以把它存储起来，比如放到cookie中 5、客户端每次向服务端请求资源时需要携带服务端签发的token，可以在co
【JWT】整合JWT权限校验，登录成功生成token
四季轮换叶，一路招摇胜
10-07 2305
整合JWT权限校验，登录成功生成token
JWT主动校验Token是否过期
詹Sir的博客
08-04 5123
JSON Web Token(简称 JWT)是目前最流行的跨域认证解决方案
基于JWT实现简单的用户登陆验证（超详细）
weixin_47025166的博客
06-20 8618
基于JWT实现简单的用户登陆验证
【springboot】jwt实现token验证
lorogy的博客
01-08 941
什么是jwt Json web token (JWT)，用于进行身份验证，开销小，适用于单点登录。优点是token是以json加密的形式保存在客户端的，跨语言；能将用户需要的所有信息都加密到token里，不用多次查询数据库；不用在服务端保存会话信息，适用于分布式微服务。 用户使用账密发送post请求 服务器使用私钥创建jwt（生成签名） 服务器返回这个jwt给浏览器 浏览器将该jwt加在之后所有请求的请求头中 服务器拦截请求验证jwt（校验token） 验证通过则返回响应信息给浏览器 jwt构成： 头
JWT Token验证技术介绍
03-03
5. 服务器在接收到请求时，验证 JWT 的签名并检查载荷中的信息是否与所需的一致。如果验证成功，服务器会处理请求。 JWT 的优点是： 1. 轻量级和简单：JWT 以 JSON 格式编码，易于理解和实现。 2. 安全性：使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值