SpringSecurity和JWT实现认证和授权

最新推荐文章于 2024-06-07 17:24:08 发布
最新推荐文章于 2024-06-07 17:24:08 发布
阅读量1k 收藏 6
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43297252/article/details/106725334
版权

SpringSecurity

SpringSecurity是一个强大的可高度定制的认证和授权框架，对于Spring应用来说它是一套Web安全标签。SpringSecurity注重于Java应用提供认证和授权功能，像所有的Spring项目一样，它对自定义需求具有强大的扩展性。

JWT

JWT是JSON WEB TOKEN的缩写，它是基于RFC 7519标准定义的一种可以安全传输的JSON对象，由于使用了数字签名，所以是可信任和安全的。

JWT的组成

JWT token的格式：header.payload.singatue

  1. head中用于存放签名的生成算法
    {"alg":"HS512"}
  2. payload中用于存放用户名、token的生成时间和过期时间
    {"sub":"admin","created":1489079981339,"exp":1489684155}
  3. signature为以header和payload生产的签名，一旦header和payload被篡改，验证将失败
    {"sub":"admin","created":1489079981339,"exp":1489684155}

JWT实现认证和授权的原理

  1. 用户调用登录接口，登录成功后获取JWT的Token
  2. 之后用户每次调用接口都在http的header中添加一个叫Authorization的头，值为JWT的token
  3. 后台程序通过对Authorization头中信息的解码及数字签名校验来获取其中的用户信息，从而实现认证和授权。

JWT的工作流程

  1. 用户导航到登录页面，输入用户名和密码进行登录
  2. 服务器在验证登录授权，如果用户合法，则会根据用户的信息和服务器所定义好的规则生成JWT Token
  3. 服务器将该Token以JSON的格式进行返回
  4. 用户得到Token后，存储在localStorage或者以其它的数据格式存储
  5. 以后用户每次请求时，需要在请求的header中加入Authorization：Bearer token
  6. 服务器对Token进行校验，合法就解析其中的内容，然后根据拥有的权限和业务逻辑给出对应的响应结果
  7. 用户注销后，令牌将在客户端进行销毁，不需要与服务器进行交互。

Authentication和Authorization的区别：

Authentication：用户认证，应用程序通过帐号和密码确认用户

Authorization：授权，在用户确认身份之后提供权限，比如管理员可以修改数据，其它用户只允许阅读数据

基于SpringSecurity与JWT Token的使用

下载地址: https://gitee.com/zhou_yunong/mall-learning.git

项目使用表说明

  1. ums_admin：后台用户表
  2. ums_role：后台用户角色表
  3. ums_permission：后台用户权限表
  4. ums_admin_role_relation：后台用户和角色关系表，用户与角色是多对多关系
  5. ums_role_permission_relation：后台用户角色和权限关系表，角色与权限是多对多关系
  6. ums_admin_permission_relation：后台用户和权限关系表(除角色中定义的权限以外的加减权限)，加权限是指用户比角色多出的权限，减权限是指用户比角色少的权限

所需要的表说明

  1. JwtTokenUtil（JWT Token生成工具类）
@Component
public class JwtTokenUtil {
    //定义Log4J文件
    private static final Logger LOGGER = LoggerFactory.getLogger(JwtTokenUtil.class);
    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";


    //JWT密钥
    @Value("${jwt.secret}")
    private String secret;

    //JWT的过期时间
    @Value("${jwt.expiration}")
    private Long expiration;

    /**
     * 根据负责生成JWT的Token
     */
    private String  generateToken(Map<String,Object> claims) {
        return Jwts.builder()
                .setClaims(claims)                                  //自定义属性
                .setExpiration(generateExpirationDate())            //过期时间
                .signWith(SignatureAlgorithm.HS512,secret)          //签名算法和密匙
                .compact();
    }

