假设我有一个类和一个方法
class A {
void foo() throws Exception() {
...
}
}
现在我想调用foo的每个实例的A交付的流，如:
void bar() throws Exception {
Stream<A> as = ...
as.forEach(a -> a.foo());
}
问:如何正确地处理异常?代码不能在我的机器上编译，因为我没有处理可能由foo()抛出的异常。bar的抛出异常在这里似乎毫无用处。为什么呢?
当前回答
可以用这种方式包装和展开异常。
class A {
void foo() throws Exception {
throw new Exception();
}
};
interface Task {
void run() throws Exception;
}
static class TaskException extends RuntimeException {
private static final long serialVersionUID = 1L;
public TaskException(Exception e) {
super(e);
}
}
void bar() throws Exception {
Stream<A> as = Stream.generate(()->new A());
try {
as.forEach(a -> wrapException(() -> a.foo())); // or a::foo instead of () -> a.foo()
} catch (TaskException e) {
throw (Exception)e.getCause();
}
}
static void wrapException(Task task) {
try {
task.run();
} catch (Exception e) {
throw new TaskException(e);
}
}
其他回答
你可能想做以下其中一件事:
传播已检查异常， 包装它并传播未检查的异常，或者 捕获异常并停止传播。
有几个库可以让您轻松地做到这一点。下面的示例是使用我的NoException库编写的。
// Propagate checked exception
as.forEach(Exceptions.sneak().consumer(A::foo));
// Wrap and propagate unchecked exception
as.forEach(Exceptions.wrap().consumer(A::foo));
as.forEach(Exceptions.wrap(MyUncheckedException::new).consumer(A::foo));
// Catch the exception and stop propagation (using logging handler for example)
as.forEach(Exceptions.log().consumer(Exceptions.sneak().consumer(A::foo)));
您需要将您的方法调用包装到另一个方法调用中，在该方法调用中不抛出受控异常。您仍然可以抛出任何RuntimeException的子类。
一个正常的包装习语是这样的:
private void safeFoo(final A a) {
try {
a.foo();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
(超类型异常异常仅作为示例，永远不要尝试自己捕获它)
然后你可以用:as.forEach(this::safeFoo)调用它。
可以用这种方式包装和展开异常。
class A {
void foo() throws Exception {
throw new Exception();
}
};
interface Task {
void run() throws Exception;
}
static class TaskException extends RuntimeException {
private static final long serialVersionUID = 1L;
public TaskException(Exception e) {
super(e);
}
}
void bar() throws Exception {
Stream<A> as = Stream.generate(()->new A());
try {
as.forEach(a -> wrapException(() -> a.foo())); // or a::foo instead of () -> a.foo()
} catch (TaskException e) {
throw (Exception)e.getCause();
}
}
static void wrapException(Task task) {
try {
task.run();
} catch (Exception e) {
throw new TaskException(e);
}
}
我建议使用谷歌番石榴投掷类
传播(Throwable Throwable) 如果是对象，则传播可抛出的原样 实例的RuntimeException或Error，或其他作为最后的手段，包装 它在RuntimeException中，然后传播。**
void bar() {
Stream<A> as = ...
as.forEach(a -> {
try {
a.foo()
} catch(Exception e) {
throw Throwables.propagate(e);
}
});
}
更新:
现在它已被弃用:
void bar() {
Stream<A> as = ...
as.forEach(a -> {
try {
a.foo()
} catch(Exception e) {
Throwables.throwIfUnchecked(e);
throw new RuntimeException(e);
}
});
}
如果你只想调用foo，并且你更喜欢传播异常(不包装)，你也可以只使用Java的for循环(在使用一些技巧将流转换为Iterable之后):
for (A a : (Iterable<A>) as::iterator) {
a.foo();
}
这至少是我在JUnit测试中所做的，我不想麻烦地包装我检查过的异常(实际上更喜欢我的测试抛出未包装的原始异常)
