怎样优化自己的统一处理异常类

最新推荐文章于 2024-04-13 20:11:35 发布

单纯的心

最新推荐文章于 2024-04-13 20:11:35 发布

阅读量832

点赞数

本文链接：https://blog.csdn.net/zhangqiang_accp/article/details/83050642

版权

Java程序中，异常处理对于程序来说是非常基础。但是真正能很好理解并且很好的统一处理，这样会使得代码逻辑更清晰，更简单、更高效。下面就是程序中需要处理并且注意的异常统一处理案例：

1、自定义异常类

Controller异常类

package com.jd.wyjm.front.common.exception;

import com.jd.wyjm.front.common.enums.CodeEnum;
import com.jd.wyjm.front.common.enums.UserStatusEnum;
import lombok.ToString;

@ToString
public class WyjmException extends RuntimeException {

    private static final long serialVersionUID = 111820440373615072L;

    /**
     * 异常代码
     */
    private int code;
    /**
     * 异常消息
     */
    private String message;

    public WyjmException(CodeEnum codeEnum) {
        this.code = codeEnum.getCode();
        this.message = codeEnum.getMessage();
    }
    public WyjmException(UserStatusEnum codeEnum) {
        this.code = codeEnum.getCode();
        this.message = codeEnum.getMessage();
    }

    public WyjmException(int code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }

    public WyjmException(int code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

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

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message; 
    }

}

说明：controller自定义异常类是控制层出现非预期结果的输入参数后，抛出的异常数据。

Service异常类

package com.jd.wyjm.front.common.exception;

import com.jd.wyjm.front.common.enums.CodeEnum;
import com.jd.wyjm.front.common.enums.UserStatusEnum;
import lombok.ToString;

import java.io.Serializable;

@ToString
public class WyjmServiceException extends WyjmException implements Serializable {

    public WyjmServiceException(CodeEnum codeEnum) {
        super(codeEnum);
    }
    public WyjmServiceException(UserStatusEnum codeEnum) {
        super(codeEnum);
    }

    public WyjmServiceException(int code, String message) {
        super(code, message);
    }

    public WyjmServiceException(int code, String message, Throwable cause) {
        super(code, message, cause);
    }

 }

说明：service自定义异常类是服务层出现非预期结果的输入参数后，抛出的异常数据。

RPC接口异常类

package com.jd.wyjm.front.common.exception;

import com.jd.wyjm.front.common.enums.CodeEnum;

import java.io.Serializable;

public class WyjmRPCException extends WyjmException implements Serializable{
    public WyjmRPCException(CodeEnum codeEnum) {
        super(codeEnum);
    }

    public WyjmRPCException(int code, String message) {
        super(code, message);
    }

    public WyjmRPCException(int code, String message, Throwable cause) {
        super(code, message, cause);
    }
}

说明：rpc自定义异常类是RPC层出现非预期结果的输入参数后，抛出的异常数据。

2、自定义错误码

package com.jd.wyjm.front.common.enums;

public enum CodeEnum {
   /**
    * 处理成功
    */
   SUCCESS(200, "处理成功"),
   /**
    * 请求参数有误
    */
   INCORRECT_REQ_PARAM(201, "请求参数有误"),
   /**
    * 未经授权
    */
   UNAUTHORIZED(401, "未经授权"),
   /**
    * 内部服务错误
    */
   INTERNAL_SERVICE_ERRORS(500, "内部服务错误"),
  /**
    * 未知异常
    */
   UNKOWN_ERROR(999,"未知异常");

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

   /**
    * 响应消息
    */
   private final String message;

   CodeEnum(int _code, String _message) {

      this.code = _code;
      this.message = _message;

   }

   CodeEnum(UserStatusEnum userStatusEnum) {

      this.code = userStatusEnum.getCode();
      this.message = userStatusEnum.getMessage();

   }

   public int getCode() {
      return code;
   }

   public String getMessage() {
      return message;
   }

