Lassen Sie uns darüber sprechen, wie Sie Datenbanktransaktionen im Laravel-Code richtig verwenden

Bei der Webentwicklung sind Datenintegrität und -genauigkeit sehr wichtig. Daher müssen wir sicherstellen, dass der von uns geschriebene Code Daten auf sichere Weise in der Datenbank speichern, aktualisieren und löschen kann.

In diesem Artikel schauen wir uns an, was Datenbanktransaktionen sind, warum sie wichtig sind und wie man sie in Laravel verwendet. Wir werden uns auch mit einem häufigen „Problem“ befassen, das Warteschlangen und Datenbanktransaktionen betrifft.

Was sind Datenbanktransaktionen?

Bevor wir uns mit Datenbanktransaktionen in Laravel befassen, schauen wir uns zunächst an, was sie sind und welchen Nutzen sie haben.

Es gibt viele komplex klingende technische Erklärungen dafür, was eine Datenbanktransaktion ist. Für die meisten Webentwickler müssen wir jedoch lediglich wissen, dass Transaktionen die Art und Weise sind, wie eine ganze Arbeitseinheit in einer Datenbank abgeschlossen wird.

Um zu verstehen, was das eigentlich bedeutet, schauen wir uns ein einfaches Beispiel an, das einen kleinen Kontext liefert.

Angenommen, wir haben eine Anwendung, mit der sich Benutzer registrieren können. Immer wenn sich ein Benutzer anmeldet, möchten wir für ihn ein neues Konto erstellen und ihm dann die Standardrolle „Allgemein“ zuweisen.

Unser Code könnte so aussehen:

$user = User::create([
    'email' => $request->email,
]);

$user->roles()->attach(Role::where('name', 'general')->first());

Auf den ersten Blick scheint dieser Code völlig in Ordnung zu sein. Wenn wir jedoch genauer hinsehen, erkennen wir, dass tatsächlich einige Dinge schiefgehen können. Wir können Benutzer erstellen, ihnen jedoch keine Rollen zuweisen. Dies kann viele verschiedene Ursachen haben, beispielsweise ein Fehler im Code, der die Rolle zuweist, oder sogar ein Hardwareproblem, das uns daran hindert, auf die Datenbank zuzugreifen.

In diesem Fall bedeutet dies, dass es einen Benutzer ohne Rolle im System gibt. Wie Sie sich vorstellen können, kann dies an anderer Stelle in Ihrer Anwendung zu Ausnahmen und Fehlern führen, da Sie immer davon ausgehen, dass der Benutzer eine Rolle hat (was richtig ist).

Um dieses Problem zu lösen, können wir Datenbanktransaktionen verwenden. Durch die Verwendung von Transaktionen wird sichergestellt, dass alle Änderungen an der Datenbank innerhalb der Transaktion rückgängig gemacht werden, wenn beim Ausführen des Codes ein Fehler auftritt. Wenn beispielsweise ein Benutzer in die Datenbank eingefügt wird, die Abfrage zum Zuweisen der Rolle jedoch aus irgendeinem Grund fehlschlägt, wird die Transaktion zurückgesetzt und die Zeile des Benutzers gelöscht. Dies bedeutet, dass wir keine Benutzer ohne zugewiesene Rollen erstellen können.

Mit anderen Worten: Es geht um „Alles oder Nichts“.

Datenbanktransaktionen in Laravel verwenden

Da wir nun eine einfache Vorstellung davon haben, was Transaktionen sind und was sie implementieren, wollen wir uns ansehen, wie man sie in Laravel verwendet.

In Laravel ist der Einstieg in die Verwendung von Transaktionen tatsächlich sehr einfach, da wir auf die transaction()-Methode auf der DB-Fassade zugreifen können. Fahren wir mit dem vorherigen Beispielcode fort und sehen wir uns an, wie Transaktionen beim Erstellen von Benutzern und beim Zuweisen von Rollen verwendet werden. DB 门面上访问 transaction() 方法，因此开始使用事务实际上是很容易的事。继续使用之前的示例代码，让我们看看在创建用户并为其分配角色时如何使用事务。

