Une brève analyse de la méthode correcte d'appel des commandes système dans les applications PHP

Parfois, vous devez utiliser des commandes au niveau du système d'exploitation dans les applications PHP. Voyons comment nous procédons et voyons si nous pouvons améliorer l'expérience des développeurs.

Au cours des dernières années, je me suis concentré sur tous les aspects de la façon dont j'écris du code et sur la manière de l'améliorer. J'ai commencé par chercher comment rendre l'intégration avec HTTP meilleure et plus orientée objet. Je crois avoir trouvé un moyen d'y parvenir et maintenant je concentre mon attention ailleurs. [Recommandations associées : Tutoriel vidéo laravel]

Dans certains cas, vous souhaitez utiliser la CLI du système d'exploitation dans votre application. Dans une application Web ou une autre application CLI. Dans le passé, nous avons utilisé des méthodes telles que exec ou passthru ou shell_exec et system. Puis est arrivé le composant Symfony Process et nous avons été sauvés. exec 或 passthru 或 shell_exec 和 system 的方法。然后出现了 Symfony Process 组件，我们得救了。

Symfony 进程组件使得与操作系统进程集成并获得输出变得非常容易。但是我们如何与这个库集成仍然有点令人沮丧。我们创建一个新进程，传入一个参数数组，使我们希望运行的命令。让我们来看看：

$command = new Process(
    command: ['git', 'push', 'origin', 'main'],
);

$command->run();

这种方法有什么问题？好吧，老实说，什么都没有。但是有没有办法改善开发人员的体验？假设我们从 git 切换到 svn（我不太可能知道）。

为了改善开发人员的体验，首先，我们需要了解逻辑上用于创建 OS 命令的组件。我们可以将它们分解为：

• 可执行的
• 参数

我们的可执行文件是我们直接与之交互的东西，例如 php、git、brew 或我们系统上任何其他已安装的二进制文件。然后争论是我们如何互动；这些可以是子命令、选项、标志或参数。

因此，如果我们稍微抽象一下，我们就会有一个process 和一个command ， 它接受参数。我们将使用接口/契约来定义我们的组件来控制我们的工作流程应该如何工作。让我们从流程契约开始：

declare(strict_types=1);

namespace JustSteveKing\OS\Contracts;

use Symfony\Component\Process\Process;

interface ProcessContract
{
    public function build(): Process;
}

我们这里是说每个进程都必须能够被构建，并且创建的进程的结果应该是一个 Symfony 进程。我们的流程应该构建一个命令供我们运行，所以现在让我们看看我们的命令契约：

declare(strict_types=1);

namespace JustSteveKing\OS\Contracts;

interface CommandContract
{
    public function toArgs(): array;
}

我们希望从命令中得到的主要内容是能够作为参数返回，我们可以将这些参数作为命令传递给 Symfony 进程。

想法已经够多了，让我们来看一个真实的例子。我们将使用 git 作为示例，因为我们大多数人应该能够与 git 命令相关联。

首先，让我们创建一个 Git 进程来实现我们刚刚描述的 Process Contract：

class Git implements ProcessContract
{
    use HandlesGitCommands;

    private CommandContract $command;
}

我们的流程实现了合约，并有一个命令属性，我们将使用它允许我们的流程被流畅地构建和执行。我们有一个特点，可以让我们集中精力为我们的 Git 流程构建和制造事物的方式。让我们看一下：

trait HandlesGitCommands
{
    public function build(): Process
    {
        return new Process(
            command: $this->command->toArgs(),
        );
    }

    protected function buildCommand(Git $type, array $args = []): void
    {
        $this->command = new GitCommand(
            type: $type,
            args: $args,
        );
    }
}

因此，我们的 trait 展示了流程契约本身的实现，并提供了有关如何构建流程的说明。它还包含一个允许我们抽象构建命令的方法。

到目前为止，我们可以创建一个流程并建立一个潜在的命令。但是，我们还没有下达命令。我们在 trait 中创建一个新的 Git 命令，它使用 Git 类作为类型。让我们看看另一个 Git 类，它是一个枚举。不过，我将展示一个精简版本 - 实际上，你希望它映射到你希望支持的所有 git 子命令：

enum Git: string
{
    case PUSH = 'push';
    case COMMIT = 'commit';
}

然后我们将它传递给 Git 命令：

final class GitCommand implements CommandContract
{
    public function __construct(
        public readonly Git $type,
        public readonly array $args = [],
        public readonly null|string $executable = null,
    ) {
    }

    public function toArgs(): array
    {
        $executable = (new ExecutableFinder())->find(
            name: $this->executable ?? 'git',
        );

        if (null === $executable) {
            throw new InvalidArgumentException(
                message: "Cannot find executable for [$this->executable].",
            );
        }

        return array_merge(
            [$executable],
            [$this->type->value],
            $this->args,
        );
    }
}

在这个类中，我们接受来自 Process 的参数，当前由我们的 HandledGitCommands trait 处理。然后我们可以把它变成 Symfony 进程可以理解的参数。我们使用 Symfony 包中的 ExecutableFinder

Le composant de processus Symfony facilite grandement l'intégration aux processus du système d'exploitation et l'obtention de résultats. Mais la façon dont nous intégrons cette bibliothèque est encore un peu frustrante. Nous créons un nouveau processus, en transmettant un tableau d'arguments pour la commande que nous souhaitons exécuter. Jetons un coup d'oeil :

