微服务 管理员登录功能实现案例

最新推荐文章于 2023-03-21 20:19:44 发布
最新推荐文章于 2023-03-21 20:19:44 发布
阅读量763 收藏
点赞数
分类专栏： 微服务项目笔记 文章标签： 微服务 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50909707/article/details/124865226
版权

目录

一、添加登录返回数据结构类

二、添加登录的控制器

三、添加登录实现的服务

四、远程调用Feign的类

五、Mapper实现

六、测试访问

一、添加登录返回数据结构类

package com.dragonwu.model;

import com.dragonwu.domain.SysMenu;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.authority.SimpleGrantedAuthority;

import java.util.List;

/**
 * 登录成功的结果
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "登录的结果")
public class LoginResult {
    /**
     * 登录成功的token，来自我们的authorization-server 里面的
     */
    @ApiModelProperty(value = "登录成功的token，来自我们的authorization-server 里面的")
    private String token ;

    /**
     * 该用户的菜单数据
     */
    @ApiModelProperty(value = "该用户的菜单数据")
    private List<SysMenu> menus ;

    /**
     * 该用户的权限数据
     */
    @ApiModelProperty(value = "该用户的权限数据")
    private List<SimpleGrantedAuthority> authorities ;
}

二、添加登录的控制器

package com.dragonwu.controller;

import com.dragonwu.model.LoginResult;
import com.dragonwu.service.SysLoginService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 登录的控制器
 */
@RestController
@Api(tags = "登录的控制器")
public class SysLoginController {

    @Autowired
    private SysLoginService loginService;

    @PostMapping("/login")
    @ApiOperation(value = "后台管理人员登录")
    @ApiImplicitParams(
            {
                    @ApiImplicitParam(name = "username", value = "用户名称"),
                    @ApiImplicitParam(name = "password", value = "用户的密码"),
            }
    )
    public LoginResult login(
            @RequestParam(required = true) String username, // 用户名称
            @RequestParam(required = true) String password  // 用户的密码
    ) {
        return loginService.login(username, password);
    }

}

三、添加登录实现的服务

登录服务

package com.dragonwu.service;

import com.dragonwu.model.LoginResult;

/**
 * 登录的接口
 */
public interface SysLoginService {

    /**
     * 登录的实现
     * @param username
     *  用户名
     * @param password
     *
     * 用户的密码
     * @return
     * 登录的结果
     */
    LoginResult login(String username ,String password) ;
}

实现类

package com.dragonwu.service.impl;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.enums.ApiErrorCode;
import com.baomidou.mybatisplus.extension.exceptions.ApiException;
import com.dragonwu.domain.SysMenu;
import com.dragonwu.feign.JwtToken;
import com.dragonwu.feign.OAuth2FeignClient;
import com.dragonwu.model.LoginResult;
import com.dragonwu.service.SysLoginService;
import com.dragonwu.service.SysMenuService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.jwt.Jwt;
import org.springframework.security.jwt.JwtHelper;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Service
@Slf4j
public class SysLoginServiceImpl implements SysLoginService {

    @Autowired
    private OAuth2FeignClient oAuth2FeignClient;

    @Autowired
    private SysMenuService sysMenuService ;

    @Value("${basic.token:Basic Y29pbi1hcGk6Y29pbi1zZWNyZXQ=}")
    private String basicToken ;

