自定义断言工具

1、自定义异常

package com.forezp.aspect;

import lombok.Data;
import lombok.EqualsAndHashCode;


/**
 * 统一返回异常

 */
@Data
@EqualsAndHashCode(callSuper = true)
public class BusinessException extends RuntimeException {
    /**
    * 
    */
   private static final long serialVersionUID = 1777331244357341577L;
   private String code;

    /**
     * 继承exception，加入错误状态值
     *
     * @param codeEnum
     */
    public BusinessException(ResultCodeEnum codeEnum) {
        super(codeEnum.getMessage());
        this.code = codeEnum.getCode();
    }

    /**
     * 自定义错误信息
     *
     * @param message
     * @param code
     */
    public BusinessException(String message, String code) {
        super(message);
        this.code = code;
    }

    /**
     * 业务异常
     *
     * @param message
     */
    public BusinessException(String message) {
        super(message);
        this.code = ResultCodeEnum.BUSINESS_ERROR.getCode();

    }
}

异常统一处理

package com.forezp.aspect;



import lombok.extern.slf4j.Slf4j;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.NoHandlerFoundException;


/**
 *  异常统一处理
 *
 */
@RestControllerAdvice
@Slf4j
public class ExceptionUnifiedHandler {

    /**
     * RestDescribeException 异常处理
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = BusinessException.class)
    public ResponseData doException(BusinessException e) {
        e.printStackTrace();
        log.info("异常:",e);
        return ResultUtils.error(e.getCode(), e.getMessage());
    }

    /**
     * NoHandlerFoundException 异常处理
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = NoHandlerFoundException.class)
    public ResponseData doException(NoHandlerFoundException e) {
        e.printStackTrace();
        log.info("异常:",e);
        return ResultUtils.error(ResultCodeEnum.NO_HANDLER_FOUND);
    }

    /**
     * HttpRequestMethodNotSupportedException 异常处理
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = HttpRequestMethodNotSupportedException.class)
    public ResponseData doException(HttpRequestMethodNotSupportedException e) {
        e.printStackTrace();
        log.info("异常:",e);
        return ResultUtils.error(ResultCodeEnum.NO_HANDLER_FOUND);
    }


    /**
     * Exception 异常处理
     *
     * @param e
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    public ResponseData doException(Exception e) {
        e.printStackTrace();
        log.error("异常:",e);;
        return ResultUtils.error(ResultCodeEnum.UNKNOW_ERROR);
    }

}

编写ResultUtils

package com.forezp.aspect;


/**
 */
public class ResultUtils {


    /**
     * 提供给部分不需要出參的接口
     *
     * @return
     */
    public static ResponseData success() {
        return success(null);
    }

    /**
     * 返回成功，传入返回体具体出參
     *
     * @param message
     * @param object
     * @return
     */
    public static <T> ResponseData success(String message, T object) {
        return generalMethod(ResultCodeEnum.SUCCESS.getCode(), message, object);
    }

    /**
     * 返回成功，传入返回体具体出參
     *
     * @param object
     * @return
     */
    public static <T> ResponseData success(T object) {
        return generalMethod(ResultCodeEnum.SUCCESS.getCode(), ResultCodeEnum.SUCCESS.getMessage(), object);
    }

    /**
     * 自定义错误信息
     *
     * @param message
     * @return
     */
    public static ResponseData error( String message) {
        return generalMethod(ResultCodeEnum.BUSINESS_ERROR.getCode(), message, null);
    }

    /**
     * 自定义错误信息
     *
     * @param message
     * @return
     */
    public static <T> ResponseData error( String message, T object) {
        return generalMethod(ResultCodeEnum.BUSINESS_ERROR.getCode(), message, object);
    }

    /**
     * 自定义错误信息
     *
     * @param code
     * @param message
     * @return
     */
    public static ResponseData error(String code, String message) {
        return generalMethod(code, message, null);
    }
    
