http://www.ibm.com/developerworks/cn/opensource/os-swt/index.html

Java 世界的人似乎一直都对 Java 的桌面应用程序十分不满，从 AWT 到 SWING，从默认的 Theme到第三方的产品，不是太难看（AWT）就是在某些平台有 BUG（SWING，Quaqua--一个Windows平台下的仿Mac的主题包），再不就是对中文支持不好（某些第三方 LookAndFeel）。于是，如果想要获得和本机平台一致的用户界面和比较稳定的性能，SWT就成了一个不可忽视的选择。SWT 是一个独立于平台的，可以脱离 Eclipse 框架单独使用的图形组件，用JNI技术提供与本机系统同样的用户界面组件的观感，较好的运行效率，稳定的平台表现。

当然，虽然这个专题名叫"全接触"，但毕竟不可能面面俱到，在一篇文章中兼收并蓄SWT的全部内容也不现实。但不管怎么说，我都将尽力展示SWT的使用细节，希望能为那些对SWT感兴趣的人提供一些帮助。

1．SWT简介

SWT-"Standard Widget Toolkit"，它是一个Java平台下开放源码的Native GUI组件库，也是Eclipse平台的UI组件之一。从功能上来说，SWT与AWT/SWING是基本等价的。SWT以方便有效的方式提供了便携式的（即Write Once，Run Away）带有本地操作系统观感的UI组件：

由于widget系统的固有复杂性以及平台之间微妙的差异，即使在理想情况下，能够达到工业标准的跨平台的widget类库也是很难编写和维护的。最早的AWT组件现在被认为是样貌丑陋的，而且存在很多问题；SWING组件虽然也是缺点多多，但是随着JDK版本的不断升高，它仍在不断进行着改进。我认为，SWT在功能上与AWT/SWING不相伯仲，但是组件更为丰富，平台表现稳定，BUG也相对较少。如果你的应用程序真的需要在多个平台上运行，需要更为美观的界面，又不那么依赖于其他基于AWT/SWING的图形库，那么SWT或许是一个比AWT/SWING更好的选择。

回页首

2． SWT起步

2.1 SWT的HelloWorld

一如介绍其他程序的起始，我们都需要来一个HelloWorld来帮助我们入门，SWT的HelloWorld如下：

import org.eclipse.swt.widgets.*;
public class HelloWorld 
{
    public static void main(String[] args) 
    {
        Display display = new Display();
		Shell shell = new Shell(display);
		shell.setText("Hello World");
		shell.setSize(200, 100);
		shell.open();
		while (!shell.isDisposed()) 
{
		    if (!display.readAndDispatch()) 
			display.sleep ();
		}
		display.dispose ();
   	 }
}

运行这个程序就会得到如下结果：

下面我讲逐一介绍这个程序所包含的内容。

• Display
  这是一个顶层容器组件，类似于Container或Component的功能，它主要负责与底层的窗口系统之间的连接。在具体含义上，它代表"屏幕"。
  一个Display可以包含多个Shell（也是容器组件，下面会介绍到）。
  通常情况下，一个应用程序只含一个Display，即Display通常是一个单例组件（Singleton）。
• Shell
  它表示位于"屏幕"上面的"窗口"，是Composite组件和Control组件构成的组件树的根。
  在我们的HelloWorld程序中，我们可以设置标题（setText()），设置大小（setSize()），然后通过open()方法来显示这个窗口。怎么样，感觉很像JFrame吧？其实功能上差不多。
• Composite
  可以包含其它Composite和Control的容器
• Control
  这是一个重量级（HeavyWeight）系统对象。像按钮（Button），标签（Label），表格，工具栏和树形结构这些组件都是Control的子类，Conposite和Shell也不例外。

2.1.1 消息循环

我们可以看到，上面的代码中有这样的语句：

while (!shell.isDisposed()) 
{
    if (!display.readAndDispatch()) 
		display.sleep ();
}

如果你像我一样是由Java语言起步的，那么你会对这个消息循环的代码感到比较陌生，毕竟在SWING中我们主要利用事件驱动模型而不这样利用类似于Windows程序设计中的消息循环的方法来处理事件。但是这段代码意义还算简单明了，就是反复的读取和分派（dispatch）事件，并在没有事件的时候把控制权还给CPU。

2.1.2 资源的释放

最后一条语句是display.dispose ();，这告诉我们操作系统的资源是由程序员显示释放的。资源的释放遵循以下两条规则：

1. 如果你创建了某个资源，那么你就有责任释放它。

2. 释放父组件资源的同时也释放了其子组件的资源。

2.1.3 标准构造函数

窗口组件被创建的时候必须伴随一个他的上层组件，例如，我要建立一个按钮就可以采用如下方法：Button button = new Button(shell, SWT.PUSH);

其中，Button的父组件Shell是必不可少的，这样就限定了我们生成组件的顺序。

第二个参数被称为"Style Bit"，表示了这个组件的显示特性，每种特性占一位，如下例所示：

Text test=new Text(group, SWT.SINGLE|SWT.BORDER);

这条代码生成了一个单一的，有边框的文本框。这显然又与习惯了JavaBeans模型，总是用setXXX()来设置属性的我们不太适应--毕竟是IBM的东西啊，秉承了其产品不易上手的传统。

2.1.4 错误与异常

SWTError指的是不能修复的错误，以及一些操作系统错误。

SWTException指的是一些可恢复的错误以及无效的线程访问之类的错误。

IllegalArgumentException指可修复的错误或参数为null之类的错误。

2.1.5 Item

Item类是一个轻量级的系统对象，总是作为基本的单位元素与其他一些类配合使用。比如Tree中的元素即为TreeItem，Table的单位元素则是TableItem，而MenuItem就是Menu的基本单位元素了。

2.1.6 SWT的类阶层体系结构

最后让我们来整体认识一下整个SWT窗口组件的层次结构，如下所示：以上的部分给我们以整体的认识，即一个SWT引用程序应该怎么创建，其基本的运行规则和相关类的体系结构。我想我就不用再对每一个控件的API或使用方面费唇舌了，熟悉这些东西是体力劳动，而网上有很多例子可供参考。下面一节我将详细介绍有关SWT布局的相关知识。

2.2 SWT的布局管理

相信对于组件的布局（Layout）大家都不会太陌生，它的存在就是提供给我们一种可以在组件位置移动或更改大小时重新绘制组件的机制。设置组件的布局我们可以采用Composite.setLayout()方法来实现。

每种布局都有其相应的数据（Layout Data），可以通过Control.setLayoutData()方法来进行关联。以下是一些布局类及其显示效果:

• FillLayout:让所有子组件等大小的"填满"整个面板空间。
  FillLayout是最简单的一个布局类，它将所有窗口组件放置到一行或一列中，并强制他们的大小也相等。FillLayout不能外覆（wrap），也不能定制边框和距离。很显然这样的限制让这个布局类最适合作类似于计算器面板的布局，或者为Taskbar和Toolbar上面的按钮作布局使用。
  
• RowLayout：类似于AWT中的FlowLayout，让所有组件按行排列，一行排不下就放到下一行。
  RowLayout比FillLayout用得更广泛一些，原因很简单，就是RowLayout支持FillLayout所部支持的功能，例如能够外覆，能够修改边框和间距等等。另外，每一个位于RowLayout中的窗口组件都可以通过设定一个RowData类来指定其在RowLayout中的宽度和高度。
  
• GridLayout： GridLayout是3个标准布局类中最有用的，但同时也是最复杂的--没办法，强大的功能必定伴随着一定程度的复杂性。通过GridLayout，一个Composite的子窗口组件被放置在一个网格（Grid）之中。GridLayout有很多配置字段，并且和RowLayout一样，每一个布局于其中的窗口组件都可以有一个与之相关联的布局数据类，称为GridData。GridLayout的强大功能是通过对于每一个窗口组件的GridData的灵活控制来实现的。
  鉴于GridLayout的复杂性（原本我就怀疑它根本就不是为手工书写代码而设计的），我并不建议各位直接手动书写GridData，最好借助可视化的工具（如VI）来帮助我们完成用GridLayout进行的界面设计。这样我们只需要书写少量控制代码，就可以获得复杂的界面布局了。
  
• FormLayout:如图所示
  
• StackLayout:几乎完全等同于CardLayout的功能。
  

在SWT中，位置和大小的变化并非自动发生的。应用程序既可以在Composite子类的构造函数中指定初始位置和大小，也可以在一个改变窗口大小的监听器中用布局类来定位和改变Composite子类的大小。

下面的一幅图包含了我们将要讨论的有关布局的大部分细节。一个Composite类的可显示区域分为三个部分，分别是Location，clientArea和trim。Composite的大小就是clientArea和trim的区域之和。一个布局类（Layout）的主要功能就是管理Composite子组件的大小和位置。通过布局类，我们可以管理子组件之间的距离-即间距（Spaceing），子组件与布局边缘之间的距离-即边距（margin）。布局的大小同时也是Composite的clientArea的大小。

至此，关于SWT的基础部分就告一段落，希望能够给大家以一个对于SWT的总体认识。下面的部分将主要介绍SWT的弱项-绘图。JGraph的一个作者就表达了对SWT/JFace/Draw2D的不满，认为SWT在执行效率上并没有什么改善，而且缺乏一些有用的API实现。话虽如此，但SWT的基本绘图功能还是不错的，如果有足够的时间和耐心的话还是可以绘出想要的图形的。下面就让我们看看SWT如何绘制2D和3D图形。

回页首

3. 用SWT绘制2D图形

用SWT绘图通常由两种方法，一种是借助Graphics Context，另一种是利用Draw2D。然而Draw2D是一个基于SWT Composite的轻量级组件，于是在效率上，它无法体现出SWT的Native Code的速度优势。故其虽然强大，但仅适用于绘图工作不是系统瓶颈的应用程序。所以我在这里只介绍第一种方法。

3.1 Graphics Context

我们可以在任何实现了org.eclipse.swt.graphics.Drawable接口的类上绘制图形，这包括一个控件，一幅图像，一个显示设备或一个打印设备。类org.eclipse.swt.graphics.GC是一个封装了所有可执行的绘图操作的图形上下文（Graphics Context）。两种使用GC的方式我们已经在本节前言中提过，稍后会作详细说明。

3.2 在一幅图像上绘制图形

下面一段代码创建了一个带有图像的GC并在上面绘制了两条线：

Image image = new Image(display,"C:/music.gif"); 
GC gc = new GC(image); 
Rectangle bounds = image.getBounds(); 
gc.drawLine(0,0,bounds.width,bounds.height); 
gc.drawLine(0,bounds.height,bounds.width,0); 
gc.dispose(); 
image.dispose();

一旦你创建了一个GC，你就有责任通过它的dispose方法释放它的资源。一个由应用程序创建的GC需要立即被绘制，然后尽快释放掉。这是因为每个GC都需要一个底层的系统资源，而在某些操作系统中这些资源是稀缺的，像Win98就只允许同时创建五个GC对象。

3.3 在Control上绘图

类org.eclipse.swt.widgets.Control是可绘制的，所以你可以用像在图像上一样的方式来绘制图形。而和在图像上绘制所不同的是，如果你使用GC在一个Control上绘制图形，你需要知道当操作系统自身要绘制这个control的时候，它将覆盖掉你的改动。所以在一个Control上绘制图形的正确方法是加入其绘制事件的监听器。监听器类为org.eclipse.swt.events.PaintListener，其回调函数的参数是一个org.eclipse.swt.events.PaintEvent类的实例。这个PaintEvent实例中包含一个GC的引用，你可以向这个GC发送消息。下面的代码示例说明了如何建立这种类型的绘图：

Shell shell = new Shell(display); 
shell.addPaintListener(new PaintListener(){ 
        public void paintControl(PaintEvent e){ 
            Rectangle clientArea = shell.getClientArea(); 
            e.gc.drawLine(0,0,clientArea.width,clientArea.height); 
        } 
    }); 
shell.setSize(150,150)

3.4 剪切（Clipping）

GC的剪切域是可见绘图发生的部分。在缺省情况下，一个GC是一个被构造的可视部分边界。改变一个GC的剪切域可以让我们构造出各种图形效果。其中的一个例子是如果你想填充一个缺失了边缘的矩形。一种方法是绘制多边形矩形来组成所需要的图形，另一种方法就是剪切GC，然后对其剪切部分进行填充。

shell.addPaintListener(new PaintListener() { 
        public void paintControl(PaintEvent e) { 
            Rectangle clientArea = shell.getClientArea(); 
            int width = clientArea.width; 
            int height = clientArea.height; 
            e.gc.setClipping(20,20,width - 40, height - 40); 
            e.gc.setBackground(display.getSystemColor(SWT.COLOR_CYAN)); 
            e.gc.fillPolygon(new int[] {0,0,width,0,width/2,height}); 
        } 
    });

这段代码在Shell上的显示的过程效果如下：

3.5 画板（Canvas）

虽然任何Control都可以通过自身的paintEvent来绘制图形，但其子类org.eclipse.swt.widgets.Canvas是专门被设计用来进行图形操作的特殊的绘图类。我们既可以使用一个Canvas，再加入一个绘图监听器来实现绘图，也可以通过继承来建立一个可重用的自定义Control。Canvas有很多style bit，可以在绘图发生时产生作用。

3.6 绘制直线和图形

我们有很多方法可以在一个GC上画线，包括在两点之间，一系列离散的点之间或一个预定义的图形上都可以。直线是以GC的前景色来绘制的，我们可以通过GC绘制拥有不同厚度的各式直线。对于一个Paint事件，GC有着与Control组件一样的属性，即激发事件且缺省的直线样式固定为1个像素宽。

GC.drawLine(int x1, int y1, int x2, int y2);这条语句在可绘制的面板上的两点间花了一条直线，起始点为(x1,y1)，终止点为(x2，y2)。终止点包含在画好的直线中。如果起始点等于终止点的话，将会有一个独立的象素点被绘制出来。

GC.drawPolyline(int[] pointArray);这条语句绘制了一系列互相连接的线段，作为参数的数组用于描述点的位置。语句gc.drawPolyline(new int[] { 25,5,45,45,5,45 })；绘制了如下的图形：

GC.drawPolygon(int[] pointArray);与drawPolyline(int[])是类似的，唯一区别在于最后一个点和低一个点是连接的。gc.drawPolygon(new int[] { 25,5,45,45,5,45 });将会获得与上图一样的结果。

GC.drawRectangle(int x, int y, int width, int height);这条语句从左上角的（X，Y）点，用参数中的宽和高画出了一个矩形。gc.drawRectangle(5,5,90,45);将会绘制出如下图形：

GC.drawRoundedRectangle(int x,int y,int width,int height,int arcWidth,int arcHeight);一个圆矩形与标准矩形的区别就在于其四个角是圆的。圆矩形的每一个角都可以被想象成为1/4个椭圆，并且arcWidth和arcHeight由完整的椭圆的宽和高决定。gc.drawRoundedRectangle(5,5,90,45,25,15);绘制了一个左上角位置为5.5的圆矩形，右边的图形是放大后的效果：

GC.drawOval(int x, int y, int width, int height);一个椭圆是由其相对应的矩形的左上角的位置（x，y）来确定绘制位置的，其宽和高即为对应矩形的宽和高。对于圆形来说，只需要另宽和高相等即可。

GC.drawArc(int x, int y, int width, int height, int startAngle, int endAngle);曲线的绘制也是与一个相应的矩形有关，即其左上角的位置与宽和高都是相应矩形的属性。StartAntle是从横向的X开始计算的，所以0度指向的是东而不是北。曲线的绘制是从StartAngle到endAngle以逆时针方向执行。gc.drawArc(5,5,90,45,90,200);所绘制的图形如下：

GC.setLineStyle(int style);可以设置所绘制曲线的样式，下面列出了一些曲线样式常量（在org.eclipse.swt.SWT中定义）和与之对应的曲线的图像：

GC.setLineWidth(int width);可以用于指定所要绘制的曲线的宽度。缺省情况下的曲线宽度为1个像素。

由于直线的样式和宽度挥作用到所有的绘图操作上，所以我们可以作出如点矩形或粗线椭圆这样的图形：

3.7 绘制文本

