apache/dubbo

This system is a high-performance, distributed RPC framework that manages service-to-service communication through a modular cluster layer. It provides dynamic traffic routing, load balancing, and governance rules that can be updated at runtime without restarting services. The architecture supports multi-instance isolation, secure serialization, and seamless integration with Spring and service mesh environments.

127 changes.

This period focused on refactoring Dubbo's core infrastructure to support multi-instance and module-scoped architectures, introducing new abstractions for configuration, extension loading, and thread management. The work also standardized the codebase with comprehensive test coverage, logging, and backward compatibility layers for legacy APIs.

111 changes.

This period focused on a comprehensive architectural refactoring to support multi-instance and multi-module scenarios, introducing a hierarchical lifecycle model (Application, Framework, Module) and a new configuration management system. The team also overhauled the Spring integration layer, implemented state-based routing for traffic management, and added extensive test coverage for these new structures.

67 changes.

This period focused on significantly expanding Dubbo's observability and protocol support. The team introduced comprehensive metrics, tracing, and health monitoring capabilities, alongside new serialization and security features. Additionally, the framework was extended to support modern web protocols like HTTP/2, HTTP/3, and WebSocket, while also integrating with Spring Boot 3 and native image compilation.

The \dubbo-maven-plugin\ now includes a new \aot\ sub-package containing the \DubboProcessAotMojo\ and supporting classes to enable Ahead-of-Time (AOT) compilation. This feature allows users to configure dependency filtering (includes/excludes), pass JVM system properties and arguments, and manage the AOT generation and compilation lifecycle phases. The implementation introduces new Mojos and utilities for handling AOT assets, command-line building, and Java process execution, effectively adding a new capability for native image and AOT processing within the Maven plugin.

dubbo-maven-plugin · high confidence

The dubbo-demo-api-provider module now includes a new demo application that registers a service using the DubboBootstrap API. This demo is configured to use Zookeeper as the registry, config center, and metadata reporting backend, providing a concrete example of how to wire up these components programmatically.

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

A new compatibility class, AbstractLoadBalance, has been added to the Alibaba Dubbo package. This class implements the LoadBalance interface and provides a default select method that delegates to an abstract doSelect method, along with weight calculation logic that accounts for warmup periods. This change enables existing Alibaba Dubbo applications to function with the Apache Dubbo runtime by providing the necessary abstract base class for load balancing strategies.

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

A new CompositeDynamicConfiguration class has been introduced in the dubbo-common module. This class implements the DynamicConfiguration interface and allows multiple configuration centers to be combined into a single logical configuration source. It iterates through all registered configuration instances to perform operations such as adding or removing listeners, retrieving configuration values, and publishing configurations, effectively enabling a fallback or aggregation strategy across different config centers.

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

The \dubbo-compatible\ module now provides a set of deprecated wrapper classes and interfaces under the \com.alibaba.dubbo\ package (including \Constants\, \URL\, \DelegateURL\, \Compiler\, \Activate\, \ExtensionFactory\, \LoggerAdapter\, \ObjectInput\/\ObjectOutput\, \Serialization\, \Status\, \StatusChecker\, \DataStore\, \ThreadPool\, and \UrlUtils\). These classes implement or extend their \org.apache.dubbo\ counterparts, allowing applications using the older Alibaba Dubbo API to continue functioning by delegating to the new Apache Dubbo implementations.

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

Added a new invocation profiler in the common module, consisting of the Profiler, ProfilerEntry, and ProfilerSwitch classes. This introduces a mechanism to track and measure the duration of Dubbo invocations, with configurable enable/disable switches for simple and detailed profiling modes, and a warning threshold for performance analysis.

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

Introduces a new Dubbo MCP (Model Context Protocol) integration plugin that enables exposing Dubbo services as MCP tools. The plugin includes annotations (@McpTool, @McpToolParam) for configuring tool exposure, a service filter for managing which services and methods are exposed, and core components for handling SSE and streamable transport protocols. The implementation registers and unregisters tools dynamically as services are exported or unexported, supporting both SSE and streamable transport modes.

dubbo-plugin/dubbo-mcp · high confidence

The mesh router now supports Dubbo-specific routing rules, introducing new model classes for virtual services, destination rules, and match conditions. This includes \VirtualServiceRule\ and \VirtualServiceSpec\ to define host and Dubbo route configurations, alongside \DubboRoute\ and \DubboRouteDetail\ for routing details. The change also adds \DestinationRule\ and \DestinationRuleSpec\ to manage traffic policies, subsets, and load balancing settings. Additionally, a comprehensive set of match classes (\DubboMatchRequest\, \DubboMethodMatch\, \DubboAttachmentMatch\, etc.) are introduced to enable matching against Dubbo method names, arguments, attachments, and headers, allowing for fine-grained traffic management based on Dubbo-specific request attributes.

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

Introduces a new Fastjson2 serialization implementation for Dubbo, including the core ObjectInput and ObjectOutput classes, a creator manager for handling class loaders, and a security manager for serializable class checks. The module registers the FastJson2Serialization extension and provides a scope model initializer to wire up the necessary beans, enabling users to select 'fastjson2' as a serialization protocol.

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

The Dubbo common module now includes a new \HashedWheelTimer\ implementation for scheduling one-time timeout tasks in a background thread. This introduces the \Timer\, \Timeout\, and \TimerTask\ interfaces along with the \HashedWheelTimer\ class, enabling applications to schedule tasks for delayed execution with approximate timing, which is suitable for most network I/O timeout scenarios.

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

The Dubbo REST protocol now supports JAX-RS style annotations (such as @Path, @QueryParam, @HeaderParam, @CookieParam, @FormParam, and @BeanParam) for resolving method and parameter metadata. This change introduces a new set of argument resolvers and adapters (e.g., JaxrsHttpRequestAdapter, JaxrsHttpResponseAdapter) that bridge Dubbo's internal HTTP request/response objects to the JAX-RS API, enabling developers to use standard JAX-RS annotations to define REST endpoints and handle incoming requests.

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

The Dubbo common module now includes a new JCL (Apache Commons Logging) logger adapter. This adds support for routing Dubbo's internal logging through the Apache Commons Logging API, allowing users who rely on that specific logging bridge to capture Dubbo's log output. The implementation provides a full set of logging methods (trace, debug, info, warn, error) and level-checking methods, delegating to the underlying Commons Logging instance.

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

The logging subsystem now includes new implementations for the JDK logging API (JdkLogger, JdkLoggerAdapter) and Log4j (Log4jLogger, Log4jLoggerAdapter). These provide concrete backends for Dubbo's internal logging, allowing users to route Dubbo logs through the standard Java logging framework or Log4j, with support for log levels, file output, and message formatting.

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

The Dubbo common module now includes a dedicated Log4j2 logging adapter (Log4j2LoggerAdapter) and its corresponding implementation (Log4j2Logger). This change enables Dubbo to route its internal logs through the Log4j2 framework, allowing users to configure logging levels and output destinations via Log4j2 configuration files.

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

The Multicast registry implementation is added, introducing the \MulticastRegistry\ class that handles UDP multicast communication for service registration and discovery. The change includes the \MulticastRegistryFactory\ and \MulticastServiceDiscovery\ classes to support the new registry type, along with corresponding SPI configuration files and unit tests to verify registry creation and availability.

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

Introduces a new OTLP (OpenTelemetry Protocol) metrics reporter for Dubbo, enabling the export of JVM and application metrics to an OTLP-compatible endpoint. The change adds the \OtlpMetricsReporter\ and its factory, along with a service provider configuration, allowing users to configure metrics export via the \otlp\ protocol. A test suite verifies that JVM metrics are correctly exported to a mock server.

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

The Dubbo framework now includes a new \ProtobufTypeBuilder\ component that automatically detects and processes Google Protobuf message types during metadata analysis. This addition enables the system to correctly parse and expose the structure of Protobuf-based services, allowing users to inspect and utilize metadata for Protobuf-defined interfaces alongside standard Java types.

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

The Dubbo common module now includes a new SLF4J-based logging implementation. The \Slf4jLogger\ class wraps \org.slf4j.Logger\ and \LocationAwareLogger\ instances, supporting all standard log levels (trace, debug, info, warn) with message formatting and exception handling. The \Slf4jLoggerAdapter\ provides the factory for creating these logger instances and detects whether the SLF4J runtime is available. This change enables Dubbo applications to route their internal logs through the SLF4J framework, allowing users to configure logging via standard SLF4J mechanisms.

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

This change introduces the Spring Boot 1.x compatible implementations for Dubbo's actuator and configuration binding. It adds the \DubboEndpoint\ and \DubboMvcEndpoint\ to expose Dubbo metadata and configuration via Spring Boot Actuator endpoints, and introduces \RelaxedDubboConfigBinder\ to support relaxed property binding for Dubbo configuration classes. These components are registered via Spring's auto-configuration and management context mechanisms, enabling users to access Dubbo runtime information and manage configurations through standard Spring Boot interfaces.

dubbo-spring-boot-project/dubbo-spring-boot-compatible/dubbo-spring-boot-actuator-autoconfigure-compatible, dubbo-spring-boot-project/dubbo-spring-boot-compatible/dubbo-spring-boot-autoconfigure-compatible · high confidence

The Dubbo Spring Boot autoconfigure module now includes dedicated auto-configuration for Spring Boot 3, enabling the Triple protocol (servlet and WebSocket) and Micrometer-based tracing/observation. A new \DubboTriple3AutoConfiguration\ registers filters for the Triple protocol and WebSocket, while \DubboMicrometerTracingAutoConfiguration\ and \DubboObservationAutoConfiguration\ integrate Dubbo with Micrometer tracing and observation. A \SpringBoot3Condition\ ensures these components are only loaded on Spring Boot 3.x, whereas existing configurations for Spring Boot 1.2/2.x remain for older versions. Additionally, a dependency check configuration (\DubboSpringBoot3DependencyCheckAutoConfiguration\) validates that the necessary Spring Boot 3 dependencies are present.

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

The Dubbo Spring Boot starter now includes a new \dubbo-spring-boot-actuator-autoconfigure\ module that automatically registers Spring Boot Actuator components. This includes a \DubboHealthIndicator\ for monitoring Dubbo service status, several metadata endpoints (\DubboConfigsMetadataEndpoint\, \DubboPropertiesMetadataEndpoint\, \DubboServicesMetadataEndpoint\, \DubboReferencesMetadataEndpoint\) for inspecting configuration and service states, a \DubboShutdownEndpoint\ for graceful shutdown, and a \DubboMetricsBinder\ for exposing Micrometer metrics. These features are enabled by default and can be controlled via properties like \management.health.dubbo.enabled\ and \management.endpoint.dubbo.\*.enabled\.

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

Introduced a new Spring Boot IDL demo module containing a provider and consumer application. The provider exposes a gRPC-style GreeterService and a MessageService, defined via helloworld.proto and message.proto respectively, and includes a unit test verifying schema descriptor registration. The consumer application demonstrates calling the GreeterService using Spring Boot and Dubbo annotations.

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

A new Spring Boot-based consumer demo has been added, providing a ready-to-run example of a Dubbo consumer. The package includes the main application class (ConsumerApplication) that demonstrates both synchronous and asynchronous service invocation, along with the corresponding configuration (application.yml) for ZooKeeper registry and protocol settings, and a Log4j2 logging configuration (log4j2.xml) to support structured logging in the demo.

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

The dubbo-triple-websocket module now includes new Java classes (TripleEndpoint, TripleBinaryMessageHandler, TripleTextMessageHandler, TripleWebSocketFilter, etc.) that enable the Dubbo Triple protocol to operate over WebSocket connections. This allows clients to establish a persistent, bidirectional communication channel using the Triple protocol, improving real-time data exchange capabilities for Dubbo services.

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

Users can now secure Dubbo services using either access key-based authentication or basic authentication. The access key method signs requests with a timestamp and signature, while the basic method encodes username and password in the Authorization header. Both are enabled via the 'auth' parameter and can be selected using the 'authenticator' parameter (values 'accesskey' or 'basic').

dubbo-plugin/dubbo-auth · high confidence

The Dubbo cluster module introduces new condition-based routers for application and service levels. This includes \AppStateRouter\ and \ServiceStateRouter\ (along with their respective factories), which listen to dynamic configuration changes to apply routing rules. The \ListenableStateRouter\ base class handles parsing and applying these rules, supporting both single and multi-destination condition routing. This enables dynamic, configuration-driven routing at the application and service levels.

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

