简介

在实现代码的过程中，使用一些函数接口可以使得代码变得更加简洁。本文基于Scala的几个比较使用的函数接口翻译成Java版本来进行一个简单的总结。

如果只是想使用的话，推荐使用现成的包来提高稳定性：

<!-- https://mvnrepository.com/artifact/io.vavr/vavr -->
<dependency>
    <groupId>io.vavr</groupId>
    <artifactId>vavr</artifactId>
    <version>0.10.3</version>
</dependency>

以下的内容是自己实现的这些接口，以方便来扩展一些功能，仅供参考。

Option

基本简介

Option(选项)类型用来表示一个值是可选的（有值或无值)。
Option[T] 是一个类型为 T 的可选值的容器：如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None。
在Java中，Option给了一个实现是Java中的Optional，其可以表示一个可空的对象，以此来防止空指针的bug。
使用场景：
- 用于标识一个方法的返回值是可能为空的，让外部人员知道这个值可能为空，记得进行空场景的处理。
- 在存在多层if判空的情况下，可以使用Option（Optional）来减少if的层级。具体可以参考本文的上一篇文章。

Lazy

基本简介

使用Lazy来定义惰性变量，实现延迟加载(懒加载)。惰性变量只能是不可变变量，并且只有在调用惰性变量时，才会去实例化这个变量。

代码实现

本实现中，提供了一个Lazy及其子类（ParallelLazy），其分别使用of方法和ofParallel方法来进行创建。后者使用了Double-checked locking来防止了多线程使用此类的并发问题（实际上延迟加载多线程的场景还是比较多的）。
- 并发场景下，Lazy如果不额外做并发的处理的话，会里面的方法重复执行。

/**
 * 惰性加载
 *
 * @author Gloduck
 * @date 2023/02/07
 */
public class Lazy<T> {
    /**
     * 生成器
     */
    private Supplier<T> supplier;

    /**
     * 值
     */
    protected volatile T value;

    /**
     * 获取值
     *
     * @return {@link T}
     */
    public final T get() {
        return isEvaluated() ? value : completeValue();
    }

    /**
     * 获取值
     *
     * @return {@link T}
     */
    protected T completeValue() {
        value = supplier.get();
        supplier = null;
        return value;
    }

    /**
     * 创建一个新的lazy对象
     *
     * @param supplier 生成器
     * @return {@link Lazy}<{@link T}>
     */
    public static <T> Lazy<T> of(Supplier<T> supplier) {
        Objects.requireNonNull(supplier);
        return new Lazy<>(supplier);
    }

    /**
     * 创建一个支持并发的lazy对象
     *
     * @param supplier 生成器
     * @return {@link Lazy}<{@link T}>
     */
    public static <T> Lazy<T> ofParallel(Supplier<T> supplier) {
        Objects.requireNonNull(supplier);
        return new ParallelLazy<>(supplier);
    }

    /**
     * 是否被计算过
     *
     * @return boolean
     */
    public final boolean isEvaluated() {
        return supplier == null;
    }

    private Lazy(Supplier<T> supplier) {
        this.supplier = supplier;
    }

    /**
     * 并发的lazy
     *
     * @author Gloduck
     * @date 2023/02/07
     */
    private final static class ParallelLazy<T> extends Lazy<T> {

        /**
         * 计算值，Double-checked locking
         *
         * @return {@link T}
         */
        @Override
        protected synchronized T completeValue() {
            return isEvaluated() ? value : super.completeValue();
        }

        private ParallelLazy(Supplier<T> supplier) {
            super(supplier);
        }
    }
}

实际场景

存在以下场景：在一段比较长的代码中，一个变量可能在一些条件分支里不一定被使用，但可能有多个条件分支（甚至以后可能还会加入新的条件分支）使用此变量。那么有两种选择：在最外层定义，或者在if里面定义。前者会导致在每个if分支里面额外做空判断（或者一开始就赋值，但是如果后续的代码没用到这个变量，那么就是个无用的操作）；后者会导致一个变量在if里面多次赋值，降低代码的可读性。

