or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

clustering.mdconfiguration.mdextensions.mdindex.mdmetadata.mdregistry.mdrpc-core.mdserialization.mdspring-boot.md
tile.json

tessl/maven-org-apache-dubbo--dubbo

Apache Dubbo is a powerful RPC framework for building enterprise-grade microservices with service discovery, load balancing, and fault tolerance.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.apache.dubbo/dubbo@3.3.x

To install, run

npx @tessl/cli install tessl/maven-org-apache-dubbo--dubbo@3.3.0

index.mddocs/

Apache Dubbo

Apache Dubbo is a powerful and user-friendly RPC framework that provides solutions for communication, service discovery, traffic management, observability, security, and tooling for building enterprise-grade microservices. It supports multiple protocols including Triple (gRPC-compatible), Dubbo2 (TCP), and REST, with comprehensive service discovery, load balancing, and fault tolerance capabilities.

Package Information

  • Package Name: org.apache.dubbo:dubbo
  • Package Type: maven
  • Language: Java
  • JDK Requirements: Java 8 or higher
  • Installation: Add dependency to your Maven or Gradle project
  • Documentation: https://dubbo.apache.org/

Core Imports

// Core bootstrap and configuration
import org.apache.dubbo.config.bootstrap.DubboBootstrap;
import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.ProtocolConfig;
import org.apache.dubbo.config.RegistryConfig;

// Service definition and consumption
import org.apache.dubbo.config.ServiceConfig;
import org.apache.dubbo.config.ReferenceConfig;

// Spring Boot integration
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.apache.dubbo.config.annotation.DubboService;
import org.apache.dubbo.config.annotation.DubboReference;

// Core RPC interfaces
import org.apache.dubbo.rpc.Invoker;
import org.apache.dubbo.rpc.RpcContext;
import org.apache.dubbo.rpc.service.GenericService;

// Extension system
import org.apache.dubbo.common.extension.ExtensionLoader;
import org.apache.dubbo.common.extension.SPI;
import org.apache.dubbo.common.extension.Adaptive;
import org.apache.dubbo.common.extension.Activate;

// Metadata management
import org.apache.dubbo.config.MetadataReportConfig;
import org.apache.dubbo.metadata.MetadataService;

// URL and parameters
import org.apache.dubbo.common.URL;

Maven dependency:

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo</artifactId>
    <version>3.3.5</version>
</dependency>

Spring Boot starter:

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>3.3.5</version>
</dependency>

Basic Usage

Programmatic Bootstrap

import org.apache.dubbo.config.bootstrap.DubboBootstrap;
import org.apache.dubbo.config.*;

// Initialize Dubbo application
DubboBootstrap bootstrap = DubboBootstrap.getInstance();

// Configure application
ApplicationConfig application = new ApplicationConfig("my-app");
ProtocolConfig protocol = new ProtocolConfig("dubbo", 20880);
RegistryConfig registry = new RegistryConfig("zookeeper://127.0.0.1:2181");

// Bootstrap configuration
bootstrap.application(application)
         .protocol(protocol)
         .registry(registry);

// Export a service
ServiceConfig<GreeterService> service = new ServiceConfig<>();
service.setInterface(GreeterService.class);
service.setRef(new GreeterServiceImpl());
bootstrap.service(service);

// Reference a service
ReferenceConfig<GreeterService> reference = new ReferenceConfig<>();
reference.setInterface(GreeterService.class);
bootstrap.reference(reference);

// Start Dubbo
bootstrap.start();

// Use the service
GreeterService greeter = reference.get();
String greeting = greeter.sayHello("World");

Spring Boot Integration

@SpringBootApplication
@EnableDubbo
public class DubboApplication {
    public static void main(String[] args) {
        SpringApplication.run(DubboApplication.class, args);
    }
}

// Service provider
@DubboService
public class GreeterServiceImpl implements GreeterService {
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

// Service consumer
@RestController
public class GreeterController {
    
    @DubboReference
    private GreeterService greeterService;
    
    @GetMapping("/greet/{name}")
    public String greet(@PathVariable String name) {
        return greeterService.sayHello(name);
    }
}

Application properties:

dubbo.application.name=my-dubbo-app
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
dubbo.registry.address=zookeeper://127.0.0.1:2181

Architecture

Apache Dubbo follows a layered architecture with these key components:

