Laravel simplifies database transaction processing with built-in support. 1. Use the DB::transaction() method to automatically commit or rollback operations to ensure data integrity; 2. Support nested transactions and implement them through savepoints, but it is usually recommended to use a single transaction wrapper to avoid complexity; 3. Provide manual control methods such as beginTransaction(), commit() and rollBack(), suitable for scenarios that require more flexible processing; 4. Best practices include keeping transactions short, only using them when necessary, testing failures, and recording rollback information. Rationally choosing transaction management methods can help improve application reliability and performance.

Handling database transactions in Laravel is straightforward, thanks to its built-in support for managing them. Whether you're dealing with a simple form submission or a complex operation that touches multiple tables, wrapping your database logic in a transaction ensures data integrity and consistency.

What Are Database Transactions?

A database transaction is a sequence of operations that must all succeed together or fail together. If any part of the transaction fails, the entire operation is rolled back, leaving the database in its original state. This behavior follows the ACID principles (Atomicity, Consistency, Isolation, Durability), which are essential for reliable database handling.

In Laravel, you can use the DB facade to start and manage transactions manually, or use higher-level helpers that simplify this process.

Using DB::transaction()

The most common way to handle transactions in Laravel is by using the DB::transaction() method. It wraps your database operations inside a closure, automatically committing the changes if everything runs smoothly or rolling back if an exception is thrown.

 use Illuminate\Support\Facades\DB;

DB::transaction(function () {
    DB::table('users')->where('id', 1)->decrement('balance', 50);
    DB::table('users')->where('id', 2)->increment('balance', 50);
});

This example transfers 50 from one user's balance to another. If either of those operations fails, neither will be applied.

Tip: Always make sure to throw exceptions inside the transaction block when something goes wrong — Laravel catches them and rolls back automatically.

You might also want to perform more complex queries or Eloquent operations inside the transaction:

 DB::transaction(function () {
    $user = User::find(1);
    $user->balance -= 50;
    $user->save();

    $recipient = User::find(2);
    $recipient->balance = 50;
    $recipient->save();
});

Just remember: any uncaught exception within the closure triggers a rollback.

Handling Nested Transactions

Laravel supports nested transactions via savepoints, although it's not something you'll need often. By default, calling DB::beginTransaction() multiple times doesn't actually create a true nested transaction but instead increments a counter internally.

If you're writing code where parts of a transaction may be handled separately — say, inside a service class — you can safely call DB::transaction() again without breaking the outer transaction.

Still, unless you have a specific reason to manage transactions manually, stick with the single DB::transaction() wrapper. It keeps things simpler and avoids potential confusion.

Manual Control with beginTransaction(), commit(), and rollBack()

Sometimes you need more control over how and when to commit or roll back a transaction. In such cases, you can use manual transaction methods:

• DB::beginTransaction()
• DB::commit()
• DB::rollBack()

Here's how you might structure it:

 DB::beginTransaction();

try {
    // Perform multiple operations
    DB::table('accounts')->where('id', 1)->update(['balance' => 100]);
    DB::table('accounts')->where('id', 2)->update(['balance' => 200]);

    DB::commit();
} catch (\Exception $e) {
    DB::rollBack();
    // Handle the error, log, notify, etc.
}

This approach gives you more flexibility, especially when integrating third-party services or handling external API calls within a transaction.

Just be careful:

• Always wrap this in a try-catch block.
• Never forget to call commit() or rollBack() after starting a transaction.

Leaving a transaction open can lead to connection leaks or deadlocks in the database.

Transaction Best Practices

To avoid issues and ensure your transactions behave as expected:

• Keep transactions short – Long-running transactions can lock tables and reduce performance.
• Use transactions only when necessary – For simple selects or single inserts, they're not always needed.
• Test failure scenarios – Throw exceptions deliberately to confirm rollback works.
• Log what happens during rollback – Helps with debugging production issues.

Also, consider wrapping transactional logic in services or jobs if it gets too complex. That keeps your controllers clean and make testing easier.

Transactions are a powerful tool for ensuring data consistency, and Laravel makes it easy to implement them properly. Just pick the right level of control based on your needs — whether it's a simple DB::transaction() or full manual management.

The above is the detailed content of Implementing Database Transactions in Laravel?. For more information, please follow other related articles on the PHP Chinese website!