caucho
Resin 1.1
FAQ
Reference
JavaDoc
Demo
Java Tutorial

Getting Started
Configuration
Servlet
JSP
XTP/XSL
JavaScript
JS Library

Source Text
Literals
Regexp
Operators
Objects
Functions
Statements
Java Wrapping
 Wrapping Java objects

  1. Packages
  2. Resin to Java
  3. Java to Resin
  4. Methods
    1. Method Overloading
    2. Method Calls
  5. Properties
    1. Fields
    2. Simple Bean Properties
    3. Indexed Bean Properties
    4. Named Bean Properties

To give Java objects a JavaScript interface, Resin wraps the Java with automatically generated classes. The wrapper classes convert between Java and JavaScript types, mashalling and unmarshalling call arguments.

Resin's wrapping tries to abide by the rule of least surprises. Wrapped objects as a developer expects. However, because of the differences between Java and JavaScript, the details of making them mesh are somewhat lengthy.

Packages

The Packages object lets scripts directly access Java classes. The properties of the Packages object are Java packages and classes.

As a convenience, the variable 'java' is preset to 'Packages.java' and 'caucho' is preset to 'Packages.com.caucho'.

Java Vector
a = new Packages.java.util.Vector();
a.addElement("a");
a.addElement("b");

Resin to Java

The pseudo-code in the following tables are based on the EcmaScript definitions.

Resin to Java
Java Type pseudo-code
boolean obj.toBoolean()
byte (byte) obj.toInt32()
short (short) obj.toInt32()
char obj.toString()[0]
int obj.toInt32()
long (long) obj.toNumber()
float (float) obj.toNumber()
double obj.toNumber()
String obj.toString()
Object obj.toJavaObject()

toJavaObject
JavaScript Java
null null
undefined null
boolean java.lang.Boolean
date java.lang.Date
string java.lang.String
number java.lang.Double
wrapper wrapper contents
regexp com.caucho.regexp.Regexp
Object unchanged, com.caucho.es.ESBase

Java to Resin


Note: Java Number's are converted to JavaScript numbers, so the Number object is not preserved.

Java to Resin
Java JavaScript
null null
boolean boolean
byte number
short number
char string
int number
long number
float number
double number
java.lang.String string
java.util.Date date
java.lang.Number number
Object Object wrapper

Methods

Scripts can call methods on the wrapped object. Each method is wrapped in a JavaScript function but will only work when this is the wrapped object.

map = new java.util.HashMap();
map.put("foo", "bar");
writeln(map.get);
writeln(map.get("foo"));
writeln(map.get("bar"));
function get() { [native code] }
bar
null

Method Overloading

Methods may be overloaded by argument length. Methods may not be overloaded by argument type. Type-overloaded methods are ignored. For example, the StringBuffer append call is not available in Resin.

Method Calls

Method calls follow these steps:
  1. Select overloaded method by argument length
  2. Convert JavaScript arguments to Java
  3. Call the method
  4. Convert any Java return value to JavaScript

Properties

Resin exposes several types of properties to the script: fields, simple bean get/set properties, bean indexed properties, and named properties. Fields always take precedence.

Fields

Resin exposes public Java fields as properties. Wrapped instances can access object and static properties, while wrapped classes can only access static properties.
Note: Fields override design pattern properties, i.e. bean properties.
Test.java
public class Test {
  public static int foo = 3;
  public int bar = 9;
}
test.es
Test = Packages.Test;
t = new Test();

writeln("Test " + Test.foo + " " + Test.bar);
writeln(Test.bar);

writeln("test " + t.foo + " " + t.bar);
Test 3 undefined
test 3 9

Simple Bean Properties

The bean properties are a convenience for some common method patterns. In all cases, the method interface always exists.

Methods matching foo getXXX() and void setXXX(foo a) are treated as simple JavaScript properties.

Test.java
public class Test {
  private int a = 19;
  public int getA() { return a; }
  public void setA(int value) { a = value }
}
test.es
t = new Packages.Test();

writeln(t.a);
t.a++;
writeln(t.a);
19
20

Indexed Bean Properties

Resin treats indexed properties as arrays using an extensions of the Bean indexed property pattern. In addition to the Foo getXXX(int) and void setXXX(int, Foo) methods, Resin will use int getXXXLength() to determine an array length.
Test.java
public class Test {
  String []data = new String[4] { "fee", "fie", "foe", "fum"};

  public String getString(int i) {
    return data[i];
  }

  public void setString(int i, String value) {
    data[i] = value;
  }

  public int getStringLength() {
    return data.length; 
  }
}
test.es
test = new Packages.Test();

writeln(test.string[0] + " " + test.string[test.length - 1]);
writeln(test.reverse().join());
fee fum
fum,foe,fie,fee

Named Bean Properties

Resin treats named properties as objections extending the Bean properties. It the named properties recognize the Foo getXXX(int) and void setXXX(int, Foo) methods, Resin will use Iterator getXXXNames() to iterate through the members of the property.

Java Def Java Call JavaScript
String getFoo(String name) test.getFoo("bar") test.foo.bar
void setFoo(String name, String value) test.setFoo("bar", "fie") test.foo.bar = "fie";
Iterator getFooNames() test.getFooNames() for (name in test.foo) { ... }
Test.java
public class Test {
  HashMap data = new HashMap();

  public String getFoo(String name) {
    return data.get(name); 
  }

  public void setFoo(String name, String value) { 
    data.set(name, value); 
  }

  public Iterator getFooNames() { 
    return data.keySet().iterator(); 
  }
}
test.es
test = new Packages.Test();

test.foo["bar"] = 13;
test.foo["baz"] = 14;

writeln(test.foo.bar + " " + test.foo.baz + " " + 
        test.foo.fie)

for (a in test.foo) {
  writeln(a + " " + test.foo[a]);
}
13 14 null
bar 13
baz 14

Statements   JS Library
Copyright © 1998-2000 Caucho Technology. All rights reserved.
Last modified: Thu, 16 Sep 1999 14:56:49 -0700 (PDT)