springboot 全局异常捕获+接口统一返回+参数校验

最新推荐文章于 2024-06-08 13:49:02 发布
最新推荐文章于 2024-06-08 13:49:02 发布
阅读量447 收藏 2
点赞数
分类专栏： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsh_ningjing/article/details/111058516
版权

项目结构
在这里插入图片描述
pom包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wsh</groupId>
    <artifactId>common</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>common</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.0.3.RELEASE</spring-boot.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
    </parent>

    <dependencies>
        <!-- Spring Boot Web 依赖 核心 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Spring Boot Test 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.10</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>
    </dependencies>
</project>

类代码

package com.wsh.common.bean.exception;

/**
 * 基础接口：自定义描述枚举类需实现该接口
 * @author wsh
 * @create 2020-12-11 10:02
 */
public interface BaseErrorInfoInterface {

    /** 状态码 */
    int code();

    /** 描述 */
    String msg();
}


package com.wsh.common.bean.exception;

/**
 * 自定义业务异常类
 * @author wsh
 * @create 2020-12-11 10:02
 */
public class CommonException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    /**
     * 错误码
     */
    protected int errorCode;
    /**
     * 错误信息
     */
    protected String errorMsg;

    public CommonException() {
        super();
    }

    public CommonException(BaseErrorInfoInterface errorInfoInterface) {
        super(errorInfoInterface.code()+"");
        this.errorCode = errorInfoInterface.code();
        this.errorMsg = errorInfoInterface.msg();
    }

    public CommonException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
        super(errorInfoInterface.code()+"", cause);
        this.errorCode = errorInfoInterface.code();
        this.errorMsg = errorInfoInterface.msg();
    }

    public CommonException(String errorMsg) {
        super(errorMsg);
        this.errorMsg = errorMsg;
    }

    public CommonException(int errorCode, String errorMsg) {
        super(errorCode+"");
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    public CommonException(int errorCode, String errorMsg, Throwable cause) {
        super(errorCode+"", cause);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }


    public int getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(int errorCode) {
        this.errorCode = errorCode;
    }

    public String getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(String errorMsg) {
        this.errorMsg = errorMsg;
    }

    public String getMessage() {
        return errorMsg;
    }

    @Override
    public Throwable fillInStackTrace() {
        return this;
    }
}


package com.wsh.common.bean.result;

import com.wsh.common.bean.exception.BaseErrorInfoInterface;

/**
 * @author wsh
 * @create 2020-12-11 10:06
 */
public enum CommonEnum implements BaseErrorInfoInterface {

    SUCCESS(0, "success"),

    SYSTEM_ERROR(100, "系统异常!"),

    PARAMETER_ERROR(101, "参数错误！"),

    NAME_ERROR(102, "已存在相同的名称！"),

    NUMBER_ERROR(103, "已存在相同的编号！"),

    SIGNATURE_NOT_MATCH(104,"用户名或密码错误！"),

    NOT_FOUND(998, "未找到该资源!"),

    SERVER_BUSY(999,"服务器正忙，请稍后再试!");



    /** 状态码 */
    private int resultCode;

    /** 返回描述 */
    private String resultMsg;

    CommonEnum(int resultCode, String resultMsg) {
        this.resultCode = resultCode;
        this.resultMsg = resultMsg;
    }

    @Override
    public int code() {
        return resultCode;
    }

    @Override
    public String msg() {
        return resultMsg;
    }
}



