Parlons de la façon d'utiliser correctement les transactions de base de données dans le code Laravel

Dans le développement Web, l'intégrité et l'exactitude des données sont très importantes. Par conséquent, nous devons nous assurer que le code que nous écrivons peut stocker, mettre à jour et supprimer des données dans la base de données de manière sûre.

Dans cet article, nous examinerons ce que sont les transactions de base de données, pourquoi elles sont importantes et comment commencer à les utiliser dans Laravel. Nous examinerons également un « problème » courant impliquant les files d’attente et les transactions de base de données.

Que sont les transactions de base de données ?

Avant de commencer à examiner les transactions de base de données dans Laravel, voyons d'abord ce qu'elles sont et en quoi elles sont bénéfiques.

Il existe de nombreuses explications techniques apparemment complexes sur ce qu'est une transaction de base de données. Cependant, pour la plupart des développeurs Web, tout ce que nous devons savoir, c'est que les transactions constituent la manière dont une unité de travail entière dans une base de données est réalisée.

Pour comprendre ce que cela signifie réellement, regardons un exemple de base qui donnera un peu de contexte.

Supposons que nous ayons une application qui permet aux utilisateurs de s'inscrire. Chaque fois qu'un utilisateur s'inscrit, nous souhaitons lui créer un nouveau compte, puis lui attribuer un rôle par défaut de "général".

Notre code pourrait ressembler à ceci :

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

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

À première vue, ce code semble parfaitement bien. Cependant, en y regardant de plus près, nous pouvons constater que certaines choses peuvent mal tourner. Nous pouvons créer des utilisateurs, mais nous ne pouvons pas leur attribuer de rôles. Cela peut être dû à de nombreuses raisons différentes, comme un bug dans le code qui attribue le rôle, ou même un problème matériel qui nous empêche d'accéder à la base de données.

Si cela se produit, cela signifiera qu'il y aura un utilisateur sans rôle dans le système. Comme vous pouvez l'imaginer, cela peut provoquer des exceptions et des bugs ailleurs dans votre application, puisque vous supposez toujours que l'utilisateur a un rôle (ce qui est correct).

Donc, pour résoudre ce problème, nous pouvons utiliser des transactions de base de données. En utilisant des transactions, cela garantit que si une erreur se produit lors de l'exécution du code, toutes les modifications apportées à la base de données à l'intérieur de la transaction seront annulées. Par exemple, si un utilisateur est inséré dans la base de données, mais que la requête visant à attribuer le rôle échoue pour une raison quelconque, la transaction sera annulée et la ligne de l'utilisateur sera supprimée. En faisant cela, cela signifie que nous ne pouvons pas créer d’utilisateurs sans rôles attribués.

En d’autres termes, c’est « tout ou rien ».

Utilisation des transactions de base de données dans Laravel

Maintenant que nous avons une idée simple de ce que sont les transactions et de ce qu'elles implémentent, voyons comment les utiliser dans Laravel.

Dans Laravel, commencer à utiliser des transactions est en fait très simple puisque nous pouvons accéder à la méthode transaction() sur la façade DB. En continuant avec l'exemple de code précédent, voyons comment les transactions sont utilisées lors de la création d'utilisateurs et de leur attribution de rôles. 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;
    }
}

Maintenant, notre code est enveloppé dans une transaction de base de données, si une exception est levée à tout moment, toute modification apportée à la base de données sera rétablie à l'état avant le début de la transaction.

Utilisation manuelle des transactions de base de données dans Laravel

Parfois, vous souhaiterez peut-être un contrôle plus granulaire sur les transactions. Par exemple, disons que vous intégrez un service tiers comme Mailchinp ou Xero. Nous dirions que chaque fois que vous créez un nouvel utilisateur, vous devez également envoyer une requête HTTP à son API pour le créer également en tant qu'utilisateur dans ce système. 🎜🎜Nous souhaiterons peut-être mettre à jour notre code afin que si nous ne parvenons pas à créer un utilisateur dans notre propre système ** et ** dans un système tiers, aucun des deux systèmes ne crée l'utilisateur. Si vous interagissez avec un système tiers, vous disposez probablement d’une classe que vous pouvez utiliser pour effectuer des requêtes. Alternativement, il peut exister un package que vous pouvez utiliser. Parfois, lorsque certaines requêtes ne peuvent pas être complétées, la classe requérante peut lever une exception. Cependant, certaines de ces classes peuvent éliminer l'erreur et renvoyer simplement false à partir de la méthode que vous appelez, en plaçant l'erreur dans un champ de la classe. 🎜🎜Supposons donc que nous ayons l'exemple de classe de base suivant qui appelle l'API : 🎜

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());

🎜 Bien sûr, le code de la classe de requête ci-dessus est incomplet, et mon exemple de code ci-dessous n'est pas très clair non plus, mais il devrait vous donner une idée générale l'idée de ce que je fais mérite d'être exprimée. Utilisons donc cette classe de requête et ajoutons-la à notre exemple de code précédent : 🎜

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');
    }
});

🎜 En regardant le code ci-dessus, nous pouvons voir que nous démarrons une transaction, créons l'utilisateur et lui attribuons un rôle, puis nous créons un service tiers. a été appelé. Si l'utilisateur est créé avec succès dans le service externe, nous pouvons valider en toute sécurité les modifications de la base de données en sachant que tout a été créé correctement. Cependant, si l'utilisateur n'est pas créé dans le service externe, les modifications apportées à la base de données sont annulées (l'utilisateur et ses attributions de rôle sont supprimés), puis une erreur est signalée. 🎜

与第三方服务交互的技巧

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

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

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

所以，我总是建议把数据库调用放在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视频教程】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!