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

秒速五厘米 2022-05-07 03:48 235阅读 0赞

**     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、总结**

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