    /**
     * 从Token中获取到JWT的负载，解析JWT
     * @param token
     * @return
     */
    private Claims getClaimsFromToken(String token) {
        //相当于一个Map,包含了我们所需要的信息
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    //设置签名的密钥
                    .setSigningKey(secret)
                    //设置需要解析的Token
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            LOGGER.info("JWT格式验证失败:{}",token);
        }
        /**
         * sub（用户名）、created（创建时间、exp（过期时间）
         * 解析结果：
         *  sub：admin
         *  created：1696877941
         *  exp：1482169527
         */
        return claims;
    }

    /**
     * 生成Token的过期时间
     * @return
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /**
     * 从token当中获取登录的用户名
     * @param token
     * @return
     */
    public String getUserNameFromToken(String token) {
        String userName;
        try {
            Claims claims = getClaimsFromToken(token);
            userName = claims.getSubject();
        } catch (Exception e) {
            userName = null;
        }
        return userName;
    }

    /**
     * 验证Token是否还有效
     * @param token         客户端传递过来的Token
     * @param userDetails   从数据库中查询用户的信息
     * @return
     */
    public Boolean validateToken(String token, UserDetails userDetails) {
        String userName = getUserNameFromToken(token);
        return userName.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

    /**
     * 判断token是否失效
     * @param token
     * @return
     */
    private Boolean isTokenExpired(String token) {
        Date expireDate = getExpiredDateFromToken(token);
        //Token有效期小于当前时间返回TRUE（未过期）,大于等于返回FALSE（已过期）
        return expireDate.before(new Date());
    }

    /**
     * 从Token当中获取过期的时间
     * @param token
     * @return
     */
    private Date getExpiredDateFromToken(String token) {
        Claims claims = getClaimsFromToken(token);
        return claims.getExpiration();
    }

    /**
     * 根据用户信息生成Token
     * @param userDetails
     * @return
     */
    public String generateToken(UserDetails userDetails) {
        Map<String,Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME,userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED,new Date());
        return generateToken(claims);
    }


    /**
     * 判断token是否可以被刷新
     */
    public boolean canRefresh(String token) {
        return !isTokenExpired(token);
    }

    /**
     * token刷新
     * @param token
     * @return
     */
    public String refreshToken(String token) {
        Claims claims = getClaimsFromToken(token);
        claims.put(CLAIM_KEY_CREATED,new Date());
        return generateToken(claims);
    }
}
  1. SpringSecurity的配置
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UmsAdminService umsAdminService;

    //当用户没有访问权限时的处理器，用于返回JSON格式的处理结果
    @Autowired
    private RestfulAccessDeniedHandler restfulAccessDeniedHandler;

    //当未登录或Token失效时，返回JSON格式的结果
    @Autowired
    private RestAuthenticationEntryPoint restAuthenticationEntryPoint;

    /**
     * 用于配置需要拦截的URL路径、JWT过滤器及出异常后的处理器
     * @param httpSecurity
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        //由于使用的是JWT,所以不需要csrf跨域
        httpSecurity.csrf()
                .disable()
                //基于Token，因为不需要Session
                .sessionManagement()
                //SessionCreationPolicy用于管理Session的创建策略
                //SpringSecurity永远不创建Session,不使用Session获取SecurityContext
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                //用于授权，可开放什么路径,什么资源
                .authorizeRequests()
                .antMatchers(HttpMethod.GET,    //允许对于网站静态资源的无授权访问
                        "/",
                        "/*.html",
                        "/favicon.ico",
                        "/**/*.html",
                        "/**/*.css",
                        "/**/*.js",
                        "/swagger-resources/**",
                        "/v2/api-docs/**"
                )
                .permitAll()
                //登录注册允许匿名访问，不做权限
                .antMatchers("/admin/login","/admin/register")
                .permitAll()
                //在跨域请求会先进行一次options请求（开放）
                .antMatchers(HttpMethod.OPTIONS)
                .permitAll()
                //测试时全部运行访问
