异常码规范、国际化

原创 已于 2025-11-24 11:59:40 修改 · 345 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#草稿
于 2025-06-05 12:31:27 首次发布

目的：断言统一封装异常码，国际化支持，调用方式

配置i18n异常码映射文件



根据项目BaseException中对编码进行转换


1.约定异常码字段（BaseErrorModule 约定各服务ModuleId等）


/**
 * 基础错误编号
 *
 * @author zj
 * @date 2024/10/02
 */
public interface BaseErrorCode {

    /**
     * 获取错误模块
     *
     * @return {@link BaseErrorModule}
     */
    BaseErrorModule getErrorModule();

    /**
     * 获取编号
     *
     * @return {@link String}
     */
    String getCode();

    /**
     * 获取消息
     *
     * @return {@link String}
     */
    String getMessage();

    /**
     * 获取解决方案
     *
     * @return {@link String}
     */
    String getSolution();

}

2.约定异常码抽象类


/**
 * 常见错误编号
 *
 * @author zj
 * @date 2024/10/02
 */
@Data
public abstract class AbstractErrorCode implements BaseErrorCode {

    /**
     * 编号
     */
    private String code;
    /**
     * 消息
     */
    private String message;

    /**
     * 错误模块
     */
    private BaseErrorModule errorModule;

    /**
     * 解决方案
     */
    private String solution;

    /**
     * 错误编号信息
     *
     * @param code    编号
     * @param message 消息
     */
    public AbstractErrorCode(String code, String message) {
        this.code = code;
        this.message = message;
    }


    /**
     * 错误编号信息
     *
     * @param code        编号
     * @param message     消息
     * @param solution    解决方案
     */
    public AbstractErrorCode(String code, String message, String solution) {
        this.code = code;
        this.message = message;
        this.solution = solution;
    }

    /**
     * 默认模块，可被子类覆盖
     */
    @Override
    public BaseErrorModule getErrorModule() {
        return ErrorModule.UN_KNOW;
    }

}

3.异常码（通常模块维度异常码，也有Domain维度异常码）

package com.gx.common.exception;

/**
 * 客户关系管理错误编号常数
 *
 * @author zj
 * @date 2024/10/02
 */
public class CrmErrorCodeConstants extends CommonErrorCode {

    /**
     * 客户【{}】放入公海失败，原因：客户已锁定
     */
    CrmErrorCodeConstants CUSTOMER_LOCKED_PUT_POOL_FAIL = new CrmErrorCodeConstants("B00001", "客户【{}】放入公海失败，原因：客户已锁定");


    /**
     * 客户关系管理错误编号常数
     *
     * @param code    编号
     * @param message 消息
     */
    public CrmErrorCodeConstants(String code, String message) {
        super(code, message);
    }

    /**
     * 客户关系管理错误编号常数
     *
     * @param code     编号
     * @param message  消息
     * @param solution 解决方案
     */
    public CrmErrorCodeConstants(String code, String message, String solution) {
        super(code, message, solution);
    }

    @Override
    public BaseErrorModule getErrorModule() {
        return ErrorModule.CRM;
    }


}

3.断言工具类


/**
 * 断言封装（基于HuTool改造）
 * 断言某些对象或值是否符合规定，否则抛出异常。经常用于做变量检查
 *
 * @author zj
 */
public class AssertUtil {

    /**
     * 默认错误
     */
    public static final CommonErrorCode DEFAULT_ERROR_CODE = CommonErrorCode.SYS_EXEC_ERROR;


    /**
     * 断言是否为真，如果为 {@code false} 抛出给定的异常<br>
     *
     * <pre class="code">
     * Assert.isTrue(i &gt; 0, ServiceException::new);
     * </pre>
     *
     * @param <X>        异常类型
     * @param expression 布尔值
     * @param supplier   指定断言不通过时抛出的异常
     * @throws X if expression is {@code false}
     */
    public static <X extends Throwable> void isTrue(boolean expression, Supplier<? extends X> supplier) throws X {
        if (false == expression) {
            throw supplier.get();
        }
    }

    /**
     * 断言是否为真，如果为 {@code false} 抛出 {@code ServiceException} 异常<br>
     *
     * <pre class="code">
     * Assert.isTrue(i &gt; 0, "The value must be greater than zero");
     * </pre>
     *
     * @param expression 布尔值
     * @throws ServiceException if expression is {@code false}
     */
    public static void isTrue(boolean expression, AbstractErrorCode errorCode) throws ServiceException {
        isTrue(expression, () -> new ServiceException(errorCode));
    }

