国产av日韩一区二区三区精品,成人性爱视频在线观看,国产,欧美,日韩,一区,www.成色av久久成人,2222eeee成人天堂

Table of Contents
PHP Custom Annotations: Enhanced Code Flexibility and Scalability
Home Backend Development PHP Tutorial Your Own Custom Annotations - More than Just Comments!

Your Own Custom Annotations - More than Just Comments!

Feb 15, 2025 am 09:22 AM

PHP Custom Annotations: Enhanced Code Flexibility and Scalability

This article discusses how to create and use custom annotations in Symfony 3 applications. Annotations are the document block metadata/configuration we see above classes, methods and properties. They are often used to declare controller routing (@Route()), Doctrine ORM mapping (@ORM()), or control various classes in packages such as Rauth. and access to methods. This article will explain how to customize annotations and read class or method information without loading the class.

Key points:

  • PHP custom annotations can be used to add metadata to the code, affecting the behavior of the code, making it more flexible and easier to adapt. They can be used to define routing information, specify verification rules, or configure dependency injection.
  • Creating a PHP custom annotation requires defining a new class to represent the annotation. This class should have properties corresponding to the value you want to set in the annotation.
  • Doctrine supports custom annotations. You can define your own annotations and use them in Doctrine entities. Doctrine's annotation reader parses these annotations and can then use them to affect the behavior of an entity.
  • One limitation of using PHP custom annotations is that they are not natively supported by the language itself. This means you need to use libraries or tools that provide annotation support, such as Doctrine or PHP-DI.
  • PHP custom annotations have a variety of uses, including defining routing information in a web application, specifying verification rules for form input, or configuring dependency injection. They can also be used to add documentation to your code.

Your Own Custom Annotations - More than Just Comments!

Disclaimer: Annotation has nothing to do with Symfony, it is a concept developed as part of the Doctrine project to solve the problem of mapping ORM information to class methods.

This article will build a small reusable bundle called WorkerBundle (for demonstration purposes only, not really packable). We will develop a small concept that allows you to define various Worker types that "run" at different speeds, which can then be used by anyone in the application. The actual worker operations are beyond the scope of this article, because we are concerned with setting up the system that manages them (and discovering them through annotations).

You can view this repository and set up the bundle in your local Symfony application as described in it.

Worker

Worker will implement an interface that requires a method: ::work(). In the new WorkerBundle, let's create a Workers/ directory to keep it tidy and add an interface to it:

<?php
namespace WorkerBundle\Workers;

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

Annotations

Each worker must implement the above interface. Very clear. But beyond that, we also need them to have an annotation above the class in order to find them and read some metadata about them.

Doctrine maps document block annotations to a class whose properties represent keys inside the annotation itself. Let's create our own annotations and do it.

Each WorkerInterface instance will have the following annotation in its document block:

<?php
namespace WorkerBundle\Workers;

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

We will keep it simple, with only two properties: unique name (string) and worker speed (integral). In order for Doctrine's annotation library to recognize this annotation, we must create a matching class, which, as expected, has some annotations on its own.

We put this class in the Annotation folder of the bundle namespace and simply named it Worker:

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

As you can see, we have two properties and some simple getter methods. More importantly, we have two annotations at the top: @Annotation (tell Doctrine such a class to represent an annotation) and @Target("CLASS") (tell it should be used above the entire class rather than above the method or property). That's it, the WorkerInterface class can now use this annotation by ensuring that the corresponding class is imported using the use statement at the top of the file:

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

Next, we need a manager that our application can use to get a list of all available workers and create them. In the same namespace as WorkerInterface, we can use this simple manager class:

use WorkerBundle\Annotation\Worker;

Discoverer

The key part of our annotation demonstration is actually part of the discovery process. Why? Because we use Worker annotations to determine whether the corresponding class should be treated as a Worker. In this process, we use metadata before actually instantiating the object. Let's take a look at our WorkerDiscovery class:

<?php
namespace WorkerBundle\Workers;

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

Connect

Now that we have the main components, it's time to connect everything. First, we need the service definition, so in the Resource/config folder of the bundle, we can have this services.yml file:

<?php
namespace WorkerBundle\Workers;

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

In order for our service definition to be picked up centrally by the container, we need to write a small extension class. So, in the DependencyInjection folder of the bundle, create a class called WorkerExtension. Location and name are important for Symfony to automatically pick it up.

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

Finally, we need to register our bundle. In our AppKernel:

<?php
namespace WorkerBundle\DependencyInjection;

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

That's it.

Let us work!

Now we are ready to work. Let's configure where our worker will be found in the central parameters.yml file:

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

These parameters are passed from the container to the WorkerDiscovery class, as described above.

Location is up to you, but now let's put our worker in the main AppBundle bundle of the app. Our first worker might look like this:

<?php
namespace WorkerBundle\Workers;

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

Our annotation is there, the use statement is in place, so nothing can prevent some business logic from finding it and instantiating it. Let's assume that inside a Controller method:

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

or

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

Conclusion

We can now use annotations to express metadata about classes (or methods and properties). In this tutorial, we build a small package that enables applications (or other external bundles) to declare a worker capable of performing some work by defining some metadata about them. This metadata not only makes them easy to discover, but also provides information on whether they should be actually used.

Your Own Custom Annotations - More than Just Comments! Do you use custom annotations in your projects? If so, how did you implement them? Maybe there is a third method? Let us know!


(Interested in learning more about Symfony, Doctrine, annotations and various enterprise-level PHP content? Join us for a three-day hands-on workshop, WebSummerCamp—the only fully manual conference, And will also take care of anyone you want to bring! )

