Enterprise Distributed Application Service: Developer guide
Enterprise Distributed Application Service (EDAS) supports Apache Dubbo for building microservice applications. This guide covers the Dubbo Service Provider Interface (SPI) extension system, framework internals, and design principles.
How the SPI extension system works
Dubbo uses a lightweight SPI mechanism to keep its core modular. Every major component -- protocols, load balancers, routers, registries -- is defined as a pluggable extension point. This means you can:
Swap built-in implementations by changing a single configuration property, without modifying framework code.
Add custom implementations by implementing a Java interface and registering it through the SPI file.
Extend behavior transparently -- Dubbo treats third-party extensions and built-in implementations equally.
For the underlying architecture, start with the framework design and SPI loading topics below.
SPI extension implementations
Dubbo defines over 20 extension points, organized here by function. Each extension point is a Java interface that supports custom implementations.
RPC and traffic management
| Extension point | What it controls |
|---|---|
| Protocol | Network protocol for remote calls |
| Filter | Request and response filter chain for cross-cutting concerns such as logging or auth |
| Cluster | Fault-tolerance strategy when a call fails (e.g., failover, failfast, forking) |
| Router | Routing rules that determine which providers receive traffic |
| LoadBalance | Request distribution strategy across multiple providers |
| Merger | Result merging logic for forked invocations |
Service discovery and configuration
| Extension point | What it controls |
|---|---|
| Registry | Service registry integration |
| Monitor | Metrics collection and monitoring data reporting |
Transport and serialization
| Extension point | What it controls |
|---|---|
| Transporter | Network transport layer |
| Exchanger | Request-response exchange pattern over the transport layer |
| Networker | Network topology management for multi-registry scenarios |
| Serialization | Data serialization format |
Lifecycle and proxying
| Extension point | What it controls |
|---|---|
| InvokerListener | Callback triggered on service invocation events |
| ExporterListener | Callback triggered on service export events |
| ExtensionFactory | Factory for creating and managing extension instances |
| ProxyFactory | Factory for creating service proxies |
| Compiler | Dynamic Java source code compilation |
| Dispatcher | Thread dispatching strategy for incoming messages |
| ThreadPool | Thread pool strategy for service execution |
Diagnostics and utilities
| Extension point | What it controls |
|---|---|
| TelnetHandler | Handler for telnet-based runtime management commands |
| StatusChecker | Health check logic for service status reporting |
| PageHandler | Status page rendering for the built-in HTTP server |
| Container | Service container lifecycle management |
| Cache | Result caching strategy for repeated invocations |
| Validation | Parameter validation before invocation |
| LoggerAdapter | Adapter for plugging in different logging frameworks |
Framework internals
These topics explain how Dubbo is built and how the SPI mechanism works under the hood.
| Topic | What it covers |
|---|---|
| Source code build | Build the Dubbo source from the repository |
| Framework design | Overall architecture, layered design, and module dependencies |
| SPI loading | How Dubbo discovers, loads, and instantiates SPI extensions |
| Implementation details | Internal implementation of core components |
| Configuration center | Centralized configuration management for distributed services |
| Public agreement | Public protocol conventions and contracts shared across Dubbo components |
Design principles
The Dubbo framework follows a set of design principles documented in these topics. Use them as a reference when contributing to the framework or building custom extensions.
| Topic | What it covers |
|---|---|
| Attention to detail | Why edge cases and subtle design decisions matter in framework code |
| Foundational design patterns | Core design patterns and conventions used throughout the codebase |
| Extensibility and incremental extension | How to design extensions that are backward-compatible and composable |
| Configuration design | Guidelines for designing configuration parameters and defaults |
| Robustness | Error handling, resilience patterns, and defensive coding in the framework |
| Fool-proof design | Preventing misuse through clear APIs, sensible defaults, and input validation |
| Extension point refactoring | When and how to refactor extension point interfaces |
Code quality standards
| Topic | What it covers |
|---|---|
| Versioning | Version numbering conventions and compatibility guarantees |
| Checklist | Pre-release verification checklist for framework changes |
| Code smells | Common anti-patterns to avoid in Dubbo framework code |
| Coding conventions | Code style, naming, and formatting standards |
| Compatibility testing | Testing strategy for backward and forward compatibility |