【三】springboot整合token

已于 2024-03-10 20:46:47 修改
阅读量1.7w 收藏 232
点赞数 72
分类专栏： My Springboot Study Note 文章标签： spring boot java spring
于 2021-09-03 10:44:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56995925/article/details/120075631
版权

互相交流入口地址 

整体目录：

【一】springboot整合swagger

【二】springboot整合自定义swagger

【三】springboot整合token

【四】springboot整合mybatis-plus

【五】springboot整合mybatis-plus

【六】springboot整合redis

【七】springboot整合AOP实现日志操作

【八】springboot整合定时任务

【九】springboot整合redis实现启动服务时热点数据保存在全局和缓存

【十】springboot整合quartz实现定时任务优化

【十一】springboot整合异步调用并获取返回值

【十二】springboot整合WebService

【十三】springboot整合WebService关于传参数

【十四】springboot整合WebSocket

【十五】springboot整合WebSocket实现聊天室

【十六】RabbitMQ基础篇（下载安装并基础使用，内含各种坑问题）

【十七】RabbitMQ基础篇（延迟队列和死信队列实战）

【十八】springboot实现自定义全局异常处理

【十九】初学Kafka并实战整合SpringCloudStream进行使用

【二十】springboot整合ElasticSearch实战（万字篇）

【二十一】springboot整合过滤器实战

【二十二】springboot整合拦截器实战并对比过滤器

【二十三】springboot整合activiti7（1）实战演示篇

【二十四】springboot整合spring事务详解以及实战

【二十五】springboot使用EasyExcel和线程池实现多线程导入Excel数据

【二十六】springboot整合jedis和redisson布隆过滤器处理缓存穿透

【二十七】springboot实现多线程事务处理

【二十八】springboot之threadLocal参数解析器实现session一样保存当前登录功能 

【二十九】springboot整合logback实现日志管理

【三十】springboot项目上高并发解决示例

目录

第一步：新增依赖（在pom文件增加） 

第二步：新增配置类

第三步：新增token工具类（用来生成token以及效验token） 

第四步：改造登陆接口

第五步：演示结果

介绍：接下来我会把学习阶段学到的框架等知识点进行整合，每一次整合是在前一章的基础上进行的，所以后面的整合不会重复放前面的代码。每次的demo我放在结尾，本次是接着上一章的内容延续的，只增加新增的或者修改的代码。

整合token，每次请求接口时进行token效验，效验通过才可以请求到接口，我是通过jwt生成的token。token个人理解大概就是用来判断用户登录状态，是否已登录的。

        首先展示一下目录结构，是根据前面几章进行的增加（原因：内容过多），如下：

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5bCPeuKZgA==,size_20,color_FFFFFF,t_70,g_se,x_16​

第一步：新增依赖（在pom文件增加） 

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--swagger        -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--swagger-ui.html模式        -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--doc.html模式        -->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.auth0/java-jwt -->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.9.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.json/json -->
        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20190722</version>
        </dependency>
    </dependencies>

        其实就增加了jwt和json两个依赖。

第二步：新增配置类

TokenInterceptor类（拦截器）：
@Component
public class TokenInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //跨域请求会首先发一个option请求，直接返回正常状态并通过拦截器
        if(request.getMethod().equals("OPTIONS")){
            response.setStatus(HttpServletResponse.SC_OK);
            return true;
        }
        response.setCharacterEncoding("utf-8");
        String token = request.getHeader("token");
        if (token!=null){
            boolean result= TokenUtils.verify(token);
            if (result){
                System.out.println("通过拦截器");
                return true;
            }
        }
        response.setContentType("application/json; charset=utf-8");
        try {
            JSONObject json=new JSONObject();
            json.put("msg","token verify fail");
            json.put("code","500");
            response.getWriter().append(json.toString());
            System.out.println("认证失败，未通过拦截器");
        } catch (Exception e) {
            return false;
        }
        /**
         * 还可以在此处检验用户存不存在等操作
         */
        return false;
    }
}
PS：此处token从request里面获取header里面的key值是token，你要根据自己的情况来，你在前端header里面传的token叫什么名称，这里就取什么名字。 
WebConfiguration类(配置拦截器)：
@Configuration
public class WebConfiguration implements WebMvcConfigurer {

