Apache Dubbo 2.7.5 Release: New Features, Performance Boosts, and Cloud‑Native Enhancements

Apache Dubbo 2.7.5 has been officially released, bringing a set of new capabilities such as application‑level service registration (beta), native HTTP/2 (gRPC) support, Protobuf integration, significant performance gains (≈30% QPS increase), TLS‑secured communication, an optimized consumer thread‑pool model, a new load‑balancing strategy for multi‑registry clusters, a revamped Bootstrap API, and various other functional enhancements.

1. Application‑Level Service Registration (beta)

Dubbo moves from interface‑granularity to application‑granularity service discovery, allowing each instance to register a single record, which reduces registration overhead and aligns Dubbo with mainstream cloud‑native ecosystems such as Spring Cloud and Kubernetes.

The mechanism, called service introspection, is illustrated by the following diagram (omitted). For details, see the earlier article "How Dubbo Becomes the Best Framework for Connecting Heterogeneous Microservice Systems".

2. HTTP/2 (gRPC) Protocol Support

Dubbo now supports the HTTP/2‑based gRPC protocol, improving universality and protocol penetration, enabling stream‑based and reactive RPC, and allowing seamless integration with existing gRPC or multi‑language ecosystems.

Sample repositories for gRPC and TLS examples:

https://github.com/apache/dubbo-samples/tree/master/java/dubbo-samples-ssl
https://github.com/apache/dubbo-samples/tree/master/java/dubbo-samples-grpc

3. Protobuf Support

Protobuf provides language‑neutral service definitions and efficient cross‑language serialization, addressing the limitations of Dubbo's previous serialization options (JSON, Hessian2, Kryo, etc.). An example .proto file is shown below.

syntax = "proto3";
option java_multiple_files = true;
option java_package = "org.apache.dubbo.demo";
option java_outer_classname = "DemoServiceProto";
option objc_class_prefix = "DEMOSRV";

package demoservice;

// The demo service definition.
service DemoService {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

4. Performance Optimizations

4.1 Call‑Chain Optimization

Benchmarking shows an overall QPS increase of nearly 30% and reduced memory allocation. The new ServiceRepository concept pre‑generates ServiceDescriptor and MethodDescriptor during registration, cutting runtime overhead.

4.2 Consumer Thread‑Pool Model Optimization

The previous model created a dedicated consumer thread pool for deserialization, which incurred extra overhead. The new model reuses the business thread after a ThreadlessExecutor.wait() call, processing the response directly in the calling thread, thereby eliminating the extra thread‑pool.

5. TLS Secure Transmission

Both the built‑in Netty server and the newly added gRPC protocol now support TLS. Configuration examples:

SslConfig sslConfig = new SslConfig();
sslConfig.setServerKeyCertChainPath("path to cert");
sslConfig.setServerPrivateKeyPath(args[1]);
// If mutual TLS is enabled
if (mutualTls) {
  sslConfig.setServerTrustCertCollectionPath(args[2]);
}
ProtocolConfig protocolConfig = new ProtocolConfig("dubbo/grpc");
protocolConfig.setSslEnabled(true);

Consumer side configuration follows a similar pattern, with optional client certificates for mutual authentication.

6. Bootstrap API (beta)

DubboBootstrap provides a unified entry point for application‑level configuration, simplifying service registration and eliminating the need to repeat global configs for each service.

ProtocolConfig protocolConfig = new ProtocolConfig("grpc");
protocolConfig.setSslEnabled(true);

SslConfig sslConfig = new SslConfig();
sslConfig.setXxxCert(...);

DubboBootstrap bootstrap = DubboBootstrap.getInstance();
bootstrap.application(new ApplicationConfig("ssl-provider"))
         .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
         .protocol(protocolConfig)
         .ssl(sslConfig);

ServiceConfig
service1 = new ServiceConfig<>();
ServiceConfig
service2 = new ServiceConfig<>();
bootstrap.service(service1).service(service2);
bootstrap.start();

7. Multi‑Registry Cluster Load Balancing

Dubbo 2.7.5 adds load‑balancing strategies across multiple registries, such as preferred priority, zone‑aware routing, and weighted round‑robin (e.g., 10:1 between Beijing and Shanghai clusters).

8. Other Enhancements

Address change event notification interface.

External configuration loading entry point.

Config module refactoring.

Extended parameters configuration.

Various bug fixes.

9. Summary and Outlook

Future Dubbo releases will continue to evolve service introspection, expand cloud‑native capabilities (Kubernetes deployment, hybrid VM/K8s scenarios), improve performance of call chains and service governance, and introduce authentication, circuit‑breaker, and other enterprise‑grade features.