  • Configuration Layer: Provides programmatic and declarative configuration options through various config classes and Spring Boot integration
  • RPC Layer: Core remote procedure call abstraction with protocol-independent service invocation
  • Registry Layer: Service discovery and registration with support for multiple backends (ZooKeeper, Nacos, Consul, etc.)
  • Cluster Layer: Load balancing, fault tolerance, and routing with multiple strategies
  • Remoting Layer: Network communication abstraction supporting various protocols and transports
  • Serialization Layer: Pluggable serialization with multiple protocol support (Protocol Buffers, Hessian, JSON)
  • Extension System: SPI-based architecture for customizing all major components

Capabilities

Application Bootstrap and Configuration

Core application lifecycle management and configuration system supporting both programmatic and declarative approaches.

// Main bootstrap entry point
public class DubboBootstrap {
    public static DubboBootstrap getInstance();
    public DubboBootstrap application(ApplicationConfig application);
    public DubboBootstrap protocol(ProtocolConfig protocol);
    public DubboBootstrap registry(RegistryConfig registry);
    public DubboBootstrap service(ServiceConfig<?> service);
    public DubboBootstrap reference(ReferenceConfig<?> reference);
    public DubboBootstrap start();
    public DubboBootstrap stop();
}

// Application configuration
public class ApplicationConfig extends AbstractConfig {
    public ApplicationConfig(String name);
    public void setName(String name);
    public void setVersion(String version);
    public void setOwner(String owner);
}

Configuration and Bootstrap

RPC Core System

Foundation RPC abstractions for service invocation, proxy creation, and request/response processing.

// Core service invoker
public interface Invoker<T> {
    Result invoke(Invocation invocation) throws RpcException;
    Class<T> getInterface();
    URL getUrl();
    boolean isAvailable();
    void destroy();
}

// RPC invocation context
public class RpcContext {
    public static RpcContext getContext();
    public RpcContext setAttachment(String key, String value);
    public String getAttachment(String key);
    public boolean isProviderSide();
    public boolean isConsumerSide();
}

// Generic service invocation
public interface GenericService {
    Object $invoke(String method, String[] parameterTypes, Object[] args) 
        throws GenericException;
    CompletableFuture<Object> $invokeAsync(String method, String[] parameterTypes, Object[] args);
}

RPC Core

Service Discovery and Registry

Service registration and discovery with support for multiple registry backends and dynamic service management.

// Registry interface
public interface Registry {
    void register(URL url);
    void unregister(URL url);
    void subscribe(URL url, NotifyListener listener);
    void unsubscribe(URL url, NotifyListener listener);
    List<URL> lookup(URL url);
}

// Registry factory
public interface RegistryFactory {
    Registry getRegistry(URL url);
}

// Configuration
public class RegistryConfig extends AbstractConfig {
    public void setAddress(String address);
    public void setProtocol(String protocol);
    public void setUsername(String username);
    public void setPassword(String password);
}

Service Discovery

Clustering and Load Balancing

Advanced clustering strategies for fault tolerance, load balancing, and traffic management across multiple service providers.

// Cluster fault tolerance strategies
public interface Cluster {
    <T> Invoker<T> join(Directory<T> directory) throws RpcException;
}

// Load balancing algorithms
public interface LoadBalance {
    <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) 
        throws RpcException;
}

// Provider directory management
public interface Directory<T> {
    Class<T> getInterface();
    List<Invoker<T>> list(Invocation invocation) throws RpcException;
    List<Invoker<T>> getAllInvokers();
    URL getUrl();
    boolean isDestroyed();
}

Clustering and Load Balancing

Spring Boot Integration

Comprehensive Spring Boot integration with auto-configuration, annotations, and properties-based configuration.

// Enable Dubbo in Spring applications
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(DubboComponentScanRegistrar.class)
public @interface EnableDubbo {
    String[] scanBasePackages() default {};
    Class<?>[] scanBasePackageClasses() default {};
}

// Service provider annotation
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DubboService {
    String version() default "";
    String group() default "";
    String protocol() default "";
    int timeout() default -1;
    int retries() default -1;
}

// Service consumer annotation
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DubboReference {
    String version() default "";
    String group() default "";
    int timeout() default -1;
    boolean async() default false;
}

Spring Boot Integration

Extension System

SPI-based extension system enabling customization of all major Dubbo components including protocols, load balancers, and registries.

// Extension point marker
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface SPI {
    String value() default "";
    ExtensionScope scope() default ExtensionScope.FRAMEWORK;
}

// Extension loading and management
public class ExtensionLoader<T> {
    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type);
    public T getExtension(String name);
    public T getAdaptiveExtension();
    public T getDefaultExtension();
    public List<T> getActivateExtensions(URL url, String[] values, String group);
    public Set<String> getSupportedExtensions();
    public boolean hasExtension(String name);
}

// Adaptive extension selection
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)  
public @interface Adaptive {
    String[] value() default {};
}

// Extension activation
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Activate {
    String[] group() default {};
    String[] value() default {};
    String[] before() default {};
    String[] after() default {};
    int order() default 0;
}

Extension System

Metadata Management

Comprehensive service metadata collection, storage, and retrieval for service discovery optimization and contract management.

