是否有内置方法来获取Doctrine 2实体中的所有已更改/更新的字段


81

假设我检索一个实体$e并使用setter修改了它的状态:

$e->setFoo('a');
$e->setBar('b');

是否有可能检索已更改的字段数组?

在我的例子的情况下,我想检索foo => a, bar => b结果

PS:是的,我知道我可以修改所有访问器并手动实现此功能,但是我正在寻找一些方便的方法

Answers:


148

您可以使用 Doctrine\ORM\EntityManager#getUnitOfWork获取Doctrine\ORM\UnitOfWork

然后只需通过触发变更集计算(仅适用于托管实体)Doctrine\ORM\UnitOfWork#computeChangeSets()

您也可以使用类似的方法,例如,Doctrine\ORM\UnitOfWork#recomputeSingleEntityChangeSet(Doctrine\ORM\ClassMetadata $meta, $entity)如果您确切知道要检查的内容而无需遍历整个对象图。

之后,您可以用于Doctrine\ORM\UnitOfWork#getEntityChangeSet($entity)检索对对象的所有更改。

把它放在一起:

$entity = $em->find('My\Entity', 1);
$entity->setTitle('Changed Title!');
$uow = $em->getUnitOfWork();
$uow->computeChangeSets(); // do not compute changes if inside a listener
$changeset = $uow->getEntityChangeSet($entity);

注意。如果尝试获取preUpdate侦听器中的已更新字段,请不要重新计算更改集,因为更改集已经完成。只需调用getEntityChangeSet即可获取对该实体所做的所有更改。

警告:如注释中所述,不应在Doctrine事件侦听器之外使用此解决方案。这将破坏教义的行为。


4
下面的评论说,如果您调用$ em-> computerChangeSets(),它将破坏您稍后调用的常规$ em-> persist(),因为它看起来好像什么都没有改变。如果是这样,解决方案是什么,我们是否不调用该函数?
Chadwick Meyer

4
您不应在UnitOfWork的生命周期事件侦听器之外使用此API。
Ocramius 2014年

6
你不应该 这不是ORM的用途。在这种情况下,请通过在应用操作前后保留数据副本来使用手动差异。
Ocramius

6
@Ocramius,它可能不是它的原意,但无疑是有用的。如果只有一种方法可以使用Doctrine计算变化而没有副作用。例如,如果在UOW中有一个新的方法/类,您可以调用该方法/类以请求进行一系列更改。但这不会以任何方式改变/影响实际的持久性周期。那可能吗?
caponica

3
查看Mohamed Ramrami bellow使用$ em-> getUnitOfWork()-> getOriginalEntityData($ entity)发布的更好的解决方案
蜡笼

41

谨记要使用上述方法检查实体上的更改的用户。

$uow = $em->getUnitOfWork();
$uow->computeChangeSets();

$uow->computeChangeSets()方法由持久化例程内部使用,其方式使上述解决方案无法使用。这也是在方法注释中写的:@internal Don't call from the outside。在使用检查了对实体的更改之后$uow->computeChangeSets(),在方法末尾(对于每个受管实体)执行以下代码:

if ($changeSet) {
    $this->entityChangeSets[$oid]   = $changeSet;
    $this->originalEntityData[$oid] = $actualData;
    $this->entityUpdates[$oid]      = $entity;
}

$actualData数组保存对实体属性的当前更改。一旦将其写入$this->originalEntityData[$oid],这些尚未持久的更改即被视为实体的原始属性。

稍后,当$em->persist($entity)调用来将更改保存到实体时,它也涉及方法$uow->computeChangeSets(),但是现在将无法找到对实体的更改,因为这些尚未持久的更改被视为实体的原始属性。 。


1
@Ocramius在检查的答案中指定的内容完全相同
zerkms,

1
$ uow =克隆$ em-> getUnitOfWork(); 解决了这个问题
tvlooy 2014年

1
不支持克隆UoW,并且可能导致不良结果。
Ocramius

9
@Slavik Derevianko,你有什么建议?只是不打电话$uow->computerChangeSets()?或什么替代方法?
Chadwick Meyer 2014年

尽管这篇文章确实很有用(这是对以上答案的强烈警告),但它本身并不是解决方案。我已经编辑了接受的答案。
Matthieu Napoli

37

检查此公共(而非内部)功能:

$this->em->getUnitOfWork()->getOriginalEntityData($entity);

从教义回购中

/**
 * Gets the original data of an entity. The original data is the data that was
 * present at the time the entity was reconstituted from the database.
 *
 * @param object $entity
 *
 * @return array
 */