文本可以被绘制在一个GC上， 字形是用GC的前景色和字体来绘制的，并且它所占用的区域是用GC背景色绘制的。要绘制文本，你需要定义要绘制文本的左上角，宽度和高度。有两组方法可以用来绘制文本，第一组方法的名字里都带有一个Text，并将会处理直线定界符和制表符。第二组API方法集的名字里都带有String，它们没有制表符或回车的处理，并主要用于控制像Eclipse的Java编辑器StyledText这样复杂的Control。

GC.drawText(String text, int x, int y);
Font font = new Font(display,"Arial",14,SWT.BOLD | SWT.ITALIC); 
// ... 
gc.drawText("Hello World",5,5); 
gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE)); 
gc.setFont(font); 
gc.drawText("Hello\tThere\nWide\tWorld",5,25); 
// ... 
font.dispose();

drawText API将控制字符\t处理为制表符，将\n处理为回车符。

GC.drawString(String text, int x, int y);
Font font = new Font(display,"Arial",14,SWT.BOLD | SWT.ITALIC); 
// ... 
gc.drawString("Hello World",5,5); 
gc.setForeground(display.getSystemColor(SWT.COLOR_BLUE)); 
gc.setFont(font); 
gc.drawString("Hello\tThere\nWide\tWorld",5,25); 
// ... 
font.dispose()

当使用drawString时，制表符和回车符将不会被处理。

在一个GC上绘制字符的时候，一个字符串所占用的大小取决于它的内容以及GC的字体。想要确定一个字符串在被绘制之后所占用的区域可以使用方法：GC.stringExtent(String text), 或 GC.textExtent(String text)。这两个方法都返回一个Point类，这个Point的X和Y是渲染参数字符串所需要的宽和高。

3.8 图形填充

直线是用GC前景色绘制的，而图形的填充用的是GC的背景色。

GC.fillPolygon(int[]);
gc.setBackground(display.getSystemColor(SWT.COLOR_BLUE)); 
gc.fillPolygon(new int[] { 25,5,45,45,5,45 }) 
 
GC.fillRectangle(int x, int y, int width, int height);
gc.fillRectangle(5,5,90,45); 

需要注意的是，当一个矩形被填充的时候，右面和下面的边缘是不被包括在内的。

GC.fillRoundedRectangle(int x, int y, int width, int height, int arcWidth, int arcHeight);
gc.fillRoundRectangle(5,5,90,45,25,15);

像GC.fillRectangle(...)方法一样，右面和下面的边缘不被包含在内，于是右下角的坐标为（94，49）而不是（95，50）。

GC.fillOval(int x, int y, int width, int height);
gc.fillOval(5,5,90,45); 

GC.fillArc(int x, int y, int widt4h., int height, int startAngle, int endAngle);
gc.fillArc(5,5,90,45,90,200);

fillArc()的参数和drawArc()的参数是类似的，偏移量是从右面的轴开始填充，然后沿逆时针方向旋转给定的角度（endAngle-startAngle）。

GC.fillGradientRectangle(int x, int y, int width. int height, vertical boolean);

这个方法让我们可以指定图形在填充时所用的颜色可以从GC的前景色按梯度变化（渐变）到背景色。梯度既可以是横向的也可以是纵向的。

gc.setBackgrouind(display,getSystemColor(SWT.COLOR_BLUE)); 
gc.fillGradientRectangle(5,5,90,45,false); 

上面两条语句建立了一个使用黑色背景的从左至右的横向梯度填充。和其他填充方法一样，左面和下面的边缘不被包括在内，所以由下角的位置缩小一个像素。

gc.setBackground(display.getSystemColor(SWT.COLOR_BLUE)); 
gc.setForeground(display.getSystemColor(SWT.COLOR_CYAN)); 
gc.fillGradientRectangle(5,5,90,45,true); 

上面这3行代码的含义为在纵向自顶向下用前cyan（景色）开始，并以蓝色（背景色）结束的填充。

3.9 异或（XOR）

如果你设置了GC的XOR模式为true的话，将会发生如下情况：对于每一个像素点，原来被显示的红，绿，蓝的值将被已存在的红，绿，蓝色进行异或操作，所得结果既作为新的目标像素。

shell.setBackground(display.getSystemColor(SWT.COLOR_WHITE)); 
// ... 
gc.setBackground(display.getSystemColor(SWT.COLOR_BLUE)); 
gc.fillRectangle(5,5,90,45); 
gc.setXORMode(true); 
gc.setBackground(display.getSystemColor(SWT.COLOR_WHITE)); 
gc.fillRectangle(20,20,50,50); 
gc.setBackground(display.getSystemColor(SWT.COLOR_RED)); 
gc.fillOval(80,20,50,50);

3.10 绘制图像（Draw Image）

类org.eclipse.swt.graphics.Image被用来表示准备要在像打印机，显示器这样的设备上显示的图形。建立一个图像最简单的方法就是从组织好的文件格式中装载它。SWT所支持的图像格式有：GIF，BMP，JGP，PNG和TIFF。

Image image = new Image(display,"C:/eclipse_lg.gif"); 
GC.drawImage(Image image, int x, int y);

每幅图像都有用其边界决定的尺寸。例如，图象eclipse_lg.gif的大小为115*164，我们可以通过image.getBounds()方法来进行设定。当一幅图像被绘制的时候，它将会以自身定义的边界作为显示之后的宽和高。gc.drawImage(image,5,5);

至此，SWT在2D绘图方面的讲解告一段落，上面所提到的内容涵盖了SWT的大部分绘图功能，并在每个部分都给出了要注意的细节。至于具体实现就要靠各位的聪明才智了。下面让我们进入最后的部分-SWT的3D绘图。

回页首

4 SWT与OpenGL编程

相较于Java3D API来说，SWT以前在3D图形绘制方面一直没有什么好的表现。OpenGL的加入会不会使SWT在3D领域有所作为还尚未可知，不过起码IBM的程序员们给了SWT机会。当大家了解了这个正处于试验阶段的组合之后，我们在SWT上绘制3D图形就不再是噩梦。

OpenGL是一个为创建高性能2D，3D图形而设计的多平台的标准。其硬件和软件的实现存在于多个系统之中，包括Windows，Linux和MacOS。OpenGL可以用于渲染简单的2D图形或复杂的3D游戏图形（OpenGL最主要的应用领域就是游戏）。作为一个正在处于事件阶段的Eclipse插件，我将在下面的小节中介绍如何在SWT窗口组件上用SWT绘制图形。在Eclipse最新的3.2版中，对OpenGL的支持被集成到org.eclipse.swt项目中，所以我们在实现的时候即可以选择以插件方式进行，也可以直接利用已经集成好的组件来进行图形操作。在本节，我们将以插件方式为例对代码进行说明。

4.1 SWT OpenGL插件

SWT实现了OpenGL1.1全部功能。包括三个核心类和一个数据类。核心类为GLContext，GL和GLU。GLContext架起了SWT和OpenGL之间的桥接。一个Context必须用Drawable，通常是用Canvas来创建，OpenGL可以在Drawable上渲染场景。需要注意的是，当context不再被使用的时候就应该将它释放掉。同样，一旦某个context被释放掉之后，就不应该再次试图去渲染它。每次Drawable改变大小的时候，context都需要通过调用其resize方法在通知这一事件。这个方法的调用让context调整自己的view port和视图参数。在下一节中将描述一个处理这一部分任务的类。

当context可用的时候，我们就可以通过定义在GL和GLU的一系列方法调用来绘制场景。一个GL类大概有超过330条命令。在GL和GLU中定义的这些函数和他们的Native实现几乎是一一对应的。下图给出了一个绘制矩形的例子，我们可以看到用C写成的API和SWT OpenGL API是何其相似：

4.2 SWT OpenGL编程基础

在下面的小节中，我将描述一个显示四幅3D图像的应用程序。应用程序采用了GLSense，这是一个用于显示OpenGL场景的工具类。它和SWT的Canvas很像，所区别的是它所展现的内容是用OpenGL命令渲染的，而不是使用GC来绘制。要做到这一点，我们需要将一个GLContext类和一个SWT Canvas相关联，并且无论何时，当前上下文中的内容都应该是由在drawScene中定义的命令来渲染的。

在构造函数中，一个SWT Canvas被创建出来。这就是那个要和一个GLContext相关联的Canvas实例。紧接着，这个Canvas又注册了两个监听器。第一个监听器的作用是确保这个Canvas无论何时被改变大小，其相应的GLContex也会收到通知并适当的改变大小。第二个监听器主要用于确保一旦Canvas被释放之后，其相对应的GLContext的也同时被释放。为了确保渲染区域是一个非零大小的区域，父组件的客户矩形区被取出来用于设置该Canvas的初始大小。这个初始大小可以在稍后用布局管理器或用户Action来修改。

GLScene将Canvas的全部区域用于绘图。无论Canvas何时调整其尺寸，我们都要获取客户区并将新的宽度和高度传递给Contex，而context将根据新的宽度和高度适当的调整视图。

GLScene被分割为两个部分：初始化Context和初始化OpenGL的状态机。对于Context来说，我们只是简单的建立一个新的GLContext并使它成为当前被使用的Context。OpenGL的渲染总是在当前的context上进行绘制，因此如果你有超过一个活动的GLScene，很重要的一点是要在所有绘制动作发生之前将它的Context设置为当前的Context。initGL方法最开始提供清除颜色缓存颜色，随后建立了一个深度缓存（depth buffer）.第47行指出了深度值如何进行比较。这一比较函数主要用于拒绝或接受正在引用的像素。GL.GL_LEQUAL选项指定接受那些在视图上更接近或有相同距离的像素。第48行启动了深度测试（depth test），紧接的一行设定阴影模型为GL.GL_SMOOTH，这一设定的效果是如果表面上的两个顶点颜色不同的话，系统将对颜色进行插值。最后，第50行要求渲染引擎在计算颜色和纹理协调插值运算的时候起到关键的作用。

GLScene类的最后两个方法用于处理重绘和场景绘制。当场景何时需要重绘的时候，第一个方法为其他类提供重绘操作的接口。第二个方法主要用于让继承GLScene的子类覆写。其缺省实现只是简单的清除了颜色和深度缓存，通过装在鉴别矩阵（identify matrix）重新恢复调整系统。

4.3 3D Chart

利用上一节的准备，我们已经将主应用程序进行了划分。这个图像显示了4组数据。每一组数据都是由相同的固定点所组成，每个点都是从0.0到10.0之间的一个正值。

示例程序运行在一个非常简单的Eclipse view上，唯一值得注意的是Refresher，这个线程将强迫OpenGL场景被周期性的重绘。通过这种方法，当视图被移动或旋转的时候，component总能进行有效的更新渲染效果。run()方法调用的时间间隔为100毫秒，所以理论上的图像速度能达到每秒10帧。

每个数据集合的点的值是用圆柱体来表示的。通过执行3个GLU调用，我们就能够绘制圆柱体：其中的两个用于渲染圆柱体两头的圆盘部分，另外一个用于渲染圆柱体的四周。例如，要渲染两个单元高的圆柱体，你可以用下面的代码来实现：

第一行申请了绘制圆盘和圆柱所需的二次曲面。然后整个场景被逆时针旋转了90度，以便圆柱体可以被垂直绘制。下一步，底部的圆盘被渲染，然后是圆柱体的四周。在我们能够绘制顶部圆盘的时候，通过场景转换（scene translation），我们可以在Z轴移动两个单元。最后一个圆盘随后被绘制出来，调整系统通过向回移动两个单元来进行恢复。最后，由第一行申请的二次曲面被释放掉。

按照上述方法运行程序是很费时间的。当仅绘制一个圆柱体的时候，效率低下不是一个很严重的问题，但如果要绘制成百个对象的话就会严重影响程序的执行性能。对于这种情况，OpenGL给出了一个解决这个问题的技巧，就是使用显示列表（display list）。

一个显示列表是一组已编译的OpenGL命令。定义命令集合的列表被放在glNewList(int list, int mode) 和 glEndList()方法调用之间。第一个参数必须是一个正整数，可以用来唯一的表示一个被创建的显示列表。你可以让GL用glGenLists(int n)方法为你生成多个列表标识符。第二个参数用于指定列表是否被编译或编译之后立即被执行。大多数情况下你都需要编译这个列表。然后，你可以使用glCallList(int list)方法来显示整个列表。

回页首

5 结束语

至此，有关于SWT与OpenGL图形有关的粗略功能就介绍完了，有鉴于3D图形对象和OpenGL的复杂性，一篇这样篇幅的文章肯定不能覆盖其每一个角落，我只能给各位一个动手尝试机会。希望整篇专题没有让你枯燥得睡着，并因此有了一个不错的SWT的基础，我的目的就达到了。

关于作者

		薛笛，是黑龙江大学研究生。他目前在黑龙江大学信息技术研究所工作，从事传感器网络和分布式数据库的研究，对Java技术特别感兴趣。可以通过 jxuedi@gmail.com 与他联系。

These days, when I’m reading some other guy’s code, I encounter some problem. In these code, I can read following codes:

Look, it use “==” but not “equals” here. “Oh, it must be a bug!”, I told myself. But, wait, when I excuted the program, it worked quite well. And till this moment, I remembered, current powerful JVM will maintain a constant pool for String, so maybe two “OK” will reference the same place. So, such mechanism will work.

But, does Java Language Specification has such standard? and all JVM will follow this standard? I continue to dig into it.

First, I found such item in JLS 3.10.5 — String literals.

Abstract some points here:

Literal strings within the same class ($8) in the same package ($7) represent references to the same String object ($4.3.1).
Literal strings within different classes in the same package represent references to the same String object.
Literal strings within different classes in different packages likewise represent references to the same String object.
Strings computed by constant expressions ($15.28) are computed at compile time and then treated as if they were literals.
Strings computed at run time are newly created and therefore distinct.
The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

So, this is the feature of String class, every JVM should follow. And, when I read the code of String.java, I found such comments in method “intern“.

public String intern()
Returns a canonical representation for the string object.
A pool of strings, initially empty, is maintained privately by the class String.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~So good:-)

When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.
It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.
All literal strings and string-valued constant expressions are interned. String literals are defined in $3.10.5 of the Java Language Specification.

It’s quite clear about the case I encountered. Then I understand, this is not a bug, but the trick . But, why he use “==” but not “equals“, I think that will be more clear and more easy to read, I think there must be other guys to be puzzled as me .

I think the author must care more about the performance than the code, the performance of “==” sure if better than “equals“, especially when the String is long~.

Ok, everything clear now, and sure, not only String has such pool. For example:

what will System.out.println(i==l) output? I think you can get the right answer.

Update (2005.11.09):

"String"’s method "equalsIgnoreCase" also take advantage of this string pool:

If the two string point the same one, simply return true.

So, if you need to compare Strings frequently, you should "Intern" them.

For example, in Lucene’s source code, you need to compare the Field name very often, so, they intern the field name.

Popularity: 9%

This entry was posted on Saturday, August 14th, 2004 at 5:25 pm and is filed under 技术. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.

为什么要区分J2EE容器和J2EE应用系统？

　　我们知道，J2EE应用系统只有部署在J2EE容器中才能运行，那么为什么划分为J2EE容器和J2EE应用系统？ 通过对J2EE容器运行机制的分析（见我的电子教材“EJB实用原理”），我们可以发现：实际上J2EE容器分离了一般应用系统的一些通用功能，例如事务机制、安全机制以及对象池或线程池等性能优化机制。

　　这些功能机制是每个应用系统几乎都需要的，因此可以从具体应用系统中分离出来，形成一个通用的框架平台，而且，这些功能机制的设计开发有一定难度，同时运行的稳定性和快速性都非常重要，必须经过长时间调试和运行经验积累而成，因此，形成了专门的J2EE容器服务器产品，如Tomcat JBoss、Websphere、WebLogic等。

　　从J2EE系统划分为J2EE容器和J2EE应用系统两个方面，我们已经看到一种分散关注的思路（separation of concerns）。

分散关注

　　将通用需求功能从不相关类之中分离出来；同时，能够使得很多类共享一个行为，一旦行为发生变化，不必修改很多类，只要修改这个行为就可以。

　　 AOP就是这种实现分散关注的编程方法，它将“关注”封装在“方面”中。

AOP是什么？

　　AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

　　举例：假设有在一个应用系统中，有一个共享的数据必须被并发同时访问，首先，将这个数据封装在数据对象中，称为Data Class，同时，将有多个访问类，专门用于在同一时刻访问这同一个数据对象。

