In Doctrine, how to achieve additional model functionalities for Entity

1)Have you tried catching the exception inside the getter method of the "group"? so that you can catch the exception and return "null" in case an exception occured.

2) as from the doctrine 2.1 documentation: "Associations are marked as Lazy by default, which means the whole collection object for an association is populated the first time its accessed." http://doctrine-orm.readthedocs.org/projects/doctrine-orm/en/latest/tutorials/extra-lazy-associations.html

Well, what about creating a service, that is going to wrap your CRUD operations on the User entity, let's say UserService? This way, you can leave group_id as it is and add group field that is not managed (no annotations, not persisted to DB).

The UserService will have getGroup method, that will take User as an argument, then retrieve his group_id and use EntityManager (or indeed GroupService) to fetch the Group entity, if none was found, you will return null, otherwise you will set the returned Group to the unmanaged field of the entity, so you don't have to fetch it again next time.

Considering your specific use-case, your best bet are the Doctrine event subscribers.

Please be careful as those are separate from the regular Symfony event subscribers. The latter are related to the generic Symfony workflow and the former is specific to Doctrine.

Specifically, the postLoad event is what you need. The idea here is to:

1. Add a group property to User with corresponding typehinted getter and setter
2. Create a custom Doctrine subscriber, called MyBundle\Entity\EventSubscriber\UserSubscriber
3. Inject it with the Doctrine entity manager service

4. Create the postLoad method like this:

   public function postLoad(LifecycleEventArgs $args) { $user = $args->getEntity(); if ($user instanceof User && $user->getGroupId()) { $r = $this->em->getRepository('MyBundle:Group'); $group = $r->find($user->getGroupId()); if ($group instanceof Group) { $user->setGroup($group); } // If not an instance of Group, no group can be found: do nothing and leave it NULL } } 

The postLoad method is called whenever a Doctrine entity is loaded from the manager, meaning all entities found through Doctrine will be populated with their group when possible.

If you want lazy loading... first, are you sure you want this? User groups are generally used in most pages in Symfony applications - in authorization checks, for instance. If groups are loaded at every page it really isn't worth it.

If you absolutely need this, you could use the Doctrine proxy factory service and populate your User with a proxy instead of an actual entity (not sure how this works exactly):

$group = $this->em->getProxyFactory()->getProxy('MyBundle:Group', $user->getGroupId()); $user->setGroup($group); 

In that case you would have to keep the following because some loading attempts will fail if the id does not exist:

/** * Get group * * @return \AppBundle\Entity\Group */ public function getGroup() { static $loaded = false; if (!$loaded) { try { $this->group; } catch (\Doctrine\ORM\EntityNotFoundException $e) { $this->group = null; } $loaded = true; } return $this->group; } 

I tweaked the original code of Jan Mares as at every call of getGroup() Doctrine would have attempted to load the Group.

OK, first, your User-Group relationship is not correctly defined. You absolutely need to add the ManyToOne relationship:

/** * @var \AppBundle\Entity\Group * * @ORM\ManyToOne(targetEntity="AppBundle\Entity\Group") * @ORM\JoinColumns({ * @ORM\JoinColumn(name="group_id", referencedColumnName="id") * }) */ private $group; 

Some word about this. In the JoinColumns clause, by default, the relationship is nullable, meaning you can have NULL instead of the foreign key in the resulting group_id column (the join column that Doctrine will create for you).

If you want to have a non-nullable relationship, the definition has to go like this instead:

/** * @var \AppBundle\Entity\Group * * @ORM\ManyToOne(targetEntity="AppBundle\Entity\Group") * @ORM\JoinColumns({ * @ORM\JoinColumn(name="group_id", referencedColumnName="id", nullable=false) * }) */ private $group; 

So, by default, you can have a NULL group for a User. Once this is properly defined, regarding your questions:

1.

If your application is properly created, you should never end up with a User related to a Group that has not yet been committed to the database. Every Group you tie to a User has to be taken from Doctrine somehow before persisting the User itself. Be it from within the application or from a form. If you need to validate that the Group exists before persisting the User, you have to tackle the problem upstream instead, by being 100% sure that any Group you use is taken from the database.

In this specific context, the setGroup setter should already ensure that what is provided is indeed a Group entity (if not you should add a typehint), and Doctrine already ensures that this entity already exists in the database. I agree that the Doctrine errors can get ugly, but a delivered product should not include any of those anyway.

Understand that Symfony validation is generally used with forms, with the intent of validating potential violations introduced by the end user, not by the developer (generally).

2.

With a properly defined relationship, as shown above, Doctrine will take care of this for you automatically. By default, all Doctrine relationships are loaded lazily.

Also:

/** * Get group * * @return \AppBundle\Entity\Group */ public function getGroup() { try { $group = $this->group; } catch (\Doctrine\ORM\EntityNotFoundException $e) { $group = null; } return $group; } 

You don't need to do this. Remove it.