Ihre eigenen benutzerdefinierten Anmerkungen - mehr als nur Kommentare!

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
{
    /**
     * 执行工作
     *
     * @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
{
    /**
     * 执行工作
     *
     * @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
{
    /**
     * 执行工作
     *
     * @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!