Java IoFuture类代码示例

import org.xnio.IoFuture; //导入依赖的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.IoFuture; //导入依赖的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.IoFuture; //导入依赖的package包/类
@Override
public void connect(final ClientCallback<ClientConnection> listener, InetSocketAddress bindAddress, final URI uri, final XnioWorker worker, final XnioSsl ssl, final Pool<ByteBuffer> bufferPool, final OptionMap options) {
    ChannelListener<StreamConnection> openListener = new ChannelListener<StreamConnection>() {
        @Override
        public void handleEvent(StreamConnection connection) {
            handleConnected(connection, listener, uri, ssl, bufferPool, options);
        }
    };
    IoFuture.Notifier<StreamConnection, Object> notifier = new IoFuture.Notifier<StreamConnection, Object>() {
        @Override
        public void notify(IoFuture<? extends StreamConnection> ioFuture, Object o) {
            if (ioFuture.getStatus() == IoFuture.Status.FAILED) {
                listener.failed(ioFuture.getException());
            }
        }
    };
    if(bindAddress == null) {
        worker.openStreamConnection(new InetSocketAddress(uri.getHost(), uri.getPort() == -1 ? 8009 : uri.getPort()), openListener, options).addNotifier(notifier, null);
    } else {
        worker.openStreamConnection(bindAddress, new InetSocketAddress(uri.getHost(), uri.getPort() == -1 ? 8009 : uri.getPort()), openListener, null, options).addNotifier(notifier, null);
    }
}
 

import org.xnio.IoFuture; //导入依赖的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.IoFuture; //导入依赖的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.IoFuture; //导入依赖的package包/类
/**
 * Non-blocking connection attempt to the given URI endpoint
 * @throws XNIOException if unable to create XNIO worker
 */