The dubbo-filter-cache module now includes the CacheFilter which enables caching of method return values for both consumers and providers. The module provides several cache implementations: LRU (Least Recently Used), LFU (Least Frequently Used), ThreadLocal, JCache (JSR-107), and Expiring caches, each with specific configuration parameters (e.g., cache.size, cache.evictionFactor, cache.seconds). The filter checks the cache for a given method invocation and returns cached values if available, otherwise invoking the remote method and caching the result.

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

New interfaces have been added to the \com.alibaba.dubbo.rpc.cluster\ package (\Cluster\, \Configurator\, \ConfiguratorFactory\, \Directory\, \LoadBalance\, \Merger\, \Router\, \RouterFactory\, and \RuleConverter\). These interfaces extend the modern Apache Dubbo equivalents and provide a compatibility layer that translates between the legacy \com.alibaba.dubbo\ types and the current \org.apache.dubbo\ types, allowing older code to function alongside the updated framework.

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

New compatibility classes have been added to the \com.alibaba.dubbo.config\ package, including \ApplicationConfig\, \ArgumentConfig\, \ConsumerConfig\, \MethodConfig\, \ModuleConfig\, \MonitorConfig\, \ProtocolConfig\, \ProviderConfig\, \ReferenceConfig\, \RegistryConfig\, and \ServiceConfig\. These classes extend their \org.apache.dubbo.config\ counterparts and are marked as \@Deprecated\, providing a migration path for users still relying on the legacy \com.alibaba.dubbo\ package structure.

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

Users can now store and manage configuration in local files via the new \FileSystemDynamicConfiguration\ implementation. This adds a file-based config center that watches for file changes and supports listener-based configuration updates, with a corresponding factory registration in \META-INF/dubbo/internal/org.apache.dubbo.common.config.configcenter.DynamicConfigurationFactory\.

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

Introduced new thread pool utilities in the \dubbo-common\ module to prevent OutOfMemoryError caused by unbounded queues. This includes \MemoryLimitCalculator\ for tracking JVM free memory, \MemoryLimiter\ for enforcing memory limits, and two new queue implementations: \MemoryLimitedLinkedBlockingQueue\ which uses the \Instrumentation\ API to track object sizes, and \MemorySafeLinkedBlockingQueue\ which uses \MemoryLimitCalculator\ to reject or discard tasks when free memory is exhausted.

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

A new metrics collection module for the configuration center has been introduced, enabling users to track configuration change events (additions, updates, deletions) across supported protocols like Nacos, Apollo, and Zookeeper. This includes a new \ConfigCenterMetricsCollector\ that aggregates change counts by key, group, and protocol, exposing them as gauge metrics for monitoring and alerting purposes.

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

A new state-based router implementation for mock functionality has been introduced. The \MockInvokersSelector\ now separates available invokers into 'normal' and 'mocked' lists, allowing the system to route requests to mock implementations when the \invocation.need.mock\ flag is set to true. This is wired via the \MockStateRouterFactory\, which registers the mock router with a high priority (order -100) to ensure it is evaluated early in the routing chain.

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

The \dubbo-common\ module introduces a new \convert.multiple\ package containing a \MultiValueConverter\ interface and a suite of implementations that convert comma-separated strings into various Java collection types. Specifically, the update adds converters for \List\, \Set\, \Deque\, \Queue\, \Collection\, \Iterable\, \Array\, and concurrent collections like \BlockingQueue\ and \TransferQueue\. This enables the framework to automatically parse string parameters into these multi-value structures during RPC calls.

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

The dubbo-compiler module now generates Dubbo3 Triple stubs with support for reactive programming models. In addition to the standard synchronous and async stubs, the compiler now produces interfaces and implementations using Project Reactor (Flux/Mono) and SmallRye Mutiny (Uni/Multi). This allows developers to integrate Dubbo3 services directly into reactive streams workflows.

dubbo-plugin/dubbo-compiler · high confidence

The dubbo-reactive module now provides a complete implementation for the Triple protocol using the Reactive Streams API. This includes new classes for client and server-side reactive publishers and subscribers (e.g., \AbstractTripleReactorPublisher\, \AbstractTripleReactorSubscriber\), as well as call handlers (\ReactorClientCalls\, \ReactorServerCalls\) that map Triple stream calls to Reactor \Mono\ and \Flux\ types. This enables developers to use reactive programming patterns for all four RPC styles (unary, server stream, client stream, and bidirectional streams) over the Triple protocol.

dubbo-plugin/dubbo-reactive · high confidence

The dubbo-spring6-security plugin now includes a new \OAuth2SecurityModule\ that registers Jackson mix-ins for Spring Security OAuth2 classes, including \OAuth2AuthenticatedPrincipal\, \BearerTokenAuthentication\, \OAuth2ClientAuthenticationToken\, \RegisteredClient\, and related settings. This enables proper serialization and deserialization of these security objects within the Dubbo framework. A corresponding \ObjectMapperCodecCustomer\ implementation and test suite are also added to verify the new functionality.

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

A new servlet-based demo application has been added to the Dubbo Spring Boot module, providing a complete example of using Dubbo's Triple protocol in a servlet container. The demo includes a provider and consumer that demonstrate standard RPC, asynchronous calls, server-side streaming, bidirectional streaming, and Server-Sent Events (SSE) support. Configuration files enable the Triple protocol on port 8082 and the servlet-based REST interface, allowing users to see how to implement and consume Dubbo services in a traditional servlet environment.

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

The Dubbo loom plugin now includes a new \VirtualThreadPool\ implementation that leverages Java's virtual threads (Project Loom) for handling concurrent tasks. This change introduces a new thread pool strategy that can be selected via the \virtual\ key in the \ThreadPool\ SPI, allowing users to configure thread pools to use virtual threads for improved scalability. The implementation supports optional configuration of the core thread count and thread naming, and includes corresponding unit tests to verify the behavior on Java 21 and later.

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

The dubbo-mutiny plugin now provides full support for reactive streams using the Mutiny library. This includes new classes for client and server-side handling of unary, streaming, and bidirectional streaming calls, enabling developers to use Mutiny's Uni and Multi types for Dubbo RPC calls. The implementation bridges the gap between Dubbo's traditional observer-based API and the reactive streams model, allowing for more flexible and asynchronous service interactions.

dubbo-plugin/dubbo-mutiny · high confidence

New page handler implementations are introduced in the \dubbo-compatible\ module to expose system diagnostics and navigation via the container's page interface. \SystemPageHandler\ displays environment details such as version, host, OS, JVM, CPU, locale, and uptime. \StatusPageHandler\ aggregates and displays the health status of registered \StatusChecker\ extensions, providing both a summary and detailed per-checker views. \LogPageHandler\ reads and displays the contents of the root log4j file appender, while \HomePageHandler\ generates a navigation menu linking to all available page handlers. These additions enhance the built-in monitoring and debugging capabilities of the Dubbo container.

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

A new event-driven mechanism has been introduced to notify users when the Dubbo thread pool becomes exhausted. This includes a new \ThreadPoolExhaustedEvent\ class to carry the exhaustion message and a \ThreadPoolExhaustedListener\ interface that allows external components to register for these notifications, enabling better observability and handling of thread pool saturation scenarios.

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

The dubbo-filter-validation module introduces a new validation filter that intercepts RPC invocations to perform parameter validation before method execution. This includes the core \ValidationFilter\ and SPI configuration files that wire the filter into the Dubbo framework. The change adds support for two distinct validation providers: \JValidator\ for the older \javax.validation\ API and \JValidatorNew\ for the newer \jakarta.validation\ API. Both implementations utilize dynamic class generation via Javassist to create parameter beans for validation. A \MethodValidated\ annotation is also added to support group-based validation scenarios. The entry also includes comprehensive unit tests for the filter and validators.

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

A new AotWithSpringDetector utility class has been added to the Spring configuration module. This class provides static methods to detect whether the application is running in a native image or has AOT (Ahead-of-Time) processing enabled, allowing the framework to conditionally apply optimizations or throw exceptions when AOT artifacts are required.

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

The \dubbo-native\ module now includes a new \org.apache.dubbo.aot\ package containing classes that describe reflection, proxy, and resource requirements for ahead-of-time (AOT) compilation. New API classes such as \TypeDescriber\, \ExecutableDescriber\, \FieldDescriber\, and \ResourcePatternDescriber\ define the metadata needed for native image builds. These are consumed by the \AotProcessor\ and related generators (\NativeClassSourceWriter\, \BasicJsonWriter\) to automatically generate the configuration files required for native image compilation, ensuring that all necessary classes and resources are reachable at runtime.

dubbo-plugin/dubbo-native · high confidence

A new \RpcUtils\ class has been added to the \dubbo-compatible\ module to provide backward compatibility for Dubbo 2.x users. This utility class acts as a wrapper that delegates all RPC-related helper methods (such as \getReturnType\, \getMethodName\, and \isAsync\) to the corresponding methods in the Apache Dubbo 3.x \org.apache.dubbo.rpc.support.RpcUtils\ class, ensuring that legacy code relying on the \com.alibaba.dubbo.rpc.support.RpcUtils\ namespace continues to function.

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

A new InstantiationStrategy class was added to the dubbo-common module, providing a mechanism to instantiate objects by matching constructor parameters to available scope models (ApplicationModel, FrameworkModel, ModuleModel, or generic ScopeModel). This enables the framework to inject the correct scope context when creating beans, supporting multi-instance and multi-module configurations.

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

New classes were added to the Dubbo common library to support JavaBean serialization: JavaBeanAccessor, which defines access modes (FIELD, METHOD, ALL); JavaBeanDescriptor, which represents the serialized structure of objects; and JavaBeanSerializeUtil, which provides the core logic to traverse and serialize objects into descriptors. This introduces a new mechanism for serializing JavaBeans, collections, maps, and primitives into a structured descriptor format.

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

A new SerializingExecutor class has been added to the dubbo-common module. This executor ensures that all submitted Runnable tasks are executed serially (one at a time) using a provided underlying Executor. It maintains a queue of tasks and processes them sequentially, handling thread-local state and ignoring RejectedExecutionExceptions if the executor is shutdown.

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

Introduced new AOT (Ahead-of-Time) processing classes for Dubbo's \@DubboReference\ and \@DubboService\ annotations in the Spring 6 module. This includes \ReferenceAnnotationWithAotBeanPostProcessor\ and \ServiceAnnotationWithAotPostProcessor\ to handle bean registration and serialization hints for native images. Additionally, utility classes like \AotUtils\ and resolvers for field/method injection were added to support automatic identification of serialization classes and generation of native image configuration, ensuring that superclass and field loading works correctly in native serialization scenarios.

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

New status checkers have been introduced for the Spring container and database connections. The SpringStatusChecker verifies that the Spring ApplicationContext is running and reports its configuration locations, while the DataSourceStatusChecker validates database connectivity by checking each configured DataSource's metadata. These additions allow users to monitor the health of their Spring context and underlying data sources through the standard Dubbo status check mechanism.

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

A new \dubbo.xsd\ file has been added to the \META-INF/compat\ directory. This XML Schema Definition provides the structural definition for Dubbo's Spring XML configuration, enabling IDE validation and auto-completion for Dubbo beans. This supports backward compatibility for users relying on XML-based configuration.

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

New files AbstractRegistry, AbstractRegistryFactory, and FailbackRegistry have been added to the com.alibaba.dubbo.registry.support package. These classes act as deprecated compatibility wrappers that bridge the old com.alibaba.dubbo API to the current Apache Dubbo implementation, utilizing DelegateURL and compatible listener adapters to ensure existing Alibaba Dubbo code continues to function.

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

The \dubbo-compatible\ module now includes \Reference\ and \Service\ annotation interfaces in the \com.alibaba.dubbo.config.annotation\ package. These act as deprecated wrappers that delegate to the modern \DubboReference\ and \DubboService\ annotations, ensuring that applications using the older \com.alibaba.dubbo\ package names continue to function without immediate code changes.

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

New deprecated interfaces—Exchanger, ResponseCallback, and ResponseFuture—have been added to the com.alibaba.dubbo.remoting.exchange package. These provide backward compatibility for existing Dubbo applications by delegating to the corresponding org.apache.dubbo classes, ensuring that legacy code relying on the alibaba.dubbo package continues to function.

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

A new \FrameworkStatusReportService\ and its SPI interface \FrameworkStatusReporter\ were added to the \dubbo-common\ module. This introduces a mechanism to report status updates for service registration, address consumption, and migration steps. The service collects and forwards status information to registered reporters, enabling better visibility into the state of these critical operations.

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