　　为了完成上述并发访问同一资源的功能，需要引入锁Lock的概念，也就是说，某个时刻，当有一个访问类访问这个数据对象时，这个数据对象必须上锁Locked，用完后就立即解锁unLocked，再供其它访问类访问。

　　使用传统的编程习惯，我们会创建一个抽象类，所有的访问类继承这个抽象父类，如下：

• accessDataObject()方法需要有“锁”状态之类的相关代码。
  
  
  
• Java只提供了单继承，因此具体访问类只能继承这个父类，如果具体访问类还要继承其它父类，比如另外一个如Worker的父类，将无法方便实现。
  
  
  
• 重用被打折扣，具体访问类因为也包含“锁”状态之类的相关代码，只能被重用在相关有“锁”的场合，重用范围很窄。
  
  仔细研究这个应用的“锁”，它其实有下列特性：
  
  
  
• “锁”功能不是具体访问类的首要或主要功能，访问类主要功能是访问数据对象，例如读取数据或更改动作。
  
  
  
• “锁”行为其实是和具体访问类的主要功能可以独立、区分开来的。
  
  
  
• “锁”功能其实是这个系统的一个纵向切面，涉及许多类、许多类的方法。如下图：
  
  

　　因此，一个新的程序结构应该是关注系统的纵向切面，例如这个应用的“锁”功能，这个新的程序结构就是aspect（方面）

　　在这个应用中，“锁”方面（aspect）应该有以下职责：

　　提供一些必备的功能，对被访问对象实现加锁或解锁功能。以保证所有在修改数据对象的操作之前能够调用lock()加锁，在它使用完成后，调用unlock()解锁。

AOP应用范围

　　很明显，AOP非常适合开发J2EE容器服务器，目前JBoss 4.0正是使用AOP框架进行开发。
　　具体功能如下：
Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading　懒加载
Debugging　　调试
logging, tracing, profiling and monitoring　记录跟踪　优化　校准
Performance optimization　性能优化
Persistence　　持久化
Resource pooling　资源池
Synchronization　同步
Transactions 事务

AOP有必要吗？

　　当然，上述应用范例在没有使用AOP情况下，也得到了解决，例如JBoss 3.XXX也提供了上述应用功能，但是没有使用AOP。

　　但是，使用AOP可以让我们从一个更高的抽象概念来理解软件系统，AOP也许提供一种有价值的工具。可以这么说：因为使用AOP结构，现在JBoss 4.0的源码要比JBoss 3.X容易理解多了，这对于一个大型复杂系统来说是非常重要的。

　　从另外一个方面说，好像不是所有的人都需要关心AOP，它可能是一种架构设计的选择，如果选择J2EE系统，AOP关注的上述通用方面都已经被J2EE容器实现了，J2EE应用系统开发者可能需要更多地关注行业应用方面aspect。

AOP具体实现

　　AOP是一个概念，并没有设定具体语言的实现，它能克服那些只有单继承特性语言的缺点（如Java），目前AOP具体实现有以下几个项目：

　　AspectJ (TM)：　创建于Xerox PARC. 有近十年历史，成熟
　　缺点：过于复杂；破坏封装；需要专门的Java编译器。

　　动态AOP：使用JDK的动态代理API或字节码Bytecode处理技术。

　动态AOP：使用JDK的动态代理API或字节码Bytecode处理技术。

　　基于动态代理API的具体项目有：
　　JBoss 4.0 JBoss 4.0服务器
　　nanning　这是以中国南宁命名的一个项目，搞不清楚为什么和中国相关？是中国人发起的？

　　基于字节码的项目有：
　　aspectwerkz　
　　spring　
在以后其它文章中，我将继续对AOP概念进行分析，和大家一起学习进步。

AOP和AspectJ 板桥里人http://www.jdon.com 2004/01/10 需求和问题 　　以上篇《AOP是什么》中并发访问应用为例子： 　　多个访问类同时访问一个共享数据对象时，每个访问类在访问这个数据对象时，需要将数据对象上锁，访问完成后，再实行解锁，供其它并发线程访问，这是我们处理并发访问资源的方式。 　　为了实现这个需求，先实现传统的编程，这里我们假定有一个写锁，对数据对象实行写之前，首先对这个对象进行上写锁，写操作完毕后，必须释放写锁。 　　首先，我们需要一个锁，这个锁可以是数据对象中一个字段或其它，这里使用Doug Lea的ReentrantWriterPreferenceReadWriteLock作为我们的锁资源。 import EDU.oswego.cs.dl.util.concurrent.*; public class Worker extends Thread { 　　Data data; 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock(); 　　public boolean createData() { 　　　try { 　　　　rwl.writeLock().acquire();　//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); 　//解锁 　　　} 　　　return true; 　　} 　　public boolean updateData() { 　　　try { 　　　　rwl.writeLock().acquire();//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); //解锁 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行createData()或updateData() 　　} } 假设可能存在另外一个访问类，也将对数据对象实现写操作，代码如下： import EDU.oswego.cs.dl.util.concurrent.*; public class AnotherWorker extends Thread { 　　Data data; 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock(); 　　 　　public boolean updateData() { 　　　try { 　　　　rwl.writeLock().acquire();//上锁 　　　　//对data实行写逻辑操作　 　　　　　　　 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　 　 rwl.writeLock().release(); //解锁 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行updateData() 　　} } 　　以上是Java传统编程的实现，这种锁的实现方式是在每个具体类中实现，如下图： 这种实现方式的缺点很多： 冗余：有很多重复的编码，如rwl.writeLock().acquire()等； 减少重用：worker的updateData()方法重用性几乎为零。 "数据对象写操作必须使用锁控制这个设计目的"不容易显现，如果更换了一个新的程序员，他可能编写一段不使用锁机制就对这个数据对象写操作的代码。 如果上述代码有读功能，那么我们需要在代码中实现先上读锁，当需要写时，解读锁，再上写锁等等，如果稍微不小心，上锁解锁次序搞错，系统就隐含大的BUG，这种可能性会随着这个数据对象永远存在下去，系统设计大大的隐患啊！ 　　那么我们使用AOP概念来重新实现上述需求，AOP并没有什么新花招，只是提供了观察问题的一个新视角度。 　　这里我们可以抛开新技术迷人雾障，真正核心还是新思维、新视点，人类很多问题如果换一个脑筋看待理解，也许结果真的是翻天覆地不一样啊，所以，作为人自身，首先要重视和你世界观和思维方式不一样的人进行交流和沟通。 　　现实生活中有很多"不公平"，例如某个小学毕业生成了千万富翁，你就怀疑知识无用，也许你认为他的机会好，其实你可能不知道，他的观察问题的视角比你独特，或者他可能会经常换不同的角度来看待问题和解决问题，而你由于过分陷入一个视角的具体实现细节中，迷失了真正的方向，要不说是读书人脑子僵化呢？ 　　言归正传，我们看看AOP是如何从一个新的视角解决上述问题的。 　　如果说上面代码在每个类中实现上锁或解锁，类似横向解决方式，那么AOP是从纵向方面来解决上述问题，纵向解决之道示意图如下： 　　AOP把这个纵向切面cross-cuts称为Aspect（方面），其实我认为AOP翻译成面向切面编程比较好，不知哪个糊涂者因为先行一步，翻译成“面向方面编程”如此抽象，故弄玄虚。 AspectJ实现 　　下面我们使用AOP的实现之一AspectJ来对上述需求改写。AspectJ是AOP最早成熟的Java实现，它稍微扩展了一下Java语言，增加了一些Keyword等，pointcut的语法如下： public pointcut 方法名：call(XXXX) 　　AspectJ增加了pointcut, call是pointcut类型，有关AspectJ更多基本语法见这里。因为AspectJ使用了一些特别语法，所以Java编译器就不能用SUN公司提供javac了，必须使用其专门的编译器，也许SUN在以后JDK版本中会引入AOP。 　　使用AspectJ如何实现上图所谓切面式的编程呢？首先,我们将上图纵向切面称为Aspect，那么我们建立一个类似Class的Aspect，Java中建立一个Class代码如下： public class MyClass{ 　　//属性和方法 ... } 　　同样，建立一个Aspect的代码如下： public aspect MyAspect{ 　　//属性和方法 ... } 建立一个Aspect名为Lock，代码如下： import EDU.oswego.cs.dl.util.concurrent.*; public aspect Lock { 　　...... 　　ReentrantWriterPreferenceReadWriteLock rwl =　 　　　　new ReentrantWriterPreferenceReadWriteLock(); 　　public pointcutwriteOperations(): 　　　　execution(public boolean Worker.createData()) || 　　　　execution(public boolean Worker.updateData()) || 　　　　execution(public boolean AnotherWorker.updateData()) ; 　　before() : writeOperations() { 　　　　rwl.writeLock().acquire();//上锁　advice body 　　} 　　after() : writeOperations() { 　　 　 rwl.writeLock().release(); //解锁 advice body 　　} 　　...... } 　　上述代码关键点是pointcut，意味切入点或触发点，那么在那些条件下该点会触发呢？是后面红字标识的一些情况，在执行Worker的createData()方法，Worker的update方法等时触发。 　　before代表触发之前做什么事情？ 　　答案是上锁。 　　after代表触发之后做什么事情？ 　　答案是上锁。 　　通过引入上述aspect，那么Worker代码可以清洁如下： public class Worker extends Thread { 　　Data data; 　　public boolean createData() { 　　　try { 　　　　//对data实行写逻辑操作　　　　　　　　 　　　}catch() { 　　 　 return false; 　　　} 　　　return true; 　　} 　　public boolean updateData() { 　　　try { 　　　　//对data实行写逻辑操作　　　　　　　　 　　　}catch() { 　　 　 return false; 　　　}finally{ 　　　} 　　　return true; 　　} 　　public void run() { 　　　　//执行createData()或updateData() 　　} } 　　Worker中关于“锁”的代码都不见了，纯粹变成了数据操作的主要方法。 AOP术语 　　通过上例已经知道AspectJ如何从切面crosscutting来解决并发访问应用需求的，其中最重要的是引入了一套类似事件触发机制。 　　Pointcut类似触发器，是事件Event发生源，一旦pointcut被触发，将会产生相应的动作Action，这部分Action称为Advice。 　　Advice在AspectJ有三种：before、 after、Around之分，上述aspect Lock代码中使用了Advice的两种before和after。 　　所以AOP有两个基本的术语：Pointcut和Advice。你可以用事件机制的Event和Action来类比理解它们。上述并发访问应用中pointcut和advice如下图所示： 小结如下： advice - 真正的执行代码，或者说关注的实现。 类似Action。 join point - 代码中激活advice被执行的触发点。 pointcut - 一系列的join point称为pointcut，pointcut有时代指join point 其中advice部分又有： Interceptor - 解释器并没有在AspectJ出现，在使用JDK动态代理API实现的AOP框架中使用，解释有方法调用或对象构造或者字段访问等事件，是调用者和被调用者之间的纽带，综合了Decorator/代理模式甚至职责链等模式。 Introduction - 修改一个类，以增加字段、方法或构造或者执行新的接口，包括Mixin实现。 例如上述并发访问应用中，如果想为每个Data对象生成相应的aspect Lock，那么可以在aspect Lock中人为数据对象增加一个字段lock，如下： aspect Lock { 　　Data sharedDataInstance; 　　Lock( Data d ) { 　　　　 sharedDataInstance = d; 　　} 　　introduce Lock Data.lock;　//修改Data类，增加一字段lock 　　advise Data() { //Data构造时触发 　　　　 static after { 　　　　　　 //当Data对象生成时，将Data中lock字段赋值为aspect Lock 　　　　　　 //为每个Data对象生成相应的aspect Lock 　　　　　　 thisObject.lock = new Lock( thisObject ); 　　　　 } 　　 } 　　.... } 上述代码等于在Data类中加入一行： public class Data{ 　　...... 　　Lock lock = new Lock(); 　　...... } 还有其它两个涉及AOP代码运行方式： weaving - 将aspect代码插入到相应代码中的过程，一般是编译完成或在运行时动态完成。取决于具体AOP产品，例如AspectJ是使用特殊编译器在编译完成weaving，而nanning、JBoss AOP是使用动态代理API，因此在运行时动态完成weaving的。 instrumentor - 用来实现weaving功能的工具。

AOP与权限控制实现 板桥里人http://www.jdon.com 2004/01/10 　　以往在J2EE系统中，访问权限控制系统的实现主要有两种：应用程序实现和J2EE容器实现。 传统的应用程序实现 　　这是最直接的、传统的一种解决方式，通常是在具体方法前加一个权限判断语句，如下： public class ForumFactoryProxy extends ForumFactory { 　　...... 　　public Forum createForum(String name, String description) 　　　　throws UnauthorizedException, ForumAlreadyExistsException 　　{ 　　　　if (permissions.get(ForumPermissions.SYSTEM_ADMIN)) { 　　　　　　Forum newForum = factory.createForum(name, description); 　　　　　　return new ForumProxy(newForum, authorization, permissions); 　　　　}else { 　　　　　　throw new UnauthorizedException(); 　　　　} 　　} 　　...... } 　　上述代码是Jive论坛中一段创建论坛功能的代码，在创建论坛前，首先进行权限角色检验，如果当前用户是系统管理员，那么可以实现真正的创建。 　　这种在具体功能前加入权限操作检验的实现方式有很多缺点： 　　1.每个功能类都需要相应的权限检验代码，将程序功能和权限检验混淆在一起，存在紧密的耦合性，扩展修改难度大。 　　2.如果类似Jive，以代理模式为每个功能类实现一个相应的代理类，虽然解耦了程序功能和权限检验，但是，从某个角色的权限检验这个切面考虑，涉及具体Proxy类太多，扩展修改难度大。 J2EE容器实现 　　在AOP概念没有诞生前，J2EE规范已经提供了关于权限控制的容器实现标准，这种变迁结果如下图所示： 　　原来需要每个应用程序实现的权限Proxy转为整个容器的Proxy实现，其中JDK1.3以后的动态代理API为这种转换实现提供了技术保证。 　　非常明显，通过容器实现权限控制验证可以大大简化应用程序的设计，分离了应用系统的权限关注，将权限控制变成了对J2EE容器服务器的配置工作，具体技术细节参考我的书籍《Java实用系统开发指南》第六章。 　　其实，容器的权限实现也是一种从一个切面来解决问题方式，AOP概念诞生后，权限控制实现由此也带来了两个方向的变化： 　　1. J2EE容器级别的权限实现，也就是容器自身的权限实现。 　　2. J2EE应用程序级别的权限实现。 　　权限控制在容器级别实现似乎使得J2EE开发者感觉没有灵活性和可扩展性，其实象JBoss 4.0这样的J2EE容器，由于引入了AOP概念，使得J2EE开发者在自己的应用系统中能够直接操纵容器的一些行为。容器和应用系统由于AOP引入的Aspect切面，变得可以成为一体了。（如果使用BEA的EJBC编辑要浪费多少时间？） 　　对于J2EE应用系统开发者，能够做到上述境界，必须的条件是对JBoss之类J2EE容器必须有足够的了解，因为这些方式并不是J2EE标准，有可能在移植到新的J2EE容器，这些知识和投入变得无用（也有可能将来J2EE扩展其标准）。 　　很显然，使用AOP实现J2EE应用系统级别的权限控制，是解决上述移植风险的一个主要方法，但是带来的缺点是必须亲自从零开始做起，耗费时间不会很短。 AOP下的应用程序权限控制实现 　　引入AOP概念后的权限实现已经不是前面Jive实例那样“落后”，我们对这个实例进行重整（Refactorying）如下： 创建一个Aspect，专门用于权限检查，如下： private static aspect PermissionCheckAspect { 　　private pointcut permissionCheckedExecution() : 　　 execution ( public Forum ForumFactory.createForum(String , String )); 　　before () : permissionCheckedExecution() { 　　　　if !(permissions.get(ForumPermissions.SYSTEM_ADMIN)) { 　　　　　　throw new UnauthorizedException(); 　　　　} 　　 } } 该段代码功能是：当系统运行ForumFactory.createForum方法之前，将首先检查是否有权限操作。 代码中pointcut触发的条件是createForum方法执行，如果有其它需要系统管理员身份才能执行的方法加入，将写成如下代码： private pointcut permissionCheckedExecution() : 　　 execution ( public Forum ForumFactory.createForum(String , String )) || 　　 execution ( public Forum ForumFactory.deleteForum(String , String )) || 　　 ...... 　　 execution ( public Forum ForumFactory.deleteThread(String , String )); 这些方法陈列比较琐碎，依据AspectJ语法，可以简化如下： private pointcut permissionCheckedExecution() : 　　 execution ( public * ForumFactory .*(..)); 有兴趣者可以将Jive论坛中相关权限Proxy部分使用AOP重整，另外，由于Jive没有引入角色概念，导致权限和用户HardCode在编码中，如何实现权限和用户解耦，最小限度的降低HardCode量，角色概念在其中起着不可忽视的重要作用。这是另外一个研究课题了。

