Fix Format

libraries-server/src/main/java/com/baeldung/netty/CalculatorOperationHandler.java

@@ -0,0 +1,49 @@
+package com.baeldung.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.codec.http.*;
+import io.netty.util.CharsetUtil;
+
+public class CalculatorOperationHandler extends SimpleChannelInboundHandler<Operation> {
+
+    protected void channelRead0(ChannelHandlerContext ctx, Operation msg) throws Exception {
+        Long result = calculateEndpoint(msg);
+        sendHttpResponse(ctx, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CREATED), result.toString());
+        ctx.fireChannelRead(result);
+    }
+
+    private long calculateEndpoint(Operation operation) {
+
+        String operator = operation.getOperator().toLowerCase().trim();
+        switch (operator) {
+            case "add":
+                return operation.getNumber1() + operation.getNumber2();
+            case "multiply":
+                return operation.getNumber1() * operation.getNumber2();
+            default:
+                throw new IllegalArgumentException("Operation not defined");
+        }
+    }
+
+    public static void sendHttpResponse(ChannelHandlerContext ctx, FullHttpResponse res, String content) {
+
+        // Generate an error page if response getStatus code is not OK (200).
+        ByteBuf buf = Unpooled.copiedBuffer(content, CharsetUtil.UTF_8);
+        res.content().writeBytes(buf);
+
+        HttpUtil.setContentLength(res, res.content().readableBytes());
+
+        ctx.channel().writeAndFlush(res);
+    }
+
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
+            throws Exception {
+
+        sendHttpResponse(ctx, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR), "Operation not defined");
+        ctx.fireExceptionCaught(cause);
+    }
+
+}

libraries-server/src/main/java/com/baeldung/netty/ChannelHandlerA.java