public function getOriginalEntityData($entity)

您要做的就是在您的实体中实现toArrayserialize函数并进行比较。像这样的东西:

$originalData = $em->getUnitOfWork()->getOriginalEntityData($entity);
$toArrayEntity = $entity->toArray();
$changes = array_diff_assoc($toArrayEntity, $originalData);

1
当实体与另一个实体(可以是OneToOne)关联时,如何将其应用于情况?这种情况下,当我在顶级lvl实体上运行getOriginalEntityData时,其相关实体的原始数据并不是真正的原始数据,而是更新的。
mu4ddi3

5

您可以使用“通知策略”跟踪更改。

首先,实现NotifyPropertyChanged接口:

/**
 * @Entity
 * @ChangeTrackingPolicy("NOTIFY")
 */
class MyEntity implements NotifyPropertyChanged
{
    // ...

    private $_listeners = array();

    public function addPropertyChangedListener(PropertyChangedListener $listener)
    {
        $this->_listeners[] = $listener;
    }
}

然后,只需在每个更改数据的方法上调用_onPropertyChanged即可将实体抛出,如下所示:

class MyEntity implements NotifyPropertyChanged
{
    // ...

    protected function _onPropertyChanged($propName, $oldValue, $newValue)
    {
        if ($this->_listeners) {
            foreach ($this->_listeners as $listener) {
                $listener->propertyChanged($this, $propName, $oldValue, $newValue);
            }
        }
    }

    public function setData($data)
    {
        if ($data != $this->data) {
            $this->_onPropertyChanged('data', $this->data, $data);
            $this->data = $data;
        }
    }
}

7
实体内部的监听器?疯狂!认真地讲,跟踪策略看起来是一个不错的解决方案,有什么办法可以在实体外部定义侦听器(我正在使用Symfony2 DoctrineBundle)。
吉尔达斯(Gildas)2014年

这是错误的解决方案。您应该关注域事件。github.com/gpslab/domain-event
ghost404 '19


2

如果有人仍然对所接受的答案以外的其他方式感兴趣(它对我不起作用,我个人认为比这种方式更混乱)。

我安装了JMS序列化程序包,并在我认为发生更改的每个实体和每个属性上添加了@Group({“ changed_entity_group”})。这样,我就可以在旧实体和更新后的实体之间进行序列化,之后只需要说$ oldJson == $ updatedJson。如果您感兴趣或想要考虑的属性发生了变化,那么JSON将会有所不同,并且甚至想要注册专门更改的内容,那么您可以将其转换为数组并搜索差异。

我之所以使用此方法,是因为我主要对一堆实体的一些属性感兴趣,而不是对整个实体感兴趣。一个有用的示例是,如果您有一个@PrePersist @PreUpdate并且您具有一个last_update日期,该日期将始终被更新,因此您将始终获得该实体是使用工作单位和类似的东西进行更新的。

希望此方法对任何人都有帮助。


1

那么...当我们想在主义生命周期之外找到一个变更集时该怎么办?就像我在@Ocramius的以上评论中提到的那样,也许可以创建一个“只读”方法,该方法不会与真正的教义持久性发生冲突,而是为用户提供更改的视图。

这是我在想的一个例子...

/**
 * Try to get an Entity changeSet without changing the UnitOfWork
 *
 * @param EntityManager $em
 * @param $entity
 * @return null|array
 */
