http://code.google.com/p/mybatis/issues/detail?id=110 . Implement CGLIB enhanced object serialiation into original domain object. Thanks Arkadi!

Author: emacarron

src/main/java/org/apache/ibatis/binding/MapperProxy.java

@@ -1,5 +1,6 @@
 package org.apache.ibatis.binding;
 
+import java.io.Serializable;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
@@ -8,7 +9,9 @@
 
 import org.apache.ibatis.session.SqlSession;
 
-public class MapperProxy implements InvocationHandler {
+public class MapperProxy implements InvocationHandler, Serializable {
+
+  private static final long serialVersionUID = -6424540398559729838L;
 
   private static final Set<String> OBJECT_METHODS = new HashSet<String>() {
     private static final long serialVersionUID = -1782950882770203582L;

src/main/java/org/apache/ibatis/executor/loader/ResultLoaderMap.java

@@ -1,15 +1,14 @@
 package org.apache.ibatis.executor.loader;
 
-import org.apache.ibatis.reflection.MetaObject;
-
-import java.io.Serializable;
 import java.sql.SQLException;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
-public class ResultLoaderMap implements Serializable {
+import org.apache.ibatis.reflection.MetaObject;
+
+public class ResultLoaderMap {
 
   private final Map<String, LoadPair> loaderMap = new HashMap<String, LoadPair>();
 
@@ -18,14 +17,14 @@ public void addLoader(String property, MetaObject metaResultObject, ResultLoader
     loaderMap.put(upperFirst, new LoadPair(property, metaResultObject, resultLoader));
   }
 
-  public int size() throws SQLException {
+  public int size() {
     return loaderMap.size();
   }
 
-  public boolean hasLoader(String methodName) throws SQLException {
+  public boolean hasLoader(String methodName) {
     return loaderMap.containsKey(methodName.toUpperCase(Locale.ENGLISH));
   }
-
+  
   public boolean load(String property) throws SQLException {
     LoadPair pair = loaderMap.remove(property.toUpperCase(Locale.ENGLISH));
     if (pair != null) {

src/main/java/org/apache/ibatis/executor/loader/ResultObjectProxy.java

@@ -1,54 +1,99 @@
 package org.apache.ibatis.executor.loader;
 
+import java.io.NotSerializableException;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import net.sf.cglib.core.Signature;
 import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.InterfaceMaker;
 import net.sf.cglib.proxy.MethodInterceptor;
 import net.sf.cglib.proxy.MethodProxy;
+
+import org.apache.ibatis.logging.Log;
+import org.apache.ibatis.logging.LogFactory;
 import org.apache.ibatis.reflection.ExceptionUtil;
+import org.apache.ibatis.reflection.factory.ObjectFactory;
 import org.apache.ibatis.reflection.property.PropertyNamer;
 import org.apache.ibatis.type.TypeHandlerRegistry;
-
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.lang.reflect.Field;
-import java.util.*;
+import org.objectweb.asm.Type;
 
 public class ResultObjectProxy {
 
+  private static final Log log = LogFactory.getLog(ResultObjectProxy.class);
+
   private static final Set<String> objectMethods = new HashSet<String>(Arrays.asList(new String[]{"equals","clone","hashCode","toString"}));
   private static final TypeHandlerRegistry registry = new TypeHandlerRegistry();
   private static final String FINALIZE_METHOD = "finalize";
+  private static final String WRITE_REPLACE_METHOD = "writeReplace";
 
-  public static Object createProxy(Object target, ResultLoaderMap lazyLoader, boolean aggressive) {
-    return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader, aggressive);
+  public static Object createProxy(Object target, ResultLoaderMap lazyLoader, boolean aggressive, ObjectFactory objectFactory) {
+    return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader, aggressive, objectFactory);
   }
 
   private static class EnhancedResultObjectProxyImpl implements MethodInterceptor, Serializable {
 
+    private static final long serialVersionUID = 3943261828110652464L;
+    private Class type;
     private ResultLoaderMap lazyLoader;
     private boolean aggressive;
+    private ObjectFactory objectFactory;
 
-    private EnhancedResultObjectProxyImpl(ResultLoaderMap lazyLoader, boolean aggressive) {
+    private EnhancedResultObjectProxyImpl(Class type, ResultLoaderMap lazyLoader, boolean aggressive, ObjectFactory objectFactory) {
+      this.type = type;
       this.lazyLoader = lazyLoader;
       this.aggressive = aggressive;
+      this.objectFactory = objectFactory;
     }
 
-    public static Object createProxy(Object target, ResultLoaderMap lazyLoader, boolean aggressive) {
+    public static Object createProxy(Object target, ResultLoaderMap lazyLoader, boolean aggressive, ObjectFactory objectFactory) {
       final Class type = target.getClass();
       if (registry.hasTypeHandler(type)) {
         return target;
       } else {
-        final Object enhanced = Enhancer.create(type, new EnhancedResultObjectProxyImpl(lazyLoader, aggressive));
-        copyInitialState(type, target, enhanced);
+        EnhancedResultObjectProxyImpl proxy = new EnhancedResultObjectProxyImpl(type, lazyLoader, aggressive, objectFactory);
+        Enhancer enhancer = new Enhancer();
+        enhancer.setCallback(proxy);
+        enhancer.setSuperclass(type);
+
+        try {
+          type.getDeclaredMethod(WRITE_REPLACE_METHOD);
+          // ObjectOutputStream will call writeReplace of objects returned by writeReplace
+          log.warn(WRITE_REPLACE_METHOD + " method was found on bean " + type + ", make sure it returns this");
+        } catch (NoSuchMethodException e) {
+          // using asm (org.objectweb.asm.Type), this will not work with cglib-nodep
+          InterfaceMaker writeReplaceInterface = new InterfaceMaker();
+          Signature signature = new Signature(WRITE_REPLACE_METHOD, Type.getType(Object.class), new Type[] {});
+          writeReplaceInterface.add(signature, new Type[] { Type.getType(ObjectStreamException.class) });
+          enhancer.setInterfaces(new Class[] { writeReplaceInterface.create() });
+        } catch (SecurityException e) {
+          // nothing to do here
+        }
+
+        final Object enhanced = enhancer.create();
+        copyBeanProperties(type, target, enhanced);
         return enhanced;
       }
     }
-
+    
     public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
+      final String methodName = method.getName();
       try {
-        final String methodName = method.getName();
         synchronized (lazyLoader) {
-          if (lazyLoader.size() > 0) {
-            if (!FINALIZE_METHOD.equals(methodName)) {
+          if (WRITE_REPLACE_METHOD.equals(methodName)) {
+            if (lazyLoader.size() > 0) {
+              throw new NotSerializableException("Not all lazy properties have been loaded yet");
+            }
+            Object original = objectFactory.create(type);
+            copyBeanProperties(type, o, original);
+            return original;
+          } else if (!FINALIZE_METHOD.equals(methodName)) {
+            if (lazyLoader.size() > 0) {
               if (aggressive || objectMethods.contains(methodName)) {
                 lazyLoader.loadAll();
               } else if (PropertyNamer.isProperty(methodName)) {
@@ -66,22 +111,22 @@ public Object intercept(Object o, Method method, Object[] args, MethodProxy meth
       }
     }
 
-    private static void copyInitialState(Class type, Object target, Object enhanced) {
+    private static void copyBeanProperties(Class type, Object sourceBean, Object destinationBean) {
       Class parent = type;
       while (parent != null) {
         final Field[] fields = parent.getDeclaredFields();
         for(Field field : fields) {
           try {
             field.setAccessible(true);
-            field.set(enhanced,field.get(target));
+            Object val = field.get(sourceBean);
+            field.set(destinationBean, val);
           } catch (Exception e) {
             // Nothing useful to do, will only fail on final fields, which will be ignored.
           }
         }
         parent = parent.getSuperclass();
       }
     }
-
   }
 
 }

src/main/java/org/apache/ibatis/executor/resultset/FastResultSetHandler.java

@@ -285,7 +285,7 @@ protected void loadMappedAndUnmappedColumnNames(ResultSet rs, ResultMap resultMa
   protected Object createResultObject(ResultSet rs, ResultMap resultMap, ResultLoaderMap lazyLoader) throws SQLException {
     final Object resultObject = createResultObject(rs, resultMap);
     if (resultObject != null && configuration.isLazyLoadingEnabled()) {
-      return ResultObjectProxy.createProxy(resultObject, lazyLoader, configuration.isAggressiveLazyLoading());
+      return ResultObjectProxy.createProxy(resultObject, lazyLoader, configuration.isAggressiveLazyLoading(), objectFactory);
     }
     return resultObject;
   }

src/test/java/org/apache/ibatis/executor/BeanWithWriteReplace.java

@@ -0,0 +1,72 @@
+package org.apache.ibatis.executor;
+
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+
+public class BeanWithWriteReplace implements Serializable {
+  
+  protected int id;
+  protected String value;
+
+  public BeanWithWriteReplace() {  
+  }
+  
+  public BeanWithWriteReplace(int id, String value) {
+    super();
+    this.id = id;
+    this.value = value;
+  }
+
+  public int getId() {
+    return id;
+  }
+
+  public void setId(int id) {
+    this.id = id;
+  }
+
+  public String getValue() {
+    return value;
+  }
+
+  public void setValue(String value) {
+    this.value = value;
+  }
+
+  @Override
+  public int hashCode() {
+    final int prime = 31;
+    int result = 1;
+    result = prime * result + id;
+    result = prime * result + ((value == null) ? 0 : value.hashCode());
+    return result;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj)
+      return true;
+    if (obj == null)
+      return false;
+    if (getClass() != obj.getClass())
+      return false;
+    BeanWithWriteReplace other = (BeanWithWriteReplace) obj;
+    if (id != other.id)
+      return false;
+    if (value == null) {
+      if (other.value != null)
+        return false;
+    } else if (!value.equals(other.value))
+      return false;
+    return true;
+  }
+
+  @Override
+  public String toString() {
+    return "BeanWithWriteReplace [id=" + id + ", value=" + value + "]";
+  }
+
+  protected Object writeReplace() throws ObjectStreamException {
+    return this;
+  }
+}

src/test/java/org/apache/ibatis/executor/SerializableProxyTest.java

@@ -1,48 +1,90 @@
 package org.apache.ibatis.executor;
 
-import domain.blog.Author;
-import domain.blog.Section;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.fail;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.NotSerializableException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
 import org.apache.ibatis.executor.loader.ResultLoaderMap;
 import org.apache.ibatis.executor.loader.ResultObjectProxy;
-import static org.junit.Assert.assertEquals;
+import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
 import org.junit.Test;
 
-import java.io.*;
+import domain.blog.Author;
+import domain.blog.Section;
 
 public class SerializableProxyTest {
 
   @Test
   public void shouldDemonstrateSerializableEnhancer() throws Exception {
     Author author = new Author(999, "someone", "!@#@!#!@#", "[email protected]", "blah", Section.NEWS);
-    Object proxy = ResultObjectProxy.createProxy(author, new ResultLoaderMap(), true);
+    Object proxy = ResultObjectProxy.createProxy(author, new ResultLoaderMap(), true, new DefaultObjectFactory());
     byte[] bytes = serialize((Serializable) proxy);
     Object proxy2 = deserialize(bytes);
-    assertEquals(author.toString(), proxy2.toString());
+    // serialization/deserialization of a cglib proxy in the same execution always works
+    // because the generated class is registerd to the jvm
+    // we should check this in different executions of just check the class name
+    assertEquals(author, proxy2);
+    assertEquals(author.getClass(), proxy2.getClass());
   }
 
-  private byte[] serialize(Serializable value) {
+  @Test
+  public void shouldGenerateWriteReplace() throws Exception {
+    Author author = new Author(999, "someone", "!@#@!#!@#", "[email protected]", "blah", Section.NEWS);
     try {
-      ByteArrayOutputStream bos = new ByteArrayOutputStream();
-      ObjectOutputStream oos = new ObjectOutputStream(bos);
-      oos.writeObject(value);
-      oos.flush();
-      oos.close();
-      return bos.toByteArray();
+      author.getClass().getDeclaredMethod("writeReplace");
+      fail("Author should not have a writeReplace method");
     } catch (Exception e) {
-      throw new RuntimeException("Error serializing object.  Cause: " + e, e);
+      // ok
     }
+    Object proxy = ResultObjectProxy.createProxy(author, new ResultLoaderMap(), true, new DefaultObjectFactory());
+    // check that writeReplace method was generated
+    proxy.getClass().getDeclaredMethod("writeReplace");
   }
-
-  private Serializable deserialize(byte[] value) {
-    Serializable result;
+  
+  @Test
+  public void shouldNotGenerateWriteReplace() throws Exception {
+    BeanWithWriteReplace beanWithWriteReplace = new BeanWithWriteReplace(999, "someone");
+    Object proxy = ResultObjectProxy.createProxy(beanWithWriteReplace, new ResultLoaderMap(), true, new DefaultObjectFactory());
     try {
-      ByteArrayInputStream bis = new ByteArrayInputStream((byte[]) value);
-      ObjectInputStream ois = new ObjectInputStream(bis);
-      result = (Serializable) ois.readObject();
-      ois.close();
+      beanWithWriteReplace.getClass().getDeclaredMethod("writeReplace");
     } catch (Exception e) {
-      throw new RuntimeException("Error deserializing object.  Cause: " + e, e);
+      fail("Bean should declare a writeReplace method");
     }
+    Method m = proxy.getClass().getDeclaredMethod("writeReplace");
+    assertFalse("generated method is public so this should be protected", m.isAccessible());
+  }
+
+  @Test(expected=NotSerializableException.class)
+  public void shouldNotSerializePartiallyLoadedBean() throws Exception {
+    BeanWithWriteReplace beanWithWriteReplace = new BeanWithWriteReplace(999, "someone");
+    ResultLoaderMap loader = new ResultLoaderMap();
+    loader.addLoader("property", null, null);
+    Object proxy = ResultObjectProxy.createProxy(beanWithWriteReplace, loader, true, new DefaultObjectFactory());
+    serialize((Serializable) proxy);
+  }
+
+  private byte[] serialize(Serializable value) throws Exception {
+    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+    ObjectOutputStream oos = new ObjectOutputStream(bos);
+    oos.writeObject(value);
+    oos.flush();
+    oos.close();
+    return bos.toByteArray();
+  }
+
+  private Serializable deserialize(byte[] value) throws Exception {
+    ByteArrayInputStream bis = new ByteArrayInputStream((byte[]) value);
+    ObjectInputStream ois = new ObjectInputStream(bis);
+    Serializable result = (Serializable) ois.readObject();
+    ois.close();
     return result;
   }