@@ -0,0 +1,22 @@
+package com.baeldung.netty;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+import java.util.logging.Logger;
+
+public class ChannelHandlerA extends ChannelInboundHandlerAdapter {
+
+    private Logger logger = Logger.getLogger(getClass().getName());
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        throw new Exception("Ooops");
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        logger.info("Exception Occurred in ChannelHandler A");
+        ctx.fireExceptionCaught(cause);
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/ChannelHandlerB.java

@@ -0,0 +1,19 @@
+package com.baeldung.netty;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+import java.util.logging.Logger;
+
+public class ChannelHandlerB extends ChannelInboundHandlerAdapter {
+
+    private Logger logger = Logger.getLogger(getClass().getName());
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        logger.info("Exception Handled in ChannelHandler B");
+        logger.info(cause.getLocalizedMessage());
+        // do more exception handling
+        ctx.close();
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/ClientHandler.java

@@ -0,0 +1,20 @@
+package com.baeldung.netty;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+public class ClientHandler extends ChannelInboundHandlerAdapter {
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        RequestData msg = new RequestData();
+        msg.setIntValue(123);
+        msg.setStringValue("all work and no play makes jack a dull boy");
+        ctx.writeAndFlush(msg);
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        System.out.println(msg);
+        ctx.close();
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/HttpMessageHandler.java

@@ -0,0 +1,40 @@
+package com.baeldung.netty;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpHeaders;
+import io.netty.handler.codec.http.HttpMethod;
+
+public class HttpMessageHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
+
+    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest msg) throws Exception {
+
+        String uri = msg.uri();
+        HttpMethod httpMethod = msg.method();
+        HttpHeaders headers = msg.headers();
+
+        if (HttpMethod.GET == httpMethod) {
+
+            String[] uriComponents = uri.split("[?]");
+            String endpoint = uriComponents[0];
+            String[] queryParams = uriComponents[1].split("&");
+
+            if ("/calculate".equalsIgnoreCase(endpoint)) {
+
+                String[] firstQueryParam = queryParams[0].split("=");
+                String[] secondQueryParam = queryParams[1].split("=");
+
+                Integer a = Integer.valueOf(firstQueryParam[1]);
+                Integer b = Integer.valueOf(secondQueryParam[1]);
+                String operator = headers.get("operator");
+
+                Operation operation = new Operation(a, b, operator);
+                ctx.fireChannelRead(operation);
+            }
+        } else {
+            throw new UnsupportedOperationException("HTTP method not supported");
+        }
+
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/NettyClient.java

@@ -0,0 +1,37 @@
+package com.baeldung.netty;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+
+public class NettyClient {
+    public static void main(String[] args) throws Exception {
+        String host = "localhost";
+        int port = 8080;
+        EventLoopGroup workerGroup = new NioEventLoopGroup();
+
+        try {
+            Bootstrap b = new Bootstrap();
+            b.group(workerGroup);
+            b.channel(NioSocketChannel.class);
+            b.option(ChannelOption.SO_KEEPALIVE, true);
+            b.handler(new ChannelInitializer<SocketChannel>() {
+                @Override
+                public void initChannel(SocketChannel ch) throws Exception {
+                    ch.pipeline().addLast(new RequestDataEncoder(), new ResponseDataDecoder(), new ClientHandler());
+                }
+            });
+
+            ChannelFuture f = b.connect(host, port).sync();
+
+            f.channel().closeFuture().sync();
+        } finally {
+            workerGroup.shutdownGracefully();
+        }
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/NettyServer.java

@@ -0,0 +1,49 @@
+package com.baeldung.netty;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+
+public class NettyServer {
+
+    private int port;
+
+    private NettyServer(int port) {
+        this.port = port;
+    }
+
+    public static void main(String[] args) throws Exception {
+        int port;
+        if (args.length > 0) {
+            port = Integer.parseInt(args[0]);
+        } else {
+            port = 8080;
+        }
+        new NettyServer(port).run();
+    }
+
+    private void run() throws Exception {
+        EventLoopGroup bossGroup = new NioEventLoopGroup();
+        EventLoopGroup workerGroup = new NioEventLoopGroup();
+        try {
+            ServerBootstrap b = new ServerBootstrap();
+            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {
+                @Override
+                public void initChannel(SocketChannel ch) throws Exception {
+                    ch.pipeline().addLast(new RequestDecoder(), new ResponseDataEncoder(), new ProcessingHandler());
+                }
+            }).option(ChannelOption.SO_BACKLOG, 128).childOption(ChannelOption.SO_KEEPALIVE, true);
+
+            ChannelFuture f = b.bind(port).sync();
+            f.channel().closeFuture().sync();
+        } finally {
+            workerGroup.shutdownGracefully();
+            bossGroup.shutdownGracefully();
+        }
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/NettyServerB.java

@@ -0,0 +1,43 @@
+package com.baeldung.netty;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+
+public class NettyServerB {
+
+    private int port;
+
+    private NettyServerB(int port) {
+        this.port = port;
+    }
+
+    private void run() throws Exception {
+
+        EventLoopGroup bossGroup = new NioEventLoopGroup();
+        EventLoopGroup workerGroup = new NioEventLoopGroup();
+
+        try {
+            ServerBootstrap b = new ServerBootstrap();
+            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {
+                public void initChannel(SocketChannel ch) throws Exception {
+                    ch.pipeline().addLast(new ChannelHandlerA(), new ChannelHandlerB());
+                }
+            }).option(ChannelOption.SO_BACKLOG, 128).childOption(ChannelOption.SO_KEEPALIVE, true);
+            ChannelFuture f = b.bind(port).sync(); // (7)
+            f.channel().closeFuture().sync();
+        } finally {
+            workerGroup.shutdownGracefully();
+            bossGroup.shutdownGracefully();
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        new NettyServerB(8080).run();
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/Operation.java

@@ -0,0 +1,49 @@
+package com.baeldung.netty;
+
+import java.io.Serializable;
+
+public class Operation implements Serializable {
+
+    private Integer number1;
+    private Integer number2;
+    private String operator;
+
+    public Operation(Integer number1, Integer number2, String operator) {
+        this.number1 = number1;
+        this.number2 = number2;
+        this.operator = operator;
+    }
+
+    public Integer getNumber1() {
+        return number1;
+    }
+
+    public void setNumber1(Integer number1) {
+        this.number1 = number1;
+    }
+
+    public Integer getNumber2() {
+        return number2;
+    }
+
+    public void setNumber2(Integer number2) {
+        this.number2 = number2;
+    }
+
+    public String getOperator() {
+        return operator;
+    }
+
+    public void setOperator(String operator) {
+        this.operator = operator;
+    }
+
+    @Override
+    public String toString() {
+        return "Operation{" +
+                "number1=" + number1 +
+                ", number2=" + number2 +
+                ", operator='" + operator + '\'' +
+                '}';
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/ProcessingHandler.java

@@ -0,0 +1,19 @@
+package com.baeldung.netty;
+
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+public class ProcessingHandler extends ChannelInboundHandlerAdapter {
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        RequestData requestData = (RequestData) msg;
+        ResponseData responseData = new ResponseData();
+        responseData.setIntValue(requestData.getIntValue() * 2);
+        ChannelFuture future = ctx.writeAndFlush(responseData);
+        future.addListener(ChannelFutureListener.CLOSE);
+        System.out.println(requestData);
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/RequestData.java

@@ -0,0 +1,27 @@
+package com.baeldung.netty;
+
+public class RequestData {
+    private int intValue;
+    private String stringValue;
+
+    int getIntValue() {
+        return intValue;
+    }
+
+    void setIntValue(int intValue) {
+        this.intValue = intValue;
+    }
+
+    String getStringValue() {
+        return stringValue;
+    }
+
+    void setStringValue(String stringValue) {
+        this.stringValue = stringValue;
+    }
+
+    @Override
+    public String toString() {
+        return "RequestData{" + "intValue=" + intValue + ", stringValue='" + stringValue + '\'' + '}';
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/RequestDataEncoder.java

@@ -0,0 +1,19 @@
+package com.baeldung.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+
+import java.nio.charset.Charset;
+
+public class RequestDataEncoder extends MessageToByteEncoder<RequestData> {
+
+    private final Charset charset = Charset.forName("UTF-8");
+
+    @Override
+    protected void encode(ChannelHandlerContext ctx, RequestData msg, ByteBuf out) throws Exception {
+        out.writeInt(msg.getIntValue());
+        out.writeInt(msg.getStringValue().length());
+        out.writeCharSequence(msg.getStringValue(), charset);
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/RequestDecoder.java

@@ -0,0 +1,22 @@
+package com.baeldung.netty;
+
+import java.nio.charset.Charset;
+import java.util.List;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ReplayingDecoder;
+
+public class RequestDecoder extends ReplayingDecoder<RequestData> {
+
+    private final Charset charset = Charset.forName("UTF-8");
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+        RequestData data = new RequestData();
+        data.setIntValue(in.readInt());
+        int strLen = in.readInt();
+        data.setStringValue(in.readCharSequence(strLen, charset).toString());
+        out.add(data);
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/ResponseData.java

@@ -0,0 +1,18 @@
+package com.baeldung.netty;
+
+public class ResponseData {
+    private int intValue;
+
+    int getIntValue() {
+        return intValue;
+    }
+
+    void setIntValue(int intValue) {
+        this.intValue = intValue;
+    }
+
+    @Override
+    public String toString() {
+        return "ResponseData{" + "intValue=" + intValue + '}';
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/ResponseDataDecoder.java

@@ -0,0 +1,17 @@
+package com.baeldung.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ReplayingDecoder;
+
+import java.util.List;
+
+public class ResponseDataDecoder extends ReplayingDecoder<ResponseData> {
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+        ResponseData data = new ResponseData();
+        data.setIntValue(in.readInt());
+        out.add(data);
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/ResponseDataEncoder.java

@@ -0,0 +1,13 @@
+package com.baeldung.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+
+public class ResponseDataEncoder extends MessageToByteEncoder<ResponseData> {
+
+    @Override
+    protected void encode(ChannelHandlerContext ctx, ResponseData msg, ByteBuf out) throws Exception {
+        out.writeInt(msg.getIntValue());
+    }
+}

libraries-server/src/main/java/com/baeldung/netty/SimpleProcessingHandler.java

@@ -0,0 +1,39 @@
+package com.baeldung.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+public class SimpleProcessingHandler extends ChannelInboundHandlerAdapter {
+    private ByteBuf tmp;
+
+    @Override
+    public void handlerAdded(ChannelHandlerContext ctx) {
+        System.out.println("Handler added");
+        tmp = ctx.alloc().buffer(4);
+    }
+
+    @Override
+    public void handlerRemoved(ChannelHandlerContext ctx) {
+        System.out.println("Handler removed");
+        tmp.release();
+        tmp = null;
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) {
+        ByteBuf m = (ByteBuf) msg;
+        tmp.writeBytes(m);
+        m.release();
+        if (tmp.readableBytes() >= 4) {
+            RequestData requestData = new RequestData();
+            requestData.setIntValue(tmp.readInt());
+            ResponseData responseData = new ResponseData();
+            responseData.setIntValue(requestData.getIntValue() * 2);
+            ChannelFuture future = ctx.writeAndFlush(responseData);
+            future.addListener(ChannelFutureListener.CLOSE);
+        }
+    }
+}