   /**
    * 通过枚举code获取对应的message
    * 
    * @return 取不到时返回null
    * @create 2018-8-21
    * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
    */
   public static String getMessageByCode(int code) {
      for (CodeEnum _enum : values()) {
         if (_enum.getCode() == code) {
            return _enum.getMessage();
         }
      }
      return null;
   }

   /**
    * 通过枚举code获取枚举对象
    * 
    * @return 取不到时返回null
    * @create 2018-8-21
    * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
    */
   public static CodeEnum getByCode(int code) {
      for (CodeEnum _enum : values()) {
         if (_enum.getCode() == code) {
            return _enum;
         }
      }
      return null;
   }

}

3、全局异常处理类

package com.jd.wyjm.front.web.common;

import com.jd.wyjm.front.common.constants.CodeKeyConstants;
import com.jd.wyjm.front.common.enums.CodeEnum;
import org.springframework.boot.autoconfigure.web.BasicErrorController;
import org.springframework.boot.autoconfigure.web.DefaultErrorAttributes;
import org.springframework.boot.autoconfigure.web.ServerProperties;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.view.json.MappingJackson2JsonView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

@Controller
public class EntryBasicError extends BasicErrorController {

    public EntryBasicError(ServerProperties serverProperties) {
        super(new DefaultErrorAttributes(), serverProperties.getError());
    }

    /**
     * 覆盖默认的Json响应
     */
    @Override
    public ResponseEntity<Map<String,Object>> error(HttpServletRequest request) {
          HttpStatus status = getStatus(request);
        return new ResponseEntity<Map<String,Object>>(this.errorResult(status),status);
    }

    /**
     * 覆盖默认的HTML响应
     */
    @Override
    @ResponseBody
    public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
        //请求的状态
        HttpStatus status = getStatus(request);
        return  new ModelAndView(new MappingJackson2JsonView(),this.errorResult(status));
    }

    /**
     * 获取错误状态编码
     * @param request
     */
    private HttpStatus getErrorStatus(HttpServletRequest request) {
        Integer statusCode = (Integer) request
                .getAttribute("javax.servlet.error.status_code");
        if (statusCode == null) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        try {
            return HttpStatus.valueOf(statusCode);
        }
        catch (Exception ex) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
    }

    /**
     * 响应错误处理结果
     * @param status 响应状态
     * @return 响应结果
     */
    private Map<String,Object> errorResult(HttpStatus status){
        Map<String,Object> map=new HashMap<>();
        switch (status.value()) {
            case 401:
                map.put(CodeKeyConstants.CODE,String.valueOf(CodeEnum.UNAUTHORIZED.getCode()));
                map.put(CodeKeyConstants.MESSAGE, CodeEnum.UNAUTHORIZED.getMessage());
                break;
            case 404:
                map.put(CodeKeyConstants.CODE,String.valueOf(CodeEnum.NOT_EXIST.getCode()));
                map.put(CodeKeyConstants.MESSAGE, CodeEnum.NOT_EXIST.getMessage());
                break;
            case 500:
                map.put(CodeKeyConstants.CODE,String.valueOf(CodeEnum.INTERNAL_SERVICE_ERRORS.getCode()));
                map.put(CodeKeyConstants.MESSAGE, CodeEnum.INTERNAL_SERVICE_ERRORS.getMessage());
                break;
            default:
                map.put(CodeKeyConstants.CODE,String.valueOf(CodeEnum.UNKOWN_ERROR.getCode()));
                map.put(CodeKeyConstants.MESSAGE, CodeEnum.UNKOWN_ERROR.getMessage());
                break;
        }
        return map;
    }
}

说明：统一处理请求到达controller前的异常错误信息，可以通过不同的头部返回不同的数据格式。例如：路径错误。

4、Controller异常处理类

package com.jd.wyjm.front.web.common;

import com.jd.jsf.gd.util.StringUtils;
import com.jd.wyjm.front.common.enums.CodeEnum;
import com.jd.wyjm.front.common.exception.WyjmException;
import com.jd.wyjm.front.common.exception.WyjmRPCException;
import com.jd.wyjm.front.common.exception.WyjmServiceException;
import com.jd.wyjm.front.common.res.CommonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.BindingResult;
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 javax.servlet.http.HttpServletResponse;
import java.util.List;

