Skip to content
CAI
Software that uses CAICheck a score

apache/dubbo

38.3

Weak · 10 November 2026

266.1k

lines of production code

Java

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Alibaba Dubbo registry compatibility shims

New compatibility classes (AbstractRegistry, AbstractRegistryFactory, FailbackRegistry) are added to the com.alibaba.dubbo.registry.support package to bridge legacy Alibaba Dubbo registry APIs with the Apache Dubbo implementation. These classes delegate operations to Apache's internal registry structures while wrapping URL and listener objects using DelegateURL and compatible listener adapters, allowing applications using the old com.alibaba.dubbo package to function with the new Apache Dubbo runtime.

dubbo-compatible/src/main/java/com/alibaba/dubbo/registry/support · high confidence

Add Apache Commons Logging (JCL) adapter for logging

Users can now route Dubbo's internal logs through Apache Commons Logging by using the JCL logger adapter. This change introduces the JclLoggerAdapter and JclLogger classes, which bridge Dubbo's logging interface to the Commons Logging API, allowing applications that rely on Commons Logging to capture Dubbo's trace, debug, info, warn, and error messages.

dubbo-common/src/main/java/org/apache/dubbo/common/logger/jcl · high confidence

Add Apollo Config Center integration

Users can now use Apollo as a dynamic configuration center for Dubbo. This change introduces the ApolloDynamicConfiguration implementation, which supports fetching configuration properties and governance rules from Apollo namespaces, listening for configuration changes, and falling back to local cache or system properties if the connection fails. A factory registration is included to enable automatic discovery, and mock tests are provided to verify the integration.

dubbo-configcenter/dubbo-configcenter-apollo · high confidence

Add CompositeDynamicConfiguration for multi-config-center support

A new CompositeDynamicConfiguration wrapper has been introduced in the config-center module, allowing users to register multiple DynamicConfiguration instances. This enables a fallback mechanism where configuration lookups iterate through registered centers until a non-null value is found, while publish operations attempt to write to all registered centers.

dubbo-common/src/main/java/org/apache/dubbo/common/config/configcenter/wrapper · high confidence

Add Dubbo Invocation Profiler

Introduces a new invocation profiler in dubbo-common that allows users to track and visualize the performance of Dubbo calls. The new Profiler class provides APIs to start, enter, and release profiling entries, supporting nested calls with a configurable maximum entry limit (1000). It includes a ProfilerSwitch to enable or disable simple and detail profiling modes, and generates detailed textual reports showing offset, usage time, and percentage breakdown for each entry.

dubbo-common/src/main/java/org/apache/dubbo/common/profiler · high confidence

Add Dubbo Spring Boot consumer demo application

A new consumer demo application has been added to the dubbo-demo-spring-boot-consumer module. This includes the main ConsumerApplication class that demonstrates calling a remote DemoService via @DubboReference, supporting both synchronous and asynchronous invocation patterns. The demo is configured via application.yml to connect to a local ZooKeeper registry and uses Log4j2 for logging with trace/span context support.

dubbo-demo/dubbo-demo-spring-boot/dubbo-demo-spring-boot-consumer · high confidence

Add JDK and Log4j logger implementations

The dubbo-common module now includes new logger adapters and implementations for the JDK logging framework (java.util.logging) and Log4j 1.x. This adds the JdkLogger and JdkLoggerAdapter classes, which bridge Dubbo's logging API to JDK's built-in logger and support configuration via a logging.properties file, as well as the Log4jLogger and Log4jLoggerAdapter classes, which integrate with Log4j 1.x, including support for fully qualified class names (FQCN) in log calls and automatic detection of file appenders. Users with these logging libraries on their classpath can now utilize them for Dubbo's internal logging.

dubbo-common/src/main/java/org/apache/dubbo/common/logger/log4j · high confidence

Add Log4j2 logging adapter

Users can now use Apache Log4j2 as the logging implementation for Dubbo. This change introduces the Log4j2Logger and Log4j2LoggerAdapter classes, which bridge Dubbo's internal logging API to Log4j2, allowing applications to route Dubbo logs through a Log4j2 configuration.

dubbo-common/src/main/java/org/apache/dubbo/common/logger/log4j2 · high confidence

Add Mutiny reactive support for Dubbo Triple RPC calls

This change introduces a new plugin in dubbo-plugin/dubbo-mutiny that enables developers to use SmallRye Mutiny reactive types (Uni and Multi) for Dubbo Triple RPC stubs. It adds publisher and subscriber adapters to bridge the Java Flow API with Mutiny, and provides client/server call handlers that map unary and streaming RPC patterns (one-to-one, one-to-many, many-to-one, many-to-many) to Mutiny streams. This allows users to write non-blocking, reactive service implementations and invocations using Mutiny operators instead of traditional callbacks or futures.

dubbo-plugin/dubbo-mutiny · high confidence

Add OAuth 2.0 serialization support for Spring Security 6

The new dubbo-spring6-security plugin introduces Jackson serialization support for Spring Security OAuth 2.0 types, enabling correct handling of objects like BearerTokenAuthentication, RegisteredClient, and OAuth2AuthenticatedPrincipal during Dubbo RPC calls. This is implemented via the OAuth2SecurityModule and OAuth2ObjectMapperCodecCustomer, which register custom mixins to ensure these security objects are properly serialized and deserialized.

dubbo-plugin/dubbo-spring6-security · high confidence

Add SimpleDataStore implementation for component data management

Introduces the SimpleDataStore class, a new implementation of the DataStore interface that provides a thread-safe mechanism for storing and retrieving component-specific data using nested ConcurrentHashMaps. This component supports adding listeners to receive updates when data is added or removed, ensuring that dependent systems are notified of changes in real-time.

dubbo-common/src/main/java/org/apache/dubbo/common/store/support · high confidence

Add Spring Boot provider demo with Triple protocol and observability

A new Spring Boot-based provider demo has been added to the dubbo-demo module. It implements the DemoService using the Triple (tri) protocol and registers with Zookeeper for service discovery, configuration, and metadata reporting. The demo includes built-in observability features, exposing metrics via Prometheus and configuring log4j2 for structured logging with trace and span context support.

dubbo-demo/dubbo-demo-spring-boot/dubbo-demo-spring-boot-provider · high confidence

Add Spring and DataSource status checkers

New status checkers have been added to the Spring configuration module to allow runtime health verification of the application context and database connections. The SpringStatusChecker now reports whether the Spring ApplicationContext is running and lists its configuration locations, while the DataSourceStatusChecker validates connectivity to all registered DataSource beans and reports their JDBC URLs and database product versions.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/status · high confidence

Add Triple protocol support over WebSocket

This change introduces the core implementation for running the Triple protocol over WebSocket connections. It adds a servlet filter to intercept WebSocket upgrade requests and register the \TripleEndpoint\, which manages the session lifecycle. The implementation includes handlers for both binary and text messages, converting incoming WebSocket frames into HTTP/2 input messages for the Triple protocol stack, and mapping outgoing HTTP/2 output messages back to WebSocket binary frames.

dubbo-plugin/dubbo-triple-websocket · high confidence

Add deprecated alibaba-dubbo RPC compatibility wrappers

The dubbo-compatible module now provides a set of deprecated wrapper interfaces and classes in the com.alibaba.dubbo.rpc package (including Exporter, Filter, Invocation, Invoker, Protocol, ProxyFactory, Result, RpcContext, RpcException, RpcInvocation, RpcResult, and GenericService). These classes delegate to the corresponding org.apache.dubbo.rpc implementations, enabling legacy Alibaba Dubbo code to interoperate with the Apache Dubbo runtime without requiring immediate refactoring.

dubbo-compatible/src/main/java/com/alibaba/dubbo/rpc · high confidence

Add deprecated compatibility annotations for migration to Apache Dubbo

The \dubbo-compatible\ module now includes \@Reference\ and \@Service\ annotations under the \com.alibaba.dubbo.config.annotation\ package. These annotations serve as deprecated drop-in replacements for the original Alibaba Dubbo annotations, allowing existing applications to continue functioning while encouraging migration to the new \@DubboReference\ and \@DubboService\ annotations provided by the Apache Dubbo core.

dubbo-compatible/src/main/java/com/alibaba/dubbo/config/annotation · high confidence

Add deprecated compatibility wrappers for cluster interfaces

The \dubbo-compatible\ module now includes deprecated wrapper interfaces for the cluster layer (Cluster, Configurator, Directory, LoadBalance, Merger, Router, RouterFactory, RuleConverter) in the \com.alibaba.dubbo.rpc.cluster\ package. These interfaces extend the new \org.apache.dubbo\ equivalents and provide default implementations that automatically translate between the legacy \com.alibaba.dubbo\ types and the new Apache types using delegation wrappers (e.g., \DelegateURL\, \CompatibleInvoker\). This allows existing applications relying on the old Alibaba package structure to continue functioning during migration.

dubbo-compatible/src/main/java/com/alibaba/dubbo/rpc/cluster · high confidence

Add deprecated compatibility wrappers for legacy config classes

The dubbo-compatible module now includes deprecated wrapper classes in the com.alibaba.dubbo.config package (ApplicationConfig, ArgumentConfig, ConsumerConfig, MethodConfig, ModuleConfig, MonitorConfig, ProtocolConfig, ProviderConfig, ReferenceConfig, RegistryConfig, and ServiceConfig) that extend their org.apache.dubbo counterparts. These wrappers preserve legacy setter signatures (such as accepting com.alibaba.dubbo.config types or Boolean mock parameters) and delegate to the new Apache implementations, allowing existing applications using the old Alibaba package structure to continue functioning without code changes.

dubbo-compatible/src/main/java/com/alibaba/dubbo/config · high confidence

Add error code metrics and refactor metrics collection infrastructure

The default metrics module now exposes error code metrics by listening to log events from FailsafeErrorTypeAwareLogger and incrementing counts in a new ErrorCodeSampler. The underlying metrics collection infrastructure has been refactored with new sampler classes (SimpleMetricsCountSampler and MetricsNameCountSampler) to manage metric counters more efficiently, and the DefaultSubDispatcher has been updated to integrate these changes while maintaining existing request, success, and error metric tracking.

dubbo-metrics-default · high confidence

Add file-system based dynamic configuration support

Users can now store and watch configuration files directly on the local file system. This change introduces the \FileSystemDynamicConfiguration\ implementation and its factory, registered via the \file\ protocol in the SPI configuration. The component monitors a configurable directory (defaulting to \\~/.dubbo/config-center\) for file changes, allowing applications to load and receive real-time updates for configuration properties stored as files, with support for custom directories, encodings, and listener registration.

dubbo-configcenter/dubbo-configcenter-file · high confidence

Add mock invoker selection router

Introduces a new router implementation (MockInvokersSelector) and its factory (MockStateRouterFactory) in the cluster router mock package. This router filters the available service invokers based on the mock configuration: when a request requires a mock response, only invokers using the MOCK protocol are selected; otherwise, standard invokers are used. This enables users to configure services to return mock data during testing or failure scenarios by ensuring the routing logic respects the mock protocol setting.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/mock · high confidence

Add script-based app-level routing with dynamic config support

This change introduces a new script router implementation for Dubbo cluster routing, allowing users to define custom routing logic via YAML-configured scripts. The new \AppScriptRouterFactory\ and \AppScriptStateRouter\ classes enable dynamic rule updates through configuration center listeners, supporting features like script type specification, force routing, and runtime execution. The \ScriptRule\ model provides YAML parsing for script definitions, with validation and error handling for malformed rules. This enables more flexible, programmatic control over service routing beyond traditional tag or label-based approaches.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/script/config · high confidence

Added AOT detection utility for native image support

Introduced the AotWithSpringDetector class to determine whether the application is running in a native image or with Spring AOT processing enabled. This utility checks system properties and native image status to allow Dubbo to adapt its behavior when running under GraalVM native compilation or Spring Boot AOT optimization, ensuring compatibility with native runtime environments.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/aot · high confidence

Added Dubbo XML schema compatibility definitions

A new \dubbo.xsd\ file has been added to the \META-INF/compat\ directory, providing the XML schema definitions for Dubbo service configurations. This update enables IDE support and validation for Dubbo-specific Spring XML namespaces, ensuring that configuration elements like services, references, and registries are correctly structured and recognized by development tools.

dubbo-config/dubbo-config-spring/src/main/resources/META-INF/compat · high confidence

Added FilterAdapter to bridge Servlet Filters with the REST protocol

The dubbo-triple-servlet module now includes a new FilterAdapter class that enables standard Servlet Filters to be used within the Triple REST protocol. This adapter implements the RestExtensionAdapter interface, allowing existing Servlet filters to be automatically detected, initialized, and executed as part of the REST filter chain, thereby integrating legacy servlet-based filtering logic into the modern REST request processing pipeline.

dubbo-triple-servlet · high confidence

Added HashedWheelTimer for approximate I/O timeout scheduling

The \dubbo-common\ module now includes a \HashedWheelTimer\ implementation for scheduling one-time tasks with approximate timing, optimized for I/O timeouts. This new component introduces the \Timer\, \TimerTask\, and \Timeout\ interfaces along with the \HashedWheelTimer\ class, allowing applications to schedule background tasks with configurable tick durations and wheel sizes while managing instance limits to prevent resource exhaustion.

dubbo-common/src/main/java/org/apache/dubbo/common/timer · high confidence

Added RpcUtils compatibility wrapper for legacy Dubbo clients

A new RpcUtils class has been added to the dubbo-compatible module to provide backward compatibility for applications still using the com.alibaba.dubbo package. This utility class acts as a thin wrapper that delegates all method calls to the corresponding implementations in the org.apache.dubbo.rpc.support package, ensuring that legacy code relying on these static utility methods continues to function without modification.

dubbo-compatible/src/main/java/com/alibaba/dubbo/rpc/support · high confidence

Added SerializingExecutor for ordered task execution

A new SerializingExecutor class has been introduced in the common threadpool module to ensure that submitted Runnable tasks are executed sequentially and in order using a provided underlying Executor. This component manages a concurrent queue of tasks and handles thread-local state restoration during execution, while also gracefully ignoring RejectedExecutionExceptions if the underlying executor is shut down.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool/serial · high confidence

Added Spring 6 AOT support for Dubbo configuration

This change introduces native Spring 6 Ahead-Of-Time (AOT) processing support for Dubbo's \@DubboReference\ and \@DubboService\ annotations. It adds new \BeanRegistrationAotProcessor\ implementations (\ReferenceAnnotationWithAotBeanPostProcessor\ and \ServiceAnnotationWithAotPostProcessor\) that generate the necessary runtime hints for reflection and serialization during the build phase. This ensures that Dubbo reference proxies and service beans are correctly registered and serialized in GraalVM native images, resolving previous issues where these components were not automatically loaded or configured for native execution.

dubbo-config/dubbo-config-spring6 · high confidence

Added Spring Boot 1.x compatibility layer and observability infrastructure

This change introduces a new \dubbo-spring-boot-compatible\ module to support Spring Boot 1.x, providing auto-configuration for relaxed property binding (via \RelaxedDubboConfigBinder\) and actuator endpoints (including \DubboEndpoint\ and \DubboMvcEndpoint\ for exposing configuration, services, and shutdown status). It also adds observability support in the main autoconfigure module, including an \ObservationRegistryPostProcessor\ for Micrometer integration and new \ZipkinRestTemplateSender\ and \ZipkinWebClientSender\ implementations for sending distributed traces to Zipkin.

(repo-wide) · high confidence

Added deprecated AbstractLoadBalance for Alibaba Dubbo compatibility

A new AbstractLoadBalance class has been added to the dubbo-compatible module to support legacy Alibaba Dubbo applications. This class implements the LoadBalance interface and provides a default select logic that delegates to an abstract doSelect method, along with utility methods for calculating weighted load balancing including warmup support. The class is marked as deprecated, indicating it is provided for backward compatibility rather than as a primary implementation.

dubbo-compatible/src/main/java/com/alibaba/dubbo/rpc/cluster/loadbalance · high confidence

Added deprecated compatibility interfaces for telnet and validation

The dubbo-compatible module now includes deprecated interface wrappers in the com.alibaba.dubbo package that extend the corresponding org.apache.dubbo interfaces. Specifically, TelnetHandler, Validation, and Validator are provided as backward-compatible shims, allowing existing applications using the old Alibaba package names to continue functioning while encouraging migration to the new Apache package structure.

dubbo-compatible/src/main/java/com/alibaba/dubbo/remoting/telnet, dubbo-compatible/src/main/java/com/alibaba/dubbo/validation · high confidence

Added native configuration generation support in dubbo-native

The dubbo-native module, now located under dubbo-plugin, includes a new BasicJsonWriter utility. This component facilitates the translation of runtime hints into native configuration files, enabling better support for native image compilation by generating the necessary JSON configuration structures.

dubbo-native · high confidence

Added override and absent configurators for URL parameter management

This change introduces the \OverrideConfigurator\ and \AbsentConfigurator\ classes, along with their respective factories, within the cluster configuration subsystem. The \OverrideConfigurator\ allows configuration rules to explicitly overwrite existing URL parameters, while the \AbsentConfigurator\ adds parameters only if they are not already present, giving users finer control over how configuration overrides are applied to service URLs.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/configurator/override · high confidence

Added system load and memory status checkers

New status checkers have been added to the common module to expose system health metrics. The LoadStatusChecker reports the system load average (falling back to CPU usage on platforms like Windows where load average is unavailable) and compares it against the number of available processors to determine an OK or WARN state. The MemoryStatusChecker monitors JVM heap usage, reporting total, used, and free memory in megabytes, and triggers a WARN status if spare memory drops below 2 MB. These components integrate with the existing StatusChecker extension mechanism to provide runtime visibility into host resource consumption.

dubbo-common/src/main/java/org/apache/dubbo/common/status/support · high confidence

Alibaba Dubbo compatibility layer added to Apache Dubbo

A new compatibility module has been introduced in the \dubbo-compatible\ package to allow applications using the legacy \com.alibaba.dubbo\ API to continue functioning with the Apache Dubbo runtime. This layer provides deprecated wrapper classes and interfaces—such as \URL\, \DelegateURL\, \Constants\, and various SPI extensions—that bridge the old Alibaba package names to the new \org.apache.dubbo\ implementations, ensuring backward compatibility for existing codebases.

dubbo-compatible/src/main/java/com/alibaba/dubbo/common · high confidence

Automatic ID assignment for Dubbo config beans