//                .antMatchers("/**")
//                .permitAll()
                //除了上面的所有请求均需要授权认证
                .anyRequest()
                .authenticated();
        //禁用缓存
        httpSecurity.headers().cacheControl();
        //添加JWT filter
        httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        //添加自定义未授权和未登录结果返回
        httpSecurity.exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler)
                .authenticationEntryPoint(restAuthenticationEntryPoint);

    }

    /**
     * 用于配置UserDetailService和PasswordEncode
     * @param auth
     * @throws Exception
     */
    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService())
                .passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }


    @Bean
    public UserDetailsService userDetailsService() {
        //获取登录的用户信息
        return username -> {
            UmsAdmin admin = umsAdminService.getAdminByUsername(username);
            if (admin != null) {
                List<UmsPermission> permissionList = umsAdminService.getPermissionList(admin.getId());
                return new AdminUserDetails(admin,permissionList);
            }
            throw new UsernameNotFoundException("用户名或者密码输入错误");
        };
    }

    /**
     * 在用户名和密码校验前添加的过滤器，如果有jwt的Token，会自动根据token信息进行登录
     * @return
     */
    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter() {
        return new JwtAuthenticationTokenFilter();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}
  1. JwtAuthenticationTokenFilter（JWT登录授权器，每次登录都会请求这个类）
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.tokenHead}")
    private String tokenHead;


    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        //获取Bearer -- Token
        String authHeader = request.getHeader(this.tokenHeader);
        if (authHeader != null && authHeader.startsWith(this.tokenHead)) {
            String authToken = authHeader.substring(this.tokenHead.length());
            String username = jwtTokenUtil.getUserNameFromToken(authToken);
            log.info("checking username:{}",username);
            //当token的username不为空是进行验证token是否为有效的token
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                //从数据库得到带有密码完整的user信息
                UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
                //判断Token是否有效
                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(userDetails,null,userDetails.getAuthorities());
                    authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    log.info("authenticated user:{}",username);
                    //设置用户登录状态
                    SecurityContextHolder.getContext().setAuthentication(authenticationToken);
                }
            }
        }
        chain.doFilter(request,response);
    }
}
  1. RestAuthenticationEntryPoint（未登录或Token访问失效时，自定义返回结果）
@Component
public class RestAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        response.getWriter().println(JSONUtil.parse(CommonResult.unauthorized(authException.getMessage())));
        response.getWriter().flush();
    }
}
  1. RestfulAccessDeniedHandler（当所访问的接口没有权限时，自定义返回结果）
@Component
public class RestfulAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request,
                       HttpServletResponse response,
                       AccessDeniedException e) throws IOException, ServletException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        response.getWriter().println(JSONUtil.parse(CommonResult.forbidden(e.getMessage())));
        response.getWriter().flush();
    }
}
  1. AdminUserDetails（从Security获取用户数据）
public class AdminUserDetails implements UserDetails {
    private UmsAdmin umsAdmin;
    private List<UmsPermission> permissionList;
    public AdminUserDetails(UmsAdmin umsAdmin, List<UmsPermission> permissionList) {
        this.umsAdmin = umsAdmin;
        this.permissionList = permissionList;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        //返回当前用户的权限
        return permissionList.stream()
                .filter(permission -> permission.getValue()!=null)
                .map(permission ->new SimpleGrantedAuthority(permission.getValue()))
                .collect(Collectors.toList());
    }

    @Override
    public String getPassword() {
        return umsAdmin.getPassword();
    }

    @Override
    public String getUsername() {
        return umsAdmin.getUsername();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return umsAdmin.getStatus().equals(1);
    }

}
  1. Application.yml（自定义JWT的Key）
#自定义jwt Key
jwt:
  tokenHeader: Authorization  #JWT存储的请求头
  secret: mySecret            #JWT加解密所使用的密钥
  expiration: 604800          #JWT的超期限时间(60*60*24)
  tokenHead:  Bearer          #JWT负载中拿到开头
  1. Swagger2配置（自动记住Authorization令牌）
/**
 * Swagger2API文档的配置
 */
