Netty is a Java-based framework that provides a simple and intuitive way to build network applications.
In this comprehensive guide, you’ll be able master Netty, from understanding its architecture and key features to building real-world applications.
By the end of this tutorial, you’ll have the skills and confidence to leverage Netty’s capabilities to take your network applications to the next level.
Let’s dive in and explore the world of Netty together!
Fundamentals of Netty
Netty is an open-source, asynchronous event-driven network application framework that enables you to build high-performance, scalable, and efficient network applications in Java.
Netty provides a robust and flexible way to handle network communications, allowing you to focus on writing business logic without worrying about the underlying complexities of network programming.
With Netty, you can create servers and clients that can handle a large number of concurrent connections, making it an ideal choice for building real-time web applications, game servers, and other high-performance network systems.
It’s built on top of the Java NIO (Non-Blocking I/O) API, which allows for asynchronous and event-driven I/O operations.
This enables Netty to handle a large number of connections efficiently, making it an ideal choice for building high-performance network applications.
One of the key benefits of using Netty is its flexibility and customizability.
You can easily extend and modify Netty’s behavior to suit your specific needs.
Netty also provides a rich set of features, including support for multiple protocols, built-in codecs, and SSL/TLS support, making it a versatile framework for building network applications.
Netty Server Example
Let’s take a look at a simple example of how you can use Netty to create a basic network application.
Here’s an example of a Netty-based echo server that echoes back any message it receives:
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 EchoServer {
public static void main(String[] args) throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup).
channel(NioServerSocketChannel.class).
childHandler(new ChannelInitializer() {
@Override
public void initChannel(SocketChannel ch)
throws Exception {
ch.pipeline().addLast(new EchoServerHandler());
}
}).
option(ChannelOption.SO_BACKLOG, 128).
childOption(ChannelOption.SO_KEEPALIVE, true);
ChannelFuture f = b.bind(8080).sync();
f.channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
} In this example, we create a Netty-based echo server that listens on port 8080.
When a message is received, it’s echoed back to the client using the EchoServerHandler class.
History and Evolution of Netty
Netty’s story began in 2004 when Trustin Lee, a Korean developer, created a lightweight I/O framework called “MINA” (Multipurpose Infrastructure for Network Applications). MINA aimed to provide a simple, efficient, and scalable way to build networked applications in Java.
Although MINA gained popularity, it had its limitations, and Trustin Lee realized that a more robust and flexible framework was needed.
In 2007, Trustin Lee started working on Netty, which was initially called “MINA 2.0.” Netty was designed to address the shortcomings of MINA and provide a more modular, extensible, and performant framework for building network applications.
The first stable release of Netty, version 3.0, was released in 2008.
Since then, Netty has undergone significant changes and improvements. In 2011, Netty 4.0 was released, which introduced a major overhaul of the API and architecture.
This new version provided better performance, improved scalability, and enhanced maintainability. The latest stable release, Netty 4.1, was released in 2019 and continues to be actively maintained by the Netty community.
Throughout its evolution, Netty has been widely adopted in various industries, including finance, gaming, and cloud computing.
Its popularity arises from its ability to handle high-traffic networks, provide low latency, and support multiple protocols, including HTTP, WebSocket, and TCP.
Key Features and Benefits of Using Netty
When you choose Netty, you can expect the following key features and benefits:
Asynchronous and Event-Driven Architecture
Netty’s architecture is designed to handle multiple connections concurrently, making it an ideal choice for building scalable and efficient network applications.
With Netty, you can write asynchronous code that is easier to maintain and debug.
Flexible and Customizable Pipeline Architecture
Netty’s pipeline architecture allows you to customize the handling of incoming and outgoing data by adding or removing handlers.
This flexibility enables you to tailor your application to specific requirements and optimize performance.
Extensive Support for Protocols and Encodings
Netty provides built-in support for various protocols, such as HTTP, WebSocket, and SSL/TLS, as well as encodings like JSON, XML, and String.
This extensive support saves you time and effort when developing network applications.
Netty Architecture
Netty’s architecture is designed to provide a flexible and scalable framework for building network applications.
It achieves this through a combination of components that work together seamlessly. These components include:
A. Channel
Represents a connection to the network
B. EventLoop
Handles I/O operations and events
C. Handler
Processes incoming and outgoing data
D. Pipeline
A chain of handlers that process data
Let’s take a closer look at each of these components and how they interact with each other.
A Channel represents a connection to the network, such as a socket or a file descriptor.
Channels are responsible for managing the underlying socket connection and providing an interface for reading and writing data.
When you create a Channel, you specify the type of transport (e.g., TCP, UDP, or local) and the address of the remote endpoint.
An EventLoop, on the other hand, is responsible for handling I/O operations and events.
It’s crucially a thread that runs in the background, waiting for incoming data or events.
When an event occurs, the EventLoop notifies the corresponding Handler, which then processes the event.
EventLoops are the backbone of Netty’s asynchronous I/O model, allowing your application to handle multiple connections concurrently.
A Handler is a crucial component in Netty’s architecture.
It’s responsible for processing incoming and outgoing data, as well as handling exceptions.
You can think of a Handler as a callback function that’s invoked when an event occurs.
Handlers can be chained together to form a Pipeline, which allows you to process data in a series of steps.
Here’s a simple example of how these components interact:
// Create a ServerBootstrap instance
ServerBootstrap b = new ServerBootstrap();
// Set up the EventLoopGroup
EventLoopGroup group = new NioEventLoopGroup();
b.group(group).
channel(NioServerSocketChannel.class);
// Set up the ChannelInitializer
b.childHandler(new ChannelInitializer() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
// Create a Pipeline and add Handlers
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new MyInboundHandler());
pipeline.addLast(new MyOutboundHandler());
}
}); In this example, you create a ServerBootstrap instance, which is used to set up a Netty server.
You then define an EventLoopGroup, which will handle events for the server.
The ChannelInitializer is responsible for setting up the Pipeline for each new connection, adding your custom Handlers to the processing flow.
Adding Dependencies
To start, you’ll need to add the Netty dependencies to your project.
You can do this by adding the following Maven dependency to your pom.xml file:
<dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.112.Final</version> </dependency>
Alternatively, if you’re using Gradle, you can add the following dependency to your build.gradle file:
implementation ‘io.netty:netty-all:4.1.112.Final’
Creating Netty Server
Once you’ve added the dependencies, let’s create a basic Netty application.
Create a new Java class, e.g., NettyApplication, and add the following code:
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
public class NettyApplication {
public static void main(String[] args) throws Exception {
// Create a NIO event loop group for the server
NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
try {
// Create a ServerBootstrap instance
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup).
channel(NioServerSocketChannel.class).
childHandler(new ChannelInitializer() {
@Override
public void initChannel(SocketChannel ch)
throws Exception {
ch.pipeline().addLast(new EchoServerHandler());
}
}).option(ChannelOption.SO_BACKLOG, 128).
childOption(ChannelOption.SO_KEEPALIVE, true);
// Bind the server to port 8080
ChannelFuture f = b.bind(8080).sync();
// Wait for the server to close
f.channel().closeFuture().sync();
} finally {
// Shut down the event loop groups
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
} This code creates a basic Netty server that listens on port 8080.
In this example, we create a ServerBootstrap instance and specify the NioServerSocketChannel class as the channel type.
This creates an NIO channel that listens for incoming connections.
Also, we set the backlog size to 128 and enable keep-alive for the channel using ChannelOption.SO_BACKLOG and ChannelOption.SO_KEEPALIVE options respectively .
Note that we have added a EchoServerHandler to the pipeline.
A handler in Netty is responsible for processing events triggered by the network, such as incoming data, connection establishment, or errors.
You can think of a handler as a callback function that is executed when a specific event occurs.
So, in this case, when a message is received, this handler will automatically be executed.
You can add as many handlers to the pipeline as required.
We will see how this handler is defined in the following section.
Writing Custom Handlers: Inbound & Outbound
All Netty applications rely on handlers to process incoming and outgoing data. In this chapter, you will learn how to write custom handlers to handle inbound and outbound data, as well as exceptions that may occur during the communication process.
A handler is a crucial component in Netty’s architecture, responsible for processing events triggered by the network, such as incoming data, connection establishment, or errors. You can think of a handler as a callback function that is executed when a specific event occurs.
In Netty, there are two types of handlers: inbound and outbound.
Inbound handlers process incoming data, while outbound handlers process outgoing data.
Additionally, you can also write exception handlers to catch and handle exceptions that may occur during the communication process.
Now, let’s take a closer look at the EchoServerHandler implementation that we added to the server pipeline in the last section
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
public class EchoServerHandler extends
ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx,
Object msg)
throws Exception {
ByteBuf in = (ByteBuf) msg;
System.out.println("Server received: " +
in.toString(CharsetUtil.UTF_8));
ctx.write(in);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx)
throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx,
Throwable cause)
throws Exception {
cause.printStackTrace(); ctx.close();
}
} In this implementation, the handler class extends ChannelInboundHandlerAdapter class and we’re overriding the channelRead() method to handle incoming messages.
We’re simply printing the received message to the console and writing it back to the client using the ctx.write(in) method.
Similarly, you can create an outbound handler by extending the ChannelOutboundHandlerAdapter class and overriding the write() method.
In Netty, an outbound handler is used to process or manipulate outbound data before it is sent over the network.
Outbound data refers to data that is being written out of the channel, typically in response to a request or as part of a server-client communication.
A typical example is to prepend a header before the message or compress it before sending it to network.
Below is an example of Outbound handler:
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
public class PrintOutboundHandler extends
ChannelOutboundHandlerAdapter {
@Override
public void write(ChannelHandlerContext ctx,
Object msg,
ChannelPromise promise) throws Exception {
System.out.println("Sending message: " + msg);
ctx.write(msg, promise);
}
} In this example, the PrintOutboundHandler class prints out the outgoing message and then passes it to the next handler in the pipeline using the ctx.write(msg, promise) method.
Exception handlers are used to catch and handle exceptions that may occur during the communication process.
You can create an exception handler by extending the ChannelHandlerAdapter class and overriding the exceptionCaught() method:
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelPipelineException;
public class PrintExceptionHandler extends ChannelHandlerAdapter {
@Override
public void exceptionCaught(ChannelHandlerContext ctx,
Throwable cause) throws Exception {
System.out.println("Exception caught: " + cause.getMessage());
ctx.close();
}
} In this example, the PrintExceptionHandler class prints out the exception message and then closes the channel using the ctx.close() method.
Handling Incoming Connections
You might want to know when did a client connect or disconnect with the server for many reasons.
It is possible in Netty by writing a simple handler.
Here’s an example of a simple ChannelHandler that prints a message when a new connection is established:
public class ConnectionHandler extends
ChannelInboundHandlerAdapter {
@Override
public void channelActive(ChannelHandlerContext ctx)
throws Exception {
System.out.println("New connection established!");
}
@Override
public void channelInactive(ChannelHandlerContext ctx)
throws Exception {
System.out.println("Client disconnected!");
}
} In this example, the channelActive() method is called when a new connection is established.
Similary, channelInactive() method is called when the connection is terminated.
Both these methods are part of the ChannelInboundHandlerAdapter class, which provides a default implementation for many of the methods in the ChannelHandler interface.
To make this handler work, you need to add this to the pipeline as we saw earlier.
Working with EventLoops: Single-Threaded vs Multi-Threaded
An EventLoop is responsible for handling events related to a Channel, such as connecting, disconnecting, reading, and writing data.
In Netty, you can configure EventLoops to run in either single-threaded or multi-threaded mode, each with its own advantages and use cases.
In a single-threaded EventLoop, all events related to a Channel are handled by a single thread.
This approach is useful when you need to ensure that events are processed in a specific order or when you’re working with a small number of connections.
Here’s an example of creating a single-threaded EventLoop:
EventLoopGroup eventLoopGroup = new NioEventLoopGroup(1);
In this example, we create an NioEventLoopGroup with a single thread, which means that all events will be handled by this single thread.
On the other hand, a multi-threaded EventLoop uses multiple threads to handle events, allowing for better concurrency and scalability.
This approach is suitable for high-traffic applications or when you need to handle a large number of connections concurrently.
Here’s an example of creating a multi-threaded EventLoop:
EventLoopGroup eventLoopGroup = new NioEventLoopGroup(4);
In this example, we create an NioEventLoopGroup with four threads, which means that events will be distributed among these four threads for processing.
When deciding between single-threaded and multi-threaded EventLoops, consider the following factors:
Concurrency
If your application requires handling multiple connections concurrently, a multi-threaded EventLoop is a better choice.
Order of events
If you need to ensure that events are processed in a specific order, a single-threaded EventLoop is more suitable.
Resource utilization
Multi-threaded EventLoops can lead to increased resource utilization, so ensure that your system can handle the added load.
Creating Netty Client
Many network applications require a client-side component to interact with a server.
To create a client with Netty, you’ll need to establish a connection to a server, send requests, and handle responses.
To get started, let’s create a new Java class that will serve as our client.
We’ll call it NettyClient.
In this class, we’ll create a main() method that will bootstrap our client and establish a connection with a server.
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 EchoClient {
private String host;
private int port;
public EchoClient(String host, int port) {
this.host = host;
this.port = port;
}
public void start() throws Exception {
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
Bootstrap b = new Bootstrap();
b.group(workerGroup).
channel(NioSocketChannel.class).
option(ChannelOption.SO_KEEPALIVE, true).
handler(new ChannelInitializer() {
@Override
public void initChannel(SocketChannel ch)
throws Exception {
ch.pipeline().addLast(new EchoClientHandler());
}
});
ChannelFuture f = b.connect(host, port).sync();
System.out.println("Echo client started");
f.channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
new EchoClient("localhost", 8080).start();
}
} In the above code, we create a Bootstrap instance and configure it to use the NioEventLoopGroup for handling outgoing connections.
We then specify the channel type as NioSocketChannel and add an instance of EchoClientHandler to the pipeline.
To connect to the server use the connect() method.
Once connected, you can send requests to the server using the writeAndFlush() method.
Finally, we will create the EchoClientHandler class, that will handle the response received by the server.
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
public class EchoClientHandler extends SimpleChannelInboundHandler {
@Override
public void channelActive(ChannelHandlerContext ctx)
throws Exception {
ctx.writeAndFlush("Hello, Netty!");
}
@Override
public void channelRead0(ChannelHandlerContext ctx, String msg)
throws Exception {
System.out.println("Received message: " + msg);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
throws Exception {
cause.printStackTrace();
ctx.close();
}
} In the EchoClientHandler class, we override the channelActive() method to send a message to the server when the channel is active.
We also override the channelRead0() method to handle incoming messages from the server.
That’s it! You have now created a simple echo server and client using Netty.
Run the EchoServer class to start the server, and then run the EchoClient class to connect to the server and send a message.
Handling HTTP Requests
Many Netty users find themselves in need of implementing common network protocols such as HTTP or WebSocket.
Fortunately, Netty provides built-in handlers for these protocols, saving you the trouble of implementing them from scratch.
In this section, we’ll explore how to use these built-in handlers to simplify your network application development.
Let’s start with the HTTP handler.
Netty provides an implementation of the HTTP protocol through the HttpServerCodec class.
This codec handles both HTTP requests and responses, making it easy to create an HTTP server.
To use the HTTP handler, you need to add it to your pipeline:
pipeline.addLast(new HttpServerCodec());
Once you’ve added the HTTP handler to your pipeline, you can start handling HTTP requests.
For example, you can create a custom handler to handle GET requests:
public class HttpRequestHandler extends SimpleChannelInboundHandler {
@Override
public void channelRead0(ChannelHandlerContext ctx, HttpObject msg)
throws Exception {
if (msg instanceof HttpRequest) {
HttpRequest req = (HttpRequest) msg;
if (req.getMethod().equals(HttpMethod.GET)) {
// Handle GET request
String response = "Hello, World!";
ctx.writeAndFlush(
new DefaultFullHttpResponse(
HTTP_1_1,
OK,
Unpooled.wrappedBuffer(response.getBytes())));
}
}
}
} In this example, we’ve created a custom handler that extends SimpleChannelInboundHandler.
We override the channelRead0() method to handle incoming HTTP requests.
When a GET request is received, we respond with a simple “Hello, World!” message.
Similarly, Netty provides built-in support for WebSockets through the WebSocketServerProtocolHandler class.
This handler enables WebSocket functionality on your server, allowing clients to establish WebSocket connections.
To use the WebSocket handler, you need to add it to your pipeline:
pipeline.addLast(new WebSocketServerProtocolHandler("/websocket")); Once you’ve added the WebSocket handler to your pipeline, you can start handling WebSocket connections.
For example, you can create a custom handler to handle WebSocket messages:
public class WebSocketHandler extends SimpleChannelInboundHandler {
@Override
public void channelRead0(ChannelHandlerContext ctx,
WebSocketFrame msg)
throws Exception {
if (msg instanceof TextWebSocketFrame) {
String message = ((TextWebSocketFrame) msg).text();
// Handle WebSocket message
ctx.writeAndFlush(new TextWebSocketFrame("Echo: " + message));
}
}
} In this example, we’ve created a custom handler that extends SimpleChannelInboundHandler.
We override the channelRead0() method to handle incoming WebSocket messages.
When a text message is received, we respond with an echo message.
By using Netty’s built-in handlers for HTTP and WebSocket, you can focus on developing your network application’s logic without worrying about the underlying protocol implementation.
Encoding and Decoding
In Netty, encoding and decoding refer to the process of converting data from one format to another, allowing your application to send and receive data over the network.
You’ll need to encode data before sending it over the wire and decode it when receiving it.
This process is important, as it ensures that data is transmitted correctly and efficiently.
Netty provides built-in codecs for common data formats such as strings, JSON, and more.
These codecs can be easily added to your pipeline to handle encoding and decoding.
For example, you can use the StringEncoder and StringDecoder to encode and decode strings:
pipeline.addLast(new StringEncoder()); pipeline.addLast(new StringDecoder());
In addition to built-in codecs, you can also create custom encoders and decoders to handle specific data formats or proprietary protocols.
This is achieved by implementing the ChannelInboundHandler interface and overriding the encode() or decode() methods.
For instance, let’s say you want to encode a custom Message object as a JSON string.
You can create a custom encoder like this:
public class MessageEncoder extends MessageToByteEncoder {
@Override
protected void encode(ChannelHandlerContext ctx,
Message msg,
ByteBuf out) throws Exception {
byte[] jsonBytes = JsonUtil.toJsonBytes(msg);
out.writeBytes(jsonBytes);
}
} In this example, the MessageEncoder class uses a JSON utility class to convert the Message object to a JSON string, which is then written to the output buffer.
MessageToByteEncoder is a Netty built in class which extends ChannelOutboundHandlerAdapter.encode() method in this class is abstract so that you can provide specific implementation.
Similarly, you can create a custom decoder to decode the JSON string back into a Message object:
public class MessageDecoder extends ByteToMessageDecoder {
@Override
protected void decode(ChannelHandlerContext ctx,
ByteBuf in,
List out) throws Exception {
byte[] jsonBytes = new byte[in.readableBytes()];
in.readBytes(jsonBytes);
Message msg = JsonUtil.fromJsonBytes(jsonBytes, Message.class);
out.add(msg);
}
} By using custom encoders and decoders, you can tailor your Netty application to handle specific data formats and protocols, giving you greater flexibility and control over your network communication.
SSL/TLS Support
Many network applications require secure communication between the client and server, and SSL/TLS (Secure Sockets Layer/Transport Layer Security) is a widely-used protocol for encrypting data in transit.
As you build high-performance network applications with Netty, it’s important to understand how to enable SSL/TLS support to ensure the confidentiality and integrity of your data.
In Netty, SSL/TLS support is provided through the SslHandler class, which is responsible for encrypting and decrypting data.
To enable SSL/TLS support in your Netty application, you need to add the SslHandler to your pipeline.
Here’s an example of how to create an SSL/TLS-enabled server:
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup).
channel(NioServerSocketChannel.class).
childHandler(new ChannelInitializer() {
@Override
public void initChannel(SocketChannel ch)
throws Exception {
ChannelPipeline pipeline = ch.pipeline();
SSLEngine engine = SslContextFactory.
createServerContext("mycert.crt", "mykey.key");
pipeline.addLast("ssl", new SslHandler(engine));
pipeline.addLast("handler", new MyServerHandler());
}
}); In this example, we create an SSLEngine instance using the SslContextFactory class, which loads the SSL/TLS certificate and private key from files.
We then add the SslHandler to the pipeline, followed by our custom server handler.
On the client-side, you can enable SSL/TLS support by adding the SslHandler to the pipeline in a similar way
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(workerGroup).
channel(NioSocketChannel.class).
handler(new ChannelInitializer() {
@Override
public void initChannel(SocketChannel ch)
throws Exception {
ChannelPipeline pipeline = ch.pipeline();
SSLEngine engine = SslContextFactory.
createClientContext("mytruststore.jks");
pipeline.addLast("ssl", new SslHandler(engine));
pipeline.addLast("handler", new MyClientHandler());
}
}); In this example, we create an SSLEngine instance using the SslContextFactory class, which loads the SSL/TLS truststore from a file.
We then add the SslHandler to the pipeline, followed by our custom client handler.
By enabling SSL/TLS support in your Netty application, you can ensure that your data is encrypted and protected from eavesdropping and tampering.
Final Words
You now have a comprehensive understanding of how to use Netty to build high-performance network applications in Java.
You’ve learned how to set up a Netty project, work with channels and event loops, write custom handlers, and build pipelines.
You’ve also explored advanced topics such as SSL/TLS support and WebSockets.
By applying the concepts and techniques covered in this tutorial, you’ll be able to create scalable and efficient network applications that meet your specific needs.
Remember to practice and experiment with the code examples provided to reinforce your understanding of Netty.
