ACID Properties of Database Transactions

Direct Answer

ACID names four transaction properties. Atomicity gives an all-or-nothing outcome. Consistency means successful work preserves the rules the schema and application actually enforce. Isolation controls what concurrent transactions can observe, with strength depending on the isolation level. Durability means an acknowledged commit survives recovery within the configured storage guarantees.

Code Example

@Service
public class BankTransferService {
    private final AccountRepository accountRepo;

    @Transactional
    public void transferMoney(Long fromId, Long toId, BigDecimal amount) {
        // Repository methods use SELECT ... FOR UPDATE in a consistent id order.
        var from = accountRepo.findByIdForUpdate(fromId)
                .orElseThrow(() -> new AccountNotFoundException(fromId));
        var to = accountRepo.findByIdForUpdate(toId)
                .orElseThrow(() -> new AccountNotFoundException(toId));

        from.debit(amount);       // checks the encoded balance rule
        to.credit(amount);
    } // the transaction manager attempts one commit; either both changes persist or neither does
}

The boundary supplies atomicity for the two database changes. The locking query and debit check supply concurrency control and the business rule; @Transactional does not invent either one.

Common Mistakes & Pitfalls

• Assuming repository calls form one unit automatically: Without an outer transaction, repository methods can complete in separate transactions, so related multi-step work may not be atomic.
• Treating isolation as perfect separation: A named level allows particular behaviors, and database implementations differ. Stronger isolation can block or abort work and may require retries; its cost is workload-specific.
• Treating durability as a backup: Durability covers an acknowledged commit within configured storage guarantees. Replication, backups, and recovery procedures cover other failures such as media loss or accidental deletion.