SPR-6394

SPR-6333
+ eliminated compile-time dependency on GlassFish custom API for the GlassFish LTW
+ added support for GlassFish 3

org.springframework.context/src/main/java/org/springframework/instrument/classloading/glassfish/ClassTransformerAdapter.java

@@ -23,7 +23,7 @@ import java.security.ProtectionDomain;
 import javax.persistence.spi.ClassTransformer;
 
 /**
- * Adapter that implements the JPA ClassTransformer interface (as required by GlassFish)
+ * Adapter that implements the JPA ClassTransformer interface (as required by GlassFish V1 and V2)
  * based on a given JDK 1.5 ClassFileTransformer.
  *
  * @author Costin Leau
@@ -34,7 +34,6 @@ class ClassTransformerAdapter implements ClassTransformer {
 
 	private final ClassFileTransformer classFileTransformer;
 
-
 	/**
 	 * Build a new ClassTransformerAdapter for the given ClassFileTransformer.
 	 * @param classFileTransformer the JDK 1.5 ClassFileTransformer to wrap
@@ -43,15 +42,13 @@ class ClassTransformerAdapter implements ClassTransformer {
 		this.classFileTransformer = classFileTransformer;
 	}
 
-
 	public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
 			ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
 
-		byte[] result = this.classFileTransformer.transform(
-				loader, className, classBeingRedefined, protectionDomain, classfileBuffer);
+		byte[] result = this.classFileTransformer.transform(loader, className, classBeingRedefined, protectionDomain,
+				classfileBuffer);
 
 		// If no transformation was done, return null.
 		return (result == classfileBuffer ? null : result);
 	}
-
 }

org.springframework.context/src/main/java/org/springframework/instrument/classloading/glassfish/GlassFishClassLoaderAdapter.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2006-2009 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.springframework.instrument.classloading.glassfish;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Reflective wrapper around the GlassFish class loader. Used to
+ * encapsulate the classloader-specific methods (discovered and
+ * called through reflection) from the load-time weaver.
+ * 
+ * <p/> Supports GlassFish V1, V2 and V3 (currently in beta).
+ * 
+ * @author Costin Leau
+ * @since 3.0.0
+ */
+class GlassFishClassLoaderAdapter {
+
+	static final String INSTRUMENTABLE_CLASSLOADER_GLASSFISH_V2 = "com.sun.enterprise.loader.InstrumentableClassLoader";
+	static final String INSTRUMENTABLE_CLASSLOADER_GLASSFISH_V3 = "org.glassfish.api.deployment.InstrumentableClassLoader";
+	private static final String CLASS_TRANSFORMER = "javax.persistence.spi.ClassTransformer";
+
+	private final ClassLoader classLoader;
+	private final Method addTransformer;
+	private final Method copy;
+	private final boolean glassFishV3;
+
+	public GlassFishClassLoaderAdapter(ClassLoader classLoader) {
+		Class<?> instrumentableLoaderClass = null;
+		boolean glassV3 = false;
+		try {
+			// try the V1/V2 API first
+			instrumentableLoaderClass = classLoader.loadClass(INSTRUMENTABLE_CLASSLOADER_GLASSFISH_V2);
+		} catch (ClassNotFoundException ex) {
+			// fall back to V3
+			try {
+				instrumentableLoaderClass = classLoader.loadClass(INSTRUMENTABLE_CLASSLOADER_GLASSFISH_V3);
+				glassV3 = true;
+			} catch (ClassNotFoundException cnfe) {
+				throw new IllegalStateException(
+						"Could not initialize GlassFish LoadTimeWeaver because GlassFish (V1, V2 or V3) API classes are not available",
+						ex);
+			}
+		}
+		try {
+			Class<?> classTransformerClass = (glassV3 ? ClassFileTransformer.class : classLoader
+					.loadClass(CLASS_TRANSFORMER));
+
+			addTransformer = instrumentableLoaderClass.getMethod("addTransformer", classTransformerClass);
+			copy = instrumentableLoaderClass.getMethod("copy");
+
+		} catch (Exception ex) {
+			throw new IllegalStateException(
+					"Could not initialize GlassFish LoadTimeWeaver because GlassFish API classes are not available", ex);
+		}
+
+		ClassLoader clazzLoader = null;
+		// Detect transformation-aware ClassLoader by traversing the hierarchy
+		// (as in GlassFish, Spring can be loaded by the WebappClassLoader).
+		for (ClassLoader cl = classLoader; cl != null && clazzLoader == null; cl = cl.getParent()) {
+			if (instrumentableLoaderClass.isInstance(cl)) {
+				clazzLoader = cl;
+			}
+		}
+
+		if (clazzLoader == null) {
+			throw new IllegalArgumentException(classLoader + " and its parents are not suitable ClassLoaders: " + "A ["
+					+ instrumentableLoaderClass.getName() + "] implementation is required.");
+		}
+
+		this.classLoader = clazzLoader;
+		this.glassFishV3 = glassV3;
+	}
+
+	public void addTransformer(ClassFileTransformer transformer) {
+		try {
+			addTransformer.invoke(classLoader, (glassFishV3 ? transformer : new ClassTransformerAdapter(transformer)));
+		} catch (InvocationTargetException ex) {
+			throw new IllegalStateException("GlassFish addTransformer method threw exception ", ex.getCause());
+		} catch (Exception ex) {
+			throw new IllegalStateException("Could not invoke GlassFish addTransformer method", ex);
+		}
+	}
+
+	public ClassLoader getClassLoader() {
+		return this.classLoader;
+	}
+
+	public ClassLoader getThrowawayClassLoader() {
+		try {
+			return (ClassLoader) copy.invoke(classLoader, (Object[]) null);
+		} catch (InvocationTargetException ex) {
+			throw new IllegalStateException("GlassFish copy method threw exception ", ex.getCause());
+		} catch (Exception ex) {
+			throw new IllegalStateException("Could not invoke GlassFish copy method", ex);
+		}
+	}
+}