Ioc模式 板桥里人http://www.jdon.com 2004/01/31 　　分离关注（ Separation of Concerns : SOC）是Ioc模式和AOP产生最原始动力，通过功能分解可得到关注点，这些关注可以是 组件Components, 方面Aspects或服务Services。 　　从GoF设计模式中，我们已经习惯一种思维编程方式：Interface Driven Design 接口驱动，接口驱动有很多好处，可以提供不同灵活的子类实现，增加代码稳定和健壮性等等，但是接口一定是需要实现的，也就是如下语句迟早要执行： 　　AInterface a = new AInterfaceImp(); 　　AInterfaceImp是接口AInterface的一个子类，Ioc模式可以延缓接口的实现，根据需要实现，有个比喻：接口如同空的模型套，在必要时，需要向模型套注射石膏，这样才能成为一个模型实体，因此，我们将人为控制接口的实现成为“注射”。 　　Ioc英文为 Inversion of Control，即反转模式，这里有著名的好莱坞理论：你呆着别动，到时我会找你。 　　其实Ioc模式也是解决调用者和被调用者之间的一种关系，上述AInterface实现语句表明当前是在调用被调用者AInterfaceImp，由于被调用者名称写入了调用者的代码中，这产生了一个接口实现的原罪：彼此联系，调用者和被调用者有紧密联系，在UML中是用依赖 Dependency 表示。 　　但是这种依赖在分离关注的思维下是不可忍耐的，必须切割，实现调用者和被调用者解耦，新的Ioc模式 Dependency Injection 模式由此产生了， Dependency Injection模式是依赖注射的意思，也就是将依赖先剥离，然后在适当时候再注射进入。 Ioc模式（Dependency Injection模式）有三种： 第一种类型 从JNDI或ServiceManager等获得被调用者，这里类似ServiceLocator模式。 1. EJB/J2EE 2. Avalon（Apache的一个复杂使用不多的项目） 第二种类型 使用JavaBeans的setter方法 1. Spring Framework, 2. WebWork/XWork 第三种类型 在构造方法中实现依赖 1. PicoContainer, 2. HiveMind 　　有过EJB开发经验的人都知道，每个EJB的调用都需要通过JNDI寻找到工厂性质的Home接口，在我的教程EJB是什么章节中，我也是从依赖和工厂模式角度来阐述EJB的使用。 　　在通常传统情况下，为了实现调用者和被调用者解耦，分离，一般是通过工厂模式实现的，下面将通过比较工厂模式和Ioc模式不同，加深理解Ioc模式。 工厂模式和Ioc 　　假设有两个类B 和 C：B作为调用者，C是被调用者，在B代码中存在对C的调用： public class B{ 　　 private C comp; 　　...... } 　　实现comp实例有两种途径：单态工厂模式和Ioc。 工厂模式实现如下： public class B{ 　　 private C comp; 　　private final static MyFactory myFactory = MyFactory.getInstance(); 　　public B(){ 　　　　this.comp = myFactory.createInstanceOfC(); 　　} 　　 public void someMethod(){ 　　　　this.comp.sayHello(); 　 } 　　...... } 特点： 每次运行时，MyFactory可根据配置文件XML中定义的C子类实现，通过createInstanceOfC()生成C的具体实例。 使用Ioc依赖性注射( Dependency Injection )实现Picocontainer如下，B类如同通常POJO类，如下： public class B{ 　　 private C comp; 　　public B(C comp){ 　　　　this.comp = comp; 　　 } 　　 public void someMethod(){ 　　　　this.comp.sayHello(); 　　 } 　　...... } 假设C接口/类有有一个具体实现CImp类。当客户端调用B时，使用下列代码： public class client{ 　　 public static void main( String[] args ) { 　　　　DefaultPicoContainer container = new DefaultPicoContainer(); 　　　　container.registerComponentImplementation(CImp.class); 　　　　container.registerComponentImplementation(B.class); 　　　　B b = (B) container.getComponentInstance(B.class); 　　　　b.someMethod(); 　　 } } 　　因此，当客户端调用B时，分别使用工厂模式和Ioc有不同的特点和区别： 　　主要区别体现在B类的代码，如果使用Ioc，在B类代码中将不需要嵌入任何工厂模式等的代码，因为这些工厂模式其实还是与C有些间接的联系，这样，使用Ioc彻底解耦了B和C之间的联系。 　　使用Ioc带来的代价是：需要在客户端或其它某处进行B和C之间联系的组装。 　　所以，Ioc并没有消除B和C之间这样的联系，只是转移了这种联系。 　　这种联系转移实际也是一种分离关注，它的影响巨大，它提供了AOP实现的可能。 Ioc和AOP 　　AOP我们已经知道是一种面向切面的编程方式，由于Ioc解放自由了B类，而且可以向B类实现注射C类具体实现，如果把B类想像成运行时的横向动作，无疑注入C类子类就是AOP中的一种Advice，如下图： 　　通过下列代码说明如何使用Picocontainer实现AOP，该例程主要实现是记录logger功能，通过Picocontainer可以使用简单一行，使所有的应用类的记录功能激活。 首先编制一个记录接口： public interface Logging { 　　public void enableLogging(Log log); } 有一个LogSwitcher类，主要用来激活具体应用中的记录功能： import org.apache.commons.logging.Log; public class LogSwitcher { 　 protected Log m_log; 　 public void enableLogging(Log log) { 　　　　m_log = log; 　　　　m_log.info("Logging Enabled"); 　　} } 一般的普通应用JavaBeans都可以继承这个类，假设PicoUserManager是一个用户管理类，代码如下： public class PicoUserManager extends LogSwitcher { 　　..... //用户管理功能 } public class PicoXXXX1Manager extends LogSwitcher { 　　..... //业务功能 } public class PicoXXXX2Manager extends LogSwitcher { 　　..... //业务功能 } 注意LogSwitcher中Log实例是由外界赋予的，也就是说即将被外界注射进入，下面看看使用Picocontainer是如何注射Log的具体实例的。 DefaultPicoContainer container = new DefaultPicoContainer(); container.registerComponentImplementation(PicoUserManager.class); container.registerComponentImplementation(PicoXXXX1Manager.class); container.registerComponentImplementation(PicoXXXX2Manager.class); ..... Logging logging = (Logging) container.getComponentMulticaster(); logging.enableLogging(new SimpleLog("pico"));//激活log 　　由上代码可见，通过使用简单一行logging.enableLogging()方法使所有的应用类的记录功能激活。这是不是类似AOP的advice实现？ 　　总之，使用Ioc模式，可以不管将来具体实现，完全在一个抽象层次进行描述和技术架构，因此，Ioc模式可以为容器、框架之类的软件实现提供了具体的实现手段，属于架构技术中一种重要的模式应用。J道的JdonSD框架也使用了Ioc模式。

作者：钟华

(一)断点续传的原理
其实断点续传的原理很简单，就是在Http的请求上和一般的下载有所不同而已。
打个比方，浏览器请求服务器上的一个文时，所发出的请求如下：
假设服务器域名为wwww.sjtu.edu.cn，文件名为down.zip。
GET /down.zip HTTP/1.1
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-
excel, application/msword, application/vnd.ms-powerpoint, */*
Accept-Language: zh-cn
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)
Connection: Keep-Alive

服务器收到请求后，按要求寻找请求的文件，提取文件的信息，然后返回给浏览器，返回信息如下：

200
Content-Length=106786028
Accept-Ranges=bytes
Date=Mon, 30 Apr 2001 12:56:11 GMT
ETag=W/"02ca57e173c11:95b"
Content-Type=application/octet-stream
Server=Microsoft-IIS/5.0
Last-Modified=Mon, 30 Apr 2001 12:56:11 GMT

所谓断点续传，也就是要从文件已经下载的地方开始继续下载。所以在客户端浏览器传给
Web服务器的时候要多加一条信息--从哪里开始。
下面是用自己编的一个"浏览器"来传递请求信息给Web服务器，要求从2000070字节开始。
GET /down.zip HTTP/1.0
User-Agent: NetFox
RANGE: bytes=2000070-
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2

仔细看一下就会发现多了一行RANGE: bytes=2000070-
这一行的意思就是告诉服务器down.zip这个文件从2000070字节开始传，前面的字节不用传了。
服务器收到这个请求以后，返回的信息如下：
206
Content-Length=106786028
Content-Range=bytes 2000070-106786027/106786028
Date=Mon, 30 Apr 2001 12:55:20 GMT
ETag=W/"02ca57e173c11:95b"
Content-Type=application/octet-stream
Server=Microsoft-IIS/5.0
Last-Modified=Mon, 30 Apr 2001 12:55:20 GMT

和前面服务器返回的信息比较一下，就会发现增加了一行：
Content-Range=bytes 2000070-106786027/106786028
返回的代码也改为206了，而不再是200了。

知道了以上原理，就可以进行断点续传的编程了。

(二)Java实现断点续传的关键几点

1. (1)用什么方法实现提交RANGE: bytes=2000070-。
   当然用最原始的Socket是肯定能完成的，不过那样太费事了，其实Java的net包中提供了这种功能。代码如下：
   
   URL url = new URL("http://www.sjtu.edu.cn/down.zip");
   HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection();
   
   
   //设置User-Agent
   httpConnection.setRequestProperty("User-Agent","NetFox");
   //设置断点续传的开始位置
   httpConnection.setRequestProperty("RANGE","bytes=2000070");
   //获得输入流
   InputStream input = httpConnection.getInputStream();
   
   
   
   

   从输入流中取出的字节流就是down.zip文件从2000070开始的字节流。
   大家看，其实断点续传用Java实现起来还是很简单的吧。
   接下来要做的事就是怎么保存获得的流到文件中去了。
   

2. 保存文件采用的方法。
   我采用的是IO包中的RandAccessFile类。
   操作相当简单，假设从2000070处开始保存文件，代码如下：
   RandomAccess oSavedFile = new RandomAccessFile("down.zip","rw");
   long nPos = 2000070;
   //定位文件指针到nPos位置
   oSavedFile.seek(nPos);
   byte[] b = new byte[1024];
   int nRead;
   //从输入流中读入字节流，然后写到文件中
   while((nRead=input.read(b,0,1024)) > 0)
   {
   oSavedFile.write(b,0,nRead);
   }
   

怎么样，也很简单吧。
接下来要做的就是整合成一个完整的程序了。包括一系列的线程控制等等。

(三)断点续传内核的实现
主要用了6个类，包括一个测试类。
SiteFileFetch.java负责整个文件的抓取，控制内部线程(FileSplitterFetch类)。
FileSplitterFetch.java负责部分文件的抓取。
FileAccess.java负责文件的存储。
SiteInfoBean.java要抓取的文件的信息，如文件保存的目录，名字，抓取文件的URL等。
Utility.java工具类，放一些简单的方法。
TestMethod.java测试类。

下面是源程序：

/*
**SiteFileFetch.java
*/
package NetFox;
import java.io.*;
import java.net.*;


public class SiteFileFetch extends Thread {


SiteInfoBean siteInfoBean = null; //文件信息Bean
long[] nStartPos; //开始位置
long[] nEndPos; //结束位置
FileSplitterFetch[] fileSplitterFetch; //子线程对象
long nFileLength; //文件长度
boolean bFirst = true; //是否第一次取文件
boolean bStop = false; //停止标志
File tmpFile; //文件下载的临时信息
DataOutputStream output; //输出到文件的输出流


public SiteFileFetch(SiteInfoBean bean) throws IOException
{
siteInfoBean = bean;
//tmpFile = File.createTempFile ("zhong","1111",new File(bean.getSFilePath()));
tmpFile = new File(bean.getSFilePath()+File.separator + bean.getSFileName()+".info");
if(tmpFile.exists ())
{
bFirst = false;
read_nPos();
}
else
{
nStartPos = new long[bean.getNSplitter()];
nEndPos = new long[bean.getNSplitter()];
}



}


public void run()
{
//获得文件长度
//分割文件
//实例FileSplitterFetch
//启动FileSplitterFetch线程
//等待子线程返回
try{
if(bFirst)
{
nFileLength = getFileSize();
if(nFileLength == -1)
{
System.err.println("File Length is not known!");
}
else if(nFileLength == -2)
{
System.err.println("File is not access!");
}
else
{
for(int i=0;i<nStartPos.length;i++)
{
nStartPos[i] = (long)(i*(nFileLength/nStartPos.length));
}
for(int i=0;i<nEndPos.length-1;i++)
{
nEndPos[i] = nStartPos[i+1];
}
nEndPos[nEndPos.length-1] = nFileLength;
}
}


//启动子线程
fileSplitterFetch = new FileSplitterFetch[nStartPos.length];
for(int i=0;i<nStartPos.length;i++)
{
fileSplitterFetch[i] = new FileSplitterFetch(siteInfoBean.getSSiteURL(),
siteInfoBean.getSFilePath() + File.separator + siteInfoBean.getSFileName(),
nStartPos[i],nEndPos[i],i);
Utility.log("Thread " + i + " , nStartPos = " + nStartPos[i] + ", nEndPos = " + nEndPos[i]);
fileSplitterFetch[i].start();
}
// fileSplitterFetch[nPos.length-1] = new FileSplitterFetch(siteInfoBean.getSSiteURL(),
siteInfoBean.getSFilePath() + File.separator + siteInfoBean.getSFileName(),nPos[nPos.length-1],nFileLength,nPos.length-1);
// Utility.log("Thread " + (nPos.length-1) + " , nStartPos = " + nPos[nPos.length-1] + ",
nEndPos = " + nFileLength);
// fileSplitterFetch[nPos.length-1].start();


//等待子线程结束
//int count = 0;
//是否结束while循环
boolean breakWhile = false;


while(!bStop)
{
write_nPos();
Utility.sleep(500);
breakWhile = true;


for(int i=0;i<nStartPos.length;i++)
{
if(!fileSplitterFetch[i].bDownOver)
{
breakWhile = false;
break;
}
}
if(breakWhile)
break;


//count++;
//if(count>4)
// siteStop();
}


System.err.println("文件下载结束！");
}
catch(Exception e){e.printStackTrace ();}
}


//获得文件长度
public long getFileSize()
{
int nFileLength = -1;
try{
URL url = new URL(siteInfoBean.getSSiteURL());
HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection ();
httpConnection.setRequestProperty("User-Agent","NetFox");


int responseCode=httpConnection.getResponseCode();
if(responseCode>=400)
{
processErrorCode(responseCode);
return -2; //-2 represent access is error
}


String sHeader;


for(int i=1;;i++)
{
//DataInputStream in = new DataInputStream(httpConnection.getInputStream ());
//Utility.log(in.readLine());
sHeader=httpConnection.getHeaderFieldKey(i);
if(sHeader!=null)
{
if(sHeader.equals("Content-Length"))
{
nFileLength = Integer.parseInt(httpConnection.getHeaderField(sHeader));
break;
}
}
else
break;
}
}
catch(IOException e){e.printStackTrace ();}
catch(Exception e){e.printStackTrace ();}


Utility.log(nFileLength);


return nFileLength;
}


//保存下载信息（文件指针位置）
private void write_nPos()
{
try{
output = new DataOutputStream(new FileOutputStream(tmpFile));
output.writeInt(nStartPos.length);
for(int i=0;i<nStartPos.length;i++)
{
// output.writeLong(nPos[i]);
output.writeLong(fileSplitterFetch[i].nStartPos);
output.writeLong(fileSplitterFetch[i].nEndPos);
}
output.close();
}
catch(IOException e){e.printStackTrace ();}
catch(Exception e){e.printStackTrace ();}
}


