The article describes how a commercial testing platform faced three limitations with its RPC client, analyzes Java class‑loading, dynamic proxy, and ThreadLocal concepts, and presents two implementation approaches—one using dynamic proxies and another leveraging ThreadLocal—to enable dynamic loading of multiple rpc.config files without restarting the service.
This article explains the fundamentals of Remote Procedure Call (RPC), covering its definition, architectural components, communication protocols, serialization process, complete call workflow, and the main technologies and frameworks used in modern backend systems.
This guide walks through the step‑by‑step process of linking Remix to a local private Ethereum node, explains the typical "Not possible to connect to the Web3 provider" error, and provides two practical solutions—including adjusting the URL scheme and adding the --rpccorsdomain flag to the Geth startup command.
A recap of Chengdu’s Node.js underground rail salon reveals how industry experts tackled enterprise‑grade challenges such as microservice architecture, security of third‑party dependencies, TypeScript adoption, RPC communication, and stream best practices, followed by an engaging round‑table discussion.
This article explains the core principles of RPC message protocol design, covering how to determine message boundaries, choose between delimiter and length‑prefix methods, handle explicit and implicit message structures, apply compression, and implement varint and zigzag encoding for optimal traffic efficiency.
This article examines common pain points of traditional RPC interfaces—excessive query methods, poor extensibility, difficult upgrades, testing challenges, and flawed exception handling—and presents practical solutions such as single‑parameter designs, Specification pattern, proper exception contracts, version‑by‑module evolution, and automated testing integration.
This article explains how Remote Procedure Call (RPC) underpins micro‑service architectures, connects load balancers like Nginx, powers big‑data frameworks such as Hadoop, fuels AI platforms like TensorFlow, and why mastering RPC is essential for senior backend engineers.
The article shares Zhihu's multi‑year journey toward service‑oriented architecture, discussing the motivations, practical challenges, design trade‑offs, and lessons learned from microservice, RPC, and SSO‑based vertical splitting, as well as guidelines for defining service boundaries and layering.
This article provides a comprehensive deep‑dive into RPC functional goals, call classifications, component breakdown, Java‑based implementation details, protocol encoding, transport considerations, execution control, and exception handling, offering practical guidance for building a reliable distributed RPC framework.
This article provides a step‑by‑step walkthrough of how a Dubbo consumer initiates a remote call, how the request is processed through clustering, load balancing, and invocation layers, and how the provider receives, executes, and returns the result, including the underlying code structures and network interactions.
This article explains the fundamentals of remote method invocation, compares traditional RMI with modern RPC frameworks, introduces Dubbo's architecture and roles, and provides a step‑by‑step guide to quickly develop, build, and run a complete Dubbo application using API‑centric configuration and multicast registration.
This article explains the Dubbo consumer initialization workflow, detailing how ReferenceConfig creates proxies, how service URLs are registered with Zookeeper, the steps to obtain Invoker objects via Protocol, and how ProxyFactory generates client-side service proxies, including code examples and asynchronous handling.
This article explains Dubbo’s core RPC principles, architecture layers, design philosophy, open‑source growth, adoption by major enterprises, and upcoming plans for modularization, metadata, async support, and its progression through the Apache Incubator toward becoming a top‑level project.
This article introduces Dubbo’s background, explains the evolution of e‑commerce architectures to RPC‑based distributed systems, details Dubbo’s components, advantages, and drawbacks, and provides a complete Maven‑based demo—including Zookeeper installation, Spring configuration, and Java code—for building and consuming a Dubbo service.
This article analyzes common problems with testing environments in fast‑iterating internet companies, compares several deployment strategies, and presents a comprehensive environment management platform that automates resource allocation, service configuration, and host mapping to improve efficiency, stability, and resource utilization.
The article describes Overwatch, a distributed monitoring system developed by Dada‑JD Daojia that collects, aggregates, and visualizes RPC traffic in real time using consumer‑side agents, Kafka, Storm, and a Node.js CQRS architecture, enabling engineers to quickly locate and resolve service failures.
This article explains microservice fundamentals, compares RPC/gRPC/HTTP/REST communication, evaluates Dubbo and Spring Cloud frameworks—including their architectures, features, advantages, and drawbacks—and discusses related technologies such as ZooKeeper, Eureka, and Service Mesh to help developers choose the right solution.
The article examines the reliability challenges of microservice architectures that rely heavily on synchronous RPC calls, and proposes a comprehensive solution that converts failing RPCs to asynchronous message‑queue workflows, introduces a write‑ahead‑queue for transactional consistency between databases and queues, and outlines offset management to ensure end‑to‑end fault tolerance.
The article examines the advantages and drawbacks of microservices versus monolithic architectures, outlines key factors that influence the decision to split, and walks through a real‑world shared‑points project, detailing a four‑step process for decomposing a monolith into independent services.
This article examines the evolution of service architectures, compares major RPC and micro‑service frameworks such as Dubbo, Dubbox, Spring Cloud, and others, and provides practical guidance on selecting the most suitable technology for high‑availability, high‑concurrency backend systems.
Facing over 60 million daily users and 100 K QPS, iQIYI’s Bubble platform migrated from a monolithic codebase to a business‑driven microservice architecture—splitting services by entity and function, adopting the internal RPCHUB RPC framework, establishing ownership, fault‑tolerance, monitoring and CI/CD pipelines, and addressing scaling challenges to sustain rapid growth.
This article explains Pandora.js's Service mechanism—a high‑level process orchestration feature for Node.js applications—covering its problem scope, core principles, capabilities, implementation of an RPC provider with etcd registration, and a simple consumer example, while demonstrating start/stop lifecycle management.
This article introduces Dubbo, Alibaba's high‑performance RPC and service‑governance framework, explains its core components, features, architecture, and provides step‑by‑step instructions with Maven dependencies, Spring Boot configuration, XML setup, and sample code for building provider and consumer services.
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.