Examples of io.netty.channel.ChannelHandler

io.netty.channel.ChannelHandler
methods here } public class DataServerHandler extends {@link ChannelInboundMessageHandlerAdapter}<Message> { private boolean loggedIn; {@code @Override}public void messageReceived( {@link ChannelHandlerContext} ctx, Message message) {{@link Channel} ch = e.getChannel();if (message instanceof LoginMessage) { authenticate((LoginMessage) message); loggedIn = true; } else (message instanceof GetDataMessage) { if (loggedIn) { ch.write(fetchSecret((GetDataMessage) message)); } else { fail(); } } } ... } Because the handler instance has a state variable which is dedicated to one connection, you have to create a new handler instance for each new channel to avoid a race condition where a unauthenticated client can get the confidential information:
```
 // Create a new handler instance per channel. // See  {@link ChannelInitializer#initChannel(Channel)}. public class DataServerInitializer extends  {@link ChannelInitializer}< {@link Channel}> { {@code @Override}public void initChannel( {@link Channel} channel) {channel.pipeline().addLast("handler", new DataServerHandler()); } } 
```
Using an attachment
Although it's recommended to use member variables to store the state of a handler, for some reason you might not want to create many handler instances. In such a case, you can use an attachment which is provided by {@link ChannelHandlerContext}:
```
 public interface Message { // your methods here } {@code @Sharable}public class DataServerHandler extends  {@link ChannelInboundMessageHandlerAdapter}<Message> { private final  {@link AttributeKey}< {@link Boolean}> auth = new  {@link AttributeKey}< {@link Boolean}>("auth"); // This handler will receive a sequence of increasing integers starting // from 1. {@code @Override}public void messageReceived( {@link ChannelHandlerContext} ctx, {@link Integer} integer) {{@link Attribute}< {@link Boolean}> attr = ctx.getAttr(auth); {@code @Override}public void messageReceived( {@link ChannelHandlerContext} ctx, Message message) {{@link Channel} ch = ctx.channel();if (message instanceof LoginMessage) { authenticate((LoginMessage) o); attr.set(true); } else (message instanceof GetDataMessage) { if (Boolean.TRUE.equals(attr.get())) { ch.write(fetchSecret((GetDataMessage) o)); } else { fail(); } } } ... } 
```
Now that the state of the handler is stored as an attachment, you can add the same handler instance to different pipelines:
```
 public class DataServerInitializer extends  {@link ChannelInitializer}< {@link Channel}> { private static final DataServerHandler SHARED = new DataServerHandler(); {@code @Override}public void initChannel( {@link Channel} channel) {channel.pipeline().addLast("handler", SHARED); } } 
```
The {@code @Sharable} annotation
In the examples above which used an attachment, you might have noticed the {@code @Sharable} annotation.
If a {@link ChannelHandler} is annotated with the {@code @Sharable}annotation, it means you can create an instance of the handler just once and add it to one or more {@link ChannelPipeline}s multiple times without a race condition.
If this annotation is not specified, you have to create a new handler instance every time you add it to a pipeline because it has unshared state such as member variables.
This annotation is provided for documentation purpose, just like the JCIP annotations.
Additional resources worth reading

Please refer to the {@link ChannelHandler}, and {@link ChannelPipeline} to find out more about inbound and outbound operations,what fundamental differences they have, how they flow in a pipeline, and how to handle the operation in your application.

        public void write(final ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            // Add the timeout handler when write is complete.
            promise.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    ChannelHandler timeoutHandler = ctx.pipeline().get(READ_TIMEOUT_HANDLER_NAME);
                    if (null == timeoutHandler) {
                        ctx.pipeline().addFirst(READ_TIMEOUT_HANDLER_NAME, new ReadTimeoutHandler(timeout, timeUnit));
                    } else {
                        // This will always be invoked from the eventloop as it is a future listener callback.
                        ChannelHandlerContext handlerContext = ctx.pipeline().context(timeoutHandler);
                        timeoutHandler.handlerAdded(handlerContext);
                    }
                }
            });
            super.write(ctx, msg, promise);
        }

View Full Code Here


        /**
         * This method is called for each new connection & the following two channel handlers are not shareable, so
         * we need to create a new instance every time.
         */
        ChannelHandler lifecycleHandler = newConnectionLifecycleHandler(pipeline);
        ObservableAdapter observableAdapter = new ObservableAdapter();


        pipeline.addFirst(BYTES_INSPECTOR_HANDLER_NAME, bytesInspector);
        pipeline.addLast(getConnectionLifecycleHandlerExecutor(), CONN_LIFECYCLE_HANDLER_NAME, lifecycleHandler);
        pipeline.addLast(getObservableAdapterExecutor(), NETTY_OBSERVABLE_ADAPTER_NAME, observableAdapter);

