Traitement des transactions distribuées à l'aide des services RPC construits avec TP6 Think-Swoole

Utilisez les services RPC construits avec TP6 Think-Swoole pour implémenter le traitement des transactions distribuées

Les systèmes distribués sont de plus en plus courants dans les applications Internet modernes. Cependant, le traitement des transactions distribuées constitue un défi pour assurer la cohérence dans un environnement distribué. Lorsqu’il s’agit d’une logique métier complexe sur plusieurs services, il est particulièrement important de garantir la cohérence et la fiabilité des données.

Dans cet article, nous utiliserons ThinkPHP 6 et Swoole pour créer un service RPC (Remote Procedure Call, appel de procédure à distance) et implémenter le traitement des transactions distribuées via ce service. Nous expliquerons comment créer un service RPC de base et montrerons comment effectuer des opérations de transaction via celui-ci.

1. Aperçu de l'architecture

Nous utiliserons l'architecture suivante pour implémenter le traitement des transactions distribuées :

• Application principale (client) : il s'agit de notre application principale, responsable du traitement de la logique métier et du traitement des transactions distribuées.
• Sous-application (Serveur) : Il s'agit de notre fournisseur de services RPC et est responsable de la réception et de l'exécution des demandes d'appels à distance.
• Base de données : nous utilisons MySQL comme moteur de stockage de base de données.

2. Installez ThinkPHP 6

Tout d'abord, nous devons installer ThinkPHP 6. L'installation peut être effectuée via Composer, exécutez la commande suivante :

composer create-project topthink/think=6.* myproject

3. Installer l'extension Swoole

Pour utiliser le plug-in Swoole de ThinkPHP, nous devons également installer l'extension Swoole. Le guide d’installation est disponible sur le site officiel de Swoole.

4. Configuration du plugin Swoole

Dans ThinkPHP 6, le plugin Swoole est fourni sous forme d'extension. Nous devons le configurer dans le fichier de configuration de l'application config/app.php. Recherchez l'extrait de code suivant : config/app.php中进行配置。找到以下代码段：

return [
    // ...
    'ext' => [
        // ...
    ],
    // ...
];

在ext数组中加入thinkswooleSwoole即可，如下所示：

return [
    // ...
    'ext' => [
        thinkswooleSwoole::class,
    ],
    // ...
];

5. 创建RPC服务

在ThinkPHP 6中，我们可以使用中间件来实现RPC服务。创建一个新的中间件类，在app/middleware目录下创建一个名为RpcMiddleware.php的文件，并在其中编写以下代码：

<?php

namespace appmiddleware;

use SwooleCoroutine;
use thinkswoolepcserverResponse;
use thinkswoolepcserverReceiveContext;
use thinkswooleRpc;

class RpcMiddleware
{
    public function handle(ReceiveContext $context, Closure $next)
    {
        // 执行远程过程调用
        $response = new Response();
        $rpc = new Rpc();
        $rpc->dispatch($context->getRaw(), $response);
        // 获取执行结果
        $result = $response->getMessage();

        if ($response->getCode() === Rpc::RESULT_CODE_SUCCESS) {
            // 执行成功，将结果返回给客户端
            $context->reply($result);
        } else {
            // 出现错误，设置错误代码和消息
            $context->setCode($response->getCode());
            $context->setMessage($response->getMessage());
        }

        return $next($context);
    }
}

6. 配置RPC服务

在ThinkPHP 6中，我们可以通过配置文件来定义中间件。打开config/middleware.php文件，并添加要使用的中间件类，如下所示：

return [
    // ...
    // rpc服务中间件
    appmiddlewareRpcMiddleware::class,
];

然后，我们需要在config/swoole.php文件中进行一些额外的配置。找到以下代码段：

return [
    // ...
    'rpc' => [
        // ...
    ],
    // ...
];

在rpc数组中添加以下代码：

return [
    // ...
    'rpc' => [
        'server' => [
            // 绑定服务地址和端口
            'host' => '127.0.0.1',
            'port' => 9502,
        ],
        'services' => [
            // 注册服务
            'AppRpcServicesTransactionService',
        ],
    ],
    // ...
];

7. 创建事务服务

我们将创建一个名为TransactionService的服务类，用于处理分布式事务。在app/rpc/services目录下创建一个名为TransactionService.php的文件，并在其中编写以下代码：

<?php

namespace apppcservices;

use thinkswoolepcRequest;
use thinkswoolepcResponse;

class TransactionService
{
    public function beginTransaction(Request $request, Response $response)
    {
        // 执行事务开始操作
        // ...

        $response->setCode(Response::CODE_SUCCESS);
        $response->setMessage('事务开始成功');
    }

