Spring 统一异常处理

最新推荐文章于 2024-09-21 21:33:45 发布
最新推荐文章于 2024-09-21 21:33:45 发布
阅读量1.9k 收藏 5
点赞数 1
分类专栏： spring 文章标签： spring 统一异常处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/johnf_nash/article/details/79307497
版权

1. Spring MVC 统一异常处理

这里使用实现 HandlerExceptionResolver 接口的方式来处理非 rest 服务统一异常。

1.1 继承 HandlerExceptionResolver 接口编写异常处理类
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

/** 非 rest 应用，需要返回视图 */
public class MyExceptionHandler implements HandlerExceptionResolver {
    private static final Logger logger = LogManager.getLogger(MyExceptionHandler.class);

    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
            Exception ex) {
        Map<String, Object> model = new HashMap<String, Object>();
        model.put("ex", ex);        

        // 将异常信息写入日志文件
        logger.error("internal error", ex);

        // 根据不同的错误转向不同的页面
        ModelAndView modelAndView = null;
        if(ex instanceof BusinessException) {
            modelAndView = new ModelAndView("error-business", model);
        } else if(ex instanceof ParameterException) {
            modelAndView = new ModelAndView("error-parameter", model);
        } else {
            modelAndView = new ModelAndView("error", model);
        }

        return modelAndView;
    }

}

这里根据不同类型的异常，转到不同的异常视图(传入异常相关信息，可以在视图上显示这些信息)。

1.2 添加spring配置
<bean id="exceptionHandler"     class="com.johnfnash.study.exception.MyExceptionHandler"/>

<!-- 配置视图解析器 -->  
<bean  
    class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
    id="internalResourceViewResolver">  
    <property name="prefix" value="/WEB-INF/jsps/"/>   
    <property name="suffix" value=".jsp" />  
</bean>
1.3 视图中显示错误信息

1.2 中传入了异常相关信息，这里我们就可以将异常信息显示到页面上了。

<%@ page contentType="text/html; charset=UTF-8"%>
<html>
    <head><title>Exception!</title></head>
<body>
    <% Exception e = (Exception)request.getAttribute("ex"); %>
    <H2>业务错误: <%= e.getClass().getSimpleName()%></H2>
    <hr />
    <P>错误描述：</P>
    <%= e.getMessage()%>
    <P>错误信息：</P>
    <% e.printStackTrace(new java.io.PrintWriter(out)); %>
</body>
</html>
1.4 示例

上面已经完成了 spring 统一异常配置，下面就可以在发生异常时，进行处理了。

@RequestMapping(value = "/controller.do", method = RequestMethod.GET)
public void controller(HttpServletResponse response, @QueryParam("id") Integer id)   throws Exception {
    switch (id) {
    case 1:
        throw new BusinessException("10", "controller10");
    case 2:
        throw new BusinessException("20", "controller20");
    case 3:
        throw new BusinessException("30", "controller30");
    case 4:
        throw new BusinessException("40", "controller40");
    case 5:
        throw new BusinessException("50", "controller50");
    case 6:
        throw new Exception("Internal error");
    default:
        throw new ParameterException("Controller Parameter Error");
    }
}

页面上访问 http://localhost:8080/spring-global-exception/controller.do?id=3 ， 就会触发 BusinessException 异常。上面配置的 HandlerExceptionResolver 解析到异常，转入异常页面。大致如下：

异常显示效果

2. Rest 服务统一异常处理

2.1 定义 Rest 异常处理器

Rest 服务统一异常处理和 Spring MVC 的稍有不同，前者不用返回视图，后者需要。这里使用 ResponseEntityExceptionHandler 来处理 Resr 服务统一异常。

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.TypeMismatchException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import com.johnfnash.study.model.Result;

/**  Rest 异常处理器，不需要返回视图。该类会处理所有在执行标有@RequestMapping注解的方法时发生的异常 */
@ControllerAdvice
public class RestExceptionHandler extends ResponseEntityExceptionHandler {
    private static final Logger log = LogManager.getLogger(RestExceptionHandler.class.getName());  

