More RPC Extension Protocol Implementations Provided by Dubbo on Apache Dubbo

Redis Protocol

Mon, 01 Jan 0001 00:00:00 +0000

RPC protocol implemented based on Redis ¹.

Tip

Supports versions above 2.3.0

Register Redis Service Address

RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
registry.register(URL.valueOf("redis://10.20.153.11/com.foo.BarService?category=providers&dynamic=false&application=foo&group=member&loadbalance=consistenthash"));

Referencing on the Client Side

Use on the client side ²:

<dubbo:reference id="store" interface="java.util.Map" group="member" />

Alternatively, point-to-point direct connection:

<dubbo:reference id="store" interface="java.util.Map" url="redis://10.20.153.10:6379" />

You can also use a custom interface:

<dubbo:reference id="store" interface="com.foo.StoreService" url="redis://10.20.153.10:6379" />

It is recommended that the method names match the standard Redis method names, namely: get(key), set(key, value), delete(key).

Thrift Protocol

Mon, 01 Jan 0001 00:00:00 +0000

The Thrift protocol currently supported by Dubbo is an extension of the native Thrift protocol ¹, adding some extra header information on top of the base protocol, such as service name, magic number, etc.

Note

Version 2.3.0 and above supported

Using the Dubbo Thrift protocol also requires the Thrift IDL compiler to compile and generate the corresponding Java code. Future versions will enhance this aspect.

Dependencies

<dependency>
 <groupId>org.apache.thrift</groupId>
 <artifactId>libthrift</artifactId>
 <version>0.8.0</version>
</dependency>

Configuration

All services share a common port ²:

Memcached Protocol

Mon, 01 Jan 0001 00:00:00 +0000

RPC protocol based on memcached ¹.

Tip

Support for version 2.3.0 and above

Registering the memcached service address

RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
registry.register(URL.valueOf("memcached://10.20.153.11/com.foo.BarService?category=providers&dynamic=false&application=foo&group=member&loadbalance=consistenthash"));

Referencing on the client side

Use on the client side ²:

<dubbo:reference id="cache" interface="java.util.Map" group="member" />

Or, connect directly point-to-point:

<dubbo:reference id="cache" interface="java.util.Map" url="memcached://10.20.153.10:11211" />

Custom interfaces can also be used:

<dubbo:reference id="cache" interface="com.foo.CacheService" url="memcached://10.20.153.10:11211" />

It is recommended that method names match the standard method names of memcached, namely: get(key), set(key, value), delete(key).

Rest Protocol

Mon, 01 Jan 0001 00:00:00 +0000

Note

Starting from Dubbo version 3.3, the Rest protocol has been moved to the Extensions library, and the Triple protocol provides more comprehensive support for Rest. For more details, see the Triple Rest User Manual. If you wish to continue using the original Rest protocol, you can introduce the corresponding dubbo-spi-extensions library dependency.

A lighter, Dubbo-style Rest protocol for interoperation within microservices (Spring Cloud Alibaba).

Annotation Parsing
Message Encoding and Decoding

Rmi Protocol

Mon, 01 Jan 0001 00:00:00 +0000

Feature Description

The RMI protocol uses the JDK standard java.rmi.* implementation, employing a blocking short connection and JDK standard serialization.

Number of connections: Multiple connections
Connection type: Short connection
Transport protocol: TCP
Transport method: Synchronous transmission
Serialization: Java standard binary serialization
Applicable scope: Mixed sizes of incoming and outgoing parameter data packets, with a number of consumers and providers roughly the same, can transfer files.
Applicable scenarios: Routine remote service method calls, interoperable with native RMI services.

Constraints

Parameters and return values must implement the Serializable interface.
The timeout configured in Dubbo is ineffective for RMI and must be set using Java startup parameters: -Dsun.rmi.transport.tcp.responseTimeout=3000, refer to the RMI configuration below.

Usage Scenarios

It is a set of APIs in Java that support the development of distributed applications, achieving method calls between programs on different operating systems.

Hessian Protocol

Mon, 01 Jan 0001 00:00:00 +0000

Feature Description

The Hessian protocol is used for integrating services that utilize Hessian. It is based on HTTP communication and uses Servlet to expose services, with Dubbo embedding Jetty as the server implementation by default.

Hessian is an open-source RPC framework from Caucho, whose communication efficiency is higher than that of WebService and Java’s built-in serialization.

Number of connections: multiple connections
Connection method: short connection
Transport protocol: HTTP
Transport method: synchronous transmission
Serialization: Hessian binary serialization
Applicable scope: larger incoming and outgoing parameter data packets, more providers than consumers, higher pressure on providers, allows file transfer.
Applicable scenarios: page transfer, file transfer, or interoperability with native Hessian services.

Dubbo’s Hessian protocol can interoperate with native Hessian services, which means:

Webservice Protocol

Mon, 01 Jan 0001 00:00:00 +0000

Feature Description

WebService-based remote call protocol, implemented based on Apache CXF frontend-simple and transports-http. Supported in versions 2.3.0 and above.

CXF is an Apache open-source RPC framework formed by the merger of Xfire and Celtix.

Number of connections: Multiple connections
Connection method: Short connections
Transport protocol: HTTP
Transport method: Synchronous transmission
Serialization: SOAP text serialization
Applicable scenarios: System integration, cross-language calls

It can interoperate with native WebService services, meaning:

The provider exposes the service via Dubbo’s WebService protocol, and the consumer directly calls using the standard WebService interface,
Or the provider uses standard WebService to expose services, and the consumer calls using Dubbo’s WebService protocol.

Constraints

Parameters and return values must implement the Serializable interface
Parameters should preferably use basic types and POJOs

Usage Scenarios

Publishing a service (internally/externally), regardless of client type or performance, it is recommended to use webservice. If the server has determined to use webservice, the client has no choice and must use webservice.