    public function commit(Request $request, Response $response)
    {
        // 执行事务提交操作
        // ...

        $response->setCode(Response::CODE_SUCCESS);
        $response->setMessage('事务提交成功');
    }

    public function rollback(Request $request, Response $response)
    {
        // 执行事务回滚操作
        // ...

        $response->setCode(Response::CODE_SUCCESS);
        $response->setMessage('事务回滚成功');
    }
}

8. 调用RPC服务

最后，我们将在主应用中调用RPC服务来执行分布式事务处理。创建一个新的控制器类，在app/controller目录下创建一个名为TransactionController.php的文件，并在其中编写以下代码：

<?php

namespace appcontroller;

use thinkacadeRpc;
use thinkswoolepcRequest;

class TransactionController
{
    public function beginTransaction()
    {
        // 创建RPC请求
        $request = new Request();
        $request->setService('AppRpcServicesTransactionService');
        $request->setMethod('beginTransaction');

        // 发起远程调用
        $result = Rpc::call($request);

        // 处理返回结果
        if ($result->getCode() === 200) {
            // 操作成功
            return '事务开始成功';
        } else {
            // 操作失败
            throw new Exception($result->getMessage(), $result->getCode());
        }
    }

    public function commit()
    {
        // 创建RPC请求
        $request = new Request();
        $request->setService('AppRpcServicesTransactionService');
        $request->setMethod('commit');

        // 发起远程调用
        $result = Rpc::call($request);

        // 处理返回结果
        if ($result->getCode() === 200) {
            // 操作成功
            return '事务提交成功';
        } else {
            // 操作失败
            throw new Exception($result->getMessage(), $result->getCode());
        }
    }

    public function rollback()
    {
        // 创建RPC请求
        $request = new Request();
        $request->setService('AppRpcServicesTransactionService');
        $request->setMethod('rollback');

        // 发起远程调用
        $result = Rpc::call($request);

        // 处理返回结果
        if ($result->getCode() === 200) {
            // 操作成功
            return '事务回滚成功';
        } else {
            // 操作失败
            throw new Exception($result->getMessage(), $result->getCode());
        }
    }
}

9. 测试RPC服务

现在我们可以使用浏览器或其他HTTP客户端测试我们的RPC服务了。在浏览器中访问/transaction/beginTransaction，/transaction/commit和/transaction/rollbackrrreee

rrreee

Créer un service RPC🎜 🎜🎜Dans ThinkPHP 6, nous pouvons utiliser un middleware pour implémenter les services RPC. Créez une nouvelle classe middleware, créez un fichier nommé RpcMiddleware.php dans le répertoire app/middleware et écrivez-y le code suivant : 🎜rrreee
🎜Configurer le service RPC🎜🎜🎜Dans ThinkPHP 6, nous pouvons définir un middleware via des fichiers de configuration. Ouvrez le fichier config/middleware.php et ajoutez la classe middleware que vous souhaitez utiliser comme indiqué ci-dessous : 🎜rrreee🎜 Ensuite, nous devons ajouter le fichier dans le config/swoole.php fichier Effectuez une configuration supplémentaire. Recherchez l'extrait de code suivant : 🎜rrreee🎜Ajoutez le code suivant dans le tableau <code>rpc : 🎜rrreee
🎜Créer un service de transaction🎜🎜🎜Nous allons créer une classe de service appelée TransactionService. , utilisé pour traiter les transactions distribuées. Créez un fichier nommé TransactionService.php dans le répertoire app/rpc/services et écrivez-y le code suivant : 🎜rrreee
🎜 Appel du Service RPC🎜🎜🎜Enfin, nous appellerons le service RPC dans l'application principale pour effectuer le traitement des transactions distribuées. Créez une nouvelle classe de contrôleur, créez un fichier nommé TransactionController.php dans le répertoire app/controller et écrivez-y le code suivant : 🎜rrreee
🎜Test du service RPC🎜🎜🎜Nous pouvons désormais tester notre service RPC à l'aide d'un navigateur ou d'un autre client HTTP. Accédez aux routes /transaction/beginTransaction, /transaction/commit et /transaction/rollback dans le navigateur pour déclencher le démarrage des transactions dans le RPC service respectivement, les opérations de validation et de restauration. Si l’opération réussit, vous verrez le message Operation Success. 🎜🎜Il s'agit du processus de base de mise en œuvre du traitement des transactions distribuées à l'aide du service RPC construit par TP6 Think-Swoole. Grâce aux services RPC, nous pouvons gérer des opérations de transaction complexes dans un environnement distribué et garantir la cohérence et la fiabilité des données. 🎜

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!