    @Autowired
    private StringRedisTemplate redisTemplate ;
    /**
     * 登录的实现
     *
     * @param username 用户名
     * @param password 用户的密码
     * @return 登录的结果
     */
    @Override
    public LoginResult login(String username, String password) {
        log.info("用户{}开始登录", username);
        // 1 获取token 需要远程调用authorization-server 该服务
        ResponseEntity<JwtToken> tokenResponseEntity = oAuth2FeignClient.getToken("password", username, password, "admin_type", basicToken);
        if(tokenResponseEntity.getStatusCode()!= HttpStatus.OK){
            throw new ApiException(ApiErrorCode.FAILED) ;
        }
        JwtToken jwtToken = tokenResponseEntity.getBody();
        log.info("远程调用授权服务器成功,获取的token为{}", JSON.toJSONString(jwtToken,true));
        String token = jwtToken.getAccessToken() ;

        // 2 查询我们的菜单数据
        Jwt jwt = JwtHelper.decode(token);
        String jwtJsonStr = jwt.getClaims();
        JSONObject jwtJson = JSON.parseObject(jwtJsonStr);
        Long userId = Long.valueOf(jwtJson.getString("user_name")) ;
        List<SysMenu> menus = sysMenuService.getMenusByUserId(userId);

        // 3 权限数据怎么查询 -- 不需要查询的，因为我们的jwt 里面已经包含了
        JSONArray authoritiesJsonArray = jwtJson.getJSONArray("authorities");
        List<SimpleGrantedAuthority> authorities = authoritiesJsonArray.stream() // 组装我们的权限数据
                                                        .map(authorityJson->new SimpleGrantedAuthority(authorityJson.toString()))
                                                        .collect(Collectors.toList());
        // 1 将该token 存储在redis 里面，配置我们的网关做jwt验证的操作
        redisTemplate.opsForValue().set(token,"", jwtToken.getExpiresIn() ,TimeUnit.SECONDS);
        //2 我们返回给前端的Token 数据，少一个bearer：
        return new LoginResult(jwtToken.getTokenType()+" "+token, menus, authorities);
    }
}

系统菜单服务

package com.dragonwu.service;

import com.dragonwu.domain.SysMenu;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.List;

 
public interface SysMenuService extends IService<SysMenu>{
        /**
         * 通过用户的id 查询用户的菜单数据
         * @param userId
         * @return
         */

        List<SysMenu> getMenusByUserId(Long userId);

}

实现类

package com.bjsxt.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.dragonwu.domain.SysMenu;
import com.dragonwu.mapper.SysMenuMapper;
import com.dragonwu.service.SysMenuService;
import com.dragonwu.service.SysRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class SysMenuServiceImpl extends ServiceImpl<SysMenuMapper, SysMenu> implements SysMenuService{

    @Autowired
    private SysRoleService sysRoleService ;

    @Autowired
    private SysMenuMapper sysMenuMapper ;

    /**
     * 通过用户的id 查询用户的菜单数据
     *
     * @param userId
     * @return
     */
    @Override
    public List<SysMenu> getMenusByUserId(Long userId) {
        // 1 如果该用户是超级管理员->>拥有所有的菜单
        if(sysRoleService.isSuperAdmin(userId)){
            return list() ; // 查询所有
        }
        // 2 如果该用户不是超级管理员->>查询角色->查询菜单
        return sysMenuMapper.selectMenusByUserId(userId);
    }

}

角色管理服务

package com.dragonwu.service;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.dragonwu.domain.SysRole;
import com.baomidou.mybatisplus.extension.service.IService;

public interface SysRoleService extends IService<SysRole>{


    /**
     * 判断一个用户是否为超级的管理员
     * @param userId
     * @return
     */
    boolean isSuperAdmin(Long userId);

    /**
     * 使用角色的名称模糊分页角色查询
     * @param page
     * 分页数据
     * @param name
     *  角色的名称
     * @return
     */
    Page<SysRole> findByPage(Page<SysRole> page, String name);

}

实现类

package com.dragonwu.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.dragonwu.domain.SysRole;
//import com.dragonwu.mapper.SysPrivilegeMapper;
import com.dragonwu.mapper.SysRoleMapper;
import com.dragonwu.service.SysRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

//import java.io.Serializable;

@Service
public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> implements SysRoleService {

    @Autowired
    private SysRoleMapper sysRoleMapper;

//    @Autowired
//    private SysPrivilegeMapper sysPrivilegeMapper ;
//
//
//    /**
//     * 根据 ID 查询
//     *
//     * @param id 主键ID
//     */
//    @Override
//    public SysRole getById(Serializable id) {
//        SysRole sysRole = super.getById(id);
//        sysRole.setPrivileges(sysPrivilegeMapper.selectByRoleId(sysRole.getId()));
//        return sysRole;
//    }

    /**
     * 判断一个用户是否为超级的管理员
     *
     * @param userId
     * @return
     */
    @Override
    public boolean isSuperAdmin(Long userId) {
        // 当用户的角色code 为：ROLE_ADMIN 时，该用户为超级的管理员
        // 用户的id->用户的角色->该角色的Code是否为ROLE_ADMIN
        String roleCode = sysRoleMapper.getUserRoleCode(userId);
        if (!StringUtils.isEmpty(roleCode) && roleCode.equals("ROLE_ADMIN")) {
            return true;
        }
        return false;
    }

    /**
     * 使用角色的名称模糊分页角色查询
     *
     * @param page 分页数据
     * @param name 角色的名称
     * @return
     */
    @Override
    public Page<SysRole> findByPage(Page<SysRole> page, String name) {
        return page(page, new LambdaQueryWrapper<SysRole>().like(
                !StringUtils.isEmpty(name),
                SysRole::getName,
                name
        ));
    }
}

