Refs RFC #19297

Introduces a new #[EventListener] PHP attribute allowing listener methods (or classes) to
declare event subscriptions directly in code, without manual EventManager::on()
calls or implementing EventListenerInterface.

class OrdersListener
{
    #[EventListener('Order.afterPlace')]
    public function sendReceipt(EventInterface $event): void { ... }

    #[EventListener('Order.afterPlace', priority: 5)]
    #[EventListener('Order.afterCancel', priority: 20)]
    public function updateMetrics(EventInterface $event): void { ... }
}

The EventManager::registerAttributeListeners() method (or AttributeEventListenerConnector
directly) reads attribute metadata via the existing AttributeResolver
infrastructure — the same scan-and-cache system used for attribute-based routing —
and registers the discovered callables.

Usage

Prerequisites

registerAttributeListeners() relies on the AttributeResolver being configured with the
paths to scan. Follow the AttributeResolver configuration docs
to set this up — typically a 'Listener/**/*.php' glob in your default config.

1. Activate in your Application

Override events() in your Application class (or a Plugin):

// src/Application.php
use Cake\Event\EventManagerInterface;

public function events(EventManagerInterface $eventManager): EventManagerInterface
{
    $eventManager->registerAttributeListeners();      // scans & registers all #[EventListener] attributes

    return $eventManager;
}

2. Declare listeners with the attribute

Method-level (most common — the decorated method is the callable):

use Cake\Event\Attribute\EventListener;

class OrdersListener
{
    #[EventListener('Order.afterPlace')]
    #[EventListener('Order.afterCancel', priority: 20)]
    public function updateMetrics(EventInterface $event): void { ... }
}

Class-level with explicit method:

#[EventListener('Order.afterPlace', method: 'handleOrder')]
class OrdersListener
{
    public function handleOrder(EventInterface $event): void { ... }
}

Class-level with invokable class:

#[EventListener('Order.afterPlace')]
class SendReceiptListener
{
    public function __invoke(EventInterface $event): void { ... }
}

Class-level with inferred method name (Order.afterPlace → onOrderAfterPlace):

#[EventListener('Order.afterPlace')]
class OrdersListener
{
    public function onOrderAfterPlace(EventInterface $event): void { ... }
}

Callable resolution order (class-level attributes)

1. Explicit method argument on the attribute
2. __invoke() when present on the class
3. Method name inferred from the event (Order.afterPlace → onOrderAfterPlace)

Abstract classes, interfaces and traits are silently skipped. Non-public or
missing methods throw EventAttributeException with a descriptive message.