是否可以从JRuby创建Java类并在Java中使用它们? [英] Is it possible to create Java classes from JRuby and use them in Java?

问题描述

我正在尝试从JRuby扩展Lucene的Analyzer并从Java中使用它.一个简单的分析器看起来像:

I'm trying to extend Lucene's Analyzer from JRuby and use it from java. A simple analyzer would look like:

class MyAnalyzer < Java::OrgApacheLuceneAnalysis::Analyzer
  def TokenStream (file_name, reader) 
     result = StandardTokenizer.new(Version::LUCENE_CURRENT, reader)
     result = LowerCaseFilter.new(result)
     result = LengthFilter.new(result, 3, 50) 
     result = StopFilter.new(result, StandardAnalyzer.STOP_WORDS_SET)
     result = PorterStemFilter.new(result)
     result
  end 
end

然后我将其编译:jrubyc -c /home/camilo/trunk/utils/target/dependency/lucene-core-3.0.2.jar --javac MyAnalyzer.rb并将其打包为jar.

Then I compile it: jrubyc -c /home/camilo/trunk/utils/target/dependency/lucene-core-3.0.2.jar --javac MyAnalyzer.rb and package it as a jar.

现在，当尝试在Java中重新使用MyAnalyzer时，MyAnalyzer是org.jruby.RubyObject的后代，而不是org.apache.lucene.analysis.Analyzer.

Now, when trying to use MyAnalyzer back in java, MyAnalyzer is a descendent of org.jruby.RubyObject, and not of org.apache.lucene.analysis.Analyzer.

是否有一种方法可以使Java将MyAnalyzer视为Analyzer而不是RubyObject?还是这种方式超出了JRuby现在可以做的范围?

Is there a way to make Java treat MyAnalyzer as an Analyzer instead of a RubyObject? Or is this way outside the scope of what JRuby can do now?

JRuby版本:jruby 1.6.0 (ruby 1.8.7 patchlevel 330)

推荐答案

根据您的理解，我想您正在尝试创建一个扩展Java类的JRuby类(使用脚本引擎) )，然后将该类交还给Java.

From what I understand from you are trying to do, I’m guessing you are trying to create a JRuby class that extends a Java class (with a scripting engine), and hand back that class to Java.

您的Ruby类可能看起来像这样:

Your Ruby class probably looks like this:

require 'java'
require 'lucene-core.jar'

java_import 'org.apache.lucene.analysis.Analyzer'
java_import 'org.apache.lucene.analysis.standard.StandardTokenizer'
java_import 'org.apache.lucene.util.Version'
java_import 'org.apache.lucene.analysis.TokenStream'
java_import 'java.io.Reader'

class MyAnalyzer < Analyzer

  def tokenStream(file_name, reader) 
     result = StandardTokenizer.new(Version::LUCENE_CURRENT, reader)
      # ...
  end 
end

然后可以按以下方式在Java中使用此类:

You can then use this class in Java as follows:

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.Reader;
import org.apache.lucene.analysis.Analyzer;

public class RunMyAnalyzer {

    public static void main(String[] args) throws ScriptException, FileNotFoundException {
        String filename = "my-analyzer.rb";

        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("jruby");
        Reader reader = new FileReader(filename);
        engine.eval(reader);

        // Instantiate the JRuby class, and cast the result of eval.
        Analyzer analyzer = (Analyzer) engine.eval("MyAnalyzer.new");

        // You can then use this analyzer like a Lucene Analyzer
    }
}

然后编译并运行:

$ javac -cp .:lucene-core.jar:$JRUBY_HOME/lib/jruby.jar RunMyAnalyzer.java 
$ java -cp .:lucene-core.jar:$JRUBY_HOME/lib/jruby.jar RunMyAnalyzer

这里的关键是JRuby生成了一个代理类，然后可以将其转换为Java超类Analyzer.

The key here is that JRuby produces a proxy class that can then be casted into Analyzer, the Java superclass.

这篇关于是否可以从JRuby创建Java类并在Java中使用它们?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！