* InvocationHandler handler = new MyInvocationHandler(...);
* Class proxyClass = Proxy.getProxyClass(
* Foo.class.getClassLoader(), new Class[] { Foo.class });
* Foo f = (Foo) proxyClass
* .getConstructor(new Class[] { InvocationHandler.class })
* .newInstance(new Object[] { handler });
*
* or more simply:
*
* Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
* new Class[] { Foo.class },
* handler);
*
*
* public and final,
* and is neither abstract nor an inner class.proxy instanceof Foo will return true,
* and the expression (Foo) proxy will succeed without
* a {@link ClassCastException}.* * In short, if a method is declared in Object (namely, hashCode, * equals, or toString), then Object will be used; otherwise, the * leftmost interface that inherits or declares a method will be used, * even if it has a more permissive throws clause than what the proxy * class is allowed. Thus, in the invocation handler, it is not always * safe to assume that every class listed in the throws clause of the * passed Method object can safely be thrown; fortunately, the Proxy * instance is robust enough to wrap all illegal checked exceptions in * {@link UndeclaredThrowableException}. * * @see InvocationHandler * @see UndeclaredThrowableException * @see Class * @author Eric Blake (ebb9@email.byu.edu) * @since 1.3 * @status updated to 1.5, except for the use of ProtectionDomain */ public class Proxy implements Serializable { /** * Compatible with JDK 1.3+. */ private static final long serialVersionUID = -2222568056686623797L; /** * Map of ProxyType to proxy class. * * @XXX This prevents proxy classes from being garbage collected. * java.util.WeakHashSet is not appropriate, because that collects the * keys, but we are interested in collecting the elements. */ private static final Map proxyClasses = new HashMap(); /** * The invocation handler for this proxy instance. For Proxy, this * field is unused, but it appears here in order to be serialized in all * proxy classes. * * NOTE: This implementation is more secure for proxy classes * than what Sun specifies. Sun does not require h to be immutable, but * this means you could change h after the fact by reflection. However, * by making h immutable, we may break non-proxy classes which extend * Proxy. * @serial invocation handler associated with this proxy instance */ protected InvocationHandler h; /** * Constructs a new Proxy from a subclass (usually a proxy class), * with the specified invocation handler. * * NOTE: This throws a NullPointerException if you attempt * to create a proxy instance with a null handler using reflection. * This behavior is not yet specified by Sun; see Sun Bug 4487672. * * @param handler the invocation handler, may be null if the subclass * is not a proxy class * @throws NullPointerException if handler is null and this is a proxy * instance */ protected Proxy(InvocationHandler handler) { if (handler == null && isProxyClass(getClass())) throw new NullPointerException("invalid handler"); h = handler; } /** * Returns the proxy {@link Class} for the given ClassLoader and array * of interfaces, dynamically generating it if necessary. * *
There are several restrictions on this method, the violation of * which will result in an IllegalArgumentException or * NullPointerException:
* *Class.forName(i.getName(), false, loader) == i
* must be true.Note that different orders of interfaces produce distinct classes.
* * @param loader the class loader to define the proxy class in; null * implies the bootstrap class loader * @param interfaces the array of interfaces the proxy class implements, * may be empty, but not null * @return the Class object of the proxy class * @throws IllegalArgumentException if the constraints above were * violated, except for problems with null * @throws NullPointerException if `interfaces' is null or contains * a null entry */ // synchronized so that we aren't trying to build the same class // simultaneously in two threads public static synchronized Class getProxyClass(ClassLoader loader, Class... interfaces) { interfaces = (Class[]) interfaces.clone(); ProxyType pt = new ProxyType(loader, interfaces); Class clazz = (Class) proxyClasses.get(pt); if (clazz == null) { if (VMProxy.HAVE_NATIVE_GET_PROXY_CLASS) clazz = VMProxy.getProxyClass(loader, interfaces); else { ProxyData data = (VMProxy.HAVE_NATIVE_GET_PROXY_DATA ? VMProxy.getProxyData(loader, interfaces) : ProxyData.getProxyData(pt)); clazz = (VMProxy.HAVE_NATIVE_GENERATE_PROXY_CLASS ? VMProxy.generateProxyClass(loader, data) : new ClassFactory(data).generate(loader)); } Object check = proxyClasses.put(pt, clazz); // assert check == null && clazz != null; if (check != null || clazz == null) throw new InternalError(/*"Fatal flaw in getProxyClass"*/); } return clazz; } /** * Combines several methods into one. This is equivalent to: *
* Proxy.getProxyClass(loader, interfaces)
* .getConstructor(new Class[] {InvocationHandler.class})
* .newInstance(new Object[] {handler});
*
* except that it will not fail with the normal problems caused
* by reflection. It can still fail for the same reasons documented
* in getProxyClass, or if handler is null.
*
* @param loader the class loader to define the proxy class in; null
* implies the bootstrap class loader
* @param interfaces the array of interfaces the proxy class implements,
* may be empty, but not null
* @param handler the invocation handler, may not be null
* @return a proxy instance implementing the specified interfaces
* @throws IllegalArgumentException if the constraints for getProxyClass
* were violated, except for problems with null
* @throws NullPointerException if `interfaces' is null or contains
* a null entry, or if handler is null
* @see #getProxyClass(ClassLoader, Class[])
* @see Class#getConstructor(Class[])
* @see Constructor#newInstance(Object[])
*/
public static Object newProxyInstance(ClassLoader loader,
Class[] interfaces,
InvocationHandler handler)
{
try
{
// getProxyClass() and Proxy() throw the necessary exceptions
return getProxyClass(loader, interfaces)
.getConstructor(new Class[] {InvocationHandler.class})
.newInstance(new Object[] {handler});
}
catch (RuntimeException e)
{
// Let IllegalArgumentException, NullPointerException escape.
// assert e instanceof IllegalArgumentException
// || e instanceof NullPointerException;
throw e;
}
catch (InvocationTargetException e)
{
// Let wrapped NullPointerException escape.
// assert e.getTargetException() instanceof NullPointerException
throw (NullPointerException) e.getCause();
}
catch (Exception e)
{
// Covers InstantiationException, IllegalAccessException,
// NoSuchMethodException, none of which should be generated
// if the proxy class was generated correctly.
// assert false;
throw (Error) new InternalError("Unexpected: " + e).initCause(e);
}
}
/**
* Returns true if and only if the Class object is a dynamically created
* proxy class (created by getProxyClass or by the
* syntactic sugar of newProxyInstance).
*
* This check is secure (in other words, it is not simply
* clazz.getSuperclass() == Proxy.class), it will not
* be spoofed by non-proxy classes that extend Proxy.
*
* @param clazz the class to check, must not be null
* @return true if the class represents a proxy class
* @throws NullPointerException if clazz is null
*/
// This is synchronized on the off chance that another thread is
// trying to add a class to the map at the same time we read it.
public static synchronized boolean isProxyClass(Class clazz)
{
if (! Proxy.class.isAssignableFrom(clazz))
return false;
// This is a linear search, even though we could do an O(1) search
// using new ProxyType(clazz.getClassLoader(), clazz.getInterfaces()).
return proxyClasses.containsValue(clazz);
}
/**
* Returns the invocation handler for the given proxy instance.
*
* NOTE: We guarantee a non-null result if successful,
* but Sun allows the creation of a proxy instance with a null
* handler. See the comments for {@link #Proxy(InvocationHandler)}.
*
* @param proxy the proxy instance, must not be null
* @return the invocation handler, guaranteed non-null.
* @throws IllegalArgumentException if
* Proxy.isProxyClass(proxy.getClass()) returns false.
* @throws NullPointerException if proxy is null
*/
public static InvocationHandler getInvocationHandler(Object proxy)
{
if (! isProxyClass(proxy.getClass()))
throw new IllegalArgumentException("not a proxy instance");
return ((Proxy) proxy).h;
}
/**
* Helper class for mapping unique ClassLoader and interface combinations
* to proxy classes.
*
* @author Eric Blake (ebb9@email.byu.edu)
*/
private static final class ProxyType
{
/**
* Store the class loader (may be null)
*/
final ClassLoader loader;
/**
* Store the interfaces (never null, all elements are interfaces)
*/
final Class[] interfaces;
/**
* Construct the helper object.
*
* @param loader the class loader to define the proxy class in; null
* implies the bootstrap class loader
* @param interfaces an array of interfaces
*/
ProxyType(ClassLoader loader, Class[] interfaces)
{
this.loader = loader;
this.interfaces = interfaces;
}
/**
* Calculates the hash code.
*
* @return a combination of the classloader and interfaces hashcodes.
*/
public int hashCode()
{
int hash = loader == null ? 0 : loader.hashCode();
for (int i = 0; i < interfaces.length; i++)
hash = hash * 31 + interfaces[i].hashCode();
return hash;
}
/**
* Calculates equality.
*
* @param other object to compare to
* @return true if it is a ProxyType with same data
*/
public boolean equals(Object other)
{
ProxyType pt = (ProxyType) other;
if (loader != pt.loader || interfaces.length != pt.interfaces.length)
return false;
for (int i = 0; i < interfaces.length; i++)
if (interfaces[i] != pt.interfaces[i])
return false;
return true;
}
} // class ProxyType
/**
* Helper class which allows hashing of a method name and signature
* without worrying about return type, declaring class, or throws clause,
* and which reduces the maximally common throws clause between two methods
*
* @author Eric Blake (ebb9@email.byu.edu)
*/
private static final class ProxySignature
{
/**
* The core signatures which all Proxy instances handle.
*/
static final HashMap coreMethods = new HashMap();
static
{
try
{
ProxySignature sig
= new ProxySignature(Object.class
.getMethod("equals",
new Class[] {Object.class}));
coreMethods.put(sig, sig);
sig = new ProxySignature(Object.class.getMethod("hashCode"));
coreMethods.put(sig, sig);
sig = new ProxySignature(Object.class.getMethod("toString"));
coreMethods.put(sig, sig);
}
catch (Exception e)
{
// assert false;
throw (Error) new InternalError("Unexpected: " + e).initCause(e);
}
}
/**
* The underlying Method object, never null
*/
final Method method;
/**
* The set of compatible thrown exceptions, may be empty
*/
final Set exceptions = new HashSet();
/**
* Construct a signature
*
* @param method the Method this signature is based on, never null
*/
ProxySignature(Method method)
{
this.method = method;
Class[] exc = method.getExceptionTypes();
int i = exc.length;
while (--i >= 0)
{
// discard unchecked exceptions
if (Error.class.isAssignableFrom(exc[i])
|| RuntimeException.class.isAssignableFrom(exc[i]))
continue;
exceptions.add(exc[i]);
}
}
/**
* Given a method, make sure it's return type is identical
* to this, and adjust this signature's throws clause appropriately
*
* @param other the signature to merge in
* @throws IllegalArgumentException if the return types conflict
*/
void checkCompatibility(ProxySignature other)
{
if (method.getReturnType() != other.method.getReturnType())
throw new IllegalArgumentException("incompatible return types: "
+ method + ", " + other.method);
// if you can think of a more efficient way than this O(n^2) search,
// implement it!
int size1 = exceptions.size();
int size2 = other.exceptions.size();
boolean[] valid1 = new boolean[size1];
boolean[] valid2 = new boolean[size2];
Iterator itr = exceptions.iterator();
int pos = size1;
while (--pos >= 0)
{
Class c1 = (Class) itr.next();
Iterator itr2 = other.exceptions.iterator();
int pos2 = size2;
while (--pos2 >= 0)
{
Class c2 = (Class) itr2.next();
if (c2.isAssignableFrom(c1))
valid1[pos] = true;
if (c1.isAssignableFrom(c2))
valid2[pos2] = true;
}
}
pos = size1;
itr = exceptions.iterator();
while (--pos >= 0)
{
itr.next();
if (! valid1[pos])
itr.remove();
}
pos = size2;
itr = other.exceptions.iterator();
while (--pos >= 0)
{
itr.next();
if (! valid2[pos])
itr.remove();
}
exceptions.addAll(other.exceptions);
}
/**
* Calculates the hash code.
*
* @return a combination of name and parameter types
*/
public int hashCode()
{
int hash = method.getName().hashCode();
Class[] types = method.getParameterTypes();
for (int i = 0; i < types.length; i++)
hash = hash * 31 + types[i].hashCode();
return hash;
}
/**
* Calculates equality.
*
* @param other object to compare to
* @return true if it is a ProxySignature with same data
*/
public boolean equals(Object other)
{
ProxySignature ps = (ProxySignature) other;
Class[] types1 = method.getParameterTypes();
Class[] types2 = ps.method.getParameterTypes();
if (! method.getName().equals(ps.method.getName())
|| types1.length != types2.length)
return false;
int i = types1.length;
while (--i >= 0)
if (types1[i] != types2[i])
return false;
return true;
}
} // class ProxySignature
/**
* A flat representation of all data needed to generate bytecode/instantiate
* a proxy class. This is basically a struct.
*
* @author Eric Blake (ebb9@email.byu.edu)
*/
static final class ProxyData
{
/**
* The package this class is in including the trailing dot
* or an empty string for the unnamed (aka default) package.
*/
String pack = "";
/**
* The interfaces this class implements. Non-null, but possibly empty.
*/
Class[] interfaces;
/**
* The Method objects this class must pass as the second argument to
* invoke (also useful for determining what methods this class has).
* Non-null, non-empty (includes at least Object.hashCode, Object.equals,
* and Object.toString).
*/
Method[] methods;
/**
* The exceptions that do not need to be wrapped in
* UndeclaredThrowableException. exceptions[i] is the same as, or a
* subset of subclasses, of methods[i].getExceptionTypes(), depending on
* compatible throws clauses with multiple inheritance. It is unspecified
* if these lists include or exclude subclasses of Error and
* RuntimeException, but excluding them is harmless and generates a
* smaller class.
*/
Class[][] exceptions;
/**
* For unique id's
*/
private static int count;
/**
* The id of this proxy class
*/
final int id = count++;
/**
* Construct a ProxyData with uninitialized data members.
*/
ProxyData()
{
}
/**
* Return the name of a package (including the trailing dot)
* given the name of a class.
* Returns an empty string if no package. We use this in preference to
* using Class.getPackage() to avoid problems with ClassLoaders
* that don't set the package.
*/
private static String getPackage(Class k)
{
String name = k.getName();
int idx = name.lastIndexOf('.');
return name.substring(0, idx + 1);
}
/**
* Verifies that the arguments are legal, and sets up remaining data
* This should only be called when a class must be generated, as
* it is expensive.
*
* @param pt the ProxyType to convert to ProxyData
* @return the flattened, verified ProxyData structure for use in
* class generation
* @throws IllegalArgumentException if `interfaces' contains
* non-interfaces or incompatible combinations, and verify is true
* @throws NullPointerException if interfaces is null or contains null
*/
static ProxyData getProxyData(ProxyType pt)
{
Map method_set = (Map) ProxySignature.coreMethods.clone();
boolean in_package = false; // true if we encounter non-public interface
ProxyData data = new ProxyData();
data.interfaces = pt.interfaces;
// if interfaces is too large, we croak later on when the constant
// pool overflows
int i = data.interfaces.length;
while (--i >= 0)
{
Class inter = data.interfaces[i];
if (! inter.isInterface())
throw new IllegalArgumentException("not an interface: " + inter);
try
{
if (Class.forName(inter.getName(), false, pt.loader) != inter)
throw new IllegalArgumentException("not accessible in "
+ "classloader: " + inter);
}
catch (ClassNotFoundException e)
{
throw new IllegalArgumentException("not accessible in "
+ "classloader: " + inter);
}
if (! Modifier.isPublic(inter.getModifiers()))
if (in_package)
{
String p = getPackage(inter);
if (! data.pack.equals(p))
throw new IllegalArgumentException("non-public interfaces "
+ "from different "
+ "packages");
}
else
{
in_package = true;
data.pack = getPackage(inter);
}
for (int j = i-1; j >= 0; j--)
if (data.interfaces[j] == inter)
throw new IllegalArgumentException("duplicate interface: "
+ inter);
Method[] methods = inter.getMethods();
int j = methods.length;
while (--j >= 0)
{
if (isCoreObjectMethod(methods[j]))
{
// In the case of an attempt to redefine a public non-final
// method of Object, we must skip it
continue;
}
ProxySignature sig = new ProxySignature(methods[j]);
ProxySignature old = (ProxySignature) method_set.put(sig, sig);
if (old != null)
sig.checkCompatibility(old);
}
}
i = method_set.size();
data.methods = new Method[i];
data.exceptions = new Class[i][];
Iterator itr = method_set.values().iterator();
while (--i >= 0)
{
ProxySignature sig = (ProxySignature) itr.next();
data.methods[i] = sig.method;
data.exceptions[i] = (Class[]) sig.exceptions
.toArray(new Class[sig.exceptions.size()]);
}
return data;
}
/**
* Checks whether the method is similar to a public non-final method of
* Object or not (i.e. with the same name and parameter types). Note that we
* can't rely, directly or indirectly (via Collection.contains) on
* Method.equals as it would also check the declaring class, what we do not
* want. We only want to check that the given method have the same signature
* as a core method (same name and parameter types)
*
* @param method the method to check
* @return whether the method has the same name and parameter types as
* Object.equals, Object.hashCode or Object.toString
* @see java.lang.Object#equals(Object)
* @see java.lang.Object#hashCode()
* @see java.lang.Object#toString()
*/
private static boolean isCoreObjectMethod(Method method)
{
String methodName = method.getName();
if (methodName.equals("equals"))
{
return Arrays.equals(method.getParameterTypes(),
new Class[] { Object.class });
}
if (methodName.equals("hashCode"))
{
return method.getParameterTypes().length == 0;
}
if (methodName.equals("toString"))
{
return method.getParameterTypes().length == 0;
}
return false;
}
} // class ProxyData
/**
* Does all the work of building a class. By making this a nested class,
* this code is not loaded in memory if the VM has a native
* implementation instead.
*
* @author Eric Blake (ebb9@email.byu.edu)
*/
private static final class ClassFactory
{
/** Constants for assisting the compilation */
private static final byte FIELD = 1;
private static final byte METHOD = 2;
private static final byte INTERFACE = 3;
private static final String CTOR_SIG
= "(Ljava/lang/reflect/InvocationHandler;)V";
private static final String INVOKE_SIG = "(Ljava/lang/Object;"
+ "Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;";
/** Bytecodes for insertion in the class definition byte[] */
private static final char ACONST_NULL = 1;
private static final char ICONST_0 = 3;
private static final char BIPUSH = 16;
private static final char SIPUSH = 17;
private static final char ILOAD = 21;
private static final char ILOAD_0 = 26;
private static final char ALOAD_0 = 42;
private static final char ALOAD_1 = 43;
private static final char AALOAD = 50;
private static final char AASTORE = 83;
private static final char DUP = 89;
private static final char DUP_X1 = 90;
private static final char SWAP = 95;
private static final char IRETURN = 172;
private static final char LRETURN = 173;
private static final char FRETURN = 174;
private static final char DRETURN = 175;
private static final char ARETURN = 176;
private static final char RETURN = 177;
private static final char GETSTATIC = 178;
private static final char GETFIELD = 180;
private static final char INVOKEVIRTUAL = 182;
private static final char INVOKESPECIAL = 183;
private static final char INVOKEINTERFACE = 185;
private static final char NEW = 187;
private static final char ANEWARRAY = 189;
private static final char ATHROW = 191;
private static final char CHECKCAST = 192;
// Implementation note: we use StringBuffers to hold the byte data, since
// they automatically grow. However, we only use the low 8 bits of
// every char in the array, so we are using twice the necessary memory
// for the ease StringBuffer provides.
/** The constant pool. */
private final StringBuffer pool = new StringBuffer();
/** The rest of the class data. */
private final StringBuffer stream = new StringBuffer();
/** Map of strings to byte sequences, to minimize size of pool. */
private final Map poolEntries = new HashMap();
/** The VM name of this proxy class. */
private final String qualName;
/**
* The Method objects the proxy class refers to when calling the
* invocation handler.
*/
private final Method[] methods;
/**
* Initializes the buffers with the bytecode contents for a proxy class.
*
* @param data the remainder of the class data
* @throws IllegalArgumentException if anything else goes wrong this
* late in the game; as far as I can tell, this will only happen
* if the constant pool overflows, which is possible even when
* the user doesn't exceed the 65535 interface limit
*/
ClassFactory(ProxyData data)
{
methods = data.methods;
// magic = 0xcafebabe
// minor_version = 0
// major_version = 46
// constant_pool_count: place-holder for now
pool.append("\u00ca\u00fe\u00ba\u00be\0\0\0\56\0\0");
// constant_pool[], filled in as we go
// access_flags
putU2(Modifier.SUPER | Modifier.FINAL | Modifier.PUBLIC);
// this_class
qualName = (data.pack + "$Proxy" + data.id);
putU2(classInfo(TypeSignature.getEncodingOfClass(qualName, false)));
// super_class
putU2(classInfo("java/lang/reflect/Proxy"));
// interfaces_count
putU2(data.interfaces.length);
// interfaces[]
for (int i = 0; i < data.interfaces.length; i++)
putU2(classInfo(data.interfaces[i]));
// Recall that Proxy classes serialize specially, so we do not need
// to worry about a