爱华网什么是BeanShell?
BeanShell是一个小型的，免费的，可嵌入式的，具有面向对象脚本语言特性的Java代码解释器。它是用Java语言写的。它能执行标准的Java语句和表达式，还自带简单的脚本命令和语法。它把编程对象当成一个简单的方法，这很像Perl和JavaScript.
你可以在写Java测试或调试时使用BeanShell，也可以用它作为你的应用程序的脚本引挚。简而言之，BeanShell可以动态的解释JAVA语 言。也就是说BeanShell在许多方面对于Java的用处就像Tcl/Tk对于C的用处一样：BeanShell是可嵌入式的---你可以在运行时从 你的应用程序调用BeanShell去动态的执行Java代码或是为你的应用程序提供脚本扩展。相反，你也可以从BeanShell调用你的应用程序及其 对象，它可以让JAVA对象和API动态运行。正因为BeanShell是用JAVA写的，所以它可以和你的应用程序运行在同一个JVM空间内，你也可以 自由的传递实时对象的参照(References)到脚本代码中并且作为结果返回。
主要特性
1.使用了JAVA的反射机制，可在运行时解释JAVA语句和表达式。
2.可以透明的存取所有的JAVA物件和API。
4.有四种运行模式：命令行，控制台，Applet,远程会话服务器(Remote Session Server)。
5.可以在Applet和Application中。
6.这个解释器包只有不到175k(不包括约135k的实用工具)。
7.采用纯JAVA语言。
9.它是完全免费的!
JAVA方面的特性
1.覆盖了所有的Java语句和表达式语法。
2.强效的变量类型与方法。
3.原始值到正确数据类型处理能力。
4.完全Java算法，逻辑，与按位操作。
5.对象构造和多维数组处理。
6.具有break和return的循环及流程控制结构。
7.具有多形/重载特性的方法调用。
8.完全的异常(Exception)处理。
脚本特性
1.动态类型(无类型)的变量。
2.具有参数和返回值的脚本方法。
3.脚本对象。
4.AWT/SWING事件的脚本处理。
5.BeanShell脚本能使用Java Interface的implements属性(要求jdk1.3+)。
6.方便的使用JavaBean的属性，hashtable,和原始数据类型的封装器(Wrapper)。
7.可扩展的工具命令集，像"load/save(bean)"和"eval(String)"。
8.支持namespace/scope修饰：this,super,global。
用途提示
1.与JAVA程序交互---试出对象特性，API和GUI对象。
2.作为应用程序的脚本扩展环境---从你的应用程序使用BeanShell代替JAVA编译器来调用。
3.教育用途---放一个JAVA开发环境在你的java教学网页上真是再好不过了。
4.科学和金融应用中的表达式求值程序---可以使用条件和循环计算复杂的表达式。
5.处理JAVABEAN的设置---用BeanShell的save()命令来写。
6.调试用途---深入JVM玩一玩。
参考资料：
http://www.beanshell.org/home.html
简介：
BeanShell是一种脚本语言，一种完全符合java语法的java脚本语言，并且又拥有自己的一些语法和方法，beanShell是一种松散类型的脚本语言（这点和JS类似）。
下载地址：http://www.beanshell.org
设置环境
l 把;bsh-xx.jar放到$JAVA_HOME/jre/lib/ext文件夹下
l unix: exportCLASSPATH=$CLASSPATH:bsh-xx.jar
l windows: set classpath%classpath%;bsh-xx.jar
运行方式：
l 界面UI方式 ：java bsh.Console
l 命令行方式 ：java bsh.Interpreter
l 运行脚本文件：javabsh.Interpreter filename [ args ]
简单举例：
在classpath中设置好环境变量，打开dos窗口，键入：java bsh.Console命令
出现BeanShell图片代表设置成功，beanshell开始运行
测试内容：
设置变量
foo = "Foo";
four = (2 + 2)*2/2;
打印变量
print( foo + " = " + four );
循环
for (i=0; i<5; i++)
print(i);
在窗口中打印按钮
button = new JButton( "My Button" );
frame = new JFrame( "My Frame" );
frame.getContentPane().add( button,"Center" );
frame.pack();
frame.setVisible(true);
完整代码：
foo = "Foo";
four = (2 + 2)*2/2;
print( foo + " = " + four );
for (i=0; i<5; i++)
print(i);
button = new JButton( "My Button" );
frame = new JFrame( "My Frame" );
frame.getContentPane().add( button,"Center" );
frame.pack();
frame.setVisible(true);
在窗口中输入上面的代码
敲回车执行，运行结果如图
说明：
因为beanshell是松散类型的脚本语言因此可以直接写
foo = "Foo";
four = (2 + 2)*2/2;
print是beanshell提供一种简单的打印命令相当于java中的System.out.println()
其他的beanshell脚本命令
· source(), run() – 读取，或者运行一个脚本文件
· frame() – 显示一个窗口
· load(), save() – 读取或者保存一个脚本对象到文件
· cd(), cat(), dir(), pwd(), etc. 使用Unix下面的命令
· exec() – 运行一个本地的方法
· javap() –使用javap命令.
· setAclearcase/"target="_blank" >ccessibility() – 设置可以接收private和protected类型的变量
BeanShell命令不一定都是内置的脚本命令，脚本方法会自动从classpath中取方法使用，因此你可以添加你自己的脚本到classpath中来扩充基本的命令
脚本方法
一般的方法：
int addTwoNumbers( int a, int b ) {
return a + b;
}
sum = addTwoNumbers( 5, 7 ); // 12
也可以使用动态的变量类型（无状态）方法
add( a, b ) {
return a + b;
}
foo = add(1, 2); // 3
foo = add(1, “2”); //”12” 只要有一个为字符串全部按照字符串处理，系统不会根据1是数字在前把“2”转换成数字处理（特别注意）
foo = add("Oh", " baby"); //"Oh baby"
实现接口
实现任何接口需要java1.3或者更高
可以使用缺省的java匿名类的语法实现一个接口类，例如：
ActionListener scriptedListener = newActionListener() {
actionPerformed( event ) { ... }
}
不需要实现接口的所有的方法，只需要实现你使用的方法即可，如果使用你没有实现的方法，beanshell将抛出一个错误，
ml = new MouseListener() {
mousePressed( event ) { ... }
// handle the rest
invoke( name, args ) { print("Method:"+name+" invoked!");
}
脚本对象
使用特殊的关键字this可以创建一个对象（根JS类似）
foo() {
print("foo");
x=5;
bar() {
print("bar");
}
return this;
}
myfoo = foo(); // prints "foo"
print( myfoo.x ); // prints "5"
myfoo.bar(); // prints "bar"
从应用程序中调用BeanShell
创建一个BeanShell的解释器(interpreter)用eval（）和source()命令可以对一个字符串求值和运行一个脚本文件
使用set（）方法可以给一个对象传入一个变量的参考
使用get（）方法可以重新得到一个变量的结果
完整代码：
package cn.com.spar.net.util;
import bsh.*;
import java.util.*;
public class BeanShell {
public static void main(String[] args) {
try {
Interpreter interpreter = new Interpreter(); // 构造一个解释器
interpreter.set("foo", 5); // 设置变量
interpreter.set("date", new Date()); //设置一个时间对象
Date date = (Date)interpreter.get("date"); // 重新得到时间变量
interpreter.println(date.toString()); //打印时间变量
interpreter.eval("bar = foo*10"); // 对一段脚本求值，并得到结果
System.out.println(interpreter.get("bar"));//打印变量
interpreter.source("d:\helloWorld.bsh");// 导入并执行一个脚本文件
}
catch (Exception e) {
//如果发生异常，写入日志文件
Log.error(new BeanShell(), "main",FormatDate.getCurrDate(), e.getMessage());
}
}
}
BeanShell语法
BeanShell是一种最原始的java解释器。
标准的java语法
/*
StandardJavasyntax
*/
// Use a hashtable
Hashtable hashtable = new Hashtable();
Date date = new Date();
hashtable.put( "today", date );
// Print the current clock value
print( System.currentTimeMillis() );
// Loop
for (int i=0; i<5; i++)
print(i);
// Pop up a frame with a button in it
JButton button = new JButton( "MyButton" );
JFrame frame = new JFrame( "My Frame" );
frame.getContentPane().add( button,"Center" );
frame.pack();
frame.setVisible(true);
松散类型的java语法
/*
Loosely Typed Java syntax
*/
// Use a hashtable
hashtable = new Hashtable();
date = new Date();
hashtable.put( "today", date );
// Print the current clock value
print( System.currentTimeMillis() );
// Loop
for (i=0; i<5; i++)
print(i);
// Pop up a frame with a button in it
button = new JButton( "My Button" );
frame = new JFrame( "My Frame" );
frame.getContentPane().add( button,"Center" );
frame.pack();
frame.setVisible(true);
异常处理
标准的java异常
try {
int i = 1/0;
} catch ( ArithmeticException e ) {
print( e );
}
松散的异常处理（类似JS）
try {
...
} catch ( e ) {
...
}
松散类型变量的作用范围
标准的java程序的变量作用范围是在一个模块中的（在模块中声明的变量），而在松散类型的语言中如果在一个模块中没有指定一个变量的类型，则认为是一个全局变量（只有它以后的代码可以使用该变量，系统在调用该变量的时候自动生成一个全局变量，也就为什么在调用模块之前不能使用该变量的原因）
// Arbitrary code block
{
y = 2; // Untyped variable assigned
int x = 1; // Typed variable assigned
}
print( y ); // 2
print( x ); // Error! x is undefined.
// Same with any block statement: if, while,try/catch, etc.
if ( true ) {
y = 2; // Untyped variable assigned
int x = 1; // Typed variable assigned
}
print( y ); // 2
print( x ); // Error! x is undefined.
同样也使用于for-loop, if-else等循环语句
for( int i=0; i<10; i++ ) { // typed for-initvariable
j=42;
}
print( i ); // Error! 'i' is undefined.
print( j ); // 42
for( z=0; z<10; z++ ) { } // untyped for-initvariable
print( z ); // 10
方便灵活的语法
标准的java语法
java.awt.Button button = new java.awt.Button();
button.setLabel(“javaButton”);
松散的语法
button = new java.awt.Button();
button.label = "my button";
你也可以使用{}来对一个对象设置属性
b = new java.awt.Button();
b{"label"} = "my button"; //Equivalent to: b.setLabel("my button");
h = new Hashtable();
h{"foo"} = "bar"; //Equivalent to: h.put("foo", "bar");
包装和未包装（box和unbox）
BeanShell自动转为简单类型
i=5;
iw=new Integer(5);
print( i * iw ); // 25
导入类和包
import javax.xml.parsers.*;
import mypackage.MyClass;
超级导入法：
import *;
BeanShell默认导入下面的包
· java.lang
· java.io
· java.util
· java.net
· java.awt
· java.awt.event
· javax.swing
· javax.swing.event
友好文档实体
BeanShell支持特殊的文档操作类型内容
@gt > @lt <
@lteq <= @gteq >=
@or || @and &&
@bitwise_and & @bitwise_or |
@left_shift << @right_shift >>
@right_unsigned_shift >>> @and_assign&=
@or_assign |= @left_shift_assign <<=
@right_shift_assign >>=@right_unsigned_shift_assign >>>=
脚本方法
你可以定义方法象java中的定义方法一样
int addTwoNumbers( int a, int b ) {
return a + b;
}
你可以使用内馅的BeanShell方法使用他们
sum = addTwoNumbers( 5, 7 );
只有BeanShell变量可以被动态定义为动态类型，方法可以有动态的参数以及返回类型
add( a, b ) {
return a + b;
}
在这个方法中，BeanShell将动态的决定类型当这个方法被调用时并且能够准确的计算出你想要的结果
foo = add(1, 2);
print( foo ); // 3
foo = add("Oh", " baby");
print( foo ); // Oh baby
在第一个例子中BeanShell将把参数定义为数字型，并返回数字型
在第二个例子中BeanShell将把参数定义为字符型，并返回字符对象
变量和方法的可见范围
就像您所预期的那样，在方法内您可以参考到上下文中上面的变量和方法
a = 42;
someMethod() { ... }
foo() {
print( a );
someMethod(); // invoke someMethod()
}
// invoke foo()
foo(); // prints 42
如果一个变量只有在方法内使用请定义成局部变量，即加上类型，如果是全局变量请在方法外定义
var = "global";
foo() {
print(var);
String var = "local";
print(var);
}
foo();
print(var);
将打印出
global
local
global
方法内的var（第四行）变量属于局部变量，不会覆盖全局变量var（第一行）的因此改变var（第四行）变量不会影响到全局变量var（第一行）
范围参考：super
使用super关键字可以在局部参考到全局变量
var = "global";
foo() {
String var = "local";
print(var);
print(super.var);
}
foo();
将输出
local
global
脚本对象
this对象
在java标准语言中可以使用this返回一个类的一个实例
// MyClass.java
MyClass {
Object getObject() {
return this; // return a reference to our object
}
}
在这个例子中getObject() 方法是返回MyClass类的一个实例
在BeanShell中对象中的变量只是局部的变量在对象内可以使用，在对象外是不可以使用（不同于前面for-loop,if-else中的使用）；
// Define the foo() method:
foo() {
bar = 42;
print( bar );
}
// Invoke the foo() method:
foo(); // prints 42
print( bar ); // Error, bar is undefined here
可以使用this返回对象，使用对象加上“.”运算符参考属性（类似JS）
foo() {
bar = 42;
return this;
}
fooObj = foo();
print( fooObj.bar ); // prints 42!
同样对象中也可以定义一些方法
foo() {
bar() {
...
}
}
例如
foo() {
int a = 42;
bar() {
print("The bar is open!");
}
bar();
return this;
}
// Construct the foo object
fooObj = foo(); // prints "the bar is open!"
// Print a variable of the foo object
print ( fooObj.a ) // 42
// Invoke a method on the foo object
fooObj.bar(); // prints "the bar isopen!"
也可以把bar（）和foo也可以代参数
foo() {
return this;
}
bar(int a) {
print("The bar is open!" + a);
}
foo().bar(1);
也可以把bar（）方法定义到对象外面
foo() {
bar(int a) {
print("The bar is open!" + a);
}
return this;
}
foo().bar(1);
BeanShell一种松散的脚本语言，有很多中声明的方法可以使用
This super global
This是参考当前对象
Super是参考父亲对象
Global是参考最上层对象
super.super.super...foo = 42; // Chain super. toreach the top
global.foo = 42;
简单例子：
文本拖动：
dragText() {
f = new Frame("Drag in the box");
f.setFont( new Font("Serif", Font.BOLD,24) );
f.setSize(300, 300);
f.show();
gc = f.getGraphics();
gc.setColor(Color.cyan);
mouseDragged( e ) {
gc.drawString("Drag Me!", e.getX(),e.getY());
}
mouseMoved( e ) { }
f.addMouseMotionListener( this );
}
简单画图
import bsh.util.BshCanvas; // BshCanvas simplybuffers graphics
graph( int width, int height ) {
canvas=new BshCanvas();
canvas.setSize( width, height );
frame=frame( canvas );
graphics=canvas.getBufferedGraphics();
// draw axis
graphics.setColor( Color.red );
graphics.drawLine( 0, height/2, width, height/2 );
graphics.drawLine( width/2, 0, width/2, height );
graphics.setColor( Color.black );
plot(int x, int y) {
graphics.fillOval( (x+width/2-1), (y+height/2-1),3, 3);
canvas.repaint();
}
return this;
}
drawSin( graph ) {
for (int x=-100; x<100; x++ ) {
y=(int)(50*Math.sin( x/10.0 ));
graph.plot( x, y );
}
}
简单web浏览器
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import java.awt.event.*;
import java.awt.*;
JFrame browser( startingUrl ) {
invoke( method, args ) {}
windowClosing(WindowEvent we) {
we.getWindow().setVisible(false);
}
setPage( url ) {
try {
pane.setPage( url );
} catch(Exception e) {
statusBar.setText("Error opening page:"+url);
}
}
hyperlinkUpdate( HyperlinkEvent he ) {
type = he.getEventType();
if (type == HyperlinkEvent.EventType.ENTERED) {
pane.setCursor(
Cursor.getPredefinedCursor( Cursor.HAND_CURSOR) );
statusBar.setText(he.getURL().toString());
} else
if (type == HyperlinkEvent.EventType.EXITED) {
pane.setCursor( Cursor.getDefaultCursor() );
statusBar.setText(" ");
} else {
setPage( he.getURL() );
if (urlField != null)
urlField.setText(he.getURL().toString());
}
}
frame = new JFrame("Browser");
frame.setSize(400,300);
frame.addWindowListener( this );
urlPanel = new JPanel();
urlPanel.setLayout(new BorderLayout());
urlField = new JTextField(startingUrl);
urlPanel.add(new JLabel("Site: "),BorderLayout.WEST);
urlPanel.add(urlField, BorderLayout.CENTER);
statusBar = new JLabel(" ");
pane = new JEditorPane();
pane.setEditable(false);
setPage( startingUrl );
jsp = new JScrollPane(pane);
frame.getContentPane().add(jsp,BorderLayout.CENTER);
frame.getContentPane().add(urlPanel,BorderLayout.SOUTH);
frame.getContentPane().add(statusBar,BorderLayout.NORTH);
// This is the equivalent of an inner class in bsh.
urlTextHandler() {
actionPerformed(ActionEvent ae) {
setPage( ae.getActionCommand() );
}
return this;
}
urlField.addActionListener( urlTextHandler() );
pane.addHyperlinkListener( (HyperlinkListener)this);
return frame;
}
browser =browser("http://java.sun.com/");
browser.show();
更多的文档参考BeanShell网站
http://www.beanshell.org
BeanShell入门指南
博文原址：http://tongqiuyan.blog.163.com/blog/static/195545302201111123381925/
·BeanShell用户手册——1.3版本
注意：此手册是正在进行中的工作，并没有更新到2.X版本。清参见附加信息来查看更新日志。
o HTML——在线浏览
o HTML——长页面
o PDF 版本印刷效果更好
·最近发布的更新日志 (有用的信息)
·你可以从bsh.Interpreter的帮助文档开始。或者你可以查看bsh packages的帮助文档。也可以下载压缩包：javadoc.zip。
·给St. Louis JavaSIG的演讲稿中的幻灯片（PDF）。这份演讲稿包括Beanshell基础已经 2.0的新功能。
·举例——一些例子
·来自Masa Sakaguchi的Beanshell实例
·与Java与各个Java发布版本的兼容性
·已知的Bugs
·常见问题（这里的不是很多，请参阅搜索邮件列表）。
·愿望清单/未来的功能
·BeanShell在Weblogic6.x上的升级
·BeanShell在NetBeans/Forte上的升级
BeanShell快速开始
http://tongqiuyan.blog.51cto.com/888093/740961
欢迎进入BeanShell的世界。这是一堂速成课程帮你入门。我们将跳过重要的内容以及细节。详情可参见其他用户指南。
下载并运行BeanShell
从http://www.beanshell.org下载最新的 JAR 文件后你可以使用图形化桌面模式或者命令行模式来启动 BeanShell 。如果你只是想摆弄一下，你可以简单得双击 BeanShell 的 JAR 文件来启动 BeanShell的桌面窗口。然而多数情况下你会将 jar 添加到classpath 中轻松地写类和应用程序。
你可以这样做，将 BeanShell的 JAR 文件放到你的 Java 扩展文件夹下或者添加到你的 classpath 中。（重要：如果你将 BeanShell 放到扩展文件夹中并希望将它使用到像 Jakarta Ant 这样的 BSF 应用程序中，你必须在相同的位置安装 bsf.jar ）
将bsh.jar 文件放在 $JAVA_HOME/jre/lib/ext 的文件夹下作为一个扩展来安装它。
（OSX用户：将 bsh.jar 文件放置在 /Library/Java/Extensions
或者~/Library/Java/Extensions 供个别用户使用）
提示：你可以使用 addClassPath() 和 setClassPath() 从 BeanShell内部来更新 classpath 。
将扩展包放在如下类似的路径，注意$JAVA_HOME 的位置要一致。
双击bsh-2.0b4.jar 后出现 BeanShell 的桌面窗口。
这样你可以通过 GUI 或者命令行模式来运行 BeanShell 。
java bsh.Console //运行图形化桌面窗口
或者
java bsh.Interpreter//在命令行上仅作为文本来运行
或者
java bsh.Interpreterfilename [ args ] // 运行脚本文件
也可以在你自己的 Java 应用程序中调用 BeanShell ，通过远程服务模式访问到它进行调试，像 servlet 一样使用它，甚至运行在applet上。更多详情见“ BeanShell 操作模式”。
BeanShell开发小结
BeanShell 是一个具有面向对象脚本语言特性的Java代码解释器开源组件
http://www.beanshell.org/
beanshell 三种调用方式：
a. BeanShell GUI(java bsh.console)
public classBeanShellGui {
public static voidmain(String[] args) {
Console.main(args);
}
}
b. BeanShell 命今行/文本 (java bsh.Interpreter)
例如:Interpreter i = new Interpreter();
i.eval("ss = 4+ 6");
System.out.println(i.get("ss"));//输出结果 10
c. BeanShell 脚本文件 (java bsh.Interpreter fileName)
例：
1. 新建一个script.bsh
script.bsh代码如下：
add(a,b) {
return a + b;
}
2. 测试代码：
int main(String[]args) {
Interpreter i = newInterpreter();
i.source("script.bsh);
i.eval("ss =add(1,2)");
System.out.println(i.get("ss"));//输出结果 3
i.eval("sdf =add("hello"," world")");
System.out.println(i.get("sdf"));//输出结果 hello world
}
Java 语句与表达式
BeanShell 支持标准的Java 语句，表达式，方法定义. 语句和表达式的内容可以是：变量，宣告，赋值，方法调用，循环，判断等
BeanShell 的变量是宽类型的， 用户在定义变量，或方法时可以不指定具体的类型。 在类型不匹配时，BeanShell将抛出一个类型错误.
foo ="Foo";
four = (2 + 2)*2/2;
print( foo + "= " + four ); // print() is a BeanShell command
// Do a loop
for (i=0; i<5;i++)
print(i);
// Pop up a framewith a button in it
button = newJButton( "My Button" );
frame = new JFrame("My Frame" );
frame.getContentPane().add(button, "Center" );
frame.pack();
frame.setVisible(true);
BeanShell 命今
BeanShell 内置的*.bsh命今函数,
提示**：BeanShell命令并不是真的"内建"其中的，而是作为脚本方法自动从classpath载入, 在/bsh/commands目录下
常用的BeanShell函数:
source(), run() - 将一个bsh脚本读到解释器或运行在另一个解释器。
frame() - 显示一个Frame或JFrame的GUI组件.
load(), save() - 载入和保存一个序列化的对象到一个文件.
cd(), cat(), dir(),pwd(), etc. - 类unix的shell命令。
exec() - 运行一个本地的程序。
javap() - 打印一个对象的方法和字段，类似于Java的javap命令。
setAccessibility()- 开启无限制的存取private 和protected的组件。
BeanShell脚本方法
你可以在bsh中宣告和使用方法，就像在java的类中一样:
如：
int addTwoNumbers(int a, int b ) {
return a + b;
}
sum =addTwoNumbers( 5, 7 ); // 12
BeanShell 支持动态类型参数和返回类型
add( a, b ) {
return a + b;
}
foo = add(1,2); // 3
foo =add("Oh", " baby"); // "Oh baby"
BeanShell 定义一类实现某一接口
用Java内部类的语法实现Interface
Interface iface =new Interface() {
public void todo(){
....
}
};
应用程序调用BeanShell
Interpreter i = newInterpreter();
i.eval("int i= 1+2");
int j =(Integer) i.get("i");
http://blog.csdn.net/xymyeah/archive/2006/05/08/713237.aspx