use Illuminate\Support\Facades\DB;

DB::transaction(function () use ($user, $request): void {
    $user = User::create([
        'email' => $request->email,
    ]);

    $user->roles()->attach(Role::where('name', 'general')->first());
});

现在我们的代码被包裹在一个数据库事务中，如果在其中的任意一点抛出异常，对数据库的任何更改都将返回到事务开始之前的状态。

在 Laravel 中手动使用数据库事务

有时，您可能希望对事务进行更精细的控制。例如，假设您正在与第三方服务集成，比如 Mailchinp 或 Xero。我们会说，每当您创建一个新用户时，您还需要向他们的 API 发出 HTTP 请求，以将他们也创建为该系统中的用户。

我们可能想要更新我们的代码，以便如果我们无法在我们自己的系统 ** 且 ** 在第三方系统中创建用户，则两个系统都不创建用户。 如果您正在与第三方系统交互，那么您可能有一个可用于发出请求的类。 或者，可能有一个您可以使用的包。 有时，当某些请求无法完成时，发出请求的类可能会抛出异常。 然而，其中一些类可能会消除错误，而只是从您调用的方法中返回 false

class ThirdPartyService
{
    private $errors;

    public function createUser($userData)
    {
        $request = $this->makeRequest($userData);

        if ($request->successful()) {
            return $request->body();
        }

        $errors = $request->errors();

        return false;
    }

    public function getErrors()
    {
        return $this->errors;
    }
}

Jetzt ist unser Code in eine Datenbanktransaktion eingeschlossen. Wenn an irgendeiner Stelle darin eine Ausnahme ausgelöst wird, werden alle Änderungen an der Datenbank auf den Zustand vor Beginn der Transaktion zurückgesetzt.

Manuelle Verwendung von Datenbanktransaktionen in Laravel

Manchmal möchten Sie möglicherweise eine detailliertere Kontrolle über Transaktionen. Angenommen, Sie integrieren einen Drittanbieterdienst wie Mailchinp oder Xero. Wir würden sagen, dass Sie jedes Mal, wenn Sie einen neuen Benutzer erstellen, auch eine HTTP-Anfrage an dessen API stellen müssen, um ihn auch als Benutzer in diesem System zu erstellen. 🎜🎜Möglicherweise möchten wir unseren Code aktualisieren, sodass, wenn wir keinen Benutzer in unserem eigenen System ** und ** in einem Drittsystem erstellen können, kein System den Benutzer erstellt. Wenn Sie mit einem Drittsystem interagieren, verfügen Sie wahrscheinlich über eine Klasse, mit der Sie Anfragen stellen können. Alternativ gibt es möglicherweise ein Paket, das Sie verwenden können. Wenn einige Anforderungen nicht abgeschlossen werden können, löst die anfordernde Klasse manchmal eine Ausnahme aus. Einige dieser Klassen beseitigen den Fehler jedoch möglicherweise und geben einfach false von der von Ihnen aufgerufenen Methode zurück, wodurch der Fehler in ein Feld der Klasse eingefügt wird. 🎜🎜Nehmen wir also an, wir haben die folgende grundlegende Beispielklasse, die die API aufruft: 🎜

use Illuminate\Support\Facades\DB;
use App\Services\ThirdPartyService;

DB::beginTransaction();

$thirdPartyService = new ThirdPartyService();

$userData = [
    'email' => $request->email,
];

$user = User::create($userData);

$user->roles()->attach(Role::where('name', 'general')->first());

if ($thirdPartyService->createUser($userData)) {
    DB::commit();

    return;
}

DB::rollBack();

report($thirdPartyService->getErrors());

