转账功能需保证原子性与并发安全，通过账户排序加锁避免死锁，并结合日志实现事务回滚。
账户转账功能是银行系统中最基础也是最核心的业务之一。在Java中实现这一功能，需要考虑数据一致性、事务管理、异常处理以及并发安全等关键问题。下面通过一个简化的模型，展示如何用Java模拟银行转账的完整交易逻辑。
1. 账户实体类设计
定义一个Account类，用于表示银行账户，包含账户ID、余额等基本信息，并提供加锁机制防止并发修改。
public class Account {
private String accountId;
private double balance;
<pre class='brush:java;toolbar:false;'>public Account(String accountId, double balance) {
this.accountId = accountId;
this.balance = balance;
}
public synchronized void deposit(double amount) {
if (amount <= 0) throw new IllegalArgumentException("存款金额必须大于0");
this.balance += amount;
}
public synchronized boolean withdraw(double amount) {
if (amount <= 0) throw new IllegalArgumentException("取款金额必须大于0");
if (balance < amount) return false;
balance -= amount;
return true;
}
public String getAccountId() {
return accountId;
}
public double getBalance() {
return balance;
}}
2. 转账服务逻辑实现
转账操作涉及两个账户：转出方和接收方。需确保整个过程具备原子性——要么全部成功，要么全部回滚。
立即学习“Java免费学习笔记（深入）”；
public class TransferService {
<pre class='brush:java;toolbar:false;'>public boolean transfer(Account from, Account to, double amount) {
if (amount <= 0) {
throw new IllegalArgumentException("转账金额必须大于0");
}
// 避免死锁：按账户ID排序锁定
Account first = from.getAccountId().compareTo(to.getAccountId()) < 0 ? from : to;
Account second = from == first ? to : from;
// 双重加锁，保证线程安全
synchronized (first) {
synchronized (second) {
if (!from.withdraw(amount)) {
return false; // 余额不足
}
to.deposit(amount);
return true;
}
}
}}
这里使用了账户ID排序加锁法来避免死锁。多个线程在转账时，总是先锁定ID较小的账户，再锁较大的，从而保证加锁顺序一致。
3. 异常与事务模拟
真实银行系统中会使用数据库事务（如JDBC或Spring Transaction）。此处用Java模拟事务行为，记录操作日志并支持失败回滚。
public class TransactionLog {
private List<String> logs = new ArrayList<>();
<pre class='brush:java;toolbar:false;'>public void log(String msg) {
logs.add(LocalDateTime.now() + " - " + msg);
}
public void rollback(Account from, Account to, double amount) {
to.deposit(amount); // 撤销到账
from.withdraw(-amount); // 补回转出金额（注意方向）
log("事务回滚: " + from.getAccountId() + " → " + to.getAccountId() + ", 金额:" + amount);
}
public void commit(String fromId, String toId, double amount) {
log("转账成功: " + fromId + " → " + toId + ", 金额:" + amount);
}}
在TransferService中集成日志和回滚逻辑：
public boolean transferWithLog(Account from, Account to, double amount, TransactionLog log) {
if (amount <= 0) throw new IllegalArgumentException();
<pre class='brush:java;toolbar:false;'>Account first = from.getAccountId().compareTo(to.getAccountId()) < 0 ? from : to;
Account second = from == first ? to : from;
synchronized (first) {
synchronized (second) {
boolean success = from.withdraw(amount);
if (!success) {
log.log("转账失败：余额不足 - " + from.getAccountId());
return false;
}
to.deposit(amount);
try {
// 模拟网络延迟或中间错误
// 若发生异常应触发回滚（实际中可用try-catch-finally或AOP）
log.commit(from.getAccountId(), to.getAccountId(), amount);
return true;
} catch (Exception e) {
log.rollback(from, to, amount);
return false;
}
}
}}
4. 测试用例验证
编写测试代码验证正常转账、余额不足、并发安全等情况。
public class TransferTest {
public static void main(String[] args) {
Account accA = new Account("A001", 1000);
Account accB = new Account("B002", 500);
TransactionLog log = new TransactionLog();
TransferService service = new TransferService();
<pre class='brush:java;toolbar:false;'> // 正常转账
boolean result = service.transferWithLog(accA, accB, 200, log);
System.out.println("转账结果: " + result);
System.out.println("A余额: " + accA.getBalance()); // 800
System.out.println("B余额: " + accB.getBalance()); // 700
// 余额不足
result = service.transferWithLog(accA, accB, 900, log);
System.out.println("二次转账结果: " + result); // false
}}
基本上就这些。这套实现虽然简化了持久层和分布式事务，但涵盖了银行转账的核心逻辑：账户安全、资金一致性、异常处理与日志追踪。实际项目中可结合Spring Boot + JPA/Hibernate + @Transactional进一步封装。
