import org.xnio.FutureResult; //导入依赖的package包/类
private static Channel getChannel ( ConnectionProviderContextImpl context, ConnectionHandler ch, OptionMap options ) throws IOException {
    Channel c;
    FutureResult<Channel> chResult = new FutureResult<Channel>(context.getExecutor());
    ch.open("jmx", chResult, options);

    IoFuture<Channel> cFuture = chResult.getIoFuture();
    Status s2 = cFuture.await();
    if ( s2 == Status.FAILED ) {
        System.err.println("Cannot connect");
        if ( cFuture.getException() != null ) {
            throw new IOException("Connect failed", cFuture.getException());
        }
    }
    else if ( s2 != Status.DONE ) {
        cFuture.cancel();
        throw new IOException("Connect timeout");
    }

    c = cFuture.get();
    return c;
}
 

import org.xnio.FutureResult; //导入依赖的package包/类
@Override
public IoFuture<byte[]> readRequestData() {
    final ByteArrayOutputStream data = new ByteArrayOutputStream();
    try {
        final ServletInputStream in = request.getInputStream();
        byte[] buf = new byte[1024];
        int r;
        while ((r = in.read(buf)) != -1) {
            data.write(buf, 0, r);
        }
        return new FinishedIoFuture<>(data.toByteArray());
    } catch (IOException e) {
        final FutureResult<byte[]> ioFuture = new FutureResult<>();
        ioFuture.setException(e);
        return ioFuture.getIoFuture();
    }
}
 

import org.xnio.FutureResult; //导入依赖的package包/类
public IoFuture<ClientConnection> connect(InetSocketAddress bindAddress, final URI uri, final XnioWorker worker, XnioSsl ssl, Pool<ByteBuffer> bufferPool, OptionMap options) {
    ClientProvider provider = getClientProvider(uri);
    final FutureResult<ClientConnection> result = new FutureResult<>();
    provider.connect(new ClientCallback<ClientConnection>() {
        @Override
        public void completed(ClientConnection r) {
            result.setResult(r);
        }

        @Override
        public void failed(IOException e) {
            result.setException(e);
        }
    }, bindAddress, uri, worker, ssl, bufferPool, options);
    return result.getIoFuture();
}
 

import org.xnio.FutureResult; //导入依赖的package包/类
@Override
public IoFuture<byte[]> readRequestData() {
    final ByteArrayOutputStream data = new ByteArrayOutputStream();
    try {
        byte[] buf = new byte[1024];
        int r;
        while ((r = in.read(buf)) != -1) {
            data.write(buf, 0, r);
        }
        return new FinishedIoFuture<>(data.toByteArray());
    } catch (IOException e) {
        final FutureResult<byte[]> ioFuture = new FutureResult<>();
        ioFuture.setException(e);
        return ioFuture.getIoFuture();
    }
}
 

import org.xnio.FutureResult; //导入依赖的package包/类
@Override
public IoFuture<Void> sendData(final ByteBuffer data) {
    try {
        final ServletOutputStream outputStream = response.getOutputStream();
        while (data.hasRemaining()) {
            outputStream.write(data.get());
        }
        return new FinishedIoFuture<>(null);
    } catch (IOException e) {
        final FutureResult<Void> ioFuture = new FutureResult<>();
        ioFuture.setException(e);
        return ioFuture.getIoFuture();
    }
}
 

import org.xnio.FutureResult; //导入依赖的package包/类
@Override
public IoFuture<Void> sendData(final ByteBuffer data) {
    try {
        while (data.hasRemaining()) {
            out.write(data.get());
        }
        return new FinishedIoFuture<>(null);
    } catch (IOException e) {
        final FutureResult<Void> ioFuture = new FutureResult<>();
        ioFuture.setException(e);
        return ioFuture.getIoFuture();
    }
}
 

import org.xnio.FutureResult; //导入依赖的package包/类
private static ConnectionHandlerFactory getConnection ( SocketAddress destination, final String username, final String password,
        ConnectionProviderContextImpl context, ConnectionProvider instance, OptionMap options )
                throws IOException, InterruptedException, KeyManagementException, NoSuchProviderException, NoSuchAlgorithmException {
    XnioSsl xnioSsl = new JsseXnioSsl(context.getXnio(), options);
    FutureResult<ConnectionHandlerFactory> result = new FutureResult<ConnectionHandlerFactory>();
    instance.connect(null, destination, options, result, new CallbackHandler() {

        public void handle ( Callback[] callbacks ) throws IOException, UnsupportedCallbackException {

            for ( Callback cb : callbacks ) {

                if ( cb instanceof NameCallback ) {
                    ( (NameCallback) cb ).setName(username);
                }
                else if ( cb instanceof PasswordCallback ) {
                    ( (PasswordCallback) cb ).setPassword(password != null ? password.toCharArray() : new char[0]);
                }
                else if ( !( cb instanceof RealmCallback) ) {
                    System.err.println(cb);
                    throw new UnsupportedCallbackException(cb);
                }
            }
        }
    }, xnioSsl);

    System.err.println("waiting for connection");
    IoFuture<ConnectionHandlerFactory> ioFuture = result.getIoFuture();
    Status s = ioFuture.await(5, TimeUnit.SECONDS);
    if ( s == Status.FAILED ) {
        System.err.println("Cannot connect");
        if ( ioFuture.getException() != null ) {
            ioFuture.getException().printStackTrace(System.err);
        }
    }
    else if ( s != Status.DONE ) {
        ioFuture.cancel();
        System.err.println("Connect timeout");
        System.exit(-1);
    }

    ConnectionHandlerFactory chf = ioFuture.getInterruptibly();
    return chf;
}