如下：

Student student = null;
if(/*条件 1*/){
    if(student == null){
        student = getStudent(id);
    }
    /*使用student*/
}

/*其他代码*/

if(/*条件 2*/){
    if(student == null){
        student = getStudent(id);
    }
    /*使用student*/
}

可以看到，这里在不同的条件分支里面，为了使用Student多次对其进行了判空（我们假定getStudent这个方法永远不会返回空），导致了if的层级加深。

如果使用Lazy来替代的话，就可以将上述代码替换为如下代码：

Lazy<Student> studentLazy = Lazy.of(() -> getStudent(id));
if(/*条件 1*/){
    String name = studentLazy.get().getName();
    /*使用student*/
}
if(/*条件 2*/){
    Boolean sex = studentLazy.get().getSex();
    /*使用student*/
}

可以发现，代码实际上简洁了不少，可能在这段demo代码里面看不出来有太大的用处，但是在一些老项目的代码中，减少一些额外的代码对阅读代码还是很有帮助的。

Either

基本简介

Either 也是一个容器类型，但不同于 Try、Option，它需要两个类型参数： Either[A, B] 要么包含一个类型为 A 的实例，要么包含一个类型为 B 的实例。
Either 只有两个子类型： Left、 Right，如果 Either[A, B] 对象包含的是 A 的实例，那它就是 Left 实例，否则就是 Right 实例。
在语义上，Either 并没有指定哪个子类型代表错误，哪个代表成功，毕竟，它是一种通用的类型，适用于可能会出现两种结果的场景。而异常处理只不过是其一种常见的使用场景而已，不过，按照约定，处理异常时，Left 代表出错的情况，Right 代表成功的情况。

代码实现

/**
 * Either包装，二元容器，同Optional类似。
 * 一般左值用于封装异常情况，右值用于封装正确情况
 *
 * @author Gloduck
 * @date 2022/12/26
 */
public class Either<L, R> extends DisjointItem<L, R> {

    /**
     * 右值，一般为正确的值
     *
     * @param right 正确的值
     * @return either包装
     */
    public static <L, R> Either<L, R> right(R right) {
        Objects.requireNonNull(right);
        return new Right<>(right);
    }


    /**
     * 左值，一般为错误的值
     *
     * @param left 错误的值
     * @return either包装
     */
    public static <L, R> Either<L, R> left(L left) {
        Objects.requireNonNull(left);
        return new Left<>(left);
    }


    /**
     * 是否是左值
     */
    public boolean isLeft() {
        return Objects.equals(this.getClass(), Left.class);
    }

    /**
     * 是否是右值
     */
    public boolean isRight() {
        return Objects.equals(this.getClass(), Right.class);
    }

    /**
     * 当是右值的时候，继续映射，并且返回Either包装（如果某个步骤返回右值（包括当前节点），那么所有当前步骤之后的操作将被阻断）
     * 用法同：{@link Either#mapRightEither(Function)}，区别在于此方法是为左值才映射，mapRightEither为右值才映射
     *
     * @param eitherMapper 映射器
     * @return either包装
     */
    @SuppressWarnings("unchecked")
    public <V> Either<V, R> mapLeftEither(Function<L, Either<V, R>> eitherMapper) {
        Objects.requireNonNull(eitherMapper);
        if (isLeft()) {
            return eitherMapper.apply(left);
        } else {
            return (Either<V, R>) this;
        }
    }

    /**
     * 当是左值的时候进行映射
     * 如果当前对象为右值，那么所有之后的操作将被阻断
     *
     * @param leftMapper 左值映射器
     * @return either包装
     */
    @SuppressWarnings("unchecked")
    public <V> Either<V, R> mapLeft(Function<L, V> leftMapper) {
        Objects.requireNonNull(leftMapper);
        if (isLeft()) {
            return left(leftMapper.apply(left));
        } else {
            return (Either<V, R>) this;
        }
    }