The Dubbo cluster module now includes dedicated merger classes for various data types, enabling more efficient and standardized merging of cluster results. New implementations include ArrayMerger, BooleanArrayMerger, ByteArrayMerger, CharArrayMerger, DoubleArrayMerger, FloatArrayMerger, IntArrayMerger, LongArrayMerger, and ShortArrayMerger for primitive and object arrays. Additionally, new mergers for common collections are introduced: ListMerger, MapMerger, and SetMerger. These are registered via the MergerFactory, which uses Java's reflection and the extension loader to automatically discover and cache these mergers by their return types, ensuring that the correct merger is used for each data type during cluster operations.

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

Introduced several new utility classes to the \dubbo-common\ module, including \NativeDetector\ for GraalVM native image detection, \OperatingSystemBeanManager\ for cross-platform CPU usage metrics, and \AllowClassNotifyListener\ for serialization check status notifications. Additionally, new utility classes \ArrayUtils\, \Assert\, \AtomicPositiveInteger\, \CacheableSupplier\, \CharSequenceComparator\, \ClassHelper\, \ClassLoaderResourceLoader\, \ClassUtils\, and \CollectionUtils\ were added to provide enhanced support for array operations, assertions, thread-safe positive integers, caching, class loading, and collection management.

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

Introduced new classes to support router snapshotting and tracing: \RouterSnapshotFilter\ acts as a consumer-side filter that enables snapshotting for specific services, while \RouterSnapshotNode\ and \RouterSnapshotSwitcher\ manage the state and storage of these snapshots. Additionally, \AbstractRouter\ and \AbstractRouterRule\ provide base implementations for router logic and rule parsing, and \RouterResult\ encapsulates routing outcomes.

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

New status checkers for system load and memory have been added to the Dubbo common module. The LoadStatusChecker now reports system load average (or CPU usage as a fallback) and available processors, while the MemoryStatusChecker monitors free, total, and maximum memory, triggering a warning when spare memory falls below 2MB. A utility class, StatusUtils, aggregates multiple status checks to produce a summary status, ensuring that errors and warnings are properly propagated in the overall system health report.

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

Introduced new utility classes, ClassUtils and JaketConfigurationUtils, in the dubbo-common module. ClassUtils provides methods to retrieve code source information, list non-static fields, and analyze parameterized types. JaketConfigurationUtils loads configuration from jaket.properties to determine which interfaces and types should be excluded or analyzed for metadata processing.

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

The dubbo-triple-servlet module now includes a comprehensive set of new classes to bridge the gap between the Servlet API and Dubbo's internal HTTP/1.2 protocol handling. This includes \TripleFilter\ to route HTTP/1.1 and HTTP/2 requests, \ServletStreamChannel\ to manage asynchronous context and streaming, and various adapters (\ServletHttpRequestAdapter\, \ServletHttpResponseAdapter\, \HttpMetadataAdapter\) that translate between standard Servlet objects and Dubbo's internal message formats. Additionally, the module introduces support for file uploads (\FileUploadPart\), filter adaptation (\FilterAdapter\), and argument resolution (\ServletArgumentResolver\) for servlet-specific types like \HttpServletRequest\ and \HttpSession\.

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

The dubbo-demo-api-consumer module has been updated to demonstrate the use of a Zookeeper-based configuration center and metadata reporting service. The new Application.java entry point configures the DubboBootstrap to connect to a local Zookeeper instance (127.0.0.1:2181) for both configuration and metadata reporting, while also showcasing generic invocation capabilities. A corresponding log4j2.xml configuration has been added to standardize logging output for the demo.

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

The AbortPolicyWithReport class now supports configurable listeners that are notified when a thread pool is exhausted, allowing external systems to react to this condition. Additionally, the implementation includes logic to generate and write Java thread dumps (jstack) to a configurable directory when the pool is exhausted, with a 10-minute cooldown to prevent excessive logging.

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

Added new HTTP/3 transport implementation for the Dubbo Triple protocol, introducing a complete set of Netty4-based components to handle QUIC and HTTP/3 communication. This includes server and client connection clients (\NettyHttp3Server\, \NettyHttp3ConnectionClient\), stream channel wrappers (\NettyHttp3StreamChannel\), and protocol selectors (\NettyHttp3ProtocolSelectorHandler\) that route requests to appropriate handlers based on content type. The change also introduces SSL context management for HTTP/3 (\Http3SslContexts\) to support configurable certificates and trust managers, as well as header adapters to bridge HTTP/2 and HTTP/3 header interfaces. These additions enable Dubbo services to be exposed and consumed over HTTP/3, leveraging Netty's QUIC support for improved performance and multiplexing.

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

Added new AbsentConfigurator and OverrideConfigurator classes, along with their respective factories, to the cluster configuration system. The AbsentConfigurator applies configuration parameters only if they are currently absent, while the OverrideConfigurator unconditionally overrides existing parameters, allowing for more granular control over service routing and configuration merging.

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

Adds a new Zookeeper client implementation based on the Curator 5 library, including the core client classes (AbstractZookeeperClient, Curator5ZookeeperClient, ZookeeperClientManager) and supporting interfaces (ChildListener, DataListener, EventType, StateListener). This provides an alternative to the existing Zookeeper client, enabling users to leverage the newer Curator 5 API for Zookeeper interactions. The implementation includes a reflection type describer registrar for AOT compatibility and corresponding unit tests to verify client behavior and connection management.

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

The Dubbo Spring module now includes a new \DubboConfigBinder\ interface along with \AbstractDubboConfigBinder\ and \DefaultDubboConfigBinder\ implementations. This change introduces a dedicated mechanism for binding Spring environment properties to Dubbo configuration objects, supporting options to ignore 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

A new \InfraAdapter\ SPI interface and an \EnvironmentAdapter\ implementation are added to the \dubbo-common\ module. This change enables Dubbo to retrieve extra attributes and labels from the underlying infrastructure or environment (such as OS environment variables and JVM system properties) and expose them as metadata. This allows users to automatically capture and propagate environment-specific configuration and labels without manual setup.

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

Added a new mesh rule router system that enables Dubbo to consume and apply routing rules from service mesh environments (such as Kubernetes or xDS). This includes a new \MeshRuleManager\ to manage rule subscriptions, a \MeshRuleCache\ to store parsed rules, and specific router implementations like \StandardMeshRuleRouter\ that match invokers based on application names and subsets defined in the mesh configuration.

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

The \dubbo-remoting-netty\ module now includes a complete implementation for Netty3, introducing classes such as \NettyServer\, \NettyClient\, \NettyChannel\, and \NettyHandler\ to handle network connections, codecs, and event processing. This adds support for the 'netty3' transport protocol, enabling Dubbo to communicate over Netty3 sockets with specific optimizations for connection management, buffer handling, and logging.

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

The Dubbo Prometheus metrics reporter now supports both the legacy and new Prometheus client stacks, automatically selecting the appropriate implementation at runtime. A no-operation (NOP) reporter is provided as a fallback when the required Micrometer dependencies are missing, ensuring the application remains stable. Additionally, a new QoS command is added to retrieve metrics data via the command line interface.

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

Added new classes in the \dubbo-common\ module to support dynamic SSL certificate handling. This includes the \Cert\ and \ProviderCert\ data models, an \AuthPolicy\ enum for authentication types, and a \CertManager\ that aggregates certificate providers. The default \SSLConfigCertProvider\ implementation loads server and client certificates from application configuration, enabling dynamic certificate management for SSL connections.

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

A new ScopeBeanFactory class has been added to the dubbo-common module to manage the creation, registration, and lifecycle of beans within a specific scope. This factory handles concurrent bean instantiation, caching, and initialization, providing methods to register and retrieve beans by type or name while ensuring thread safety and proper scope management.

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

A new ClusterInterceptor interface has been added to the dubbo-cluster module, providing a mechanism to execute logic before and after cluster invocations at the outermost layer. The interface includes before/after hooks and an intercept method, along with a Listener interface for handling messages and errors. This component is marked as @Deprecated, indicating it is being superseded or is in a state of transition within the framework's architecture.

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

The \dubbo-security\ module now includes a new set of classes and configuration files that enable automatic certificate generation and renewal. This includes a \DubboCertManager\ that connects to a remote Certificate Authority (CA) via gRPC, manages the lifecycle of certificates, and handles periodic refreshes. The \CertDeployerListener\ integrates with the application lifecycle to initiate certificate connections during startup and clean up during shutdown. A \CertProvider\ implementation (\DubboCertProvider\) is registered to supply certificate data for both provider and consumer SSL configurations. The feature is supported by a new \ca.proto\ definition for the certificate service and corresponding unit tests.

dubbo-plugin/dubbo-security · high confidence

Users can now customize JSON serialization by implementing the new \JsonUtil\ SPI interface in \dubbo-common/src/main/java/org/apache/dubbo/common/json/JsonUtil.java\. This change introduces a framework-level extension point for JSON handling, alongside a default \GsonUtils\ implementation that provides \toJson\ and \fromJson\ methods backed by Google's Gson library. This allows for greater flexibility in how Dubbo serializes and deserializes JSON data.

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

The test-check module now provides a global, embedded Zookeeper registry center that is automatically started and stopped by JUnit test execution listeners. This new infrastructure, including the \GlobalRegistryCenter\ and associated context/processor classes, allows tests in packages like \org.apache.dubbo.config\ and \org.apache.dubbo.registry\ to run against a shared, embedded Zookeeper instance rather than each test managing its own. The implementation handles downloading, unpacking, and configuring the Zookeeper binary, with specific handling for Windows and Unix environments.

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

Added new interfaces and classes to manage global resources and executor services across the framework. The \Disposable\ interface defines a \destroy()\ method for resource cleanup, while \Initializable\ provides an \initialize()\ hook. \GlobalResourcesRepository\ acts as a singleton registry for global and one-off disposable resources, ensuring they are properly cleaned up when the application shuts down. \GlobalResourceInitializer\ integrates with this repository to automatically register resources for automatic release on shutdown.

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

Added new classes in the \org.apache.dubbo.common.threadlocal\ package to provide high-performance, thread-safe storage for thread-local variables. This includes \InternalThread\, \InternalThreadLocal\, \InternalThreadLocalMap\, and \InternalRunnable\, which together offer a faster alternative to standard \ThreadLocal\ by using indexed arrays instead of hash tables. The \InternalRunnable\ wrapper ensures that thread-local variables are automatically cleared after task execution, preventing memory leaks in container environments.

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

A new thread pool management system has been added to Dubbo, introducing an 'IsolationExecutorRepository' that allows each service to have its own dedicated thread pool, preventing interference between services. This is supported by a new 'FrameworkExecutorRepository' for framework-level shared executors and a 'Ring' utility for managing executor pools. The 'ExecutorRepository' interface and its default implementation 'DefaultExecutorRepository' provide the core logic for creating and managing these executors, enabling users to configure thread pools per service for better resource isolation and performance tuning.

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

Added new \MultipleRegistry\ and \MultipleServiceDiscovery\ implementations that allow Dubbo to connect to and manage multiple registry centers simultaneously. This enables users to register services and discover instances across different registry clusters, with the framework automatically aggregating results from all configured registries. The change includes the core registry and service discovery classes, their respective factories, and the necessary SPI configuration files to register these new implementations.

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

Added a new service discovery implementation for Zookeeper, including the core classes (ZookeeperServiceDiscovery, ZookeeperInstance) and their associated factories and utilities. This provides a modern, Curator-based approach to service discovery in the Zookeeper registry module, alongside the traditional registry interface.

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

Added new model classes for condition-based routing, including ConditionRouterRule, ConditionRuleParser, ConditionSubSet, Destination, DestinationSet, MultiDestCondition, and MultiDestConditionRouterRule. These classes support parsing and handling of condition-based routing rules, enabling more flexible and granular control over traffic routing in the Dubbo cluster module.

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

A new set of classes in the \dubbo-common\ deploy package introduces a structured lifecycle for Dubbo applications and modules. This includes the \DeployState\ enum and \Deployer\ interface to track initialization, starting, started, completion, stopping, and failure states. The \AbstractDeployer\ provides a base implementation that manages state transitions and notifies registered \DeployListener\s (such as \ApplicationDeployListener\ and \ModuleDeployListener\) at each stage. This change provides a more robust and observable way to manage the startup and shutdown of Dubbo components, allowing for better control over the deployment process.

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

Added NopDynamicConfiguration and NopDynamicConfigurationFactory classes that provide a default, no-op implementation of the DynamicConfiguration interface. This serves as a fallback when no valid config center is specified, preventing potential null pointer exceptions by returning null for configuration retrieval and performing no-ops for listener registration and removal.

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

Adds a new \RegistryMetricsCollector\ and supporting classes (constants, events, stat composite, and a SPI registration) to the \dubbo-metrics-registry\ module. This enables automatic collection of registry-related metrics, including application-level and service-level metrics for register, subscribe, notify, and directory operations, as well as response time tracking for these events.

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

