Ronger

Beanshell翻译27

281696143@qq.com(Ronger) — Fri, 26 Dec 2008 08:18:49 GMT

1.BeanShell Commands Beanshell命令
1.1.run
run ( String filename , Object runArgument )
run ( String filename )
Run a command in its own in its own private global namespace,
with its own class manager and interpeter context.
(kind of like unix "chroot" for a namespace).
运行一个命令在它自己私有的全局名字空间中，
通过它自己的类管理器和解释器环境。
(就像unix中名字空间中的"chroot"一样)
The root bsh system object is extended (with the extend() command) and made visible here,
so that general system info (e.g. current working directory) is effectively inherited.
Because the root bsh object is extended it is effectively read only / copy on write... e.g.
you can change directories in the child context,
do imports, change the classpath, etc.
and it will not affect the calling context.
这个根bsh系统对象是被继承的(通过extend()命令)并且在这儿是可见的，
所以通常的系统信息(当前工作路径)是有效的继承而得到。
因为根bsh对象是被继承出来的，所以它是只读的。
你能在子类环境中修改目录，
导入，修改类路径，等等。
并且它将不会影响调用环境。
run() is like source() except that it runs the command in a new,
subordinate and prune()'d namespace.
So it's like "running" a command instead of "sourcing" it.
run() teturns the object context in which the command was run.
Returns the object context so that you can gather results.
Parameter runArgument an argument passed to the child context under the name runArgument.
e.g. you might pass in the calling This context from which to draw variables, etc.
run()和source()一样，
除了它在一个新的下级的prune()的名字空间中运行这个命令。
所以它就像"running"一个命令来代替"sourcing"它。
run()返回命令正在运行的对象环境。
返回这个对象环境，所以你能搜集结果。
参数runArgument的一个参数在runArgument的下面通过子类环境。
例如，你能通过调用定义变量的这个环境，等等。
1.2.save
void save ( Object obj , String filename )
Save a serializable Java object to filename.
存储一个能序列化的Java对象到一个文件中。
1.3.server
void server ( int port )
Create a remote BeanShell listener service attached to the current interpreter,
listening on the specified port.
创建一个远程Beanshell监听器服务，这个服务隶属于当前解释器，
监听特定的端口。
1.4.setAccessibility
setAccessibility ( boolean b )
Setting accessibility on enables to private and other non.public fields and method.
设置能操作私有和其他的非公有属性和方法的入口。
1.5.setClassPath
void setClassPath( URL [] )
Change the classpath to the specified array of directories and/or archives.
See "Class Path Management" for details.
修改类路径为目录和URL的特定数组。
请看"Class Path Management"的细节。
1.6.setFont
Font setFont ( Component comp , int ptsize )
Change the point size of the font on the specified component, to ptsize.
This is just a convenience for playing with GUI components.
在特定的组件上修改字体的大小。
这是使用GUI组件的一个便利。
1.7.setNameCompletion
void setNameCompletion ( boolean bool )
Allow users to turn off name completion.
Turn name completion in the GUI console on or off.
Name competion is on by default.
Explicitly setting it to true
however can be used to prompt bsh to read the classpath and provide immediate feedback.
(Otherwise this may happen behind the scenes the first time name completion is attempted).
Setting it to false will disable name completion.
允许用户关闭名字编辑。
在GUI平台上打开或者关闭名字编辑。
名字编辑在默认的情况下是打开的。
很明白的将它设置为true,
但是能被用于促使bsh去读取类路径和提供直接的反应。
(其他的，这个能在第一次命名编辑被运行的时候发生)。
将它设置为false的时候将不允许名字编辑。
1.8.setNameSpace
setNameSpace ( ns )
Set the namespace (context) of the current scope.
The following example illustrates swapping the current namespace.
设置当前作用域的名字空间(环境)。
下面的例子举例说明了交换当前名字空间。
fooState = object();
barState = object();
print(this.namespace);
setNameSpace(fooState.namespace);
print(this.namespace);
a=5;
setNameSpace(barState.namespace);
print(this.namespace);
a=6;
setNameSpace(fooState.namespace);
print(this.namespace);
print(a); // 5
setNameSpace(barState.namespace);
print(this.namespace);
print(a); // 6
You could use this to creates the effect of a static namespace for a method
by explicitly setting the namespace upon entry.
你能使用这些为一个方法创建一个静态名字空间的效果，
通过清晰地将名字空间设置到输入中。
1.9.setStrictJava
void setStrictJava ( boolean val )
Enable or disable "Strict Java Mode".
When strict Java mode is enabled BeanShell will:
1.9.1. Require typed variable declarations, method arguments and return types.
1.9.2. Modify the scoping of variables to look for the variable declaration first
in the parent namespace, as in a java method inside a java class.
允许或者不允许"严格Java模式"。
当严格Java模式开启的时候，Beanshell将会：
需要定义类型变量，方法参数和返回类型。
修改变量作用域去首先查找在父名字空间中变量的定义，就像一个java方法在一个java类中一样。
e.g. if you can write a method called incrementFoo() that will
do the expected thing without referring to "super.foo".
See "Strict Java Mode" for more details.
Note: Currently most standard BeanShell commands will not work in Strict Java mode simply
because they have not been written with full types, etc.
例如，如果你能写一个名字为incrementFoo()的方法，
这个方法不用指向"super.foo"，
就能做预期的事情。
请看"Strict Java Mode"来了解更多细节。
注意：当前很多标准Beanshell命令将不能工作在Java严格模式下，
仅仅因为他们没有被重写为所有的类型。
1.10.show
show ( )
Toggle on or off displaying the results of expressions (off by default).
When show mode is on bsh will
print() the value returned by each expression you type on the command line.
开启或关闭表达式的显示结果(默认状态为关闭)。
当显示模式开启的时候，
bsh将打印通过你定义在命令行上的每一个表达式的值。
1.11.source
Object source ( String filename )
Object source ( URL url )
Read filename into the interpreter and evaluate it in the current namespace.
Like the Bourne Shell "." command.
This command acts exactly like the eval() command but reads from a file or URL source.
将文件名读取到在当前的名字空间的解释器并且计算它。
就像目的地的"."命令。
这个命令正确的行为应该像eval()命令一样，但是是从一个文件或者URL源读取。
1.12.sourceRelative
sourceRelative ( String file )
Source a file relative to the callering script's directory. e.g.
scripts A running in dir A sources script B in dir B.
Script B can use this command to load additional scripts
(data, etc.) relative to its own location (dir B)
without having to explicitly know its "home" directory (B).
加载一个和调用脚本目录有关系的文件，例如，
运行在目录A上的脚本A加载目录B上的脚本B。
脚本B能使用这个命令，在没有清晰的知道它自己的"home"目录的情况下(B),
去加载和它自己位置(目录B)有关系的另外的脚本(数据等)。
Note: this only works for files currently.
注意：这个仅仅运行在当前的文件上。
1.13.super
This super( String scopename )
Return a BeanShell 'this' reference to the enclosing scope (method scope) of the specified name. e.g.
返回一个Beanshell的'this'引用到这个特定名字所在的作用域(方法作用域)。
foo() {
x=1;
bar() {
x=2;
gee() {
x=3;
print( x ); // 3
print( super.x ); // 2
print( super("foo").x ); // 1
}
}
}
This is an experimental command that is not intended to be of general use.
这是一个根据实验的命令，不能延伸到普通用户。
1.13.unset
void unset ( String name )
"Undefine" the variable specifed by 'name' (So that it tests == void).
Note: there will be a better way to do this in the future.
This is currently equivalent to doing namespace.setVariable(name, null);
"不确定"通过'名字'确定的变量(所以它测试==空的)。
注意：在未来将有一个更好的方法去做这些。
这个在当前等价于使用名字空间来设置变量。
1.14.which
which( classIdentifier | string | class )
Use classpath mapping to determine the source of the specified class file.
(Like the Unix which command for executables).
使用映射到特定的类文件的源的类路径。(就像在Unix中，确定哪一个命令能执行)。
This command maps the entire classpath and prints all of the occurrences of the class.
这个命令映射完整的类路径并且打印所有出现的类。
If you just want to find the first occurrence in the classpath
(the one that will be used by Java)
you can also get it by printing the URL of the resource. e.g.:
如果你正好在类路径中找到第一次出现
(这个将被Java实现)
你也能够通过打印源文件的URL来取得它，例如：
print( getResource("/com/foo/MyClass.class") );
// Same as... 等价于
// System.out.println(
// getClass().getResourceAsStream("/com/foo/MyClass.class" ) );
Note: This is all a lie!
This command is broken and only reports the currently first occurence! To be fixed!
注意：这完全是一个谎言！
这个命令会被打断，并且仅仅报告当前的第一次出现！被确定！
1.15.workspaceEditor
workspaceEditor( bsh.Interpreter parent, String name )
Make a new workspaceEditor in the GUI.
在GUI中构造一个新的工作区间编辑器。

Beanshell翻译26

281696143@qq.com(Ronger) — Thu, 25 Dec 2008 09:01:49 GMT