```java
package com.wsh.common.bean.result;

import com.wsh.common.bean.exception.BaseErrorInfoInterface;

/**
 * @author wsh
 * @create 2020-12-11 10:04
 */
public class Result {

    /**
     * 响应代码
     */
    private int code;

    /**
     * 响应消息
     */
    private String msg;

    /**
     * 响应结果
     */
    private Object data;

    public Result() {
    }

    public Result(BaseErrorInfoInterface errorInfo) {
        this.code = errorInfo.code();
        this.msg = errorInfo.msg();
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    /**
     * 成功(不含data数据)
     *
     * @return
     */
    public static Result success() {
        return success(null);
    }

    /**
     * 成功(包含data数据)
     * @param data
     * @return
     */
    public static Result success(Object data) {
        Result rb = new Result();
        rb.setCode(CommonEnum.SUCCESS.code());
        rb.setMsg(CommonEnum.SUCCESS.msg());
        rb.setData(data);
        return rb;
    }

    /**
     * 失败(code、msg枚举类获取，不包含data数据)
     */
    public static Result error(BaseErrorInfoInterface errorInfo) {
        Result rb = new Result();
        rb.setCode(errorInfo.code());
        rb.setMsg(errorInfo.msg());
        rb.setData(null);
        return rb;
    }

    /**
     * 失败（code、msg枚举类获取，包含data数据）
     */
    public static Result error(BaseErrorInfoInterface errorInfo, Object data) {
        Result rb = new Result();
        rb.setCode(errorInfo.code());
        rb.setMsg(errorInfo.msg());
        rb.setData(data);
        return rb;
    }

    /**
     * 失败（code、msg自定义，不包含data数据）
     */
    public static Result error(int code, String msg) {
        Result rb = new Result();
        rb.setCode(code);
        rb.setMsg(msg);
        rb.setData(null);
        return rb;
    }

}


package com.wsh.common.bean;

/**
 * @author wsh
 * @create 2020-12-11 10:28
 */
public class User {

    private Long id;

    private String name;

    private Integer age;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}


package com.wsh.common.config.exceptionhandler;

import com.wsh.common.bean.exception.CommonException;
import com.wsh.common.bean.result.CommonEnum;
import com.wsh.common.bean.result.Result;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 *
 * @author wsh
 * @create 2020-12-11 10:03
 */
@ControllerAdvice
public class GlobalExceptionHandler {

    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    /**
     * 处理自定义的业务异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value = CommonException.class)
    @ResponseBody
    public Result bizExceptionHandler(HttpServletRequest req, CommonException e){
        log.error("{},业务异常！{}",req.getRequestURI(),e.getErrorMsg());
        return Result.error(e.getErrorCode(),e.getErrorMsg());
    }

    /**
     * Valid 校验参数合法性
     * @param e
     * @param request
     * @return
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public Result bindException(Exception e, HttpServletRequest request) {
        log.error("url:{},{}", request.getRequestURI(), ExceptionUtils.getStackTrace(e));
        StringBuilder sb = new StringBuilder("[");
        List<ObjectError> list = ((MethodArgumentNotValidException) e).getBindingResult().getAllErrors();
        for (ObjectError item : list) {
            sb.append(item.getDefaultMessage()).append(',');
        }
        sb.deleteCharAt(sb.length()-1);
        sb.append(']');
        return Result.error(CommonEnum.PARAMETER_ERROR,sb.toString());
    }

    /**
     * 处理其他异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Result exceptionHandler(HttpServletRequest req, Exception e){
        log.error("url:{},系统异常！", req.getRequestURI(), e);
        return Result.error(CommonEnum.SYSTEM_ERROR,e.getMessage());
    }


}



```java
package com.wsh.common.config.validated;

/**
 * @author wsh
 * @create 2020-12-10 17:16
 */
public interface Add {
}


package com.wsh.common.config.validated;

/**
 * @author wsh
 * @create 2020-12-10 17:16
 */
public interface Update {
}


package com.wsh.common.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

/**
 * 解决跨域问题
 */
@Configuration
public class CorsConfig {
    private static final Logger log = LoggerFactory.getLogger(CorsConfig.class);

    @Value("${cors.allow-origins:*}")
    private String allowOrigins;

    public CorsConfig() {
    }

    @Bean
    @Order
    public CorsFilter corsFilter() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        if (this.allowOrigins == null || this.allowOrigins.trim().equals("")) {
            log.error("不合法的origin配置,allowOrigins:{}", this.allowOrigins);
            System.exit(-1);
        }

        String[] allowOriginArr = this.allowOrigins.split(",");

        for (String origin : allowOriginArr) {
            corsConfiguration.addAllowedOrigin(origin);
        }

        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        corsConfiguration.setAllowCredentials(true);
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", corsConfiguration);
        return new CorsFilter(source);
    }
}

package com.wsh.common.config;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;

/**
 * 打印所有的controller包下的接口请求和响应日志
 * @author wsh
 * @create 2020-10-10 11:20
 */
@Aspect
@Configuration
@Order
public class WebLogAspect {
    private static final Logger log = LoggerFactory.getLogger(WebLogAspect.class);

    private ThreadLocal<Long> startTime=new ThreadLocal<>();

    // 指定所有调用controller包下类中的方法
    @Pointcut("execution(public * *.*.*.controller.*.*(..))")
    public void webLog(){
    }

    @Before(value = "webLog()")
    public void doBefore(JoinPoint point){
        startTime.set(System.currentTimeMillis());
        log.info("WebLogAspect.doBefore............");
        ServletRequestAttributes attributes= (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request=attributes.getRequest();
        log.info("请求IP:{}",request.getRemoteAddr());
        log.info("请求URL:{}" , request.getRequestURL().toString());
        log.info("请求方法类型 HTTP_METHOD:{}",request.getMethod());
        log.info("请求方法路径 CLASS_NAME:{}" , point.getSignature().getDeclaringTypeName()+"."+point.getSignature().getName());
        log.info("请求参数值:{}", Arrays.toString(point.getArgs()));
    }

    @AfterReturning(value = "webLog()",returning = "ret")
    public void doAferReturning(Object ret){
        log.info("WebLogAspect.doAfterReturning.............");
        log.info("响应结果:{}", ret);
        log.info("响应时间:{}ms", (System.currentTimeMillis()-startTime.get()));
    }

}


package com.wsh.common.controller;

import com.wsh.common.bean.User;
import com.wsh.common.bean.result.CommonEnum;
import com.wsh.common.bean.result.Result;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;
import java.util.ArrayList;
import java.util.List;

/**
 * @author wsh
 * @create 2020-12-11 10:27
 */
@RestController
@RequestMapping(value = "/api")
public class TestController {