Added a new ScriptStateRouter and its factory, enabling users to define and execute custom routing logic via scripts (e.g., JavaScript) in the Dubbo cluster layer. This allows for more flexible, dynamic routing decisions based on script evaluation rather than static configuration.

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

Added new model classes (ParamMatch, Tag, TagRouterRule, TagRuleParser) in the dubbo-cluster module to parse and represent tag-based routing rules, enabling more flexible rule matching and improved handling of tag configurations.

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

Added wrapper classes (MockClusterWrapper, ScopeClusterWrapper) and invoker implementations (MockClusterInvoker, ScopeClusterInvoker, AbstractCluster) in the cluster support package. These changes enable the framework to intercept and manage cluster invocations for mock handling and local/remote scope selection at runtime.

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

Added ZoneAwareCluster and ZoneAwareClusterInvoker to enable traffic distribution across multiple registries based on zone information. The new invoker first selects a registry marked as 'preferred', then attempts to route to a registry in the same zone as the current request, and finally falls back to load-balanced selection across all registries. This allows users to configure zone-based routing for better traffic distribution in multi-registry scenarios.

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

Added a new \org.apache.dubbo.config.spring.util\ package containing utility classes such as \AnnotatedBeanDefinitionRegistryUtils\, \AnnotationUtils\, \BeanRegistrar\, \DubboAnnotationUtils\, \DubboBeanUtils\, \EnvironmentUtils\, \GenericBeanPostProcessorAdapter\, \LazyTargetInvocationHandler\, \LazyTargetSource\, \LockUtils\, \ObjectUtils\, and \PropertySourcesUtils\. These utilities provide helper methods for bean registration, annotation processing, environment property extraction, and lazy target handling within the Spring context.

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

Added new classes in the Dubbo cluster module to support script-based routing rules. The \AppScriptRouterFactory\ and \AppScriptStateRouter\ handle the creation and execution of stateful routers that apply dynamic scripts to filter or modify traffic for a specific application. The \ScriptRule\ model parses YAML-formatted rules containing a script and its type, enabling users to define custom routing logic via configuration center updates.

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

The Dubbo RPC cluster module now includes a new \DefaultFilterChainBuilder\ implementation and associated interfaces (\FilterChainBuilder\, \InvocationInterceptorBuilder\) that construct the filter chain for both consumer and provider invocations. This change introduces a structured way to build and manage the sequence of filters applied to RPC calls, supporting multi-instance scenarios by iterating through module models and deduplicating filters. The \ProtocolFilterWrapper\ is updated to use this new builder, ensuring that service exports and references are wrapped with the appropriate filter chain logic.

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

The metrics module now includes a dedicated event bus (MetricsEventBus) and a base MetricsEvent class that support a publish/subscribe model for metric data. The new structure includes a MetricsEventMulticaster interface for dispatching events to registered MetricsListener instances, a TimeCounterEvent for tracking execution time, and a comprehensive set of MetricsKey constants defining metric names and descriptions for application, registry, and metadata operations. This change refactors how metrics are collected and dispatched, providing a more structured and extensible way to handle metric events across the Dubbo framework.

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

A new state-based routing system is introduced, centered around the \StateRouter\ interface and its \AbstractStateRouter\ base class, which manages routing logic through a chain of routers. This includes a \BitList\ implementation for efficient invoker filtering, a \CacheableStateRouterFactory\ for caching router instances, and a \TailStateRouter\ to handle the end of the routing chain. This change provides a more structured and potentially higher-performance approach to service routing compared to previous methods.

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

The Dubbo framework now includes a new 'EagerThreadPool' implementation that allows the thread pool to create new worker threads immediately when the core pool is busy, rather than queuing tasks. This change adds three new classes in the \dubbo-common\ module: \EagerThreadPool\, \EagerThreadPoolExecutor\, and \TaskQueue\. The \TaskQueue\ is designed to return \false\ when the pool has free workers, which triggers the \EagerThreadPoolExecutor\ to spawn a new thread. This behavior is controlled by standard thread pool parameters such as \CORES\, \THREADS\, \QUEUES\, and \ALIVE\ time, giving users more responsive handling of concurrent requests.

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

The Dubbo RPC module adds a new \ByteAccessor\ SPI interface and a \ClientsProvider\ interface, alongside several new classes (\ChannelWrappedInvoker\, \CallbackServiceCodec\, \DecodeableRpcInvocation\, \DecodeableRpcResult\, \DubboCodec\, \DubboCodecSupport\, \DubboCountCodec\, \DubboExporter\, and \Constants\). These changes enable custom implementations to intercept and customize the decoding of RPC invocations and results, as well as manage client connections, providing a more flexible way to handle the Dubbo protocol's binary data.

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

The framework now supports thread pool isolation between services. A new \IsolationExecutorSupportFactory\ SPI and its \Default\ implementation are added to the \dubbo-common\ module, enabling the RPC executor to be isolated per service rather than sharing a global pool. This change allows providers to configure separate thread pools for different services, improving resource isolation and preventing one service's load from affecting others.

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

The dubbo-remoting-http12 module now includes a comprehensive set of new classes and interfaces that define the core abstractions for HTTP/1.2 and HTTP/2 communication, including \AbstractServerHttpChannelObserver\, \CompositeInputStream\, \HttpChannel\, \HttpHeaders\, \HttpRequest\, \HttpResponse\, and \HttpResult\. These additions establish the foundational API for handling HTTP requests, responses, headers, and streaming data within the Dubbo framework.

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

The \dubbo-rpc-api\ module introduces several new classes that redefine the RPC execution and result handling model. \AsyncRpcResult\ and \AppResponse\ replace the legacy \RpcResult\ and \AsyncRpcResult\ pattern, where \AsyncRpcResult\ now wraps a \CompletableFuture\<AppResponse\>\ to represent an unfinished RPC call, while \AppResponse\ holds the actual business result. An \AsyncContext\ interface and \AsyncContextImpl\ implementation are added to manage asynchronous execution states and context switching across threads. Additionally, \AdaptiveMetrics\ and \AdaptiveScopeModelInitializer\ are introduced to support adaptive metrics statistics for load balancing, and \AbstractGracefulShutdown\ provides a template for graceful shutdown mechanisms across different protocols.

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

The dubbo-common module introduces a new set of model classes in the org.apache.dubbo.rpc.model package to support a hierarchical lifecycle management for Dubbo applications. This includes ApplicationModel, FrameworkModel, and ModuleModel, which manage the initialization, execution, and destruction of Dubbo components at the application, framework, and module levels respectively. Additionally, new classes such as MethodDescriptor, ConsumerModel, ProviderModel, and various service repositories (FrameworkServiceRepository, ModuleServiceRepository) are added to handle service registration, lookup, and metadata management. These changes enable better resource management, concurrent safety, and support for multi-instance scenarios within a single JVM.

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

The dubbo-rpc-triple module now includes a suite of new classes that form the core of the Triple protocol implementation. This includes status and exception handling (StatusRpcException, TriRpcStatus), stream observer interfaces (CancelableStreamObserver, ClientStreamObserver), deadline management (DeadlineFuture), and protocol-specific utilities (DescriptorUtils, ExceptionUtils, ClassLoadUtil). It also introduces protocol handlers and factories (GrpcHttp2Protocol, GrpcProtocol, Http2ProtocolDetector, Http3Exchanger, DefaultPackableMethodFactory, ReflectionPackableMethod, PbArrayPacker, PbUnpack) that enable the framework to serialize, deserialize, and manage RPC calls using the Triple protocol.

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

Adds new configuration lifecycle hooks via ConfigInitializer and ConfigPostProcessor interfaces, allowing custom logic to run during reference and service configuration initialization and post-processing. Introduces a new DubboShutdownHook class to manage the JVM shutdown process, coordinating graceful shutdown of modules and applications while handling Spring lifecycle conflicts. Additionally, adds a ServiceListener interface to notify about service export/unexport events, and a BootstrapTakeoverMode enum to define how DubboBootstrap lifecycle is managed (SPRING, MANUAL, AUTO, SERVLET).

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

The dubbo-cluster module adds four new filter implementations in the \rpc/cluster/filter/support\ package: \CallbackConsumerContextFilter\ to manage RpcContext for callback invocations, \ConsumerClassLoaderFilter\ to temporarily swap the thread's context ClassLoader to match the service model, \ConsumerContextFilter\ to populate and clean up RpcContext attachments and handle timeout countdowns, and \MetricsConsumerFilter\ to expose consumer-side metrics. These changes ensure that consumer-side RPC calls correctly maintain execution context, classloader isolation, and observability data throughout the filter chain.

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

Adds several new classes to the common module to support the multi-instance and service discovery architecture: \BaseServiceMetadata\ for managing service metadata and keys, \ProtocolServiceKey\ and \ServiceKey\ for identifying and matching services, \BatchExecutorQueue\ for optimized task execution, and \CommonScopeModelInitializer\ for registering shared framework resources like executors and security managers. Additionally, the \Experimental\ annotation is introduced to mark unstable APIs, while \URL\ and \URLBuilder\ are refactored to support a new internal URL structure with \URLAddress\ and \URLParam\ components for better performance and thread-safety.

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

The dubbo-metadata-api module now includes a new AbstractCacheManager and MappingCacheManager to handle file-based caching of service name mappings, alongside a new DefaultMetadataParamsFilter that defines which parameters are included or excluded from metadata. Additionally, a new DubboMetadataServiceV2Triple class provides the gRPC/Protobuf implementation for the MetadataServiceV2, exposing methods like GetMetadataInfo and GetOpenAPIInfo via the Triple protocol. The change also adds supporting classes such as InstanceMetadataChangedListener, MappingChangedEvent, and MetadataInfoV2 to support these new capabilities.

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

The dubbo-serialization-api module now includes a comprehensive set of new interfaces and classes to handle serialization. This includes the core \Serialization\ interface with \getContentTypeId\ and \getContentType\ methods, alongside \DataInput\ and \DataOutput\ for basic data types, and \ObjectInput\/\ObjectOutput\ for object-level serialization. Additionally, a \MultipleSerialization\ interface and its \DefaultMultipleSerialization\ implementation are added to support multiple serialization types, with a \DefaultSerializationSelector\ to manage the default remoting serialization (defaulting to 'hessian2' via system properties or environment variables). The change also introduces a \SerializableClassRegistry\ for registering serializable classes at startup and a \PreferSerializationProviderImpl\ to determine preferred serialization types based on available extensions.

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

The metrics module now supports time-window based aggregation, introducing new classes such as SlidingWindow, TimeWindowAggregator, TimeWindowCounter, and TimeWindowQuantile to enable statistical calculations over configurable time intervals. This change adds the core aggregation logic and data structures (including Pane, SampleAggregatedEntry, and various collectors) that allow the system to collect and export metrics with time-based windowing, improving the granularity and accuracy of performance data.

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

A new \SimpleDataStore\ class has been added to the \dubbo-common\ module, providing a concrete implementation of the \DataStore\ interface. This component manages a concurrent map of component data and supports adding listeners to receive updates, effectively enabling a new way to store and retrieve data within the Dubbo framework.

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

A new \Compiler\ interface has been added to the \dubbo-common\ module, defining the Service Provider Interface (SPI) for compiling Java source code. This interface provides two methods: a legacy method for simple compilation and a newer method that accepts a 'neighbor' class to support JDK 16+ module restrictions. This change introduces a new abstraction for dynamic compilation within the framework.

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

The dubbo-cluster module now includes a set of new core interfaces and classes that define the contract for cluster operations, routing, and configuration. This includes the \Cluster\ interface for joining directories, \ClusterInvoker\ for final RPC proxy references, \Directory\ for managing invoker lists, \LoadBalance\ for selecting invokers, and \Configurator\/\ConfiguratorFactory\ for applying override rules. Additionally, \CacheableRouterFactory\ and \RouterChain\/\SingleRouterChain\ provide the infrastructure for executing routing rules, while \AffinityStateRouter\ introduces affinity-based routing capabilities.

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

A new \AddressListener\ interface has been added to the registry module, defining a SPI contract for processing provider address lists and providing a \destroy\ lifecycle method scoped to the module.

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

The Nacos config center module now includes a complete implementation for dynamic configuration management, featuring a \NacosDynamicConfiguration\ class that handles connection retries, server status validation, and property mapping. The change introduces a \NacosConfigServiceWrapper\ to abstract Nacos API calls and a factory to instantiate the configuration service. Additionally, unit tests are added to verify retry behavior, server status checks, and configuration listener functionality.

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