//读取保存的下载信息（文件指针位置）
private void read_nPos()
{
try{
DataInputStream input = new DataInputStream(new FileInputStream(tmpFile));
int nCount = input.readInt();
nStartPos = new long[nCount];
nEndPos = new long[nCount];
for(int i=0;i<nStartPos.length;i++)
{
nStartPos[i] = input.readLong();
nEndPos[i] = input.readLong();
}
input.close();
}
catch(IOException e){e.printStackTrace ();}
catch(Exception e){e.printStackTrace ();}
}


private void processErrorCode(int nErrorCode)
{
System.err.println("Error Code : " + nErrorCode);
}


//停止文件下载
public void siteStop()
{
bStop = true;
for(int i=0;i<nStartPos.length;i++)
fileSplitterFetch[i].splitterStop();


}
}
/*
**FileSplitterFetch.java
*/
package NetFox;


import java.io.*;
import java.net.*;


public class FileSplitterFetch extends Thread {


String sURL; //File URL
long nStartPos; //File Snippet Start Position
long nEndPos; //File Snippet End Position
int nThreadID; //Thread's ID
boolean bDownOver = false; //Downing is over
boolean bStop = false; //Stop identical
FileAccessI fileAccessI = null; //File Access interface


public FileSplitterFetch(String sURL,String sName,long nStart,long nEnd,int id) throws IOException
{
this.sURL = sURL;
this.nStartPos = nStart;
this.nEndPos = nEnd;
nThreadID = id;
fileAccessI = new FileAccessI(sName,nStartPos);
}


public void run()
{
while(nStartPos < nEndPos && !bStop)
{


try{
URL url = new URL(sURL);
HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection ();
httpConnection.setRequestProperty("User-Agent","NetFox");
String sProperty = "bytes="+nStartPos+"-";
httpConnection.setRequestProperty("RANGE",sProperty);
Utility.log(sProperty);


InputStream input = httpConnection.getInputStream();
//logResponseHead(httpConnection);


byte[] b = new byte[1024];
int nRead;
while((nRead=input.read(b,0,1024)) > 0 && nStartPos < nEndPos && !bStop)
{
nStartPos += fileAccessI.write(b,0,nRead);
//if(nThreadID == 1)
// Utility.log("nStartPos = " + nStartPos + ", nEndPos = " + nEndPos);
}


Utility.log("Thread " + nThreadID + " is over!");
bDownOver = true;
//nPos = fileAccessI.write (b,0,nRead);
}
catch(Exception e){e.printStackTrace ();}
}
}


//打印回应的头信息
public void logResponseHead(HttpURLConnection con)
{
for(int i=1;;i++)
{
String header=con.getHeaderFieldKey(i);
if(header!=null)
//responseHeaders.put(header,httpConnection.getHeaderField(header));
Utility.log(header+" : "+con.getHeaderField(header));
else
break;
}
}


public void splitterStop()
{
bStop = true;
}


}


/*
**FileAccess.java
*/
package NetFox;
import java.io.*;


public class FileAccessI implements Serializable{


RandomAccessFile oSavedFile;
long nPos;


public FileAccessI() throws IOException
{
this("",0);
}


public FileAccessI(String sName,long nPos) throws IOException
{
oSavedFile = new RandomAccessFile(sName,"rw");
this.nPos = nPos;
oSavedFile.seek(nPos);
}


public synchronized int write(byte[] b,int nStart,int nLen)
{
int n = -1;
try{
oSavedFile.write(b,nStart,nLen);
n = nLen;
}
catch(IOException e)
{
e.printStackTrace ();
}


return n;
}


}


/*
**SiteInfoBean.java
*/
package NetFox;


public class SiteInfoBean {


private String sSiteURL; //Site's URL
private String sFilePath; //Saved File's Path
private String sFileName; //Saved File's Name
private int nSplitter; //Count of Splited Downloading File


public SiteInfoBean()
{
//default value of nSplitter is 5
this("","","",5);
}


public SiteInfoBean(String sURL,String sPath,String sName,int nSpiltter)
{
sSiteURL= sURL;
sFilePath = sPath;
sFileName = sName;
this.nSplitter = nSpiltter;


}


public String getSSiteURL()
{
return sSiteURL;
}


public void setSSiteURL(String value)
{
sSiteURL = value;
}


public String getSFilePath()
{
return sFilePath;
}


public void setSFilePath(String value)
{
sFilePath = value;
}


public String getSFileName()
{
return sFileName;
}


public void setSFileName(String value)
{
sFileName = value;
}


public int getNSplitter()
{
return nSplitter;
}


public void setNSplitter(int nCount)
{
nSplitter = nCount;
}
}


/*
**Utility.java
*/
package NetFox;


public class Utility {


public Utility()
{


}


public static void sleep(int nSecond)
{
try{
Thread.sleep(nSecond);
}
catch(Exception e)
{
e.printStackTrace ();
}
}


public static void log(String sMsg)
{
System.err.println(sMsg);
}


public static void log(int sMsg)
{
System.err.println(sMsg);
}
}


/*
**TestMethod.java
*/
package NetFox;


public class TestMethod {


public TestMethod()
{ ///xx/weblogic60b2_win.exe
try{
SiteInfoBean bean = new SiteInfoBean("http://localhost/xx/weblogic60b2_win.exe","L:\\temp","weblogic60b2_win.exe",5);
//SiteInfoBean bean = new SiteInfoBean("http://localhost:8080/down.zip","L:\\temp","weblogic60b2_win.exe",5);
SiteFileFetch fileFetch = new SiteFileFetch(bean);
fileFetch.start();
}
catch(Exception e){e.printStackTrace ();}


}


public static void main(String[] args)
{
new TestMethod();
}
}

import java.awt.*;
import javax.swing.*;

/**
*
* <p>Title: MyJava</p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004－2008</p>
* <p>Company: b9527</p>
* @author robertb9527
* @version 1.0
*/
public class RobTTSApp {
  boolean packFrame = false;

  //Construct the application
  public RobTTSApp() {
    TTSFrame frame = new TTSFrame();
    //Validate frames that have preset sizes
    //Pack frames that have useful preferred size info, e.g. from their layout
    if (packFrame) {
      frame.pack();
    }
    else {
      frame.validate();
    }
    //Center the window
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    Dimension frameSize = frame.getSize();
    if (frameSize.height > screenSize.height) {
      frameSize.height = screenSize.height;
    }
    if (frameSize.width > screenSize.width) {
      frameSize.width = screenSize.width;
    }
    frame.setLocation( (screenSize.width - frameSize.width) / 2,
                      (screenSize.height - frameSize.height) / 2);
    frame.setVisible(true);
  }