    /**
     * 请求参数：{"id":1,"age":18}
     * @param user
     * @return
     */
    @RequestMapping("/insert")
    public Result insert(@Valid @RequestBody User user) {
        //测试 业务自定义异常
//        if(user.getName()==null){
//            throw new CommonException(CommonEnum.NAME_ERROR);
//        }
        Assert.notNull(user.getName(),CommonEnum.NAME_ERROR.msg());
        return Result.success();
    }

    /**
     * 请求参数：{"id":1,"age":18}
     * @param user
     * @return
     */
    @RequestMapping("/update")
    public Result update(@RequestBody User user) {
        //测试 业务层中发生空指针异常
        String str=null;
        str.equals("111");
        return Result.success();
    }

    /**
     * 请求参数：{"id":1,"age":18}
     * @param user
     * @return
     */
    @RequestMapping("/delete")
    public Result delete(@RequestBody User user)  {
        //内部服务器异常：未知异常
        Integer.parseInt("abc123");
        return Result.success();
    }

    /**
     *  不需要参数
     * @param user
     * @return
     */
    @RequestMapping("/findByUser")
    public Result findByUser(User user) {
        System.out.println("正常查询用户，没有异常。");
        List<User> userList =new ArrayList<>();
        User user2=new User();
        user2.setId(1L);
        user2.setName("cc");
        user2.setAge(18);
        userList.add(user2);
        return Result.success(userList);
    }


}


package com.wsh.common.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Map;

/**
 * @author wsh
 * @create 2020-12-11 16:59
 */
public class TokenUtil {

    public static String createToken(String accountId,String account){
//        Date expiresAt = new Date(System.currentTimeMillis() + 24L * 60L * 3600L * 1000L);
        String token = JWT.create()
//                .withExpiresAt(expiresAt) // 设置tocken过期时间
                .withClaim("iss", "lyzh_third") //  jwt签发者
                .withClaim("aud", "lyzh_third") // aud: 接收jwt的一方
                .withClaim("accountId", accountId)
                .withClaim("account", account)
                .sign(Algorithm.HMAC256("lyzhSecret"));
        return token;
    }

