Doctrine多对多关联：如何按额外字段过滤关联对象并实现分组方法

核心问题说明 #

你当前使用Doctrine的ManyToMany注解建立了Child与Parent的关联，但关联表ROLE包含额外的PARENTTYPE（M/F）字段，无法直接通过原映射获取该字段并过滤母亲/父亲集合。

解决方案 #

1. 正确方案：将关联表转为独立实体（推荐） #

Doctrine的ManyToMany关联仅适用于无额外字段的纯关联表，当关联表有自定义字段时，必须将其转为独立实体，通过OneToMany/ManyToOne关联实现。

步骤1：创建中间实体ParentChildRole

<?php

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="ROLE")
 */
class ParentChildRole
{
    /**
     * @ORM\Id
     * @ORM\ManyToOne(targetEntity=Child::class, inversedBy="parentRoles")
     * @ORM\JoinColumn(name="children_ID", referencedColumnName="ID")
     */
    private $child;

    /**
     * @ORM\Id
     * @ORM\ManyToOne(targetEntity=Parent::class, inversedBy="childRoles")
     * @ORM\JoinColumn(name="parent_ID", referencedColumnName="ID")
     */
    private $parent;

    /**
     * @ORM\Column(type="string", length=1)
     */
    private $parentType;

    public function __construct(Child $child, Parent $parent, string $parentType)
    {
        $this->child = $child;
        $this->parent = $parent;
        $this->parentType = $parentType;
    }

    public function getParent(): Parent
    {
        return $this->parent;
    }

    public function getParentType(): string
    {
        return $this->parentType;
    }
}

步骤2：修改Child实体映射与方法

替换原$parents关联，新增$parentRoles，并实现getMothers()和getFathers()：

<?php

namespace App\Entity;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 */
class Child
{
    // ... 其他字段和映射

    /**
     * @var Collection<int, ParentChildRole>
     * @ORM\OneToMany(targetEntity=ParentChildRole::class, mappedBy="child", cascade={"persist", "remove"})
     */
    private $parentRoles;

    public function __construct()
    {
        $this->parentRoles = new ArrayCollection();
    }

    public function addParentRole(ParentChildRole $parentRole): self
    {
        if (!$this->parentRoles->contains($parentRole)) {
            $this->parentRoles->add($parentRole);
        }

        return $this;
    }

    public function getMothers(): array
    {
        return $this->parentRoles->filter(function (ParentChildRole $role) {
            return $role->getParentType() === 'M';
        })->map(function (ParentChildRole $role) {
            return $role->getParent();
        })->toArray();
    }

    public function getFathers(): array
    {
        return $this->parentRoles->filter(function (ParentChildRole $role) {
            return $role->getParentType() === 'F';
        })->map(function (ParentChildRole $role) {
            return $role->getParent();
        })->toArray();
    }
}

步骤3：修改Parent实体映射

<?php

namespace App\Entity;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 */
class Parent
{
    // ... 其他字段和映射

    /**
     * @var Collection<int, ParentChildRole>
     * @ORM\OneToMany(targetEntity=ParentChildRole::class, mappedBy="parent", cascade={"persist", "remove"})
     */
    private $childRoles;

    public function __construct()
    {
        $this->childRoles = new ArrayCollection();
    }
}

2. 临时方案：Repository中编写查询过滤（不推荐） #

如果暂时不想调整实体结构，可在ChildRepository中编写DQL查询，直接过滤出指定类型的父集合：

<?php

namespace App\Repository;

use App\Entity\Child;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;

class ChildRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, Child::class);
    }

    public function findWithMothers(int $childId): Child
    {
        return $this->createQueryBuilder('c')
            ->leftJoin('c.parents', 'p')
            ->leftJoin('ROLE', 'r', 'WITH', 'c.id = r.children_ID AND p.id = r.parent_ID AND r.parentType = :type')
            ->setParameter('type', 'M')
            ->where('c.id = :id')
            ->setParameter('id', $childId)
            ->getQuery()
            ->getSingleResult();
    }

    public function findWithFathers(int $childId): Child
    {
        return $this->createQueryBuilder('c')
            ->leftJoin('c.parents', 'p')
            ->leftJoin('ROLE', 'r', 'WITH', 'c.id = r.children_ID AND p.id = r.parent_ID AND r.parentType = :type')
            ->setParameter('type', 'F')
            ->where('c.id = :id')
            ->setParameter('id', $childId)
            ->getQuery()
            ->getSingleResult();
    }
}

关键结论 #

• 无法通过Doctrine的ManyToMany注解直接过滤：该关联会将中间表视为黑盒，无法访问其额外字段；
• 推荐使用中间实体方案：这是Doctrine处理带额外字段关联表的标准方式，能在实体层面直接实现类型过滤；
• 临时查询方案仅适用于特定场景：无法在实体的get方法中直接获取过滤后的集合，只能用于单独查询。

内容的提问来源于stack exchange，提问作者b126