You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@isis.apache.org by da...@apache.org on 2021/07/06 12:36:10 UTC

[isis] 05/11: ISIS-2789: extends EntityChangeTracker to allow JPA (EclipseLink) to provide the 'pre values' already.

This is an automated email from the ASF dual-hosted git repository.

danhaywood pushed a commit to branch ISIS-2789
in repository https://gitbox.apache.org/repos/asf/isis.git

commit 1fcf7c6f927739c2e44fd4e27201f515a52a9087
Author: danhaywood <da...@haywood-associates.co.uk>
AuthorDate: Tue Jul 6 13:07:34 2021 +0100

    ISIS-2789: extends EntityChangeTracker to allow JPA (EclipseLink) to provide the 'pre values' already.
    
    This is more efficient, but is also necessary as the pojo itself that we have will already have been updated.
---
 .../changetracking/EntityChangeTrackerDefault.java | 29 ++++++++++++---
 .../EntityChangeTrackerWithPreValue.java           | 43 ++++++++++++++++++++++
 .../jpa/applib/integration/IsisEntityListener.java | 33 +++++++++++++----
 3 files changed, 92 insertions(+), 13 deletions(-)

diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java
index 102f662..58bba51 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java
@@ -19,6 +19,7 @@
 package org.apache.isis.core.transaction.changetracking;
 
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -94,7 +95,7 @@ import lombok.extern.log4j.Log4j2;
 public class EntityChangeTrackerDefault
 implements
     MetricsService,
-    EntityChangeTracker,
+        EntityChangeTrackerWithPreValue,
     HasEnlistedEntityPropertyChanges,
     HasEnlistedEntityChanges {
 
@@ -151,12 +152,26 @@ implements
         enlistForPreAndPostValuePublishing(adapter, record->record.setPreValue(IsisTransactionPlaceholder.NEW));
     }
 
