This report recaps a technical closed‑door session where experts from Weibo and Ziroom shared real‑world API gateway implementations, discussed centralized versus decentralized designs, explored the evolution of Ziroom's gateway, introduced the Gamma‑RPC framework, and debated future trends like service mesh.
This article explains the concepts and usage of three Java RPC frameworks—RMI, Hessian, and Dubbo—detailing their serialization methods, transport protocols, and service registration mechanisms, and provides complete code samples for interface definition, service implementation, client, and server setup.
This article explains why the Kitty Cloud project integrates both Feign and Dubbo, discusses the need for dual‑protocol support during migration from Dubbo to Spring Cloud, presents three migration strategies, and shows how to implement and configure both HTTP and RPC calls within the same service.
This article explains the fundamentals of RPC protocols, compares common designs such as HTTP/1.1, RESP, HTTP/2, and gRPC, and outlines the motivations and key features of Dubbo 3.0’s next‑generation protocol for better performance, extensibility, and cross‑language support.
This article introduces a lightweight RPC framework that demonstrates the essential publishing and invocation processes, explains the underlying SPI mechanism, and details service registration, load balancing, fault‑tolerance strategies, and module structure, providing code references and visual diagrams for practical understanding.
The article introduces Tars, a high‑performance RPC framework and integrated service governance platform that leverages micro‑service architecture, detailing its design philosophy, layered architecture, key features such as the Tars protocol, load balancing, fault tolerance, overload protection, configuration management, and open‑source availability.
The article introduces Tars, an open‑source high‑performance RPC framework and integrated service governance platform derived from Tencent's internal microservice architecture, detailing its design philosophy, layered architecture, core features such as the Tars protocol, load balancing, fault and overload protection, and centralized configuration management.
This article introduces Apache Thrift, explains its cross‑language IDL, data types, transport and protocol options, and walks through setting up the Thrift compiler, adding a Gradle dependency, writing a .thrift definition, generating Java code, and building a simple Java RPC server and client.
This article reviews Dubbo 3.0’s evolution from its early Alibaba SOA roots to a cloud‑native microservice framework, detailing its open‑source growth, next‑generation RPC protocol, application‑level registration discovery, Kubernetes integration, flexible enhancements, and the roadmap for upcoming releases.
This article explains how to overcome the limitations of PC‑based simulators for in‑vehicle navigation development by using a Thrift‑based proxy (Sandwich) to forward car‑side signals to a PC, enable bidirectional debugging, and project map rendering back to the vehicle display.
This article explains the principles behind NFS file‑lock state view consistency, covering NFSv4's stateful design, the SeqId mechanism, SunRPC handling of duplicate requests, and how signal interruptions are managed to keep client and server lock views synchronized.
This article explains the root causes of sticky and split packet problems in TCP-based RPC frameworks, outlines four common mitigation strategies, and provides detailed Netty implementations—including FixedLengthFrameDecoder, LineBasedFrameDecoder, LengthFieldBasedFrameDecoder, and custom handlers—complete with runnable Java code examples.
The article introduces the SOFARPC Java RPC framework, outlines its new 5.6.x release features, enhancements, compatibility notes, bug fixes, and details its core capabilities such as extensible filters, routing, load balancing, protocol support, and microservice governance.
This article shares practical dubbo-go experience at Tuya Smart, covering the gateway architecture, generic invocation mechanics, step‑by‑step integration, configuration pitfalls, performance tuning, and extension points to help developers adopt the high‑performance RPC framework efficiently.
Apache Avro is a high‑performance binary data serialization system originating from Hadoop that uses JSON‑defined schemas to enable compact storage, efficient network transfer, container file formats for MapReduce, and RPC communication without requiring code generation or explicit field numbers.
This tutorial walks through building a Spring Boot application that uses Alibaba's Dubbo framework, covering the RPC workflow, project structure, Maven dependencies, Spring Boot and XML configurations, service interface definition, provider and consumer implementations, and a RESTful endpoint for testing.
This article explains how a Java‑based instant‑messaging system was restructured by replacing raw HTTP calls with API packages, introducing dynamic proxies for transparent RPC, and simplifying the code to resemble local method invocations while improving maintainability and scalability.
This article presents the design, reconstruction, and deployment of an asynchronous, event‑driven PHP microservice framework built on Swoole, detailing its background, technical objectives, serialization, RPC architecture, coroutine handling, service governance, and performance improvements for high‑concurrency rental‑business applications.
This article analyzes a real e‑commerce incident to explain how RPC timeouts work in microservice architectures, why proper timeout and retry configurations are essential, and provides step‑by‑step guidelines for setting sensible timeout values while avoiding common pitfalls such as duplicate requests and retry storms.
Aloha is a Scala‑implemented distributed task scheduling and management framework built on Spark that provides plug‑in extensions, high‑availability Master‑Worker architecture, custom event listeners, and a lightweight Scala‑based RPC layer for managing long‑running jobs such as Spark, Flink, and ETL tasks.
This article describes the architecture, features, and implementation details of a self‑developed SCF RPC testing platform that provides interface testing, automatic documentation, mock services, and automated test case management to streamline RPC service development and testing.
This article explains how to read and compare the RPC implementations of Spark and Flink, covering Actor Model concepts, Akka integration, message handling, threading models, and practical code‑reading techniques while providing detailed code excerpts and architectural analysis.
The article explains how microservices communicate via RPC or event‑driven approaches, analyzes different coupling types, compares event notification and event sourcing, discusses API‑gateway and service composition, and offers practical guidance on limiting microservice count and using internal microservice design.
This article provides a comprehensive beginner-friendly guide to gRPC, covering its definition, the protobuf syntax for defining messages and services, field constraints, supported data types, usage of the protoc tool, and complete Go examples for both server and client implementations.
The article introduces the MockRpc platform, which uses Spring‑based extensions and a mock server to fully decouple front‑end services from middle‑end services in a micro‑service architecture, enabling zero‑intrusion testing, configurable mock data, and improved development efficiency for JD Retail.
This article explains the technical differences between RPC and HTTP services, covering the OSI model, RPC architecture, synchronous versus asynchronous calls, and compares popular frameworks like gRPC, Thrift, and Dubbo to help developers choose the right approach for large‑scale systems.
iQIYI has adopted Apache Dubbo since 2019, building a custom SPI‑based plugin system, integrating registration, configuration and metadata centers, enhancing availability with instance‑level health checks and Sentinel circuit‑breaking, implementing region‑aware routing and AK/SK authentication, and contributing extensive optimizations and future‑oriented plans to the open‑source Dubbo ecosystem.
This article explains what Dubbo is, its core capabilities such as cluster fault tolerance, remote communication, and service discovery, details default and alternative communication and serialization frameworks, outlines key configuration elements, and provides solutions to frequent deployment and runtime issues.
This article introduces Apache Thrift, explaining its open‑source RPC framework, IDL‑based code generation, protocol and transport layers, and its advantages for high‑performance data exchange in mobile advertising engines, while noting practical considerations such as static schema updates and usage of TFileTransport.
The article explains how traditional monolithic, RPC, and sharding architectures eventually hit MySQL connection limits, why simple database partitioning cannot guarantee unlimited scaling, and proposes a unitization approach that restricts each service to a single database shard to overcome connection‑count bottlenecks.
This article provides a comprehensive overview of Dubbo, the Java-based distributed RPC framework, covering its core components, supported protocols, serialization options, configuration elements, load‑balancing strategies, security mechanisms, and common troubleshooting tips for developers building backend services.
This article discusses the motivations behind moving beyond HTTP/HTTPS API testing to RPC service testing, outlines the difficulties of manual test code development, and presents an automated workflow—including Beetle integration, JSON-to-Java conversion, and template‑based test generation—to improve efficiency and reduce manual effort.
This article explains what Dubbo is, its core features, built‑in containers, key configurations, clustering and load‑balancing strategies, communication frameworks, and compares its advantages and drawbacks with Spring Cloud to help candidates prepare for Java backend interview questions.
This article outlines multiple Ethereum RPC attack techniques—including unlock‑account hijacking, miner‑address manipulation, brute‑force, offline, and zero‑fee attacks—provides detailed attack flow diagrams, code‑path references, recent honeypot statistics, and practical defense measures to secure RPC endpoints.
This guide walks through designing a Java RPC framework from the user's viewpoint, covering interface definition, client stub generation with dynamic proxies, flexible protocol and service discovery layers, server request handling, and key implementation steps, illustrated with diagrams and code snippets.
This article traces the history of dubbo-go from its 2016 inception, describes its reconstruction by Ctrip in 2018, outlines its modular Apache‑licensed components, showcases cross‑language usage with Java Dubbo, and details its current features, roadmap, and cloud‑native ambitions.
This article guides readers through preparing gRPC RPC scripts, creating Java sampler code for JMeter, packaging the scripts, and executing load tests to evaluate RPC performance, providing step‑by‑step instructions and code examples for Java‑based testing.
This guide shows how to reduce excessive NameNode RPC calls caused by frequent HDFS directory listings and demonstrates a complete ELK pipeline—Filebeat, Kafka/Logstash, Elasticsearch, and Kibana—plus Grafana dashboards for real‑time monitoring of Hadoop RPC operations.
qrpc is a lightweight, high‑performance RPC framework that adopts gRPC's streaming and bidirectional concepts without HTTP/2, offering a smaller binary, lower memory usage, up to three‑fold throughput gains, and flexible modes such as blocking, non‑blocking, streaming, push, and bidirectional calls, all demonstrated with Go code examples and real‑world use cases.
This article describes how Ctrip introduced a customized Dubbo framework called CDubbo, covering the motivations for adopting Dubbo, the initial implementation of service governance and monitoring, and subsequent extensions such as callback enhancement, serialization support, circuit‑breaking, testing tools, and a bastion testing gateway.
This article examines why robust API specifications are crucial for cloud services, outlines seven major challenges—from choosing design patterns and resource modeling to error handling, versioning, and ecosystem integration—and offers practical guidance for building consistent, reliable OpenAPI interfaces at scale.
This article benchmarks the throughput, average latency, median latency, and maximum latency of five RPC frameworks—Dubbo, Motan, rpcx, gRPC, and Thrift—using a unified protobuf‑based service across varying client concurrency levels, and discusses the resulting performance trends and conclusions.
The article introduces Apache Dubbo, a high‑performance Java RPC framework, outlines its history, current features, multi‑language ecosystem, recent releases, and future plans such as cloud‑native integration, service‑mesh support, reactive programming, and the roadmap toward Dubbo 3.0.
This article explains the fundamentals of RPC, the evolution and necessity of Dubbo in large‑scale Java applications, and outlines the core components, registration mechanisms, communication protocols, and step‑by‑step remote call process required to design a robust Dubbo‑based RPC framework.
This article introduces RPC and gRPC concepts, explains how to define services with Protocol Buffers, and provides step‑by‑step Node.js and Go examples for building gRPC servers and clients, while covering language support, limitations, and reference resources.
This article walks through building a simple RPC framework in Go using about 300 lines of code, covering RPC fundamentals, TLV network data format, serialization, transport layer, server and client implementations, and a complete example to help readers understand RPC concepts.
This article walks through creating a lightweight RPC framework in Go, covering the definition of RPC, TLV data encoding, gob serialization, transport handling, server and client implementation, and a complete test example to illustrate core remote‑call concepts.
OCTO is Meituan's distributed microservice communication and governance platform that unifies service registration, discovery, load balancing, fault tolerance, gray releases, and call data across thousands of services, handling billions of calls with components such as OCTO‑RPC, OCTO‑NS, OCTO‑Portal, SGAgent, Oceanus, Watt, and MCC, achieving 99.999% success and moving toward API‑based naming and service‑mesh evolution.
Since 2017, Youzan transformed its monolithic Nginx‑PHP stack into a language‑agnostic service mesh by introducing Dubbo, the ZanPHP RPC framework, a custom NOVA protocol, and the Go‑based Tether sidecar that offloads discovery, load‑balancing and monitoring, later adding a Service Pretender for cross‑region traffic, and now migrates discovery to Istio Pilot on Kubernetes for seamless, containerized microservice orchestration.
This article explains how Apache Flink builds its RPC communication layer on top of Akka by detailing the Actor model, actor system creation, message passing patterns, key RPC interfaces such as RpcGateway and RpcEndpoint, and the internal workflow of request handling and execution.
The article examines Hadoop’s RPC framework—detailing its client‑server workflow, core classes (RPC, Client, Server), dynamic proxy handling, NIO‑based server threading, configurable concurrency controls such as FairCallQueue, and a practical HDFS mkdir command example, illustrating high‑performance distributed communication.
This article analyzes Youzan Cloud's architecture for supporting multi‑language customizations, detailing the distinction between small and large SaaS customers, the role of tool, self‑use, and industry apps, and the service‑mesh‑based RPC framework that abstracts protocols, monitoring, and logging across Java, PHP, Python, and Node.js.
This interview with Ctrip's He Xinming details the motivation, architecture, features, performance benchmarks, and future roadmap of dubbo-go, the Go language implementation of Apache Dubbo, highlighting its role in bridging Java and Go microservice ecosystems and its cloud‑native aspirations.
The article explains Dubbo's exception‑filter mechanism, demonstrates with a HelloException example why a custom RuntimeException is wrapped into a generic RuntimeException on the consumer side, analyzes the source code logic that decides when to re‑throw or wrap exceptions, and offers practical ways to avoid this pitfall in real projects.
Dubbo 3.0 preview introduces a fully asynchronous Filter chain, native Reactive Streams support via RSocket, early Service‑Mesh integration, and tighter fusion with Alibaba’s internal systems, offering developers a modern, high‑throughput Java RPC framework for cloud‑native applications.
Aloha is a Scala‑implemented distributed scheduling framework built on Spark that provides extensible plugins, high‑availability master/worker architecture, REST submission, custom application interfaces, event listeners, and a Scala‑based RPC system for managing long‑running tasks such as Spark, Flink, and ETL jobs.
This article presents an automated RPC diff testing framework that extracts real‑world request parameters, generates Java test code, executes calls against both production and sandbox services, and compares JSON results to quickly verify interface correctness without extensive manual effort.
This article explains why RPC is essential for modern distributed systems, defines its core concepts, outlines the typical architecture and call flow, compares it with REST/SOAP/SOA, and reviews key technologies and popular Java RPC frameworks.
This article introduces the EasyRPC framework, explaining its RPC fundamentals, the use of Netty for communication, Spring for configuration, dynamic proxy for transparent calls, Protostuff for message serialization, and details both server-side service publishing and client-side invocation with reconnection handling.
This article explains what Dubbo is, its key features such as transparent RPC, cluster fault tolerance, communication protocols, registration centers, serialization options, configuration details, load‑balancing strategies, security mechanisms, common issues and solutions, and compares it with Dubbox and other distributed frameworks.
This article presents a comprehensive guide to improving SOFARPC performance, covering custom BOLT protocol design, Netty transport optimizations, serialization choices, batch decoding, and client‑proxy benchmarking, with practical code demos and configuration recommendations for Java RPC services.
This article introduces the Remote Procedure Call (RPC) protocol, outlines common Java RPC frameworks such as Thrift, Dubbo, and Spring Cloud, compares RPC with messaging queues, and provides a hands‑on tutorial for implementing a basic RPC framework to help readers understand distributed service calls.
This article explores advanced Dubbo capabilities—including direct provider connections, multi‑version support for gray releases, echo testing, implicit parameters via RpcContext, local mock fallback, generic invocation, access logging, and delayed service exposure—providing code snippets and practical usage guidelines for each feature.
Apache Dubbo’s latest 2.7.0 release introduces full async programming, separates registry, config, and metadata centers, adds native support for ZooKeeper, Nacos and Apollo, expands multi‑language clients, and outlines the roadmap toward Dubbo 3.0 and graduation from the Apache incubator, reflecting a thriving community revival.
This article explains the fundamentals of Remote Procedure Call (RPC), the motivations behind RPC frameworks like Dubbo, their core components and communication processes, and outlines the technical considerations required to design a high‑performance, reliable RPC system for distributed Java applications.
Xianyu refactored its item publishing and editing features using the self‑developed SWAK framework, first extracting business logic into isolated packages to separate platform code, then service‑izing the rental business via remote RPC, dramatically improving code clarity, reuse, team coordination, and system scalability.
This article explains the concept of RPC in Java, compares three popular frameworks—RMI, Hessian, and Dubbo—describes their architectures, and provides complete code samples for interfaces, service implementations, clients, and servers to help developers build scalable distributed applications.
This tutorial explains key concepts such as distributed systems, RPC, and Dubbo, then guides you through installing Zookeeper, creating Maven modules, configuring SpringBoot and Dubbo, implementing service interfaces, providers, and consumers, and testing a simple HelloWorld distributed service.
This article explains the concept of Remote Procedure Call (RPC), why distributed systems need remote invocation, the roles of provider, consumer and registry, essential technologies such as dynamic proxies, serialization and NIO, and introduces popular open‑source Java RPC frameworks.
This article provides a comprehensive guide to RabbitMQ, covering the fundamentals of message middleware, the P2P and Pub/Sub models, a comparison with Kafka and RocketMQ, detailed explanations of exchanges, queues, channels, and advanced features such as mandatory routing, backup exchanges, TTL, dead‑letter queues, delayed queues, priority queues, and RPC implementations for reliable distributed systems.
This article provides a detailed, macro‑level walkthrough of Apache Dubbo's startup sequence, covering Spring schema extensions, event‑driven service export, URL construction, local and remote exposure decisions, and the Netty server initialization that together enable transparent Java RPC services.
This article introduces SOFARPC, Ant Financial's financial‑grade Java RPC framework, covering its overall architecture, extension mechanism, link tracing, connection management, synchronous and asynchronous invocation models, thread model, fault‑tolerance, generic invocation, data passthrough, graceful shutdown, routing implementation, and annotation support for building robust microservice systems.
This article explains why Tubi adopted Node.js’s async_hooks API, describes the challenges of context propagation in asynchronous calls, demonstrates a monkey‑patching solution for HTTP servers, and shares production‑grade practices for tracing, retries, and memory management in their micro‑framework.
This article introduces the SCF RPC framework developed by 58, covering its overall architecture, synchronous and callback call modes, timeout handling, custom serialization techniques, service registration and discovery using etcd, as well as data collection, storage, and monitoring mechanisms for large‑scale distributed services.
This article explains how to describe, publish, register, discover, invoke, monitor, trace, and govern RPC services in a microservice architecture, covering RESTful API, XML configuration, IDL files, registry principles, Zookeeper deployment, connection methods, server processing models, monitoring metrics, tracing concepts, and common governance techniques such as load balancing and fault tolerance.
This article explains what RPC is, compares it with SOA, SOAP, and REST, outlines the step‑by‑step RPC execution process, and introduces several mainstream RPC frameworks such as RMI, Hessian, protobuf‑rpc‑pro, Thrift, Avro, and Dubbo.
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.
