This article analyzes six public benchmark datasets comparing HTTP/1.1+JSON (REST) against binary protocols like gRPC+Protobuf and Dubbo, showing gRPC achieves roughly 2x throughput and half the latency, but argues the gap is often negligible in real business scenarios where database and logic dominate latency.
This comprehensive guide compares Dubbo, gRPC, and Feign across eight critical dimensions including protocols, serialization, performance, cross-language support, service discovery, circuit breaking, streaming, and hybrid architecture coordination, with detailed interview questions and answers for each.
This article compares Dubbo, gRPC, and Feign across circuit breaking, streaming, contract management, learning curves, and real-world scenarios, providing a decision matrix and a Spring Cloud Alibaba hybrid architecture where all three coexist for external HTTP, internal high-frequency Java, and cross-language algorithm services.
The article walks through three real‑world Java service scenarios—high‑frequency internal calls, cross‑language algorithm services, and Spring Cloud gateway integration—comparing Dubbo, gRPC and OpenFeign on protocol, serialization, latency, throughput, cross‑language support, service governance and discovery, and finally presents a decision matrix and a mixed‑architecture demo.
This article details a production-ready full-chain gray release system using Spring Cloud Gateway and Dubbo, distinguishing canary from gray release, covering implementation, four real-world pitfalls with solutions, and a seven-step standardized rollout process for zero-downtime microservice deployments.
Based on three years running 50+ microservices, this article details production pitfalls in Nacos, Sentinel, Seata, and Dubbo, covering configuration isolation, hot-update risks, rule persistence, distributed transaction misuse, and thread pool tuning, with real incident postmortems and concrete configuration standards.
This article provides a deep dive into Dubbo’s core architecture, registry resilience, protocol choices, load‑balancing strategies, cluster fault‑tolerance policies, SPI enhancements, the shift from interface‑level to application‑level service discovery, timeout‑cascade pitfalls, and how to run Dubbo alongside Spring Cloud in a Spring Boot 3 + Nacos environment.
The article explains Java SPI’s purpose, how the thread context class loader overcomes parent‑delegation limits, and compares the standard JDK SPI with the extended mechanisms used by Kafka Connect, Elasticsearch, Dubbo, and Spring Boot, providing interview‑ready insights and concrete code examples.
The article examines how to choose between Dubbo and Spring Cloud for high‑traffic microservice systems, analyzing communication models, thread and connection handling, governance capabilities, real‑world e‑commerce scenarios, and provides practical guidance on combining HTTP gateways, RPC, and asynchronous messaging for scalable, resilient architectures.
The article breaks down a complete Dubbo RPC invocation into ten precise steps—five on the consumer side and five on the provider side—explaining each core component such as Proxy, Filter, Cluster, LoadBalance, Protocol, and Transport, and addresses common interview follow‑up questions about clustering, load balancing, and sync vs async calls.
The article explains that RPC outperforms traditional HTTP/1.1 + JSON because of a slimmer binary protocol, faster binary serialization, persistent long‑connection reuse, and an efficient NIO network model, while noting that HTTP/2 + gRPC narrows the gap.
This article compares token pass‑through, unified gateway authentication, Feign, Dubbo, Spring Boot Web + Dubbo, regular auth modules, and Kubernetes integration, explaining their pros, cons, and implementation details to help you choose the most suitable internal‑call pattern for microservices.
Apache Dubbo Admin 0.7.0 transforms the classic registry‑center console into a Kubernetes‑native control plane, adding unified traffic‑governance UI, deep observability with Grafana dashboards, multi‑registry support, event‑driven architecture, and a roadmap for further service‑governance and AI‑assisted features.
This article compares Dubbo and Spring Cloud across four core dimensions—purpose, communication protocol, service registry, and ecosystem breadth—then expands the analysis with deployment complexity, learning curve, community activity, cloud‑native integration, and future trends to guide framework selection for Java microservice architectures.
This article explains the fundamentals of distributed communication, outlines essential elements such as serialization, transport protocols, service discovery, load balancing, security, and reliability, and reviews popular frameworks like gRPC, Dubbo, Thrift, and OpenFeign for building robust backend architectures.
This article walks through creating a custom Spring Boot starter that uses conditional auto‑configuration to provide primary and secondary data sources, DAOs, and services, enabling high‑frequency Dubbo calls to be replaced with direct database access and dramatically improving performance.
The article details how a high‑frequency Dubbo call bottleneck was resolved by creating a conditional Spring Boot auto‑configuration multi‑data‑source SDK that dynamically loads beans, avoids bean conflicts, and enables direct database access, dramatically reducing latency and system load.
The article analyzes why an e‑commerce system that mixes Spring Cloud (Finchley) and Dubbo (2.7.8) suffers from duplicate point deductions, premature Hystrix trips, and a 30% latency increase during peak traffic, then proposes a unified governance solution covering timeout‑retry control, integrated circuit‑breaker rules, and coordinated cross‑zone routing using Nacos, Sentinel and custom load‑balancing.
The 2025 Vivo Developer Conference showcased cutting‑edge advances in traffic‑driven growth, microservice and Dubbo performance tuning, full‑link multi‑version environment automation, and GPU‑container AI training platforms, highlighting how these innovations boost efficiency, reliability, and cost‑effectiveness across Vivo’s internet services.
This guide walks you through the concepts, environment setup, step‑by‑step integration, advanced configurations, monitoring, troubleshooting, and best practices for combining Dubbo's high‑performance RPC framework with Spring Boot to build production‑grade distributed Java services.
During a gray‑release a single server reported that the Spring container was closed while the Netty server still accepted HTTP requests, leading to an IllegalStateException; the article analyzes the root cause in Dubbo startup, explains the event flow, and proposes a reliable fix using ApplicationReadyEvent.
This article compares four major RPC frameworks—gRPC, Dubbo, Thrift, and Spring Cloud OpenFeign—detailing their core features, performance characteristics, language support, and ideal use cases to help engineers choose the right solution for high‑throughput, low‑latency microservice architectures.
This comprehensive guide explains microservice fundamentals, RPC frameworks, serialization, distributed transaction models (ACID, CAP, BASE, TCC), system monitoring, high‑availability strategies, load balancing, configuration management, service registration/discovery, Spring Cloud components, Dubbo fault‑tolerance clusters, and compares Spring Boot with Spring MVC, providing practical code examples and diagrams.
This article compares RPC and HTTP services, explains the OSI model layers relevant to each, details RPC architecture components, discusses synchronous and asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right approach for large‑scale enterprise applications.
This article explores how extracting hot‑path conditions from a switch statement into separate if checks can leverage CPU branch prediction to dramatically improve Java backend throughput, backed by benchmarks, bytecode analysis, and a discussion of instruction pipelines and sorted‑array effects.
The article explores how Dubbo’s ChannelEventRunnable code was optimized by separating the frequently‑taken ChannelState.RECEIVED case into its own if statement, compares the runtime efficiency of pure if‑else, mixed if‑switch, and pure switch structures, and explains the underlying CPU branch‑prediction and instruction‑pipeline mechanisms that affect these choices.
This article compares RPC and HTTP services, explains the OSI seven‑layer model, details RPC architecture and its synchronous versus asynchronous calls, reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose RPC over HTTP for enterprise applications.
From monolithic Java applications to Dubbo‑powered microservices, this article traces the evolution of backend development, highlights key milestones, and explains why mastering server‑side skills remains essential for data professionals in 2025 today.
This article introduces Dubbo, Alibaba’s high‑performance Java RPC framework, and provides a detailed examination of its client‑side load‑balancing mechanisms, covering the default Random strategy and the alternatives RoundRobin, LeastActive, and ConsistentHash, along with their principles, advantages, and drawbacks.
This article traces the evolution of internet architecture from monolithic and MVC designs through multi‑application and distributed systems, explains service‑oriented architecture and its benefits, introduces Dubbo‑based service governance, and outlines the core concepts, features, and implementation approaches of microservices.
This tutorial walks through integrating Dubbo with Seata in a Spring Boot microservice architecture, showing how to create service interfaces, configure Maven dependencies, set up Nacos discovery, implement distributed transaction logic, test normal and rollback scenarios, and externalize Seata server addresses for scalable deployments.
The article discusses why token transmission is discouraged in microservice authentication, proposes passing explicit parameters, compares Feign, Dubbo, and Spring Boot Web internal call approaches, and explains how to integrate these patterns with a unified gateway, regular authentication modules, and Kubernetes Ingress for scalable backend architectures.
This article walks through integrating SpringBoot, Dubbo, and Seata to implement reliable distributed transactions, covering project setup, Maven dependencies, service definitions, Nacos registration, configuration files, testing normal commits and rollbacks, and troubleshooting version incompatibilities.
This tutorial walks through integrating Dubbo with Spring Boot using Nacos as the service registry, showing how to create a shared API module, configure provider and consumer Maven projects, annotate services with @Service and @Reference, and verify successful RPC calls via a simple REST endpoint.
This article introduces Spring Cloud Alibaba, outlines its key components such as Nacos, Dubbo, Sentinel, RocketMQ and Seata, explains how to manage its versions with Maven, highlights compatibility checks, and compares the first‑ and second‑generation Spring Cloud stacks.
This article explains how to generate a unique traceId for each request, propagate it through Rest, RocketMQ, and Dubbo RPC modules, and configure Log4j2 (including custom Message, MessageFactory, and PatternConverter) to output the traceId so that logs across services can be correlated and read sequentially.
This article explains how Apache Dubbo 3.3.3 natively supports OpenAPI 3, allowing developers to automatically generate API documentation, export Proto files, integrate with Swagger UI and Apifox, and customize the output via annotations, all without extra dependencies or complex configuration.
This article explains the concept and implementation of the time wheel in Dubbo, covering its use for scheduled retries, heartbeat handling, underlying HashedWheelTimer mechanics, configuration details, performance considerations, and related issues, providing a thorough guide for backend developers.
Maoyan, a leading ticketing platform, migrated its Dubbo‑based microservice registry from Nacos to Tencent Cloud Polaris, achieving a 30% improvement in registration discovery speed, higher scalability, and stronger fault tolerance across millions of services.
The article explains how Apache Dubbo's Triple X protocol now fully supports HTTP/3, detailing its design goals, performance advantages, configuration steps, code examples, and real‑world benchmarks that demonstrate significant latency reduction and reliability improvements in cloud‑native microservice environments.
This article compares Dubbo and Feign, outlining their architectures, features, and suitability for different microservice scenarios, and provides practical guidance on selecting the appropriate RPC framework based on performance, reliability, and development efficiency requirements.
This article walks through a systematic investigation of a slow‑starting Dubbo service built on Spring 3.2, using JProfile to pinpoint costly class‑loading checks, disabling unnecessary annotation processing, and resolving thread‑waiting issues caused by RabbitMQ and other components, ultimately reducing deployment time by about 40%.
Dubbo’s microkernel architecture isolates only essential core functions—service invocation, clustering, and routing—while delegating all other capabilities to dynamically loaded extensions via its advanced SPI mechanism, which scans META‑INF files, supports precise lookups, dependency injection, bytecode generation, and hierarchical extension points, enabling flexible, modular, and fault‑tolerant RPC services.
This article compares Spring Cloud and Dubbo, detailing their core design philosophies, communication protocols, service governance features, and ideal application scenarios to help developers choose the most suitable microservice framework for their projects.
The article chronicles the time wheel algorithm from its 1997 origins, explains simple, round‑based, and hierarchical wheel designs, compares them to queue timers, details Dubbo’s HashedWheelTimer implementation, and shows how combining the wheel with a delay‑message queue can dramatically improve service scalability and efficiency.
The article diagnoses a 2023 Dubbo outage caused by Zookeeper’s jute.maxbuffer limit being exceeded by millions of temporary nodes, explains why Zookeeper’s CP model is ill‑suited for service registries, and outlines an automated migration to Spring Cloud using generated REST controllers and proxies that achieve comparable performance, especially for larger payloads.
This article explains why Dubbo transitioned from interface-level to application-level service registration in version 3.x, detailing the performance pressures of interface registration, alignment with Spring Cloud and Kubernetes, and the underlying implementation using metadata centers, Nacos, Redis, and Zookeeper.
This article explains microservice service governance, covering registration and discovery, load balancing, rate limiting, circuit breaking, dynamic configuration management, and monitoring using tools like Nacos, Dubbo, Sentinel, Prometheus, and SkyWalking.
This guide explains how to connect Dubbo microservices to Alibaba Cloud Service Mesh (ASM) to obtain mTLS, observability, and traffic management, covering prerequisites, step‑by‑step deployment, code examples, a registry‑based transition approach, and recommended best‑practice configurations.
This article walks through the complete lifecycle of a single RPC call in Dubbo 3.x, covering demo setup, provider exposure, consumer referencing, parameter packaging, filter chains, cluster decision, routing, load balancing, communication and serialization protocols, and finally how the provider processes the request.
This article explains the fundamentals of distributed RPC, outlines its end‑to‑end communication workflow, and compares major frameworks such as gRPC, Apache Thrift, Dubbo, Spring Cloud Netflix, ZeroMQ, Apache Avro, and gRPC‑Web, helping developers choose the right solution for their microservice architecture.
The article discusses the drawbacks of token pass‑through authentication in microservices, recommends explicit userId parameter passing, compares unified authorization approaches using Spring Cloud Gateway with Feign or Dubbo, and explores non‑unified and Kubernetes‑integrated deployment patterns for backend services.
This article explains the Chain of Responsibility pattern, compares self‑driven and handler‑driven implementations with Java code, and demonstrates how major frameworks such as Spring Interceptor, Servlet Filter, Dubbo, and Sentinel realize the pattern, followed by practical usage scenarios.
This guide walks you through preparing a Dubbo test environment, creating mock providers, writing JUnit 5 test cases, configuring consumers, sending requests, validating responses, handling errors, and optionally adding performance testing, monitoring, and CI automation to ensure robust backend services.
When Dubbo RPC uses Protostuff serialization, DTO fields declared with ambiguous types that contain non‑standard collections such as subList results can trigger ClassNotFound or null errors during deserialization, so converting these to regular JDK collections (or switching to a more tolerant format like Hessian2/JSON) restores stability.
This article explains the concept of Service Provider Interface (SPI), demonstrates how Java's ServiceLoader, Spring's SpringFactoriesLoader, and Dubbo's ExtensionLoader implement SPI, compares their configurations and capabilities, and discusses advanced features such as adaptive extensions, IOC/AOP integration, wrappers, and auto‑activation.
The article explains the drawbacks of token pass‑through in microservice authentication, advocates explicit parameter passing, outlines unified gateway authentication with Feign or Dubbo, explores Kubernetes‑integrated deployment options, and concludes with a promotional invitation to a technical community.
This article examines the pitfalls of token pass‑through authentication in microservices, proposes explicit userId parameter passing, compares unified auth approaches using Spring Cloud Gateway with Feign or Dubbo, and explores non‑unified alternatives, including K8s Ingress integration and practical code examples.
This article explains Dubbo's role as a high‑performance RPC framework, details its ten‑layer architecture, and walks through the eleven‑step call process, providing clear diagrams and concise descriptions for developers building distributed systems.
The article compares several microservice internal‑call strategies—including token‑pass-through, Feign, Dubbo, Spring Boot Web with Dubbo, and K8s‑integrated approaches—explaining their advantages, drawbacks, and how to implement unified authentication while keeping APIs stateless and reusable.
The article discusses why forwarding raw tokens between microservices is discouraged, recommends passing explicit user identifiers after gateway authentication, compares Feign and Dubbo internal‑call approaches, explores gateway‑less designs, and shows how to integrate authentication with Kubernetes deployments.
This article details how to transition a Dubbo 3.0 microservice architecture to an Istio service mesh on Kubernetes, covering code modifications, deployment configurations, sidecar injection, traffic management policies, and verification steps with practical YAML examples and log analysis.
The article explains that Dubbo’s zero‑capacity SynchronousQueue causes a thread‑pool “EXHAUSTED” error when incoming requests outpace consumption, often triggered by slow DB queries, lock contention, or network jitter, and that JVM stop‑the‑world pauses fill the OS TCP receive buffer, creating a post‑pause traffic burst that overwhelms the pool, with diagnostics using safepoint statistics.
This article provides a comprehensive overview of Dubbo, a Java RPC framework, covering its necessity, core components, implementation principles, architecture layers, supported protocols, registry options, load‑balancing strategies, and typical application scenarios for building scalable micro‑services.
The article explains why passing tokens between microservices is a poor design, proposes exposing explicit userId parameters, describes unified authentication via an API gateway with Feign, Dubbo or Spring Boot Web implementations, compares their pros and cons, and shows how to integrate these patterns with Kubernetes and internal API path rules.
Explore a comprehensive guide to popular microservice frameworks—including Spring Cloud, Dubbo, Spring Cloud Alibaba, and Service Mesh—detailing core components such as Eureka, Zuul, Hystrix, Ribbon, Feign, Sentinel, Nacos, RocketMQ, and Seata, and illustrating their architectures with clear diagrams.
The article critiques token pass‑through for microservice authentication, explains why internal APIs should stay stateless, and presents unified authorization patterns using Spring Cloud Gateway with Feign, Dubbo, or a gateway‑less design, plus Kubernetes integration and trade‑offs.
This article provides a comprehensive overview of Dubbo's six built‑in load‑balancing strategies—Random, Round Robin, Least Connection, Consistent Hash, Weighted Random, and Weighted Round Robin—explaining their principles, suitable scenarios, and exact XML configuration examples for Java RPC services.
This tutorial walks through creating a complete Spring Boot 2.7 project that integrates Apache Dubbo for RPC, covering environment setup, Maven dependency management, interface definition, provider and consumer implementations, configuration with Nacos, and testing the end‑to‑end service.
This article analyzes the CPU‑heavy routing and load‑balancing modules of Dubbo in a large‑scale microservice cluster, identifies O(n) traversal as the root cause, and presents a step‑by‑step redesign—including disabling unused routers, caching route results with epoch validation, BitMap‑based intersection, and grouped routing—that reduces CPU usage by up to 27% and doubles TPS when provider instances exceed 2,000.
The paper presents a centralized online batch‑processing framework for large‑scale promotion systems, where applications integrate via an SDK, a task‑center schedules and dispatches sub‑tasks through RocketMQ to Dubbo‑enabled containers, employing MapReduce‑style splitting, Guava rate‑limiting, heartbeat health checks, and has successfully handled over 1.3 million tasks during Double‑11.
This article provides an in‑depth overview of Spring Validation, covering standard Bean Validation 2.0 annotations, Hibernate extensions, the differences between @Valid and @Validated, practical usage in controllers, programmatic validation, Dubbo integration, group validation, and how to create custom validation annotations with full code examples.
Although many developers avoid using thread pools in business code, this article explains how thread pools already exist in web containers and RPC frameworks, why inserting custom pools can backfire, and when proper tuning or message queues are the better solution for improving throughput.
The article reports on Zhengcai Cloud's successful migration to Dubbo3.1.8, detailing the motivations, scale of the system, upgrade process, and the resulting performance and stability improvements for its massive procurement platform.
This article details how Vivo identified heavy CPU usage in Dubbo's routing and load‑balancing modules, applied asynchronous processing, cache‑based routing, disabled unused routers, and introduced grouping strategies, resulting in over 100% TPS gains and significant CPU reductions for large service clusters.
This article explains ThreadPoolExecutor's configuration parameters, creation and execution flow, state management, graceful shutdown techniques, common pitfalls such as OOM and ThreadLocal issues, and provides monitoring alerts and sample Java code for robust thread‑pool handling.
Vivo tackled high CPU overhead in large‑scale Dubbo deployments by disabling unused routers, caching routing results with BitMap intersections and epoch validation, optimizing weight calculations, and adding a grouping router, which together delivered over 100 % TPS gains for 20 k+ providers and cut CPU usage by roughly 27 %.
The article details how a Dubbo thread‑pool exhaustion incident was traced to a deadlock in Redis Cluster pipeline usage, caused by Jedis pools lacking a borrow timeout, which let threads block indefinitely while holding cross‑node connections, and recommends configuring maxWaitMillis or enlarging the pool to prevent recurrence.
This article explains how a government procurement platform built a hybrid cloud‑native “highway” solution using Dubbo to achieve reusable, tunnel‑based data synchronization across cloud and isolated island networks, detailing the background, challenges, design choices, implementation steps, and future roadmap.
This article explains the microservice architecture style, its evolution from monoliths, the technical challenges it introduces, compares leading open‑source solutions such as Dubbo, Spring Cloud Netflix, and Spring Cloud Alibaba, and details essential components like service registries, configuration centers, API gateways, tracing, fault tolerance, and monitoring.
The article explains the Chain of Responsibility design pattern, compares its two implementation styles—chain‑driven and processor‑self‑driven—and demonstrates how open‑source frameworks such as Spring Interceptor, Servlet Filter, Dubbo, and Sentinel employ the pattern to achieve low coupling, high extensibility, and flexible request processing.
This tutorial walks through setting up Apache Dubbo3’s Triple protocol in Node.js, from installing code‑generation tools and defining a protobuf service to generating TypeScript stubs, implementing the service, launching a Fastify server, and invoking the RPC via curl or a Dubbo client.
This article details the identification, analysis, and resolution of JVM memory problems in a core music metadata service, covering GC tuning, large‑object handling, fault‑tolerance strategies, custom Dubbo codec monitoring, and non‑intrusive memory object tracking to improve performance and stability.
This article walks through the importance of rate limiting in microservice architectures, compares Dubbo, Spring Cloud, and gateway approaches, explains token‑bucket, leaky‑bucket and sliding‑window algorithms, and provides step‑by‑step AOP implementations using Guava, Sentinel, and Redis with full code samples.
To eliminate the brief latency spike that occurs when new Dubbo services start, the authors introduce a @Warmup annotation and early‑startup listeners that generate mock traffic and trigger a forced GC before publishing, cutting initial response times from seconds to tens of milliseconds and improving reliability for latency‑sensitive applications.
The article introduces Dubbo's upgraded Triple protocol—a HTTP‑based, gRPC‑compatible RPC protocol that supports both HTTP/1 and HTTP/2, streaming, and easy front‑end access, explains its design goals versus gRPC, showcases usage examples, and details multi‑language implementations and production adoption.
Aeraki Mesh 1.3.0 (code‑named Dragonboat) adds Istio 1.16.x compatibility, introduces connection multiplexing, enables MetaProtocol routing on gateways, expands Dubbo service governance options, provides Redis traffic management, and migrates official images to GitHub Packages, with a detailed changelog and configuration examples.
This article compares RPC and HTTP interfaces, detailing their architectures, popular frameworks, performance characteristics, load‑balancing, and service‑governance features, and provides practical guidance on selecting the right approach for internal high‑performance services or external cross‑platform APIs.
By refactoring Dubbo RPC interfaces to return CompletableFuture, applying thenApply/thenCombine/thenCompose patterns, isolating a custom business thread pool, and handling errors and tracing, the team achieved up to 50% latency reduction, 25% response‑time improvement, a one‑third server cut and CPU utilization rise, demonstrating substantial performance and cost benefits.
This article explains the Service Provider Interface (SPI) concept and compares the implementations in Java (ServiceLoader), Spring (SpringFactoriesLoader), and Dubbo (ExtensionLoader), covering their configuration files, core mechanisms, advantages, drawbacks, and typical usage scenarios.
This article explains the fundamental differences between RPC and HTTP services, covering OSI model layers, RPC architecture components, synchronous vs asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and when to choose each approach for enterprise applications.
This guide walks you through using the Dubbo Initializer web UI to quickly generate a ready‑to‑run Dubbo Spring Boot microservice project, covering version selection, project metadata, module structure, dependency choices, code generation, download, and a brief walkthrough of the generated source files.
This article provides a step‑by‑step guide on how to integrate Dubbo with SpringBoot to enable the gRPC protocol, covering project structure, Maven BOM dependencies, protobuf generation, service implementation, configuration details, and the differences between Dubbo‑enabled gRPC and native gRPC.
This article explains the fundamental distinctions between RPC and HTTP services by reviewing the OSI network layers, RPC architecture components, synchronous versus asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and the typical use cases of each approach.
This article explains the principles and differences of the SPI mechanisms in Java, Spring, and Dubbo, covering ServiceLoader, SpringFactoriesLoader, and Dubbo's ExtensionLoader, with detailed demos, core implementation details, advantages, drawbacks, and typical usage scenarios for each framework.
This article details the design and implementation of a transparent cross‑network data‑transfer system built on Dubbo, covering its evolution from early one‑way solutions to a highway architecture, the technical challenges encountered, the applied fixes and community contributions, and the roadmap for future stability, extensibility, and multi‑protocol support.
The article presents a detailed guide on designing and implementing fine-grained permission control for microservices using Apache Shiro, Spring Boot, Dubbo, and Redis to share session data across services, including code examples, configuration steps, and testing of role‑based access.
This article provides a detailed walkthrough of Dubbo’s remoting module, covering its overall architecture, the dubbo‑remoting‑api abstraction, key packages such as buffer, exchange and transport, core interfaces like Endpoint and Channel, the role of ChannelHandler, the Transporter facade, and a concise summary of how these components interact to enable flexible, pluggable network communication.