// Metadata report configuration
public class MetadataReportConfig extends AbstractConfig {
    public void setAddress(String address);
    public void setUsername(String username);
    public void setPassword(String password);
    public void setTimeout(Integer timeout);
    public void setRetryTimes(Integer retryTimes);
    public void setCycleReport(Boolean cycleReport);
    public void setSyncReport(Boolean syncReport);
}

// Metadata service for runtime operations
public interface MetadataService {
    String getServiceDefinition(String interfaceName, String version, String group);
    SortedSet<String> getExportedURLs(String serviceInterface, String group, String version, String protocol);
    SortedSet<String> getSubscribedURLs();
    String getMetadataVersion();
    MetadataInfo getMetadataInfo(String revision);
}

// Metadata report interface
@SPI("zookeeper")
public interface MetadataReport {
    void storeProviderMetadata(MetadataIdentifier providerMetaDataIdentifier, String serviceDefinition);
    void storeConsumerMetadata(MetadataIdentifier consumerMetadataIdentifier, String serviceParameterString);
    String getServiceDefinition(MetadataIdentifier metadataIdentifier);
}

Metadata Management

Serialization

Pluggable serialization framework supporting multiple protocols including Hessian2, Protobuf, JSON, and Java native serialization.

// Serialization interface
@SPI("hessian2")
public interface Serialization {
    byte getContentTypeId();
    String getContentType();
    ObjectOutput serialize(URL url, OutputStream output) throws IOException;
    ObjectInput deserialize(URL url, InputStream input) throws IOException;
}

// Object output for writing serialized data
public interface ObjectOutput extends DataOutput {
    void writeObject(Object obj) throws IOException;
    void writeUTF(String s) throws IOException;
    void writeBytes(byte[] b) throws IOException;
    void flushBuffer() throws IOException;
}

// Object input for reading serialized data
public interface ObjectInput extends DataInput {
    Object readObject() throws IOException, ClassNotFoundException;
    <T> T readObject(Class<T> cls) throws IOException, ClassNotFoundException;
    String readUTF() throws IOException;
    byte[] readBytes() throws IOException;
}

Serialization

Key Constants and Enums

// Common constants
public class CommonConstants {
    public static final String DEFAULT_TIMEOUT = "1000";
    public static final String DEFAULT_RETRIES = "2";
    public static final String GENERIC_SERIALIZATION_NATIVE_JAVA = "nativejava";
    public static final String GENERIC_SERIALIZATION_DEFAULT = "true";
    public static final String HEARTBEAT_KEY = "heartbeat";
    public static final String HEARTBEAT_TIMEOUT_KEY = "heartbeat.timeout";
}

// Registry constants
public class RegistryConstants {
    public static final String REGISTRY_KEY = "registry";
    public static final String REGISTRY_PROTOCOL = "registry";
    public static final String DYNAMIC_KEY = "dynamic";
    public static final String CATEGORY_KEY = "category";
    public static final String PROVIDERS_CATEGORY = "providers";
    public static final String CONSUMERS_CATEGORY = "consumers";
}

// RPC constants
public class RpcConstants {
    public static final String TOKEN_KEY = "token";
    public static final String ASYNC_KEY = "async";
    public static final String RETURN_KEY = "return";
    public static final String THROW_EXCEPTION_KEY = "throw.exception";
}

Types and Interfaces

// Core URL type for configuration and addressing
public class URL implements Serializable {
    public URL(String protocol, String host, int port, String path, Map<String, String> parameters);
    public String getProtocol();
    public String getHost();
    public int getPort();
    public String getPath();
    public String getParameter(String key);
    public String getParameter(String key, String defaultValue);
    public Map<String, String> getParameters();
    public URL addParameter(String key, String value);
    public URL removeParameter(String key);
}

// RPC invocation representation
public interface Invocation {
    String getTargetServiceUniqueName();
    String getMethodName();
    String getServiceName();
    Class<?>[] getParameterTypes();
    Object[] getArguments();
    Map<String, String> getAttachments();
    String getAttachment(String key);
    String getAttachment(String key, String defaultValue);
}

// RPC result container
public interface Result {
    Object getValue();
    void setValue(Object value);
    Throwable getException();
    void setException(Throwable t);
    boolean hasException();
    Map<String, String> getAttachments();
    String getAttachment(String key);
}

// RPC exception with error codes
public class RpcException extends RuntimeException {
    public static final int UNKNOWN_EXCEPTION = 0;
    public static final int NETWORK_EXCEPTION = 1;
    public static final int TIMEOUT_EXCEPTION = 2;
    public static final int BIZ_EXCEPTION = 3;
    public static final int FORBIDDEN_EXCEPTION = 4;
    public static final int SERIALIZATION_EXCEPTION = 5;
    
    public RpcException(int code, String message);
    public int getCode();
}