Analisis ringkas tentang kaedah yang betul untuk memanggil arahan sistem dalam aplikasi PHP

Kadangkala anda perlu menggunakan arahan tahap sistem pengendalian dalam aplikasi PHP. Mari lihat cara kami melakukan ini dan lihat sama ada kami boleh menjadikan pengalaman pembangun lebih baik.

Sejak beberapa tahun kebelakangan ini, saya telah memfokuskan pada setiap aspek cara saya menulis kod dan cara memperbaikinya. Saya bermula dengan melihat bagaimana untuk menjadikan penyepaduan dengan HTTP lebih baik dan lebih berorientasikan objek. Saya percaya saya telah menemui cara untuk mencapai ini dan kini saya menumpukan perhatian saya ke tempat lain. [Cadangan berkaitan: tutorial video laravel]

Dalam sesetengah kes, anda ingin menggunakan OS CLI dalam aplikasi anda. Dalam aplikasi web atau aplikasi CLI yang lain. Pada masa lalu, kami telah menggunakan sesuatu seperti exec atau passthru atau shell_exec dan system . Kemudian bersama-sama datang komponen Proses Symfony dan kami telah diselamatkan.

Komponen proses Symfony memudahkan untuk disepadukan dengan proses sistem pengendalian dan mendapatkan output. Tetapi cara kami mengintegrasikan dengan perpustakaan ini masih agak mengecewakan. Kami mencipta proses baharu, menghantar pelbagai hujah untuk arahan yang ingin kami jalankan. Mari kita lihat:

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

$command->run();

Apakah yang salah dengan pendekatan ini? Sejujurnya, tiada apa-apa. Tetapi adakah terdapat cara untuk meningkatkan pengalaman pembangun? Katakan kita bertukar dari git ke svn (yang saya tidak mungkin tahu).

Untuk menambah baik pengalaman pembangun, pertama, kita perlu memahami komponen yang secara logik digunakan untuk membuat arahan OS. Kita boleh memecahkannya kepada:

• Boleh laku
• Parameter

Boleh laku kami ialah sesuatu yang kami berinteraksi secara langsung, cth binari lain yang dipasang pada sistem kami. Hujahnya ialah cara kita berinteraksi ini boleh menjadi subperintah, pilihan, bendera atau parameter.

Jadi jika kita abstrak sedikit, kita mempunyai process dan command , yang memerlukan hujah. Kami akan menggunakan antara muka/kontrak untuk menentukan komponen kami untuk mengawal cara aliran kerja kami harus berfungsi. Mari kita mulakan dengan kontrak proses:

declare(strict_types=1);

namespace JustSteveKing\OS\Contracts;

use Symfony\Component\Process\Process;

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

Apa yang kami katakan di sini ialah setiap proses mesti boleh dibina, dan hasil daripada proses yang dibuat haruslah proses Symfony. Proses kita harus membina perintah untuk kita jalankan, jadi sekarang mari kita lihat kontrak arahan kita:

declare(strict_types=1);

namespace JustSteveKing\OS\Contracts;

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

Perkara utama yang kita inginkan daripada arahan itu ialah dapat mengembalikannya sebagai hujah, kita boleh lulus Parameter ini dihantar ke proses Symfony sebagai arahan.

Cukup dengan idea, mari kita lihat contoh kehidupan sebenar. Kami akan menggunakan git sebagai contoh kerana kebanyakan kita sepatutnya dapat mengaitkan dengan arahan git.

Pertama, mari kita buat proses Git yang melaksanakan Kontrak Proses yang baru kami nyatakan:

class Git implements ProcessContract
{
    use HandlesGitCommands;

    private CommandContract $command;
}

Proses kami melaksanakan kontrak dan mempunyai atribut perintah yang akan kami gunakan untuk membenarkan proses kami tersusun dan dilaksanakan dengan lancar. Kami mempunyai ciri yang membolehkan kami menumpukan pada cara kami membina dan membuat sesuatu untuk proses Git kami. Mari kita lihat:

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

Jadi, sifat kami menunjukkan pelaksanaan kontrak proses itu sendiri dan memberikan arahan tentang cara membina proses tersebut. Ia juga mengandungi kaedah yang membolehkan kita mengabstrak arahan binaan.

Setakat ini kita boleh mencipta proses dan membina arahan yang berpotensi. Namun, kami masih belum memberi arahan. Kami mencipta arahan Git baharu dalam sifat, menggunakan kelas Git sebagai jenisnya. Mari lihat kelas Git yang lain, iaitu penghitungan. Walau bagaimanapun, saya akan menunjukkan versi yang dilucutkan - pada asasnya, anda mahu ia dipetakan ke semua subperintah git yang anda ingin sokong:

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

dan kemudian kami menghantarnya ke arahan 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,
        );
    }
}

Dalam kelas ini, kami menerima parameter daripada Proses, yang kini dikendalikan oleh ciri HandledGitCommands kami. Kami kemudiannya boleh mengubahnya menjadi parameter yang boleh difahami oleh proses Symfony. Kami menggunakan ExecutableFinder daripada pakej Symfony untuk meminimumkan ralat dalam laluan. Walau bagaimanapun, kami juga ingin membuang pengecualian jika boleh laku tidak dijumpai.

Apabila kita meletakkannya dalam proses Git kita, ia akan kelihatan seperti ini:

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

Sekarang yang perlu dilakukan hanyalah menjalankan kod itu sendiri supaya kita boleh menggunakan git dengan baik dalam aplikasi PHP:

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

$result = $command->run();

Hasil kaedah Push akan membolehkan anda berinteraksi dengan proses symfony - bermakna anda boleh melakukan semua pengisihan menggunakan arahan di hujung yang lain. Satu-satunya perkara yang kami ubah ialah membina pembalut berorientasikan objek di sekeliling penciptaan proses ini. Ini membolehkan kami membangunkan dan mengekalkan konteks dengan baik dan memanjangkan perkara dengan cara yang boleh diuji dan berskala.

Berapa kerap anda menggunakan arahan sistem pengendalian dalam aplikasi anda? Bolehkah anda memikirkan sebarang kes penggunaan? Saya telah menerbitkan kod sampel dalam repositori di GitHub supaya anda boleh bermain dengannya dan melihat sama ada anda boleh meningkatkan integrasi OS anda.

Contoh yang baik ialah SSH, MySQL, atau juga Anable atau Terraform! Bayangkan jika anda boleh menjalankan pembuangan MySQL dengan cekap dari Laravel Artisan mengikut jadual tanpa perlu menggunakan pakej pihak ketiga sepanjang masa!

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

Alamat terjemahan: https://learnku.com/ laravel/t/71422

Untuk lebih banyak pengetahuan berkaitan pengaturcaraan, sila lawati: Video Pengaturcaraan! !

Atas ialah kandungan terperinci Analisis ringkas tentang kaedah yang betul untuk memanggil arahan sistem dalam aplikasi PHP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!