Removed dependency on asm. We need to make beans implement an interface but there is no need to generate the interface itself.

Author: emacarron

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

@@ -1,26 +1,25 @@
 package org.apache.ibatis.executor.loader;
 
-import java.io.ObjectStreamException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Set;
 
-import net.sf.cglib.core.Signature;
+import net.sf.cglib.proxy.Callback;
 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.executor.ExecutorException;
 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.PropertyCopier;
 import org.apache.ibatis.reflection.property.PropertyNamer;
 import org.apache.ibatis.type.TypeHandlerRegistry;
-import org.objectweb.asm.Type;
 
 public class ResultObjectProxy {
 
@@ -31,23 +30,50 @@ public class ResultObjectProxy {
   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,
-      ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
-    return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader, aggressive, objectFactory,
-        constructorArgTypes, constructorArgs);
+  public static Object createProxy(Object target, ResultLoaderMap lazyLoader, boolean aggressive, ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
+    return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader, aggressive, objectFactory, constructorArgTypes, constructorArgs);
   }
 
-  private static class EnhancedResultObjectProxyImpl implements MethodInterceptor {
+  public static Object createDeserializationProxy(Object target, Set<String> unloadedProperties, ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
+    return EnhancedDeserializationProxyImpl.createProxy(target, unloadedProperties, objectFactory, constructorArgTypes, constructorArgs);
+  }
+
+  private static Object crateProxy(Class type, Callback callback, List<Class> constructorArgTypes, List<Object> constructorArgs) {
+
+    Enhancer enhancer = new Enhancer();
+    enhancer.setCallback(callback);
+    enhancer.setSuperclass(type);
+
+    try {
+      type.getDeclaredMethod(WRITE_REPLACE_METHOD);
+      // ObjectOutputStream will call writeReplace of objects returned by writeReplace
+      log.debug(WRITE_REPLACE_METHOD + " method was found on bean " + type + ", make sure it returns this");
+    } catch (NoSuchMethodException e) {
+      enhancer.setInterfaces(new Class[] { WriteReplaceInterface.class });
+    } catch (SecurityException e) {
+      // nothing to do here
+    }
 
+    Object enhanced = null;
+    if (constructorArgTypes.isEmpty()) {
+      enhanced = enhancer.create();
+    } else {
+      Class[] typesArray = constructorArgTypes.toArray(new Class[constructorArgTypes.size()]);
+      Object[] valuesArray = constructorArgs.toArray(new Object[constructorArgs.size()]);
+      enhanced = enhancer.create(typesArray, valuesArray);
+    }
+    return enhanced;
+  }
+
+  private static class EnhancedResultObjectProxyImpl implements MethodInterceptor {
     private Class type;
     private ResultLoaderMap lazyLoader;
     private boolean aggressive;
     private ObjectFactory objectFactory;
     private List<Class> constructorArgTypes;
     private List<Object> constructorArgs;
 
-    private EnhancedResultObjectProxyImpl(Class type, ResultLoaderMap lazyLoader, boolean aggressive,
-        ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
+    private EnhancedResultObjectProxyImpl(Class type, ResultLoaderMap lazyLoader, boolean aggressive, ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
       this.type = type;
       this.lazyLoader = lazyLoader;
       this.aggressive = aggressive;
@@ -56,39 +82,13 @@ private EnhancedResultObjectProxyImpl(Class type, ResultLoaderMap lazyLoader, bo
       this.constructorArgs = constructorArgs;
     }
 
-    public static Object createProxy(Object target, ResultLoaderMap lazyLoader, boolean aggressive,
-        ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
+    public static Object createProxy(Object target, ResultLoaderMap lazyLoader, boolean aggressive, ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
       final Class type = target.getClass();
       if (registry.hasTypeHandler(type)) {
         return target;
-      } else {
-        EnhancedResultObjectProxyImpl proxy = new EnhancedResultObjectProxyImpl(type, lazyLoader, aggressive,
-            objectFactory, constructorArgTypes, constructorArgs);
-        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) {
-          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
-        }
-
-        Object enhanced = null;
-        if (constructorArgTypes.isEmpty()) {
-          enhanced = enhancer.create();
-        } else {
-          Class[] typesArray = constructorArgTypes.toArray(new Class[constructorArgTypes.size()]);
-          Object[] valuesArray = constructorArgs.toArray(new Object[constructorArgs.size()]);
-          enhanced = enhancer.create(typesArray, valuesArray);
-        }
+      } else {        
+        EnhancedResultObjectProxyImpl callback = new EnhancedResultObjectProxyImpl(type, lazyLoader, aggressive, objectFactory, constructorArgTypes, constructorArgs);
+        Object enhanced = crateProxy(type, callback, constructorArgTypes, constructorArgs);
         PropertyCopier.copyBeanProperties(type, target, enhanced);
         return enhanced;
       }
@@ -107,8 +107,7 @@ public Object intercept(Object enhanced, Method method, Object[] args, MethodPro
             }
             PropertyCopier.copyBeanProperties(type, enhanced, original);
             if (lazyLoader.size() > 0) {
-              return new SerialStateHolder(original, lazyLoader.getPropertyNames(), objectFactory,
-                  constructorArgTypes, constructorArgs);
+              return new SerialStateHolder(original, lazyLoader.getPropertyNames(), objectFactory, constructorArgTypes, constructorArgs);
             } else {
               return original;
             }
@@ -132,4 +131,56 @@ public Object intercept(Object enhanced, Method method, Object[] args, MethodPro
     }
   }
 
+  private static class EnhancedDeserializationProxyImpl implements MethodInterceptor {
+    private Class type;
+    private Set<String> unloadedProperties;
+    private ObjectFactory objectFactory;
+    private List<Class> constructorArgTypes;
+    private List<Object> constructorArgs;
+
+    private EnhancedDeserializationProxyImpl(Class type, Set<String> unloadedProperties, ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
+      this.type = type;
+      this.unloadedProperties = unloadedProperties;
+      this.objectFactory = objectFactory;
+      this.constructorArgTypes = constructorArgTypes;
+      this.constructorArgs = constructorArgs;
+    }
+
+    public static Object createProxy(Object target, Set<String> unloadedProperties, ObjectFactory objectFactory, List<Class> constructorArgTypes, List<Object> constructorArgs) {
+      final Class type = target.getClass();
+      EnhancedDeserializationProxyImpl callback = new EnhancedDeserializationProxyImpl(type, unloadedProperties, objectFactory, constructorArgTypes, constructorArgs);
+      Object enhanced = crateProxy(type, callback, constructorArgTypes, constructorArgs);
+      PropertyCopier.copyBeanProperties(type, target, enhanced);
+      return enhanced;
+    }
+
+    public Object intercept(Object enhanced, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
+      final String methodName = method.getName();
+      try {
+        if (WRITE_REPLACE_METHOD.equals(methodName)) {
+          Object original = null;
+          if (constructorArgTypes.isEmpty()) {
+            original = objectFactory.create(type);
+          } else {
+            original = objectFactory.create(type, constructorArgTypes, constructorArgs);
+          }
+          PropertyCopier.copyBeanProperties(type, enhanced, original);
+          return new SerialStateHolder(original, unloadedProperties, objectFactory, constructorArgTypes, constructorArgs);
+        } else {
+          if (!FINALIZE_METHOD.equals(methodName) && PropertyNamer.isProperty(methodName)) {
+            final String property = PropertyNamer.methodToProperty(methodName);
+            if (unloadedProperties.contains(property.toUpperCase(Locale.ENGLISH))) {
+              throw new ExecutorException("An attempt has been made to read a not loaded lazy property '" 
+                  + property
+                  + "' of a disconnected object");
+            }
+          }
+          return methodProxy.invokeSuper(enhanced, args);
+        }
+      } catch (Throwable t) {
+        throw ExceptionUtil.unwrapThrowable(t);
+      }
+    }
+  }
+
 }

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

@@ -31,7 +31,7 @@ protected Object readResolve() throws ObjectStreamException {
     Set<String> arrayProps = new HashSet<String>(Arrays.asList(this.unloadedProperties));
     List<Class> arrayTypes = Arrays.asList(this.constructorArgTypes);
     List<Object> arrayValues = Arrays.asList(this.constructorArgs);
-    return DeserializedObjectProxy.createProxy(userBean, arrayProps, objectFactory, arrayTypes, arrayValues);
+    return ResultObjectProxy.createDeserializationProxy(userBean, arrayProps, objectFactory, arrayTypes, arrayValues);
   }
 
 }

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

@@ -0,0 +1,9 @@
+package org.apache.ibatis.executor.loader;
+
+import java.io.ObjectStreamException;
+
+public interface WriteReplaceInterface {
+
+  Object writeReplace() throws ObjectStreamException;
+
+}

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

@@ -15,9 +15,9 @@
 import java.util.ArrayList;
 import java.util.HashSet;
 
-import org.apache.ibatis.executor.loader.DeserializedObjectProxy;
 import org.apache.ibatis.executor.loader.ResultLoaderMap;
 import org.apache.ibatis.executor.loader.ResultObjectProxy;
+import org.apache.ibatis.executor.loader.WriteReplaceInterface;
 import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
 import org.junit.Test;
 
@@ -93,19 +93,19 @@ public void shouldFailCallingAnUnloadedProperty() throws Exception {
     // yes, it must go in uppercase
     HashSet<String> unloadedProperties = new HashSet<String>();
     unloadedProperties.add("ID");
-    Author author2 = (Author) DeserializedObjectProxy.createProxy(author, unloadedProperties, new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
+    Author author2 = (Author) ResultObjectProxy.createDeserializationProxy(author, unloadedProperties, new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
     author2.getId();
   }
 
   @Test
   public void shouldLetCallALoadedProperty() throws Exception {
-    Author author2 = (Author) DeserializedObjectProxy.createProxy(author, new HashSet<String>(), new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
+    Author author2 = (Author) ResultObjectProxy.createDeserializationProxy(author, new HashSet<String>(), new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
     assertEquals(999, author2.getId());
   }
 
   @Test
   public void shouldSerizalizeADeserlizaliedProxy() throws Exception {
-    Object proxy = DeserializedObjectProxy.createProxy(author, new HashSet<String>(), new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
+    Object proxy = ResultObjectProxy.createDeserializationProxy(author, new HashSet<String>(), new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
     Author author2 = (Author) deserialize(serialize((Serializable) proxy));
     assertEquals(author, author2);
     assertFalse(author.getClass().equals(author2.getClass()));
@@ -120,20 +120,27 @@ public void shouldGenerateWriteReplace() throws Exception {
       // ok
     }
     Object proxy = ResultObjectProxy.createProxy(author, new ResultLoaderMap(), true, new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
-    proxy.getClass().getDeclaredMethod("writeReplace");
+    Method m = proxy.getClass().getDeclaredMethod("writeReplace");
   }
 
   @Test
   public void shouldNotGenerateWriteReplaceItThereIsAlreadyOne() throws Exception {
     AuthorWithWriteReplaceMethod beanWithWriteReplace = new AuthorWithWriteReplaceMethod(999, "someone", "!@#@!#!@#", "[email protected]", "blah", Section.NEWS);
-    Object proxy = ResultObjectProxy.createProxy(author, new ResultLoaderMap(), true, new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
     try {
       beanWithWriteReplace.getClass().getDeclaredMethod("writeReplace");
     } catch (NoSuchMethodException e) {
       fail("Bean should declare a writeReplace method");
     }
-    Method m = proxy.getClass().getDeclaredMethod("writeReplace");
-    assertFalse(m.isAccessible()); //generated method is public so this one should be protected
+    Object proxy = ResultObjectProxy.createProxy(beanWithWriteReplace, new ResultLoaderMap(), true, new DefaultObjectFactory(), new ArrayList<Class>(), new ArrayList<Object>());
+    Class[] interfaces = proxy.getClass().getInterfaces();
+    boolean ownInterfaceFound = false;
+    for (Class i : interfaces) {
+      if (i.equals(WriteReplaceInterface.class)) {
+        ownInterfaceFound = true;
+        break;
+      }
+    }
+    assertFalse(ownInterfaceFound);
   }
 
   @Test