🎜 Natürlich ist der Code der Anforderungsklasse oben unvollständig und mein Codebeispiel unten ist auch nicht ganz klar, aber es sollte Ihnen einen allgemeinen Überblick darüber geben ​​Was ich tue, muss zum Ausdruck gebracht werden. Verwenden wir also diese Anforderungsklasse und fügen sie unserem vorherigen Codebeispiel hinzu: 🎜

use Illuminate\Support\Facades\DB;
use App\Services\ThirdPartyService;

DB::transaction(function () use ($user, $request): void {
    $user = User::create([
        'email' => $request->email,
    ]);

    $user->roles()->attach(Role::where('name', 'general')->first());

    if (! $thirdPartyService->createUser($userData)) {
        throw new \Exception('User could not be created');
    }
});

🎜 Wenn wir uns den obigen Code ansehen, können wir sehen, dass wir eine Transaktion starten, den Benutzer erstellen und ihm eine Rolle zuweisen und dann einen Drittanbieterdienst verwenden wurde aufgerufen. Wenn der Benutzer erfolgreich im externen Dienst erstellt wurde, können wir die Datenbankänderungen sicher übernehmen, da wir wissen, dass alles korrekt erstellt wurde. Wenn der Benutzer jedoch nicht im externen Dienst erstellt wird, werden die Änderungen in der Datenbank zurückgesetzt (der Benutzer und seine Rollenzuweisungen werden gelöscht) und ein Fehler wird gemeldet. 🎜

与第三方服务交互的技巧

作为一个额外的技巧，我通常建议将任何影响第三方系统、文件存储或缓存的代码放在数据库调用之后。

为了更深入地理解这一点，让我们以上面的代码示例为例。请注意，在向第三方服务发出请求之前，我们是如何首先对数据库进行所有更改的。这意味着，如果从第三方请求返回任何错误，将回滚我们自己数据库中的用户和角色分配。

然而， 如果我们反过来做，我们在修改数据库之前发出请求，那就不是这种情况了。出于任何原因，如果我们在数据库中创建用户时发生任何错误，我们会在第三方系统中创建一个新用户，但是在我们系统中却没有创建。如你所想， 这可能会导致更多问题。通过编写一个清理方法将用户从第三方系统中删除，可以降低这个问题的严重性。 但是，正如您可以想象的那样， 这可能会导致更多的问题，并导致编写、维护和测试更多的代码。

所以，我总是建议把数据库调用放在API调用之前。但并不总是这样，有时可能需要将第三方请求返回的值保存到数据库中。如果是这种情况，就需要API调用放到数据库调用之前了，只要您确保有一些代码可以处理任何失败，这是完全可以的。

使用自动或手动事务

同样值得注意的是，因为我们最初的示例使用DB:transaction()方法，在抛出异常时回滚事务，所以我们也可以使用这种方法向我们的第三方服务发出请求。相反，我们可以这样更新类:

use Illuminate\Support\Facades\DB;
use App\Services\ThirdPartyService;

DB::transaction(function () use ($user, $request): void {
    $user = User::create([
        'email' => $request->email,
    ]);

    $user->roles()->attach(Role::where('name', 'general')->first());

    if (! $thirdPartyService->createUser($userData)) {
        throw new \Exception('User could not be created');
    }
});

这绝对是一个可行的解决方案，并将按照预期成功回滚事务。事实上，就我个人的偏好而言，我实际上更喜欢这种方式，而不是手动使用事务。我认为它看起来更容易阅读和理解。

然而，与手动提交或回滚事务时使用 ‘if’ 语句相比，异常处理在时间和性能方面可能会比较昂贵。

因此，举个例子，如果这段代码用于导入包含10,000个用户数据的 CSV 文件，您可能会发现抛出异常会大大减慢导入速度。

但是，如果它只是在一个用户可以注册的简单web请求中使用，那么抛出异常可能没有问题。当然，这取决于应用程序的大小，性能是关键因素；所以你需要根据具体情况来决定。

在数据库事务中调度队列

每当您在事务中处理队列时，您都需要注意一个“陷阱”。