-    private void enlistUpdatingInternal(final @NonNull ManagedObject adapter) {
+    private void enlistUpdatingInternal(
+            final @NonNull ManagedObject adapter,
+            String propertyIdIfAny,
+            Object preValue) {
         if(!isEntityEnabledForChangePublishing(adapter)) {
             return;
         }
         enlistForChangeKindPublishing(adapter, EntityChangeKind.UPDATE);
-        enlistForPreAndPostValuePublishing(adapter, _PropertyChangeRecord::updatePreValue);
+        enlistForPreAndPostValuePublishing(adapter, propertyChangeRecord -> {
+            if(propertyIdIfAny != null) {
+                // if we've been provided with the preValue, then just save it
+                // in the appropriate PropertyChangeRecord
+                if(Objects.equals(propertyChangeRecord.getPropertyId(), propertyIdIfAny)) {
+                    propertyChangeRecord.setPreValue(preValue);
+                }
+            } else {
+                // read from the pojo using the Isis MM.
+                propertyChangeRecord.updatePreValue();
+            }
+        });
     }
 
     private void enlistDeletingInternal(final @NonNull ManagedObject adapter) {
@@ -372,11 +387,16 @@ implements
 
     @Override
     public void enlistUpdating(ManagedObject entity) {
+        enlistUpdating(entity, null, null);
+    }
+
+    @Override
+    public void enlistUpdating(ManagedObject entity, String propertyIdIfAny, Object preValue) {
         _Xray.enlistUpdating(entity, interactionProviderProvider);
         val hasAlreadyBeenEnlisted = isEnlisted(entity);
         // we call this come what may;
         // additional properties may now have been changed, and the changeKind for publishing might also be modified
-        enlistUpdatingInternal(entity);
+        enlistUpdatingInternal(entity, propertyIdIfAny, preValue);
 
         if(!hasAlreadyBeenEnlisted) {
             // prevent an infinite loop... don't call the 'updating()' callback on this object if we have already done so
@@ -437,5 +457,4 @@ implements
     }
 
 
-
 }
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java
new file mode 100644
index 0000000..9efdbca
--- /dev/null
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java
@@ -0,0 +1,43 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.apache.isis.core.transaction.changetracking;
+
+import org.apache.isis.core.metamodel.spec.ManagedObject;
+
+/**
+ * @since 2 {@index}
+ */
+public interface EntityChangeTrackerWithPreValue extends EntityChangeTracker {
+
+    /**
+     * An override of {@link EntityChangeTracker#enlistUpdating(ManagedObject)}
+     * where the caller already knows the old value (and so the
+     * {@link EntityChangeTracker} does not need to capture the old value itself.
+     *
+     * <p>
+     *     Introduced for JPA (EclipseLink implementation).
+     * </p>
+     *
+     * @param entity - being enlisted
+     * @param propertyIdIfAny - the entity property id (its simple name); if non-null, indicates that the pre value is known
+     * @param preValue - the pre-value (could be null); only relevant if propertyNameIfAny is provided (non-null).
+     */
+    void enlistUpdating(ManagedObject entity, String propertyIdIfAny, Object preValue);
+}
+
diff --git a/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java b/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
index 6d3dfe6..2b4c660 100644
--- a/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
+++ b/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
@@ -19,6 +19,7 @@
 package org.apache.isis.persistence.jpa.applib.integration;
 
 import javax.inject.Inject;
+import javax.inject.Provider;
 import javax.persistence.PostLoad;
 import javax.persistence.PostPersist;
 import javax.persistence.PostRemove;
@@ -27,9 +28,13 @@ import javax.persistence.PrePersist;
 import javax.persistence.PreRemove;
 import javax.persistence.PreUpdate;
 
+import org.eclipse.persistence.sessions.UnitOfWork;
+
 import org.apache.isis.applib.services.inject.ServiceInjector;
 import org.apache.isis.core.metamodel.objectmanager.ObjectManager;
 import org.apache.isis.core.transaction.changetracking.EntityChangeTracker;
+import org.apache.isis.core.transaction.changetracking.EntityChangeTrackerWithPreValue;
+import org.apache.isis.persistence.jpa.applib.services.JpaSupportService;
 
 import lombok.extern.log4j.Log4j2;
 import lombok.val;
@@ -54,13 +59,8 @@ public class IsisEntityListener {
 
     // not managed by Spring (directly)
     @Inject private ServiceInjector serviceInjector;
-    private EntityChangeTracker entityChangeTracker;
-
-    @Inject
-    public void setEntityChangeTracker(EntityChangeTracker entityChangeTracker) {
-        this.entityChangeTracker = entityChangeTracker;
-    }
-
+    @Inject private Provider<EntityChangeTrackerWithPreValue> entityChangeTrackerProvider;
+    @Inject private Provider<JpaSupportService> jpaSupportServiceProvider;
     @Inject private ObjectManager objectManager;
 
 
@@ -69,6 +69,7 @@ public class IsisEntityListener {
         log.debug("onPrePersist: {}", entityPojo);
         serviceInjector.injectServicesInto(entityPojo);
         val entity = objectManager.adapt(entityPojo);
+        val entityChangeTracker = entityChangeTrackerProvider.get();
         entityChangeTracker.recognizePersisting(entity);
     }
 
@@ -77,7 +78,19 @@ public class IsisEntityListener {
         log.debug("onPreUpdate: {}", entityPojo);
         serviceInjector.injectServicesInto(entityPojo);
         val entity = objectManager.adapt(entityPojo);
-        entityChangeTracker.enlistUpdating(entity);
+        val entityChangeTracker = entityChangeTrackerProvider.get();
+        val entityManagerResult = jpaSupportServiceProvider.get().getEntityManager(entityPojo.getClass());
+        entityManagerResult.getValue().ifPresent(em -> {  // https://wiki.eclipse.org/EclipseLink/FAQ/JPA#How_to_access_what_changed_in_an_object_or_transaction.3F
+            val unwrap = em.unwrap(UnitOfWork.class);
+            val changes = unwrap.getCurrentChanges();
+            val objectChanges = changes.getObjectChangeSetForClone(entityPojo);
+            val changeRecords = objectChanges.getChanges();
+            changeRecords.forEach(changeRecord -> {
+                val propertyName = changeRecord.getAttribute();
+                val oldValue = changeRecord.getOldValue();
+                entityChangeTracker.enlistUpdating(entity, propertyName, oldValue);
+            });
+        });
     }
 
     @PreRemove
@@ -85,6 +98,7 @@ public class IsisEntityListener {
         log.debug("onAnyRemove: {}", entityPojo);
         serviceInjector.injectServicesInto(entityPojo);
         val entity = objectManager.adapt(entityPojo);
+        val entityChangeTracker = entityChangeTrackerProvider.get();
         entityChangeTracker.enlistDeleting(entity);
     }
 
@@ -92,6 +106,7 @@ public class IsisEntityListener {
     private void onPostPersist(Object entityPojo) {
         log.debug("onPostPersist: {}", entityPojo);
         val entity = objectManager.adapt(entityPojo);
+        val entityChangeTracker = entityChangeTrackerProvider.get();
         entityChangeTracker.enlistCreated(entity);
     }
 
@@ -99,6 +114,7 @@ public class IsisEntityListener {
     private void onPostUpdate(Object entityPojo) {
         log.debug("onPostUpdate: {}", entityPojo);
         val entity = objectManager.adapt(entityPojo);
+        val entityChangeTracker = entityChangeTrackerProvider.get();
         entityChangeTracker.recognizeUpdating(entity);
     }
 
@@ -112,6 +128,7 @@ public class IsisEntityListener {
         log.debug("onPostLoad: {}", entityPojo);
         serviceInjector.injectServicesInto(entityPojo);
         val entity = objectManager.adapt(entityPojo);
+        val entityChangeTracker = entityChangeTrackerProvider.get();
         entityChangeTracker.recognizeLoaded(entity);
     }