CtrlK
BlogDocsLog inGet started
Tessl Logo

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.

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

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();
}
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.apache.dubbo/dubbo@3.3.x
Publish Source
CLI
Badge
tessl/maven-org-apache-dubbo--dubbo badge