apache/dubbo-spring-boot-project

Features

• Microservices Communications - Implements a comprehensive framework for orchestrating distributed systems through high-performance RPC and messaging patterns.
• Remote Procedure Call Frameworks - Provides a comprehensive framework for invoking methods on remote services as if they were local using gRPC and HTTP/2.
• Spring Boot Integrations - Integrates Apache Dubbo RPC services within the Spring Boot application lifecycle via automated configuration.
• Service Routing Metadata - Syncs application addresses and interface definitions to enable precise routing in large clusters.
• Centralized Configuration Management - Provides centralized management of environment-specific settings and global defaults across a microservice platform.
• Interface Metadata Registries - Publishes application configuration metadata to a centralized store to support remote discovery.
• Cross-Language RPC Frameworks - Provides a communication layer enabling interoperability between services written in different languages using IDL and Protobuf.
• Cross-Language Service Communication - Ensures cross-language compatibility between services using standards like gRPC and HTTP/2.
• Registry-Based Service Discovery - Coordinates communication by syncing service addresses and metadata between providers and consumers via a central registry.
• Multi-Protocol Endpoint Exposure - Exposes services as REST endpoints via the Triple protocol for direct HTTP/1, HTTP/2, and HTTP/3 access.
• Remote Procedure Calls - Enables the execution of functions on remote servers as if they were local within a Spring Boot application.
• RPC Frameworks - Provides a high-performance framework for executing remote procedures across network nodes using gRPC, Triple, and TCP.
• Multi-Language RPC Services - Supports implementing services in multiple languages using a shared RPC framework and IDLs like Protobuf.
• RPC Service Exports - Provides the ability to publish local service implementations as remote providers that other applications can call over a network.
• Service Governance - Coordinates service discovery, registration, and load balancing to maintain stability in distributed microservices environments.
• Application Component Lifecycles - Provides a centralized startup entry point to initialize protocols, registries, and metrics for backend services.
• Dynamic Service Discovery - Locates available service provider instances across a network using a centralized registry.
• Automatic Service Registrations - Automates the registration of service implementation classes with discovery tools to make them available to external consumers.
• Interface Definition Languages - Uses interface definition languages to provide platform-neutral service contracts and data structures.
• RPC Framework Bootstrapping - Provides starters and configurations to automate the integration and bootstrapping of RPC infrastructure within Spring Boot.
• Service Discovery Registries - Maintains dynamic registries of service locations and health status to locate available providers in distributed environments.
• Automatic Service Registrations - Automatically broadcasts service network locations to a registry server so consumers can connect.
• Proxy-Based Remote Invocation - Injects remote service references into local applications to execute logic on different servers as if they were local calls.
• General Auto-Configuration Starters - Provides Spring Boot starters to automatically bootstrap RPC infrastructure using application properties.
• REST API Backends - Exposes backend microservices as RESTful endpoints using HTTP/1, HTTP/2, or HTTP/3 without requiring a gateway.
• REST API Implementations - Implements server-side RESTful endpoints to enable cross-language communication over HTTP.
• RESTful Services - Exposes microservices as RESTful services using HTTP/1 or HTTP/2 with JSON payloads.
• Configuration Aggregators - Aggregates configuration from properties, environment variables, and APIs using a prioritized override system.
• Environment Bootstrapping - Bootstraps infrastructure across virtual machines or Kubernetes using a unified governance system.
• External Configuration Integration - Connects applications to distributed key-value stores for dynamic service configuration management.
• Remote Service Providers - Publishes local service implementations as remote providers for invocation by other applications over a network.
• API Gateways - Routes external traffic to internal microservices through an API gateway entry point.
• Declarative Remote Service Proxies - Generates remote service proxies from interfaces to inject remote logic into local applications.
• Prioritized Overrides - Determines final application behavior by merging settings from JVM parameters, environment variables, and remote configuration centers.
• Canary Deployment Controllers - Implements canary releases and proportional traffic forwarding using dynamic routing rules.
• Infrastructure Abstractions - Abstracts underlying infrastructure to support seamless operation across virtual machines, containers, and service meshes.
• Request Rate Limiting - Integrates a flow control engine to manage request rates and protect system stability from traffic surges.
• Request Timeout Management - Establishes global default time limits for service calls to prevent resource exhaustion from hanging requests.
• High-Throughput RPC Scaling - Optimizes RPC throughput using multiplexed TCP long connections and NIO asynchronous communication.
• HTTP/3 Implementations - Implements the HTTP/3 protocol over QUIC to reduce latency and prevent head-of-line blocking.
• HTTP Client Integrations - Provides standard HTTP encoding to allow web browsers and third-party HTTP clients to interact with services.
• Microservice Framework Interoperability - Facilitates communication between different microservice frameworks to enable hybrid deployment and migration.
• Multi-Protocol Service Publishing - Publishes the same service across different communication protocols simultaneously to support diverse client requirements.
• Multi-Protocol Transport Layers - Supports simultaneous service exposure over TCP, HTTP/2, and gRPC to enable cross-language and browser interoperability.
• RPC Interface Exposure - Exposes local interfaces and their implementations as remote services available to other applications.
• Java-Specific - Uses a specialized protocol to handle remote procedure calls between services in a Java environment.
• Service Exposure - Registers and exposes internal services over the network to make them accessible to remote clients.
• Proxyless Integrations - Supports deploying data planes in proxy or proxyless modes for integration with external service mesh control planes.
• Traffic Interception - Monitors and modifies data flowing between services using custom filters and routers.
• Protocol-Based Routing Rules - Directs service calls to specific protocol versions based on keywords defined during service declaration.
• Transmission Rate Regulation - Regulates the rate of data transmission to prevent receiving services from being overwhelmed.
• Weighted Network Routing - Directs requests based on conditions or weights to facilitate canary and grayscale deployments.
• HTTP Request Filtering - Executes custom request lifecycle logic using Servlet Filters and specialized REST filter extensions.
• Access Control - Implements mechanisms to control which users or systems can access specific services via authentication.
• Traffic Governance - Updates routing rules in a remote store to change request flow in real-time.
• Metadata-Driven Routing - Controls request flow and canary releases by applying routing rules stored in a centralized metadata center.
• REST API Security - Secures RESTful service endpoints using basic authentication and custom identity validators.
• Service Communication Security - Encrypts network traffic between distributed services using certificates and private keys.
• Zero Trust Networking - Establishes a zero-trust security model through transport encryption and strict identity verification.
• Annotation-Based Route Mapping - Routes incoming HTTP requests to specific service methods using standard path and parameter annotations.
• Transport Protocol Configuration - Allows switching between transport protocols such as gRPC, HTTP/2, and TCP via configuration.
• Invocation Pipeline Extensions - Customizes invocation and control logic through a plugin system for filters and routers.
• SPI-Based Extension Mechanisms - Allows customization of routing, discovery, and protocols by loading external implementations through a service provider interface.
• Pluggable Cluster Metadata Stores - Provides interchangeable backends for persisting cluster metadata to ensure consistent service discovery.
• Zookeeper Coordination - Distributes application settings and traffic rules via Zookeeper to ensure synchronization across services.
• Remote Service Invocations - Enables transparent remote service invocation with integrated load balancing and asynchronous patterns.
• Canary and Proportional Routing - Provides request flow routing rules to enable canary deployments and proportional traffic forwarding.
• Metric Collection Tools - Gathers internal system performance metrics and exports them to observability tools.
• Distributed Tracing - Tracks request flow across service boundaries using unique identifiers to analyze distributed system performance.
• Observability Tools - Offers observability tools for collecting distributed traces, performance metrics, and health logs from RPC calls.
• Metrics Exports - Exports structured RPC performance statistics and operational metadata to external monitoring tools.
• Service Health Monitoring - Tracks the operational status of internal application services through health check interfaces, metrics, and logs.
• HTTP Response Builders - Provides utilities to construct custom HTTP responses including status codes, headers, and redirects.
• Service Action Exposure - Maps internal service methods to external HTTP/1 and HTTP/2 endpoints for browser consumption.
• Exception Handling - Converts unhandled exceptions into formatted API error responses through global handlers and filters.
• Request Mappings - Declaratively maps incoming HTTP requests to specific service methods using MVC or custom resolvers.
• Request Parameter Mapping - Implements automatic binding of HTTP path variables and headers to service method arguments.
• Content Negotiation - Determines output formats like JSON, XML, and YAML based on request headers or extensions.

Star history