How to Create a Custom Validation Constraint
Edit this pageHow to Create a Custom Validation Constraint
You can create a custom constraint by extending the base constraint class, Constraint. As an example you're going to create a basic validator that checks if a string contains only alphanumeric characters.
Creating the Constraint Class
First you need to create a Constraint class and extend Constraint:
- Annotations
- Attributes
1 2 3 4 5 6 7 8 9 10 11 12 13
// src/Validator/ContainsAlphanumeric.php
namespace App\Validator;
use Symfony\Component\Validator\Constraint;
/**
* @Annotation
*/
class ContainsAlphanumeric extends Constraint
{
public $message = 'The string "{{ string }}" contains an illegal character: it can only contain letters or numbers.';
public $mode = 'strict'; // If the constraint has configuration options, define them as public properties
}
Add @Annotation
or #[\Attribute]
to the constraint class if you want to
use it as an annotation/attribute in other classes.
Creating the Validator itself
As you can see, a constraint class is fairly minimal. The actual validation is
performed by another "constraint validator" class. The constraint validator
class is specified by the constraint's validatedBy()
method, which
has this default logic:
1 2 3 4 5
// in the base Symfony\Component\Validator\Constraint class
public function validatedBy()
{
return static::class.'Validator';
}
In other words, if you create a custom Constraint
(e.g. MyConstraint
),
Symfony will automatically look for another class, MyConstraintValidator
when actually performing the validation.
The validator class only has one required method validate()
:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
// src/Validator/ContainsAlphanumericValidator.php
namespace App\Validator;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;
use Symfony\Component\Validator\Exception\UnexpectedValueException;
class ContainsAlphanumericValidator extends ConstraintValidator
{
public function validate($value, Constraint $constraint)
{
if (!$constraint instanceof ContainsAlphanumeric) {
throw new UnexpectedTypeException($constraint, ContainsAlphanumeric::class);
}
// custom constraints should ignore null and empty values to allow
// other constraints (NotBlank, NotNull, etc.) to take care of that
if (null === $value || '' === $value) {
return;
}
if (!is_string($value)) {
// throw this exception if your validator cannot handle the passed type so that it can be marked as invalid
throw new UnexpectedValueException($value, 'string');
// separate multiple types using pipes
// throw new UnexpectedValueException($value, 'string|int');
}
// access your configuration options like this:
if ('strict' === $constraint->mode) {
// ...
}
if (!preg_match('/^[a-zA-Z0-9]+$/', $value, $matches)) {
// the argument must be a string or an object implementing __toString()
$this->context->buildViolation($constraint->message)
->setParameter('{{ string }}', $value)
->addViolation();
}
}
}
Inside validate
, you don't need to return a value. Instead, you add violations
to the validator's context
property and a value will be considered valid
if it causes no violations. The buildViolation()
method takes the error
message as its argument and returns an instance of
ConstraintViolationBuilderInterface.
The addViolation()
method call finally adds the violation to the context.
Using the new Validator
You can use custom validators like the ones provided by Symfony itself:
- Annotations
- Attributes
- YAML
- XML
- PHP
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
// src/Entity/AcmeEntity.php
namespace App\Entity;
use App\Validator as AcmeAssert;
use Symfony\Component\Validator\Constraints as Assert;
class AcmeEntity
{
// ...
/**
* @Assert\NotBlank
* @AcmeAssert\ContainsAlphanumeric(mode="loose")
*/
protected $name;
// ...
}
If your constraint contains options, then they should be public properties on the custom Constraint class you created earlier. These options can be configured like options on core Symfony constraints.
Constraint Validators with Dependencies
If you're using the default services.yaml configuration,
then your validator is already registered as a service and tagged
with the necessary validator.constraint_validator
. This means you can
inject services or configuration like any other service.
Create a Reusable Set of Constraints
In case you need to consistently apply a common set of constraints across your application, you can extend the Compound constraint.
Class Constraint Validator
Besides validating a single property, a constraint can have an entire class
as its scope. You only need to add this to the Constraint
class:
1 2 3 4
public function getTargets()
{
return self::CLASS_CONSTRAINT;
}
With this, the validator's validate()
method gets an object as its first argument:
1 2 3 4 5 6 7 8 9 10 11
class ProtocolClassValidator extends ConstraintValidator
{
public function validate($protocol, Constraint $constraint)
{
if ($protocol->getFoo() != $protocol->getBar()) {
$this->context->buildViolation($constraint->message)
->atPath('foo')
->addViolation();
}
}
}
Tip
The atPath()
method defines the property with which the validation error is
associated. Use any valid PropertyAccess syntax
to define that property.
A class constraint validator is applied to the class itself, and not to the property:
- Annotations
- Attributes
- YAML
- XML
- PHP
1 2 3 4 5 6 7 8 9 10 11 12
// src/Entity/AcmeEntity.php
namespace App\Entity;
use App\Validator as AcmeAssert;
/**
* @AcmeAssert\ProtocolClass
*/
class AcmeEntity
{
// ...
}