使用Suppliers.memoize处理抛IOException的方法时，如何优雅转发异常？

这个问题本质上是因为Guava的Supplier<T>接口的get()方法没有声明抛出检查型异常，而你的供给函数会抛出IOException（属于检查型异常），直接用Suppliers.memoize()包装时，编译器会要求你处理这个未声明的异常，导致代码变得冗余。下面给你几个简洁的解决方案，让你能优雅地把IOException转发给调用方：

方案一：自定义带检查型异常的Supplier接口（最推荐） #

我们可以先定义一个支持抛出检查型异常的Supplier接口，然后封装Guava的memoize逻辑来处理异常的包装与拆包，这样复用性拉满，代码也干净：

@FunctionalInterface
public interface CheckedSupplier<T, E extends Exception> {
    T get() throws E;
}

// 工具类：实现带检查型异常的memoize
public class CheckedSuppliers {
    public static <T, E extends Exception> CheckedSupplier<T, E> memoize(CheckedSupplier<T, E> supplier) {
        // 先用Guava包装成普通Supplier，把检查型异常包装成RuntimeException
        Supplier<T> memoized = Suppliers.memoize(() -> {
            try {
                return supplier.get();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        // 再包装回CheckedSupplier，把RuntimeException拆回原始检查型异常
        return () -> {
            try {
                return memoized.get();
            } catch (RuntimeException e) {
                if (e.getCause() instanceof Exception) {
                    @SuppressWarnings("unchecked")
                    E originalException = (E) e.getCause();
                    throw originalException;
                }
                throw e;
            }
        };
    }
}

使用方式 #

在你的类里直接用这个自定义的memoize方法，构造器或调用方可以直接抛出IOException，完全不用额外处理：

public class YourClass {
    private final CheckedSupplier<YourObject, IOException> memoizedLoader;

    // 构造器可以直接抛出IOException，转发给调用方
    public YourClass() throws IOException {
        this.memoizedLoader = CheckedSuppliers.memoize(this::loadYourObject);
        // 如果需要在构造器里提前初始化（触发第一次加载）
        memoizedLoader.get();
    }

    // 业务方法也能直接抛出原始异常
    public YourObject getObject() throws IOException {
        return memoizedLoader.get();
    }

    // 你的原始加载方法，抛出IOException
    private YourObject loadYourObject() throws IOException {
        // ... 加载逻辑
    }
}

这个方案的好处是把异常处理逻辑封装在工具类里，业务代码完全不用关心包装拆包的细节，非常简洁。

方案二：直接包装+拆包（快速实现，无需自定义接口） #

如果不想额外定义接口，可以在使用Suppliers.memoize()时，手动包装异常，然后在需要获取结果的地方拆包抛出原始异常：

public class YourClass {
    private final Supplier<YourObject> memoizedSupplier;

    public YourClass() {
        // 把IOException包装成RuntimeException，让Supplier能通过编译
        this.memoizedSupplier = Suppliers.memoize(() -> {
            try {
                return loadYourObject();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
    }

    // 在获取结果时拆包，把RuntimeException转回IOException抛出
    public YourObject getObject() throws IOException {
        try {
            return memoizedSupplier.get();
        } catch (RuntimeException e) {
            if (e.getCause() instanceof IOException) {
                throw (IOException) e.getCause();
            }
            throw e; // 非IOException的异常直接抛出
        }
    }

    private YourObject loadYourObject() throws IOException {
        // ... 加载逻辑
    }
}

如果需要在构造器里触发初始化（比如提前加载对象），只需要在构造器里调用getObject()并抛出异常即可：

public YourClass() throws IOException {
    this.memoizedSupplier = Suppliers.memoize(() -> {
        try {
            return loadYourObject();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    });
    getObject(); // 触发加载，异常会被getObject()拆包抛出
}

这个方案的优点是不用额外写工具类，适合快速解决问题，但如果多个地方需要使用，代码会有重复的try-catch逻辑。

方案三：用CompletableFuture实现memoization（适合异步场景） #

如果你能接受用Java 8的CompletableFuture来实现缓存逻辑，也可以这样写，它天然支持异常传递：

public class YourClass {
    private final CompletableFuture<YourObject> cachedObject;

    public YourClass() {
        // 异步加载（如果需要同步可以去掉supplyAsync，直接调用loadYourObject）
        this.cachedObject = CompletableFuture.supplyAsync(this::loadYourObject)
                .exceptionally(ex -> {
                    // 把检查型异常包装成CompletionException
                    throw new CompletionException(ex);
                });
    }

    public YourObject getObject() throws IOException {
        try {
            return cachedObject.get();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new IOException("加载被中断", e);
        } catch (ExecutionException e) {
            if (e.getCause() instanceof IOException) {
                throw (IOException) e.getCause();
            }
            throw new RuntimeException("加载失败", e.getCause());
        }
    }

    private YourObject loadYourObject() throws IOException {
        // ... 加载逻辑
    }
}

这个方案适合需要异步加载的场景，但如果只是简单的同步缓存，相比前两种方案会稍显复杂。

内容的提问来源于stack exchange，提问作者Shvalb