Netty 4 read/write in handler multiple times

Question

I'm new in Netty, and I decided to start with 4.0.0, because I thought it should be better, because it's newer. My server application should receive data from gps devices, and the process is like this - at first I'm receiving 2 bytes, which are length of device imei, and then I'm receiving imei with that length, then I should send 0x01 to device if I want to accept data from it. After my answer device sends me gps data with AVL protocol. Now my server is working without Netty, and I want to change it to work with netty. This is what I have done:

I have created server class like this

public class BusDataReceiverServer {

private final int port;
private final Logger LOG = LoggerFactory.getLogger(BusDataReceiverServer.class);

public BusDataReceiverServer(int port) {
    this.port = port;
}

public void run() throws Exception {
    LOG.info("running thread");
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try{
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new BusDataReceiverInitializer());
        b.bind(port).sync().channel().closeFuture().sync();
    }catch (Exception ex){
        LOG.info(ex.getMessage());
    }
    finally {
        LOG.info("thread closed");
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

public static void main(String[] args) throws Exception {
    new BusDataReceiverServer(3129).run();
}

}

and created initializer class

public class BusDataReceiverInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();

        pipeline.addLast("imeiDecoder", new ImeiDecoder());
        pipeline.addLast("busDataDecoder", new BusDataDecoder());
        pipeline.addLast("encoder", new ResponceEncoder());

        pipeline.addLast("imeiHandler", new ImeiReceiverServerHandler());
        pipeline.addLast("busDataHandler", new BusDataReceiverServerHandler());
    }
}

then I have created decoders and encoder and 2 handlers. My imeiDecoder and encoder, and ImeiReceiverServerHandler are working. This is my ImeiReceiverServerHandler

public class ImeiReceiverServerHandler extends ChannelInboundHandlerAdapter {

    private final Logger LOG = LoggerFactory.getLogger(ImeiReceiverServerHandler.class);

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageList<Object> msgs) throws Exception {
        MessageList<String> imeis = msgs.cast();
        String imei = imeis.get(0);

        ctx.write(Constants.BUS_DATA_ACCEPT);
        ctx.fireMessageReceived(msgs);

    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        super.channelInactive(ctx);    //To change body of overridden methods use File | Settings | File Templates.
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);    //To change body of overridden methods use File | Settings | File Templates.
    }
}

Now, after accepting I don't understand how to continue receive gps data and forward it to handler BusDataReceiverServerHandler. If anyone could help me with this or could offer me useful documentation, I will be very grateful. Or if it is possible to do this with Netty 3, for this I will also be thankful.

Answer 1

I have not used Netty 4, so I am not sure if my answer will be 100% accurate or the best way to do things in Netty 4, but what you need to do is track the state of your connection / client session in order to know when to forward messages to your second handler.

E.g.

private enum HandlerState { INITIAL, IMEI_RECEIVED; }
private HandlerState state = HandlerState.INITIAL;

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageList<Object> msgs) throws Exception
{

    if (state == HandlerState.INITIAL)
    {
        MessageList<String> imeis = msgs.cast();
        String imei = imeis.get(0);

        ctx.write(Constants.BUS_DATA_ACCEPT);
        state = HandlerState.IMEI_RECEIVED;
    } else
    {
        // Forward message to next handler...
        // Not sure exactly how this is done in Netty 4
        // Maybe: ctx.fireMessageReceived(msgs);
        // Or maybe it is:
        // ctx.nextInboundMessageBuffer().add(msg);
        // ctx.fireInboundBufferUpdated();

        // I believe you could also remove the IMEI handler from the
        // pipeline instead of having it keep state, if it is not going to do anything
        // further.
    }

}

So either track state in the handler, or remove the handler from the pipeline once it has finished if it will not be used further. When tracking state, you can either keep the state in the handler itself (as shown above), or keep the state variables in the context / attribute map (however that is done in netty 4).

The reason to not keep the state in the handler itself would be if you were going to make the handler shareable (one instance used across multiple channels). It is not necessary to do this, but there could be some resource savings if you have a large number of concurrent channels.