针对不同的场景,我们可能需要不同的回调,每一个回调操作是不同的
定义回调操作抽象类
public abstract abstract class Operation<V> implements Callable<V> {
/** 内部具体的执行操作 */
protected abstract V run() throws HttpRequestException, IOException;
/** 执行完成后的回调 **/
protected abstract void done() throws IOException;
/** 内部进行一列的异常捕获,确保 run 函数 和 done函数 正常执行 **/
public V call() throws HttpRequestException {
boolean thrown = false;
try {
return run();
} catch (HttpRequestException e) {
thrown = true;
throw e;
} catch (IOException e) {
thrown = true;
throw new HttpRequestException(e);
} finally {
try {
done();
} catch (IOException e) {
if (!thrown) {
throw new HttpRequestException(e);
}
}
}
}
}
我们定义一个 call
函数,内部调用 run
和 done
函数,这样我们可以针对不同的回调,我们可以继承此抽象类,实现不同 的 done
函数,来达到实现不同的回调操作,run
函数是调用者要实现的
实现一个自由控制的关闭回调
我们通过ignoreCloseExceptions
参数,来控制是否当 done
发生异常时,程序是忽略还是终止
public abstract class CloseOperation<V> extends Operation<V> {
private final Closeable closeable;
private final boolean ignoreCloseExceptions;
protected CloseOperation(final Closeable closeable, final boolean ignoreCloseExceptions) {
this.closeable = closeable;
this.ignoreCloseExceptions = ignoreCloseExceptions;
}
@Override
protected void done() throws IOException {
if (closeable instanceof Flushable) {
((Flushable) closeable).flush();
}
if (ignoreCloseExceptions) {
try {
closeable.close();
} catch (IOException e) {
// Ignored,如果发生异常了,程序继续执行,会忽略掉此异常
}
} else {
// 如果发生异常了,此时程序会退出
closeable.close();
}
}
}
实现一个流刷新操作,确保流正常刷新到底层
public abstract class FlushOperation<V> extends Operation<V> {
private final Flushable flushable;
protected FlushOperation(final Flushable flushable) {
this.flushable = flushable;
}
@Override
protected void done() throws IOException {
flushable.flush();
}
}
使用
new CloseOperation<HttpRequest>(reader, ignoreCloseExceptions) {
@Override
public HttpRequest run() throws IOException {
return copy(reader, writer);
}
}.call();
new FlushOperation<HttpRequest>(writer) {
@Override
protected HttpRequest run() throws IOException {
return copy(input, writer);
}
}.call();