@Slf4j
@ControllerAdvice
public class HandlerExceptionAspect {
    /**
     * 统一处理JSON响应结果的错误结果 例如：{"code":201,message:"入参异常",data:null}
     *
     * @param cause   {@link Throwable} 异常
     * @param request {@link HttpServletRequest} 请求
     * @return {@link CommonResult} 响应结果
     * @create 2018-8-21
     * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
     */
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public CommonResult process(Throwable cause, HttpServletRequest request, HttpServletResponse response) {
        CommonResult result;
        if (cause instanceof WyjmRPCException) {
            result = new CommonResult(((WyjmRPCException) cause).getCode(), cause.getMessage());
        } else if (cause instanceof WyjmServiceException) {
            result = new CommonResult(((WyjmServiceException) cause).getCode(), cause.getMessage());
        } else if (cause instanceof WyjmException) {
            result = new CommonResult(((WyjmException) cause).getCode(), cause.getMessage());
        } else if (cause instanceof MethodArgumentNotValidException) {
            String errorMessage = this.methodArgumentMessage((MethodArgumentNotValidException) cause);
            result = new CommonResult(CodeEnum.INCORRECT_REQ_PARAM.getCode(), errorMessage);
        } else {
            result = new CommonResult(CodeEnum.UNKOWN_ERROR.getCode(), CodeEnum.UNKOWN_ERROR.getMessage());
        }
        setHeader(request, response);
        log.error(result.getMessage(), cause);
        return result;
    }

    /**
     * 参数异常消息获取
     *
     * @param cause 参数异常
     * @return 异常原因
     */
    private String methodArgumentMessage(MethodArgumentNotValidException cause) {
        MethodArgumentNotValidException validException = cause;
        BindingResult bindingResult = validException.getBindingResult();
        List<ObjectError> allErrors = bindingResult.getAllErrors();
        StringBuilder builder = new StringBuilder();
        for (ObjectError objectError : allErrors) {
            if (StringUtils.isNotBlank(objectError.getDefaultMessage())) {
                if (StringUtils.isNotBlank(builder)) {
                    builder.append(";");
                }
                builder.append(objectError.getDefaultMessage());
            }

        }
        if (StringUtils.isBlank(builder)) {
            builder.append(CodeEnum.INCORRECT_REQ_PARAM.getMessage());
        }
        return builder.toString();
    }

    /*
     * @Description: 设置跨域
     * @param [request, response]
     * @return void
     */
    private void setHeader(HttpServletRequest request, HttpServletResponse response) {
        response.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
        response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
    }
}

说明：统一处理请求到达controller后，抛出的异常错误信息。其中"cause instanceof MethodArgumentNotValidException"是为了捕获controlle方法中@Valid注解表单验证的异常消息，这些异常消息存储到MethodArgumentNotValidException的BindingResult 类。从BindingResult 获取到@NotNull、@NotBlank等验证注解的message消息。

5、@Valid表单验证实体数据类

package com.jd.wyjm.front.common.req;

import lombok.Data;
import lombok.ToString;
import org.hibernate.validator.constraints.NotBlank;

import javax.validation.constraints.NotNull;
import java.math.BigDecimal;

/**
 * 订单提交参数实体
 *
 * @create 2018-8-22
 * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
 */
