2 * Copyright 2005-2010 the original author or authors.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.wamblee.persistence;
18 import java.io.Serializable;
19 import java.lang.reflect.InvocationTargetException;
20 import java.lang.reflect.Method;
21 import java.lang.reflect.Modifier;
22 import java.util.ArrayList;
23 import java.util.List;
26 import java.util.Map.Entry;
28 import javax.persistence.EntityManager;
30 import org.apache.commons.logging.Log;
31 import org.apache.commons.logging.LogFactory;
32 import org.wamblee.persistence.PersistentFactory.EntityAccessor;
33 import org.wamblee.reflection.ReflectionUtils;
36 * Support for merging of JPA entities. This utility allows the result of a
37 * merge (modifications of primary key and/or version) to be merged back into
38 * the argument that was merged. As a result, the merged entity can be reused
39 * and the application is not forced to use the new version that was returned
42 * The utility traverses the object graph based on the public getter methods.
43 * Therefore, care should be taken with this utility as usage could lead to
44 * recursively loading all objects reachable from the given object. Then again,
45 * this utility is for working with detached objects and it would, in general,
46 * be bad practice to work with detached objects that still contain unresolved
47 * lazy loaded relations and with detached objects that implicitly refer to
48 * almost the entire datamodel.
50 * This utility best supports a service oriented design where interaction is
51 * through service interfaces where each service has its own storage isolated
52 * from other services. That would be opposed to a shared data design with many
53 * services acting on the same data.
55 * @author Erik Brakkee
57 public class JpaMergeSupport {
58 private static final Log LOG = LogFactory.getLog(JpaMergeSupport.class);
61 * Constructs the object.
64 public JpaMergeSupport() {
69 * As {@link #merge(Persistent)} but with a given template. This method can
70 * be accessed in a static way.
73 * The result of the call to {@link EntityManager#merge(Object)}.
75 * Object that was passed to {@link EntityManager#merge(Object)}.
77 public static void merge(Object aMerged, Object aPersistent) {
78 processPersistent(aMerged, aPersistent, new ArrayList<ObjectElem>());
82 * Copies primary keys and version from the result of the merged to the
83 * object that was passed to the merge operation. It does this by traversing
84 * the properties of the object. It copies the primary key and version for
85 * objects that implement {@link Persistent} and applies the same rules to
86 * objects in maps and sets as well (i.e. recursively).
89 * Object whose primary key and version are to be set.
91 * Object that was the result of the merge.
93 * List of already processed Persistent objects of the persistent
97 public static void processPersistent(Object aMerged, Object aPersistent,
98 List<ObjectElem> aProcessed) {
99 if ((aPersistent == null) && (aMerged == null)) {
103 if ((aPersistent == null) || (aMerged == null)) {
104 throw new RuntimeException("persistent or merged object is null '" +
105 aPersistent + "'" + " '" + aMerged + "'");
108 ObjectElem elem = new ObjectElem(aPersistent);
110 if (aProcessed.contains(elem)) {
111 return; // already processed.
114 aProcessed.add(elem);
116 LOG.debug("Setting pk/version on " + aPersistent + " from " + aMerged);
118 Persistent persistentWrapper = PersistentFactory.create(aPersistent);
119 Persistent mergedWrapper = PersistentFactory.create(aMerged);
121 if (persistentWrapper == null) {
122 // Not an entity so it is ignored.
126 Serializable pk = persistentWrapper.getPrimaryKey();
127 boolean pkIsNull = false;
128 if (pk instanceof Number) {
129 if (((Number) pk).longValue() != 0l) {
135 pkIsNull = (pk == null);
138 !mergedWrapper.getPrimaryKey().equals(
139 persistentWrapper.getPrimaryKey())) {
140 throw new IllegalArgumentException(
141 "Mismatch between primary key values: " + aPersistent + " " +
144 persistentWrapper.setPersistedVersion(mergedWrapper
145 .getPersistedVersion());
146 persistentWrapper.setPrimaryKey(mergedWrapper.getPrimaryKey());
149 List<Method> methods = ReflectionUtils.getAllMethods(aPersistent
150 .getClass(), Object.class);
152 for (Method getter : methods) {
153 if ((getter.getName().startsWith("get") || getter.getName()
154 .startsWith("is")) &&
155 !Modifier.isStatic(getter.getModifiers())) {
156 Class returnType = getter.getReturnType();
159 if (Set.class.isAssignableFrom(returnType)) {
160 Set merged = (Set) getter.invoke(aMerged);
161 Set persistent = (Set) getter.invoke(aPersistent);
162 processSet(merged, persistent, aProcessed);
163 } else if (List.class.isAssignableFrom(returnType)) {
164 List merged = (List) getter.invoke(aMerged);
165 List persistent = (List) getter.invoke(aPersistent);
166 processList(merged, persistent, aProcessed);
167 } else if (Map.class.isAssignableFrom(returnType)) {
168 Map merged = (Map) getter.invoke(aMerged);
169 Map persistent = (Map) getter.invoke(aPersistent);
170 processMap(merged, persistent, aProcessed);
171 } else if (returnType.isArray()) {
172 // early detection of whether it is an array of entities
173 // to avoid performance problems.
174 EntityAccessor accessor = PersistentFactory
175 .createEntityAccessor(returnType.getComponentType());
176 if (accessor != null) {
177 Object[] merged = (Object[]) getter.invoke(aMerged);
178 Object[] persistent = (Object[]) getter
179 .invoke(aPersistent);
180 if (merged.length != persistent.length) {
181 throw new IllegalArgumentException("Array sizes differ " + merged.length +
182 " " + persistent.length);
184 for (int i = 0; i < persistent.length; i++) {
185 processPersistent(merged[i], persistent[i],
190 Object merged = getter.invoke(aMerged);
191 Object persistent = getter.invoke(aPersistent);
192 processPersistent(merged, persistent, aProcessed);
194 } catch (InvocationTargetException e) {
195 throw new RuntimeException(e.getMessage(), e);
196 } catch (IllegalAccessException e) {
197 throw new RuntimeException(e.getMessage(), e);
204 * Process the persistent objects in the collections.
207 * Collection in the original object.
209 * Collection as a result of the merge.
211 * List of processed persistent objects.
214 public static void processList(List aMerged, List aPersistent,
215 List<ObjectElem> aProcessed) {
216 Object[] merged = aMerged.toArray();
217 Object[] persistent = aPersistent.toArray();
219 if (merged.length != persistent.length) {
220 throw new IllegalArgumentException("Array sizes differ " + merged.length +
221 " " + persistent.length);
224 for (int i = 0; i < merged.length; i++) {
225 assert merged[i].equals(persistent[i]);
226 processPersistent(merged[i], persistent[i], aProcessed);
231 * Process the persistent objects in sets.
234 * Collection in the original object.
236 * Collection as a result of the merge.
238 * List of processed persistent objects.
241 public static void processSet(Set aMerged, Set aPersistent,
242 List<ObjectElem> aProcessed) {
243 if (aMerged.size() != aPersistent.size()) {
244 throw new IllegalArgumentException("Array sizes differ " + aMerged.size() +
245 " " + aPersistent.size());
248 for (Object merged : aMerged) {
249 // Find the object that equals the merged[i]
250 for (Object persistent : aPersistent) {
251 if (persistent.equals(merged)) {
252 processPersistent(merged, persistent, aProcessed);
260 * Process the Map objects in the collections.
263 * Collection in the original object.
265 * Collection as a result of the merge.
267 * List of processed persistent objects.
270 public static <Key, Value> void processMap(Map<Key, Value> aMerged,
271 Map<Key, Value> aPersistent, List<ObjectElem> aProcessed) {
272 if (aMerged.size() != aPersistent.size()) {
273 throw new IllegalArgumentException("Sizes differ " + aMerged.size() + " " +
277 Set<Entry<Key, Value>> entries = aMerged.entrySet();
279 for (Entry<Key, Value> entry : entries) {
280 Key key = entry.getKey();
281 if (!aPersistent.containsKey(key)) {
282 throw new IllegalArgumentException("Key '" + key + "' not found");
285 Value mergedValue = entry.getValue();
286 Object persistentValue = aPersistent.get(key);
288 processPersistent(mergedValue, persistentValue, aProcessed);
293 * This class provided an equality operation based on the object reference
294 * of the wrapped object. This is required because we cannto assume that the
295 * equals operation has any meaning for different types of persistent
296 * objects. This allows us to use the standard collection classes for
297 * detecting cyclic dependences and avoiding recursion.
299 private static final class ObjectElem {
300 private Object object;
302 public ObjectElem(Object aObject) {
306 public boolean equals(Object aObj) {
310 if (!(aObj instanceof ObjectElem)) {
313 return ((ObjectElem) aObj).object == object;
316 public int hashCode() {
317 return object.hashCode();