Dubbo config beans now automatically receive their Spring bean name as their ID if no ID is explicitly configured. This is handled by the new DubboConfigDefaultPropertyValueBeanPostProcessor, which sets the ID during bean initialization to ensure every config bean has a unique identifier, resolving issues where beans could not be found during ReferenceBean initialization.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/beans/factory/config · high confidence

Automatic propagation of Spring Security context in Dubbo RPC calls

A new filter, ContextHolderAuthenticationResolverFilter, has been added to the Dubbo Spring Security plugin. This filter automatically deserializes authentication data attached to RPC invocations and sets it in the Spring Security SecurityContextHolder before the request is processed, then clears the context in a finally block to prevent thread pollution. This allows services to access the caller's security context seamlessly without manual handling.

dubbo-spring-security · high confidence

Decoupled Netty4 client connection management with unified address resolution

The Netty4 remoting module introduces a new connection client architecture that decouples the Netty transport layer from the Dubbo connection lifecycle. A new \AbstractNettyConnectionClient\ and \NettyConnectionClient\ handle connection state, reconnection, and initialization promises, replacing the previous direct client implementation. To support this, a new \ChannelAddressAccessor\ SPI and \AddressUtils\ utility were added, allowing custom protocols to provide local and remote address information for channels, which is now used consistently in \NettyChannel\ and handler logging. This change improves connection stability and provides a cleaner separation of concerns for protocol-specific channel handling.

dubbo-remoting/dubbo-remoting-netty4 · high confidence

Dynamic certificate management for Dubbo security

This change introduces a new dynamic certificate management system within the dubbo-security plugin. It adds a \DubboCertManager\ that connects to a remote Certificate Authority via gRPC to generate, retrieve, and automatically refresh SSL certificates (including private keys, certificates, and trust chains) on a configurable interval. The system integrates with the application lifecycle through a \CertDeployerListener\ that triggers certificate connection on startup and disconnection on shutdown, and exposes the generated credentials via a \DubboCertProvider\ implementation for both provider and consumer SSL configurations. It also includes a \CertScopeModelInitializer\ to conditionally register the manager based on the availability of gRPC and Bouncy Castle dependencies.

dubbo-plugin/dubbo-security · high confidence

The \dubbo-common\ logger support now includes \FailsafeLogger\ and \FailsafeErrorTypeAwareLogger\ wrappers that prevent logging exceptions from crashing the application. Error logs can now include an error code (format X-X) which automatically appends a link to the Dubbo FAQ for troubleshooting instructions. Additionally, logging can be globally disabled via a new \setDisabled\ option, and listeners can be registered to receive log events.

dubbo-common/src/main/java/org/apache/dubbo/common/logger/support · high confidence

HTTP/3 (QUIC) transport support for Dubbo Triple

This change introduces the \dubbo-remoting-http3\ module, enabling Dubbo Triple services to communicate over HTTP/3 using the QUIC protocol. It adds server and client implementations (\NettyHttp3Server\, \NettyHttp3ConnectionClient\) that bind to UDP and configure Netty's QUIC codec, including support for custom SSL/TLS certificates via \Http3SslContexts\ and configurable QUIC parameters (such as stream limits and congestion control algorithms) through \Http3Config\. The module also provides protocol selection via \NettyHttp3ProtocolSelectorHandler\ to route requests to the appropriate transport listener based on content type, and ensures correct address resolution for loopback interfaces to prevent peer-address mismatches on multi-homed hosts.

dubbo-remoting/dubbo-remoting-http3 · high confidence

HTTP/3 stream channel implementation for Dubbo Triple

The dubbo-remoting-http3 module now includes a new Netty-based HTTP/3 stream channel implementation. This change introduces the NettyHttp3StreamChannel class, which wraps a QUIC stream channel to handle HTTP/3 communication, enabling support for the Dubbo Triple protocol over HTTP/3. The implementation manages stream lifecycle, header writing, message output, and address resolution, integrating with existing HTTP/1.2 and HTTP/2 abstractions to provide a consistent interface for HTTP/3 traffic.

dubbo-remoting-http3 · high confidence

Hessian2 serialization output implementation added

The Hessian2 serialization module now includes a new \Hessian2ObjectOutput\ class that implements the \ObjectOutput\ and \Cleanable\ interfaces. This class wraps the underlying \Hessian2Output\ stream and delegates primitive type writes (booleans, bytes, shorts, ints, longs, floats, doubles, strings, and byte arrays) to it. It supports initialization via a standard \OutputStream\ or by explicitly providing a \Hessian2FactoryManager\ for serializer factory configuration, and includes a \cleanup\ method to reset the underlying output stream for reuse.

dubbo-serialization-hessian2 · high confidence

Initial project scaffolding and governance configuration

The repository has been initialized with essential governance and development infrastructure files. This includes the Apache License 2.0, a comprehensive list of Maven modules in .artifacts, and configuration for GitHub workflows (.asf.yaml) enabling wiki, issues, projects, and discussions. Developer experience is supported by .editorconfig for code formatting, .gitignore for build artifacts, .gitattributes for line-ending normalization, and a license compliance configuration (.licenserc.yaml). Additionally, a threat model (AGENTS.md) is provided to guide security reporting, and CI/CD pipelines are defined via Jenkinsfiles for snapshot deployment and SonarCloud quality checks.

(repo-wide) · high confidence

Introduce AbstractDirectory and StaticDirectory for router chain integration

The cluster directory module now includes AbstractDirectory and StaticDirectory implementations that integrate with the RouterChain architecture. AbstractDirectory manages the lifecycle of invokers, handles connectivity checks, and applies routing logic via a RouterChain, while StaticDirectory provides a concrete directory implementation for static invoker lists that supports router-based filtering. This change enables dynamic routing and service discovery features within the cluster layer.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/directory · high confidence

Introduce Adaptive and ShortestResponse load balancing strategies

The load balancing module in dubbo-cluster now includes two new strategies: AdaptiveLoadBalance, which uses a Power-of-Two-Choices algorithm to select the invoker with the lowest current load based on metrics, and ShortestResponseLoadBalance, which estimates response times using a sliding window to route requests to the fastest available invokers. These additions expand the available routing options alongside the existing Random, RoundRobin, LeastActive, and ConsistentHash strategies.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/loadbalance · high confidence

Introduce Curator 5 Zookeeper client implementation

This change adds a new Zookeeper client implementation based on the Curator 5 library, providing the core interfaces (ZookeeperClient, ChildListener, DataListener, StateListener, EventType) and the AbstractZookeeperClient base class. It includes a ZookeeperClientManager for connection pooling and caching, and registers a ReflectionTypeDescriberRegistrar to support native image compilation by declaring required reflection access for Curator classes. Tests are added to verify client creation, connection state handling, and backup address resolution.

dubbo-remoting-zookeeper-curator5, dubbo-remoting/dubbo-remoting-zookeeper-curator5 · high confidence

Introduce DataStore SPI for application-scoped data management

A new application-scoped SPI interface, DataStore, has been added to the common store module, providing methods to get, put, and remove key-value data associated with component names. This interface also supports a DataStoreUpdateListener, allowing components to register for notifications when data changes, enabling reactive updates across the application context.

dubbo-common/src/main/java/org/apache/dubbo/common/store · high confidence

Introduce Dubbo MCP integration plugin

The new dubbo-mcp plugin enables Dubbo services to be exposed as tools to AI models via the Model Context Protocol (MCP). It provides annotations (@McpTool, @McpToolParam) to mark methods as tools, a service filter for include/exclude patterns, and transport providers for both SSE and streamable protocols. The plugin automatically registers Dubbo services as MCP tools on application startup and dynamically handles service export/unexport events.

dubbo-plugin/dubbo-mcp · high confidence

Introduce Fastjson2 serialization support for Dubbo

This change adds a new Fastjson2-based serialization implementation to Dubbo, allowing users to select 'fastjson2' as a protocol serialization format (e.g., via \<dubbo:protocol serialization="fastjson2" /\>). The module provides the core serialization/deserialization logic (FastJson2ObjectInput/ObjectOutput), a security manager to enforce serialization allowlists and strict mode checks, and a creator manager to handle object instantiation. It also includes the necessary SPI registrations and unit tests to validate the new serialization behavior.

dubbo-serialization/dubbo-serialization-fastjson2 · high confidence

Introduce GovernanceRuleRepository for dynamic service governance rules

A new SPI interface GovernanceRuleRepository and its default implementation have been added to the cluster governance package, enabling Dubbo to fetch and listen for dynamic configuration rules (such as routing or load balancing rules) from a configuration center. This change allows governance rules to be updated at runtime without restarting services, with the default implementation delegating to the module's dynamic configuration environment.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/governance · high confidence

Introduce Nacos as a Metadata Report implementation

This change adds a new metadata report implementation for Nacos, allowing Dubbo to store and retrieve service metadata using a Nacos config server. The module introduces \NacosMetadataReport\ to handle metadata operations, \NacosConfigServiceWrapper\ to abstract Nacos client interactions (including symbol handling for data IDs and groups), and \NacosMetadataReportFactory\ to instantiate the report. It also includes a retry mechanism for connecting to the Nacos server and a test suite with mocks to verify connection resilience.

dubbo-metadata/dubbo-metadata-report-nacos · high confidence

Introduce Netty 3.x transport implementation

This change adds the Netty 3.x-based transport implementation to the Dubbo remoting module. It introduces core classes such as NettyClient, NettyServer, NettyHandler, and NettyCodecAdapter to handle network connections, message encoding/decoding, and channel lifecycle events using the Netty 3.x API. The implementation is registered via SPI files (Transporter and PortUnificationTransporter) to enable the 'netty3' transport protocol. Additionally, it includes a NettyBackedChannelBuffer wrapper to adapt Netty 3.x buffers to Dubbo's internal buffer abstraction, and a NettyHelper to configure Netty's logging to use Dubbo's logger.

dubbo-remoting/dubbo-remoting-netty · high confidence

Introduce Prometheus metrics reporting with QoS command support

This change adds the Prometheus metrics reporter implementation to the Dubbo metrics subsystem. It introduces the \PrometheusMetricsReporter\ and its factory (\PrometheusMetricsReporterFactory\), which automatically falls back to a no-operation reporter if Micrometer dependencies are missing. A new QoS command (\metrics\) is registered via \PrometheusMetricsReporterCmd\, allowing users to retrieve metrics data through the existing QoS port. The module also includes a \NopPrometheusMetricsReporter\ for graceful degradation and corresponding unit tests to verify JVM metrics, exporter functionality, and thread pool metrics.

dubbo-metrics/dubbo-metrics-prometheus · high confidence

Introduce SLF4J-based logging implementation

Added Slf4jLogger and Slf4jLoggerAdapter to enable SLF4J as a logging backend for Dubbo. The Slf4jLoggerAdapter creates logger instances that delegate to SLF4J, supporting both standard and location-aware logging with formatted messages, while the Slf4jLogger handles the actual logging calls via SLF4J's API.

dubbo-common/src/main/java/org/apache/dubbo/common/logger/slf4j · high confidence

Introduce Script-based State Router for dynamic routing rules

Users can now define custom routing logic using JavaScript scripts via the new ScriptStateRouter and ScriptStateRouterFactory. This feature allows routing decisions to be driven by evaluable script rules (configured via the 'rule' and 'type' URL parameters) rather than static configuration, enabling more flexible, dynamic control over service invocations at the cluster level.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/script · high confidence

Introduce Triple protocol exception handling and HTTP/3 support infrastructure

The \dubbo-rpc-triple\ module now includes new classes to standardize error reporting and transport capabilities. \TriRpcStatus\ and \StatusRpcException\ provide a structured way to map Dubbo RPC errors to gRPC-compatible status codes, ensuring consistent error details are returned to clients. Additionally, \Http3Exchanger\ adds the necessary server and client binding logic to enable HTTP/3 (QUIC) transport for the Triple protocol, while \DeadlineFuture\ and \DescriptorUtils\ enhance timeout management and method resolution. These changes improve error visibility and expand the protocol's transport options.

dubbo-rpc/dubbo-rpc-triple · high confidence

Introduce basic authentication support for Dubbo RPC calls

This change adds a new \BasicAuthenticator\ implementation to the \dubbo-auth\ plugin, enabling users to secure RPC invocations using standard HTTP Basic authentication. The authenticator extracts \username\ and \password\ parameters from the Dubbo URL, encodes them in Base64, and injects the resulting \Authorization\ header into the RPC invocation attachments. To support this, the module introduces new SPI interfaces (\Authenticator\, \AccessKeyStorage\), a default URL-based access key storage implementation, and corresponding RPC filters (\ConsumerSignFilter\, \ProviderAuthFilter\) that handle signing and verification. The change also includes unit tests for the new authenticator and utility classes, ensuring the basic auth flow is validated alongside existing access key mechanisms.

dubbo-plugin/dubbo-auth · high confidence

Introduce common deployer lifecycle and event listener APIs

The dubbo-common module now provides a standardized lifecycle management framework for Dubbo components. This change introduces the DeployState enum (PENDING, STARTING, STARTED, COMPLETION, STOPPING, STOPPED, FAILED) and the Deployer interface, which allows applications to track and control the initialization, starting, and stopping of modules and applications. It also adds the DeployListener interface and its adapters (ApplicationDeployListener, ModuleDeployListener), enabling users to register callbacks for deployment events such as onInitialize, onStarting, onStarted, onCompletion, onStopping, and onStopped. The AbstractDeployer class provides a base implementation that manages state transitions and notifies registered listeners, ensuring consistent lifecycle handling across Dubbo's scope models.

dubbo-common/src/main/java/org/apache/dubbo/common/deploy · high confidence

Introduce dubbo-filter-cache plugin with multiple cache implementations

