PHP -benutzerdefinierte Anmerkungen: Verbesserte Code -Flexibilit?t und Skalierbarkeit

In diesem Artikel wird erl?utert, wie benutzerdefinierte Anmerkungen in Symfony 3 -Anwendungen erstellt und verwendet werden. Annotationen sind die Dokumentblockmetadaten/Konfiguration, die wir oben Klassen, Methoden und Eigenschaften sehen. und Zugang zu Methoden. In diesem Artikel wird erl?utert, wie Anmerkungen angepasst und Klassen- oder Methodeninformationen gelesen werden, ohne die Klasse zu laden. @Route() @ORM()

Schlüsselpunkte:

PHP -benutzerdefinierte Anmerkungen k?nnen verwendet werden, um dem Code Metadaten hinzuzufügen, was das Verhalten des Codes beeinflusst, wodurch es flexibler und leichter anpasst. Sie k?nnen verwendet werden, um Routing -Informationen zu definieren, überprüfungsregeln anzugeben oder die Abh?ngigkeitsinjektion zu konfigurieren.

• Erstellen einer benutzerdefinierten PHP -Annotation erfordert die Definition einer neuen Klasse, um die Annotation darzustellen. Diese Klasse sollte Eigenschaften haben, die dem Wert entsprechen, den Sie in der Annotation festlegen m?chten.
• Doktrin unterstützt benutzerdefinierte Anmerkungen. Sie k?nnen Ihre eigenen Anmerkungen definieren und sie in Loktrinit?ten verwenden. Der Annotationsleser der Doktrin analysiert diese Annotationen und kann sie dann verwenden, um das Verhalten einer Entit?t zu beeinflussen.
• Eine Einschr?nkung der Verwendung von PHP -benutzerdefinierten Anmerkungen besteht darin, dass sie nicht von der Sprache selbst unterstützt werden. Dies bedeutet, dass Sie Bibliotheken oder Tools verwenden müssen, die Annotationsunterstützung bieten, z. B. Doktrin oder PHP-DI.
• PHP -benutzerdefinierte Annotationen haben eine Vielzahl von Verwendungszwecken, einschlie?lich der Definition von Routing -Informationen in einer Webanwendung, Angabe von Best?tigungsregeln für die Formulareingabe oder die Konfiguration der Abh?ngigkeitsinjektion. Sie k?nnen auch verwendet werden, um Ihrem Code Dokumentation hinzuzufügen.

Haftungsausschluss:

Annotation hat nichts mit Symfony zu tun. Es handelt sich um ein Konzept, das als Teil des Doktrinprojekts entwickelt wurde, um das Problem der Zuordnung von ORM -Informationen auf Klassenmethoden zu l?sen. Dieser Artikel erstellt ein kleines wiederverwendbares Bündel namens WorkerBundle (nur zu Demonstrationszwecken, nicht wirklich packbar). Wir werden ein kleines Konzept entwickeln, mit dem Sie verschiedene Arbeitertypen definieren k?nnen, die mit unterschiedlichen Geschwindigkeiten "laufen", die dann von jedem in der Anwendung verwendet werden k?nnen. Die tats?chlichen Arbeiteroperationen liegen au?erhalb des Rahmens dieses Artikels, da wir uns mit der Einrichtung des Systems befassen, das sie verwaltet (und durch Anmerkungen entdeckt).

Sie k?nnen

dieses Repository

anzeigen und das Bundle in Ihrer lokalen Symfony -Anwendung wie in ihm beschrieben einrichten.

Arbeiter

Worker implementiert eine Schnittstelle, die eine Methode erfordert:

. Lassen Sie uns im neuen WorkerBundle ein

-Verzeichnis erstellen, um es ordentlich zu halten und eine Schnittstelle dazu hinzuzufügen: ::work() Workers/

<?php
namespace WorkerBundle\Workers;

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

Annotationen

Jeder Arbeiter muss die obige Schnittstelle implementieren. Sehr klar. Darüber hinaus brauchen wir sie auch, um eine Annotation über der Klasse zu haben, um sie zu finden und etwas über sie zu lesen.

Doktrinkarten dokumentieren Blockanmerkungen zu einer Klasse, deren Eigenschaften Schlüssel innerhalb der Annotation selbst darstellen. Lassen Sie uns unsere eigenen Anmerkungen erstellen und es tun.

Jede WorkerInterface -Instanz hat die folgende Annotation in seinem Dokumentblock:

<?php
namespace WorkerBundle\Workers;

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

Wir werden es einfach halten, mit nur zwei Eigenschaften: eindeutiger Name (String) und Arbeitergeschwindigkeit (integral). Damit die Annotationsbibliothek der Doktrin diese Annotation erfasst, müssen wir eine passende Klasse erstellen, die wie erwartet einige Anmerkungen für sich enth?lt.

