<think>我们在之前已经讨论过使用
JdbcTemplate获取
多个数据库数据的基本方法（方案三）。现在，我将详细展开如何使用
JdbcTemplate实现多数据源
配置和操作。
核心思路：
配置多个数据源，然后为每个数据源创建一个
JdbcTemplate实例，在Service中注入这些
JdbcTemplate实例，分别使用。
步骤：
1.
配置多个数据源（在application.properties或application.yml中
配置多个数据库连接信息）
2. 创建
多个数据源的
配置类（或在一个
配置类中
配置多个DataSource Bean）
3. 为每个数据源创建
JdbcTemplate Bean
4. 在Service中注入这些
JdbcTemplate实例，并分别使用
具体实现：
1.
配置数据源信息（application.properties）：
```properties
# 第一个
数据库
spring.datasource.db1.jdbc-url=jdbc:mysql://localhost:3306/db1
spring.datasource.db1.username=root
spring.datasource.db1.password=root
spring.datasource.db1.driver-class-name=com.mysql.cj.jdbc.Driver
# 第二个
数据库
spring.datasource.db
2.jdbc-url=jdbc:mysql://localhost:3306/db
2
spring.datasource.db
2.username=root
spring.datasource.db
2.password=root
spring.datasource.db
2.driver-class-name=com.mysql.cj.jdbc.Driver
```
2.
配置多个数据源和对应的
JdbcTemplate（在
配置类中）：
```
java
@Configuration
public class DatabaseConfig {
//
配置第一个数据源
@Bean
(name = "db1DataSource"
)
@ConfigurationProperties
(prefix = "
spring.datasource.db1"
)
public DataSource db1DataSource
() {
return DataSourceBuilder.create
().build
();
}
//
配置第二个数据源
@Bean
(name = "db
2DataSource"
)
@ConfigurationProperties
(prefix = "
spring.datasource.db
2"
)
public DataSource db
2DataSource
() {
return DataSourceBuilder.create
().build
();
}
// 为第一个数据源创建
JdbcTemplate
@Bean
(name = "db1
JdbcTemplate"
)
public
JdbcTemplate db1
JdbcTemplate(@Qualifier
("db1DataSource"
) DataSource dataSource
) {
return new
JdbcTemplate(dataSource
);
}
// 为第二个数据源创建
JdbcTemplate
@Bean
(name = "db
2JdbcTemplate"
)
public
JdbcTemplate db
2JdbcTemplate(@Qualifier
("db
2DataSource"
) DataSource dataSource
) {
return new
JdbcTemplate(dataSource
);
}
}
```
3. 在Service中使用这两个
JdbcTemplate：
```
java
@Service
public class MultiDBService {
private final
JdbcTemplate db1
JdbcTemplate;
private final
JdbcTemplate db
2JdbcTemplate;
// 通过构造器注入，使用@Qualifier指定具体的Bean
public MultiDBService
(
@Qualifier
("db1
JdbcTemplate"
) JdbcTemplate db1
JdbcTemplate,
@Qualifier
("db
2JdbcTemplate"
) JdbcTemplate db
2JdbcTemplate) {
this.db1
JdbcTemplate = db1
JdbcTemplate;
this.db
2JdbcTemplate = db
2JdbcTemplate;
}
public List<User> getUsersFromDb1
() {
String sql = "SELECT * FROM users";
return db1
JdbcTemplate.query
(sql,
(rs, rowNum
) -> {
User user = new User
();
user.setId
(rs.getLong
("id"
));
user.setName
(rs.getString
("name"
));
// 设置其他属性
return user;
}
);
}
public List<Order> getOrdersFromDb
2() {
String sql = "SELECT * FROM orders";
return db
2JdbcTemplate.query
(sql,
(rs, rowNum
) -> {
Order order = new Order
();
order.setId
(rs.getLong
("id"
));
order.setProduct
(rs.getString
("product"
));
// 设置其他属性
return order;
}
);
}
// 同时从两个
数据库获取数据并合并
public CombinedData getCombinedData
() {
List<User> users = getUsersFromDb1
();
List<Order> orders = getOrdersFromDb
2();
return new CombinedData
(users, orders
);
}
}
```
4. 实体类（示例）：
```
java
public class User {
private Long id;
private String name;
// getters and setters
}
public class Order {
private Long id;
private String product;
// getters and setters
}
public class CombinedData {
private List<User> users;
private List<Order> orders;
// 构造方法、getters and setters
}
```
注意事项：
- 如果两个
数据库的表结构相同，可以使用同一个实体类，但通常
不同数据库有
不同的表，所以使用
不同的实体类。
- 在多数据源
配置中，必须使用@Qualifier注解来指定注入的是哪个数据源或
JdbcTemplate。
- 如果数据源较多，可以考虑使用Map来管理
多个JdbcTemplate，但需要更复杂的
配置。
- 事务管理：默认情况下，每个
JdbcTemplate操作是独立事务。如果需要跨
多个数据源的事务（分布式事务），则需要使用JTA事务管理器（如Atomikos）。
如何添加分布式事务支持？
如果需要跨两个
数据库的事务，比如在同一个事务中同时更新两个
数据库，则不能使用普通的DataSourceTransactionManager，而应该使用JTA事务管理器。可以使用Atomikos或Bitronix等。
示例（使用Atomikos）：
1. 添加依赖：
```xml
<dependency>
<groupId>org.
springframework.boot</groupId>
<artifactId>
spring-boot-starter-jta-atomikos</artifactId>
</dependency>
```
2. 修改数据源
配置，使用AtomikosDataSourceBean：
```
java
@Bean
(name = "db1DataSource"
)
@ConfigurationProperties
(prefix = "
spring.datasource.db1"
)
public DataSource db1DataSource
() {
// 使用Atomikos提供的DataSource
return new AtomikosDataSourceBean
();
}
@Bean
(name = "db
2DataSource"
)
@ConfigurationProperties
(prefix = "
spring.datasource.db
2"
)
public DataSource db
2DataSource
() {
return new AtomikosDataSourceBean
();
}
```
3.
配置JTA事务管理器（
Spring Boot会自动
配置，但需要确保Atomikos依赖存在）
4. 在需要事务的方法上使用@Transactional注解：
```
java
@Transactional
public void updateMultipleDatabases
() {
// 更新
数据库1
db1
JdbcTemplate.update
("UPDATE ..."
);
// 更新
数据库2
db
2JdbcTemplate.update
("UPDATE ..."
);
// 如果发生异常，两个操作都会回滚
}
```
这样，当updateMultipleDatabases方法执行时，两个更新操作将在同一个分布式事务中。
总结：
使用
JdbcTemplate操作
多个数据库，核心在于
配置多个数据源和对应的
JdbcTemplate，然后在Service中注入使用。对于分布式事务，则需引入JTA事务管理器。
§§相关问题§§:
1. 如何使用
JdbcTemplate进行分页查询？
2.
JdbcTemplate如何执行批量更新操作？
3. 在
Spring Boot中如何
配置多个MongoDB数据源？
4. 使用
JdbcTemplate时如何防止SQL注入攻击？
</think>
#
Java后端使用
JdbcTemplate获取
多个数据库数据
使用
JdbcTemplate在
Java后端获取
多个数据库的数据是一种常见需求，下面我将详细解释实现方案并提供完整代码示例。
## 解决方案：多
JdbcTemplate实例
配置
核心思路是为每个
数据库配置独立的`DataSource`和`
JdbcTemplate`实例，然后在服务层注入并使用这些实例。
### 1. 添加依赖
(pom.xml
)
```xml
<dependencies>
<!--
Spring Boot Starter -->
<dependency>
<groupId>org.
springframework.boot</groupId>
<artifactId>
spring-boot-starter-web</artifactId>
</dependency>
<!-- JDBC 依赖 -->
<dependency>
<groupId>org.
springframework.boot</groupId>
<artifactId>
spring-boot-starter-jdbc</artifactId>
</dependency>
<!--
数据库驱动
(以MySQL为例
) -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-
java</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
```
###
2.
配置多个数据源
(application.yml
)
```yaml
spring:
datasource:
# 主
数据库配置
primary:
url: jdbc:mysql://localhost:3306/db1
username: user1
password: pass1
driver-class-name: com.mysql.cj.jdbc.Driver
# 第二个
数据库配置
secondary:
url: jdbc:mysql://10.0.0.
2:3306/db
2
username: user
2
password: pass
2
driver-class-name: com.mysql.cj.jdbc.Driver
```
### 3.
配置多个JdbcTemplate实例
```
java
@Configuration
public class DatabaseConfig {
//
配置主
数据库数据源
@Bean
@Primary
@ConfigurationProperties
(prefix = "
spring.datasource.primary"
)
public DataSource primaryDataSource
() {
return DataSourceBuilder.create
().build
();
}
//
配置第二个
数据库数据源
@Bean
@ConfigurationProperties
(prefix = "
spring.datasource.secondary"
)
public DataSource secondaryDataSource
() {
return DataSourceBuilder.create
().build
();
}
// 主
数据库JdbcTemplate
@Bean
(name = "primary
JdbcTemplate"
)
public
JdbcTemplate primary
JdbcTemplate(@Qualifier
("primaryDataSource"
) DataSource dataSource
) {
return new
JdbcTemplate(dataSource
);
}
// 第二个
数据库JdbcTemplate
@Bean
(name = "secondary
JdbcTemplate"
)
public
JdbcTemplate secondary
JdbcTemplate(@Qualifier
("secondaryDataSource"
) DataSource dataSource
) {
return new
JdbcTemplate(dataSource
);
}
}
```
### 4. 服务层使用
多个JdbcTemplate
```
java
@Service
public class MultiDatabaseService {
private final
JdbcTemplate primary
JdbcTemplate;
private final
JdbcTemplate secondary
JdbcTemplate;
@Autowired
public MultiDatabaseService
(
@Qualifier
("primary
JdbcTemplate"
) JdbcTemplate primary
JdbcTemplate,
@Qualifier
("secondary
JdbcTemplate"
) JdbcTemplate secondary
JdbcTemplate) {
this.primary
JdbcTemplate = primary
JdbcTemplate;
this.secondary
JdbcTemplate = secondary
JdbcTemplate;
}
/**
* 从
多个数据库获取数据并合并
*/
public Map<String, Object> fetchDataFromMultipleSources
() {
Map<String, Object> result = new HashMap<>
();
// 从主
数据库获取数据
List<Map<String, Object>> primaryData =
primary
JdbcTemplate.queryForList
("SELECT * FROM primary_table"
);
// 从第二个
数据库获取数据
List<Map<String, Object>> secondaryData =
secondary
JdbcTemplate.queryForList
("SELECT * FROM secondary_table"
);
// 合并结果
result.put
("primaryDatabase", primaryData
);
result.put
("secondaryDatabase", secondaryData
);
return result;
}
/**
* 并行查询
多个数据库（提高性能）
*/
public Map<String, Object> fetchDataInParallel
() {
Map<String, Object> result = new HashMap<>
();
// 使用CompletableFuture实现并行查询
CompletableFuture<List<Map<String, Object>>> primaryFuture = CompletableFuture.supplyAsync
(() ->
primary
JdbcTemplate.queryForList
("SELECT * FROM primary_table"
)
);
CompletableFuture<List<Map<String, Object>>> secondaryFuture = CompletableFuture.supplyAsync
(() ->
secondary
JdbcTemplate.queryForList
("SELECT * FROM secondary_table"
)
);
// 等待所有查询完成
CompletableFuture.allOf
(primaryFuture, secondaryFuture
).join
();
try {
result.put
("primaryDatabase", primaryFuture.get
());
result.put
("secondaryDatabase", secondaryFuture.get
());
} catch
(InterruptedException | ExecutionException e
) {
throw new RuntimeException
("Error fetching data", e
);
}
return result;
}
}
```
### 5. 控制器层调用
```
java
@RestController
@RequestMapping
("/api/data"
)
public class DataController {
private final MultiDatabaseService dataService;
@Autowired
public DataController
(MultiDatabaseService dataService
) {
this.dataService = dataService;
}
@GetMapping
("/combined"
)
public ResponseEntity<Map<String, Object>> getCombinedData
() {
Map<String, Object> result = dataService.fetchDataFromMultipleSources
();
return ResponseEntity.ok
(result
);
}
@GetMapping
("/parallel"
)
public ResponseEntity<Map<String, Object>> getParallelData
() {
Map<String, Object> result = dataService.fetchDataInParallel
();
return ResponseEntity.ok
(result
);
}
}
```
## 关键点解释
1. **数据源
配置**：
- 使用`@ConfigurationProperties`绑定
配置文件中的
数据库连接参数
- `@Primary`注解标记主数据源（必须指定一个主数据源）
- 为每个数据源创建独立的
JdbcTemplate实例
2. **服务层使用**：
- 使用`@Qualifier`注解区分
不同的
JdbcTemplate实例
- 提供两种查询方式：顺序查询和并行查询
- 并行查询使用`CompletableFuture`提高性能
3. **异常处理**：
- 捕获并处理可能的查询异常
- 使用try-catch块处理并行查询中的异常
## 高级优化技巧
1. **
连接池
配置**：
为每个数据源添加
连接池
配置（如HikariCP）：
```
java
@Bean
@ConfigurationProperties
(prefix = "
spring.datasource.primary"
)
public DataSource primaryDataSource
() {
return DataSourceBuilder.create
()
.type
(HikariDataSource.class
) // 使用HikariCP
连接池
.build
();
}
```
2. **动态数据源切换**：
实现动态数据源路由机制，根据上下文动态切换数据源：
```
java
public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey
() {
return DatabaseContextHolder.getDataSourceKey
();
}
}
```
3. **自定义RowMapper**：
使用自定义的RowMapper处理查询结果：
```
java
public class UserRowMapper implements RowMapper<User> {
@Override
public User mapRow
(ResultSet rs, int rowNum
) throws SQLException {
User user = new User
();
user.setId
(rs.getLong
("id"
));
user.setName
(rs.getString
("name"
));
return user;
}
}
// 使用
List<User> users =
jdbcTemplate.query
("SELECT * FROM users", new UserRowMapper
());
```
4. **批量操作**：
使用
JdbcTemplate的批量操作提高效率：
```
java
jdbcTemplate.batchUpdate
(
"INSERT INTO users
(name, email
) VALUES
(?, ?
)",
new BatchPreparedStatementSetter
() {
public void setValues
(PreparedStatement ps, int i
) throws SQLException {
User user = users.get
(i
);
ps.setString
(1, user.getName
());
ps.setString
(2, user.getEmail
());
}
public int getBatchSize
() {
return users.size
();
}
}
);
```
## 工作流程示意图
```mermaid
graph TD
A[客户端请求] --> B[Controller]
B --> C[Service]
C --> D1[主
数据库 JdbcTemplate]
C --> D
2[次
数据库 JdbcTemplate]
D1 --> E1[
数据库1]
D
2 --> E
2[
数据库2]
E1 --> F[返回数据]
E
2 --> F
F --> G[组合结果]
G --> H[返回客户端]
```
本文介绍了一种实现数据库连接管理和表信息获取的方法，涵盖了Oracle、MySQL和SQL Server等数据库类型，通过JdbcTemplate对象缓存减少资源消耗，并提供定时清理机制。
最低0.47元/天 解锁文章
扫一扫
903
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