@Configuration
@EnableSwagger2
public class Swagger2Config {
    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                //为当前包下controller生成API文档
                .apis(RequestHandlerSelectors.basePackage("com.mall.tiny.controller"))
                //为有@Api注解的Controller生成API文档
//                .apis(RequestHandlerSelectors.withClassAnnotation(Api.class))
                //为有@ApiOperation注解的方法生成API文档
//                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
                .paths(PathSelectors.any())
                .build()
                //添加登录认证
                .securitySchemes(securitySchemes())
                .securityContexts(securityContexts());
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("SwaggerUI演示")
                .description("mall-tiny")
                .contact("macro")
                .version("1.0")
                .build();
    }

    private List<ApiKey> securitySchemes() {
        //设置请求头信息
        List<ApiKey> result = new ArrayList<>();
        ApiKey apiKey = new ApiKey("Authorization", "Authorization","header");
        result.add(apiKey);
        return result;
    }

    private List<SecurityContext> securityContexts() {
        //设置需要登录认证的路径
        List<SecurityContext> result = new ArrayList<>();
        result.add(getContextByPath("/brand/.*"));
        return result;
    }

    private SecurityContext getContextByPath(String pathRegex){
        return SecurityContext.builder()
                .securityReferences(defaultAuth())
                .forPaths(PathSelectors.regex(pathRegex))
                .build();
    }

    private List<SecurityReference> defaultAuth() {
        List<SecurityReference> result = new ArrayList<>();
        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
        authorizationScopes[0] = authorizationScope;
        result.add(new SecurityReference("Authorization", authorizationScopes));
        return result;
    }
}
  1. 给需要调用的接口添加访问权限
    1、给查询接口添加pms:brand:read权限
    2、给修改接口添加pms:brand:update权限
    3、给删除接口添加pms:brand:delete权限
    4、给添加接口添加pms:brand:create权限
@PreAuthorize("hasAuthority('pms:brand:read')")

认证与授权流程演示地址和所作笔记来源

链接: mall-learing.

周雨雨雨雨农
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
整合SpringSecurity和JWT实现登录认证和授权
Java升级之路的博客
09-07 4325
文章目录前言一、SpringSecurity是什么？二、JWT是什么？1. JWT的组成2. JWT实现认证和授权的原理三、整合步骤1. 引入相关依赖2. yml配置中加入jwt配置信息3. 添加JWT token的工具类4. 添加SpringSecurity的配置类5. 添加自定义结果处理类5.1 添加CustomAccessDeniedHandler5.2 添加CustomAuthenticationEntryPoint6. 添加JwtUser类7. 添加过滤器JwtAuthenticationTok
解析SpringSecurity+JWT认证流程实现
08-18
SpringSecurity+JWT认证流程实现是认证流程中的一种重要方式，它可以帮助我们实现安全的认证和授权。通过使用SpringSecurity+JWT，我们可以实现基于token的认证方式，以便更好地保护我们的系统。 七、参考资料 * ...
SpringSecurity JwtAuthenticationTokenFilter过滤器
weixin_46256404的博客
11-15 3736
SpringSecurity JwtAuthenticationTokenFilter过滤器
SpringSecurity定义、配置JWT的过滤器(重要)
最新发布
weixin_52861960的博客
06-07 512
SpringSecurity定义、配置JWT的过滤器(重要)
JWT token 相关配置 (全局配置 身份认证 重写Authenticate方法)
weixin_69282446的博客
04-27 1780
文章目录一. jwt 全局配置 判断用户是否登录1.settings配置二. 配置jwt过期时间 自定义返回的json数据1.utils.py函数编写,返回指定格式的json数据2.settings配置三. 配置django的认证后端 目的是只让管理员登录 自定义一个认证类 重写Authenticate方法1.utils.py类编写 重写Authenticate方法2.settings配置四. 路由配置五. 模型类1.models.py里定义用户类2.settings配置3 添加测试数据 一.
05 【若依框架解读】登录认证JWTtoken验证机制
热门推荐
kouryoushine的博客
12-06 2万+
背景 今天讲下若依框架对于登录认证方面的实现，这个方面若依做的不算太好，如果项目中想用的话需要参考其他框架的实现，做的更好一些。 我建议是前后端放在一起来看，单纯看后端会比较无趣。 后端部分 /login 接口 userName password code 验证码 前端获取上面三个要素后调用接口，整体改接口做了下面几件事情 验证用户身份（账号密码+验证码） 生成token 保存用户登录态到spring security中 安全配置：定义了基本的配置信息 framework.config.Securi
Spring Security采用JWT验证时filter异常处理和JWT续期问题
hey_lie的博客
11-03 2101
1.spring security JWT过滤器异常自定义处理 2.spring security 认证和授权时的异常自定义处理 3.JWT 续期问题
springboot+springSecurity+jwt实现登录认证后令牌授权
09-12
在这个项目中，我们将探讨如何利用Spring Boot、Spring Security和JWT来实现登录认证后的令牌授权。 首先，让我们从Spring Boot开始。Spring Boot简化了Spring应用的初始搭建以及开发过程。通过提供默认配置，它极...
SpringSecurity之JWT实现token认证和授权.zip
08-09
在这个主题中，我们将深入探讨如何使用Spring Security结合JSON Web Token (JWT) 实现token认证和授权。 JWT 是一种轻量级的、安全的、无状态的身份验证机制，常用于API的鉴权。它通过在客户端和服务器之间传递令牌...
Springboot+SpringSecurity+JWT实现用户登录和权限认证示例
08-19
7. **Spring Security配置**：配置Spring Security以启用JWT认证，设置访问控制规则，例如哪些URL需要认证，哪些URL对所有用户开放。 8. **认证Controller**：创建一个专门处理用户登录请求的Controller，接收登录...
spring Security jwt授权和认证.rar
06-13
下载可以直接运行。使用mysql保存数据。包括数据文件、测试过可以正常使用（API权限可控） 请地址是POST:http://localhost:8080/api/login JSON参数：{ "username":"user1", "password":"123456" }
Java JWT: JSON Web Token
weixin_33730836的博客
06-17 811
  Java JWT: JSON Web Token for Java and Android JJWT aims to be the easiest to use and understand library for creating and verifying JSON Web Tokens (JWTs) on the JVM. JJWT is a Java implementation...
