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 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 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 unified exchange mall middleware platform consolidates disparate points‑redemption and lottery flows into a four‑layer architecture—business, gameplay templates, domain models, and downstream services—offering standardized APIs, dynamic RPC routing, Redis‑based inventory control, anti‑fraud safeguards, and built‑in monitoring, thereby cutting development costs, enhancing maintainability, and ensuring system stability.
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 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 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.
This article explains the fundamentals of Remote Procedure Call (RPC), why it is crucial for developing production‑grade instant‑messaging clusters, how it differs from plain HTTP, the typical RPC call flow, common frameworks such as gRPC, Thrift and Dubbo, and practical considerations for high‑throughput distributed systems.
The article explains how microservice systems handle service calls, compares RPC and event‑driven (message) communication, details various coupling types, discusses event notification and event sourcing, and offers practical guidance on reducing tight coupling through API gateways, versioning, and gRPC.
This article explains why remote procedure call (RPC) is essential for modern distributed services, describes the evolution from monolithic to service‑oriented architectures, and details the core components, communication steps, serialization, service discovery, and full call flow of an RPC framework.
This article explains the fundamentals of Remote Procedure Call (RPC), its historical origins, the step‑by‑step execution process, and provides a practical guide to installing and using gRPC with Protocol Buffers in Go, including full code examples and advantages.
The article analyzes why Spring Cloud often prefers HTTP instead of RPC for remote calls, detailing the technical differences, advantages, disadvantages, and selection criteria of each approach, and explains how microservice trends shape this choice.
The article explains why Spring Cloud prefers HTTP over RPC for remote calls, detailing the advantages of embedded Tomcat and JSON over HTTP, the limitations of TCP‑based RPC, and provides a comparative analysis of their architectures, pros, cons, and suitability for microservices.
This article explains how Spring Cloud leverages embedded Tomcat to handle HTTP requests for flexible, cross‑platform microservice communication, contrasts it with TCP‑based RPC's handshake and serialization requirements, and outlines the advantages, disadvantages, and future trends of each approach.
This tutorial walks through creating a complete Spring Boot 2.7 project that integrates Apache Dubbo for RPC, covering environment setup, Maven dependency management, interface definition, provider and consumer implementations, configuration with Nacos, and testing the end‑to‑end service.
This article details the practical steps and architectural choices NetEase Cloud Music took to improve RPC stability in a micro‑service environment, covering service discovery, connection management, cloud‑native challenges, SLO design, log governance, degradation, rate limiting, outlier detection, thread‑pool isolation, fast‑failure handling, registry optimizations, multi‑registry support, and post‑incident knowledge‑base building.
This article explains how Spring Cloud leverages HTTP via an embedded Tomcat container for flexible, cross‑platform microservice communication, contrasts it with TCP‑based RPC's serialization requirements, and outlines the advantages, disadvantages, and selection criteria for each approach.
This article explains the concepts, design principles, and key differences among RESTful, SOAP, RPC, SOA, and microservices, and outlines why microservices have emerged as an evolution of SOA, illustrated with typical framework examples and architectural evolution diagrams.
This article provides a comprehensive overview of the lightweight XXL‑RPC framework, covering fundamental RPC concepts, the framework's architecture built on Spring and Netty, detailed provider and consumer implementations, various call types, and the service registry‑discovery mechanism, concluding with practical insights for developers.
This article explains the fundamentals of device communication, from simple LAN setups using hubs and switches to internet protocols like HTTP, then guides the design of custom communication protocols, illustrates JSON‑RPC over sockets, and explores CAN bus specifics, offering practical code examples and architectural diagrams.
This article details the challenges of RPC stability in a large‑scale microservice environment and explains the architectural redesign, SLO implementation, logging governance, exception dashboards, degradation, rate‑limiting, outlier removal, thread‑pool isolation, weak registry dependencies, and post‑incident knowledge‑base practices that together ensure reliable, high‑performance service communication.
The article reports on Zhengcai Cloud's successful migration to Dubbo3.1.8, detailing the motivations, scale of the system, upgrade process, and the resulting performance and stability improvements for its massive procurement platform.
tRPC is a highly extensible, plugin‑driven backend RPC framework designed to unify disparate service stacks, support cloud‑native components, and provide cross‑language, multi‑protocol, and streaming capabilities while delivering strong performance and easy integration for large‑scale enterprises.
This article explains the different types of coupling in microservice architectures, compares RPC and event‑driven communication methods, discusses event notification and event sourcing, and offers practical guidance on choosing and combining these approaches to reduce tight coupling while maintaining system flexibility.
The article examines microservice communication methods, comparing event‑driven (including event notification and event sourcing) with RPC, discussing API gateways, service coupling, design limits, internal microservice design, and provides practical guidance on choosing the appropriate approach.
Vivo tackled high CPU overhead in large‑scale Dubbo deployments by disabling unused routers, caching routing results with BitMap intersections and epoch validation, optimizing weight calculations, and adding a grouping router, which together delivered over 100 % TPS gains for 20 k+ providers and cut CPU usage by roughly 27 %.
tRPC is an open‑source, plugin‑based RPC framework that separates core communication, service‑governance, and invocation layers, supports extensible codecs, naming, config, metrics, logging and tracing plugins, offers an Admin API, and demonstrates high throughput and low tail latency in cloud‑native deployments.
This article explains the concept of Remote Procedure Call (RPC), compares it with other inter‑system communication methods, outlines the three core problems RPC must solve—call ID mapping, serialization, and network transport—and discusses high‑availability considerations and I/O models for building robust RPC frameworks.
This article explains the concept of RPC frameworks, compares popular solutions such as Dubbo, gRPC, Thrift and Feign, and details the architectural differences and use‑cases of Dubbo versus Spring Cloud for building high‑performance backend services.
This article explains the OSI seven‑layer network model, compares RPC and HTTP services, describes RPC architecture, synchronous and asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right approach for enterprise back‑end systems.
