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.
This article explains the OSI model basics, compares RPC and HTTP service architectures, details synchronous and asynchronous calls, introduces major RPC frameworks like gRPC, Thrift, and Dubbo, and offers guidance on choosing between RPC and HTTP based on project needs.
This article describes how the author investigated recurring errors in a Java-based lecture hall system, identified thread pool leaks caused by improper use of AsyncHttpClient, and resolved the issue through command‑line diagnostics, code fixes, and system monitoring, improving stability.
This article introduces the fundamentals of IntelliJ IDEA plugin development, covering plugin types, project structure, essential components, a complete development workflow with Gradle, action registration, extension points, live templates, Dubbo integration, publishing procedures, common pitfalls, and how to include local JARs.
This article examines a production incident where Dubbo services became congested, explains the underlying communication process with detailed code analysis, identifies key protocol and service parameters affecting performance, conducts experiments on connection count and TCP buffers, and offers practical recommendations to optimize Dubbo throughput.
This article explains the distinctions between SOA and microservice architectures, describes ESB and API gateway roles, outlines the characteristics of both architectures, and provides practical Dubbo service design guidelines such as packaging, granularity, versioning, and pre‑release environment configuration.
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 need for high‑performance scheduling in Java, introduces the hashed timing wheel algorithm, and details Dubbo's implementation—including core interfaces, data structures, worker logic, and practical use cases such as retries and heartbeat handling.
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 explains how Dubbo Spring Cloud bridges Apache Dubbo 3.0 with the Spring Cloud ecosystem, covering version compatibility, service registration and discovery, load balancing, circuit breaking, service introspection, migration strategies, and provides step‑by‑step Maven and YAML configurations with complete code examples for both provider and consumer applications.
The article analyzes a production incident where a Dubbo thread pool exhausted its threads due to CompletableFuture#join blocking, explains how the custom business thread pool caused mutual waiting, and presents a solution that isolates asynchronous tasks into a separate pool to restore service stability.
This article describes the design, architecture, and innovations of a custom API gateway for microservice systems, covering technical selection, protocol conversion for Dubbo, service orchestration, embedded gateway deployment, high‑availability strategies, and measurable efficiency gains.
This article details CTrip's journey from its early .Net‑based ESB architecture through a self‑developed Java microservice framework to the current CDubbo platform, covering registration, monitoring, dynamic configuration, protocol compatibility, performance gains, extensibility, and future Service Mesh integration.
The article outlines dubbogo's five‑year evolution, its milestone‑driven roadmap, the launch of dubbo-go-proxy, community recruitment, management practices, tooling, code‑quality measures, and future challenges, providing a comprehensive view of this Go‑based backend framework.
This article explains the concept of microservices, how they communicate via synchronous RPC or asynchronous messaging, compares Spring Cloud with Dubbo, clarifies the relationship between SpringBoot and SpringCloud, and discusses circuit breaking, service degradation, pros and cons, Eureka vs Zookeeper, and a typical technology stack.
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 what microservices are, how they communicate, compares Spring Cloud with Dubbo, describes the relationship between Spring Boot and Spring Cloud, and discusses circuit breaking, service degradation, advantages, disadvantages, service discovery tools, and typical technology stacks.
This article explains how to configure Dubbo for local service calls and test‑environment isolation by using @Reference URL specifications, a user‑home properties file, and Nacos namespace isolation, providing practical steps for backend developers to avoid cross‑instance interference and streamline branch testing.
This article explains the mechanics of Java deserialization vulnerabilities, demonstrates how malicious payloads can trigger Runtime.exec via Commons‑Collections transformers and AnnotationInvocationHandler, showcases full exploit code, discusses Dubbo‑specific issues, and provides practical mitigation strategies.
This article provides a comprehensive overview of microservices, covering their definition, independent communication methods, differences between Spring Cloud and Dubbo, the relationship between Spring Boot and Spring Cloud, fault‑tolerance mechanisms like circuit breaking and degradation, advantages and disadvantages, and a comparison of Eureka and Zookeeper for service registration and discovery.
This article walks through a real‑world Dubbo debugging case where a NoClassDefFoundError was silently swallowed, showing how to use Arthas watch commands to capture the exception, analyze the root cause in static initializers, and fix the logging dependency conflict.
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.
The article examines the ongoing relevance of Spring Cloud and Dubbo, explaining how they have become complementary rather than competing frameworks, and argues that both are likely to coexist long‑term thanks to integration efforts and strong community support.
The article investigates a Nacos 1.2.0 bug that caused excessive TIME_WAIT connections in Dubbo clients, explains the underlying HttpURLConnection misuse, and reviews TCP three‑way handshake and four‑way termination to illustrate why disconnect() leads to connection buildup.
The article describes a full‑field automation framework for Dubbo services that validates both read and write interfaces by routing identical requests to base and project environments, generating ignore‑field maps via object‑to‑map conversion, and orchestrating multi‑round TestNG executions to achieve exhaustive field verification while dramatically improving test‑case authoring efficiency.
This article explains how Dubbo's tag router feature can isolate parallel test environments by assigning tags to providers and consumers, outlines configuration methods, compares it with version/group routing, discusses known attachment bugs, and presents a practical SPI‑filter solution for reliable tag propagation.
This article investigates why @Configuration classes imported via @Import in a Spring Boot Dubbo starter fail to inject @Value properties and execute @PostConstruct, tracing the issue to early bean creation by a FactoryBean and offering practical work‑arounds.
This article explains the microservice architecture style, defines key terminology, illustrates how services communicate via APIs and gateways, reviews the evolution of major frameworks such as Spring Cloud, Dubbo, and Istio, and compares them based on features and community activity.
The article explains why Spring Cloud is better suited than traditional Nginx or Dubbo solutions for building scalable, DevOps‑friendly microservices, detailing its REST‑based communication, comprehensive service‑governance components, and ongoing community support.
The article introduces Alibaba's open‑source web server Tengine, explains its Dubbo integration that enables HTTP‑to‑Dubbo proxying, compares it with traditional Java gateway architectures, highlights performance and stability advantages, and provides practical examples and future roadmap details.
This article explains why Dubbo's default thread pool can become exhausted, demonstrates how to reproduce the issue, and shows how to use Arthas's dashboard and thread commands to pinpoint and resolve thread‑pool problems in Java services.
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.
This article compares Dubbo and Spring Cloud across architecture, performance, development difficulty, community activity, and ecosystem integration, offering practical guidance on choosing the right micro‑service framework for different team sizes and business needs.
This article explains the conceptual differences between SOA and microservice architectures, compares ESB with API gateways, outlines the characteristics of each approach, and provides practical guidelines for designing and managing Dubbo services in a distributed backend system.
The Apache Dubbo 2.7.5 release introduces application‑level service registration, native HTTP/2 (gRPC) and Protobuf support, a 30% performance uplift, TLS security, an optimized consumer thread‑pool, a new Bootstrap API, multi‑registry load balancing, and numerous other enhancements aimed at cloud‑native microservice development.
This article compares Spring Cloud and Dubbo across protocol handling, performance tuning, load‑balancing strategies, fault‑tolerance mechanisms, and routing/traffic‑shaping features, highlighting their flexibility, configuration complexity, and suitability for different microservice scenarios.
This article outlines a systematic approach to dependency governance in high‑traffic backend services, covering service classification, rate limiting, Dubbo, HTTP, database, and message‑queue management to enhance availability, reduce failure impact, and improve overall system stability.
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 presents a detailed case study of intermittent Dubbo connect‑timeout errors in a high‑concurrency deployment, describing step‑by‑step diagnostics—from port status checks and registry verification to TCP dump analysis—and explains how adjusting the server’s backlog and accept queue resolved the SYN‑drop issue.
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 analyzes a real‑world incident where Dubbo services continued to operate despite Nacos registry failures, explains the role of local provider caches, examines the namingLoadCacheAtStart configuration, and provides reproduction steps and best‑practice recommendations for high‑availability service discovery.
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.
A recent offline performance test of a Dubbo service revealed that enabling Logback’s default packageData option caused massive AladdinClassLoader lock contention, dramatically increasing response times, and the issue was fixed by upgrading Logback to a version where packageData is disabled by default.
This article explores Dubbo's graceful shutdown mechanisms across versions 2.5.x, 2.6.x, and 2.7.x, detailing the underlying shutdown hooks, registry and protocol cleanup, Spring integration challenges, and best‑practice configurations to ensure in‑flight requests complete without service disruption.
The article explains how Java 8 parallel streams in Tomcat containers trigger class‑loading failures because ForkJoinWorkerThreads inherit a null context class loader after Tomcat 7.0.74 introduced SafeForkJoinWorkerThreadFactory, leading to deserialization errors and memory‑leak risks, and recommends avoiding dynamic class loading or using custom thread pools.
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.
This article details CTrip's migration of its internal Dubbo‑based RPC framework (CDubbo) from version 2.5.10 to 2.7.3, describing the motivations, encountered incompatibilities, step‑by‑step resolutions, performance regressions, and the comprehensive compatibility, stress, and integration testing performed to ensure a stable production rollout.
This article explains why large codebases should be split into distributed services, how to perform the split, the role of Dubbo in RPC communication, and provides practical tips for interviewers and candidates tackling system‑splitting questions.
This article explains why adding spring-boot-devtools can trigger a ClassCastException due to its dual classloader mechanism, demonstrates how to reproduce the issue in a Maven multi‑module project, and provides two practical solutions: customizing the RestartClassLoader or removing the devtools dependency.
To avoid duplicated effort across multiple mobile platforms, the article proposes a unified permission and approval management system that abstracts module identifiers, user roles, and release workflows, detailing the interaction flow, interface design, and optimization measures such as permission request shortcuts and configurable approval toggles.
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 tutorial walks through integrating Dubbo into a Spring Cloud Alibaba project using Nacos as the service registry, covering interface definition, provider and consumer setup, Maven dependencies, configuration details, testing, and the benefits of combining Dubbo's RPC performance with Spring Cloud's ecosystem.
This article introduces Alibaba's Cloud Toolkit IDE plugin, explaining how its one‑click deployment, Windows and EDAS Kubernetes support, SSH proxy capabilities, real‑time log viewing, and rapid Dubbo project creation can automate repetitive tasks and significantly improve developer productivity.
This article explains a practical approach to performance‑testing Dubbo add and delete methods of a message queue by pre‑generating payloads, using a thread‑safe LinkedBlockingQueue, and driving the calls with JMeter‑compatible Java code.
This article describes how to conduct load testing of Dubbo queue service methods for adding and deleting messages using Java concurrency utilities and JMeter, including code examples for constructing test data, managing a thread‑safe LinkedBlockingQueue, and handling initialization challenges during repeated test runs.
This article explains how the IoT business platform adopts Alibaba Sentinel to provide circuit breaking and rate‑limiting for Dubbo microservices, integrates with Apollo for centralized rule distribution, implements automatic downgrade, thread isolation, and cache‑based degradation to improve system reliability and resilience.
The article recounts the author’s path from a novice Java developer at Alibaba to becoming an Apache Tomcat committer, PMC member, and Apache Foundation member, detailing early challenges, contributions to Tomcat and Dubbo, participation in Apache Roadshows, and insights on open‑source collaboration and community governance.
The author recounts his path from joining Alibaba's middleware team in 2014 to becoming an Apache Tomcat committer, PMC member, and Apache Foundation member, while also guiding Dubbo's migration to Apache and sharing practical lessons on open‑source contribution and large‑scale backend systems.
This article explores why Java remains the dominant backend language, introduces the Dubbo framework and its evolution, explains core concepts such as providers, consumers, and registries, and details practical configurations for registry, load balancing, rate limiting, governance, monitoring, and extensions like DubboX and REST support.
This article explains how to design and implement a mock plugin for Dubbo-based services, enabling stable CI integration, multi‑service mocking, per‑test case responses, custom annotations, and service‑chain routing, with detailed code examples and deployment steps.
This article explains how Dubbo handles service communication when the Zookeeper registration center crashes, the role of local caches, the differences between registry-based and direct point‑to‑point connections, Dubbo’s token‑based security, and how new providers are discovered or missed.
The latest Spring Cloud Alibaba release, arriving four months after Nacos 1.0.0, introduces several new modules—including Dubbo integration, Seata distributed transactions, Sentinel‑Zuul filters, and SMS support—while upgrading core components such as Nacos to 1.0.0 and Sentinel to 1.5.2, and provides a detailed version‑compatibility matrix for Spring Boot, Spring Cloud, and Spring Cloud Alibaba.
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.
The author critically examines common misconceptions about Spring Cloud Alibaba, discussing the compatibility of Dubbo with Feign, the choice of service registries like Nacos versus Eureka, and the role of circuit‑breaker tools such as Sentinel, while urging readers to think independently.
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 introduces the newly released Dubbo Admin 0.1, explains the architectural changes such as switching to Spring Boot, Vue, and Swagger integration, details the updated configuration format, and showcases the enhanced service governance features like tag routing, application‑level rules, and metadata‑driven testing.
Dubbo Admin 0.1, a freshly refactored standalone project, replaces the old Webx backend with Spring Boot, adopts Vue and Vuetify for the UI, integrates Swagger, and introduces updated configuration, tag routing, application‑level service governance, and metadata‑driven testing to fully support Dubbo 2.7 features.
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.
This article lists and briefly describes the eleven most popular Java‑related GitHub repositories in December, covering learning guides, e‑commerce platforms, advanced Java topics, performance monitoring, high‑concurrency demos, diagnostic tools, Spring Boot, tutorials, messaging middleware, community software, and the Dubbo RPC framework.
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 article details NetEase Kaola’s journey from a monolithic Java backend to a micro‑service architecture powered by Dubbo, covering service decomposition, circuit breaking, rate limiting, comprehensive monitoring, API gateway, multi‑language support, registration‑center redesign, and future plans for dual‑data‑center deployment and service‑mesh adoption.
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 describes how a SpringMVC‑Dubbo micro‑service payment system was stress‑tested, diagnosed for thread‑creation and connection‑pool issues, and tuned through JVM, Log4j, and Dubbo configuration changes to raise throughput from 1 req/s to over 2600 req/s.
This article chronicles Dubbo’s journey from its 2018 Apache incubation vote through its key features, release history, and upcoming 2.7 version that aims to graduate the high‑performance Java RPC framework to an Apache top‑level project.
This article introduces Spring Cloud as a comprehensive microservice solution, outlines its key features and typical microservice architecture requirements, and compares its advantages and disadvantages with Dubbo, highlighting differences in community activity, architectural completeness, and documentation quality.
The article reviews the evolution of Service Mesh and Dubbo, compares sidecar and SDK deployment models, discusses key technical challenges such as multi‑language support, performance, and operations, and explains how Dubbo integrates with Kubernetes to enable cloud‑native micro‑service architectures.
This article explains Dubbo's system roles, layered architecture, supported protocols, default settings, source modules, and the detailed processes of service exposure and consumption, providing a comprehensive overview for backend developers.
This guide explains why reading framework source code is essential for developers, outlines step‑by‑step methods such as researching online, scanning packages, locating entry points, systematic reading, organizing insights, and applying critical thinking to deepen understanding and improve coding practice.
This guide explains why contributing to open‑source projects matters, outlines the benefits, walks through essential Git operations, forking, pull‑request workflow, CI checks, mailing‑list communication, and best practices, helping newcomers become effective contributors to projects like incubator‑dubbo.
The article explains why Spring Cloud is the preferred framework for building microservices, comparing it with traditional Nginx‑based routing and Dubbo’s RPC approach, highlighting benefits such as better DevOps alignment, centralized service governance, RESTful communication, broader ecosystem integration, and ongoing community support.
This guide explains how to install, configure, and use the open‑source Pinpoint APM tool to monitor Java‑based Dubbo applications, covering environment preparation, downloading binaries, modifying configuration files, deploying collector and web components, installing agents, and adding startup parameters for both Tomcat and SpringBoot deployments.
This article explains why microservice architectures demand specialized automated testing, compares testing styles such as unit, contract, and end‑to‑end, and walks through a practical Java‑based framework built on Spring, TestNG and Dubbo, including setup steps and code examples.
This article explains the evolution from a single‑system e‑commerce application to vertically split and SOA‑based distributed architectures, demonstrates how to expose and consume services using Dubbo with complete Java interface and implementation code, and provides configuration, deployment, and testing guidance for both providers and consumers.
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.