四、远程调用Feign的类

package com.dragonwu.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(value = "authorization-server")
public interface OAuth2FeignClient {

    @PostMapping("/oauth/token")
    ResponseEntity<JwtToken> getToken(
            @RequestParam("grant_type") String grantType , // 授权类型
            @RequestParam("username") String username , // 用户名
            @RequestParam("password") String  password , // 用户的密码
            @RequestParam("login_type")  String loginType,  // 登录的类型
            @RequestHeader("Authorization") String basicToken // Basic Y29pbi1hcGk6Y29pbi1zZWNyZXQ= 由第三方客户端信息加密出现的值
    ) ;
}

package com.dragonwu.feign;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;

@Data
public class JwtToken {
    /**
     * access_token
     */
    @JsonProperty("access_token")
    private String accessToken;

    /**
     * token类型
     */
    @JsonProperty("token_type")
    private String tokenType;

    /**
     * refresh_token
     */
    @JsonProperty("refresh_token")
    private String refreshToken;

    /**
     * 过期时间
     */
    @JsonProperty("expires_in")
    private Long expiresIn;


    /**
     * token的范围
     */
    private String scope;

    /**
     * 颁发的凭证
     */
    private String jti;
}

启动类开发Feign调用

@EnableFeignClients

五、Mapper实现

package com.dragonwu.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dragonwu.domain.SysMenu;

import java.util.List;

public interface SysMenuMapper extends BaseMapper<SysMenu> {

    /**
     * 通过用户的id 查询用户的菜单数据
     * @param userId
     * @return
     */
    List<SysMenu> selectMenusByUserId(Long userId);

    /**
     * 使用角色的Id 查询所有菜单列表
     * @param roleId
     * @return
     */
    List<SysMenu> selectMenusByRoleId(Long roleId);
}

SysMenuMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dragonwu.mapper.SysMenuMapper">
  <resultMap id="BaseResultMap" type="com.dragonwu.domain.SysMenu">
    <!--@mbg.generated-->
    <!--@Table sys_menu-->
    <id column="id" jdbcType="BIGINT" property="id" />
    <result column="parent_id" jdbcType="BIGINT" property="parentId" />
    <result column="parent_key" jdbcType="VARCHAR" property="parentKey" />
    <result column="type" jdbcType="TINYINT" property="type" />
    <result column="name" jdbcType="VARCHAR" property="name" />
    <result column="desc" jdbcType="VARCHAR" property="desc" />
    <result column="target_url" jdbcType="VARCHAR" property="targetUrl" />
    <result column="sort" jdbcType="INTEGER" property="sort" />
    <result column="status" jdbcType="TINYINT" property="status" />
    <result column="create_by" jdbcType="BIGINT" property="createBy" />
    <result column="modify_by" jdbcType="BIGINT" property="modifyBy" />
    <result column="created" jdbcType="TIMESTAMP" property="created" />
    <result column="last_update_time" jdbcType="TIMESTAMP" property="lastUpdateTime" />
  </resultMap>
  <sql id="Base_Column_List">
    <!--@mbg.generated-->
    id, parent_id, parent_key, `type`, `name`, `desc`, target_url, sort, `status`, create_by,
    modify_by, created, last_update_time
  </sql>
  <select id="selectMenusByUserId" resultMap="BaseResultMap">
        SELECT
          m.id,
          m.parent_id,
          m.parent_key,
          m.`type`,
          m.`name`,
          m.`desc`,
          m.target_url,
          m.sort,
          m.`status`,
          m.create_by,
          m.modify_by,
          m.created,
          m.last_update_time
        FROM sys_menu as m
                LEFT JOIN sys_role_menu AS rm ON rm.menu_id = m.id
                LEFT JOIN sys_user_role AS ur ON ur.role_id = rm.role_id
        WHERE
		        ur.user_id = #{userId}
  </select>
  <select id="selectMenusByRoleId" resultMap="BaseResultMap">
        SELECT
              m.id,
              m.parent_id,
              m.parent_key,
              m.`type`,
              m.`name`,
              m.`desc`,
              m.target_url,
              m.sort,
              m.`status`,
              m.create_by,
              m.modify_by,
              m.created,
              m.last_update_time
            FROM sys_menu AS m
                    LEFT JOIN sys_role_menu AS rm ON rm.menu_id = m.id
            WHERE
                    rm.role_id = #{roleId}
            ORDER BY m.id
  </select>
