Eine kurze Analyse der korrekten Methode zum Aufrufen von Systembefehlen in PHP-Anwendungen

Manchmal müssen Sie in PHP-Anwendungen Befehle auf Betriebssystemebene verwenden. Schauen wir uns an, wie wir das machen und sehen, ob wir das Entwicklererlebnis verbessern können.

In den letzten Jahren habe ich mich auf jeden Aspekt der Art und Weise konzentriert, wie ich Code schreibe und wie ich ihn verbessern kann. Ich habe zunächst untersucht, wie die Integration mit HTTP besser und objektorientierter gestaltet werden kann. Ich glaube, ich habe einen Weg gefunden, dies zu erreichen, und jetzt konzentriere ich meine Aufmerksamkeit auf etwas anderes. [Verwandte Empfehlungen: Laravel-Video-Tutorial]

In manchen Fällen möchten Sie die OS-CLI in Ihrer Anwendung verwenden. In einer Webanwendung oder einer anderen CLI-Anwendung. In der Vergangenheit haben wir Methoden wie exec oder passthru oder shell_exec und system verwendet. Dann kam die Symfony Process-Komponente und wir waren gerettet. 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

Die Symfony-Prozesskomponente erleichtert die Integration in Betriebssystemprozesse und die Ausgabe. Aber wie wir diese Bibliothek integrieren, ist immer noch etwas frustrierend. Wir erstellen einen neuen Prozess und übergeben eine Reihe von Argumenten für den Befehl, den wir ausführen möchten. Werfen wir einen Blick darauf:

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

Was ist an diesem Ansatz falsch? Na ja, ehrlich gesagt, nichts. Aber gibt es eine Möglichkeit, das Entwicklererlebnis zu verbessern? Nehmen wir an, wir wechseln von Git zu SVN (was ich wahrscheinlich nicht weiß).

Um die Entwicklererfahrung zu verbessern, müssen wir zunächst die Komponenten verstehen, die logisch zum Erstellen von Betriebssystembefehlen verwendet werden. Wir können sie unterteilen in:

• Ausführbare Dateien
• Parameter

Unsere ausführbare Datei ist etwas, mit dem wir direkt interagieren, wie PHP, Git, Brew oder irgendetwas anderes andere installierte Binärdatei auf unserem System. Das Argument ist dann, wie wir interagieren; dies können Unterbefehle, Optionen, Flags oder Parameter sein.

Wenn wir also ein wenig abstrahieren, haben wir einen Prozess und einen Befehl, die Parameter akzeptieren. Wir werden Schnittstellen/Verträge verwenden, um unsere Komponenten zu definieren und zu steuern, wie unser Workflow funktionieren soll. Beginnen wir mit dem Prozessvertrag:

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

$result = $command->run();

Was wir hier sagen ist, dass jeder Prozess erstellt werden kann und das Ergebnis des erstellten Prozesses ein Symfony-Prozess sein sollte. Unser Prozess sollte einen Befehl erstellen, den wir ausführen können. Schauen wir uns nun unseren Befehlsvertrag an: 🎜rrreee🎜 Das Wichtigste, was wir von dem Befehl erwarten, ist, dass er ihn als Parameter zurückgeben kann, die wir als Befehl an Symfony übergeben können Verfahren. 🎜🎜Genug der Ideen, schauen wir uns ein Beispiel aus der Praxis an. Wir verwenden Git als Beispiel, da die meisten von uns mit dem Git-Befehl vertraut sein sollten. 🎜🎜Erstellen wir zunächst einen Git-Prozess, der den Prozessvertrag implementiert, den wir gerade beschrieben haben: 🎜rrreee🎜 Unser Prozess implementiert den Vertrag und verfügt über ein Befehlsattribut, das wir verwenden werden, damit unser Prozess reibungslos erstellt und ausgeführt werden kann. Wir haben eine Funktion, die es uns ermöglicht, uns auf die Art und Weise zu konzentrieren, wie wir Dinge für unseren Git-Prozess erstellen und erstellen. Werfen wir einen Blick darauf: 🎜rrreee🎜 Unser Trait zeigt also die Umsetzung des Prozessvertrags selbst und gibt Anweisungen zum Aufbau des Prozesses. Es enthält auch eine Methode, die es uns ermöglicht, den Build-Befehl zu abstrahieren. 🎜🎜Bis jetzt können wir einen Prozess erstellen und einen potenziellen Befehl aufbauen. Allerdings haben wir den Auftrag noch nicht erteilt. Wir erstellen einen neuen Git-Befehl im Trait und verwenden dabei die Git-Klasse als Typ. Schauen wir uns eine andere Git-Klasse an, bei der es sich um eine Aufzählung handelt. Ich zeige jedoch eine abgespeckte Version – im Wesentlichen möchten Sie, dass sie allen Git-Unterbefehlen zugeordnet wird, die Sie unterstützen möchten: 🎜rrreee🎜 Dann übergeben wir sie an den Git-Befehl: 🎜rrreee🎜 In dieser Klasse akzeptieren wir die Anfrage aus Prozessparametern, die derzeit von unserem HandledGitCommands-Merkmal verarbeitet werden. Wir können dies dann in einen Parameter umwandeln, den der Symfony-Prozess verstehen kann. Wir verwenden den ExecutableFinder aus dem Symfony-Paket, um Fehler im Pfad zu minimieren. Allerdings möchten wir auch eine Ausnahme auslösen, wenn die ausführbare Datei nicht gefunden wird. 🎜🎜Wenn wir sie in unseren Git-Prozess einfügen, sieht es ungefähr so ​​aus: 🎜rrreee🎜Jetzt müssen wir nur noch den Code selbst ausführen, damit wir Git gut in unserer PHP-Anwendung verwenden können: 🎜rrreee🎜Das Ergebnis von Mit der Push-Methode können Sie mit dem Symfony-Prozess interagieren – das heißt, Sie können die gesamte Sortierung mithilfe von Befehlen am anderen Ende durchführen. Das Einzige, was wir geändert haben, war, einen objektorientierten Wrapper rund um die Erstellung dieses Prozesses zu erstellen. Dies ermöglicht es uns, den Kontext gut zu entwickeln und zu pflegen und Dinge testbar und skalierbar zu erweitern. 🎜🎜Wie oft verwenden Sie Betriebssystembefehle in Anwendungen? Können Sie sich Anwendungsfälle vorstellen? Ich habe den Beispielcode 🎜in einem Repository auf GitHub veröffentlicht 🎜, damit Sie damit herumspielen und sehen können, ob Sie Ihre Betriebssystemintegration verbessern können. 🎜

Ein gutes Beispiel wäre SSH, MySQL oder sogar Anable oder Terraform! Stellen Sie sich vor, Sie könnten MySQL-Dumps von Laravel Artisan nach einem Zeitplan effizient ausführen, ohne ständig ein Paket eines Drittanbieters verwenden zu müssen!

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

Übersetzungsadresse: https://learnku.com/laravel/t/71422

Mehr für Programmierkenntnisse finden Sie unter: Programmiervideo! !

Das obige ist der detaillierte Inhalt vonEine kurze Analyse der korrekten Methode zum Aufrufen von Systembefehlen in PHP-Anwendungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!