@Override
public void connect() throws XNIOException {
    logger.debug("Trying to connect to {}", this.uri);
    IoFuture<WebSocketChannel> chanFuture = connectionBuilder().connect();
    chanFuture.addNotifier((ioFuture, client) -> {
        if (ioFuture.getStatus() == IoFuture.Status.DONE) {
            try {
                this.channel = ioFuture.get();
                this.channel.setIdleTimeout(this.idleTimeout);
                registerChannelReceivers();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            handlerService.submit(() -> onError(ioFuture.getException()));
        }
    }, this);
}
 

import org.xnio.IoFuture; //导入依赖的package包/类
/**
 * Blocking connection attempt to the given URI endpoint
 *
 * @param timeout time to wait in seconds before aborting connection attempt
 * @return true if connected; false otherwise
 * @throws IOException if something goes wrong with XNIO worker
 */
@Override
public boolean connectBlocking(long timeout) throws IOException {
    logger.debug("Connect blocking... ({})", this);
    IoFuture<WebSocketChannel> futureChan = connectionBuilder().connect();
    IoFuture.Status status = futureChan.await(timeout, TimeUnit.SECONDS);
    logger.debug("Connect blocking status: {}", status);
    switch (status) {
        case DONE:
            // ok
            this.channel = futureChan.get();
            this.channel.setIdleTimeout(this.idleTimeout);
            registerChannelReceivers();
            return true;

        default:
            // error or interrupted or timed-out
            return false;
    }
}
 

import org.xnio.IoFuture; //导入依赖的package包/类
@Override
public void connect() throws XNIOException {
    logger.debug("Trying to connect to {} ... {}", this.uri, this);
    connectionBuilder().connect().addNotifier(((ioFuture, client) -> {
        if (ioFuture.getStatus() == IoFuture.Status.DONE) {
            // ok
            try {
                this.channel = ioFuture.get();
                registerChannelReceivers();
                logger.debug("Connected :) {}", this.uri, this);
            } catch (IOException ignore) {}
        } else {
            handlerService.submit(() -> onError(ioFuture.getException()));
            startReconnectTask();
        }
    }), this);
}
 

import org.xnio.IoFuture; //导入依赖的package包/类
@Override
public boolean connectBlocking(long timeout) throws IOException {
    logger.debug("Connect blocking... ({})", this);
    IoFuture<WebSocketChannel> futureChan = connectionBuilder().connect();
    IoFuture.Status status = futureChan.await(timeout, TimeUnit.MILLISECONDS);
    logger.debug("Connect blocking status: {}", status);
    switch (status) {
        case DONE:
            // ok
            this.channel = futureChan.get();
            registerChannelReceivers();
            return true;

        default:
            handlerService.submit(() -> onError(futureChan.getException()));
            try {
                Thread.sleep(reconnectDelay);
                return this.connectBlocking(timeout);
            } catch (InterruptedException e) {
                logger.warn("Connect blocking interrupted while sleeping", e);
            }
            // error or interrupted or timed-out
            return false;
    }
}
 

import org.xnio.IoFuture; //导入依赖的package包/类
@Override
public Status await(IoFuture<?> future, long timeoutMillis) {
    final long startTime = System.currentTimeMillis();

    IoFuture.Status status = future.await(timeoutMillis, TimeUnit.MILLISECONDS);
    while (status == IoFuture.Status.WAITING) {
        if (thinking) {
            status = future.await(timeoutMillis, TimeUnit.MILLISECONDS);
        } else {
            long timeToWait = (timeoutMillis + thinkTime.get()) - (System.currentTimeMillis() - startTime);
            if (timeToWait > 0) {
                status = future.await(timeToWait, TimeUnit.MILLISECONDS);
            } else {
                return status;
            }
        }
    }

    return status;
}
 

import org.xnio.IoFuture; //导入依赖的package包/类
Channel openChannel(final Connection connection) throws IOException {
    final IoFuture<Channel> future = connection.openChannel(DEFAULT_CHANNEL_SERVICE_TYPE, OptionMap.EMPTY);
    future.await(10L, TimeUnit.SECONDS);
    if (future.getStatus() == IoFuture.Status.WAITING) {
        future.cancel();
        throw ProtocolLogger.ROOT_LOGGER.channelTimedOut();
    }
    final Channel channel = future.get();
    channel.addCloseHandler(new CloseHandler<Channel>() {
        @Override
        public void handleClose(final Channel old, final IOException e) {
            synchronized (ChannelStrategy.this) {
                if(ChannelStrategy.this.channel == old) {
                    ChannelStrategy.this.handler.handleClose(old, e);
                    ChannelStrategy.this.channel = null;
                }
            }
            handler.handleChannelClosed(old, e);
        }
    });
    return channel;
}
 

import org.xnio.IoFuture; //导入依赖的package包/类
private boolean connectUsingRemoting(CommandContext cmdCtx, RemotingMBeanServerConnection rmtMBeanSvrConn)
        throws IOException, CliInitializationException {
    Connection conn = rmtMBeanSvrConn.getConnection();
    Channel channel;
    final IoFuture<Channel> futureChannel = conn.openChannel("management", OptionMap.EMPTY);
    IoFuture.Status result = futureChannel.await(5, TimeUnit.SECONDS);
    if (result == IoFuture.Status.DONE) {
        channel = futureChannel.get();
    } else {
        futureChannel.cancel();
        return false;
    }

    ModelControllerClient modelCtlrClient = ExistingChannelModelControllerClient.createReceiving(channel, createExecutor());
    cmdCtx.bindClient(modelCtlrClient);

    return true;
}
 

import org.xnio.IoFuture; //导入依赖的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.IoFuture; //导入依赖的package包/类
private IoFuture.Notifier<StreamConnection, Object> createNotifier(final ClientCallback<ClientConnection> listener) {
    return new IoFuture.Notifier<StreamConnection, Object>() {
        @Override
        public void notify(IoFuture<? extends StreamConnection> ioFuture, Object o) {
            if (ioFuture.getStatus() == IoFuture.Status.FAILED) {
                listener.failed(ioFuture.getException());
            }
        }
    };
}
 

import org.xnio.IoFuture; //导入依赖的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();
    }
}