1. JDBC查询后更新操作的核心模式
在Java数据库开发中，查询后更新是最常见的操作模式之一。这种模式看似简单，但实际开发中需要考虑事务管理、并发控制、性能优化等多个关键因素。我们先从一个基础示例开始，逐步深入探讨各种场景下的最佳实践。
1.1 基础查询-更新模式
最基本的JDBC查询后更新操作包含以下几个关键步骤：
java复制// 1. 获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);
// 2. 创建Statement对象
Statement stmt = conn.createStatement();
// 3. 执行查询
ResultSet rs = stmt.executeQuery("SELECT id, status FROM orders WHERE status='PENDING'");
// 4. 遍历结果集并更新
while(rs.next()) {
int id = rs.getInt("id");
String status = rs.getString("status");
// 5. 执行更新
stmt.executeUpdate("UPDATE orders SET status='PROCESSED' WHERE id=" + id);
}
// 6. 关闭资源
rs.close();
stmt.close();
conn.close();
这个基础模式虽然简单，但存在几个明显问题：
- 没有使用事务，可能导致数据不一致
- 直接拼接SQL语句，存在SQL注入风险
- 每次循环都执行单独的更新语句，性能较差
- 缺乏完善的错误处理机制
1.2 使用PreparedStatement改进
针对上述问题，我们可以使用PreparedStatement进行改进：
java复制String querySQL = "SELECT id, amount FROM accounts WHERE status = ?";
String updateSQL = "UPDATE accounts SET status = ? WHERE id = ?";
try (Connection conn = DriverManager.getConnection(url, user, password);
PreparedStatement queryStmt = conn.prepareStatement(querySQL);
PreparedStatement updateStmt = conn.prepareStatement(updateSQL)) {
conn.setAutoCommit(false); // 开启事务
queryStmt.setString(1, "PENDING");
ResultSet rs = queryStmt.executeQuery();
while(rs.next()) {
int id = rs.getInt("id");
BigDecimal amount = rs.getBigDecimal("amount");
// 业务逻辑判断
String newStatus = amount.compareTo(BigDecimal.ZERO) > 0 ? "ACTIVE" : "REJECTED";
updateStmt.setString(1, newStatus);
updateStmt.setInt(2, id);
updateStmt.executeUpdate();
}
conn.commit(); // 提交事务
} catch (SQLException e) {
conn.rollback(); // 回滚事务
e.printStackTrace();
}
这个改进版本：
- 使用try-with-resources自动管理资源
- 采用参数化查询防止SQL注入
- 添加了事务控制
- 使用PreparedStatement提高性能
2. 并发控制策略
在高并发环境下，查询后更新操作需要考虑并发控制，避免出现数据竞争问题。常见的并发控制策略包括悲观锁和乐观锁。
2.1 悲观锁实现
悲观锁假设冲突经常发生，因此在查询时就锁定记录：
java复制String lockQuery = """
SELECT id, quantity
FROM inventory
WHERE product_id = ?
FOR UPDATE"""; // 关键锁定语句
try (Connection conn = getConnection();
PreparedStatement stmt = conn.prepareStatement(lockQuery)) {
conn.setAutoCommit(false);
stmt.setInt(1, productId);
ResultSet rs = stmt.executeQuery();
if(rs.next()) {
int currentQty = rs.getInt("quantity");
if(currentQty >= orderQty) {
// 执行更新
String updateSQL = "UPDATE inventory SET quantity = quantity - ? WHERE product_id = ?";
try (PreparedStatement updateStmt = conn.prepareStatement(updateSQL)) {
updateStmt.setInt(1, orderQty);
updateStmt.setInt(2, productId);
updateStmt.executeUpdate();
conn.commit();
return true;
}
}
}
conn.rollback();
return false;
}
悲观锁的特点：
- 使用
FOR UPDATE锁定查询到的记录 - 其他事务无法修改被锁定的记录
- 适合冲突频繁的场景
- 可能导致死锁和性能问题
2.2 乐观锁实现
乐观锁假设冲突很少发生，通过版本号控制并发：
java复制// 1. 查询当前数据和版本号
String query = "SELECT id, quantity, version FROM inventory WHERE product_id = ?";
PreparedStatement queryStmt = conn.prepareStatement(query);
queryStmt.setInt(1, productId);
ResultSet rs = queryStmt.executeQuery();
if(rs.next()) {
int currentQty = rs.getInt("quantity");
int version = rs.getInt("version");
// 2. 执行业务逻辑...
// 3. 更新时检查版本号
String update = """
UPDATE inventory
SET quantity = ?, version = version + 1
WHERE product_id = ? AND version = ?""";
PreparedStatement updateStmt = conn.prepareStatement(update);
updateStmt.setInt(1, newQuantity);
updateStmt.setInt(2, productId);
updateStmt.setInt(3, version);
int rows = updateStmt.executeUpdate();
if(rows == 0) {
// 版本号不匹配，更新失败
throw new OptimisticLockException("并发修改冲突");
}
}
乐观锁的特点：
- 需要额外的version字段
- 更新时检查版本号是否变化
- 冲突时需要重试或放弃
- 适合冲突较少的场景
- 性能较好
3. 批量处理优化
当需要处理大量数据时，单个记录处理效率低下，我们需要采用批量处理技术。
3.1 基础批量更新
JDBC提供了批量更新API：
java复制String query = "SELECT id FROM users WHERE last_login < ?";
String update = "UPDATE users SET status = 'INACTIVE' WHERE id = ?";
try (Connection conn = getConnection();
PreparedStatement queryStmt = conn.prepareStatement(query);
PreparedStatement updateStmt = conn.prepareStatement(update)) {
conn.setAutoCommit(false);
queryStmt.setDate(1, Date.valueOf(LocalDate.now().minusMonths(6)));
ResultSet rs = queryStmt.executeQuery();
int batchSize = 0;
while(rs.next()) {
updateStmt.setInt(1, rs.getInt("id"));
updateStmt.addBatch();
batchSize++;
if(batchSize % 100 == 0) {
updateStmt.executeBatch();
conn.commit();
batchSize = 0;
}
}
if(batchSize > 0) {
updateStmt.executeBatch();
conn.commit();
}
}
3.2 分页批量处理
对于超大结果集，可以采用分页查询：
java复制int pageSize = 500;
int page = 1;
int totalProcessed = 0;
while(true) {
String query = """
SELECT id, name
FROM products
ORDER BY id
LIMIT ? OFFSET ?""";
try (PreparedStatement stmt = conn.prepareStatement(query)) {
stmt.setInt(1, pageSize);
stmt.setInt(2, (page-1)*pageSize);
ResultSet rs = stmt.executeQuery();
if(!rs.next()) break; // 没有更多数据
do {
// 处理数据...
totalProcessed++;
} while(rs.next());
page++;
}
}
System.out.println("总共处理了 " + totalProcessed + " 条记录");
分页处理的优点：
- 避免一次性加载过多数据导致内存溢出
- 可以控制每次处理的数据量
- 支持断点续处理
4. 复杂业务场景实现
实际业务中，查询后更新往往涉及复杂的业务逻辑和多表操作。下面我们看几个典型场景。
4.1 工资计算场景
java复制public void calculateSalaries(LocalDate month) throws SQLException {
String query = """
SELECT e.id, e.base_salary,
COUNT(a.id) as attendance_days,
SUM(o.amount) as overtime_amount
FROM employees e
LEFT JOIN attendance a ON e.id = a.employee_id
AND a.date BETWEEN ? AND ?
LEFT JOIN overtime o ON e.id = o.employee_id
AND o.month = ?
WHERE e.status = 'ACTIVE'
GROUP BY e.id, e.base_salary""";
String insert = """
INSERT INTO salaries (employee_id, month, base_salary,
attendance_days, overtime_amount, total_amount)
VALUES (?, ?, ?, ?, ?, ?)""";
try (Connection conn = getConnection();
PreparedStatement queryStmt = conn.prepareStatement(query);
PreparedStatement insertStmt = conn.prepareStatement(insert)) {
conn.setAutoCommit(false);
// 设置查询参数
LocalDate start = month.withDayOfMonth(1);
LocalDate end = month.withDayOfMonth(month.lengthOfMonth());
queryStmt.setDate(1, Date.valueOf(start));
queryStmt.setDate(2, Date.valueOf(end));
queryStmt.setString(3, month.format(DateTimeFormatter.ofPattern("yyyy-MM")));
ResultSet rs = queryStmt.executeQuery();
while(rs.next()) {
int empId = rs.getInt("id");
BigDecimal baseSalary = rs.getBigDecimal("base_salary");
int attendanceDays = rs.getInt("attendance_days");
BigDecimal overtime = rs.getBigDecimal("overtime_amount");
// 计算工资
BigDecimal dailySalary = baseSalary.divide(new BigDecimal(22), 2, RoundingMode.HALF_UP);
BigDecimal attendanceSalary = dailySalary.multiply(new BigDecimal(attendanceDays));
BigDecimal total = attendanceSalary.add(overtime);
// 插入工资记录
insertStmt.setInt(1, empId);
insertStmt.setString(2, month.format(DateTimeFormatter.ofPattern("yyyy-MM")));
insertStmt.setBigDecimal(3, baseSalary);
insertStmt.setInt(4, attendanceDays);
insertStmt.setBigDecimal(5, overtime);
insertStmt.setBigDecimal(6, total);
insertStmt.executeUpdate();
}
conn.commit();
}
}
4.2 库存调整场景
java复制public void adjustInventory(LocalDate checkDate) throws SQLException {
String query = """
SELECT p.id, p.code, i.quantity as system_qty,
c.quantity as physical_qty
FROM products p
JOIN inventory i ON p.id = i.product_id
JOIN (
SELECT product_id, SUM(quantity) as quantity
FROM physical_checks
WHERE check_date = ?
GROUP BY product_id
) c ON p.id = c.product_id
WHERE c.quantity != i.quantity""";
String update = "UPDATE inventory SET quantity = ? WHERE product_id = ?";
String insert = """
INSERT INTO adjustments (product_id, before_qty, after_qty,
difference, adjusted_at)
VALUES (?, ?, ?, ?, NOW())""";
try (Connection conn = getConnection();
PreparedStatement queryStmt = conn.prepareStatement(query);
PreparedStatement updateStmt = conn.prepareStatement(update);
PreparedStatement insertStmt = conn.prepareStatement(insert)) {
conn.setAutoCommit(false);
queryStmt.setDate(1, Date.valueOf(checkDate));
ResultSet rs = queryStmt.executeQuery();
while(rs.next()) {
int productId = rs.getInt("id");
int systemQty = rs.getInt("system_qty");
int physicalQty = rs.getInt("physical_qty");
int diff = physicalQty - systemQty;
// 更新库存
updateStmt.setInt(1, physicalQty);
updateStmt.setInt(2, productId);
updateStmt.executeUpdate();
// 记录调整
insertStmt.setInt(1, productId);
insertStmt.setInt(2, systemQty);
insertStmt.setInt(3, physicalQty);
insertStmt.setInt(4, diff);
insertStmt.executeUpdate();
}
conn.commit();
}
}
5. 性能优化技巧
查询后更新操作的性能优化需要从多个方面考虑：
5.1 索引优化
确保查询条件涉及的列有适当的索引：
sql复制-- 为常用查询条件创建索引
CREATE INDEX idx_orders_status ON orders(status);
CREATE INDEX idx_accounts_status ON accounts(status);
-- 复合索引
CREATE INDEX idx_employee_attendance ON attendance(employee_id, date);
5.2 批量操作优化
使用JDBC批量操作减少网络往返：
java复制// 批量更新示例
String update = "UPDATE products SET price = ? WHERE id = ?";
PreparedStatement stmt = conn.prepareStatement(update);
for(Product p : products) {
stmt.setBigDecimal(1, p.getNewPrice());
stmt.setInt(2, p.getId());
stmt.addBatch();
if(++count % 100 == 0) {
stmt.executeBatch();
}
}
if(count % 100 != 0) {
stmt.executeBatch();
}
5.3 连接池配置
使用连接池管理数据库连接：
java复制// HikariCP配置示例
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("user");
config.setPassword("password");
config.setMaximumPoolSize(20);
config.setConnectionTimeout(30000);
HikariDataSource ds = new HikariDataSource(config);
// 使用连接
try (Connection conn = ds.getConnection()) {
// 执行操作...
}
5.4 事务隔离级别
根据业务需求选择合适的事务隔离级别：
java复制// 设置事务隔离级别
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
// 常用隔离级别：
// TRANSACTION_READ_UNCOMMITTED - 读未提交
// TRANSACTION_READ_COMMITTED - 读已提交（默认）
// TRANSACTION_REPEATABLE_READ - 可重复读
// TRANSACTION_SERIALIZABLE - 串行化
6. 常见问题与解决方案
6.1 连接泄漏问题
问题表现：应用运行一段时间后无法获取数据库连接。
解决方案：
- 使用try-with-resources自动关闭资源
- 确保finally块中关闭所有资源
- 使用连接池并配置合理的超时时间
java复制// 正确做法
try (Connection conn = ds.getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(query)) {
// 处理结果...
} catch (SQLException e) {
// 异常处理...
}
6.2 死锁问题
问题表现：事务长时间等待或报死锁错误。
解决方案：
- 按照固定顺序访问表和记录
- 减少事务持有时间
- 使用适当的隔离级别
- 添加重试机制
java复制int retries = 3;
while(retries-- > 0) {
try {
// 执行业务操作...
break;
} catch (SQLException e) {
if(e.getErrorCode() == 1213 && retries > 0) { // 死锁错误码
Thread.sleep(100); // 等待后重试
continue;
}
throw e;
}
}
6.3 性能问题
问题表现：批量处理数据时速度慢。
解决方案：
- 使用批量操作代替单条操作
- 适当调整批量大小（通常100-1000条/批）
- 关闭自动提交
- 考虑使用多线程处理
java复制// 批量大小优化
int batchSize = 500; // 根据测试调整最佳值
for(int i=0; i<data.size(); i++) {
stmt.setXXX(1, data.get(i).getValue());
stmt.addBatch();
if((i+1) % batchSize == 0 || i == data.size()-1) {
stmt.executeBatch();
}
}
6.4 内存溢出问题
问题表现：处理大量数据时出现OutOfMemoryError。
解决方案：
- 使用分页查询代替全量查询
- 及时清理不再使用的对象
- 增加JVM内存
- 使用流式处理ResultSet
java复制// 流式处理ResultSet
stmt.setFetchSize(100); // 设置适当的fetch size
ResultSet rs = stmt.executeQuery();
while(rs.next()) {
// 处理当前行...
}
7. 高级技巧与最佳实践
7.1 使用模板模式封装通用逻辑
将重复的JDBC操作封装成模板：
java复制public interface ResultSetProcessor<T> {
T process(ResultSet rs) throws SQLException;
}
public class JdbcTemplate {
public <T> T query(String sql, ResultSetProcessor<T> processor, Object... params) {
try (Connection conn = getConnection();
PreparedStatement stmt = conn.prepareStatement(sql)) {
for(int i=0; i<params.length; i++) {
stmt.setObject(i+1, params[i]);
}
ResultSet rs = stmt.executeQuery();
return processor.process(rs);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
// 使用示例
public List<Product> getActiveProducts() {
return query("SELECT id, name FROM products WHERE active = true", rs -> {
List<Product> list = new ArrayList<>();
while(rs.next()) {
list.add(new Product(rs.getInt("id"), rs.getString("name")));
}
return list;
});
}
}
7.2 使用Spring JdbcTemplate
Spring框架提供了更完善的JdbcTemplate：
java复制@Repository
public class ProductRepository {
private final JdbcTemplate jdbcTemplate;
public ProductRepository(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public List<Product> findActiveProducts() {
return jdbcTemplate.query(
"SELECT id, name, price FROM products WHERE active = true",
(rs, rowNum) -> new Product(
rs.getInt("id"),
rs.getString("name"),
rs.getBigDecimal("price")
)
);
}
public int updateProductPrice(int productId, BigDecimal newPrice) {
return jdbcTemplate.update(
"UPDATE products SET price = ? WHERE id = ?",
newPrice, productId
);
}
}
7.3 使用Java 8 Stream API处理结果
结合Stream API可以更灵活地处理查询结果：
java复制public Stream<Product> streamAllProducts() throws SQLException {
Connection conn = getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT id, name FROM products");
return StreamSupport.stream(new Spliterators.AbstractSpliterator<Product>(
Long.MAX_VALUE, Spliterator.ORDERED) {
@Override
public boolean tryAdvance(Consumer<? super Product> action) {
try {
if(!rs.next()) {
rs.close();
stmt.close();
conn.close();
return false;
}
action.accept(new Product(rs.getInt("id"), rs.getString("name")));
return true;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}, false);
}
// 使用示例
streamAllProducts()
.filter(p -> p.getName().contains("Pro"))
.sorted(Comparator.comparing(Product::getId))
.forEach(System.out::println);
7.4 使用JPA/Hibernate等ORM框架
对于复杂应用，可以考虑使用ORM框架：
java复制@Entity
@Table(name = "products")
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String name;
private BigDecimal price;
private boolean active;
// getters/setters...
}
@Repository
public class ProductRepository {
@PersistenceContext
private EntityManager em;
public List<Product> findActiveProducts() {
return em.createQuery(
"SELECT p FROM Product p WHERE p.active = true", Product.class)
.getResultList();
}
@Transactional
public void updateProductPrices(double increaseRate) {
List<Product> products = findActiveProducts();
for(Product p : products) {
p.setPrice(p.getPrice().multiply(new BigDecimal(1 + increaseRate)));
}
}
}
8. 实际项目中的经验分享
在实际项目中应用查询后更新模式时，我总结了以下几点经验：
8.1 事务边界划分
事务应该尽可能短小，但也要保持业务完整性。常见原则：
- 一个业务用例对应一个事务
- 避免在事务中进行远程调用
- 长时间运行的事务考虑拆分为多个小事务
8.2 异常处理策略
完善的异常处理应包括：
- SQLException的特定处理
- 事务回滚机制
- 重试策略（对乐观锁冲突等）
- 适当的日志记录
java复制@Transactional
public void processOrder(int orderId) {
try {
Order order = orderRepository.findById(orderId);
// 业务处理...
} catch (OptimisticLockingFailureException e) {
// 乐观锁冲突，重试
throw new RetryableException("并发修改冲突，请重试", e);
} catch (DataAccessException e) {
// 数据访问异常
throw new BusinessException("处理订单失败", e);
}
}
8.3 性能监控与调优
关键性能指标：
- 查询执行时间
- 更新影响行数
- 事务持续时间
- 锁等待时间
可以使用如下工具监控：
- JDBC性能监控工具（如P6Spy）
- 应用性能管理(APM)工具
- 数据库自带的性能视图
8.4 代码组织建议
良好的代码组织可以提高可维护性：
- 将SQL语句集中管理（属性文件或常量类）
- 使用DAO模式分离数据访问逻辑
- 对复杂查询使用专门的查询对象
- 保持方法单一职责
java复制// SQL集中管理示例
public interface SqlQueries {
String GET_ACTIVE_PRODUCTS = """
SELECT id, name, price
FROM products
WHERE active = true
AND stock > 0""";
String UPDATE_PRODUCT_PRICE = """
UPDATE products
SET price = ?, updated_at = NOW()
WHERE id = ?""";
}
// DAO接口示例
public interface ProductDao {
List<Product> findActiveProducts();
int updatePrice(int productId, BigDecimal newPrice);
}
// 实现类
@Repository
public class ProductDaoImpl implements ProductDao {
private final JdbcTemplate jdbcTemplate;
@Override
public List<Product> findActiveProducts() {
return jdbcTemplate.query(
SqlQueries.GET_ACTIVE_PRODUCTS,
(rs, rowNum) -> mapProduct(rs)
);
}
private Product mapProduct(ResultSet rs) throws SQLException {
// 映射逻辑...
}
}
8.5 测试策略建议
可靠的测试策略应包括：
- 单元测试：测试业务逻辑
- 集成测试：测试数据库交互
- 性能测试：验证批量操作性能
- 并发测试：验证锁策略有效性
java复制// 集成测试示例
@SpringBootTest
@Transactional
class ProductDaoIntegrationTest {
@Autowired
private ProductDao productDao;
@Test
void updatePrice_shouldAffectCorrectProduct() {
// 准备测试数据
jdbcTemplate.update("INSERT INTO products(id, name, price) VALUES(1, 'Test', 10.00)");
// 执行操作
int updated = productDao.updatePrice(1, new BigDecimal("12.50"));
// 验证结果
assertEquals(1, updated);
BigDecimal newPrice = jdbcTemplate.queryForObject(
"SELECT price FROM products WHERE id = 1", BigDecimal.class);
assertEquals(0, new BigDecimal("12.50").compareTo(newPrice));
}
}
9. 现代Java数据库访问趋势
随着Java生态的发展，数据库访问方式也在不断演进：
9.1 响应式数据库访问
使用R2DBC进行非阻塞数据库访问：
java复制@Repository
public class ProductRepository {
private final DatabaseClient dbClient;
public Flux<Product> findActiveProducts() {
return dbClient.sql("SELECT id, name FROM products WHERE active = true")
.map((row, meta) -> new Product(
row.get("id", Integer.class),
row.get("name", String.class)
))
.all();
}
}
9.2 使用JOOQ类型安全SQL
JOOQ提供了类型安全的SQL构建：
java复制// 使用JOOQ查询
List<Product> products = ctx.select(PRODUCT.ID, PRODUCT.NAME, PRODUCT.PRICE)
.from(PRODUCT)
.where(PRODUCT.ACTIVE.eq(true))
.fetchInto(Product.class);
// 使用JOOQ更新
int updated = ctx.update(PRODUCT)
.set(PRODUCT.PRICE, PRODUCT.PRICE.multiply(1.1))
.where(PRODUCT.STOCK.gt(0))
.execute();
9.3 使用MyBatis简化操作
MyBatis提供了灵活的SQL映射：
xml复制<!-- Mapper XML -->
<select id="selectActiveProducts" resultType="Product">
SELECT id, name, price
FROM products
WHERE active = true
</select>
<update id="updateProductPrice">
UPDATE products
SET price = #{price}
WHERE id = #{id}
</update>
java复制// Mapper接口
public interface ProductMapper {
List<Product> selectActiveProducts();
int updateProductPrice(@Param("id") int id, @Param("price") BigDecimal price);
}
// 使用示例
@Autowired
private ProductMapper productMapper;
public void increasePrices(double rate) {
List<Product> products = productMapper.selectActiveProducts();
for(Product p : products) {
BigDecimal newPrice = p.getPrice().multiply(BigDecimal.valueOf(1 + rate));
productMapper.updateProductPrice(p.getId(), newPrice);
}
}
10. 总结与个人实践建议
经过多年的Java数据库开发实践，我认为以下几点尤为重要：
-
理解业务需求：任何技术方案都应服务于业务需求，不要过度设计
-
保持简单：在满足需求的前提下，选择最简单的实现方案
-
重视事务管理：正确使用事务可以避免很多数据一致性问题
-
考虑并发场景：多思考"如果同时有多个请求会怎样"
-
性能意识：从小数据量开始就考虑性能问题，避免后期重构
-
完善的错误处理：数据库操作可能失败的各种情况都要考虑
-
持续学习：关注Java数据库访问技术的新发展
在实际项目中，我通常会：
- 对于简单CRUD：使用Spring Data JPA
- 对于复杂查询：使用JOOQ或MyBatis
- 对于高性能需求：考虑直接使用JDBC或R2DBC
- 对于报表类操作：使用存储过程或专门的分析数据库
最后提醒一点：无论使用哪种技术，良好的数据库设计和适当的索引都是高性能的基础。在优化查询更新操作之前，先确保你的数据库结构是合理的。