Back to Blog List

Deep Dive into Network Programming: Building a High-Performance RPC Framework with Netty

2020-10-26

In the second half of 2020, as my thinking about backend performance and architecture deepened, I turned my attention to the high-performance network communication framework Netty. In particular, while researching how to build an efficient RPC (Remote Procedure Call) framework, Netty became the focus of my study and practice.

Why Netty?

In the Java ecosystem, Netty is a widely used asynchronous, event-driven network application framework for rapidly developing maintainable, high-performance protocol servers and clients. Built on the NIO (Non-blocking I/O) model, it can handle large numbers of concurrent connections in a non-blocking way, making it a great fit for high-performance distributed systems.

My Learning Path and Core Concepts

My learning centered on one goal — writing a Netty-based RPC framework entirely by hand — which gave me a much deeper understanding of Netty's core concepts:

  • NIO model: gained a deep understanding of core NIO components such as Selector, Channel, and ``Buffer`, and of how they work together to achieve non-blocking I/O.
  • Event-driven model: At the heart of Netty is its event-driven model. All network operations are abstracted as events and processed through a chain of ChannelHandlers, decoupling business logic from network communication.
  • Custom protocols: Learned how to design and implement custom network communication protocols, including protocol encoding and decoding (solving sticky-packet and packet-splitting problems) — the key to building an RPC framework.
  • Connection pooling: To make RPC calls more efficient, I studied how to build a client-side connection pool on top of Netty, reusing connections to reduce resource overhead.
  • The full RPC call flow: I analyzed and practiced the entire RPC call flow in detail — from the client initiating a call, request serialization, and network transmission, to server-side deserialization and method invocation, and finally returning the result.

What I Took Away

By studying Netty in depth and attempting to hand-write an RPC framework, I not only mastered how to use Netty but, more importantly, made a qualitative leap in my understanding of the underlying principles of high-performance network programming. I now understand:

  • The essence of RPC: A remote procedure call is not magic — it is serialized requests and responses transmitted over a network.
  • Stateful vs. stateless RPC: Different business scenarios place different demands on connection management and session state in RPC.
  • Performance optimization: The key role that codec design, connection reuse, zero-copy, and similar techniques play in improving network communication performance.

This learning greatly broadened my technical horizons and laid a solid foundation for designing and optimizing distributed systems in the future — especially microservice communication under high concurrency and low latency. It moved me a big step forward from application developer toward a systems engineer who understands the lower levels and the architecture.