    @Override
    protected ResponseEntity<Object> handleExceptionInternal(Exception ex, Object body, HttpHeaders headers,
            HttpStatus status, WebRequest request) {
        log.error("Internal error", ex);
        //return super.handleExceptionInternal(ex, body, headers, status, request);
        return new ResponseEntity<Object>(Result.getFailResult("Error,please contact administrator!"), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @Override
    protected ResponseEntity<Object> handleMissingServletRequestParameter(MissingServletRequestParameterException ex,
            HttpHeaders headers, HttpStatus status, WebRequest request) {
        return super.handleMissingServletRequestParameter(ex, headers, status, request);
    }

    @Override
    protected ResponseEntity<Object> handleTypeMismatch(TypeMismatchException ex, HttpHeaders headers,
            HttpStatus status, WebRequest request) {
        return super.handleTypeMismatch(ex, headers, status, request);
    }

    @Override
    protected ResponseEntity<Object> handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException ex,
            HttpHeaders headers, HttpStatus status, WebRequest request) {
        log.error("Method not allowed", ex);
        //return super.handleHttpRequestMethodNotSupported(ex, headers, status, request);
        return new ResponseEntity<Object>(Result.getFailResult("Request method not allowed!"), HttpStatus.METHOD_NOT_ALLOWED);
    }

    @ExceptionHandler(BusinessException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    protected ResponseEntity<Object> handleHttpBusinessException(BusinessException ex) {
        log.error("Business Exception", ex);
        return new ResponseEntity<Object>(Result.getFailResult(ex.getMessage()), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(ParameterException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    protected ResponseEntity<Object> handleHttpParameterException(ParameterException ex) {
        log.error("Parameter Exception", ex);
        return new ResponseEntity<Object>(Result.getFailResult(ex.getMessage()), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    protected ResponseEntity<Object> handleException(Exception ex) {
        log.error("Exception", ex);
        return new ResponseEntity<Object>(Result.getFailResult("Exception!"), HttpStatus.INTERNAL_SERVER_ERROR);
    }

}

在 spring 配置文件中添加 Handler 的定义

<bean id="restExHandler" class="com.johnfnash.study.exception.RestExceptionHandler"/>

注意：

  1. ResponseEntityExceptionHandler 类中实现了一些常见的异常的处理，如 请求方法不对、确实 path param 等，可以根据实际情况进行重写

  2. 这里新增了几个用于处理自定义异常的方法 handleHttpBusinessException、handleHttpParameterException、handleException。这里使用了 spring 中的 @ExceptionHandler 注解用于指定当前方法要处理的异常类型，@ResponseStatus 用于设置 response status code。这几个方法返回的类型为 spring 中的 ResponseEntity，我们可以很方便地使用这个来返回接口的响应

2.2 RestExceptionHandler 使用

为了更好地说明 RestExceptionHandler 的用法，这里添加一个实体类，以及引入 spring validation。

2.2.1 添加 validation maven 依赖
<!-- validation -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>5.1.3.Final</version>
</dependency>

<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>1.1.0.Final</version>
    </dependency>

<dependency>
    <groupId>org.jboss.logging</groupId>
    <artifactId>jboss-logging</artifactId>
    <version>3.1.1.GA</version>
</dependency>
2.2.2 添加实体类 User
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

public class User {
    @NotNull(message = "{username.null}")
    @Size(min = 5, max = 16, message = "{username.size}")
    private String username;

    @NotNull(message = "{password.null}")
    @Size(min = 5, max = 25, message = "{password.size}")
    private String password;

    @Size(min = 2, max = 30, message = "{firstName.size}")
    private String firstName;

    @Size(min = 2, max = 30, message = "{lastName.size}")
    private String lastName;

    @NotBlank
    @Email(message = "{email.valid}")
    private String email;

    // getter, setter

}

注意：

  1. @NotNull 限制必须不为null，当传入的参数不包含该字段时，会触发校验规则；而如果设置为 @NotBlank，则当传入的参数不包含该字段时，不会触发校验规则
2.2.2 ValidationMessages.properties 添加错误信息配置

src/main/resources 下添加 ValidationMessages.properties 文件配置校验不通过时的提示信息

firstName.size=First name must be between {min} and {max} characters long.
lastName.size=Last name must be between {min} and {max} characters long.
username.null=Username is required.
username.size=Username must be between {min} and {max} characters long.
password.size=Password must be between {min} and {max} characters long.
password.null=Password is required.
email.valid=The email address must be valid.

注意：

  1. @NotNull 限制必须不为null，当传入的参数不包含该字段时，会触发校验规则；而如果设置为 @NotBlank，则当传入的参数不包含该字段时，不会触发校验规则
  2. 文件中配置的 key 对应实体类注解中 message 的设置，value 则对应具体的值
2.2.3 Controller 中添加 validation 校验
import java.util.List;

import javax.validation.Valid;

import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.johnfnash.study.exception.ParameterException;
import com.johnfnash.study.model.Result;
import com.johnfnash.study.model.User;

@RestController
public class UserController {
    @RequestMapping(value = "/user", method = RequestMethod.POST)
    public Result addUser(@Valid @RequestBody User user, BindingResult errors) {
        if(errors.hasFieldErrors()) {
            StringBuilder sb = new StringBuilder();
            List<ObjectError> errorList = errors.getAllErrors();
            for (ObjectError err : errorList) {
                sb.append(err.getDefaultMessage());
            }

            // 传入参数校验不通过时，抛出 ParameterException 异常。RestExceptionHandler 会捕获该异常
            throw new ParameterException(sb.toString());
        }
        return Result.getSuccessResult(null);
    }
}

注意：这里在 user 参数前加了 @Valid 注解，用于校验传入的参数；user 参数后面 必须紧跟着一个 BindingResult 类型的参数，校验结果放在了这个变量中

传入如下参数调用该接口 

{"firstName":"123456"}

响应如下：

{
  "success": false,
  "result": "Username is required.Password is required."
}

如果不想每次都在controller方法里写if(result.hasErrors())怎么办呢，写个切面，把if写在切面里，如果有errors直接就返回，不再执行controller方法。详见 2.2.4。

2.2.4 使用 @Aspect 定义切面将校验错误处理逻辑分离出来
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import javax.validation.Valid;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
//import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;

import com.johnfnash.study.exception.ParameterException;
import com.johnfnash.study.model.Result;

@Aspect
//@Component
public class ValidAspect {

    @Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)")  
    public Object processErrors(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod();
        if(!Result.class.equals(method.getReturnType())) {
            return pjp.proceed();
        }

        Object[] args = pjp.getArgs();
        Annotation[][] annotations = method.getParameterAnnotations();
        for (int i = 0; i < annotations.length; i++) {
            if(!hasValidAnnotation(annotations[i])){  
                continue;  
            }

            if(! ( i<annotations.length-1 && args[i+1] instanceof BindingResult )  ) {
                //验证对象后面没有跟bindingResult,事实上如果没有应该到不了这一步  
                continue;  
            }

            BindingResult bindingResult = (BindingResult) args[i+1];
            if(bindingResult.hasErrors()) {
                throw new ParameterException(parseError(bindingResult));
                //return Result.getFailResult(parseError(bindingResult));
            }
        }

        return pjp.proceed();
    }

    private boolean hasValidAnnotation(Annotation[] annotations) {
        if(annotations == null){  
            return false;  
        }  
        for(Annotation annotation : annotations){  
            if(annotation instanceof Valid){  
                return true;  
            }  
        }  
        return false;
    }

    private String parseError(BindingResult result) {
        StringBuilder sBuilder = null;
        if(null != result && result.hasErrors()) {
            sBuilder = new StringBuilder();
            for (ObjectError error : result.getAllErrors()) {
                sBuilder.append(error.getDefaultMessage()).append('\n');
            }
        }
        return sBuilder==null ? null : sBuilder.toString();
    }

}

注意：springmvc 中加入如下配置：

<!-- 参数 error 处理切面  -->
<bean id="errorAspect" class="com.johnfnash.study.validation.ValidAspect" />

<context:annotation-config />
<!-- 启用aop -->
<aop:aspectj-autoproxy proxy-target-class="true"/>

配置切面之后，原来的 addUser 方法就可以改成下面这样了

@RequestMapping(value = "/user", method = RequestMethod.POST)
public Result addUser(@Valid @RequestBody User user, BindingResult errors) {    
    return Result.getSuccessResult(null);
}

本文参考：

  1. 使用Spring MVC统一异常处理实战 http://cgs1999.iteye.com/blog/1547197#comments
  2. 使用 @RestController,@ExceptionHandler 和 @Valid,把检验和异常处理从主要业务逻辑里面抽离出来 http://blog.csdn.net/sanjay_f/article/details/47441631
  3. springboot 使用校验框架validation校验http://blog.csdn.net/u012373815/article/details/72049796
  4. springmvc使用JSR-303进行校验http://blog.csdn.net/tsingheng/article/details/42555307
xxc1605629895
关注
专栏目录
Spring REST API异常处理机制
苏暖午后
08-29 598
@ControllerAdvice @ExceptionHandler 实现方式 @ControllerAdvice @ControllerAdvice是一个@Component，用于定义@ExceptionHandler，@InitBinder和@ModelAttribute方法，适用于所有使用@RequestMapping方法。 Spring4之前，@Controlle...
Spring MVC 统一异常处理总结
u011851478的博客
02-15 3193
在一个Spring MVC项目中，使用统一异常处理，可以使维护代码变得容易。下面总结一下常用的3种方法。实现HandlerExceptionResolver接口实现HandlerExceptionResolver接口，实现resolveException()方法，根据传入的异常类型做出处理。继承AbstractHandlerExceptionResolver类继承AbstractHandlerExc
Spring：项目中的统一异常处理和自定义异常
最新发布
2301_77053417的博客
09-21 687
这里的自定义异常也就是定义一个异常类，然后作为@ExceptionHandler捕获的对象（1）先自定义一个普通的异常步骤：实现Exception类或者其子类，然后写构造方法（记得先初始化父类），可以看情况重写几个方法于是我们得到下面的自定义异常类//自定义的错误结果(里面包含错误码和错误信息)//用于throw new ApplicationException(Result.fail("我走的是构造方法"))这种情况/*** 构造方法 用于填充信息*/
SpringBoot异常处理
猪猪神功屁
04-24 1390
在J2EE项目的开发中，不管是对底层的数据库操作过程，还是业务层的处理过程，还是控制层的处理过程，都不可避免会遇到各种可预知的、不可预知的异常需要处理。每个过程都单独处理异常，系统的代码耦合度高，工作量大且不好统一，维护的工作量也很大。那么，能不能将所有类型的异常处理从各处理过程解耦出来，这样既保证了相关处理过程的功能较单一，也实现了异常信息的统一处理和维护？答案是肯定的。下面将介绍使用Sprin...
ResponseStatusException
汤键的博客
03-07 1975
ResponseStatusException目录概述：综合实例：继承 ResponseStatusException-自定义异常类继承 ResponseStatusException-自定义响应头信息继承 ResponseStatusException-定制更多异常处理逻辑继承 ResponseStatusException-根据异常发生的上下文动态改变 HTTP 状态码在这个示例中：通过这样重写这些方法，我们可以提供更加具体的错误状态和信息，以便在记录日志、返回给客户端、调试等方面提供有用的上下文
spring security oauth2中UsernameNotFoundException无法在认证失败后被捕获的问题
咘噜biu的博客
11-24 3537
1.问题描述： 在认证失败后UsernameNotFoundException异常会被默认转换成BadCredentialsException异常，导致不能捕获到UsernameNotFoundException， 一般来说UsernameNotFoundException是用户名错误导致的登录失败，BadCredentialsException是用户名或者密码错误导致的登录失败。如果我们能捕获到UsernameNotFoundException就能很好的区分登录失败是哪种具体的原因，以便在某些时候做一些
详解SpringCloud Finchley Gateway 统一异常处理
08-26
详解 SpringCloud Finchley Gateway 统一异常处理 SpringCloud Finchley Gateway 统一异常处理是指在使用 SpringCloud Finchley 版本的 Gateway 时，如何统一处理系统级异常的方法。默认情况下，SpringCloud ...
Spring Cloud zuul自定义统一异常处理实现方法
08-28
Spring Cloud zuul自定义统一异常处理实现方法 Spring Cloud zuul自定义统一异常处理实现方法是指在Spring Cloud微服务体系中，使用zuul提供filer和router功能时，实现自定义统一异常处理的方法。在zuul中，默认的...
Spring Boot统一异常处理最佳实践(拓展篇)
08-26
Spring Boot 统一异常处理最佳实践拓展篇 在 Spring Boot 中，统一异常处理是非常重要的，今天我们将介绍 Spring Boot 统一异常处理最佳实践的拓展篇。之前我们已经了解了基本的统一异常处理思路，现在我们将继续...
Spring Boot统一异常处理详解
08-31
Spring Boot作为一款流行的Java开发框架，提供了便捷的方式来实现统一异常处理。本文将深入探讨如何在Spring Boot中进行全局异常处理。 首先，Spring Boot默认提供了一个“error”映射，但其提供的错误页面并不适合...
Java异常介绍及Spring Boot统一异常处理
01-05
Spring Boot 提供了统一的异常处理机制，通过使用 @ControllerAdvice 和 @ExceptionHandler 注解，可以实现对控制器层、Service 层、Dao 层以及 Spring 系统内定义的部分异常的统一处理。 在 Spring Boot 中，可以...
[转]彻底征服 Spring AOP 之 实战篇
weixin_30315723的博客
11-14 236
Spring AOP 实战 看了上面这么多的理论知识, 不知道大家有没有觉得枯燥哈. 不过不要急, 俗话说理论是实践的基础, 对 Spring AOP 有了基本的理论认识后, 我们来看一下下面几个具体的例子吧.下面的几个例子是我在工作中所遇见的比较常用的 Spring AOP 的使用场景, 我精简了很多有干扰我们学习的注意力的细枝末节, 以力求整个例子的简洁性. 下面几个 Demo 的源码都可...
Spring 五种常见的异常处理方式
MOKE_SPACE
07-26 1782
异常处理 能够给Controller加切面的机制都能变相的进行统一异常处理，比如之前通过 AOP 实现的全局统一的异常处理：Spring aop 统一异常处理和日志输出。 这里总结一下，其他常用的异常处理方式。 接下来主要介绍五种处理异常的方式： HandlerExceptionResolver @ControllerAdvice 与 @ExceptionHandler ResponseEntityExceptionHandler ResponseStatusException ErrorControll
@NotBlank @NotNull 全局捕获异常返回自定义封装
qq_41822960的博客
01-20 7877
应为在代码中会存在这大量的判空， == null , isEmpty,isNull 等等。会导致代码很不美观而且不便管理，所以使用到了javax.validation的@NotBlank（String类型判空），@NotNull等方式去在Dto层进行判断。 DTO举例： import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModelProperty; import lombok.Data; import lo
SpringCloud Gateway 全局异常处理
weixin_42270645的博客
03-22 5856
在全局过滤器中可以处理网络异常请求，但是当设置Gateway请求超时时间，超时后的异常全局过滤器中处理不了。 定义CustomWebExceptionHandler类 import com.alibaba.csp.sentinel.slots.block.BlockException; import com.tigerkin.util.ApiResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springfr
spring @ExceptionHandler 异常处理3
汪小哥
06-09 4713
spring @ExceptionHandler 异常处理3 闲聊 在经过前面的两篇博客的简单闲聊的基础上，我们已经基本明确啦，如何掌握和深入了解spring异常处理体系的原理基本的途径，以及通过哪几个类可以简单的了解，下面从源码的角度了解其中的几个简单的类！最复杂的处理@ExpectionHandler等下一篇在继续闲聊。 HandlerExceptionResolver的继承体系...
异常处理：ResponseStatusExceptionResolver类，DefaultHandlerExceptionResolver类，SimpleMappingExceptionResolve
方法属性类，一个都不会
02-27 373
1.ResponseStatusExceptionResolver类 2.DefaultHandlerExceptionResolver类 3.SimpleMappingExceptionResolver类 ResponseStatusExceptionResolver类： 下面实现一个功能： 后台登录账户密码，正确返回正常页面，错误返回错误页面。 UserInfoControlle...
使用Spring中的ExceptionHandlerExceptionResolver进行统一的异常处理
热门推荐
linwei_1029的专栏
12-02 5万+
还是直接上代码说明： 1。 编写相关AnnotationHandlerMethodExceptionResolver异常处理类 package com.pss.res.base.exceptionresolver; import com.pss.res.client.base.constants.BusiStatusCons; import com.pss.res.client.base.d
SpringBoot注解校验validation自定义异常返回错误消息给前端
涛哥是个大帅比
07-01 5757
1.pom文件引用Spring Boot 2.3 1 之前，只需要引用spring-boot-starter-web Spring Boot 2.3 1 之后，spring-boot-starter-validation 已经不包括在了 spring-boot-starter-web 中，需要我们手动加上。 如果是普通 Java 程序 2.全局异常处理类ExceptionHandler 3.返回封装类 SpringBoot基础框架-Java文档类资源-CSDN下载注意：如果是sp
Spring MVC统一异常处理实战解析
"本文详细介绍了如何在Spring MVC应用中进行统一异常处理的实战，包括三种处理方式：SimpleMappingExceptionResolver、自定义HandlerExceptionResolver以及@ExceptionHandler注解。通过创建测试项目，从Dao层、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值