Meneroka Suntikan Ketergantungan dengan Objek Malas dalam PHP 8.4

Dalam bidang PHP moden, keluaran versi 8.4 memperkenalkan ciri terobosan: Lazy Objects. Objek ini membolehkan cara baharu untuk menangguhkan permulaan sehingga benar-benar diperlukan, meningkatkan prestasi dan mengurangkan penggunaan sumber. Fungsi ini disepadukan secara mendalam ke dalam bahasa melalui peningkatan pada ReflectionClass API, seperti yang digariskan dalam Lazy Initialization for Lazy Objects RFC.

Contoh daripada RFC
Untuk menggambarkan potensi Lazy Objects, pertimbangkan contoh berikut secara langsung RFC:

class MyClass
{
    public function __construct(private int $foo)
    {
        // Heavy initialization logic here.
    }

    // ...
}

$initializer = static function (MyClass $ghost): void {
    $ghost->__construct(123);
};

$reflector = new ReflectionClass(MyClass::class);
$object = $reflector->newLazyGhost($initializer);

// At this point, $object is a lazy ghost object.

Mekanisme ini membolehkan pembangun mengawal proses permulaan dengan teliti, memastikan sumber hanya dimuatkan apabila diakses.

Diinspirasikan oleh RFC ini, saya berhasrat untuk membina Bekas Suntikan Ketergantungan yang serasi dengan PSR-11, memanfaatkan API Lazy Objects untuk prestasi optimum.

Asas ContainerLazyObject

Inti bekas kami terletak pada kelas ContainerLazyObject. Dengan itu, anda boleh mendaftar kebergantungan dan memulakannya dengan malas, bermakna ia hanya digunakan apabila benar-benar diperlukan. Berikut ialah kaedah utama yang melaksanakan tugas ini:

public function set(string $id, object|string $concrete): void
{
    $reflector = new ReflectionClass($id);
    $initializer = $concrete;

    if (is_string($concrete)) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete($this);
        };
    }

    if (is_object($concrete) && !$concrete instanceof Closure) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete;
        };
    }

    $this->instances[$id] = $reflector->newLazyGhost($initializer);
}

Mendaftar Perkhidmatan dalam Bekas

Kontena kami menyokong pelbagai cara untuk mendaftarkan perkhidmatan, menawarkan fleksibiliti kepada pembangun. Berikut ialah beberapa contoh:

$container = new ContainerLazyObject();
$containerer->set(DatabaseService::class, fn() => new DatabaseService(new LoggerService()));
$container->set(LoggerService::class, fn() => new LoggerService());

// Alternative approach with class names
$container->set(DatabaseService::class, DatabaseService::class);
$containerr->set(LoggerService::class, LoggerService::class);

// Using already instantiated objects
$container->set(DatabaseService::class, new DatabaseService(new LoggerService()));
$container->set(LoggerService::class, new LoggerService());

Fleksibiliti ini menjadikan ContainerLazyObject boleh disesuaikan dengan pelbagai senario, sama ada membina kebergantungan secara dinamik atau menggunakan semula objek prakonfigurasi.

Mengambil semula Perkhidmatan daripada Bekas
Setelah perkhidmatan didaftarkan dalam bekas, anda boleh mendapatkannya semula apabila diperlukan. Bekas memastikan bahawa perkhidmatan dibuat secara malas, jadi mereka tidak akan dibuat sehingga benar-benar diminta. Berikut ialah contoh cara untuk mendapatkan semula perkhidmatan berdaftar:

// Retrieving the services from the container
$loggerService = $container->get(LoggerService::class);
$databaseService = $container->get(DatabaseService::class);

Teras ContainerLazyObject Inti kontena kami terletak pada kelas ContainerLazyObject. Dengan itu, anda boleh mendaftar kebergantungan dan memulakannya dengan malas, bermakna ia hanya dibuat apabila ia benar-benar digunakan. Berikut ialah kaedah utama yang melaksanakan tugas ini:

public function set(string $id, object|string $concrete): void
{
    $reflector = new ReflectionClass($id);
    $initializer = $concrete;

    if (is_string($concrete)) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete($this);
        };
    }

    if (is_object($concrete) && !$concrete instanceof Closure) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete;
        };
    }

    $this->instances[$id] = $reflector->newLazyGhost($initializer);
}

Keserasian PSR-11

Kelebihan tambahan ContainerLazyObject ialah keserasiannya dengan PSR-11, standard PHP untuk bekas suntikan kebergantungan. Ini memastikan kesalingoperasian dengan perpustakaan dan rangka kerja mengikut spesifikasi, menjadikannya penyelesaian yang ringan dan universal.

Perbandingan Prestasi dengan Bekas Lain

Untuk mengukur prestasi bekas kami, saya menggunakan PhpBench dalam persekitaran terkawal, membandingkannya dengan alternatif popular: Pimple, Illuminate dan PHP-DI. Hasilnya memberangsangkan:

class MyClass
{
    public function __construct(private int $foo)
    {
        // Heavy initialization logic here.
    }

    // ...
}

$initializer = static function (MyClass $ghost): void {
    $ghost->__construct(123);
};

$reflector = new ReflectionClass(MyClass::class);
$object = $reflector->newLazyGhost($initializer);

// At this point, $object is a lazy ghost object.

Bekas kami menunjukkan prestasi cemerlang, jauh lebih pantas daripada alternatif yang lebih mantap seperti Kontena Illuminate dan PHP-DI dalam senario penyelesaian pergantungan yang mudah.

Kelas Lengkap

public function set(string $id, object|string $concrete): void
{
    $reflector = new ReflectionClass($id);
    $initializer = $concrete;

    if (is_string($concrete)) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete($this);
        };
    }

    if (is_object($concrete) && !$concrete instanceof Closure) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete;
        };
    }

    $this->instances[$id] = $reflector->newLazyGhost($initializer);
}

Kesimpulan

PHP 8.4 dan Lazy Objectsnya telah membuka kemungkinan baharu untuk memudahkan dan mengoptimumkan suntikan pergantungan. ContainerLazyObject kami, selain ringan, cekap dan fleksibel, mematuhi PSR-11, memastikan kesalingoperasian dengan perpustakaan dan rangka kerja lain.

Cuba pendekatan ini dan lihat cara ia boleh memudahkan pengurusan pergantungan dalam projek anda yang seterusnya!

Atas ialah kandungan terperinci Membina Bekas Suntikan Ketergantungan Serasi PSR dengan PHP Lazy Objects. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!