  //Main method
  public static void main(String[] args) {
    try {
      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    new RobTTSApp();
  }
}

2。窗体TTSFrame.java

import java.util.*;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import com.sun.speech.freetts.*;

/**
*
* <p>Title: MyJava</p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004－2008</p>
* <p>Company: b9527</p>
* @author robertb9527
* @version 1.0
*/
public class TTSFrame
    extends JFrame {
  JPanel contentPane;
  JScrollPane jScrollPane1 = new JScrollPane();
  JScrollPane jScrollPane2 = new JScrollPane();
  JTextArea from = new JTextArea();
  JTextArea to = new JTextArea();
  JButton jButton1 = new JButton();
  JButton jButton2 = new JButton();
  JLabel jLabel1 = new JLabel();

  //Construct the frame
  public TTSFrame() {
    enableEvents(AWTEvent.WINDOW_EVENT_MASK);
    try {
      jbInit();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }

  //Component initialization
  private void jbInit() throws Exception {
    contentPane = (JPanel)this.getContentPane();
    contentPane.setLayout(null);
    this.setSize(new Dimension(479, 406));
    this.setTitle("robTTS");
    jScrollPane1.setBounds(new Rectangle(108, 25, 282, 124));
    jScrollPane2.setBounds(new Rectangle(108, 172, 282, 122));
    jButton1.setBounds(new Rectangle(14, 176, 74, 27));
    jButton1.setText("转换");
    jButton1.addActionListener(new TTSFrame_jButton1_actionAdapter(this));
    jButton2.setBounds(new Rectangle(194, 321, 76, 25));
    jButton2.setText("朗读");
    jButton2.addActionListener(new TTSFrame_jButton2_actionAdapter(this));
    jLabel1.setText("输入原文：");
    jLabel1.setBounds(new Rectangle(20, 26, 71, 31));
    from.setText("");
    to.setText("");

    from.setLineWrap(true);
    contentPane.add(jLabel1, null);
    contentPane.add(jButton1, null);
    contentPane.add(jScrollPane1, null);
    contentPane.add(jScrollPane2, null);
    contentPane.add(jButton2, null);
    jScrollPane2.getViewport().add(to, null);
    jScrollPane1.getViewport().add(from, null);
  }

  //Overridden so we can exit when window is closed
  protected void processWindowEvent(WindowEvent e) {
    super.processWindowEvent(e);
    if (e.getID() == WindowEvent.WINDOW_CLOSING) {
      System.exit(0);
    }
  }

  void jButton1_actionPerformed(ActionEvent e) {
    if (from.getText().length() == 0) {
      JOptionPane.showMessageDialog(from, "输入原文窗体框为空!", "Warning",
                                    JOptionPane.WARNING_MESSAGE);
    }
    String text = from.getText();
    to.setText(TTSKernel.getFullSpell(text));
    // c.pack();
  }

  void jButton2_actionPerformed(ActionEvent e) {
    String textTo = to.getText();

    String voiceName = "kevin16";
    System.out.println();
    System.out.println("使用声音: " + voiceName);

    /* The VoiceManager manages all the voices for FreeTTS.
     */
    VoiceManager voiceManager = VoiceManager.getInstance();
    Voice helloVoice = voiceManager.getVoice(voiceName);

    if (helloVoice == null) {
      System.err.println(
          "找不到你所指定的声音. "
          + voiceName + "请选择另一种.");
      System.exit(1);
    }

    /* Allocates the resources for the voice.
     */
    helloVoice.allocate();
    Locale a = helloVoice.getLocale();
    System.out.println(a.getLanguage());
    /* Synthesize speech.
     */
    helloVoice.speak(textTo);
    /* Clean up and leave.
     */
    helloVoice.deallocate();

  }

}

class TTSFrame_jButton1_actionAdapter
    implements java.awt.event.ActionListener {
  TTSFrame adaptee;

  TTSFrame_jButton1_actionAdapter(TTSFrame adaptee) {
    this.adaptee = adaptee;
  }

  public void actionPerformed(ActionEvent e) {
    adaptee.jButton1_actionPerformed(e);
  }
}

class TTSFrame_jButton2_actionAdapter
    implements java.awt.event.ActionListener {
  TTSFrame adaptee;

  TTSFrame_jButton2_actionAdapter(TTSFrame adaptee) {
    this.adaptee = adaptee;
  }

  public void actionPerformed(ActionEvent e) {
    adaptee.jButton2_actionPerformed(e);
  }
}

3。汉字转拼音TTSChange.java

import java.util.*;

/**
*
* <p>Title: MyJava</p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2004－2008</p>
* <p>Company: b9527</p>
* @author robertb9527
* @version 1.0
*/
public class TTSChange {
  private static LinkedHashMap spellMap = null;

  static {
    if (spellMap == null) {
      spellMap = new LinkedHashMap(400);
    }
    initialize();
    System.out.println("转换准备完成。");
  }

  private TTSKernel() {
  }

  private static void spellPut(String spell, int ascii) {
    spellMap.put(spell, new Integer(ascii));
  }

  private static void initialize() {
    spellPut("a", -20319);
    spellPut("ai", -20317);
    spellPut("an", -20304);
    spellPut("ang", -20295);
    spellPut("ao", -20292);
    spellPut("ba", -20283);
    spellPut("bai", -20265);
    spellPut("ban", -20257);
    spellPut("bang", -20242);
    spellPut("bao", -20230);
    spellPut("bei", -20051);
    spellPut("ben", -20036);
    spellPut("beng", -20032);
    spellPut("bi", -20026);
    spellPut("bian", -20002);
    spellPut("biao", -19990);
    spellPut("bie", -19986);
    spellPut("bin", -19982);
    spellPut("bing", -19976);
    spellPut("bo", -19805);
    spellPut("bu", -19784);
    spellPut("ca", -19775);
    spellPut("cai", -19774);
    spellPut("can", -19763);
    spellPut("cang", -19756);
    spellPut("cao", -19751);
    spellPut("ce", -19746);
    spellPut("ceng", -19741);
    spellPut("cha", -19739);
    spellPut("chai", -19728);
    spellPut("chan", -19725);
    spellPut("chang", -19715);
    spellPut("chao", -19540);
    spellPut("che", -19531);
    spellPut("chen", -19525);
    spellPut("cheng", -19515);
    spellPut("chi", -19500);
    spellPut("chong", -19484);
    spellPut("chou", -19479);
    spellPut("chu", -19467);
    spellPut("chuai", -19289);
    spellPut("chuan", -19288);
    spellPut("chuang", -19281);
    spellPut("chui", -19275);
    spellPut("chun", -19270);
    spellPut("chuo", -19263);
    spellPut("ci", -19261);
    spellPut("cong", -19249);
    spellPut("cou", -19243);
    spellPut("cu", -19242);
    spellPut("cuan", -19238);
    spellPut("cui", -19235);
    spellPut("cun", -19227);
    spellPut("cuo", -19224);
    spellPut("da", -19218);
    spellPut("dai", -19212);
    spellPut("dan", -19038);
    spellPut("dang", -19023);
    spellPut("dao", -19018);
    spellPut("de", -19006);
    spellPut("deng", -19003);
    spellPut("di", -18996);
    spellPut("dian", -18977);
    spellPut("diao", -18961);
    spellPut("die", -18952);
    spellPut("ding", -18783);
    spellPut("diu", -18774);
    spellPut("dong", -18773);
    spellPut("dou", -18763);
    spellPut("du", -18756);
    spellPut("duan", -18741);
    spellPut("dui", -18735);
    spellPut("dun", -18731);
    spellPut("duo", -18722);
    spellPut("e", -18710);
    spellPut("en", -18697);
    spellPut("er", -18696);
    spellPut("fa", -18526);
    spellPut("fan", -18518);
    spellPut("fang", -18501);
    spellPut("fei", -18490);
    spellPut("fen", -18478);
    spellPut("feng", -18463);
    spellPut("fo", -18448);
    spellPut("fou", -18447);
    spellPut("fu", -18446);
    spellPut("ga", -18239);
    spellPut("gai", -18237);
    spellPut("gan", -18231);
    spellPut("gang", -18220);
    spellPut("gao", -18211);
    spellPut("ge", -18201);
    spellPut("gei", -18184);
    spellPut("gen", -18183);
    spellPut("geng", -18181);
    spellPut("gong", -18012);
    spellPut("gou", -17997);
    spellPut("gu", -17988);
    spellPut("gua", -17970);
    spellPut("guai", -17964);
    spellPut("guan", -17961);
    spellPut("guang", -17950);
    spellPut("gui", -17947);
    spellPut("gun", -17931);
    spellPut("guo", -17928);
    spellPut("ha", -17922);
    spellPut("hai", -17759);
    spellPut("han", -17752);
    spellPut("hang", -17733);
    spellPut("hao", -17730);
    spellPut("he", -17721);
    spellPut("hei", -17703);
    spellPut("hen", -17701);
    spellPut("heng", -17697);
    spellPut("hong", -17692);
    spellPut("hou", -17683);
    spellPut("hu", -17676);
    spellPut("hua", -17496);
    spellPut("huai", -17487);
    spellPut("huan", -17482);
    spellPut("huang", -17468);
    spellPut("hui", -17454);
    spellPut("hun", -17433);
    spellPut("huo", -17427);
    spellPut("ji", -17417);
    spellPut("jia", -17202);
    spellPut("jian", -17185);
    spellPut("jiang", -16983);
    spellPut("jiao", -16970);
    spellPut("jie", -16942);
    spellPut("jin", -16915);
    spellPut("jing", -16733);
    spellPut("jiong", -16708);
    spellPut("jiu", -16706);
    spellPut("ju", -16689);
    spellPut("juan", -16664);
    spellPut("jue", -16657);
    spellPut("jun", -16647);
    spellPut("ka", -16474);
    spellPut("kai", -16470);
    spellPut("kan", -16465);
    spellPut("kang", -16459);
    spellPut("kao", -16452);
    spellPut("ke", -16448);
    spellPut("ken", -16433);
    spellPut("keng", -16429);
    spellPut("kong", -16427);
    spellPut("kou", -16423);
    spellPut("ku", -16419);
    spellPut("kua", -16412);
    spellPut("kuai", -16407);
    spellPut("kuan", -16403);
    spellPut("kuang", -16401);
    spellPut("kui", -16393);
    spellPut("kun", -16220);
    spellPut("kuo", -16216);
    spellPut("la", -16212);
    spellPut("lai", -16205);
    spellPut("lan", -16202);
    spellPut("lang", -16187);
    spellPut("lao", -16180);
    spellPut("le", -16171);
    spellPut("lei", -16169);
    spellPut("leng", -16158);
    spellPut("li", -16155);
    spellPut("lia", -15959);
    spellPut("lian", -15958);
    spellPut("liang", -15944);
    spellPut("liao", -15933);
    spellPut("lie", -15920);
    spellPut("lin", -15915);
    spellPut("ling", -15903);
    spellPut("liu", -15889);
    spellPut("long", -15878);
    spellPut("lou", -15707);
    spellPut("lu", -15701);
    spellPut("lv", -15681);
    spellPut("luan", -15667);
    spellPut("lue", -15661);
    spellPut("lun", -15659);
    spellPut("luo", -15652);
    spellPut("ma", -15640);
    spellPut("mai", -15631);
    spellPut("man", -15625);
    spellPut("mang", -15454);
    spellPut("mao", -15448);
    spellPut("me", -15436);
    spellPut("mei", -15435);
    spellPut("men", -15419);
    spellPut("meng", -15416);
    spellPut("mi", -15408);
    spellPut("mian", -15394);
    spellPut("miao", -15385);
    spellPut("mie", -15377);
    spellPut("min", -15375);
    spellPut("ming", -15369);
    spellPut("miu", -15363);
    spellPut("mo", -15362);
    spellPut("mou", -15183);
    spellPut("mu", -15180);
    spellPut("na", -15165);
    spellPut("nai", -15158);
    spellPut("nan", -15153);
    spellPut("nang", -15150);
    spellPut("nao", -15149);
    spellPut("ne", -15144);
    spellPut("nei", -15143);
    spellPut("nen", -15141);
    spellPut("neng", -15140);
    spellPut("ni", -15139);
    spellPut("nian", -15128);
    spellPut("niang", -15121);
    spellPut("niao", -15119);
    spellPut("nie", -15117);
    spellPut("nin", -15110);
    spellPut("ning", -15109);
    spellPut("niu", -14941);
    spellPut("nong", -14937);
    spellPut("nu", -14933);
    spellPut("nv", -14930);
    spellPut("nuan", -14929);
    spellPut("nue", -14928);
    spellPut("nuo", -14926);
    spellPut("o", -14922);
    spellPut("ou", -14921);
    spellPut("pa", -14914);
    spellPut("pai", -14908);
    spellPut("pan", -14902);
    spellPut("pang", -14894);
    spellPut("pao", -14889);
    spellPut("pei", -14882);
    spellPut("pen", -14873);
    spellPut("peng", -14871);
    spellPut("pi", -14857);
    spellPut("pian", -14678);
    spellPut("piao", -14674);
    spellPut("pie", -14670);
    spellPut("pin", -14668);
    spellPut("ping", -14663);
    spellPut("po", -14654);
    spellPut("pu", -14645);
    spellPut("qi", -14630);
    spellPut("qia", -14594);
    spellPut("qian", -14429);
    spellPut("qiang", -14407);
    spellPut("qiao", -14399);
    spellPut("qie", -14384);
    spellPut("qin", -14379);
    spellPut("qing", -14368);
    spellPut("qiong", -14355);
    spellPut("qiu", -14353);
    spellPut("qu", -14345);
    spellPut("quan", -14170);
    spellPut("que", -14159);
    spellPut("qun", -14151);
    spellPut("ran", -14149);
    spellPut("rang", -14145);
    spellPut("rao", -14140);
    spellPut("re", -14137);
    spellPut("ren", -14135);
    spellPut("reng", -14125);
    spellPut("ri", -14123);
    spellPut("rong", -14122);
    spellPut("rou", -14112);
    spellPut("ru", -14109);
    spellPut("ruan", -14099);
    spellPut("rui", -14097);
    spellPut("run", -14094);
    spellPut("ruo", -14092);
    spellPut("sa", -14090);
    spellPut("sai", -14087);
    spellPut("san", -14083);
    spellPut("sang", -13917);
    spellPut("sao", -13914);
    spellPut("se", -13910);
    spellPut("sen", -13907);
    spellPut("seng", -13906);
    spellPut("sha", -13905);
    spellPut("shai", -13896);
    spellPut("shan", -13894);
    spellPut("shang", -13878);
    spellPut("shao", -13870);
    spellPut("she", -13859);
    spellPut("shen", -13847);
    spellPut("sheng", -13831);
    spellPut("shi", -13658);
    spellPut("shou", -13611);
    spellPut("shu", -13601);
    spellPut("shua", -13406);
    spellPut("shuai", -13404);
    spellPut("shuan", -13400);
    spellPut("shuang", -13398);
    spellPut("shui", -13395);
    spellPut("shun", -13391);
    spellPut("shuo", -13387);
    spellPut("si", -13383);
    spellPut("song", -13367);
    spellPut("sou", -13359);
    spellPut("su", -13356);
    spellPut("suan", -13343);
    spellPut("sui", -13340);
    spellPut("sun", -13329);
    spellPut("suo", -13326);
    spellPut("ta", -13318);
    spellPut("tai", -13147);
    spellPut("tan", -13138);
    spellPut("tang", -13120);
    spellPut("tao", -13107);
    spellPut("te", -13096);
    spellPut("teng", -13095);
    spellPut("ti", -13091);
    spellPut("tian", -13076);
    spellPut("tiao", -13068);
    spellPut("tie", -13063);
    spellPut("ting", -13060);
    spellPut("tong", -12888);
    spellPut("tou", -12875);
    spellPut("tu", -12871);
    spellPut("tuan", -12860);
    spellPut("tui", -12858);
    spellPut("tun", -12852);
    spellPut("tuo", -12849);
    spellPut("wa", -12838);
    spellPut("wai", -12831);
    spellPut("wan", -12829);
    spellPut("wang", -12812);
    spellPut("wei", -12802);
    spellPut("wen", -12607);
    spellPut("weng", -12597);
    spellPut("wo", -12594);
    spellPut("wu", -12585);
    spellPut("xi", -12556);
    spellPut("xia", -12359);
    spellPut("xian", -12346);
    spellPut("xiang", -12320);
    spellPut("xiao", -12300);
    spellPut("xie", -12120);
    spellPut("xin", -12099);
    spellPut("xing", -12089);
    spellPut("xiong", -12074);
    spellPut("xiu", -12067);
    spellPut("xu", -12058);
    spellPut("xuan", -12039);
    spellPut("xue", -11867);
    spellPut("xun", -11861);
    spellPut("ya", -11847);
    spellPut("yan", -11831);
    spellPut("yang", -11798);
    spellPut("yao", -11781);
    spellPut("ye", -11604);
    spellPut("yi", -11589);
    spellPut("yin", -11536);
    spellPut("ying", -11358);
    spellPut("yo", -11340);
    spellPut("yong", -11339);
    spellPut("you", -11324);
    spellPut("yu", -11303);
    spellPut("yuan", -11097);
    spellPut("yue", -11077);
    spellPut("yun", -11067);
    spellPut("za", -11055);
    spellPut("zai", -11052);
    spellPut("zan", -11045);
    spellPut("zang", -11041);
    spellPut("zao", -11038);
    spellPut("ze", -11024);
    spellPut("zei", -11020);
    spellPut("zen", -11019);
    spellPut("zeng", -11018);
    spellPut("zha", -11014);
    spellPut("zhai", -10838);
    spellPut("zhan", -10832);
    spellPut("zhang", -10815);
    spellPut("zhao", -10800);
    spellPut("zhe", -10790);
    spellPut("zhen", -10780);
    spellPut("zheng", -10764);
    spellPut("zhi", -10587);
    spellPut("zhong", -10544);
    spellPut("zhou", -10533);
    spellPut("zhu", -10519);
    spellPut("zhua", -10331);
    spellPut("zhuai", -10329);
    spellPut("zhuan", -10328);
    spellPut("zhuang", -10322);
    spellPut("zhui", -10315);
    spellPut("zhun", -10309);
    spellPut("zhuo", -10307);
    spellPut("zi", -10296);
    spellPut("zong", -10281);
    spellPut("zou", -10274);
    spellPut("zu", -10270);
    spellPut("zuan", -10262);
    spellPut("zui", -10260);
    spellPut("zun", -10256);
    spellPut("zuo", -10254);
    spellPut("zz", -10247);
  }

  /**
   * 获得单个汉字的Ascii.
   */
  public static int getCnAscii(char cn) {
    byte[] bytes = (String.valueOf(cn)).getBytes();
    if (bytes == null || bytes.length > 2 || bytes.length <= 0) { //错误
      return 0;
    }
    if (bytes.length == 1) { //英文字符
      return bytes[0];
    }
    if (bytes.length == 2) { //中文字符
      int hightByte = 256 + bytes[0];
      int lowByte = 256 + bytes[1];

      int ascii = (256 * hightByte + lowByte) - 256 * 256;

      //System.out.println("ASCII=" + ascii);

      return ascii;
    }

    return 0; //错误
  }

  /**
   * 根据ASCII码到SpellMap中查找对应的拼音
   */
  public static String getSpellByAscii(int ascii) {
    if (ascii > 0 && ascii < 160) { //单字符
      return String.valueOf( (char) ascii);
    }

    if (ascii < -20319 || ascii > -10247) { //不知道的字符
      return null;
    }

    Set keySet = spellMap.keySet();
    Iterator it = keySet.iterator();

    String spell0 = null; ;
    String spell = null;

    int asciiRang0 = -20319;
    int asciiRang;
    while (it.hasNext()) {

      spell = (String) it.next();
      Object valObj = spellMap.get(spell);
      if (valObj instanceof Integer) {
        asciiRang = ( (Integer) valObj).intValue();

        if (ascii >= asciiRang0 && ascii < asciiRang) { //区间找到
          return (spell0 == null) ? spell : spell0;
        }
        else {
          spell0 = spell;
          asciiRang0 = asciiRang;
        }
      }
    }

    return null;

  }

  /**
   * 返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换
   */
  public static String getFullSpell(String cnStr) {
    if (null == cnStr || "".equals(cnStr.trim())) {
      return cnStr;
    }

    char[] chars = cnStr.toCharArray();
    StringBuffer retuBuf = new StringBuffer();
    for (int i = 0, Len = chars.length; i < Len; i++) {
      int ascii = getCnAscii(chars[i]);
      if (ascii == 0) { //取ascii时出错
        retuBuf.append(chars[i]);
        retuBuf.append(" ");
      }
      else {
        String spell = getSpellByAscii(ascii);
        if (spell == null) {
          retuBuf.append(chars[i]);
          retuBuf.append(" ");
        }
        else {
          retuBuf.append(spell);
          retuBuf.append(" ");
        } // end of if spell == null
      } // end of if ascii <= -20400
    } // end of for

    return retuBuf.toString();
  }

  public static String getFirstSpell(String cnStr) {
    return null;
  }

  }
}

说明：1。freeTTS可以从网上免费获得源码。

      2。汉字转拼音只是初级的，未能区分多音字等，也不能分词。

      3。freeTTS对于中文的朗读效果不好。

检查字符串是否为空或null或仅仅包含空格
  String test = "";
  String test1=" ";
  String test2 = "\n\n\t";
  String test3 = null;
  System.out.println( "test blank? " + StringUtils.isBlank( test ) );
  System.out.println( "test1 blank? " + StringUtils.isBlank( test1 ) );
  System.out.println( "test2 blank? " + StringUtils.isBlank( test2 ) );
  System.out.println( "test3 blank? " + StringUtils.isBlank( test3 ) );
  运行结果：
  test blank? true
  test1 blank? true
  test2 blank? true
  test3 blank? true
  相对应的还有一个StringUtils.isNotBlank(String str)
  StringUtils.isEmpty(String str)则检查字符串是否为空或null（不检查是否仅仅包含空格）
  
  分解字符串
  StringUtils.split(null, *, *)            = null
  StringUtils.split("", *, *)              = []
  StringUtils.split("ab de fg", null, 0)   = ["ab", "cd", "ef"]
  StringUtils.split("ab   de fg", null, 0) = ["ab", "cd", "ef"]
  StringUtils.split("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
  StringUtils.split("ab:cd:ef", ":", 1)    = ["ab:cd:ef"]
  StringUtils.split("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
  StringUtils.split(String str,String separatorChars,int max) str为null时返回null
  separatorChars为null时默认为按空格分解，max为0或负数时分解没有限制，max为1时返回整个字符串，max为分解成的个数（大于实际则无效）
  
  去除字符串前后指定的字符
  StringUtils.strip(null, *)          = null
  StringUtils.strip("", *)            = ""
  StringUtils.strip("abc", null)      = "abc"
  StringUtils.strip(" abc ", null)    = "abc"
  StringUtils.strip("  abcyx", "xyz") = "  abc"
  StringUtils.strip(String str,String stripChars) str为null时返回null,stripChars为null时默认为空格

  创建醒目的Header（调试时用）
  public String createHeader( String title ) {
    int width = 30;
    String stars = StringUtils.repeat( "*", width);
    String centered = StringUtils.center( title, width, "*" );
    String heading = StringUtils.join(new Object[]{stars, centered, stars}, "\n");
    return heading;
  }
  调用createHeader("TEST")的输出结果:
  ******************************
  ************ TEST ************
  ******************************

  字符的全部反转及以单个词为单位的反转
  String original = "In time, I grew tired of his babbling nonsense.";
  StringUtils.reverse( original )   = ".esnesnon gnilbbab sih fo derit werg I ,emit nI"
  以单个词为单位的反转
  public Sentence reverseSentence(String sentence) {
    String reversed = StringUtils.chomp( sentence, "." );
    reversed = StringUtils.reverseDelimited( reversed, ' ' );
    reversed = reversed + ".";
    return reversed;
  }
  String sentence = "I am Susan."
  reverseSentence( sentence ) )   = "Susan am I."

  检查字符串是否仅仅包含数字、字母或数字和字母的混合
  String test1 = "ORANGE";
  String test2 = "ICE9";
  String test3 = "ICE CREAM";
  String test4 = "820B Judson Avenue";
  String test5 = "1976";
  结果：
  boolean t1val = StringUtils.isAlpha( test1 ); // returns true
  boolean t2val = StringUtils.isAlphanumeric( test2 ); // returns true
  boolean t3val = StringUtils.isAlphaSpace( test3 ); // returns true
  boolean t4val = StringUtils.isAlphanumericSpace( test4 ); // returns true
  boolean t5val = StringUtils.isNumeric( test5 ); // returns true

ArrayUtils类使用

primitive 数组克隆及反转排序
  long[] array = { 1, 3, 2, 3, 5, 6 };
  long[] reversed = ArrayUtils.clone( array );
  ArrayUtils.reverse( reversed );
  System.out.println( "Original: " + ArrayUtils.toString( array ) );   //打印
  System.out.println( "Reversed: " + ArrayUtils.toString( reversed ) );
  
  对象数组克隆及反转排序
  Long[] array = new Long[] { new Long(3), new Long(56), new Long(233) };
  Long[] reversed = ArrayUtils.clone( array );
  ArrayUtils.reverse( reversed );
  
  primitive 数组与对象数组之间的转换
  long[] primitiveArray = new long[] { 12, 100, 2929, 3323 };
  Long[] objectArray = ArrayUtils.toObject( primitiveArray );
  Double[] doubleObjects = new Double[] { new Double( 3.22, 5.222, 3.221 ) };
  double[] doublePrimitives = ArrayUtils.toPrimitive( doubleObject );
  注意：对象数组可以含有null元素，primitive 数组则不容许含有null元素，所以对象数组转换为primitive 数组时，可以添入第二个参数，当碰到为null的元素时用其代替（如下，Double.NaN）。如果不添入第二个参数，当碰到为null的元素时，则会抛出NullPointerException 。
  double[] result = ArrayUtils.toPrimitive( resultObjArray, Double.NaN  );
  
  查找一个数组中是否含有特定的元素（查找对象数组时，比较的是对象的equals()方法），及特定元素的第一次出现位置和最后一次出现位置
  String[] stringArray = { "Red", "Orange", "Blue", "Brown", "Red" };
  boolean containsBlue = ArrayUtils.contains( stringArray, "Blue" );
  int indexOfRed = ArrayUtils.indexOf( stringArray, "Red");
  int lastIndexOfRed = ArrayUtils.lastIndexOf( string, "Red" );  
  
  由二维对象数组创建一个 Map
  Object[] weightArray =
    new Object[][] { {"H" , new Double( 1.007)},
                     {"He", new Double( 4.002)},
                     {"Li", new Double( 6.941)},
                     {"Be", new Double( 9.012)},
                     {"B",  new Double(10.811)},
                     {"C",  new Double(12.010)},
                     {"N",  new Double(14.007)},
                     {"O",  new Double(15.999)},
                     {"F",  new Double(18.998)},
                     {"Ne", new Double(20.180)} };

  Map weights = ArrayUtils.toMap( weightArray );
  Double hydrogenWeight = （Double)weights.get( "H" );
  注意：当二维对象数组"key"值重复时，创建的Map，后面的键-值对会把前面的覆盖掉

最近由于项目的特殊需求，我们必须在程序调用window的dll。
开始我们用jni，后来由于调用的dll太多，而且很烦琐。所以，我们决定用开源的jawin调用。
jawin 可以对dll中的方法进行调用，也可以调用com中的方法.内部还提供了一个工具，直接对 com组件导出成 java的类，个人认为很方便。

下面是我们作的一个测试，很顺利便通过了。
1、下载jawin：http://jawinproject.sourceforge.net/。
2、配置：
    》将jawin.jar放于%JAVA_HOME%\jre\lib\ext下 。
    》将jawin.dll放于c:\winnt\system32下。否则将出现错误：COMException : no jawin in java.library.path；
    也可将jawin.dll放于每个项目目录下。