The Apollo config center module now provides a complete, standalone implementation for dynamic configuration management. The \ApolloDynamicConfiguration\ class handles connecting to Apollo, managing listeners for configuration changes, and supporting both governance rules and properties files via namespaces. A factory \ApolloDynamicConfigurationFactory\ and SPI registration enable Dubbo to discover and use this implementation. Additionally, a mock server \EmbeddedApolloJunit5\ and corresponding unit tests (\ApolloDynamicConfigurationTest\) are added to verify the new behavior.

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

A new DataStore interface and its associated DataStoreUpdateListener interface have been added to the common module. The DataStore provides methods to get, put, and remove data by component name and key, and supports registering listeners to be notified of updates. This introduces a new mechanism for managing application-scoped data within Dubbo.

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

A new demo application for the Dubbo MCP (Model Context Protocol) server has been added. This includes a Spring Boot application entry point, a service interface and implementation using the @McpTool annotation, and data models (ComplexRequest, ComplexResponse, NestedDetail) that demonstrate handling of nested objects, lists, and maps. The server is configured to run on port 50055 using the Triple protocol with both OpenAPI and MCP (streamable protocol) enabled.

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

The Dubbo Spring Boot actuator module now exposes several new management endpoints and health indicators. Users can access metadata for Dubbo configurations, properties, services, and references via the 'dubboconfigs', 'dubboproperties', 'dubboservices', and 'dubboreferences' endpoints. A new 'dubbo' endpoint allows invoking QoS commands, while 'dubboshutdown' provides a way to gracefully shut down the application. Additionally, a new health indicator checks the status of various Dubbo components (memory, load, registries, etc.) to report the overall health of the Dubbo runtime.

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

The dubbo-common module introduces new core interfaces and supporting classes for remote procedure calls. Specifically, it adds the \Destroyable\ interface for resource cleanup, the \EchoService\ interface for testing connectivity, and the \GenericService\ interface for dynamic invocation. These are accompanied by corresponding detector classes (\EchoServiceDetector\, \GenericServiceDetector\) that implement \BuiltinServiceDetector\ to register these services, and a \ServiceDescriptorInternalCache\ to cache their descriptors. Additionally, a \GenericException\ class is added to handle exceptions in generic invocations.

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

A new \ScheduledCompletableFuture\ class has been added to \dubbo-common\ under \org.apache.dubbo.common.threadpool.concurrent\. This utility provides static methods to schedule tasks for delayed or immediate execution using a \ScheduledExecutorService\, returning a \CompletableFuture\ that completes with the result or exception of the provided supplier. This simplifies the creation of scheduled async operations within the common library.

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

The dubbo-common module introduces a new exception class, ScopeBeanException, and a new extension injector, ScopeBeanExtensionInjector, which enables injection of scope beans into SPI extension instances via the ScopeBeanFactory.

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

A new Spring Boot-based provider demo has been added, providing a complete example for running a Dubbo service using Spring Boot. The demo includes a provider application class, a service implementation that logs requests using SLF4J, and configuration files for ZooKeeper registry, Prometheus metrics, and log4j2 logging.

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

The dubbo-spring-security plugin has been introduced to handle Spring Security integration. It adds filters to serialize and deserialize authentication contexts across RPC calls, ensuring that security contexts are properly propagated from consumers to providers. The implementation includes an ObjectMapperCodec for JSON serialization, filters for preparing and resolving authentication contexts, and a mechanism to translate Spring Security exceptions into Dubbo RPC exceptions. Additionally, the plugin registers a scope model initializer to manage the ObjectMapperCodec bean and allows for customization via the ObjectMapperCodecCustomer SPI.

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

The dubbo-config-spring module now provides a set of Spring ApplicationEvents to track the Dubbo application lifecycle and service export status. Developers can listen for DubboApplicationStateEvent and DubboModuleStateEvent to monitor application and module start/stop states, as well as DubboConfigInitEvent for configuration initialization. Additionally, ServiceBeanExportedEvent is available to detect when a service has been successfully exported. Note that DubboBootstrapStatedEvent and DubboBootstrapStopedEvent are marked as deprecated.

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

The Dubbo Spring module introduces a new configuration binding system that automatically maps Spring environment properties to Dubbo configuration beans. This includes the \@EnableConfigurationBeanBinding\ and \@EnableConfigurationBeanBindings\ annotations, which drive the \ConfigurationBeanBindingPostProcessor\ to bind properties (e.g., \dubbo.application\, \dubbo.registry\) to their respective \AbstractConfig\ classes. Additionally, the \@EnableDubbo\ and \@EnableDubboConfig\ annotations are introduced to enable Dubbo components and config binding in a single step, while \@DubboComponentScan\ and \DubboClassPathBeanDefinitionScanner\ provide a unified way to scan for \@Service\ and \@Reference\ annotated classes.

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

The \dubbo-config-spring\ module introduces a new set of classes (\ReferenceAttributes\, \ReferenceBeanBuilder\, \ReferenceBeanManager\, \ReferenceBeanSupport\, \ReferenceCreator\) to handle the creation and management of \ReferenceBean\ instances in a Spring environment. This refactors how Dubbo reference beans are built and registered, providing a builder pattern for Java config and a centralized manager to track and initialize reference beans, including support for \@DubboReference\ annotations and property placeholder resolution.

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

The \dubbo-common\ module introduces new annotation types in the \org.apache.dubbo.config.annotation\ package to support service and reference configuration: \Argument\, \DubboReference\, \DubboService\, \Method\, \ProvidedBy\, \Reference\, and \Service\. The \Reference\ and \Service\ annotations are marked as deprecated in favor of \DubboReference\ and \DubboService\ respectively, which provide more comprehensive configuration options for Dubbo services and client references. Additionally, \Argument\ and \Method\ annotations allow for fine-grained method-level configuration, while \ProvidedBy\ enables declaring the providing application for an interface.

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

The dubbo-metadata-processor module now includes a new Java annotation processor that automatically generates metadata definitions for classes annotated with Dubbo's @Service. This processor scans annotated classes and builds a comprehensive ServiceDefinition, including type definitions for all properties, methods, and nested types. The generated metadata is written to META-INF/dubbo/service-definitions.json on the classpath, enabling runtime discovery of service interfaces and their signatures without manual configuration.

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

Added new classes in the \dubbo-common\ bytecode package to support dynamic class generation and proxying. This includes \ClassGenerator\ for creating dynamic classes using Javassist, \Mixin\ for combining interfaces with delegate classes, \Proxy\ for generating interface proxies with caching, and \Wrapper\ for reflective method/property access. Also added \DubboLoaderClassPath\ to ensure Javassist loads Dubbo classes from the correct classloader, and custom exceptions \NoSuchMethodException\ and \NoSuchPropertyException\.

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

The dubbo-common module now includes two new thread pool implementations: CachedThreadPool and LimitedThreadPool. CachedThreadPool creates new threads as needed and recycles idle threads after one minute, while LimitedThreadPool creates new threads until a specified limit is reached and does not shrink automatically. Both pools use configurable parameters for core/maximum threads, queue size, and thread naming, and both utilize a custom MemorySafeLinkedBlockingQueue for negative queue sizes. These changes provide users with more explicit control over thread pool behavior in the common library.

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

Added new classes in the \dubbo-common\ module to manage memory-safe queue operations: a \Rejector\ interface and three implementations (\AbortPolicy\, \DiscardPolicy\, \DiscardOldestPolicy\) that define how queues should behave when memory is exhausted. A \RejectException\ was also introduced to signal rejection conditions, and a \CallableSafeInitializer\ was added to provide thread-safe, lazy initialization of objects. These changes enhance the framework's ability to handle concurrent resource management and prevent memory-related failures.

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

A new condition-based state router implementation (ConditionStateRouter and MultiDestConditionRouter) has been added to the cluster package. This introduces a new routing mechanism that evaluates 'when' and 'then' conditions to direct traffic to specific subsets of providers, supporting complex matching rules and multiple destinations with weights.

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

The Dubbo framework introduces a new config management architecture in the \dubbo-common\ module, centered around \AbstractConfigManager\, \ConfigManager\, and \ModuleConfigManager\. This refactoring introduces a \ConfigMode\ enum that allows users to control how duplicate or conflicting configurations are handled. The available modes are STRICT (throw exception on duplicates), OVERRIDE (last config wins), OVERRIDE\_ALL (last config overrides all attributes), OVERRIDE\_IF\_ABSENT (last config only fills missing attributes), and IGNORE (first config wins). This provides a more flexible and predictable way to manage configuration overrides and duplicates across the application and module scopes.

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

The \dubbo-config-spring\ module introduces a new \org.apache.dubbo.config.spring.context.config\ package containing core interfaces and implementations for binding and customizing Dubbo configuration beans. This includes the \ConfigurationBeanBinder\ interface and its \DefaultConfigurationBeanBinder\ implementation, which handle property binding via Spring's \DataBinder\. Additionally, the \ConfigurationBeanCustomizer\ and \DubboConfigBeanCustomizer\ interfaces allow post-binding customization of configuration beans, with a specific \NamePropertyDefaultValueDubboConfigBeanCustomizer\ implementation that sets the 'name' property to the bean name if it is absent. These changes provide a structured way to bind externalized configuration to Dubbo config beans and apply custom logic after binding.

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

The \dubbo-common\ module introduces a suite of new configuration classes in the \org.apache.dubbo.config.nested\ package, enabling granular control over application behavior. These include \AggregationConfig\, \HistogramConfig\, and \OtlpMetricConfig\ for metrics and monitoring; \SamplingConfig\ and \PropagationConfig\ for distributed tracing; \ExporterConfig\ for Zipkin and OTLP settings; \Http3Config\ for HTTP/3 protocol options; \RestConfig\ for RESTful service mappings; and \ServletConfig\ for servlet-based transport. These classes provide the foundational data structures for configuring Dubbo's observability and transport layers.

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

Added new model classes in the Dubbo cluster configurator parser—ConditionMatch, ConfigItem, ConfiguratorConfig, and ParamMatch—to structure dynamic configuration rules. These classes define the data schema for parsing and matching conditions (such as address, service, application, and parameter matching) used by the cluster configurator to apply dynamic rules at runtime.

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

The dubbo-metrics-default module now provides the default implementation for Dubbo's metrics system. This includes a new DefaultMetricsCollector and AggregateMetricsCollector to handle request, error code, and thread pool metrics, alongside a MetricsGlobalRegistry to manage Micrometer registries. The change introduces a new DefaultConstants interface defining method-level and aggregated metric keys, and registers a MetricsScopeModelInitializer to bootstrap the metrics dispatcher. Additionally, reflection type describers are added to support AOT (Ahead-of-Time) compilation for histogram metrics.

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

