This article explains how to achieve comprehensive service governance in a microservice architecture using SpringCloud Alibaba's Nacos and Dubbo, covering service registration and discovery, load balancing, rate limiting and circuit breaking with Sentinel, configuration management, and monitoring with Prometheus and SkyWalking.
This tutorial walks through building a simple Dubbo‑Nacos integration using Spring Boot, covering environment setup, Maven project structure, dependency management, service interface definition, provider and consumer modules, configuration files, and a test call, enabling rapid development of high‑performance Java microservices.
The article analyzes why most production failures stem from new version rollouts, examines a real e‑commerce microservice architecture, and presents detailed gray‑release strategies—including full‑link canary, logical isolation, and warm‑up mechanisms—to achieve zero‑damage upgrades in cloud‑native environments.
This tutorial provides a complete, code‑rich example of integrating Dubbo with Nacos using Spring Boot, covering environment setup, Maven project structure, module creation, configuration files, Java source code, and testing the RPC service call.
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 details how the Sohu video PUGC team refactored a legacy video‑object‑creation API by introducing a reactive, asynchronous, non‑blocking architecture built on RxJava, Vert.x WebClient and a custom Dubbo reactive client, achieving clearer business flow and a 43% latency reduction.
This article traces the evolution of internet architecture from monolithic to distributed and microservice models, explains the concepts of serviceization and service governance, and details how Dubbo implements these ideas while highlighting the benefits, challenges, and practical implementation steps for modern backend systems.
Explore the complete lifecycle of graceful shutdown in Java backend systems, covering kernel signal handling, JVM shutdown hooks, Spring’s ContextClosedEvent, Dubbo’s integration and bug fix, and Netty’s Reactor shutdown process, with detailed code examples and state transition diagrams.
This article explains the concept and usage of Service Provider Interface (SPI) in Java, demonstrating how JDK’s ServiceLoader, Dubbo’s enhanced SPI, and Spring’s SPI mechanisms enable flexible extension of logging frameworks and other components, while comparing their features, configuration files, and limitations.
This article explains the hidden pitfalls when converting Java Beans to Map objects—such as type loss and incorrect property names caused by JSON libraries, BeanUtils, and CGLIB—and demonstrates reliable solutions using Dubbo's PojoUtils with clear code examples and visual debugging screenshots.
This article provides an in‑depth overview of microservice architecture, covering concepts such as RPC, serialization, CAP and BASE theories, distributed transaction patterns like TCC, service monitoring with Sleuth and ELK, high‑availability strategies, load balancing, configuration management, Dubbo fault‑tolerance clusters, timeout handling, service registration and discovery, communication protocols, AOP fundamentals, Spring annotations, JdbcTemplate and RestTemplate usage, transaction management, and the inner workings of Spring Boot starters.
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.
Converting Java beans to maps often leads to type loss and incorrect property names due to JSON frameworks and BeanUtils behavior, and this article examines those pitfalls, demonstrates them with code examples, analyzes underlying Java introspection mechanisms, and presents a Dubbo‑based solution to reliably preserve types and property names.
The article explains how a Business Monitoring Platform isolates user‑defined Groovy scripts by assigning each script its own custom Java ClassLoader that loads uploaded JARs, breaking parent‑delegation, preventing class conflicts, reducing Metaspace growth, and dynamically creating Feign and Dubbo beans for safe, independent execution.
In 2022, Suzhou Zhonglun Network migrated its entire microservice ecosystem—supporting over 3,000 services across 300 cities—from Dubbo 2 to Dubbo 3, leveraging Kubernetes‑native deployment, enhanced service governance, and instance‑level upgrade strategies to improve scalability, reliability, and resource utilization.
This guide explains how to connect Dubbo services to Aeraki Mesh using Dubbo2Istio or direct ServiceEntry definitions, covering configuration, environment variables, Kubernetes deployment, and client adjustments to achieve comprehensive L7 traffic routing, load balancing, and rate limiting within an Istio service mesh.
This article explains why resource isolation is essential in distributed systems, outlines various isolation methods such as thread, process, cluster, and data read/write isolation, and demonstrates practical implementations using Netty, Dubbo, Tomcat, and Hystrix with code examples and configuration tips.
The article explains why Dubbo’s RPC model, with its serialization limits, single‑connection design, and high memory consumption, is ill‑suited for transmitting files, and compares it with HTTP and Feign approaches that handle large file uploads more efficiently, while also providing practical code examples.
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 tutorial demonstrates how to install Aeraki Mesh, view its default Round Robin load balancing, and configure a Consistent Hash algorithm for Dubbo services using Istio DestinationRule metadata, then verifies the behavior and explains the underlying RDS routing configuration.
Converting Java Beans to Maps can cause type loss and incorrect property names due to JSON serialization and BeanMap implementations, but using Dubbo's PojoUtils.generalize method or custom reflection with caching can preserve types and correctly map property names, as demonstrated with code examples and analysis.
This article explores the complete lifecycle of graceful shutdown for Java server applications, detailing how operating‑system signals, JVM shutdown hooks, and framework‑level mechanisms in Spring, Dubbo, and Netty collaborate to safely stop services while preserving in‑flight requests and resources.
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 principles and implementations of Java's built‑in SPI, Dubbo's enhanced SPI, and Spring's SPI mechanisms, compares their designs, walks through concrete code examples, and shows how they can be applied for dynamic extension in real projects.
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 presents a one‑stop solution that uses dynamic proxies, Spring extensions, and Dubbo generic invocation to let overseas applications call domestic Dubbo services via HTTP without refactoring existing callers, reducing workload and eliminating previous drawbacks.
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 (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.
SPI (Service Provider Interface) is a service discovery mechanism used in Java, Spring, and Dubbo that loads implementations via configuration files, enabling runtime extensibility, decoupling, and plug‑in architecture, with examples ranging from custom interfaces to MySQL drivers and Dubbo extensions.
This article outlines Huolala's journey through five architectural stages—monolith, RPC, SOA, microservices, and service mesh—detailing the motivations, challenges, and technical choices such as Dubbo, Spring Cloud, and Istio that shaped its high‑availability, cloud‑native backend platform.
This article chronicles how 于雨 transformed Dubbogo—from a one‑person Go implementation of the Dubbo RPC framework into a large, cloud‑native open‑source community—detailing technical challenges, community building, personal sacrifices, and future goals for sustainable growth.
On April 8 2022, JDTECH and JD Retail’s Platform Business R&D co‑hosted a hybrid technical salon on open‑source construction and sustainable development, featuring internal and external experts who shared practical experiences, architectural designs, compliance guidelines, and strategies for building lasting open‑source ecosystems within the company.
The article explains why a time‑wheel scheduler outperforms traditional timers, describes single‑ and multi‑layer wheel designs, and walks through Apache Dubbo’s HashedWheelTimer implementation—including TimerTask, Timeout, bucket and worker components—showing its use in Dubbo heartbeats and Redisson lock renewal.
This article walks through the fundamentals of Apache Dubbo, covering its service discovery, RPC communication, traffic management, configuration, and deployment architecture, and provides a step‑by‑step SpringBoot implementation of a simple RPC service with Zookeeper registration, including code snippets for provider, consumer, and controller.
The article shows how to integrate JSR‑303 bean validation into Dubbo services by adding the necessary Maven dependencies, annotating parameter classes, enabling validation on provider and consumer, customizing the validation filter to return a unified FacadeResult, disabling the default filter, and extending validation with custom annotations for clean, maintainable RPC parameter checks.
This article analyzes a persistent full‑GC and CPU spike issue in a Dubbo microservice gateway, tracing the root cause to repeated Zookeeper subscriptions caused by timestamp‑varying URLs and offering a simple fix by disabling reference checks.
This article explains how to implement graceful shutdown and startup for SpringBoot microservices using Dubbo, including unregistering services, timed waits, kill signals, JVM tuning, health checks, and deployment strategies such as rolling and blue‑green releases.
The Vivo comment middleware achieves high‑availability, cross‑service comment publishing by using Dubbo tag‑routing for traffic isolation, Sentinel hotspot‑parameter flow control with dynamic per‑tenant limits, and both physical and logical MongoDB isolation via a multi‑factory selector and runtime collection naming, preventing data leakage across business lines.
This article explains the Service Provider Interface (SPI) mechanism across JDK, Spring, and Dubbo, showing how to create modular, maintainable code through interface definitions, configuration files, and ServiceLoader or ExtensionLoader usage, with detailed examples, code snippets, and analysis of advantages and drawbacks.
This article explains the principles of consistent hashing, its data‑skew issue, how virtual nodes mitigate that problem, and demonstrates the implementation and usage of ConsistentHashLoadBalance in Dubbo with detailed code analysis and practical load‑balancing examples.
This article examines the motivations for rewriting the Java‑centric Dubbo RPC framework in Go, discussing language efficiency, company‑level technology choices, the advantages of Go’s lightweight concurrency for gateways, and how Dubbo‑Go bridges Java and Go in modern microservice and service‑mesh architectures.
This article explains the principles of time wheels, how Dubbo implements them for retry mechanisms and heartbeat scheduling, walks through the relevant source code, discusses performance considerations, and references related issues and improvements in both Dubbo and Netty.
This article analyzes a Spring Boot startup failure caused by a conflict between @Autowired and @DubboReference annotations when injecting the same service bean, explaining the underlying mechanism and providing solutions.
This article explains why multiple Java logging frameworks often clash in SpringBoot and Dubbo applications, identifies common causes such as transitive dependencies and duplicate versions, and provides step‑by‑step Maven configurations and adaptation techniques to unify logging with SLF4J and Logback.
This article details how a Go‑based Dubbo registration center suffered high CPU usage, how profiling identified the AssembleUrlWeight function as the bottleneck, and how custom URL‑parameter extraction and weight‑insertion code cut CPU consumption by over ten percent and improved performance by up to twenty times.
This article introduces Apache Dubbo, explains its core concepts and RPC fundamentals, and provides step‑by‑step demo projects—first a simple setup without a service registry using direct URL calls, then an enhanced version that registers services with Zookeeper, including all necessary Maven dependencies, Spring XML configurations, Java code, and execution results.
This article explains what microservices are, how they communicate, compares Spring Cloud with Dubbo, outlines the relationship between Spring Boot and Spring Cloud, describes circuit breaking and service degradation, lists pros and cons, and compares Eureka and Zookeeper for service discovery.
This article examines the importance of resource isolation in distributed systems, covering thread, process, cluster, data‑read/write, static, and crawler isolation, and illustrates practical implementations with Netty, Dubbo, Tomcat, and Hystrix, including code snippets and configuration tips.
The article recounts a puzzling case where a custom Dubbo load‑balance extension (XLB) stopped being applied, explains how conflicting XML and Spring‑Boot configurations caused the consumer to ignore the custom setting, and walks through the source‑code investigation that reveals the loading order and caching behavior, ending with a concise summary of the root cause and resolution.
When a high‑traffic Dubbo interface began throwing thread‑pool exhaustion errors, the team traced the issue to Redis request spikes, identified mis‑configured connection‑pool parameters and version‑specific bugs, and applied a series of quick fixes, pool‑size adjustments, and client‑side optimizations that dramatically reduced latency and error rates.
When a Dubbo interface handling 18 billion daily requests began failing due to thread‑pool exhaustion, a systematic investigation uncovered traffic spikes, Redis request overload, and mis‑configured connection‑pool parameters, leading to a series of targeted fixes—including timeout adjustments, Redis scaling, and pool‑parameter tuning—that restored stability and dramatically reduced error rates.
After a late‑night incident where a Dubbo 2.7.12 service crashed, the author traced high memory and CPU usage to a full GC spike, identified a HashedWheelTimer thread‑pool bug causing request timeouts to be missed, reproduced the leak, and confirmed the issue was fixed in Dubbo 2.7.13.
The article explains why resource isolation is essential for distributed architectures, describes common isolation methods such as thread, process, cluster, data, static and crawler isolation, and provides concrete examples and code snippets for Netty, Dubbo, Tomcat, and Hystrix to illustrate practical implementations.
This article examines Dubbo’s connection‑control feature, demonstrates how long‑living TCP connections are created, runs benchmark tests with one and two connections, discovers that varying IO thread counts skew results, and shows that increasing connections alone rarely improves throughput.
This article provides a comprehensive overview of Dubbo, the high‑performance Java RPC framework, covering its core components, advantages over alternatives, supported protocols, configuration methods, startup behavior, integration with Spring Boot, and detailed architecture for building scalable distributed services.
The article explains why resource isolation is essential in distributed architectures and details various isolation strategies—including thread, process, cluster, data read/write, static, and crawler isolation—illustrated with Netty, Dubbo, Tomcat examples, code snippets, and a comparison of thread‑pool versus semaphore isolation in Hystrix.
The article by the Vivo Internet Server Team details Apache Dubbo’s ten‑layer architecture—service, config, proxy, registry, cluster, monitor, protocol, exchange, transport, and serialization—explaining each layer’s role, the RPC invocation flow, registration/discovery mechanisms, configuration options, and how Dubbo’s extensive SPI‑based modular design enables loose coupling, extensibility, and robust micro‑service development.
This article details how to create a VSCode plugin that automates the entire workflow of building, versioning, and publishing a WeChat mini‑program using uni‑app, shell commands, Git operations, Dubbo service calls, and the WeChat DevTools CLI, providing code examples and step‑by‑step analysis.
This article compares RPC and HTTP services by explaining their protocol foundations, the OSI network layers, RPC architecture components, synchronous versus asynchronous calls, and popular frameworks such as gRPC, Thrift, and Dubbo, while also outlining when each approach is appropriate for enterprise development.
This article traces the evolution of software architecture from monolithic applications through vertical, distributed, and microservice stages to service mesh, compares SOA with microservices, contrasts Spring Cloud and Dubbo, examines their overlap with Kubernetes, and outlines the benefits and challenges of adopting a service mesh like Istio.
Youzan’s service registration and discovery architecture progressed from fine‑grained interface‑level registration on Etcd, through an intermediate application‑level discovery layer using Istio Pilot and the Tether sidecar, to a fully application‑level, sidecar‑driven model with CRD metadata, enabling scalable, cloud‑native multi‑region service mesh.
This article explains how to test and invoke Dubbo services without provider JARs by using telnet or generic calls, compares Java and Go implementations, details the underlying filters, and provides practical code samples for building a Dubbo-go based gateway or testing platform.
This article explains the Service Provider Interface (SPI) concept, demonstrates its use in plain JDK, Dubbo, and Spring frameworks with code examples, compares their strengths and limitations, and shows how SPI enhances extensibility and modularity in Java applications.
Pixiu is a Golang‑based, cloud‑native API gateway built on dubbo‑go that bridges RESTful and Dubbo services, offering high performance, extensibility, and easy configuration through Listener, Router, Filters, and Client modules, with roadmap plans for gRPC, mesh integration, and more.
In this interview, Mercyblitz shares his background, discusses Java's role in cloud‑native computing, explains recent Dubbo advancements and plans for native support, and offers insights on technology selection, architectural challenges, and his upcoming GIAC talk on Java cloud‑native ecosystems.
This article explains why Swagger‑Dubbo is needed, introduces Swagger, describes the Swagger‑Dubbo tool, provides step‑by‑step integration instructions with Maven dependencies and Java configuration code, demonstrates how to launch and test the generated API docs, and outlines additional integrations with Knife4j and YApi.
Spring Cloud Alibaba 2.2.6, compatible with Spring Cloud Hoxton.SR9, introduces feature enhancements for Nacos, Dubbo, and Sentinel along with numerous bug fixes, providing developers with improved service registration, refactored integrations, and resolved issues across Kubernetes, Consul, and tracing components.
This article explains the design goals and conventions of Java's Service Provider Interface (SPI), demonstrates a practical JDK SPI example with a Command interface, discusses its drawbacks, and shows how Dubbo extends and customizes SPI for protocol implementations.
After a new feature rollout caused a sudden CPU surge and thousands of Dubbo threads to stall, this article walks through log inspection, code review, thread‑dump analysis, and memory‑leak detection to uncover the root cause and suggest concrete optimizations.
The article explains Java’s built‑in SPI mechanism, then details Dubbo’s enhanced SPI—including ExtensionLoader caching, wrapper and adaptive classes, and @Activate automatic activation—showing how extensions are discovered from META‑INF directories, classified, and loaded on demand for flexible, plug‑in style service implementation.
The case study details how a high‑traffic Dubbo service handling 1.8 billion daily requests suffered periodic circuit‑breaks due to thread‑pool exhaustion, traced to a cache‑bypass bug, Redis setex spikes, and an improperly warmed commons‑pool2 connection pool, and resolved by fixing the bug, scaling Redis, and tuning or downgrading the pool configuration to enable pre‑warming via minEvictableIdleTimeMillis.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI model, RPC architecture, synchronous vs asynchronous calls, and popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, to help developers choose the right approach for large‑scale systems.
This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture and sync/async calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo with traditional RESTful HTTP, and offers guidance on choosing the right approach for a project.
This article explains the Service Provider Interface (SPI) concept, demonstrates how Java's built‑in SPI, Dubbo's enhanced SPI, and Spring's SPI work with code examples, compares their strengths and limitations, and discusses classpath ordering and extension loading issues.
This article details a large‑scale C10K performance test of Dubbo, analyzes why service calls time out under thousands of concurrent consumers, identifies heartbeat‑induced Netty thread saturation and TCP full‑connection‑queue overflow as root causes, and presents concrete optimizations that dramatically improve latency and stability.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI network model, RPC architecture components, synchronous and asynchronous calls, and introduces popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, before comparing their suitability for various enterprise scenarios.
This article analyzes the C10K scenario where Dubbo‑based services experience massive timeout failures, examines root causes such as heartbeat‑induced Netty thread saturation and TCP backlog overflow, and presents a series of optimizations that dramatically improve latency, CPU usage, and stability in large‑scale deployments.
The article analyses a duplicate deregistration bug in Apache Dubbo 2.7.0‑2.7.4 caused by shutdown‑hook interactions, demonstrates how it reproduces with custom and open‑source versions, explains the internal debugging steps, and shows that the issue was fixed in Dubbo 2.7.5 onward, offering insights for registry extensions.
This article investigates the duplicate unregister bug in Dubbo 2.7.3, explains how the shutdown hook interaction causes the error, and shows how the issue was fixed in later versions and can be mitigated without upgrading the whole framework.
This article recounts Alibaba's year‑long Service Mesh journey, highlighting how the team shifted from large‑scale rollout to delivering incremental business value, adopted non‑intrusive sidecar designs, integrated Dubbo 3.0, and applied software‑lifecycle thinking to create scalable, low‑overhead traffic management solutions.
This article walks through Dubbo’s RPC encoding and decoding mechanisms, explaining how Netty pipelines add codec handlers, detailing the message header format, exploring Hessian2 serialization, and answering common pitfalls such as class‑path changes and field mismatches.
This article explains why multiple Java logging frameworks often clash in SpringBoot and Dubbo projects, outlines the root causes such as transitive dependencies and duplicate versions, and provides step‑by‑step Maven configurations and adaptation techniques to unify logging under a single implementation.
This article explains the fundamental differences between RPC and HTTP services, outlines the OSI model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for backend development.
This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for enterprise applications.
This article explains what Dubbo Spring Cloud is, how it registers Dubbo services as REST metadata, the core DubboMetadataService API, step‑by‑step integration with Spring Cloud clients, and the differences in routing and load‑balancing compared to traditional Spring Cloud Ribbon.
This article explains how Dubbo Spring Cloud enables Spring Cloud clients to invoke Dubbo services, covering metadata handling, code examples, configuration steps, and a comparison of routing and load‑balancing mechanisms between Dubbo and Spring Cloud.
An in‑depth analysis reveals that Dubbo 2.7.x fails to propagate provider‑side implicit parameters back to the consumer because the new AsyncRpcResult/AppResponse architecture discards attachments, a change introduced for better async support, effectively making this behavior a bug in the 2.7 series.
The article explains how Dubbo can use the Protostuff library as a drop‑in replacement for .proto files to perform Protobuf TLV serialization, detailing the wire‑type encoding, Maven setup, POJO example, byte‑level analysis, Dubbo configuration, and tips for reducing serialization overhead.
This article traces Dubbo’s evolution from its Alibaba origins to its Apache graduation, outlines its core features such as protocol design, service registry, clustering, filters, and extensibility, and discusses recent cloud‑native and reactive programming directions shaping its future.
This article explains how Dubbo integrates with Kubernetes to provide application‑level service discovery using a metadata service and revision mechanism, detailing both API‑client and DNS‑client implementations, their workflows, advantages, drawbacks, and future directions toward cloud‑native adoption.
This article explains Dubbo’s internal architecture, covering service registration and discovery with Zookeeper, RPC invocation details including load balancing, routing, and fault‑tolerance strategies, as well as its network protocol and thread‑dispatch mechanisms, providing practical insights for backend developers.
This guide explains how to integrate Dubbo‑Api‑Docs into a Dubbo project, providing Swagger‑style interface documentation and testing via Dubbo‑Admin, covering annotation setup, Maven dependencies, example projects, and deployment steps.
This article explains how Nacos achieves high availability through client retry mechanisms, the distro consistency protocol, local cache failover, heartbeat synchronization, and robust cluster deployment strategies, providing a comprehensive guide for selecting a reliable service registry in microservice architectures.
Faced with a legacy Dubbo service needing both Dubbo and HTTP protocols and a new Spring Cloud project requiring seamless Feign calls, this article details the challenges, the solution using Dubbo’s SPI Container extension, and how Arthas was employed to diagnose and resolve hidden loading errors.
smart-doc is a Java tool that automatically creates clear Markdown, HTML5, and Postman Collection API documentation for both REST and Apache Dubbo RPC interfaces without requiring any annotations, leveraging only standard JavaDoc comments and source code analysis.
Vivo extends Dubbo with a custom NearestRouter that reads each provider’s app_loc label to preferentially route RPC calls to services in the same data‑center or city, falling back based on configurable thresholds, and plans to enhance routing with richer topology metadata, composite policies, and cloud‑native service‑mesh integration.
The article explains Service Provider Interface (SPI) concepts, shows how the JDK’s built‑in SPI works, and details Dubbo’s extended SPI mechanism—including named and adaptive extensions, dependency injection, AOP wrappers, and activation filtering—highlighting its richer features and implementation compared to standard Java SPI.
This article details Industrial Bank's migration to Dubbo micro‑services, the performance and high‑availability challenges of managing over 20,000 services with Zookeeper, and the concrete optimizations—delayed subscription, multiple‑registry mode, and per‑node registration—that enabled stable, large‑scale service discovery.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous and asynchronous calls, and popular RPC frameworks such as gRPC, Thrift, and Dubbo, while also comparing their suitability for large‑scale versus small‑scale applications.