View Full Code Here

                        subscriber.onError(future.cause());
                    } else {
                        eventsSubject.onEvent(ClientMetricsEvent.CONNECT_SUCCESS, Clock.onEndMillis(startTimeMillis));
                        ChannelPipeline pipeline = future.channel().pipeline();
                        final ObservableConnection<I, O> newConnection = connectionFactory.newConnection(future.channel());
                        ChannelHandler lifecycleHandler = pipeline.get(RxRequiredConfigurator.CONN_LIFECYCLE_HANDLER_NAME);
                        if (null == lifecycleHandler) {
                            onNewConnection(newConnection, subscriber);
                        } else {
                            @SuppressWarnings("unchecked")
                            ConnectionLifecycleHandler<I, O> handler = (ConnectionLifecycleHandler<I, O>) lifecycleHandler;

View Full Code Here

        if (handler() != null) {
            p.addLast(handler());
        }


        final EventLoopGroup currentChildGroup = childGroup;
        final ChannelHandler currentChildHandler = childHandler;
        final Entry<ChannelOption<?>, Object>[] currentChildOptions;
        final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
        synchronized (childOptions) {
            currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
        }

View Full Code Here

        }


        final BlockingQueue<ChannelFuture> futureQueue =
            new LinkedBlockingQueue<ChannelFuture>();


        ChannelHandler binder = new Binder(localAddress, futureQueue);
        ChannelHandler parentHandler = getParentHandler();


        ChannelPipeline bossPipeline = pipeline();
        bossPipeline.addLast("binder", binder);
        if (parentHandler != null) {
            bossPipeline.addLast("userHandler", parentHandler);

View Full Code Here

                    "handlers should contain at least one " +
                    ChannelHandler.class.getSimpleName() + '.');
        }


        for (int i = 0; i < handlers.length; i ++) {
            ChannelHandler h = handlers[i];
            if (h == null) {
                throw new NullPointerException("handlers[" + i + "]");
            }
            pipeline.addLast(String.valueOf(i), handlers[i]);
        }

View Full Code Here

        if (handler() != null) {
            p.addLast(handler());
        }


        final EventLoopGroup currentChildGroup = childGroup;
        final ChannelHandler currentChildHandler = childHandler;
        final Entry<ChannelOption<?>, Object>[] currentChildOptions;
        final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
        synchronized (childOptions) {
            currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
        }

View Full Code Here

        if (handler() != null) {
            p.addLast(handler());
        }


        final EventLoopGroup currentChildGroup = childGroup;
        final ChannelHandler currentChildHandler = childHandler;
        final Entry<ChannelOption<?>, Object>[] currentChildOptions;
        final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
        synchronized (childOptions) {
            currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
        }

View Full Code Here

    // Flush out all pending data
    endReadAndFlush();


    // remove old http handlers and replace the old handler with one that handle plain sockets
    ChannelPipeline pipeline = channel.pipeline();
    ChannelHandler inflater = pipeline.get(HttpContentDecompressor.class);
    if (inflater != null) {
      pipeline.remove(inflater);
    }
    pipeline.remove("codec");
    pipeline.replace("handler", "handler", new VertxNetHandler(client.getVertx(), connectionMap) {

View Full Code Here

      client.handleException(e);
    }


    private void handshakeComplete(ChannelHandlerContext ctx, FullHttpResponse response) {
      handshaking = false;
      ChannelHandler handler = ctx.pipeline().get(HttpContentDecompressor.class);
      if (handler != null) {
        // remove decompressor as its not needed anymore once connection was upgraded to websockets
        ctx.pipeline().remove(handler);
      }
      ws = new WebSocketImpl(vertx, ClientConnection.this, supportsContinuation, client.getOptions().getMaxWebsocketFrameSize());

View Full Code Here

0 1 2

TOP

Related Classes of io.netty.channel.ChannelHandler

io.netty.bootstrap.ServerBootstrap

io.netty.channel.embedded.EmbeddedChannelTest

io.netty.channel.local.LocalTransportThreadModelTest3

io.netty.handler.codec.embedder.AbstractCodecEmbedder

io.netty.handler.codec.marshalling.AbstractCompatibleMarshallingDecoderTest

io.netty.test.udt.bench.xfer.UdtNetty

io.netty.testsuite.transport.socket.SocketFileRegionTest

io.reactivex.netty.client.ClientChannelFactoryImpl

io.reactivex.netty.pipeline.ReadTimeoutPipelineConfigurator

io.reactivex.netty.pipeline.ReadTimeoutPipelineConfigurator$ReadTimeoutHandlerLifecycleManager

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of io.netty.channel.ChannelHandler

Using an attachment

The {@code @Sharable} annotation

Additional resources worth reading

Related Classes of io.netty.channel.ChannelHandler