The logging subsystem in dubbo-common now includes new \FailsafeLogger\ and \FailsafeErrorTypeAwareLogger\ classes that wrap existing loggers to prevent logging exceptions from crashing the application. The error-type-aware logger enhances log output by appending the Dubbo version, current host, and a structured error code. Additionally, it automatically appends a link to the Dubbo FAQ page (https://dubbo.apache.org/faq/%d/%d) for specific error codes, helping users find instructions for resolving issues. The logger can also be globally disabled via a static flag.

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

A new file-based cache store implementation has been introduced, consisting of the \FileCacheStore\ class and its \FileCacheStoreFactory\. This change adds the ability to persist cache data to local files, with the factory managing the lifecycle and thread-safe access to these stores. The implementation includes logic for reading and writing cache entries, handling file locking to prevent concurrent access issues, and sanitizing cache names to ensure valid file paths.

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

The logging subsystem in dubbo-common has been expanded with new interfaces and implementations to improve error reporting and developer experience. A new \ErrorTypeAwareLogger\ interface and its \Failsafe\ wrapper allow logging methods to include an error code, cause, and extended information, which can be used to display solution links in log output. Additionally, a \FluentLogger\ interface and its \FluentLoggerImpl\ implementation provide a builder-style API for constructing log messages, supporting lazy evaluation of message suppliers and chaining of cause/extended information. A \Level\ enum and \ListenableLogger\/\LogListener\ interfaces for log event subscription have also been added to the \org.apache.dubbo.common.logger\ package.

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

A new \GovernanceRuleRepository\ interface and its \DefaultGovernanceRuleRepositoryImpl\ implementation have been added to the cluster governance package. This provides a dedicated mechanism for Dubbo to listen to and retrieve dynamic configuration rules via a \ConfigurationListener\, enabling runtime updates to governance policies without service restarts.

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

The \dubbo-common\ module introduces a new set of thread-unsafe I/O utilities designed for performance-critical paths where external synchronization is handled by the caller. This includes \Bytes\ for efficient byte array conversions and base64/hex encoding, \StreamUtils\ for limiting input stream reads and wrapping streams that do not support mark/reset, and specialized \Unsafe\*\ classes (\UnsafeByteArrayInputStream\, \UnsafeByteArrayOutputStream\, \UnsafeStringReader\, \UnsafeStringWriter\) that provide faster, non-thread-safe alternatives to standard Java I/O classes.

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

The Dubbo framework introduces a new component lifecycle model via the \Lifecycle\ interface, which defines \initialize\, \start\, and \destroy\ phases. This is supported by a default \LifecycleAdapter\ implementation and specific extension points (\ApplicationExt\ and \ModuleExt\) that allow application and module-level components to participate in this lifecycle. This change enables more robust initialization and cleanup of Dubbo beans and SPI extensions.

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

The load balancing module introduces several new implementations: an adaptive load balancer that selects providers based on dynamic metrics (P2C algorithm), a shortest response time strategy, and a round-robin strategy with weighted sliding window. Additionally, the existing consistent hash, least active, and random strategies are refactored to support warmup periods and weight calculations, while the abstract base class provides a common interface for all load balancers.

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

The mesh cluster router now uses new data model classes to represent routing rules. A new BaseRule class provides a base structure with apiVersion, kind, and metadata fields, while a new VsDestinationGroup class groups application-level virtual service and destination rules together, enabling the router to parse and apply these specific rule types for traffic management.

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

Added three new classes to the Dubbo cluster router mesh module: MeshRuleDispatcher, which manages and dispatches mesh rules to registered listeners; MeshRuleListener, an interface for components to receive rule change notifications; and TracingContextProvider, an SPI interface for retrieving tracing context from third-party tools like OpenTracing. These changes introduce new mechanisms for handling mesh-based routing rules and distributed tracing integration.

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

The Dubbo metrics module now includes a dedicated metadata metrics collector that tracks push, subscribe, and provider interface store operations at both application and service levels. This change introduces a new event-driven architecture for metadata observability, including constants, a collector implementation, event classes, and a dispatcher, along with the necessary test coverage to validate the new functionality.

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

Added new Java classes—FullServiceDefinition, MethodDefinition, ServiceDefinition, and TypeDefinition—to the dubbo-common metadata model. These classes define the structure for service and method metadata, including properties for canonical names, code sources, method signatures, return types, and type definitions with generic support.

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

The dubbo-tracing module has been refactored to use Micrometer's Observation API for tracing, replacing the previous implementation. This introduces new components including \ObservationReceiverFilter\ and \ObservationSenderFilter\ to wrap incoming and outgoing RPC calls with observations, and dedicated handlers (\DubboClientTracingObservationHandler\, \DubboServerTracingObservationHandler\) to manage trace context propagation. The \DubboObservationRegistry\ now initializes the observation registry and registers handlers for both client and server sides. Additionally, new classes like \DubboClientContext\ and \DubboServerContext\ manage the observation state, while \DefaultDubboClientObservationConvention\ and \DefaultDubboServerObservationConvention\ define the structure of the observations. This change also adds support for exporting spans to OTLP and Zipkin via new exporter classes (\OTlpSpanExporter\, \ZipkinSpanExporter\, \ZipkinSpanHandler\).

dubbo-metrics/dubbo-tracing · high confidence

The \dubbo-common\ module now includes concrete implementations of the \JsonUtil\ interface for four popular JSON libraries: Fastjson, Fastjson2, Gson, and Jackson. Each library is registered as an active implementation, allowing Dubbo to serialize and deserialize Java objects using the corresponding JSON library. This change provides users with the flexibility to choose their preferred JSON processing library for Dubbo's internal JSON handling, with Jackson's implementation notably supporting custom modules via a new \addModule\ method.

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

The remoting module introduces a new set of core interfaces and classes to support a modernized, protocol-agnostic connection management model. This includes the \WireProtocol\ and \ProtocolDetector\ interfaces for dynamic protocol negotiation, alongside \AbstractConnectionClient\ and \ConnectionManager\ to manage connection lifecycles and reference counting. Additionally, the \ChannelEvent\ interface is added to allow protocols to fire custom events, such as read-only or writeable states, enabling more flexible server-side behavior control.

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

Added a new set of interfaces in the \dubbo-common\ module to support advanced flow control and backpressure for streaming RPCs. This includes the base \CallStreamObserver\ interface, along with \ClientCallStreamObserver\ and \ServerCallStreamObserver\ for client and server-side flow control respectively. These interfaces mirror the gRPC \CallStreamObserver\ API, enabling developers to manage send-side and receive-side backpressure via methods like \isReady()\, \setOnReadyHandler()\, \request()\, and \disableAutoFlowControl()\. The \ClientResponseObserver\ interface is also introduced to allow configuration of these flow control settings before a stream starts.

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

The \dubbo-common\ module introduces a new \convert\ package containing a \Converter\ interface and a \ConverterUtil\ class that caches and retrieves type converters via the extension loader. This change adds specific string-to-type conversion implementations, including \StringToBooleanConverter\, \StringToByteConverter\, \StringToCharArrayConverter\, \StringToCharacterConverter\, \StringToDoubleConverter\, \StringToDurationConverter\, \StringToFloatConverter\, \StringToIntegerConverter\, \StringToLongConverter\, \StringToOptionalConverter\, \StringToShortConverter\, and \StringToStringConverter\. These new components enable automatic conversion of string values to their corresponding Java types, with the utility class handling the lookup and caching of these converters.

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

The metadata definition module now includes dedicated builders for handling Java array, collection, map, and enum types. These new components allow the framework to more accurately reflect the structure of complex types in service metadata, ensuring that array elements, collection item types, map key/value types, and enum values are correctly captured and exposed.

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

Added new utility classes in the \dubbo-common\ module to simplify functional programming patterns. \Predicates\ provides static methods to create \Predicate\ instances (always true/false, AND, OR). \Streams\ offers helper methods to filter streams, lists, and sets using predicates. \ThrowableAction\, \ThrowableConsumer\, and \ThrowableFunction\ are functional interfaces that allow throwing checked exceptions, with static \execute\ methods that wrap thrown exceptions in \RuntimeException\ for easier handling.

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

Added new classes in the common language package to support application lifecycle management and task ordering. The \Nullable\ annotation marks parameters, fields, or methods that may be null. The \Prioritized\ interface and its associated \COMPARATOR\ allow objects to be sorted by priority, with \Prioritized\ implementing \Comparable\ to ensure correct ordering. The \ShutdownHookCallback\ interface defines a callback invoked when the Dubbo application stops, supporting both Java shutdown hooks and explicit application destruction. The \ShutdownHookCallbacks\ class manages a collection of these callbacks, loading them via the extension mechanism, sorting them by priority, and executing them in order during shutdown.

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

Added foundational repository configuration files including \.artifacts\ (listing all Dubbo modules), \.asf.yaml\ (GitHub/ASF metadata), \.editorconfig\ (code formatting rules), \.gitattributes\ (line ending normalization), \.gitignore\ (build/IDE artifacts), \.licenserc.yaml\ (license header enforcement), \AGENTS.md\ (threat model and security reporting guidelines), \CHANGES.md\ (release notes), \CODE\_OF\_CONDUCT.md\ (community standards), \CONTRIBUTING.md\ (contribution workflow), \Jenkinsfile\ (CI/CD pipeline), \Jenkinsfile.sonar\ (code quality checks), and \LICENSE\ (Apache 2.0 text).

(repo-wide) · high confidence

The Netty4 remoting module introduces a new set of classes to manage network connections and data handling. A new \AbstractNettyConnectionClient\ provides a foundation for client-side connection management, including reconnection logic and state tracking. A \NettyChannel\ class wraps Netty channels and maintains a cache of active connections. A \NettyCodecAdapter\ bridges Dubbo's codec interface with Netty's encoder/decoder pipeline. Additionally, \AddressUtils\ and \ChannelAddressAccessor\ are introduced to standardize how local and remote addresses are retrieved and formatted. These changes restructure how the Netty4 module handles I/O, moving towards a more modular and extensible architecture for network transport.

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

The Dubbo cluster module now explicitly registers its internal Service Provider Interface (SPI) mappings through new resource files in \META-INF/dubbo/internal/\. This includes mappings for cluster implementations (e.g., \failover\, \failfast\), load balancing strategies (e.g., \random\, \roundrobin\), governance rules, router factories, and various filters (e.g., \consumercontext\, \metricsConsumerFilter\). This change ensures that these components are automatically discovered and available for use without requiring manual configuration or external XML/properties files.

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

Added the \PageServlet\, \PageHandler\ interface, and supporting classes (\Menu\, \MenuComparator\, \Page\, \ResourceFilter\) to the \dubbo-compatible\ module. This change restores the Servlet-based Page API, allowing users to access and manage pages through a web interface, with support for sorting menus by order and serving static resources.

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

The Dubbo REST module now supports Spring MVC-style annotations for request handling. This includes argument resolvers for @RequestParam, @PathVariable, @RequestHeader, @CookieValue, @ModelAttribute, @RequestBody, @RequestPart, @MatrixVariable, and @RequestAttribute, as well as support for Spring's @CrossOrigin (CORS) and @ExceptionHandler. A new HandlerInterceptorAdapter bridges Spring's HandlerInterceptor to the Dubbo filter chain, and a ConfigurationWrapper provides access to application configuration. These changes enable developers to build RESTful services using familiar Spring MVC patterns.

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

The \dubbo-config-spring\ module now provides the XSD schema (\dubbo.xsd\), Spring namespace handler, and schema mapping files (\spring.handlers\, \spring.schemas\) that enable XML-based configuration for Dubbo services. This allows users to define and configure Dubbo beans directly in Spring XML files using the \http://dubbo.apache.org/schema/dubbo\ namespace.

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

The \ZookeeperMetadataReport\ class and its factory are introduced to enable storing and retrieving service metadata in a ZooKeeper cluster. This change allows Dubbo applications to use ZooKeeper as a backend for metadata storage, supporting operations like saving provider/consumer metadata, managing service-app mappings, and handling app metadata publishing and removal via the ZooKeeper registry.

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

Added new security configuration files, serialize.allowlist and serialize.blockedlist, to control which classes can be deserialized. The allowlist explicitly permits safe, standard Java and Dubbo types, while the blockedlist prevents deserialization of potentially dangerous classes from various libraries (e.g., Spring, Hibernate, Log4j). This change restricts the set of serializable classes to mitigate remote code execution vulnerabilities associated with unsafe deserialization.

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

The condition router's matching logic has been refactored into a new, extensible architecture within the \dubbo-cluster\ module. This change introduces a \ConditionMatcher\ interface and an \AbstractConditionMatcher\ base class to standardize how conditions are evaluated. Specific matchers are now separated by context: \UrlParamConditionMatcher\ for URL parameters, \ArgumentConditionMatcher\ for method arguments, and \AttachmentConditionMatcher\ for RPC attachments. Each context has its own factory and implementation, allowing for cleaner, more maintainable routing rules. This structural change supports future extensibility for new condition types.

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

The configuration classes in the dubbo-common module have been refactored to use a new abstract base hierarchy. New abstract classes including AbstractConfig, AbstractInterfaceConfig, AbstractMethodConfig, AbstractReferenceConfig, and AbstractServiceConfig have been introduced to consolidate common configuration logic, property handling, and scope model management. This change restructures how service, reference, and application configurations are managed internally, providing a more consistent and extensible foundation for Dubbo's configuration system.

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

A change to existing behaviour in dubbo-common/src/main/resources/META-INF/org — 1 commit, 1 file.

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

A new deprecated class, FutureAdapter, has been added to the dubbo-compatible module. This class implements the legacy java.util.Future interface and adapts it to the modern CompletableFuture-based async model. It provides constructors that accept either a CompletableFuture or an older ResponseFuture, allowing existing code relying on the synchronous Future API to interoperate with the new async result handling mechanisms.

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

New interfaces in the \com.alibaba.dubbo.remoting\ package (Channel, ChannelHandler, Codec, Codec2, Dispatcher, RemotingException, Server, Transporter) are added as deprecated wrappers that delegate to the corresponding \org.apache.dubbo\ classes. This provides a backward-compatible bridge for existing code using the legacy \com.alibaba.dubbo\ package, ensuring that calls to these deprecated APIs are routed to the current Apache Dubbo implementations.

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

New deprecated wrapper classes and interfaces have been added to the \com.alibaba.dubbo.rpc\ package (including \Exporter\, \Filter\, \Invocation\, \Invoker\, \Protocol\, \ProxyFactory\, \Result\, \RpcContext\, \RpcException\, \RpcInvocation\, \RpcResult\, and related service interfaces). These classes delegate to the modern \org.apache.dubbo\ equivalents, ensuring that legacy Alibaba Dubbo code continues to function without modification.

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

New files have been added to the \com.alibaba.dubbo.cache\ package, providing backward-compatible wrappers for the \Cache\ and \CacheFactory\ interfaces. These classes, now marked as \@Deprecated\, bridge the old \com.alibaba.dubbo\ API to the current \org.apache.dubbo\ implementations, ensuring that legacy code relying on the Alibaba package structure continues to function.

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

New deprecated interfaces and classes have been added to the \com.alibaba.dubbo\ package to provide backward compatibility with older Dubbo versions. This includes \Monitor\ and \MonitorFactory\ interfaces that wrap the Apache Dubbo equivalents, and \Registry\, \RegistryFactory\, and \NotifyListener\ interfaces that bridge the \com.alibaba.dubbo\ types to the modern \org.apache.dubbo\ types using \DelegateURL\ for URL conversion. These changes allow legacy applications using the \com.alibaba.dubbo\ namespace to function with the current Apache Dubbo runtime.

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

A new placeholder file named 'version' was added to the META-INF 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 · low confidence

A new BeanPostProcessor, DubboConfigDefaultPropertyValueBeanPostProcessor, now automatically assigns the Spring bean name as the default ID for Dubbo configuration beans when no explicit ID is provided. This ensures that every Dubbo config bean has a predictable identifier, resolving issues where beans could not be found during initialization.

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

Users can now select a preferred JSON library (Fastjson2, Fastjson, Gson, or Jackson) and define the order in which extension classes are loaded via new service provider files. This allows for greater control over serialization and extension loading behavior.

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

The dubbo-compatible module now includes new, deprecated interface shims for the telnet handler and validation components. Specifically, TelnetHandler, Validation, and Validator interfaces in the com.alibaba.dubbo package now extend their org.apache.dubbo counterparts, providing backward compatibility for legacy code while signaling that these APIs are deprecated.

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

The \BaseCommand\ interface and \CommandContext\ class in the \com.alibaba.dubbo.qos.command\ package are now marked as deprecated. These legacy wrappers now delegate to the newer \org.apache.dubbo.qos.api\ equivalents, signaling that users should migrate their custom QoS commands and contexts to the updated API.

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

The @EnableDubbo annotation in the dubbo-compatible module is now marked as @Deprecated. This annotation previously served as a convenience wrapper that internally triggered @DubboComponentScan and @EnableDubboConfig. Users relying on @EnableDubbo for component scanning and configuration binding should migrate to using @DubboComponentScan directly, as the old annotation will be removed in a future release.

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

The FixedThreadPool implementation now logs a warning when configured with an unbounded queue (queues \< 0), alerting users to the risk of OutOfMemoryError under high load and advising them to set a positive integer for the 'queues' parameter.

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

The Hessian2 serialization implementation has been refactored to introduce a new \Hessian2FactoryManager\ that manages serializer factories per \FrameworkModel\ and classloader, enabling scoped configuration of serialization behavior. This change introduces support for configuring Hessian2 serialization via system properties (\DUBBO\_HESSian\_WHITELIST\, \DUBBO\_HESSIAN\_DENY\, \DUBBO\_HESSIAN\_ALLOW\, \DUBBO\_HESSIAN\_ALLOW\_NON\_SERIALIZABLE\), allowing users to define strict whitelist/denylist policies or allow non-serializable classes. The \Hessian2Serialization\ class now retrieves the appropriate factory from the current \FrameworkModel\, ensuring that security and serialization settings are isolated per model. Additionally, AOT (Ahead-of-Time) reflection and resource describers are registered to support native image compilation.

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

Added ActivateComparator and WrapperComparator to the extension support package. These classes provide explicit, deterministic sorting for Dubbo extensions based on @Activate and @Wrapper annotations, ensuring that filters and wrappers are applied in the correct order during invocation. This replaces ad-hoc or implicit ordering logic with a structured comparator approach.

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

The Spring XML schema parsing logic for Dubbo has been refactored to use new, dedicated parser classes. \DubboBeanDefinitionParser\ now handles the majority of Dubbo configuration elements (such as application, module, registry, provider, and consumer), while \AnnotationBeanDefinitionParser\ specifically processes the \\<dubbo:annotation\>\ element. The \DubboNamespaceHandler\ has been updated to register these new parsers, centralizing the XML-to-BeanDefinition mapping for all Dubbo configuration tags.

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

Added ReferenceCountedResource, an abstract base class that manages resource lifecycle via a reference counter. This enables automatic cleanup when the last reference is released, supporting the try-with-resources pattern and preventing potential memory leaks in protocol client handling.

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

Added new classes in the Dubbo common serialization module: a \ClassHolder\ utility that caches classes in a \ConcurrentHashMap\ to avoid potential deadlocks, and a \PreferSerializationProvider\ interface for managing preferred serialization types.

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

The tag routing logic has been refactored into a new state-based implementation (TagStateRouter) that supports dynamic configuration updates from the config center. This change replaces the previous static router with a stateful version that can react to rule changes in real-time, allowing for more flexible and hot-releasable tag-based service routing.

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

The logging subsystem in dubbo-common now supports parameterized message formatting using curly braces (e.g., 'Hi {}'). This is enabled by adding helper classes (FormattingTuple, MessageFormatter) that process message patterns and arguments, allowing developers to write cleaner, more efficient log statements with dynamic content.

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

The Nacos registry module has been refactored to introduce a new service discovery model and improved connection management. A new \NacosServiceDiscovery\ class now handles service registration, unregistration, and instance updates, while \NacosConnectionManager\ manages Nacos \NamingService\ instances with retry logic and health checks. The \NacosRegistry\ has been updated to use the new \NacosNamingServiceWrapper\ for subscribing, unsubscribing, and batch registering instances, which supports both single and batch registration based on server capabilities. Additionally, \NacosAggregateListener\ aggregates service instances for legacy name support, and \NacosServiceName\ provides structured parsing and matching of service names. These changes improve reliability, performance, and compatibility with modern Nacos features.

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

The Dubbo framework now includes a comprehensive set of Service Provider Interface (SPI) configuration files in dubbo-common/src/main/resources/META-INF/dubbo/internal/. These files define mappings for core components including compilers (Adaptive, Jdk, Javassist), JSON utilities (Fastjson2, Fastjson, Gson, Jackson), loggers (Slf4j, Log4j, Log4j2, JCL, JDK), thread pools (Fixed, Cached, Limited, Eager), and metadata builders (Array, Collection, Map, Enum). This change establishes the foundational infrastructure for Dubbo's extension mechanism, enabling dynamic loading of these implementations at runtime.

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

The \dubbo-common\ module introduces a new \param\ package containing a dynamic URL parameter caching system. This includes the \DynamicParamTable\ for global parameter caching, a \DynamicParamSource\ SPI interface for defining parameter sources, and concrete implementations like \DefaultDynamicParamSource\ which initializes standard keys (e.g., version, side, interface) with dynamic or fixed values. This change replaces previous mechanisms for handling URL parameters, aiming to improve memory performance and support multi-instance scenarios.

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

The \ProtocolUtils\ class in \dubbo-common\ has been refactored to improve performance by introducing a new \GroupServiceKeyCache\ class. This change adds a multi-level concurrent cache (\ConcurrentMap\) to store and retrieve service keys, reducing object allocation and memory usage during service key generation. Additionally, the \ProtocolUtils\ class now provides utility methods to identify various generic serialization types (such as default, native Java, Gson, Bean, Protobuf, and raw return) based on the generic string value.

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

The QoS API module was split into a dedicated package, introducing new core interfaces and classes to support command execution and access control. This includes the BaseCommand interface, the Cmd annotation for command metadata, the CommandContext for managing command state, and the PermissionLevel enum to define access tiers. Additionally, the QosConfiguration class was added to manage QoS settings, including anonymous access permissions and IP whitelisting, enabling more granular control over who can execute QoS commands.

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

The QoS module has been refactored to support multi-instance architectures by introducing a new \QosScopeModelInitializer\ that registers the \Server\ and \ActuatorCommandExecutor\ as scope beans. A new \ActuatorCommandExecutor\ and \DefaultCommandExecutor\ handle command execution, routing requests to the appropriate \BaseCommand\ implementations (such as \BaseOffline\, \BaseOnline\, \ChangeTelnet\, and \CountTelnet\) via the framework's extension loader. This change decouples command execution from the global state, allowing each application model to maintain its own set of QoS commands and metrics reporters.

dubbo-plugin/dubbo-qos · high confidence

The directory package is refactored by introducing an AbstractDirectory base class that centralizes connectivity validation, router chain management, and invoker lifecycle handling. StaticDirectory now extends this new base, which manages the router chain, handles connectivity checks, and publishes directory refresh events. This change modifies how invokers are refreshed and filtered, ensuring thread-safe router chain operations and proper cleanup of stale invokers.

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

The Dubbo Spring integration has been refactored to use a new set of Spring BeanPostProcessors for handling @Service, @DubboService, @Reference, and @DubboReference annotations. This includes the introduction of AbstractAnnotationBeanPostProcessor as a base class, alongside specific processors like ReferenceAnnotationBeanPostProcessor for injecting references and ServiceAnnotationPostProcessor for exporting services. The change also adds DubboConfigAliasPostProcessor to manage bean aliases based on configuration IDs, and introduces helper classes like ServiceBeanNameBuilder and ServicePackagesHolder to standardize bean naming and package scanning. This restructuring improves compatibility with modern Spring versions and provides a more robust foundation for annotation-driven service configuration.

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

The Spring integration layer has been refactored to use a new set of components for managing the Dubbo bootstrap lifecycle and configuration initialization. A new \DubboSpringInitializer\ coordinates the binding of Dubbo's \ApplicationModel\ and \ModuleModel\ to the Spring container, ensuring that infrastructure beans like \ReferenceAnnotationBeanPostProcessor\ are registered early. The refactored \DubboConfigBeanInitializer\ now explicitly loads and registers all Dubbo config beans (such as \ApplicationConfig\, \RegistryConfig\, and \ProtocolConfig\) before Spring processes other singleton beans. Additionally, new listeners (\DubboDeployApplicationListener\, \DubboBootstrapApplicationListener\) handle Spring context events to start and stop the Dubbo module and bootstrap, while a \DubboContextPostProcessor\ initializes the environment and config manager. This change improves compatibility with various Spring versions and ensures that Dubbo's internal state is correctly synchronized with the Spring lifecycle.

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

The DynamicConfiguration interface and its abstract implementation have been refactored to support a new event-driven listener model. A new ConfigurationListener interface and ConfigChangedEvent class now allow components to subscribe to configuration changes, receiving notifications for ADDED, MODIFIED, or DELETED events. The DynamicConfiguration interface now exposes methods like addListener/removeListener and getConfigItem, while the abstract base class manages thread pools for executing configuration operations. This change provides a more robust way to react to configuration updates in the config center.

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

The \dubbo-rpc-injvm\ module was refactored to introduce a pluggable deep copy mechanism for local invocations. A new \ParamDeepCopyUtil\ SPI interface and its \DefaultParamDeepCopyUtil\ implementation handle parameter serialization and deserialization, allowing for future customization of the deep copy strategy. The \InjvmInvoker\ and \InjvmProtocol\ classes were restructured to use this utility, and the exporter logic was moved into a dedicated \InjvmExporter\ class. Additionally, test coverage was added for classloader isolation and deep copy behavior.

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

The \AbstractCompiler\ base class was refactored to use a \ConcurrentHashMap\ with \ReentrantLock\ for thread-safe compilation, while \JdkCompiler\ and \JavassistCompiler\ were restructured to use new helper classes \ClassUtils\ and \CtClassBuilder\. This change improves code organization and thread safety in the \dubbo-common\ compiler support package.

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

The extension loading mechanism has been refactored to support scoped extension instances, introducing a hierarchical \ExtensionDirector\ that manages \ExtensionLoader\ instances per scope (Framework, Application, Module, or Self). This change introduces new annotations (\@Activate\, \@Adaptive\, \@DisableInject\, \@Wrapper\) and interfaces (\ExtensionAccessor\, \ExtensionPostProcessor\, \LoadingStrategy\) to control how extensions are discovered, instantiated, and post-processed. The \ExtensionLoader\ now utilizes \LoadingStrategy\ implementations (such as \DubboLoadingStrategy\ and \ServicesLoadingStrategy\) to define resource loading priorities and exclusion rules, allowing for more granular control over which classes are loaded as SPI extensions.

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

The \dubbo-common\ module introduces a new set of classes in the \org.apache.dubbo.common.url.component\ package to handle URL parsing and parameter management. New classes include \DubboServiceAddressURL\, \ServiceAddressURL\, \ServiceConfigURL\, \URLAddress\, \URLItemCache\, \URLParam\, and \URLPlainParam\. This refactoring introduces a more structured approach to URL handling, with \URLParam\ using a \DynamicParamTable\ for compression and \URLPlainParam\ supporting serialization. The \URLItemCache\ provides a thread-safe LRU cache for parameters and paths. These changes aim to improve performance, memory usage, and support for serialization, addressing issues like timeout caching and memory leaks mentioned in the commit history.

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

The Zookeeper config center implementation has been refactored to improve performance and observability. A new caching layer (CacheListener) was introduced to reuse ZK data listeners per path, reducing the creation of duplicate listeners and improving efficiency. Additionally, configuration change events are now published to the metrics event bus, enabling monitoring of config center activity. The implementation also includes a dedicated thread pool for handling ZK events and improved lifecycle management for ZK clients.

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

The cluster support classes in the \dubbo-cluster\ module have been refactored. The \AbstractClusterInvoker\ and all concrete cluster invokers (e.g., \FailoverClusterInvoker\, \FailbackClusterInvoker\, \ForkingClusterInvoker\) have been restructured, introducing a \ClusterUtils\ helper for URL merging and updating the base class to support connectivity validation and sticky invoker selection. This change modifies how cluster routing, retry logic, and concurrent invocation are handled internally.

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

The configuration loading mechanism has been refactored to support multi-instance and module-scoped configurations. A new \Environment\ class manages distinct configuration sources (system properties, environment variables, app configs) and composites them via \CompositeConfiguration\. This enables proper precedence and isolation of configuration values per module or application scope, improving how Dubbo resolves properties from different sources.

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

The AbstractConfigurator class was refactored to separate v2.7+ condition matching from legacy behavior. The new logic explicitly checks the CONFIG\_VERSION\_KEY to determine whether to apply modern condition matching (including support for ConditionMatch via the parser model) or fall back to deprecated matching for pre-2.7 compatibility. This ensures that configurator rules are applied only when conditions match, with specific handling for provider/consumer side effects and application/service key validation.

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

The extension injection system has been refactored to introduce two new classes: AdaptiveExtensionInjector, which dynamically resolves dependencies by iterating through all registered ExtensionInjectors, and SpiExtensionInjector, which handles injection for SPI-annotated interfaces. This change modifies how the framework manages dependency injection for extensions, potentially affecting how services are instantiated and accessed within the Dubbo runtime.

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

The metadata definition logic in dubbo-common has been refactored to improve how service and method definitions are constructed. New builder classes—MethodDefinitionBuilder, ServiceDefinitionBuilder, and TypeDefinitionBuilder—have been introduced to handle the generation of method and service metadata. The ServiceDefinitionBuilder now constructs FullServiceDefinition and ServiceDefinition objects by iterating over interface methods and their parameters, while the TypeDefinitionBuilder manages type caching and delegates to specific TypeBuilder extensions. This change alters the internal mechanism for generating JSON schemas and metadata representations, which may affect how metadata is serialized or interpreted by downstream consumers.

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

The registry module has been refactored to introduce new core interfaces and wrapper classes. A new \Registry\ interface has been added, along with a \ListenerRegistryWrapper\ that wraps registry implementations to notify \RegistryServiceListener\ instances for register, unregister, subscribe, and unsubscribe events. A \RegistryNotifier\ class has been introduced to handle delayed notification scheduling. Additionally, a \Constants\ interface was added to centralize registry-related keys and default values, and a \RegistryScopeModelInitializer\ was added to register beans like \RegistryManager\ and \MetadataServiceDelegation\ during application model initialization.

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

The Dubbo Spring module now registers several Spring-specific implementations via the Service Provider Interface (SPI) mechanism. These include the SpringExtensionInjector, SpringStatusChecker, DataSourceStatusChecker, SpringParameterNameReader, DubboBootstrapStartStopListener, and SpringScopeModelInitializer. This configuration enables Spring-aware extension loading, status checking, parameter name reading, and lifecycle management within the Spring environment.

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

The SpringExtensionInjector is introduced to allow Dubbo to resolve extension instances from the Spring ApplicationContext. This enables automatic injection of Spring-managed beans into Dubbo components, improving interoperability between Spring and Dubbo's extension mechanism.

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

The Spring module's configuration and bean handling has been refactored. A new \ConfigCenterBean\ is introduced to support standard Spring \PropertySource\ integration, allowing Dubbo to read external configurations from the Spring \Environment\ when \includeSpringEnv\ is enabled. The existing \ServiceBean\ and \ReferenceBean\ have been updated to align with this new configuration model, ensuring that service exports and references are properly initialized within the Spring lifecycle.

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

The ConfigParser now supports parsing configuration rules scoped to the application level, in addition to the existing service-level scoping. When a configuration specifies an application scope, the parser generates URLs with the 'application' parameter and the 'app\_dynamic\_configurators' category, ensuring that override rules are correctly applied to all services within that application.

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

The Maven Wrapper configuration has been updated to use Maven 3.9.9 and the Maven Wrapper 3.1.1. This ensures that all developers and CI systems use a consistent, pre-configured version of Maven for building the project, eliminating discrepancies caused by different local Maven installations.

.mvn/wrapper · high confidence

A new .mvn/jvm.config file has been added to the project to set JVM system properties for file and stream encoding (UTF-8). This change addresses an OutOfMemoryError that occurred during Maven builds, ensuring consistent character encoding and improving build stability.

.mvn · low confidence

Add unit tests for DefaultDubboConfigBinder; Added FileTest to verify Dubbo module consistency; Added Nacos demo test suite for Dubbo Spring integration; Added Spring integration tests for annotation and Java config scenarios; Added concurrency and routing tests for the directory module; Added mock implementations for Dubbo SPI extensions in tests; Added mock registry and service discovery classes for testing; Added sample bootstrap classes for Zookeeper-based Spring integration; Added serialization allowlist and blockedlist test resources; Added serialization allowlist for security testing; Added serialization test suite for custom serialization implementation; Added test annotations for merged @Service and @Reference attributes; Added test certificates for dynamic cert support; Added test configuration files for Dubbo Spring integration; Added test configuration files for Nacos integration; Added test configuration files for Zookeeper-based service introspection; Added test configuration for Dubbo consumer annotations; Added test coverage for AppScriptStateRouter; Added test coverage for ConfigCenterBean external configuration loading; Added test coverage for Dubbo RPC filters and support classes; Added test coverage for local call reference mixing; Added test fixture for annotation-based consumer configuration; Added test fixtures for Dubbo annotation-based service providers; Added test fixtures for Dubbo service testing; Added test fixtures for multiple Dubbo configuration issues; Added test for Dubbo keeping running after Spring context close; Added test for duplicate Dubbo reference bean handling; Added test for multiple consumer and provider configurations; Added test implementation classes for Dubbo Spring integration; Added test infrastructure for Dubbo Spring integration; Added test interfaces for Dubbo Spring integration; Added test resource files for Dubbo compatibility layer; Added test resource files for unit tests; Added test resources for Dubbo SPI and extension loading; Added test resources for Dubbo cluster routing and configuration; Added test resources for Dubbo configuration; Added test resources for bytecode, extension, and serialization tests; Added test resources for cluster and router components; Added test resources for cluster router rules; Added test resources for logging and configuration; Added test resources for metrics, registry, and RPC filters; Added test service provider files for Dubbo extension loading; Added test utilities and fixtures for the Spring config module; Added test utilities and sample services for integration testing; Added test version configuration for Dubbo Common; Added tests for Dubbo Spring Boot configuration and reference bean conditional loading; Added tests for Dubbo XML configuration with N/A registry; Added tests for Dubbo config Spring integration; Added tests for Dubbo generic and echo services; Added tests for Dubbo-compatible router implementations; Added tests for DubboSpringInitCustomizer; Added tests for Spring property placeholder resolution in Dubbo configuration; Added tests for Spring schema namespace handling and generic service invocation; Added tests for annotation processing and type definition builders; Added tests for local call reference bean registration and multiple reference annotations; Added tests for thread pool isolation between services; Added unit tests for BitList; Added unit tests for ConditionStateRouter; Added unit tests for DefaultFilterChainBuilder; Added unit tests for Dubbo Spring annotation configuration; Added unit tests for Dubbo Spring annotation processing; Added unit tests for Dubbo cluster invokers and utilities; Added unit tests for Dubbo cluster merger implementations; Added unit tests for Dubbo cluster wrapper invokers; Added unit tests for Dubbo config bean initialization and reference key generation; Added unit tests for Dubbo config classes; Added unit tests for Dubbo extension loading and annotation utilities; Added unit tests for Dubbo load balancing strategies; Added unit tests for Dubbo mesh routing rule matchers; Added unit tests for FileRouterEngine; Added unit tests for Java-based Dubbo reference bean configuration; Added unit tests for MockInvokersSelector; Added unit tests for NacosServiceName; Added unit tests for RpcContext future handling; Added unit tests for ScriptStateRouter; Added unit tests for Spring extension injection; Added unit tests for Spring status checkers; Added unit tests for TagStateRouter; Added unit tests for ZoneAwareClusterInvoker; Added unit tests for cluster configuration and sticky load balancing; Added unit tests for cluster configurators; Added unit tests for common module components; Added unit tests for condition-based routing rules; Added unit tests for configuration classes and demo services; Added unit tests for local Dubbo calls; Added unit tests for mesh routing components; Added unit tests for mesh routing rules; Added unit tests for router snapshot filtering; Added unit tests for the Affinity Router; Added unit tests for the cache module; Updated Dubbo-compatible test definitions for configuration classes.

The project has upgraded the Netty dependency to version 4.2.15.Final. This update brings the latest improvements and fixes from the Netty 4.2.x series, ensuring compatibility with newer Java versions and providing enhanced performance and stability for the underlying network communication layer.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 64.

• Code Health 70
• Architecture 100
• Maturity 58
• Readiness 65
• Security 70

• 300 commits — 265 feature/other, 35 fixes

• dubbo-dependencies-bom/pom.xml — 117 commits
• (root) — 44 commits
• dubbo-plugin/dubbo-rest-openapi — 18 commits
• dubbo-config/dubbo-config-api — 14 commits
• dubbo-common/src — 13 commits
• dubbo-config/dubbo-config-spring — 12 commits
• dubbo-maven-plugin/pom.xml — 12 commits
• dubbo-rpc/dubbo-rpc-triple — 12 commits
• dubbo-demo/dubbo-demo-spring-boot — 6 commits
• dubbo-remoting/dubbo-remoting-http12 — 6 commits
• (repo) — 5 commits
• dubbo-cluster/src — 4 commits
• dubbo-registry/dubbo-registry-api — 4 commits
• dubbo-remoting/dubbo-remoting-netty4 — 4 commits
• .github/workflows — 3 commits
• dubbo-plugin/dubbo-spring6-security — 3 commits
• dubbo-test/dubbo-test-check — 3 commits
• dubbo-metadata/dubbo-metadata-api — 2 commits
• dubbo-rpc/dubbo-rpc-dubbo — 2 commits
• .github/ISSUE_TEMPLATE — 1 commit

• fix: Enhance bug template with reproduction demo checkbox (#15977)
• fix: Fix #15988: Clear SecurityContext in finally block to prevent thread pollution (#15997)
• fix: Fix CompositeInputStream close handling (#16305)
• fix: Fix LRUCache and LRU2Cache to trim entries when max capacity is reduced (#16053)
• fix: Fix StringUtils.substringAfter to return empty string when separator is absent (#16350)
• fix: Fix StringUtils.toBoolean to return false for "off" (#16348)
• fix: Fix Triple method resolution for overloaded wrapper methods (#16325)
• fix: Fix UnsupportedOperationException in DubboDefaultPropertiesEnvironmentPostProcessor on immutable defaultProperties (#16268) (#16313)
• fix: Fix environment-dependent flakiness in XmlSafetyTest by restricting process comparison to child sleep commands (#15776)
• fix: Fix init stream race (#16039)
• fix: Fix issue 12517, implemented new module for otlp config along with test checking jvm metric export using mock server (#16023)
• fix: Fix mesh route match list semantics (#16377)
• fix: Fix misleading NPE when request parameter is not Serializable (#16299)
• fix: Fix multiple tests in ServiceConfigTest.java (#15785)
• fix: Fix order-sensitive thread pool status test (#16300)
• fix: Fix remaining outlier dubbo-config-spring tests (#15846)
• fix: Fix several flaky tests in DubboBootstrapTest (#15793)
• fix: Fix several tests in dubbo-config-spring beans module (#15834)
• fix: Fix some bug about proto copy (#15825)
• fix: Fix timestamp filtering in ZooKeeper registry causing pre-warmup failure (#16034)
• …and 280 more

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

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.