FastReflection.java

/******************************************************************************
 * Inspired by https://github.com/EsotericSoftware/reflectasm
 * the main idea is to take away introspection from ReflectASM
 *
 * You must obtain reflection member (Constructor,Method or Field)
 * yourself then pass it to FastReflection.of() method to obtain
 * code generated access-object...
 *
 * Also (since it operate per-member basis) it takes away ugly switches
 * into generated bytecode, supports parametrized constructors and
 * static fields/members...
 */
package com.esotericsoftware.reflectasm.dimzon;

import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Type;

import java.io.File;
import java.lang.reflect.Member;
import java.lang.reflect.Modifier;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Objects;

import static org.objectweb.asm.Opcodes.*;

@SuppressWarnings("UnusedDeclaration")
public final class FastReflection {
    public static void main(String[] args) throws Throwable {
        Class ps = System.out.getClass();
        java.lang.reflect.Method psMethod = ps.getMethod("println", Object.class);
        Method println = of(psMethod);
        println.invoke(System.out, "System.out");
        println.invoke(System.err, "System.err");
        java.lang.reflect.Method nanoTime = System.class.getMethod("nanoTime");
        println.invoke(System.out, of(nanoTime).invokeStatic());
        println.invoke(System.err, of(nanoTime).invokeStatic());

        java.lang.reflect.Constructor<File> fileConstructor = File.class.getConstructor(String.class);
        Object o = of(fileConstructor).newInstance("c:\\bla.txt");
        System.out.println(o);

        java.lang.reflect.Field field = System.class.getField("out");
        Object o1 = of(field).get(null);
        System.out.println(o1);
    }


    private static final Object[] EMPTY_VARARGS = new Object[0];
    private static final ThreadLocal<MessageDigest> md5 = new ThreadLocal<MessageDigest>() {
        @Override
        protected MessageDigest initialValue() {
            try {
                return MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException nsae) {
                throw new RuntimeException(nsae);
            }
        }
    };


    private static String memberAccessClassName(Member member) {
        byte[] md5Bytes = md5.get().digest(member.toString().getBytes(StandardCharsets.UTF_8));
        String sign = member.getDeclaringClass().getName()
                + "__"
                + javax.xml.bind.DatatypeConverter.printHexBinary(md5Bytes);
        if (sign.startsWith("java.")) sign = "reflectasm." + sign;
        return sign;
    }

    public static Constructor of(java.lang.reflect.Constructor ctor) {
        Objects.requireNonNull(ctor);
        Class accessClass;
        String accessClassName = memberAccessClassName(ctor);
        AccessClassLoader_2 loader = AccessClassLoader_2.get(ctor.getDeclaringClass());
        //noinspection SynchronizationOnLocalVariableOrMethodParameter
        synchronized (loader) {
            try {
                accessClass = loader.loadClass(accessClassName);
            } catch (ClassNotFoundException ignored) {
                byte[] byteCode = createAccessor(accessClassName, ctor);
                accessClass = loader.defineClass(accessClassName, byteCode);
            }
        }
        try {
            Constructor m = (Constructor) accessClass.newInstance();
            m._member = ctor;
            return m;
        } catch (Throwable e) {
            throw new RuntimeException("Error constructing constructor access class: " + accessClassName, e);
        }
    }


    public static Method of(java.lang.reflect.Method method) {
        Objects.requireNonNull(method);
        Class accessClass;
        String accessClassName = memberAccessClassName(method);
        AccessClassLoader_2 loader = AccessClassLoader_2.get(method.getDeclaringClass());
        //noinspection SynchronizationOnLocalVariableOrMethodParameter
        synchronized (loader) {
            try {
                accessClass = loader.loadClass(accessClassName);
            } catch (ClassNotFoundException ignored) {
                byte[] byteCode = createAccessor(accessClassName, method);
                accessClass = loader.defineClass(accessClassName, byteCode);
            }
        }
        try {
            Method m = (Method) accessClass.newInstance();
            m._member = method;
            return m;
        } catch (Throwable e) {
            throw new RuntimeException("Error constructing method access class: " + accessClassName, e);
        }
    }