    /**
     * 自定义错误信息及回传信息
     *
     * @param code
     * @param message
     * @param object
     * @param <T>
     * @return
     */
    public static <T> ResponseData error(String code, String message, T object) {
        return generalMethod(code, message, object);
    }

    /**
     * 返回异常信息，在已知的范围内
     *
     * @param codeEnum
     * @return
     */
    public static ResponseData error(ResultCodeEnum codeEnum) {
        return generalMethod(codeEnum.getCode(), codeEnum.getMessage(), null);
    }

    /**
     * 返回异常信息，在已知的范围内
     *
     * @param codeEnum
     * @return
     */
    public static <T> ResponseData error(ResultCodeEnum codeEnum, T object) {
        return generalMethod(codeEnum.getCode(), codeEnum.getMessage(), object);
    }

    /**
     * 通用方法
     *
     * @param code
     * @param message
     * @param object
     * @param <T>
     * @return
     */
    private static <T> ResponseData generalMethod(String code, String message, T object) {
       ResponseData<T> result = new ResponseData<T>();
       result.setResult(code.equals(ResultCodeEnum.SUCCESS.getCode()) ? 1: 0);
        result.setCode(code);
        result.setMsg(message);
        result.setData(object);
        return result;
    }

}

 

 

 

2、编写常用返回code枚举

package com.forezp.aspect;

/**
 * 常用返回code枚举
 *
 */
public enum ResultCodeEnum {
    
   SUCCESS("200", "成功"),
   DATA_ERROR("600", "数据异常"),
   NO_HANDLER_FOUND("404", "404"),
   BUSINESS_ERROR("-100", "服务器错误"),
   REMOTE_INTERFACE_ERROR("700", "接口调用异常"),
   DECRYPT_ERROR("702", "解密失败"),
   ENCRYPT_ERROR("701", "加密失败"),
   UNKNOW_ERROR("500", "未知错误"),
   TMC1001("1001", "参数传递有误"),
   TMC1002("1002", "查无航班"),
   TMC1003("1003", "数据过期"),
   TMC1004("1004", "接口验价失败，该航班的没有有效价格"),
   TMC1005("1005", "接口占位失败，该航班舱位已售完"),
   TMC1006("1006", "订单状态无效，确认失败"),
   TMC1007("1007", "客人支付金额与实际订单金额不符"),
   TMC1008("1008", "当前订单状态不允许取消"),
   TMC1009("1009", "客票规定不允许改期"),
   TMC1010("1010", "客票规定不允许退票"),
   TMC1011("1011", "订单当天状态不允许"),
   TMC1012("1012", "请求条件校验不通过"),
   TMC1099("1099", "系统故障");
   
    private String code;
    private String message;

    ResultCodeEnum(String code, String message) {
        this.code = code;
        this.message = message;
    }

    public String getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

 

3、编写断言工具

package com.forezp.aspect;


import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;


/**
 * 异常错误抛出工具
 *
 */
public class AssertionUtils {

    /**
     * 对象为空时
     *
     * @param obj
     * @param message
     */
    public static void isNull(Object obj, String message) {
        if (Objects.isNull(obj)) {
            message(message);
        }
    }


    /**
     * 对象不为空时
     *
     * @param obj
     * @param message
     */
    public static void isNotNull(Object obj, String message) {
        if (obj!=null) {
            message(message);
        }
    }


    /**
     * 对象为空时
     *
     * @param obj
     * @param codeEnum
     */
    public static void isNull(Object obj, ResultCodeEnum codeEnum) {
        if (Objects.isNull(obj)) {
            message(codeEnum);
        }
    }

    /**
     * 对象为空时
     *
     * @param obj
     */
    public static void isNull(Object obj) {
        if (Objects.isNull(obj)) {
            message();
        }
    }

    /**
     * 对象为空时
     *
     * @param obj
     * @param message
     */
    public static void nonNull(Object obj, String message) {
        if (Objects.nonNull(obj)) {
            message(message);
        }
    }

