附注：发现又有上一篇的错误，中文版的Eclipse在新建项目时，比较容易有“由于类路径错误（不完整或涉及循环），所以未构建项目。”这类的错误。好办，因为中文包只是一些文本文件，对开发没用，用前面一篇所说的方法删除那些对中文包的引用（前面字符为ECLIPSE_HOME_LANGUAGE_LINK…….），如下图：  

  
二、插件开发的几个关注点。 
　　a) 库引用。如上附注所说库引用是在建立插件初期要设置好的地方，不过一经设置基本不需要再改变。功能类似于JDK的classpath或者Jbuilder里的库引用。 
　　b) 插件JAVA源代码。今后主要的工作，狂写代码吧。主要都是一些*.JAVA文件。 
　　c) 项目根目录下的plugin.xml文件。这个文件是插件的入口文件，Eclipse根据这个文件中的设置来加载插件。代码写完了，要让Eclipse加载你的代码就要在这里面做些手脚了，这些手脚有个术语叫“设置扩展点”。象在Eclipse的加个主菜单、视图、按钮，都在这个文件里面做不同的扩展点，后面的教程会看到这个文件的使用。要人会说那我开发一个系统会有很多的菜单和按钮，那是不是都要设置这个文件呢？回答：不必，这里面只设置主要和Eclipse接壤的扩展点，其它系统里的菜单按钮就没必要了，今后会讲到。 
  
三、设置库引用。 
　　在删除了上面附注所说的无用且出错的引用，接下来我们要加入一些开发插件要用到的库。是那些呢？呵呵，前面我们还是用向导建立了一个helloword插件吗，参考它的就行了。如下图： 

  
　　手工加可真累，这里有个好办法。把目录C:\eclipse2.1.3\eclipse\workspace\myplugin\下的.classpath文件拷贝到C:\eclipse2.1.3\eclipse\workspace\myplugin2目录就行了。所有关于库引用的设置全保存在这个文件中。最后别忘记刷新一下项目，如下图所示： 

附注说明：

　　有些文章在这里是用“文件>导入...>外部插件和段”来提供插件开发支持库的引用，本文不采用这种方法，因为这种会将支持库（也是一种插件项目）会新建很多相应项目，让开发界面显得很乱。还不如本文所用的建立库引用变量的方法方便简洁。  
  

四、写源代码。 
　　a) 新建一个包。方法如下图所示。 
　　　

　　包名如下： 

　　　
  
　　结果如下： 

　　　

  
　　b) 然后将上一章的myplugin的SampleAction直接移动本项目myplugin2中就可以了（Eclipse支持鼠标拖拉操做）。 
　　c)  本文SampleAction做了一些小修改（删除了注释和构造函数）。代码如下：  

五、在plugin.xml文件中加入扩展点的代码。 
　　库将本项目plugin.xml文件打开，并转到其源代码视图。将如下代码加入到“</runtime>”之后。（这些xml还是从上一章的项目搬过来的  

　　你可能会问，这不是JavaScript的语法吗？完全正确！如果你使用过JavaScript，就会感到非常轻松，因为表达式语言正是借用了访问结构化数据的JavaScript语法。

　　--------------------------------------------------------------------------------

　　注意：

　　表达式语言最初是作为JSP标准标签库（JSTL）1.0的一部分而开发的，JSTL是一种标准标签库，它提供对通用的、结构化的任务的支持，如迭代和条件、XML文档处理、国际化和利用SQL访问数据库等。JSTL规范是由JSR 52专家组开发的。关于JSTL的介绍，请参见Faster Development with JSTL（使用JSTL加速开发）.

访问应用程序数据

　　可以使用点号运算符（.）访问作为对象属性的应用程序数据，也可使用方括号运算符[‘name’]访问命名的数组元素。

　　表达式${ data}表示名为data的scoped变量。可以使用点号（.）或方括号（[]）运算符从集合中检索属性值：

　　点号运算符用于访问命名的属性，比如表达式${ customer.name}表示scoped变量customer的name属性；方括号运算符可用于检索命名的属性，比如在${ customer[“name”]}中。也可以通过${ customers[0]}的形式来访问集合customers中的第一项。

　　表达式语言统一了对点号和方括号运算符的处理，因此${ customer.name}与${ customer[“name”]}是等价的。正如你看到的那样，表达式必须使用${ 和}包围起来。

　　EL的标识符求值方式是使用PageContext.findAttribute(String)，把标识符作为一个属性来查找它的值。如果没有找到该属性，则返回null。

　　运算符

　　表达式语言支持算术运算符、关系运算符和逻辑运算符，以完成大多数的数据处理操作。此外，它还提供了一个用于测试一个对象是否为空的特殊运算符。运算符如表1所示。你可以使用empty运算符判断某个集合或字符串是否为空。比方说，只有当要求的命名参数param没有给出时，表达式${ empty param.name}才返回真。Empty运算符可以与“!”运算符一起使用，比如${ !empty param.name}当要求的命名参数param存在时返回真。

　　表1：表达式语言运算符

图1：JSP表达式语言和隐含对象

图2：表单处理

定义和使用函数

　　表达式语言允许你定义可在表达式中调用的函数。函数必须作为public类中的public static方法编写。函数一经定义，它的签名（signature）就映射到标签库描述符（TLD）中。

　　为了说明函数的使用，我们举一个简单的例子，把两个数相加。首先要编写求两数之和的Java方法代码，如代码示例3所示，这里定义了一个静态方法，它接收两个字符串参数，把它们解析成整数并返回它们的和。

　　代码示例3: Compute.java

package jsp2.examples.el;
import java.util.*;
public class Compute {
　public static int add(String x, String y) {
　　int a = 0;
　　int b = 0;
　　try {
　　　a = Integer.parseInt(x);
　　　b = Integer.parseInt(y);
　　}catch(Exception e) {
　　}
　　return a + b;
　}
}
　　用javac把这段代码编译成功后，下一步就要把函数的签名映射到标签库。代码示例4说明了如何把add函数映射到包含函数实现和函数签名的类。后面将说明把这段代码添加到哪儿。

　　代码示例4: 函数描述符

＜function＞
　＜description＞add x and y＜/description＞
　＜name＞add＜/name＞
　＜function-class＞jsp2.examples.el.Compute ＜/function-class＞
　＜function-signature＞int add(java.lang.String,java.lang.String) ＜/function-signature＞
＜/function＞
　　现在我们就可以编写一个JSP页面来使用这个函数。代码示例5是包含两个字段的一个表单，用户输入两个数字并按下“求和”按钮，就会调用上面的函数并把两个数相加，结果在同一个页面中显示出来。

　　代码示例5: math.jsp

＜%@ taglib prefix="my" uri="http://jakarta.apache.org/tomcat/jsp2-example-taglib %＞
＜HEAD＞＜TITLE＞Functions＜/TITLE＞＜/HEAD＞
＜BODY＞
＜H3＞Add Numbers＜/H3＞
＜P＞
＜FORM action="math.jsp" method="GET"＞ X = ＜input type="text" name="x" value="${ param["x"]}"＞
＜BR＞
Y = ＜input type="text" name="y" value="${param["y"]}"＞
＜input type="submit" value="Add Numbers"＞
＜/FORM＞
＜P＞The sum is: ${my:add(param["x"],param["y"])}
＜/BODY＞
＜/HTML＞
　　要运行这个例子：

　　复制Compute.java并保存到C:\Tomcat5.0\webapps\jsp-examples\WEB-INF\classes\jsp2\examples\el下；使用javac编译Compute.java；编辑文件C:\Tomcat5.0\webapps\jsp-examples\WEB-INF\jsp2\jsp2-example-taglib.tld，把代码示例4中的代码段添加到文件中最后一个＜/function＞标签之后，＜/taglib＞标签之前；复制math.jsp并保存到c:\Tomcat5.0\webapps\jsp-examples\jsp2-tutorial下；用浏览器打开该文件。

　　如果一切正常，应该会看到类似如图3所示的窗口。

图3：使用函数

图4：简单标签处理器

标签文件

　　使用简单标签扩展机制的另一种方法是通过标签文件。标签文件是一种资源文件，网页作者可以利用它抽取一段JSP代码，通过定制功能来实现代码的复用。换句话说，标签文件允许JSP网页作者使用JSP语法创建可复用的标签库。标签文件的扩展名必须是“.tag”。

　　为说明使用标签文件是多么容易，考虑一下代码示例9。没错，这就是一个标签文件！

　　代码示例9: greetings.tag

Hello there. How are you doing?
　　一旦定义了标签文件，就可以在JSP网页的编写中使用这种定制的功能。比如代码示例10中的JSP网页。

　　代码示例10: chat.jsp

＜%@ taglib prefix="tags" tagdir="/WEB-INF/tags" %＞
＜HTML＞
＜HEAD＞
＜TITLE＞JSP 2.0 Examples - Hello World Using a Tag File＜/TITLE＞
＜/HEAD＞
＜BODY＞
＜H2＞Tag File Example＜/H2＞
＜P＞
＜B＞The output of my first tag file is＜/B＞: ＜tags:greetings/＞
＜/BODY＞
＜/HTML＞
　　要运行这个例子：