The dubbo-filter-cache module is added to the dubbo-plugin directory, providing a CacheFilter that enables method return value caching for Dubbo services. Users can configure caching via the 'cache' attribute (e.g., \<dubbo:service cache=

dubbo-plugin/dubbo-filter-cache · high confidence

Introduce eager thread pool to create threads before queuing tasks

Added the EagerThreadPool implementation and its supporting classes (EagerThreadPoolExecutor and TaskQueue) to the common module. This new thread pool strategy changes task execution behavior: when core threads are busy, it creates new threads up to the maximum limit instead of immediately queuing tasks, which can reduce latency for bursty workloads. Users can now select this 'eager' thread pool type to optimize for scenarios where thread creation overhead is acceptable to avoid queuing delays.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool/support/eager · high confidence

Introduce extensible SSL certificate management framework

Dubbo now includes a new extensible SSL certificate management system in the common module, allowing applications to dynamically load and manage SSL/TLS credentials. This change introduces core abstractions including the \Cert\ and \ProviderCert\ data models, an \AuthPolicy\ enum for specifying authentication modes (None, Server, Client), and a \CertProvider\ SPI interface that enables pluggable certificate sources. A default implementation, \SSLConfigCertProvider\, is provided to load certificates directly from application configuration paths for both provider and consumer connections, supporting dynamic certificate updates without requiring code changes.

dubbo-common/src/main/java/org/apache/dubbo/common/ssl · high confidence

Introduce isolated thread pool management for services

The framework now supports per-service thread pool isolation via the new ExecutorRepository SPI (defaulting to 'isolation' mode). This change adds a dedicated FrameworkExecutorRepository for internal framework tasks and an IsolationExecutorRepository that assigns a separate thread pool to each service (identified by service key) rather than sharing pools by protocol or globally, improving resource isolation and preventing cross-service interference.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool/manager · high confidence

Introduce mesh-based routing rule support

This change adds a new mesh rule router implementation to the Dubbo cluster module, enabling service routing based on external mesh rules (such as Kubernetes or Service Mesh configurations). It introduces a new \MeshRuleManager\ to coordinate rule subscriptions from dynamic configuration and environment listeners, a \MeshAppRuleListener\ to parse and dispatch YAML-based routing rules, and a \MeshRuleRouter\ that applies these rules to filter and select target invokers based on virtual service and destination rules. The implementation includes caching (\MeshRuleCache\) for efficient rule evaluation and an SPI-based factory (\MeshEnvListenerFactory\) to allow environment-specific rule listening.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/mesh/route · high confidence

Introduce multiple registry and service discovery support

This change adds a new \multiple\ registry implementation that allows Dubbo applications to connect to and coordinate across multiple distinct registry centers simultaneously. The \MultipleRegistry\ component aggregates separate service and reference registries, ensuring that service registration, unregistration, and subscription notifications are propagated to all configured underlying registries. Additionally, a \MultipleServiceDiscovery\ implementation is provided to unify service instance retrieval and metadata fetching across these multiple backends, enabling users to configure multiple registry addresses via URL parameters for enhanced availability and redundancy.

dubbo-registry/dubbo-registry-multicast, dubbo-registry/dubbo-registry-multiple · high confidence

Introduce new URL component model for Dubbo 3.0

The URL representation in dubbo-common has been refactored to support the Dubbo 3.0 architecture. This change introduces a new set of classes including \ServiceAddressURL\, \DubboServiceAddressURL\, \ServiceConfigURL\, \PathURLAddress\, \URLAddress\, \URLParam\, and \URLPlainParam\. These components replace the previous monolithic URL structure with a more modular and performant design, featuring compressed parameter storage via \DynamicParamTable\ and improved memory management through caching mechanisms in \URLItemCache\. The new model supports better separation of concerns between service addresses, configuration URLs, and parameter handling, enabling features like multi-instance support and optimized hash performance.

dubbo-common/src/main/java/org/apache/dubbo/common/url/component · high confidence

Introduce new metadata definition model classes

The \dubbo-common\ module now includes four new model classes in the \org.apache.dubbo.metadata.definition.model\ package: \ServiceDefinition\, \MethodDefinition\, \TypeDefinition\, and \FullServiceDefinition\. These classes provide structured representations for service interfaces, their methods, parameter/return types (including generic types and enums), and associated annotations, forming the core data structures for service metadata definition.

dubbo-common/src/main/java/org/apache/dubbo/metadata/definition/model · high confidence

Introduce serialization API interfaces and default implementations

The dubbo-serialization-api module now exposes the core serialization contracts, including the \Serialization\, \MultipleSerialization\, \ObjectInput\, \ObjectOutput\, \DataInput\, and \DataOutput\ interfaces, along with the \Constants\ class defining serialization IDs. It provides \DefaultMultipleSerialization\ for handling multiple serialization types and \DefaultSerializationExceptionWrapper\ to wrap serialization errors. Additionally, it registers \PreferSerializationProviderImpl\ to prioritize \hessian2\ and \fastjson2\ when available, and sets \hessian2\ as the default remoting serialization via \DefaultSerializationSelector\.

dubbo-serialization/dubbo-serialization-api · high confidence

Introduce serialization preference provider and class holder utilities

The serialization module now includes a new \PreferSerializationProvider\ interface, allowing components to declare a preferred serialization format, and a \ClassHolder\ class that manages a cache of loaded classes using a thread-safe utility to avoid potential deadlocks during cache population.

dubbo-common/src/main/java/org/apache/dubbo/common/serialization · high confidence

Introduces AOT code generation for GraalVM native image support

The dubbo-native module now includes an AOT (Ahead-of-Time) generation toolchain that produces the static configuration files and pre-generated Java source code required for running Dubbo on GraalVM native images. This change adds a set of API classes in the \org.apache.dubbo.aot.api\ package—such as \TypeDescriber\, \ExecutableDescriber\, \ResourcePatternDescriber\, and \JdkProxyDescriber\—to define reflection, resource, and proxy requirements. It also introduces a \generate\ package containing \AotProcessor\, \ClassSourceScanner\, and various configuration writers that scan the classpath to automatically generate \reflect-config.json\, \resource-config.json\, \proxy-config.json\, and adaptive SPI class sources, ensuring that dynamic features like reflection and adaptive proxies work correctly in a native image environment.

dubbo-plugin/dubbo-native · high confidence

Introduces Dubbo 2.x compatibility layer and new infrastructure adapter SPI

This change adds a compatibility layer in the \dubbo-common/compact\ package (\Dubbo2ActivateUtils\, \Dubbo2CompactUtils\, \Dubbo2GenericExceptionUtils\) to support running Dubbo 3.x alongside legacy Dubbo 2.x annotations and classes (such as \com.alibaba.dubbo.config.annotation.Reference\ and \GenericException\). It also introduces a new \InfraAdapter\ SPI and an \EnvironmentAdapter\ implementation, allowing the framework to extract extra attributes and labels from the underlying infrastructure (e.g., via \DUBBO\_LABELS\ and \DUBBO\_ENV\_KEYS\ system properties). Additionally, the \constants\ package is expanded with new interfaces for cluster rules, load balance strategies, metrics, and registry types to support these new capabilities.

dubbo-common/src/main/java/org/apache/dubbo/common/constants · high confidence

Introduces Dubbo Spring Security plugin for RPC context propagation

Adds the \dubbo-spring-security\ plugin, enabling seamless integration with Spring Security by automatically serializing and propagating the \SecurityContext\ (including OAuth2 client details) across Dubbo RPC calls. The plugin registers consumer-side filters (\ContextHolderAuthenticationPrepareFilter\, \ContextHolderParametersSelectedTransferFilter\) to attach authentication data to invocations, a provider-side filter (\AuthenticationExceptionTranslatorFilter\) to translate Spring Security exceptions into Dubbo RPC exceptions, and an \ObjectMapperCodec\ to handle JSON serialization of security objects using Jackson modules. It also includes an SPI (\ObjectMapperCodecCustomer\) for customizing the codec and a scope model initializer to manage bean lifecycle.

dubbo-plugin/dubbo-spring-security · high confidence

Introduces HTTP/1.2 and HTTP/2 protocol support with payload size limits and Server-Sent Events

This change adds the core implementation classes for the HTTP/1.2 and HTTP/2 protocols in the \dubbo-remoting-http12\ module. It introduces \HttpOutputMessage\ and protocol-specific implementations (\Http1OutputMessage\, \Http2OutputMessage\) to handle response bodies, along with \Http2InputMessageFrame\ for request handling. To prevent resource exhaustion, it adds \LimitedByteArrayOutputStream\ and \LimitedByteBufOutputStream\ which enforce payload size limits by throwing \HttpOverPayloadException\ when exceeded. The update also includes \ServerSentEvent\ to support Server-Sent Events (SSE), \HttpWriteQueue\ for asynchronous write operations, and \NettyHttpHeaders\ to bridge Netty headers with the new HTTP abstraction.

dubbo-remoting-http12 · high confidence

Introduces Metadata Service V2 with file-based mapping cache and instance-level metadata filtering

This change adds a new Metadata Service V2 implementation (including the Triple protocol stub DubboMetadataServiceV2Triple and protobuf messages MetadataInfoV2 and MetadataRequest) to expose service metadata. It introduces a new file-based caching mechanism for service name mappings via AbstractCacheManager and MappingCacheManager, which persists mapping data to disk to improve resilience and reduce memory pressure. Additionally, it adds the MetadataParamsFilter SPI, allowing users to configure include/exclude policies for service and instance parameters sent to the metadata center, and introduces InstanceMetadataChangedListener to notify consumers of provider metadata updates.

dubbo-metadata/dubbo-metadata-api · high confidence

Introduces Service Discovery API and Registry Listener SPI

This change adds the core interfaces and implementations for Dubbo's new Service Discovery model within the registry-api module. It introduces the \RegistryServiceListener\ SPI, allowing users to register callbacks for registration, unregistration, subscription, and unsubscription events, and wires this into the \ListenerRegistryWrapper\ via the \RegistryFactoryWrapper\. Additionally, it provides the foundational \ServiceDiscovery\ abstraction (\AbstractServiceDiscovery\, \AbstractServiceDiscoveryFactory\) and \DefaultServiceInstance\ to support instance-based service registration and discovery, alongside new constants and AOT reflection support for native image compatibility.

dubbo-registry/dubbo-registry-api · high confidence

Introduces a new HTTP/1.2 remoting abstraction layer

This change adds a new \dubbo-remoting-http12\ module that provides a unified, protocol-agnostic abstraction for HTTP-based communication. It introduces core interfaces such as \HttpChannel\, \HttpRequest\, and \HttpResponse\ to standardize request and response handling, along with supporting classes like \HttpCookie\, \HttpHeaderNames\, and \HttpResult\. The module also includes an \AbstractServerHttpChannelObserver\ to manage server-side streaming and message encoding, and a \CompositeInputStream\ to handle input streams more efficiently. This serves as the foundational API for the upcoming unified HTTP/1.2 and Triple protocol implementations.

dubbo-remoting/dubbo-remoting-http12 · high confidence

Introduces extensible JSON serialization via JsonUtil SPI and GsonUtils implementation

The dubbo-common module now provides a new SPI interface, JsonUtil, allowing users to customize JSON serialization behavior, alongside a concrete GsonUtils implementation that enables Gson-based generic serialization (toJson/fromJson) when the Gson library is present on the classpath.

dubbo-common/src/main/java/org/apache/dubbo/common/json · high confidence

Introduces extensible byte accessor and dedicated callback service codec for the Dubbo protocol

The Dubbo protocol implementation now supports custom serialization logic through a new SPI-based \ByteAccessor\ interface, allowing users to provide enhanced \DecodeableRpcInvocation\ and \DecodeableRpcResult\ subclasses for flexible decoding. Additionally, a new \CallbackServiceCodec\ and \ChannelWrappedInvoker\ are introduced to handle server-push callback scenarios, enabling the registration and management of callback service instances on the client side with proper lifecycle and scope model integration.

dubbo-rpc/dubbo-rpc-dubbo · high confidence

Introduces high-performance InternalThreadLocal implementation

The dubbo-common module now includes a new set of classes (InternalThread, InternalThreadLocal, InternalThreadLocalMap, InternalRunnable, and NamedInternalThreadFactory) that provide a high-performance alternative to standard Java ThreadLocal. Inspired by Netty's FastThreadLocal, this implementation uses an indexed array for variable storage instead of hash tables, offering faster access for frequently used thread-local variables. It also includes mechanisms to automatically clean up thread-local variables to prevent memory leaks, particularly in container environments or when using the provided InternalRunnable wrapper.

dubbo-common/src/main/java/org/apache/dubbo/common/threadlocal · high confidence

Introduces local file-based cache store with thread-safe factory and locking

The local caching mechanism now uses a new \FileCacheStore\ implementation backed by human-readable property files, managed by a \FileCacheStoreFactory\ that ensures thread-safe, singleton access per cache path. The factory handles directory creation, sanitizes cache names for safe file system usage, and employs file locking to prevent concurrent access issues across multiple applications or threads. It also enforces configurable limits on entry count and file size, logging warnings when these thresholds are exceeded, and gracefully falls back to an empty cache if file operations fail.

dubbo-common/src/main/java/org/apache/dubbo/common/cache · high confidence

Introduces mesh rule dispatching and tracing context SPI

The mesh router module now includes a new \MeshRuleDispatcher\ utility that manages the lifecycle of \MeshRuleListener\ implementations, allowing registered listeners to react to incoming mesh routing rules or clear them when rules are removed. Additionally, a new \TracingContextProvider\ SPI interface is added to the mesh router utilities, enabling integration with third-party tracing systems (such as OpenTracing) to retrieve context values from RPC invocations.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/mesh/util · high confidence

Introduces new Dubbo annotation types and deprecates legacy ones

The \dubbo-common\ module now includes new annotation definitions for service configuration: \@DubboService\ and \@DubboReference\ are added as the recommended replacements for the legacy \@Service\ and \@Reference\ annotations, which are now marked as deprecated. Additionally, new supporting annotations \@Argument\ and \@Method\ are introduced to allow fine-grained configuration of method-level parameters and arguments, while \@ProvidedBy\ is added to declare the provider application name for interfaces.

dubbo-common/src/main/java/org/apache/dubbo/config/annotation · high confidence

Introduces new RPC core abstractions and async execution model

This change adds foundational classes for the RPC API module, including the \AppResponse\ class to represent the actual business result of an RPC call (distinct from the \AsyncRpcResult\ status wrapper), and the \AsyncContext\ interface with its \AsyncContextImpl\ to support asynchronous invocation patterns similar to Servlet 3.0. It also introduces \AbstractGracefulShutdown\ as a base for protocol-specific graceful shutdown implementations, \AdaptiveMetrics\ for dynamic load balancing statistics, and \DefaultProtocolServer\ to wrap remoting servers. Additionally, it defines the \BaseFilter.Listener\ interface to standardize callback handling for filter chains.

dubbo-rpc/dubbo-rpc-api · high confidence

Introduces new core infrastructure classes for service metadata, URL handling, and scope initialization

This change adds several new foundational classes to the common module: BaseServiceMetadata for managing service identification keys and display names; ServiceKey and ProtocolServiceKey to standardize service matching logic with support for interface, version, group, and protocol matching; URLBuilder and URLStrParser to provide a fluent API and optimized parsing for URL construction; BatchExecutorQueue for batching asynchronous execution tasks; CommonScopeModelInitializer to register shared beans across framework, application, and module scopes; and utility classes like Experimental, Node, Parameters, and Resetable. These additions lay the groundwork for improved service discovery, URL management, and scope-based resource initialization in Dubbo 3.0.

dubbo-common/src/main/java/org/apache/dubbo/common · high confidence

Introduces service-level thread pool isolation for providers

The \dubbo-common\ module now includes a new executor isolation framework (\ExecutorSupport\, \AbstractIsolationExecutorSupport\, and \IsolationExecutorSupportFactory\) that allows providers to assign separate thread pools to different services. This enables better resource isolation and prevents noisy-neighbor issues where one service's load impacts the performance of others on the same provider.

dubbo-common/src/main/java/org/apache/dubbo/rpc/executor · high confidence

Introduces signature-based access key authentication for Dubbo RPC calls

The dubbo-auth module now supports a new authentication mechanism based on access keys and request signatures. This change adds an AccessKeyAuthenticator implementation that signs outgoing requests on the consumer side (via ConsumerSignFilter) and validates those signatures on the provider side (via ProviderAuthFilter and ProviderAuthHeaderFilter). Users can enable this by setting the auth parameter, allowing them to secure their RPC services with cryptographic verification of request integrity and origin.

dubbo-auth · high confidence

Introduces state-based routing with BitList optimization

Adds a new state-based routing architecture in the \dubbo-cluster\ module, introducing the \StateRouter\ interface and \AbstractStateRouter\ base class to manage router chains and snapshots. This change includes a new \BitList\ data structure that uses a BitSet to optimize invoker filtering and reduce memory allocation during routing operations, alongside supporting classes like \CacheableStateRouterFactory\ and \TailStateRouter\ to facilitate this new routing model.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/state · high confidence

Introduces thread pool exhaustion event and listener SPI

This change adds the \ThreadPoolExhaustedEvent\ class and the \ThreadPoolExhaustedListener\ SPI interface to the \dubbo-common\ module. The listener, scoped to the framework, allows users to register custom handlers that are notified when the Dubbo thread pool becomes exhausted, enabling custom monitoring or alerting logic for this specific condition.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool/event · high confidence

Introduces zone-aware traffic distribution for multi-registry subscriptions

The \ZoneAwareCluster\ and \ZoneAwareClusterInvoker\ are added to the cluster support registry package, enabling a new routing strategy when subscribing to multiple registries. This feature prioritizes registries marked as 'preferred', then attempts to route traffic to providers within the same zone as the current request (using a \ZoneDetector\ or explicit context attachments), and finally falls back to standard load balancing across all available registries. If zone forcing is enabled and no providers are found in the target zone, the invocation fails with an \IllegalStateException\.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/support/registry · high confidence

Introduction of Adaptive and SPI Extension Injectors

The extension injection mechanism now includes two new components: AdaptiveExtensionInjector and SpiExtensionInjector. The AdaptiveExtensionInjector acts as a central dispatcher that aggregates all registered ExtensionInjector implementations and delegates instance retrieval to them in order, returning the first non-null result. The SpiExtensionInjector specifically handles the injection of SPI-annotated interfaces by retrieving their adaptive extensions via the ExtensionLoader. These additions enhance the flexibility and coverage of the dependency injection system for extension points.

dubbo-common/src/main/java/org/apache/dubbo/common/extension/inject · high confidence

Introduction of AddressListener SPI for address notification processing

A new AddressListener SPI interface has been added to the registry module, allowing users to intercept and process the list of provider addresses received during service discovery. The interface includes a notify method to handle address updates and a default destroy method for cleanup, with the extension scope set to MODULE to align with the new lifecycle management.

dubbo-cluster/src/main/java/org/apache/dubbo/registry · high confidence

Introduction of Cached and Limited thread pool implementations

The Dubbo framework now includes two new thread pool strategies in the common module: CachedThreadPool and LimitedThreadPool. The CachedThreadPool behaves like a self-tuning pool that recycles idle threads after one minute, while the LimitedThreadPool creates new threads up to a specified limit without shrinking. Both implementations support configurable core threads, maximum threads, queue capacity, and thread naming, and they utilize a new MemorySafeLinkedBlockingQueue when the queue size parameter is set to a negative value.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool/support/cached · high confidence

Introduction of Compiler SPI interface for dynamic Java source compilation

The dubbo-common module now exposes a new SPI interface, org.apache.dubbo.common.compiler.Compiler, allowing users to plug in custom implementations for compiling Java source code at runtime. The interface provides two methods: a legacy method accepting only source code and a classloader, and a new method that accepts a 'neighbor' class to support class loading requirements in JDK 16 and above, ensuring compatibility with newer Java versions' module system.

dubbo-common/src/main/java/org/apache/dubbo/common/compiler · high confidence

Introduction of InjvmExporter class for local service export management

The InjvmExporter class has been added to handle the lifecycle of local (in-JVM) service exports. It extends AbstractExporter and manages the registration and removal of the exporter instance in a shared map, ensuring that local service references are properly tracked and cleaned up when unexported.

dubbo-rpc-injvm · high confidence

Introduction of NettyChannel implementation for Dubbo remoting

The dubbo-remoting-netty module now includes the NettyChannel class, which implements the core channel abstraction for Netty-based transport. This change introduces the specific logic for managing Netty channel lifecycle, including connection state checks, message sending with configurable timeouts, and attribute management, effectively establishing the concrete transport layer for Dubbo services using Netty.

dubbo-remoting-netty · high confidence

Introduction of ScopeBeanExtensionInjector for SPI extension injection

The Dubbo framework now includes a new ScopeBeanExtensionInjector that enables the injection of scope beans into SPI extension instances. This change introduces a new ScopeBeanException class to handle errors related to scope bean operations. The injector implements the ExtensionInjector interface and is aware of the ScopeModel, allowing it to retrieve beans from the ScopeBeanFactory based on type and name. This enhancement improves the integration between Dubbo's scope-based bean management and its SPI extension mechanism.

dubbo-common/src/main/java/org/apache/dubbo/common/beans · high confidence

Introduction of ScopeBeanFactory for scoped bean lifecycle management

The new ScopeBeanFactory class provides a mechanism for creating, caching, and managing beans within specific scopes, supporting features such as concurrent-safe registration, bean initialization, and destruction checks. This component enables applications to handle scoped bean lifecycles more robustly, including support for extension post-processors and instantiation strategies, while preventing issues like memory leaks and concurrent creation errors through internal synchronization and state management.

dubbo-common/src/main/java/org/apache/dubbo/common/beans/factory · high confidence

Introduction of a hierarchical application model architecture

Dubbo introduces a new hierarchical model structure consisting of FrameworkModel, ApplicationModel, and ModuleModel to better manage resources and support multi-instance deployments. This change replaces the previous flat singleton-based model with a scoped hierarchy where FrameworkModel manages global resources, ApplicationModel handles application-level configurations and service repositories, and ModuleModel manages module-specific resources. The diff shows new classes like ApplicationInitListener, FrameworkServiceRepository, and ModuleServiceRepository that implement this new architecture, along with lifecycle management for proper initialization and destruction of these models.

dubbo-common/src/main/java/org/apache/dubbo/rpc/model · high confidence

Introduction of bytecode generation utilities for proxies and wrappers

The dubbo-common module now includes a new set of classes in the org.apache.dubbo.common.bytecode package to support dynamic class generation. This adds ClassGenerator for creating dynamic classes using Javassist, Proxy for generating invocation handlers, Wrapper for reflecting on class properties and methods, and Mixin for combining interfaces with delegate implementations. It also introduces DubboLoaderClassPath to ensure Javassist correctly resolves Dubbo classes from the appropriate classloader, along with supporting exception classes (NoSuchMethodException, NoSuchPropertyException).

dubbo-common/src/main/java/org/apache/dubbo/common/bytecode · high confidence

Introduction of core RPC service interfaces and detection infrastructure

The dubbo-common module now includes the foundational interfaces for generic invocation (GenericService with $invoke and $invokeAsync), service echo (EchoService with $echo), and service lifecycle management (Destroyable with $destroy). To support these, the module adds GenericException for wrapping remote errors, detector classes (EchoServiceDetector, GenericServiceDetector) that implement BuiltinServiceDetector to identify these built-in services, and a ServiceDescriptorInternalCache that provides cached ReflectionServiceDescriptor instances for GenericService and EchoService.

dubbo-common/src/main/java/org/apache/dubbo/rpc/service · high confidence

Introduction of new mesh routing rule data models

The mesh router module now includes new model classes, BaseRule and VsDestinationGroup, to structure routing configuration. BaseRule provides a foundation for rule metadata including API version, kind, and custom metadata, while VsDestinationGroup aggregates VirtualServiceRule and DestinationRule lists per application, ensuring validity only when both rule types are present. This change establishes the data structures required for the new routing rule implementation.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/mesh/rule · high confidence

JAX-RS Exception Mappers now handle errors in the Triple REST protocol

Users can now leverage existing JAX-RS ExceptionMapper implementations to customize error responses when using the Dubbo Triple REST protocol. A new ExceptionMapperAdapter bridges the JAX-RS exception handling model to the internal REST filter chain, ensuring that exceptions are mapped to HTTP responses via standard JAX-RS contracts.

dubbo-rest-jaxrs · high confidence

JAX-RS dialect support for the Triple REST protocol

The \dubbo-rest-jaxrs\ module now provides a complete JAX-RS dialect implementation for the Triple REST protocol. This adds support for standard JAX-RS annotations (such as \@Path\, \@QueryParam\, \@HeaderParam\, \@CookieParam\, \@FormParam\, and \@BeanParam\) and integrates with the Resteasy library via adapters for HTTP requests and responses. Users can now expose services using JAX-RS annotations within the Triple REST framework, with automatic argument resolution and binding.

dubbo-plugin/dubbo-rest-jaxrs · high confidence

Logger messages now support placeholder substitution

The logging system in dubbo-common now supports formatted messages using curly-brace placeholders (e.g., "Hi {}"). This is achieved by introducing local copies of SLF4J's \MessageFormatter\ and \FormattingTuple\ classes, allowing developers to pass arguments that will be substituted into log patterns at runtime, similar to standard SLF4J usage.

dubbo-common/src/main/java/org/apache/dubbo/common/logger/helpers · high confidence

Nacos config center support with retry and symbol handling

This change introduces the Nacos implementation for Dubbo's dynamic configuration center. It adds a wrapper to handle Nacos-specific character restrictions (converting inner-class symbols and slashes) and a factory to wire the configuration. The core client now includes a robust connection mechanism that retries creation up to a configurable limit (default 10 times) with a configurable wait interval, and allows users to disable the initial server health check via the \nacos.check\ parameter.

dubbo-configcenter/dubbo-configcenter-nacos · high confidence

Native image support and AOT processing added to the Maven plugin

The dubbo-maven-plugin now includes a new 'aot' package containing Mojo classes (such as DubboProcessAotMojo) that enable Ahead-of-Time (AOT) processing and native image configuration generation. This adds the 'dubbo-process-aot' goal, which runs an AOT processor to generate sources and resources, compiles them using the project's configured Java compiler settings, and copies the results to the output directory. The implementation also introduces dependency filtering capabilities (Include/Exclude filters) and utilities for executing Java processes with Maven toolchain support, allowing users to prepare their Dubbo applications for native compilation.

dubbo-maven-plugin · high confidence

New AbortPolicyWithReport thread pool handler with exhaustion events and thread dumps

The thread pool support module now includes a new AbortPolicyWithReport class that extends the standard Java AbortPolicy. When a thread pool is exhausted, this handler logs detailed diagnostic information, optionally dumps the Java thread stack (JStack) to a file based on configuration, and dispatches a ThreadPoolExhaustedEvent to registered listeners. This allows applications to react to thread pool exhaustion events and capture diagnostic data for troubleshooting.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool/support · high confidence

New Dubbo Actuator endpoints and health indicator

This change introduces a new set of Spring Boot Actuator endpoints for Dubbo, allowing users to inspect application state and configuration via HTTP. New endpoints include \dubbo\ (for invoking QOS commands), \dubboconfigs\ (listing all Dubbo config beans), \dubboservices\ (exposing \@DubboService\ metadata), \dubboreferences\ (exposing \@DubboReference\ metadata), \dubboproperties\ (filtering and exposing Dubbo properties), and \dubboshutdown\ (triggering a graceful shutdown). Additionally, a \DubboHealthIndicator\ is added to report the health status of Dubbo components (like registries and protocols) based on configurable status checkers.

dubbo-spring-boot-project/dubbo-spring-boot-actuator · high confidence

New Dubbo MCP Server demo application

A new demo application has been added to showcase Dubbo's Model Context Protocol (MCP) integration. This server-side demo exposes Dubbo services as MCP tools, demonstrating how to configure the Triple protocol with MCP enabled via the 'streamable' protocol, and includes example implementations for both simple and complex request/response scenarios.

dubbo-demo/dubbo-demo-mcp-server · high confidence

New Dubbo config property binding infrastructure

The dubbo-config-spring module now includes a new property binding layer consisting of the DubboConfigBinder interface, its AbstractDubboConfigBinder base class, and the DefaultDubboConfigBinder implementation. This change introduces a standardized mechanism for binding Spring environment properties to Dubbo AbstractConfig objects using a configurable prefix, with support for ignoring unknown or invalid fields during the binding process.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/context/properties · high confidence

New Dubbo protocol components for graceful shutdown, client management, and status monitoring

This change introduces several new classes within the dubbo-rpc-dubbo module to enhance protocol capabilities. DubboGracefulShutdown implements graceful shutdown by sending READONLY\_EVENT and WRITEABLE\_EVENT to connected clients, allowing for controlled service termination and recovery. ExclusiveClientsProvider and SharedClientsProvider manage client lifecycle and reference counting, with SharedClientsProvider handling batch reference increments and scheduled removal of unused shared connections. DubboCountCodec wraps the standard codec to log message lengths for requests and responses via attachments. Additionally, ThreadPoolStatusChecker provides runtime visibility into executor pool metrics (active, core, max, and task counts) for monitoring.

dubbo-rpc-dubbo · high confidence

New InstantiationStrategy for scope-aware bean creation

A new InstantiationStrategy interface has been added to the common beans support module to handle object instantiation with awareness of Dubbo's scope hierarchy (Framework, Application, Module). This strategy allows beans to be created using constructors that accept specific scope model arguments, enabling better support for multi-instance and multi-module configurations by injecting the correct scope context during bean creation.

dubbo-common/src/main/java/org/apache/dubbo/common/beans/support · high confidence

New JavaBean serialization utilities in dubbo-common

The \dubbo-common\ module now includes a new beanutil package containing \JavaBeanAccessor\, \JavaBeanDescriptor\, and \JavaBeanSerializeUtil\. These classes provide a mechanism to serialize Java objects into a type-safe \JavaBeanDescriptor\ structure, supporting fields, methods, primitives, enums, collections, maps, and arrays. This enables consistent serialization of complex object graphs for internal use, such as configuration or data transfer, within the Dubbo framework.

dubbo-common/src/main/java/org/apache/dubbo/common/beanutil · high confidence

New Micrometer Observation-based tracing implementation for Dubbo RPC

The dubbo-tracing module now uses the Micrometer Observation API to manage distributed tracing for Dubbo RPC calls. This change introduces a new observation registry (\DubboObservationRegistry\) that initializes tracing handlers for both client and server sides, supporting both OpenTelemetry and Brave backends. New filters (\ObservationSenderFilter\ and \ObservationReceiverFilter\) create observations around incoming and outgoing RPC messages, while specific conventions (\DefaultDubboClientObservationConvention\, \DefaultDubboServerObservationConvention\) define standard low-cardinality tags like \rpc.system\, \rpc.service\, \rpc.method\, \net.peer.name\, and \net.peer.port\. The module also includes context classes (\DubboClientContext\, \DubboServerContext\) and exporter handlers for OTLP and Zipkin, providing a unified, standards-compliant tracing experience for Dubbo applications.

dubbo-metrics/dubbo-tracing · high confidence

New OTLP metrics reporter module for exporting JVM metrics

This change introduces the \dubbo-metrics-otlp\ module, enabling users to export Dubbo metrics to OpenTelemetry Protocol (OTLP) endpoints. It adds \OtlpMetricsReporter\ and \OtlpMetricsReporterFactory\ to handle configuration via \OtlpMetricConfig\ (including endpoint, step, headers, and resource attributes like service name) and registers the factory in \META-INF/dubbo/internal/org.apache.dubbo.metrics.report.MetricsReporterFactory\. The module includes tests verifying that JVM metrics are correctly pushed to an OTLP collector.

dubbo-metrics-otlp, dubbo-metrics/dubbo-metrics-otlp · high confidence

New ReferenceCountedResource base class for safe resource lifecycle management

A new abstract base class, ReferenceCountedResource, has been added to the common reference package to manage the lifecycle of resources using a reference-counting mechanism. This class allows components to safely acquire and release references to shared resources (such as client connections), automatically triggering a destroy operation when the reference count drops to zero. This supports the broader optimization to share client pools among services and helps prevent potential memory leaks by ensuring resources are properly cleaned up when no longer in use.

dubbo-common/src/main/java/org/apache/dubbo/common/reference · high confidence

New SPI-based filter chain building infrastructure

The cluster filter module now uses a new SPI interface, FilterChainBuilder, to construct invocation and cluster filter chains. This replaces the previous inline logic with a pluggable architecture, introducing DefaultFilterChainBuilder as the standard implementation. The ProtocolFilterWrapper has been updated to delegate chain construction to this builder, ensuring that filters are correctly resolved and ordered based on the URL's scope model (application or module level). This change also introduces new wrapper classes like CallbackRegistrationInvoker to handle asynchronous callback registration within the filter chain.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/filter · high confidence

New SPI-based type conversion framework with caching

The \dubbo-common\ module now includes a new type conversion system centered on the \Converter\ SPI interface, allowing developers to register custom type conversions via the extension loader. This system includes a \ConverterUtil\ that caches resolved converters to improve performance, and provides built-in implementations for converting strings to common types such as Boolean, Byte, Character, Double, Float, Integer, Long, Short, char\[\], Duration, and Optional.

dubbo-common/src/main/java/org/apache/dubbo/common/convert · high confidence

New Spring Boot Actuator integration and application lifecycle listeners

This change introduces a new \dubbo-spring-boot-actuator-autoconfigure\ module that automatically registers Spring Boot Actuator endpoints (for QoS, configs, properties, references, services, and shutdown) and a Dubbo health indicator, along with a metrics binder for Micrometer. It also adds several application context listeners in the core module: \DubboNetInterfaceConfigApplicationListener\ to support preferred and ignored network interfaces via Spring Environment, \DubboOpenAPIExportListener\ to export OpenAPI specifications on application ready, \DubboConfigBeanDefinitionConflictApplicationListener\ to resolve \ApplicationConfig\ bean definition conflicts, and \AwaitingNonWebApplicationListener\ to keep non-web applications running until shutdown.

dubbo-spring-boot-project/dubbo-spring-boot · high confidence

New Spring Boot IDL demo with gRPC-Triple support

The provider module now includes a complete Spring Boot-based IDL demo that uses Protocol Buffers to define services. It provides a GreeterService implementation supporting synchronous, asynchronous, and streaming (StreamObserver) calls, alongside a separate MessageService. The demo is configured to use the Triple protocol over Zookeeper and includes a test verifying that the message.proto schema is correctly registered.

dubbo-demo/dubbo-demo-spring-boot-idl/dubbo-demo-spring-boot-idl-provider · high confidence

New Spring application events for Dubbo lifecycle and configuration

The dubbo-config-spring module now exposes several new Spring ApplicationEvents to allow users to react to specific phases of the Dubbo runtime. DubboApplicationStateEvent and DubboModuleStateEvent broadcast the deployment state (starting, started, stopping, stopped) and any associated errors for the application and module scopes. DubboConfigInitEvent signals when the configuration bean initialization process begins. Additionally, ServiceBeanExportedEvent is provided to notify listeners after a service has been successfully exported. The legacy DubboBootstrapStatedEvent and DubboBootstrapStopedEvent are retained but marked as deprecated in favor of the new state-based events.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/context/event · high confidence

New Spring integration utility classes for bean registration and annotation processing

This change introduces a suite of new utility classes in the \dubbo-config-spring\ module to streamline Spring framework integration. \DubboBeanUtils\ centralizes the registration of core infrastructure beans (such as \ReferenceAnnotationBeanPostProcessor\ and \DubboConfigAliasPostProcessor\), ensuring consistent initialization. \AnnotatedBeanDefinitionRegistryUtils\ and \AnnotationUtils\ provide robust helpers for scanning base packages, detecting annotated classes, and resolving annotation attributes across different Spring versions. Additionally, \DubboAnnotationUtils\ standardizes the resolution of service interfaces and parameter conversion for \@Service\ and \@Reference\ annotations, while \BeanRegistrar\ and \EnvironmentUtils\ offer utilities for alias management and property extraction. These utilities collectively enhance the reliability and maintainability of Dubbo's Spring auto-configuration.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/util · high confidence

New Zookeeper Service Discovery implementation

This change introduces a new Service Discovery model for the Zookeeper registry module, implemented via the new ZookeeperServiceDiscovery class and its factory. It adds a ZookeeperInstance payload class to represent registered service data in Zookeeper, compatible with Spring Cloud, and registers the necessary factories (ZookeeperRegistryFactory, ZookeeperServiceDiscoveryFactory) and AOT reflection type describers to enable the new discovery mechanism alongside the existing registry logic.

dubbo-registry/dubbo-registry-zookeeper · high confidence

New annotation processor for generating service metadata definitions

The metadata processor now includes a new Java annotation processor that automatically generates a \service-definitions.json\ file at \META-INF/dubbo/\ during compilation. This processor scans classes annotated with Dubbo's \@Service\ and, using a SPI-based builder system, captures their type hierarchies, methods, and parameters to produce a complete service definition model for runtime discovery.

dubbo-metadata/dubbo-metadata-processor · high confidence

New annotation-driven configuration binding and component scanning infrastructure

The \dubbo-config-spring\ module introduces a new annotation-based configuration binding system. Users can now use \@EnableConfigurationBeanBinding\ (and the composite \@EnableConfigurationBeanBindings\) to bind Dubbo config classes (such as \ApplicationConfig\, \RegistryConfig\, \ProtocolConfig\, etc.) directly from Spring \PropertySources\ using specific prefixes (e.g., \dubbo.application\, \dubbo.registries\). The \DubboConfigConfiguration\ class provides pre-configured \Single\ and \Multiple\ modes for these bindings. Additionally, \@DubboComponentScan\ and \@EnableDubbo\ are introduced to simplify component scanning for \@Service\ and \@Reference\ annotations, automatically registering the necessary post-processors and initializing Dubbo beans via \DubboSpringInitializer\.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/context/annotation · high confidence

New application and module lifecycle extension interfaces

Dubbo introduces \ApplicationExt\ and \ModuleExt\ interfaces in the \dubbo-common\ context package, allowing SPI extensions to be managed at the application and module scopes respectively. These interfaces extend the new \Lifecycle\ contract (providing \initialize\, \start\, and \destroy\ phases) and \Disposable\, enabling finer-grained control over component initialization and teardown within specific runtime scopes.

dubbo-common/src/main/java/org/apache/dubbo/common/context · high confidence

New application and service-level condition routers

This change introduces new router implementations for Dubbo's cluster routing: AppStateRouter and ProviderAppStateRouter for application-level routing, and ServiceStateRouter for service-level routing. These routers listen to dynamic configuration changes (via ConfigurationListener) and parse condition rules to route requests. The factories (AppStateRouterFactory, ProviderAppStateRouterFactory, ServiceStateRouterFactory) are registered with specific activation orders (150, 145, 140 respectively) to control their execution sequence in the router chain. This allows for more granular control over traffic routing based on application or service identity.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/condition/config · high confidence

New array and collection merger implementations for cluster results

The cluster merger package now includes dedicated merger classes for primitive arrays (boolean, byte, char, double, float, int, long, short), generic object arrays, lists, sets, and maps. These implementations consolidate multiple result arrays into single collections or arrays, with the numeric array mergers utilizing Java 8 streams for concatenation, ensuring that null entries are safely skipped during the merge process.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/merger · high confidence

New code generators for Mutiny and Reactor Triple stubs

The dubbo-compiler plugin now includes new generator classes and Mustache templates for generating Dubbo Triple stubs using reactive libraries. Users can generate client stubs that return SmallRye Mutiny types (Uni/Multi) via the MutinyDubbo3TripleGenerator, or Project Reactor types (Mono/Flux) via the ReactorDubbo3TripleGenerator, in addition to the existing standard CompletableFuture-based Triple stubs.

dubbo-plugin/dubbo-compiler · high confidence

New common language utilities and shutdown hook management

The dubbo-common module introduces four new classes in the \org.apache.dubbo.common.lang\ package to support application lifecycle and utility needs. It adds a \@Nullable\ annotation for static analysis support, a \Prioritized\ interface with a built-in comparator for sorting tasks by priority, and a \ShutdownHookCallback\ SPI interface for registering cleanup logic. Additionally, it provides a \ShutdownHookCallbacks\ manager that loads, sorts, and executes these callbacks during application shutdown, ensuring proper resource disposal.

dubbo-common/src/main/java/org/apache/dubbo/common/lang · high confidence

New concurrent rejection policies and safe initializer in dubbo-common

The \dubbo-common\ module now includes a new \concurrent\ package providing thread-safe initialization and queue rejection handling. \CallableSafeInitializer\ offers a lazy, thread-safe, and removable initializer for managing resources that implement \Disposable\. Additionally, three new rejection policies—\AbortPolicy\ (throws \RejectException\), \DiscardPolicy\ (silently drops items), and \DiscardOldestPolicy\ (removes the oldest item to make space)—are available via the \Rejector\ interface to handle memory-constrained queue scenarios.

dubbo-common/src/main/java/org/apache/dubbo/common/concurrent · high confidence

New condition router rule model for Dubbo 3.1+ multi-destination routing

The cluster module now includes a new set of model classes in the condition router config package to support the v3.1 condition router specification. This introduces \ConditionRuleParser\ to parse YAML-based routing rules, distinguishing between legacy single-destination rules (\ConditionRouterRule\) and new multi-destination rules (\MultiDestConditionRouterRule\, \MultiDestCondition\, \Destination\, \DestinationSet\). Users can now define routing configurations that direct traffic to multiple distinct sets of invokers based on weighted conditions, enabling more granular traffic management and A/B testing scenarios within the application scope.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/condition/config/model · high confidence

New condition rule matcher architecture for Dubbo routing

The condition router matcher logic has been restructured into a new extensible SPI-based architecture. This change introduces a \ConditionMatcher\ interface and an \AbstractConditionMatcher\ base class that handles common matching logic, along with specific implementations for evaluating URL parameters (\UrlParamConditionMatcher\), method arguments (\ArgumentConditionMatcher\), and RPC attachments (\AttachmentConditionMatcher\). It also adds a \ValuePattern\ SPI to support different value matching strategies, including range patterns (e.g., \1\~100\) and wildcard patterns (e.g., \hello\*\). This refactoring allows for more flexible and modular definition of condition rules in Dubbo's cluster routing.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/condition/matcher · high confidence

New condition-based state routers for traffic routing

The condition router module now includes \ConditionStateRouter\ and \MultiDestConditionRouter\, which allow users to direct traffic based on specific request attributes (such as method names or arguments) using 'when' and 'then' conditions. \ConditionStateRouter\ handles single-destination routing rules, while \MultiDestConditionRouter\ supports routing to multiple destinations with configurable weights. These components are registered via \ConditionStateRouterFactory\ and integrate with the existing state router infrastructure to provide flexible, rule-based service governance.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/condition · high confidence

New config center metrics collection module

A new \dubbo-metrics-config-center\ module has been added to track configuration center activity. It introduces a \ConfigCenterMetricsCollector\ that gathers gauge metrics on configuration changes (such as adds or updates) from protocols like Nacos, Apollo, and Zookeeper. The module includes the necessary event handling infrastructure (\ConfigCenterEvent\, \ConfigCenterSubDispatcher\) and constants to tag these metrics with application name, config key, group, and protocol, allowing users to monitor configuration center usage and change frequency.

dubbo-metrics/dubbo-metrics-config-center · high confidence

New consumer-side RPC filters for context, classloader, callbacks, and metrics

Four new cluster filters have been added to the consumer side to improve context management and observability. ConsumerContextFilter ensures RpcContext (including invoker, invocation, local/remote host, and port) is correctly populated for consumer invocations and handles timeout countdown propagation. ConsumerClassLoaderFilter temporarily switches the thread's context classloader to the service model's classloader during invocation to prevent class-loading issues. CallbackConsumerContextFilter extends ConsumerContextFilter to ensure RpcContext is available in the execution thread for callback invokers. MetricsConsumerFilter delegates to the standard MetricsFilter to enable metrics collection for consumer-side RPC calls.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/filter/support · high confidence

New default metrics collection and aggregation infrastructure

This change introduces the core implementation for Dubbo's default metrics system within the dubbo-metrics-default module. It adds a new metrics registry (MetricsGlobalRegistry) that supports both Dubbo-managed and global Micrometer registries, and defines the default method-level metrics keys for providers and consumers (e.g., request counts, successes, failures, timeouts). The update includes new collectors for aggregate metrics (using time-windowed counters and quantiles for RT/QPS) and histogram-based response time metrics, as well as samplers for thread pool statistics (core size, active count, queue size) and thread pool rejection events. It also adds support for error code metrics and integrates with AOT (Ahead-of-Time) compilation via reflection type describers for native image support.

dubbo-metrics/dubbo-metrics-default · high confidence

Dubbo introduces a new fluent logging API (FluentLogger) and an error-type-aware logger (ErrorTypeAwareLogger) in the common logger module. The fluent API allows developers to chain method calls to attach error causes, extended information, and messages before emitting log entries at various levels. The error-type-aware logger automatically appends a clickable FAQ link to log output, directing users to the corresponding solution page based on the provided error code. These interfaces are supported by a refactored LoggerFactory that detects and configures the underlying logging adapter (such as SLF4J, Log4j2, or Log4j) and a new ListenableLogger interface for registering log message listeners.

dubbo-common/src/main/java/org/apache/dubbo/common/logger · high confidence

New framework status reporting infrastructure for registration, consumption, and migration

This change introduces the \FrameworkStatusReporter\ SPI interface and the \FrameworkStatusReportService\ implementation within the common module. The service enables the framework to report status updates for service registration, address consumption, and migration steps by delegating to registered reporter extensions. This provides a standardized mechanism for collecting and exposing internal framework state, which is essential for monitoring and debugging service mesh or migration scenarios.

dubbo-common/src/main/java/org/apache/dubbo/common/status/reporter · high confidence

New functional utility interfaces and helpers in dubbo-common

Added new utility classes in the \org.apache.dubbo.common.function\ package to simplify functional programming patterns: \Predicates\ provides static methods for creating always-true/false predicates and composing them with logical AND/OR; \Streams\ offers convenience methods to filter iterables into lists, sets, or streams while preserving insertion order; and \ThrowableAction\, \ThrowableConsumer\, and \ThrowableFunction\ introduce functional interfaces that allow throwing checked exceptions, along with helper methods that wrap those exceptions in runtime exceptions for easier integration with standard Java streams and consumers.

dubbo-common/src/main/java/org/apache/dubbo/common/function · high confidence

New global resource lifecycle management infrastructure

The \dubbo-common\ module introduces a new resource management subsystem in the \org.apache.dubbo.common.resource\ package to handle global resource initialization and cleanup. This includes the \Disposable\ and \Initializable\ interfaces for defining resource lifecycles, and the \GlobalResourcesRepository\ singleton which maintains a registry of global and one-off disposable resources. The \GlobalResourceInitializer\ class leverages this repository to automatically register resources for destruction upon Dubbo shutdown, ensuring that global shared handlers and other resources are properly terminated when the framework stops.

dubbo-common/src/main/java/org/apache/dubbo/common/resource · high confidence

New high-performance, thread-unsafe I/O utilities in dubbo-common

The dubbo-common module now includes a new set of thread-unsafe I/O utility classes designed for performance-critical paths where external synchronization is handled by the caller. This adds Bytes for efficient byte array conversions and encoding, StreamUtils for managing input stream limits and mark/reset behavior, UnsafeByteArrayInputStream and UnsafeByteArrayOutputStream for fast byte stream operations, and UnsafeStringReader and UnsafeStringWriter for efficient string reading and writing. These components provide lower-overhead alternatives to standard Java I/O classes for internal Dubbo serialization and data handling.

dubbo-common/src/main/java/org/apache/dubbo/common/io · high confidence

New memory-safe concurrency primitives for thread pools

The \dubbo-common\ thread pool module now includes new classes to prevent OutOfMemoryError (OOM) caused by unbounded queue growth. \MemoryLimitCalculator\ periodically tracks JVM free memory to provide a dynamic limit. \MemoryLimiter\ uses Java Instrumentation to track the exact size of queued objects, enforcing a hard memory cap. \MemoryLimitedLinkedBlockingQueue\ integrates this limiter to block or reject additions when the limit is reached. Additionally, \MemorySafeLinkedBlockingQueue\ offers a simpler, instrumentation-free alternative that rejects tasks based on available free memory using a configurable \Rejector\ policy.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool · high confidence

New mesh routing rule models for Dubbo virtual services and destinations

This change introduces a new set of data model classes in the \dubbo-cluster\ module to support mesh-style routing rules for Dubbo services. Specifically, it adds the \VirtualServiceRule\ and \DestinationRule\ models, along with their specifications (\VirtualServiceSpec\, \DestinationRuleSpec\) and associated components like \DubboRoute\, \DubboRouteDetail\, \DubboDestination\, and \Subset\. It also includes a comprehensive set of matchers in the \match\ sub-package (e.g., \DubboMethodMatch\, \DubboAttachmentMatch\, \AddressMatch\, \StringMatch\) that enable routing decisions based on method names, arguments, attachments, source labels, and address patterns. These models provide the structural foundation for defining and parsing complex traffic routing policies within the Dubbo mesh router.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/mesh/rule/virtualservice · high confidence

New metadata definition utility classes for class analysis and configuration

Added two new utility classes in the metadata definition package: ClassUtils, which provides reflection-based helpers to retrieve code sources, non-static fields, public non-static methods, and canonical names for parameterized types; and JaketConfigurationUtils, which loads exclusion and analysis rules from a jaket.properties file to determine whether specific classes or interfaces should be included in metadata processing.

dubbo-common/src/main/java/org/apache/dubbo/metadata/definition/util · high confidence

New metadata metrics collection for push, subscribe, and provider storage operations

This change introduces a new \MetadataMetricsCollector\ and supporting event infrastructure in the \dubbo-metrics-metadata\ module to expose observability data for metadata center interactions. Users can now monitor application-level metrics for metadata push and subscribe operations (including success/failure counts) as well as service-level metrics for provider metadata storage. The collector respects the \enableMetadata\ configuration flag and registers via the SPI mechanism, emitting standard gauge metrics and response-time statistics for these specific metadata workflows.

dubbo-metrics/dubbo-metrics-metadata · high confidence

New metrics aggregation and collection architecture

The metrics API module introduces a new internal architecture for collecting and aggregating metrics data. This includes new sliding-window based aggregators (TimeWindowAggregator, TimeWindowCounter) for time-series statistics, t-digest implementations (DubboAbstractTDigest, DubboMergingDigest) for high-performance percentile calculations, and a refactored collector hierarchy (MetricsCollector, CombMetricsCollector) that unifies application, service, and method-level metric collection. These changes provide the foundational data structures and interfaces for the metrics system, enabling more accurate and performant metric reporting.

dubbo-metrics/dubbo-metrics-api · high confidence

New metrics event infrastructure and constants

The dubbo-metrics-event module now introduces a dedicated event-driven architecture for metrics collection. This includes a new MetricsEventBus for publishing and dispatching events, a MetricsEventMulticaster interface for listener management, and base event classes like MetricsEvent and TimeCounterEvent to support lifecycle tracking. The change also adds supporting model classes such as MetricsKey (defining metric identifiers), MetricsLevel, TypeWrapper, and TimePair, along with constants in MetricsConstants and a custom exception class. This provides the foundational plumbing for emitting and handling metrics events within the application.

dubbo-metrics/dubbo-metrics-event · high confidence

New nested configuration classes for metrics, tracing, HTTP/3, and REST protocols

The \dubbo-common/src/main/java/org/apache/dubbo/config/nested\ package now includes a comprehensive set of new configuration classes to support advanced observability and protocol features. Users can now configure metric aggregation (\AggregationConfig\), histogram metrics (\HistogramConfig\), and Prometheus exporters/pushgateways (\PrometheusConfig\) alongside OpenTelemetry metrics (\OtlpMetricConfig\). Distributed tracing is supported via configuration for Zipkin and OTLP endpoints (\ExporterConfig\), baggage correlation (\BaggageConfig\), sampling probabilities (\SamplingConfig\), and context propagation types (\PropagationConfig\). Protocol-specific configurations have also been added, including HTTP/3 settings (\Http3Config\), Triple protocol options (\TripleConfig\), and Servlet transport settings (\ServletConfig\). Additionally, the Triple REST protocol now exposes configuration for CORS policies (\CorsConfig\), OpenAPI document generation (\OpenAPIConfig\), and Model Context Protocol (MCP) server integration (\McpConfig\).

dubbo-common/src/main/java/org/apache/dubbo/config/nested · high confidence

New registry metrics collector with multi-level granularity

The dubbo-metrics-registry module now includes a new RegistryMetricsCollector that exposes registry activity metrics at application, registry, and service levels. Users can monitor registration, subscription, notification, and directory status counts, along with response-time statistics (last, min, max, avg, sum) for these operations. The collector is enabled via the metrics configuration (metrics.enableRegistry) and is registered as the 'registry-collector' extension, allowing observability tools to track registry interactions with detailed tagging.

dubbo-metrics/dubbo-metrics-registry · high confidence

New remoting API interfaces and connection management abstractions

The dubbo-remoting-api module introduces a set of core remoting interfaces and abstractions to support the new wire protocol and connection management architecture. This includes the Channel, Client, RemotingServer, and Transporter interfaces for standardizing network communication, alongside Codec and Codec2 for message serialization. A new WireProtocol abstraction with ProtocolDetector enables dynamic protocol negotiation, while AbstractConnectionClient and ConnectionManager provide reference-counted connection lifecycle management. Additionally, ChannelEvent support allows protocols to fire custom events like ReadOnlyEvent and WriteableEvent for graceful shutdown signaling.

dubbo-remoting/dubbo-remoting-api · high confidence

New remoting buffer, future, and telnet components introduced

The dubbo-remoting-api module now includes new classes to handle network I/O and remote interactions: ByteBufferBackedChannelBuffer and HeapChannelBuffer provide concrete implementations for wrapping Java NIO buffers and byte arrays as channel buffers; DefaultFuture manages asynchronous RPC responses with timeout checks via a HashedWheelTimer and handles channel closure by returning inactive responses; MultiMessage aggregates multiple messages into a single iterable collection; and TelnetHandlerAdapter provides a secure telnet command interface that disables commands by default unless explicitly enabled via configuration.

dubbo-remoting-api · high confidence

New servlet-based demo for Triple protocol streaming and SSE

This location introduces a new Spring Boot demo application that runs the Triple protocol over a servlet container (Tomcat). It provides a complete consumer and provider example demonstrating synchronous, asynchronous, server-streaming, bidirectional streaming, and Server-Sent Events (SSE) capabilities. The demo includes the necessary service interfaces, implementations, and configuration to enable the Triple REST OpenAPI specification, allowing users to test streaming behaviors in a standard web server environment.

dubbo-demo/dubbo-demo-spring-boot/dubbo-demo-spring-boot-servlet · high confidence

New stream backpressure and flow-control interfaces

The dubbo-common module introduces a new \org.apache.dubbo.common.stream\ package containing \StreamObserver\, \CallStreamObserver\, \ClientCallStreamObserver\, \ServerCallStreamObserver\, and \ClientResponseObserver\. These interfaces mirror gRPC's streaming APIs to provide explicit send-side and receive-side backpressure controls (such as \isReady\, \setOnReadyHandler\, \request\, and \disableAutoFlowControl\), enabling developers to manage data flow rates and prevent overwhelming senders or receivers in streaming RPCs.

dubbo-common/src/main/java/org/apache/dubbo/common/stream · high confidence

New string-to-collection converters for arrays, lists, sets, and queues

The \dubbo-common\ module now includes a new \convert.multiple\ package that automatically converts comma-separated string values into various multi-value types. This adds support for converting strings into Java arrays, \List\, \Set\, \Collection\, \Queue\, \Deque\, and their concurrent variants (such as \BlockingQueue\ and \TransferQueue\). Users can now pass comma-separated string parameters to methods expecting these collection or array types, and Dubbo will handle the parsing and conversion automatically.

dubbo-common/src/main/java/org/apache/dubbo/common/convert/multiple · high confidence

New tag router rule model classes for Dubbo 3.0

Added four new model classes in the tag router module: \ParamMatch\, \Tag\, \TagRouterRule\, and \TagRuleParser\. These classes provide the data structures and parsing logic for tag-based routing rules, including support for parameter matching via \ParamMatch\ and YAML parsing via \TagRuleParser\. The \Tag\ class handles parsing of tag configurations including version-specific logic for Dubbo 3.0, and \TagRouterRule\ manages the mapping between tags and addresses.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/tag/model · high confidence

New type-definition builders for arrays, collections, maps, and enums

The metadata definition module now includes dedicated builders for complex Java types. ArrayTypeBuilder handles array component types, CollectionTypeBuilder processes parameterized collections, MapTypeBuilder extracts key and value types from maps, and EnumTypeBuilder captures enum constant names. DefaultTypeBuilder provides a centralized entry point for building type definitions for custom classes by analyzing their fields. These components implement the TypeBuilder SPI to ensure consistent and accurate metadata generation for service interfaces.

dubbo-common/src/main/java/org/apache/dubbo/metadata/definition/builder · high confidence

New utility classes and system integration support in dubbo-common

This update introduces a suite of new utility classes and system integration components within the dubbo-common module. It adds a NativeDetector to identify GraalVM native image contexts, an OperatingSystemBeanManager to abstract CPU usage metrics across JVM implementations (HotSpot and J9), and a ClassLoaderResourceLoader to cache and manage classpath resources. Additionally, it includes new utility classes for assertions (Assert), atomic positive integers (AtomicPositiveInteger), CIDR network calculations (CIDRUtils), and annotation handling (AnnotationUtils), alongside the deprecation of the legacy ClassHelper in favor of ClassUtils.

dubbo-common/src/main/java/org/apache/dubbo/common/utils · high confidence

New utility for scheduled and immediate async tasks

A new ScheduledCompletableFuture utility class has been added to the concurrent threadpool package. It provides static methods to schedule a supplier task for execution after a delay or to submit it immediately, wrapping the result in a CompletableFuture that is completed normally or exceptionally based on the task's outcome.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool/concurrent · high confidence

Protobuf metadata type building via extension mechanism

The protobuf module now includes a new ProtobufTypeBuilder that is automatically loaded when the protobuf dependency is present, enabling the system to correctly build and expose metadata definitions for Protobuf-generated types (including handling of maps, lists, and repeated fields) in service definitions.

dubbo-metadata/dubbo-metadata-definition-protobuf · high confidence

QoS API introduces anonymous command allow list and permission levels

The QoS API now supports fine-grained access control for commands via a new PermissionLevel enum (PUBLIC, PROTECTED, PRIVATE) and a QosConfiguration that allows specifying an anonymous access permission level and a comma-separated list of commands explicitly allowed for anonymous access. This enables users to restrict which commands unauthenticated or foreign clients can execute, supplementing existing IP-based access controls.

dubbo-plugin/dubbo-qos-api · high confidence

QoS commands now support multi-instance and Spring Boot Actuator integration

The QoS command execution model has been refactored to support multi-instance deployments and Spring Boot Actuator. Command executors now accept FrameworkModel or ApplicationModel to resolve commands via the ExtensionLoader, enabling proper isolation in multi-instance scenarios. New commands include 'live' for Spring Boot Actuator-style liveness probes, 'getOpenAPI' for retrieving OpenAPI descriptors, and 'enableRouterSnapshot'/'disableRouterSnapshot'/'getRouterSnapshot'/'getRecentRouterSnapshot' for managing and viewing invocation-level router snapshots. The 'ls' command output is now sorted for consistent display, and the 'cd' command has been updated to match services by serviceKey.

dubbo-qos · high confidence

QoS module refactored for multi-instance support with new command architecture

The QoS module has been restructured to support multi-instance deployments. This introduces a new command execution model with dedicated interfaces (ActuatorExecutor, CommandExecutor) and factories (CommandContextFactory) to handle command context. Existing commands like online/offline, metrics, and profiler controls have been migrated to this new BaseCommand interface. Additionally, new commands have been added to retrieve service addresses (getAddress) and current configurations (getConfig), and the module now includes initialization logic (QosScopeModelInitializer) and AOT reflection support (QosReflectionTypeDescriberRegistrar) to properly manage beans and native-image compatibility within the new scope model.

dubbo-plugin/dubbo-qos · high confidence

Reactive Triple protocol support for Dubbo stubs

The dubbo-reactive module now provides a complete implementation of the Triple protocol using Reactor, enabling developers to use reactive types (Mono and Flux) in Dubbo stubs. This change introduces new handler classes (OneToOne, OneToMany, ManyToOne, ManyToMany) and call adapters that bridge the Triple stream observers to the Reactor API, allowing for non-blocking, backpressure-aware communication for unary, server-streaming, client-streaming, and bidirectional-streaming RPC methods.

dubbo-plugin/dubbo-reactive · high confidence

Recover Servlet-based Page API with new diagnostic handlers

The Dubbo container's web-based diagnostic interface is restored by adding four new page handlers: Home (listing available menus), Log (displaying the last 30KB of the root log file), Status (showing individual and summary health checks with color-coded levels), and System (reporting environment details like version, host, OS, JVM, CPU, uptime, and time). These handlers implement the PageHandler interface to render HTML pages via the existing PageServlet infrastructure, bringing back the ability to inspect runtime state and logs through the container's built-in HTTP endpoints.

dubbo-compatible/src/main/java/com/alibaba/dubbo/container/page/pages · high confidence

Recovery of the Servlet-based Page API for Dubbo containers

This change restores the Servlet Page API within the Dubbo-compatible module, adding a new \PageServlet\ that serves as the entry point for container management pages. The implementation includes a \PageHandler\ SPI interface for extensibility, a \Menu\ annotation and \MenuComparator\ to define and sort navigation menus, and a \ResourceFilter\ to serve static resources. Users can now access and customize container dashboard pages via standard HTTP servlet mappings, with page content generated by registered \PageHandler\ extensions.

dubbo-compatible/src/main/java/com/alibaba/dubbo/container/page · high confidence

Register cluster SPI extensions for Dubbo 3.0 multi-instance support

The \dubbo-cluster\ module now registers its Service Provider Interface (SPI) definitions in \META-INF/dubbo/internal/\, enabling the framework to discover cluster-related components in a multi-instance environment. This includes mappings for cluster strategies (e.g., \failover\, \failfast\, \zone-aware\), load balancing algorithms (e.g., \random\, \consistenthash\, \adaptive\), result mergers, router factories (including state routers and mesh rules), governance rule repositories, and scope model initializers. Users benefit from correct component resolution when running multiple Dubbo contexts or using advanced routing and governance features.

dubbo-cluster/src/main/resources · high confidence

Router snapshot debugging support

Added a new router snapshot mechanism to help users debug routing decisions. This includes a RouterSnapshotFilter that marks requests for snapshot collection, a RouterSnapshotNode model to track invoker counts and messages at each router in the chain, and a RouterSnapshotSwitcher to enable/disable snapshots per service and store recent history. This allows users to inspect how routers transform the invoker list during request processing.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router · high confidence

Servlet support for Dubbo Triple REST protocol

This change introduces a new servlet-based transport layer for the Dubbo Triple REST protocol, enabling applications to run Triple REST services on top of standard Servlet containers (like Tomcat or Jetty). It adds a \TripleFilter\ to intercept HTTP requests and route them to the appropriate HTTP/1.1 or HTTP/2 handlers, along with adapters (\ServletHttpRequestAdapter\, \ServletHttpResponseAdapter\) that bridge Dubbo's internal HTTP/12 model to the \javax.servlet\ API. The implementation includes support for servlet-specific features such as cookie handling, file uploads, session management, and argument resolution, allowing developers to expose Triple REST endpoints using familiar servlet-based configuration and deployment models.

dubbo-plugin/dubbo-triple-servlet · high confidence

Spring Boot 3 support for Triple protocol and Micrometer tracing

This change adds auto-configuration support for the Triple protocol and Micrometer tracing on Spring Boot 3. It introduces DubboTriple3AutoConfiguration to register the Jakarta EE-based Triple and WebSocket filters, and DubboSpringBoot3DependencyCheckAutoConfiguration to fail fast if the required Spring Boot 3 dependencies are missing. Additionally, DubboMicrometerTracingAutoConfiguration enables Micrometer tracing integration for Dubbo when the necessary classes are present.

dubbo-spring-boot-project/dubbo-spring-boot-autoconfigure · high confidence

Spring HandlerInterceptor support for Dubbo REST protocol

The dubbo-rest-spring module now allows standard Spring MVC HandlerInterceptors to be used within the Dubbo Triple/REST protocol stack. A new HandlerInterceptorAdapter bridges the Spring interceptor lifecycle (preHandle, postHandle, afterCompletion) to the Dubbo REST filter chain, enabling existing Spring security, logging, or validation interceptors to apply to RESTful RPC calls without modification.

dubbo-rest-spring · high confidence

Spring MVC-style argument resolution for the Triple REST protocol

The \dubbo-rest-spring\ module now supports binding HTTP request arguments using standard Spring MVC annotations (such as \@RequestParam\, \@PathVariable\, \@RequestBody\, \@RequestHeader\, \@CookieValue\, \@MatrixVariable\, \@ModelAttribute\, and \@RequestPart\). This change introduces a suite of argument resolvers and a \BeanArgumentBinder\ that leverage Spring's \DataBinder\ and \ConversionService\ to parse and validate incoming requests, allowing developers to use familiar Spring-style method signatures when implementing services over the Triple REST protocol.

dubbo-plugin/dubbo-rest-spring · high confidence

Spring XML namespace support for Dubbo configuration

The Dubbo Spring module now registers its XML schema and namespace handler, enabling users to configure Dubbo services and references using Spring XML elements (e.g., \<dubbo:service\>, \<dubbo:reference\>). This change adds the dubbo.xsd schema file, along with spring.handlers and spring.schemas registrations, mapping the dubbo.apache.org and legacy code.alibabatech.com namespaces to the DubboNamespaceHandler for parsing.

dubbo-config/dubbo-config-spring/src/main/resources/META-INF · high confidence

Spring-aware Dubbo config beans and scope model initialization

The Spring configuration module now includes dedicated Spring-aware beans—ConfigCenterBean, ReferenceBean, ServiceBean, and SpringScopeModelInitializer—that integrate Dubbo's configuration and lifecycle with the Spring container. ConfigCenterBean can optionally include the Spring Environment as an external configuration source via the includeSpringEnv flag, allowing Dubbo to read properties from Spring's PropertySources. ReferenceBean and ServiceBean implement Spring lifecycle interfaces (ApplicationContextAware, InitializingBean, DisposableBean) to properly register with Spring's bean factory, handle lazy proxying for references, and publish export events for services. SpringScopeModelInitializer provides hooks to initialize Dubbo's scope model hierarchy (Framework, Application, Module) within the Spring context.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring · high confidence

Spring-based extension injection support

The Spring configuration module now includes a dedicated SpringExtensionInjector that allows Dubbo SPI extensions to be resolved directly from the Spring ApplicationContext. This enables users to inject Spring-managed beans as Dubbo extensions, facilitating tighter integration between Dubbo's extension mechanism and the Spring dependency injection container.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/extension · high confidence

Support Project Loom virtual threads as a thread pool factory

Users can now configure Dubbo to use Java 21+ virtual threads for handling requests. This change introduces a new \VirtualThreadPool\ implementation and registers it under the \virtual\ key in the thread pool SPI, allowing users to switch to virtual threads by setting the thread pool type to \virtual\. The implementation supports optional configuration of a core thread count via the \threads.virtual.core\ parameter; if specified, it creates a \ThreadPoolExecutor\ backed by virtual threads, otherwise it falls back to \Executors.newThreadPerTaskExecutor\ for one virtual thread per task.

dubbo-plugin/dubbo-plugin-loom · high confidence

Support for WebSocket protocol upgrade in Netty4 transport

The WebSocket module now includes a dedicated upgrade codec for Netty4 that manages the HTTP-to-WebSocket handshake. When a connection upgrade is initiated, this component automatically removes specified existing channel handlers and adds the necessary WebSocket handlers to the pipeline, enabling the transport layer to support the WebSocket protocol.

dubbo-remoting-websocket · high confidence

Support for application-level override rules in configurators

The ConfigParser now distinguishes between service-level and application-level configuration scopes. When a configuration specifies an application scope, the parser generates URLs with the 'application' parameter and the 'app\_dynamic\_configurators' category, enabling dynamic configuration rules to be applied at the application level rather than just per-service. This allows for broader governance rules that affect all services within a specific application.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/configurator/parser · high confidence

Support for both legacy and new Prometheus client stacks

The Prometheus metrics reporter now automatically detects and supports both the legacy and the new Prometheus client implementations. It attempts to initialize the new client first, falling back to the legacy client if the new one is unavailable, ensuring compatibility regardless of which Prometheus client library is present in the classpath.

dubbo-metrics-prometheus · high confidence

Support for label-based matching in dynamic configuration rules

The configurator parser model now supports matching rules based on application labels. New model classes (ConditionMatch, ParamMatch) and updated parsing logic in ConfigItem allow dynamic configuration rules to specify match conditions on application attributes (via the 'app' field) and specific URL parameters. This enables more granular service governance by allowing overrides and routing rules to target specific subsets of instances based on their label metadata.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/configurator/parser/model · high confidence

Support metrics collection for multiple registries

The registry metrics collector now supports tracking statistics across multiple registry instances. A new \RegistryStatComposite\ class manages metrics using a nested structure keyed by \MetricsKey\ and \ApplicationMetric\, allowing distinct counters for different registry clusters. This enables users to observe per-registry performance and status metrics rather than aggregated totals.

dubbo-metrics-registry · high confidence

Triple protocol adds support for graceful shutdown, HTTP/3 negotiation, and REST mapping conditions

The Triple protocol implementation now includes a graceful shutdown mechanism that sends HTTP/2 GOAWAY frames to clients to stop new requests while allowing existing streams to complete. It also introduces HTTP/3 ALPN negotiation on the consumer side via a dedicated client call handler, and adds a suite of REST mapping conditions (Consumes, Headers, Methods, MediaTypeExpression) to support content-type and header-based routing. Additionally, the protocol now supports Bzip2 and Gzip compression with configurable maximum message sizes, and implements a ping-pong handler to detect and close idle connections.

dubbo-rpc-triple · high confidence

Unified JSON utility with pluggable backend implementations

Dubbo now provides a standardized JSON utility layer in \dubbo-common\ that supports multiple serialization backends via a pluggable architecture. The new \AbstractJsonUtilImpl\ base class and specific implementations for Fastjson, Fastjson2, Gson, and Jackson allow the framework to automatically select the available JSON library at runtime. This change ensures consistent JSON handling across the platform, with specific behaviors such as disabling circular reference detection for Fastjson and ignoring unknown properties for Jackson.

dubbo-common/src/main/java/org/apache/dubbo/common/json/impl · high confidence

Validation filter now supports both javax and jakarta validation APIs

The validation filter in dubbo-filter-validation has been updated to support both the legacy javax.validation and the newer jakarta.validation APIs. This is achieved by introducing new SPI implementations (JValidationNew and JValidatorNew) that activate when jakarta.validation classes are present, alongside the existing JValidation/JValidator pair for javax. The AdapterValidation class now attempts to load both validator types, allowing the framework to automatically switch to the appropriate validation provider based on the available libraries in the classpath.

dubbo-plugin/dubbo-filter-validation · high confidence

Zookeeper as a Metadata Report implementation

Users can now store Dubbo service metadata in Zookeeper. This change introduces the ZookeeperMetadataReport and its factory, enabling the platform to persist provider/consumer definitions and service URLs in Zookeeper nodes, with corresponding unit tests validating the store, retrieve, and remove operations.

dubbo-metadata/dubbo-metadata-report-zookeeper · high confidence

Security

Introduce serialization allowlist and blockedlist for security hardening

Added \serialize.allowlist\ and \serialize.blockedlist\ configuration files to explicitly control which classes can be deserialized. The allowlist permits safe, standard Java types (primitives, collections, dates) and specific Dubbo internal classes, while the blockedlist prevents deserialization of known risky libraries (e.g., Spring, Hibernate, Logback, OGNL) to mitigate remote code execution vulnerabilities.

dubbo-common/src/main/resources/security · high confidence

Architecture

Refactored configuration class hierarchy in dubbo-common

The configuration classes in the \org.apache.dubbo.config\ package have been restructured into a new inheritance hierarchy to support multi-instance and modular deployment. \AbstractConfig\ now serves as the base for all configuration objects, introducing scope model management and standardized property appending. \AbstractMethodConfig\ extends this base to handle method-level settings like timeouts and retries. \AbstractInterfaceConfig\ extends \AbstractMethodConfig\ to manage interface-level concerns such as registry and protocol configurations. \AbstractReferenceConfig\ and \AbstractServiceConfig\ extend \AbstractInterfaceConfig\ to provide consumer-specific and provider-specific defaults respectively. This refactoring centralizes common configuration logic and improves modularity.

dubbo-common/src/main/java/org/apache/dubbo/config · high confidence

Refactored configuration lifecycle and bootstrap architecture

The configuration API has been restructured to introduce a new modular lifecycle model. A new \ConfigInitializer\ SPI allows dynamic parameter injection and validation for service and reference configurations, while \ConfigPostProcessor\ provides a hook for post-processing these configs. The \DubboBootstrap\ now manages the application lifecycle through a \ConfigManager\ and \ApplicationDeployer\, supporting multiple takeover modes (SPRING, MANUAL, AUTO, SERVLET) to control when the environment initializes. Additionally, a new \DubboShutdownHook\ handles graceful cleanup, coordinating with Spring contexts to prevent shutdown conflicts, and a \ServiceListener\ SPI exposes callbacks for service export and unexport events.

dubbo-config/dubbo-config-api/src/main · high confidence

Behavioural changes

1 commit (0 fixes) modifying dubbo-common/src/main/resources/META-INF/org

A change to existing behaviour in dubbo-common/src/main/resources/META-INF/org — 1 commit, 1 file: “feat(logging): \#13378 Uniformly uses log4j2 as the logging component (\#13402)” (refs \#13378, \#13402).

dubbo-common/src/main/resources/META-INF/org · low confidence · unverified

API consumer demo now uses DubboBootstrap and Zookeeper config center

The dubbo-demo-api-consumer application has been updated to initialize via DubboBootstrap instead of legacy configuration methods. It now explicitly configures a Zookeeper-based config center and metadata report, registers the service via the Triple protocol, and demonstrates generic invocation capabilities. Logging is standardized using log4j2.

dubbo-demo/dubbo-demo-api/dubbo-demo-api-consumer · high confidence

API demo provider updated to use DubboBootstrap and Zookeeper

The dubbo-demo-api-provider demo has been restructured to use the DubboBootstrap API for service registration and configuration, replacing previous initialization methods. It now explicitly configures a Zookeeper-based registry, config center, and metadata report, and includes a log4j2 configuration file for logging. The provider application demonstrates how to bootstrap a Dubbo service with these components.

dubbo-demo/dubbo-demo-api/dubbo-demo-api-provider · high confidence

Added FutureAdapter to bridge legacy Dubbo futures with CompletableFuture

A new \FutureAdapter\ class has been introduced in the \com.alibaba.dubbo.rpc.protocol.dubbo\ package to facilitate compatibility between the legacy \com.alibaba.dubbo.remoting.exchange.ResponseFuture\ interface and the modern \java.util.concurrent.CompletableFuture\. This adapter allows existing Dubbo-compatible code that relies on the older asynchronous result model to function correctly by wrapping \CompletableFuture\ instances and translating callbacks and exceptions appropriately, ensuring smooth interoperability during the transition to the newer async result handling mechanisms.

dubbo-compatible/src/main/java/com/alibaba/dubbo/rpc/protocol · high confidence

Backward-compatible cache interfaces for legacy com.alibaba.dubbo consumers

The dubbo-compatible module now provides deprecated \com.alibaba.dubbo.cache.Cache\ and \CacheFactory\ interfaces that extend their \org.apache.dubbo\ counterparts. This allows applications still referencing the old Alibaba package to continue working, with the implementation transparently delegating to the Apache equivalents via \DelegateURL\ and \Invocation.CompatibleInvocation\ wrappers.

dubbo-compatible/src/main/java/com/alibaba/dubbo/cache · high confidence

Backward-compatible wrappers for legacy com.alibaba.dubbo registry and monitor APIs

The dubbo-compatible module now includes deprecated wrapper interfaces for the legacy com.alibaba.dubbo.monitor.Monitor, MonitorFactory, and the com.alibaba.dubbo.registry.Registry, RegistryFactory, and NotifyListener APIs. These interfaces extend their org.apache.dubbo counterparts and provide default implementations that bridge between the old com.alibaba.dubbo.common.URL and the new org.apache.dubbo.common.URL using DelegateURL, allowing existing applications relying on the legacy package names to continue functioning without code changes.

dubbo-compatible/src/main/java/com/alibaba/dubbo/registry · high confidence

Cache implementation classes added to dubbo-plugin/dubbo-filter-cache

The dubbo-filter-cache module now includes the concrete cache implementation classes (ExpiringCache, JCache, LruCache, ThreadLocalCache) that back the Dubbo cache filter. These classes provide the actual storage and retrieval logic for cached method return values, enabling users to configure caching strategies (expiring, jcache, lru, threadlocal) via service/consumer XML or annotation attributes.

dubbo-filter-cache · high confidence

Configurable JSON implementation and extension loading order

Users can now customize the JSON serialization library used by Dubbo by providing their own implementation of the \org.apache.dubbo.common.json.JsonUtil\ interface, with a default fallback chain of Fastjson2, Fastjson, Gson, and Jackson. Additionally, the extension loading strategy has been updated to enforce a specific precedence order (DubboInternal, Dubbo, Services) via a new \LoadingStrategy\ service file, ensuring consistent override rules for extension loading.

dubbo-common/src/main/resources/META-INF/services · high confidence

Configurator rules now support conditional matching and version-specific application logic

The configurator logic in the cluster module has been updated to support more granular rule application. For rules with API version 3.0 or above, the system now utilizes a \ConditionMatch\ matcher to evaluate specific parameters before applying configuration changes, allowing for precise control based on current URL attributes. Additionally, the configuration process distinguishes between provider and consumer sides using the \SIDE\_KEY\ for modern versions (2.7+), while maintaining backward compatibility with deprecated port-based matching logic for older rule formats. This ensures that override rules are applied only when conditions match, preventing unintended configuration changes on mismatched hosts or services.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/configurator · high confidence

Default configuration center now uses a no-op implementation

When no external configuration center is specified, Dubbo now defaults to a no-op implementation (NopDynamicConfiguration) instead of potentially failing or behaving unexpectedly. This change ensures that configuration operations like getting or publishing config silently succeed or return null without errors, providing a safer fallback for users who do not configure a specific config center.

dubbo-common/src/main/java/org/apache/dubbo/common/config/configcenter/nop · high confidence

Deprecated @EnableDubbo annotation for backward compatibility

The legacy \@EnableDubbo\ annotation in the \com.alibaba.dubbo.config.spring.context.annotation\ package is now deprecated. It serves as a backward-compatibility shim that delegates to the modern \@DubboComponentScan\ and \@EnableDubboConfig\ annotations, allowing existing applications using the old Alibaba namespace to continue functioning while encouraging migration to the Apache Dubbo configuration model.

dubbo-compatible/src/main/java/com/alibaba/dubbo/config/spring · high confidence

Deprecated Alibaba remoting interfaces bridge to Apache Dubbo

The \dubbo-compatible\ module now provides deprecated wrapper interfaces and classes in the \com.alibaba.dubbo.remoting\ package (including \Channel\, \ChannelHandler\, \Codec\, \Codec2\, \Dispatcher\, \RemotingException\, \Server\, and \Transporter\) that extend their \org.apache.dubbo\ counterparts. These wrappers maintain backward compatibility for existing Alibaba Dubbo clients by delegating calls to the Apache implementation, with \Transporter\ specifically handling the translation between Alibaba and Apache URL and handler types via \DelegateURL\.

dubbo-compatible/src/main/java/com/alibaba/dubbo/remoting · high confidence

Deprecated legacy exchange interfaces added for backward compatibility

The dubbo-compatible module now includes deprecated stub interfaces for \Exchanger\, \ResponseCallback\, and \ResponseFuture\ under the \com.alibaba.dubbo.remoting.exchange\ package. These interfaces serve as backward-compatibility shims, allowing existing applications relying on the legacy Alibaba Dubbo API to continue functioning while encouraging migration to the corresponding \org.apache.dubbo\ equivalents.

dubbo-compatible/src/main/java/com/alibaba/dubbo/remoting/exchange · high confidence

Establishes SPI extension mappings for Dubbo core components

This change registers Service Provider Interface (SPI) implementations for Dubbo's internal infrastructure, including compilers (Adaptive, Jdk, Javassist), JSON utilities (Fastjson2, Fastjson, Gson, Jackson), logger adapters (Slf4j, Log4j2, etc.), thread pools (Fixed, Cached, Limited, Eager), and various converters. By defining these mappings in the \META-INF/dubbo\ resources, the framework ensures that core subsystems can dynamically load the correct implementations at runtime, supporting features like multi-JSON provider selection, thread pool isolation, and flexible logging backends.

dubbo-common/src/main/resources/META-INF/dubbo · high confidence

FixedThreadPool warns on unbounded queues and uses MemorySafeLinkedBlockingQueue

The FixedThreadPool implementation now logs a warning when configured with an unbounded queue (queues \< 0) to help prevent OutOfMemoryError under high load, and it utilizes the MemorySafeLinkedBlockingQueue for such configurations instead of the standard LinkedBlockingQueue.

dubbo-common/src/main/java/org/apache/dubbo/common/threadpool/support/fixed · high confidence

Hessian2 serialization refactored for scope-aware factory management and AOT support

The Hessian2 serialization module has been restructured to manage serializer factories per classloader scope, introducing \Hessian2FactoryManager\ to cache and clean up factories when classloaders are removed, and \Hessian2ClassLoaderListener\ to trigger this cleanup. This change ensures that serialization security checks (whitelist/deny patterns) and non-serializable class handling are correctly scoped to the \FrameworkModel\. Additionally, AOT (Ahead-of-Time) compatibility is improved by registering \HessianReflectionTypeDescriberRegistrar\ and \HessianResourceDescriberRegistrar\ to expose reflection and resource patterns for native image builds.

dubbo-serialization/dubbo-serialization-hessian2 · high confidence

Injvm protocol now deep-copies parameters and isolates thread context

The local (injvm) RPC protocol now creates a deep copy of method arguments before invoking the target service, preventing shared mutable state between the consumer and provider. This is implemented via a new \ParamDeepCopyUtil\ SPI and a default serialization-based \DefaultParamDeepCopyUtil\. Additionally, the \InjvmInvoker\ now clears \ThreadLocal\ data before child invocations to prevent context pollution and supports configurable async execution using the consumer's executor.

dubbo-rpc/dubbo-rpc-injvm · high confidence

Introduce dynamic URL parameter caching for improved performance

A new parameter caching mechanism has been added to the Dubbo URL component to optimize memory usage and access speed. This change introduces a \DynamicParamTable\ that acts as a global cache for URL parameters, utilizing a \DynamicParamSource\ SPI to initialize a set of common keys (such as version, side, interface, and application) with either dynamic or fixed value handlers. By mapping parameter keys and values to integer indices, the system reduces the overhead of string comparisons and lookups during URL processing, directly addressing memory performance concerns in version 3.0.

dubbo-common/src/main/java/org/apache/dubbo/common/url/component/param · high confidence

Introduce global embedded Zookeeper registry center for unit tests

The test-check module now manages a single, global embedded Zookeeper instance for unit tests instead of starting and stopping separate instances per test. New classes (AbstractRegistryCenterTestExecutionListener, RegistryCenterStarted, RegistryCenterFinished, GlobalRegistryCenter) coordinate lifecycle: the listener starts the global registry before tests in supported packages (config, test, registry, remoting-zookeeper, metadata-store-zookeeper) and shuts it down after. Zookeeper is downloaded, unpacked, and configured via initializers (DownloadZookeeperInitializer, ConfigZookeeperInitializer, etc.) with configurable ports (default 2181/2182) and admin ports (18081/18082), and the registry is reset between tests. A new DubboTestChecker listener also provides thread-unclosed checking and reporting, and a DubboTestException type is added for test-time errors.

dubbo-test/dubbo-test-check · high confidence

Introduce state-based Tag Router for dynamic routing

The tag routing capability has been refactored to use a new state-based router implementation (TagStateRouter) that extends AbstractStateRouter. This change enables the router to listen for dynamic configuration changes via ConfigurationListener, allowing tag routing rules to be updated in real-time without service restarts. The router now supports both dynamic tag groups (address-based) and static tag matching, with improved fallback logic for failover scenarios when no tagged providers are available.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/tag · high confidence

Introduction of Scoped SPI Extension Management

The extension loading mechanism in dubbo-common has been refactored to support hierarchical scopes (Framework, Application, Module, and Self). This change introduces the ExtensionDirector to manage extension lifecycles and caching within specific scopes, allowing extensions to be isolated or shared across different application and module boundaries. The SPI annotation now includes a scope parameter, and the ExtensionLoader utilizes this scope to determine instance sharing, enabling multi-instance support and better resource management in complex deployment scenarios.

dubbo-common/src/main/java/org/apache/dubbo/common/extension · high confidence

Introduction of deprecated ClusterInterceptor interface

A new ClusterInterceptor interface has been added to the cluster package, designed to operate at the outermost layer before a specific address or invoker is selected. This interface, which is marked as deprecated, provides before/after hooks and an intercept method for custom logic, along with a Listener interface for handling messages and errors. Its introduction signals a shift in how cluster-level interception is handled, likely superseding previous mechanisms like AbstractCluster enhancements.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/interceptor · high confidence

Introduction of extensible configuration bean binding and customization interfaces

The Dubbo Spring integration now exposes a new internal extension point for configuration binding via the \ConfigurationBeanBinder\ and \ConfigurationBeanCustomizer\ interfaces in the \org.apache.dubbo.config.spring.context.config\ package. This change allows the framework to bind environment properties to configuration beans and apply post-binding customizations through pluggable strategies, such as the default \DefaultConfigurationBeanBinder\ which utilizes Spring's \DataBinder\. Additionally, the \NamePropertyDefaultValueDubboConfigBeanCustomizer\ is introduced to automatically assign the bean name to the \name\ property of Dubbo config beans when it is absent, though it is marked as deprecated in favor of \DubboConfigDefaultPropertyValueBeanPostProcessor\.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/context/config · high confidence

New ConfigManager hierarchy with ConfigMode and duplicate handling

The configuration management in dubbo-common has been refactored to introduce a new \AbstractConfigManager\ base class, with specific implementations for \ConfigManager\ (application-level) and \ModuleConfigManager\ (module-level). This change introduces a \ConfigMode\ enum (STRICT, OVERRIDE, OVERRIDE\_ALL, OVERRIDE\_IF\_ABSENT, IGNORE) that allows users to control how duplicate configurations for unique types (like ApplicationConfig or ModuleConfig) are handled, rather than always throwing exceptions. The new managers use lock-free \ConcurrentHashMap\ structures for better performance and include logic to ignore or warn on duplicated equivalent configs based on the configured mode. A new \ConfigConfigurationAdapter\ also exposes config attributes via the Configuration interface.

dubbo-common/src/main/java/org/apache/dubbo/config/context · high confidence

New comparators for ordering activated and wrapper extensions

The extension loading mechanism now uses two new comparator classes, ActivateComparator and WrapperComparator, to determine the execution order of extensions. ActivateComparator orders extensions based on the @Activate annotation's before, after, and order attributes, ensuring that filters and other activated components run in the specified sequence. WrapperComparator orders wrapper extensions based on the @Wrapper annotation's order attribute, providing a consistent and predictable order for wrapper implementations.

dubbo-common/src/main/java/org/apache/dubbo/common/extension/support · high confidence

Optimized Netty4 remoting with batched writes and direct buffer handling

The Netty4 transport layer now supports batched message writing via the new Netty4BatchWriteQueue, which aggregates multiple messages into a single MultiMessage for more efficient network transmission. Additionally, the NettyBackedChannelBuffer implementation has been updated to optimize direct buffer transfers, reducing unnecessary data copying when moving bytes between Netty's ByteBuf and Dubbo's ChannelBuffer interfaces.

dubbo-remoting-netty4 · high confidence

Optimized service key generation with caching

The \ProtocolUtils.serviceKey\ method now uses a \GroupServiceKeyCache\ to cache generated service keys, reducing object allocation and improving performance for repeated lookups. This change also refactors the utility class to use \StringUtils\ for cleaner string handling.

dubbo-common/src/main/java/org/apache/dubbo/rpc/support · high confidence

Placeholder version file added to resources

A new placeholder file named 'version' has been added to the dubbo-common resources directory. This file serves as a template that will be replaced with the actual version number during the project compilation process, ensuring the correct version information is available at runtime.

dubbo-common/src/main/resources/META-INF · medium confidence

QoS command interfaces deprecated in favor of Apache API

The \BaseCommand\ interface and \CommandContext\ class in the \com.alibaba.dubbo.qos.command\ package are now marked as deprecated. These classes serve as compatibility wrappers that delegate to the new \org.apache.dubbo.qos.api\ equivalents, ensuring that existing Dubbo-compatible code continues to function while encouraging migration to the upstream Apache API.

dubbo-compatible/src/main/java/com/alibaba/dubbo/qos · high confidence

Refactored Dubbo XML schema parsing and initialization logic

The Dubbo Spring XML schema handling has been refactored to improve modularity and initialization control. The new \AnnotationBeanDefinitionParser\ now delegates the actual bean class resolution to \SpringCompatUtils\, allowing for better compatibility across Spring versions, while the common beans registration has been moved out of the parser to the \DubboNamespaceHandler\. The \DubboNamespaceHandler\ now explicitly invokes \DubboSpringInitializer.initialize()\ during the parsing phase, centralizing the initialization of Dubbo-specific beans and ensuring they are registered in the Spring context before other XML-defined beans are processed.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/schema · high confidence

Refactored Dubbo annotation processing infrastructure for Spring integration

The annotation processing logic in the Spring config module has been restructured to improve modularity and compatibility. A new abstract base class, AbstractAnnotationBeanPostProcessor, now centralizes the scanning and injection metadata logic for Dubbo annotations, replacing previous scattered implementations. The specific processors for services and references, ServiceAnnotationPostProcessor and ReferenceAnnotationBeanPostProcessor, have been updated to extend this base and utilize the new ReferenceBeanManager for resolving reference beans, ensuring consistent behavior for @DubboService, @Service, @DubboReference, and @Reference annotations. Additionally, a new DubboConfigAliasPostProcessor has been introduced to automatically register bean aliases based on the config object's ID, and the ServiceBeanNameBuilder has been refined to better handle version and group conflicts in bean naming.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/beans/factory/annotation · high confidence

Refactored Java code compilation infrastructure with thread-safe locking and Javassist builder

The compiler support module has been restructured to improve thread safety and code organization. AbstractCompiler now uses a ConcurrentHashMap-backed lock map to prevent concurrent compilation issues for the same class name. The Javassist compiler implementation has been refactored to use a new CtClassBuilder utility, which cleanly separates the construction of class metadata (imports, interfaces, methods) from the actual compilation process. Additionally, ClassUtils has been introduced to centralize class loading and primitive type handling, replacing scattered utility logic.

dubbo-common/src/main/java/org/apache/dubbo/common/compiler/support · high confidence

Refactored Nacos registry with new connection management and legacy service name deprecation

The Nacos registry implementation has been refactored to introduce dedicated connection management via NacosConnectionManager and a new NacosNamingServiceWrapper that supports Nacos batch registration. Service name handling is now centralized in NacosServiceName, and the NacosAggregateListener now detects and warns on legacy service names (those not matching the standard four-part format), signaling that support for these legacy names will be removed in the future.

dubbo-registry/dubbo-registry-nacos · high confidence

Refactored Spring initialization lifecycle with new context and listener components

The Spring integration initialization flow has been restructured to improve modularity and compatibility. The location now introduces a new \DubboSpringInitializer\ as the entry point, supported by a \DubboSpringInitContext\ to manage the binding between Spring containers and Dubbo models, and a \DubboSpringInitCustomizer\ SPI to allow programmatic customization of the initialization phase. Existing lifecycle management is split into specialized listeners: \DubboConfigApplicationListener\ handles config bean loading, \DubboDeployApplicationListener\ manages module deployment states and publishes state events, and \DubboContextPostProcessor\ initializes the environment and registers infrastructure beans. Additionally, \DubboInfraBeanRegisterPostProcessor\ ensures critical infrastructure beans like \ReferenceAnnotationBeanPostProcessor\ are registered early, while the legacy \DubboBootstrapApplicationListener\ and \DubboBootstrapStartStopListenerSpringAdapter\ are marked as deprecated.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/context · high confidence

Refactored Zookeeper config center with listener caching and metrics

The Zookeeper config center implementation has been refactored to improve performance and observability. A new caching layer (CacheListener and ZookeeperDataListener) ensures that only one Zookeeper watcher is registered per path, even when multiple application listeners are attached, reducing overhead. The change also introduces metrics publishing for configuration change events via the MetricsEventBus and adds support for optimistic concurrency control (CAS) when publishing configuration updates.

dubbo-configcenter/dubbo-configcenter-zookeeper · high confidence

Refactored cluster invoker implementations to use shared executors and async invocation

The cluster invoker implementations in the dubbo-cluster module have been refactored to improve resource management and performance. FailbackClusterInvoker now uses a HashedWheelTimer for background retries instead of blocking threads, and ForkingClusterInvoker delegates concurrent execution to a shared FrameworkExecutorRepository rather than creating local thread pools. Additionally, invocations are now performed asynchronously via invokeWithContextAsync to better support non-blocking scenarios and reduce memory allocation during address change notifications.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/support · high confidence

Refactored cluster invoker wrappers to support interceptors and runtime scope selection

The cluster support wrapper layer has been restructured to introduce new invoker wrappers that enhance request interception and local/remote invocation handling. AbstractCluster now builds a chain of ClusterFilterInvoker and InvocationInterceptorInvoker instances, allowing filters and interceptors to wrap the core cluster logic before invocation. MockClusterInvoker has been updated to correctly handle RpcException types during fail-mock scenarios, ensuring that business exceptions are propagated while other errors trigger the mock logic. Additionally, ScopeClusterInvoker now dynamically selects between local (injvm) and remote invokers at runtime based on the service scope and export status, replacing static configuration checks with a more flexible runtime decision process.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/support/wrapper · high confidence

Refactored cluster routing with dual-chain RouterChain and state routers

The cluster module's routing mechanism has been restructured to improve thread-safety and performance. A new \RouterChain\ implementation now manages routing via a dual-chain (main and backup) architecture, allowing safe, lock-free switching of invoker lists during updates. The \Router\ interface has been updated to support a new \route\ method returning a \RouterResult\, enabling better control over routing continuation and snapshot logging. Additionally, a new \StateRouter\ abstraction and \CacheableRouterFactory\ have been introduced to handle stateful routing rules (like Affinity and Condition routers) with instance caching, replacing the previous per-URL instantiation model.

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster · high confidence

Refactored configuration loading with modular environment and composite sources

The configuration loading mechanism in dubbo-common has been restructured to support a more modular and extensible approach. A new \Configuration\ interface defines the contract for property retrieval, implemented by specific sources like \SystemConfiguration\ (JVM system properties), \EnvironmentConfiguration\ (OS environment variables with flexible key normalization), \PropertiesConfiguration\ (classpath properties), and \InmemoryConfiguration\ (dynamic in-memory maps). These sources are aggregated via \CompositeConfiguration\, which enforces a strict precedence order (System → Environment → App External → External → App Config → Abstract Config → Properties) to resolve property values. The \Environment\ class now acts as the central coordinator, managing these sources and exposing them through \ConfigurationUtils\. Additionally, \ModuleEnvironment\ introduces module-scoped configuration overrides via \OrderedPropertiesProvider\, allowing extensions to inject properties with defined priorities. A new \ConfigurationCache\ provides lock-free caching for dynamic properties to improve performance, and \PrefixedConfiguration\ enables scoped property lookups.

dubbo-common/src/main/java/org/apache/dubbo/common/config · high confidence

Refactored dynamic configuration center with new event model and caching

The dynamic configuration center in dubbo-common has been refactored to improve extensibility and performance. A new event-driven model is introduced via the ConfigurationListener interface and ConfigChangedEvent, allowing applications to react to configuration changes (added, modified, deleted) rather than polling. The AbstractDynamicConfiguration base class now manages a dedicated thread pool for executing configuration tasks, ensuring non-blocking operations. Additionally, the AbstractDynamicConfigurationFactory provides a built-in cache for DynamicConfiguration instances, reducing overhead when retrieving configurations for the same URL. The API also now supports specifying a default group and timeout for configuration operations.

dubbo-common/src/main/java/org/apache/dubbo/common/config/configcenter · high confidence

Refactored metadata definition builders for service discovery

The metadata definition logic in dubbo-common has been refactored to support service discovery by introducing dedicated builder classes: MethodDefinitionBuilder, ServiceDefinitionBuilder, and TypeDefinitionBuilder. These components replace previous inline logic with structured builders that use Java Reflection to construct MethodDefinition, ServiceDefinition, and TypeDefinition objects, including handling of generic parameter types, return types, and annotations. This change improves the accuracy and maintainability of the metadata generated for service interfaces.

dubbo-common/src/main/java/org/apache/dubbo/metadata/definition · high confidence

Refactored metrics data collection and aggregation infrastructure

The metrics API module has been refactored to introduce a new, structured data collection layer. New composite containers (ApplicationStatComposite, ServiceStatComposite, MethodStatComposite, and RtStatComposite) now manage statistics at the application, service, and method levels, replacing previous ad-hoc storage with explicit initialization and export flows. A new TimeWindowQuantile class using TDigest enables sliding-window quantile calculations for response times. Additionally, the event publishing mechanism has been simplified via a new SimpleMetricsEventMulticaster that supports lifecycle events and filters out events when application configuration is missing.

dubbo-metrics-api · high confidence

Refactored reference bean registration and configuration model

The reference bean registration logic has been restructured to use a new \ReferenceBeanManager\ that tracks beans via a \referenceKeyMap\ (mapping keys to \CopyOnWriteArrayList\s of bean names) and a \referenceAliasMap\, replacing the previous flat caching approach. A new \ReferenceAttributes\ interface centralizes all attribute names for \@DubboReference\ and \ReferenceConfig\, and \ReferenceBeanBuilder\ provides a fluent API for constructing reference beans in Java config. \ReferenceBeanSupport\ now handles attribute conversion (e.g., \registry\ array to \registryIds\ string) and reference key generation, while \ReferenceCreator\ manages the actual \ReferenceConfig\ instantiation with improved module model integration. This change improves how duplicate references are detected and how reference configurations are resolved and initialized.

dubbo-config/dubbo-config-spring/src/main/java/org/apache/dubbo/config/spring/reference · high confidence

Refined metadata parameter filtering and new service-to-app mapping events

The metadata reporting mechanism now distinguishes between service-level and instance-level parameters: the new DefaultMetadataParamsFilter explicitly excludes infrastructure and operational keys (such as QoS settings, validation, and PIDs) from service metadata while including specific instance keys like heartbeat timeout, timestamp, and IPv6 support. Additionally, a new MappingChangedEvent class has been introduced to notify listeners when the mapping between a service key and its associated applications changes, enabling better tracking of service-to-app relationships.

dubbo-metadata-api · high confidence

Register Spring-specific Dubbo extension implementations

The Spring configuration module now registers several Spring-specific extension implementations via META-INF service files. This includes the SpringExtensionInjector for dependency injection, SpringStatusChecker and DataSourceStatusChecker for health status reporting, SpringParameterNameReader for reading parameter names, DubboBootstrapStartStopListenerSpringAdapter for lifecycle management, and SpringScopeModelInitializer for scope model initialization. These registrations enable Dubbo to integrate with the Spring framework's lifecycle and dependency injection mechanisms.

dubbo-config/dubbo-config-spring/src/main/resources/META-INF/dubbo · high confidence

Service discovery migration and registry retry improvements

The registry module now supports migrating from interface-based address pools to instance-based address pools via the new ServiceInstancesChangedListener and DefaultMigrationAddressComparator, allowing consumers to switch to service discovery addresses based on a configurable threshold. Additionally, the FailbackRegistry implementation has been enhanced to improve reliability by optimizing retry logic for failed registration, subscription, and unsubscription operations.

dubbo-registry-api · high confidence

Support for Object-typed attachments and enhanced RPC context handling

The RPC API now supports attachments with Object values (Map\<String, Object\>) in addition to the previous String-only model, enabling richer data exchange in RpcContext, Invocation, and Result. This change introduces AttachmentsAdapter and RpcServerContextAttachment to manage the new type, updates ContextFilter to handle object attachments and filter specific keys, and adds FutureAdapter to properly unwrap async results for users.

dubbo-rpc-api · high confidence

Updated Maven Wrapper to version 3.1.1 with Maven 3.9.9 distribution

The Maven wrapper configuration has been updated to use Maven Wrapper version 3.1.1 and the Apache Maven 3.9.9 distribution. This ensures that local builds and CI pipelines use a consistent, specified version of Maven, eliminating potential discrepancies caused by different local Maven installations.

.mvn/wrapper · high confidence

Fixes

Added JVM configuration for Maven builds

A new \.mvn/jvm.config\ file has been added to enforce UTF-8 encoding for file, standard output, and standard error streams during Maven builds. This ensures consistent character encoding across the build process.

.mvn · medium confidence

Test coverage

Added API definition files for Dubbo-compatible config classes; Added JavaScript router rule test resources; Added Nacos registry demo test fixtures; Added SPI test fixtures for dubbo-common; Added SPI test fixtures for metrics, registry, and RPC filters; Added Spring integration tests for Dubbo initialization customization; Added Zookeeper-based Spring integration sample tests; Added ZookeeperInitializer for test registry center setup; Added concurrency and static directory tests for the cluster module; Added dependency consistency tests for Dubbo modules; Added mock registry and service discovery test utilities; Added regression tests for Dubbo Spring configuration issues \#6000 and \#6252; Added serialization allowlist and blockedlist test resources; Added serialization allowlist test resource; Added test SPI registrations for mock and integration listeners; Added test SPI service files for extension loading scenarios; Added test certificates for dynamic certificate support; Added test configuration classes for consumer-side @Reference and @DubboReference annotations; Added test configuration file for Dubbo API; Added test configuration files for Dubbo Spring integration; Added test configuration files for Zookeeper service introspection; Added test configuration files for issues 6000, 6252, 7003, 9172, and 9207; Added test configuration files for logging and caching; Added test fixture for annotation-based consumer configuration; Added test fixtures and unit tests for Dubbo Spring annotation configuration; Added test fixtures and unit tests for common module components; Added test fixtures for complex object serialization in dubbo-compatible; Added test fixtures for merged annotation attributes; Added test for ConfigCenterBean external configuration loading; Added test for Dubbo keeping running after Spring context closure; Added test for duplicate DubboReference deduplication; Added test for local call reference mixing; Added test for multiple consumer and provider configurations; Added test implementation classes for Dubbo Spring config tests; Added test infrastructure and unit tests for dubbo-config-spring; Added test interfaces for the Spring API module; Added test provider implementations and configuration for annotation-based service scanning; Added test resource files for Dubbo Spring configuration; Added test resource files for Dubbo cluster SPI registrations; Added test resource files for Dubbo configuration and extension loading; Added test resources for Dubbo cluster routing and configuration rules; Added test resources for bytecode, extension, and serialization tests; Added test resources for dubbo-common; Added test version configuration for dubbo-common; Added tests for DefaultFilterChainBuilder invoker chain construction; Added tests for Dubbo XML consumer and provider configurations with N/A registry; Added tests for Dubbo schema configuration and generic service handling; Added tests for GenericImplFilter exception handling; Added tests for Spring Boot configuration property binding and reference bean conditionals; Added tests for Spring context reloading with Dubbo init customizers; Added tests for Spring property placeholder resolution in Dubbo consumers; Added tests for cluster router compatibility and sorting; Added tests for local (in-JVM) service calls; Added tests for metadata annotation processing type builders; Added tests for per-service thread pool isolation in Spring configuration; Added tests for the custom MySerialization implementation; Added unit tests for Affinity Service State Router; Added unit tests for AppScriptStateRouter; Added unit tests for BitList; Added unit tests for ConditionStateRouter; Added unit tests for Configurator parsing and Sticky cluster invoker behavior; Added unit tests for DefaultDubboConfigBinder; Added unit tests for Dubbo Spring annotation configuration; Added unit tests for Dubbo Spring annotation processing; Added unit tests for Dubbo cluster configurators; Added unit tests for Dubbo config bean initialization and reference key generation; Added unit tests for Dubbo config bean post-processor and YAML property source factory; Added unit tests for Dubbo configuration classes and multi-classloader demo services; Added unit tests for Dubbo load balancing strategies; Added unit tests for Dubbo-compatible configuration classes; Added unit tests for Dubbo-compatible extension loading and annotation utilities; Added unit tests for FileRouterEngine; Added unit tests for Java-based Dubbo reference configuration; Added unit tests for MockInvokersSelector; Added unit tests for NacosServiceName; Added unit tests for RouterSnapshotFilter; Added unit tests for RpcContext future handling; Added unit tests for ScriptStateRouter; Added unit tests for Spring Extension Injector behavior; Added unit tests for Spring status checkers; Added unit tests for TagStateRouter; Added unit tests for ZoneAwareClusterInvoker; Added unit tests for cluster invoker support classes; Added unit tests for cluster result mergers; Added unit tests for cluster wrapper invokers and filters; Added unit tests for generic and echo service compatibility; Added unit tests for local call reference annotations; Added unit tests for mesh routing rule components; Added unit tests for mesh routing rule parsing; Added unit tests for mesh virtual service match rules; Added unit tests for the Dubbo-compatible filter module; Added unit tests for v3.1 condition router and provider application routing; New test utilities and demo service implementations added.

Dependencies

2079 commits updating dependencies (119 manifests)

A dependency / build maintenance change in (dependencies) — 2079 commits (144 fixs), 119 files: “Bump netty4\_version from 4.1.116.Final to 4.1.117.Final (\#15080)”; “Bump jackson\_version from 2.16.0 to 2.16.1 (\#13566)”; “Bump org.apache.maven.plugins:maven-surefire-plugin from 3.5.1 to 3.5.2 (\#14855)”; and 1999 more (refs \#15080, \#13566, \#14855, \#14607, \#15944, …).

(dependencies) · high confidence · unverified

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 37 → 38 (+1.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 59 → 59 (+0.0)
  • Architecture 77 → 77 (-0.0)
  • Maturity 55 → 67 (+12.8)
  • Readiness 60 → 60 (+0.0)
  • Security 72 → 64 (-8.2)
  • Domain Modelling 10 → 10 (+0.0)
  • Performance 79 → 100 (+21.1)

Resolved (939)

  • Concentrated knowledge decay
  • Critical CVE: [GHSA redacted] (dubbo-plugin/dubbo-filter-cache/pom.xml)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (10 lines × 2) (dubbo-registry/dubbo-registry-api/src/main/java/org/apache/dubbo/registry/client/ServiceDiscoveryRegistryDirectory.java)
  • Duplicated block (11 lines × 3) (dubbo-common/src/main/java/org/apache/dubbo/config/ConfigCenterConfig.java)
  • Duplicated block (15 lines × 2) (dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/argument/GeneralTypeConverter.java)
  • Duplicated block (17 lines × 2) (dubbo-plugin/dubbo-filter-validation/src/main/java/org/apache/dubbo/validation/support/jvalidation/JValidator.java)
  • Duplicated block (35 lines × 2) (dubbo-plugin/dubbo-filter-validation/src/main/java/org/apache/dubbo/validation/support/jvalidation/JValidator.java)
  • Duplicated block (6 lines × 6) (dubbo-plugin/dubbo-qos/src/main/java/org/apache/dubbo/qos/command/impl/GetAddress.java)
  • Duplicated block (7 lines × 2) (dubbo-plugin/dubbo-qos/src/main/java/org/apache/dubbo/qos/command/impl/GetAddress.java)
  • Duplicated block (9 lines × 2) (dubbo-plugin/dubbo-filter-validation/src/main/java/org/apache/dubbo/validation/support/jvalidation/JValidator.java)
  • Members sharing a duplicated core (4 members, 50+ identical tokens) (dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/affinity/config/AffinityProviderAppStateRouter.java)
  • Members sharing a duplicated core (5 members, 50+ identical tokens) (dubbo-remoting/dubbo-remoting-http3/src/main/java/org/apache/dubbo/remoting/transport/netty4/NettyHttp3Server.java)
  • Most significant orphaned file (dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/aggregate/DubboMergingDigest.java)
  • Most significant orphaned file (dubbo-remoting/dubbo-remoting-api/src/main/java/org/apache/dubbo/remoting/buffer/ChannelBuffer.java)
  • Most significant orphaned file (dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/argument/GeneralTypeConverter.java)
  • Near-duplicate member pair (39 shared lines) (dubbo-plugin/dubbo-qos/src/main/java/org/apache/dubbo/qos/command/impl/GetAddress.java)
  • Off-boarding risk: anonymized user #1
  • Orphaned file (dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/Configurator.java)
  • Orphaned file (dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/Constants.java)
  • …and 919 more

New (47)

  • Dependency hygiene PARTLY measured — Maven build resolved part of the dependency graph, currency reported but not scored
  • Duplicated block (11 lines × 2) (dubbo-remoting/dubbo-remoting-netty4/src/main/java/org/apache/dubbo/remoting/transport/netty4/NettyPortUnificationServer.java)
  • Duplicated block (6 lines × 6) (dubbo-plugin/dubbo-qos/src/main/java/org/apache/dubbo/qos/command/impl/GetAddress.java)
  • High IaC: DS-0002 (dubbo-plugin/dubbo-native/target/classes/Dockerfile)
  • High IaC: DS-0029 (dubbo-plugin/dubbo-native/target/classes/Dockerfile)
  • Members sharing a duplicated core (4 members, 50+ identical tokens) (dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/affinity/config/AffinityProviderAppStateRouter.java)
  • Members sharing a duplicated core (5 members, 50+ identical tokens) (dubbo-remoting/dubbo-remoting-http3/src/main/java/org/apache/dubbo/remoting/transport/netty4/NettyHttp3Server.java)
  • Near-duplicate member pair (39 shared lines) (dubbo-plugin/dubbo-qos/src/main/java/org/apache/dubbo/qos/command/impl/GetAddress.java)
  • No assertions (empty test): testBuild (dubbo-compatible/src/test/java/org/apache/dubbo/metadata/annotation/processing/builder/GeneralTypeDefinitionBuilderTest.java)
  • No assertions (empty test): testRestore (dubbo-rpc/dubbo-rpc-api/src/test/java/org/apache/dubbo/rpc/RpcContextTest.java)
  • No assertions: testBuild (dubbo-metadata/dubbo-metadata-processor/src/test/java/org/apache/dubbo/metadata/annotation/processing/builder/CollectionTypeDefinitionBuilderTest.java)
  • No assertions: testBuild (dubbo-metadata/dubbo-metadata-processor/src/test/java/org/apache/dubbo/metadata/annotation/processing/builder/SimpleTypeDefinitionBuilderTest.java)
  • No assertions: testCompile (dubbo-compatible/src/test/java/org/apache/dubbo/metadata/tools/CompilerTest.java)
  • No assertions: testInfo (dubbo-compatible/src/test/java/org/apache/dubbo/metadata/annotation/processing/util/LoggerUtilsTest.java)
  • No assertions: testInjvm (dubbo-compatible/src/test/java/org/apache/dubbo/config/ReferenceConfigTest.java)
  • No assertions: testWarn (dubbo-compatible/src/test/java/org/apache/dubbo/metadata/annotation/processing/util/LoggerUtilsTest.java)
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2
  • Outdated (compile (optional) -- module com.fasterxml.jackson.annotation): com.fasterxml.jackson.core:jackson-annotations
  • Outdated (compile (optional) -- module com.fasterxml.jackson.core): com.fasterxml.jackson.core:jackson-core
  • …and 27 more

Changes since last survey

  • 14 commits — 8 feature/other, 6 fixes

By area

  • (root) — 4 commits
  • dubbo-cluster/src — 2 commits
  • dubbo-common/src — 2 commits
  • dubbo-plugin/dubbo-triple-servlet — 1 commit
  • dubbo-registry/dubbo-registry-multicast — 1 commit
  • dubbo-remoting/dubbo-remoting-http12 — 1 commit
  • dubbo-remoting/dubbo-remoting-netty4 — 1 commit
  • dubbo-rpc/dubbo-rpc-triple — 1 commit
  • dubbo-serialization/dubbo-serialization-api — 1 commit

Notable commits

  • fix: Fix DefaultSerializationExceptionWrapper hiding Cleanable from codecs (#16538)
  • fix: Fix HTTP request authority port parsing (#16551)
  • fix: Fix application script routing after rule deletion (#16549)
  • fix: Fix application state router isolation across service chains (#16546)
  • fix: Fix the servlet encodeURL methods and the root context path (#16564)
  • fix: [Fix] Bound the connect timeout of the multicast liveness probe (#16542)
  • change: Bump to 3.3.8-SNAPSHOT
  • change: Fix typo in StringConverter Javadoc (covert → convert) (#16540)
  • change: Hash only the bytes read from a stream in Bytes.getMD5 (#16543)
  • change: Honor keep-alive configuration in the port-unification server (#16562)
  • change: Keep '+' in Triple REST path and matrix variables (#16560)
  • change: Prepare 3.3.7 release (#16579)
  • change: Update version compatibility table with links
  • change: docs: fix mismatched version links in README (#16539)

Architecture

  • Unchanged — 0 containers · 34 contexts · 99 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

apache/dubbo was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 10 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 1cf125c421691ab2b3f1b82f0125be03eff338c9 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.12+preprod-0a1a03138314.