How to Create a custom Validation Constraint

Edit this page

Warning: You are browsing the documentation for Symfony 3.4, which is no longer maintained.

Read the updated version of this page for Symfony 6.3 (the current stable version).

How 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 simple 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:

        1
2
3
4
5
6
7
8
9
10
11
12
        // src/AppBundle/Validator/Constraints/ContainsAlphanumeric.php
namespace AppBundle\Validator\Constraints;

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.';
}
    

Note

The @Annotation annotation is necessary for this new constraint in order to make it available for use in classes via annotations. Options for your constraint are represented as public properties on the constraint class.

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 includes some simple default logic:

        1
2
3
4
5
        // in the base Symfony\Component\Validator\Constraint class
public function validatedBy()
{
    return \get_class($this).'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 is also simple, and 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
        // src/AppBundle/Validator/Constraints/ContainsAlphanumericValidator.php
namespace AppBundle\Validator\Constraints;

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;

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.) take care of that
        if (null === $value || '' === $value) {
            return;
        }

        if (!is_string($value)) {
            throw new UnexpectedTypeException($value, 'string');
        }

        if (!preg_match('/^[a-zA-Z0-9]+$/', $value, $matches)) {
            $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 just as the ones provided by Symfony itself:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
        // src/AppBundle/Entity/AcmeEntity.php
use AppBundle\Validator\Constraints as AcmeAssert;
use Symfony\Component\Validator\Constraints as Assert;

class AcmeEntity
{
    // ...

    /**
     * @Assert\NotBlank
     * @AcmeAssert\ContainsAlphanumeric
     */
    protected $name;

    // ...
}
    

        1
2
3
4
5
6
        # src/AppBundle/Resources/config/validation.yml
AppBundle\Entity\AcmeEntity:
    properties:
        name:
            - NotBlank: ~
            - AppBundle\Validator\Constraints\ContainsAlphanumeric: ~
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
        <!-- src/AppBundle/Resources/config/validation.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">

    <class name="AppBundle\Entity\AcmeEntity">
        <property name="name">
            <constraint name="NotBlank"/>
            <constraint name="AppBundle\Validator\Constraints\ContainsAlphanumeric"/>
        </property>
    </class>
</constraint-mapping>
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
        // src/AppBundle/Entity/AcmeEntity.php
use AppBundle\Validator\Constraints\ContainsAlphanumeric;
use Symfony\Component\Validator\Constraints\NotBlank;
use Symfony\Component\Validator\Mapping\ClassMetadata;

class AcmeEntity
{
    public $name;

    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addPropertyConstraint('name', new NotBlank());
        $metadata->addPropertyConstraint('name', new ContainsAlphanumeric());
    }
}
    

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.yml 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.

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 which the validation error is associated to. Use any valid PropertyAccess syntax to define that property.

A class constraint validator is applied to the class itself, and not to the property:

        1
2
3
4
5
6
7
        /**
 * @AcmeAssert\ProtocolClass
 */
class AcmeEntity
{
    // ...
}
    

        1
2
3
4
        # src/AppBundle/Resources/config/validation.yml
AppBundle\Entity\AcmeEntity:
    constraints:
        - AppBundle\Validator\Constraints\ProtocolClass: ~
    

        1
2
3
4
        <!-- src/AppBundle/Resources/config/validation.xml -->
<class name="AppBundle\Entity\AcmeEntity">
    <constraint name="AppBundle\Validator\Constraints\ProtocolClass"/>
</class>
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
        // src/AppBundle/Entity/AcmeEntity.php
use AppBundle\Validator\Constraints\ProtocolClass;
use Symfony\Component\Validator\Mapping\ClassMetadata;

class AcmeEntity
{
    // ...

    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addConstraint(new ProtocolClass());
    }
}
    

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.

How to Create a custom Validation Constraint

How to Create a custom Validation Constraint

Creating the Constraint Class

Creating the Validator itself

Using the new Validator

Constraint Validators with Dependencies

Class Constraint Validator

What is Symfony?

Learn Symfony

Screencasts

Community

Blog

Services

Deployed on