/** @param args */
public static void main(String[] args) {
String proxyName = "TempProxy";
TempImpl t = new TempImpl("proxy");
// TempProxy t = new TempProxy("proxy");
Class[] interfaces = t.getClass().getInterfaces();
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
// File f = new File("classes/TempProxy.class");
File f =
new File(
"D:\\workspace\\mianshi\\WebRoot\\WEB-INF\\classes\\com\\geek\\proxy\\TempProxy.class");
try {
FileOutputStream fos = new FileOutputStream(f);
fos.write(proxyClassFile);
fos.flush();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
} catch (IOException e) {
e.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
}
public static void main(String[] args) throws Exception {
Subject sub = new RealSubject();
Subject proxySub =
(Subject)
Proxy.newProxyInstance(
Subject.class.getClassLoader(), new Class[] {Subject.class}, new ProxyHandler(sub));
proxySub.say("fengxiang");
byte[] buffer = ProxyGenerator.generateProxyClass("ProxyClass", new Class[] {Subject.class});
FileOutputStream out = new FileOutputStream("ProxyClass.class");
out.write(buffer);
out.close();
// 从这里可以看到具体的接口创建代理的时候， 只会创建一个代理类， 而当前代理类的构造方法的参数就是InvocationHandler接口的对象， 所以如果
// 想要生成不同的对象， 并且有不同的功能， 此时直接设置不同的InvocationHandler就可以了， 就可以表现出完全不一样的行为。
// 从这里可以看到类肯定只是生成一次， 剩下的仅仅只是生成对象， 仅此而已， 所以一般情况下来说并不会有太大的性能影响的。
Subject proxySub2 =
(Subject)
Proxy.newProxyInstance(
Subject.class.getClassLoader(), new Class[] {Subject.class}, new ProxyHandler(sub));
System.out.println(proxySub.getClass() == proxySub2.getClass()); // true
}
/**
* Returns the {@code java.lang.Class} object for a proxy class given a class loader and an array
* of interfaces. The proxy class will be defined by the specified class loader and will implement
* all of the supplied interfaces. If a proxy class for the same permutation of interfaces has
* already been defined by the class loader, then the existing proxy class will be returned;
* otherwise, a proxy class for those interfaces will be generated dynamically and defined by the
* class loader.
*
* <p>There are several restrictions on the parameters that may be passed to {@code
* Proxy.getProxyClass}:
*
* <ul>
* <li>All of the {@code Class} objects in the {@code interfaces} array must represent
* interfaces, not classes or primitive types.
* <li>No two elements in the {@code interfaces} array may refer to identical {@code Class}
* objects.
* <li>All of the interface types must be visible by name through the specified class loader. In
* other words, for class loader {@code cl} and every interface {@code i}, the following
* expression must be true:
* <pre>
* Class.forName(i.getName(), false, cl) == i
* </pre>
* <li>All non-public interfaces must be in the same package; otherwise, it would not be
* possible for the proxy class to implement all of the interfaces, regardless of what
* package it is defined in.
* <li>For any set of member methods of the specified interfaces that have the same signature:
* <ul>
* <li>If the return type of any of the methods is a primitive type or void, then all of
* the methods must have that same return type.
* <li>Otherwise, one of the methods must have a return type that is assignable to all of
* the return types of the rest of the methods.
* </ul>
* <li>The resulting proxy class must not exceed any limits imposed on classes by the virtual
* machine. For example, the VM may limit the number of interfaces that a class may
* implement to 65535; in that case, the size of the {@code interfaces} array must not
* exceed 65535.
* </ul>
*
* <p>If any of these restrictions are violated, {@code Proxy.getProxyClass} will throw an {@code
* IllegalArgumentException}. If the {@code interfaces} array argument or any of its elements are
* {@code null}, a {@code NullPointerException} will be thrown.
*
* <p>Note that the order of the specified proxy interfaces is significant: two requests for a
* proxy class with the same combination of interfaces but in a different order will result in two
* distinct proxy classes.
*
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class to implement
* @return a proxy class that is defined in the specified class loader and that implements the
* specified interfaces
* @throws IllegalArgumentException if any of the restrictions on the parameters that may be
* passed to {@code getProxyClass} are violated
* @throws NullPointerException if the {@code interfaces} array argument or any of its elements
* are {@code null}
*/
public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)
throws IllegalArgumentException {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
Class<?> proxyClass = null;
/* collect interface names to use as key for proxy class cache */
String[] interfaceNames = new String[interfaces.length];
// for detecting duplicates
Set<Class<?>> interfaceSet = new HashSet<>();
for (int i = 0; i < interfaces.length; i++) {
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
String interfaceName = interfaces[i].getName();
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(interfaceName, false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != interfaces[i]) {
throw new IllegalArgumentException(interfaces[i] + " is not visible from class loader");
}
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");
}
/*
* Verify that this interface is not a duplicate.
*/
if (interfaceSet.contains(interfaceClass)) {
throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());
}
interfaceSet.add(interfaceClass);
interfaceNames[i] = interfaceName;
}
/*
* Using string representations of the proxy interfaces as
* keys in the proxy class cache (instead of their Class
* objects) is sufficient because we require the proxy
* interfaces to be resolvable by name through the supplied
* class loader, and it has the advantage that using a string
* representation of a class makes for an implicit weak
* reference to the class.
*/
List<String> key = Arrays.asList(interfaceNames);
/*
* Find or create the proxy class cache for the class loader.
*/
Map<List<String>, Object> cache;
synchronized (loaderToCache) {
cache = loaderToCache.get(loader);
if (cache == null) {
cache = new HashMap<>();
loaderToCache.put(loader, cache);
}
/*
* This mapping will remain valid for the duration of this
* method, without further synchronization, because the mapping
* will only be removed if the class loader becomes unreachable.
*/
}
/*
* Look up the list of interfaces in the proxy class cache using
* the key. This lookup will result in one of three possible
* kinds of values:
* null, if there is currently no proxy class for the list of
* interfaces in the class loader,
* the pendingGenerationMarker object, if a proxy class for the
* list of interfaces is currently being generated,
* or a weak reference to a Class object, if a proxy class for
* the list of interfaces has already been generated.
*/
synchronized (cache) {
/*
* Note that we need not worry about reaping the cache for
* entries with cleared weak references because if a proxy class
* has been garbage collected, its class loader will have been
* garbage collected as well, so the entire cache will be reaped
* from the loaderToCache map.
*/
do {
Object value = cache.get(key);
if (value instanceof Reference) {
proxyClass = (Class<?>) ((Reference) value).get();
}
if (proxyClass != null) {
// proxy class already generated: return it
return proxyClass;
} else if (value == pendingGenerationMarker) {
// proxy class being generated: wait for it
try {
cache.wait();
} catch (InterruptedException e) {
/*
* The class generation that we are waiting for should
* take a small, bounded time, so we can safely ignore
* thread interrupts here.
*/
}
continue;
} else {
/*
* No proxy class for this list of interfaces has been
* generated or is being generated, so we will go and
* generate it now. Mark it as pending generation.
*/
cache.put(key, pendingGenerationMarker);
break;
}
} while (true);
}
try {
String proxyPkg = null; // package to define proxy class in
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
for (int i = 0; i < interfaces.length; i++) {
int flags = interfaces[i].getModifiers();
if (!Modifier.isPublic(flags)) {
String name = interfaces[i].getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException("non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) { // if no non-public proxy interfaces,
proxyPkg = ""; // use the unnamed package
}
{
/*
* Choose a name for the proxy class to generate.
*/
long num;
synchronized (nextUniqueNumberLock) {
num = nextUniqueNumber++;
}
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Verify that the class loader hasn't already
* defined a class with the chosen name.
*/
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
try {
proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
// add to set of all generated proxy classes, for isProxyClass
proxyClasses.put(proxyClass, null);
} finally {
/*
* We must clean up the "pending generation" state of the proxy
* class cache entry somehow. If a proxy class was successfully
* generated, store it in the cache (with a weak reference);
* otherwise, remove the reserved entry. In all cases, notify
* all waiters on reserved entries in this cache.
*/
synchronized (cache) {
if (proxyClass != null) {
cache.put(key, new WeakReference<Class<?>>(proxyClass));
} else {
cache.remove(key);
}
cache.notifyAll();
}
}
return proxyClass;
}