This article analyzes why Netty and ZooKeeper form the foundation of RPC frameworks, covering IO model evolution, communication and coordination layers, core components, common pitfalls, and a 10-part series roadmap to build a mini RPC system.
This article compares four Java approaches for calling WebServices — Axis2 code generation, RPC, HttpURLConnection, and HttpClient — detailing pros, cons, code samples, and a real-world namespace mismatch issue when integrating with C-based services.
This article details migrating from Spring Cloud/OpenFeign to Apache Dubbo 3 with Spring Boot 3, covering Triple protocol over HTTP/2, binary serialization, service governance (timeouts, retries, load balancing), streaming, observability, and production pitfalls with benchmark comparisons showing 3-5x throughput gains.
This article analyzes six public benchmark datasets comparing HTTP/1.1+JSON (REST) against binary protocols like gRPC+Protobuf and Dubbo, showing gRPC achieves roughly 2x throughput and half the latency, but argues the gap is often negligible in real business scenarios where database and logic dominate latency.
This article analyzes three real e-commerce production incidents caused by misconfigured timeouts and uncontrolled retries, then provides a systematic framework for timeout calculation, call-chain layering, retry decision boundaries, MQ-specific rules, and a release-review checklist to prevent cascading failures in microservices.
This comprehensive guide compares Dubbo, gRPC, and Feign across eight critical dimensions including protocols, serialization, performance, cross-language support, service discovery, circuit breaking, streaming, and hybrid architecture coordination, with detailed interview questions and answers for each.
This article compares Dubbo, gRPC, and Feign across circuit breaking, streaming, contract management, learning curves, and real-world scenarios, providing a decision matrix and a Spring Cloud Alibaba hybrid architecture where all three coexist for external HTTP, internal high-frequency Java, and cross-language algorithm services.
The article walks through three real‑world Java service scenarios—high‑frequency internal calls, cross‑language algorithm services, and Spring Cloud gateway integration—comparing Dubbo, gRPC and OpenFeign on protocol, serialization, latency, throughput, cross‑language support, service governance and discovery, and finally presents a decision matrix and a mixed‑architecture demo.
Based on three years running 50+ microservices, this article details production pitfalls in Nacos, Sentinel, Seata, and Dubbo, covering configuration isolation, hot-update risks, rule persistence, distributed transaction misuse, and thread pool tuning, with real incident postmortems and concrete configuration standards.
This article provides a deep dive into Dubbo’s core architecture, registry resilience, protocol choices, load‑balancing strategies, cluster fault‑tolerance policies, SPI enhancements, the shift from interface‑level to application‑level service discovery, timeout‑cascade pitfalls, and how to run Dubbo alongside Spring Cloud in a Spring Boot 3 + Nacos environment.
This article walks through creating a minimal Java 17 RPC framework—from defining a simple binary protocol and using JDK serialization to implementing server loops, dynamic proxy‑based clients, and a runnable demo—while also highlighting the gaps that production‑grade solutions like Dubbo or gRPC must fill.
This guide presents a systematic, layer‑by‑layer methodology for diagnosing and resolving NFS share mount failures, covering version differences, architecture layers, key daemons, RPC mechanisms, common error messages, detailed server and client checks, firewall and SELinux considerations, performance tuning, high‑availability setups, and monitoring.
A 3‑second fixed timeout turned an 800 ms latency spike in a recommendation service into a full‑site outage, illustrating how static timeouts can exhaust thread pools; the article walks through evolving from global timeouts to per‑interface limits, deadline propagation, and coordinated timeout‑retry‑circuit‑breaker strategies for resilient 10 M‑QPS systems.
A large‑scale load test revealed that 70% of latency was spent packing and unpacking HTTP messages, prompting an analysis of why early‑stage HTTP is convenient, how text‑based formats and connection handling become costly at high frequencies, and why binary serialization, private protocols, and connection reuse are essential for reaching ten‑million QPS.
This article introduces gRPC, Google’s high‑performance RPC framework built on HTTP/2 and Protocol Buffers, compares it with REST, explains protobuf type mappings, demonstrates service definitions and all four communication patterns, and covers advanced topics such as interceptors, load balancing, deadlines, error handling, and microservice integration.
The article breaks down three fundamental mechanisms—synchronous RPC, asynchronous MQ, and offline scripts—by comparing their lifecycles, IO models, bottlenecks, and consistency guarantees, and provides a concrete decision framework for choosing the right tool for different business scenarios.
The article breaks down a complete Dubbo RPC invocation into ten precise steps—five on the consumer side and five on the provider side—explaining each core component such as Proxy, Filter, Cluster, LoadBalance, Protocol, and Transport, and addresses common interview follow‑up questions about clustering, load balancing, and sync vs async calls.
The article explains that RPC outperforms traditional HTTP/1.1 + JSON because of a slimmer binary protocol, faster binary serialization, persistent long‑connection reuse, and an efficient NIO network model, while noting that HTTP/2 + gRPC narrows the gap.
This article walks through the inner workings of the open‑source tRPC‑Go RPC framework, detailing the client invoke lifecycle, selector reporting, codec serialization, transport handling, server processing, plugin architecture, streaming support, and performance‑oriented design choices for Go backend developers.
The article explains how network protocols have evolved from raw TCP sockets to standardized HTTP and finally to RPC frameworks, showing that each step is an abstraction upgrade rather than a replacement, and clarifies when to use HTTP versus RPC based on system boundaries and engineering trade‑offs.
This article explains why remote procedure call (RPC) remains essential for microservice communication, detailing its historical roots, the limitations of HTTP, the multi‑step RPC workflow—including service discovery, serialization, network transmission, dynamic proxies, and governance—and how RPC and HTTP complement each other in modern architectures.
The article demystifies APIs by defining them as communication bridges between software, outlining their core functions—data sharing, feature reuse, system decoupling—highlighting common pitfalls such as permission, versioning, error handling and parameter validation, describing RESTful, SOAP and RPC types, and illustrating real‑world scenarios like real‑time data collection, data service exposure, and third‑party integration.
The article traces the evolution from monolithic Java apps to RPC services, explains why sharding and database partitioning cannot alone achieve limitless scaling due to connection limits, and introduces unitization—assigning each application to a specific database shard—to overcome the bottleneck.
The article explains how TCP provides reliable byte‑stream transport but lacks message boundaries, how HTTP adds structured semantics with headers like Content‑Length, and why RPC frameworks such as gRPC are introduced to make remote calls feel like local method invocations, especially in modern microservice architectures.
This article dives deep into Olric’s network communication architecture and RPC mechanism, explaining its layered transport design, request/response structures, pipeline and batch processing, client‑to‑cluster interactions, data migration and rebalancing, and provides Go code examples illustrating high‑throughput, safe distributed operations.
The article dissects XXL-JOB's communication layer, showcasing Netty HTTP usage, a full asynchronous processing pipeline, dynamic proxy abstraction, request‑ID based thread wake‑up, and detailed Java code examples that illustrate how the scheduler and executor achieve high‑throughput remote job execution.
This article explains the role of an API gateway in microservice architectures, walks through configuring the micro framework’s gateway with options like address, namespace and handler, shows how to modify server and client code, and demonstrates testing the gateway using curl.
This article explains how xxl-job uses Netty HTTP as its communication backbone, hides network details with dynamic proxies, processes tasks asynchronously via queues, and synchronously retrieves results through future‑response mechanisms, all illustrated with code snippets and a flow diagram.
This article explains how xxl-job employs Netty HTTP, dynamic proxy patterns, and fully asynchronous processing to achieve efficient remote procedure calls, detailing the communication layer, overall workflow, key design points, and the underlying Java code that synchronously retrieves results from asynchronous operations.
This guide walks you through the concepts, environment setup, step‑by‑step integration, advanced configurations, monitoring, troubleshooting, and best practices for combining Dubbo's high‑performance RPC framework with Spring Boot to build production‑grade distributed Java services.
This article explains how xxl‑job uses Netty HTTP, dynamic proxies, and fully asynchronous processing to implement a high‑throughput RPC mechanism, detailing the communication layer, overall workflow, and the clever design that wraps async calls into synchronous‑looking code.
This article compares four major RPC frameworks—gRPC, Dubbo, Thrift, and Spring Cloud OpenFeign—detailing their core features, performance characteristics, language support, and ideal use cases to help engineers choose the right solution for high‑throughput, low‑latency microservice architectures.
This article explains how xxl-job leverages Netty HTTP, dynamic proxy patterns, and fully asynchronous processing—including thread‑waiting mechanisms and UUID request IDs—to achieve efficient remote procedure calls, with detailed code examples illustrating the scheduler‑executor communication flow.
This guide explains why RPC is needed, introduces the tinywan/rpc plugin for the Webman framework, and provides step‑by‑step installation, server and client code examples, response handling, error logging, advantages, and real‑world use cases for building fast, flexible backend services.
This guide introduces Workerman‑JsonRpc, a lightweight PHP RPC framework built on Workerman, detailing its key features, environment requirements, installation steps, synchronous and asynchronous client usage, server implementation, and built‑in monitoring capabilities for creating scalable network applications.
Learn the fundamentals of NFS (Network File System) on Linux, including its architecture, advantages, required packages, configuration files, export options, essential commands like rpcinfo, exportfs, showmount, and step‑by‑step examples for setting up NFS servers and clients with autofs.
This article explains SSE streaming for LLM outputs by analyzing DeepSeek's network packets, demonstrates production-grade SSE client and server code using Go's Hertz framework, and evaluates SSE versus gRPC for internal service-to-service streaming RPC.
This article explains what RPC is, why RPC frameworks are needed, the underlying principles and technologies such as dynamic proxies, serialization, NIO communication, service registration, governance and routing, and walks through a simple hand‑crafted RPC implementation with a comparison of popular frameworks.
This article compares RPC and HTTP services, explains the OSI model layers relevant to each, details RPC architecture components, discusses synchronous and asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right approach for large‑scale enterprise applications.
This article explains why RPC should be used when callers need immediate results, why forcing MQ for request‑response adds complexity and risk, and how combining RPC for result‑sensitive flows with MQ for fire‑and‑forget events achieves clean architectural decoupling.
This article compares RPC and HTTP services, explains the OSI seven‑layer model, details RPC architecture and its synchronous versus asynchronous calls, reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose RPC over HTTP for enterprise applications.
This article explains how NFS provides Linux file sharing, details the RPC-based architecture, walks through server and client configuration, demonstrates integration with nginx, and offers troubleshooting tips for common NFS failures, making it a comprehensive guide for operations engineers.
This guide explains the lightweight, stateless JSON-RPC 2.0 protocol, detailing its request and response structures, error handling, notifications, batch processing, and real‑world use cases such as AI tool integration, blockchain node interaction, and IoT device communication.
The article explains why RPC should be used when callers need immediate results, while MQ is preferable for fire‑and‑forget notifications, illustrating the trade‑offs with code examples, common pitfalls of misusing each method, and practical steps to achieve physical and logical decoupling in backend systems.
This article introduces the JSON-RPC 2.0 protocol, demonstrates how to integrate the jsonrpc4j library into a Spring Boot 3.4.2 project, and provides step‑by‑step code examples for defining services, exposing them via beans or annotations, configuring various client proxies, handling errors, and implementing streaming socket communication.
This tutorial demonstrates how to reverse‑engineer the X‑Product Android app, locate the dynamic newSign parameter, hook the RequestUtils.c method with Frida, and expose it via an RPC‑based FastAPI service to generate valid signed requests for the search API.
This article demonstrates how to employ Frida's RPC forwarding to intercept and bypass encryption in a mobile app, providing step‑by‑step environment setup, hook scripts, and a FastAPI service that enables Python‑based crawling of protected API endpoints.
The article analyzes data‑consistency challenges caused by RPC timeouts, especially when interfaces lack idempotency or idempotency fails, and presents a lightweight mock/spy utility that can intercept, mock, or spy on service calls to quickly restore consistency in distributed systems.
This tutorial walks through integrating Dubbo with Spring Boot using Nacos as the service registry, showing how to create a shared API module, configure provider and consumer Maven projects, annotate services with @Service and @Reference, and verify successful RPC calls via a simple REST endpoint.
The article explains why modern AI agent systems need horizontal and vertical scaling, outlines the engineering challenges such as state consistency, scheduling, protocol design, and message efficiency, and compares three collaboration approaches—AutoGen's distributed runtime, classic RPC/MCP, and Google's A2A—while providing concrete code examples and deployment steps.
This guide explains what NFS (Network File System) is, its advantages, required packages, configuration file syntax, export options, essential tools like rpcinfo, exportfs, showmount and mount.nfs, and provides step‑by‑step examples for mounting, fstab entries, and integrating autofs on CentOS systems.
The article presents a lightweight tool to handle data consistency in RPC services during network timeouts by mocking or spying on service calls, ensuring data integrity without actual execution.
This article explores the challenges of data consistency in RPC timeout scenarios, especially when idempotency fails, and introduces a lightweight mock/spy tool that can dynamically configure mock responses for any method call, helping restore consistency without full transaction support.
This article compares four major API architectural styles—RPC, SOAP, REST, and GraphQL—by detailing their mechanisms, advantages, disadvantages, and typical use cases, and then provides guidance on selecting the most suitable style based on language, environment, and resource constraints.
The article explains why designing RPC interfaces with generic Result objects that contain errorCode, errorMessage and data defeats RPC's purpose, and demonstrates how returning plain business objects and leveraging Java exceptions leads to cleaner, more maintainable backend code.
This article explains why designing RPC (JSF) interfaces to return HTTP‑like result objects with errorCode, errorMessage, and data defeats the purpose of RPC, and it offers concrete guidelines and Java examples for building clean, exception‑driven RPC APIs.
This article examines four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, advantages, disadvantages, and typical use cases, and provides guidance on selecting the most suitable style based on project requirements and constraints.
Learn how to configure and manage NFS on Linux, covering its architecture, required packages, export file syntax, common options, essential tools like rpcinfo and exportfs, mounting techniques, and a step‑by‑step autofs deployment example.
A detailed investigation reveals why an RPC interface with an average 1.5 ms execution time still experiences hundreds of 100 ms+ timeouts, analyzes framework versus business latency, identifies GC and I/O jitter as root causes, and proposes an elastic timeout strategy to meet five‑nine reliability targets.
This article explains RPC fundamentals, detailing a Java example that uses Spring for bean management, Netty for high‑performance network communication, and Zookeeper for service registration and discovery, and walks through both server and client implementations with code snippets and test results.
This article explains how Apache Dubbo 3.3.3 natively supports OpenAPI 3, allowing developers to automatically generate API documentation, export Proto files, integrate with Swagger UI and Apifox, and customize the output via annotations, all without extra dependencies or complex configuration.
The article details a performance optimization case where interface latency was diagnosed with Pfinder and UMP, revealing excessive RPC calls and database queries, and then improved by replacing inefficient list operations with Set-based logic and introducing JSF asynchronous calls, cutting response times from seconds to milliseconds.
This article investigates why an RPC interface with an average execution time of 1.5 ms still experiences numerous 100 ms+ timeouts, analyzes the root causes such as GC and I/O jitter, and proposes an elastic timeout optimization to improve service reliability.
This article examines gRPC’s implementation principles, multi‑language support, Protocol Buffers foundation, advantages and disadvantages, and provides a C++/Go demo illustrating its cross‑language capabilities within cloud‑native environments, including project structure, code snippets, and discussion of HTTP/2 transport.
This article examines gRPC’s implementation principles, its multi‑language support, Protocol Buffers integration, performance advantages, and limitations such as browser compatibility, while providing a C++/Go demo that showcases cross‑language RPC calls and a detailed project structure.
This guide explains the purpose of NFS for Linux file sharing, its architecture and RPC relationship, step‑by‑step server and client deployment, integration with Nginx, and common troubleshooting techniques for reliable shared storage in production environments.
The article systematically compares four major API styles—SOAP, REST, GraphQL, and RPC—detailing each one's core characteristics, advantages, limitations, and suitable use‑cases, and concludes with guidance on selecting the most appropriate protocol based on security, performance, complexity, and team expertise.
The article explains how Apache Dubbo's Triple X protocol now fully supports HTTP/3, detailing its design goals, performance advantages, configuration steps, code examples, and real‑world benchmarks that demonstrate significant latency reduction and reliability improvements in cloud‑native microservice environments.
This article compares Dubbo and Feign, outlining their architectures, features, and suitability for different microservice scenarios, and provides practical guidance on selecting the appropriate RPC framework based on performance, reliability, and development efficiency requirements.
This article walks frontend developers through the fundamentals of the TRPC framework, explaining why understanding RPC protocols, the layered architecture, plugin system, multi‑process handling, and Protobuf serialization is essential for building high‑performance, scalable services and improving debugging efficiency.
This article provides practical Python code examples for various messaging and serialization tools—including Celery, RQ, Huey, ZeroMQ, kafka‑python, Pika, stomp.py, nats‑py, gRPC, Thrift, Protobuf, Avro, msgpack, and Flatbuffers—demonstrating how to set up producers, consumers, and services for asynchronous processing and data exchange.
The article details how a Java SDK for a CIM instant‑messaging system was redesigned using Java 8+ features and the Builder pattern, introduced a lightweight proxy resembling RPC frameworks with dynamic‑URL support, and added comprehensive integration tests that verify automatic client reconnection and reliable message delivery across clustered servers.
This article explains why Spring Cloud uses HTTP instead of RPC for remote calls, compares HTTP and RPC protocols, describes how to implement a simple HTTP server in Java, outlines the principles of RESTful architecture, and discusses the advantages, disadvantages, and future trends of both approaches.
The article clarifies that RPC (Remote Procedure Call) is a mechanism—not a protocol—used to abstract network communication so remote methods can be invoked like local calls, illustrating its design with LPC, dynamic proxies, request handlers, and showing HTTP as one possible implementation.
This article explains why Spring Cloud prefers HTTP over RPC for remote calls, covering the embedded Tomcat architecture, JSON data exchange, the fundamentals of RPC over TCP, and compares their advantages, disadvantages, and suitability for microservice development.
This tutorial walks through creating a remote procedure call (RPC) system with RabbitMQ in Java, covering client and server design, callback queues, correlation IDs, code examples, deployment steps, scalability benefits, and common pitfalls to avoid.
The article compares Spring Cloud’s HTTP‑based, Tomcat‑served JSON services with TCP‑based RPC, highlighting HTTP’s cross‑platform flexibility and ease of use versus RPC’s faster, binary‑serialized calls that mimic local methods, and advises choosing HTTP for microservice, loosely‑coupled architectures despite RPC’s speed advantage.
This article explains why Spring Cloud prefers HTTP over RPC for remote calls, detailing the underlying Tomcat-based web service, the differences between HTTP and RPC protocols, their advantages and disadvantages, and provides guidance on choosing the appropriate approach for microservice architectures.
This report analyzes performance bottlenecks caused by serialization in a search‑recommendation system, presents detailed measurements of request latency, evaluates multiple optimization strategies—including Redis caching, lazy metric handling, and custom byte‑array serialization—and documents the resulting latency reductions and implementation considerations.
This article compares Spring Cloud and Dubbo, detailing their core design philosophies, communication protocols, service governance features, and ideal application scenarios to help developers choose the most suitable microservice framework for their projects.
This article explains the fundamentals and key characteristics of Remote Procedure Call (RPC), outlines common use cases and popular frameworks, and then walks through the design and implementation of a simple custom RPC system—including a bespoke binary protocol, client‑side proxy generation, serialization, Netty‑based encoding/decoding, server‑side request handling, and result delivery—using Java and Netty.
This article explains the fundamentals of Remote Procedure Call (RPC), its role in distributed systems, the architecture and workflow of RPC frameworks, and compares popular implementations such as Thrift, Dubbo, and Spring Cloud with other communication styles like REST, SOAP, and SOA.
This article introduces the fundamentals and key features of Remote Procedure Call (RPC), explores common use cases and popular frameworks, then walks through the design and implementation of a custom RPC system using Netty, covering protocol design, client‑server communication, serialization, encoding, decoding, and result handling.
This article walks through the complete lifecycle of a single RPC call in Dubbo 3.x, covering demo setup, provider exposure, consumer referencing, parameter packaging, filter chains, cluster decision, routing, load balancing, communication and serialization protocols, and finally how the provider processes the request.
The article explains how microservice architectures handle inter‑service calls using RPC or event‑driven approaches, analyzes different coupling types, compares event notification with event sourcing, and offers practical guidance on API gateways, service composition, and when to choose each communication style.
This guide explains how to set up remote procedure calls in a ThinkPHP application using the Swoole extension, covering extension installation, Composer dependencies, server and client configuration, interface definition, hot‑reload handling, and common pitfalls such as Xdebug conflicts.
This article walks through creating a distributed instant‑messaging system in Go, covering the full tech stack, Docker‑based and local startup methods, configuration files, the end‑to‑end request flow, and detailed code examples for RPC, Redis queues, WebSocket delivery and the internal bucket architecture.
This article explains the principles and implementation of a Java RPC framework, covering service registration with Zookeeper, serialization, compression, network communication via Netty, dynamic proxy generation using reflection and Javassist, and performance considerations, providing extensive code examples for each component.
This article explains the fundamentals of Network File System (NFS), its reliance on RPC for communication, the step‑by‑step workflow of NFS operations, configuration details in /etc/exports, common troubleshooting cases, and practical command‑line examples for Linux administrators.
This article compares the four major API architectural styles—RPC, SOAP, REST, and GraphQL—by explaining how each works, outlining their strengths and weaknesses, presenting real‑world use cases, and offering guidance on selecting the most suitable style for a given project.
This article explains the fundamentals of Remote Procedure Call (RPC), its core components and workflow, compares it with other communication methods, lists popular RPC frameworks, and distinguishes RPC from SOA, SOAP, and REST, providing a comprehensive overview for backend developers.
This article explains the fundamentals of TCP, why raw TCP communication faces issues like message boundary ambiguity, how HTTP and RPC are built on TCP as application‑layer protocols, and compares their use cases, performance, and evolution to help developers choose the right protocol for their systems.
This article explains the fundamentals of Remote Procedure Call (RPC) frameworks, their underlying architecture, communication steps, role of providers, consumers, and registries, and compares popular RPC solutions with other service paradigms such as SOA, SOAP, and REST.
This article explains TCP basics, why raw TCP communication has boundary issues, how custom protocols like HTTP and RPC are built on TCP, and compares their purposes, performance, and usage scenarios in modern software architecture.
HSF (High‑speed Service Framework) is Alibaba’s high‑performance SOA solution that decouples monolithic applications via non‑blocking RPC, offering service discovery, dynamic routing, grouping, and both synchronous and asynchronous calls, configurable serialization, timeout, and thread pools, and employing patterns such as proxy, chain‑of‑responsibility, observer and decorator.
Spring Cloud can use either HTTP‑based REST calls, which offer flexible, language‑agnostic JSON communication and simpler implementation, or RPC over TCP, which provides faster, binary‑serialized calls that appear local but require tighter API contracts, so modern microservices usually prefer HTTP for its adaptability and scalability.
This article explores the fundamentals of TCP communication, explains why raw TCP lacks message boundaries, and compares HTTP and RPC protocols—covering their histories, use cases, service discovery, connection handling, serialization, and performance trade‑offs—to answer why both coexist in modern software architectures.
This article explains Dubbo's role as a high‑performance RPC framework, details its ten‑layer architecture, and walks through the eleven‑step call process, providing clear diagrams and concise descriptions for developers building distributed systems.