This tutorial walks through setting up Apache Dubbo3’s Triple protocol in Node.js, from installing code‑generation tools and defining a protobuf service to generating TypeScript stubs, implementing the service, launching a Fastify server, and invoking the RPC via curl or a Dubbo client.
This article explains the fundamentals of Remote Procedure Call (RPC), explores how data moves across OSI layers, compares HTTP and RPC, and provides a complete Node.js JSON‑RPC example with code, error handling, and real‑world use cases such as Chrome DevTools Protocol.
This article explains the concept and implementation principles of RPC frameworks, describes the roles of provider, consumer, and registry, outlines the communication, addressing, serialization, and service invocation steps, and compares RPC with SOA, SOAP, and REST in terms of architecture and usage.
This article explains how to use Thrift as an interface definition language to automatically generate TypeScript client code, covering the definition syntax, annotation for request mapping, code generation architecture, and practical examples that boost frontend development efficiency.
This article explains the fundamental differences between RPC and HTTP, covering their historical origins, design principles, serialization formats, protocol layers, network communication mechanisms, and appropriate usage scenarios in micro‑service architectures.
An in‑depth guide walks through TCP basics, why raw TCP lacks message boundaries, how HTTP and RPC build on TCP, and compares their service discovery, connection handling, and serialization, revealing why both protocols coexist in modern client‑server architectures.
This article walks through building a simple Java RPC framework, covering core concepts such as service registration with Zookeeper, client-side dynamic proxies, network communication via Netty, serialization, compression, and both reflection and Javassist-based proxy generation, complete with code examples and performance comparisons.
This article explains Dubbo's three core capabilities—remote method invocation, intelligent fault tolerance with load balancing, and service registration/discovery—details its main components and ten architectural layers, and walks through the eight-step RPC call flow, providing a comprehensive overview of the backend framework.
This article explains the fundamentals of TCP, why pure TCP communication faces boundary issues, how HTTP and RPC are built on TCP as application‑layer protocols, and compares their architectures, service discovery, serialization, and performance to clarify when each should be used.
This article explains how to use a timing wheel to efficiently handle RPC timeout processing, startup timeouts, and heartbeat tasks, reducing thread proliferation and CPU waste by organizing timed tasks into hierarchical time slots.
The article outlines practical coding habits—thorough input validation, comprehensive logging, careful RPC handling, batch processing, cautious SQL execution, safe extensions, disciplined refactoring, minimal dependencies, data consistency, and avoiding over‑engineering—to help engineers write reliable, maintainable code.
The article walks Java developers through constructing a lightweight Netty‑based RPC framework—using RocketMQ’s NettyRemotingServer and NettyRemotingClient to handle synchronous, asynchronous and one‑way calls, routing request codes to dedicated processors and thread pools, exposing services via dynamic proxies, and outlining extensions such as service‑registry integration for a full microservice communication solution.
This article shares a detailed account of a Tencent testing engineer interview, covering self‑introduction, Go knowledge, Redis performance, distributed lock implementation, semaphore mechanics, RPC vs HTTP, concurrency usage, Git security practices, Linux commands, and a few brain‑teaser and algorithm questions.
This article details the design and implementation of a self‑built automated testing platform for backend services that achieves near‑full test‑case coverage by unifying HTTP/RPC access, introducing a parameter‑pool, leveraging JSON Schema and JSONPath, and automating case generation and promotion.
This article explains the fundamental differences between RPC and HTTP interfaces, their underlying protocols, component architectures, popular frameworks, performance characteristics, and provides guidance on when to use each approach in backend service development.
This article explains the fundamental differences between RPC and HTTP interfaces, describes their underlying client‑server architectures, compares performance, transport protocols, load balancing and service governance, and provides guidance on when to choose each approach in modern backend development.
This article compares RPC and HTTP interfaces, detailing their architectures, popular frameworks, performance characteristics, load‑balancing, and service‑governance features, and provides practical guidance on selecting the right approach for internal high‑performance services or external cross‑platform APIs.
This article explains the definition, importance, and practical design guidelines for achieving idempotency in distributed systems, especially in financial and payment scenarios, by detailing key elements, principles, common pitfalls, and implementation patterns with code examples.
This article examines microservice communication, comparing RPC and event‑driven approaches, explains different types of coupling, explores event notification and event sourcing, discusses API gateways and internal microservice design, and offers guidance on choosing the right integration method and managing service count.
This article explains how JD.com’s retail shopping‑cart team tackled growing business complexity by redesigning the cart with a full asynchronous architecture, detailing the overall solution, implementation challenges such as fine‑grained retries and monitoring, and the resulting performance gains.
This article explains the fundamental differences between RPC and HTTP services, covering OSI model layers, RPC architecture components, synchronous vs asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and when to choose each approach for enterprise applications.
This article explains the fundamentals of Remote Procedure Call (RPC), covering its definition, core challenges, service registration and discovery with Zookeeper, client proxy generation, network transmission using Netty, serialization and compression, server-side request handling via reflection or Javassist, and performance comparisons between proxy strategies.
This article explains the fundamental distinctions between RPC and HTTP services by reviewing the OSI network layers, RPC architecture components, synchronous versus asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and the typical use cases of each approach.
This article explains the core concepts, design principles, and key differences among RESTful, SOAP, RPC, SOA, and microservices, illustrating how they relate to each other and why modern architectures increasingly adopt microservices for scalability and business agility.
This article explains the design and implementation of JD's JSF RPC framework, detailing the architecture, XML configuration of providers and consumers, Spring namespace handling, service registration, server startup, client initialization, load balancing, and the overall workflow from provider exposure to consumer invocation.
The gRPC 1.53.0 release introduces a series of core improvements, language‑specific enhancements for C++, C#, Python and Ruby, as well as bug fixes and new APIs, providing higher stability and performance for modern high‑performance RPC applications.
This article explains the design of a compact RPC service that aggregates product benefit information, detailing how Sirector thread scheduling reduces CPU consumption and how abstract handlers and Spring prototype beans improve code maintainability and extensibility.
This article explains the core components of an RPC framework—including transport, serialization, protocol framing, compression, bootstrap integration, service discovery, connection management, and a plugin‑based microkernel architecture—while highlighting design trade‑offs and practical extensions for robust backend systems.
This article explains the core principle of RPC using dynamic proxies, showing how interfaces are proxied at runtime, the code generation process, and compares JDK, Javassist, and Byte Buddy proxy implementations with practical examples.
This article explains the role of network communication in RPC, compares blocking I/O, non‑blocking I/O, I/O multiplexing and asynchronous I/O, discusses why blocking I/O and multiplexing dominate, introduces zero‑copy techniques at the OS and Netty levels, and shows how Netty optimizes data handling for high‑performance RPC.
A mistaken Zookeeper restart caused a 30‑minute outage of all microservices; this article analyzes the ZK session mechanism, why temporary nodes were not recreated, and presents two concrete solutions and best‑practice recommendations to prevent similar failures.
This article walks through a hands‑on Go RPC demo, explains the underlying server and client mechanisms, explores registration, HTTP handling, request processing, object pooling, and the gob codec, and clarifies why Go includes RPC alongside HTTP.
The article examines how microservices interact, compares RPC and event‑driven approaches, analyzes different types of coupling, discusses event notification, event sourcing, API gateways, versioning, and offers practical guidance on reducing tight coupling and deciding the appropriate microservice architecture.
This guide introduces the high‑performance Workerman PHP socket framework, outlines its key features, provides step‑by‑step installation and start/stop commands, and demonstrates how to build and consume RPC services with both synchronous and asynchronous client calls.
This article explains the fundamental components of RPC architecture, details the client‑server roles, communication protocols, serialization methods, transport protocols, and synchronous versus asynchronous invocation patterns, providing a comprehensive guide for building a custom RPC framework.
This article examines the trade‑offs between RPC and event‑driven communication in microservice architectures, detailing different types of coupling, the benefits and drawbacks of event notification and event sourcing, practical examples, and strategies such as API gateways and internal microservice design to reduce tight coupling.
This article walks through the design and implementation of a lightweight Java RPC framework, covering core concepts such as service registration and discovery with Zookeeper, network communication via Netty, serialization, compression, dynamic proxy generation using Javassist, and performance comparisons between reflection and bytecode‑generated proxies.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous vs asynchronous calls, popular RPC frameworks, and when to choose each approach for enterprise applications.
This article explains the principles and implementation of a lightweight Java RPC framework, covering service registration with Zookeeper, client-side dynamic proxies, serialization, compression, Netty-based network transport, and both reflection and Javassist proxy generation, with extensive code examples and performance comparison.
This article explains the need for generic RPC calls in gateway and testing scenarios, compares Java‑Bean‑based and serialization‑intermediate approaches, and shares Zhuanzhuan's practical implementation details, helping developers choose the most suitable generic invocation method for their RPC frameworks.
This article explains the core distinctions between Remote Procedure Call (RPC) and Message Queue (MQ) technologies, covering their architectures, communication patterns, functional features, and performance considerations, and outlines typical use cases such as synchronous calls, decoupling, traffic shaping, and asynchronous processing in distributed systems.
The article explains how microservices communicate, comparing RPC and event‑driven approaches, describing event notification and event sourcing, discussing API gateways, coupling types, internal microservice design, and practical guidelines for limiting service count and reducing tight coupling.
This article explains the OSI seven‑layer model, compares RPC and HTTP services, details RPC architecture, synchronous vs asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right communication approach for enterprise applications.
Facing rapid growth and complex service interactions, Huolala transitioned from a simple PHP‑based architecture to a self‑developed microservice framework, combining data and control planes, custom RPC protocols, and robust governance, while explaining why existing solutions like Dubbo and Istio were unsuitable.
This article compares 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 approach based on project requirements, language, environment, and resource constraints.
This article compares four major API architectural styles—RPC, SOAP, REST, and GraphQL—by outlining their mechanisms, advantages, disadvantages, and typical use cases, helping developers choose the most suitable approach for their specific requirements.
This article explains the fundamental differences between HTTP and RPC, covering protocol layers, communication formats, performance considerations, RPC architecture, synchronous vs asynchronous calls, popular RPC frameworks, and when to choose RPC over HTTP for backend services.
This article outlines the challenges of API security, proposes a hybrid symmetric‑asymmetric encryption scheme with signed requests, describes client and server processing flows, defines service attributes, and provides implementation references for a robust RPC encryption solution.
After Elon Musk apologized for Twitter’s sluggish performance, a heated exchange erupted on the platform as engineers disputed his claim of over 1,200 RPC calls per request, revealing internal tensions, firings, and debates over microservice usage and GraphQL knowledge within Twitter’s backend architecture.
This article explains the fundamental structure of Remote Procedure Call (RPC) architecture, detailing its core components such as providers, consumers, channels, protocols, and processors, and discusses the supporting technical system including network communication, serialization methods, transport protocols, and synchronous versus asynchronous remote invocation strategies.
This article explains the concept of Remote Procedure Call (RPC), demonstrates how to build a lightweight PHP RPC server and client with socket programming, shows the full source code, execution steps, and explains the custom protocol used for cross‑language method invocation.
The article explains RPC fundamentals and why they are vital for distributed systems, then details the core components—service provider, consumer, and registry—along with extensions such as load‑balancing, circuit breaking, and serialization, and walks through a concrete Java implementation using Zookeeper, Netty, custom protocol, JSON/Protobuf, and Spring Boot SPI plugins.
This article details how JD's retail shopping‑cart team tackled growing business complexity by fully converting the cart service to an asynchronous architecture, addressing challenges such as increasing RPC dependencies, pagination, and resource costs, and achieving a 30% reduction in core interface latency.
The article explains the different kinds of coupling in microservice communication, compares RPC and event‑driven (event notification and event sourcing) approaches, discusses API gateways, service versioning, and offers practical guidance on when to use each method while highlighting the challenges of tight coupling and internal microservice design.
This article provides a comprehensive overview of DolphinScheduler’s design strategies, distributed architecture, fault‑tolerance mechanisms, configuration files, core APIs, Quartz integration, master‑worker execution flow, RPC communication, load‑balancing algorithms, and logging services, accompanied by detailed code excerpts and diagrams.
This article provides a comprehensive overview of Dubbo, a high‑performance Java RPC framework, detailing its three core capabilities, essential components, layered architecture design, and the step‑by‑step remote invocation workflow for both service providers and consumers.
gRPC is a high‑performance, open‑source RPC framework built on HTTP/2 and Protocol Buffers, and this guide explains its core concepts, communication patterns, protobuf usage, and provides step‑by‑step Python examples for creating, compiling, and running client‑server services, plus deployment tips.
This article provides a practical step‑by‑step guide to integrating Dubbo with Nacos in a Spring Boot project, covering environment setup, Maven configuration, module creation for public API, provider and consumer services, and testing the RPC call, while highlighting version compatibility and common pitfalls.
The article explains the different types of service coupling in microservice architectures, compares RPC and event‑driven approaches—including event notification and event sourcing—provides practical examples, discusses API gateways and strategies to reduce tight coupling, and concludes with guidance on internal microservice design and when to adopt microservices.
This article explains the design and implementation steps for a multi‑active (geo‑distributed) system, covering data‑center segmentation, traffic scheduling, RPC routing, database and Redis sharding, distributed IDs, message queue handling, job coordination, and cut‑over procedures.
By applying Dubbo's GenericService $invoke method, the vivo project replaced tightly‑coupled direct API calls with a unified remote‑call layer that eliminates third‑party JAR dependencies, reduces system coupling, and leverages Dubbo’s internal proxy‑exporter mechanisms to dynamically invoke diverse external services.
This article provides an in‑depth technical overview of Apache DolphinScheduler, covering its distributed design strategies, fault‑tolerance mechanisms, remote log access, source‑code module breakdown, API interfaces, Quartz integration, master‑worker execution flows, RPC communication, load‑balancing algorithms, logging services, and community contribution guidelines.
The article outlines the growing challenges of a high‑traffic shopping cart caused by numerous RPC dependencies, proposes a full asynchronous redesign—including parallel RPC calls, batch pagination, and JSF CompletableFuture usage—addresses retry, monitoring, and timeout issues, and reports a 30% latency reduction.
This article explains the fundamentals of remote procedure call (RPC), presents a complete system architecture diagram, and provides a step‑by‑step implementation of a custom rpc‑spring‑starter using Java, Spring, Zookeeper for service registration, Netty for network communication, and dynamic proxy techniques for client‑side invocation.
This article explains the fundamentals of TCP, why raw TCP lacks message boundaries, how HTTP and RPC are built on top of TCP, and the practical reasons why both protocols coexist in modern software architectures.
This article provides an in‑depth overview of microservice concepts, RPC frameworks, serialization methods, distributed transaction models, CAP and BASE theories, monitoring solutions, high‑availability strategies, load‑balancing techniques, configuration management, service registration/discovery, and Dubbo fault‑tolerance clusters, offering practical examples and code snippets for Java‑based cloud native systems.
This article explains the different types of coupling in microservice architectures, compares RPC and event‑driven communication, discusses event notification and event sourcing, and offers practical guidance on reducing tight coupling, designing service gateways, and deciding the appropriate number of microservices.
This article explains the fundamentals of RPC and gRPC, compares popular RPC frameworks, details gRPC's features and Protocol Buffers advantages, and provides a complete Java hands‑on example with code, project structure, and performance benchmarks.
This article introduces Apache Dubbo, compares it with Eureka, and provides a complete step‑by‑step example—including service interface, implementation, provider and consumer configurations, XML files, and code snippets—plus instructions for installing and using Dubbo‑Admin for monitoring micro‑service deployments.
This article explains the fundamentals of Remote Procedure Call (RPC), compares popular RPC frameworks such as gRPC, Thrift, Dubbo and Spring Cloud, details gRPC’s architecture, Protocol Buffers serialization, HTTP/2 advantages, and provides a step‑by‑step Java demo with full source code and performance benchmarks.
This article explains the fundamentals of TCP sockets, why raw TCP lacks message boundaries, how custom protocols add headers to solve the sticky‑packet problem, and compares HTTP and RPC as application‑layer protocols, highlighting their histories, use‑cases, and performance trade‑offs.
This article explains the evolution from raw TCP sockets to HTTP and RPC, highlighting why RPC remains useful despite HTTP's prevalence, covering TCP basics, message framing, service discovery, connection handling, serialization, and performance considerations.
The article explains why Dubbo's RPC design and single‑connection model make it inefficient for transmitting files, compares the memory‑heavy approach of sending byte arrays with the streaming nature of HTTP, and shows how Feign can upload files but still suffers from in‑memory buffering.
This article explains the fundamentals of service governance in distributed systems, covering RPC communication, common anomalies, replica types, design principles, performance metrics, and the architecture and workflow of RPC frameworks, while also detailing key practices such as registration, discovery, load balancing, traffic shaping, version compatibility, circuit breaking, degradation, and rate limiting.
This article presents a comprehensive overview of a hand‑crafted RPC framework built with Spring Boot, Netty, and Zookeeper, covering its core concepts, architecture, custom message protocol, load‑balancing strategies, serialization choices, starter design, deployment steps, and testing procedures.
This article explores xxl-job’s underlying communication architecture, detailing how it employs Netty HTTP, dynamic proxy patterns, full asynchronous processing, and thread‑blocking mechanisms to achieve efficient remote procedure calls, accompanied by code examples and a visual activity diagram.
This article compares four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, advantages, disadvantages, and suitable use cases to help developers choose the most appropriate approach for their projects in today’s fast‑changing environment.
This article explains the core concepts and implementation steps of a lightweight Java RPC framework, covering RPC definition, service registration and discovery with Zookeeper, client-side dynamic proxies, network transmission using Netty, serialization, compression, and two server‑side proxy generation strategies (reflection and Javassist).
This article describes a complete solution for per‑process monitoring of CPU, memory, disk I/O and network usage on Linux servers, covering the shortcomings of existing tools, data collection methods, aggregation logic, storage in MySQL, visualization with Grafana, deployment steps, and operational best practices.
This article explains the OSI seven‑layer model, then compares RPC and HTTP services by detailing RPC’s architecture, synchronous versus asynchronous invocation, and the most popular open‑source RPC frameworks—gRPC, Thrift, and Dubbo—highlighting why RPC often offers higher efficiency for large‑scale enterprise applications.
This article explains the problems caused by naive timer implementations in high‑concurrency RPC frameworks and introduces the timing‑wheel mechanism, illustrating its principles, multi‑level design, and practical applications such as request timeout, startup timeout, and heartbeat handling.
xxl-job uses Netty HTTP for communication, employing dynamic proxy patterns, full asynchronous processing, and thread‑blocking mechanisms to efficiently dispatch tasks from the scheduler to executors, with detailed code examples illustrating request IDs, future responses, and synchronized result retrieval.
This tutorial demonstrates how to capture and reproduce the dynamic newSign parameter of the X‑Wu Android app by reverse‑engineering the request‑signing method with Frida, exposing it via an RPC server, and then using the generated signature to call the official search API.
This article explains the fundamentals of RPC, describes the components involved in a basic remote call, and provides a complete Java implementation using Spring, custom XML configuration, Netty for network communication, and Zookeeper for service registration and discovery, complete with server and client code examples.
This article explains how to employ Frida RPC to intercept and forward encrypted mobile app requests, demonstrates the required environment, provides hook scripts for encryption and decryption, and shows how to wrap them in a FastAPI service for automated crawling.
This article explains why forward and backward compatibility are crucial for evolving systems, covering database encoding, schema evolution, REST and RPC communication, message brokers, and actor frameworks, and provides practical guidance for designing compatible data flows across services.
This article chronicles ByteDance's transition from Python to Go, the shortcomings of the first‑generation Kite RPC framework, and the design, features, performance advantages, open‑source journey, and real‑world deployment lessons of the next‑generation Kitex framework for scalable microservices.
This article outlines a comprehensive approach to securing backend APIs through authentication, anti‑hijacking measures, and a custom RPC encryption scheme that combines asymmetric and symmetric keys, detailing design principles, data flow, and implementation resources.
An online service threw an IllegalArgumentException because a downstream system added a new enum constant without notifying dependent services, leading to deserialization failures in RPC calls; the article explains the root cause, JSON serialization behavior, and recommends using strings instead of enums for API parameters and return values.
This article explains the OSI seven‑layer model, compares RPC and HTTP services, details RPC architecture, synchronous vs asynchronous calls, and reviews popular RPC frameworks, helping developers choose the right approach for enterprise applications.
This article explains the fundamentals of RPC, walks through a complete Java implementation using Spring, Netty, and Zookeeper, and provides step‑by‑step code for both the service provider and consumer, including registration, dynamic proxy generation, network communication, and testing.
This article explains the fundamental distinctions between RPC and HTTP services, covering OSI network layers, the core components of RPC architecture, synchronous versus asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and a comparison with RESTful HTTP services.
This article walks through Dubbo’s RPC communication using a packet‑as‑narrator metaphor, detailing the thread models of Netty 3 and Netty 4, OS socket handling, and practical troubleshooting steps for latency and timeout issues in a clear, engaging style.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous and asynchronous calls, and introduces popular RPC frameworks such as gRPC, Thrift, and Dubbo, while also showing a simple HTTP request example.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI model, RPC architecture components, synchronous vs asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right approach for backend development.
This article explains the communication architecture of the XXL‑Job scheduler, detailing its Netty‑based transport layer, the overall task dispatch flow, and the clever design choices such as dynamic proxies, full asynchronous processing, and response wrapping that improve throughput and simplify remote calls.
This article explains the fundamental differences between RPC (Remote Procedure Call) and HTTP services, covering OSI layers, RPC architecture components, synchronous vs asynchronous calls, and popular frameworks such as gRPC, Thrift, and Dubbo, to help developers choose the right approach.
This article presents a comprehensive overview of designing and implementing a custom RPC framework using Spring Boot and Netty, covering concepts, architecture, service registration with Zookeeper, load balancing, custom message protocol, serialization, handling TCP fragmentation, and various client invocation modes.
This article explains how to build a versatile browser message‑communication library that works across iframes, Web Workers, ServiceWorkers, BroadcastChannel and other MessagePort‑like objects, using a unified interface design, TypeScript typings, event‑driven architecture and JSON‑RPC for reliable remote procedure calls.
This article analyzes the four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, strengths, weaknesses, and typical use cases, and provides guidance on selecting the most suitable style based on language, environment, and resource constraints.