　　复制标签文件greetings.tags并保存在c:\Tomcat5.0\webapps\jsp-examples\WEB-INF\tags 目录下；复制JSP网页文件char.jsp并保存在c:\Tomcat5.0\webapps\jsp-examples\jsp2-tutorial 目录下；用浏览器打开chat.jsp文件。

　　如果一切正常，应该会看到类似如图5所示的窗口。

图5：简单的标签文件

＜%@ attribute name="color" %＞＜%@ attribute name="bgcolor" %＞＜%@ attribute name="title" %＞
＜TABLE border="0" bgcolor="${color}"＞
＜TR＞
＜TD＞＜B＞${title}＜/B＞ ＜/TD＞
＜/TR＞
＜TR＞
＜TD＞ bgcolor="${ bgcolor}"＞ ＜jsp:doBody/＞ ＜/TD＞
＜/TR＞
＜/TABLE＞

图6：把标签文件用作模板

 2.据说能看见9张脸的智商有一百八十了 

 3.狮子在哪里?

4.那个红衣女人是真实的还是拼图里的???

5. 十二个人还是十三个人？




6.有几个黑点???

7.是静的还是动的?

8.看得出图里有一张脸吗?


　
9.一张只要你能在图中找出9颗心就可以许个愿望而且它会马上实现的神奇图片！并且能和自己心爱的人在一起！但是如果你看了这幅图不回帖或半途而废,你将成为天刹孤星 ,孤独终老..希望大家认真观察.能找出几颗算几颗.找的越多.你将来越幸福.千万别看了图不找...后果自负.信不信由你 , 天国神秘的照片 预测你一生的幸福



10. 看着黑点身体前后移动,发现了什么？

第1步，设置CVS的库配置文件（模块CVSROOT）的访问权限
方法：建立超级用户的工作目录 WINCVSADMIN
       a.以cvsnt服务器超级用户administrtor 登陆 wincvs
       b.CHECKOUT 库控制文件 checkout moudel 'cvsroot',此目录下的文件为CVS的高级配置文件，可以在本地进行修改，提交，本身在版本控制之中
       c.修改CVSRoot的访问权限，在命令行输入如下命令  #之后为说明，不需要输入 每行命令要单独执行，这是4条命令
         cvs chacl default:n          #取消所有用户的默认权限
         cvs chacl administrator:rcw  #设置Administrator拥有所有权限 读取;创建和删除;写入
         cvs chown administrator      #更改的拥有者Administrator
         cvs lsacl                   #察看权限的设置情况
第2步，建立CVS的用户
       正常可以用WINNT 系统的用户作为CVS 的用户，访问CVS ，但是这种方式安全性太差
       可以建立CVS 自己的用户
       a.建立WINNT系统用户 CVSUSER，权限设为一般用户就可以，只要能访问WINNT就可以
       b.建立密码文件PASSWD,
           直接在服务端 CVSROOT 目录下建立文件就可以 PASSWD
           出于安全考虑，不要将 passwd列在 checkoutlist 文件里面。
       C.建立CVS用户
          在WINCVS 命令行下输入命令
          cvs passwd -a -r cvsuser zxh         #建立ZXH用户与系统用户cvsuser有一样的权限,回车后提示输入两次口令
          cvs passwd -a -r cvsuser lxw         #建立lxw用户与系统用户cvsuser有一样的权限,回车后提示输入两次口令
          cvs passwd -a -r administratro administrator #建立administrator用户与系统用户administrator有一样的权限,回车后提示输入两次口令
          可以看到PASSWD 文件多了两行
          zxh:CUXQwLMdoZHNs:cvsuser     #中间为加密的密码,密码使用Unix标准的crypt()函数加密
          lxw:ZTUCMKUkZ6ap2:cvsuser    
          administrator:oN2Stm4NIf31Q:administrator
第3步, 使用CVS用户登陆
       由于CVS 在默认模式下,是采用系统用户登陆的,这就要修改配置文件 CONFIG
       设置文件CONFIG为修改状态
       加入如下一行
       SystemAuth=no  #yes 默认值,表示 如果用户在PASSWD文件中不存在,就用系统用户检查权限是否正确
                      #no   表示用PASSWD检查用户密码权限是否正确
       之后提交
       （在设置CONFIG 文件SystemAuth=no  之后
        需要在cvs 控制目录cvsroot\ 下建立admin文件  
        这个文件是指定CVSNT的管理员列表的文件，CVSNT根据这个文件来判断一个用户是否是管理员。文件的内容很是一个用户列表。如下：
user1
  user2
  user3
这些代表user1,user2,user3都是管理员 ；
在此之前 cvs将服务器的管理员用户作为自己的管理员用户的）

第4步,加入文件 WRITERS ,READERS   控制用户的读写权限
      在cvsroot目录下加入两个文本文件，WRITERS ,READERS
      其每行内容为  用户名 回车
      只有加入WRITERS中的用户才能进行提交
      加入READERS中的用户只能读取
      同时在两个文件中的用户只能读取
      在writers文件中加入如下
          zxh
          lxw  
          administrator      

第5步，    配置CVS库模块文件——modules
       a.将MODUES文件设为可编辑状态
       b.在MOUDES 加入如下3行
         CVSRoot            CVSRoot
         大狼的工作目录 -a  lxwDIR
         开心的工作目录 -a  ZXHDIR
       c.保存,提交 COMMIT
第6步, 为2个用户分别上传工作目录
       选中LXW的工作目录'LXWDIR'       IMPORT MODULE  
       选中ZXH的工作目录'ZXHDIR'       IMPORT MODULE          
       注意:上传的目录不能为空目录,其下必须有文件(啥文件都行)
       上传成功后,删除这2个目录OR 改名