Spring Boot 4 实现JwtToken验证(重点)&&实现后端API(重点)&&前端：实现注册与登录模块(略)
qq_52384627的博客
08-18 399
1.实现JwtToken验证 1.1添加依赖 1.2 编写、修改相关类 1.2.1实现 JwtUtil 类 1.2.2实现 JwtAuthenticationTokenFilter 类 1.2.3 配置config.SecurityConfig类 2.实现后端API 2.1 修改数据库 2.2实现接口API 实现LoginService 实现InfoService 实现RegisterService 前端调试 3. 实现前端的登陆、注册界面（略）.........
关于Authentication（认证）和Authorization（授权）及Session、Cookie、Token、JWT的一点总结
weixin_42583145的博客
07-06 2995
1.认证 (Authentication) 和授权 (Authorization)的区别 Authentication(认证) 是验证身份的凭据，如用户名/密码等 Authorization（授权） 在Authentication之后，主要用来授权，特定的人才能访问特定的资源，如有些资源的删除、更新操作只对管理员开放。 一般在系统中结合两者使用，保证系统的安全性。 2.什么是Cookie？ Cookies是某些网站为了辨别用户身份而储存在用户本地终端上的数据（通常经过加密）。简单来说： Cookie 存
jwt+token验证
qq_51127361的博客
09-19 1882
导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId
Token 与 JWT认证
Waller_的博客
02-21 528
为什么用Token 先了解身份验证的演变: 随着交互式Web应用的兴起，像在线购物网站，需要登录的网站等等,遇到的一个问题就是身份验证会话管理,必须记住登录的用户,也就是必须吧每个用户区分开,因为HTTP请求是无状态的,所以解决办法就是给每个人发送一个回话标识(sessionid)随机字符串,每次大家向我发起HTTP请求的时候，把这个字符串给一并捎过来， 这样我就能区分开谁是谁了. 这样就产...
【SpringSecurity+JWT】实现前后端分离认证授权
hupengfei_shenyang的博客
07-03 922
SpringSecurity + JWT 认证授权
SpringSecurity +Jwt 实现权限管理
xiuyuandashen的博客
03-31 778
目录标题原理架构图demo的项目结构JwtTokenUtilRestAuthenticationEntryPoint 和 RestfulAccessDeniedHandlerMyUserDetailsServiceJwtAuthenticationTokenFilterSecurityConfigControllerPostman 测试 原理架构图 demo的项目结构 JwtTokenUtil : JwtToken生成的工具类 RestAuthenticationEntryPoint : 当未登录或
SpringSecurity+JWT快速入门
胡云峰的博客
01-02 4558
SpringSecurity+JWT快速入门
用SpringSecurity和JWT实现单点登录
04-22
在Spring Security的配置文件中，实现认证和授权的相关配置，包括用户信息的获取和校验、角色的定义和权限的配置等。 3. 实现JWT的生成和校验 在认证成功后，生成JWT令牌，包括签名、过期时间和用户信息等。在后续...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值