Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ***** BEGIN LICENSE BLOCK *****
   * Version: CPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Common Public
   * License Version 1.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.eclipse.org/legal/cpl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2006 Kresten Krab Thorup <krab@gnu.org>
  * Copyright (C) 2007 William N Dortch <bill.dortch@gmail.com>
  * 
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the CPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the CPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 
 package org.jruby.javasupport.proxy;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import org.jruby.Ruby;
Generalized proxy for classes and interfaces. API looks a lot like java.lang.reflect.Proxy, except that you can specify a super class in addition to a set of interfaces. The main implication for users of this class is to handle the case where a proxy method overrides an existing method, because in this case the invocation handler should "default" to calling the super implementation {JavaProxyMethod.invokeSuper}.

Author(s):
krab@trifork.com
See also:
java.lang.reflect.Proxy
 
 public class JavaProxyClass extends JavaProxyReflectionObject {
     static ThreadLocal<RubyruntimeTLS = new ThreadLocal<Ruby>();
     private final Class proxyClass;
     private final ArrayList<JavaProxyMethodmethods = new ArrayList<JavaProxyMethod>();
     private final HashMap<StringList<JavaProxyMethod>> methodMap = new HashMap<StringList<JavaProxyMethod>>();
     private final RubyArray constructors;
 
     /* package scope */
     JavaProxyClass(Class proxyClass) {
         super(getThreadLocalRuntime(), 
                 (RubyClassgetThreadLocalRuntime().getModule("Java").getClass("JavaProxyClass"));
         
         this. = proxyClass;
         this. = buildRubyArray(getConstructors());
     }
 
     public boolean equals(Object other) {
         return other instanceof JavaProxyClass &&
            this. == ((JavaProxyClass)other).;
    }
    
    public int hashCode() {
        return .hashCode();
    }
    public Object getValue() {
        return this;
    }
    private static Ruby getThreadLocalRuntime() {
        return .get();
    }
    public static JavaProxyClass getProxyClass(Ruby runtimeClass superClass,
            Class[] interfacesSet namesthrows InvocationTargetException {
        Ruby save = .get();
        .set(runtime);
        try {
            ClassLoader loader = runtime.getJRubyClassLoader();
            
            return runtime.getJavaProxyClassFactory().newProxyClass(runtimeloadernullsuperClassinterfacesnames);
        } finally {
            .set(save);
        }
    }
    public static JavaProxyClass getProxyClass(Ruby runtimeClass superClass,
            Class[] interfacesthrows InvocationTargetException {
        return getProxyClass(runtime,superClass,interfaces,null);
    }
    
    public static Object newProxyInstance(Ruby runtimeClass superClassClass[] interfaces
            Class[] constructorParametersObject[] constructorArgs
            JavaProxyInvocationHandler handlerthrows IllegalArgumentException
            SecurityExceptionNoSuchMethodException {
        JavaProxyClass jpc = getProxyClass(runtimesuperClassinterfaces);
        JavaProxyConstructor cons = jpc.getConstructor(constructorParameters == null ? 
                new Class[0] : constructorParameters);
        
        return cons.newInstance(constructorArgshandler);
    }
    public Class getSuperclass() {
        return .getSuperclass();
    }
    public Class[] getInterfaces() {
        Class[] ifaces = .getInterfaces();
        Class[] result = new Class[ifaces.length - 1];
        int pos = 0;
        for (int i = 0; i < ifaces.lengthi++) {
            if (ifaces[i] != InternalJavaProxy.class) {
                result[pos++] = ifaces[i];
            }
        }
        return result;
    }
        Constructor[] cons = .getConstructors();
        JavaProxyConstructor[] result = new JavaProxyConstructor[cons.length];
        for (int i = 0; i < cons.lengthi++) {
            result[i] = new JavaProxyConstructor(getRuntime(), thiscons[i]);
        }
        return result;
    }
    public JavaProxyConstructor getConstructor(Class[] args)
            throws SecurityExceptionNoSuchMethodException {
        Class[] realArgs = new Class[args.length + 1];
        System.arraycopy(args, 0, realArgs, 0, args.length);
        realArgs[args.length] = JavaProxyInvocationHandler.class;
        Constructor constructor = .getConstructor(realArgs);
        return new JavaProxyConstructor(getRuntime(), thisconstructor);
    }
    public JavaProxyMethod[] getMethods() {
        return .toArray(new JavaProxyMethod[.size()]);
    }
    public JavaProxyMethod getMethod(String nameClass[] parameterTypes) {
        List<JavaProxyMethodmethods = .get(name);
        if (methods != null) {
            for (int i = methods.size(); --i >= 0; ) {
                ProxyMethodImpl jpm = (ProxyMethodImplmethods.get(i);
                if (jpm.matches(nameparameterTypes)) return jpm;
            }
        }
        return null;
    }

    
return the class of instances of this proxy class
    Class getProxyClass() {
        return ;
    }
    
    @Override
    public Class getJavaClass() {
        return ;
    }
    @JRubyClass(name="JavaProxy::JavaProxyMethod")
    public static class ProxyMethodImpl extends JavaProxyReflectionObject
            implements JavaProxyMethod {
        private final Method m;
        private Object state;
        private final Method sm;
        private final Class[] parameterTypes;
        private final JavaProxyClass clazz;
        public ProxyMethodImpl(Ruby runtimeJavaProxyClass clazzMethod m,
                Method sm) {
            super(runtimeruntime.getJavaSupport().getJavaModule()
                    .getClass("JavaProxyMethod"));
            this. = m;
            this. = m.getParameterTypes();
            this. = sm;
            this. = clazz;
        }
        public boolean equals(Object other) {
            return other instanceof ProxyMethodImpl &&
                this. == ((ProxyMethodImpl)other).;
        }
        
        public int hashCode() {
            return .hashCode();
        }
        public Method getMethod() {
            return ;
        }
        public Method getSuperMethod() {
            return ;
        }
        public int getModifiers() {
            return .getModifiers();
        }
        public String getName() {
            return .getName();
        }
        public Class<?>[] getExceptionTypes() {
            return .getExceptionTypes();
        }
        public Class<?>[] getParameterTypes() {
            return ;
        }
        
        public boolean isVarArgs() {
            return .isVarArgs();
        }
        public Object getState() {
            return ;
        }
        public boolean hasSuperImplementation() {
            return  != null;
        }
        public Object invoke(Object proxyObject[] argsthrows IllegalArgumentException
            
            if (!hasSuperImplementation()) throw new NoSuchMethodException();
            return .invoke(proxyargs);
        }
        public void setState(Object state) {
            this. = state;
        }
        public String toString() {
            return .toString();
        }
        public Object defaultResult() {
            Class rt = .getReturnType();
            
            if (rt == .return null;
            if (rt == .return .;
            if (rt == .return Byte.valueOf((byte) 0);
            if (rt == .return Short.valueOf((short) 0);
            if (rt == .return Integer.valueOf(0);
            if (rt == .return Long.valueOf(0L);
            if (rt == .return new Float(0.0f);
            if (rt == .return new Double(0.0);
            return null;
        }
        public boolean matches(String nameClass[] parameterTypes) {
            return .getName().equals(name) && Arrays.equals(this.parameterTypes);
        }
        public Class getReturnType() {
            return .getReturnType();
        }
        
        public static RubyClass createJavaProxyMethodClass(Ruby runtimeRubyModule javaProxyModule) {
            RubyClass result = javaProxyModule.defineClassUnder("JavaProxyMethod"
                    runtime.getObject(), .);
            JavaProxyReflectionObject.registerRubyMethods(runtimeresult);
            result.defineAnnotatedMethods(ProxyMethodImpl.class);
            return result;
        }
        public RubyObject name() {
            return getRuntime().newString(getName());
        }
        @JRubyMethod(name = "declaring_class")
        public JavaProxyClass getDeclaringClass() {
            return ;
        }
        @JRubyMethod
        public RubyArray argument_types() {
            return buildRubyArray(getParameterTypes());
        }
        @JRubyMethod(name = "super?")
        public IRubyObject super_p() {
            return hasSuperImplementation() ? getRuntime().getTrue() : getRuntime().getFalse();
        }
        @JRubyMethod
        public RubyFixnum arity() {
            return getRuntime().newFixnum(getArity());
        }
        protected String nameOnInspection() {
            return getDeclaringClass().nameOnInspection() + "/" + getName();
        }
        @JRubyMethod
        public IRubyObject inspect() {
            StringBuilder result = new StringBuilder();
            result.append(nameOnInspection());
            result.append("(");
            Class[] parameterTypes = getParameterTypes();
            for (int i = 0; i < parameterTypes.lengthi++) {
                result.append(parameterTypes[i].getName());
                if (i < parameterTypes.length - 1) {
                    result.append(',');
                }
            }
            result.append(")>");
            return getRuntime().newString(result.toString());
        }
        @JRubyMethod(name = "invoke", rest = true)
        public IRubyObject do_invoke(IRubyObject[] nargs) {
            if (nargs.length != 1 + getArity()) {
                throw getRuntime().newArgumentError(nargs.length, 1 + getArity());
            }
            IRubyObject invokee = nargs[0];
            if (!(invokee instanceof JavaObject)) {
                throw getRuntime().newTypeError("invokee not a java object");
            }
            Object receiver_value = ((JavaObjectinvokee).getValue();
            Object[] arguments = new Object[nargs.length - 1];
            System.arraycopy(nargs, 1, arguments, 0, arguments.length);
            Class[] parameterTypes = getParameterTypes();
            for (int i = 0; i < arguments.lengthi++) {
                arguments[i] = 
                    ((IRubyObjectarguments[i]).toJava(parameterTypes[i]);
            }
            try {
                Object javaResult = .invoke(receiver_valuearguments);
                return JavaUtil.convertJavaToRuby(getRuntime(), javaResultgetReturnType());
            } catch (IllegalArgumentException e) {
                throw getRuntime().newTypeError("expected " + argument_types().inspect());
            } catch (IllegalAccessException iae) {
                throw getRuntime().newTypeError("illegal access on '" + .getName() + "': " + 
                        iae.getMessage());
            } catch (InvocationTargetException ite) {
                if (getRuntime().getDebug().isTrue()) ite.getTargetException().printStackTrace();
                getRuntime().getJavaSupport().handleNativeException(ite.getTargetException(), );
                // This point is only reached if there was an exception handler
                // installed.
                return getRuntime().getNil();
            }
        }
        private int getArity() {
            return getParameterTypes().length;
        }
    }
    JavaProxyMethod initMethod(String nameString descboolean hasSuper) {
        Class proxy = ;
        try {
            Class[] parms = parse(proxy.getClassLoader(), desc);
            Method m = proxy.getDeclaredMethod(nameparms);
            Method sm = null;
            if (hasSuper) {
                sm = proxy.getDeclaredMethod("__super$" + nameparms);
            }
            JavaProxyMethod jpm = new ProxyMethodImpl(getRuntime(), thismsm);
            .add(jpm);
            List<JavaProxyMethodmethodsWithName = .get(name);
            if (methodsWithName == null) {
                methodsWithName = new ArrayList<JavaProxyMethod>(2);
                .put(name,methodsWithName);
            }
            methodsWithName.add(jpm);
            
            return jpm;
        } catch (ClassNotFoundException e) {
            throw new InternalError(e.getMessage());
        } catch (SecurityException e) {
            throw new InternalError(e.getMessage());
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.getMessage());
        }
    }
    private static Class[] parse(final ClassLoader loaderString desc)
            throws ClassNotFoundException {
        List<Classal = new ArrayList<Class>();
        int idx = 1;
        while (desc.charAt(idx) != ')') {
            int arr = 0;
            while (desc.charAt(idx) == '[') {
                idx += 1;
                arr += 1;
            }
            Class type;
            switch (desc.charAt(idx)) {
            case 'L':
                int semi = desc.indexOf(';'idx);
                final String name = desc.substring(idx + 1, semi);
                idx = semi;
                try {
                    type = AccessController.doPrivileged(new PrivilegedExceptionAction<Class>() {
                                public Class run() throws ClassNotFoundException {
                                    return Class.forName(name.replace('/''.'), falseloader);
                                }
                            });
                } catch (PrivilegedActionException e) {
                    throw (ClassNotFoundExceptione.getException();
                }
                break;
            case 'B'type = .break;
            case 'C'type = .break;
            case 'Z'type = .break;
            case 'S'type = .break;
            case 'I'type = .break;
            case 'J'type = .break;
            case 'F'type = .break;
            case 'D'type = .break;
            default:
                throw new InternalError("cannot parse " + desc + "[" + idx + "]");
            }
            idx += 1;
            if (arr != 0) {
                type = Array.newInstance(typenew int[arr]).getClass();
            }
            al.add(type);
        }
        return (Class[]) al.toArray(new Class[al.size()]);
    }
    //
    // Ruby-level methods
    //
        
    public static RubyClass createJavaProxyClassClass(Ruby runtimeRubyModule javaModule) {
        RubyClass result = javaModule.defineClassUnder("JavaProxyClass",
                runtime.getObject(),.);
        JavaProxyReflectionObject.registerRubyMethods(runtimeresult);
        result.defineAnnotatedMethods(JavaProxyClass.class);
        return result;
    }
    @JRubyMethod(meta = true)
    public static RubyObject get(IRubyObject recvIRubyObject obj) {
        if (!(obj instanceof JavaClass)) {
            throw recv.getRuntime().newTypeError(objrecv.getRuntime().getJavaSupport().getJavaClassClass());
        }
        JavaClass type = (JavaClass)obj;
        
        try {
            return getProxyClass(recv.getRuntime(), (Classtype.getValue(), new Class[0]);
        } catch (Error e) {
            RaiseException ex = recv.getRuntime().newArgumentError("unable to create proxy class for " + type.getValue());
            ex.initCause(e);
            throw ex;
        } catch (InvocationTargetException e) {
            RaiseException ex = recv.getRuntime().newArgumentError("unable to create proxy class for " + type.getValue());
            ex.initCause(e);
            throw ex;
        }
    }
    
    private static final HashSet<StringEXCLUDE_MODULES = new HashSet<String>();
    static {
        .add("Kernel");
        .add("Java");
        .add("JavaProxyMethods");
        .add("Enumerable");
    }
    private static final HashSet<StringEXCLUDE_METHODS = new HashSet<String>();
    static {
        .add("class");
        .add("finalize");
        .add("initialize");
        .add("java_class");
        .add("java_object");
        .add("__jcreate!");
        .add("__jsend!");
    }
    @JRubyMethod(meta = true)
    public static RubyObject get_with_class(IRubyObject recvIRubyObject obj) {
        Ruby runtime = recv.getRuntime();
        
        if (!(obj instanceof RubyClass)) {
            throw runtime.newTypeError(objruntime.getClassClass());
        }
        
        RubyClass clazz = (RubyClass)obj;
        
        // Let's only generate methods for those the user may actually 
        // intend to override.  That includes any defined in the current
        // class, and any ancestors that are also JavaProxyClasses (but none
        // from any other ancestor classes). Methods defined in mixins will
        // be considered intentionally overridden, except those from Kernel,
        // Java, and JavaProxyMethods, as well as Enumerable. 
        // TODO: may want to exclude other common mixins?
        JavaClass javaClass = null;
        Set<Stringnames = new HashSet<String>(); // need names ordered for key generation later
        List<Class<?>> interfaceList = new ArrayList<Class<?>>();
        List<IRubyObjectancestors = clazz.getAncestorList();
        boolean skipRemainingClasses = false;
        for (IRubyObject ancestorObjectancestors) {
            RubyModule ancestor = (RubyModuleancestorObject;
            if (ancestor instanceof RubyClass) {
                if (skipRemainingClassescontinue;
                // we only collect methods and interfaces for 
                // user-defined proxy classes.
                if (!ancestor.getInstanceVariables().hasInstanceVariable("@java_proxy_class")) {
                    skipRemainingClasses = true;
                    continue;
                }
                // get JavaClass if this is the new proxy class; verify it
                // matches if this is a superclass proxy.
                IRubyObject var = ancestor.getInstanceVariables().getInstanceVariable("@java_class");
                if (var == null) {
                    throw runtime.newTypeError(
                            "no java_class defined for proxy (or ancestor): " + ancestor);
                } else if (!(var instanceof JavaClass)) {
                    throw runtime.newTypeError(
                            "invalid java_class defined for proxy (or ancestor): " +
                            ancestor + ": " + var);
                }
                if (javaClass == null) {
                    javaClass = (JavaClass)var;
                } else if (javaClass != var) {
                    throw runtime.newTypeError(
                            "java_class defined for " + clazz + " (" + javaClass +
                            ") does not match java_class for ancestor " + ancestor +
                            " (" + var + ")");
                }
                // get any included interfaces
                var = ancestor.getInstanceVariables().getInstanceVariable("@java_interfaces");
                if (var != null && !(var instanceof RubyNil)) {
                    if (!(var instanceof RubyArray)) {
                        throw runtime.newTypeError(
                                "invalid java_interfaces defined for proxy (or ancestor): " +
                                ancestor + ": " + var);
                    }
                    RubyArray ifcArray = (RubyArray)var;
                    int size = ifcArray.size();
                    for (int i = size; --i >= 0; ) {
                        IRubyObject ifc = ifcArray.eltInternal(i);
                        if (!(ifc instanceof JavaClass)) {
                            throw runtime.newTypeError(
                                "invalid java interface defined for proxy (or ancestor): " +
                                ancestor + ": " + ifc);
                        }
                        Class interfaceClass = ((JavaClass)ifc).javaClass();
                        if (!interfaceClass.isInterface()) {
                            throw runtime.newTypeError(
                                    "invalid java interface defined for proxy (or ancestor): " +
                                    ancestor + ": " + ifc + " (not an interface)");
                        }
                        if (!interfaceList.contains(interfaceClass)) {
                            interfaceList.add(interfaceClass);
                        }
                    }
                }
                // set this class's method names in var @__java_ovrd_methods if this
                // is the new class; otherwise, get method names from there if this is
                // a proxy superclass.
                
                // FIXME: shouldn't need @__java_ovrd_methods, just query locally defined methods.
                
                var = ancestor.getInstanceVariables().getInstanceVariable("@__java_ovrd_methods");
                if (var == null) {
                    // lock in the overridden methods for the new class, and any as-yet
                    // uninstantiated ancestor class.
                    Map<StringDynamicMethodmethods;
                    RubyArray methodNames;
                    synchronized(methods = ancestor.getMethods()) {
                        methodNames = RubyArray.newArrayLight(runtime,methods.size());
                        for (String methodNamemethods.keySet()) {
                            if (!.contains(methodName)) {
                                names.add(methodName);
                                methodNames.append(runtime.newString(methodName));
                            }
                        }
                    }
                    ancestor.setInstanceVariable("@__java_ovrd_methods",methodNames);
                } else {
                    if (!(var instanceof RubyArray)) {
                        throw runtime.newTypeError(
                                "invalid @__java_ovrd_methods defined for proxy: " +
                                ancestor + ": " + var);
                    }
                    RubyArray methodNames = (RubyArray)var;
                    int size = methodNames.size();
                    for (int i = size; --i >= 0; ) {
                        IRubyObject methodName = methodNames.eltInternal(i);
                        if (!(methodName instanceof RubyString)) {
                            throw runtime.newTypeError(
                                    "invalid method name defined for proxy (or ancestor): " +
                                    ancestor + ": " + methodName);
                        }
                        names.add(methodName.asJavaString());
                    }
                }
            } else if (!.contains(ancestor.getName())) {
                Map<StringDynamicMethodmethods;
                synchronized(methods = ancestor.getMethods()) {
                    for (String methodNamemethods.keySet()) {
                        if (!.contains(methodName)) {
                            names.add(methodName);
                        }
                    }
                }
            }
        }
        if (javaClass == null) {
            throw runtime.newArgumentError("unable to create proxy class: no java_class defined for " + clazz);
        }
        
        int interfaceCount = interfaceList.size();
        Class<?>[] interfaces = new Class<?>[interfaceCount];
        for (int i = interfaceCount; --i >= 0; ) {
            interfaces[i] = interfaceList.get(i);
        }
       
        try {
            return getProxyClass(recv.getRuntime(), javaClass.javaClass(), interfacesnames);
        } catch (Error e) {
            RaiseException ex = recv.getRuntime().newArgumentError("unable to create proxy class for " + javaClass.getValue() + " : " + e.getMessage());
            //e.printStackTrace();
            ex.initCause(e);
            throw ex;
        } catch (InvocationTargetException e) {
            RaiseException ex = recv.getRuntime().newArgumentError("unable to create proxy class for " + javaClass.getValue() + " : " + e.getMessage());
            //e.printStackTrace();
            ex.initCause(e);
            throw ex;
        }
    }
    public RubyObject superclass() {
        return JavaClass.get(getRuntime(), getSuperclass());
    }
    public RubyArray methods() {
        return buildRubyArray(getMethods());
    }
    public RubyArray interfaces() {
        return buildRubyArray(getInterfaces());
    }
    public RubyArray constructors() {
        return this.;
    }
    public static void createJavaProxyModule(Ruby runtime) {
        // TODO Auto-generated method stub
        RubyModule javaProxyModule = runtime.getJavaSupport().getJavaModule();
        JavaProxyClass.createJavaProxyClassClass(runtimejavaProxyModule);
        ProxyMethodImpl.createJavaProxyMethodClass(runtimejavaProxyModule);
        JavaProxyConstructor.createJavaProxyConstructorClass(runtimejavaProxyModule);
    }
    public String nameOnInspection() {
        return "[Proxy:" + getSuperclass().getName() + "]";
    }