public static function diffDoctrineObject(EntityManager $em, $entity) {
    $uow = $em->getUnitOfWork();

    /*****************************************/
    /* Equivalent of $uow->computeChangeSet($this->em->getClassMetadata(get_class($entity)), $entity);
    /*****************************************/
    $class = $em->getClassMetadata(get_class($entity));
    $oid = spl_object_hash($entity);
    $entityChangeSets = array();

    if ($uow->isReadOnly($entity)) {
        return null;
    }

    if ( ! $class->isInheritanceTypeNone()) {
        $class = $em->getClassMetadata(get_class($entity));
    }

    // These parts are not needed for the changeSet?
    // $invoke = $uow->listenersInvoker->getSubscribedSystems($class, Events::preFlush) & ~ListenersInvoker::INVOKE_MANAGER;
    // 
    // if ($invoke !== ListenersInvoker::INVOKE_NONE) {
    //     $uow->listenersInvoker->invoke($class, Events::preFlush, $entity, new PreFlushEventArgs($em), $invoke);
    // }

    $actualData = array();

    foreach ($class->reflFields as $name => $refProp) {
        $value = $refProp->getValue($entity);

        if ($class->isCollectionValuedAssociation($name) && $value !== null) {
            if ($value instanceof PersistentCollection) {
                if ($value->getOwner() === $entity) {
                    continue;
                }

                $value = new ArrayCollection($value->getValues());
            }

            // If $value is not a Collection then use an ArrayCollection.
            if ( ! $value instanceof Collection) {
                $value = new ArrayCollection($value);
            }

            $assoc = $class->associationMappings[$name];

            // Inject PersistentCollection
            $value = new PersistentCollection(
                $em, $em->getClassMetadata($assoc['targetEntity']), $value
            );
            $value->setOwner($entity, $assoc);
            $value->setDirty( ! $value->isEmpty());

            $class->reflFields[$name]->setValue($entity, $value);

            $actualData[$name] = $value;

            continue;
        }

        if (( ! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity()) && ($name !== $class->versionField)) {
            $actualData[$name] = $value;
        }
    }

    $originalEntityData = $uow->getOriginalEntityData($entity);
    if (empty($originalEntityData)) {
        // Entity is either NEW or MANAGED but not yet fully persisted (only has an id).
        // These result in an INSERT.
        $originalEntityData = $actualData;
        $changeSet = array();

        foreach ($actualData as $propName => $actualValue) {
            if ( ! isset($class->associationMappings[$propName])) {
                $changeSet[$propName] = array(null, $actualValue);

                continue;
            }

            $assoc = $class->associationMappings[$propName];

            if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
                $changeSet[$propName] = array(null, $actualValue);
            }
        }

        $entityChangeSets[$oid] = $changeSet; // @todo - remove this?
    } else {
        // Entity is "fully" MANAGED: it was already fully persisted before
        // and we have a copy of the original data
        $originalData           = $originalEntityData;
        $isChangeTrackingNotify = $class->isChangeTrackingNotify();
        $changeSet              = $isChangeTrackingNotify ? $uow->getEntityChangeSet($entity) : array();

        foreach ($actualData as $propName => $actualValue) {
            // skip field, its a partially omitted one!
            if ( ! (isset($originalData[$propName]) || array_key_exists($propName, $originalData))) {
                continue;
            }

            $orgValue = $originalData[$propName];

            // skip if value haven't changed
            if ($orgValue === $actualValue) {
                continue;
            }

            // if regular field
            if ( ! isset($class->associationMappings[$propName])) {
                if ($isChangeTrackingNotify) {
                    continue;
                }

                $changeSet[$propName] = array($orgValue, $actualValue);

                continue;
            }

            $assoc = $class->associationMappings[$propName];

            // Persistent collection was exchanged with the "originally"
            // created one. This can only mean it was cloned and replaced
            // on another entity.
            if ($actualValue instanceof PersistentCollection) {
                $owner = $actualValue->getOwner();
                if ($owner === null) { // cloned
                    $actualValue->setOwner($entity, $assoc);
                } else if ($owner !== $entity) { // no clone, we have to fix
                    // @todo - what does this do... can it be removed?
                    if (!$actualValue->isInitialized()) {
                        $actualValue->initialize(); // we have to do this otherwise the cols share state
                    }
                    $newValue = clone $actualValue;
                    $newValue->setOwner($entity, $assoc);
                    $class->reflFields[$propName]->setValue($entity, $newValue);
                }
            }

            if ($orgValue instanceof PersistentCollection) {
                // A PersistentCollection was de-referenced, so delete it.
    // These parts are not needed for the changeSet?
    //            $coid = spl_object_hash($orgValue);
    //
    //            if (isset($uow->collectionDeletions[$coid])) {
    //                continue;
    //            }
    //
    //            $uow->collectionDeletions[$coid] = $orgValue;
                $changeSet[$propName] = $orgValue; // Signal changeset, to-many assocs will be ignored.

                continue;
            }

            if ($assoc['type'] & ClassMetadata::TO_ONE) {
                if ($assoc['isOwningSide']) {
                    $changeSet[$propName] = array($orgValue, $actualValue);
                }

    // These parts are not needed for the changeSet?
    //            if ($orgValue !== null && $assoc['orphanRemoval']) {
    //                $uow->scheduleOrphanRemoval($orgValue);
    //            }
            }
        }

        if ($changeSet) {
            $entityChangeSets[$oid]     = $changeSet;
    // These parts are not needed for the changeSet?
    //        $originalEntityData         = $actualData;
    //        $uow->entityUpdates[$oid]   = $entity;
        }
    }

    // These parts are not needed for the changeSet?
    //// Look for changes in associations of the entity
    //foreach ($class->associationMappings as $field => $assoc) {
    //    if (($val = $class->reflFields[$field]->getValue($entity)) !== null) {
    //        $uow->computeAssociationChanges($assoc, $val);
    //        if (!isset($entityChangeSets[$oid]) &&
    //            $assoc['isOwningSide'] &&
    //            $assoc['type'] == ClassMetadata::MANY_TO_MANY &&
    //            $val instanceof PersistentCollection &&
    //            $val->isDirty()) {
    //            $entityChangeSets[$oid]   = array();
    //            $originalEntityData = $actualData;
    //            $uow->entityUpdates[$oid]      = $entity;
    //        }
    //    }
    //}
    /*********************/

    return $entityChangeSets[$oid];
}