为了提供一些上下文，让我们继续使用之前的代码示例。我们可以想象，在我们创建了我们的用户之后，我们想要运行一个任务来提醒管理员通知他们新注册并向新用户发送欢迎电子邮件。我们将通过分派一个名为 AlertNewUser 的队列任务来做到这一点，如下所示：

use Illuminate\Support\Facades\DB;
use App\Jobs\AlertNewUser;
use App\Services\ThirdPartyService;

DB::transaction(function () use ($user, $request): void {
    $user = User::create([
        'email' => $request->email,
    ]);

    $user->roles()->attach(Role::where('name', 'general')->first());

    AlertNewUser::dispatch($user);
});

当您开始一个事务并对其中的任何数据进行更改时，这些更改仅对正在运行事务的请求/进程可用。对于任何其他访问您更改的数据的请求或进程，必须先提交事务。因此，这意味着如果我们从事务内部分派任何排队的队列、事件监听器、邮件，通知或广播事件。由于竞争条件，我们的数据更改可能在事务内部不可用。

如果队列在事务提交之前开始处理排队的代码，就会发生这种情况。因此，这可能导致您的排队代码可能试图访问不存在的数据，并可能导致错误。在我们的例子中，如果在事务提交之前运行队列AlertNewUser作业，那么我们的作业将尝试访问一个尚未实际存储在数据库中的用户。如您所料，这将导致作业失败。

为了防止这种竞争条件的发生，我们可以对我们的代码和/或我们的配置进行一些更改，以确保仅在事务成功提交后才调度队列。

我们可以更新 config/queue.php 并添加 after commit 字段。让我们想象一下，我们正在使用 redis 队列驱动程序，所以我们可以这样更新配置：

<?php

return [

    // ...

    &#39;connections&#39; => [

        // ...

        &#39;redis&#39; => [
            &#39;driver&#39; => &#39;redis&#39;,
            // ...
            &#39;after_commit&#39; => true,
        ],

        // ...

    ],

    // ...
];

通过进行此更改，如果我们尝试在事务内调度队列，则队列将在实际调度队列之前等待事务提交。 方便的是，如果事务回滚，它也会阻止队列被调度。

然而，可能有一个原因，您不希望在配置中全局设置此选项。 如果是这种情况，Laravel 仍然提供了一些很好的助手方法，我们可以根据具体情况使用它们。
如果我们想更新事务中的代码，只在任务提交后才分派任务，可以使用afterCommit()方法，如下所示：

use Illuminate\Support\Facades\DB;
use App\Jobs\AlertNewUser;
use App\Services\ThirdPartyService;

DB::transaction(function () use ($user, $request): void {
    $user = User::create([
        'email' => $request->email,
    ]);

    $user->roles()->attach(Role::where('name', 'general')->first());

    AlertNewUser::dispatch($user)->afterCommit();
});

Laravel 还提供了另一个我们可以使用的方便的beforeCommit()方法。 如果我们在队列配置中设置了全局after_commit => true，但不关心等待事务被提交，就可以使用这个。 要做到这一点，我们可以简单地像这样更新我们的代码：

use Illuminate\Support\Facades\DB;
use App\Jobs\AlertNewUser;
use App\Services\ThirdPartyService;

DB::transaction(function () use ($user, $request): void {
    $user = User::create([
        'email' => $request->email,
    ]);

    $user->roles()->attach(Role::where('name', 'general')->first());

    AlertNewUser::dispatch($user)->beforeCommit();
});

总结

希望本文能让您大致了解什么是数据库事务以及如何在 Laravel 中使用它们。 它还向您展示了如何在从内部事务调度队列时避免“陷阱”。

原文地址：https://dev.to/ashallendesign/using-database-transactions-to-write-safer-laravel-code-13ek

译文地址：https://learnku.com/laravel/t/61575

【相关推荐：laravel视频教程】

Das obige ist der detaillierte Inhalt vonLassen Sie uns darüber sprechen, wie Sie Datenbanktransaktionen im Laravel-Code richtig verwenden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!