Truy cập trường chặn đối tượng java trong Rhino

Question

Có thể chặn truy cập trường (và phương pháp) của các đối tượng Java trong mã JavaScript được thực thi không? Cũng giống như các đại biểu trong JSCocoa cho phép để xử lý tài sản và phương pháp truy cập.

Answer 1

Bạn có thể sử dụng Context.setWrapFactory để chỉ định cách bọc Java Objects. đây cho thấy giấy gói mà in truy cập hiện trường và gọi phương thức:

InterceptWrapFactory.java

import org.mozilla.javascript.Context; 
import org.mozilla.javascript.Scriptable; 
import org.mozilla.javascript.WrapFactory; 
public class InterceptWrapFactory extends WrapFactory{ 
    @Override 
    public Scriptable wrapAsJavaObject(Context cx, Scriptable scope, 
      Object javaObject, Class<?> staticType) { 
     return new InterceptNativeObject(scope, javaObject, staticType); 
    } 
} 

InterceptNativeObject.java

import org.mozilla.javascript.NativeJavaMethod; 
import org.mozilla.javascript.NativeJavaObject; 
import org.mozilla.javascript.Scriptable; 
public class InterceptNativeObject extends NativeJavaObject { 
    @Override 
    public Object get(String name, Scriptable start) { 
     Object res = super.get(name, start); 
     System.out.println("Field get name="+name+" result="+res); 
     if (res instanceof NativeJavaMethod) { 
      NativeJavaMethod method = (NativeJavaMethod) res; 
      return new JavaMethodWrapper(method); 
     } 
     return res; 
    } 
    public InterceptNativeObject(Scriptable scope, Object javaObject, 
      Class<?> staticType) { 
     super(scope, javaObject, staticType); 
    } 
} 

JavaMethodWrapper.java

import org.mozilla.javascript.Context; 
import org.mozilla.javascript.Function; 
import org.mozilla.javascript.NativeJavaMethod; 
import org.mozilla.javascript.Scriptable; 

public class JavaMethodWrapper implements Function { 
    NativeJavaMethod method; 
    public JavaMethodWrapper(NativeJavaMethod method) { 
     this.method = method; 
    } 
    public boolean hasInstance(Scriptable instance) { 
     return method.hasInstance(instance); 
    } 
    public Object call(Context cx, Scriptable scope, Scriptable thisObj, 
      Object[] args) { 
     System.out.println("Call method: "+method); 
     return method.call(cx, scope, thisObj, args); 
    } 
    public boolean has(int index, Scriptable start) { 
     return method.has(index, start); 
    } 
    public Scriptable construct(Context cx, Scriptable scope, Object[] args) { 
     return method.construct(cx, scope, args); 
    } 
    public void put(int index, Scriptable start, Object value) { 
     method.put(index, start, value); 
    } 
    public void delete(int index) { 
     method.delete(index); 
    } 
    public Scriptable createObject(Context cx, Scriptable scope) { 
     return method.createObject(cx, scope); 
    } 
    public boolean has(String name, Scriptable start) { 
     return method.has(name, start); 
    } 
    public void defineConst(String name, Scriptable start) { 
     method.defineConst(name, start); 
    } 
    public void put(String name, Scriptable start, Object value) { 
     method.put(name, start, value); 
    } 
    public void delete(String name) { 
     method.delete(name); 
    } 
    public Scriptable getPrototype() { 
     return method.getPrototype(); 
    } 
    public void setPrototype(Scriptable m) { 
     method.setPrototype(m); 
    } 
    public Scriptable getParentScope() { 
     return method.getParentScope(); 
    } 
    public void setParentScope(Scriptable m) { 
     method.setParentScope(m); 
    } 
    public Object[] getIds() { 
     return method.getIds(); 
    } 
    public Object get(int index, Scriptable start) { 
     return method.get(index, start); 
    } 
    public Object get(String name, Scriptable start) { 
     return method.get(name, start); 
    } 
    public String getClassName() { 
     return method.getClassName(); 
    } 
    public Object getDefaultValue(Class<?> typeHint) { 
     return method.getDefaultValue(typeHint); 
    } 
} 

Và đây là một mã kiểm tra:

import java.util.Vector; 

import org.mozilla.javascript.Context; 
import org.mozilla.javascript.Scriptable; 
import org.mozilla.javascript.ScriptableObject; 


public class InterceptTest { 
    public static void main(String[] args) { 
     Context cx=Context.enter(); 
     cx.setWrapFactory(new InterceptWrapFactory()); 
     Scriptable root=cx.initStandardObjects(); 
     ScriptableObject.putProperty(root,"v", new Vector<String>()); 
     cx.evaluateString(root, "v.add('foo'); v.get(0)", "src", 1, null); 
    } 
} 

Answer 2

Thay thế cho những gì hog1e3 đề xuất, bạn cũng có thể triển khai giao diện Scriptable để chặn cuộc gọi đến các phương thức/trường của lớp.