How to Define Relationships with Abstract Classes and Interfaces

Referencing Entities with Abstract Classes and Interfaces

One of the goals of bundlesisto create discrete bundles of functionality

functionality in other applications without including unnecessary items.

In applications where functionalityissegregated with minimal concrete dependencies

it might be hard to prevent hard dependencies on entities between modules.

Doctrine 2.2 includes a new utility called the ``ResolveTargetEntityListener``,

that functions by intercepting certain calls inside Doctrine and rewriting

``targetEntity`` parameters in your metadata mapping at runtime. It means that

in your bundleyou are able to use an interface or abstract class in your

mappings and expectcorrect mapping to a concrete entity at runtime.

you are able to use an interface or abstract class in your mappings and expect

correct mapping to a concrete entity at runtime.

This functionality allows you to define relationships between different entities

without making them hard dependencies.

Background

Suppose you have anInvoiceBundle which providesinvoicing functionality

and aCustomerBundlethat contains customer management tools. You want

to keep these separated, because theycan be used in other systems without

each other, but for your application you want to use them together.

Suppose you have anapplication which providestwo modules; an Invoice module which

provides invoicing functionality,and aCustomer modulethat contains customer management

tools. You wantto keepdependencies betweenthesemodulesseparated, because theyshould

not be aware of the other module's implementation details.

In this case, you have an ``Invoice`` entity with a relationship toa

non-existent object, an``InvoiceSubjectInterface``.The goalisto get

the ``ResolveTargetEntityListener`` to replace any mention of the interface

In this case, you have an ``Invoice`` entity with a relationship tothe interface

``InvoiceSubjectInterface``.Thisisnot recognized as a valid entity by Doctrine.

The goal is to getthe ``ResolveTargetEntityListener`` to replace any mention of the interface

with a real object that implements that interface.

Set up

Next, you need to configure thelistener, which tells the DoctrineBundle

Next, you need to configure the``resolve_target_entities`` option, which tells the DoctrineBundle

about the replacement:

..configuration-block::

With the ``ResolveTargetEntityListener``, you are able to decouple your

bundles, keeping them usable by themselves, but still being able to

modules, keeping them usable by themselves, but still being able to

define relationships between different objects. By using this method,

yourbundles will end up being easier to maintain independently.

yourmodules will end up being easier to maintain independently.