(补充一下分组的使用方法：
分组：将权限相同的用户划分到一组，这样方便维护。就是角色的意思，分组使用在对模块访问权限的划分。
方法：
a.在服务器端 cvsroot 目录下新建文件 group
b.建立分组 group1,group2 ,group文件内容如下
group1:user1 user2 user3
  group2:user5 user6 user7
c.之后对组进行权限划分，和对单个用户方式一样，就可以使组内用户和组具有相同的权限，如 选中模块，执行如下命令
   chacl -R default:n
      cvs chacl -R group1:rcw
      cvs lsacl  
可以使，用户 user1 user2 user3 同时具有对该模块的读写和控制的权限

第7步,下载目录目到本地做权限设置 CHECKOUT MODULE
       CHECKOUT MODULE        选择 大狼的工作目录  'LXWDIR'
       CHECKOUT MODULE        选择 开心的工作目录  'ZXHDIR'
    做法是这样的
      选择 菜单\remote\checkou moudule
            在打开窗口中 点击‘...’ 按钮
      在打开窗口中选择 大狼的工作目录
      ok 按钮
      确定 按钮

第8步 分别设置2用户(LXW;ZXH)对各自目录的访问权限
      选中模块 LXW ,在命令行输入如下3条命令,
      cvs chacl -R default:n
      cvs chacl -R LXW:rcw
      cvs lsacl
      选中模块 ZXH ,在命令行输入如下3条命令,
      cvs chacl -R default:n
      cvs chacl -R ZXH:rcw
      cvs lsacl
说明 加 ‘-R ’参数表示对模块的权限是递归的。解释一下：
如目录结构   dira
                               |---dira1
                               |---dira2
命令：cvs chacl default:n 只对 目录 dira 有效，而对子目录无效
      cvs chacl -R default:n    对目录dira及其下子目录都有效
                              
第9步 已经完成了设置  
      以用户 LXW OR ZXH 登陆WINCVS 就只能CHECKOU 各自的模块 LXWDIR,ZXHDIR  
      进行相应的开发工作了

在执行命令cvs passwd -a -r cvsuser zxh         的时候
在本地目录 CVSROOT 目录下的PASSWD文件里没有生成相关的用户和密码
而在服务器 CVSROOT 目录下的PASSWD文件里生成了相关的用户和密码

如果是这样，是一种正常现象
原因是你没有把passwd 控制文件加入到 cvs版本 控制之中—文件checkoutlist里

版本

我的安装过程:
确认是否安装了老版本的cvs,如果有老版本的,就统统删除
[root@redhat /]# rpm -qa |grep cvs
libbonoboui-2.8.0.99cvs20040929-2
cvs-1.11.17-7.RHEL4
[root@redhat /]# rpm -e cvs-1.11.17-7.RHEL4
[root@redhat /]# rpm -qa | grep cvs
libbonoboui-2.8.0.99cvs20040929-2

将下载的cvs文件解压
[root@redhat cvs]# tar zxvf cvsnt-2.5.03.2151-rh9-rpm.tar.gz
cvsnt-2.5.03.2151-1.i386.rpm
cvsnt-database-mysql-2.5.03.2151-1.i386.rpm
cvsnt-database-odbc-2.5.03.2151-1.i386.rpm
cvsnt-database-sqlite-2.5.03.2151-1.i386.rpm
cvsnt-protocol-gserver-2.5.03.2151-1.i386.rpm
cvsnt-protocol-sserver-2.5.03.2151-1.i386.rpm
[root@redhat cvs]# ls
cvsnt-2.5.03.2151-1.i386.rpm cvsnt-database-sqlite-2.5.03.2151-1.i386.rpm
cvsnt-2.5.03.2151-rh9-rpm.tar.gz cvsnt-protocol-gserver-2.5.03.2151-1.i386.rpm
cvsnt-database-mysql-2.5.03.2151-1.i386.rpm cvsnt-protocol-sserver-2.5.03.2151-1.i386.rpm
cvsnt-database-odbc-2.5.03.2151-1.i386.rpm

安装相关的rpm包(之后立刻确认安装)
[root@redhat cvs]# rpm -ivh cvsnt-2.5.03.2151-1.i386.rpm
Preparing... ########################################### [100%]
   1:cvsnt ########################################### [100%]
[root@redhat cvs]# rpm -qa |grep cvs
libbonoboui-2.8.0.99cvs20040929-2
cvsnt-2.5.03.2151-1

[root@redhat src]# cvs -version

Concurrent Versions System (CVSNT) 2.5.03 (Scorpio) Build 2151 (client/server)

建立cvs用户组
[root@redhat /]# groupadd cvs
以上建立组的语句,不会在/home中多出任何目录来.

建立以后的存放目录
[root@redhat /]# mkdir cvs
[root@redhat /]# cd cvs
[root@redhat cvs]# mkdir src
[root@redhat cvs]# cd src
[root@redhat src]# pwd
/cvs/src
[root@redhat src]#

指定cvs组的cvsroot用户和所属的目录
[root@redhat src]# useradd -g cvs -G cvs -d/cvs cvsroot

为cvsroot用户添加密码
[root@redhat cvs]# passwd cvsroot
Changing password for user cvsroot.
New UNIX password:
BAD PASSWORD: it does not contain enough DIFFERENT characters
Retype new UNIX password:
passwd: all authentication tokens updated successfully.

改变/cvs的目录属性
[root@redhat /]# chmod 775 /cvs
drwxrwxr-x 4 root root 4096 Dec 7 14:14 cvs
[root@redhat cvs]# chmod 775 src
drwxrwxr-x 2 root root 4096 Dec 7 14:06 src

对cvs进行相关的版本确认
[root@redhat /]# cvs version
Concurrent Versions System (CVSNT) 2.5.03 (Scorpio) Build 2151 (client/server)

启动cvs服务器
[root@redhat /]# more /etc/services|grep cvspserver
cvspserver 2401/tcp # CVS client/server operations
cvspserver 2401/udp # CVS client/server operations

如果上面没有这个内容就
[root@redhat /]# vi /etc/services
来添加相关的内容

[root@redhat /]# vi /etc/xinetd.d/cvspserver
service cvspserver
{
disable = no
flags = REUSE
port = 2401
socket_type = stream
protocol = tcp
wait = no
user = root
passenv = PATH
server = /usr/bin/cvs
server_args = -f --allow-root=/cvs pserver
log_on_failure += USERID
}

shift+wq!
"/etc/xinetd.d/cvspserver" [New] 14L, 225C written
[root@redhat src]# ls /etc/xinetd.d/cvspserver
/etc/xinetd.d/cvspserver
[root@redhat src]# su cvsroot
[cvsroot@redhat src]$ pwd
/cvs/src
[root@redhat /]# service xinetd restart
Stopping xinetd: [ OK ]
Starting xinetd: [ OK ]
[root@redhat /]# netstat -l |grep cvspserver
tcp 0 0 *:cvspserver *:* LISTEN

初始化cvs源码库,新建立一个Repository,此操作生成目录/cvs/CVSROOT(或者/cvs/src/CVSROOT),其下

为一些初始化文件
[root@redhat src]# export CVSROOT=/cvs/src
[root@redhat src]# env | grep CVSROOT
CVSROOT=/cvs/src

[root@redhat src]# cvs -d /cvs/src init

在服务器端初置口令认证

首先，你可能需要 $CVSROOT 和 $CVSROOT/CVSROOT 上设定权限。见 Password authentication security。

在服务器端，需要编辑文件 /etc/inetd.conf 让 inetd 它在正确的端口上收到一个连接的时候运行 cvs pserver 命令。按照默认，端口号是 2401；当然，如果客户端用 CVS_AUTH_PORT 重新编译了就会有一些不同。也可以在 CVSROOT 变量(参阅 Remote repositories)指定或用 CVS_CLIENT_PORT 环境变量(参阅 Environment variables)跨越。

如果你的 inetd 在 /etc/inetd.conf 中允许原始的端口号定义，那么下面的命令就足够了（所有命令在 inetd.conf 中都是单行）：

     2401  stream  tcp  nowait  root  /usr/local/bin/cvs
     cvs -f --allow-root=/usr/cvsroot pserver

（你也可以使用 `-T' 选项来指定一个临时目录。）

`--allow-root' 选项指定一个允许的 cvsroot 目录。试图使用一个另外的 cvsroot 目录的客户将被拒绝连接。如果你希望设置多个允许的 cvsroot 目录，重复设置这一选项就行了。（不幸的是，许多版本的 inetd 对参数的数量和/或命令长度小有限制。通常解决方法是在 inetd 中运行一个 shell 脚本，然后在脚本中调用 cvs 所需的参数。）

如果你希望 inetd 使用符号服务名称来代替原始端口号，那么把它放进 /etc/services 里：

     cvspserver      2401/tcp

并且在 inetd.conf 中使用 cvspserver 代替 2401。

如果你的系统用 xinetd 替代 inetd，步骤有些不同。创建一个叫 /etc/xinetd.d/cvspserver 的文件，包含下列内容：

     service cvspserver
     {
        port        = 2401
        socket_type = stream
        protocol    = tcp
        wait        = no
        user        = root
        passenv     = PATH
        server      = /usr/local/bin/cvs
        server_args = -f --allow-root=/usr/cvsroot pserver
     }

（如果已在 /etc/services 中定义 cvspserver，可以省略 port 这一行。）

做了上面的修改之后，需要重新启动你的 inetd，或者采取其它可以使它重新读取初始化文件手段。

如果设置这有麻烦，参阅 Connection。

因为客户端以明文存储和传输口令(几乎是—请见 Password authentication security)，通常使用了一个独立的 cvsCVS 口令文件，这样人们访问仓库的时候不会危及定期口令的安全。这个文件是 $CVSROOT/CVSROOT/passwd (参阅 Intro administrative files)。除了只用较少的域（cvs 用户名称，可有可无的口令和服务器的用户名称）以外，它的格式和 Unix 上的 /etc/passwd 相似，采用分号分隔。这里是个有五个表项的例子 passwd 文件：

     anonymous:
     bach:ULtgRLXo7NRxs
     spwang:1sOp854gDF3DY
     melissa:tGX1fS8sun6rY:pubcvs
     qproj:XR4EZcEs0szik:pubcvs

（口令使用 Unix 标准的 crypt() 函数加密，因此它可以直接从常规 Unix /etc/passwd 文件粘贴过来。）

例子中第一行允许任何 cvs 客户机使用 anonymous 来访问，口令可以用任意字符还可以用空口令。（这是一个站点允许匿名进行只读访问的典型用法；“只读（read-only）”部分信息的做法，参看 Read-only access。）

如果他们提供各自的明文口令第二、三行允许对 bach 和 spwang 进行访问。

如果她提供正确的口令第四行允许对 melissa 访问，但她的 cvs 操作将实际运行在服务器侧的 pubcvs 用户名下。虽然系统上不须有 melissa 用户名，但 必须 使用 pubcvs。

第五行显示系统用户标识可以共享：作为 qproj 成功认证的任何客户实际将按 pubcvs 来运行，和 melissa 所做的一样。用这种方法你可以在你的仓库中为每个项目创建一单个共享的系统用户，并且在 $CVSROOT/CVSROOT/passwd 文件中为每个开发者设置一行。每行的 cvs 用户名应该不同，而系统用户名应该相同。用不同的 cvs 用户名目的是在 cvs 将在其名字下记录其动作： 当 melissa 提交了项目中的一个修改，检入被纪录在项目历史中的 melissa 名下，而不是 pubcvs 下。而共享一个系统用户的原因是可以安排仓库中相关区域的权限，只有那个帐户有写权限。

如果系统用户域存在的时候，全部口令鉴定 cvs 命令按该用户运行；如果没有指定系统用户，cvs 简单地取 cvs 用户名作为系统用户名并且按此户名运行命令。无论哪种情况，如果系统上没有这样的用户，于是 cvs 操作会失败(不管客户机是否提供了正确的口令)。

口令和系统用户字段都可以省略（如果系统用户字段省略，那么与口令分隔的冒号也省略）。例如，这将是有效的 $CVSROOT/CVSROOT/passwd 文件：

     anonymous::pubcvs
     fish:rKa5jzULzmhOo:kfogel
     sussman:1sOp854gDF3DY

当口令字段为空，客户的认证可以用包括空字符串在内的任何口令。但 cvs 用户名后的分隔冒号必需存在，即使口令为空。

cvs 还可借助于系统认证。认证口令的时候，服务器先检查 $CVSROOT/CVSROOT/passwd 文件中的用户。如果找到用户，就按上面说的方法使用该项进行认证。如果没有找到，或 cvspasswd 文件不存在，服务器将采用操作系统的用户认证机制（这种机制可以通过设置 cvsconfig 文件中的 SystemAuth=no 来禁止，参阅 config）。

除非系统中有 PAM(Pluggable Authentication Modules)，或者 cvs 服务器端编译的时候配置 (使用 ./configure --enable-pam - 参考 INSTALL 中的说明)，否则默认的回调(callback)是查找 /etc/passwd 中的口令。在此情况下，将磋商以 PAM 代替。这意味着可以配置 cvs 使用 PAM 提供的各种口令认证方式(可能是 UNIX password，NIS，LDAP，或其他)，这取决于 PAM 的全局配置文件(通常在 /etc/pam.conf 或可能是 /etc/pam.d/cvs)。详细配置 PAM 的方法请参考 PAM 的文档。

注意，PAM 是 cvs 中使用的实验特性，鼓励反馈信息。如果你使用了 PAM 支持，请发邮件到 cvs 的邮件列表(info-cvs@gnu.org 或 bug-cvs@gnu.org)。

警告：采用 PAM 可以给系统管理员更多的 cvs 认证灵活性，但并不比别的方法有更高的安全性。详见下。

CVS 在 PAM 配置文件里需要“auth”，“account”和“session”模块。因此典型的 PAM 配置是在文件 /etc/pam.conf 里模拟标准的 cvs 系统 /etc/passwd 认证：

     cvs	auth	    required	pam_unix.so
     cvs	account	    required	pam_unix.so
     cvs	session	    required	pam_unix.so

对等的 /etc/pam.d/cvs 文件里包括

     auth	    required	pam_unix.so
     account	    required	pam_unix.so
     session	    required	pam_unix.so

一些系统要求给出模块的完整路径，因此 pam_unix.so (Linux) 改为类似 /usr/lib/security/$ISA/pam_unix.so.1 (Sun Solaris)。参考 cvs 源码发布子目录 contrib/pam 中更多的配置例子。

PAM 中指出的服务名“cvs”是默认配置中的服务名，也可以在编译前使用 ./configure --with-hardcoded-pam-service-name=<pam-service-name> 重新设置。 cvs 也可以被设置成调用其他的名字 ./configure --without-hardcoded-pam-service-name，但这个特性只有你有权控制 cvs 用什么名字时才有效。

要知道，在使用系统认证时会有安全漏洞：cvs 操作时是使用系统中用户的正规注册口令，而该口令网络传输中是采用明码方式。见 Password authentication security。这点对使用 PAM 认证会有更多的问题，因为系统口令的源头是某些像 LDAP 的中心服务，而 LDAP 它还被用于认证别的服务。

另一方面，PAM 使得定期地修改口令非常容易。如果对全部活动给用户一个口令系统的选项，用户经常定期改变他们的口令。

在非 PAM 的配置中，口令是保存在 CVSROOT/passwd 文件里面，因为只有管理员用户(或有等同的权限)才有此文件的修改访问权限，所以想用定期改变口令会很困难。可以采用设计的网页程序或 set-uid 程序来更新文件，或者是提交请求让管理员进行手动修改来更新。第一种情况下，必须记住去定期更新各自的口令可能是很困难的。第二种情况下，手工的本性将是只有绝对必要时才会去修改口令。

注意，PAM 管理员应避免在 cvs 证明/授权(authentication/authorization)中采用配置一次性口令 OTP。如果用 OTP，管理员最好考虑其他的 Client/Server 访问方式。参阅 Remote repositories 获得其他方法的列表。

现在，cvspasswd 文件里加入口令的唯一方法是从别处粘贴而来。也许有一天，会有一条命令 cvs passwd。

不像其他在 $CVSROOT/CVSROOT 目录下的文件，可以在不是通过 cvs来编辑 passwd 的地方进行编辑。这是因为使 passwd 文件检出为人们的工作副本可能的安全风险。如果你的确需要将 $CVSROOT/CVSROOT 中的 passwd 检出，参看 checkoutlist。

本文总结了我喜爱的Ant技巧或最佳实践，多数是从我亲身经历的项目错误或我听说的其他人经历的 “恐怖”故事中得到灵感的。比如，有人告诉我有个项目把XDoclet 生成的代码放入带有锁定文件功能的版本控制工具中。当开发者修改源代码时，他必须记住手工检出（Check out）并锁定所有将要重新生成的文件。然后，手工运行代码生成器，只到这时他才能够让Ant编译代码，这一方法还存在如下一些问题：

• 生成的代码无法存储在版本控制系统中。
• Ant（本案例中是Xdoclet）应该自动确定下一次构建涉及的源文件，而不应由程序员手工确定。
• Ant的构建文件应该定义好正确的任务依赖关系，这样程序员就不必为了完成构建而不得不按照特定顺序调用任务。

当我开始一个新项目时，我首先编写Ant构建文件。Ant文件明确地定义构建的过程，并被团队中的每个程序员使用。本文所列的技巧基于这样的假定：Ant构建文件是一个必须仔细编写的重要文件，它应在版本控制系统中得到维护，并被定期进行重构。下面是我的十五大Ant最佳实践。

1. 采用一致的编码规范

Ant用户有的喜欢有的痛恨其构建文件的XML语法。与其跳进这一令人迷惑的争论中，不如让我们先看一些能保持XML构建文件简洁的方法。

首先也是最重要的，花费时间格式化你的XML让它看上去很清晰。不论XML是否美观，Ant都可以工作。但是丑陋的XML很难令人读懂。倘若你在任务之间留出空行，有规则的缩进，每行文字不超过90列左右，那么XML令人惊讶地易读。再加上使用能够高亮XML语法的优秀编辑器或IDE工具，你就不会有阅读的麻烦。

同样，精选含意明确、容易读懂的词汇来命名任务和属性。比如，dir.reports就比rpts好。特定的编码规范并不重要，只要拿出一套规范并坚持使用就行。

2. 将build.xml放在项目根目录中

Ant构建文件build.xml可以放在任何位置，但是放在项目顶级目录中可以保持项目简洁。这是最常用的规范，开发者能够在顶级目录中找到预期的build.xml。把构建文件放在根目录中，也能够使人容易了解项目目录树中不同目录之间的逻辑关系。以下是一个典型的项目目录层次：

[root dir]
  | build.xml 
  +--src 
  +--lib (包含第三方 JAR包) 
  +--build (由 build任务生成) 
  +--dist (由 build任务生成)

当build.xml在顶级目录时，假设你处于项目某个子目录中，只要输入：ant -find compile 命令，不需要改变工作目录就能够以命令行方式编译代码。参数-find告诉Ant寻找存在于上级目录中的build.xml并执行。

3. 使用单一的构建文件

有人喜欢将一个大项目分解成几个小的构建文件，每个构建文件分担整个构建过程的一小部分工作。这确实是看法不同的问题，但是应该认识到，将构建文件分割会增加对整体构建过程的理解难度。要注意在单一构建文件能够清楚表现构建层次的情况下不要过工程化(over-engineer)。

即使你把项目划分为多个构建文件，也应使程序员能够在项目根目录下找到核心build.xml。尽管该文件只是将实际构建工作委派给下级构建文件，也应保证该文件可用。

4. 提供良好的帮助说明

应尽量使构建文件自文档化。增加任务描述是最简单的方法。当你输入ant -projecthelp时，你就可以看到带有描述的任务清单。比如，你可以这样定义任务：

最简单的规则是把所有你想让程序员通过命令行就可以调用的任务都加上描述。对于一般用来执行中间处理过程的内部任务，比如生成代码或建立输出目录等，就无法使用描述属性。

这时，可以通过在构建文件中加入XML注释来处理。或者专门定义一个help任务，当程序员输入ant help时来显示详细的使用说明。

5. 提供清除任务

每个构建文件都应包含一个清除任务，用来删除所有生成的文件和目录，使系统回到构建文件执行前的初始状态。执行清空任务后还存在的文件都应处在版本控制系统的管理之下。比如：

除非是在产生整个系统版本的特殊任务中，否则不要自动调用clean任务。当程序员仅仅执行编译任务或其他任务时，他们不需要构建文件事先执行既令人讨厌又没有必要的清空任务。要相信程序员能够确定何时需要清空所有文件。

6. 使用ANT管理任务从属关系

假设你的应用由Swing GUI组件、Web界面、EJB层和公共应用代码组成。在大型系统中，你需要清晰地定义每个Java包属于系统的哪一层。否则任何一点修改都要被迫重新编译成百上千个文件。糟糕的任务从属关系管理会导致过度复杂而脆弱的系统。改变GUI面板的设计不应造成Servlet和EJB的重编译。

当系统变得庞大后，稍不注意就可能将依赖于客户端的代码引入到服务端。这是因为典型的IDE项目文件编译任何文件都使用单一的classpath。而Ant能让你更有效地控制构建活动。

设计你的Ant构建文件编译大型项目的步骤：首先，编译公共应用代码，将编译结果打成JAR包文件。然后，编译上一层的项目代码，编译时依靠第一步产生的JAR文件。不断重复这一过程，直到最高层的代码编译完成。

分步构建强化了任务从属关系管理。如果你工作在底层Java框架上，偶然引用到高层的GUI模板组件，这时代码不需要编译。这是由于构建文件在编译底层框架时在源路径中没有包含高层GUI面板组件的代码。

7. 定义并重用文件路径

如果文件路径在一个地方一次性集中定义，并在整个构建文件中得到重用，那么构建文件更易于理解。以下是这样做的一个例子：

当项目不断增长构建日益复杂时，这一技术越发体现出其价值。你可能需要为编译不同层次的应用定义各自的文件路径，比如运行单元测试的、运行应用程序的、运行Xdoclet的、生成JavaDocs的等等不同路径。这种组件化路径定义的方法比为每个任务单独定义路径要优越得多。否则，很容易丢失任务从属关系的轨迹。

8. 定义恰当的任务从属关系

假设dist任务从属于jar任务，那么哪个任务从属于compile任务哪个任务从属于prepare任务呢？Ant构建文件最终定义了任务的从属关系图，它必须被仔细地定义和维护。

应该定期检查任务的从属关系以保证构建工作得到正确执行。大的构建文件随着时间推移趋向于增加更多的任务，所以到最后可能由于不必要的从属关系导致构建工作非常困难。比如，你可能发现在程序员只需编译一些没有使用EJB的GUI代码时又重新生成了EJB代码。

以“优化”的名义忽略任务的从属关系是另一种常见的错误。这种错误迫使程序员为了得到恰当的结果必须记住并按照特定的顺序调用一串任务。更好的做法是：提供描述清晰的公共任务，这些任务包含正确的任务从属关系；另外提供一套“专家”任务让你能够手工执行个别的构建步骤，这些任务不提供完整的构建过程，但是让那些专家用户在快速而恼人的编码期间能够跳过某些步骤。

9.使用属性

任何需要配置或可能发生变化的信息都应作为Ant属性定义下来。对于在构建文件中多次出现的值也同样处理。属性既可以在构建文件头部定义，也可以为了更好的灵活性而在单独的属性文件中定义。以下是在构建文件中定义属性的样式：

或者你可以使用属性文件：

在属性文件 sample.properties中:

用一个独立的文件定义属性是有好处的，它可以清晰地定义构建中的可配置部分。另外，在开发者工作在不同操作系统的情况下，你可以在不同的平台上提供该文件的不同版本。

10. 保持构建过程独立

为了最大限度的扩展性，不要应用外部路径和库文件。最重要的是不要依赖于程序员的CLASSPATH设置。取而代之的是，在构建文件中使用相对路径并定义自己的路径。如果你引用了绝对路径如C:\java\tools，其他开发者未必使用与你相同的目录结构，所以就无法使用你的构建文件。

如果你部署开放源码项目，应该提供包含编译代码所需的所有JAR文件的发行版本。当然，这是在遵守许可协议的基础上。对于内部项目，相关的JAR文件都应在版本控制系统的管理中，并捡出（check out）到大家都知道的位置。

当你必须引用外部路径时，应将路径定义为属性。使程序员能够用适合他们自己的机器环境的参数重载这些属性。你也可以使用以下语法引用环境变量：

11. 使用版本控制系统

构建文件是一个重要的制品，应该像代码一样进行版本控制。当你标记你的代码时，也应用同样的标签标记构建文件。这样当你需要回溯到旧版本并进行构建时，能够使用相应版本的构建文件。

除构建文件之外，你还应在版本控制中维护第三方JAR文件。同样，这使你能够重新构建旧版本的软件。这也能够更容易保证所有开发者拥有一致的JAR文件，因为他们都是同构建文件一起从版本控制系统中捡出的。

通常应避免在版本控制系统中存放构建成果。倘若你的源代码很好地得到了版本控制，那么通过构建过程你能够重新生成任何版本的产品。

12. 把Ant作为“最小公分母”

假设你的开发团队使用IDE工具，当程序员通过点击图标就能够构建整个应用时为什么还要为Ant而烦恼呢？

IDE的问题是一个关于团队一致性和重现性的问题。几乎所有的IDE设计初衷都是为了提高程序员的个人生产率，而不是开发团队的持续构建。典型的IDE要求每个程序员定义自己的项目文件。程序员可能拥有不同的目录结构，可能使用不同版本的库文件，还可能工作在不同的平台上。这将导致出现这种情况：在Bob那里运行良好的代码，到Sally那里就无法运行。

不管你的开发团队使用何种IDE，一定要建立所有程序员都能够使用的Ant构建文件。要建立一个程序员在将新代码提交版本控制系统前必须执行Ant构建文件的规则。这将确保代码是经过同一个Ant构建文件构建的。当出现问题时，要使用项目标准的Ant构建文件，而不是通过某个IDE来执行一个干净的构建。

程序员可以自由选择任何他们习惯使用的IDE工具或编辑器。但是Ant应作为公共基线以保证代码永远是可构建的。

13. 使用zipfileset属性

人们经常使用Ant产生WAR、JAR、ZIP和 EAR文件。这些文件通常都要求有一个特定的内部目录结构，但其往往与你的源代码和编译环境的目录结构不匹配。

一个最常用的方法是写一个Ant任务，按照期望的目录结构把一大堆文件拷贝到临时目录中，然后生成压缩文件。这不是最有效的方法。使用zipfileset属性是更好的解决方案。它让你从任何位置选择文件，然后把它们按照不同目录结构放进压缩文件中。以下是一个例子：

在这个例子中，所有JAR文件都放在EAR文件包的lib目录中。hr.jar和billing.jar是从构建目录拷贝过来的。因此我们使用zipfileset属性把它们移动到EAR文件包内部的lib目录。prefix属性指定了其在EAR文件中的目标路径。

14. 测试Clean任务

假设你的构建文件中有clean和compile的任务，执行以下的测试。第一步，执行ant clean；第二步，执行ant compile；第三步，再执行ant compile。第三步应该不作任何事情。如果文件再次被编译，说明你的构建文件有问题。

构建文件应该只在与输出文件相关联的输入文件发生变化时执行任务。一个构建文件在不必执行诸如编译、拷贝或其他工作任务的时候执行这些任务是低效的。当项目规模增长时，即使是小的低效工作也会成为大的问题。

15. 避免特定平台的Ant封装

不管什么原因，有人喜欢用简单的、名称叫做compile之类的批文件或脚本装载他们的产品。当你去看脚本的内容你会发现以下内容：

ant compile

其实开发人员都很熟悉Ant，并且完全能够自己键入ant compile。请不要仅仅为了调用Ant而使用特定平台的脚本。这只会使其他人在首次使用你的脚本时增加学习和理解的烦扰。除此之外，你不可能提供适用于每个操作系统的脚本，这是真正烦扰其他用户的地方。

总结

太多的公司依靠手工方法和特别程序来编译代码和生成软件发布版本。那些不使用Ant或类似工具定义构建过程的开发团队，花费了太多的时间来捕捉代码编译过程中出现的问题：在某些开发者那里编译成功的代码，到另一些开发者那里却失败了。

生成并维护构建脚本不是一项富有魅力的工作，但却是一项必需的工作。一个好的Ant构建文件将使你能够集中到更喜欢的工作——写代码中去！

<taglib>
  <taglib-uri>http://java.sun.com/jstl/fmt</taglib-uri>
  <taglib-location>/WEB-INF/fmt.tld</taglib-location>
  </taglib>
  <taglib>
   <taglib-uri>http://java.sun.com/jstl/core</taglib-uri>
   <taglib-location>/WEB-INF/c.tld</taglib-location>
  </taglib>
  <taglib>
   <taglib-uri>http://java.sun.com/jstl/sql</taglib-uri>
   <taglib-location>/WEB-INF/sql.tld</taglib-location>
  </taglib>
  <taglib>
   <taglib-uri>http://java.sun.com/jstl/x</taglib-uri>
   <taglib-location>/WEB-INF/x.tld</taglib-location>
  </taglib>

<c:out value="${anExpression}"/>
<c:out value="literalText${anExpression}${anotherExpression}"/>
<c:out value="literalText"/>

${alist[4]}
${aList[someVariable]}

${anObject.aProperty}
${anObject["aPropertyName"]}
${anObject[aVariableContainingPropertyName]}

　　在EL中定义了许多隐藏变量：
　　● pageContext：用于该网页的pageContext对象
　　● pageScope, requestScope, sessionScope, 和 applicationScope：这些是映射这些范围的每一个变量到值上的Map集。
　　● param 和 paramValues：用页访问传递的参数，与在JSP中一样
　　● header 和 headerValues：用页请求传递的头，与在JSP中一样
　　● cookie：Map映射cookie程序到特定的cookie对象上

　　EL定义了全套与你在Java中非常熟悉的那些完全对应的操作符。算法操作符包括+、 -、 *、 / (或 div)、 和% (或 mod)。相关的操作符包括==、！=、<、>、<=、>=，它分别对应于eq、ne、lt、gt、le、和ge。我不想详细阐述这些操作符，因为他们都能自我说明。

　　JSTL标记库
　　至此，我已经解释了一些基本原理并且涵盖了EL语法。我要专门讨论四种JSTL标记库。我主要讨论核心库，因为它是你一定要使用的；但是，我也会详细的讨论其余几个，以便你能启动它。

　　首先，尽管我应该更多地谈论JSTL标记库的两种风格，我上面提到的每个JSTL标记库以两个版本出现：一个支持使用EL的表达式；另一个支持标准JSP表达式。当你引入任何标记库到一个JSP页时，你要定义一个前缀，该前缀指定了与库中标记相对应的命名空间。

　　四种标准标记库，和他们的JSTL规范定义的前缀常规，列表如下。记住：你可以定义自己的前缀，但是这绝对没有什么好处。

四种标准标记库

　　为了使用页中的核心标记库（ 实际上，你使你的页对标记库的命名空间可见），在你的页首包含下列例子中的指令：

<%@ taglib prefix="c" uri=http://java.sun.com/jstl/core %>

　　为了使用该标记库的标记，用你在你的包含语句中设计好的前缀，在你的页中给每个标记加上前缀：

<c:out value="${anExpression}"/>

　　核心数据库

　　让我们更详细的测试核心数据库，先看看他最通用的功能。

　　显示/设定值和异常处理

　　核心库的最基本的标记是c:out标记，它在页中显示一个EL表达式的值。一个使用c:out的表达式通常是这样：

We have <c:out value="${applicationScope.product.inventoryCount}" escapeXml="true" default="0" /> of those items in stock.

　　上例中，value属性是我们送到页输出的表达式。我也说明了选项escapeXml的属性和默认属性。escapeXml的属性指定了XML字符(<、>、 &、 和 .)是否应该转化为相应的字符实体代码（这样他们可以让这些字符出现在一个HTML页中）；默认属性用于EL不能估算出数值或者数值计算出来为空的情况。

　　注意：当EL支持完全贯穿整个JSP2.0的时候，你不需要使用c:out动作；你可以仅嵌套JSP表达式直接在页中。

　　另一个普遍使用的核心动作是c:set，它在页中设定一个变量。你可以用两种方法使用c:set动作，第一种方法设定在var属性中定义的变量到在value属性中定义的值上，方法如下：

<c:set var="customerID" value="$param:customerNumber" scope="session" />

　　上述的选择项scope属性指定了我们要在会话期范围内设定变量customerID；如果范围没有制定，范围默认为页。

　　c:set另一个强大的用途就是将c:set标记的体的内容赋给一个指定的变量：

<c:set var="cellContents"> <td> <c:out value="${myCell}"/> </td> </c:set>

　　在上例中，c:set动作定义了名为cellContents（在页的范围内）的变量，该变量拥有在标记的体中定义的内容。在这种情况下，体定义了一个HTML表格单元格元素，计算体中的c:out动作，并且该计算的结果包括在体中的字符串直接量值。

　　就像你预想的那样，JSTL进行异常处理有点早。在典型的JSP页中，你有两种异常处理的方法：试图/捕捉直接嵌入到页中的小脚本代码中的块；或者用一个JSP errorPage指令。JSP errorPage指令提供一个良好的捕捉所有异常的方法来处理页中任何可能的异常。JSTL用一个c:catch动作提供一个好的可选择的方式。这个c:catch动作提供一个更细粒度的有效方法来处理异常。而且没有嵌入Java代码到页中。一个c:catch动作是这样的：

<c:catch> <!--. . . some set of nested JSTL tags below which would be hit on an exception--> </c:catch>

　　c:catch动作有一个可选的属性，即一个指向抛出异常的变量。

　　你可能不怎么愿意使用c:remove标记。这个标记有用于变量名和范围的属性，并且可从指定的范围内删除指定的变量。

　　流程控制
　　让我们转为讨论JSTL的流程控制和条件标记。如果你已经用任何一种语言使用了条件和流程控制语句，理论上这里没什么新鲜的东西。

　　c:if动作处理简单条件语句的测试。计算测试属性中的Boolean表达式的值，如果表达式为真的话，计算体的内容。在下面的动作中，我们也说明了备选项var属性。为了以后的使用，var属性保存测试结果在页（如果没有指定其他scope属性的话）中。

<c:if test="${status.totalVisits == 1000000}" var="visits"> You are the millionth visitor to our site! Congratulations! </c:if>

　　下面我们展示了用c:choose、 c:when、 和 c:otherwise交换逻辑的JSTL的支持。一组c:when动作可能包括在一个备选的标记内，如果在c:when块中任何表达式计算值为真的话，就不用计算c:choose动作内的测试。如果c:when块中没有一个测试计算值为真的时候：如果出现c:otherwise动作内容时，则计算c:otherwise动作的内容：

<c:choose> <c:when test="${item.type == 'book'}"> ... </c:when> <c:when test="${item.type == 'electronics'}"> ... </c:when> <c:when test="${item.type == 'toy'}"> ... </c:when> <c:otherwise> ... </c:otherwise> </c:choose>

　　c:foreach动作提供一个容易的方法来迭代一个集合的元素。如果你想只迭代集合的一部分的话，你可以分别用begin、 end、 和 step属性指定起点、终点和一个递增值。在下面的例子中，我们在变量customerNames中迭代一个集合的内容；在每个循环中，下一个元素输入到变量名内并在c:foreach动作的体内计算：

<table> <c:forEach var="name" items="${customerNames}"> <tr><td><c:out value="${name}"/></td></tr> </c:forEach> </table>

　　 记得Java的StringTokenizer类吗？有了c:forTokens动作，你可以用JSTL获得类似的功能。这个程序片断可使用在delims属性中定义的定界符通过items String属性中的条目迭代。注意，items 属性不必是一个字符直接量；它可以是任何有效的EL表达式:

<table> <c:forTokens items="47,52,53,55,46,22,16,2" delim="," var="dailyPrice"> <tr><td><c:out value="${dailyPrice}"/></td></tr> </c:forTokens> </table>

　　在接下来的完整的JSTL页中，我列出了已经传递到该页的所有参数。param 和paramValues对象是映射关键字到一个或多个值的Java Map集。在本例中，我们找出了用于集合的每个MapEntry的关键字即参数名，并且使用关键字来查找所有与关键字关联的参数值：

<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %> <html> <body> <head> <title>Parameter Listing Example</title> </head> <br> <b>Parameter values passed to this page for each parameter: </b> <table border="2"> <c:forEach var="current" items="${param}"> <tr> <td> <b><c:out value="${current.key}" /></b> </td> <c:forEach var="aVal" items="${paramValues[current.key]}"> <td> <c:out value="${aVal}" /> </td> </c:forEach> </tr> </c:forEach> </table> </body> </html>

　　其他动作
　　我们也需要讨论一些其他重要的核心标记库动作。在网页实现中一个潜在的问题范围与URL编码有关。没有URL编码，在网页中传递的URL的某个字符如空格，可能会迷惑Web服务器。URL编码确保这些特殊的字符用不引起迷惑的字符代替。下列例子在变量myUrl中定义了一个URL,该变量myUrl由一个URL和一系列参数组成。URL动作（注意，这里只在JSTL意义上的动作）保证所有字符都正确的编码:

<c:url value="http://acme.com/exec/register" var="myUrl"> <c:param name="name" value="${param.name}"/> <c:param name="country" value="${param.country}"/> </c:url> <a href='<c:out value="${myUrl}"/>'>Register</a>

　　在上面的代码中，param动作简单的定义了一组名值对。

　　JSP允许设计者用 <JSP:INCLUDE></JSP:INCLUDE>

　　<JSP:INCLUDE>指令包括其他页的内容。JSTL用JSTL c:import动作扩展了这个概念。c:import的主要优势是：你能指定一个任意的URL；也可以包含你的Web应用之外（W3C的任何地方）的页的内容或者你的服务器上的另一个Web应用内的页的内容。

　　对于一组与HTTP相关的标记来说，没有一个方法处理HTTP重定向是不完整的。JSTL用c:redirect动作支持它。

　　国际化标记库

　　在讨论了JSTL支持国际化中，我假设你已经有了对下列主题的合理的理解：

　　●资源包和Java如何找到它们
　　●Locale类
　　●资源包查找和MessageFormat类
　　●局部编码以及它与Java国际化的关系
　　●Java文本和数据格式化

　　如果你需要这些主题的更多的信息，请阅读Resources (http://www.javaworld.com/javaworld/jw-02-2003/jw-0228-jstl-p4.html#resources#resources)上的参考部分与国际化有关的参考文章。

　　我在下面的两个部分讨论了国际化标记库。在第一部分，我包括了你可能使用的格式化和解释相关的动作（它最初对应于java.text封装包中的类），尽管你没有开发过完全的国际化应用程序，可能你也要用到它。在第二部分，我说明了更针对于国际化的动作。

　　如果存在一个远程的可能性，你的应用程序会在你本国之外使用。如果你从一开始就建立在国际化的支持上，那么开发就会更加容易。无论你使用何种方法来开发，即使像JSTL一样容易使用的方法，一开始建立在国际化支持上也是十分有益的。

　　格式标记库：格式动作
　　如果你已经使用了Java的 DateFormat 和NumberFormat类，在下面的标记中使用的方法应该看起来眼熟，因为JSTL格式化动作是在这些类之上建立的。这些Java类普遍提供一个format( )函数，它将一个Java类型转化为一个格式化的String和创建对应于该String的Java对象。

　　fmt:formatNumber动作有一个value属性和一个pattern属性。value属性是一个与我们看到的其它value属性类似的EL表达式或者变量。pattern属性与在NumberFormat类中定义的模式一样。下列动作发送一个格式化的String到JSP页的输出上：

<fmt:formatNumber value="1000.001" pattern="#,#00.0#"/>

　　在这个fmt:formatNumber动作里，我们使用了type属性来指定：格式化我们需要格式化的值为一个货币值。我们保存格式化的结果在一个变量名为dollars中。在一个美国的locale类中，下面的程序生成一个字符串$3456.79（注意，它将使用的货币值四舍五入了）：

<fmt:formatNumber value="3456.789" type="currency" var="dollars"/>

　　用于上面的type属性的可能值包括currency、 number、 和percent。

　　在例中，我们使用了另一种方法——使用了一个包括在value属性中的一个格式化的域（currency，每type属性）的一个文本字符串。并且解析它来获取一个数字。结果储存在由var属性指定的一个变量内。尽管这个属性是可选的，还是会经常使用它。另外，解析的值送到页输出上：

<fmt:parseNumber value="${currencyInput}" type="currency" var="parsedNumber"/> fmt:formatDate动作有一个value属性、一个format属性、 一个指向处理格式化的格式类的属性（典型的，如java.util.Date）： <jsp:useBean id="now" class="java.util.Date" /> <fmt:formatDate value="${now}" timeStyle="long" dateStyle="long"/>

　　像数字格式化一样，JSTL页提供一个机制来解析一个代表日期的、进入Date对象的字符串：

<fmt:parseDate value="${dateInput}" pattern="MM dd, YYYY" />

　　查看java.util.DateFormat类，了解如何处理格式化和模式的更多详细的资料。

　　格式标记库：国际化动作
　　Java本地化的一个关键点是ResourceBundle类。JSTL动作允许你用这个类简单的工作。这个例子使用了fmt:bundle动作来得到与当前Locale 和 fmt:message动作对应的一个ResourceBundle动作，从而查看该资源包中的本地化的字符串：

<fmt:bundle basename="myBundle"> <%-- Use values in myBundle --%> <fmt:message key="Introduction"> <fmt:param value="${loginName}"/> <fmt:param value="${loginCount}"/> </fmt:message> <fmt:formatDate value="${now}" var="parsedDate"/> </fmt:bundle>

　　经常，fmt:message动作简单的查看了对应于一个关键词的字符串。在上面的例子中，在ResourceBundle中的字符串包含了取代两个值的占位符。这些值在fmt:param动作中定义过，这就像Java MessageFormat类使用的方法。

　　有一些类似的动作可指定一个时区，时区可应用到在标记的体中计算的任何事上：

<fmt:timeZone value="someTimeZone"> <!-- actions in this context will be evaluated using someTimeZone --> </fmt:timeZone>

　　上述的fmt:bundle 和 fmt:timeZone动作有分别对应的fmt:setBundle和fmt:setTimeZone的动作。这些动作添加了可选的scope属性；因此，你可以使用这些动作在任何等同于应用范围的范围内设定一个资源捆绑或者一个时区。

　　如果你用非欧洲的locale类工作的话，你可能得担心编码的问题，JSTL支持用fmt:requestEncoding动作编码。

　　SQL标记库

　　JSTL 允许容易的数据库的集成。但是，值得注意的是：沙箱之外的JSTL的执行有一些限制。主要的问题与连接池有关。建立并维护到数据库的连接是很消耗资源的。JSTL SQL动作使得许多数据库连接建立起来，通常的，每个用户至少有一个。因此，JSTL SQL标记对于原型开发的或低容量的、基于Web的应用程序意义重大。但是它不适合于大规模的应用程序。一个可缩放的产品应用程序一般是在一个页面内处理数据库访问如隐藏数据库访问和处理像连接池之类的细节。但是，还是有方法允许你实现连接池和用一点自定义码来使用JSTL SQL动作（请看："JSTL 1.0: What JSP Applications Need, Part 2" in Resources ：http://www.javaworld.com/javaworld/jw-02-2003/jw-0228-jstl-p5.html#resources#resources).

　　我们看一些简单的例子。这些例子使用来自SQL库的JSTL标记。如果你熟悉SQL基础的话，你应该能够改编这些例子用在你的应用程序上。

　　在下面的程序片断中，我们建立了一条到一个数据库的连接，选择一组匹配一个订单ID的订单项目，并且在一个表格中显示item属性：

<sql:setDataSource driver="com.cheapDrivers.jdbcDriver" url="jdbc:cheapDrivers:." user="guest" password="password" var="dataSource" /> <sql:query var="orderItems" dataSource="${dataSource}"> SELECT * FROM items WHERE order_id = <cout value="${orderID}"/> ORDER BY price </sql:query> <table> <c:forEach var="row" items="${orderItems.rows}"> <tr> <td><c:out value="${row.itemName}"/></td> <td><c:out value="${row.price}"/></td> <td><c:out value="${row.weight}"/></td> </tr> </c:forEach> </table>

　　在下一个例子中，我会说明JSTL是如何支持数据库事务的，在数据库中，许多包含对表格多个改动的操作必须是对所有的，或者什么也不做：如果出现一个问题时，改动必须为空操作。在下面例子中，sql:update动作包含在一个sql:transaction动作内，如果在事务处理过程中，存在任何SQL错误的话，在事务范围内执行的所有操作都得重来。

　　sql:update动作的命名有一点误导：除了SQL UPDATE外，sql:update也支持INSERT 和 DELETE，甚至是SQL CREATE。实际上，它支持不产生结果的任何一条SQL操作。在下面的例子中，sql:update通过插入变量值到一个PreparedStatement中来执行一个UPDATE动作。在这个代码片断中，我们在两个账户之间传送钱（需要预先包装在一个事务中的某些东西的一个经典的例子）：

<sql:transaction dataSource="${dataSource}"> <sql:update> UPDATE account SET account_balance =account_balance -? WHERE accountNo = ? <sql:param value="${transferAmount}"/> <sql:param value="${sourceAccount}"/> </sql:update> <sql:update> UPDATE account SET account_balance =account_balance +? WHERE accountNo = ? <sql:param value="${transferAmount}"/> <sql:param value="${destAccount}"/> </sql:update> </sql:transaction>

　　XML标记库
　　使用标准的XML标记库，你所能做的完整的处理，特别是可扩展性单一语言变换说明（XSLT）的处理，对于另一篇文章来说是一个很好的主题。下面我会涵盖足够的让你开始的知识。

　　在JSTL的XML支持遵循XPath规范。XPath的重要功能之一是为访问XML著名的分层的信息提供一个清晰的语法。也许看到每件是如何工作的最容易的方法就是看看我们如何使用来自于一个真实JSTL页的一个片断里的标记：

!-- Find and parse our XML document (somewhere on the WWW) --> <c:import url="http://www.cheapstuff.com/orderStatus?id=2435" var="xml"/> <x:parse xml="${xml}" var="doc"/> <!-- access XML data via XPath expressions --> <x:out select="$doc/name"/> <x:out select="$doc/shippingAddress"/> <x:out select="$doc/deliveryDate"/> <!-- Set a scoped variable --> <x:set var="custName" scope="request" select="$doc/name"/>

　　在上面的输入和解析动作中，我们装载和解析了一个指定的XML文档到一个变量doc里。在上面的每个x:out动作中，我们使用了一个XPath表达式访问了解析的XML文档的元素，并且发送结果到JSP页输出中。

　　上面的设置表达式计算了一个XPath表达式并且将结果输入到一个限定范围的变量里（在上述例子中，它指在一个请求范围内）。

　　x:out 和x:set动作可以输出一个JspTagException。如果他们没有成功的话（极有可能因为XPath表达式指向并不存在的标记），你的页，像在所有其他情况下一样，应该智能的处理这些异常（要么通过传统的JSP errorPage指令，要么使用JSTL的c:catch动作），

　　JSTL容易处理XSLT转换。在下面的示范页中，我们使用来自XML标记库中的x:transform动作，用一个XSLT stylesheet创建一个来自于XML源文档的一个格式化的页。x:transform动作最重要的属性是XML和XSLT属性，在下面的例子中，我们设置了一个来自于我们在同一页初始化的变量的xslt属性；我们也在动作的体中设置了XML属性。该动作默认为x:transform动作。

　　默认的，转换的结果送到页输出上；你也可以保存结果到一个带x:var属性的变量内：

<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %> <%@ taglib uri="http://java.sun.com/jstl/xml" prefix="x" %> <c:set var="xsltSource"> <?xml version="1.0"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:template match="/"> <xsl:apply-templates/> </xsl:template> <xsl:template match="music"> <html> <head></head> <body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0"> <table cellpadding="0" cellspacing="0" border="1" bgcolor="#ffffff"> <tr> <td><STRONG>Artist</STRONG></td> <td><STRONG>Album</STRONG></td> <td><STRONG>Year</STRONG></td> <td><STRONG>Genre</STRONG></td> </tr> <!---Set up for loop to collect all the artist information //--> <!-- <xsl:for-each select="./*[name()='artists']"> --> <xsl:for-each select="artists"> <tr> <td><xsl:value-of select="artist"/></td> <td><xsl:value-of select="album"/></td> <td><xsl:value-of select="year"/></td> <td><xsl:value-of select="genre"/></td> </tr> </xsl:for-each> </table> </body> </html> </xsl:template> </xsl:stylesheet> </c:set> <x:transform xslt="${xsltSource}" > <music> <artists> <artist>Jonny B</artist> <album>Feedback and Distortion</album> <year>2001</year> <genre>Rock</genre> </artists> <artists> <artist>Harmony's Nieces</artist> <album>Sappy Pop Ballads</album> <year>2002</year> <genre>Pop</genre> </artists> </music> </x:transform>

　　你也能使用c:import动作再定义一个额外的源文档和stylesheet，就好像在这个示范的代码片断展示的一样：：

<c:import var="${xmlSource}" url="${someDocumentURL}" /> <c:import var="${xsltSource}" url="${anotherDocumentURL}" /> <x:transform xml="${xmlSource}" xslt="${xsltSource}" >

　　结束语
　　至此，你应该对JSTL、它的四种标准标记库、和它如何使网页开发更为容易 有了很好的理解。现在你开始写一些JSTL!

• 远程服务的接口定义
• 远程服务接口的具体实现
• 桩（Stub）和框架（Skeleton）文件
• 一个运行远程服务的服务器
• 一个RMI命名服务，它允许客户端去发现这个远程服务
• 类文件的提供者（一个HTTP或者FTP服务器）
• 一个需要这个远程服务的客户端程序

　　下面我们一步一步建立一个简单的RMI系统。首先在你的机器里建立一个新的文件夹，以便放置我们创建的文件，为了简单起见，我们只使用一个文件夹存放客户端和服务端代码，并且在同一个目录下运行服务端和客户端。

　　如果所有的RMI文件都已经设计好了，那么你需要下面的几个步骤去生成你的系统：

　　1、  编写并且编译接口的Java代码
　　2、  编写并且编译接口实现的Java代码
　　3、  从接口实现类中生成桩（Stub）和框架（Skeleton）类文件
　　4、  编写远程服务的主运行程序
　　5、  编写RMI的客户端程序
　　6、  安装并且运行RMI系统

　　1、  接口
　　第一步就是建立和编译服务接口的Java代码。这个接口定义了所有的提供远程服务的功能，下面是源程序：

//Calculator.java
//define the interface
import java.rmi.Remote;

public interface Calculator extends Remote
{
    public long add(long a, long b)
        throws java.rmi.RemoteException;

    public long sub(long a, long b)
        throws java.rmi.RemoteException;

    public long mul(long a, long b)
        throws java.rmi.RemoteException;

    public long div(long a, long b)
        throws java.rmi.RemoteException;
}
　　注意，这个接口继承自Remote，每一个定义的方法都必须抛出一个RemoteException异常对象。

　　建立这个文件，把它存放在刚才的目录下，并且编译。

　　>javac Calculator.java

　　2、  接口的具体实现

　　下一步，我们就要写远程服务的具体实现，这是一个CalculatorImpl类文件：

//CalculatorImpl.java
//Implementation
import java.rmi.server.UnicastRemoteObject

public class CalculatorImpl extends UnicastRemoteObject implements Calculator
{

    // 这个实现必须有一个显式的构造函数，并且要抛出一个RemoteException异常
    public CalculatorImpl()
        throws java.rmi.RemoteException {
        super();
    }

    public long add(long a, long b)
        throws java.rmi.RemoteException {
        return a + b;
    }

    public long sub(long a, long b)
        throws java.rmi.RemoteException {
        return a - b;
    }

    public long mul(long a, long b)
        throws java.rmi.RemoteException {
        return a * b;
    }

    public long div(long a, long b)
        throws java.rmi.RemoteException {
        return a / b;
    }
}
　　同样的，把这个文件保存在你的目录里然后编译他。

　　这个实现类使用了UnicastRemoteObject去联接RMI系统。在我们的例子中，我们是直接的从UnicastRemoteObject这个类上继承的，事实上并不一定要这样做，如果一个类不是从UnicastRmeoteObject上继承，那必须使用它的exportObject()方法去联接到RMI。

　　如果一个类继承自UnicastRemoteObject，那么它必须提供一个构造函数并且声明抛出一个RemoteException对象。当这个构造函数调用了super()，它久激活UnicastRemoteObject中的代码完成RMI的连接和远程对象的初始化。

　　3、  桩（Stubs）和框架（Skeletons）

　　下一步就是要使用RMI编译器rmic来生成桩和框架文件，这个编译运行在远程服务实现类文件上。

　　>rmic CalculatorImpl

　　在你的目录下运行上面的命令，成功执行完上面的命令你可以发现一个Calculator_stub.class文件，如果你是使用的Java2SDK，那么你还可以发现Calculator_Skel.class文件。

　　4、  主机服务器

　　远程RMI服务必须是在一个服务器中运行的。CalculatorServer类是一个非常简单的服务器。

//CalculatorServer.java
import java.rmi.Naming;

public class CalculatorServer {

   public CalculatorServer() {
     try {
       Calculator c = new CalculatorImpl();
       Naming.rebind("rmi://localhost:1099/CalculatorService", c);
     } catch (Exception e) {
       System.out.println("Trouble: " + e);
     }
   }

   public static void main(String args[]) {
     new CalculatorServer();
   }
}
　　建立这个服务器程序，然后保存到你的目录下，并且编译它。

　　5、  客户端

　　客户端源代码如下：

//CalculatorClient.java

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.net.MalformedURLException;
import java.rmi.NotBoundException;

public class CalculatorClient {

    public static void main(String[] args) {
        try {
            Calculator c = (Calculator)
                           Naming.lookup(
                 "rmi://localhost
                        /CalculatorService");
            System.out.println( c.sub(4, 3) );
            System.out.println( c.add(4, 5) );
            System.out.println( c.mul(3, 6) );
            System.out.println( c.div(9, 3) );
        }
        catch (MalformedURLException murle) {
            System.out.println();
            System.out.println(
              "MalformedURLException");
            System.out.println(murle);
        }
        catch (RemoteException re) {
            System.out.println();
            System.out.println(
                        "RemoteException");
            System.out.println(re);
        }
        catch (NotBoundException nbe) {
            System.out.println();
            System.out.println(
                       "NotBoundException");
            System.out.println(nbe);
        }
        catch (
            java.lang.ArithmeticException
                                      ae) {
            System.out.println();
            System.out.println(
             "java.lang.ArithmeticException");
            System.out.println(ae);
        }
    }
}
　　保存这个客户端程序到你的目录下（注意这个目录是一开始建立那个，所有的我们的文件都在那个目录下），并且编译他。

　　6、  运行RMI系统

　　现在我们建立了所有运行这个简单RMI系统所需的文件，现在我们终于可以运行这个RMI系统啦！来享受吧。

　　我们是在命令控制台下运行这个系统的，你必须开启三个控制台窗口，一个运行服务器，一个运行客户端，还有一个运行RMIRegistry。

　　首先运行注册程序RMIRegistry，你必须在包含你刚写的类的那么目录下运行这个注册程序。

　　>rmiregistry

　　好，这个命令成功的话，注册程序已经开始运行了，不要管他，现在切换到另外一个控制台，在第二个控制台里，我们运行服务器CalculatorService，因为RMI的安全机制将在服务端发生作用,所以你必须增加一条安全策略。以下是对应安全策略的例子
grant {
permission java.security.AllPermission "", "";
};
　　注意:这是一条最简单的安全策略,它允许任何人做任何事,对于你的更加关键性的应用,你必须指定更加详细安全策略。
　　现在为了运行服务端，你需要除客户类(CalculatorClient.class)之外的所有的类文件。确认安全策略在policy.txt文件之后,使用如下命令来运行服务器。

　　> java -Djava.security.policy=policy.txt CalculatorServer

　　这个服务器就开始工作了，把接口的实现加载到内存等待客户端的联接。好现在切换到第三个控制台，启动我们的客户端。
　　为了在其他的机器运行客户端程序你需要一个远程接口(Calculator.class) 和一个stub(CalculatorImpl_Stub.class)。 使用如下命令运行客户端

　　 prompt> java -Djava.security.policy=policy.txt CalculatorClient

如果所有的这些都成功运行，你应该看到下面的输出：
　　1
　　9
　　18
　　3
　　如果你看到了上面的输出，恭喜你，你成功了，你已经成功的创建了一个RMI系统，并且使他正确工作了。即使你运行在同一个计算机上，RMI还是使用了你的网络堆栈和TCP/IP去进行通讯，并且是运行在三个不同的Java虚拟机上。这已经是一个完整的RMI系统。