How to Apply only a Subset of all Your Validation Constraints (Validation Groups)
Warning: You are browsing the documentation for Symfony 2.x, which is no longer maintained.
Read the updated version of this page for Symfony 7.1 (the current stable version).
By default, when validating an object all constraints of this class will be checked whether or not they actually pass. In some cases, however, you will need to validate an object against only some constraints on that class. To do this, you can organize each constraint into one or more "validation groups" and then apply validation against just one group of constraints.
For example, suppose you have a User
class, which is used both when a
user registers and when a user updates their contact information later:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
// src/AppBundle/Entity/User.php
namespace AppBundle\Entity;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Validator\Constraints as Assert;
class User implements UserInterface
{
/**
* @Assert\Email(groups={"registration"})
*/
private $email;
/**
* @Assert\NotBlank(groups={"registration"})
* @Assert\Length(min=7, groups={"registration"})
*/
private $password;
/**
* @Assert\Length(min=2)
*/
private $city;
}
1 2 3 4 5 6 7 8 9 10 11
# src/AppBundle/Resources/config/validation.yml
AppBundle\Entity\User:
properties:
email:
- Email: { groups: [registration] }
password:
- NotBlank: { groups: [registration] }
- Length: { min: 7, groups: [registration] }
city:
- Length:
min: 2
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
<!-- 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
http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd
">
<class name="AppBundle\Entity\User">
<property name="email">
<constraint name="Email">
<option name="groups">
<value>registration</value>
</option>
</constraint>
</property>
<property name="password">
<constraint name="NotBlank">
<option name="groups">
<value>registration</value>
</option>
</constraint>
<constraint name="Length">
<option name="min">7</option>
<option name="groups">
<value>registration</value>
</option>
</constraint>
</property>
<property name="city">
<constraint name="Length">
<option name="min">7</option>
</constraint>
</property>
</class>
</constraint-mapping>
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
// src/AppBundle/Entity/User.php
namespace AppBundle\Entity;
use Symfony\Component\Validator\Mapping\ClassMetadata;
use Symfony\Component\Validator\Constraints as Assert;
class User
{
public static function loadValidatorMetadata(ClassMetadata $metadata)
{
$metadata->addPropertyConstraint('email', new Assert\Email(array(
'groups' => array('registration'),
)));
$metadata->addPropertyConstraint('password', new Assert\NotBlank(array(
'groups' => array('registration'),
)));
$metadata->addPropertyConstraint('password', new Assert\Length(array(
'min' => 7,
'groups' => array('registration'),
)));
$metadata->addPropertyConstraint('city', new Assert\Length(array(
"min" => 3,
)));
}
}
With this configuration, there are three validation groups:
Default
- Contains the constraints in the current class and all referenced classes that belong to no other group.
User
-
Equivalent to all constraints of the
User
object in theDefault
group. This is always the name of the class. The difference between this andDefault
is explained in How to Sequentially Apply Validation Groups. registration
-
Contains the constraints on the
email
andpassword
fields only.
Constraints in the Default
group of a class are the constraints that have
either no explicit group configured or that are configured to a group equal to
the class name or the string Default
.
Caution
When validating just the User object, there is no difference between the
Default
group and the User
group. But, there is a difference if
User
has embedded objects. For example, imagine User
has an
address
property that contains some Address
object and that you've
added the Valid constraint to this property
so that it's validated when you validate the User
object.
If you validate User
using the Default
group, then any constraints
on the Address
class that are in the Default
group will be used.
But, if you validate User
using the User
validation group, then
only constraints on the Address
class with the User
group will be
validated.
In other words, the Default
group and the class name group (e.g.
User
) are identical, except when the class is embedded in another
object that's actually the one being validated.
If you have inheritance (e.g. User extends BaseUser
) and you validate
with the class name of the subclass (i.e. User
), then all constraints
in the User
and BaseUser
will be validated. However, if you
validate using the base class (i.e. BaseUser
), then only the default
constraints in the BaseUser
class will be validated.
To tell the validator to use a specific group, pass one or more group names
as the third argument to the validate()
method:
1 2 3 4 5
// If you're using the new 2.5 validation API (you probably are!)
$errors = $validator->validate($author, null, array('registration'));
// If you're using the old 2.4 validation API, pass the group names as the second argument
// $errors = $validator->validate($author, array('registration'));
If no groups are specified, all constraints that belong to the group Default
will be applied.
Of course, you'll usually work with validation indirectly through the form library. For information on how to use validation groups inside forms, see How to Define the Validation Groups to Use.