/**
* Copyright (C) 2012 FuseSource, Inc.
* http://fusesource.com
*
* 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.fusesource.hawtdispatch;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.fusesource.hawtdispatch.DispatchQueue;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import static org.objectweb.asm.Type.*;
import static org.objectweb.asm.ClassWriter.*;
/**
* <p>
* This class creates proxy objects that allow you to easily service all
* method calls to an interface via a {@link DispatchQueue}.
* </p><p>
* The general idea is that proxy asynchronously invoke the delegate using
* the dispatch queue. The proxy implementation is generated using ASM
* using the following code generation pattern:
* </p>
* <pre>
* class <<interface-class>>$__ACTOR_PROXY__ implements <<interface-class>> {
*
* private final <<interface-class>> target;
* private final DispatchQueue queue;
*
* public <<interface-class>>$__ACTOR_PROXY__(<<interface-class>> target, DispatchQueue queue) {
* this.target = target;
* this.queue = queue;
* }
*
* <<for each method in interface-class>>
*
* <<method-signature>> {
* queue.execute( new Runnable() {
* public void run() {
* this.target.<<method-call>>;
* }
* } );
* }
* <<for each end>>
* }
* </pre>
*
*
* @author <a href="http://hiramchirino.com">Hiram Chirino</a>
*/
public class DispatchQueueProxy {
/**
* Create an asynchronous dispatch proxy to the target object via the dispatch queue. The
* class loader of the generated proxy will be the same as the class loader of the target
* object.
*
* @param interfaceClass the interface that will be implemented by the proxy
* @param target the delegate object the proxy will asynchronously invoke
* @param queue the dispatch queue that the asynchronous runnables will execute on
* @param <T> the type of the interface class
* @return the new asynchronous dispatch proxy
* @throws IllegalArgumentException
*/
public static <T> T create(Class<T> interfaceClass, T target, DispatchQueue queue) throws IllegalArgumentException {
return create(target.getClass().getClassLoader(), interfaceClass, target, queue);
}
/**
* Create an asynchronous dispatch proxy to the target object via the dispatch queue.
*
* @param classLoader the classloader which the proxy class should use
* @param interfaceClass the interface that will be implemented by the proxy
* @param target the delegate object the proxy will asynchronously invoke
* @param queue the dispatch queue that the asyncronous runnables will execute on
* @param <T> the type of the interface asynchronous
* @return the new asynchronous dispatch proxy
* @throws IllegalArgumentException
*/
synchronized public static <T> T create(ClassLoader classLoader, Class<T> interfaceClass, T target, DispatchQueue queue) throws IllegalArgumentException {
Class<T> proxyClass = getProxyClass(classLoader, interfaceClass);
Constructor<?> constructor = proxyClass.getConstructors()[0];
Object rc;
try {
rc = constructor.newInstance(new Object[]{target, queue});
} catch (Throwable e) {
throw new RuntimeException("Could not create an instance of the proxy due to: "+e.getMessage(), e);
}
return proxyClass.cast(rc);
}
@SuppressWarnings("unchecked")
private static <T> Class<T> getProxyClass(ClassLoader loader, Class<T> interfaceClass) throws IllegalArgumentException {
String proxyName = proxyName(interfaceClass);
try {
return (Class<T>) loader.loadClass(proxyName);
} catch (ClassNotFoundException e) {
Generator generator = new Generator(loader, interfaceClass);
return generator.generate();
}
}
static private String proxyName(Class<?> clazz) {
return clazz.getName()+"$__ACTOR_PROXY__";
}
private static final class Generator<T> implements Opcodes {
private static final String RUNNABLE = "java/lang/Runnable";
private static final String OBJECT_CLASS = "java/lang/Object";
private static final String DISPATCH_QUEUE = DispatchQueue.class.getName().replace('.','/');
private final ClassLoader loader;
private Method defineClassMethod;
private final Class<T> interfaceClass;
private String proxyName;
private String interfaceName;
private Generator(ClassLoader loader, Class<T> interfaceClass) throws RuntimeException {
this.loader = loader;
this.interfaceClass = interfaceClass;
this.proxyName = proxyName(interfaceClass).replace('.', '/');
this.interfaceName = interfaceClass.getName().replace('.','/');
try {
defineClassMethod = java.lang.ClassLoader.class.getDeclaredMethod("defineClass", new Class[] { String.class, byte[].class, int.class, int.class });
defineClassMethod.setAccessible(true);
} catch (Throwable e) {
throw new RuntimeException("Could not access the 'java.lang.ClassLoader.defineClass' method due to: "+e.getMessage(), e);
}
}
private Class<T> generate() throws IllegalArgumentException {
// Define all the runnable classes used for each method.
Method[] methods = interfaceClass.getMethods();
for (int index = 0; index < methods.length; index++) {
String name = runnable(index, methods[index]).replace('/', '.');
byte[] clazzBytes = dumpRunnable(index, methods[index]);
defineClass(name, clazzBytes);
}
String name = proxyName.replace('/', '.');
byte[] clazzBytes = dumpProxy(methods);
return defineClass(name, clazzBytes);
}
@SuppressWarnings("unchecked")
private Class<T> defineClass(String name, byte[] classBytes) throws RuntimeException {
try {
return (Class<T>) defineClassMethod.invoke(loader, new Object[] {name, classBytes, 0, classBytes.length});
} catch (IllegalAccessException e) {
throw new RuntimeException("Could not define the generated class due to: "+e.getMessage(), e);
} catch (InvocationTargetException e) {
throw new RuntimeException("Could not define the generated class due to: "+e.getMessage(), e);
}
}
public byte[] dumpProxy(Method[] methods) {
ClassWriter cw = new ClassWriter(COMPUTE_FRAMES);
FieldVisitor fv;
MethodVisitor mv;
Label start, end;
// example:
cw.visit(V1_4, ACC_PUBLIC + ACC_SUPER, proxyName, null, OBJECT_CLASS, new String[] { interfaceName });
{
// example:
fv = cw.visitField(ACC_PRIVATE + ACC_FINAL, "queue", sig(DISPATCH_QUEUE), null, null);
fv.visitEnd();
// example:
fv = cw.visitField(ACC_PRIVATE + ACC_FINAL, "target", sig(interfaceName), null, null);
fv.visitEnd();
// example: public PizzaServiceCustomProxy(IPizzaService target, DispatchQueue queue)
mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(" + sig(interfaceName) + sig(DISPATCH_QUEUE) + ")V", null, null);
{
mv.visitCode();
// example: super();
start = new Label();
mv.visitLabel(start);
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, OBJECT_CLASS, "<init>", "()V");
// example: queue=queue;
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, 2);
mv.visitFieldInsn(PUTFIELD, proxyName, "queue", sig(DISPATCH_QUEUE));
// example: this.target=target;
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, 1);
mv.visitFieldInsn(PUTFIELD, proxyName, "target", sig(interfaceName));
// example: return;
mv.visitInsn(RETURN);
end = new Label();
mv.visitLabel(end);
mv.visitLocalVariable("this", sig(proxyName), null, start, end, 0);
mv.visitLocalVariable("target", sig(interfaceName), null, start, end, 1);
mv.visitLocalVariable("queue", sig(DISPATCH_QUEUE), null, start, end, 2);
mv.visitMaxs(2, 3);
}
mv.visitEnd();
for (int index = 0; index < methods.length; index++) {
Method method = methods[index];
Class<?>[] params = method.getParameterTypes();
Type[] types = Type.getArgumentTypes(method);
String methodSig = Type.getMethodDescriptor(method);
// example: public void order(final long count)
mv = cw.visitMethod(ACC_PUBLIC, method.getName(), methodSig, null, null);
{
mv.visitCode();
// example: queue.execute(new OrderRunnable(target, count));
start = new Label();
mv.visitLabel(start);
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, proxyName, "queue", sig(DISPATCH_QUEUE));
mv.visitTypeInsn(NEW, runnable(index, methods[index]));
mv.visitInsn(DUP);
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, proxyName, "target", sig(interfaceName));
for (int i = 0; i < params.length; i++) {
mv.visitVarInsn(types[i].getOpcode(ILOAD), 1+i);
}
mv.visitMethodInsn(INVOKESPECIAL, runnable(index, methods[index]), "<init>", "(" + sig(interfaceName) + sig(params) +")V");
mv.visitMethodInsn(INVOKEINTERFACE, DISPATCH_QUEUE, "execute", "(" + sig(RUNNABLE) + ")V");
Type returnType = Type.getType(method.getReturnType());
Integer returnValue = defaultConstant(returnType);
if( returnValue!=null ) {
mv.visitInsn(returnValue);
}
mv.visitInsn(returnType.getOpcode(IRETURN));
end = new Label();
mv.visitLabel(end);
mv.visitLocalVariable("this", sig(proxyName), null, start, end, 0);
for (int i = 0; i < params.length; i++) {
mv.visitLocalVariable("param"+i, sig(params[i]), null, start, end, 1+i);
}
mv.visitMaxs(0, 0);
}
mv.visitEnd();
}
}
cw.visitEnd();
return cw.toByteArray();
}
private Integer defaultConstant(Type returnType) {
Integer value=null;
switch(returnType.getSort()) {
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
value = ICONST_0;
break;
case Type.LONG:
value = LCONST_0;
break;
case Type.FLOAT:
value = FCONST_0;
break;
case Type.DOUBLE:
value = DCONST_0;
break;
case ARRAY:
case OBJECT:
value = ACONST_NULL;
}
return value;
}
public byte[] dumpRunnable(int index, Method method) {
ClassWriter cw = new ClassWriter(COMPUTE_FRAMES);
FieldVisitor fv;
MethodVisitor mv;
Label start, end;
// example: final class OrderRunnable implements Runnable
String runnableClassName = runnable(index, method);
cw.visit(V1_4, ACC_FINAL + ACC_SUPER, runnableClassName, null, OBJECT_CLASS, new String[] { RUNNABLE });
{
// example: private final IPizzaService target;
fv = cw.visitField(ACC_PRIVATE + ACC_FINAL, "target", sig(interfaceName), null, null);
fv.visitEnd();
// TODO.. add field for each method parameter
// example: private final long count;
Class<?>[] params = method.getParameterTypes();
Type[] types = Type.getArgumentTypes(method);
for (int i = 0; i < params.length; i++) {
fv = cw.visitField(ACC_PRIVATE + ACC_FINAL, "param"+i, sig(params[i]), null, null);
fv.visitEnd();
}
// example: public OrderRunnable(IPizzaService target, long count)
mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(" + sig(interfaceName)+sig(params)+")V", null, null);
{
mv.visitCode();
// example: super();
start = new Label();
mv.visitLabel(start);
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, OBJECT_CLASS, "<init>", "()V");
// example: this.target = target;
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, 1);
mv.visitFieldInsn(PUTFIELD, runnableClassName, "target", sig(interfaceName));
// example: this.count = count;
for (int i = 0; i < params.length; i++) {
// TODO: figure out how to do the right loads. it varies with the type.
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(types[i].getOpcode(ILOAD), 2+i);
mv.visitFieldInsn(PUTFIELD, runnableClassName, "param"+i, sig(params[i]));
}
// example: return;
mv.visitInsn(RETURN);
end = new Label();
mv.visitLabel(end);
mv.visitLocalVariable("this", sig(runnableClassName), null, start, end, 0);
mv.visitLocalVariable("target", sig(interfaceName), null, start, end, 1);
for (int i = 0; i < params.length; i++) {
mv.visitLocalVariable("param"+i, sig(params[i]), null, start, end, 2+i);
}
mv.visitMaxs(0, 0);
}
mv.visitEnd();
// example: public void run()
mv = cw.visitMethod(ACC_PUBLIC, "run", "()V", null, null);
{
mv.visitCode();
// example: target.order(count);
start = new Label();
mv.visitLabel(start);
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, runnableClassName, "target", sig(interfaceName));
for (int i = 0; i < params.length; i++) {
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, runnableClassName, "param"+i, sig(params[i]));
}
String methodSig = Type.getMethodDescriptor(method);
mv.visitMethodInsn(INVOKEINTERFACE, interfaceName, method.getName(), methodSig);
Type returnType = Type.getType(method.getReturnType());
if( returnType != VOID_TYPE ) {
mv.visitInsn(POP);
}
// example: return;
mv.visitInsn(RETURN);
end = new Label();
mv.visitLabel(end);
mv.visitLocalVariable("this", sig(runnableClassName), null, start, end, 0);
mv.visitMaxs(0, 0);
}
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
private String sig(Class<?>[] params) {
StringBuilder methodSig = new StringBuilder();
for (int i = 0; i < params.length; i++) {
methodSig.append(sig(params[i]));
}
return methodSig.toString();
}
private String sig(Class<?> clazz) {
return Type.getDescriptor(clazz);
}
private String runnable(int index, Method method) {
return proxyName+"$"+index+"$"+method.getName();
}
private String sig(String name) {
return "L"+name+";";
}
}
}