JDK1.7新特性(3):java语言动态性之脚本语言API

简介: 简要描述:其实在jdk1.6中就引入了支持脚本语言的API。这使得java能够很轻松的调用其他脚本语言。具体API的使用参考下面的代码: 1 package com.rampage.jdk7.

简要描述:其实在jdk1.6中就引入了支持脚本语言的API。这使得java能够很轻松的调用其他脚本语言。具体API的使用参考下面的代码:

  1 package com.rampage.jdk7.chapter2;
  2 
  3 import java.io.FileWriter;
  4 import java.io.IOException;
  5 
  6 import javax.script.Bindings;
  7 import javax.script.Compilable;
  8 import javax.script.CompiledScript;
  9 import javax.script.Invocable;
 10 import javax.script.ScriptContext;
 11 import javax.script.ScriptEngine;
 12 import javax.script.ScriptEngineManager;
 13 import javax.script.ScriptException;
 14 import javax.script.SimpleBindings;
 15 
 16 /**
 17  * 简单的脚本引擎使用方法
 18  * 
 19  * @author zyq
 20  *
 21  */
 22 public class SimpleScriptAPI {
 23     public static void main(String[] args) throws ScriptException, IOException, NoSuchMethodException {
 24         SimpleScriptAPI simpleScriptEngine = new SimpleScriptAPI();
 25         
 26         // Part 1: 通用的脚本引擎用法
 27         ScriptEngine engine = simpleScriptEngine.getJavaScriptEngine();
 28         if (engine == null) {
 29             throw new RuntimeException("找不到JavaScript脚本执行引擎!");
 30         }
 31         engine.eval("var a = 12;");
 32         
 33         // Part 2: 不同脚本语言与java之间的对象绑定
 34         engine.put("name", "Alex");
 35         engine.eval("var message = 'hello ' + name");
 36         Object message = engine.get("message");
 37         System.out.println(message);         // hello Alex
 38         
 39         // 当然也可以通过SimpleBinds对象来进行变量绑定或者通过脚本引擎的createBindings方法
 40         Bindings bindings = new SimpleBindings();
 41         bindings = engine.createBindings();
 42         bindings.put("hobby1", "java");
 43         bindings.put("hobby2", "dota");
 44         engine.eval("var message2 = 'I like ' + hobby1 + ' and ' + hobby2", bindings);
 45         // 使用binding来绑定的变量只能在脚本语言内部是使用,java语言内获取不到对应的变量
 46         System.out.println(engine.get("message2"));        // null 
 47         System.out.println(engine.get("hobby1"));        // null
 48         System.out.println(engine.get("hobby2"));        // null
 49         engine.put("hobby1", "java");
 50         engine.put("hobby2", "dota");
 51         engine.eval("var message2 = 'I like ' + hobby1 + ' and ' + hobby2"); 
 52         System.out.println(engine.get("message2"));   // I like java and dota
 53         System.out.println(engine.get("hobby1"));      // java
 54         System.out.println(engine.get("hobby2"));      // dota
 55         
 56         // Part 3: 脚本执行上下文
 57         // ScriptContext的setReader/setWriter/setErrorWriter可以分别设置脚本执行时候的输入来源,输出目的地和错误输出目的地
 58         ScriptContext context = engine.getContext();
 59         context.setWriter(new FileWriter("output.txt"));
 60         engine.eval("var a = 13");
 61         // ScriptContext中也有setAttribute和getAttribute方法来自定义属性。属性有不同的作用域之分。
 62         // 每个作用域都以一个对应的整数表示其查找顺序,该整数越小,说明查找时的顺序更优先。
 63         // 因此在设置属性时需显示的指定所在的作用域,在获取属性的时候可以指定查找的作用域。也可以选择根据作用域优先级
 64         // 自动进行查找。
 65         // 但是脚本执行上下文所能包含的作用域可以通过 getScopes 方法得到而不能随意指定
 66         System.out.println(context.getScopes());        // [100, 200]
 67         // ScriptContext预先定义了两个作用域: ENGINE_SCOPE(当前脚本引擎) 和 GLOBAL_SCOPE(从同一引擎工厂创建出来的所有脚本引擎),前者的优先级更高
 68         context.setAttribute("name", "Alex", ScriptContext.GLOBAL_SCOPE);
 69         context.setAttribute("name", "Bob", ScriptContext.ENGINE_SCOPE);
 70         System.out.println(context.getAttribute("name"));        // Bob
 71         // ScriptContext的setbindings方法设置的语言绑定对象会影响到ScriptEngine在执行脚本时的变量解析。
 72         // ScriptEngine的put和get方法所操作的实际上就是ScriptContext中作用域为ENGINE_SCOPE的语言绑定对象。
 73         // 从ScriptContext中得到语言绑定对象之后,可以直接对这个对象进行操作。如果在ScriptEngine的eval中没有
 74         // 指明所使用的语言绑定对象,实际上起作用的是ScriptContext中作用域为ENGINE_SCOPE的语言绑定对象。
 75         Bindings binding1 = engine.createBindings();
 76         binding1.put("name", "Alex");
 77         context.setBindings(binding1, ScriptContext.GLOBAL_SCOPE);
 78         Bindings binding2 = engine.createBindings();
 79         binding2.put("name", "Bob2");
 80         context.setBindings(binding2, ScriptContext.ENGINE_SCOPE);
 81         System.out.println(engine.get("name"));        // Bob2
 82         Bindings binding3 = context.getBindings(ScriptContext.ENGINE_SCOPE);
 83         binding3.put("name", "Alex2");
 84         System.out.println(engine.get("name"));        // Alex2
 85         context.setAttribute("name", "Bob3", ScriptContext.ENGINE_SCOPE);
 86         System.out.println(engine.get("name"));        // Bob3
 87         
 88         // Part 4: 脚本的编译
 89         // 脚本语言一般是解释执行的,脚本引擎在运行时需要先解析脚本之后再执行。一般来说
 90         // 通过解释执行的方式运行脚本的速度比先编译再运行会慢一些。所以对于需要多次执行的脚本,我们
 91         // 可以选择先编译,以防止重复解析。不是所有的脚本语言都支持对脚本进行编译,如果脚本支持
 92         // 编译,他会实现 javax.script.Compilable接口。编译的结果用CompiledScript来表示。
 93         if (engine instanceof Compilable) {
 94             CompiledScript script  = ((Compilable) engine).compile("var a = 12; b = a * 3;");
 95             script.eval();
 96         }
 97         
 98         // Part 5: 方法调用
 99         // 有些脚本引擎允许使用者单独调用脚本中的某个方法。支持这种调用方法的脚本引擎可以实现
100         // javax.script.Invocable 接口。通过Invocable接口既可以调用脚本中的顶层方法,也可一
101         // 调用对象中的成员方法。如果脚本中的顶层方法或者对象中的成员方法实现了java中的接口,
102         // 可以通过Invocable接口中的方法来获取及脚本中对应的java接口 的实现对象。这样就可以
103         // 在java中定义借口,在脚本中实现接口。程序中使用该接口的其他部分代码并不知道接口是
104         // 由脚本来实现的。
105         String scriptText = "function greet(name) {return 'hello ' + name; }";
106         engine.eval(scriptText);
107         Invocable invocable = (Invocable) engine;
108         System.out.println(invocable.invokeFunction("greet", "Alex"));  // hello Alex
109         // 如果调用的是脚本中对象的成员方法,则需要用invokeMethod.
110         scriptText = "var obj = {getGreeting: function(name) {return 'hello ' + name;}};";
111         engine.eval(scriptText);
112         Object scope = engine.get("obj");
113         System.out.println(invocable.invokeMethod(scope, "getGreeting", "Bob"));  // hello Bob
114         // 在脚本中实现接口
115         scriptText = "function getGreeting(name) {return 'Hello ' + name;}";
116         engine.eval(scriptText);
117         Greet greet = invocable.getInterface(Greet.class);        // 接口必须是public类型的
118         System.out.println(greet.getGreeting("KiDe"));
119     }
120 
121     private ScriptEngine getJavaScriptEngine() {
122         ScriptEngineManager manager = new ScriptEngineManager();
123         // PS: 通过脚本引擎管理者来获取对应引擎,有三种方法:一是通过getEngineByName(这时只能是 javascript 或者
124         // JavaScript)
125         ScriptEngine engine = manager.getEngineByName("JavaScript");
126         // 第二种方法是通过 getEngineByExtension (这时候只能是全小写的js)
127         // engine = manager.getEngineByExtension("js");
128         // 第三种方法是通过 getEngineByMimeType (这时候也必须是全小写的 text/javascript)
129         // engine = manager.getEngineByMimeType("text/javascript");
130         
131         return engine;
132     }
133 }
SimpleScriptAPI
1 package com.rampage.jdk7.chapter2;
2 
3 public interface Greet {
4     String getGreeting(String name);
5 }
Greet

 

