This article explains how Netty, an asynchronous event‑driven framework built on Java NIO, powers high‑throughput RPC systems by detailing its core components, data handling with ByteBuf, and practical client‑server examples, offering developers a clear roadmap for building efficient distributed services.
This talk walks through Sharding-Proxy’s role within Apache ShardingSphere, detailing its architecture, SQL lifecycle from protocol decoding to routing, rewriting, execution, and result merging, while highlighting core principles, performance bottlenecks, and practical optimization techniques for high‑throughput, low‑latency database proxying.
This article dissects Netty's custom FastThreadLocal and FastThreadLocalThread implementations, showing how they replace JDK ThreadLocal with constant‑time indexed access, padding to avoid false sharing, and customizable initialization and cleanup to boost backend concurrency performance.
This article compiles essential Java interview questions covering language fundamentals, core APIs, collections, concurrency mechanisms, JVM internals, design patterns, database concepts, and Netty networking, providing a thorough reference for candidates preparing for backend development positions.
This guide introduces Bitchat, a Netty‑based IM framework, showing how to start the server and client, use built‑in commands for login, user listing and private messaging, explains its architecture, custom protocol, health‑check mechanisms, and how to handle business logic with asynchronous thread pools.
This article demystifies Netty’s ByteBuf pooling mechanism, explaining how off‑heap memory is allocated and managed through PooledByteBufAllocator, detailing the internal structures such as PoolThreadCache, PoolArena, PoolChunk, and Subpage, and providing code examples to illustrate allocation and release processes.
This article walks through the root cause analysis of an OutOfDirectMemoryError in a Netty‑based MQTT IoT broker, detailing how to detect off‑heap memory leaks, monitor them with BTrace and custom metrics, and apply proper ByteBuf release and configuration fixes.
This article provides a detailed walkthrough of the Openflowplugin handshake in Opendaylight, explaining how the TCP server is started, how channels are initialized, how listeners are registered, how the hello exchange and version negotiation are performed, and how the controller finalizes the handshake by requesting features and sending a barrier message to the switch.
This article explains the concept of zero‑copy, its I/O fundamentals, and how Java, Netty, RocketMQ and Kafka use mmap, sendfile and other techniques to eliminate data copies and boost backend throughput and latency.
This article introduces the EasyRPC framework, explaining its RPC fundamentals, the use of Netty for communication, Spring for configuration, dynamic proxy for transparent calls, Protostuff for message serialization, and details both server-side service publishing and client-side invocation with reconnection handling.
This article presents a comprehensive guide to improving SOFARPC performance, covering custom BOLT protocol design, Netty transport optimizations, serialization choices, batch decoding, and client‑proxy benchmarking, with practical code demos and configuration recommendations for Java RPC services.
This article introduces the "Big Data Path to God" series, lists several Java advanced topics, and provides a comprehensive Netty guide covering BIO/NIO/AIO differences, Netty features, threading model, TCP packet handling, serialization choices, zero‑copy, performance aspects, and key source‑code components.
This article introduces CIM, a cross‑platform instant messaging framework, detailing its architecture, core components, registration and routing mechanisms, client‑server interaction, custom protocol, built‑in commands, and step‑by‑step deployment using SpringBoot, Netty, Redis and Zookeeper.
This article provides a detailed, macro‑level walkthrough of Apache Dubbo's startup sequence, covering Spring schema extensions, event‑driven service export, URL construction, local and remote exposure decisions, and the Netty server initialization that together enable transparent Java RPC services.
This article explains how to design and implement a high‑concurrency, Netty‑driven push platform that supports device registration, authentication, message routing, and distributed scaling for millions of IoT connections, covering protocol design, channel management, load balancing, and monitoring.
This article provides a comprehensive analysis of Pigeon, a point-based open-source RPC framework used by the company, covering its client-side invoker, server-side provider, call flows, Zookeeper integration, service isolation, and operational features.
When a WebSocket‑based service built on Netty started returning massive 5xx errors, we used log analysis, CAT monitoring, reflective access to Netty's internal memory counter, and step‑by‑step debugging to locate and fix an off‑heap memory leak caused by a null subType field in the encoder.
This article explains how to design and implement a high‑performance, scalable push messaging platform using Netty, covering protocol design, registration/authentication, channel management, message routing, distributed deployment, load balancing, stateful connections, monitoring, and logging to support millions of IoT device connections.
Netty is a high‑performance, asynchronous, event‑driven NIO framework that supports TCP, UDP and file transfer, offering robust, customizable, and scalable networking solutions widely adopted across internet, big‑data, gaming and telecom industries, with detailed analysis of its architecture, I/O model, threading, serialization, reliability, traffic shaping, graceful shutdown, and security features.
This article dissects RocketMQ’s Remoting communication module, covering its architecture, class hierarchy, custom protocol design, message encoding/decoding, synchronous, asynchronous and one‑way communication modes, and the detailed client‑server interaction flow including timeout handling and callback execution.
This article explains why Spring Boot 2.0 replaced the Jedis Redis client with Lettuce, highlighting Lettuce’s netty‑based architecture, thread‑safe shared connections, asynchronous and reactive support, seamless Redis Sentinel and Cluster integration, SSL, streaming API, and provides code examples for both blocking and async usage.
This technical article discusses implementing an automatic printing solution for e-commerce merchants using WebSocket and Netty frameworks to enable real-time order push notifications and reduce manual intervention in the order processing workflow.
This report details how integrating OSP Proxy as an SDK into the Netty‑based Janus gateway dramatically improves throughput, yet introduces a 100 KB payload memory‑leak bug, analyzes its root causes, and evaluates mitigation strategies such as connection and worker‑thread tuning.
The article details the Jingmai Message Center’s end‑to‑end architecture, covering message ingestion via Anycall and MQ, protocol conversion, Netty‑based push system, Snowflake ID generation, Elasticsearch storage, multi‑level caching, distributed locking, and the overall design principles that enable a scalable, reliable messaging platform.
This article introduces buddha, a lightweight distributed RPC framework, detailing its design principles, serialization choices, TCP packet handling, BIO vs NIO networking, service registration and discovery using ZooKeeper, and provides implementation insights for building efficient remote procedure call systems.
This article explains the background, protocol basics, handshake process, and practical implementation of WebSocket using Netty and netty‑socketio on the server side and socket.io on the client side, providing full code examples and deployment tips for high‑concurrency real‑time applications.
This article demonstrates how to build a Netty‑based server and client that support long‑living WebSocket connections, high concurrency, heartbeat monitoring, and automatic reconnection, providing complete code examples and detailed explanations of each component.
This article introduces Netty, an asynchronous event‑driven network framework, covering its design goals, performance benefits, core components such as zero‑copy and unified APIs, advanced features like SSL/TLS and WebSocket support, and explains its single‑thread, multi‑thread, and master‑slave thread models for high‑concurrency backend development.
This article explains the motivations for using Netty's HTTP protocol stack instead of a traditional Tomcat web container, covering high‑concurrency support, lower resource consumption, detailed HTTP request/response handling, custom decoders, memory‑leak prevention, and keep‑alive connection management.
This article describes the design, technology selection, and performance evaluation of Ctrip's real‑time user behavior data collection platform, covering Netty‑based network handling, Kafka/Hermes messaging, encryption, compression, Avro backup, and related analytics products, with detailed feasibility analysis and benchmark results.
This article explains how a Janus service gateway ran out of memory due to unreleased Netty off‑heap ByteBufs, how enabling Netty's leak detection and adjusting JVM parameters helped reproduce the issue, and how to fix the leak by explicitly releasing the buffers.
This article details the design, technology selection, architecture, encryption, compression, and performance evaluation of Ctrip's real-time user data collection system, which leverages Java, Netty, Kafka, and Avro to achieve high throughput, low latency, and robust fault tolerance for mobile and web applications.
The article outlines the core components of Netty—Bootstrap/ServerBootstrap, EventLoop, EventLoopGroup, ChannelPipeline, Channel, Future/ChannelFuture, ChannelInitializer, and ChannelHandler (Inbound and Outbound)—explaining their roles in configuring, handling I/O, and processing data within a non‑blocking, event‑driven network application.
This article explains Dubbo’s network transport architecture, the Dubbo protocol with Hessian2 serialization, details the encoding/decoding process using Netty, and proposes optimization techniques such as reducing array copies, leveraging Netty 4 decoders, compressing binary data, and adopting alternative high‑performance serialization formats.
This article explains the internal workflow of Netty when launching a server, covering why Netty is chosen over raw JDK NIO, the key components created during bootstrap, the step‑by‑step source‑code analysis of channel creation, initialization, registration, and the final bind operation that activates the server.
This article explains the principles of RPC, evaluates performance‑critical factors such as I/O models and transport protocols, and provides a step‑by‑step guide to building a high‑throughput, Netty‑based RPC server in Java, including design, code structure, testing, and possible enhancements.
This article explains how Twitter’s open‑source Finagle framework, built on Netty and written in Scala/Java, provides a fault‑tolerant, protocol‑agnostic RPC layer with load balancing, metrics, tracing, and filters, enabling massive tweet traffic without latency or downtime.
This article explains how large‑scale internet companies replace local service calls with remote procedure calls (RPC), covering Java dynamic proxies, message encoding, serialization, asynchronous response handling, and Zookeeper‑based service registration and discovery to achieve transparent, scalable service communication.
The article explains how TCPCopy can duplicate live TCP/UDP traffic for testing, describes the challenges of selective traffic copying, and details the design and implementation of DubboCopy—a Netty‑based proxy that lowers usage barriers, supports multi‑dimensional traffic selection, and monitors performance metrics with minimal resource overhead.
This article analyzes common push‑service questions, presents a memory‑leak case from an IoT MQTT middleware, and provides detailed Netty design guidelines—including file‑handle limits, CLOSE_WAIT handling, thread and task management, heartbeat tuning, buffer allocation, memory‑pool usage, logging pitfalls, TCP and JVM optimizations—to help engineers build stable, high‑performance million‑connection push servers.
This article analyzes common push‑service questions, presents a real‑world IoT case of memory leakage, and outlines key design points—including kernel limits, CLOSE_WAIT handling, heartbeat configuration, buffer management, memory pooling, logging pitfalls, TCP tuning, and JVM settings—to build a scalable, stable Netty‑based push server for millions of concurrent connections.
The article examines why upgrading from Netty 3.x to 4.x can cause severe performance drops, analyzes thread‑model changes, GC overhead, context loss, and provides detailed comparisons of inbound/outbound processing, concluding with best‑practice recommendations for safe migrations.