    /**
     * 集合为空时
     *
     * @param list
     * @param message
     */
    public static void isEmpty(List list, String message) {
        if (CollectionUtils.isEmpty(list)) {
            message(message);
        }
    }

    /**
     * 对象不为空时
     *
     * @param obj
     * @param codeEnum
     */
    public static void nonNull(Object obj, ResultCodeEnum codeEnum) {
        if (Objects.nonNull(obj)) {
            message(codeEnum);
        }
    }

    /**
     * 对象不为空时
     *
     * @param obj
     */
    public static void nonNull(Object obj) {
        if (Objects.nonNull(obj)) {
            message();
        }
    }


    /**
     * 对象相等时
     *
     * @param val1
     * @param val2
     * @param message
     */
    public static void equals(Object val1, Object val2, String message) {
        if (Objects.equals(val1, val2)) {
            message(message);
        }
    }

    /**
     * 对象相等时
     *
     * @param val1
     * @param val2
     * @param codeEnum
     */
    public static void equals(Object val1, Object val2, ResultCodeEnum codeEnum) {
        if (Objects.equals(val1, val2)) {
            message(codeEnum);
        }
    }

    /**
     * 对象相等时
     *
     * @param val1
     * @param val2
     */
    public static void equals(Object val1, Object val2) {
        if (Objects.equals(val1, val2)) {
            message();
        }
    }

    /**
     * 对象不相等时
     *
     * @param val1
     * @param val2
     * @param message
     */
    public static void unequals(Object val1, Object val2, String message) {
        if (!Objects.equals(val1, val2)) {
            message(message);
        }
    }

    /**
     * 对象不相等时
     *
     * @param val1
     * @param val2
     * @param codeEnum
     */
    public static void unequals(Object val1, Object val2, ResultCodeEnum codeEnum) {
        if (!Objects.equals(val1, val2)) {
            message(codeEnum);
        }
    }

    /**
     * 对象不相等时
     *
     * @param val1
     * @param val2
     */
    public static void unequals(Object val1, Object val2) {
        if (!Objects.equals(val1, val2)) {
            message();
        }
    }

    /**
     * 字符串相等时
     *
     * @param val1
     * @param val2
     * @param message
     */
    public static void equals(String val1, String val2, String message) {
        if (StringUtils.equals(val1, val2)) {
            message(message);
        }
    }

    /**
     * 字符串相等时
     *
     * @param val1
     * @param val2
     * @param codeEnum
     */
    public static void equals(String val1, String val2, ResultCodeEnum codeEnum) {
        if (StringUtils.equals(val1, val2)) {
            message(codeEnum);
        }
    }

    /**
     * 字符串相等时
     *
     * @param val1
     * @param val2
     */
    public static void equals(String val1, String val2) {
        if (StringUtils.equals(val1, val2)) {
            message();
        }
    }

    /**
     * 字符串不相等时
     *
     * @param val1
     * @param val2
     * @param message
     */
    public static void unequals(String val1, String val2, String message) {
        if (!StringUtils.equals(val1, val2)) {
            message(message);
        }
    }

    /**
     * 字符串不相等时
     *
     * @param val1
     * @param val2
     * @param codeEnum
     */
    public static void unequals(String val1, String val2, ResultCodeEnum codeEnum) {
        if (!StringUtils.equals(val1, val2)) {
            message(codeEnum);
        }
    }

    /**
     * 字符串不相等时
     *
     * @param val1
     * @param val2
     */
    public static void unequals(String val1, String val2) {
        if (!StringUtils.equals(val1, val2)) {
            message();
        }
    }


    /**
     * 集合不为空时
     *
     * @param coll
     * @param message
     */
    public static void isNotEmpty(Collection coll, String message) {
        if (CollectionUtils.isNotEmpty(coll)) {
            message(message);
        }
    }

    /**
     * 集合不为空时
     *
     * @param coll
     * @param codeEnum
     */
    public static void isNotEmpty(Collection coll, ResultCodeEnum codeEnum) {
        if (CollectionUtils.isNotEmpty(coll)) {
            message(codeEnum);
        }
    }

