2011-01-09 12 views

risposta

17

Non sono sicuro che ciò che intendevi per le API sia diverso. Java 6 ha un motore di scripting in cui uno dei motori disponibili è Rhino denotato da "js". Quindi l'unica differenza tra il pacchetto Mozilla Rhino ECMAScript e quello che puoi ottenere dal loro sito web saranno le differenze tra le versioni. Credo che la versione in bundle di Mozilla Rhino ECMAScript sia la versione 1.6 rev2.

Questo è simile al modo in cui funzionano le librerie XML. Esiste un "motore" con un'implementazione predefinita.

utilizzo Esempio di client

     ========== 
         | Client | 
         ========== 
          | 
      =============================== 
      |        | 
=========================   ============= 
| Java Scripting Engine |   | Rhino API | 
=========================   ============= 
      | 
     ================== 
     |    | 
============= =============  
| Rhino API | | Other API | 
============= ============= 

Aggiornamento

Giusto per rispondere alla tua domanda un po 'più, sì Java 6 Scripting Engine si occupa di contesti e di altre operazioni di configurazione che si fare manualmente se si utilizza Rhino direttamente. Ecco un esempio di utilizzo dei due. Tieni presente che quando usi Java6 Scripting Engine, cose simili stanno accadendo sotto il cofano. Lo ScriptingEngine usato qui NON DEVE essere supportato da Rhino. Potrebbe avere un'implementazione di scripting personalizzata.

public class Main { 

    static class Shell extends ScriptableObject { 

     @Override 
     public String getClassName() { 
      return "global"; 
     } 

     public static void print(Context cx, Scriptable thisObj, Object[] args, Function funObj) { 
      for (int i = 0; i < args.length; i++) { 
       String s = Context.toString(args[i]); 
       System.out.print(s); 
      } 
     } 
    } 

    public static void useJava6ScriptingEngine() throws Exception { 
     ScriptEngineManager mgr = new ScriptEngineManager(); 
     ScriptEngine jsEngine = mgr.getEngineByName("JavaScript"); 
     jsEngine.eval("print('Hello, world!')"); 
    } 

    public static void useRhinoDirectly() throws Exception { 
     Context context = Context.enter(); 
     try { 
      Shell shell = new Shell(); 
      String[] names = {"print"}; 
      shell.defineFunctionProperties(names, Shell.class, ScriptableObject.DONTENUM); 
      Scriptable scope = context.initStandardObjects(shell); 
      context.evaluateString(scope, "print('Hello, world!')", null, 0, null); 
     } finally { 
      Context.exit(); 
     } 
    } 

    /** 
    * @param args the command line arguments 
    */ 
    public static void main(String[] args) throws Exception { 
     useJava6ScriptingEngine(); 
     useRhinoDirectly(); 
    } 
} 
+2

La differenza nelle API che mi riferisco è che il pacchetto Rhino di Mozilla utilizza un sacco di gestione esplicita dei contesti e delle Scopes, ma da tutti gli esempi che ho visto del incorporato nell'implementazione in Java 6 sembra che quei dettagli siano forse trascinati sullo sfondo in modo da non doverli preoccupare di essi? –

+0

@Jeremy Da quello che posso dire non li considererei spazzati sotto il tappeto. Dovrai imparare come funziona ScriptEngine in Java 6. Come stavo dicendo Java 6 introduce un framework di Scripting Engine. Mozilla Rhino ECMAScript ha un'implementazione di quel motore di scripting. Ciò significa che Mozilla Rhino ECMAScript viene riprodotto nel contesto del framework di scripting di Java 6. Avete due scelte, usate direttamente l'API di Rhino o imparate la nuova API del motore di scripting Java 6. –

Problemi correlati