created an interface that helps with dealing with proxied objects that has a default implementation and one for hibernate

Author: graemerocher

src/java/org/codehaus/groovy/grails/orm/hibernate/proxy/HibernateProxyHandler.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2004-2008 the original author or authors.
+ *
+ * Licensed 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.codehaus.groovy.grails.orm.hibernate.proxy;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.apache.commons.beanutils.PropertyUtils;
+import org.codehaus.groovy.grails.support.proxy.ProxyHandler;
+import org.hibernate.Hibernate;
+import org.hibernate.collection.AbstractPersistentCollection;
+import org.hibernate.collection.PersistentCollection;
+import org.hibernate.proxy.HibernateProxy;
+import org.hibernate.proxy.LazyInitializer;
+
+/**
+ * Implementation of the ProxyHandler interface for Hibernate
+ * 
+ * @author Graeme Rocher
+ * @since 1.2.2
+ */
+public class HibernateProxyHandler implements ProxyHandler {
+
+	public boolean isInitialized(Object o) {
+		if(o instanceof HibernateProxy) {
+			return !((HibernateProxy)o).getHibernateLazyInitializer().isUninitialized();
+		}
+		else if(o instanceof PersistentCollection) {
+			return ((PersistentCollection)o).wasInitialized();
+		}
+		return true;
+	}
+
+	public boolean isInitialized(Object obj, String associationName) {
+        try {
+            Object proxy = PropertyUtils.getProperty(obj, associationName);
+            return Hibernate.isInitialized(proxy);
+        }
+        catch (IllegalAccessException e) {
+            return false;
+        }
+        catch (InvocationTargetException e) {
+            return false;
+        }
+        catch (NoSuchMethodException e) {
+            return false;
+        }
+	}
+
+	public Object unwrapIfProxy(Object instance) {
+        if(instance instanceof HibernateProxy) {
+            final HibernateProxy proxy = (HibernateProxy)instance;
+			return unwrapProxy(proxy);
+        }
+        else if(instance instanceof AbstractPersistentCollection) {
+        	initialize(instance);
+        	return instance;
+        }
+        else {
+            return instance;
+        }
+	}
+
+	public Object unwrapProxy(final HibernateProxy proxy) {
+		final LazyInitializer lazyInitializer = proxy.getHibernateLazyInitializer();
+		if(lazyInitializer.isUninitialized()) {
+		    lazyInitializer.initialize();
+		}
+		return lazyInitializer.getImplementation();
+	}
+	
+	public HibernateProxy getAssociationProxy(Object obj, String associationName) {
+        try {
+            Object proxy = PropertyUtils.getProperty(obj, associationName);
+            if(proxy instanceof HibernateProxy) return (HibernateProxy) proxy;
+            else return null;
+        }
+        catch (IllegalAccessException e) {
+            return null;
+        }
+        catch (InvocationTargetException e) {
+            return null;
+        }
+        catch (NoSuchMethodException e) {
+            return null;
+        }
+	}
+
+	public boolean isProxy(Object o) {
+		return (o instanceof HibernateProxy) || (o instanceof AbstractPersistentCollection);
+	}
+
+	public void initialize(Object o) {
+		if(o instanceof HibernateProxy) {
+			final LazyInitializer hibernateLazyInitializer = ((HibernateProxy)o).getHibernateLazyInitializer();
+			if(hibernateLazyInitializer.isUninitialized())
+				hibernateLazyInitializer.initialize();
+		}
+		else if(o instanceof AbstractPersistentCollection) {
+			final AbstractPersistentCollection col = (AbstractPersistentCollection)o;
+			if(!col.wasInitialized())
+				col.forceInitialization();
+		}		
+	}
+
+}

src/java/org/codehaus/groovy/grails/support/proxy/DefaultProxyHandler.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2004-2008 the original author or authors.
+ *
+ * Licensed 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.codehaus.groovy.grails.support.proxy;
+
+/**
+ * Trivial default implementation that always returns true and the object
+ * 
+ * @author Graeme Rocher
+ * @since 1.2.2
+ *
+ */
+public class DefaultProxyHandler implements ProxyHandler {
+
+	public boolean isInitialized(Object o) {		
+		return true;
+	}
+
+	public boolean isInitialized(Object obj, String associationName) {
+		return true;
+	}
+
+	public Object unwrapIfProxy(Object instance) {
+		return instance;
+	}
+
+	public boolean isProxy(Object o) {
+		return false;
+	}
+
+	public void initialize(Object o) {
+		// do nothing		
+	}
+
+}

src/java/org/codehaus/groovy/grails/support/proxy/ProxyHandler.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2004-2008 the original author or authors.
+ *
+ * Licensed 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.codehaus.groovy.grails.support.proxy;
+
+/**
+ * Interface that defines logic for handling proxied instances
+ * 
+ * @author Graeme Rocher
+ * @since 1.2.2
+ *
+ */
+public interface ProxyHandler {
+
+	/**
+	 * Returns true if the specified object is a proxy
+	 * @param o The object in question
+	 * @return True if it is a proxy
+	 */
+	public boolean isProxy(Object o);
+	/**
+	 * Returns the unwrapped proxy instance or the original object if not proxied
+	 * 
+	 * @param instance The instance to unwrap 
+	 * @return The unwrapped instance
+	 */
+    public Object unwrapIfProxy(Object instance);
+
+    /**
+     * Returns whether a lazy proxied instance has been initialized
+     *  
+     * @param o The instance to test
+     * @return True if it has been initialized false otherwise
+     */
+    public boolean isInitialized(Object o);
+    
+    /**
+     * Initializes an existing uninitialized proxy instance
+     * @param o The proxy instance
+     */
+    public void initialize(Object o);
+    
+    /**
+     * Tests whether an association of the given object has been initialized or not 
+     * @param obj The object to check
+     * @param associationName The association
+     * @return True if has been init
+     */
+    boolean isInitialized(Object obj, String associationName);
+}