Anotasi tersuai anda sendiri - lebih daripada sekadar komen!

anotasi adat php: fleksibiliti dan skalabiliti kod yang dipertingkatkan

Artikel ini membincangkan cara membuat dan menggunakan anotasi tersuai dalam aplikasi Symfony 3. Anotasi adalah blok dokumen metadata/konfigurasi yang kita lihat di atas kelas, kaedah dan sifat. dan akses kepada kaedah. Artikel ini akan menerangkan cara menyesuaikan anotasi dan membaca maklumat kelas atau kaedah tanpa memuatkan kelas. @Route() @ORM()

Mata utama:

Anotasi adat PHP boleh digunakan untuk menambah metadata ke kod, yang mempengaruhi tingkah laku kod, menjadikannya lebih fleksibel dan mudah disesuaikan. Mereka boleh digunakan untuk menentukan maklumat penghalaan, menentukan peraturan pengesahan, atau mengkonfigurasi suntikan ketergantungan.

• Mewujudkan anotasi adat PHP memerlukan menentukan kelas baru untuk mewakili anotasi. Kelas ini sepatutnya mempunyai sifat yang sepadan dengan nilai yang anda mahu tetapkan dalam anotasi.
• Doktrin menyokong anotasi tersuai. Anda boleh menentukan anotasi anda sendiri dan menggunakannya dalam entiti doktrin. Pembaca Anotasi Doktrin menghuraikan anotasi ini dan kemudian boleh menggunakannya untuk mempengaruhi tingkah laku entiti.
• Satu batasan menggunakan anotasi adat PHP ialah mereka tidak disokong secara asli oleh bahasa itu sendiri. Ini bermakna anda perlu menggunakan perpustakaan atau alat yang menyediakan sokongan anotasi, seperti doktrin atau php-di.
• Anotasi Custom PHP mempunyai pelbagai kegunaan, termasuk menentukan maklumat penghalaan dalam aplikasi web, menentukan peraturan pengesahan untuk input borang, atau mengkonfigurasi suntikan pergantungan. Mereka juga boleh digunakan untuk menambah dokumentasi ke kod anda.

Penafian:

Anotasi tidak ada kaitan dengan Symfony, ia adalah konsep yang dibangunkan sebagai sebahagian daripada projek doktrin untuk menyelesaikan masalah pemetaan maklumat ORM kepada kaedah kelas.

Artikel ini akan membina satu bundle yang boleh diguna semula yang dipanggil Workerbundle (untuk tujuan demonstrasi sahaja, tidak benar -benar boleh dibungkus). Kami akan membangunkan konsep kecil yang membolehkan anda menentukan pelbagai jenis pekerja yang "berjalan" pada kelajuan yang berbeza, yang kemudiannya boleh digunakan oleh sesiapa sahaja dalam aplikasi. Operasi pekerja sebenar berada di luar skop artikel ini, kerana kami bimbang dengan menubuhkan sistem yang menguruskannya (dan menemui mereka melalui anotasi).

anda boleh melihat

repositori ini

dan sediakan bundle dalam aplikasi Symfony tempatan anda seperti yang diterangkan di dalamnya.

Pekerja

Pekerja akan melaksanakan antara muka yang memerlukan kaedah: . Di Workerbundle baru, mari kita buat direktori

untuk memastikan ia kemas dan tambahkan antara muka:

::work() Workers/

Anotasi

<?php
namespace WorkerBundle\Workers;

interface WorkerInterface
{
    /**
     * 执行工作
     *
     * @return NULL
     */
    public function work();
}

Setiap pekerja mesti melaksanakan antara muka di atas. Sangat jelas. Tetapi di luar itu, kami juga memerlukan mereka untuk mempunyai penjelasan di atas kelas untuk mencari mereka dan membaca beberapa metadata tentang mereka.

Peta doktrin dokumen anotasi blok ke kelas yang sifatnya mewakili kunci di dalam anotasi itu sendiri. Mari buat anotasi kita sendiri dan lakukannya.

Setiap contoh WorkerInterface akan mempunyai penjelasan berikut dalam blok dokumennya:

<?php
namespace WorkerBundle\Workers;

interface WorkerInterface
{
    /**
     * 执行工作
     *
     * @return NULL
     */
    public function work();
}

Kami akan menyimpannya mudah, dengan hanya dua sifat: nama unik (rentetan) dan kelajuan pekerja (integral). Agar perpustakaan anotasi doktrin untuk mengenali penjelasan ini, kita mesti membuat kelas yang sepadan, yang, seperti yang dijangkakan, mempunyai beberapa anotasi sendiri.

kami meletakkan kelas ini dalam folder anotasi ruang nama bundle dan hanya menamakannya pekerja:

/**
 * @Worker(
 *     name = "唯一的Worker名称",
 *     speed = 10
 * )
 */

Seperti yang anda lihat, kami mempunyai dua sifat dan beberapa kaedah getter yang mudah. Lebih penting lagi, kami mempunyai dua anotasi di bahagian atas: @Annotation (Beritahu doktrin kelas sedemikian untuk mewakili anotasi) dan @Target("CLASS") (memberitahu ia harus digunakan di atas seluruh kelas dan bukannya di atas kaedah atau harta). Itu sahaja, kelas WorkerInterface kini boleh menggunakan anotasi ini dengan memastikan bahawa kelas yang sepadan diimport menggunakan pernyataan use di bahagian atas fail:

<?php
namespace WorkerBundle\Annotation;