    /**
     * 解密Token, 获取 claims 中的信息
     *
     * @param token
     * @return
     * @throws Exception
     */
    public static Map<String, Claim> decryToken(String token) {
        JWTVerifier verifier = JWT.require(Algorithm.HMAC256("lyzhSecret")).build();
        DecodedJWT jwt = verifier.verify(token);
        return jwt.getClaims();
    }


}
w宁静致远
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用AOP捕获并记录全局异常 具体到方法和参数
qq_29807783的博客
09-07 1543
@Aspect @Component public class ErrAspect { private static final Logger log = LoggerFactory.getLogger(ErrAspect.class); @Autowired private SysErrLogMapper errLogMapper; // 配置织入点 @Pointcut("within(com.haxk..*)") public void logPoi.
SpringBoot全局异常与数据校验的方法
08-26
本文将详细介绍如何在SpringBoot中实现全局异常处理和数据校验。 首先，我们需要理解什么是全局异常处理。全局异常处理是指在应用程序中设置一个统一的机制，当发生异常时，能够捕获并处理这些异常，而不是让它们...
Spring Boot 全局异常处理
fhiguin的博客
03-14 163
Spring Boot 全局异常处理 一、GlobalExceptionHandler @Slf4j @RestControllerAdvice public class GlobalExceptionHandler { /** * @Description TODO 系统内部异常 **/ @ExceptionHandler(value = Exception.class) @ResponseStatus(HttpStatus.INTERNAL_SERVER_ER
SpringBoot实现参数校验拦截(采用AOP方式)
最新发布
weixin_60523038的博客
06-08 716
springBoot实现参数校验,AOP
Springboot统一异常处理返回
L1481333167的博客
12-23 523
Springboot统一异常处理返回
springboot中异常处理
m0_37539286的博客
05-25 569
1. commons-lang3中ExceptionUtils工具类 org.apache.commons.lang.exception.ExceptionUtils getMessage(throwable);获取错误信息 getStackTrace(throwable);获取错误堆栈信息 getRootCauseMessage(throwable);获取错误的根消息 getRootCause(throwable);获取错误的根原因 getStackFrames(throwable);获取栈帧消
SpringBoot全局异常捕获参以及参数异常
杨海吉
02-28 2142
现在比较常用的方式是给前端返回JSON，但是有些时候程序出现一些异常，导致前端页面报错不是很友好，所以就需要对项目进行全局的异常捕获，返回给前端固定的格式，进行友好的处理！ 话不多说，开始写代码 一.全局异常捕获 1.1 全局捕获 @Slf4j @RestControllerAdvice(annotations = {RestController.class, Service.class}) pu...
Spring Boot + validation + AOP 请求参数校验
12-20
结合AOP，我们可以创建一个全局的异常处理器，当参数校验失败时，捕获`ConstraintViolationException`并返回自定义的错误响应。这样可以确保整个应用的统一性和用户体验。 四、AOP处理 在Spring Boot中，通过AOP...
Springboot前后端分离，JWT+Security+Redis实现登录拦截及权限认证，包含全局异常处理以及统一返回风格
12-25
7. **统一返回风格**：保持API返回结果的一致性对于前后端交互至关重要。可以定义一个统一的响应模型，包括状态码、消息和数据，无论操作成功还是失败，都按照这个模型返回，这样前端可以方便地解析和处理。 8. **...
SpringBoot2.X Kotlin系列之数据校验和异常处理详解
08-26
对于异常处理，SpringBoot提供了`@RestControllerAdvice`注解，它可以捕获控制器层的全局异常。在`RestExceptionHandler`类中，我们定义了一个`@ExceptionHandler(Exception::class)`的方法，它会捕获所有类型的异常...
Springboot异常错误处理解决方案详解
09-07
例如，你可以创建一个自定义异常类`UserNotExitException`，并在处理器中捕获它，将错误信息封装成Map并返回。 ```java @ControllerAdvice public class MyExceptionHandler { @ResponseBody @...
SpringBoot全局异常捕获处理及参数校验
weixin_44421461的博客
08-18 860
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细...
Spring Controller获取ResponseBody 对象
xyw10000
03-24 1477
心血来潮想全局打印一下Controller请求入参，及返回。原本以为可以通过HandlerInterceptorAdapter 拦截器获取，但是postHandle 不能获取返回类型是JSON的，ModelAndView 这种倒是可以获取。 public void postHandle(HttpServletRequest request, HttpServletResponse res...
java获取异常堆栈信息_重构获取异常栈信息--printStackTrace
weixin_31857991的博客
02-20 186
MyStackTrace:/**** @author wumingkun* @version 1.0.0* @Description*/package com.demo.stacktrace;import java.io.PrintStream;/*** @author wumingkun**/public class MyStackTrace {public static String getS...
springboot项目三种请求参数类型异常捕获处理方式
小蜜蜂1010的博客
02-19 3628
springboot项目，请求参数验证异常统一处理方式
SpringBoot 全局异常处理
Java后端技术栈
06-29 3622
异常处理主要分为三类：基于请求转发的异常处理方式是真正的全局异常处理。实现方式有：基于异常处理器的异常处理方式其实并不是真正的全局异常处理，因为它处理不了过滤器等抛出的异常。实现方式有：基于过滤器的异常处理方式近似与全局异常处理。它能处理过滤器及之后的环节抛出的异常。实现方式有：这是SpringBoot默认处理异常方式：一旦程序中出现了异常SpringBoot就会请求/error的url，在SpringBoot中提供了一个叫BasicExceptionController的类来处理/error请求，然后跳转
SpringBoot 参数校验 异常捕获统一处理
zjy660358的专栏
01-09 829
Maven <!-- validation --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> Control.
springboot 实现对请求参数的验证 和 全局异常捕获
gyk163的博客
07-05 997
要实现注解对参数的验证，需要先创建一个模型类 ,然后在控制器中获取参数并进行验证，具体步骤如下， 先要创建spring的工程，这部分先不讲了 现在pom.xml 中加入如下依赖： <dependency> <groupId>javax.validation</groupId> <artifactId>validation-api</artifactId> <version>2.0.1.Final&l...
Springboot 全局异常捕获以及统一接口返回结果
默默不代表沉默
07-10 7270
以前写过一篇全局异常抓取以及日志log使用的文章， 今天我们再来单独优化一下这个全局异常抓取，并结合统一的接口返回类。 首先，我们先定义一个错误码接口（其实是返回码接口），里面包含返回码和错误描述，BaseErrorInfoInterface.java ： /** * @Author：JCccc * @Description：此接口用于返回码枚举使用 * @Date： creat...
springboot全局异常捕获
06-10
在 Spring Boot 中，可以通过实现一个全局异常处理器来捕获应用程序中的异常，并对异常进行统一处理。 实现一个全局异常处理器的步骤如下： 1. 创建一个异常处理器类，用于处理应用程序中的异常。 ```java @...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值