io.netty.channel.ChannelHandlerContext#disconnect ( )源码实例Demo

@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
        throws Exception {

    if (evt instanceof IdleStateEvent) {
        IdleStateEvent event = (IdleStateEvent) evt;
        if (event.state() == IdleState.READER_IDLE) {
            log.info("READER_IDLE read timeout");
            ctx.disconnect();
        } else if (event.state() == IdleState.WRITER_IDLE) {
            log.info("WRITER_IDLE write timeout");
            ctx.disconnect();
        } else if (event.state() == IdleState.ALL_IDLE) {
            log.info("ALL_IDLE total timeout");
            ctx.disconnect();
        }
    }
}
 

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
    // logger.error("network error ", cause);
    // lost the connection，get ip info
    String host = ((SocketChannel) ctx.channel()).remoteAddress().getAddress().getHostAddress();
    Integer port = ((SocketChannel) ctx.channel()).remoteAddress().getPort();

    logger.debug(
            " exceptionCaught, disconnect "
                    + host
                    + ":"
                    + String.valueOf(port)
                    + " ,"
                    + String.valueOf(ctx.channel().isActive()));

    ctx.disconnect();
    ctx.close();
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    if (logger.isEnabled(internalLevel)) {
        logger.log(internalLevel, format(ctx, "DISCONNECT"));
    }
    ctx.disconnect(promise);
}
 

private void closeOutboundAndChannel(
        final ChannelHandlerContext ctx, final ChannelPromise promise, boolean disconnect) throws Exception {
    if (!ctx.channel().isActive()) {
        if (disconnect) {
            ctx.disconnect(promise);
        } else {
            ctx.close(promise);
        }
        return;
    }

    outboundClosed = true;
    engine.closeOutbound();

    ChannelPromise closeNotifyPromise = ctx.newPromise();
    try {
        flush(ctx, closeNotifyPromise);
    } finally {
        // It's important that we do not pass the original ChannelPromise to safeClose(...) as when flush(....)
        // throws an Exception it will be propagated to the AbstractChannelHandlerContext which will try
        // to fail the promise because of this. This will then fail as it was already completed by safeClose(...).
        // We create a new ChannelPromise and try to notify the original ChannelPromise
        // once it is complete. If we fail to do so we just ignore it as in this case it was failed already
        // because of a propagated Exception.
        //
        // See https://github.com/netty/netty/issues/5931
        safeClose(ctx, closeNotifyPromise, ctx.newPromise().addListener(
                new ChannelPromiseNotifier(false, promise)));
    }
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    if (logger.isEnabled(internalLevel)) {
        logger.log(internalLevel, format(ctx, "DISCONNECT"));
    }
    ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    // HTTP/2 connection requirements:
    //
    // When either endpoint closes the transport-level connection,
    // it must first send a GOAWAY frame.
    //
    // Avoid NotYetConnectedException
    if (!ctx.channel().isActive()) {
        ctx.disconnect(promise);
    } else {
        sendGoAwayFrame(ctx, promise);
    }
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) {
  ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    ctx.disconnect(promise);
}
 

@SuppressWarnings("FutureReturnValueIgnored")
@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) {
  failAndResetUserPromise(new ClosedChannelException());
  ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
  Gdx.app.debug(TAG, "disconnect");
  ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
  if (DEBUG_CALLS) Gdx.app.debug(TAG, "disconnect");
  ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    // Try to flush one last time if flushes are pending before disconnect the channel.
    resetReadAndFlushIfNeeded(ctx);
    ctx.disconnect(promise);
}
 

public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) {
    ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext nettyctx, ChannelPromise promise)
        throws Exception {
    nettyctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
  ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    ctx.disconnect(promise);
}
 

@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
  Gdx.app.debug(TAG, "disconnect");
  ctx.disconnect(promise);
}
 

/**
 * Called once a disconnect operation is made.
 *
 * @param context the {@link ChannelHandlerContext} for which the disconnect operation is made
 * @param promise the {@link ChannelPromise} to notify once the operation completes
 */
@Override
public void disconnect(final ChannelHandlerContext context, final ChannelPromise promise) {
    this.traceOperation(context, "disconnect");
    context.disconnect(promise);
}