Safely extending Drupal plugin classes without fear of constructor changes (2026 edition)

A brief history of autowiring in core

In Drupal 9.3 (December 2021), support for autowiring services was added to core. This allows us to remove arguments from services.yml. Symfony will automatically inject dependencies as long as the constructor parameter typehint matches a service name or alias.

Two years later, in Drupal 10.2 (December 2023), the AutowireTrait was introduced. This allows any class implementing ContainerInjectionInterface to drop the ::create() method, and the trait will autowire the dependencies for you. 

Unfortunately, that didn’t work with Plugin classes, because the ::create() method has some additional parameters to deal with. It wasn’t until Drupal 11.3 (December 2025)that the same treatment was added to PluginBase, allowing plugins to drop the ::create() method as well.

Of course, none of this really helps us with the original problem - dealing with constructor changes in the parent class. Our previous solution relied on overriding the ::create() method and setting additional services as properties. But the improvements are all about removing the ::create() method. 

So how should we add dependencies in 2026, I hear you ask?

Once again, Symfony provides the solution; we just need to glue it together.

Introducing automatic setter injection and the Required attribute

Up until now, we’ve only used autowiring for constructor injection, but it’s also possible in Symfony to autowire a method by applying the #[Required] attribute. This tells Symfony the method must be called when the class is instantiated, and any parameters will be autowired to the matching service. That looks something like this:

use Symfony\Contracts\Service\Attribute\Required;

class ExamplePlugin extends ExamplePluginBase {

  protected FooMeddlerInterface $fooMeddler;

  #[Required]
  public function setFooMeddler(FooMeddlerInterface $fooMeddler): void {
    $this->fooMeddler = $fooMeddler;
  }

}

We’re adding a typed property with a setter method, and we don’t need to touch the constructor or create method. The service will automatically be injected when the plugin is instantiated. Crucially, this means constructor changes in the parent class no longer affect us.

Support for this was added in Drupal 11.4 and applies to plugins extending \Drupal\Core\Plugin\PluginBase and controllers extending \Drupal\Core\Controller\ControllerBase.

Credit to @longwave and @godotislate (Drupal’s newest release manager) for working on this issue.