    /**
     * 当是右值的时候，继续映射，并且返回Either包装（如果某个步骤返回左值（包括当前节点），那么所有当前步骤之后的操作将被阻断）
     * <pre>
     *  Student student = Student.boy(1, "kxt");
     *  Either<String, Student> studentEither = Either.right(student);
     *  Either<String, Integer> idEither = studentEither.mapRightEither(i -> i.getId() > 0 ? Either.right(i) : Either.left("当前用户ID错误"))
     *          .mapRightEither(i -> !i.getSex() ? Either.right(i.getId()) : Either.left("当前用户不为男生"));
     *  System.out.println(idEither.isLeft());
     *  System.out.println(idEither.getLeft());
     * </pre>
     * 如以上代码，如果false表示男生，true表示女生。
     * Student student = Student.boy(1, "kxt")，则：idEither.isLeft() = false,idEither.getLeft() = null;
     * Student student = Student.girl(1, "kxt")，则：idEither.isLeft() = true,idEither.getLeft() = 当前用户不为男生;
     * Student student = Student.boy(-1, "kxt")，则：idEither.isLeft() = true,idEither.getLeft() = 当前用户ID错误;
     *
     * @param eitherMapper 映射器
     * @return either包装
     */
    @SuppressWarnings("unchecked")
    public <V> Either<L, V> mapRightEither(Function<R, Either<L, V>> eitherMapper) {
        Objects.requireNonNull(eitherMapper);
        if (isRight()) {
            return eitherMapper.apply(right);
        } else {
            return (Either<L, V>) this;
        }
    }

    /**
     * 当是右值的时候进行映射
     * 如果当前对象为左值，那么所有之后的操作将被阻断
     *
     * @param rightMapper 右值映射器
     * @return either包装
     */
    @SuppressWarnings("unchecked")
    public <V> Either<L, V> mapRight(Function<R, V> rightMapper) {
        Objects.requireNonNull(rightMapper);
        if (isRight()) {
            return right(rightMapper.apply(right));
        } else {
            return (Either<L, V>) this;
        }
    }


    /**
     * 对值进行映射，为左值，则映射左值，否则映射右值
     *
     * @param leftMapper  左值映射器
     * @param rightMapper 右值映射器
     * @return either包装
     */
    public <T, V> Either<T, V> map(Function<L, T> leftMapper, Function<R, V> rightMapper) {
        Objects.requireNonNull(leftMapper);
        Objects.requireNonNull(rightMapper);
        return isLeft() ? left(leftMapper.apply(left)) : right(rightMapper.apply(right));
    }


    private Either(L left, R right) {
        super(left, right);
    }

    /**
     * 覆盖父类的创建方法
     */
    public static <L, R> Either<L, R> create(L left, R right) {
        throw new UnsupportedOperationException("can't create either by create method");
    }

    private static class Left<L, R> extends Either<L, R> {
        private Left(L left) {
            super(left, null);
        }
    }

    private static class Right<L, R> extends Either<L, R> {
        private Right(R right) {
            super(null, right);
        }
    }
}

/**
 * 不相交项
 *
 * @author Gloduck
 * @date 2023/01/13
 */
public class DisjointItem<L, R> {

    /**
     * 左值
     */
    protected final L left;

    /**
     * 右值
     */
    protected final R right;

    protected DisjointItem(L left, R right) {
        this.left = left;
        this.right = right;
    }

    public static <L, R> DisjointItem<L, R> create(L left, R right){
        return new DisjointItem<>(left, right);
    }

    public L getLeft() {
        return left;
    }

    public R getRight() {
        return right;
    }

    @Override
    public String toString() {
        return "DisjointItem{" +
                "left=" + left +
                ", right=" + right +
                '}';
    }
}

实际场景

一种场景是作为Service层方法的返回值：如一个登录方法，登录成功后返回用户信息，我们在Service层处理的过程中，可能会遇到找不到用户、用户密码不匹配的情况。我们可以通过异常来处理这些错误情况。如下：

public User login(String account, String password){
    User user = userDao.findUserByAccount(account);
    if(user != null){
        throw new ServiceException("用户不存在");
    }
    if(Objects.equals(password, user.getPassword())){
        throw new ServiceException("用户密码错误");
    }
    return user;
}

