异常处理设计

异常处理设计

使用接口+枚举+自定义异常处理异常：

1.接口

public interface IError {
    String msg();

    int code();
}

2.枚举

public enum CommonError implements IError {
    API_KEYS_NOT_NUL(500, "API KEYS 不能为空"),
    SYS_ERROR(500, "系统繁忙"),
    PARAM_ERROR(501, "参数异常"),
    RETRY_ERROR(502, "请求异常，请重试~"),
    OPENAI_AUTHENTICATION_ERROR(401, "身份验证无效/提供的 API 密钥不正确/您必须是组织的成员才能使用 API"),
    OPENAI_LIMIT_ERROR(429, "达到请求的速率限制/您超出了当前配额，请检查您的计划和帐单详细信息/发动机当前过载，请稍后重试"),
    OPENAI_SERVER_ERROR(500, "服务器在处理您的请求时出错");

    private int code;
    private String msg;

    private CommonError(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public String msg() {
        return this.msg;
    }

    public int code() {
        return this.code;
    }
}

3.自定义异常

public class BaseException extends RuntimeException {
    private String msg;
    private int code;

    public BaseException(IError error) {
        super(error.msg());
        this.code = error.code();
        this.msg = error.msg();
    }

    public BaseException(String msg) {
        super(msg);
        this.code = CommonError.SYS_ERROR.code();
        this.msg = msg;
    }

    public BaseException() {
        super(CommonError.SYS_ERROR.msg());
        this.code = CommonError.SYS_ERROR.code();
        this.msg = CommonError.SYS_ERROR.msg();
    }
    
    @Override
    public String toString() {
        return this.getClass().getSimpleName() + ": {" +
                "message='" + message + '\'' +
                '}';
    }
}

使用：

        if (StrUtil.isBlank(uid)) {
            throw new BaseException(CommonError.SYS_ERROR);
        }

使用Optional处理空指针异常

示例类：

/**
 * 示例类，展示如何使用Optional优雅地处理空指针问题。
 */
public class OptionalExample {
    public static void main(String[] args) {
        Person person = new Person("John", null);
        String companyName = getCompanyName(person);
        System.out.println("Company name: " + companyName);
    }

    /**
     * 获取Person关联的公司的名称。如果Person或公司对象为null，返回默认值"Unknown"。
     *
     * @param person 一个Person对象，可能关联了一个公司对象。
     * @return 公司的名称，或在找不到名称时返回默认值"Unknown"。
     */
    public static String getCompanyName(Person person) {
        return Optional.ofNullable(person)
            .map(Person::getCompany)
            .map(Company::getName)
            .orElse("Unknown");
    }
}

/**
 * Person类，包含一个名字和一个关联的公司对象。
 */
class Person {
    private String name;
    private Company company;

    public Person(String name, Company company) {
        this.name = name;
        this.company = company;
    }

    public Company getCompany() {
        return company;
    }
}

/**
 * Company类，包含一个公司名称。
 */
class Company {
    private String name;

    public Company(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Optional是Java 8引入的一个包装器类，用于解决null引用问题，避免NullPointerException。它是一个容器，可以保存一个值，也可以为空。Optional鼓励使用更函数式的方法处理可能为空的值。

下面是Optional的一些常用方法：

1. Optional.of(T value)：创建一个包含非空值的Optional对象。如果值为null，将抛出NullPointerException。

Optional<String> optional = Optional.of("Hello, World!");

2. Optional.empty()：创建一个不包含值的Optional对象。这表示缺少值。

Optional<String> emptyOptional = Optional.empty();

3. Optional.ofNullable(T value)：创建一个包含值的Optional对象，如果值为null，则创建一个空的Optional对象。

Optional<String> nullableOptional = Optional.ofNullable(null);

4. boolean isPresent()：检查Optional对象是否包含值。如果包含值，则返回true，否则返回false。

boolean hasValue = optional.isPresent(); // true

5. T get()：获取Optional对象中的值。如果对象为空，将抛出NoSuchElementException。

String value = optional.get(); // "Hello, World!"

6. void ifPresent(Consumer<? super T> action)：如果Optional对象包含值，则执行给定的操作。

optional.ifPresent(value -> System.out.println("Value: " + value));

7. Optional<T> filter(Predicate<? super T> predicate)：如果Optional对象包含值，并且该值满足给定的谓词条件，则返回原始Optional对象；否则，返回一个空的Optional对象。

Optional<String> filteredOptional = optional.filter(value -> value.length() > 10);

8. Optional<U> map(Function<? super T, ? extends U> mapper)：如果Optional对象包含值，则将其转换为另一个类型的值。

Optional<Integer> mappedOptional = optional.map(String::length); // Optional containing the length of the string

9. Optional<T> orElse(T other)：如果Optional对象包含值，则返回该值；否则，返回给定的默认值。

String valueOrFallback = optional.orElse("Fallback value");

10. Optional<T> orElseGet(Supplier<? extends T> other)：如果Optional对象包含值，则返回该值；否则，通过调用给定的Supplier函数生成一个值。

String valueOrGenerated = optional.orElseGet(() -> "Generated value");

11. T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果Optional对象包含值，则返回该值；否则，抛出给定Supplier函数生成的异常。

String valueOrException = optional.orElseThrow(() -> new NoSuchElementException("No value present"));

使用Optional可以帮助您编写更安全、更清晰的代码，减少对null值的检查，并降低NullPointerException的风险。