    @Autowired
    private TokenInterceptor tokenInterceptor;

    /**
     * 解决跨域请求
     * @param registry
     */
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedHeaders("*")
                .allowedMethods("*")
//                .allowedOrigins("*")
                .allowedOriginPatterns("*")
                .allowCredentials(true);
    }

    /**
     * 异步请求配置
     * @param configurer
     */
    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        configurer.setTaskExecutor(new ConcurrentTaskExecutor(Executors.newFixedThreadPool(3)));
        configurer.setDefaultTimeout(30000);
    }

    /**
     * 配置拦截器、拦截路径
     * 每次请求到拦截的路径，就会去执行拦截器中的方法
     * @param configurer
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        List<String> excludePath = new ArrayList<>();
        //排除拦截，除了注册登录(此时还没token)，其他都拦截
        excludePath.add("/userController/login");  //登录
        excludePath.add("/userController/register");     //注册
        excludePath.add("/doc.html");     //swagger
        excludePath.add("/swagger-ui.html");     //swagger
        excludePath.add("/swagger-resources/**");     //swagger
        excludePath.add("/v2/api-docs");     //swagger
        excludePath.add("/webjars/**");     //swagger
//        excludePath.add("/static/**");  //静态资源
//        excludePath.add("/assets/**");  //静态资源
        registry.addInterceptor(tokenInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns(excludePath);
        WebMvcConfigurer.super.addInterceptors(registry);

    }
}
PS：addInterceptors方法里面需要按自己情况进行修改，excludePath集合add的是需要放行的接口路径，前几章整合了swagger，所以此处需要放行swagger相关的路径，swagger-ui.html、doc.html、swagger-resources、等等，你再加上自己想要放行的接口路径即可，一般是首页请求的接口以及登录注册的接口（不需要进行token效验的接口）。

第三步：新增token工具类（用来生成token以及效验token） 

public class TokenUtils {

    //token到期时间10小时
    private static final long EXPIRE_TIME= 10*60*60*1000;
    //密钥盐
    private static final String TOKEN_SECRET="ljdyaishijin**3nkjnj??";

    /**
     * 生成token
     * @param user
     * @return
     */
    public static String sign(User user){

        String token=null;
        try {
            Date expireAt=new Date(System.currentTimeMillis()+EXPIRE_TIME);
            token = JWT.create()
                    //发行人
                    .withIssuer("auth0")
                    //存放数据
                    .withClaim("username",user.getUserName())
                    //过期时间
                    .withExpiresAt(expireAt)
                    .sign(Algorithm.HMAC256(TOKEN_SECRET));
        } catch (IllegalArgumentException|JWTCreationException je) {

        }
        return token;
    }


    /**
     * token验证
     * @param token
     * @return
     */
    public static Boolean verify(String token){

        try {
            //创建token验证器
            JWTVerifier jwtVerifier=JWT.require(Algorithm.HMAC256(TOKEN_SECRET)).withIssuer("auth0").build();
            DecodedJWT decodedJWT=jwtVerifier.verify(token);
            System.out.println("认证通过：");
            System.out.println("username: " + decodedJWT.getClaim("username").asString());
            System.out.println("过期时间：      " + decodedJWT.getExpiresAt());
        } catch (IllegalArgumentException |JWTVerificationException e) {
            //抛出错误即为验证不通过
            return false;
        }
        return true;
    }

}
PS：此处到期时间可以自定义按情况进行设置，1000是1秒。此处token的生成方法以及效验方法可以根据具体情况进行更改，生成token1是使用的jwt，此处验证方法存在一个用户有多个token的情况（可以同时多次登陆同一账号，重新请求token之后，前一次的token只要没有过期也能使用。），可以整合redis后进行改造（后面会讲到），可以达到一个用户只有一个token的效果（重新请求token之后，前一次的token即使没有过期也不能使用。）

