baomidou/dynamic-datasource
Dynamic Datasource
This project is a dynamic datasource manager for Spring Boot designed to handle multiple database connections and switch between them at runtime. It provides a system for managing database read-write splitting, coordinating distributed transactions across disparate databases, and updating connection settings without requiring an application restart.
The framework differentiates itself through its ability to route traffic based on user sessions or headers to support multi-tenant architectures. It also includes a mechanism for encrypting sensitive database credentials within configuration files to prevent plain text exposure.
The capability surface extends to database connection routing, read-write splitting between master and slave nodes, and lazy connection initialization to reduce startup time. It further manages data consistency through centralized transaction control and supports the runtime addition or removal of database connection configurations.
Features
- Spring Boot Database Access - Provides a framework for Spring Boot that handles multiple database connections and switches between them at runtime.
- Runtime Connection Configuration - Enables adding or modifying database connection settings without requiring an application restart.
- Request Routing - Directs requests to specific database groups to support read-write splitting and master-slave replication.
- Runtime Connection Management - Allows programmatically adding, removing, or switching database connection configurations while the application is running.
- Dynamic Connection Switching - Evaluates dynamic parameters from sessions or headers to swap active database connections at runtime.
- Read-Write Splitting - Routes traffic between master and slave databases to optimize performance and load balancing.
- Tenant Request Routing - Directs application requests to different databases based on user sessions or headers to support multi-tenant architectures.
- Multi-datasource Configurators - Provides a system for defining and switching between multiple named database connections within a single application.
- Read-Write Splitting - Optimizes database performance by routing read queries to slave nodes and write queries to the master node.
- Context-Aware Connection Selection - Determines the target database by retrieving routing keys from thread-local storage or request headers.
- Dynamic Proxy Routing - Wraps the data source in a proxy that delegates queries to different physical connections based on the current context.
- Connection Route Switching - Implements AOP-based interception to switch database connections dynamically based on annotations.
- Secure Database Configurations - Protects sensitive database credentials in configuration files using encryption to prevent plain text exposure.
- Lazy Connection Initialization - Delays the creation of database connections until the first request occurs to reduce startup time.
- Lazy Connection Initialization - Postpones the creation of database connection pools until the first request to reduce startup time.
- Runtime Configuration Refreshes - Updates the internal data source map and connection pools without restarting the application when configuration changes.
- Credential Encryption - Protects sensitive connection information in configuration files using built-in or custom encryption methods.
- Distributed Transaction Coordinators - Coordinates commit and rollback operations across multiple data sources by hooking into a distributed transaction coordinator.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