黎明前最黑暗,成功前最绝望!
相关文章
|
10天前
|
JSON Java Apache
Java基础-常用API-Object类
继承是面向对象编程的重要特性,允许从已有类派生新类。Java采用单继承机制,默认所有类继承自Object类。Object类提供了多个常用方法,如`clone()`用于复制对象,`equals()`判断对象是否相等,`hashCode()`计算哈希码,`toString()`返回对象的字符串表示,`wait()`、`notify()`和`notifyAll()`用于线程同步,`finalize()`在对象被垃圾回收时调用。掌握这些方法有助于更好地理解和使用Java中的对象行为。
|
25天前
|
算法 Java API
如何使用Java开发获得淘宝商品描述API接口?
本文详细介绍如何使用Java开发调用淘宝商品描述API接口,涵盖从注册淘宝开放平台账号、阅读平台规则、创建应用并申请接口权限,到安装开发工具、配置开发环境、获取访问令牌,以及具体的Java代码实现和注意事项。通过遵循这些步骤,开发者可以高效地获取商品详情、描述及图片等信息,为项目和业务增添价值。
57 10
|
24天前
|
存储 Java 开发者
什么是java的Compact Strings特性,什么情况下使用
Java 9引入了紧凑字符串特性,优化了字符串的内存使用。它通过将字符串从UTF-16字符数组改为字节数组存储,根据内容选择更节省内存的编码方式,通常能节省10%至15%的内存。
|
1月前
|
存储 Java 数据挖掘
Java 8 新特性之 Stream API:函数式编程风格的数据处理范式
Java 8 引入的 Stream API 提供了一种新的数据处理方式,支持函数式编程风格,能够高效、简洁地处理集合数据,实现过滤、映射、聚合等操作。
57 6
|
8天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
10天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
10天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
|
11天前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式:助您写出线程安全的代码
`synchronized` 是 Java 中的关键字,用于实现线程同步,确保多个线程互斥访问共享资源。它通过内置的监视器锁机制,防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块,分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器,JDK 1.6 后引入了偏向锁、轻量级锁等优化措施,提高了性能。
34 3
|
11天前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
92 2
|
19天前
|
安全 Java API
java如何请求接口然后终止某个线程
通过本文的介绍,您应该能够理解如何在Java中请求接口并根据返回结果终止某个线程。合理使用标志位或 `interrupt`方法可以确保线程的安全终止,而处理好网络请求中的各种异常情况,可以提高程序的稳定性和可靠性。
46 6