    public static Field of(java.lang.reflect.Field field) {
        Objects.requireNonNull(field);
        Class accessClass;
        String accessClassName = memberAccessClassName(field);
        AccessClassLoader_2 loader = AccessClassLoader_2.get(field.getDeclaringClass());
        //noinspection SynchronizationOnLocalVariableOrMethodParameter
        synchronized (loader) {
            try {
                accessClass = loader.loadClass(accessClassName);
            } catch (ClassNotFoundException ignored) {
                byte[] byteCode = createAccessor(accessClassName, field);
                accessClass = loader.defineClass(accessClassName, byteCode);
            }
        }
        try {
            Field m = (Field) accessClass.newInstance();
            m._member = field;
            return m;
        } catch (Throwable e) {
            throw new RuntimeException("Error constructing field access class: " + accessClassName, e);
        }
    }

    private static byte[] createAccessor(String accessClassName, java.lang.reflect.Constructor<?> member) {
        String className = member.getDeclaringClass().getName();
        String classNameInternal = internalClassName(className);

        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);

        injectConstructor(accessClassName, Constructor.class, cw);
        {
            MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_VARARGS, "newInstance",
                    "([Ljava/lang/Object;)Ljava/lang/Object;", null, null);
            mv.visitCode();
            mv.visitTypeInsn(NEW, classNameInternal);
            mv.visitInsn(DUP);
            StringBuilder buffer = new StringBuilder(128);
            buffer.setLength(0);
            buffer.append('(');
            injectVarArgs(mv, buffer, member.getParameterTypes(), 1);
            buffer.append(")V");
            mv.visitMethodInsn(INVOKESPECIAL, classNameInternal, "<init>", buffer.toString());
            mv.visitInsn(ARETURN);
            mv.visitMaxs(0, 0);
            mv.visitEnd();
        }
        cw.visitEnd();
        return cw.toByteArray();
    }

    private static String internalClassName(String classicClassName) {
        return classicClassName.replace('.', '/');
    }

    private static byte[] createAccessor(String accessClassName, java.lang.reflect.Field member) {
        String className = member.getDeclaringClass().getName();
        String classNameInternal = internalClassName(className);
        boolean isStatic = Modifier.isStatic(member.getModifiers());
        Class<?> memberType = member.getType();
        Type fieldType = Type.getType(memberType);
        int fieldTypeSort = fieldType.getSort();

        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);

        injectConstructor(accessClassName, Field.class, cw);
        MethodVisitor mv;
        {
            mv = cw.visitMethod(ACC_PUBLIC, "get",
                    "(Ljava/lang/Object;)Ljava/lang/Object;", null, null);
            mv.visitCode();
            if (!isStatic) {
                mv.visitVarInsn(ALOAD, 1);
                mv.visitTypeInsn(CHECKCAST, classNameInternal);
            }
            mv.visitFieldInsn(isStatic ? GETSTATIC : GETFIELD, classNameInternal, member.getName(), Type.getDescriptor(memberType));
            injectBoxing(mv, fieldTypeSort);
            mv.visitInsn(ARETURN);
            mv.visitMaxs(0, 0);
            mv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_PUBLIC, "set",
                    "(Ljava/lang/Object;Ljava/lang/Object;)V", null, null);
            mv.visitCode();
            if (!isStatic) {
                mv.visitVarInsn(ALOAD, 1);
                mv.visitTypeInsn(CHECKCAST, classNameInternal);
            }
            mv.visitVarInsn(ALOAD, 2);
            injectUnBoxing(mv, fieldType);
            mv.visitFieldInsn(isStatic ? PUTSTATIC : PUTFIELD, classNameInternal, member.getName(), fieldType.getDescriptor());
            mv.visitInsn(RETURN);
            mv.visitMaxs(0, 0);
            mv.visitEnd();
        }
        switch (fieldTypeSort) {
            case Type.BOOLEAN:
                injectPrimitiveGetterSetter("Boolean", IRETURN, ILOAD,
                        fieldType, fieldTypeSort, cw, member, isStatic, classNameInternal);
                break;
            case Type.BYTE:
                injectPrimitiveGetterSetter("Byte", IRETURN, ILOAD,
                        fieldType, fieldTypeSort, cw, member, isStatic, classNameInternal);
                break;
            case Type.CHAR:
                injectPrimitiveGetterSetter("Char", IRETURN, ILOAD,
                        fieldType, fieldTypeSort, cw, member, isStatic, classNameInternal);
                break;
            case Type.SHORT:
                injectPrimitiveGetterSetter("Short", IRETURN, ILOAD,
                        fieldType, fieldTypeSort, cw, member, isStatic, classNameInternal);
                break;
            case Type.INT:
                injectPrimitiveGetterSetter("Int", IRETURN, ILOAD,
                        fieldType, fieldTypeSort, cw, member, isStatic, classNameInternal);
                break;
            case Type.FLOAT:
                injectPrimitiveGetterSetter("Float", FRETURN, FLOAD,
                        fieldType, fieldTypeSort, cw, member, isStatic, classNameInternal);

                break;
            case Type.LONG:
                injectPrimitiveGetterSetter("Long", LRETURN, LLOAD,
                        fieldType, fieldTypeSort, cw, member, isStatic, classNameInternal);
                break;
            case Type.DOUBLE:
                injectPrimitiveGetterSetter("Double", DRETURN, DLOAD,
                        fieldType, fieldTypeSort, cw, member, isStatic, classNameInternal);
                break;
        }
        cw.visitEnd();
        return cw.toByteArray();
    }

    private static void injectPrimitiveGetterSetter(String name, int returnValueInstruction, int loadValueInstruction,
                                                    Type fieldType, int fieldTypeSort, ClassWriter cw,
                                                    java.lang.reflect.Field field,
                                                    boolean isStatic, String classNameInternal) {
        final String typeNameInternal = fieldType.getDescriptor();
        MethodVisitor mv;
        {
            mv = cw.visitMethod(ACC_PUBLIC, "get" + name, "(Ljava/lang/Object;)" + typeNameInternal, null, null);
            mv.visitCode();
            if (!isStatic) {
                mv.visitVarInsn(ALOAD, 1);
                mv.visitTypeInsn(CHECKCAST, classNameInternal);
            }
            mv.visitFieldInsn(isStatic ? GETSTATIC : GETFIELD, classNameInternal, field.getName(), typeNameInternal);
            mv.visitInsn(returnValueInstruction);
            mv.visitMaxs(0, 0);
            mv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_PUBLIC, "set" + name, "(Ljava/lang/Object;" + typeNameInternal + ")V", null, null);
            mv.visitCode();
            if (!isStatic) {
                mv.visitVarInsn(ALOAD, 1);
                mv.visitTypeInsn(CHECKCAST, classNameInternal);
            }
            mv.visitVarInsn(loadValueInstruction,2);
            mv.visitFieldInsn(isStatic ? PUTSTATIC : PUTFIELD, classNameInternal, field.getName(), typeNameInternal);
            mv.visitInsn(RETURN);
            mv.visitMaxs(0, 0);
            mv.visitEnd();
        }
    }

    private static byte[] createAccessor(String accessClassName, java.lang.reflect.Method member) {
        String className = member.getDeclaringClass().getName();
        String classNameInternal = internalClassName(className);

        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        injectConstructor(accessClassName, Method.class, cw);
        {
            MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_VARARGS, "invoke",
                    "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;", null, null);
            mv.visitCode();
            boolean isStatic = Modifier.isStatic(member.getModifiers());
            if (!isStatic) {
                mv.visitVarInsn(ALOAD, 1);
                mv.visitTypeInsn(CHECKCAST, classNameInternal);
            }

            StringBuilder buffer = new StringBuilder(128);

            buffer.setLength(0);
            buffer.append('(');

            Class[] paramTypes = member.getParameterTypes();
            injectVarArgs(mv, buffer, paramTypes, 2);

            buffer.append(')');
            buffer.append(Type.getDescriptor(member.getReturnType()));
            mv.visitMethodInsn(isStatic ? INVOKESTATIC : INVOKEVIRTUAL, classNameInternal, member.getName(), buffer.toString());

            int retValType = Type.getType(member.getReturnType()).getSort();
            injectBoxing(mv, retValType);

            mv.visitInsn(ARETURN);
            mv.visitMaxs(0, 0);
            mv.visitEnd();
        }
        cw.visitEnd();
        return cw.toByteArray();
    }

    private static void injectBoxing(MethodVisitor mv, int retValType) {
        switch (retValType) {
            case Type.VOID:
                mv.visitInsn(ACONST_NULL);
                break;
            case Type.BOOLEAN:
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;");
                break;
            case Type.BYTE:
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Byte", "valueOf", "(B)Ljava/lang/Byte;");
                break;
            case Type.CHAR:
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Character", "valueOf", "(C)Ljava/lang/Character;");
                break;
            case Type.SHORT:
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Short", "valueOf", "(S)Ljava/lang/Short;");
                break;
            case Type.INT:
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;");
                break;
            case Type.FLOAT:
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Float", "valueOf", "(F)Ljava/lang/Float;");
                break;
            case Type.LONG:
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Long", "valueOf", "(J)Ljava/lang/Long;");
                break;
            case Type.DOUBLE:
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Double", "valueOf", "(D)Ljava/lang/Double;");
                break;
        }
    }

    private static void injectVarArgs(MethodVisitor mv, StringBuilder buffer, Class[] paramTypes, int varArgsPosition) {
        for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
            mv.visitVarInsn(ALOAD, varArgsPosition);
            mv.visitIntInsn(BIPUSH, paramIndex);
            mv.visitInsn(AALOAD);
            Type paramType = Type.getType(paramTypes[paramIndex]);

            injectUnBoxing(mv, paramType);
            buffer.append(paramType.getDescriptor());
        }
    }

    private static void injectUnBoxing(MethodVisitor mv, Type paramType) {
        int paramTypeSort = paramType.getSort();
        switch (paramTypeSort) {
            case Type.BOOLEAN:
                mv.visitTypeInsn(CHECKCAST, "java/lang/Boolean");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z");
                break;
            case Type.BYTE:
                mv.visitTypeInsn(CHECKCAST, "java/lang/Number");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Number", "byteValue", "()B");
                break;
            case Type.CHAR:
                mv.visitTypeInsn(CHECKCAST, "java/lang/Character");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C");
                break;
            case Type.SHORT:
                mv.visitTypeInsn(CHECKCAST, "java/lang/Number");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Number", "shortValue", "()S");
                break;
            case Type.INT:
                mv.visitTypeInsn(CHECKCAST, "java/lang/Number");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Number", "intValue", "()I");
                break;
            case Type.FLOAT:
                mv.visitTypeInsn(CHECKCAST, "java/lang/Number");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Number", "floatValue", "()F");
                break;
            case Type.LONG:
                mv.visitTypeInsn(CHECKCAST, "java/lang/Number");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Number", "longValue", "()J");
                break;
            case Type.DOUBLE:
                mv.visitTypeInsn(CHECKCAST, "java/lang/Number");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Number", "doubleValue", "()D");
                break;
            case Type.ARRAY:
                mv.visitTypeInsn(CHECKCAST, paramType.getDescriptor());
                break;
            case Type.OBJECT:
                mv.visitTypeInsn(CHECKCAST, paramType.getInternalName());
                break;
        }
    }

    private static void injectConstructor(String accessClassName, Class<?> baseClass, ClassWriter cw) {
        String accessClassNameInternal = internalClassName(accessClassName);
        String baseClassNameInternal = internalClassName(baseClass.getName());
        cw.visit(V1_1, ACC_PUBLIC + ACC_SUPER, accessClassNameInternal, null, baseClassNameInternal,
                null);
        {
            MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
            mv.visitCode();
            mv.visitVarInsn(ALOAD, 0);
            mv.visitMethodInsn(INVOKESPECIAL, baseClassNameInternal, "<init>", "()V");
            mv.visitInsn(RETURN);
            mv.visitMaxs(0, 0);
            mv.visitEnd();
        }
    }


    public static abstract class Constructor {
        private java.lang.reflect.Constructor<?> _member;

        public java.lang.reflect.Constructor<?> member() {
            return _member;
        }

        public final Object newInstance() {
            return newInstance(EMPTY_VARARGS);
        }

        public abstract Object newInstance(Object... args);

        @Override
        public String toString() {
            return member().toString();
        }

    }

    public static abstract class Method {
        private java.lang.reflect.Method _member;

        public java.lang.reflect.Method member() {
            return _member;
        }

        public final Object invokeStatic() {
            return invoke(null, EMPTY_VARARGS);
        }

        public final Object invokeStatic(Object... args) {
            return invoke(null, args);
        }

        public final Object invoke(Object instance) {
            return invoke(instance, EMPTY_VARARGS);
        }

        public abstract Object invoke(Object instance, Object... args);

        @Override
        public String toString() {
            return member().toString();
        }

    }

    public static abstract class Field {
        abstract public void set(Object instance, Object value);

        public void setBoolean(Object instance, boolean value) {
            throw new UnsupportedOperationException();
        }

        public void setByte(Object instance, byte value) {
            throw new UnsupportedOperationException();
        }

        public void setShort(Object instance, short value) {
            throw new UnsupportedOperationException();
        }

        public void setInt(Object instance, int value) {
            throw new UnsupportedOperationException();
        }

        public void setLong(Object instance, long value) {
            throw new UnsupportedOperationException();
        }

        public void setDouble(Object instance, double value) {
            throw new UnsupportedOperationException();
        }

        public void setFloat(Object instance, float value) {
            throw new UnsupportedOperationException();
        }

        public void setChar(Object instance, char value) {
            throw new UnsupportedOperationException();
        }

        abstract public Object get(Object instance);

        public char getChar(Object instance) {
            throw new UnsupportedOperationException();
        }

        public boolean getBoolean(Object instance) {
            throw new UnsupportedOperationException();
        }

        public byte getByte(Object instance) {
            throw new UnsupportedOperationException();
        }

        public short getShort(Object instance) {
            throw new UnsupportedOperationException();
        }

        public int getInt(Object instance) {
            throw new UnsupportedOperationException();
        }

        public long getLong(Object instance) {
            throw new UnsupportedOperationException();
        }

        public double getDouble(Object instance) {
            throw new UnsupportedOperationException();
        }

        public float getFloat(Object instance) {
            throw new UnsupportedOperationException();
        }

        private java.lang.reflect.Field _member;

        public java.lang.reflect.Field member() {
            return _member;
        }

        @Override
        public String toString() {
            return member().toString();
        }
    }

    /*************************************************************
     * taken from https://github.com/EsotericSoftware/reflectasm
     */
    @SuppressWarnings("unchecked")
    private static class AccessClassLoader_2 extends ClassLoader {
        static private final ArrayList<AccessClassLoader_2> accessClassLoaders = new ArrayList();

        static AccessClassLoader_2 get(Class type) {
            ClassLoader parent = type.getClassLoader();
            synchronized (accessClassLoaders) {
                //noinspection ForLoopReplaceableByForEach
                for (int i = 0, n = accessClassLoaders.size(); i < n; i++) {
                    AccessClassLoader_2 accessClassLoader = accessClassLoaders.get(i);
                    if (accessClassLoader.getParent() == parent) return accessClassLoader;
                }
                AccessClassLoader_2 accessClassLoader = new AccessClassLoader_2(parent);
                accessClassLoaders.add(accessClassLoader);
                return accessClassLoader;
            }
        }

        private AccessClassLoader_2(ClassLoader parent) {
            super(parent);
        }

        private static final Class[] wellKnownClasses = new Class[]{
                FastReflection.class,
                FastReflection.Constructor.class,
                FastReflection.Method.class,
                FastReflection.Field.class
        };

        protected synchronized java.lang.Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
            // These classes come from the classloader that loaded AccessClassLoader_2.
            for (Class wellKnownClass : wellKnownClasses) {
                if (name.equals(wellKnownClass.getName())) return wellKnownClass;
            }
            // All other classes come from the classloader that loaded the type we are accessing.
            return super.loadClass(name, resolve);
        }

        Class<?> defineClass(String name, byte[] bytes) throws ClassFormatError {
            try {
                // Attempt to load the access class in the same loader, which makes protected and default access members accessible.
                java.lang.reflect.Method method = ClassLoader.class.getDeclaredMethod("defineClass", new Class[]{String.class, byte[].class, int.class,
                        int.class});
                method.setAccessible(true);
                //noinspection RedundantArrayCreation,UnnecessaryBoxing
                return (Class) method.invoke(getParent(), new Object[]{name, bytes, Integer.valueOf(0), Integer.valueOf(bytes.length)});
            } catch (Exception ignored) {
            }
            return defineClass(name, bytes, 0, bytes.length);
        }
    }

}