Synchronizing Owning & Inverse Sides

Keep on Learning!

If you liked what you've learned so far, dive in!
Subscribe to get access to this tutorial plus
video, code and script downloads.

Start your All-Access Pass
Buy just this tutorial for $12.00

Ultimately, when we submit... we're still only updating the studiedGenuses property in User, which is the inverse side of this relationship:

... lines 1 - 16
class User implements UserInterface
{
... lines 19 - 77
/**
* @ORM\ManyToMany(targetEntity="Genus", mappedBy="genusScientists")
... line 80
*/
private $studiedGenuses;
... lines 83 - 236
}

So, nothing actually saves.

How can we set the owning side? Why not just do it inside the adder and remover methods? At the bottom of addStudiedGenus(), add $genus->addGenusScientist($this):

... lines 1 - 16
class User implements UserInterface
{
... lines 19 - 223
public function addStudiedGenus(Genus $genus)
{
if ($this->studiedGenuses->contains($genus)) {
return;
}
$this->studiedGenuses[] = $genus;
$genus->addGenusScientist($this);
}
... lines 233 - 238
}

Booya, we just set the owning side of the relationship!

In removeStudiedGenus(), do the same thing: $genus->removeGenusScientist($this):

... lines 1 - 16
class User implements UserInterface
{
... lines 19 - 233
public function removeStudiedGenus(Genus $genus)
{
$this->studiedGenuses->removeElement($genus);
$genus->removeGenusScientist($this);
}
}

So.... yea, that's all we need to do. Go back to the form, uncheck a genus, check a genus and hit update. It's alive!!!

We didn't need to add a lot of code to get this to work... but this situation has caused many developers to lose countless hours trying to get their relationship to save. To summarize: if you're modifying the inverse side of a relationship, set the by_reference form option to false, create an adder and remover function, and make sure you set the owning side of the relationship in each. That is it.

Synchronizing Both Sides

So, we're done! Well, technically we are done, but there is one last, tiny, teeny detail that I'd like to perfect. In Genus, when we call addGenusScientist(), it would be nice if we also updated this User to know that this Genus is now being studied by it. In other words, it would be nice if we called $user->addStudiedGenus($this):

... lines 1 - 14
class Genus
{
... lines 17 - 174
public function addGenusScientist(User $user)
{
if ($this->genusScientists->contains($user)) {
return;
}
$this->genusScientists[] = $user;
// not needed for persistence, just keeping both sides in sync
$user->addStudiedGenus($this);
}
... lines 185 - 199
}

I'm also going to add a note: this is not needed for persistence, but it might save you from an edge-case bug. Suppose we called $genus->addGenusScientist() to link a User to the Genus. Then later, during the same request - that's important - we have that same User object, and we call getStudiedGenuses(). We would want the Genus that was just linked to be in that collection. This does that! We're guaranteeing that both sides of the relationship stay synchronized.

Do the same thing down in the remover: $user->removeStudiedGenus($this):

... lines 1 - 14
class Genus
{
... lines 17 - 185
public function removeGenusScientist(User $user)
{
$this->genusScientists->removeElement($user);
// not needed for persistence, just keeping both sides in sync
$user->removeStudiedGenus($this);
}
... lines 192 - 199
}

Have Fun and Avoid Infinite Recursion!

That's great! Oh, except for one thing I just introduced: infinite recursion! When we call removeStudiedGenus(), that calls removeGenusScientist(), which calls removeStudiedGenus(), and so on... forever. And we are too busy to let our scripts run forever!

The fix is easy - I was being lazy. Add an if statement in the remove functions, like if !$this->studiedGenuses->contains($genus), then just return:

... lines 1 - 16
class User implements UserInterface
{
... lines 19 - 233
public function removeStudiedGenus(Genus $genus)
{
if (!$this->studiedGenuses->contains($genus)) {
return;
}
$this->studiedGenuses->removeElement($genus);
$genus->removeGenusScientist($this);
}
}

In other words, if the $genus is not in the studiedGenuses array, there's no reason to try to remove it.

Inside Genus, do the exact same thing: if !$this->genusScientists->contains($user), then return:

... lines 1 - 14
class Genus
{
... lines 17 - 185
public function removeGenusScientist(User $user)
{
if (!$this->genusScientists->contains($user)) {
return;
}
$this->genusScientists->removeElement($user);
// not needed for persistence, just keeping both sides in sync
$user->removeStudiedGenus($this);
}
... lines 196 - 203
}

Bye bye recursion.

Head back: uncheck a few genuses, check a few more and.... save! It works perfectly. We don't really notice this last perfection... but it may help us out in the future.

Leave a comment!

This course is built on Symfony 3, but most of the concepts apply just fine to newer versions of Symfony.

What PHP libraries does this tutorial use?

// composer.json
{
    "require": {
        "php": ">=5.5.9",
        "symfony/symfony": "3.1.*", // v3.1.4
        "doctrine/orm": "^2.5", // v2.7.2
        "doctrine/doctrine-bundle": "^1.6", // 1.6.4
        "doctrine/doctrine-cache-bundle": "^1.2", // 1.3.0
        "symfony/swiftmailer-bundle": "^2.3", // v2.3.11
        "symfony/monolog-bundle": "^2.8", // 2.11.1
        "symfony/polyfill-apcu": "^1.0", // v1.2.0
        "sensio/distribution-bundle": "^5.0", // v5.0.22
        "sensio/framework-extra-bundle": "^3.0.2", // v3.0.16
        "incenteev/composer-parameter-handler": "^2.0", // v2.1.2
        "knplabs/knp-markdown-bundle": "^1.4", // 1.4.2
        "doctrine/doctrine-migrations-bundle": "^1.1", // 1.1.1
        "stof/doctrine-extensions-bundle": "^1.2" // v1.2.2
    },
    "require-dev": {
        "sensio/generator-bundle": "^3.0", // v3.0.7
        "symfony/phpunit-bridge": "^3.0", // v3.1.3
        "nelmio/alice": "^2.1", // 2.1.4
        "doctrine/doctrine-fixtures-bundle": "^2.3" // 2.3.0
    }
}