use JustSteveKing\OS\Commands\Types\Git as SubCommand;

class Git implements ProcessContract
{
    use HandlesGitCommands;

    private CommandContract $command;

    public function push(string $branch): Process
    {
        $this->buildCommand(
            type: SubCommand:PUSH,
            args: [
                'origin',
                $branch,
            ],
        );

        return $this->build();
    }
}

Qu'est-ce qui ne va pas avec cette approche ? Eh bien, honnêtement, rien. Mais existe-t-il un moyen d’améliorer l’expérience des développeurs ? Disons que nous passons de git à svn (ce que je ne connais probablement pas).

Pour améliorer l'expérience du développeur, nous devons d'abord comprendre les composants qui sont logiquement utilisés pour créer des commandes du système d'exploitation. Nous pouvons les décomposer en :

• Exécutables
• Paramètres

Notre exécutable est quelque chose avec lequel nous interagissons directement, comme php , git, Brew ou tout autre autre binaire installé sur notre système. L’argument est alors la manière dont nous interagissons ; il peut s’agir de sous-commandes, d’options, d’indicateurs ou de paramètres.

Donc, si on fait un peu d'abstraction, nous avons un processus et une commande, qui acceptent des paramètres. Nous utiliserons des interfaces/contrats pour définir nos composants afin de contrôler le fonctionnement de notre flux de travail. Commençons par le contrat de processus :

$git = new Git();
$command = $git->push(
    branch: 'main',
);

$result = $command->run();

Ce que nous disons ici, c'est que chaque processus doit pouvoir être construit, et que le résultat du processus créé doit être un processus Symfony. Notre processus devrait créer une commande que nous pouvons exécuter, alors regardons maintenant notre contrat de commande : 🎜rrreee🎜 La principale chose que nous attendons de la commande est de pouvoir la renvoyer sous forme de paramètres, que nous pouvons transmettre à Symfony en tant que commande. processus. 🎜🎜Assez avec les idées, regardons un exemple concret. Nous utiliserons git comme exemple puisque la plupart d'entre nous devraient être capables de s'identifier à la commande git. 🎜🎜Tout d'abord, créons un processus Git qui implémente le contrat de processus que nous venons de décrire : 🎜rrreee🎜 Notre processus implémente le contrat et possède un attribut de commande que nous utiliserons pour permettre à notre processus d'être construit et exécuté en douceur. Nous disposons d'une fonctionnalité qui nous permet de nous concentrer sur la façon dont nous construisons et réalisons les éléments de notre processus Git. Jetons un coup d'oeil : 🎜rrreee🎜 Notre trait montre donc la mise en œuvre du contrat de processus lui-même et fournit des instructions sur la façon de construire le processus. Il contient également une méthode qui nous permet d'abstraire la commande build. 🎜🎜Jusqu'à présent, nous pouvons créer un processus et construire une commande potentielle. Cependant, nous n’avons pas encore donné l’ordre. Nous créons une nouvelle commande Git dans le trait, en utilisant la classe Git comme type. Regardons une autre classe Git, qui est une énumération. Cependant, je vais montrer une version allégée - essentiellement, vous voulez qu'elle soit mappée à toutes les sous-commandes git que vous souhaitez prendre en charge : 🎜rrreee🎜 Ensuite, nous la transmettons à la commande Git : 🎜rrreee🎜 Dans cette classe, nous acceptons la demande à partir des paramètres de processus, actuellement gérés par notre trait HandledGitCommands. Nous pouvons ensuite transformer cela en un paramètre que le processus Symfony peut comprendre. Nous utilisons le ExecutableFinder du package Symfony pour minimiser les erreurs dans le chemin. Cependant, nous souhaitons également lever une exception si l'exécutable n'est pas trouvé. 🎜🎜Quand nous les mettons dans notre processus Git, cela ressemble un peu à ceci : 🎜rrreee🎜Il ne nous reste plus qu'à exécuter le code lui-même pour que nous puissions bien utiliser git dans notre application PHP : 🎜rrreee🎜Le résultat de la méthode Push vous permettra d'interagir avec le processus symfony, ce qui signifie que vous pourrez effectuer tous les tris à l'aide de commandes à l'autre extrémité. La seule chose que nous avons changée a été de créer un wrapper orienté objet autour de la création de ce processus. Cela nous permet de bien développer et maintenir le contexte et d'étendre les choses de manière testable et évolutive. 🎜🎜À quelle fréquence utilisez-vous les commandes du système d'exploitation dans les applications ? Pouvez-vous penser à des cas d’utilisation ? J'ai 🎜publié l'exemple de code 🎜 dans un référentiel sur GitHub afin que vous puissiez jouer avec et voir si vous pouvez améliorer l'intégration de votre système d'exploitation. 🎜

Un bon exemple serait SSH, MySQL, ou même Anable ou Terraform ! Imaginez si vous pouviez exécuter efficacement des dumps MySQL à partir de Laravel Artisan selon un calendrier sans avoir à utiliser des packages tiers à tout moment !

Adresse originale : https://laravel-news.com/working-with-os-process-in-php

Adresse de traduction : https://learnku.com/laravel/t/71422

Plus pour connaissances liées à la programmation, veuillez visiter : Vidéo de programmation ! !

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!