例子：
foo.bar()
foo.bar
bar()
print "hello world\n"
语法：
[表达式 .] 标识符 [( 表达式 ... [* [表达式]] )]
若未指定被调用方法的对象，则调用 self 的方法。
方法名中除了通常的标识符以外，还可以添加“?”或“!”等后缀。通常在布尔型（返回真或伪）方法名后添加“?”，在比同名（无“!”）方法更具破坏性的方法名（例：tr 和 tr!）后添加“!”。
若最后一个参数前带“*”的话，将会先展开该参数的值，然后才传递。例如：
foo(1,*[2,3,4]) # 等同于 foo(1,2,3,4)
3.2 Java与JRuby的整合[size=x-large][/size]
当前版本的JRuby与Java的结合并不是非常完美，需要编写一些接口代码。笔者所使用的JRuby包是： jruby-complete-1.0.1.jar。
3.2.1 Java中的Ruby运行库环境
首先，Java程序中需要进行如下定义:
RubyInstanceConfig config = new RubyInstanceConfig();
Ruby runtime = Ruby.newInstance(config);
其中 RubyInstanceConfig config里可以配置JRuby运行环境的各种参数，比如
currentDirectory(当前目录)，environment（环境变量）等。config作为Ruby.newInstance的参数来构造runtime ，而runtime 是JRuby的运行库环境，各种JRuby语句的执行都需要在runtime的上下文中执行 。
其次，需要在ParalleIRVirtualMachine进行如下定义：
IRubyObject rt = JavaUtil.convertJavaToRuby(runtime, this);
这句代码把ParalleIRVirtualMachine对象转换成IRubyObject对象，以便在这个对象上进行其他操作。
最后，我们需要把对象rt作为一个全局变量添加到runtime上去：
IAccessor d = new ValueAccessor(rt);
runtime.getGlobalVariables().define("$vm", d);
这步操作完成之后，runtime里就有了一个可供使用的全局对象$vm, 而$vm实际引用的是
IRubyObject对象rt， 由于rt是由ParalleIRVirtualMachine对象转化而来的，所以$vm实际引用的是ParalleIRVirtualMachine对象。
为了在$vm对象上添加方法，需要在rt.getMetaClass()返回的对象上调用defineMethod方法。defineMethod的第一个参数是函数名，第二个参数是一个org.jruby.runtime.callback.Callback对象。
例如，要在$vm上添加一个名为match的方法，可以这样写：
rt.getMetaClass().defineMethod("match", processMatch);
其中，第一个参数是函数名，第二个参数是一个org.jruby.runtime.callback.Callback对象。processMatch的定义是：
Callback processMatch = new IRSReflectionCallback(
ParalleIRVirtualMachine.class, "processMatchRuby",
new Class[] { RubyString.class }, false,// if restArg
false, // if staticArg
Arity.singleArgument(), true);// if fast
上述new IRSReflectionCallback构造函数的第一个参数ParalleIRVirtualMachine.class
是目标Java对象的类型，processMatchRuby是对象上的函数名，new Class[] { RubyString.class }是参数类型数组，参数Arity.singleArgument()指明有几个参数，single是指一个参数，其他参数一般情况下不需修改。
其中 IRSReflectionCallback类是一个自定义的类，它提供了Callback接口的实现。
Callback接口定义如下：
Callback.java：
public interface Callback {
public IRubyObject execute(IRubyObject recv, IRubyObject[] args, Block block);
public Arity getArity();
}
3.2.2 IRSReflectionCallback类实现
IRSReflectionCallback.java: package com.irs..ruby; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Arrays; import java.util.List; import org.jruby.exceptions.JumpException; import org.jruby.exceptions.MainExitException; import org.jruby.exceptions.RaiseException; import org.jruby.exceptions.ThreadKill; import org.jruby.javasupport.JavaObject; import org.jruby.runtime.Arity; import org.jruby.runtime.Block; import org.jruby.runtime.builtin.IRubyObject; import org.jruby.runtime.callback.Callback; /** * A wrapper forjava.lang.reflect.Methodobjects which implement Ruby methods. */ public class IRSReflectionCallback implements Callback { private Method method; private Class type; private String methodName; private Class[] argumentTypes; private boolean isRestArgs; private Arity arity; private boolean isStaticMethod; private boolean fast; /*构造函数*/ public IRSReflectionCallback(Class type, String methodName, Class[] argumentTypes, boolean isRestArgs, boolean isStaticMethod, Arity arity, boolean fast) { this.type = type; this.methodName = methodName; this.argumentTypes = argumentTypes; this.isRestArgs = isRestArgs; this.isStaticMethod = isStaticMethod; this.arity = arity; this.fast = fast; assert type != null; assert methodName != null; assert arity != null; loadMethod(fast); } /* 按照是否为静态方法来传递函数参数 静态方法不需要传递this对象，成员方法需要传递this对象 */ private void loadMethod(boolean fast) { Class[] args; if (isStaticMethod) { Class[] types = new Class[argumentTypes.length + 1]; System.arraycopy(argumentTypes, 0, types, 1, argumentTypes.length); types[0] = IRubyObject.class; args = types; } else { args = argumentTypes; } // ENEBO: Perhaps slow but simple for now if (!fast) { Class[] types = new Class[args.length + 1]; System.arraycopy(args, 0, types, 0, args.length); types[args.length] = Block.class; args = types; } try { ListtmpArg=Arrays.asList(args); //通过反射来从对象上获得方法，供Ruby引擎调用 method = type.getMethod(methodName, args); } catch (NoSuchMethodException e) { throw new RuntimeException("NoSuchMethodException: Cannot get method \"" + methodName + "\" in class \"" + type.getName() + "\" by Reflection."); } catch (SecurityException e) { throw new RuntimeException("SecurityException: Cannot get method \"" + methodName + "\" in class \"" + type.getName() + "\" by Reflection."); } } /** * Returns an object array that collects all rest arguments in its own object array which * is then put into the last slot of the first object array. That is, assuming that this * callback expects one required argument and any number of rest arguments, an input of * [1, 2, 3]is transformed into[1, [2, 3]]. */ protected final Object[] packageRestArgumentsForReflection(final Object[] originalArgs) { IRubyObject[] restArray = new IRubyObject[originalArgs.length - (argumentTypes.length - 1)]; Object[] result = new Object[argumentTypes.length]; try { System.arraycopy(originalArgs, argumentTypes.length - 1, restArray, 0, originalArgs.length - (argumentTypes.length - 1)); } catch (ArrayIndexOutOfBoundsException e) { assert false : e; return null; } System.arraycopy(originalArgs, 0, result, 0, argumentTypes.length - 1); result[argumentTypes.length - 1] = restArray; return result; } /** 在IRubyObject recv对象上调用目标方法 * Invokes the Ruby method. Actually, this methods delegates to an internal version * that may throw the usual Java reflection exceptions. Ruby exceptions are rethrown, * other exceptions throw an AssertError and abort the execution of the Ruby program. * They should never happen. */ /** * Calls a wrapped Ruby method for the specified receiver with the specified arguments. */ public IRubyObject execute(IRubyObject recv, IRubyObject[] oargs, Block block) { arity.checkArity(recv.getRuntime(), oargs); Object[] methodArgs = oargs; if (isRestArgs) { methodArgs = packageRestArgumentsForReflection(methodArgs); } try { JavaObject receiver = (JavaObject)recv; Object target=receiver.getValue(); if (isStaticMethod) { Object[] args = new Object[methodArgs.length + (fast ? 1 : 2)]; System.arraycopy(methodArgs, 0, args, 1, methodArgs.length); args[0] = recv; if (!fast) args[methodArgs.length + 1] = block; receiver = null; methodArgs = args; } else { Object[] args = new Object[methodArgs.length + (fast ? 0 : 1)]; System.arraycopy(methodArgs, 0, args, 0, methodArgs.length); if (!fast) args[methodArgs.length] = block; methodArgs = args; } return (IRubyObject) method.invoke(target, methodArgs); } catch (InvocationTargetException e) { if (e.getTargetException() instanceof RaiseException) { throw (RaiseException) e.getTargetException(); } else if (e.getTargetException() instanceof JumpException) { throw (JumpException) e.getTargetException(); } else if (e.getTargetException() instanceof ThreadKill) { // allow it to bubble up throw (ThreadKill) e.getTargetException(); } else if (e.getTargetException() instanceof Exception) { if(e.getTargetException() instanceof MainExitException) { throw (RuntimeException)e.getTargetException(); } recv.getRuntime().getJavaSupport().handleNativeException(e.getTargetException()); return recv.getRuntime().getNil(); } else { throw (Error) e.getTargetException(); } } catch (IllegalAccessException e) { StringBuffer message = new StringBuffer(); message.append(e.getMessage()); message.append(':'); message.append(" methodName=").append(methodName); message.append(" recv=").append(recv.toString()); message.append(" type=").append(type.getName()); message.append(" methodArgs=["); for (int i = 0; i < methodArgs.length; i++) { message.append(methodArgs[i]); message.append(' '); } message.append(']'); assert false : message.toString(); return null; } catch (final IllegalArgumentException e) { /* StringBuffer message = new StringBuffer(); message.append(e.getMessage()); message.append(':'); message.append(" methodName=").append(methodName); message.append(" recv=").append(recv.toString()); message.append(" type=").append(type.getName()); message.append(" methodArgs=["); for (int i = 0; i < methodArgs.length; i++) { message.append(methodArgs[i]); message.append(' '); } message.append(']');*/ assert false : e; return null; } } /** * Returns the arity of the wrapped Ruby method. */ public Arity getArity() { return arity; } }
3.2.3 在Java中编译执行Ruby脚本
public IRubyObject compileAndRun(String scriptTxt) {
// Node node
try {
//获得全局的runtime对象（Ruby运行库环境）
Ruby ruby = runtime;
Script script = null;
StringReader reader = new StringReader(scriptTxt);
Node parsedScriptNode = ruby.parse(reader, scriptTxt,
ruby.getCurrentContext().getCurrentScope(), 0);
// do the compile
StandardASMCompiler compiler = new StandardASMCompiler(
parsedScriptNode);
NodeCompilerFactory.getCompiler(parsedScriptNode).compile(
parsedScriptNode, compiler);
//加载类
Class scriptClass = compiler.loadClass(new JRubyClassLoader());
//生成script对象
script = (Script) scriptClass.newInstance();
ThreadContext tc = ruby.getCurrentContext();
//执行脚本
return script.run(tc, tc.getFrameSelf(), IRubyObject.NULL_ARRAY,
Block.NULL_BLOCK);
} catch (NotCompilableException nce) {
System.err.println("Error -- Not compileable: " + nce.getMessage());
return null;
} catch (JumpException je) {
if (je.getJumpType() == JumpException.JumpType.ReturnJump) {
return (IRubyObject) je.getValue();
} else {
throw je;
}
} catch (ClassNotFoundException e) {
System.err.println("Error -- Not compileable: " + e.getMessage());
return null;
} catch (InstantiationException e) {
System.err.println("Error -- Not compileable: " + e.getMessage());
return null;
} catch (IllegalAccessException e) {
System.err.println("Error -- Not compileable: " + e.getMessage());
return null;
}
}
3.2.4 Java内嵌Ruby方法总结
结合以上各个步骤，我们就可以在Java中定义方法，然后在Ruby中调用它了，下面总结一下整个过程。
//示例Java类，其中的helloword方法将在Ruby中被调用
Class JavaSampleCls{
public void helloworld(RubyString param){
System.out.println(“hello ”+param.toString());
}
}
//初始化Ruby运行环境
RubyInstanceConfig config = new RubyInstanceConfig();
Ruby runtime = Ruby.newInstance(config);
//初始化目标Java对象
JavaSampleCls javasample=new JavaSampleCls();
//把目标的普通Java对象转化为Ruby可识别的IRubyObject对象
IRubyObject targetObject = JavaUtil.convertJavaToRuby(runtime,javasample);
//定义callback对象： 类JavaSampleCls上的helloworld方法，一个String参数
Callback helloCallback = new IRSReflectionCallback(
JavaSampleCls.class, "helloworld",
new Class[] { RubyString.class }, false,// if restArg
false, // if staticArg
Arity.singleArgument(), true);// if fast
//把callback定义到targetObject上
targetObject.getMetaClass().defineMethod("helloworld", helloCallback);
IAccessor d = new ValueAccessor(targetObject);
//把targetObject绑定到Ruby运行库环境中
runtime.getGlobalVariables().define("$vm", d);
//声明Ruby脚本
String rubycode=”$vm.helloworld(“java”)”;
//编译执行
compileAndRun（rubycode）;