use Doctrine\Common\Annotations\Annotation;

/**
 * @Annotation
 * @Target("CLASS")
 */
class Worker
{
    /**
     * @Required
     *
     * @var string
     */
    public $name;

    /**
     * @Required
     *
     * @var int
     */
    public $speed;

    /**
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @return int
     */
    public function getSpeed()
    {
        return $this->speed;
    }
}

Pengurus

Seterusnya, kami memerlukan pengurus yang boleh digunakan oleh aplikasi kami untuk mendapatkan senarai semua pekerja yang ada dan menciptanya. Di ruang nama yang sama seperti WorkerInterface, kita boleh menggunakan kelas Pengurus Mudah ini:

use WorkerBundle\Annotation\Worker;

Discoverer

Bahagian utama demonstrasi anotasi kami sebenarnya adalah sebahagian daripada proses penemuan. Kenapa? Kerana kita menggunakan anotasi pekerja untuk menentukan sama ada kelas yang sepadan harus dianggap sebagai pekerja. Dalam proses ini, kami menggunakan metadata sebelum benar -benar meneliti objek. Mari kita lihat kelas Workerdiscovery kami:

<?php
namespace WorkerBundle\Workers;

class WorkerManager
{
    // ... (代码与原文相同) ...
}

Connect

Sekarang kita mempunyai komponen utama, sudah tiba masanya untuk menghubungkan segala -galanya. Pertama, kita memerlukan definisi perkhidmatan, jadi dalam folder sumber/konfigurasi bundle, kita boleh mempunyai fail perkhidmatan.yml ini:

<?php
namespace WorkerBundle\Workers;

// ... (代码与原文相同) ...
}

Agar definisi perkhidmatan kami dijemput secara berpusat oleh bekas, kita perlu menulis kelas lanjutan kecil. Oleh itu, dalam folder DependencyInjection bundle, buat kelas yang dipanggil WorkerExtension. Lokasi dan nama penting bagi Symfony untuk mengambilnya secara automatik.

services:
    worker_manager:
        class: WorkerBundle\Workers\WorkerManager
        arguments: ["@worker_discovery"]
    worker_discovery:
        class: WorkerBundle\Workers\WorkerDiscovery
        arguments: ["%worker_namespace%", "%worker_directory%", "%kernel.root_dir%", "@annotation_reader"]

Akhirnya, kita perlu mendaftarkan bundle kami. Di Appkernel kami:

<?php
namespace WorkerBundle\DependencyInjection;

// ... (代码与原文相同) ...
}

itu sahaja.

Marilah kita bekerja!

Sekarang kita sudah bersedia untuk bekerja. Mari kita konfigurasikan di mana pekerja kami akan ditemui di parameter pusat.yml fail:

public function registerBundles()
{
    return array(
        // ...
        new WorkerBundle\WorkerBundle(),
        // ...
    );
}

Parameter ini diluluskan dari bekas ke kelas Workerdiscovery, seperti yang diterangkan di atas.

Lokasi terpulang kepada anda, tetapi sekarang mari kita letakkan pekerja kami di bundle appbundle utama aplikasinya. Pekerja pertama kami mungkin kelihatan seperti ini:

<?php
namespace WorkerBundle\Workers;

interface WorkerInterface
{
    /**
     * 执行工作
     *
     * @return NULL
     */
    public function work();
}

Anotasi kami ada di sana, pernyataan use ada di tempat, jadi tidak ada yang dapat menghalang beberapa logik perniagaan dari mencarinya dan instantiatingnya. Mari kita anggap bahawa di dalam kaedah pengawal:

/**
 * @Worker(
 *     name = "唯一的Worker名称",
 *     speed = 10
 * )
 */

atau

<?php
namespace WorkerBundle\Annotation;

use Doctrine\Common\Annotations\Annotation;

/**
 * @Annotation
 * @Target("CLASS")
 */
class Worker
{
    /**
     * @Required
     *
     * @var string
     */
    public $name;

    /**
     * @Required
     *
     * @var int
     */
    public $speed;

    /**
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @return int
     */
    public function getSpeed()
    {
        return $this->speed;
    }
}

Kesimpulan

kita kini boleh menggunakan anotasi untuk menyatakan metadata mengenai kelas (atau kaedah dan sifat). Dalam tutorial ini, kami membina satu pakej kecil yang membolehkan aplikasi (atau berkas luaran lain) untuk mengisytiharkan pekerja yang mampu melakukan beberapa kerja dengan menentukan beberapa metadata tentang mereka. Metadata ini bukan sahaja menjadikannya mudah untuk ditemui, tetapi juga memberikan maklumat mengenai sama ada ia sepatutnya digunakan.

Adakah anda menggunakan anotasi tersuai dalam projek anda? Jika ya, bagaimana anda melaksanakannya? Mungkin ada kaedah ketiga? Beritahu kami!

(berminat untuk mempelajari lebih lanjut mengenai symfony, doktrin, anotasi dan pelbagai kandungan php peringkat perusahaan? Sertai kami untuk bengkel tangan tiga hari, WebSummerPamp-satu-satunya persidangan manual sepenuhnya, dan juga akan menjaga sesiapa sahaja yang anda mahu bawa!

---

(bahagian FAQ teks asal telah ditinggalkan kerana kandungannya sangat diduplikasi dengan kandungan diterjemahkan dan ditulis semula.)

Atas ialah kandungan terperinci Anotasi tersuai anda sendiri - lebih daripada sekadar komen!. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!