Callback

The purpose of the Callback constraint is to create completely custom validation rules and to assign any validation errors to specific fields on your object. If you’re using validation with forms, this means that instead of displaying custom errors at the top of the form, you can display them next to the field they apply to.

This process works by specifying one or more callback methods, each of which will be called during the validation process. Each of those methods can do anything, including creating and assigning validation errors.

Note

A callback method itself doesn’t fail or return any value. Instead, as you’ll see in the example, a callback method has the ability to directly add validator “violations”.

Applies to	class or property/method
Options	callback groups payload
Class	`Symfony\Component\Validator\Constraints\Callback`
Validator	`Symfony\Component\Validator\Constraints\CallbackValidator`

Configuration

Annotations

// src/Entity/Author.php
namespace App\Entity;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
class Author
{
    /**
     * @Assert\Callback
     */
    public function validate(ExecutionContextInterface $context, $payload)
    {
        // ...
    }
}

YAML

# config/validator/validation.yaml
App\Entity\Author:
    constraints:
        - Callback: validate

XML

<!-- config/validator/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="App\Entity\Author">
        <constraint name="Callback">validate</constraint>
    </class>
</constraint-mapping>

PHP

// src/Entity/Author.php
namespace App\Entity;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Mapping\ClassMetadata;
class Author
{
    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addConstraint(new Assert\Callback('validate'));
    }
    public function validate(ExecutionContextInterface $context, $payload)
    {
        // ...
    }
}

The Callback Method

The callback method is passed a special ExecutionContextInterface object. You can set “violations” directly on this object and determine to which field those errors should be attributed:

// ...
use Symfony\Component\Validator\Context\ExecutionContextInterface;
class Author
{
    // ...
    private $firstName;
    public function validate(ExecutionContextInterface $context, $payload)
    {
        // somehow you have an array of "fake names"
        $fakeNames = [/* ... */];
        // check if the name is actually a fake name
        if (in_array($this->getFirstName(), $fakeNames)) {
            $context->buildViolation('This name sounds totally fake!')
                ->atPath('firstName')
                ->addViolation();
        }
    }
}

Static Callbacks

You can also use the constraint with static methods. Since static methods don’t have access to the object instance, they receive the object as the first argument:

public static function validate($object, ExecutionContextInterface $context, $payload)
{
    // somehow you have an array of "fake names"
    $fakeNames = [/* ... */];
    // check if the name is actually a fake name
    if (in_array($object->getFirstName(), $fakeNames)) {
        $context->buildViolation('This name sounds totally fake!')
            ->atPath('firstName')
            ->addViolation()
        ;
    }
}

External Callbacks and Closures

If you want to execute a static callback method that is not located in the class of the validated object, you can configure the constraint to invoke an array callable as supported by PHP’s [call_user_func](https://www.php.net/manual/en/function.call-user-func.php "call_user_func") function. Suppose your validation function is Acme\Validator::validate():

namespace Acme;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
class Validator
{
    public static function validate($object, ExecutionContextInterface $context, $payload)
    {
        // ...
    }
}

You can then use the following configuration to invoke this validator:

Annotations

// src/Entity/Author.php
namespace App\Entity;
use Symfony\Component\Validator\Constraints as Assert;
/**
 * @Assert\Callback({"Acme\Validator", "validate"})
 */
class Author
{
}

YAML

# config/validator/validation.yaml
App\Entity\Author:
    constraints:
        - Callback: [Acme\Validator, validate]

XML

<!-- config/validator/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="App\Entity\Author">
        <constraint name="Callback">
            <value>Acme\Validator</value>
            <value>validate</value>
        </constraint>
    </class>
</constraint-mapping>

PHP

// src/Entity/Author.php
namespace App\Entity;
use Acme\Validator;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Mapping\ClassMetadata;
class Author
{
    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addConstraint(new Assert\Callback([
            Validator::class,
            'validate',
        ]));
    }
}

Note

The Callback constraint does not support global callback functions nor is it possible to specify a global function or a service method as callback. To validate using a service, you should create a custom validation constraint and add that new constraint to your class.

When configuring the constraint via PHP, you can also pass a closure to the constructor of the Callback constraint:

// src/Entity/Author.php
namespace App\Entity;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
use Symfony\Component\Validator\Mapping\ClassMetadata;
class Author
{
    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $callback = function ($object, ExecutionContextInterface $context, $payload) {
            // ...
        };
        $metadata->addConstraint(new Assert\Callback($callback));
    }
}

Warning

Using a Closure together with annotation configuration will disable the annotation cache for that class/property/method because Closure cannot be cached. For best performance, it’s recommended to use a static callback method.

Options

`callback`

type: string, array or Closure [default option]

The callback option accepts three different formats for specifying the callback method:

A string containing the name of a concrete or static method;
An array callable with the format ['<Class>', '<method>'];
A closure.

Concrete callbacks receive an Symfony\Component\Validator\Context\ExecutionContextInterface instance as only argument.

Static or closure callbacks receive the validated object as the first argument and the Symfony\Component\Validator\Context\ExecutionContextInterface instance as the second argument.

`groups`

type: array | string

It defines the validation group or groups this constraint belongs to. Read more about validation groups.

`payload`

type: mixed default: null

This option can be used to attach arbitrary domain-specific data to a constraint. The configured payload is not used by the Validator component, but its processing is completely up to you.

For example, you may want to use several error levels to present failed constraints differently in the front-end depending on the severity of the error.

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