它在这里被表述为静态方法,但是可能成为UnitOfWork内部的方法...?

我无法掌握Doctrine的所有内部原理,因此可能错过了一些副作用,或者误解了该方法的功能,但是(非常)快速的测试似乎可以为我带来预期的结果查看。

希望对您有所帮助!


1
好吧,如果我们见面,您将获得清晰的高五!非常感谢您的帮助。也很容易在其他2个函数中使用:hasChangesgetChanges(后者仅获取已更改的字段,而不是整个更改集)。
rkeet

0

就我而言,对于从远程WS到本地的同步数据,DB我使用这种方式比较两个实体(检查旧实体是否与已编辑实体存在差异)。

我将克隆持久实体以使两个对象不持久:

<?php

$entity = $repository->find($id);// original entity exists
if (null === $entity) {
    $entity    = new $className();// local entity not exists, create new one
}
$oldEntity = clone $entity;// make a detached "backup" of the entity before it's changed
// make some changes to the entity...
$entity->setX('Y');

// now compare entities properties/values
$entityCloned = clone $entity;// clone entity for detached (not persisted) entity comparaison
if ( ! $em->contains( $entity ) || $entityCloned != $oldEntity) {// do not compare strictly!
    $em->persist( $entity );
    $em->flush();
}

unset($entityCloned, $oldEntity, $entity);

而不是直接比较对象的另一种可能性:

<?php
// here again we need to clone the entity ($entityCloned)
$entity_diff = array_keys(
    array_diff_key(
        get_object_vars( $entityCloned ),
        get_object_vars( $oldEntity )
    )
);
if(count($entity_diff) > 0){
    // persist & flush
}

0

在我的情况下,我想获取实体中关系的旧值,因此我在基础上使用Doctrine \ ORM \ PersistentCollection :: getSnapshot


0

它对我有用1.导入EntityManager 2.现在您可以在类中的任何位置使用它。

  use Doctrine\ORM\EntityManager;



    $preData = $this->em->getUnitOfWork()->getOriginalEntityData($entity);
    // $preData['active'] for old data and $entity->getActive() for new data
    if($preData['active'] != $entity->getActive()){
        echo 'Send email';
    }

0

在Doctrine事件侦听器中UnitOfWorkcomputeChangeSets 在其中进行工作可能是首选方法。

但是:如果您要在此侦听器中保留并刷新一个新实体,则可能会遇到很多麻烦。看起来,唯一合适的侦听器将onFlush有自己的问题。

因此,我建议进行一个简单但轻巧的比较,只需将其注入EntityManagerInterface(由上一帖中的@Mohamed Ramrami启发),即可在Controllers甚至Services中使用:

$uow = $entityManager->getUnitOfWork();
$originalEntityData = $uow->getOriginalEntityData($blog);

// for nested entities, as suggested in the docs
$defaultContext = [
    AbstractNormalizer::CIRCULAR_REFERENCE_HANDLER => function ($object, $format, $context) {
        return $object->getId();
    },
];
$normalizer = new Serializer([new DateTimeNormalizer(), new ObjectNormalizer(null, null, null, null, null,  null, $defaultContext)]);
$yourEntityNormalized = $normalizer->normalize();
$originalNormalized = $normalizer->normalize($originalEntityData);

$changed = [];
foreach ($originalNormalized as $item=>$value) {
    if(array_key_exists($item, $yourEntityNormalized)) {
        if($value !== $yourEntityNormalized[$item]) {
            $changed[] = $item;
        }
    }
}

注意:它确实可以正确比较字符串,日期时间,布尔值,整数和浮点数,但是对对象失败(由于循环引用问题)。人们可以更深入地比较这些对象,但是对于例如文本更改检测而言,这比处理事件侦听器就足够了,而且要简单得多。

更多信息:

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.