Wir haben diese Klasse in den Annotationsordner des Bundle -Namespace eingestellt und einfach Worker genannt:

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

Wie Sie sehen, haben wir zwei Eigenschaften und einige einfache Getter -Methoden. Noch wichtiger ist, dass wir zwei Anmerkungen an der Spitze haben: @Annotation (sagen Sie die Doktrin, dass eine solche Klasse eine Annotation darstellt) und @Target("CLASS") (sagen Sie, dass es über der gesamten Klasse und nicht über der Methode oder Eigenschaft verwendet werden sollte). Das ist es, die WorkerInterface -Klasse kann diese Annotation nun verwenden, indem sicherstellt use

<?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;
    }
}

Manager

Als n?chstes ben?tigen wir einen Manager, den unsere Anwendung verwenden kann, um eine Liste aller verfügbaren Arbeitnehmer zu erhalten und zu erstellen. Im gleichen Namespace wie WorkerInterface k?nnen wir diese einfache Managerklasse verwenden:

use WorkerBundle\Annotation\Worker;

entdecker

Der Hauptbestandteil unserer Annotationsdemonstration ist tats?chlich Teil des Entdeckungsprozesses. Warum? Weil wir Arbeiteranmerkungen verwenden, um festzustellen, ob die entsprechende Klasse als Arbeiter behandelt werden sollte. In diesem Prozess verwenden wir Metadaten, bevor wir das Objekt tats?chlich instanziieren. Schauen wir uns unseren WorkerDiscovery -Kurs an:

<?php
namespace WorkerBundle\Workers;

class WorkerManager
{
    // ... (代碼與原文相同) ...
}

verbinden

Jetzt, da wir die Hauptkomponenten haben, ist es Zeit, alles zu verbinden. Erstens ben?tigen wir die Service -Definition, sodass wir im Ressourcen-/Konfigurationsordner des Bündels diese dienste.yml -Datei haben k?nnen:

Damit unsere Servicedefinition zentral vom Container abgeholt werden kann, müssen wir eine kleine Erweiterungsklasse schreiben. Erstellen Sie also im Abh?ngigkeitsinjektionsordner des Bundle eine Klasse namens Workerextsion. Ort und Name sind wichtig, damit Symfony es automatisch aufnimmt.

<?php
namespace WorkerBundle\Workers;

// ... (代碼與原文相同) ...
}

Schlie?lich müssen wir unser Bundle registrieren. In unserem Appkernel:

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"]

Das war's.

<?php
namespace WorkerBundle\DependencyInjection;

// ... (代碼與原文相同) ...
}

Lassen Sie uns arbeiten!

Jetzt sind wir bereit zu arbeiten. Konfigurieren wir, wo unser Arbeiter in der zentralen Parameter.yml -Datei gefunden wird:

Diese Parameter werden wie oben beschrieben vom Container an die WorkerDiscovery -Klasse übergeben.

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

Standort liegt bei Ihnen, aber jetzt lassen wir unseren Arbeiter in das Haupt -Appbundle -Bundle der App einsetzen. Unser erster Arbeiter k?nnte so aussehen:

<?php
namespace WorkerBundle\Workers;

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

Unsere Annotation ist da, die use -Anweisung ist vorhanden, sodass nichts eine Gesch?ftslogik daran hindert, sie zu finden und zu instanziieren. Nehmen wir an, dies innerhalb einer Controller -Methode:

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

oder

<?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;
    }
}

Schlussfolgerung

Wir k?nnen jetzt Anmerkungen verwenden, um Metadaten über Klassen (oder Methoden und Eigenschaften) auszudrücken. In diesem Tutorial erstellen wir ein kleines Paket, mit dem Anwendungen (oder andere externe Bündel) einen Arbeiter erkl?ren k?nnen, der in der Lage ist, einige Arbeiten auszuführen, indem sie einige Metadaten über sie definieren. Diese Metadaten machen sie nicht nur leicht zu entdecken, sondern liefert auch Informationen darüber, ob sie tats?chlich verwendet werden sollten.

Verwenden Sie benutzerdefinierte Anmerkungen in Ihren Projekten? Wenn ja, wie haben Sie sie implementiert? Vielleicht gibt es eine dritte Methode? Lass es uns wissen!

---

(m?chte mehr über Symfony, Doktrin, Annotationen und verschiedene PHP-Inhalte auf Unternehmensebene erfahren? Begleiten von jedem, den Sie mitbringen m?chten!)

(Der FAQ -Teil des Originaltextes wurde weggelassen, da sein Inhalt mit übersetzter und neu geschriebener Inhalt stark dupliziert wird.)

Das obige ist der detaillierte Inhalt vonIhre eigenen benutzerdefinierten Anmerkungen - mehr als nur Kommentare!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!