ClassMetadata

1
namespace Doctrine\Common\Persistence\Mapping;

interface ClassMetadata
{
    public function getName();
    public function getIdentifier();
    public function getReflectionClass();
    public function isIdentifier($fieldName);
    public function hasField($fieldName);
    public function hasAssociation($fieldName);
    public function isSingleValuedAssociation($fieldName);
    public function isCollectionValuedAssociation($fieldName);
    public function getFieldNames();
    public function getIdentifierFieldNames();
    public function getAssociationNames();
    public function getTypeOfField($fieldName);
    public function getAssociationTargetClass($assocName);
    public function isAssociationInverseSide($assocName);
    public function getAssociationMappedByTargetField($assocName);
    public function getIdentifierValues($object);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

ClassMetadataFactory

The Doctrine\Common\Persistence\Mapping\ClassMetadataFactory class can be used to manage the instances for each of your mapped PHP classes.

1
namespace Doctrine\Common\Persistence\Mapping;

interface ClassMetadataFactory
{
    public function getAllMetadata();
    public function getMetadataFor($className);
    public function hasMetadataFor($className);
    public function setMetadataFor($className, $class);
    public function isTransient($className);
}
2
3
4
5
6
7
8
9
10

FileDriver

The file driver operates in a mode where it loads the mapping files of individual classes on demand. This requires the user to adhere to the convention of 1 mapping file per class and the file names of the mapping files must correspond to the full class name, including namespace, with the namespace delimiters '', replaced by dots '.'.

Extend the Doctrine\Common\Persistence\Mapping\Driver\FileDriver class to implement your own file driver. Here is an example JSON file driver implementation.

1
use Doctrine\Common\Persistence\Mapping\Driver\FileDriver;

final class JSONFileDriver extends FileDriver
{
    public function loadMetadataForClass($className, ClassMetadata $metadata)
    {
        $mappingFileData = $this->getElement($className);

        // use the array of mapping information from the file to populate the $metadata instance
    }

    protected function loadMappingFile($file)
    {
        return json_decode($file, true);
    }
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Now you can use it like the following.

1
use Doctrine\Common\Persistence\Mapping\Driver\DefaultFileLocator;

$fileLocator = new DefaultFileLocator('/path/to/mapping/files', 'json');

$jsonFileDriver = new JSONFileDriver($fileLocator);
2
3
4
5

Now if you have a class named App\Model\User and you can load the mapping information like this.

1
use App\Model\User;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;

$classMetadata = new ClassMetadata();

// looks for a file at /path/to/mapping/files/App.Model.User.json
$jsonFileDriver->loadMetadataForClass(User::class, $classMetadata);
2
3
4
5
6
7

AnnotationDriver

1
composer require doctrine/annotations

The AnnotationDriver reads the mapping metadata from docblock annotations.

1
final class MyAnnotationDriver extends AnnotationDriver
{
    public function loadMetadataForClass($className, ClassMetadata $metadata)
    {
        /** @var ClassMetadata $class */
        $reflClass = $class->getReflectionClass();

        $classAnnotations = $this->reader->getClassAnnotations($reflClass);

        // Use the reader to read annotations from your classes to then populate the $metadata instance.
    }
}
2
3
4
5
6
7
8
9
10
11
12

Now you can use it like the following:

1
use App\Model\User;
use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;

$annotationReader = new AnnotationReader();

$annotationDriver = new AnnotationDriver($annotationReader, '/path/to/classes/with/annotations');

$classMetadata = new ClassMetadata();

// looks for a PHP file at /path/to/classes/with/annotations/App/Model/User.php
$annotationDriver->loadMetadataForClass(User::class, $classMetadata);
2
3
4
5
6
7
8
9
10
11
12

PHPDriver

The PHPDriver includes PHP files which just populate ClassMetadata instances with plain PHP code.

1
use Doctrine\Common\Persistence\Mapping\Driver\PHPDriver;

$phpDriver = new PHPDriver('/path/to/mapping/files');
2
3

Now you can use it like the following:

1
use App\Model\User;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;

$classMetadata = new ClassMetadata();

// looks for a PHP file at /path/to/mapping/files/App.Model.User.php
$phpDriver->loadMetadataForClass(User::class, $classMetadata);
2
3
4
5
6
7

Inside the /path/to/mapping/files/App.Model.User.php file you can write raw PHP code to populate a ClassMetadata instance. You will have access to a variable named $metadata inside the file that you can use to populate the mapping metadata.

1
use App\Model\User;

$metadata->name = User::class;

// ...
2
3
4
5

StaticPHPDriver

The StaticPHPDriver calls a static loadMetadata() method on your model classes where you can manually populate the ClassMetadata instance.

1
$staticPHPDriver = new StaticPHPDriver('/path/to/classes');

$classMetadata = new ClassMetadata();

// looks for a PHP file at /path/to/classes/App/Model/User.php
$phpDriver->loadMetadataForClass(User::class, $classMetadata);
2
3
4
5
6

Your class in App\Model\User would look like the following.

1
namespace App\Model;

final class User
{
    // ...

    public static function loadMetadata(ClassMetadata $metadata)
    {
        // populate the $metadata instance
    }
}
2
3
4
5
6
7
8
9
10
11