这种场景，如果是在本地接口的话，那么其实这种方法挺合适的，但是如果这个是一个对外的RPC方法，那么这个就不合理了。外层的方法不应该去处理你这些业务异常。那么，我们就可以使用Either来进行修改：

public Either<String, User> login(String account, String password){
    User user = userDao.findUserByAccount(account);
    if(user != null){
        return Either.left("用户不存在");
    }
    if(Objects.equals(password, user.getPassword())){
        return Either.left("用户密码错误");
    }
    return Either.right(user);
}

这样RPC调用方，就可以通过Either来判断调用结果是否成功了，甚至能通过map方法进行链式的后续处理。
另外一种场景就是可以将其当作下面的Try来使用。例如读取Excel这种场景，使用Either来防止Excel格式不正确就很方便了。

Try

基本简介

Try 有两个子类型：
1. Success[A]：代表成功的计算。
2. 封装了 Throwable 的 Failure[A]：代表出了错的计算。
如果知道一个计算可能导致错误，我们可以简单的使用 Try[A] 作为函数的返回类型。这使得出错的可能性变得很明确，而且强制客户端以某种方式处理出错的可能。
Try的使用和Option比较类似，同时，Try可以相当于一个特化版的Either。

代码实现

这里除了实现了Try的功能，还给Try封装了一个sneakyThrows的语义，这个和Lombok中的SneakyThrows就比较类似了。

/**
 * try，用于封装可能会出现异常的方法
 *
 * @author Gloduck
 * @date 2022/12/26
 */
public final class Try<T> {
    /**
     * 异常
     */
    private final Throwable exception;

    /**
     * 值
     */
    private final T value;

    /**
     * 创建一个try包装
     *
     * @param supplier 生成器
     * @return try包装
     */
    public static <V> Try<V> of(CheckedSupplier<V> supplier) {
        Objects.requireNonNull(supplier);
        try {
            return success(supplier.get());
        } catch (Throwable ex) {
            return failure(ex);
        }
    }

    /**
     * 创建一个try包装
     *
     * @param action 执行的操作
     * @return try包装
     */
    public static Try<Void> of(CheckedAction action) {
        Objects.requireNonNull(action);
        try {
            action.action();
            return success(null);
        } catch (Throwable ex) {
            return failure(ex);
        }
    }

    /**
     * 同lombok的SneakyThrows，可以把非RuntimeException封装成RuntimeException
     *
     * @param action 执行的操作
     */
    public static void sneakyThrows(CheckedAction action) {
        Objects.requireNonNull(action);
        try {
            action.action();
        } catch (Throwable ex) {
            throw toRuntimeException(ex);
        }
    }

    /**
     * 同lombok的SneakyThrows，可以把非RuntimeException封装成RuntimeException
     *
     * @param supplier 生成器
     */
    public static <V> V sneakyThrows(CheckedSupplier<V> supplier) {
        Objects.requireNonNull(supplier);
        try {
            return supplier.get();
        } catch (Throwable ex) {
            throw toRuntimeException(ex);
        }
    }

    /**
     * 当前步骤后执行
     *
     * @param function 生成器
     * @return try包装
     */
    @SuppressWarnings("unchecked")
    public <V> Try<V> thenTry(CheckedFunction<T, V> function) {
        Objects.requireNonNull(function);
        return isSuccess() ? of(() -> function.apply(value)) : (Try<V>) this;
    }

    /**
     * 使用给定的值，修复错误（如果出现错误）
     *
     * @param repairData 修复后的值
     * @return 修复后的try包装
     */
    public Try<T> repair(T repairData) {
        if (isSuccess()) {
            return this;
        }
        return Try.success(repairData);
    }

    /**
     * 修复错误，如果出现错误将会使用supplier修复错误
     *
     * @param supplier 修复错误的生成器
     * @return 修复后的try包装
     */
    public Try<T> repair(CheckedSupplier<T> supplier) {
        Objects.requireNonNull(supplier);
        if (isSuccess()) {
            return this;
        }
        return of(supplier);
    }

