This article outlines the historical evolution of application architecture—from early vertical monolithic designs through RPC and SOA approaches to modern microservice architectures—highlighting their characteristics, deployment models, and the motivations behind each transition.
The Dubbo project has entered a maintenance phase with a dedicated virtual team, releasing three successive versions (2.5.5, 2.5.6, 2.5.7) that address key community issues, add new features, and outline a roadmap for future enhancements and modularization.
This article traces the evolution of Remote Procedure Call (RPC) from its early definitions in the 1970s through various middleware implementations like CORBA, Java RMI, Thrift, and gRPC, highlighting key concepts, criticisms, and modern developments in distributed systems.
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.
Overwatch is an open‑source distributed monitoring platform built by Dada‑Jingdong Home that collects, aggregates, and visualizes RPC traffic across thousands of micro‑services in real time, enabling engineers to quickly pinpoint the root cause of system failures using directed‑graph visualizations and CQRS‑based data queries.
This article walks through Dubbo’s cluster fault‑tolerance mechanism, detailing the roles of Directory, Router, and LoadBalance, illustrating each step with architecture diagrams and source‑code snippets, and clarifying how different fault‑tolerance strategies like failover, failsafe, and load‑balancing are implemented.
The article explains how Ethereum and Ethereum Classic handle transaction nonces via RPC interfaces, why incorrect nonces cause pending or queued transactions, and provides practical ways to obtain the correct nonce using eth_getTransactionCount to ensure reliable transaction submission.
During Geth fast synchronization, the RPC call eth.blockNumber may keep returning 0 even after some blocks are downloaded, because the node lacks complete block data until the fast‑sync process finishes, causing the latest block number to appear unavailable.
This article interviews Baidu’s chief architect Ge Jun about the origins, design principles, performance advantages, and open‑source release of the high‑performance C++/Java RPC framework brpc, highlighting its extensive internal use, architectural features, and future roadmap.
This article provides a comprehensive overview of Apache Spark's architecture, covering its RDD abstraction, computation model, various cluster deployment modes, RPC communication layer, startup procedures, core components, interaction flows, and block management for broadcast variables.
This tutorial explains how to set up protobuf and gRPC, generate code from .proto files, and create a simple Python client (wrapped with Flask) to query relay information for live cloud streaming services, providing a lightweight alternative to manual log inspection.
This article breaks down Dubbo’s core architecture, explaining the roles of Provider, Consumer, Registry, Monitor and Container, the step‑by‑step service registration and discovery process, the conversion of services to Invokers and Exporters, and how load balancing and monitoring work in a typical RPC workflow.
This article explores the design of distributed service frameworks, detailing Dubbo’s architecture—including RPC foundation, service publishing, call chains, registry, governance, protocol support, module layers, and the step-by-step processes for exposing and consuming services—providing a comprehensive guide for backend developers.
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 breaks down Dubbo's overall architecture, integration with Spring, URL‑bus design, startup sequences for registry, provider and consumer, the actual invocation chains, and the key design patterns such as Factory, Decorator, Observer, and Dynamic Proxy that power the framework.
This article explains RPC fundamentals, its advantages, serialization processes, and provides a step‑by‑step TCP‑based Java RPC implementation with code examples and performance comparisons, helping backend developers understand and build simple remote procedure call systems.
This guide explains how to open Windows Event Viewer on Windows Server 2012 R2, filter security logs to examine recent login events and RPC service failures, and troubleshoot authentication issues by reviewing system processes and configuring services.
This article breaks down Dubbo’s distributed service framework, detailing its RPC foundation, service publishing and consumption, call chain, registry and governance, system roles, protocol choices, layer-by-layer architecture, and the step-by-step processes of exposing and consuming services.
The conference featured a series of high‑availability architecture talks covering performance‑driven design, RPC framework resilience, big‑data platform evolution, MySQL cluster consistency, and cloud infrastructure best practices, presented by experts from 58.com, Alibaba, Tencent, Baidu, and others.
This article benchmarks four widely used RPC frameworks—Dubbo, Motan, rpcx, gRPC, and Thrift—by measuring throughput, average latency, median latency, and maximum latency under varying client concurrency levels, revealing rpcx’s superior performance and the impact of serialization choices.
Dubbo, an extensible Java RPC framework, evolves from simple single‑app setups to distributed service and dynamic resource governance architectures, offering RESTful calls, high‑performance serialization, flexible protocols, various clustering strategies, load‑balancing options, and a modular SPI‑based core, all detailed with diagrams and code snippets.
Google's gRPC 1.0 release brings high‑performance, multi‑language RPC support built on Protocol Buffers and HTTP/2, enabling loosely coupled, scalable backend systems for data centers, mobile apps, IoT, and microservices with improved efficiency, security, and ecosystem adoption.
PhxRPC is a compact, 450KB RPC framework from the WeChat backend team that uses Protobuf for IDL, offers semi‑sync/async processing with Epoll‑based IO threads, provides built‑in overload protection, and includes performance benchmarks, usage instructions, and code generation details.
The article examines common misconceptions about game server performance, outlines essential message pipelines, introduces Gate as a reverse‑proxy for low‑latency scene synchronization, discusses integrating a message‑queue (MQ) for decoupled services, and presents a service‑oriented RPC framework with patterns to build maintainable, scalable multiplayer back‑ends.
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.
The article explains why and when to use message queues, then walks through designing one from scratch, covering decoupling, eventual consistency, broadcast, flow control, RPC protocols, high availability, storage choices, consumer relationships, reliable delivery, transactions, performance optimizations, and push versus pull models.
This tutorial walks you through installing Thrift, creating the interface file, and writing both server and client programs in Python to demonstrate a basic cross‑language RPC service.
The article describes how Weibo evolved from a LAMP‑based first generation to a third‑generation, orthogonal‑decomposed backend architecture featuring three horizontal layers (interface, service, resource) and vertical technical components such as Web V4, MCQ queue, Motan RPC, object storage, SSD cache, and the WatchMan distributed tracing system for monitoring and service governance.
The article analyzes the limitations of Dubbo's default synchronous RPC model, explains existing consumer and provider asynchronous mechanisms, and proposes a cleaner annotation‑processor based API that enables transparent async calls without extra configuration, improving thread utilization and service reliability.
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 the layered architecture of Alibaba's open‑source Dubbo framework, detailing its service, config, proxy, registry, cluster, monitor, protocol, exchange, transport, and serialization layers, as well as service definition, registration, monitoring, communication protocols, and package organization for building distributed backend services.
Meituan’s internal RPC services, largely built on Thrift, required a streamlined pressure‑testing solution, leading to the development of a custom tool that automates traffic capture, provides an intuitive UI, aggregates metrics via InfluxDB, and supports both Thrift and HTTP workloads, addressing the shortcomings of existing open‑source options.
This article introduces Sina Weibo's Motan RPC framework, compares RPC with other remote‑call technologies, explains Motan's modular architecture and high‑availability features, and details recent hybrid‑cloud adaptations such as traffic compression, dynamic group‑based routing, and extensible command‑driven traffic control.
The article outlines WeChat’s backend design that achieves seamless, low‑latency messaging through a minimalist sync protocol, efficient notification mechanisms, a three‑tier RPC framework, user‑level thread concurrency, and globally distributed IDC architecture ensuring high availability and eventual consistency.
The article outlines WeChat’s backend architecture, detailing extreme business requirements such as low latency and power efficiency, challenges of synchronizing diverse data across terminals, and solutions including a minimal sync protocol, high‑efficiency notification mechanisms, a three‑tier backend, unified RPC framework, coroutine‑based high‑concurrency RPC, and multi‑IDC distribution with strong consistency and disaster‑recovery strategies.
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.
gRPC, an open‑source RPC framework built by Google on HTTP/2 and Protocol Buffers, offers strong IDL capabilities, multi‑language support, and efficient streaming that reduce bandwidth, CPU usage, and battery drain, making it ideal for low‑latency, scalable backend and mobile client architectures.
In the cloud and mobile era, while many scalability issues can be addressed by cloud platforms, services still face challenges such as remote RPC calls, distributed tracing, configuration management including service discovery and load balancing, and scheduling with lifecycle management, prompting architects to design transparent, pluggable solutions.