第四步：改造登陆接口

@ApiOperation(value = "登录")
    @GetMapping("/login")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "userName", value = "用户名", paramType = "String"),
            @ApiImplicitParam(name = "passWord", value = "密码", paramType = "String")
    })
    public BaseResponse<HashMap> login(@RequestParam(value = "userName") String userName, @RequestParam(value = "passWord") String passWord) throws JsonProcessingException {
        //包装token
        User user = new User();
        user.setUserName(userName);
        user.setPassword(passWord);
        String token= TokenUtils.sign(user);
        HashMap<String,Object> hs=new HashMap<>();
        hs.put("token",token);
        return RespGenerator.returnOK(hs);
    }
PS：可以根据自己的情况包装数据作为登录请求的返回结果。

第五步：演示结果

        1、当请求没有放行的接口不带token请求时： 

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5bCPeuKZgA==,size_20,color_FFFFFF,t_70,g_se,x_16​

        结果：会提示token效验失败。

        2、当请求放行的接口不带token请求时：

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5bCPeuKZgA==,size_20,color_FFFFFF,t_70,g_se,x_16​

        结果：成功请求到接口，此处是登陆接口，返回了token。

        3、当请求没有放行的接口带token请求时： 

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5bCPeuKZgA==,size_20,color_FFFFFF,t_70,g_se,x_16​

         结果：成功请求到接口。

本期整合到此完毕，接下来会继续更新加强整合，尽情期待。

访问地址：http://localhost:8085/swagger-ui.html或者http://localhost:8085/doc.html

小z♂
关注
  • 72
    点赞
  • 踩
  • 232
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 28
    评论
