¿Es posible interceptar el acceso de campo (y método) de objetos Java en el código JavaScript ejecutado? Al igual que el delegado en JSCocoa que permite gestionar el acceso a propiedades y métodos.Interceptar el acceso de campo de objetos Java en Rhino
6
A
Respuesta
5
Puede usar Context.setWrapFactory para especificar cómo ajustar objetos de Java. Aquí muestra envoltorios que imprime el acceso de campo y la llamada al método:
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);
}
}
y esto es una código de prueba:
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);
}
}
0
Como una alternativa a lo que hog1e3 sugirió, también es posible implementar la interfaz Scriptable para interceptar llamadas a métodos/campos de una clase.
Cuestiones relacionadas
- 1. Cómo interceptar la creación de objetos en Java
- 2. Java reflexión - Acceso campo de protección
- 3. Rhino y acceso concurrente a javax.script.ScriptEngine
- 4. sincronizar el acceso a un campo estático
- 5. edificio depurador de java script para Rhino
- 6. La exposición de una función de Java a Rhino
- 7. caso el acceso a objetos en el controlador de eventos
- 8. Objetos inmutables en Java y acceso a datos
- 9. Interpretación de JavaScript en Java con Rhino: pausar/reanudar scripts
- 10. ¿Cómo obtener el campo de acceso en Delphi usando RTTI?
- 11. forma del acceso Selección múltiple de campo en el frasco
- 12. C# acceso protegido campo
- 13. Acceso global en Java
- 14. por nombre de campo en Java
- 15. Interceptar el botón Atrás
- 16. ¿Cuál es la diferencia entre la versión incorporada de Java 6 de Rhino y el paquete Rhino directo de Mozilla?
- 17. Resolviendo módulos usando require.js y Java/Rhino
- 18. Soporte de Rhino y DOM
- 19. Acceso al campo de identidad de incremento automático después de insertar SQL en Java
- 20. Cómo sincronizar el acceso a muchos objetos
- 21. Función de impresión de Rhino
- 22. Permitir el acceso a los objetos contenedor en C++
- 23. JSON - Campo de acceso llamado '*' asterisco
- 24. acceso en campo de .Net C# cuando el nombre del campo es una palabra clave reservada
- 25. valor de Acceso desde el conjunto de objetos
- 26. R: valores del campo de acceso
- 27. ¿Hay un lenguaje con niveles de acceso basados en objetos?
- 28. Acceso al campo de la clase externa
- 29. Cómo interceptar el acceso a un archivo en un programa .NET
- 30. Acceso al campo de respaldo en una propiedad de automóvil
Muchas gracias, esto es justo lo que estaba buscando. Tengo curiosidad, ¿dónde encontraste información sobre el tema? –