How to Provide Model Classes for several Doctrine Implementations

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

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

When building a bundle that could be used not only with Doctrine ORM but also the CouchDB ODM, MongoDB ODM or PHPCR ODM, you should still only write one model class. The Doctrine bundles provide a compiler pass to register the mappings for your model classes.

Note

For non-reusable bundles, the easiest option is to put your model classes in the default locations: Entity for the Doctrine ORM or Document for one of the ODMs. For reusable bundles, rather than duplicate model classes just to get the auto-mapping, use the compiler pass.

In your bundle class, write the following code to register the compiler pass. This one is written for the CmfRoutingBundle, so parts of it will need to be adapted for your case:

        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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
        use Doctrine\Bundle\CouchDBBundle\DependencyInjection\Compiler\DoctrineCouchDBMappingsPass;
use Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler\DoctrineOrmMappingsPass;
use Doctrine\Bundle\MongoDBBundle\DependencyInjection\Compiler\DoctrineMongoDBMappingsPass;
use Doctrine\Bundle\PHPCRBundle\DependencyInjection\Compiler\DoctrinePhpcrMappingsPass;
use Symfony\Cmf\RoutingBundle\Model;

class CmfRoutingBundle extends Bundle
{
    public function build(ContainerBuilder $container)
    {
        parent::build($container);
        // ...

        $modelDirectory = realpath(__DIR__.'/Resources/config/doctrine/model');
        $mappings = [
            $modelDirectory => Model::class,
        ];

        if (class_exists(DoctrineOrmMappingsPass::class)) {
            $container->addCompilerPass(
                DoctrineOrmMappingsPass::createXmlMappingDriver(
                    $mappings,
                    ['cmf_routing.model_manager_name'],
                    'cmf_routing.backend_type_orm',
                    ['CmfRoutingBundle' => Model::class]
            ));
        }

        if (class_exists(DoctrineMongoDBMappingsPass::class)) {
            $container->addCompilerPass(
                DoctrineMongoDBMappingsPass::createXmlMappingDriver(
                    $mappings,
                    ['cmf_routing.model_manager_name'],
                    'cmf_routing.backend_type_mongodb',
                    ['CmfRoutingBundle' => Model::class]
            ));
        }

        if (class_exists(DoctrineCouchDBMappingsPass::class)) {
            $container->addCompilerPass(
                DoctrineCouchDBMappingsPass::createXmlMappingDriver(
                    $mappings,
                    ['cmf_routing.model_manager_name'],
                    'cmf_routing.backend_type_couchdb',
                    ['CmfRoutingBundle' => Model::class]
            ));
        }

        if (class_exists(DoctrinePhpcrMappingsPass::class)) {
            $container->addCompilerPass(
                DoctrinePhpcrMappingsPass::createXmlMappingDriver(
                    $mappings,
                    ['cmf_routing.model_manager_name'],
                    'cmf_routing.backend_type_phpcr',
                    ['CmfRoutingBundle' => Model::class]
            ));
        }
    }
}
    

Note the class_exists check. This is crucial, as you do not want your bundle to have a hard dependency on all Doctrine bundles but let the user decide which to use.

The compiler pass provides factory methods for all drivers provided by Doctrine: Annotations, XML, Yaml, PHP and StaticPHP. The arguments are:

A map/hash of absolute directory path to namespace;
An array of container parameters that your bundle uses to specify the name of the Doctrine manager that it is using. In the example above, the CmfRoutingBundle stores the manager name that's being used under the cmf_routing.model_manager_name parameter. The compiler pass will append the parameter Doctrine is using to specify the name of the default manager. The first parameter found is used and the mappings are registered with that manager;
An optional container parameter name that will be used by the compiler pass to determine if this Doctrine type is used at all. This is relevant if your user has more than one type of Doctrine bundle installed, but your bundle is only used with one type of Doctrine;
A map/hash of aliases to namespace. This should be the same convention used by Doctrine auto-mapping. In the example above, this allows the user to call $om->getRepository('CmfRoutingBundle:Route').

Note

The factory method is using the SymfonyFileLocator of Doctrine, meaning it will only see XML and YML mapping files if they do not contain the full namespace as the filename. This is by design: the SymfonyFileLocator simplifies things by assuming the files are just the "short" version of the class as their filename (e.g. BlogPost.orm.xml)

If you also need to map a base class, you can register a compiler pass with the DefaultFileLocator like this. This code is taken from the DoctrineOrmMappingsPass and adapted to use the DefaultFileLocator instead of the SymfonyFileLocator:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
        use AppBundle\Model;
use Doctrine\ORM\Mapping\Driver\XmlDriver;
use Doctrine\Persistence\Mapping\Driver\DefaultFileLocator;

// ...
private function buildMappingCompilerPass()
{
    $fileLocator = new Definition(DefaultFileLocator::class, [
        [realpath(__DIR__ . '/Resources/config/doctrine-base')],
        '.orm.xml'
    ]);
    $driver = new Definition(XmlDriver::class, [$fileLocator]);

    return new DoctrineOrmMappingsPass(
        $driver,
        [Model::class],
        ['your_bundle.manager_name'],
        'your_bundle.orm_enabled'
    );
}
    

Note that you do not need to provide a namespace alias unless your users are expected to ask Doctrine for the base classes.

Now place your mapping file into /Resources/config/doctrine-base with the fully qualified class name, separated by . instead of \, for example Other.Namespace.Model.Name.orm.xml. You may not mix the two as otherwise the SymfonyFileLocator will get confused.

Adjust accordingly for the other Doctrine implementations.

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

TOC

Version