<think>我们将在
Spring Boot项目中配置三个数据源：MySQL、Cassandra和MongoDB。我们将使用
Spring Boot的自动配置特性，并通过配置文件（application.yml）来配置各个数据源。同时，我们将通过代码配置来支持多数据源，并确保可以通过更改配置文件来切换数据源（例如，从开发环境切换到生产环境）。
步骤：
1. 添加依赖
2. 配置application.yml文件，定义三个数据源的连接信息
3. 创建每个数据源的配置类，分别配置各自的数据源和模板（如JdbcTemplate、CassandraTemplate、MongoTemplate）
4. 使用@Primary注解指定一个默认数据源（如果有必要）
5. 在需要使用的地方通过@Qualifier注入特定的数据源模板
注意：由于
Spring Boot自动配置默认只配置一个数据源，因此我们需要禁用自动配置，然后手动配置多个数据源。
实现：
第一步：添加依赖（pom.xml）
我们需要添加MySQL、Cassandra和MongoDB的依赖，以及
Spring Data相关的依赖。
```xml
<dependencies>
<!--
Spring Boot Starter -->
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-data-cassandra</artifactId>
</dependency>
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-data-mongodb</artifactId>
</dependency>
<!-- MySQL Connector -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-
java</artifactId>
<scope>runtime</scope>
</dependency>
<!-- 其他依赖 -->
</dependencies>
```
第二步：配置application.yml
在application.yml中配置三个数据源。注意，为了避免冲突，我们使用不同的配置前缀。
```yaml
spring:
# 主数据源（MySQL）配置
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://local
host:3306/mydb?useSSL=false&serverTimezone=UTC
username: root
password: root
# 第二个数据源：Cassandra
data:
cassandra:
keyspace-name: mykeyspace
contact-points: local
host
port: 9042
username: cassandra
password: cassandra
# 第三个数据源：MongoDB
mongodb:
host: local
host
port: 27017
database: test
username: mongo
password: mongo
authentication-database: admin
# 可以定义多个profile，比如dev, prod等，通过
spring.profiles.active指定
```
第三步：配置数据源
由于我们配置了多个数据源，我们需要为每个数据源创建配置类，并分别创建对应的Template。
注意：为了避免
Spring Boot自动配置单个数据源，我们需要在
启动类上排除某些自动配置类。
```
java
@
SpringBootApplication(exclude = {
DataSourceAutoConfiguration.class,
CassandraAutoConfiguration.class,
MongoAutoConfiguration.class
})
public class MultiDataSourceApplication {
public static void main(String[] args) {
SpringApplication.run(MultiDataSourceApplication.class, args);
}
}
```
然后，我们为每个数据源创建配置类：
1. MySQL数据源配置（使用JPA，这里我们配置JdbcTemplate和EntityManagerFactory）
```
java
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
basePackages = "com.example.repository.mysql", // 指定MySQL的Repository包路径
entityManagerFactoryRef = "mysqlEntityManagerFactory",
transactionManagerRef = "mysqlTransactionManager"
)
public class MysqlDataSourceConfig {
@Bean
@ConfigurationProperties(prefix = "
spring.datasource")
public DataSource mysqlDataSource() {
return DataSourceBuilder.create().build();
}
@Bean
public LocalContainerEntityManagerFactoryBean mysqlEntityManagerFactory(
EntityManagerFactoryBuilder builder) {
return builder
.dataSource(mysqlDataSource())
.packages("com.example.entity.mysql") // 指定MySQL的实体类包路径
.persistenceUnit("mysql")
.build();
}
@Bean
public PlatformTransactionManager mysqlTransactionManager(
@Qualifier("mysqlEntityManagerFactory") LocalContainerEntityManagerFactoryBean mysqlEntityManagerFactory) {
return new JpaTransactionManager(Objects.requireNonNull(mysqlEntityManagerFactory.getObject()));
}
@Bean
public JdbcTemplate mysqlJdbcTemplate(@Qualifier("mysqlDataSource") DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
}
```
2. Cassandra数据源配置
```
java
@Configuration
public class CassandraDataSourceConfig {
@Bean
@ConfigurationProperties(prefix = "
spring.data.cassandra")
public CassandraProperties cassandraProperties() {
return new CassandraProperties();
}
@Bean
public CassandraTemplate cassandraTemplate() {
CassandraProperties properties = cassandraProperties();
Cluster cluster = Cluster.builder()
.addContactPoints(properties.getContactPoints().toArray(new String[0]))
.withPort(properties.getPort())
.withCredentials(properties.getUsername(), properties.getPassword())
.build();
Session session = cluster.connect(properties.getKeyspaceName());
return new CassandraTemplate(session);
}
}
```
3. MongoDB数据源配置
```
java
@Configuration
public class MongoDataSourceConfig {
@Bean
@ConfigurationProperties(prefix = "
spring.mongodb")
public MongoProperties mongoProperties() {
return new MongoProperties();
}
@Bean
public MongoTemplate mongoTemplate() {
MongoProperties properties = mongoProperties();
MongoClient mongoClient = new MongoClient(properties.get
Host(), properties.getPort());
MongoDbFactory factory = new SimpleMongoDbFactory(mongoClient, properties.getDatabase());
return new MongoTemplate(factory);
}
}
```
第四步：使用数据源
在Service或Repository中，我们可以通过@Qualifier来注入不同的Template。
例如，在Service中使用：
```
java
@Service
public class MyService {
private final JdbcTemplate mysqlJdbcTemplate;
private final CassandraTemplate cassandraTemplate;
private final MongoTemplate mongoTemplate;
public MyService(
@Qualifier("mysqlJdbcTemplate") JdbcTemplate mysqlJdbcTemplate,
@Qualifier("cassandraTemplate") CassandraTemplate cassandraTemplate,
@Qualifier("mongoTemplate") MongoTemplate mongoTemplate) {
this.mysqlJdbcTemplate = mysqlJdbcTemplate;
this.cassandraTemplate = cassandraTemplate;
this.mongoTemplate = mongoTemplate;
}
// 使用mysqlJdbcTemplate进行操作
// 使用cassandraTemplate进行操作
// 使用mongoTemplate进行操作
}
```
或者，在Repository中，由于我们已经在配置中指定了不同数据源的Repository包路径，所以
Spring会自动将对应包下的Repository接口与对应的数据源关联。
例如，MySQL的Repository：
```
java
package com.example.repository.mysql;
import com.example.entity.mysql.User;
import org.
springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
}
```
这样，UserRepository就会使用MySQL数据源。
第五步：通过配置文件切换环境
我们可以使用
Spring Profiles来定义不同的环境配置，例如在application-dev.yml、application-prod.yml中分别配置不同环境的数据源连接信息。然后在
启动时通过`
spring.profiles.active`来激活相应的配置。
例如，创建application-dev.yml：
```yaml
spring:
datasource:
url: jdbc:mysql://dev-db:3306/mydb
username: dev
password: dev
data:
cassandra:
contact-points: dev-cassandra
...
mongodb:
host: dev-mongo
...
```
创建application-prod.yml：
```yaml
spring:
datasource:
url: jdbc:mysql://prod-db:3306/mydb
username: prod
password: prod
data:
cassandra:
contact-points: prod-cassandra
...
mongodb:
host: prod-mongo
...
```
启动时指定profile：`--
spring.profiles.active=prod`
这样，我们就可以通过更改配置文件来切换数据源，而不需要修改代码。
注意事项：
1. 确保每个数据源的配置类中指定的包路径（如实体类、Repository接口）是独立的，避免
Spring扫描冲突。
2. 如果某个数据源不需要，可以在配置文件中不配置，然后在代码中通过条件注解（如@ConditionalOnProperty）来控制是否创建对应的数据源Bean。
总结：通过以上步骤，我们在
Spring Boot项目中配置了三个数据源，并且可以通过更改配置文件来切换环境。每个数据源都有自己独立的配置和模板，在代码中通过@Qualifier来区分使用。
§§相关问题§§:
1. 如何在
Spring Boot中配置动态数据源（运行时切换）？
2.
Spring Boot中如何实现数据源的健康检查？
3. 在多数据源的情况下，如何统一管理事务（分布式事务）？
4. 如何为不同的数据源配置连接池？</think># 在
Spring Boot 项目中配置多数据源（MySQL、Cassandra、MongoDB）
下面我将详细介绍如何在
Spring Boot 项目中配置三个数据源（MySQL、Cassandra、MongoDB），并实现仅通过配置文件切换数据源的功能。
## 整体解决方案
### 1. 添加依赖 (pom.xml)
```xml
<dependencies>
<!--
Spring Boot Starter -->
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-web</artifactId>
</dependency>
<!-- MySQL 数据源 -->
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-
java</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Cassandra 数据源 -->
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-data-cassandra</artifactId>
</dependency>
<!-- MongoDB 数据源 -->
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-data-mongodb</artifactId>
</dependency>
<!-- 配置处理 -->
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
```
### 2. 配置文件 (application.yml)
```yaml
# 主数据源配置
spring:
application:
name: multi-datasource-demo
# MySQL 数据源配置
mysql:
datasource:
url: jdbc:mysql://local
host:3306/mysql_db?useSSL=false&serverTimezone=UTC
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver
hikari:
maximum-pool-size: 10
minimum-idle: 5
connection-timeout: 30000
jpa:
show-sql: true
hibernate:
ddl-auto: update
properties:
hibernate:
dialect: org.hibernate.dialect.MySQL8Dialect
# Cassandra 数据源配置
cassandra:
keyspace-name: cassandra_keyspace
contact-points: local
host
port: 9042
username: cassandra
password: cassandra
schema-action: CREATE_IF_NOT_EXISTS
jmx-enabled: false
# MongoDB 数据源配置
mongodb:
uri: mongodb://mongoUser:mongoPass@local
host:27017/mongo_db
database: mongo_db
auto-index-creation: true
```
### 3. 配置类结构
```
src/main/
java
├── com
│ └── example
│ └── multidatasource
│ ├── config
│ │ ├── CassandraConfig.
java
│ │ ├── MongoConfig.
java
│ │ └── MysqlConfig.
java
│ ├── model
│ │ ├── mysql
│ │ │ └── User.
java
│ │ ├── cassandra
│ │ │ └── LogRecord.
java
│ │ └── mongo
│ │ └── Product.
java
│ ├── repository
│ │ ├── mysql
│ │ │ └── UserRepository.
java
│ │ ├── cassandra
│ │ │ └── LogRepository.
java
│ │ └── mongo
│ │ └── ProductRepository.
java
│ └── MultiDataSourceApplication.
java
```
### 4. 数据源配置类
#### MySQL 配置类
```
java
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
basePackages = "com.example.multidatasource.repository.mysql",
entityManagerFactoryRef = "mysqlEntityManagerFactory",
transactionManagerRef = "mysqlTransactionManager"
)
public class MysqlConfig {
@Bean
@ConfigurationProperties("
spring.mysql.datasource")
public DataSource mysqlDataSource() {
return DataSourceBuilder.create().build();
}
@Bean
public LocalContainerEntityManagerFactoryBean mysqlEntityManagerFactory(
EntityManagerFactoryBuilder builder) {
return builder
.dataSource(mysqlDataSource())
.packages("com.example.multidatasource.model.mysql")
.persistenceUnit("mysql")
.build();
}
@Bean
public PlatformTransactionManager mysqlTransactionManager(
@Qualifier("mysqlEntityManagerFactory") LocalContainerEntityManagerFactoryBean mysqlEntityManagerFactory) {
return new JpaTransactionManager(Objects.requireNonNull(mysqlEntityManagerFactory.getObject()));
}
}
```
#### Cassandra 配置类
```
java
@Configuration
@EnableCassandraRepositories(
basePackages = "com.example.multidatasource.repository.cassandra",
sessionFactoryRef = "cassandraSessionFactory"
)
public class CassandraConfig {
@Bean
@Primary
@ConfigurationProperties("
spring.data.cassandra")
public CassandraProperties cassandraProperties() {
return new CassandraProperties();
}
@Bean
public CqlSessionFactoryBean cassandraSession() {
CassandraProperties properties = cassandraProperties();
CqlSessionFactoryBean session = new CqlSessionFactoryBean();
session.setContactPoints(properties.getContactPoints());
session.setPort(properties.getPort());
session.setKeyspaceName(properties.getKeyspaceName());
session.setLocalDatacenter("datacenter1");
session.setUsername(properties.getUsername());
session.setPassword(properties.getPassword());
return session;
}
@Bean
public CassandraConverter cassandraConverter() {
return new MappingCassandraConverter(cassandraMapping());
}
@Bean
public CassandraMappingContext cassandraMapping() {
return new CassandraMappingContext();
}
@Bean
public CassandraSessionFactoryBean cassandraSessionFactory(
@Qualifier("cassandraSession") CqlSessionFactoryBean session,
CassandraConverter converter) {
CassandraSessionFactoryBean factory = new CassandraSessionFactoryBean();
factory.setSession(session.getObject());
factory.setConverter(converter);
factory.setSchemaAction(SchemaAction.CREATE_IF_NOT_EXISTS);
return factory;
}
}
```
#### MongoDB 配置类
```
java
@Configuration
@EnableMongoRepositories(
basePackages = "com.example.multidatasource.repository.mongo",
mongoTemplateRef = "mongoTemplate"
)
public class MongoConfig {
@Bean
@ConfigurationProperties("
spring.data.mongodb")
public MongoProperties mongoProperties() {
return new MongoProperties();
}
@Bean
public MongoClient mongoClient() {
MongoProperties properties = mongoProperties();
return MongoClients.create(properties.getUri());
}
@Bean
public MongoTemplate mongoTemplate() {
MongoProperties properties = mongoProperties();
return new MongoTemplate(mongoDbFactory());
}
@Bean
public MongoDatabaseFactory mongoDbFactory() {
MongoProperties properties = mongoProperties();
return new SimpleMongoClientDatabaseFactory(mongoClient(), properties.getDatabase());
}
@Bean
public MongoTransactionManager mongoTransactionManager() {
return new MongoTransactionManager(mongoDbFactory());
}
}
```
### 5. 实体类和 Repository 示例
#### MySQL 实体和 Repository
```
java
// 实体类
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String email;
// Getters and setters
}
// Repository
public interface UserRepository extends JpaRepository<User, Long> {
}
```
#### Cassandra 实体和 Repository
```
java
// 实体类
@Table("log_records")
public class LogRecord {
@PrimaryKey
private UUID id;
private String message;
private Instant timestamp;
// Getters and setters
}
// Repository
public interface LogRepository extends CassandraRepository<LogRecord, UUID> {
}
```
#### MongoDB 实体和 Repository
```
java
// 实体类
@Document(collection = "products")
public class Product {
@Id
private String id;
private String name;
private BigDecimal price;
// Getters and setters
}
// Repository
public interface ProductRepository extends MongoRepository<Product, String> {
}
```
### 6. 使用数据源的服务类
```
java
@Service
public class DataService {
private final UserRepository userRepository;
private final LogRepository logRepository;
private final ProductRepository productRepository;
public DataService(
UserRepository userRepository,
LogRepository logRepository,
ProductRepository productRepository) {
this.userRepository = userRepository;
this.logRepository = logRepository;
this.productRepository = productRepository;
}
@Transactional(transactionManager = "mysqlTransactionManager")
public User createUser(User user) {
return userRepository.save(user);
}
@Transactional(transactionManager = "cassandraTransactionManager")
public LogRecord createLog(LogRecord log) {
return logRepository.save(log);
}
@Transactional(transactionManager = "mongoTransactionManager")
public Product createProduct(Product product) {
return productRepository.save(product);
}
public List<User> getAllUsers() {
return userRepository.findAll();
}
public List<LogRecord> getAllLogs() {
return logRepository.findAll();
}
public List<Product> getAllProducts() {
return productRepository.findAll();
}
}
```
## 环境切换配置
### 1. 创建不同环境的配置文件
#### application-dev.yml (开发环境)
```yaml
spring:
mysql:
datasource:
url: jdbc:mysql://dev-db:3306/dev_db
username: dev_user
password: dev_pass
cassandra:
contact-points: dev-cassandra
keyspace-name: dev_keyspace
username: dev_user
password: dev_pass
mongodb:
uri: mongodb://dev_user:dev_pass@dev-mongo:27017/dev_db
```
#### application-prod.yml (生产环境)
```yaml
spring:
mysql:
datasource:
url: jdbc:mysql://prod-db:3306/prod_db?useSSL=true
username: prod_user
password: prod_pass
cassandra:
contact-points: prod-cassandra1,prod-cassandra2
keyspace-name: prod_keyspace
username: prod_user
password: prod_pass
mongodb:
uri: mongodb://prod_user:prod_pass@prod-mongo1:27017,prod-mongo2:27017/prod_db?replicaSet=rs0
```
### 2. 激活环境配置
在
启动应用时指定环境：
```bash
# 开发环境
java -jar your-app.jar --
spring.profiles.active=dev
# 生产环境
java -jar your-app.jar --
spring.profiles.active=prod
```
或者在 application.yml 中设置默认环境：
```yaml
spring:
profiles:
active: dev # 默认使用开发环境
```
## 高级配置：动态数据源切换
如果需要运行时动态切换数据源（例如基于租户或请求参数），可以扩展配置：
### 1. 创建抽象数据源路由
```
java
public abstract class AbstractRoutingDataSource extends AbstractDataSource {
@Override
public Connection getConnection() throws SQLException {
return determineTargetDataSource().getConnection();
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
return determineTargetDataSource().getConnection(username, password);
}
protected abstract DataSource determineTargetDataSource();
}
public class TenantDataSourceRouter extends AbstractRoutingDataSource {
private final Map<Object, Object> targetDataSources = new ConcurrentHashMap<>();
public void addDataSource(String tenantId, DataSource dataSource) {
targetDataSources.put(tenantId, dataSource);
}
@Override
protected DataSource determineTargetDataSource() {
String tenantId = TenantContext.getCurrentTenant();
return (DataSource) targetDataSources.get(tenantId);
}
}
```
### 2. 动态数据源配置类
```
java
@Configuration
public class DynamicDataSourceConfig {
@Bean
public TenantDataSourceRouter dataSourceRouter(
@Qualifier("mysqlDataSource") DataSource mysqlDataSource,
@Qualifier("cassandraDataSource") DataSource cassandraDataSource,
@Qualifier("mongoDataSource") DataSource mongoDataSource) {
TenantDataSourceRouter router = new TenantDataSourceRouter();
// 添加默认数据源
router.addDataSource("mysql", mysqlDataSource);
router.addDataSource("cassandra", cassandraDataSource);
router.addDataSource("mongo", mongoDataSource);
return router;
}
@Bean
@Primary
public DataSource dataSource(TenantDataSourceRouter router) {
return router;
}
}
```
### 3. 使用切面切换数据源
```
java
@Aspect
@Component
public class DataSourceAspect {
@Pointcut("@annotation(com.example.multidatasource.config.DataSourceSelector)")
public void dataSourcePointcut() {}
@Before("dataSourcePointcut()")
public void before(JoinPoint joinPoint) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
DataSourceSelector selector = method.getAnnotation(DataSourceSelector.class);
if (selector != null) {
TenantContext.setCurrentTenant(selector.value());
}
}
@After("dataSourcePointcut()")
public void after() {
TenantContext.clear();
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataSourceSelector {
String value() default "mysql";
}
```
### 4. 在服务中使用动态数据源
```
java
@Service
public class DynamicDataService {
@DataSourceSelector("mysql")
public User getUser(Long id) {
// 从 MySQL
获取用户
}
@DataSourceSelector("cassandra")
public LogRecord getLog(UUID id) {
// 从 Cassandra
获取日志
}
@DataSourceSelector("mongo")
public Product getProduct(String id) {
// 从 MongoDB
获取产品
}
}
```
## 配置验证和测试
### 1. 测试配置类
```
java
@
SpringBootTest
public class DataSourceConfigTest {
@Autowired
private ApplicationContext context;
@Test
public void testMysqlDataSource() {
assertNotNull(context.getBean("mysqlDataSource", DataSource.class));
assertNotNull(context.getBean("mysqlEntityManagerFactory", EntityManagerFactory.class));
}
@Test
public void testCassandraDataSource() {
assertNotNull(context.getBean("cassandraSession", CqlSession.class));
assertNotNull(context.getBean("cassandraTemplate", CassandraTemplate.class));
}
@Test
public void testMongoDataSource() {
assertNotNull(context.getBean("mongoTemplate", MongoTemplate.class));
}
}
```
### 2. 集成测试
```
java
@
SpringBootTest
@ActiveProfiles("test")
public class DataServiceIntegrationTest {
@Autowired
private DataService dataService;
@Test
@Transactional(transactionManager = "mysqlTransactionManager")
public void testUserOperations() {
User user = new User();
user.setName("Test User");
user.setEmail("test@example.com");
User saved = dataService.createUser(user);
assertNotNull(saved.getId());
List<User> users = dataService.getAllUsers();
assertFalse(users.isEmpty());
}
@Test
@Transactional(transactionManager = "cassandraTransactionManager")
public void testLogOperations() {
LogRecord log = new LogRecord();
log.setId(UUID.randomUUID());
log.setMessage("Test log");
log.setTimestamp(Instant.now());
LogRecord saved = dataService.createLog(log);
assertEquals(log.getId(), saved.getId());
List<LogRecord> logs = dataService.getAllLogs();
assertFalse(logs.isEmpty());
}
@Test
@Transactional(transactionManager = "mongoTransactionManager")
public void testProductOperations() {
Product product = new Product();
product.setName("Test Product");
product.setPrice(new BigDecimal("19.99"));
Product saved = dataService.createProduct(product);
assertNotNull(saved.getId());
List<Product> products = dataService.getAllProducts();
assertFalse(products.isEmpty());
}
}
```
## 最佳实践和注意事项
1. **事务管理**：
- 为每个数据源配置独立的事务管理器
- 在服务方法上明确指定使用哪个事务管理器
- 避免跨数据源的事务操作（分布式事务复杂）
2. **连接池优化**：
- 为每个数据源配置合适的连接池参数
- 监控连接池使用情况（HikariCP、Mongo连接池）
- 定期检查连接泄漏
3. **性能考虑**：
- 为每个数据源配置独立的线程池
- 避免在同一个请求中访问多个数据源
- 使用缓存减少数据库访问
4. **安全配置**：
- 使用加密存储数据库密码
- 配置SSL/TLS连接
- 使用最小权限原则配置数据库用户
5. **监控和日志**：
- 为每个数据源配置独立的日志记录器
- 监控每个数据源的性能指标
- 配置
慢查询日志
## 总结
通过以上配置，我们实现了在
Spring Boot 项目中同时使用三个不同类型的数据源（MySQL、Cassandra、MongoDB）。关键点包括：
1. **模块化配置**：每个数据源有独立的配置类
2. **包隔离**：实体类和 Repository 按数据源类型分包
3. **环境切换**：通过 profile 实现不同环境配置
4. **事务管理**：为每个数据源配置独立的事务管理器
5. **动态切换**：通过路由数据源实现运行时切换
这种架构设计使得系统具有很好的扩展性，可以轻松添加或替换数据源，同时保持代码的清晰和可维护性。
本文揭示了InetAddress.getLocalHost()方法运行缓慢的问题，并分享了解决方案——在hosts文件中添加本地IP映射，以提高性能。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