   》至此在Editplus中调试Jawin/NJawin的例子，可以通过。 而在Eclipse中有时还会出上面的错误：COMException : no jawin in java.library.path。
   》在Eclipse中，菜单->window->preference->Java->installed JREs 将原来的remove,重新建一个指到你的java sdk目录。
   》 ok了。
3、程序测试：

     》调用 dll，dll 的方式不需要导出了,直接调用就可以了，下面是下载的包中提供的一个例子:
     》我在win2000下，测试通过。
/*
* Created on Dec 22, 2005
*
*/
import org.jawin.FuncPtr;

import org.jawin.ReturnFlags;

/**
* @author gf  mail to gf@163.com
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class GfJawinTest {

       public static void main(String[] args) {

              try {

                     FuncPtr msgBox = new FuncPtr("USER32.DLL", "MessageBoxW");

                     msgBox.invoke_I(0, "Hello From a DLL", "From Jawin", 0, ReturnFlags.CHECK_NONE);

              } catch (Exception e) {

                     e.printStackTrace();

              }

       }

}

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Set;

/**
 *
 汉字转化为全拼
 *
 JDK版本:  1.4

public class CnToSpell {
    private static LinkedHashMap spellMap = null;

    static {
        if (spellMap == null) {
            spellMap = new LinkedHashMap(400);
        }
        initialize();
        System.out.println("Chinese transfer Spell Done.");
    }

    private CnToSpell() {
    }

    private static void spellPut(String spell, int ascii) {
        spellMap.put(spell, new Integer(ascii));
    }

    private static void initialize() {
        spellPut("a", -20319);
        spellPut("ai", -20317);
        spellPut("an", -20304);
        spellPut("ang", -20295);
        spellPut("ao", -20292);
        spellPut("ba", -20283);
        spellPut("bai", -20265);
        spellPut("ban", -20257);
        spellPut("bang", -20242);
        spellPut("bao", -20230);
        spellPut("bei", -20051);
        spellPut("ben", -20036);
        spellPut("beng", -20032);
        spellPut("bi", -20026);
        spellPut("bian", -20002);
        spellPut("biao", -19990);
        spellPut("bie", -19986);
        spellPut("bin", -19982);
        spellPut("bing", -19976);
        spellPut("bo", -19805);
        spellPut("bu", -19784);
        spellPut("ca", -19775);
        spellPut("cai", -19774);
        spellPut("can", -19763);
        spellPut("cang", -19756);
        spellPut("cao", -19751);
        spellPut("ce", -19746);
        spellPut("ceng", -19741);
        spellPut("cha", -19739);
        spellPut("chai", -19728);
        spellPut("chan", -19725);
        spellPut("chang", -19715);
        spellPut("chao", -19540);
        spellPut("che", -19531);
        spellPut("chen", -19525);
        spellPut("cheng", -19515);
        spellPut("chi", -19500);
        spellPut("chong", -19484);
        spellPut("chou", -19479);
        spellPut("chu", -19467);
        spellPut("chuai", -19289);
        spellPut("chuan", -19288);
        spellPut("chuang", -19281);
        spellPut("chui", -19275);
        spellPut("chun", -19270);
        spellPut("chuo", -19263);
        spellPut("ci", -19261);
        spellPut("cong", -19249);
        spellPut("cou", -19243);
        spellPut("cu", -19242);
        spellPut("cuan", -19238);
        spellPut("cui", -19235);
        spellPut("cun", -19227);
        spellPut("cuo", -19224);
        spellPut("da", -19218);
        spellPut("dai", -19212);
        spellPut("dan", -19038);
        spellPut("dang", -19023);
        spellPut("dao", -19018);
        spellPut("de", -19006);
        spellPut("deng", -19003);
        spellPut("di", -18996);
        spellPut("dian", -18977);
        spellPut("diao", -18961);
        spellPut("die", -18952);
        spellPut("ding", -18783);
        spellPut("diu", -18774);
        spellPut("dong", -18773);
        spellPut("dou", -18763);
        spellPut("du", -18756);
        spellPut("duan", -18741);
        spellPut("dui", -18735);
        spellPut("dun", -18731);
        spellPut("duo", -18722);
        spellPut("e", -18710);
        spellPut("en", -18697);
        spellPut("er", -18696);
        spellPut("fa", -18526);
        spellPut("fan", -18518);
        spellPut("fang", -18501);
        spellPut("fei", -18490);
        spellPut("fen", -18478);
        spellPut("feng", -18463);
        spellPut("fo", -18448);
        spellPut("fou", -18447);
        spellPut("fu", -18446);
        spellPut("ga", -18239);
        spellPut("gai", -18237);
        spellPut("gan", -18231);
        spellPut("gang", -18220);
        spellPut("gao", -18211);
        spellPut("ge", -18201);
        spellPut("gei", -18184);
        spellPut("gen", -18183);
        spellPut("geng", -18181);
        spellPut("gong", -18012);
        spellPut("gou", -17997);
        spellPut("gu", -17988);
        spellPut("gua", -17970);
        spellPut("guai", -17964);
        spellPut("guan", -17961);
        spellPut("guang", -17950);
        spellPut("gui", -17947);
        spellPut("gun", -17931);
        spellPut("guo", -17928);
        spellPut("ha", -17922);
        spellPut("hai", -17759);
        spellPut("han", -17752);
        spellPut("hang", -17733);
        spellPut("hao", -17730);
        spellPut("he", -17721);
        spellPut("hei", -17703);
        spellPut("hen", -17701);
        spellPut("heng", -17697);
        spellPut("hong", -17692);
        spellPut("hou", -17683);
        spellPut("hu", -17676);
        spellPut("hua", -17496);
        spellPut("huai", -17487);
        spellPut("huan", -17482);
        spellPut("huang", -17468);
        spellPut("hui", -17454);
        spellPut("hun", -17433);
        spellPut("huo", -17427);
        spellPut("ji", -17417);
        spellPut("jia", -17202);
        spellPut("jian", -17185);
        spellPut("jiang", -16983);
        spellPut("jiao", -16970);
        spellPut("jie", -16942);
        spellPut("jin", -16915);
        spellPut("jing", -16733);
        spellPut("jiong", -16708);
        spellPut("jiu", -16706);
        spellPut("ju", -16689);
        spellPut("juan", -16664);
        spellPut("jue", -16657);
        spellPut("jun", -16647);
        spellPut("ka", -16474);
        spellPut("kai", -16470);
        spellPut("kan", -16465);
        spellPut("kang", -16459);
        spellPut("kao", -16452);
        spellPut("ke", -16448);
        spellPut("ken", -16433);
        spellPut("keng", -16429);
        spellPut("kong", -16427);
        spellPut("kou", -16423);
        spellPut("ku", -16419);
        spellPut("kua", -16412);
        spellPut("kuai", -16407);
        spellPut("kuan", -16403);
        spellPut("kuang", -16401);
        spellPut("kui", -16393);
        spellPut("kun", -16220);
        spellPut("kuo", -16216);
        spellPut("la", -16212);
        spellPut("lai", -16205);
        spellPut("lan", -16202);
        spellPut("lang", -16187);
        spellPut("lao", -16180);
        spellPut("le", -16171);
        spellPut("lei", -16169);
        spellPut("leng", -16158);
        spellPut("li", -16155);
        spellPut("lia", -15959);
        spellPut("lian", -15958);
        spellPut("liang", -15944);
        spellPut("liao", -15933);
        spellPut("lie", -15920);
        spellPut("lin", -15915);
        spellPut("ling", -15903);
        spellPut("liu", -15889);
        spellPut("long", -15878);
        spellPut("lou", -15707);
        spellPut("lu", -15701);
        spellPut("lv", -15681);
        spellPut("luan", -15667);
        spellPut("lue", -15661);
        spellPut("lun", -15659);
        spellPut("luo", -15652);
        spellPut("ma", -15640);
        spellPut("mai", -15631);
        spellPut("man", -15625);
        spellPut("mang", -15454);
        spellPut("mao", -15448);
        spellPut("me", -15436);
        spellPut("mei", -15435);
        spellPut("men", -15419);
        spellPut("meng", -15416);
        spellPut("mi", -15408);
        spellPut("mian", -15394);
        spellPut("miao", -15385);
        spellPut("mie", -15377);
        spellPut("min", -15375);
        spellPut("ming", -15369);
        spellPut("miu", -15363);
        spellPut("mo", -15362);
        spellPut("mou", -15183);
        spellPut("mu", -15180);
        spellPut("na", -15165);
        spellPut("nai", -15158);
        spellPut("nan", -15153);
        spellPut("nang", -15150);
        spellPut("nao", -15149);
        spellPut("ne", -15144);
        spellPut("nei", -15143);
        spellPut("nen", -15141);
        spellPut("neng", -15140);
        spellPut("ni", -15139);
        spellPut("nian", -15128);
        spellPut("niang", -15121);
        spellPut("niao", -15119);
        spellPut("nie", -15117);
        spellPut("nin", -15110);
        spellPut("ning", -15109);
        spellPut("niu", -14941);
        spellPut("nong", -14937);
        spellPut("nu", -14933);
        spellPut("nv", -14930);
        spellPut("nuan", -14929);
        spellPut("nue", -14928);
        spellPut("nuo", -14926);
        spellPut("o", -14922);
        spellPut("ou", -14921);
        spellPut("pa", -14914);
        spellPut("pai", -14908);
        spellPut("pan", -14902);
        spellPut("pang", -14894);
        spellPut("pao", -14889);
        spellPut("pei", -14882);
        spellPut("pen", -14873);
        spellPut("peng", -14871);
        spellPut("pi", -14857);
        spellPut("pian", -14678);
        spellPut("piao", -14674);
        spellPut("pie", -14670);
        spellPut("pin", -14668);
        spellPut("ping", -14663);
        spellPut("po", -14654);
        spellPut("pu", -14645);
        spellPut("qi", -14630);
        spellPut("qia", -14594);
        spellPut("qian", -14429);
        spellPut("qiang", -14407);
        spellPut("qiao", -14399);
        spellPut("qie", -14384);
        spellPut("qin", -14379);
        spellPut("qing", -14368);
        spellPut("qiong", -14355);
        spellPut("qiu", -14353);
        spellPut("qu", -14345);
        spellPut("quan", -14170);
        spellPut("que", -14159);
        spellPut("qun", -14151);
        spellPut("ran", -14149);
        spellPut("rang", -14145);
        spellPut("rao", -14140);
        spellPut("re", -14137);
        spellPut("ren", -14135);
        spellPut("reng", -14125);
        spellPut("ri", -14123);
        spellPut("rong", -14122);
        spellPut("rou", -14112);
        spellPut("ru", -14109);
        spellPut("ruan", -14099);
        spellPut("rui", -14097);
        spellPut("run", -14094);
        spellPut("ruo", -14092);
        spellPut("sa", -14090);
        spellPut("sai", -14087);
        spellPut("san", -14083);
        spellPut("sang", -13917);
        spellPut("sao", -13914);
        spellPut("se", -13910);
        spellPut("sen", -13907);
        spellPut("seng", -13906);
        spellPut("sha", -13905);
        spellPut("shai", -13896);
        spellPut("shan", -13894);
        spellPut("shang", -13878);
        spellPut("shao", -13870);
        spellPut("she", -13859);
        spellPut("shen", -13847);
        spellPut("sheng", -13831);
        spellPut("shi", -13658);
        spellPut("shou", -13611);
        spellPut("shu", -13601);
        spellPut("shua", -13406);
        spellPut("shuai", -13404);
        spellPut("shuan", -13400);
        spellPut("shuang", -13398);
        spellPut("shui", -13395);
        spellPut("shun", -13391);
        spellPut("shuo", -13387);
        spellPut("si", -13383);
        spellPut("song", -13367);
        spellPut("sou", -13359);
        spellPut("su", -13356);
        spellPut("suan", -13343);
        spellPut("sui", -13340);
        spellPut("sun", -13329);
        spellPut("suo", -13326);
        spellPut("ta", -13318);
        spellPut("tai", -13147);
        spellPut("tan", -13138);
        spellPut("tang", -13120);
        spellPut("tao", -13107);
        spellPut("te", -13096);
        spellPut("teng", -13095);
        spellPut("ti", -13091);
        spellPut("tian", -13076);
        spellPut("tiao", -13068);
        spellPut("tie", -13063);
        spellPut("ting", -13060);
        spellPut("tong", -12888);
        spellPut("tou", -12875);
        spellPut("tu", -12871);
        spellPut("tuan", -12860);
        spellPut("tui", -12858);
        spellPut("tun", -12852);
        spellPut("tuo", -12849);
        spellPut("wa", -12838);
        spellPut("wai", -12831);
        spellPut("wan", -12829);
        spellPut("wang", -12812);
        spellPut("wei", -12802);
        spellPut("wen", -12607);
        spellPut("weng", -12597);
        spellPut("wo", -12594);
        spellPut("wu", -12585);
        spellPut("xi", -12556);
        spellPut("xia", -12359);
        spellPut("xian", -12346);
        spellPut("xiang", -12320);
        spellPut("xiao", -12300);
        spellPut("xie", -12120);
        spellPut("xin", -12099);
        spellPut("xing", -12089);
        spellPut("xiong", -12074);
        spellPut("xiu", -12067);
        spellPut("xu", -12058);
        spellPut("xuan", -12039);
        spellPut("xue", -11867);
        spellPut("xun", -11861);
        spellPut("ya", -11847);
        spellPut("yan", -11831);
        spellPut("yang", -11798);
        spellPut("yao", -11781);
        spellPut("ye", -11604);
        spellPut("yi", -11589);
        spellPut("yin", -11536);
        spellPut("ying", -11358);
        spellPut("yo", -11340);
        spellPut("yong", -11339);
        spellPut("you", -11324);
        spellPut("yu", -11303);
        spellPut("yuan", -11097);
        spellPut("yue", -11077);
        spellPut("yun", -11067);
        spellPut("za", -11055);
        spellPut("zai", -11052);
        spellPut("zan", -11045);
        spellPut("zang", -11041);
        spellPut("zao", -11038);
        spellPut("ze", -11024);
        spellPut("zei", -11020);
        spellPut("zen", -11019);
        spellPut("zeng", -11018);
        spellPut("zha", -11014);
        spellPut("zhai", -10838);
        spellPut("zhan", -10832);
        spellPut("zhang", -10815);
        spellPut("zhao", -10800);
        spellPut("zhe", -10790);
        spellPut("zhen", -10780);
        spellPut("zheng", -10764);
        spellPut("zhi", -10587);
        spellPut("zhong", -10544);
        spellPut("zhou", -10533);
        spellPut("zhu", -10519);
        spellPut("zhua", -10331);
        spellPut("zhuai", -10329);
        spellPut("zhuan", -10328);
        spellPut("zhuang", -10322);
        spellPut("zhui", -10315);
        spellPut("zhun", -10309);
        spellPut("zhuo", -10307);
        spellPut("zi", -10296);
        spellPut("zong", -10281);
        spellPut("zou", -10274);
        spellPut("zu", -10270);
        spellPut("zuan", -10262);
        spellPut("zui", -10260);
        spellPut("zun", -10256);
        spellPut("zuo", -10254);
    }

    /**
     * 获得单个汉字的Ascii.
     * @param cn char
     * 汉字字符
     * @return int
     * 错误返回 0,否则返回ascii
     */
    public static int getCnAscii(char cn) {
        byte[] bytes = (String.valueOf(cn)).getBytes();
        if (bytes == null || bytes.length > 2 || bytes.length <= 0) { //错误
            return 0;
        }
        if (bytes.length == 1) { //英文字符
            return bytes[0];
        }
        if (bytes.length == 2) { //中文字符
            int hightByte = 256 + bytes[0];
            int lowByte = 256 + bytes[1];

            int ascii = (256 * hightByte + lowByte) - 256 * 256;

//System.out.println("ASCII=" + ascii);

            return ascii;
        }

        return 0; //错误
    }

