Inject Value Objects Into An Autowired Symfony Service

While working on a Symfony project with my team, I needed to inject specific Value Object instances into one of my services. The values themselves, in this particular case, needed to be set from values provided in our .env file.

I could, of course, just pass the string values directly into my service and have the service instantiate the Value Objects in the constructor, but I wanted to see if it was possible to configure it in the services.yaml file and inject the fully-instantiated objects instead. This would allow me to pass those object instances to multiple services and not have to repeat the Value Object creation inside each.

Here's how I did it...

Background

Our application utilizes the Twilio SDK. We have various services wrapping the SDK calls, and they need to use our environment-specific configuration values (our company's API Key for each environment, etc.).

The Twilio API makes use of String Identifiers, or SIDs. Each type of SID has a different 2-letter prefix associated with it, followed by 32 characters made up of the digits 0 through 9 and the letters A through F (upper and lowercase).

For example:

• A ConferenceSid has the prefix CF and looks like CFabcdef0123456789abcdef0123456789
• A CallSid has the prefix CA and looks like CAabcdef0123456789abcdef0123456789
• There are other types of SIDs and they all use the same format, only differentiated by the prefix

I wanted to make sure the Value Objects for each SID type validated that the passed-in value had the proper prefix for that SID type, along with making sure the string was the correct length and was only made up of the allowed characters.

The Value Objects

Each of my SID types use the same validation logic and functionality, only diffentiating by the SID type's prefix, so it makes sense to create a base Trait. This could be an Abstract Class if you prefer. I don't need the concept of a TwilioStringIdentifier in the app as a parameter type or anything like that, so I prefer a Trait over an Abstract Class here.

This Trait does define an abstract method getPrefixForSidType() that each SID type must implement, providing the proper prefix for that given type. It also performs the validation logic.

namespace App\Domain\Model\Twilio\Sid;

use Assert\Assert;

trait TwilioStringIdentifier
{
    private readonly string $sid;

    abstract private function getPrefixForSidType(): string;

    public static function fromString(string $string): self
    {
        return new self($string);
    }

    public function __construct(string $sid)
    {
        Assert::that($sid)
            ->startsWith($this->getPrefixForSidType())
            ->length(34)
            ->regex('/^[a-zA-Z]{2}[0-9a-fA-F]{32}$/')
        ;

        $this->sid = $sid;
    }

    public function asString(): string
    {
        return $this->sid;
    }
}    

The SID classes

The Value Object classes representing each of the SID types are simple. They just need to use the TwilioStringIdentifier Trait and to define the proper prefix via the getPrefixForSidType() method.

namespace App\Domain\Model\Twilio\Sid;

final readonly class AccountSid
{
    use TwilioStringIdentifier;

    private function getPrefixForSidType(): string
    {
        return 'AC';
    }
}

The other SID type classes are identical except for their defined prefix.

Injecting the instantiated objects

Because these Value Objects will be used all throughout the application and with various values associated, and not just our company's global values, I needed a way to inject into services an object of a specific type that was already instantiated with the values defined in our .env file

I knew that Symfony has the ability to define services to be instantiated via a Factory but had never really seen (that I recall) anything about injecting an object that was the result of a method call from somewhere else. I also knew these Factory methods could have arguments passed to them, I just wasn't sure how to do this with one Value Object instance.

Defining the Specific Value Object Instance

Symfony's service definition allows you to name each service. Typically it's done with the Service class' name:

App\Path\To\My\Service:
    class: App\Path\To\My\Service
    arguments: []

But, that service name doesn't have to match the class name. It could be app.my_service or FooBarBazService or whatever.

So, what if I create a service with a unique name that is the instantiated instance of the Value Object I need? I could pass the .env value in as the argument and then have that object instance to inject into my service classes!

services.yaml

# Create services named with a Global "namespace"
Global\Twilio\Sid\Account:
    factory: ['App\Domain\Model\Twilio\Sid\AccountSid', 'fromString']
    arguments: ['%env(TWILIO_ACCOUNT_SID)%']

Global\Twilio\Sid\Api:
    factory: ['App\Domain\Model\Twilio\Sid\ApiSid', 'fromString']
    arguments: ['%env(TWILIO_API_SID)%']

Global\Twilio\Sid\Application:
    factory: ['App\Domain\Model\Twilio\Sid\ApplicationSid', 'fromString']
    arguments: ['%env(TWILIO_APP_SID)%']

Then pass those services (objects) into my Twilio service via their named arguments:

App\Service\Vendor\Twilio\TwilioService:
    arguments:
        $accountSid: '@Global\Twilio\Sid\Account'
        $apiSid: '@Global\Twilio\Sid\Api'
        $applicationSid: '@Global\Twilio\Sid\Application'
        $apiSecret: '%env(TWILIO_API_SECRET)%'

Now my service class can expect to receive the fully-instantiated Value Object instances:

TwilioService

namespace App\Service\Vendor\Twilio;

use App\Domain\Model\Twilio\Sid\AccountSid;
use App\Domain\Model\Twilio\Sid\ApiSid;
use App\Domain\Model\Twilio\Sid\ApplicationSid;

final readonly class TwilioService
{
    public function __construct(
        private AccountSid $accountSid,
        private ApiSid $apiSid,
        private ApplicationSid $applicationSid,
        private string $apiSecret
    ) {}
}

Voila!

Symfony is flexible enough and intuitive enough that it was simple to figure out how to do this. Since I couldn't find a quick reference for doing this elsewhere, I thought I'd write this up as a reference for Future Me and anyone else who may need to do something similar

Cheers, and Happy Coding!

The above is the detailed content of Inject Value Objects Into An Autowired Symfony Service. For more information, please follow other related articles on the PHP Chinese website!