1.BeanShell Commands Beanshell命令
1.1.getClass
Class getClass ( String name )
Get a class through the current namespace utilizing the current imports,
extended classloader, etc.
使用当前导入的类取得一个类到当前名字空间中，
扩展类加载器，等。
This is equivalent to the standard Class.forName() method for class loading,
however it takes advantage of
the BeanShell class manager so that added classpath will be taken into account.
You can also use Class.forName(),
however if you have modified the classpath or reloaded classes from within your script the
modifications will only appear if you use the getClass() command.
这个是和标准的用于类加载Class.forName()方法等价的，
但是它比Beanshell类管理器有优势，
以至于增加的类路径将被考虑。
你也能使用Class.forName(),
但是如果你已经修改类路径或者从你的脚本中重新加载类，
当你使用getClass()命令的时候，仅仅显示修改。
1.2.getClassPath
URL [ ] getClassPath ( )
Get the current classpath including all user path, extended path,
and the bootstrap JAR file if possible.
取得的当前的类路径，这个路径包含所有的用户路径，扩充的路径，
和如果可能的JAR文件。
1.3.getResource
URL getResource ( String path )
Get a resource from the BeanShell classpath.
This method takes into account modification to the BeanShell
class path via addClassPath() and setClassPath();
从Beanshell类路径中取得一个源。
这个函数会通过addClassPath()和setClassPath()来计算Beanshell类路径的修改;
1.4.getSourceFileInfo
getSourceFileInfo ( )
Return the name of the file or source from which the current interpreter is reading.
Note that if you use this within a method,
the result will not be the file from which the method was sourced,
but will be the file that the caller of the method is reading.
Methods are sourced once but can be called many times...
Each time the interpreter may be associated with a different file
and it is that calling interpreter that you are asking for information.
从当前解释器正在读取的东西中返回文件或者源的名字。
注意如果你通过一个方法来使用这些，
结果将不是这个函数来源的文件，
而是函数的调用者正在读取的文件。
函数只可以被加载一次，但是能被调用很多次...
每次解释器可以被和一个不同的文件相联系，
并且这是调用你正在要求的信息的解释器。
Note: although it may seems like this command would always return the getSourceFileInfo.bsh file,
it does not since it is being executed after sourcing by the caller's interpreter.
If one wanted to know the file from
which a bsh method was sourced one would have to either capture
that info when the file was sourced (by
saving the state of the getSourceFileInfo() in a variable outside of the method
or more generally we could add the info to the BshMethod class so
that bsh methods remember from what source they were created...
注意：虽然它看起来能一直返回这个getSourceFileInfo.bsh文件，
在调用者的解释器之后，它不能被执行。
如果一个人想去知道一个bsh函数被调用的源文件，
当文件被加载用来存储getSourceFileInfo()的状态到函数的一个外部变量中的时候，
这个人既可以去捕捉信息，
也可以更多的，我们能够追加信息到BshMethod类中，
这样bsh函数可以从他们创建的源中加载。
1.5.importCommands
void importCommands( resource path | package name )
Import scripted or compiled BeanShell commands in the following package in the classpath.
You may use either "/" path or "." package notation. e.g.
导入脚本或者编译好的Beanshell命令在类路径的下面的包中。
你不仅能使用"/"路径，或者"."包注释。等。
// equivalent 等价于
importCommands("/bsh/commands")
importCommands("bsh.commands")
When searching for a command each path will be checked for first,
a file named 'command'.bsh and second a class file named 'command'.class.
当查找一个命令，每一个路径都会被检查，
首先检查一个名字为'command'.bsh的文件，
其次检查一个名字为'command'.class的类文件。
You may add to the BeanShell classpath using the addClassPath()
or setClassPath() commands and then import them as usual.
你能使用addClassPath()或者setClassPath()来增加到Beanshell类路径中，
并且像通常一样导入他们。
addClassPath("mycommands.jar");
importCommands("/mypackage/commands");
If a relative path style specifier is used
then it is made into an absolute path by prepending "/".
Later imports take precedence over earlier ones.
Imported commands are scoped just like imported clases.
如果一个相对在路径样式被使用，
那么它就通过预先考虑的"/"变成一个绝对路径。
后来导入的内容优先于较早的一个。
被导入的命令的作用域就像被导入的类一样。
1.6.javap
void javap( String | Object | Class | ClassIdentifier )
Print the public fields and methods of the specified class
(output similar to the JDK javap command).
打印特殊类在公共的属性和方法
(输出到JDK的javap命令)。
If the argument is a string it is considered to be a class name.
If the argument is an object, the class of the object is used.
If the arg is a class, the class is used.
If the argument is a class identifier,
the class identified by the class identifier will be used.
e.g. If the argument is the empty string an error will be printed.
如果参数是一个字符串，它被考虑为一个类名字。
如果参数是一个对象，这个对象的类型会被使用。
如果这个参数是一个类型，这个类型就被使用。
如果这个参数是一个类标示符，
被这个类标示符标示的类型将被使用。
等等，如果这个参数是空字符串，一个错误将被打印。
// equivalent 等价
javap( java.util.Date ); // class identifier 类标示符
javap( java.util.Date.class ); // class 类
javap( "java.util.Date" ); // String name of class 类的字符串名
javap( new java.util.Date() ); // instance of class 类的实例
1.7.load
Object load ( String filename )
Load a serialized Java object from filename. Returns the object.
从文件中加载一个被序列化的对象，返回这个对象。
1.8.makeWorkspace
makeWorkspace ( String name )
Open a new workspace (JConsole) in the GUI desktop.
在GUI桌面上打开一个新的工作空间(JConsole)。
1.9.mv
mv ( String fromFile , String toFile )
Rename a file (like Unix mv).
重命名一个文件(就像Unix中的mv一样)。
1.10.object
This object()
Return an "empty" BeanShell object context which can be used to hold data items. e.g.
返回一个"empty"Beanshell对象环境，这个对象能被用于保存数据项，等等。
myStuff = object();
myStuff.foo = 42;
myStuff.bar = "blah";
1.11.pathToFile
File pathToFile ( String filename )
Create a File object corresponding to the specified file path name,
taking into account the bsh current working directory (bsh.cwd) .
创建一个符合特殊文件路径名称的文件对象，
计算这个bsh当前工作路径(bsh.cwd).
1.12.print
void print ( arg )
Print the string value of the argument, which may be of any type.
If beanshell is running interactively,
the output will always go to the command line,
otherwise it will go to System.out.
打印参数的字符串值，可以为任何类型。
如果beanshell正在交互运行，
输出将一直到命令行中，
其他的将去System.out。
Most often the printed value of an object will simply be the Java toString() of the object.
However if the argument is an array the contents of the array
will be (recursively) listed in a verbose way.
最经常的情况，一个对象打印的值将简单的变成该对象的toString().
但是如果这个参数是一个数组，
数组的内容将(递归地)被列在一个详细清单上。
Note that you are always free to use System.out.println() instead of print().
注意你可以一直自由的使用System.out.println()来代替print().
1.13.printBanner
printBanner ( )
Print the BeanShell banner (version and author line) . GUI or non GUI.
打印Beanshell标语(版本和作者信息)。GUI模式或者非GUI模式。
1.14.pwd
pwd ( )
Print the BeanShell working directory.
This is the cwd obeyed by all the unix.like bsh commands.
答应Beanshell工作目录。
这是cwd，被服从于所有的unix.like bsh命令。
1.15.reloadClasses
void reloadClasses( [ package name ] )
Reload the specified class, package name, or all classes if no name is given. e.g.
重新加载特定的类，包名，或者如果没有名字被提到就加载所有的类，等等。
reloadClasses();
reloadClasses("mypackage.*");
reloadClasses(".*") // reload unpackaged classes 重新加载没有打包的类
reloadClasses("mypackage.MyClass")
See "Class Path Management" 请看"Class Path Management"
1.16.rm
boolean rm ( String pathname )
Remove a file (like Unix rm).
移除一个文件(就像Unix下面的rm一样)。

Beanshell翻译25

281696143@qq.com(Ronger) — Wed, 24 Dec 2008 07:01:36 GMT

1.BeanShell Commands Beanshell命令
1.1.classBrowser
classBrowser ( )
Open the class browser.
打开类浏览器。
1.2.clear
clear ( )
Clear all variables, methods, and imports from this namespace.
If this namespace is the root, it will be reset to the default imports.
See NameSpace.clear();
清理所有的变量，方法，并且从这个名字空间中导入。
如果这个名字空间是根，它讲重新设置默认的导入。
请看NameSpace.clear();
1.3.cp
cp ( String fromFile , String toFile )
Copy a file (like Unix cp).
复制一个文件(像Unix cp一样)。
1.4.debug
debug ( )
Toggle on and off debug mode.
Debug output is verbose and generally useful only for developers.
打开和关闭调试模式。
调试输出是冗长的并且通常仅仅对开发者有用。
1.5.desktop
void desktop()
Start the BeanShell GUI desktop.
开始Beanshell GUI桌面。
1.6.dirname
String dirname ( String pathname )
Return directory portion of path based on the system default file separator.
Note: you should probably use pathToFile() to localize the path relative to BeanShell's working directory
and then file.getAbsolutePath() to get back to a system localized string.
直接返回路径的一部分取决于系统默认文件隔离物。
注意：你能够使用pathToFile()去定位Beanshell的工作目录的路径关系
并且也可以使用file.getAbsolutePath()去返回一个系统当前字符串。
Example: to change to the directory that contains the script we're currently executing:
例如：改变包含脚本的目录，我们在当前可以执行：
// Change to the directory containing this script
修改包含这个脚本的目录
path=pathToFile( getSourceFileInfo() ).getAbsolutePath();
cd( dirname( path ) );
1.7.editor
editor ( )
Open a GUI editor from the command line or in the GUI desktop mode.
When run from the command line the editor is a simple standalone frame.
When run inside the GUI desktop it is a workspace editor.
See workspaceEditor()
从命令行中或者在GUI桌面模式下打开一个GUI编辑器。
当从命令行中运行的时候，编辑器是一个简单的孤立的框架。
当进入GUI内部运行的时候，它是一个工作空间编辑器。
请看workspaceEditor()
1.8.error
void error ( item )
Print the item as an error.
In the GUI console the text will show up in (something like) red,
else it will be printed to standard error.
对待一个错误一样打印细节。
在GUI平台中，文本下面将显示为红色，
否则它将打印标准错误。
1.9.eval
Object eval ( String expression )
Evaluate the string in the current interpreter (see source()).
Returns the result of the evaluation or null.
评价在当前解释器中的字符串(请看source())。
返回计算的结果或者null.
Evaluate a string as if it were written directly in the current scope,
with side effects in the current scope.
计算一个字符串就像它被直接的写入在当前作用域中，
在当前作用域中有同样的效果。
e.g.
a=5;
eval("b=a*2");
print(b); // 10
eval() acts just like invoked text except
that any exceptions generated by the code are captured in a bsh.EvalError.
This includes ParseException for syntactic errors
and TargetError for exceptions thrown by the evaluated code.
eval()功能就像调用文本，
除了一些通过代码产生的一场在bsh.EvalError中捕捉一样。
这个包含依据造句法的错误的ParseException
和被计算代码抛出来的TargetError异常。
e.g.
try {
eval("foo>>>M>JK$LJLK$");
} catch ( EvalError e ) {
// ParseException caught here
ParseException在这儿捕捉。
}
try {
eval("(Integer)true"); // illegal cast 非法转换
} catch ( EvalError e ) {
// TargetException caught here
TargetException在这儿捕捉。
print( e.getTarget() ) // prints ClassCastException 打印ClassCastException
}
If you want eval() to throw target exceptions directly,
without wrapping them, you can simply redefine own eval like so:
如果你想eval()直接抛出target异常，
不用包装它们，你能简单重定义自己的eval，就像下面这样：
myEval( String expression ) {
try {
return eval( expression );
} catch ( TargetError e ) {
throw e.getTarget();
}
}
Here is a cute example of how to use eval to implement a dynamic cast.
i.e. to cast a script to an arbitrary type by name at run.time
where the type is not known when you are writing the script.
In this case the type is in the variable interfaceType.
这儿是一个好的例子，来说明如何使用eval去实现动态类型转换。
例如当你在写脚本的时候，并且这时候类型还未知，
通过在运行时通过名字将一个脚本转换为一个任意类型。
在这个例子中，类型是在变量接口类型中。
reference = eval( "("+interfaceType+")this" );
Returns the value of the expression.
返回表达式的值。
Throws bsh.EvalError on error
在错误中抛出bsh.EvalError
1.10.exec执行
exec ( String arg )
Start an external application using the Java Runtime exec() method.
Display any output to the standard BeanShell output using print().
使用Java运行时执行函数，开始一个第三方的应用程序。
使用print()函数显示一些输出到标准的Beanshell输出上去。
1.11.exit 退出
exit ( )
Conditionally exit the virtual machine.
Call System.exit(0) unless bsh.system.shutdownOnExit == false.
有条件地退出虚拟机。
调用System.exit(0)直到bsh.system.shutdownOnExit==false.
1.12.extend 扩展
This extend( This object )
Return a new object that is a child of the specified object.
Note: this command will likely change along
with a better inheritance mechanism for bsh in a future release.
返回一个新对象，这个对象是特定对象的一个孩子。
注意:这个命令在未来的版本中将因为bsh的一个更好的继承机制而改变。
extend() is like the object() command,
which creates a new bsh scripted object,
except that the namespace of the new object is a child of the parent object.
For example:
extend()类似于object()命令，
这个命令创建了一个新的bsh脚本对象，
除了新对象的名字空间是父对象的一个孩子之外。
例如：
foo=object();
bar=extend(foo);
is equivalent to: 等同于：
foo() {
bar() {
return this;
}
}
foo=foo();
bar=foo.bar();
and also:并且：
oo=object();
ar=object();
ar.namespace.bind( foo.namespace );
The last example above is exactly what the extend() command does.
In each case the bar object inherits variables from foo in the usual way.
上面的最后一个例子完全是说明extend()命令可以做什么。
在每一个例子中，在通常的情形下，bar对象都是从foo中继承。
1.13.frame 框架
Frame | JFrame | JInternalFrame frame( Component component )
Show component in a frame, centered and packed,
handling disposal with the close button.
在一个框架中显示组件，在中间并且打包，
通过关闭按钮来处理。
Display the component, centered and packed, in a Frame, JFrame, or JInternalFrame.
Returns the frame.
If the GUI desktop is running
then a JInternaFrame will be used and automatically added to the desktop.
Otherwise if Swing is available a top level JFrame will be created.
Otherwise a plain AWT Frame will be created.
显示组件，在中间打包，在一个框架中，JFrame,或者JInternalFrame.
返回这个框架。
如果GUI平台正在运行，
那么一个JInternaFrame将被使用并且自动加到平台中。
其他情况下，如果Swing是可用的，一个顶级JFrame将被创建。
同时一个AWT Frame也将被创建。
1.14.getBshPrompt
String getBshPrompt ( ) Get the value to display for the bsh interactive prompt.
This command checks for the variable bsh.prompt and uses it if set.
else returns "bsh % " Remember
that you can override bsh commands simply by defining the method in your namespace.
e.g. the following method displays the current working directory in your prompt:
字符串getBshPrompt()取得值去显示bsh的互动提示。
这个命令检查变量bsh.prompt并且使用它，如果有设置的话。
否则返回"bsh % "记得，
你能通过在你的名字空间中定义函数来简单的覆盖bsh命令。
例如下面的函数显示当前工作目录在你的提示中：
String getBshPrompt() {
return bsh.cwd + " % ";
}

Beanshell翻译24

281696143@qq.com(Ronger) — Fri, 05 Dec 2008 09:03:17 GMT

1.Here are some things that we can always use help with:
这儿是一些事情，我们能够常常这么做：
· Tests for the test suite .
.为测试案例进行测试。
We need more tests! BeanShell relies heavily on its test suite to guarantee
that changes don't break subtle aspects of the language.
Often tests are added for specific bug cases
(Developers: please add a test for any bug you fix!).
But it would be best if tests were generalized to
cover all of the "corner cases" too.
我们需要更多的测试！
Beanshell严重的依赖它的测试案例去保证，
修改一点也不能打破语言的外貌。
通常，测试被追加到特殊的缺陷案例中
(开发者：请为你选定的一些缺陷增加一个测试！)。
但是它会变得更好，如果测试也被推广到覆盖所有的"边角案例"。
· Bug fixes . Check the bugs list at the sourceforge site and dig into the code.
.选定的缺陷.在源文件欺骗站点上检查缺陷列表并且搜集代码。
Some bug fixes are easy,
some are deep.
一些确定的缺陷是容易的，
一些是深入的。
Feel free to contact me ([email=[ft=,4,]pat@pat.net]pat@pat.net[/email]) directly
if you want help getting started on an issue.
很自由的能够直接联系我，
如果你想帮助在一个案例上开始。
· Docs . We can always use articles,
documentation and examples.
.Docs.我们能够通常使用文章，文档和例子。
· Integration and third party tools .
Have you integrated BeanShell into another tool or environment?
Let us know and we'll link to your site.
.综合和第三个工具.
你有讲Beanshell结合到其他的工具或者环境中去吗？
让我们了解并且我们讲链接到你的站点。
· Feedback from the World .
Despite BeanShell's relative popularity you would be amazed at how
little information we have about who is using the tool and how.
If you are using it or you know people using it please let us know!
.从世界上的回馈.
不管Beanshell的相关物多么流行，
你都会震惊在我们知道谁在使用和怎么使用这个工具方面有如此少的信息。
如果你正在使用它或者你知道有人在使用它，请让我们知道。
2.Credit and Acknowledgments 信任和感谢
Many people have contributed substantially to BeanShell over the years.
I will attempt to start crediting those individual here.
Please do not be offended if your name is missing.
This list will grow as I have time to work backwards through my email
and recover names.
很多人已经为Beanshell贡献了很多年。
在这里我将尝试着开始信任这些个人。
如果你的名字没有列入，请不要感到不愉快。
当我通过我的邮箱工作的时候，
这个列表就会增加，
并且覆盖对应的名字。
· Thanks to Daniel Leuck for his long time support and many contributions to the project.
.谢谢Daniel Leuck长时间的支持和对项目的很多贡献。
Me
Finally, I will put in a plug for myself: Pat Niemeyer ([email=[ft=,4,]pat@pat.net]pat@pat.net[/email])
我自己，最后，我将把一个插件给我自己:Pat Niemeyer ([email=[ft=,4,]pat@pat.net]pat@pat.net[/email])
If you like BeanShell check out my book: Learning Java, O'Reilly & Associates, 2nd edition.
如果你喜欢Beanshell，请检验我的书:Learning Java, O'Reilly & Associates, 2nd edition.
Winner of the Best Java Introductory Book .
JavaOne 2001. Learning Java (previously titled Exploring Java)
is available in nine languages world.wide.
It is a comprehensive overview of the Java language
and APIs including a brief introduction to BeanShell as well!
最好的Java介绍书籍的赢家。
JavaOne 2001。学习Java(最初标题为探索Java)
在全球的九种语言中是很有价值的。
它完全的展现了Java语言并且包含了一些对Beanshell有简单介绍的APIs.
3.License and Terms of Use 序列号和使用期限
You may freely use and reproduce this document
in its entirety as long as you preserve this license information
and a pointer to the original web site: http://www.beanshell.org.
You may integrate parts of this document into your own documentation
as long as you provide this same information at an appropriate place in your document.
你能很自由的使用和复制这些文档，
如果你能保存这些序列号信息和指向最初web站点:http://www.beanshell.org.
你能够将这个文档的一部分进入你自己的文档中去，
如果你在你的文档中在合适的位置提供这些同样的信息。
This document is copyright Pat Niemeyer, 2002.
Sections contributed by other authors are copyrighted to those individuals
and subject to the terms of use described above.
这个文档是Pat Niemeyer, 2002的版权。
其他作者做出贡献的章节的版权是那些个人和上面提到的主题的使用期限。
4.BeanShell Commands Documentation Beanshell命令文档
The following documentation was generated automatically by 'BshDoc'
from Javadoc style comments in the BeanShell command script files.
See "BshDoc" for more information.
下面的文档在Beanshell命令脚本文件中从Javadoc样式的注释中
被'BshDoc'自动产生。
请看"BshDoc"了解更多信息。
addClassPath void addClassPath( string | URL )
bg Thread bg( String filename )
bind bind ( bsh .This ths , bsh .NameSpace namespace )
browseClass void browseClass( String | Object | Class )
cat
cat ( String filename )
cat ( URL url )
cat ( InputStream ins )
cat ( Reader reader )
cd void cd ( String pathname )
classBrowser classBrowser ( )
clear clear ( )
cp cp ( String fromFile , String toFile )
debug debug ( )
desktop void desktop()
dirname String dirname ( String pathname )
editor editor ( )
error void error ( item )
eval Object eval ( String expression )
exec exec ( String arg )
exit exit ( )
extend This extend( This object )
frame Frame | JFrame | JInternalFrame frame( Component component )
getBshPrompt String getBshPrompt ( )
getClass Class getClass ( String name )
getClassPath URL [ ] getClassPath ( )
getResource URL getResource ( String path )
getSourceFileInfo getSourceFileInfo ( )
importCommands void importCommands( resource path | package name )
javap void javap( String | Object | Class | ClassIdentifier )
load Object load ( String filename )
makeWorkspace makeWorkspace ( String name )
mv mv ( String fromFile , String toFile )
object This object()
pathToFile File pathToFile ( String filename )
print void print ( arg )
printBanner printBanner ( )
pwd pwd ( )
reloadClasses void reloadClasses( [ package name ] )
rm boolean rm ( String pathname )
run
run ( String filename , Object runArgument )
run ( String filename )
save void save ( Object obj , String filename )
server void server ( int port )
setAccessibility setAccessibility ( boolean b )
setClassPath void setClassPath( URL [] )
setFont Font setFont ( Component comp , int ptsize )
setNameCompletion void setNameCompletion ( boolean bool )
setNameSpace setNameSpace ( ns )
setStrictJava void setStrictJava ( boolean val )
show show ( )
source
Object source ( String filename )
Object source ( URL url )
sourceRelative sourceRelative ( String file )
super This super( String scopename )
unset void unset ( String name )
which which( classIdentifier | string | class )
workspaceEditor workspaceEditor( bsh.Interpreter parent, String name )
addClassPath
void addClassPath( string | URL )
Add the specified directory or JAR file to the class path. e.g.
将特殊的路径或者JAR文件加到类路径中，例如。
addClassPath( "/home/pat/java/classes" );
addClassPath( "/home/pat/java/mystuff.jar" );
addClassPath( new URL("http://myserver/~pat/somebeans.jar") );
See Class Path Management 请看类路径管理器
bg
Thread bg( String filename )
Source a command in its own thread in the caller's namespace
This is like run() except that it runs the command in its own thread.
Returns the Thread object control.
在调用者的名字空间，在它自己的线程中加载一个命令，
这是类似与run()方法一样，
除了它运行命令在它自己的线程上面。
返回线程对象控制。
bind
bind ( bsh .This ths , bsh .NameSpace namespace )
Bind a bsh object into a particular namespace and interpreter
绑定一个bsh对象进入一个特殊名字空间和解释器
browseClass
void browseClass( String | Object | Class )
Open the class browser to view the specified class.
If the argument is a string it is considered to be a class name.
If the argument is an object, the class of the object is used.
If the arg is a class, the class is used.
打开这个类浏览器去查看这个特定的类。
如果参数是一个字符串，它是被认为一个类名。
如果参数是一个对象，对象的类型是被使用的。
如果参数是一个类型，这个类型被使用。
Note: To browse the String class you can't supply a String.
You'd have to do: browseClass( String.class );
注意：浏览这个字符串类，你不能提供一个字符串。
你得这样去做：browseClass( String.class );
cat
cat ( String filename )
cat ( URL url )
cat ( InputStream ins )
cat ( Reader reader )
Print the contents of filename, url, or stream (like Unix cat)
打印文件名,url,或者流(类似于Unix下的猫)的内容
cd
void cd ( String pathname )
Change working directory for dir(), etc. commands (like Unix cd)
为dir()修改工作目录，等等。命令(类似于Unix下面的cd)

Beanshell翻译23

281696143@qq.com(Ronger) — Thu, 04 Dec 2008 02:50:47 GMT

1.BshMethod
You can inspect a BshMethod object to determine its method name and argument types:
name = bshMethod.getName();
Class [] types = bshMethod.getArgumentTypes();
Class returnType = bshMethod.getReturnType();
你能检查一个BshMethod对象去决定它的方法名字和参数类型：
To invoke the BshMethod, call its invoke() method, passing an array of arguments,
an interpreter reference, and a "callstack" reference.
调用BshMethod,调用它的invoke()方法，通过一个参数数组，
一个解释器引用，和一个"callstack"引用。
// invoke the method with arg 通过参数调用方法
bshMethod.invoke( new Object [] { new Integer(1), "blah!" }, this.interpreter, this.callstack );
For the interpreter and callstack references
you can simply pass along the current context's values via
'this.interpreter' and 'this.callstack',as we did above.
The arguments array may be null or empty for no arguments.
对于解释器和堆栈调用引用，
你能简单的顺着当前环境的值连接'this.interpreter'和'this.callstack',
就像我们上面做到的一样。
这个参数数组能为null或者没有参数。
2.Uses 使用
Why would anyone want to do this?
Well, perhaps you are sourcing a script created by a user and want to
automatically begin using methods that they have defined.
Perhaps the user is allowed to define methods to
take control of various aspects of your application.
With the tools we've described in this section you can list
the methods they have defined and invoke them dynamically.
为何一些人想去做这些呢？
也许你正在加载一个被用户创建的脚本，
并且想去自动的使用他们已经定义的方法。
也许用户被允许去定义方法去控制你的应用程序的变量方面。
通过我们在本节描述的工具，
你能列出他们已经定义好的方法并且有力的调用他们。
3.Executable scripts under Unix 在Unix底下执行脚本
You can use BeanShell for writing scripts as you would any other shell under many Unixs:
你能使用Beanshell写脚本，
就像你可以在很多Unixs底下操作其他的一些shell一样：
#!/usr/java/bin/java bsh.Interpreter
print("foo");
However some flavors of Unix are more picky about what they will allow as a shell program.
For those you can use the following hack to make your BeanShell scripts executable.
但是有一些Unix在关于它们允许在一个shell程序中过分讲究，
那样，你能使用下面的黑客去使你的Beanshell脚本执行。
#!/bin/sh
# The following hack allows java to reside anywhere in the PATH.
下面的黑客允许java在路径中的任何地方。
//bin/true; exec java bsh.Interpreter "$0" "$@"
print("foo");
The above trick presumes that /bin/true exists on your system and that //bin is the same as /bin.
The // causes BeanShell to ignore the line.
上面的骗局假定，
/bin/true存在你的系统中，并且//bin是和/bin一样的。
这个//是Beanshell忽视这个线。
The above has been tested on Solaris. It does not seem to work under Cygwin.
上面已经在Solaris中测试过了。
它看起来不能工作在Cygwin上面。
OSX
For OSX the path is a bit different:
对于OSX来说，路径有一点点的不同：
#!/Library/Java/home/bin/java bsh.Interpreter
print("foo");
On OSX /usr/bin/java is itself a shell script, which unfortunately won't work out.of.the.box.
在OSX /usr/bin/java上面是它自己的一个shell脚本，
这个脚本很不幸，不能工作在盒子的外面。
4.BSF Bean Scripting Framework BSF脚本框架
BSF is the Apache "Bean Scripting Framework".
It is generic framework that allows many scripting
languages to be plugged into an application.
It shields the application from knowledge of how to invoke the
scripting languages and their APIs, via adapter "engines".
BSF是Apache的"Bean脚本框架"。
它是普通的框架，
这个框架允许许多的脚本语言插入应用程序。
它从怎样调用脚本语言和它们的APIs来防护应用程序，
这些API是连接适配器的"引擎"。
BeanShell supports the BSF API by providing the necessary adapter.
This means that BeanShell can be used
as a scripting language for any BSF 2.3 capable application
simply by dropping the bsh JAR file into the classpath.
Beanshell通过提供需要的适配器来支持BSF的API.
这意味着，
Beanshell做为一个脚本语言能被用于对于BSF2.3有能力的应用程序，
这个应用程序能简单的将bsh的JAR文件推入类路径中。
Prior to version 2.3, BSF was maintained by IBM.
To get BeanShell to work with older versions of BSF
you must use the older bsh.bsf.1.2x.jar file
which includes the adapter class for the previous ibm packaged BSF API.
最初的版本2.3,BSF是被IBM主张的。
如果想让Beanshell和老版本的BSF一起工作，
你必须使用比较老的bsh.bsf.1.2x.jar文件，
这个文件包含最初的定义了BSF的API的IBM公司开发的适配器类。
You must also explicitly register the BeanShell adapter with older versions of BSF.
Here is an example of how to do that:
你也必须将BSF的比较老的版本清楚的注册在Beanshell适配器上面。
这儿是一个怎么去做那些的例子：
import com.ibm.bsf.*;
// register beanshell with the BSF framework
通过BSF框架注册beanshell
String [] extensions = { "bsh" };
BSFManager.registerScriptingEngine(
"beanshell", "bsh.util.BeanShellBSFEngine", extensions );
See http://jakarta.apache.org/bsf/ and
http://oss.software.ibm.com/developerworks/projects/bsf for more
请看http://jakarta.apache.org/bsf/ and
http://oss.software.ibm.com/developerworks/projects/bsf，
以了解更多
5.information about BSF. 关于BSF的信息
Ant 编译
This section needs to be updated.
I'm not sure what versionf of Ant use the new and which use the old BSF API.
这一节需要去更新。
我不能确定，
哪一种版本的Ant使用这些新特性，
哪些使用旧的BSF的API.
Ant 1.5+ has explicit support for BeanShell as a BSF scripting language.
The BeanShell JAR file includes the necessary BSF adapter.
You must simply specify language="beanshell" in your script tags.
Ant 1.5+已经清楚的支持Beanshell为一个BSF脚本语言。
Beanshell JAR文件包含需要的BSF适配器。
你必须在你的脚本标签中简单的指定语言为"beanshell".
6.Installation 安装
To use BeanShell within Ant you must do two things:
在Ant里面使用Beanshell，
你必须做两件事情：
1. Add the BSF bsf.jar file to ANT_HOME/lib or the classpath.
将BSF bsf.jar文件加入到ANT_HOME/lib或者类路径中。
2. Add the BeanShell bsh.jar file to ANT_HOME/lib or the classpath.
You can then run scripts from a file, or in.line like so:
将Beanshell bsh.jar文件加入到ANT_HOME/lib中或者类路径中。
你能够从一个文件中运行脚本，或者像下面这样：

从一个文件中运行脚本

7.Learning More 学习更多
BeanShell is a simple tool but one with rapidly evolving capabilities.
To learn more about BeanShell
you are highly encouraged to download the source
and build it (using the Ant build file).
Even if you don't consider yourself a developer,
you can learn a lot from the source distribution
by looking at the implementation of the standard BeanShell commands and the test suite.
Beanshell是一个简单工具，同时也是具备快速进化能力的工具。
想更多的了解Beanshell，
你最好下载源文件并且编译它(使用Ant编译文件)。
甚至如果你没有把你自己当做一个开发者，
你能从源文件分类中了解到一些，
通过查看标准Beanshell命令和测试案例的实现。
Almost all of the built.in BeanShell commands are simply scripts stored
in the BeanShell JAR file under the path "bsh/commands".
A good way to familiarize yourself with more of BeanShell
is to take a look at those commands.
Simply unpack bsh/commands/*.bsh from the JAR file.
The BeanShell test suite consists of many BeanShell scripts
that exercise all parts of the language.
几乎所有的built.in Beanshell命令，
是存在Beanshell JAR文件并且在路径"bsh/commands"下面的简单脚本。
简单的从JAR文件下面拆包bsh/commands/*.bsh.
这个Beanshell测试案例是由很多Beanshell脚本组成的，
这个脚本可以行使所有的语言。
In addition to the mailing list and mailing list archives,
an important source of information
is the "recent changes" file supplied with the source distribution
and online at: http://www.beanshell.org/Changes.html.
This file is one of the few documents
that is always up to date with the latest release (smile).
增加邮件列表和邮件列表保存，
一个重要的源文件方面的信息
是通过源文件分类支持的"最近的修改"并且在线信息在http://www.beanshell.org/Changes.html.
这个文件是文档中的一个，
这些文档是常常保存最后的释放。
8.Helping With the Project 通过项目帮助
BeanShell is an open source project which relies on people like you to get things done.
If you are excited about BeanShell there is undoubtedly some way for you to help.
If you are a developer, there is always work (sometimes boring, sometimes not) to be done.
If you are not a developer
you may still be able to help by writing new tests for the test suite,
or working on the documentation, web site, tutorials or examples.
Beanshell是一个开源项目，
这个项目依赖人们比如你去完成一些事情。
如果你是Beanshell的爱好者，
有一些方法对你是有帮助的，
这是不可怀疑的。
如果你是一位开发者，
也经常有一些工作需要去做(一些很无聊，一些不会)。
如果你不是一位开发者，
你仍然能帮助它，通过以下方式：为测试案例写一些新的测试，
工作在文档中，web站点，指南或例子中。

Beanshell翻译22

281696143@qq.com(Ronger) — Tue, 02 Dec 2008 05:35:45 GMT

1.Using JConsole 使用JConsole
The bsh.util.JConsole is a light weight graphical shell console window,
with simple command editing and history capabilities.
BeanShell uses the JConsole for the GUI desktop mode again
in the JRemoteApplet for the remote server mode.
这个bsh.util.JConsole是一个轻量级绘画平台窗口，
通过简单的命令编辑。
Beanshell再一次为了GUI平台模式，
在远程服务器模式下的JRemoteApplet中，使用JConsole。
You can use the JConsole to provide an interactive BeanShell prompt in your own applications.
You are free to use the JConsole for your own purposes outside of BeanShell as well!
It is a fairly generic shell window
easily attached to any kind of streams or through the simple console interface.
你能在你的应用程序中，
使用JConsole去提供一个互动的Beanshell提示。
你能自由的为自己的在Beanshell之外的目的使用JConsole！
它是一个清楚的一般的窗口，很容易放到一些流中或者通过简单的平台接口。
JConsole is a Swing component.
Embed it in your application as you would any other swing component. For example:
JConsole是一个Swing类型的组件。
就像你使用的其他swing组件一样嵌入在你的应用程序中，例如：
JConsole console = new JConsole();
myPanel.add(console);
You can connect an Interpreter to the console by specifying it in the Interpreter constructor,
like so:
你能通过在解释器构造函数中详细列出这些，
连接一个解释器到这个平台上，像这样：
Interpreter interpreter = new Interpreter( console );
new Thread( interpreter ).start(); // start a thread to call the run() method 开始一个进程去调用这个run()方法
Or you can connect the JConsole to the Interpreter directly with Interpreter setConsole().
或者你能通过解释器的setConsole()直接连接JConsole到解释器。
For external use, JConsole can supply a PrintWriter through its getOut() method
and has a full suite of direct print() methods.
其他多余的使用，JConsole能够通过它的getOut()方法提供一个PrintWriter
并且有一套完整的直接print()方法。
Tip: 提示：
When interacting with any Swing component from outside the Java event handling thread,
use the Swing thread safety facilities:
SwingUtilities.invokeNow() and invokeLater().
当从Java事件处理进程的外部和Swing组件进行交互的时候，
使用Swing的安全进程工具：
SwingUtilities.invokeNow()和invokeLater()。
2.ConsoleInterface 平台接口
JConsole implements the bsh.ConsoleInterface interface,
which defines how the Interpreter interacts with a console object.
To the interpreter a console is simply a set of I/O streams with some optimized print methods:
JConsole实现bsh.ConsoleInterface接口，
这个接口定义了解释器怎样和一个平台对象进行交互。
对于解释器来说，一个平台是一个简单的和最优的打印方法一致的输入输出流：
Reader getIn();
PrintStream getOut();
PrintStream getErr();
void println( String s );
void print( String s );
void error( String s );
Any object that implements this interface can be attached to the Interpreter as a GUI console.
一些实现这个接口的对象能被隶属于一个GUI平台上的解释器。
The bsh.util.GUIConsoleInterface extends the ConsoleInterface
and adds methods for printing a string with a color attribute,
supplying wait feedback (the wait cursor) and name completion support.
JConsole implements this interface
and it is used indirectly via BeanShell commands when it is detected.
bsh.util.GUIConsoleInterface继承ConsoleInterface，
并且增加包含颜色属性的打印字符串的方法，
提供等待回馈(等待指针)和名字完成支持。
JConsole实现了这个接口，
并且当它被发现的时候，
它不是直接用于连接Beanshell命令。
3.AWTConsole AWT平台
The bsh.util.AWTConsole is a legacy implementation of the GUI Console using AWT instead of Swing.
This console does work,
but it is not as slick or pretty as the JConsole.
The primary reason it is still here is to
support remote access from generic web browsers using only Java 1.1.
bsh.util.AWTConsole是GUI平台使用AWT替代Swing的遗产实现物。
这个平台也可以工作，
但是它没有JConsole平台那么灵活那么好。
它仍然在这儿的初步的原因是从仅仅使用Java1.1的一般web浏览器中支持远程接受。
4。Reflective Style Access to Scripted Methods 脚本方法反射样式入口
The following examples show how to work with BeanShell methods dynamically from within scripts, using
the equivalent of reflective style access in Java.
This is an advanced topic primarily of interest to developers
who wish to do tight integration of BeanShell scripts with their application environment.
下面的例子表明，怎样从脚本中有力的同Beanshell方法一起工作，
反射样式的等价物在Java中被接受。
这是一个高级话题，最初是希望通过应用程序环境紧密综合Beanshell脚本的开发人员，
比较感兴趣的话题。
eval()
The simplest form of reflective style access to scripts is through the eval() command.
With eval() you can evaluate any text just as if it had appeared in the current scope.
For example:
接受脚本的反射样式的最简单模式是通过eval()命令。
通过eval(),你能够计算一些文本，就像它已经出现在当前的作用域中。
例如：
eval("a=5;");
print( a ); // 5
So, if you know the signature (argument types) of a method you wish to work with
you can simply construct a method call as a string
and evaluate it with eval() as in the following:
于是，如果你知道这个你要一起工作的方法的签名(参数类型)，
你能简单的构造一个类似于调用字符串一样的方法
并且在接下来通过eval()来计算它。
// Declare methods foo() and bar( int, String ) 定义方法foo()和bar(int, String)
foo() { ... }
bar( int arg1, String arg2 ) { ... }
// Invoke a no.args method foo() by its name using eval()
通过名字使用eval()调用一个没有参数的方法foo()
name="foo";
// invoke foo() using eval() 使用eval()调用foo()
eval( name+"()");
// Invoke two arg method bar(arg1,arg2) by name using eval()
通过名字使用eval()调用一个有两个参数的方法bar(arg1,arg2)
name="bar";
arg1=5;
arg2="stringy";
eval( name+"(arg1,arg2)");
You can get the names of all of the methods defined in the current scope
using the 'this.methods' magic reference,
which returns an array of Strings:
你能够取到定义在当前作用域中的所有方法的名字，
使用"this.methods"这个神奇的参考，
这个参考翻译字符串的一个数组：
// Print the methods defined in this namespace
打印定义在这个名字空间中的方法
print( this.methods );
We'll talk about more powerful forms of method lookup in a moment.
我们讲谈论更多有更强功能样式的方法，这些方法片刻之间就可以查找到。
invokeMethod()
You can explicitly invoke a method by name with arguments
through a 'this' type reference using the invokeMethod() method:
通过一个'this'类型引用并且使用invokeMethod()方法，
你能够明确的通过名字和参数调用一个方法：
this.invokeMethod( "bar", new Object [] { new Integer(5), "stringy" } );
Arguments are passed as an array of objects.
Primitive types must be wrapped in their appropriate wrappers.
BeanShell will select among overloaded methods
using the standard Java method resolution rules. (JLS 15.11.2).
参数可以看作一个对象的数组。
原始类型必须包装成与它们像适应的包装类型。
使用标准Java方法规则，
Beanshell将选择加载方法中的一个。
5.Reflective Style Access to Scripted Methods 接受脚本模式的反射模式
The previous section showed how to invoke a method by name when we know the argument types.
Of course, in general we'd like to be able to find out
what methods are defined in the current script or to look up a method by its signature.
前面的章节中提到了，
当我们知道参数类型的时候，
如果通过名字来调用一个方法。
当然，通常我们能够找到在当前的脚本中那些方法已经定义了，
或者通过方法签名找到它。
You can get "handles" to all of the methods defined in a context
using the namespace getMethods() method.
getMethods() returns an array of bsh.BshMethod objects,
which are wrappers for the internally parsed representation of BeanShell scripted methods:
使用名字空间中的getMethods()方法，
你能取得定义在环境中的所有方法的"句柄"。
getMethods()返回bsh.BshMethod对象的一个数组，
bsh.BshMethod对象是为Beanshell脚本方法的内在解析表示法包装的：
foo() { ... }
foo( int a ) { ... }
bar( int arg1, String arg2 ) { ... }
print ( this.namespace.getMethods() );
// Array: [Lbsh.BshMethod;@291aff {
// Bsh Method: bar
// Bsh Method: foo
// Bsh Method: foo
// }
We'll talk about what you can do with a BshMethod in a moment.
我们一会儿将谈到通过BshMethod，你能做些什么。
Alternately, you can use the namespace getMethod() method
to search for a specific method signature.
The method signature is a set of argument types represented by an array of Classes:
交替地，你能使用名字空间的getMethod()方法去搜索一个特定的方法签名。
这个方法签名是一系列的被一个类型数组描绘的参数类型：
name="bar";
signature = new Class [] { Integer.TYPE, String.class };
// Look up a method named bar with arg types int and String
通过参数类型int和String查找一个名字为bar的方法
bshMethod = this.namespace.getMethod( name, signature );
print("Found method: "+bshMethod);
Tip: 提示：
The Java reflection API uses special class values to represent primitive types such as int,
char, an boolean.
These types are static fields in the respective primitive wrapper classes. e.g.
Integer.TYPE, Character.TYPE, Boolean.TYPE.
Java反射API使用特定的类型值去描绘原始类型比如int,
char,boolean.
这些类型是静态的域，在分别的原始包装类型中.例如。
整型，字符型，布尔型。
In the above snippet we located the bar() method by its signature.
If there had been overloaded forms of bar() getMethod()
would have located the most specific one according
to the standard Java method resolution rules (JLS 15.11.2).
The result of the lookup is a bsh.BshMethod object, as before.
在上面的片段中，我们通过它们的签名定位bar()方法。
如果已经加载了bar()方法的样式，
getMethod()将定义最特别的一个协定到标准Java方法解决规则。
查找的结构是bsh.BshMethod对象，就像之前一样。

Beanshell翻译21

281696143@qq.com(Ronger) — Thu, 27 Nov 2008 02:55:44 GMT

1.The bshcommands.xsl stylesheet bshcommands.xml样式表格
The bshcommands.xsl stylesheet
can be used to render the output of bshdoc.bsh
to an indexed HTML page describing BeanShell commands.
bshcommands.xsl样式表格能用于将bshdoc.bsh的输出着色为一个有索引的
通过Beanshell命令描述的HTML页面。
The bshcommands.xsl stylesheet is intended for scripts that serve as BeanShell commands.
These are script files containing one or more overloaded methods
which have the same name as the filename containing them.
这个bshcommands.xsl样式表格是指脚本，该脚本是服务于Beanshell命令的。
这些是包含一个或者更多超过负载方法的脚本文件，这些方法和包含脚本的文件有同样的名字。
The BshDoc script produces a complete description of any BeanShell script file.
However the supplied bshcommands.xsl stylesheet
does not necessarily use all of this information.
Specifically, it does not present all individual method comments.
BshDoc脚本提出一些Beanshell脚本文件的一个完整的描述。
但是被提供的bshcommands.xsl样式表格不需要使用所有的这些信息。
特别的是，它不是赠送的所有个人方法的注释。
Instead it tries to identify the comments pertaining to the command,
based upon the file name.
It (the XSL stylesheet) applies some logic to choose either the single File Comment if it
exists or the Method Comment of the first method matching the filename.
Another stylesheet could (and will) be easily created
for more general BeanShell file documentation.
Please check the web site for updates.
代替它尝试去确定适合命令的注释，
取决于文件名字。
它(XSL样式表格)应用一些逻辑去挑选单独的文件注释或者匹配文件名的第一个方法的方法注释。
另一个样式表格能够很容易的，被更多普通的Beanshell文件文档创建。
请检查web站点来更新。
Method signatures displayed for methods can be overridden for the bshcommands.xsl stylesheet
by explicitly supplying them in special javadoc @method tags within a Method Comment.
For example you might do this
to provide a more verbose description for loosely typed arguments to a BeanShell command.
The bshcommands.xsl stylesheet
will use the @method tag signatures in lieu of autogenerated ones
when they are present.
So you can also use this tag to determine exactly
which methods from a file are listed if you wish. e.g.
显示方法的方法签名，能够被bshcommands.xsl演示覆盖，
通过在方法注释中清楚的提供给他们特别的javadoc的method标签。
例如你能做这些，提供一个有详细注释的松散类型参数给Beanshell命令。
这个bshcommands.xsl样式表格
将使用方法标签在自动产生的场合。
所以你也能使用这些标签去完全的决定，
一个文件中的哪些方法可以被排列出来。例如：
/**
BshDoc for the foo() command.
Explicitly supply the signature to be displayed for the foo() method.
@method foo( int | Integer ) and other text...
foo()命令的BshDoc.清楚的提供标记去显示foo()方法。
@方法foo(基本整型/引用整型)和其他的文本...
*/
foo( arg ) { ... }
Tip: 提示：
BshDoc uses the bsh.Parser API to parse the BeanShell script files
without actually running them.
bshdoc.bsh is not very complex.
Take a look at it to learn how to use the parser API.
BshDoc在没有实际上运行他们的情况下，
使用bsh.Parser接口去解析BeanShell脚本文件。
bshdoc.bsh并不是非常复杂。
看一看它去学习如何使用这个解析接口。
2.The BeanShell Parser Beanshell解析器
This BeanShell parser class bsh.Parser is used internally by the BeanShell Interpreter.
It is responsible for the lexical parsing of the input text,
the application of the grammar structure,
and the building of an internal representation of the BeanShell script file
called an "abstract syntax tree" (AST).
BeanShell解析类bsh.Parser是用在Beanshell解析器内部的。
它是输入文本的词汇解析的责任，
语法结构的应用程序，
并且Beanshell脚本文件的一个中间表示法的构造称作一个"抽象的语法树"(AST).
The Parser just analyzes the language syntax.
It knows only how to parse the structure of the language .
it does not interpret names, or execute methods or commands.
You can use the Parser directly if you have a need to analyze the structure of BeanShell scripts
or Java methods and statements in general.
解析器仅仅解析语言符号。
他仅仅知道如何解析语言的结构。
它不能解释名字，或者执行方法或命令。
你能直接使用解析器，如果你有需要去分析Beanshell脚本或者Java方法和表达式的结构。
3.Validating Scripts With bsh.Parser 通过bsh.Parser验证脚本
You can use the Parser class from the command line
to do basic structural validation of BeanShell files without actually executing them. e.g.
你能从命令行中，在没有完整的执行他们的时候
，使用它去做Beanshell文件的基本结构验证。
java bsh.Parser [ .p ] file [ file ] [ ... ]
The .p option causes some of the abstract syntax to be printed.
这个.p选项使一些抽象标记能被打印。
The parser will detect any syntax errors in the script and print an error.
Note again that names, imports, and string evaluations are analyzed only for syntax .
not content or meaning.
解析器能够推测脚本中的一些符号错误并且打印一个错误。
注意重复的那些名字，导入，并且字符串赋值仅仅能为语法分析。
4.Parsing and Performance 解析和执行
It is useful to have a high level understanding
how BeanShell works with scripts to understand performance issues.
对于Beanshell通过脚本来工作去理解执行事件是有用的。
The first time a script is read or sourced into an interpreter,
BeanShell uses the parser to parse the script internally to an AST.
The AST consists of Java object representations of all of the language structures and objects.
The AST consists of Java classes,
but is not the same as compiled Java code.
When the script is
"executed" BeanShell steps through each element of the AST
and tells it to perform whatever it does
(e.g. a variable assignment, for.loop, etc.).
This execution of the ASTs is generally much faster than the original
parsing of the text of the method.
It is really only limited by the speed of the application calls that it is making,
the speed of the Java reflection API,
and the efficiency of the implementation of the structures in BeanShell.
开始的时候，一个脚本被读入或者进入解释器，
BeanShell使用解析器去解析中间的脚本变成一个AST。
这个AST已经存在的Java对象组成的。
这个AST是由Java类组成的，但是不是等同于经过编译的Java代码。
当脚本通过AST的每一个元素来执行脚本
并且告诉它去执行它要执行的对象(例如一个变量定义，for循环，等等.).
ASTs的执行通常通常比方法的最初解析更快。
When parsing "line by line" through a BeanShell script the ASTs are routinely executed
and then thrown away.
However the case of a BeanShell method declaration is different.
A BeanShell method is parsed only once:
when it is declared in the script.
It is then stored in the namespace like any variable.
Successive invocations of the method execute the ASTs again,
but do not re.parse the original text.
当通过Beanshell脚本"线对线"解析，ASTs是例行公事的执行并且马上抛弃这个脚本。
但是Beanshell方法定义的情况是不同的。
一个Beanshell方法仅仅被解析一次：
当它在脚本中被解析的时候。
它就像一些变量一样保存在名字空间中。
方法的连续调用再次执行ASTs,
但是不会重新编译最初的文本。
This means that successive calls to the same scripted method are as fast as possible .
much faster than re.parsing the script each time.
You can use this to your advantage
when running the same script many times simply
by wrapping your code in the form of a BeanShell scripted method
and executing the method repeatedly,
rather than sourcing the script repeatedly. For example:
这个意味着，对同样脚本方法的连续调用是越快越好。
比每次都重新编译脚本快。
你能使用这些反应你的优势，
当简单的通过包装你的代码在一个Beanshell脚本方法中并且重复的执行这个方法，
运行相同的脚本很多次的时候，
比重复的编译这些脚本要好，例如：
// From Java 从Java中
import bsh.Interpreter;
i=new Interpreter();
// Declare method or source from file 从文件中定义方法或源脚本
i.eval("foo( args ) { ... }");
i.eval("foo(args)"); // repeatedly invoke the method 重复的调用方法
i.eval("foo(args)");
...
In the above example we defined a method called foo() which holds our script.
Then we executed the method repeatedly.
The foo() method was parsed only once:
when its declaration was evaluated.
Subsequent invocations simply execute the AST.
在上面的例子中，我们定义一个称作foo()的方法，foo()支持我们的脚本。
那么我们重复的执行这个方法。
foo()方法仅仅被编译一次：
当它的定义被计算。
后面的祈祷简单的执行AST.
5.Parsing Scripts Procedurally 程序上解析脚本
If you are willing to learn about the BeanShell abstract syntax tree classes
you can use the Parser to parse a BeanShell script into its ASTs like this:
如果你准备去学习Beanshell抽象语法树类，
你能使用解析器去解析一个Beanshell脚本进入它的ASTs,就像下面这样:
in=new FileReader("somefile.bsh");
Parser parser = new Parser(in);
while( !(eof=parser.Line()) ) {
SimpleNode node = parser.popNode();
// Use the node, etc. (See the bsh.BSH* classes) 使用这个节点，等等(请看这个bsh.BSH* 类)
...
}
To learn more about the abstract syntax tree
please download the source distribution and consult the source documentation.
学习抽象的语法树，请下载源分布状态并且考虑源文档。
Tip: 提示：
The BshDoc bshdoc.bsh script uses the parser to extract method signatures
and comments from a BeanShell file.
Check it out for a more realistic example.
这个BshDoc的bshdoc.bsh脚本
使用解析器去摘录方法标记并且对一个Beanshell文件进行注释。
为了一个更加现实的例子把它挑出来。
Note: Many components of the AST classes are not public at this time.
Use setAccessibility(true) to access them.
注意：这个AST类的许多组件在这是不是公开的。
使用setAccessibility(true)来接受他们。

Beanshell翻译20

281696143@qq.com(Ronger) — Mon, 17 Nov 2008 08:43:43 GMT

1.Running Scripts 运行脚本
After deploying the servlet, test it by fetching the default page with your web browser.
在发布了servlet之后，测试它通过取到你的web浏览器的默认网页。
http://localhost/bshservlet/eval
You can use the servlet interactively through the form that it generates,
or, more importantly, through the command line launcher bsh.Remote.
bsh.Remote accepts a URL for a target bsh interpreter
and one or more file names to send to that server, printing the results.
你能它产生的模式使用servlet交互，
或者，更重要的，通过命令行发射台bsh.Remote.
java bsh.Remote
http://localhost/bshservlet/evaltest1.bsh
You can execute remote scripts programmatically using the static method bsh.Remote.eval().
If bsh.Remote can parse the retun value as an integer
it will return it as the exit status to the command line.
你能使用静态方法bsh.Remote.eval()来执行脚本程序。
如果bsh.Remote能将返回值解析为一个整数，
它将让它作为退出状态返回到命令行。
2.The Script Environment 脚本环境
Scripts have access to the servlet environment through two predefined variables:
通过两个事先定义好的变量,脚本可以接受servlet环境：
· bsh.httpServletRequest
· bsh.httpServletResponse
which are the standard servlet request and response objects, respectively.
这两个分别是标准的servlet请求和响应对象。
When set to "raw" output mode via the forms interface or servlet parameter
(described in the next section)
the script is expected to generate the complete response
using the httpServletResponse object.
This means that you can have your script generate HTML
or other output to be consumed by the client.
For example: 例如：
当通过接口类型或者servlet参数设置"没有加工"的输出模式的时候(在下一节中描述)
脚本被期望使用httpServletResponse对象产生完整的响应。
这个意思就是，你能用你的脚本产生HTML或者被客户端使用的其他输出。
// Server side script generates HTML response page 服务器端的脚本产生HTML响应页面
bsh.httpServletResponse.setContentType("text/html");
out = bsh.httpServletResponse.getWriter();
out.println("

Hello World!

");
More generally,
you can use the httpServletRequest to get access to the server environment
such as the servlet session object.
You can also access all of the standard Java tools such as JNDI to fetch EJB homes,etc.
and perform testing or script activities.
更一般的，
你能使用httpServletRequest，类似于servlet的会话对象一样，去接受服务器环境。
你也能接受所有标准的Java工具，类似于JNDI,去抓取EJB容器，等等。
并且执行测试或者脚本活动。
3.BshServlet Parameters BshServlet参数
The following parameters are recognized by BshServlet:
下面的参数被BshServlet重新提出：
Parameter Value 参数值
bsh.script The BeanShell Script Beanshell脚本
bsh.servlet.captureOutErr "true" .
capture standard out and standard error during the evaluation of the script.
Note: this is inherently non.thread safe. All output from the VM will be captured.
bsh.servlet.captureOutErr="true".在脚本的计算中，捕捉标准输出和标准错误。
注意：这些是固有的线程安全的。所有从虚拟机中的输出都会被捕捉。
bsh.servlet.output "raw" .
Do not generate the servlet HTML result page.
Instead rely on the script to generate the complete result using the servlet response.
bsh.servlet.output="raw".不要产生servlet的HTML结果页面。
使用servlet响应来代替脚本去产生完整的结果。
bsh.client "remote" .
set by the bsh.Remote launcher to indicate that results should be raw
and the return value should be encoded for transport back to the client.
bsh.client="remote" .设置bsh.Remote变量暗示了结果将是未被加工的，
并且返回的值将被重新编码传送回客户端。
4.The BeanShell Demo Applet Beanshell的Applet类型的Demo
The Beanshell Applet is primarily for demostration and educational purposes.
It allows you to experiment with Beanshell live,directly in your web browser.
You can try the applet live at the following locations:
Beanshell的Applet最初是为了做示范和教育目的的。
它允许你去和Beanshell一起实验，直接用在你的web浏览器中。
你能允许applet运行在下面的位置中：
5.Swing JConsole Applet Swing做平台的Applet
A Swing enabled JConsole usable with the Java plug.in (or other swing capable browser:
BeanShell Demo with Swing Console (
http://www.beanshell.org/jbshdemo.html)
Swing使平台可以和Java插件一起工作(或者其他的swing的可能的浏览器：
演示Swing平台的Beanshell示范(
http://www.beanshell.org/jbshdemo.html))
6.AWT Console Applet AWT作为平台的Applet
A minimal (not very good) AWT based console that should work in any browser.
BeanShell Demo with simple AWT Console (
http://www.beanshell.org/awtbshdemo.html)
一个最小限度的(不是最好的)AWT基础的平台，这个平台可以运行在所有的浏览器上面。
通过简单AWT平台实现的Beanshell示例(
http://www.beanshell.org/awtbshdemo.html)
7.Signed JConsole Applet 有符号的平台Applet
There are many additional security restrictions on Applets
and this limits what you can do with BeanShell in this mode.
For unrestricted access try the signed version of the applet here.
It requires the Java 1.4 plug.in to function.
在Applet上面有很多额外的权限限制，并且这些会限制，
在这种模式下你能通过Beanshell来做些什么。
在这儿对于没有限制的入口尝试applet有符号的版本。
它需要Java1.4的函数插件。
A Swing enabled JConsole as a signed applet with the Java plug.in
(or other swing capable browser).
The signed applet will allow you unrestricted access to your environment through scripting.
一个使平台变成一个有符号的通过Java内置插件开发的applet的Swing
(或者其他的支持swing的浏览器)。
BeanShell Demo with Swing Console .
Signed Applet (
http://www.beanshell.org/signedjbshdemo.html)
通过Swing平台演示的Beanshell示例
有符号的Applet(
http://www.beanshell.org/signedjbshdemo.html)
8.BeanShell Desktop Beanshell桌面平台
The BeanShell Desktop is a simple GUI environment that provides multiple bsh shell windows(MDI),
a simple text editor, and a simple class browser.
The desktop is mostly implemented by BeanShell scripts,
launched by the desktop() command.
Beanshell桌面平台使一个简单的GUI环境，这个环境提供多个bsh的外形窗口(MDI),
一个简单的文本编辑器，和一个简单的类浏览器。
这个桌面平台主要使通过Beanshell脚本实现的，
通过平台命令发起的。
9。Shell Windows 外壳窗口
The bsh console windows provide simple command line editing, history, cut & paste,
and variable and class name completion.
bsh平台窗口提供简单的命令行编辑，历史，剪切和粘贴，
和变量和类名定义。
10。Editor Windows 编辑窗口
11.The Class Browser 类浏览器
BshDoc . Javadoc Style Documentation BshDoc.JavaDoc样式的文档
BshDoc requires JDK1.4 and BeanShell 1.2b6 or greater to run BshDoc需要JDK1.4和Beanshell1.2b6或者以上版本运行。
BshDoc is a BeanShell script that supports javadoc style documentation of BeanShell scripts.
BshDoc parses one or more BeanShell script files for method information
and javadoc style formal comments.
BshDoc是一个Beanshell脚本，支持Beanshell脚本的javadoc样式的文档。
BshDoc为函数解析一个或更多Beanshell脚本文件，并且解析javadoc样式的注释。
Its output is an XML description of the files,
containing all of the method signature and comment information.
An XSL stylesheet, bshcommands.xsl, supplied with the user manual source,
can be used to render the XML
to a nicely indexed HTML document describing BeanShell commands.
它的输出是一个文件的XML描述，
包含所有函数和注释信息。
一个XSL样式表格，bshcommands.xsl，提供用户手工资源，
能够用于将一个XML着色为一个精细的有索引的通过Beanshell命令描述的HTML文档。
The bshdoc.bsh script is currently distributed with the source distribution.
An example of the styled output of
this command is the "BeanShell Commands Documentation" section of this user manual.
That section is automatically generated as part of the build process
by running bshdoc.bsh on bsh/commands/*.bsh.
See the source distribution Ant build file for an example of how to do this
and the user manual Ant build file for an
example of using a stylesheet to build your documents.
bshdoc.bsh脚本现在是被源来划分的。
这个命令的样式输出的一个例子是这个用户手工的"Beanshell命令文档"章节。
这个章节是通过运行bshdoc.bsh,作为构造过程的一部分自动产生的。
请看源文件分类，Ant构造文件为一个如何去运行的例子，
用户手工Ant构造文件使用一个样式表格去构造你的文档的一个例子。
12.BshDoc Comments BshDoc注释
BshDoc comments look just like JavaDoc comments
and may include HTML markup and javadoc style @tags.
If you wish to use the associates XSL stylesheet,
you should use well formed XHTML for you documentation.
(Always close tags, etc.). e.g.
BshDoc注释看起来就像JavaDoc注释，并且能包含HTML标记和Javadoc式样标签。
如果你希望使用相关的XSL样式表格，
你最好在你的文档中使用XHTML。(关闭标签，等等..).例如.
/**
This is a javadoc style comment. 这是一个javadoc样式注释。

 
Here is some HTML markup. 这儿是一些HTML标记 
 
Here is some more. 这儿是一些更多内容

@author Pat Niemeyer
*/
Javadoc style @tags are parsed by bshdoc for inclusion in the XML output.
Currently they are only recognized at the start of a line and they terminate the comment.
(i.e. they must come at the end of the comment).
javadoc样式标签是被包含在XML输出中解析出来的。
现在，他们仅仅在开始的一行中被认出并且他们终止注释.(他们会在注释结束的时候到来)。
BshDoc identifies two kinds of Javadoc style comments: File Comments and Method Comments.
Method comments are comments
that appear immediately before a method declaration with no statements intervening.
File comments are comments that appear as the first statement of a script
and are not method comments.
If a comment appears as the first statement in a script
and is also immediately followed by a method declaration it
is considered a method comment.
BshDoc识别两种类型的Javadoc样式注释：文件注释和方法注释。
方法注释是这样一种注释，在一个方法定义之前并且没有表达式干预的时候，马上出现的注释。
文件注释是这样一种注释，出现在一个脚本的第一个表达式并且不是方法注释。
如果一个注释出现在一个脚本中的第一个声明中，
并且也是跟随在一个方法定义之后，
它被认为是一个方法注释。
13.BshDoc XML Output BshDoc的XML输出
To use BshDoc, run the bshdoc.bsh script on one or more BeanShell script files:
java bsh.Interpreter bshdoc.bsh myfile.bsh [ myfile2.bsh ] [ ... ] > output.xml
The output goes to standard out. It looks something like this:
使用BshDoc,运行bshdoc.bsh脚本在一个或者更多的Beanshell脚本文件上面：
java bsh.Interpreter bshdoc.bsh myfile.bsh [ myfile2.bsh ] [ ... ] > output.xml
这个输出到标准的输出上去。它看起来像这些：
14.BshDoc . Javadoc Style Documentation BshDoc-Javadoc样式文档

下面的文件是自动通过bshdoc.bsh脚本产生的..

foo

doFoo
doFoo ( int x )

<![CDATA[ doFoo() method comment. ]]>

<![CDATA[ foo file comment. ]]>

Beanshell翻译19

281696143@qq.com(Ronger) — Wed, 12 Nov 2008 07:21:28 GMT

1.Remote Server Mode 远程服务器模式
Remote server mode lets you access a BeanShell Interpreter inside of a remote VM.
With remote server mode activated you can literally telnet into the running application
and type commands at the BeanShell shell prompt.
Or, even better, you can use any web browser to bring up a remote GUI console.
远程服务器模式让你接受一个远程虚拟机的解释器进入。
通过运行远程服务器模式，你能慢慢的进入正在运行的应用程序和Beanshell的命令框中。
或者，更好的，你能使用一些web浏览器进入一个远程GUI平台。
Warning: 警告：
When activated remote server mode can provide unrestricted access to all parts of your
application and the host server.
This mode should not be used in production environments
or anywhere that server security is an issue.
当运行远程服务器模式对你的应用程序的所有部分和主机服务器，能提供没有限制的访问。
这个模式将不能用在生产环境中，也不能用在要考虑权限的其他地方。
To enable remote access simply issue the BeanShell server() command,
specifying a base port number:
使远程可以存取将简单的发布Beanshell的服务器命令，
列一个基础端口号码：
server(1234);
// Httpd started on port: 1234 Httpd在端口1234开始
// Sessiond started on port: 1235 Sessiond在端口1235开始
At this point BeanShell will run two services:
a tiny HTTP server on the port you specified
and the BeanShell telnet session server on the next port (the port you specified + 1).
在这里，Beanshell将运行两个服务：
在你列出的端口中的一个小的HTTP服务器和在下一个端口上的Beanshell的远程会议服务器
(你定义的端口加上1).
2.Web Browser Access web浏览器接受
After starting the server you can connect your web browser to the port you specified.
BeanShell will respond by sending an HTML page offering you a choice of the Swing based JConsole
or the older AWTConsole.
You may choose whichever is appropriate for your web browser.
在打开服务器之后，你能连接你的web浏览器到你定义的端口上面。
Beanshell将响应给你，通过发送一个HTML网页提供给你Swing基础平台或者老的AWT平台的一个选择。
你可以选择哪一个是适合你的web浏览器。
You can skip this decision page by hitting one of the following URLs directly:
你能通过直接点击下面的URL中的一个，跳过这个选择界面。

http://:/remote/jconsole.htmlSwing based JConsole page 基于Swing的平台

http://:/remote/awtconsole.htmlMinmal (old) AWT based Console page 基于AWT的平台页面
The httpd server then serves the remote console applet.
When it starts you will have a BeanShell session that looks like the regular console,
but is connected to the remote BeanShell VM.
这个Httpd类型服务器于是保留远程平台的applet.
当它启动的时候，你将有一个Beanshell会话，这个会话看起来像规则在平台，
但是是和远程的Beanshell虚拟机连接的。
You can open as many sessions into that VM as you like in this way,
but note that unlike the BeanShell desktop environment .
All remote sessions share the same global scope.
You are effectively working in the
same interpreter instance for all connections.
This is intended as a feature,
as the primary usefulness of this mode is for debugging.
You can set variables and access components across many sessions.
你能打开很多的会话进入虚拟机，
但是注意不能是beanshell的桌面环境。
所有的远程会话共享相同的全局作用域。
对于所有的连接来说，你都是有效的工作在相同的解释器实例上面。
这些被扩展为一个特征，
这种模式的最初使用是为了调试。
你能通过很多会话设置变量和入口组件。
Example 例子
Let's look at a quick example of
how you might start a remote session from within your application:
让我们看一个快速例子，通过你的应用程序，如何开始一个远程会话：
// Java code Java模式
import bsh.Interpreter;
i = new Interpreter();
i.set( "myapp", this ); // Provide a reference to your app 提供一个引用给你的应用程序
i.set( "portnum", 1234 );
i.eval("setAccessibility(true)"); // turn off access restrictions 关掉入口限制
i.eval("server(portnum)");
Here we have set up the interpreter instance just as
we would to do any other kind of scripting .
passing in Java objects using set().
In this case we passed a general reference to our application using 'this', as well.
We have turned on accessibility so
that we can access private and protected members of our classes
(useful for debugging).
Finally we start the server on the desired port.
这儿我们已经构造解释器实例就像我们去处理其他类型的脚本一样。
使用set()传递Java对象。
在这种情况下，我们使用'this'对象来传递一个普通引用到我们的应用程序中。
我们已经可以打开入口，所以我们能接受我们的类中的私有的和受保护成员。
最后我们可以在这个端口上打开服务器。
3.Telnet Access 远程登录入口
We mentioned earlier that BeanShell starts its telnet session server
on the port next to the HTTP port.
You can use any telnet client to access a BeanShell command line directly,
in text only.mode, without the use of a web browser.
我们前面提到，Beanshell在HTTP端口的下一个端口上，
开始它的远程会话服务器。
你能使用一些远程登录客户端去直接访问一个Beanshell命令，
使用文本模式，没有web浏览器的使用。
telnet
Note that this command line is not very friendly.
In particular it does not respond to gratuitous newlines with a new prompt
(as the text only Interpreter command line does).
注意这个命令行不识十分友好。
在特殊的情况下，它不会通过一个新的提示返回一个新行(就像只有解释器命令行的文本一样)。
At the time of this writing there is no explicit way to close a session.
BeanShell will simply detect the end of streams.
此时，写那些对于关闭一个会话来说不是清楚的方法。
Beanshell将简单的察觉到流的结束。
4.BshServlet and Servlet Mode Scripting BshServlet和Servlet模式脚本
BshServlet is a simple servlet
that can be used to evaluate BeanShell scripts inside of an application server
or servlet container.
BshServlet accepts BeanShell scripts via the POST method,
evaluates them capturing output (optionally including standard out and standard error)
and returns the results.
BshServlet是一个简单的servlet,能在应用程序或者servlet容器中，计算Beanshell脚本。
BshServlet通过POST方法来接受Beanshell脚本，
计算他们捕获输出(有选择的包含标准输出和标准错误)并且返回结果。
BshServlet has a simple form based interface for interactive experimentation
(analogous to the remote server mode).
But more generally you can send standalone BeanShell scripts from the command line
to the BshServlet for evaluation using the bsh.Remote launcher.
bsh.Remote complements bsh.Interpreter and bsh.Console as a launch point for BeanShell.
BshServlet有一个简单的模式，基于接口的交互式体验(在远程服务器模式中也相似).
但是更通常的做法是，你能从命令行发送单纯的Beanshell脚本，
使用bsh.Remote发射台，到BshSerlet中去计算。
bsh.Remote实现了bsh.Interpreter和bsh.Console，作为Beanshell的一个发射点。
Tip: 提示
You may find BshServlet useful for writing unit tests
that must run inside an application server environment.
In this mode BshServlet can be used in the same way as
or in combination with the Jakarta project's cactus.
你会发现BshServlet在写单元测试的时候很有用，
当然必须在一个应用程序服务器环境中运行。
在这个模式中，BshServlet能以同样的方式使用，
或者和Jakarta项目联合使用。
5.Deploying BshServlet 发布BshServlet
To test drive BshServlet you can grab one of the following sample application WAR files here:
检验BshServlet的运行，你能抓住下面的样本应用程序WAR文件中的一个：
·
http://www.beanshell.org/bshservlet.war
·
http://www.beanshell.org/bshservlet.wbsh.war
Rename this file to "bshservlet.war" for use. 方便使用，重命名这个文件为"bshservlet.war"
Tip: 提示：
A WAR file is a Web Application Archive. It is a JAR file containing HTML, images, servlets,
and configuration files comprising a complete web application.
Web applications can usually be deployed to a servlet container
by simply dropping the WAR file into a special directory.
一个WAR文件是一个web应用程序的存档。它是一个JAR文件，包含HTML,图片，servlets,
和由一个完全的web应用程序组成的配置文件。
通过简单的把WAR推到一个特殊的目录下，
web应用程序通常能部署到一个servlet容器中。
The first file, bshservlet.war,
assumes that BeanShell has been installed in your application server's classpath.
It includes only the web.xml file necessary to deploy an instance of the test servlet
and an index.html README file.
第一个文件，bshservlet.war,
假设Beanshell已经安装在你的应用程序服务器的类路径下。
需要发布测试servlet的实例，它仅仅需要web.xml文件和index.html说明文件。
Note: 注意：
To install BeanShell in the Tomcat server classpath place the bsh.jar file in common/lib.
To use BeanShell in Weblogic you must upgrade its version of the package.
See Upgrading BeanShell in Weblogic (
http://www.beanshell.org/weblogic.html).
在Tomcat服务器类路径中安装Beanshell要将bsh.jar文件放在common/lib文件夹底下。
在Weblogic中使用Beanshell，你必须升级包的级别。
请看在Weblogic中升级Beanshell(
http://www.beanshell.org/weblogic.html).
The second WAR, bshservlet.wbsh.war,
includes a copy of the BeanShell application bsh.jar inside the WAR's lib directory.
This WAR includes everything you need to just drop the WAR into an application server.
第二个WAR，bshservlet.wbsh.war,
包括Beanshell应用程序bsh.jar进入WAR的lib目录的一个拷贝。
这个WAR包括所有的内容，你需要去将WAR移除进入一个应用程序服务器的内容。
Note: 提示：
Using bshservlet.wbsh.war will still *not* work in Weblogic 6.x
unless you upgrade Weblogic's internal version of BeanShell first.
See Upgrading BeanShell in Weblogic. (
http://www.beanshell.org/weblogic.html).
使用bshservlet.wbsh.war将不能运行在Weblogic6.x上面，
直到你首先升级Weblogic的Beanshell的内置版本。
请看在Weblogic中升级Beanshell. (
http://www.beanshell.org/weblogic.html).
To use the servlet for testing your own applications
you will probably want to deploy an instance of the test servlet in your WAR file.
This will allow the test servlet to to share a classloader with your webapp so
that you can test things like application classes and EJB local homes.
Since the servlet is included in the standard BeanShell distribution,
all that is necessary to do this is to include bsh.jar
and add an entry to your wegapp's web.xml file.
Here is an example:
使用servlet来测试你自己的应用程序，
你将可能想去发布测试servlet的一个实例在你的WAR文件中。
这个将允许这个测试的servlet和你的web应用共享一个类加载器，
所以你能像应用程序类和EJB容器一样测试。
由于servlet是被包含在标准的Beanshell的分类中，
需要做的是去包含bsh.jar和增加一个入口到你的web应用的web.xml文件中。
这儿是一个例子：

PUBLIC ".//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"
http://java.sun.com/dtd/web.app_2_3.dtd">

bshservlet
bsh.servlet.BshServlet

bshservlet
/eval

The above example deploys an instance of BshServlet under the name "/eval".
The full path to the servlet will then depend on the name given to the webapp WAR file.
For example if the above appears in a WAR file named "myapp.war" then the path would be:
http://localhost/myapp/eval
上面的例子在名字"/eval"的下面发布了BshServlet的一个实例。
servlet的全路径在那时将依靠被发送给web应用WAR文件的名字。
例如，如果上面的例子显示在一个名字为"myapp.war"的WAR文件中，那么这个路径将是：
http://localhost/myapp/eval

Beanshell翻译18

281696143@qq.com(Ronger) — Mon, 10 Nov 2008 07:13:27 GMT

1.Multiple Interpreters vs. Multi.threading 多线程Interpreters VS.多线程 threading
A common design question is whether to use a single BeanShell interpreter
or multiple interpreter instances in your application.
一个通常的设计问题是，是否去使用一个单独的Beanshell解释器或者
在你的应用程序中使用多个解释器实例。
The Interpreter class is, in general, thread safe and allows you to work with threads,
within the normal bounds of the Java language.
解释类，通常是，线程安全的并且允许你和线程一起工作，
通过Java语言的通常的边界。
BeanShell does not change the normal application level threading issues of multiple
threads from accessing the same variables:
Beanshell不能改变通常应用程序的多线程的线程事务的级别，当接受相同的变量时：
you still have to synchronize access using some mechanism if necessary.
However it is legal to perform multiple simultaneous evaluations.
You can also write multi.threaded scripts within the language,
as we discussed briefly in "Scripting Interfaces".
当需要的时候，你仍然要去使用一些机制去同步接受。
但是处理多个相似的计算是合法的。
你也可以使用语言写多线程的脚本，
就像我们在"脚本接口"中短暂的讨论的一样。
Since working with multiple threads introduces issues of synchronization
and application structure,
you may wish to simply create multiple Interpreter instances.
BeanShell Interpreter instances were designed to be very light weight.
Construction time is usually negligible and in simple tests,
we have found that it is possible to maintain hundreds (or even thousands) of instances.
当在多线程的工作模式下提出同步的事件，和在应用程序的结构下，
你会希望简单的创建多线程的解释器实例。
Beanshell解释器实例是被设计为非常轻量级的。
构造时间在简单的测试中，通常是被忽略的，
我们已经发现，有可能去维持成百个（甚至上千个）实例。
There are other options in.between options as well.
It is possible to retrieve BeanShell scripted objects from the interpreter
and "re.bind" them again to the interpreter.
We'll talk about that in the next section.
You can also get and set the root level bsh.NameSpace object for the entire Interpreter.
The NameSpace is roughly equivalent to a BeanShell method context.
Each method context has an associated NameSpace object.
在所有的选择中有一些其他的选择。
有可能重新从解释器中重新得到Beanshell脚本对象并且将他们重新绑定到解释器中。
我们将在下一个章节中讨论到。
我们也能从整个的解释器中取得和设置根级别的bsh.NameSpace对象。
对于一个Beanshell函数环境来说名字空间是不可能相等的。
每一个函数环境有一个相联系的名字对象。
Tip: 提示：
You can clear all variables, methods, and imports from a scope using the clear() command.
你可以清除所有的变量，方法，并且从一个包含clear()命令的作用域中导入。
Note: at the time of this writing the synchronized language keyword is not implemented.
This will be corrected in an upcoming release.
注意：本次书面同步语言关键字是没有得到执行。
在即将来临的释放中，这些将都是正确的。
See also "The BeanShell Parser" for more about performance issues.
再看"Beanshell解析"获得更多的执行信息。
2.Serializing Interpreters and Scripted Objects 序列化解释器和脚本对象
The BeanShell Interpreter is serializable,
assuming of course that all objects referenced by variables in the global scope
are also serializable.
So you can save the entire static state of the interpreter by serializing it and storing it.
Note that serializing the Intepreter does not "freeze" execution of BeanShell scripts
in any sense other than saving the current state of the variables.
In general if you serialize an Interpreter while it is
executing code the results will be undetermined.
De.serializing an interpreter does not automatically restart method executions;
it simply restores state.
Beanshell是序列化的，假定所有在全局作用域的对象也是序列化的。
所以你能通过序列化来保存解释器的完整的静态状态。
注意，序列化解释器对象在一定程度上，比存储变量的当前状态，更加不会冰冻执行Beanshell脚本。
通常当它是执行代码时候，如果你序列化一个解释器，结果将变成不确定的。
完全的序列化一个解释器不能自动在重新启动函数执行;
它可以简单的存储状态。
Note: 注意：
There is serious Java bug that affects BeanShell serializability in Java versions prior to 1.3.
When using these versions of Java the primitive type class identifiers cannot be de.serialized.
See the FAQ for a workaround.
It is also possible to serialize individual BeanShell scripted objects
('this' type references and interfaces to scripts).
The same rules apply.
One thing to note is that by default serializing a scripted object context
will also serialize all of that object's parent contexts up to the global scope .
effectively serializing the whole interpreter.
有一个严重的Java缺陷，影响Beanshell在Java1.3之前的版本Beanshell的序列化。
当使用Java的这些版本，这个最初的类型标示不能被完全的序列化。
看工作台中的FAQ.
也可以序列化个人的Beanshell脚本对象(脚本的'this'类型引用和接口)。
相同的规则应用。
有一个要注意的事情是，默认的情况下，序列化一个脚本对象
也将序列化全局作用域的该对象的父对象。
有效的序列化整个解释器。
To detach a scripted object from its parent namespace
you can use the namespace prune() method:
从父亲的名字空间中，分离一个脚本对象，
你能使用名字空间prune()函数：
// From BeanShell 从Beanshell中执行。
object.namespace.prune();
// From Java 从Java中执行
object.getNameSpace().prune();
To bind a BeanShell scripted object back into a particular method scope
you can use the bind() command:
绑定一个Beanshell脚本对象到一个特定的函数作用域中，
你能使用bind()函数：
// From BeanShell 从Beanshell中实现
bind( object, this.namespace );
// From Java 从Java中实现
bsh.This.bind( object, namespace, interpreter );
The bind() operation requires not only the namespace (method scope) into
which to bind the object,
but an interpreter reference as well.
The interpreter reference is the "declaring interpreter" of the object
and is used for cases where there is no active interpreter .
e.g. where an external method call from compiled Java enters the object.
bind()操作不仅需要名字空间(函数作用域)到绑定对象的哪一个，
而是一个解释器引用。
解释器引用是对象的定义解释器，并且用于没有现行的解释器的情况。
例如，一个第三方的函数调用编译好的Java的地方进入这个对象。
The BeanShell save() command which serializes objects recognize
when you are trying to save a BeanShell scripted object (a bsh.This reference) type
and automatically prune()s it from the parent namespace,
so that saving the object doesn't drag along the whole interpreter along for the ride.
Similarly, load() binds the object to the current scope.
当你尝试着存储一个Beanshell对象类型并且自动的从父亲名字空间中剪除的时候，
调用Beanshell的可以序列化对象的save命令，
于是存储对象不会向前拖累整个的解释器，而只是乘着它。
相似的是，load()绑定对象到当前的作用域中。