    /**
     * 根据ASCII码到SpellMap中查找对应的拼音
     * @param ascii int
     * 字符对应的ASCII
     * @return String
     * 拼音,首先判断ASCII是否>0&<160,如果是返回对应的字符,
     *
     否则到SpellMap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音.
     */
    public static String getSpellByAscii(int ascii) {
        if (ascii > 0 && ascii < 160) { //单字符
            return String.valueOf((char) ascii);
        }

        if (ascii < -20319 || ascii > -10247) { //不知道的字符
            return null;
        }

        Set keySet = spellMap.keySet();
        Iterator it = keySet.iterator();

        String spell0 = null; ;
        String spell = null;

        int asciiRang0 = -20319;
        int asciiRang;
        while (it.hasNext()) {

            spell = (String) it.next();
            Object valObj = spellMap.get(spell);
            if (valObj instanceof Integer) {
                asciiRang = ((Integer) valObj).intValue();

                if (ascii >= asciiRang0 && ascii < asciiRang) { //区间找到
                    return (spell0 == null) ? spell : spell0;
                } else {
                    spell0 = spell;
                    asciiRang0 = asciiRang;
                }
            }
        }

        return null;

    }

    /**
     * 返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换
     * @param cnStr String
     * 字符串
     * @return String
     * 转换成全拼后的字符串
     */
    public static String getFullSpell(String cnStr) {
        if (null == cnStr || "".equals(cnStr.trim())) {
            return cnStr;
        }

        char[] chars = cnStr.toCharArray();
        StringBuffer retuBuf = new StringBuffer();
        for (int i = 0, Len = chars.length; i < Len; i++) {
            int ascii = getCnAscii(chars[i]);
            if (ascii == 0) { //取ascii时出错
                retuBuf.append(chars[i]);
            } else {
                String spell = getSpellByAscii(ascii);
                if (spell == null) {
                    retuBuf.append(chars[i]);
                } else {
                    retuBuf.append(spell);
                } // end of if spell == null
            } // end of if ascii <= -20400
        } // end of for

        return retuBuf.toString();
    }

    public static String getFirstSpell(String cnStr) {
        return null;
    }

    public static void main(String[] args) {
        String str = null;
        str = "小红帽";
        System.out.println("Spell=" + CnToSpell.getFullSpell(str));   }
}

     public static int getCharCode(String s)
     {
         if(s == null && s.equals(""))
             return -1;
         byte b[] = s.getBytes();
         int value = 0;
         for(int i = 0; i < b.length && i <= 2; i++)
             value = value * 100 + b[i];

         return value;
     }

     public static int chineseCompareTo(String s1, String s2)
     {
         int len1 = s1.length();
         int len2 = s2.length();
         int n = Math.min(len1, len2);
         for(int i = 0; i < n; i++)
         {
             int s1_code = getCharCode(s1.charAt(i) + "");
             int s2_code = getCharCode(s2.charAt(i) + "");
             if(s1_code * s2_code < 0)
                 return Math.min(s1_code, s2_code);
             if(s1_code != s2_code)
                 return s1_code - s2_code;
         }

         return len1 - len2;
     }

     public static String getBeginCharacter(String res)
     {
         String a = res;
         String result = "";
         for(int i = 0; i < a.length(); i++)
         {
             String current = a.substring(i, i + 1);
             if(compare(current, "\u554A") < 0)
                 result = result + current;
             else
             if(compare(current, "\u554A") >= 0 && compare(current, "\u5EA7") <= 0)
                 if(compare(current, "\u531D") >= 0)
                     result = result + "z";
                 else
                 if(compare(current, "\u538B") >= 0)
                     result = result + "y";
                 else
                 if(compare(current, "\u6614") >= 0)
                     result = result + "x";
                 else
                 if(compare(current, "\u6316") >= 0)
                     result = result + "w";
                 else
                 if(compare(current, "\u584C") >= 0)
                     result = result + "t";
                 else
                 if(compare(current, "\u6492") >= 0)
                     result = result + "s";
                 else
                 if(compare(current, "\u7136") >= 0)
                     result = result + "r";
                 else
                 if(compare(current, "\u671F") >= 0)
                     result = result + "q";
                 else
                 if(compare(current, "\u556A") >= 0)
                     result = result + "p";
                 else
                 if(compare(current, "\u54E6") >= 0)
                     result = result + "o";
                 else
                 if(compare(current, "\u62FF") >= 0)
                     result = result + "n";
                 else
                 if(compare(current, "\u5988") >= 0)
                     result = result + "m";
                 else
                 if(compare(current, "\u5783") >= 0)
                     result = result + "l";
                 else
                 if(compare(current, "\u5580") >= 0)
                     result = result + "k";
                 else
                 if(compare(current, "\u51FB") > 0)
                     result = result + "j";
                 else
                 if(compare(current, "\u54C8") >= 0)
                     result = result + "h";
                 else
                 if(compare(current, "\u5676") >= 0)
                     result = result + "g";
                 else
                 if(compare(current, "\u53D1") >= 0)
                     result = result + "f";
                 else
                 if(compare(current, "\u86FE") >= 0)
                     result = result + "e";
                 else
                 if(compare(current, "\u642D") >= 0)
                     result = result + "d";
                 else
                 if(compare(current, "\u64E6") >= 0)
                     result = result + "c";
                 else
                 if(compare(current, "\u82AD") >= 0)
                     result = result + "b";
                 else
                 if(compare(current, "\u554A") >= 0)
                     result = result + "a";
         }

         return result;
     }

     public static String getFirstStr(String str)
     {
         char a = str.charAt(0);
         char aa[] = {
             a
         };
         String sss = new String(aa);
         if(Character.isDigit(aa[0]))
             sss = "data";
         else
         if(a >= 'a' && a <= 'z' || a >= 'A' && a <= 'Z')
             sss = "character";
         else
             sss = getBeginCharacter(sss);
         return sss;
     }

     private static String _FromEncode_ = "GBK";
     private static String _ToEncode_ = "GBK";

}

最新一代的 iPod 媒体播放器在移动视频编程领域开辟了一个新机会 —— 但是如何入门呢？本文介绍将 QuickTime for Java™ 库，以编程方式为 iPod 媒体播放器创建视频内容时需要这个库。

Apple iPod 是当今市场上的几个媒体播放器之一，它能播放多种媒体，其中包括音频、视频和图片。在美国和其他地方，iPod 引领着便携媒体播放器市场，从诞生至今，已经售出 3千万套 iPod ，这占据了整个媒体播放器市场 78％ 以上的份额。虽然 iPod 的成功显然是受 MP3 流行的推动，而且手机用户拍摄和交易数字图片到现在也有了一段时间，但移动视频的市场仍然在形成中。早期进入移动视频市场的潜在收益是显而易见的，但对许多开发人员来说，他们要解决的问题是最好地应用这项新技术的方式和地方。

在这篇文章中，我首先将推荐一些移动视频的实际（可能也是非常流行的）应用，然后演示两个程序，让您开始使用 QuickTime for Java API 为 iPod 创建视频内容。这两个程序可以让您很容易地给现有的视频文件添加标题，并将传统的视频文件转换成与 iPod 兼容的格式。在文章末尾，将留给您一些示例代码，可以用它们学习使用 QuickTime for Java API 进行视频操作的更多内容。

为什么要用移动视频？

便携媒体播放器在特定人群（即年龄在 18 到 38 岁之间，具有一定的可支配收入的消费者）中特别流行。因为移动视频对于便携媒体播放器来是相对较新的东西，所以对大多数开发者来说，遇到的第一个问题就是： 为什么要创建移动视频内容？除了移动媒体最明显的娱乐要求之外，还有许多实际的使用情况：移动媒体既可以促进销售，也可以给便携媒体播放器和内容带来一类新用户。请想想以下这些情况：

• 房地产经纪人可以创建一段视频，将视频做成房产可用属性和用录制好的配音说明的一些功能的虚拟漫步。然后，潜在的住房买主可能会用便携媒体播放器查看中意的属性。在没有时间寻找所有符合自己需求的房产的住宅搜索客户中，这种极为节约时间的方式会变得非常流行。
• 汽车厂商和经销商可以使用移动视频发布所销售的最新车型的视频目录。潜在客户就会更熟悉中意的车型的特性和好处，而不必亲自去经销商那里。
• 学院和大学的官员可以用移动视频格式向学生提供提供演讲，辅助学生学习。
• 生产商可以为汽车、书架、玩具（等等）提供移动视频格式的安装说明。

显然，这只是创建移动视频内容的商业驱动力的几个示例。这些示例中的共同之处就是向新市场介绍便携媒体的潜力。现在，我们来看看允许用编程方式创建和编辑视频文件的 Java API。

回页首

QuickTime for Java API

对于 Java 开发人员来说，支持数字媒体的创建、修改和回放的能力最强、功能最丰富的 API 就是 QuickTime for Java API。QuickTime for Java 最初是为 Macintosh 平台创建的，但过去这几年时间里，Windows 和 Mac 用户也可以随意使用它。当然，如果曾经用 Java 语言做过一些编程，那么您可能会问：为什么不可以只使用 Java 媒体框架 (JMF) API。

最初创建 JMF 是为了给 Java V1.0.2 的开发人员提供处理各种媒体的能力。但是，它的应用并不广，它支持一些过时的媒体格式和编码方式，例如 MPEG-2、AU、HotMedia 和 Flash 2。另一方面，QuickTime for Java 支持 QuickTime 可以播放的所有媒体格式和编码方式。使用 QuickTime for Java API 可以访问更新的媒体格式，其中包括 MPEG-4、MP3 音频、H.264 和 Flash 5。实际上，下面就是 QuickTime 支持的视频编码方式的完整列表：

• 动画
• Apple BMP
• Apple Pixlet
• Apple Video
• Cinepak
• Component video
• DV and DVC Pro NTSC
• DV PAL
• DVC Pro PAL
• Graphics
• H.261
• H.263
• H.264
• JPEG 2000
• Microsoft® OLE
• Microsoft Video 1
• Motion JPEG A
• Motion JPEG B
• MPEG-4 (Part 2)
• Photo JPEG
• Planar RGB
• PNG
• Sorenson Video 2
• Sorenson Video 3
• TGA
• TIFF

回页首

向视频添加标题

如果是初次接触 QuickTime for Java API 或者是初次处理数字媒体，那么向视频片断添加标题是一个好的起点。清单 1 显示的 CaptionAdder.java 是一个简单的程序，它接受视频文件，然后向视频添加一个文本字符串作为标题。

import quicktime.*;
import quicktime.io.*;
import quicktime.std.image.*;
import quicktime.std.movies.media.*;
import quicktime.std.movies.*;
import quicktime.std.*;
import quicktime.qd.*;
import quicktime.util.QTPointer;


import java.io.*;

public class CaptionAdder {

 public static void main (String args[]) {

  if (args.length != 1){

    System.out.println("Usage: java CaptionAdder [input_filename]");

  } else {
      
    try {
     QTSession.open();     

     System.out.println ("QuickTime version: " + QTSession.getMajorVersion() + "." + 
        QTSession.getMinorVersion());

     QTFile qtfile = new QTFile(new File(args[0]));
     DataRef urlMovie = new DataRef ("file://" + qtfile.getPath());
     Movie movie = Movie.fromDataRef (urlMovie,StdQTConstants.newMovieActive);
    
     float  textTrackHeight = 32;

     QDRect movieBounds = movie.getNaturalBoundsRect();
     float  movieWidth  = movieBounds.getWidthF();
     float  movieHeight = movieBounds.getHeightF();

     Track  textTrack = movie.addTrack(movieWidth, textTrackHeight, 0);

     Matrix textTrackMatrix = textTrack.getMatrix();
     textTrackMatrix.translate (0, movieHeight - textTrackHeight);
     textTrack.setMatrix (textTrackMatrix);

     textTrack.setEnabled (true);

     int movieTimeScale = movie.getTimeScale();
     TextMedia textMedia = new TextMedia (textTrack, movieTimeScale);

       QDRect textBounds = new QDRect (movieWidth, movieHeight);

     textMedia.beginEdits();

      TimeInfo sampleTime = new TimeInfo (0, movie.getDuration()/2);
    
      String text = new String ("1234 Main St. - Listing price: $164,000");
      TextMediaHandler textMediaHandler = textMedia.getTextHandler();
      QTPointer textPointer = new QTPointer ( text.length() + 1, true );
      textPointer.copyFromArray ( 0, text.getBytes(), 0, text.length() );
      textMediaHandler.addTextSample (
        textPointer,
        QDFont.getFNum("Times"), 
        16, 
        0,
        QDColor.white,
        QDColor.black,
        QDConstants.teCenter,
        textBounds,
        StdQTConstants.dfClipToTextBox | StdQTConstants.dfKeyedText,
        0,0,0,
        null,
        sampleTime.duration );
      
     textMedia.endEdits();

     textTrack.insertMedia (sampleTime.time, 0, sampleTime.duration, 1 );
     OpenMovieFile outStream = OpenMovieFile.asWrite (qtfile); 

     movie.updateResource (outStream, StdQTConstants.movieInDataForkResID, 
        qtfile.getName());
    } catch (Exception e) {
         e.printStackTrace();
             QTSession.close();
             System.exit(0);
    }
        
               QTSession.close();

  // end else
  }

  System.out.println ("complete.");

 //end method
 }
  

}

关于代码

几乎每个 QuickTime for Java 应用程序都一样，所有的实际动作都发生在 QTSession.open() 和 QTSession.close() 语句之间。在调用 QTSession.open() 时，QuickTime 引擎可以初始化其自身。如果没有先调用 QTSession.open()，就想调用其他 QuickTime for Java 类，那么您会获得抛出到命令行中的非常难看的堆栈跟踪。

QuickTime for Java API 中使用的核心对象之一是 quicktime.std.movies.Movie 对象。如果初次使用 QuickTime for Java，那么需要认识到，在 quicktime.std.movies.Movie 对象和硬盘上可能存在的 file_name.mov 之间有一点细微的区别。重要的是，可以创建 quicktime.std.movies.Movie 对象，并且无需要在硬盘上创建 file_name.mov 文件该对象就可以存在。

quicktime.std.movies.Movie 对象可由多个轨道 组成，这些轨道是独立的媒体源（例如音频、视频、静态图片或文本）。在 CaptionAdder.java() 中，在创建了 quicktime.std.movies.Track 对象后，我在 textMedia.beginEdits() 语句和 textMedia.endEdits() 语句之间添加了文本标题。在这个示例中，我用 quicktime.std.movies.TimeInfo 对象设置标题在视频中显示的时间长度，以及什么时候开始显示标题。我想让文本标题在视频的前半段显示，所以我把 TimeInfo 设为从 0 开始，并通过 movie 的持续时间将它设置为运行到一半时结束。

回页首