(The FAQ part of the original text has been omitted because its content is highly duplicated with translated and rewritten content.)

The above is the detailed content of Your Own Custom Annotations - More than Just Comments!. For more information, please follow other related articles on the PHP Chinese website!

Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Hot AI Tools

Undress AI Tool

Undress AI Tool

Undress images for free

Undresser.AI Undress

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

AI Clothes Remover

Online AI tool for removing clothes from photos.

Clothoff.io

Clothoff.io

AI clothes remover

Video Face Swap

Video Face Swap

Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Tools

Notepad++7.3.1

Notepad++7.3.1

Easy-to-use and free code editor

SublimeText3 Chinese version

SublimeText3 Chinese version

Chinese version, very easy to use

Zend Studio 13.0.1

Zend Studio 13.0.1

Powerful PHP integrated development environment

Dreamweaver CS6

Dreamweaver CS6

Visual web development tools

SublimeText3 Mac version

SublimeText3 Mac version

God-level code editing software (SublimeText3)

What are some best practices for versioning a PHP-based API? What are some best practices for versioning a PHP-based API? Jun 14, 2025 am 12:27 AM

ToversionaPHP-basedAPIeffectively,useURL-basedversioningforclarityandeaseofrouting,separateversionedcodetoavoidconflicts,deprecateoldversionswithclearcommunication,andconsidercustomheadersonlywhennecessary.StartbyplacingtheversionintheURL(e.g.,/api/v

How do I implement authentication and authorization in PHP? How do I implement authentication and authorization in PHP? Jun 20, 2025 am 01:03 AM

TosecurelyhandleauthenticationandauthorizationinPHP,followthesesteps:1.Alwayshashpasswordswithpassword_hash()andverifyusingpassword_verify(),usepreparedstatementstopreventSQLinjection,andstoreuserdatain$_SESSIONafterlogin.2.Implementrole-basedaccessc

What are weak references (WeakMap) in PHP, and when might they be useful? What are weak references (WeakMap) in PHP, and when might they be useful? Jun 14, 2025 am 12:25 AM

PHPdoesnothaveabuilt-inWeakMapbutoffersWeakReferenceforsimilarfunctionality.1.WeakReferenceallowsholdingreferenceswithoutpreventinggarbagecollection.2.Itisusefulforcaching,eventlisteners,andmetadatawithoutaffectingobjectlifecycles.3.YoucansimulateaWe

What are the differences between procedural and object-oriented programming paradigms in PHP? What are the differences between procedural and object-oriented programming paradigms in PHP? Jun 14, 2025 am 12:25 AM

Proceduralandobject-orientedprogramming(OOP)inPHPdiffersignificantlyinstructure,reusability,anddatahandling.1.Proceduralprogrammingusesfunctionsorganizedsequentially,suitableforsmallscripts.2.OOPorganizescodeintoclassesandobjects,modelingreal-worlden

How can you handle file uploads securely in PHP? How can you handle file uploads securely in PHP? Jun 19, 2025 am 01:05 AM

To safely handle file uploads in PHP, the core is to verify file types, rename files, and restrict permissions. 1. Use finfo_file() to check the real MIME type, and only specific types such as image/jpeg are allowed; 2. Use uniqid() to generate random file names and store them in non-Web root directory; 3. Limit file size through php.ini and HTML forms, and set directory permissions to 0755; 4. Use ClamAV to scan malware to enhance security. These steps effectively prevent security vulnerabilities and ensure that the file upload process is safe and reliable.

How can you interact with NoSQL databases (e.g., MongoDB, Redis) from PHP? How can you interact with NoSQL databases (e.g., MongoDB, Redis) from PHP? Jun 19, 2025 am 01:07 AM

Yes, PHP can interact with NoSQL databases like MongoDB and Redis through specific extensions or libraries. First, use the MongoDBPHP driver (installed through PECL or Composer) to create client instances and operate databases and collections, supporting insertion, query, aggregation and other operations; second, use the Predis library or phpredis extension to connect to Redis, perform key-value settings and acquisitions, and recommend phpredis for high-performance scenarios, while Predis is convenient for rapid deployment; both are suitable for production environments and are well-documented.

What are the differences between == (loose comparison) and === (strict comparison) in PHP? What are the differences between == (loose comparison) and === (strict comparison) in PHP? Jun 19, 2025 am 01:07 AM

In PHP, the main difference between == and == is the strictness of type checking. ==Type conversion will be performed before comparison, for example, 5=="5" returns true, and ===Request that the value and type are the same before true will be returned, for example, 5==="5" returns false. In usage scenarios, === is more secure and should be used first, and == is only used when type conversion is required.

How do I perform arithmetic operations in PHP ( , -, *, /, %)? How do I perform arithmetic operations in PHP ( , -, *, /, %)? Jun 19, 2025 pm 05:13 PM

The methods of using basic mathematical operations in PHP are as follows: 1. Addition signs support integers and floating-point numbers, and can also be used for variables. String numbers will be automatically converted but not recommended to dependencies; 2. Subtraction signs use - signs, variables are the same, and type conversion is also applicable; 3. Multiplication signs use * signs, which are suitable for numbers and similar strings; 4. Division uses / signs, which need to avoid dividing by zero, and note that the result may be floating-point numbers; 5. Taking the modulus signs can be used to judge odd and even numbers, and when processing negative numbers, the remainder signs are consistent with the dividend. The key to using these operators correctly is to ensure that the data types are clear and the boundary situation is handled well.

See all articles