专栏目录
springboot整合token的实现代码
08-25
Spring Boot整合Token实现代码详解 在本文中，我们将详细介绍Spring Boot整合Token的实现代码，包括 TokenUtil.java 的实现、 token 生成和解析、Redis 的使用等。下面是相关知识点的总结： 1. Token 的概念： ...
Spring boot 入门教程-token验证
a369966697的博客
03-31 1180
面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。机会都是留给有准备的人，只有充足的准备，才可能让自己可以在候选人中脱颖而出。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！” />面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。
【SpringBoot】1、SpringBoot整合JWT实现Token验证
qq_24099547的博客
04-10 7811
单点登录
双Token方案实现Token自动续期（基于springboot+vue前后端分离项目）
最新发布
qq_44286009的博客
06-10 1758
jwt理论介绍springboot+vue项目中使用jwt实现登录认证本篇文章的代码是在springboot+vue项目中使用jwt实现登录认证的基础上实现的Token自动续期的功能。双token解决方案是一种用于增强用户登录安全性和提升用户体验的认证机制。它主要涉及两个令牌：访问令牌（accessToken）和刷新令牌（refreshToken）。
springboot中使用token
Cidaren的博客
07-15 1万+
1. pom.xml文件中添加依赖 <!-- 引入操作JWT的相关依赖 --> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.11.0</version> </dependency> 除此依赖之外还需要添加springbootweb的起步依赖，以及使用的数据库依赖 2. 定
深入了解Token认证的来龙去脉
zyh568879280的博客
02-15 473
转载至：https://blog.csdn.net/niugang0920/article/details/80615137 Token 是在服务端产生的，如果前端使用用户名/密码向服务端请求认证，服务端认证成功，那么在服务端会返回 Token 给前端。前端可以在每次请求的时候带上 Token 证明自己的合法地位。     不久前，我在前后端分离实践中提到了基于 Token 的认证，现在我...
SpringBoot集成JWT实现Token登录验证
Young_深情不及里子的博客
11-25 1万+
JSON Web令牌(JWT)是一种开放的标准(RFC 7519)，它定义了一种紧凑而独立的方式在各方之间安全地传输信息为JSON对象。学习总结一下SpringBoot整合JWT的登录token验证，简单易理解哦~
SpringBoot项目使用JWT+拦截器实现token验证
weixin_44320429的博客
10-18 1万+
上述流程当中token的具体实现方式为JWT，其全称是，官网地址：https://jwt.io/就是通过JSON形式作为Web应用中的令牌,用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。通俗地说，JWT的本质就是一个字符串，它是将用户信息保存到一个Json字符串中，然后进行编码后得到一个JWT token，并且这个JWT token带有签名信息，接收后可以校验是否被篡改，所以可以用于在各方之间安全地将信息作为Json对象传输。
springboot之token的用法总结
热门推荐
east123321的博客
04-03 1万+
一、 token的构造    token是又header（头）、payload（荷载）、sign（签名）三部分组成。    header：头部信息主要包括（参数的类型--JWT,签名的算法--HS256）    payload：存放自己想要的信息        sign：是为了防止恶意篡改数据二、JWT的生成和解析生成：String token=JavaWebTokenUtil.createJWT...
SpringBoot框架集成token实现登录校验功能
08-25
3. 编写token的三个方法：创建、查询、修改token，使用MyBatis框架来实现数据库的增删改操作。 4. 创建拦截器：创建一个拦截器，用于拦截用户的请求，检查token的合法性，如果token为空或错误，则让其登录，如果...
基于SpringBoot整合oauth2实现token认证
08-25
基于SpringBoot整合oauth2实现token认证 本文主要介绍了基于SpringBoot整合oauth2实现token认证的技术，通过示例代码对该技术进行了详细的介绍，对读者学习或工作具有重要参考价值。 SpringBoot和oauth2的整合 在...
Springboot整合Shiro的代码实例
08-25
Springboot 整合 Shiro 的代码实例 Springboot 整合 Shiro 的代码实例是指在 Springboot 项目中集成 Shiro 框架来实现身份验证和授权管理的过程。Shiro 是一个功能强大且灵活的身份验证和授权框架，可以帮助开发者...
SpringBoot(51) 整合Sa-Token实现权限认证
08-17
SpringBoot(51) 整合Sa-Token实现权限认证
SpringBoot（九）jwt + 拦截器实现token验证
zhaojun的博客
07-31 7946
前面两篇文章的过滤器和拦截器，我们都提到过可以做诸如权限验证的事情。http/https是无状态的协议，当用户访问一个后端接口时，如何判断该用户有没有权限？当然，可以使用账号+密码去验证。但是，如果使用账号和密码，需要频繁访问数据库，很明显，会带来一些额外的开销。本篇介绍下使用jwt和拦截器实现token权限验证。
springboot整合jwt实现token，简明笔记
学习，是熵减的最有效途径。
06-21 2571
一篇搞定springboot整合jwt实现token
Springboot集成JWT，用户名，密码生成token
administratop的博客
11-11 1970
基于标准化:你的API可以采用标准化的 JSON Web Token (JWT). 这个标准已经存在多个后端库（.NET, Ruby,更适用于移动应用: 当你的客户端是一个原生平台（iOS, Android，Windows 8等）时，Cookie是不被支持的。更适用CDN: 可以通过内容分发网络请求你服务端的所有资料（如：javascript，HTML,图片等），而你的服。支持跨域访问: Cookie是不允许垮域访问的，这一点对Token机制是不存在的，前提是传输的用户认证信息通。务端只要提供API即可.
SpringBoot实现token登录
m0_52012606的博客
03-23 9472
在进行登录验证时，我们需要session或cookie会话进行验证，客户端包括浏览器、app、微信小程序、公众号，只有浏览器有session和cookie机制，当我们脱离浏览器用app等向服务端发请求就没有session和cookie机制，这时我们就需要使用token令牌进行登录验证。...
springBoot整合jwt实现token令牌认证
weixin_61779644的博客
12-12 559
作为计算机术语时，是“令牌”的意思。Token是服务端生成的一串字符串，以作客户端进行请求的一个令牌，当第一次登录后，服务器生成一个Token便将此Token返回给客户端，以后客户端只需带上这个Token前来请求数据即可，无需再次带上用户名和密码。实施 Token 验证的方法挺多的，还有一些标准方法，比如 JWT，读作：jot ，表示：JSON Web Tokens。在这里我定义的签名是静态变量 可以根据自己需求来定义 这里的id是从数据库里面拿到的 这里的验证token符合的话就放行，否则就抛异常。
SpringBoot基于token的请求验证
一路向北的博客
09-09 4623
SpringBoot实现基于Token的请求验证
springboot整合token认证
07-27
Spring Boot提供了多种方式来实现Token认证，下面是一种基本的实现方式： 首先，在pom.xml文件中添加Spring Security和JWT依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency> ``` 接下来，创建一个JWTUtil类，用于生成和解析Token： ```java import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; import java.util.Date; @Component public class JWTUtil { @Value("${jwt.secret}") private String secret; @Value("${jwt.expiration}") private Long expiration; public String generateToken(String username) { Date now = new Date(); Date expireDate = new Date(now.getTime() + expiration * 1000); return Jwts.builder() .setSubject(username) .setIssuedAt(now) .setExpiration(expireDate) .signWith(SignatureAlgorithm.HS512, secret) .compact(); } public String getUsernameFromToken(String token) { Claims claims = Jwts.parser() .setSigningKey(secret) .parseClaimsJws(token) .getBody(); return claims.getSubject(); } public boolean validateToken(String token, String username) { String tokenUsername = getUsernameFromToken(token); return tokenUsername.equals(username) && !isTokenExpired(token); } private boolean isTokenExpired(String token) { Date expirationDate = Jwts.parser() .setSigningKey(secret) .parseClaimsJws(token) .getBody() .getExpiration(); return expirationDate.before(new Date()); } } ``` 然后，创建一个JwtAuthenticationFilter类，用于处理Token认证： ```java import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.Authentication; import org.springframework.security.core.AuthenticationException; import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter; import org.springframework.security.web.util.matcher.AntPathRequestMatcher; import javax.servlet.FilterChain; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; public class JwtAuthenticationFilter extends AbstractAuthenticationProcessingFilter { private final JWTUtil jwtUtil; public JwtAuthenticationFilter(AuthenticationManager authenticationManager, JWTUtil jwtUtil) { super(new AntPathRequestMatcher("/api/login", "POST")); setAuthenticationManager(authenticationManager); this.jwtUtil = jwtUtil; } @Override public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException { String username = request.getParameter("username"); String password = request.getParameter("password"); return getAuthenticationManager().authenticate( new UsernamePasswordAuthenticationToken(username, password) ); } @Override protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException { String username = ((UserDetails) authResult.getPrincipal()).getUsername(); String token = jwtUtil.generateToken(username); response.addHeader("Authorization", "Bearer " + token); } } ``` 最后，在SecurityConfig中配置认证： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; 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.crypto.password.PasswordEncoder; @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { private final UserDetailsService userDetailsService; private final PasswordEncoder passwordEncoder; private final JWTUtil jwtUtil; @Autowired public SecurityConfig(UserDetailsService userDetailsService, PasswordEncoder passwordEncoder, JWTUtil jwtUtil) { this.userDetailsService = userDetailsService; this.passwordEncoder = passwordEncoder; this.jwtUtil = jwtUtil; } @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder); } @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable() .authorizeRequests() .antMatchers("/api/login").permitAll() .anyRequest().authenticated() .and() .addFilter(new JwtAuthenticationFilter(authenticationManager(), jwtUtil)); } @Bean public AuthenticationManager authenticationManagerBean() throws Exception { return super.authenticationManagerBean(); } } ``` 以上即为使用Spring Boot整合Token认证的基本步骤。首先，在JWTUtil类中实现Token的生成和解析逻辑，然后通过JwtAuthenticationFilter处理请求中的Token，最后在SecurityConfig中配置认证规则。
评论 28
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小z♂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值