</mapper>
package com.dragonwu.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dragonwu.domain.SysRole;

public interface SysRoleMapper extends BaseMapper<SysRole> {
    /**
     * 获取用户角色Code的实现
     * @param userId
     * @return
     */
    String getUserRoleCode(Long userId);
}
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dragonwu.mapper.SysRoleMapper">
    <resultMap id="BaseResultMap" type="com.dragonwu.domain.SysRole">
        <!--@mbg.generated-->
        <!--@Table sys_role-->
        <id column="id" jdbcType="BIGINT" property="id"/>
        <result column="name" jdbcType="VARCHAR" property="name"/>
        <result column="code" jdbcType="VARCHAR" property="code"/>
        <result column="description" jdbcType="VARCHAR" property="description"/>
        <result column="create_by" jdbcType="BIGINT" property="createBy"/>
        <result column="modify_by" jdbcType="BIGINT" property="modifyBy"/>
        <result column="status" jdbcType="TINYINT" property="status"/>
        <result column="created" jdbcType="TIMESTAMP" property="created"/>
        <result column="last_update_time" jdbcType="TIMESTAMP" property="lastUpdateTime"/>
    </resultMap>
    <sql id="Base_Column_List">
        <!--@mbg.generated-->
        id, `name`, code, description, create_by, modify_by, `status`, created, last_update_time
    </sql>
    <select id="getUserRoleCode" resultType="java.lang.String">
        SELECT
            r.`code`
        FROM
            sys_role AS r LEFT JOIN sys_user_role as ur on r.id = ur.role_id
        WHERE
          ur.user_id =#{userId}
    </select>
</mapper>

六、测试访问

 获取到token切正常，注意关键字。

登录至此实现！