@Data
@ToString
public class OrderSubmitReq {
    /**
     * 订单编号ID
     */
    private Long orderId;
    /**
     * 收货地址ID
     */
    private Integer addressId;
    /**
     * 收货人手机号
     */
    private String buyerMobile;
    /**
     * 收货人名称
     */
    private String buyerFullName;
    /**
     * 收货人地址
     */
    private String buyerFullAddress;
    /**
     * 标品来源ID
     */
    @NotNull(message="标品来源不允许为空")
    private Long srcProId;
    /**
     * 标品来源类型 1:售卖 2:求购
     */
    @NotNull(message="标品来源类型不允许为空")
    private Integer srcProType;
    /**
     * 支付方式 1-在线支付
     */
    @NotNull(message="支付方式不允许为空")
    private Integer payType;
    /**
     * 邮寄方式 1:卖家包邮 2:货到付款
     */
    @NotNull(message="邮寄方式不允许为空")
    private Integer expressType;
    /**
     * 商品购买数量
     */
    @NotNull(message="购买数量不允许为空")
    private Integer quantity;
    /**
     * 订单应付金额
     */
    @NotNull(message="订单应付金额不允许为空")
    private BigDecimal buyerPayableMoney;
    /**
     * 订单买家备注
     */
    private String  buyerRemark;
    /**
     * token令牌
     */
    @NotBlank(message="Token令牌不允许为空")
    private String  token;
}

6、Controller层接口类

package com.jd.wyjm.front.web.controller.trade;

import com.jd.wyjm.front.common.constants.CommonConstants;
import com.jd.wyjm.front.common.req.OrderUpdatePriceReq;
import com.jd.wyjm.front.common.res.CommonResult;
import com.jd.wyjm.front.service.trade.OrderService;
import com.jd.wyjm.front.common.req.OrderSubmitReq;
import com.jd.wyjm.front.vo.user.PersonVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;

/**
 * 订单提交，C2C结算页订单的提交
 *
 * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
 * @create 2018-8-22
 */
@Slf4j
@RestController
@RequestMapping("/order")
public class OrderController {
    /**
     * C2C订单提交数据信息Service
     */
    @Autowired
    private OrderService orderService;
    /**
     * 订单提交方法
     *
     * @param orderSubmit
     *         {@link OrderSubmitReq} 结算页订单参数
     * @param request
     *         {@link HttpServletRequest} HTTP请求信息
     *
     * @return 订单编号
     */
    @PostMapping(value = "/saveOrder")
    public CommonResult saveOrder(@RequestBody @Valid  OrderSubmitReq orderSubmit,HttpServletRequest request) {
        PersonVo person=(PersonVo)request.getAttribute(CommonConstants.WYJM_USER_INFO);
        return new CommonResult(String.valueOf(orderService.saveOrder(person.getPin(), orderSubmit,request)));
    }
}

说明：controller接口层无需捕获catch异常，出现异常后将抛出到外层的HandlerExceptionAspect 进行捕获。@Valid验证出现异常后将自动抛出到HandlerExceptionAspect 。

7、Service层处理自定义异常

package com.jd.wyjm.front.service.trade.impl;

import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private CacheService cacheService;
    /**
     * C2C订单收单
     *
     * @param loginUserPin
     *         买家登录PIN
     * @param order
     *         {@link OrderSubmitReq} 订单信息
     *
     * @return 订单编号
     * @create 2018-8-23
     * @author zhangqiang200<https:   /   /   blog.csdn.net   /   zhangqiang_accp>
     */
    @Override
    public Long saveOrder(String loginUserPin, OrderSubmitReq order, HttpServletRequest request) {
        //检查TOKEN令牌
        String token = cacheService.get(CacheKeyEnum.WYJM_ORDER_REPEAT_TOKEN.getKey(loginUserPin));
        if (StringUtils.isBlank(token) || !token.equals(order.getToken())) {
            throw new WyjmServiceException(CodeEnum.USER_TOKEN_VALID_FAIL);
        }
        return null;
    }

说明：service层无需捕获catch异常，出现异常后将抛出到外层的HandlerExceptionAspect 进行捕获，自行处理。

8、总结

高效、快速、简单的程序异常处理，不仅能程序逻辑简单，代码量少。

单纯的心

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
怎样优化自己的统一处理异常类

Java程序中，异常处理对于程序来说是非常基础。但是真正能很好理解并且很好的统一处理，这样会使得代码逻辑更清晰，更简单、更高效。下面就是程序中需要处理并且注意的异常统一处理案例：1、自定义异常类Controller异常类package com.jd.wyjm.front.common.exception;import com.jd.wyjm.front.common.en...
复制链接

扫一扫