    /**
     * 断言是否为真，如果为 {@code false} 抛出 {@code ServiceException} 异常<br>
     *
     * <pre class="code">
     * Assert.isTrue(i &gt; 0);
     * </pre>
     *
     * @param expression 布尔值
     * @throws ServiceException if expression is {@code false}
     */
    public static void isTrue(boolean expression) throws ServiceException {
        isTrue(expression, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言是否为假，如果为 {@code true} 抛出指定类型异常<br>
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     *  Assert.isFalse(i &gt; 0, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return");
     *  });
     * </pre>
     *
     * @param <X>           异常类型
     * @param expression    布尔值
     * @param errorSupplier 指定断言不通过时抛出的异常
     * @throws X if expression is {@code false}
     */
    public static <X extends Throwable> void isFalse(boolean expression, Supplier<X> errorSupplier) throws X {
        if (expression) {
            throw errorSupplier.get();
        }
    }

    /**
     * 断言是否为假，如果为 {@code true} 抛出 {@code ServiceException} 异常<br>
     *
     * <pre class="code">
     * Assert.isFalse(i &lt; 0, "The value must not be negative");
     * </pre>
     *
     * @param expression 布尔值
     * @throws ServiceException if expression is {@code false}
     */
    public static void isFalse(boolean expression, AbstractErrorCode errorCode) throws ServiceException {
        isFalse(expression, () -> new ServiceException(errorCode));
    }

    /**
     * 断言是否为假，如果为 {@code true} 抛出 {@code ServiceException} 异常<br>
     *
     * <pre class="code">
     * Assert.isFalse(i &lt; 0);
     * </pre>
     *
     * @param expression 布尔值
     * @throws ServiceException if expression is {@code false}
     */
    public static void isFalse(boolean expression) throws ServiceException {
        isFalse(expression, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言对象是否为{@code null} ，如果不为{@code null} 抛出指定类型异常
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.isNull(value, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return");
     *  });
     * </pre>
     *
     * @param <X>           异常类型
     * @param object        被检查的对象
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @throws X if the object is not {@code null}
     */
    public static <X extends Throwable> void isNull(Object object, Supplier<X> errorSupplier) throws X {
        if (null != object) {
            throw errorSupplier.get();
        }
    }

    /**
     * 断言对象是否为{@code null} ，如果不为{@code null} 抛出{@link ServiceException} 异常
     *
     * <pre class="code">
     * Assert.isNull(value, "The value must be null");
     * </pre>
     *
     * @param object 被检查的对象
     * @throws ServiceException if the object is not {@code null}
     */
    public static void isNull(Object object, AbstractErrorCode errorCode) throws ServiceException {
        isNull(object, () -> new ServiceException(errorCode));
    }

    /**
     * 断言对象是否为{@code null} ，如果不为{@code null} 抛出{@link ServiceException} 异常
     *
     * <pre class="code">
     * Assert.isNull(value);
     * </pre>
     *
     * @param object 被检查对象
     * @throws ServiceException if the object is not {@code null}
     */
    public static void isNull(Object object) throws ServiceException {
        isNull(object, DEFAULT_ERROR_CODE);
    }

    // ----------------------------------------------------------------------------------------------------------- Check not null

    /**
     * 断言对象是否不为{@code null} ，如果为{@code null} 抛出指定类型异常
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.notNull(clazz, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return");
     *  });
     * </pre>
     *
     * @param <T>           被检查对象泛型类型
     * @param <X>           异常类型
     * @param object        被检查对象
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 被检查后的对象
     * @throws X if the object is {@code null}
     */
    public static <T, X extends Throwable> T notNull(T object, Supplier<X> errorSupplier) throws X {
        if (null == object) {
            throw errorSupplier.get();
        }
        return object;
    }

    /**
     * 断言对象是否不为{@code null} ，如果为{@code null} 抛出{@link ServiceException} 异常 Assert that an object is not {@code null} .
     *
     * <pre class="code">
     * Assert.notNull(clazz, "The class must not be null");
     * </pre>
     *
     * @param <T>    被检查对象泛型类型
     * @param object 被检查对象
     * @return 被检查后的对象
     * @throws ServiceException if the object is {@code null}
     */
    public static <T> T notNull(T object, AbstractErrorCode errorCode) throws ServiceException {
        return notNull(object, () -> new ServiceException(errorCode));
    }

    /**
     * 断言对象是否不为{@code null} ，如果为{@code null} 抛出{@link ServiceException} 异常
     *
     * <pre class="code">
     * Assert.notNull(clazz);
     * </pre>
     *
     * @param <T>    被检查对象类型
     * @param object 被检查对象
     * @return 非空对象
     * @throws ServiceException if the object is {@code null}
     */
    public static <T> T notNull(T object) throws ServiceException {
        return notNull(object, DEFAULT_ERROR_CODE);
    }

    // ----------------------------------------------------------------------------------------------------------- Check empty

    /**
     * 检查给定字符串是否为空，为空抛出自定义异常，并使用指定的函数获取错误信息返回。
     * <pre class="code">
     * Assert.notEmpty(name, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return");
     *  });
     * </pre>
     *
     * @param <X>           异常类型
     * @param <T>           字符串类型
     * @param text          被检查字符串
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 非空字符串
     * @throws X 被检查字符串为空抛出此异常
     * @see StrUtil#isNotEmpty(CharSequence)
     */
    public static <T extends CharSequence, X extends Throwable> T notEmpty(T text, Supplier<X> errorSupplier) throws X {
        if (StrUtil.isEmpty(text)) {
            throw errorSupplier.get();
        }
        return text;
    }

    /**
     * 检查给定字符串是否为空，为空抛出 {@link ServiceException}
     *
     * <pre class="code">
     * Assert.notEmpty(name, "Name must not be empty");
     * </pre>
     *
     * @param <T>  字符串类型
     * @param text 被检查字符串
     * @return 非空字符串
     * @throws ServiceException 被检查字符串为空
     * @see StrUtil#isNotEmpty(CharSequence)
     */
    public static <T extends CharSequence> T notEmpty(T text, AbstractErrorCode errorCode) throws ServiceException {
        return notEmpty(text, () -> new ServiceException(errorCode));
    }

    /**
     * 检查给定字符串是否为空，为空抛出 {@link ServiceException}
     *
     * <pre class="code">
     * Assert.notEmpty(name);
     * </pre>
     *
     * @param <T>  字符串类型
     * @param text 被检查字符串
     * @return 被检查的字符串
     * @throws ServiceException 被检查字符串为空
     * @see StrUtil#isNotEmpty(CharSequence)
     */
    public static <T extends CharSequence> T notEmpty(T text) throws ServiceException {
        return notEmpty(text, DEFAULT_ERROR_CODE);
    }

    /**
     * 检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出自定义异常。
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.notBlank(name, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return");
     *  });
     * </pre>
     *
     * @param <X>              异常类型
     * @param <T>              字符串类型
     * @param text             被检查字符串
     * @param errorMsgSupplier 错误抛出异常附带的消息生产接口
     * @return 非空字符串
     * @throws X 被检查字符串为空白
     * @see StrUtil#isNotBlank(CharSequence)
     */
    public static <T extends CharSequence, X extends Throwable> T notBlank(T text, Supplier<X> errorMsgSupplier) throws X {
        if (StrUtil.isBlank(text)) {
            throw errorMsgSupplier.get();
        }
        return text;
    }

    /**
     * 检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出 {@link ServiceException}
     *
     * <pre class="code">
     * Assert.notBlank(name, "Name must not be blank");
     * </pre>
     *
     * @param <T>  字符串类型
     * @param text 被检查字符串
     * @return 非空字符串
     * @throws ServiceException 被检查字符串为空白
     * @see StrUtil#isNotBlank(CharSequence)
     */
    public static <T extends CharSequence> T notBlank(T text, AbstractErrorCode errorCode) throws ServiceException {
        return notBlank(text, () -> new ServiceException(errorCode));
    }

    /**
     * 检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出 {@link ServiceException}
     *
     * <pre class="code">
     * Assert.notBlank(name);
     * </pre>
     *
     * @param <T>  字符串类型
     * @param text 被检查字符串
     * @return 非空字符串
     * @throws ServiceException 被检查字符串为空白
     * @see StrUtil#isNotBlank(CharSequence)
     */
    public static <T extends CharSequence> T notBlank(T text) throws ServiceException {
        return notBlank(text, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言给定字符串是否不被另一个字符串包含（即是否为子串）
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.notContain(name, "rod", ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return ");
     *  });
     * </pre>
     *
     * @param <T>           字符串类型
     * @param <X>           异常类型
     * @param textToSearch  被搜索的字符串
     * @param substring     被检查的子串
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 被检查的子串
     * @throws X 非子串抛出异常
     * @see StrUtil#contains(CharSequence, CharSequence)
     */
    public static <T extends CharSequence, X extends Throwable> T notContain(CharSequence textToSearch, T substring, Supplier<X> errorSupplier) throws X {
        if (StrUtil.contains(textToSearch, substring)) {
            throw errorSupplier.get();
        }
        return substring;
    }

    /**
     * 断言给定字符串是否不被另一个字符串包含（即是否为子串）
     *
     * <pre class="code">
     * Assert.notContain(name, "rod", "Name must not contain 'rod'");
     * </pre>
     *
     * @param textToSearch 被搜索的字符串
     * @param substring    被检查的子串
     * @return 被检查的子串
     * @throws ServiceException 非子串抛出异常
     */
    public static String notContain(String textToSearch, String substring, AbstractErrorCode errorCode) throws ServiceException {
        return notContain(textToSearch, substring, () -> new ServiceException(errorCode));
    }

    /**
     * 断言给定字符串是否不被另一个字符串包含（即是否为子串）
     *
     * <pre class="code">
     * Assert.notContain(name, "rod");
     * </pre>
     *
     * @param textToSearch 被搜索的字符串
     * @param substring    被检查的子串
     * @return 被检查的子串
     * @throws ServiceException 非子串抛出异常
     */
    public static String notContain(String textToSearch, String substring) throws ServiceException {
        return notContain(textToSearch, substring, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言给定数组是否包含元素，数组必须不为 {@code null} 且至少包含一个元素
     * 并使用指定的函数获取错误信息返回
     *
     * <pre class="code">
     * Assert.notEmpty(array, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return");
     *  });
     * </pre>
     *
     * @param <T>           数组元素类型
     * @param <X>           异常类型
     * @param array         被检查的数组
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 被检查的数组
     * @throws X if the object array is {@code null} or has no elements
     * @see ArrayUtil#isNotEmpty(Object[])
     */
    public static <T, X extends Throwable> T[] notEmpty(T[] array, Supplier<X> errorSupplier) throws X {
        if (ArrayUtil.isEmpty(array)) {
            throw errorSupplier.get();
        }
        return array;
    }

    /**
     * 断言给定数组是否包含元素，数组必须不为 {@code null} 且至少包含一个元素
     *
     * <pre class="code">
     * Assert.notEmpty(array, "The array must have elements");
     * </pre>
     *
     * @param <T>   数组元素类型
     * @param array 被检查的数组
     * @return 被检查的数组
     * @throws ServiceException if the object array is {@code null} or has no elements
     */
    public static <T> T[] notEmpty(T[] array, AbstractErrorCode errorCode) throws ServiceException {
        return notEmpty(array, () -> new ServiceException(errorCode));
    }

    /**
     * 断言给定数组是否包含元素，数组必须不为 {@code null} 且至少包含一个元素
     *
     * <pre class="code">
     * Assert.notEmpty(array, "The array must have elements");
     * </pre>
     *
     * @param <T>   数组元素类型
     * @param array 被检查的数组
     * @return 被检查的数组
     * @throws ServiceException if the object array is {@code null} or has no elements
     */
    public static <T> T[] notEmpty(T[] array) throws ServiceException {
        return notEmpty(array, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言给定数组是否不包含{@code null}元素，如果数组为空或 {@code null}将被认为不包含
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.noNullElements(array, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return ");
     *  });
     * </pre>
     *
     * @param <T>           数组元素类型
     * @param <X>           异常类型
     * @param array         被检查的数组
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 被检查的数组
     * @throws X if the object array contains a {@code null} element
     * @see ArrayUtil#hasNull(Object[])
     */
    public static <T, X extends Throwable> T[] noNullElements(T[] array, Supplier<X> errorSupplier) throws X {
        if (ArrayUtil.hasNull(array)) {
            throw errorSupplier.get();
        }
        return array;
    }

    /**
     * 断言给定数组是否不包含{@code null}元素，如果数组为空或 {@code null}将被认为不包含
     *
     * <pre class="code">
     * Assert.noNullElements(array, "The array must not have null elements");
     * </pre>
     *
     * @param <T>   数组元素类型
     * @param array 被检查的数组
     * @return 被检查的数组
     * @throws ServiceException if the object array contains a {@code null} element
     */
    public static <T> T[] noNullElements(T[] array, AbstractErrorCode errorCode) throws ServiceException {
        return noNullElements(array, () -> new ServiceException(errorCode));
    }

    /**
     * 断言给定数组是否不包含{@code null}元素，如果数组为空或 {@code null}将被认为不包含
     *
     * <pre class="code">
     * Assert.noNullElements(array);
     * </pre>
     *
     * @param <T>   数组元素类型
     * @param array 被检查的数组
     * @return 被检查的数组
     * @throws ServiceException if the object array contains a {@code null} element
     */
    public static <T> T[] noNullElements(T[] array) throws ServiceException {
        return noNullElements(array, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言给定集合非空
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.notEmpty(collection, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return");
     *  });
     * </pre>
     *
     * @param <E>           集合元素类型
     * @param <T>           集合类型
     * @param <X>           异常类型
     * @param collection    被检查的集合
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 非空集合
     * @throws X if the collection is {@code null} or has no elements
     * @see CollUtil#isNotEmpty(Iterable)
     */
    public static <E, T extends Iterable<E>, X extends Throwable> T notEmpty(T collection, Supplier<X> errorSupplier) throws X {
        if (CollUtil.isEmpty(collection)) {
            throw errorSupplier.get();
        }
        return collection;
    }

    /**
     * 断言给定集合非空
     *
     * <pre class="code">
     * Assert.notEmpty(collection, "Collection must have elements");
     * </pre>
     *
     * @param <E>        集合元素类型
     * @param <T>        集合类型
     * @param collection 被检查的集合
     * @return 非空集合
     * @throws ServiceException if the collection is {@code null} or has no elements
     */
    public static <E, T extends Iterable<E>> T notEmpty(T collection, AbstractErrorCode errorCode) throws ServiceException {
        return notEmpty(collection, () -> new ServiceException(errorCode));
    }

    /**
     * 断言给定集合非空
     *
     * <pre class="code">
     * Assert.notEmpty(collection);
     * </pre>
     *
     * @param <E>        集合元素类型
     * @param <T>        集合类型
     * @param collection 被检查的集合
     * @return 被检查集合
     * @throws ServiceException if the collection is {@code null} or has no elements
     */
    public static <E, T extends Iterable<E>> T notEmpty(T collection) throws ServiceException {
        return notEmpty(collection, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言给定Map非空
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.notEmpty(map, ()-&gt;{
     *      // to query relation message
     *      return new ServiceException("relation message to return");
     *  });
     * </pre>
     *
     * @param <K>           Key类型
     * @param <V>           Value类型
     * @param <T>           Map类型
     * @param <X>           异常类型
     * @param map           被检查的Map
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 被检查的Map
     * @throws X if the map is {@code null} or has no entries
     * @see MapUtil#isNotEmpty(Map)
     */
    public static <K, V, T extends Map<K, V>, X extends Throwable> T notEmpty(T map, Supplier<X> errorSupplier) throws X {
        if (MapUtil.isEmpty(map)) {
            throw errorSupplier.get();
        }
        return map;
    }

    /**
     * 断言给定Map非空
     *
     * <pre class="code">
     * Assert.notEmpty(map, "Map must have entries");
     * </pre>
     *
     * @param <K> Key类型
     * @param <V> Value类型
     * @param <T> Map类型
     * @param map 被检查的Map
     * @return 被检查的Map
     * @throws ServiceException if the map is {@code null} or has no entries
     */
    public static <K, V, T extends Map<K, V>> T notEmpty(T map, AbstractErrorCode errorCode) throws ServiceException {
        return notEmpty(map, () -> new ServiceException(errorCode));
    }

    /**
     * 断言给定Map非空
     *
     * <pre class="code">
     * Assert.notEmpty(map, "Map must have entries");
     * </pre>
     *
     * @param <K> Key类型
     * @param <V> Value类型
     * @param <T> Map类型
     * @param map 被检查的Map
     * @return 被检查的Map
     * @throws ServiceException if the map is {@code null} or has no entries
     */
    public static <K, V, T extends Map<K, V>> T notEmpty(T map) throws ServiceException {
        return notEmpty(map, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言给定对象是否是给定类的实例
     *
     * <pre class="code">
     * Assert.instanceOf(Foo.class, foo);
     * </pre>
     *
     * @param <T>  被检查对象泛型类型
     * @param type 被检查对象匹配的类型
     * @param obj  被检查对象
     * @return 被检查的对象
     * @throws ServiceException if the object is not an instance of clazz
     * @see Class#isInstance(Object)
     */
    public static <T> T isInstanceOf(Class<?> type, T obj) {
        return isInstanceOf(type, obj, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言给定对象是否是给定类的实例
     *
     * <pre class="code">
     * Assert.instanceOf(Foo.class, foo, "foo must be an instance of class Foo");
     * </pre>
     *
     * @param <T>  被检查对象泛型类型
     * @param type 被检查对象匹配的类型
     * @param obj  被检查对象
     * @return 被检查对象
     * @throws ServiceException if the object is not an instance of clazz
     * @see Class#isInstance(Object)
     */
    public static <T> T isInstanceOf(Class<?> type, T obj, AbstractErrorCode errorCode) throws ServiceException {
        notNull(type, DEFAULT_ERROR_CODE);
        if (false == type.isInstance(obj)) {
            throw new ServiceException(errorCode);
        }
        return obj;
    }

    /**
     * 断言 {@code superType.isAssignableFrom(subType)} 是否为 {@code true}.
     *
     * <pre class="code">
     * Assert.isAssignable(Number.class, myClass);
     * </pre>
     *
     * @param superType 需要检查的父类或接口
     * @param subType   需要检查的子类
     * @throws ServiceException 如果子类非继承父类，抛出此异常
     */
    public static void isAssignable(Class<?> superType, Class<?> subType) throws ServiceException {
        isAssignable(superType, subType, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言 {@code superType.isAssignableFrom(subType)} 是否为 {@code true}.
     *
     * <pre class="code">
     * Assert.isAssignable(Number.class, myClass, "myClass must can be assignable to class Number");
     * </pre>
     *
     * @param superType 需要检查的父类或接口
     * @param subType   需要检查的子类
     * @throws ServiceException 如果子类非继承父类，抛出此异常
     */
    public static void isAssignable(Class<?> superType, Class<?> subType, AbstractErrorCode errorCode) throws ServiceException {
        notNull(superType, DEFAULT_ERROR_CODE);
        if (subType == null || !superType.isAssignableFrom(subType)) {
            throw new ServiceException(errorCode);
        }
    }

    /**
     * 检查boolean表达式，当检查结果为false时抛出 {@code IllegalStateException}。
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.state(id == null, ()-&gt;{
     *      // to query relation message
     *      return "relation message to return ";
     *  });
     * </pre>
     *
     * @param expression       boolean 表达式
     * @param errorMsgSupplier 错误抛出异常附带的消息生产接口
     * @throws IllegalStateException 表达式为 {@code false} 抛出此异常
     */
    public static void state(boolean expression, Supplier<String> errorMsgSupplier) throws IllegalStateException {
        if (false == expression) {
            throw new ServiceException(errorMsgSupplier.get());
        }
    }

    /**
     * 检查boolean表达式，当检查结果为false时抛出 {@code IllegalStateException}。
     *
     * <pre class="code">
     * Assert.state(id == null, "The id property must not already be initialized");
     * </pre>
     *
     * @param expression boolean 表达式
     * @throws IllegalStateException 表达式为 {@code false} 抛出此异常
     */
    public static void state(boolean expression, AbstractErrorCode errorCode) throws IllegalStateException {
        if (false == expression) {
            throw new ServiceException(errorCode);
        }
    }

    /**
     * 检查boolean表达式，当检查结果为false时抛出 {@code IllegalStateException}。
     *
     * <pre class="code">
     * Assert.state(id == null);
     * </pre>
     *
     * @param expression boolean 表达式
     * @throws IllegalStateException 表达式为 {@code false} 抛出此异常
     */
    public static void state(boolean expression) throws IllegalStateException {
        state(expression, DEFAULT_ERROR_CODE);
    }


    /**
     * 检查值是否在指定范围内
     *
     * @param <X>           异常类型
     * @param value         值
     * @param min           最小值（包含）
     * @param max           最大值（包含）
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 经过检查后的值
     * @throws X if value is out of bound
     */
    public static <X extends Throwable> int checkBetween(int value, int min, int max, Supplier<? extends X> errorSupplier) throws X {
        if (value < min || value > max) {
            throw errorSupplier.get();
        }

        return value;
    }

    /**
     * 检查值是否在指定范围内
     *
     * @param value 值
     * @param min   最小值（包含）
     * @param max   最大值（包含）
     * @return 经过检查后的值
     */
    public static int checkBetween(int value, int min, int max, AbstractErrorCode errorCode) {
        return checkBetween(value, min, max, () -> new ServiceException(errorCode));
    }


    /**
     * 检查值是否在指定范围内
     *
     * @param <X>           异常类型
     * @param value         值
     * @param min           最小值（包含）
     * @param max           最大值（包含）
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 经过检查后的值
     * @throws X if value is out of bound
     */
    public static <X extends Throwable> long checkBetween(long value, long min, long max, Supplier<? extends X> errorSupplier) throws X {
        if (value < min || value > max) {
            throw errorSupplier.get();
        }

        return value;
    }

    /**
     * 检查值是否在指定范围内
     *
     * @param value 值
     * @param min   最小值（包含）
     * @param max   最大值（包含）
     * @return 经过检查后的值
     */
    public static long checkBetween(long value, long min, long max, AbstractErrorCode errorCode) {
        return checkBetween(value, min, max, () -> new ServiceException(errorCode));
    }

    /**
     * 检查值是否在指定范围内
     *
     * @param <X>           异常类型
     * @param value         值
     * @param min           最小值（包含）
     * @param max           最大值（包含）
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @return 经过检查后的值
     * @throws X if value is out of bound
     */
    public static <X extends Throwable> double checkBetween(double value, double min, double max, Supplier<? extends X> errorSupplier) throws X {
        if (value < min || value > max) {
            throw errorSupplier.get();
        }

        return value;
    }


    /**
     * 断言两个对象是否不相等,如果两个对象相等 抛出ServiceException 异常
     * <pre class="code">
     *   Assert.notEquals(obj1,obj2);
     * </pre>
     *
     * @param obj1 对象1
     * @param obj2 对象2
     * @throws ServiceException obj1 must be not equals obj2
     */
    public static void notEquals(Object obj1, Object obj2) {
        notEquals(obj1, obj2, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言两个对象是否不相等,如果两个对象相等 抛出ServiceException 异常
     * <pre class="code">
     *   Assert.notEquals(obj1,obj2,"obj1 must be not equals obj2");
     * </pre>
     *
     * @param obj1 对象1
     * @param obj2 对象2
     * @throws ServiceException obj1 must be not equals obj2
     */
    public static void notEquals(Object obj1, Object obj2, AbstractErrorCode errorCode) throws ServiceException {
        notEquals(obj1, obj2, () -> new ServiceException(errorCode));
    }

    /**
     * 断言两个对象是否不相等,如果两个对象相等,抛出指定类型异常,并使用指定的函数获取错误信息返回
     *
     * @param obj1          对象1
     * @param obj2          对象2
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @param <X>           异常类型
     * @throws X obj1 must be not equals obj2
     */
    public static <X extends Throwable> void notEquals(Object obj1, Object obj2, Supplier<X> errorSupplier) throws X {
        if (ObjectUtil.equals(obj1, obj2)) {
            throw errorSupplier.get();
        }
    }
    // ----------------------------------------------------------------------------------------------------------- Check not equals

    /**
     * 断言两个对象是否相等,如果两个对象不相等 抛出ServiceException 异常
     * <pre class="code">
     *   Assert.isEquals(obj1,obj2);
     * </pre>
     *
     * @param obj1 对象1
     * @param obj2 对象2
     * @throws ServiceException obj1 must be equals obj2
     */
    public static void equals(Object obj1, Object obj2) {
        equals(obj1, obj2, DEFAULT_ERROR_CODE);
    }

    /**
     * 断言两个对象是否相等,如果两个对象不相等 抛出ServiceException 异常
     * <pre class="code">
     *   Assert.isEquals(obj1,obj2,"obj1 must be equals obj2");
     * </pre>
     *
     * @param obj1 对象1
     * @param obj2 对象2
     * @throws ServiceException obj1 must be equals obj2
     */
    public static void equals(Object obj1, Object obj2, AbstractErrorCode errorCode) throws ServiceException {
        equals(obj1, obj2, () -> new ServiceException(errorCode));
    }

    /**
     * 断言两个对象是否相等,如果两个对象不相等,抛出指定类型异常,并使用指定的函数获取错误信息返回
     *
     * @param obj1          对象1
     * @param obj2          对象2
     * @param errorSupplier 错误抛出异常附带的消息生产接口
     * @param <X>           异常类型
     * @throws X obj1 must be equals obj2
     */
    public static <X extends Throwable> void equals(Object obj1, Object obj2, Supplier<X> errorSupplier) throws X {
        if (ObjectUtil.notEqual(obj1, obj2)) {
            throw errorSupplier.get();
        }
    }

    // ----------------------------------------------------------------------------------------------------------- Check is equals


    /**
     * 错误的下标时显示的消息
     *
     * @param index  下标
     * @param size   长度
     * @param desc   异常时的消息模板
     * @param params 参数列表
     * @return 消息
     */
    private static String badIndexMsg(int index, int size, String desc, Object... params) {
        if (index < 0) {
            return StrUtil.format("{} ({}) must not be negative", StrUtil.format(desc, params), index);
        } else if (size < 0) {
            throw new IllegalArgumentException("negative size: " + size);
        } else { // index >= size
            return StrUtil.format("{} ({}) must be less than size ({})", StrUtil.format(desc, params), index, size);
        }
    }
    // -------------------------------------------------------------------------------------------------------------------------------------------- Private method end

4.异常码转换

package com.gx.common.utils.i18n;

import cn.hutool.extra.spring.SpringUtil;
import org.springframework.context.MessageSource;
import org.springframework.context.i18n.LocaleContextHolder;


/**
 * 国际化工具类
 *
 * @author zj
 * @date 2024/03/20
 */
public class MessageUtils {
    /**
     * 消息来源
     */
    private static final MessageSource MESSAGE_SOURCE;

    static {
        MESSAGE_SOURCE = SpringUtil.getBean("messageSource");
    }

    /**
     * 获取消息
     *
     * @param code 编号
     * @return {@link String }
     */
    public static String getMessage(String code){
        return getMessage(code, new String[0]);
    }

    /**
     * 获取消息
     *
     * @param code   编号
     * @param params 参数
     * @return {@link String }
     */
    public static String getMessage(String code, String... params){
        return MESSAGE_SOURCE.getMessage(code, params, LocaleContextHolder.getLocale());
    }
}

菜单语言相关维护进表，通过语言字段区分

SpringBoot自定义错误码，并支持国际化
hq.zheng的博客
03-31 3301
错误异常始祖抽象类定义，所有的错误信息都是通过该类去实现。获取错误信息接口类，所有的错误都要统一实现该接口类。实现效果：不同的业务模块用不同的错误编码。统一异常响应类，反馈给前端信息。
【异常】——JAVA之全局国际化异常处理
我爱吃土豆
07-25 9545
前言 在项目的开发中，不管是对底层的数据库操作过程，还是业务层的处理过程，还是控制层的处理过程，都不可避免会遇到各种可预知的、不可预知的异常需要处理。每个过程都单独处理异常，系统的代码耦合度高，工作量大且不好统一，维护的工作量也很大。 那么，能不能将所有类型的异常处理从各处理过程解耦出来，这样既保证了相关处理过程的功能较单一，也实现了异常信息的统一处理和维护？答案是肯定的。 一、自定义异常 ...
国际化与异常提示结合
M义薄云天的博客
02-26 1654
一.背景意义 国际化（internationalization）是设计和制造容易适应不同区域要求的产品的一种方式。它要求从产品中抽离所有地域语言，国家/地区和文化相关的元素。换言之，应用程序的功能和代码设计考虑在不同地区运行的需要，其代码简化了不同本地版本的生产。开发这样的程序的过程，就称为国际化。   二.本文主要内容 再搭建后台服务端异常框架时，考虑到产品中抽离所有地域语言，产品的拓展与...
java 异常国际化_基于springboot实现http响应异常信息国际化
weixin_40002846的博客
02-13 1462
背景国际化是指在设计软件，将软件与特定语言及地区脱钩的过程。当软件被移植到不同的语言及地区时，软件本身不用做内部工程上的改变或修正。本文提到的异常响应信息国际化是指：前端向后台发起请求，后台在处理逻辑中发生异常，把异常信息返回给前端，返回的异常信息应该支持国际化，能够对应特定的语言、地区等环境。例如，中文语言环境下返回的异常信息应该是中文的，英文语言环境下返回的则是对应的英文。javaweb项目中...
java 异常国际化,SpringMVC异常统一处理(异常信息的国际化,日志记录)
weixin_30682905的博客
03-20 1093
JAVA EE项目中,不管是对底层的数据操作,还是业务层的处理过程,还是控制层的处理,都不可避免的会遇到各种可预知的(业务异常主动抛出)、不可预知的异常需要处理。一般dao层、service层的异常都会直接抛出,最后由controller统一进行处理,每个过程都单独处理异常,且要考虑到异常信息和前端的反馈,代码的耦合度高,不统一,后期维护的工作也多。同时还必须考虑异常模块和日志模块、国际化的支持。...
Java异常消息国际化的最佳实践路径
2501_90410679的博客
07-19 110
本文探讨Java异常消息国际化的最佳实践路径。随着全球化发展，异常消息国际化成为提升用户体验的重要环节。当前面临地区差异、语言环境处理及技术更新等挑战。提出的解决方案包括：1）制定统一规范标准；2）采用国际化翻译工具；3）加强技术支撑；4）创新异常处理机制；5）建立完善管理体系。建议企业通过标准化建设、技术创新和管理优化提升异常消息国际化水平，增强市场竞争力。
Java基础26-Java 异常：自定义业务异常设计（含错误码与堆栈传递）
热门推荐
千淘万漉虽辛苦，吹尽狂沙始到金
09-09 2万+
Java自定义业务异常设计（含错误码与堆栈传递） 本文系统介绍了Java中自定义业务异常的设计方案，包括： 设计原则 分层清晰、可扩展、一致性强 支持错误追溯和用户友好提示 核心组件 模块化错误码体系（模块+业务+错误三级编码） 异常基类BusinessException 无堆栈异常NoStackBusinessException 关键特性 统一错误码管理（枚举实现） 上下文信息传递（Map存储） 堆栈控制选项（性能优化） 应用场景 适用于Spring Boot、微服务等架构 解决标准异常语义模糊、信息不统
国际化(i18n)测试实施规范
2501_94456679的博客
12-11 509
国际化测试（i18n）是验证软件多语言、多区域适应性的关键环节，重点包括字符编码、区域格式和UI弹性测试。需遵循ISO标准框架，覆盖Unicode支持、日期/货币格式及双向文本等核心维度。常见挑战如编码异常、格式适配问题可通过UTF-8统一编码、弹性布局设计解决。最佳实践包括集中管理多语言资源、分层自动化测试，使用VueI18n等工具链。实施路线从需求分析到持续改进，为软件全球化奠定基础，确保核心代码无需修改即可适应不同市场。
Python全栈开发源码包：Pandas数据分析Matplotlib可视化FastAPI接口与Excel自动化办公
06-19
Python 全栈开发实战源码包，含四类可运行示例，附 sample 数据，解压即可使用。 【包含模块】 1. Pandas 数据分析：批量合并 CSV、去重、导出 Excel 2. Matplotlib 可视化：销售趋势折线图与产品汇总统计 3. openpyxl 自动化：自动生成带折线图的 Excel 周报 4. FastAPI Web 接口：健康检查与销售数据 REST 查询 【使用方法】 1. 安装依赖：pip install -r requirements.txt 2. 一键演示：python run_all_demos.py 3. 启动 API：uvicorn module_04_fastapi_demo:app --host 127.0.0.1 --port 8000 4. 接口文档：浏览器打开 http://127.0.0.1:8000/docs 【目录说明】 data/ 示例 CSV 数据 | output/ 运行输出 | README.md 详细说明 【环境要求】Python 3.8+，支持 Windows / macOS / Linux
设计工作室 DWG 图纸乱码？下载设计专用字体库.rar
06-19
解决CAD图纸文字变问号、文字变乱码，欢迎下载！
顶刊复现配电网两阶段鲁棒故障恢复研究（Matlab代码实现)
06-19
内容概要：本资源聚焦于配电网在发生故障后的两阶段鲁棒恢复研究，旨在提升电力系统在不确定性条件下的恢复能力与运行可靠性。研究采用两阶段优化方法，第一阶段进行预恢复决策，如网络重构、分布式电源出力调整等，以最小化预期损失；第二阶段则针对实际发生的故障场景实施校正控制，利用鲁棒优化理论应对负荷波动、新能源出力不确定性等因素，确保恢复方案的可行性与强健性。资源提供了完整的Matlab代码实现，复现了相关顶刊研究成果，便于使用者深入理解模型构建、算法求解及仿真分析全过程。; 适合人群：具备电力系统分析、优化理论基础及Matlab编程能力的研究生、科研人员及电力行业工程师。; 使用场景及目标：① 学习并掌握配电网故障恢复的先进优化方法，特别是两阶段鲁棒优化模型的构建与应用；② 复现和验证顶刊论文中的算法，为自身科研工作提供技术参考和代码基础；③ 将所学方法拓展应用于微电网、主动配电网等新型电力系统的可靠性评估与优化调度研究。; 阅读建议：学习者应结合提供的Matlab代码，仔细研读模型的数学公式与求解逻辑，重点关注不确定性建模、两阶段决策变量的设定以及鲁棒对等转换技巧。建议在掌握基础案例后，尝试修改参数或引入新的约束条件进行扩展研究，以深化理解并提升创新能力。
易语言源码易语言D2D物理效果源码
最新发布
06-19
易语言源码易语言D2D物理效果源码
数农产业大脑平台PPT.pptx
06-19
数农产业大脑平台PPT.pptx
拖拉机路径跟踪的预测 Stanley 控制方法.zip
06-19
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
逆变器开环控制仿真研究（Simulink仿真实现）
06-19
逆变器开环控制仿真研究（Simulink仿真实现）
video-parse.rar（输入url即可解析出m3u8）
06-19
video_parse.rar（输入url即可解析出m3u8）
DataGrip连接MySQL数据库教程[项目源码]
06-19
本文详细介绍了如何使用DataGrip连接MySQL数据库的完整步骤。首先，需要安装MySQL数据库，包括从官网下载安装包、通过终端进入MySQL、查看数据库版本、创建数据库和表等基本操作。其次，下载并安装DataGrip工具，然后进行连接配置，包括设置主机、端口、用户名和密码等参数。最后，展示了如何显示所有数据库。文章还附带了作者的个人介绍和一份Java开发学习资料的推广信息，旨在帮助初中级Java工程师提升技能。
stm32单片机项目资料课程设计文档C语言程序代码原理图电路PCB实例0052,汽车尾灯控制电路设计论文资料
06-19
stm32单片机项目资料课程设计文档C语言程序代码原理图电路PCB实例0052、汽车尾灯控制电路设计论文资料
基于RK3588的AI中医脉搏诊断仪.zip
06-19
多智能体ai中医大师系统，模仿张仲景、张锡纯等经方大师，根据历代名医病案及现代中医医学研究，综合给出中医治疗方案，并严格审核方剂配伍，堪比一小型中医国医大师诊所
uxplaywindows-installer.rar
06-19
uxplaywindows-installer.rar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值