org.springframework.context/src/main/java/org/springframework/instrument/classloading/glassfish/GlassFishLoadTimeWeaver.java

@@ -18,28 +18,26 @@ package org.springframework.instrument.classloading.glassfish;
 
 import java.lang.instrument.ClassFileTransformer;
 
-import com.sun.enterprise.loader.InstrumentableClassLoader;
-
 import org.springframework.instrument.classloading.LoadTimeWeaver;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
 /**
  * {@link LoadTimeWeaver} implementation for GlassFish's
- * {@link InstrumentableClassLoader}.
+ * {@link InstrumentableClassLoader}. 
+ * 
+ * <p/>Since Spring 3.0.0, GlassFish V3 is supported as well.
  *
  * @author Costin Leau
  * @author Juergen Hoeller
  * @since 2.0.1
- * @see com.sun.enterprise.loader.InstrumentableClassLoader
  */
 public class GlassFishLoadTimeWeaver implements LoadTimeWeaver {
 
-	private final InstrumentableClassLoader classLoader;
-
+	private final GlassFishClassLoaderAdapter classLoader;
 
 	/**
-	 * Create a new instance of the <code>GlassFishLoadTimeWeaver</code> class
+	 * Creates a new instance of the <code>GlassFishLoadTimeWeaver</code> class
 	 * using the default {@link ClassLoader}.
 	 * @see #GlassFishLoadTimeWeaver(ClassLoader)
 	 */
@@ -48,49 +46,25 @@ public class GlassFishLoadTimeWeaver implements LoadTimeWeaver {
 	}
 
 	/**
-	 * Create a new instance of the <code>GlassFishLoadTimeWeaver</code> class.
+	 * Creates a new instance of the <code>GlassFishLoadTimeWeaver</code> class.
 	 * @param classLoader the specific {@link ClassLoader} to use; must not be <code>null</code>
 	 * @throws IllegalArgumentException if the supplied <code>classLoader</code> is <code>null</code>;
 	 * or if the supplied <code>classLoader</code> is not an {@link InstrumentableClassLoader}
 	 */
 	public GlassFishLoadTimeWeaver(ClassLoader classLoader) {
 		Assert.notNull(classLoader, "ClassLoader must not be null");
-		InstrumentableClassLoader icl = determineClassLoader(classLoader);
-		if (icl == null) {
-			throw new IllegalArgumentException(classLoader + " and its parents are not suitable ClassLoaders: " +
-					"An [" + InstrumentableClassLoader.class.getName() + "] implementation is required.");
-		}
-		this.classLoader = icl;
+		this.classLoader = new GlassFishClassLoaderAdapter(classLoader);
 	}
 
-	/**
-	 * Determine the GlassFish {@link InstrumentableClassLoader} for the given
-	 * {@link ClassLoader}.
-	 * @param classLoader the <code>ClassLoader</code> to check
-	 * @return the <code>InstrumentableClassLoader</code>, or <code>null</code> if none found
-	 */
-	protected InstrumentableClassLoader determineClassLoader(ClassLoader classLoader) {
-		// Detect transformation-aware ClassLoader by traversing the hierarchy
-		// (as in GlassFish, Spring can be loaded by the WebappClassLoader).
-		for (ClassLoader cl = classLoader; cl != null; cl = cl.getParent()) {
-			if (cl instanceof InstrumentableClassLoader) {
-				return (InstrumentableClassLoader) cl;
-			}
-		}
-		return null;
-	}
-
-
 	public void addTransformer(ClassFileTransformer transformer) {
-		this.classLoader.addTransformer(new ClassTransformerAdapter(transformer));
+		this.classLoader.addTransformer(transformer);
 	}
 
 	public ClassLoader getInstrumentableClassLoader() {
-		return (ClassLoader) this.classLoader;
+		return this.classLoader.getClassLoader();
 	}
 
 	public ClassLoader getThrowawayClassLoader() {
-		return this.classLoader.copy();
+		return this.classLoader.getThrowawayClassLoader();
 	}
-
-}
+}