Dragon Wu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring框架下的管理员登录功能实现
wzjnbl111的专栏
07-23 1712
首页管理员登陆界面如下：
基于DDD和微服务中台架构与实现
10-21
【基于DDD和微服务的中台架构与实现】是一本深度探讨现代企业IT架构的书籍，作者欧创新和邓頔结合实践经验，阐述了如何利用领域驱动设计（DDD）和微服务架构构建灵活且高效的中台系统。以下是该书涉及的主要知识点：...
BookManager （2）---＞管理员登录功能实现
weixin_51271043的博客
07-13 850
1、实体层：com.java.model； 创建一个model实体的包。首先创建一个用户的实体。 在model包下创建一个名为 user 类，封装了一些User的信息、get set方法以及构造方法： package com.java.model; public class User { // 编号 private int id; // 用户名 private String userName; // 密码 private String passWord; public Us
J2SE图书管理系统(2)——管理员登录功能实现
程序员的时光
01-16 1629
1.实体层：com.java.model； 先在实体层model里新建一个User类，封装了一些User的信息、get set方法以及构造方法： package com.java.model; public class User { // 编号 private int id; // 用户名 private String userName; // 密码 private Stri...
SSO方式实现微服务的登入业务
weixin_56851586的博客
11-30 581
单一服务器模式用于登录的方式通常是使用session。JSON Web Tokens, 这是一个开放的标准,规定了一种Token实现方式,以JSON为格式.
微服务实战（一）
weixin_34239169的博客
05-29 240
一、持续集成对于微服务的意义：拆之前要先解决合的问题 在很多微服务化的文章中，很少会把持续集成放在第一篇，因为大多数的文章都会讲如何拆的问题，例如拆的粒度，拆的时机，拆的方式。为什么需要拆呢？因为这是人类处理问题的本质方式：将一个大的复杂问题，变成很多个小问题解决。所以当一个系统复杂到一定程度，当维护一个系统的人数多到一定程度，解决问题的难度和沟通成本大大提高，因而需要拆成很多个工程，拆成很多个...
DDD指导微服务拆分的详细流程和案例
08-22
案例中提到，微服务的大小没有固定的标准，但通常一个服务应该足够小，以便于理解和管理，同时又能独立完成其业务功能。微服务架构的引入带来了更高的复杂性，需要完善的DevOps实践、监控报警系统、开发流程管理和...
微服务架构领域知识及案例详细说明
12-13
微服务架构是一种现代软件开发的方法论，它主张将大型单体应用分解为一系列小型、独立的服务，每个服务专注于特定的业务功能。这种架构允许服务独立部署、扩展和更新，从而提高了系统的灵活性、可维护性和可扩展性。...
JavaWeb实现用户登录管理
qq_43540348的博客
11-29 1003
**Web网站框架分析** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;客户端将请求数据交给服务器端，服务器端里的servlet首先接收数据，处理，然后将处理结果交给service，service再将数据处理后交给dao，dao将数据在数据库里进行检查，然后将结果返回给service，service将结果返回给servle...
Spring Boot项目实践-员工管理系统（四）·登录功能实现
思
04-11 1501
本次实战项目主要是借鉴b站上的视频资源【狂神说Java】SpringBoot最新教程IDEA版通俗易懂完成的，有需求的话，可以直接去b站观看完整的视频教程，本文若有不对之处，望不吝赐教，谢谢~ 博文前提： Spring Boot项目实践-员工管理系统（一）·准备工作 Spring Boot项目实践-员工管理系统（二）·首页实现 Spring Boot项目实践-员工管理系统（三）·国际化 一、新...
微服务单点登录实现
qq_61393507的博客
12-11 2734
概述： 单点登录，英文是 Single Sign On（缩写为 SSO）。即多个站点共用一台认证授权服务器，用户在其中任何一个站点登录后，可以免登录访问其他所有站点。而且，各站点间可以通过该登录状态直接交互。那为什么要用单点登录呢？为了在分布式系统中让用户再访问不同服务资源时，不需要进行多次登录，进而改善用户的体验。如何解决呢？ 解决方案：根据了解常用两种: spring security+jwt+oauth2,spring security+redis+oauth2，那...
登录--微服务
荣霖的博客
11-05 605
在同父域下完成登录 单点登录 思路图 网上开源的单点登录项目
C++ 机房预约系统（四）：管理员模块——管理员登录和注销、添加账号功能、重复添加检测的具体实现
最新发布
UUUUU22的博客
03-21 1366
C++ 机房预约系统（四）：管理员模块——管理员登录和注销、添加账号功能、重复添加检测的具体实现
六、微服务版的单点登陆系统设计及实现
꯭ 瞎꯭扯꯭蛋꯭的博客
09-26 792
文章目录1.简介1.1 背景分析1.2 单点登陆系统2.快速入门实践2.1 工程结构如下2.2 创建认证授权工程2.3 添加项目依赖2.4 构建项目配置文件2.5 添加项目启动类2.6 启动并访问项目3.自定义登陆逻辑3.1 业务描述3.2 定义安全配置类3.3 定义用户信息处理对象3.4 网关中登陆路由配置3.5 基于Postman进行访问测试3.6 SpringSecurity 执行流程3.7 自定义登陆页面4.颁发登陆成功令牌4.1 构建令牌配置对象4.2 定义认证授权核心配置4.3 配置网关认证的U
微服务-Android客户端: 实现注册和登录
CodingMan
06-20 1327
简介 在 微服务项目系列文章 中跟大家一起学习了如何搭建、部署（本机和远程部署、热部署、Nginx等）、运行一个 SpringBoot 服务以及 MySQL 数据库的操作、文档（Swagger）的生成等操作，客户端采用浏览器的方式实现了用户注册、登录的流程。根据 微服务-立志做个伟大的项目 立下的【誓言】可以循序渐进的实现我们伟大的理想了，今天我们正式进入 Android 客户端的学习，希望对微服务、Android 开发感兴趣的同学有点帮助。 如果你对 Android 不了解，建议先学习 Google 官网
微服务——用户微服务单点登录
weixin_45528987的博客
04-08 1103
用户微服务单点登录为什么要使用单点登录原理链接：https://blog.csdn.net/weixin_45528987/article/details/105365115架构图看图可能还有点懵，下面贴过程与代码第一步：在用户微服务下添加两个依赖第二步：application.yml配置文件配置redis与jjwt的配置用户登录时的代码逻辑判断token是否过期或者存在盗用的风险 为什么要使用单...
微服务用户登录流程
hearth_b的博客
07-21 967
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值