    /**
     * 是否成功
     *
     * @return 是否成功
     */
    public boolean isSuccess() {
        return exception == null;
    }

    /**
     * 是否失败
     *
     * @return 是否成功
     */
    public boolean isFailed() {
        return exception != null;
    }

    /**
     * 转化为either
     *
     * @return either
     */
    public Either<Throwable, T> either() {
        return isSuccess() ? Either.right(value) : Either.left(exception);
    }

    /**
     * 将异常转换为运行时异常（如果非运行时异常的话）
     *
     * @param ex 待转换异常
     */
    private static RuntimeException toRuntimeException(Throwable ex) {
        if (!(ex instanceof RuntimeException)) {
            ex = new RuntimeException(ex);
        }
        return (RuntimeException) ex;
    }

    private static <V> Try<V> failure(Throwable ex) {
        return new Try<>(null, ex);
    }

    private static <V> Try<V> success(V value) {
        return new Try<>(value, null);
    }

    private Try(T value, Throwable ex) {
        this.value = value;
        this.exception = ex;
    }

    public Throwable getException() {
        return exception;
    }

    public T getValue() {
        return value;
    }
}

一些Functional接口的实现。

/**
 * 受检查的Action，，其可以抛出异常
 *
 * @author Gloduck
 * @date 2022/12/26
 */
@FunctionalInterface
public interface CheckedAction {
    /**
     * 执行
     * @throws Throwable 可能的异常
     */
    void action() throws Throwable;
}

/**
 * 受检查的Function，区别于内置的Function，其可以抛出异常
 *
 * @author Gloduck
 * @date 2022/12/26
 */
@FunctionalInterface
public interface CheckedFunction<T, R> {

    /**
     * 使用给的参数获取值
     * @param t 给的参数
     * @return 获取的值
     * @throws Throwable 可能的异常
     */
    R apply(T t) throws Throwable;

}

/**
 * 受检查的Supplier，区别于内置的Supplier，其可以抛出异常
 *
 * @author Gloduck
 * @date 2022/12/26
 */
@FunctionalInterface
public interface CheckedSupplier<T> {
    /**
     * 获取值
     *
     * @return 获取的值
     * @throws Throwable 可能的异常
     */
    T get() throws Throwable;

}

使用场景

Try场景

Try其实就是相当于把try...catch...换了一种表示形式，这种形式在Lambda表达式中尤为可靠。

如以下场景：有一批URI列表（String类型），里面可能包含不正确的URI，我们需要请求此URI获取其内容，那么不用Try的写法如下：

List<String> contentLists = urls.stream().map(s -> {
    try {
        return new URI(s);
    } catch (URISyntaxException e) {
        return null;
    }
}).filter(Objects::nonNull).map(uri -> {
    try {
        return Files.readString(Path.of(uri));
    } catch (IOException e) {
        return "";
    }
}).filter(Objects::nonNull).collect(Collectors.toList());

可以看到上述代码为了解决异常，使得代码变得比较臃肿。替换为Try后，效果如下：

List<Try<String>> contentLists = urls.stream()
    .map(s -> Try.of(() -> new URI(s)))
    .filter(Try::isSuccess)
    .map(uriTry -> uriTry.thenTry(uri -> Files.readString(Path.of(uri))).repair(() -> ""))
    .collect(Collectors.toList());

SneakyThrows场景

至于封装的SneakyThrows的使用如下，如当前线程睡眠几秒：

try {
    TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {

}

可以替换为：

1	`Try.sneakyThrows(() -> TimeUnit.SECONDS.sleep(1));`

如何在Java中使用一些函数接口来优化代码

Gloduck 发布于 2023-02-07

最后更新于 2023-02-27

文章访问量

简介

Option

基本简介

Lazy

基本简介

代码实现

实际场景

Either

基本简介

代码实现

实际场景

Try

基本简介

代码实现

使用场景

Try场景

SneakyThrows场景

Gloduck