    /**
     * 集合不为空时
     *
     * @param coll
     */
    public static void isNotEmpty(Collection coll) {
        if (CollectionUtils.isNotEmpty(coll)) {
            message();
        }
    }

    /**
     * 集合为空时
     *
     * @param coll
     * @param message
     */
    public static void isEmpty(Collection coll, String message) {
        if (CollectionUtils.isEmpty(coll)) {
            message(message);
        }
    }

    /**
     * 集合为空时
     *
     * @param coll
     * @param codeEnum
     */
    public static void isEmpty(Collection coll, ResultCodeEnum codeEnum) {
        if (CollectionUtils.isEmpty(coll)) {
            message(codeEnum);
        }
    }

    /**
     * int为空时
     * @param coll
     * @param message
     */
    public static void isIntBlank(Integer coll, String message) {
        if (coll==null) {
            message(message);
        }
    }

    /**
     * 集合为空时
     *
     * @param coll
     */
    public static void isEmpty(Collection coll) {
        if (CollectionUtils.isEmpty(coll)) {
            message();
        }
    }


    /**
     * 字符串为空
     *
     * @param str
     * @param message
     */
    public static void isBlank(String str, String message) {
        if (StringUtils.isBlank(str)) {
            message(message);
        }
    }

    /**
     * 字符串为空
     *
     * @param str
     * @param codeEnum
     */
    public static void isBlank(String str, ResultCodeEnum codeEnum) {
        if (StringUtils.isBlank(str)) {
            message(codeEnum);
        }
    }

    /**
     * 字符串为空
     *
     * @param str
     */
    public static void isBlank(String str) {
        if (StringUtils.isBlank(str)) {
            message();
        }
    }

    /**
     * 字符串不为空
     *
     * @param str
     * @param message
     */
    public static void isNotBlank(String str, String message) {
        if (StringUtils.isNotBlank(str)) {
            message(message);
        }
    }

    /**
     * 字符串不为空
     *
     * @param str
     * @param codeEnum
     */
    public static void isNotBlank(String str, ResultCodeEnum codeEnum) {
        if (StringUtils.isNotBlank(str)) {
            message(codeEnum);
        }
    }

    /**
     * 字符串不为空
     *
     * @param str
     */
    public static void isNotBlank(String str) {
        if (StringUtils.isNotBlank(str)) {
            message();
        }
    }

    /**
     * 判断为真时
     *
     * @param judgment
     * @param message
     * @
     */
    public static void isTrue(boolean judgment, String message) {
        if (judgment) {
            message(message);
        }
    }

    /**
     * 判断为真时
     *
     * @param judgment
     * @
     */
    public static void isTrue(boolean judgment) {
        if (judgment) {
            message();
        }
    }

    /**
     * 判断为真时
     *
     * @param judgment
     * @param codeEnum
     * @
     */
    public static void isTrue(boolean judgment, ResultCodeEnum codeEnum) {
        if (judgment) {
            message(codeEnum);
        }
    }

    /**
     * 判断为假时
     *
     * @param judgment
     * @param message
     * @
     */
    public static void isFalse(boolean judgment, String message) {
        isTrue(!judgment, message);
    }

    /**
     * 判断为假时
     *
     * @param judgment
     * @param codeEnum
     * @
     */
    public static void isFalse(boolean judgment, ResultCodeEnum codeEnum) {
        isTrue(!judgment, codeEnum);
    }

    /**
     * 判断为假时
     *
     * @param judgment
     * @
     */
    public static void isFalse(boolean judgment) {
        isTrue(!judgment);
    }

    /**
     * map中包含key时
     *
     * @param map
     * @param key
     * @param message
     * @param <K>
     * @param <V>
     */
    public static <K, V> void containsKey(Map<K, V> map, K key, String message) {
        if (MapUtils.isNotEmpty(map) && map.containsKey(key)) {
            message(message);
        }
    }

