使用Callable实现不同回调函数

针对不同的场景，我们可能需要不同的回调，每一个回调操作是不同的

定义回调操作抽象类

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();