Creating a TCP/UDP server in Java using Netty 4.2 RC3 involves several steps. Netty is an asynchronous event-driven network application framework, which simplifies the development of network applications such as protocol servers and clients. Below is a basic guide to creating both a TCP and a UDP server using Netty 4.2 RC3.

TCP Server

1. Add Netty Dependency: Ensure you have the Netty dependency in your pom.xml if you're using Maven.

   <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
       <version>4.2.0.RC3</version>
   </dependency>

2. Create the TCP Server:

   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;
   import io.netty.handler.codec.string.StringDecoder;
   import io.netty.handler.codec.string.StringEncoder;
   
   public class TcpServer {
   
       private final int port;
   
       public TcpServer(int port) {
           this.port = port;
       }
   
       public void start() throws InterruptedException {
           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 StringDecoder(), new StringEncoder(), new TcpServerHandler());
                    }
                })
                .option(ChannelOption.SO_BACKLOG, 128)
                .childOption(ChannelOption.SO_KEEPALIVE, true);
   
               ChannelFuture f = b.bind(port).sync();
               System.out.println("TCP Server started at port: " + port);
               f.channel().closeFuture().sync();
           } finally {
               workerGroup.shutdownGracefully();
               bossGroup.shutdownGracefully();
           }
       }
   
       public static void main(String[] args) throws InterruptedException {
           new TcpServer(8080).start();
       }
   }

3. Create the TCP Server Handler:

   import io.netty.channel.ChannelHandlerContext;
   import io.netty.channel.SimpleChannelInboundHandler;
   
   public class TcpServerHandler extends SimpleChannelInboundHandler<String> {
   
       @Override
       protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
           System.out.println("Received: " + msg);
           ctx.writeAndFlush("Echo: " + msg);
       }
   
       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
           cause.printStackTrace();
           ctx.close();
       }
   }

UDP Server

1. Create the UDP Server:

   import io.netty.bootstrap.Bootstrap;
   import io.netty.channel.ChannelOption;
   import io.netty.channel.EventLoopGroup;
   import io.netty.channel.nio.NioEventLoopGroup;
   import io.netty.channel.socket.nio.NioDatagramChannel;
   
   public class UdpServer {
   
       private final int port;
   
       public UdpServer(int port) {
           this.port = port;
       }
   
       public void start() throws InterruptedException {
           EventLoopGroup group = new NioEventLoopGroup();
           try {
               Bootstrap b = new Bootstrap();
               b.group(group)
                .channel(NioDatagramChannel.class)
                .option(ChannelOption.SO_BROADCAST, true)
                .handler(new UdpServerHandler());
   
               b.bind(port).sync().channel().closeFuture().await();
               System.out.println("UDP Server started at port: " + port);
           } finally {
               group.shutdownGracefully();
           }
       }
   
       public static void main(String[] args) throws InterruptedException {
           new UdpServer(8081).start();
       }
   }

2. Create the UDP Server Handler:

   import io.netty.channel.ChannelHandlerContext;
   import io.netty.channel.SimpleChannelInboundHandler;
   import io.netty.channel.socket.DatagramPacket;
   import io.netty.channel.socket.nio.NioDatagramChannel;
   
   public class UdpServerHandler extends SimpleChannelInboundHandler<DatagramPacket> {
   
       @Override
       protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) throws Exception {
           String msg = packet.content().toString(io.netty.util.CharsetUtil.UTF_8);
           System.out.println("Received: " + msg);
           ctx.writeAndFlush(new DatagramPacket(packet.content().copy(), packet.sender()));
       }
   
       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
           cause.printStackTrace();
           ctx.close();
       }
   }

Explanation

• TCP Server: Uses ServerBootstrap to set up the server, binding it to a specified port. The TcpServerHandler processes incoming messages and echoes them back to the client.

• UDP Server: Uses Bootstrap to set up the server, binding it to a specified port. The UdpServerHandler processes incoming datagram packets and echoes them back to the sender.

These examples provide a basic framework for creating TCP and UDP servers using Netty 4.2 RC3. You can expand upon these by adding more complex logic, error handling, and additional features as needed.