improve SERIALIZE_IDENTIFIER_FOR_LAZY_NOT_LOADED_OBJECTS feature

- don't require session or mapping for ids mapped with property access
- add a testcase
- improve documentation

Author: bedag-moo

hibernate4/src/main/java/com/fasterxml/jackson/datatype/hibernate4/Hibernate4Module.java

@@ -31,10 +31,19 @@ public enum Feature {
         USE_TRANSIENT_ANNOTATION(true),
 
 	    /**
-	     * If FORCE_LAZY_LOADING is false lazy-loaded object should be serialized as map IdentifierName=>IdentifierValue
-	     * instead of null (true); or serialized as nulls (false)
+	     * If FORCE_LAZY_LOADING is false, this feature serializes uninitialized lazy loading proxies as
+	     * <code>{"identifierName":"identifierValue"}</code> rather than <code>null</code>. 
 	     * <p>
-	     * Default value is false.
+         * Default value is false.
+	     * <p>
+	     * Note that the name of the identifier property can only be determined if 
+	     * <ul>
+	     * <li>the {@link Mapping} is provided to the Hibernate4Module, or </li>
+	     * <li>the persistence context that loaded the proxy has not yet been closed, or</li> 
+	     * <li>the id property is mapped with property access (for instance because the {@code @Id}
+	     * annotation is applied to a method rather than a field)</li>
+	     * </ul>
+	     * Otherwise, the entity name will be used instead. 
 	     */
         SERIALIZE_IDENTIFIER_FOR_LAZY_NOT_LOADED_OBJECTS(false),
 

hibernate4/src/main/java/com/fasterxml/jackson/datatype/hibernate4/HibernateProxySerializer.java

@@ -1,6 +1,8 @@
 package com.fasterxml.jackson.datatype.hibernate4;
 
 import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.util.HashMap;
 
 import com.fasterxml.jackson.core.*;
@@ -18,6 +20,7 @@
 import org.hibernate.engine.spi.SessionImplementor;
 import org.hibernate.proxy.HibernateProxy;
 import org.hibernate.proxy.LazyInitializer;
+import org.hibernate.proxy.pojo.BasicLazyInitializer;
 
 /**
  * Serializer to use for values proxied using {@link org.hibernate.proxy.HibernateProxy}.
@@ -174,15 +177,18 @@ protected Object findProxied(HibernateProxy proxy)
         LazyInitializer init = proxy.getHibernateLazyInitializer();
         if (!_forceLazyLoading && init.isUninitialized()) {
             if (_serializeIdentifier) {
-                final String idName;
+                String idName;
                 if (_mapping != null) {
                     idName = _mapping.getIdentifierPropertyName(init.getEntityName());
                 } else {
                     final SessionImplementor session = init.getSession();
                     if (session != null) {
                         idName = session.getFactory().getIdentifierPropertyName(init.getEntityName());
                     } else {
-                        idName = init.getEntityName();
+                        idName = ProxyReader.getIdentifierPropertyName(init);
+                        if (idName == null) {
+                        	idName = init.getEntityName();
+                        }
                     }
                 }
         		final Object idValue = init.getIdentifier();
@@ -194,4 +200,40 @@ protected Object findProxied(HibernateProxy proxy)
         }
         return init.getImplementation();
     }
+    
+    // Alas, hibernate offers no public api to access this information, so we must resort to ugly hacks ...
+    protected static class ProxyReader {
+
+        // static final so the JVM can inline the lookup
+        private static final Field getIdentifierMethod;
+
+        static {
+            try {
+                getIdentifierMethod = BasicLazyInitializer.class.getDeclaredField("getIdentifierMethod");
+                getIdentifierMethod.setAccessible(true);
+            } catch (Exception e) {
+            	// should never happen: the field exists in all versions of hibernate 4 and 5
+                throw new RuntimeException(e); 
+            }
+        }
+
+        /**
+         * @return the name of the identifier property, or null if the name could not be determined
+         */
+        static String getIdentifierPropertyName(LazyInitializer init) {
+            try {
+                Method idGetter = (Method) getIdentifierMethod.get(init);
+                if (idGetter == null) {
+                	return null;
+                }
+                String name = idGetter.getName();
+                if (name.startsWith("get")) {
+                    name = Character.toLowerCase(name.charAt(3)) + name.substring(4);
+                }
+                return name;
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
 }

hibernate4/src/test/java/com/fasterxml/jackson/datatype/hibernate4/LazyLoadingTest.java

@@ -6,7 +6,9 @@
 import javax.persistence.EntityManagerFactory;
 import javax.persistence.Persistence;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.hibernate4.Hibernate4Module.Feature;
 import com.fasterxml.jackson.datatype.hibernate4.data.Customer;
 import com.fasterxml.jackson.datatype.hibernate4.data.Payment;
 
@@ -54,4 +56,25 @@ public void testGetCustomerJson() throws Exception
             emf.close();
         }
     }
+    
+    @Test
+    public void testSerializeIdentifierFeature() throws JsonProcessingException {
+		Hibernate4Module module = new Hibernate4Module();
+		module.enable(Feature.SERIALIZE_IDENTIFIER_FOR_LAZY_NOT_LOADED_OBJECTS);
+		ObjectMapper objectMapper = new ObjectMapper().registerModule(module);
+
+		EntityManagerFactory emf = Persistence.createEntityManagerFactory("persistenceUnit");
+    	try {
+    		EntityManager em = emf.createEntityManager();
+    		Customer customerRef = em.getReference(Customer.class, 103);
+    		em.close();
+    		assertFalse(Hibernate.isInitialized(customerRef));
+    		
+			String json = objectMapper.writeValueAsString(customerRef);
+			assertFalse(Hibernate.isInitialized(customerRef));
+			assertEquals("{\"customerNumber\":103}", json);
+    	} finally {
+    		emf.close();
+    	}
+    }
 }