    /**
     * map中包含key时
     *
     * @param map
     * @param key
     * @param codeEnum
     * @param <K>
     * @param <V>
     */
    public static <K, V> void containsKey(Map<K, V> map, K key, ResultCodeEnum codeEnum) {
        if (MapUtils.isNotEmpty(map) && map.containsKey(key)) {
            message(codeEnum);
        }
    }

    /**
     * map中包含key时
     *
     * @param map
     * @param key
     * @param <K>
     * @param <V>
     */
    public static <K, V> void containsKey(Map<K, V> map, K key) {
        if (MapUtils.isNotEmpty(map) && map.containsKey(key)) {
            message();
        }
    }

    /**
     * map中不包含key时
     *
     * @param map
     * @param key
     * @param message
     * @param <K>
     * @param <V>
     */
    public static <K, V> void notContainsKey(Map<K, V> map, K key, String message) {
        if (MapUtils.isEmpty(map) || !map.containsKey(key)) {
            message(message);
        }
    }

    /**
     * map中不包含key时
     *
     * @param map
     * @param key
     * @param codeEnum
     * @param <K>
     * @param <V>
     */
    public static <K, V> void notContainsKey(Map<K, V> map, K key, ResultCodeEnum codeEnum) {
        if (MapUtils.isEmpty(map) || !map.containsKey(key)) {
            message(codeEnum);
        }
    }

    /**
     * map中不包含key时
     *
     * @param map
     * @param key
     * @param <K>
     * @param <V>
     */
    public static <K, V> void notContainsKey(Map<K, V> map, K key) {
        if (MapUtils.isEmpty(map) || !map.containsKey(key)) {
            message();
        }
    }

    /**
     * 集合中包含obj时
     *
     * @param coll
     * @param obj
     * @param message
     * @param <T>
     * @
     */
    public static <T> void contains(Collection<T> coll, T obj, String message) {
        if (coll.contains(obj)) {
            message(message);
        }
    }

    /**
     * 集合中包含obj时
     *
     * @param coll
     * @param obj
     * @param codeEnum
     * @param <T>
     * @
     */
    public static <T> void contains(Collection<T> coll, T obj, ResultCodeEnum codeEnum) {
        if (coll.contains(obj)) {
            message(codeEnum);
        }
    }

    /**
     * 集合中包含obj时
     *
     * @param coll
     * @param obj
     * @param <T>
     * @
     */
    public static <T> void contains(Collection<T> coll, T obj) {
        if (coll.contains(obj)) {
            message();
        }
    }

    /**
     * 集合中不包含obj时
     *
     * @param coll
     * @param obj
     * @param message
     * @param <T>
     * @
     */
    public static <T> void notContains(Collection<T> coll, T obj, String message) {
        if (!coll.contains(obj)) {
            message(message);
        }
    }

    /**
     * 集合中不包含obj时
     *
     * @param coll
     * @param obj
     * @param codeEnum
     * @param <T>
     * @
     */
    public static <T> void notContains(Collection<T> coll, T obj, ResultCodeEnum codeEnum) {
        if (!coll.contains(obj)) {
            message(codeEnum);
        }
    }

    /**
     * 集合中不包含obj时
     *
     * @param coll
     * @param obj
     * @param <T>
     * @
     */
    public static <T> void notContains(Collection<T> coll, T obj) {
        if (!coll.contains(obj)) {
            message();
        }
    }

    /**
     * 默认数据异常
     */
    public static void message() {
        message(ResultCodeEnum.DATA_ERROR);
    }

    /**
     * 抛出业务异常
     *
     * @param message
     */
    public static void message(String message) {
        throw new BusinessException(message);
    }

    /**
     * 抛出业务异常
     *
     * @param codeEnum
     */
    public static void message(ResultCodeEnum codeEnum) {
        throw new BusinessException(codeEnum);
    }

    /**
     * 抛出自定义异常
     *
     * @param code
     * @param message
     */
    public static void message(String code, String message) {
        throw new BusinessException(message, code);
    }


}