PHP 8 attributes combine reflection to implement powerful metaprogramming. 1. Attributes are metadata that can be read at runtime, such as #[Route] for tagging classes or methods; 2. The Reflection API parses and instantiates attributes through getAttributes() and newInstance(); 3. Practical applications include routing systems, verification serialization and ORM mapping; 4. Best practices include keeping attributes concise, using type attributes, cache reflected results and avoiding abuse; 5. The target and repetition can be defined through Attribute constants, and ultimately implement clear and type-safe self-description code.

PHP has evolved significantly over the years, and with the introduction of attributes in PHP 8 , metaprogramming has become more powerful and elegant. Combined with Reflection , attributes allow developers to write cleaner, more expressive code that can inspect and react to metadata at runtime—opening the door to frameworks, ORMs, routing systems, and validation libraries that feel almost magical.

Let's break down how attributes and reflection work together to enable powerful metaprogramming in modern PHP.

What Are Attributes?

In PHP 8 , attributes are a native language feature that lets you add metadata to classes, methods, properties, parameters, and constants. Think of them as structured annotations—like PHPDoc comments, but actually usable at runtime and type-safe.

 #[Attribute]
class Route {
    public function __construct(
        public string $path,
        public string $method = 'GET'
    ) {}
}

#[Route('/api/users', 'POST')]
class CreateUserAction {
    public function handle(): array {
        return ['message' => 'User created'];
    }
}

Here, #[Route(...)] is an attribute applied to the class. Unlike comments, this is real PHP code that can be inspected and processed.

How Reflection Makes It Work

To read attributes at runtime, you use PHP's Reflection API . This allows your code to examine classes, methods, etc., and extract the attributes you've defined.

 $reflection = new ReflectionClass(CreateUserAction::class);
$routeAttribute = $reflection->getAttributes(Route::class)[0] ?? null;

if ($routeAttribute) {
    $route = $routeAttribute->newInstance();
    echo "Path: {$route->path}, Method: {$route->method}";
    // Output: Path: /api/users, Method: POST
}

The key methods:

• getAttributes() – gets all or filtered attributes
• newInstance() – instantiates the attribute class with the values you passed

This combo (attributes reflection) is what powers tools like Symfony, Laravel, and custom frameworks under the hood.

Practical Use Cases

1. Routing System

You can build a simple router that scans for #[Route] attributes and maps URLs to handlers.

 $routes = [];
foreach (get_declared_classes() as $class) {
    $ref = new ReflectionClass($class);
    foreach ($ref->getAttributes(Route::class) as $attr) {
        $route = $attr->newInstance();
        $routes[$route->path] = [
            'class' => $class,
            'method' => $route->method,
        ];
    }
}

Now your app knows which class handles which endpoint—without configuration files.

2. Validation and Serialization

Use attributes to define validation rules or serialization behavior:

 #[Attribute]
class Validate { 
    public function __construct(public string $rule) {}
}

class User {
    #[Validate('email')]
    public string $email;
}

// At runtime, inspect properties and apply validation
$ref = new ReflectionProperty(User::class, 'email');
$validation = $ref->getAttributes(Validate::class)[0]->newInstance();
if ($validation->rule === 'email') {
    // validate format
}

3. ORM Mapping

Doctrine-style mapping is now possible natively:

 #[Attribute]
class Column {
    public function __construct(
        public string $type,
        public bool $nullable = false
    ) {}
}

class Product {
    #[Column('string', nullable: false)]
    public string $name;
}

A persistence layer can use reflection to generate SQL or hydrate objects based on metadata.

Best Practices and Pitfalls

• Keep attributes simple – they should be data containers, not contain complex logic.
• Use typed properties in attribute classes for better IDE support and safety.
• Cache reflection results in production – reflection is powerful but slow if repeated.
• Avoid overuse – not every config needs an attribute. Use them where they improve clarity.

Also, remember:

• Attributes can target specific elements via Attribute::TARGET_CLASS , TARGET_METHOD , etc.
• You can allow multiple attributes on the same element with Attribute::IS_REPEATABLE .

Example:

 #[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
class Middleware {
    public function __construct(public string $name) {}
}

Final Thoughts

Metaprogramming in PHP used to rely on messy workarounds—like parsing docblocks or relying on naming conventions. With attributes and reflection , you now have a clean, type-safe way to attach metadata and build intelligent systems that inspect code structure.

Whether you're building a micro-framework, an API layer, or just want cleaner configuration, attributes reflection gives you the tools to write expressive, self-describing code.

It's not magic—it's just modern PHP.

The above is the detailed content of Metaprogramming in PHP: The Power of Attributes and Reflection. For more information, please follow other related articles on the PHP Chinese website!