Symfony 4 + Doctrine：持久化子实体时避免重复条目

首先得帮你理清一个关键点：你提到的捕获重复键异常后EntityManager失效的问题是真实存在的——当Doctrine抛出UniqueConstraintViolationException时，EntityManager的内部状态会变得不一致（事务可能已回滚，缓存的实体状态也会混乱），此时继续用同一个EntityManager操作确实容易出问题，必须重置EntityManager或者重新开启事务，这也是你觉得重新处理数据仍有问题的原因。

下面给你几个更靠谱的解决方案，适配你不想手动归一化大量动态结构的需求：

方案1：直接利用MySQL的INSERT ON DUPLICATE KEY UPDATE特性（推荐） #

既然你倾向于用MySQL的原生特性，最直接的方式是给Address实体写一个自定义Repository方法，绕过Doctrine的ORM自动persist，直接执行原生SQL实现“存在则更新，不存在则插入”。

步骤1：确保Address实体的ID策略正确 #

因为地址ID是来自API的外部值，不是自增生成的，必须修改实体映射：

// src/Entity/Address.php
namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass=AddressRepository::class)
 * @ORM\Table(uniqueConstraints={@ORM\UniqueConstraint(name="address_id_unique", columns={"id"})})
 */
class Address
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="NONE") // 关键：禁用自增，使用外部传入的ID
     */
    private $id;

    // 其他字段示例
    /** @ORM\Column(type="string") */
    private $street;

    /** @ORM\Column(type="string") */
    private $city;

    // getter/setter...
}

步骤2：在AddressRepository中实现自定义方法 #

// src/Repository/AddressRepository.php
namespace App\Repository;

use App\Entity\Address;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Doctrine\DBAL\Connection;

class AddressRepository extends ServiceEntityRepository
{
    private $connection;

    public function __construct(ManagerRegistry $registry, Connection $connection)
    {
        parent::__construct($registry, Address::class);
        $this->connection = $connection;
    }

    /**
     * 执行INSERT ON DUPLICATE KEY UPDATE，处理重复地址
     */
    public function upsert(Address $address): void
    {
        $sql = <<<SQL
            INSERT INTO address (id, street, city)
            VALUES (:id, :street, :city)
            ON DUPLICATE KEY UPDATE
                street = VALUES(street),
                city = VALUES(city)
            -- 这里可以继续添加需要更新的字段，和INSERT部分对应即可
        SQL;

        $this->connection->executeQuery($sql, [
            'id' => $address->getId(),
            'street' => $address->getStreet(),
            'city' => $address->getCity(),
        ]);
    }
}

步骤3：在保存订单前批量处理地址 #

因为你是通过级联保存订单，所以可以先遍历所有订单中的地址，用自定义方法处理重复，再保存订单：

// 在你的业务服务或控制器中
use App\Repository\AddressRepository;
use Doctrine\ORM\EntityManagerInterface;

// ...

public function processOrders(array $ordersData, EntityManagerInterface $em, AddressRepository $addressRepo): void
{
    // 先处理所有地址，避免重复插入
    foreach ($ordersData as $orderData) {
        foreach ($orderData['customers'] as $customerData) {
            foreach ($customerData['addresses'] as $addressData) {
                $address = new Address();
                $address->setId($addressData['id']);
                $address->setStreet($addressData['street']);
                $address->setCity($addressData['city']);
                // 用自定义upsert方法处理
                $addressRepo->upsert($address);
            }
        }

        // 构建Order实体（这里省略你的实体映射逻辑）
        $order = $this->mapToOrderEntity($orderData);
        $em->persist($order);
    }

    // 最后flush订单即可，地址已经提前处理完毕
    $em->flush();
}

这个方案的优势是直接利用MySQL的高效特性，避免ORM层面的额外开销，也不需要手动维护大量动态结构的归一化逻辑。

方案2：用Doctrine生命周期事件自动处理重复地址 #

如果你更倾向于用ORM的原生机制，可以通过监听prePersist事件，在地址被级联保存前自动检查并合并重复实体。

步骤1：创建事件监听器 #

// src/EventListener/AddressDuplicateListener.php
namespace App\EventListener;

use App\Entity\Address;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Event\PrePersistEventArgs;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;

class AddressDuplicateListener
{
    public function __construct(
        private EntityManagerInterface $em,
        private PropertyAccessorInterface $propertyAccessor
    ) {}

    public function prePersist(PrePersistEventArgs $args): void
    {
        $entity = $args->getObject();
        if (!$entity instanceof Address) {
            return;
        }

        // 查找数据库中已存在的同ID地址
        $existingAddress = $this->em->getRepository(Address::class)->find($entity->getId());
        if (!$existingAddress) {
            return;
        }

        // 复制当前实体的所有属性到已有实体（自动更新字段）
        $reflectionClass = new \ReflectionClass(Address::class);
        foreach ($reflectionClass->getProperties() as $property) {
            if ($property->getName() === 'id') {
                continue;
            }
            $value = $this->propertyAccessor->getValue($entity, $property->getName());
            $this->propertyAccessor->setValue($existingAddress, $property->getName(), $value);
        }

        // 合并已有实体到EntityManager，同时取消当前实体的persist
        $this->em->merge($existingAddress);
        $this->em->detach($entity);
    }
}

步骤2：注册监听器 #

在config/services.yaml中添加：

services:
    App\EventListener\AddressDuplicateListener:
        tags:
            - { name: doctrine.event_listener, event: prePersist }
        arguments:
            $propertyAccessor: '@property_accessor'

这个方案完全基于Doctrine的ORM机制，不需要手动处理SQL，适合字段较多且经常变动的实体，但性能略低于原生SQL方案。

关于捕获异常的补充说明 #

如果还是想尝试捕获异常的方式，必须在捕获后重置EntityManager的状态：

try {
    $em->flush();
} catch (\Doctrine\DBAL\Exception\UniqueConstraintViolationException $e) {
    // 回滚事务
    $em->getConnection()->rollBack();
    // 清除EntityManager的所有缓存状态
    $em->clear();
    // 重新处理数据（比如先手动去重地址，再重新persist）
    $this->reprocessOrders($ordersData, $em);
}

不过这种方式需要额外处理重复数据的逻辑，效率较低，一般只作为兜底方案。

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