common-fileupload组件是apache的一个开源项目之一，可以从http://jakarta.apache.org/commons/fileupload/下载。用该组件可实现一次上传一个或多个文件，并可限制文件大小。
下载后解压zip包，将commons-fileupload-1.0.jar复制到tomcat的webapps\你的webapp\WEB-INF\lib\下，目录不存在请自建目录。

新建一个servlet: Upload.java用于文件上传：

在 JDBC 应用程序中，JDBC 语句对象用于将 SQL 语句发送到数据库服务器。一个语句对象与一个连接相关联，应用程序与数据库服务器之间的通信由语句对象来处理。

JDBC 中有三种类型的语句对象：

1. 常规语句（General statement）
2. 预置语句（Prepared statement）
3. 可调用语句（Callable statement）

语句对象与一个连接相关联，所以要创建一个语句对象，首先应该建立一个数据库连接。

创建连接

清单 1 中的代码示例演示了如何创建连接：

            Connection con = null;
            try {
            Class.forName("com.informix.jdbc.IfxDriver");
            String url = "jdbc:informix-sqli://hostname:port_number/dbname:
            informixserver=servername; userid=userid;password=pwd;";
            con = DriverManager.getConnection(url);
            }
            

现在逐个考察这三种类型的语句对象。

常规语句

可以使用连接的 createStatement 方法创建这种语句。这种语句专用于不需要传递任何值作为参数的 SQL 语句。

            Statement stmt = con.createStatement();
            cmd = "create database testDB;";
            rc = stmt.executeUpdate(cmd);
            stmt.close();
            

预置语句

预置语句是 statement 类的一个子类。预置语句与 statement 类的主要区别在于，前者可以只编译和优化一次，然后通过设置不同的参数值多次使用。所以，如果想多次执行一条语句，那么预置语句是更好的选择。由于已经预先编译好，所以减少了执行时间。因此，预置语句的优点是，它不仅包含一条 SQL 语句，而且还是一条预先编译好的 SQL 语句。另一个区别是，SQL 语句在创建后就被提供给预置语句。

            PreparedStatement pstmt = con.prepareStatement("UPDATE tab1 "+
            "set col1 = ? where key = 1");
            pstmt.setShort(1, (short)2);
            int rowcount = pstmt.executeUpdate();
            

在此，同一个预置语句可用于不同的 col1 值。参数一旦设定，它的值将保持不变，直到被重新设置或者 clearParameters 被调用。这项特性使得预置语句可以用于批量处理 INSERT/UPDATE。

批量更新

通过设置多个值，批量更新特性提高了需要多次执行的语句的性能。这样可以将多个更新操作提交到一个数据源并进行一次性处理。语句对象也可以使用批量更新。但语句对象提交不同的 SQL 语句进行批处理，而预置语句提交的是一组参数。

清单 4 显示了如何使用预置语句进行批量插入：

            PreparedStatement pst = conn.prepareStatement("insert into tab1 values (?)");
            for loop....
            {
            pst.setInt (1, i);
            pst.addBatch();
            }
            pst.executeBatch();
            

addBatch 方法将语句添加到一个缓存中，然后使用 executeBatch() 方法转储到数据库中。所以它节省了语句的编译/优化，因为它只编译一次（对于预置语句），而且还节省了与服务器之间的往返，因为它一次性发送了批量插入。

可调用语句

这是调用 SQL 语句的第三种方法，它提供了一种从 Java™ 程序中调用服务器上的存储过程的方式。可调用语句也需要先作准备，然后使用 set 方法设置它们的参数。可以通过以下两种方式设置参数值：

1. 顺序位置
2. 命名参数

顺序位置是传统的参数设置方式，它根据参数在 CallableStatements 中的位置来设置参数。但是，命名参数则提供了更大的灵活性，它允许根据名称而不是顺序位置来设置参数。在调用例程时，必须以名称或顺序格式指定 CallableStatement 的参数。例如，如果对一个参数使用了参数名称，那么对所有其他参数也必须使用参数名称。

在调用具有许多参数，而且其中一些参数有默认值的存储过程时，命名参数特别有用。如果过程是惟一的，那么可以省略有默认值的参数，并且可以按任意顺序输入参数。命名参数使应用程序更加健壮，所以，即使存储过程中参数的顺序发生了改变，也不必修改应用程序。

JDBC 驱动程序提供了 DatabaseMetaData.supportsNamedParameters() 方法来确认驱动程序和 RDMS 是否支持 CallableStatement 中的命名参数。如果支持命名参数，则系统返回 true。例如：

            Connection myConn = . . .   // connection to the RDBMS for Database
            DatabaseMetaData dbmd = myConn.getMetaData();
            if (dbmd.supportsNamedParameters() == true)
            {
            System.out.println("NAMED PARAMETERS FOR CALLABLE"
            + "STATEMENTS IS SUPPORTED");
            }
            

获取存储过程的参数名称

可以使用 DatabaseMetaData 的 getprocedureColumns 获取存储过程的参数名称，该方法的定义如清单 6 所示：

            Connection myConn = . . .   // connection to the RDBMS for Database
            . .
            DatabaseMetaData dbmd = myConn.getMetaData();
            ResultSet rs = dbmd.getProcedureColumns(
            "myDB", schemaPattern, procedureNamePattern, columnNamePattern);
            rs.next() {
            String parameterName = rs.getString(4);
            - - - or - - -
            String parameterName = rs.getString("COLUMN_NAME");
            - - -
            System.out.println("Column Name: " + parameterName);
            

与 getProcedureColumns() 方法的参数相匹配的所有列的名称都将被显示。

清单 7 显示了 CallableStatements 中的命名参数的使用。

创建存储过程

            create procedure createProductDef(productname   varchar(64),
            productdesc  varchar(64),
            listprice    float,
            minprice     float,
            out prod_id      float);
            . . .
            let prod_id="value for prod_id";
            end procedure;
            

清单 8 中的 Java 代码首先创建一个有 5 个参数的 CallableStatement，这 5 个参数与存储过程中的参数相对应。JDBC 调用的括号中的问号字符 (?) 对参数进行引用。设置或注册所有的参数。使用格式 cstmt.setString("arg", name); 命名参数，其中 arg 是相应的存储过程中的参数名称。这里不需要按照存储过程中的参数顺序来命名参数。

            String sqlCall = "{call CreateProductDef(?,?,?,?,?)}";
            CallableStatement cstmt = conn.prepareCall(sqlCall);
            cstmt.setString("productname", name);     // Set Product Name.
            cstmt.setString("productdesc", desc);     // Set Product Description.
            cstmt.setFloat("listprice", listprice);   // Set Product ListPrice.
            cstmt.setFloat("minprice", minprice);     // Set Product MinPrice.
            // Register out parameter which should return the product is created.
            cstmt.registerOutParameter("prod_id", Types.FLOAT);
            // Execute the call.
            cstmt.execute();
            // Get the value of the id from the OUT parameter: prod_id
            float id = cstmt.getFloat("prod_id");
            

如果 CallableStatement 中的参数数量少于存储过程中的参数数量，那么剩下的参数必须有默认值。不需要为有默认值的参数设置值，因为服务器会自动使用默认值。例如，如果一个存储过程有 10 个参数，其中 4 个参数没有默认值，6 个参数有默认值，那么在 CallableStatement 中必须至少有 4 个问号。也可以使用 5 个、6 个或至多 10 个问号。在下面这个惟一的存储过程中，参数 listprice 和 minprice 有默认值：

            create procedure createProductDef(productname   varchar(64),
            productdesc  varchar(64),
            listprice    float default 100.00,
            minprice     float default  90.00,
            out prod_id      float);
            . . .
            let prod_id = value for prod_id;
            end procedure;

清单 10 中的 Java 代码使用少于存储过程中参数数量的参数（存储过程中有 5 个参数，而代码中只使用 4 个参数）调用存储过程。由于 listprice 有一个默认值，因此可以在 CallableStatement 中省略它。

            String sqlCall = "{call CreateProductDef(?,?,?,?)}";
            // 4 params for 5 args
            CallableStatement cstmt = conn.prepareCall(sqlCall);
            cstmt.setString("productname", name);   // Set Product Name.
            cstmt.setString("productdesc", desc);   // Set Product Description.
            cstmt.setFloat("minprice", minprice);   // Set Product MinPrice.
            // Register out parameter which should return the product id created.
            cstmt.registerOutParameter("prod_id", Types.FLOAT);
            // Execute the call.
            cstmt.execute();
            // Get the value of the id from the OUT parameter: prod_id
            float id = cstmt.getFloat("prod_id");
            

如果可调用语句包含 OUT 或 INOUT 参数，那么需要使用 CallableStatement 的 registerOutParameter 注册这些参数。清单 11 使用 out 参数 prod_id 创建一个具有 OUT 参数的存储过程。类似地，可以使用关键字 INOUT 创建 INOUT 参数。

            create procedure createProductDef(productname   varchar(64),
            productdesc  varchar(64),
            inout    listprice    float default 100.00,
            minprice     float default  90.00,
            out prod_id      float);     

清单 12 使用 CallableStatements registerOutparameter 方法注册 CallableStatement 的 out 参数。

            cstmt.registerOutParameter("prod_id", Types.FLOAT);
            

清单 13 将使用命名参数特性的所有语句合并在一起：

            package Callable;
            import java.sql.CallableStatement;
            import java.sql.Connection;
            import java.sql.DriverManager;
            import java.sql.ResultSet;
            import java.sql.SQLException;
            import java.sql.Statement;
            import java.sql.Types;
            public class out1 {
            static Connection conn;
            public static void main(String[] args) {
            getConnect();
            System.out.println("Connection Established");
            createProc();
            runthis();
            System.out.println("\n=============Finished=============");
            System.exit(0);
            }
            private static void getConnect() {
            try
            {
            Class.forName("com.informix.jdbc.IfxDriver");
            String url = "jdbc:informix-sqli://host name or ip :porn number/database
            name:informixserver=dbservername;";
            System.out.println("URL: "+url);
            conn = DriverManager.getConnection(url);
            }
            catch( Exception e )
            {
            e.printStackTrace();
            System.exit(1);
            }
            }
            private static void createProc() {
            String str=null;
            Statement stmt = null;
            try
            {
            stmt = conn.createStatement();
            }
            catch (SQLException e2)
            {
            e2.printStackTrace();
            }
            str="drop function c_out_proc";
            try
            {
            stmt.executeUpdate (str);
            }
            catch (SQLException e1)
            {	}
            str = "create function  c_out_proc ( i int, OUT d varchar(20) ) \n" +
            "returning float; \n" +
            "define f float; \n" +
            "let d= \"Hello OUT\"; \n" +
            "let f=i*2; \n" +
            "return f; \n" +
            "end function; \n";
            try
            {
            stmt.executeUpdate (str);
            System.out.println("Function created \n");
            }
            catch (SQLException e)
            {
            System.out.println("Error on creating function: " + e.toString());
            System.exit(1);
            }
            }
            private static void runthis()
            {
            CallableStatement cstmt = null;
            String command = "{? = call c_out_proc(?, ?)}  ";
            try
            {
            cstmt = conn.prepareCall (command);
            cstmt.setInt(1, 2);
            cstmt.registerOutParameter(2, Types.VARCHAR);
            ResultSet rs = cstmt.executeQuery();
            if (rs == null)
            {
            System.out.println("rs is null *** this is BAD.");
            System.exit(0);
            }
            else
            {
            rs.next();
            System.out.println(rs.getFloat(1));
            System.out.println(cstmt.getString(2));
            }
            }
            catch (SQLException e)
            {
            e.printStackTrace();
            }
            }
            }

<html> 
 <head> 
 <title>利用XMLHTTP检测网址及探测服务器类型</title> 
 <META http-equiv=Content-Type content="text/html; charset=gb2312"> 
 <meta name="Generator" content="EditPlus"> 
 <meta name="Author" content="JnKc">
 <meta name="Keywords" content="">
 </head> 
 <body> 
 <input type="text" id="jnkcInput" value="http://www.cnbruce.com" size="50"><button id="chk">检测</button> 
 <div id="jnkc_show"></div> 
 <scrīpt LANGUAGE="VBscrīpt"> 
 Dim i,jnkcUrl,jnkcHTML,jnkcStatus,jnkcServer 
 Function chk_onClick() 
 jnkcUrl = jnkcInput.value 
 Call GetDetail 
 i = i+1 
 jnkc_show.innerHTML = "<hr><pre><font color=red>" & i & "、" & jnkcUrl & "</font><br>" & jnkcStatus & "</pre>" & jnkc_show.innerHTML 
 End Function 
 Dim jnkcXMLHTTP 
 Sub GetDetail 
    Set jnkcXMLHTTP = CreateObject("Msxml2.XMLHTTP") 
      jnkcXMLHTTP.OnReadyStateChange = GetRef("GetStatus") 
      jnkcXMLHTTP.Open "GET", jnkcUrl, False 
      On Error Resume Next 
      jnkcXMLHTTP.Send 
    Set jnkcXMLHTTP = Nothing 
 End Sub 
 Sub GetStatus 
    If jnkcXMLHTTP.ReadyState <> 4 Then
      Exit Sub 
    End If 
    If jnkcXMLHTTP.Status = 404 Then
      jnkcStatus = "该网页不存在！" 
    ElseIf jnkcXMLHTTP.Status < 200 Then
      jnkcStatus = "客户端错误，信息：" & CStr(jnkcXMLHTTP.Status) & " " & jnkcXMLHTTP.StatusText 
    ElseIf jnkcXMLHTTP.Status < 300 Then 
      jnkcStatus = "成功，该网页能访问。" 
    ElseIf jnkcXMLHTTP.Status < 400 Then
      jnkcStatus = "重定向，信息：" & CStr(jnkcXMLHTTP.Status) & " " & jnkcXMLHTTP.StatusText 
    ElseIf jnkcXMLHTTP.Status < 500 Then
      jnkcStatus = "客户端错误，信息：" & CStr(jnkcXMLHTTP.Status) & " " & jnkcXMLHTTP.StatusText 
    ElseIf jnkcXMLHTTP.Status < 600 Then
      jnkcStatus = "服务器错误，信息：" & CStr(jnkcXMLHTTP.Status) & " " & jnkcXMLHTTP.StatusText 
    Else 
      jnkcStatus = "域名不可用或网络连接错误，信息：" & CStr(jnkcXMLHTTP.Status) & " " & jnkcXMLHTTP.StatusText 
    End If 
    If jnkcXMLHTTP.Status < 600 Then Call GetServer 
 End Sub
 
 Sub GetServer
    jnkcServer = jnkcXMLHTTP.GetResponseHeader("Server") 
    If jnkcServer <> "" Then 
      jnkcStatus = jnkcStatus & "<br>HTTP服务器：" & jnkcServer 
    End If 
    jnkcStatus = "<b>" & jnkcStatus & "</b><br>所有反馈信息：<br>"& jnkcXMLHTTP.GetAllResponseHeaders 
 End Sub 
 </scrīpt> 
 </body> 
 </html> 

　　 是在服务器端起作用,当使用forward()时,Servlet engine传递HTTP请求从当前的Servlet or JSP到另外一个Servlet,JSP 或普通HTML文件,也即你的form提交至a.jsp,在a.jsp用到了forward()重定向至b.jsp,此时form提交的所有信息在 b.jsp都可以获得,参数自动传递.

　　但forward()无法重定向至有frame的jsp文件,可以重定向至有frame的html文件,同时forward()无法在后面带参数传递,比如servlet?name=frank,这样不行,可以程序内通过response.setAttribute("name",name)来传至下一个页面.

　　重定向后浏览器地址栏URL不变.

　　例:在servlet中进行重定向

public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException
{
　 response.setContentType("text/html; charset=gb2312");
　 ServletContext sc = getServletContext();
　 RequestDispatcher rd = null;
　 rd = sc.getRequestDispatcher("/index.jsp"); //定向的页面
　 rd.forward(request, response);
}

　　通常在servlet中使用，不在jsp中使用。

　　 2.response.sendRedirect()

　　是在用户的浏览器端工作,sendRedirect()可以带参数传递,比如servlet?name=frank传至下个页面,同时它可以重定向至不同的主机上,sendRedirect()可以重定向有frame.的jsp文件.

　　重定向后在浏览器地址栏上会出现重定向页面的URL

　　例:在servlet中重定向

public void doPost(HttpServletRequest request,HttpServletResponse response)
throws ServletException,IOException
{
　 response.setContentType("text/html; charset=gb2312");
　 response.sendRedirect("/index.jsp");
}

　　由于response是jsp页面中的隐含对象，故在jsp页面中可以用response.sendRedirect()直接实现重定位。

　　注意：

　　 (1) 使用response.sendRedirect时，前面不能有HTML输出

　　这并不是绝对的，不能有HTML输出其实是指不能有HTML被送到了浏览器。事实上现在的server都有cache机制，一般在8K（我是说 JSP　SERVER），这就意味着，除非你关闭了cache，或者你使用了out.flush()强制刷新，那么在使用sendRedirect之前，有少量的HTML输出也是允许的。

　　 (2) response.sendRedirect之后，应该紧跟一句return;

　　我们已经知道response.sendRedirect是通过浏览器来做转向的，所以只有在页面处理完成后，才会有实际的动作。既然你已经要做转向了，那么后的输出还有什么意义呢？而且有可能会因为后面的输出导致转向失败。

　　比较：

　　 (1) Dispatcher.forward()是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；

　　 (2) response.sendRedirect()则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。

　　前者更加高效，在前者可以满足需要时，尽量使用RequestDispatcher.forward()方法.

　　注：在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用HttpServletResponse.sendRequest()方法。

　　 3.<jsp:forward page="" />

　　它的底层部分是由RequestDispatcher来实现的，因此它带有RequestDispatcher.forward()方法的印记。

　　如果在<jsp:forward>之前有很多输出,前面的输出已使缓冲区满,将自动输出到客户端,那么该语句将不起作用,这一点应该特别注意。

　　另外要注意：它不能改变浏览器地址，刷新的话会导致重复提交

　　 4.修改HTTP header的Location属性来重定向

　　通过设置直接修改地址栏来实现页面的重定向。

　　 jsp文件代码如下：

<%
response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);
String newLocn = "/newpath/jsa.jsp";
response.setHeader("Location",newLocn);
%>

　　 5.JSP中实现在某页面停留若干秒后,自动重定向到另一页面

　　在html文件中，下面的代码：

<meta http-equiv="refresh" content="300; url=target.jsp">

　　它的含义：在5分钟之后正在浏览的页面将会自动变为target.html这一页。代码中300为刷新的延迟时间，以秒为单位。targer.html为你想转向的目标页,若为本页则为自动刷新本页。

　　由上可知，可以通过setHeader来实现某页面停留若干秒后,自动重定向到另一页面。

　　关键代码：

String content=stayTime+";URL="+URL;
response.setHeader("REFRESH",content);

　　通过JDBC3.0规范可以知道具体数据库连接池的实现可以分为JDBC Driver级和Application Server级。在JDBC Driver级的实现中任何相关的工作均由特定数据库厂商的JDBC Drvier的开发人员来具体实现，即JDBC Driver既需要提供对数据库连接池的支持同时也必须对数据库连接池进行具体实现。而在Application Server级中数据库连接池的实现中特定数据库厂商的JDBC Driver开发人员和Application Server开发人员来共同实现数据库连接池的实现（但是现在大多数Application Server厂商实现的连接池的机制和规范中提到有差异），其中特定数据库厂商的JDBC Driver提供数据库连接池的支持而特定的Application Server厂商提供数据库连接池的具体实现。

　　JDBC3.0规范规定了如下的类和接口来支持数据库连接池的实现。

javax.sql.ConnectionEvent
javax.sql.ConnectionPoolDataSource
javax.sql.PooledConnection
javax.sql.ConnectionEventListener

　　其中除javax.sql.ConnectionEvent是类，其它的均为接口。

JDBC3.0连接池框架的关系图

　　通过此图可以大概的了解相关接口在一个典型的三层环境中应用程序的位置。

2、检索自动产生的关键字
　　为了解决对获取自动产生的或自动增加的关键字的值的需求，JDBC 3.0 API 现在将获取这种值变得很轻松。要确定任何所产生的关键字的值，只要简单地在语句的 execute() 方法中指定一个可选的标记，表示您有兴趣获取产生的值。您感兴趣的程度可以是 Statement.RETURN_GENERATED_KEYS，也可以是 Statement.NO_GENERATED_KEYS。在执行这条语句后，所产生的关键字的值就会通过从 Statement 的实例方法 getGeneratedKeys() 来检索 ResultSet 而获得，ResultSet 包含了每个所产生的关键字的列，下面的示例创建一个新的作者并返回对应的自动产生的关键字。

……
Statement stmt = conn.createStatement();
// Obtain the generated key that results from the query.
stmt.executeUpdate("INSERT INTO authors " +
"(first_name, last_name) " +
"VALUES (‘Ghq’, ‘Wxl’)",
Statement.RETURN_GENERATED_KEYS);
ResultSet rs = stmt.getGeneratedKeys();
if ( rs.next() ) {
// Retrieve the auto generated key(s).
int key = rs.getInt();
}
……

3、返回多重结果
　　JDBC 2 规范的一个局限是，在任意时刻，返回多重结果的语句只能打开一个ResultSet。作为 JDBC 3.0 规范中改变的一个部分，规范将允许 Statement 接口支持多重打开的 ResultSets。然而，重要的是 execute() 方法仍然会关闭任何以前 execute() 调用中打开的 ResultSet。所以，要支持多重打开的结果，Statement 接口就要加上一个重载的 getMoreResults() 方法。新式的方法会做一个整数标记，在 getResultSet() 方法被调用时指定前一次打开的 ResultSet 的行为。接口将按如下所示定义标记：

　　CLOSE_ALL_RESULTS：当调用 getMoreResults() 时，所有以前打开的 ResultSet 对象都将被关闭。

　　CLOSE_CURRENT_RESULT：当调用 getMoreResults() 时，当前的 ResultSet 对象将被关闭。

　　KEEP_CURRENT_RESULT：当调用 getMoreResults() 时，当前的 ResultSet 对象将不会被关闭。

　　下面展示的是一个处理多重打开结果的示例。

……
String procCall;
// Set the value of procCall to call a stored procedure.
// …
CallableStatement cstmt = connection.prepareCall(procCall);
int retval = cstmt.execute();
if (retval == false) {
// The statement returned an update count, so handle it.
// …
} else { // ResultSet
ResultSet rs1 = cstmt.getResultSet();
// …
retval = cstmt.getMoreResults(Statement.KEEP_CURRENT_RESULT);
if (retval == true) {
ResultSet rs2 = cstmt.getResultSet();
// Both ResultSets are open and ready for use.
rs2.next();
rs1.next();
// …
}
}
……

Savepoint 的直观表示
　　你或许不是经常需要使用 Savepoint。然而，在一种普遍的情况下 Savepoint 会发挥作用，那就是您需要作一系列的改变，但是在知道所有的结果之前不能确定应该保留这些改变的哪一部分。下面的代码示例说明了如何使用 Savepoint 接口。

......
conn.setAutoCommit(false);
// Set a conservative transaction isolation level.
conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
Statement stmt = conn.createStatement();
int rows = stmt.executeUpdate( "INSERT INTO authors " +
" (first_name, last_name) VALUES " +
" ('Ghq', 'Wxl')");
// Set a named savepoint.
Savepoint svpt = conn.setSavepoint("NewAuthor");
// …
rows = stmt.executeUpdate( "UPDATE authors set type = 'fiction' " +
"WHERE last_name = 'Wxl'");
// …
conn.rollback(svpt);
// …
// The author has been added, but not updated.
conn.commit();
......

5、其他的特性
　　1）元数据 API
　　元数据 API 已经得到更新，DatabaseMetaData 接口现在可以检索 SQL 类型的层次结构，一种新的 ParameterMetaData 接口可以描述 PreparedStatement 对象中参数的类型和属性。

　　2）CallableStatements 中已命名的参数
　　在 JDBC 3.0 之前，设置一个存储过程中的一个参数要指定它的索引值，而不是它的名称。 CallableStatement 接口已经被更新了，现在您可以用名称来指定参数。

　　3）数据类型的改变
　　JDBC 所支持的数据类型作了几个改变，其中之一是增加了两种新的数据类型。

　　为了便于修改 CLOB（Character Large OBject，字符型巨对象）、BLOB（Binary Large OBject，二进制巨对象）和 REF（SQL 结构）类型的值，同名的数据类型接口都被更新了。接下来的是，因为我们现在能够更新这些数据类型的值，所以 ResultSet 接口也被修改了，以支持对这些数据类型的列的更新，也包括对 ARRAY 类型的更新。增加的两种新的数据类型是 java.sql.Types.DATALINK 和 java.sql.Types.BOOLEAN。新增的数据类型指的是同名的 SQL 类型。DATALINK 提供对外部资源的访问或 URL，而 BOOLEAN 类型在逻辑上和 BIT 类型是等同的，只是增加了在语义上的含义。DATALINK 列值是通过使用新的 getURL() 方法从 ResultSet 的一个实例中检索到的，而 BOOLEAN 类型是通过使用 getBoolean() 来检索的。

二进制大对象Blob
　　Blob对象是SQL Blob的Java语言映射。SQL Blob是一个内置类型，它可以将一个二进制大对象保存在数据库中。接口ResultSet、CallableStatement和PreparedStatement中的方法允许程序员使用与访问SQL 92内置类型同样的方式来访问SQL 99类型BLOB。

　　在标准实现中，JDBC驱动程序在后台使用SQL类型LOCATOR(BLOB)来实现Blob接口。LOCATOR(BLOB)指向保存在数据库服务器上的SQL BLOB值，而且这些操作作用在这个LOCATOR（定位器）上与作用在BLOB值本身有同样的结果。这意味着用户可以在一个Blob实例上执行操作而不必将这个BLOB数据物化到用户上，这将显著的提高性能。因为驱动程序在后台使用LOCATOR(BLOB),所以它的使用对程序员是完全透明的。

　　Blob实例的标准行为一直保持有效，直到这个事务（创建一个Blob的事务）执行了提交或者回滚操作。

1. 创建Blob对象
   　　下面的代码说明了如何创建一个Blob对象，其中stmt是一个Statement对象：

   Statement stmt = con..createStatement(ResultSet.TYPE_INSENSITIVE,
       ResultSet.CONCUR_READ_ONLY);
       ResultSet rs = stmt.excuteQuery(“SELECT DATA  FROM  TABLE	1”);
       If (rs.next()){
       rs.first();
       Blob blob=rs.getBlob(“DATA”);
       }
       变量blob包含一个指向BLOB值的逻辑指针，该BLOB值保存在结果集rs的第一行的DATA列中。即使变量blob实际上并不包含BLOB值中的数值，应用程序在blob上执行操作仍然像在实际的数据上执行一样。即应用程序在blob上所作的任何操作都会对表中的BLOB值起作用。

2. 物化BLOB数据
   　　开发人员可以在Blob对象上调用JDBC API中的方法，就像这些方法直接
   　　在该对象所指向的SQL BLOB上执行操作一样。然而，如果想在BLOB数据上执行操作，就必须首先将BLOB数据物化到客户。Blob接口提供了两个方法来物化BLOB数据：getBinaryStream，这个方法将BLOB数据物化为一个输入流；getBytes，这个方法将BLOB值得一部分或者全部物化为一个字节数组。下面的代码说明了如何将Blob所指向的BLOB值得全部物化为一个输入流：

    java.io.InputStream in = blob.getBinaryStream();
       byte b;
       while((b = in.read()) >-1){
       System.out.println(b);
       }
       

   接下来的代码同样物化了blob所指向的BLOB值得所有数据，但是它产生的是字节数组而不是输入流。

    long len = blob.length();
       byte [] data = blob.getBytes(1,len);
       for(int i=0;i<len;i++){
       byte b = data[i];
       System.out.println(b);
       }
       

   　　变量data复制了blob所指向的BLOB值的所有字节。这是因为传递给方法getBytes的参数值说明了整个BLOB值：第一个参数表示从第一个字节开始返回字节，第二个参数说明它返回的字节长度是BLOB值的长度。
   　　需要说明的是，因为SQL和Java语言之间的不同，一个BLOB值得第一个字节在位置1，而Java数组的第一个元素的索引是0。
3. 存储Blob值
   　　若要在数据库中存储Blob值，应用程序可以把它作为一个参数传递给
   　　PreparedStatement的方法setBlob。下面的代码就实现了这个功能：

   PreparedStatement的方法setBlob。下面的代码就实现了这个功能：
       Blob stats = rs.getBlob(“STATS”);
       PreparedStatement pstmt= con.preparedStatement(
       “UPDATE SIGHTINGS SET MEAS= ? WHERE  AREA = ‘BEIJING’ ”);
       pstmt.setBlob(1,stats);
       pstmt.excuteUpdate();
       

4. 发现Blob对象中的模式
   　　如果一个Blob对象包含一个给定的字节集合，应用程序可以使用方法
   　　position的两个方法来找到它。其中一个方法搜索一个给定的字节数组，而另一个在一个Blob对象中搜索一个给定的Blob对象。如果发现一个匹配的结果，则返回该模式字节的起始位置。
5. 修改Blob对象的方法
   　　JDBC 3.0 API中新增的方法setBytes和setBinaryStream允许应用程序对
   　　Blob对象进行修改。
   　　方法setBytes有两个方法来向Blob对象添加数据。其中一个方法增加给定的字节数组的全部内容，而另一个方法增加给定字节数组的特定部分。两个方法都使用一个参数说明向Blob对象插入数据的起始位置。例如，下面的代码段在一个Blob对象blob1的第一个字节处写入整个字节数组bytes。在这种情况下，bytes包含了Blob对象blob的所有字节，因此执行的结果是blob2被写入了blob1的起始处。需要注意的是如果blob2的长度是1024字节，那么blob2的1024各字节将覆盖blob1的开头的1024各字节。

   byte [] bytes = blob2.getBytes(1,blob2.length());
       blob.setBytes(1,bytes,0,512);
       

   　　下面的代码段说明如何仅仅向Blob对象加入一个字节数组的特定部分。在这种情况下，方法setBytes接受两个附加的参数来说明需要增加字节数组的哪一个部分。其中一个参数指明了这个字节数组的起始偏移量，另一个参数说明这个字节数组包含多少个连续的字节。

   byte [] bytes={……};
       blob.setBytes(1,bytes,0,512);
       

   　　除了可以向Blob对象增加字节之外，Blob接口还提供了删除字节的方法。方法truncate接受一个字节数目作为一个参数并且根据这个数目来缩短Blob对象。
6. 定位器和更新
   　　在标准实现中，指向SQL BLOB的Blob对象使用了SQL LOCATOR类型。定位器(locator)是一个指向保存在数据库中的BLOB值的指针，而DBMS如何更新一个作为定位器实现的对象则依赖于具体的数据库。某些DBMS会更新表中的BLOB值，而另一些则仅仅更新BLOB值的一个副本，并不改变数据库中的值。在后一种情况下，应用程序必须直接更新BLOb值。
   　　为了发现DBMS是如何更新BLOB值的，应用程序可以调用DatabaseMetaData的方法locatorsUpdateCopy。如果这个方法返回true，则应用程序必须自己更新数据库中的BLOB值。下面的代码显示了这个过程：首先从rs取回Blob对象，然后把它的值改为字节数据val的值。如果方法locatorsUpdateCopy返回true，那么它随后执行一个PreparedStatement对象来更新数据库中的值。如果方法locatorsUpdateCopy返回false，代码什么也不用做，因为数据库中的值已经被更新过了。

   byte [] val ={0,1,2,3,4};
       Blob data =rs.getBlob(“DATA”);
       int numWritten = data.setBytes(1,val);
       if (dbmd.locatorUpdateCopy() == true){
       PreparedStatement pstmt= con . preparedStatement(
       “UPDATE statistics SET DATA = ? WHERE REGION = ‘BEIJING’ “);
       pstmt.setBlob(“DATA”,data);
       pstmt.executeUpdate();
       }
       

字符大对象Clob

1. 创建Blob对象
   　　Clob clob = rs.getClob(1);
   　　变量clob现在可以被用于在CLOB值上执行操作，而假设这CLOB值保存在结果集rs的第一列中。

    

2. 物化Clob数据
   　　和物化Blob的方式一样。不过Clob接口提供了三种方法达到将CLOB作为一个Java对象的形式保存在客户的内存中。

   使用getAsiiStream把CLOB值物化为一个包含Ascii字节的字符流。
       ① 使用getAsiiStream把CLOB值物化为一个包含Ascii字节的字符流。
       Clob notes = rs.getClob(“NOTES”);
       java.io.InputStream in = notes.getAsciiStream();
       byte b = in.read();
       ② 使用getCharacterStream把CLOB值物化为一个Unicode字符流。
       Clob notes = rs.getClob(“NOTES”);
       java.io.Reader reader = notes.getCharacterStream();
       int c = reader.read();
       //
       ③	使用getSubString将CLOB值的全部或者部分化为一个String对象。
       Clob notes = rs.getClob(4);
       String substring= notes.getSubString(10,5);
       或者
       long len =notes.length();
       String substring = notes.getSubString(1,(int)len);

3. 存储、更新Clob对象
   　　和存储、更新Blob对象类似。

元数据接口使用详解
　　三个元数据接口DatabaseMetaData、ResultSetMetaData和ParameterMetaData接口是三个常用的元数据接口。DatabaseMetaData提供与数据库或者DBMS相关的信息；ResultSetMetaData对象提供与特定ResultSet实例中与列相关的信息；ParameterMetaData对象提供与PreparedStatement对象的参数有关的信息。本文讨论的内容并不仅限于JDBC的某个版本，而是基于1.0—3.0的规范进行学习。

• ResultSetMetaData对象
  　　当在JDBC应用程序中发送select语句时，该操作会返回一个ResultSet对象，这个ResultSet对象包含满足条件的数据。通过创建ResultMetaData对象和调用该对象的方法，可以获取与这个ResultSet对象中的列有关的信息。下面的代码段将创建ResultSet对象rs，然后使用rs来创建ResultSetMetaData对象，所创建的ResultSetMetaData对象包含与rs中的列有关的信息。

       Statement stmt= con . createStatement();
      ResultSet rs = stmt.executeQuery(“select * from sales”);
      ResultSetMetaData rsmd = rs.getMetaData();
      

  　　现在可以使用rsmd调用ResultSetMetaData的方法来访问与rs中的列有关的信息。除了方法getColumnCount给出结果集中总的列数外，所有的ResultSetMetaData方法都返回与单个列有关的信息，并都接受一个表示对应列号的参数。
  1. getColumnCount方法
     　　 这也许是ResultSetMetaData中使用最多的方法，该方法返回结果集中列数目　：

     ResultSet rs = stmt.executeQuery(“select * from sales”);
             ResultSetMetaData rsmd = rs.getMetaData();
             int numberOfColumns = rsmd.getColumnCount();
             while(rs.next()){
             for(int i=1;i<=numberOfColumn;i++){
             String s = rs.getString(i);
             System.out.println(“Column ” +i +”:   ” +s +”  ”);
             }
             }
             

     　　需要注意的是，用于检索所有列值的ResultSet方法是getString。当不知道每一列的类型，这是比较容易的方法；如果希望能检索所有的数据类型（包括SQL 99数据型），则可以使用方法getObject，这是保证能够检索所有列值得唯一方法。
  2. 获取列类型信息
     　　有两个ResultSetMetaData方法可以获取与结果集列的类型有关的信息。这

      

     两个方法是getColumnType和getColumnTypeName。getColumnType方法用于确定存储在指定列中的值的JDBC类型。该方法以一个int值来返回JDBC类型。如下面的代码获得rs第二列的JDBC类型：

         ResultSetMetaData rsmd = rs.getMetaData();
             int jdbcType = rsmd.getColumnType(2);
             

  3. 获取其他信息
     　　另外有几个方法用来提供与存储数值类型的列有关的信息。

     isAutoIncrement
             isCurrency
             isSigned
             getPrecision
             getScale
             isNullable
             getColumnDisplaySize

  1. 使用DatabaseMetaData对象
     　　接口DatabaseMetaData提供了大量的方法取得与数据库相关的信息。一旦获得了打开的连接，就可以创建包含与数据库系统有关的信息的DatabaseMetaData对象。
  2. DatabaseMetaData方法的类别
     　　按照返回值的类型对DatabaseMetaData的方法进行分类，可以分为4种。
     　　有三种类型返回单一的值，另外一种返回一个结果集，这个结果集包含1～18列的数据。 ① 返回String的方法
     　　最小的类别是指返回String对象的DatabaseMetaData方法。这些方法中的一些方法可以获取与DBMS有关的总体信息，包括数据库的URL、username、产品名称、驱动程序信息等等。
     ② 返回int的方法
     ③ 返回boolean的方法
     ④返回ResultSet对象的方法
     　　这些方法可以返回ResultSet对象，所返回的ResultSet对象可以包含1到最多18列。
  3. 获取与主外键有关的信息
     　　返回与主外键有关信息的方法主要有getPrimaryKeys、getImportedKeys、getExportedKeys以及getCrossReference等。
     　　下面的代码段显示了如果在定义表时指定了主键，则可以调用方法getPrimaryKeys开获取对于表中主键列的描述。

      import java.sql.*;
             public class static PrimaryKeysExample{
             public static void main(String args[]){
             String url =”jdbc:mySubprotocol:myDataSource”;
             Connection con;
             String createString =”create table supplierspk”+
             “(sup_id integer not null,”+
             “sup_name varchar(40),”+
             “street varchar(40),”+
             “city varchar(20)”+
             “state char(10),”+
             “zip char(10),”+
             “primary key(sup_id))”;
             Statement stmt;
             try{
             Class.forName(“myDriver.className”);
             }catch(java.lang.ClassNotFoundException e){
             System.err.println(“ClassNotFoundException: ”);
             System.err.println(“e.getMessage()”);
             }
             try{
             con =DriverManager.getConnection(url,”username”,”pwd”);
             stmt=con.createStatement;
             stmt.executeUpdate(createString);
             DatabaseMetaData dbmd=con.getMetaData();
             ResultSet rs= dbmd.getPrimaryKey(null,null,”suplierspk”);
             While(rs.next()){
             String name =rs.getString(“table_name”);
             String columnName=rs.getString(“column_name”);
             String keySeq=rs.getString(“key_seq”);
             String pkName=rs.getString(“pk_name”);
             System.out.println(“table name :”+name);
             System.out.println(“column name: ”+columnName);
             System.out.println(“sequence in key:”+keySeq);
             System.out.println(“primary key name:”+pkName);
             }
             rs.close();
             stmt.close();
             con.close();
             }catch(SQLException ex){
             System.err.println(“SQLException: ”+ex.getMessage());
             }
             }
             }
             

     　　如果主键多余一列的话，那么方法getPrimaryKeys等将详细描述每一列。列key_seq中的值表示描述的是哪一列。
• 使用ParameterMetaData对象
  

  　　可以使用ParameterMetaData对象来获取与PreparedStatement对象或者CallableStatement对象有关的信息。这些参数由”?”占位符表示，”?”占位符是提供给Connection方法prepareStatement和prepareCall的SQL语句。下面的代码行使用两个参数占位符来创建一个PreparedStatement对象。
  　　PreparedStatement pstmt=con.prepareStatement(“select id from employees where dept=? and salary>?”);
  　　这些参数根据其序号来编号，因此第一个参数编号1，第二个参数编号2，依此类推。在上面的代码行中，参数1是列dept中的一个值，参数2是salary中的一个值。下面的代码段用于找出PreparedStatement pstmt有多少个参数。首先创建pstmt并用它来创建ParameterMetaData对象pmd，这个对象包含与pstmt中的参数有关的信息。接着调用pmd上的方法getColumnCount来找出pstmt有多少参数。

      PreparedStatement pstmt=con.prepareStatement(
      “update employees set salary =? Where level=?”);
      ParameterMetaData pmd = pstmt.getParameterMetaData();
      int count=pmd.getParameterCount();
      

  　　变量count的值应该等于2。方法getParameterCount不接受参数，因为它返回与PreparedStatement对象的所有参数有关的信息。ParameterMetaData接口中的所有其他方法都接受序号来表示作为要查询的信息的参数。
  
• JDBC 3.0API中新增的方法示例
  　　JDBC 3.0 API引入了这样一种应用功能，即决定在已经调用commit方法来终止事务之后，ResultSet对象是否仍旧打开。这个功能即为结果集可保持性。ResultSet中加入了两个域HOLD_CURSORS_OVER_COMMIT和 CLOSE_CURSORS_AT_COMMIT，这些域可以用于指定ResultSet对象的可保持性，这些常量可以提供给创建Statement、PreparedStatement和CallableStatement对象的Connection方法，还可以作为提供给DataBaseMetaData方法supportResultSetHoldability的可能的参数值。

   

  
  　　在下面的代码段中，首先判断驱动程序是否支持ResultSet可保持性，如果支持，则接着创建会生成带有可保持性游标的ResultSet对象的Statement对象，另外此代码还指定了stmt在执行查询时产生的ResultSet对象的类型和并发模式。

   

  if (Boolean b =dbms.supportsResultSetHoldability(
      ResultSet. HOLD_CURSORS_OVER_COMMIT){
      Statement.stmt=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE,
      ResultSet.HOLD_CURSORS_OVER_COMMIT);
      }
      

  　　参考《JDBC API Reference》 Maydene Fisher etc. 著

RowSet
　　RowSet对象是表格式数据的容器，封装了一组从数据源获取得数据行。在RowSet接口的基本实现中是从JDBC数据源中获取数据行。由于行集是可以定制的，所以行集中的数据可以来自电子数据表、flat文件（平面文件？）或者其他任何表格式样的数据源。RowSet对象是ResultSet接口的扩展，这就意味着RowSet对象是可滚动的、可更新的，并且能够执行ResultSet对象可以执行的任何操作。

　　RowSet对象不同于ResultSet对象，它是JavaBean组件，因此，该对象有JavaBean属性，并遵循其事件模型。另外RowSet对象的属性也允许该对象建立自己的数据库连接，执行自己的查询。此外，RowSet可以是disconnected的，也就是说使用行集的过程中，不必一直保持到数据源的打开连接。另外，行集可以串行化，所以可以通过网络把它发送到远程对象中去。

　　通常情况下，JDBC API可以分为两类：RowSet部分和驱动程序部分。RowSet以及支持它的接口使用其他JDBC API实现。从逻辑上来说，可以把实现RowSet接口的类看作是执行在JDBC驱动程序的上一层的软件。

　　现在的J2SE 5.0中，可以把JDBC API分为三种类别，除了上面的两类，还有RowSet接口的5种标准实现。这些实现提供了一组接口，以扩展基本的RowSet接口，通过在这些接口上建立application，可以确保在事件处理、游标控制以及其他操作方面的实现遵循JDBC API。

　　RowSet接口提供了一组基本方法，这些方法对于所有行集都是通用的。因为所有的RowSet对象都是JavaBean组件，因此，RowSet接口具有添加和删除event listener的方法，也有get/set RowSet对象所有属性的方法。RowSet对象的大多数属性都支持建立连接或者执行命令。为了执行查询、更新等SQL语句，并生成能够从中获取数据的结果集，行集会使用到数据源的连接。

　　若一个组件希望得到在RowSet对象上发生的事件的通知，它就应该实现RowSetListener接口，并向RowSet对象进行注册。这就是listener，一个GUI组件。这样每当行集产生事件时，listener每次都会得到事件的通知，这样就能够保持它的游标位置和数据与行集的内容一致。

　　RowSetInternal、RowSetReader、和RowSetWriter接口支持行集的reader/weiter工具。reader是一个实现RowSetReader接口的类的实例，用来读取数据并数据插入到行集中。writer是一个实现RowSetWriter接口的类的实例，用来将修改后的数据写回到数据源。reader和writer就像是listener一样，都向行集进行动态注册。

　　调用reader或者writer的RowSet对象必须是实现RowSetInternal接口的类的实例。这个接口为reader或者writer提供了附加的方法，用来操作行集的内部状态。例如行集可以跟踪它的初始值，RowSetInternal方法允许writer检测数据源中的相应数据是否已经被其他用户修改。另外，能够使用RowSetInternal方法来获取为行集的命令字符串设置的输入参数，也能够获取传递给行集的连接。最后，RowSetInternal方法允许reader设置新的RowSetMetaData对象，这个对象用来为行集描述reder将要插入到该行集中的数据行。

　　行集可以是connected的，也可以是disconnected的，一个连接的RowSet对象，在使用的整个过程中保持到数据源的连接，而一个未连接的行集，只有从数据源读取数据或者将数据写回数据源时才会连接到它的数据源。若行集是未连接的，它就不需要JDBC驱动或者JDBC API的完整实现。这使得它非常小巧，因此也成为发送一组数据到一个thin client的理想的容器。这个客户端可以选择更新数据，并将行集发送回应用服务器。在服务器端，未连接的RowSet对象使用它的reader来建立到数据源的连接，并把数据写回数据源。这一操作的具体实现依赖于reader的实现方式。通常reader将建立连接与读/写数据的操作委托给JDBC驱动。

行集的事件模型
　　行集事件模型使得Java对象或者组件能够收到RowSet对象产生的事件的通知。通知机制的建立包括被通知的组件，也包括RowSet对象自身。首先，每一个希望得到事件通知的组件都必须实现RowSetListener接口。然后，RowSet对象必须注册每一个组件，这通过在RowSet对象的事件通知组件列表中添加这些组件来完成。在这种情况下，这样的组件是一个listener，它是一个实现RowSetListener方法的类的实例，并已经向RowSet对象进行过注册。

　　在RowSet对象中可能发生三种事件：游标移动、数据行发生变化（ins、del、upd）或者该对象的整个内容发生变化。RowSetListener接口的cursorMoved、rowChanged和rowSetChanged方法分别对应与这些事件。当事件发生时，行集将创建一个RowSetEvent对象，使用这个对象将该行集标识为事件源。在每一个listener上调用适当的RowSetListender方法，并向此方法传递一个RowSetEvent对象作为输入参数，就将事件通知给行集所有的listener。

RowSet属性
　　RowSet接口提供了一组JavaBeans属性，可以配置RowSet实例以连接到数据源并获取数据行集合。有些属性可能并不需要，这取决于特定实现。如用URL或者数据源名来建立连接，但只要设置了其中一个属性，另一个属性就是可选的。如果设置了两个属性，就会使用最近设置的那个属性。若行集的数据是从不支持名命令的非SQL数据源中如电子表格中获取的，那么就不需要设置命令属性。

几个接口的讲解

1. WebRowSet
   　　WebRowSet接口扩展了CacheRowSet接口。相比CacheRowSet接口，增加了读写XML格式行集的能力。WebRowSetImpl对象使用WebRowSetXmlReader对象来读取XML格式的行集，使用WebRowSetXmlWriter对象向XML格式的行集中写入数据。XML版本包含WebRowSetSetImpl对象的元数据，同时也包含它自己的数据。 　　WebRowSetImpl对象和CachedRowSetImpl相似点是二者都将瘦客户端连接到应用服务器。所以它们都适合为瘦客户提供数据；不同的地方是二者使用的协议。前者使用http/xml协议与中间层进行通信，而后者使用RMI/IIOP。　　
    
2. JoinRowSet
   　　JoinRowSet对象使得程序员能够从两个不同的RowSet对象合并数据。当相关联（p/f keys相关或者其他列唯一对应）的数据存储在不同的数据源中时，这种合并数据的功能很有用。任何RowSet实现都可以参与合并，但通常情况下，连接的双方是两个CachedRowSetImpl对象。将相关数据合并到一个JoinRowSetImpl对象中，应用程序就能够处理任何其他类型的RowSet对象一样来处理这些数据。
   　　 假设有两个表：employees表和bonus_plan表，两表的第一个数据列都是ID，这个数据列是主键，现要将两表的信息进行匹配合并：

      JoinRowSetImpl jrs=new JoinRowSetImpl();
       ResultSet rs1 = stmt.executeQuery(“select * from employees”);
       CachedRowSetImpl empl=new CachedRowSetImpl();
       empl.populate(rs1);
       empl.setMatchColumn(1);
       jrs.addRowSet(empl);
       ResultSet rs2=stmt.executeQuery(“select * from bonum_plan”);
       CachedRowSetImpl bonums= new CachedRowSetImpl();
       bonus.populate(rs2);
       bonus.setMatchColumn(1);
       jrs.addRowSet(bonus);//已合并
       

   XAConnection 介绍
   　　XAConnection对象是可以用于分布式事务的PooledConnection对象。它表示数据库的物理连接，多层结构中的服务器可以用它来创建返回给应用程序的Connection对象。因为是通过扩展PooledConnection接口得到的，所以继承了其所有的方法，另外添加了自己的方法 getXAResource。
   　　分布式事务中的命令可以发送给多个DBMS服务器分布式事务是通过中间层应用服务器和外部的事务管理器以及JDBC服务器一同进行管理的，中间层的基础设施的这三个部分提供了plumbing。
   　　分布式事务基础设施的首要元素是事务管理器，它可以是JTA的具体实现。事务管理器控制着事务边界以及两阶段提交过程。它启动和关闭与分布式事务 XAConnection对象相关的组件，并跟踪那些参与了分布式事务的DBMS服务器。事务管理器在每一个dbms中进行运行决定是否提交事务，仅当所有的dbms都同意提交时，事务管理器才提交事务，否则进行rollback。
   　　分布式事务的另一个元素是支持jdbc api的jdbc驱动程序，而且这个驱动程序必须包含实现XADataSource和XAConnection接口的类。XADataResource接口和DataSource接口类似，但是它创建的对象是XAConnection对象而不是Connection对象。继承于 PooledConnection的XAConnection对象的特殊在于可以用它来获取XASource对象。事务管理器使用这个XARource对象开始和结束与分布式事务中的这个XAConnection相关的组件。
   　　分布式事务基础设施中的第三个部分通常是一个连接池模块。XAConnection接口从PooledConnection接口继承而来，这表示分布式事务中的数据库连接可以来自连接池模块所管理的连接池。

J2SE 1.4在语言上提供了一个新特性，就是assertion(断言)功能，它是该版本在Java语言方面最大的革新。在软件开发中，assertion是一种经典的调试、测试方式，本文将深入解析assertion功能的使用以及其设计理念，并给出相关的例子 。

assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制，如C，C++和Eiffel等，但是支持的形式不尽相同，有的是通过语言本身、有的是通过库函数等。另外，从理论上来说，通过assertion方式可以证明程序的正确性，但是这是一项相当复杂的工作，目前还没有太多的实践意义。

在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。下面简单介绍一下Java中assertion的实现。

1．1) 语法表示

在语法上，为了支持assertion，Java增加了一个关键字assert。它包括两种表达式，分别如下：

1. assert expression1;
2. assert expression1: expression2;

在两种表达式中，expression1表示一个boolean表达式，expression2表示一个基本类型或者是一个对象(Object) ，基本类型包括boolean,char,double,float,int和long。由于所有类都为Object的子类，因此这个参数可以用于所有对象。

1．2) 语义含义

在运行时，如果关闭了assertion功能，这些语句将不起任何作用。如果打开了assertion功能，那么expression1的值将被计算，如果它的值为false，该语句强抛出一个AssertionError对象。如果assertion语句包括expression2参数，程序将计算出expression2的结果，然后将这个结果作为AssertionError的构造函数的参数，来创建AssertionError对象，并抛出该对象；如果expression1值为true，expression2将不被计算。

一种特殊情况是，如果在计算表达式时，表达式本身抛出Exception，那么assert将停止运行，而抛出这个Exception。

1．3) 一些assertion例子

下面是一些Assert的例子。

1. assert　　0 < value;
2. assert　　0 < value:"value="+value;
3. assert　　ref != null:"ref doesn't equal null";
4. assert　　isBalanced();

1．4) 编译

由于assert是一个新关键字，使用老版本的JDK是无法编译带有assert的源程序。因此，我们必须使用JDK1.4(或者更新)的Java编译器，在使用Javac命令时，我们必须加上-source 1.4作为参数。-source 1.4表示使用JDK 1.4版本的方式来编译源代码，否则编译就不能通过，因为缺省的Javac编译器使用JDK1.3的语法规则。

一个简单的例子如下：

javac -source 1.4 test.java

1．5) 运行

由于带有assert语句的程序运行时，使用了新的ClassLoader和Class类，因此，这种程序必须在JDK1.4(或者更高版本)的JRE下运行，而不能在老版本的JRE下运行。

由于我们可以选择开启assertion功能，或者不开启，另外我们还可以开启一部分类或包的assertion功能，所以运行选项变得有些复杂。通过这些选项，我们可以过滤所有我们不关心的类，只选择我们关心的类或包来观察。下面介绍两类参数：

1. 参数 -esa和 -dsa：
   它们含义为开启(关闭)系统类的assertion功能。由于新版本的Java的系统类中，也使了assertion语句，因此如果用户需要观察它们的运行情况，就需要打开系统类的assertion功能 ，我们可使用-esa参数打开，使用 -dsa参数关闭。 -esa和-dsa的全名为-enablesystemassertions和-disenablesystemassertions，全名和缩写名有同样的功能。
2. 参数 -ea和 -ea：
   它们含义为开启(关闭)用户类的assertion功能：通过这个参数，用户可以打开某些类或包的assertion功能，同样用户也可以关闭某些类和包的assertion功能。打开assertion功能参数为-ea；如果不带任何参数，表示打开所有用户类；如果带有包名称或者类名称，表示打开这些类或包；如果包名称后面跟有三个点，代表这个包及其子包；如果只有三个点，代表无名包。关闭assertion功能参数为-da，使用方法与-ea类似。
   -ea和-da的全名为-enableassertions和-disenableassertions，全名和缩写名有同样的功能。
   下面表格表示了参数及其含义，并有例子说明如何使用。
   

   参数	例子	说明
   -ea	java -ea	打开所有用户类的assertion
   -da	java -da	关闭所有用户类的assertion
   -ea:<classname>	java -ea:MyClass1	打开MyClass1的assertion
   -da:<classname>	java -da: MyClass1	关闭MyClass1的assertion
   -ea:<packagename>	java -ea:pkg1	打开pkg1包的assertion
   -da:<packagename>	java -da:pkg1	关闭pkg1包的assertion
   -ea:...	java -ea:...	打开缺省包(无名包)的assertion
   -da:...	java -da:...	关闭缺省包(无名包)的assertion
   -ea:<packagename>...	java -ea:pkg1...	打开pkg1包和其子包的assertion
   -da:<packagename>...	java -da:pkg1...	关闭pkg1包和其子包的assertion
   -esa	java -esa	打开系统类的assertion
   -dsa	java -dsa	关闭系统类的assertion
   综合使用	java -dsa:MyClass1:pkg1	关闭MyClass1和pkg1包的assertion

   
   其中...代表，此包和其子包的含义。例如我们有两个包为pkg1和pkg1.subpkg。那么pkg1...就代表pkg1和pkg1.subpkg两个包。
   另外，Java为了让程序也能够动态开启和关闭某些类和包的assertion功能，Java修该了Class和ClassLoader的实现，增加了几个用于操作assert的API。下面简单说明一下几个API的作用。
   ClassLoader类中的几个相关的API:
   　　setDefaultAssertionStatus:用于开启/关闭assertion功能
   　　setPackageAssertionStatus:用于开启/关闭某些包的assertion功能
   　　setClassAssertionStatus: 用于开启/关闭某些类的assertion功能
   　　clearAssertionStatus：用于关闭assertion功能

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项

级别: 初级

欧阳辰 (yeekee@sina.com),
周欣 (zhouxin@sei.pku.edu.cn),

2002 年 6 月 12 日

J2SE 1.4在语言上提供了一个新特性，就是assertion(断言)功能，它是该版本在Java语言方面最大的革新。在软件开发中，assertion是一种经典的调试、测试方式，本文将深入解析assertion功能的使用以及其设计理念，并给出相关的例子 。

assertion的语法和语义

J2SE 1.4在语言上提供了一个新特性，就是assertion(断言)功能，它是该版本在Java语言方面最大的革新。在软件开发中，assertion是一种经典的调试、测试方式，本文将深入解析assertion功能的使用以及其设计理念，并给出相关的例子 。

assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制，如C，C++和Eiffel等，但是支持的形式不尽相同，有的是通过语言本身、有的是通过库函数等。另外，从理论上来说，通过assertion方式可以证明程序的正确性，但是这是一项相当复杂的工作，目前还没有太多的实践意义。

在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。下面简单介绍一下Java中assertion的实现。

1．1) 语法表示

在语法上，为了支持assertion，Java增加了一个关键字assert。它包括两种表达式，分别如下：

1. assert expression1;
2. assert expression1: expression2;

在两种表达式中，expression1表示一个boolean表达式，expression2表示一个基本类型或者是一个对象(Object) ，基本类型包括boolean,char,double,float,int和long。由于所有类都为Object的子类，因此这个参数可以用于所有对象。

1．2) 语义含义

在运行时，如果关闭了assertion功能，这些语句将不起任何作用。如果打开了assertion功能，那么expression1的值将被计算，如果它的值为false，该语句强抛出一个AssertionError对象。如果assertion语句包括expression2参数，程序将计算出expression2的结果，然后将这个结果作为AssertionError的构造函数的参数，来创建AssertionError对象，并抛出该对象；如果expression1值为true，expression2将不被计算。

一种特殊情况是，如果在计算表达式时，表达式本身抛出Exception，那么assert将停止运行，而抛出这个Exception。

1．3) 一些assertion例子

下面是一些Assert的例子。

1. assert　　0 < value;
2. assert　　0 < value:"value="+value;
3. assert　　ref != null:"ref doesn't equal null";
4. assert　　isBalanced();

1．4) 编译

由于assert是一个新关键字，使用老版本的JDK是无法编译带有assert的源程序。因此，我们必须使用JDK1.4(或者更新)的Java编译器，在使用Javac命令时，我们必须加上-source 1.4作为参数。-source 1.4表示使用JDK 1.4版本的方式来编译源代码，否则编译就不能通过，因为缺省的Javac编译器使用JDK1.3的语法规则。

一个简单的例子如下：

javac -source 1.4 test.java

1．5) 运行

由于带有assert语句的程序运行时，使用了新的ClassLoader和Class类，因此，这种程序必须在JDK1.4(或者更高版本)的JRE下运行，而不能在老版本的JRE下运行。

由于我们可以选择开启assertion功能，或者不开启，另外我们还可以开启一部分类或包的assertion功能，所以运行选项变得有些复杂。通过这些选项，我们可以过滤所有我们不关心的类，只选择我们关心的类或包来观察。下面介绍两类参数：

1. 参数 -esa和 -dsa：
   它们含义为开启(关闭)系统类的assertion功能。由于新版本的Java的系统类中，也使了assertion语句，因此如果用户需要观察它们的运行情况，就需要打开系统类的assertion功能 ，我们可使用-esa参数打开，使用 -dsa参数关闭。 -esa和-dsa的全名为-enablesystemassertions和-disenablesystemassertions，全名和缩写名有同样的功能。
2. 参数 -ea和 -ea：
   它们含义为开启(关闭)用户类的assertion功能：通过这个参数，用户可以打开某些类或包的assertion功能，同样用户也可以关闭某些类和包的assertion功能。打开assertion功能参数为-ea；如果不带任何参数，表示打开所有用户类；如果带有包名称或者类名称，表示打开这些类或包；如果包名称后面跟有三个点，代表这个包及其子包；如果只有三个点，代表无名包。关闭assertion功能参数为-da，使用方法与-ea类似。
   -ea和-da的全名为-enableassertions和-disenableassertions，全名和缩写名有同样的功能。
   下面表格表示了参数及其含义，并有例子说明如何使用。
   

   参数	例子	说明
   -ea	java -ea	打开所有用户类的assertion
   -da	java -da	关闭所有用户类的assertion
   -ea:<classname>	java -ea:MyClass1	打开MyClass1的assertion
   -da:<classname>	java -da: MyClass1	关闭MyClass1的assertion
   -ea:<packagename>	java -ea:pkg1	打开pkg1包的assertion
   -da:<packagename>	java -da:pkg1	关闭pkg1包的assertion
   -ea:...	java -ea:...	打开缺省包(无名包)的assertion
   -da:...	java -da:...	关闭缺省包(无名包)的assertion
   -ea:<packagename>...	java -ea:pkg1...	打开pkg1包和其子包的assertion
   -da:<packagename>...	java -da:pkg1...	关闭pkg1包和其子包的assertion
   -esa	java -esa	打开系统类的assertion
   -dsa	java -dsa	关闭系统类的assertion
   综合使用	java -dsa:MyClass1:pkg1	关闭MyClass1和pkg1包的assertion

   
   其中...代表，此包和其子包的含义。例如我们有两个包为pkg1和pkg1.subpkg。那么pkg1...就代表pkg1和pkg1.subpkg两个包。
   另外，Java为了让程序也能够动态开启和关闭某些类和包的assertion功能，Java修该了Class和ClassLoader的实现，增加了几个用于操作assert的API。下面简单说明一下几个API的作用。
   ClassLoader类中的几个相关的API:
   　　setDefaultAssertionStatus:用于开启/关闭assertion功能
   　　setPackageAssertionStatus:用于开启/关闭某些包的assertion功能
   　　setClassAssertionStatus: 用于开启/关闭某些类的assertion功能
   　　clearAssertionStatus：用于关闭assertion功能

回页首

assertion的设计问题

首先，我们认为assertion是必要的。因为，如果没有统一的assertion机制，Java程序通常使用if-then-else或者switch-case语句进行assertion检查，而且检查的数据类型也不完全相同。assertion机制让Java程序员用统一的方式处理assertion问题，而不是按自己的方式处理。另外，如果用户使用自己的方式进行检查，那么这些代码在发布以后仍然将起作用，这可能会影响程序的性能。而从语言言层次支持assertion功能，这将把assertion对性能带来的负面影响降到最小。

Java是通过增强一个关键字assert实现支持assertion，而不是使用一个库函数支持，这说明Java认为assertion对于语言本身来说是非常重要的。实际上，在Java的早期的规范中，Java是能够支持assert的，但是由于一些实现的限制，这些特性从规范中除去了。因此，assert的再次引入应该是恢复了Java对assert的支持。C语言就是通过Assert.h函数库实现断言的支持。

Java的assertion的开启也和C语言不太一样，我们都知道在C语言中，assertion的开启是在编译时候决定的。当我们使用debug方式编译程序时候，assertion被开启，而使用release方式编译时候，assertion自动被关闭。而Java的assertion却是在运行的时候进行决定的。其实，这两种方式是各有优缺点。如果采用编译时决定方式，开发人员将处理两种类型的目标码，debug版本和release版本，这加大了文档管理的难度，但是提高了代码的运行效率。Java采用运行时决定的方式，这样所有的assertion信息将置于目标代码中，同一目标代码可以选择不同方式运行，增强目标代码的灵活性，但是它将牺牲因为assertion而引起一部分性能损失。Java专家小组认为，所牺牲的性能相当小，因此java采用了运行时决定方式。

另外，我们注意到AssertionError作为Error的一个子类，而不是RuntimeException。关于这一点，专家组也进行了长期的讨论。Error代表一些异常的错误，通常是不可以恢复的，而RuntimeException强调该错误在运行时才发生的特点。AssertionError通常为非常关键的错误，这些错误往往是不容易恢复的，而且assertion机制也不鼓励程序员对这种错误进行恢复。因此，为了强调assertion的含义，Java专家小组选择了让AssertError为Error的子类。

assertion与继承

在本节，我们将考虑assertion与继承的关系，研究assert是如何定位的。如果开启一个子类的assertion，那么它的父类的assertion是否执行？

下面的例子将显示如果一个assert语句在父类，而当它的子类调用它时，该assert为false。我们看看在不同的情况下，该assertion是否被处理。

class Base
            {
            public void baseMethod()
            {
            assert      false : "Assertion failed:This is base ";// 总是assertion失败
            System.out.println("Base Method");
            }
            }
            class Derived
            extends Base
            {
            public void derivedMethod()
            {
            assert false: "Assertion failed:This is derive";// 总是assertion失败
            System.out.println( "Derived Method" );
            }
            public static void main( String[] args )
            {
            try
            {
            Derived derived = new Derived();
            derived.baseMethod(  );
            derived.derivedMethod();
            }
            catch( AssertionError ae )
            {
            System.out.println(ae);
            }
            }
            }

assertion的使用

assertion的使用是一个复杂的问题，因为这将涉及到程序的风格，assertion运用的目标，程序的性质等问题。通常来说，assertion用于检查一些关键的值，并且这些值对整个程序，或者局部功能的完成有很大的影响，并且这种错误不容易恢复的。assertion表达式应该短小、易懂，如果需要评估复杂的表达式，应该使用函数计算。以下是一些使用assertion的情况的例子，这些方式可以让java程序的可靠性更高。

1. 检查控制流； 在if-then-else和swith-case语句中，我们可以在不应该发生的控制支流上加上assert false语句。如果这种情况发生了，assert能够检查出来。例如：x取值只能使1,2,3，我们的程序可以如下表示

   switch (x) { case 1: …; case 2: …; case 3: … default: assert false:"x value is invalid: "+x; }

   
   
   
2. 在私有函数计算前，检查输入参数是否有效；对于一私有些函数，要求输入满足一些特定的条件，那么我们可以在函数开始处使用assert进行参数检查。对于公共函数，我们通常不使用assertion检查，因为一般来说，公共函数必须对无效的参数进行检查和处理。而私有函数往往是直接使用的。
   例如：某函数可能要求输入的参数必须不为null。那么我们可以在函数的一开始加上 assert parameter1!=null : "paramerter is null in test method";
   
3. 在函数计算后，检查函数结果是否有效；对于一些计算函数，函数运行完成后，某些值需要保证一定的性质，因此我们可以通过assert检查该值。例如，我们有一个计算绝对值的函数，那么我们就可以在函数的结果处，加上一个语句：

   assert value>=0:"Value should be bigger than 0:"+value;

   
   
   通过这种方式，我们可以对函数计算完的结果进行检查。
4. 检查程序不变量；有些程序中，存在一些不变量，在程序的运行生命周期，这些不变量的值都是不变的。这些不变量可能是一个简单表达式，也可能是一个复杂的表达式。对于一些关键的不变量，我们可以通过assert进行检查。例如，在一个财会系统中，公司的支出和收入必须保持一定的平衡关系，因此我们可以编写一个表达式检查这种平衡关系，如下表示。

   private boolean isBalance() { …… }

   
   
   在这个系统中，在一些可能影响这种平衡关系的方法的前后，我们都可以加上assert验证： assert isBalance():"balance is destoried";

结论

assertion为开发人员提供了一种灵活地调试和测试机制，它的使用也非常简单、方便。但是，如何规范、系统地使用assertion(特别是在Java语言中)仍然是一个亟待研究的问题。

运行命令	含义	结果
Java Derived	不启用assertion	Base MethodDerived Method
Java -ea Derived	开启所有assertion	Java.lang.AssertionError:Assertion Failed:This is base
Java -da Derived	关闭所有assertion	Base MethodDerived Method
Java -ea:Base Derived	仅打开Base的assertion	Java.lang.AssertionError:Assertion Failed:This is base
Java -ea:Derived Derived	仅打开Derived的assertion	Base MethodJava.lang.AssertionError:Assertion Failed:This is derived

从这个例子我们可以看出，父类的assert语句将只有在父类的assert开启才起作用，如果仅仅开启子类的assert，父类的assert仍然不运行。例如，我们执行java -ea:Derived Derived的时候，Base类的assert语句并不执行。因此，我们可以认为，assert语句不具有继承功能。

消息传递是一种在软件组件或应用之间进行分布式通信的松散耦合方法，与各种紧密耦合通信技术（如CORBA、Java RMI、COM/DCOM）相比，不同之处在于：①消息系统是一种对等实施，通信双方即消息的发送者和接受者都是该系统中的客户端，彼此不呈C/S关系；②通信双方的工作是异步的；③基于消息格式一致，通信双方只需一个中介来存储并管理消息就可以实现通信，而紧密耦合技术则需要知道远程方法在本地的接口。因自身特点，消息传递技术在企业中和企业间有较广泛的应用需求。

JMS（Java Message Service）是J2EE企业平台的Java消息服务，目前主流J2EE产品的JMS都实现了存储功能，JMS客户端通过JMS API创建，彼此间通过目的地（Destination）对象进行通信；可是JMS消息系统多见于桌面应用，而Web应用鲜见，本文以笔者开发的CWNF校务系统为案例，讨论面向Web的JMS应用系统的实现原理及采用的关键技术。

1  面向Web的JMS应用系统实现原理

1.1  JMS应用系统消息传递原理

JMS应用系统有4个部分：①JMS提供者（JMS Provider），是一个逻辑数据存储体，并提供管理工具和控制特性；②JMS客户端，是用Java语言编写的发送或接收消息的组件或应用；③消息，是JMS客户端间被传递的承载信息的对象；④被管理对象，是系统管理员为客户端预置的JMS对象，包括目的地对象和连接工厂对象，其中目的地对象是客户端间的消息中介。这4个部分通过JNDI相关联：管理员通过管理工具把目的地对象和连接工厂对象绑定到一个JNDI API命名空间中，JMS客户端就可以在命名空间中查找这些对象，并通过JMS提供者建立与这些对象的逻辑连接，从而彼此之间实现通信（图1）。JMS支持2种消息传递域：点到点、发布/订阅，与之相对应的消息目的地对象也有2种：队列、主题。

1.2  Web应用的消息提交机制

通常，无论是消息发送方还是接收方，桌面应用都不容许消息丢失或重复，JMS消息提交机制是基于这个要求的，它们从不同方面保证该要求的实现：①在接收方控制消息的确认。通过确认保证一个接收者对一个消息只消费一次，在非事务性的会话中，消息确认方式取决于create×××Session方法第二个参数的值；在事务性会话中，无论由Bean管理事务还是由Bean容器管理事务，消息确认都由Bean容器自动完成。②在发送方指定消息的提交模式和生存期。提交模式有两种：PERSISTENT(稳定存储)和NON_PERSISTENT(非稳定存储)，稳定存储保证在故障情况下消息不会丢失；生存期决定一个消息在存储中介中的存在寿命，JMS提供者会自动摧毁到期的消息。③创建持久定阅的接收方。在发布/订阅系统中，持久订阅者可以接收到在订阅者关闭阶段消息发送方发布的消息。

但是Web应用系统在消息接收方有Web特有的用户环境要求：①若干个用户共用一个JMS客户端组件，因此消息就应向一个消息接收者提交而不需确认，具有容器自动确认功能的Bean是无法实现这一要求的；在一个组件内如果把会话设置成事务性的，而这个组件的容器又不具有事务管理能力，则这个组件就能做到"接收而不确认"，在Web应用系统中只有Servlet组件符合这一要求。②JMS客户端的消息接收者经常关闭，为了接收在关闭期间发送来的消息，消息接收者必定是基于主题的持久定阅者，所以面向Web的JMS应用系统必定采用发布/订阅消息传递域。

2  CWNF校务系统模型

CWNF是一个面向Web的JMS校务系统，用于校园发布通知及征求意见等校务工作，通知分为2类：普通通知和征求意见性通知。

该系统用户分成3类，用户不同，处理模型也不同，基本情况如下：①发布用户，拥有通知发布权，向主题发布通知；②署名用户，查阅通知，也可发表对征求意见性通知的反馈意见；③匿名用户，只查阅通知。

2.1  数据与数据流模型

系统中的数据因此有2类：通知、反馈。接收方接收的数据将形成一个XML文档对象，以便发往Web浏览器显示；基于这样的要求，考察下面2个问题：①系统中各方之间的数据关系，②各方数据的形式。

主要的数据关系有3个：①通知发送方与通知接收方的数据关系，②反馈发送方与反馈接收方的数据关系，③通知接收方与反馈接收方的数据关系。（如图2）在发送方，数据（通知或反馈）是一件一件的发送，在接收方，数据（通知或反馈）则是批接收，是对应发送方数据的集合，因此在发送方没有必要把数据直接加工成XML文档对象形式，只要生成能构成XML文档对象的元素对象即可；而通知接收方与反馈接收方的数据关系则是：每一条征求意见性通知都有相关的一个反馈集合。

系统的数据流模型如下：
①通知发送方：表单数据→XML元素（通知）→主题(存储)
②通知接收方：主题(存储)→XML元素（通知）→XML文档（通知）→XSL显示（含表单）
③通知接收方到反馈接收方: XSL显示（含表单）→主题（存储）
④反馈接收方：主题(存储)→XML元素（反馈）→XML文档（反馈）→XSL显示（含表单）
⑤反馈发送方：表单数据→XML元素（反馈）→主题(存储)

2.2  组件模型

系统组件模型如图3：主题CWNFTopic是消息传递中介，NoticerServlet组件向发布用户发送表单，并从表单接收数据，然后生成XML元素对象，该元素对象和其它一些数据被作为参数调用PublisherBean组件方法，向主题发送以该元素对象为消息体的消息；ReaderServlet组件处理署名用户和匿名用户查阅通知的业务，它从表单获得用户将查阅什么方面通知的有关信息后，便使用receive方法限时阻塞地从主题接收消息并对消息进行筛选，把筛选出的若干消息的消息体取出，然后加工成XML文档对象（根元素是通知集），最后输出。FeedbackerPubServlet用于反馈发送方的业务处理，功能与NoticerServlet相似；FeedbackerSubServlet用于反馈接收方的业务处理，功能与ReaderServlet相似；PublisherBean组件被NoticerServlet组件和FeedbackerPubServlet组件调用，用于发送消息，容器管理发送事务，具有很高的可靠性。

3  关键的实现技术

3.1  JDOM建立、输出XML文档

JDOM是一个开放源代码的纯Java树式API，用于分析、建立、处理和序列化XML文档。在数据流模型中，XML元素和XML文档都由JDOM API建立，在发送方，通过用户提交的表单取得名/值对若干，这些数据经过JDOM方法处理生成XML元素对象，元素对象被作为消息的消息体发往主题存储；在接收方，持久订阅者接收到若干XML元素对象后，继续通过JDOM方法建立XML文档对象。且XML文档向Web浏览器输出也依赖于JDOM的XMLOutputte对象方法：

XMLOutputter serializer=new XMLOutputter();
            ...
            PrintWriter out=response.getWriter();	// out 是ServletResponse的输出流对象
            serializer.output(xmldoc,out);			//通过out把XML文档输出到页面
            

3.2  XSL定义XML文档显示样式

XSL是可扩展的样式单语言，通知集的XML文档和反馈集的XML文档都有相关的XSL文档决定其页面显示，如通知集XML文档的XSL样式定义如下：

<?xml version="1.0" encoding="GBK"?>
            <xsl:stylesheet>
            <xsl:template match="/">
            <HTML>
            <BODY>
            ...
            <DIV><xsl:apply-templates select="通知集"/></DIV>
            </BODY>
            </HTML>
            </xsl:template>
            <xsl:template match="通知集">
            <xsl:for-each select="通知">
            ...
            </xsl:for-each>
            </xsl:template>
            </xsl:stylesheet>
            

3.3  Servlet间数据的传递

3.3.1  注册/登录

用户的一些处理工作需要注册/登录后才能进行，因此注册/登录的获准信息必须能在有关Servlet组件之间传递。ServletContext 对象可设置和读取属性，使不同Servlet之间相互通信，在系统中被用于有关组件对用户身份的验证。

3.3.2  通知与反馈的数据关联

每一条征求意见性通知都有一个相关联的反馈集合，关联可通过设置消息属性实现。JMS消息（包括通知类消息）都有系统级JMSMessageID属性，其值是唯一的，可用于表征每一条征求意见性通知，因此对任何反馈消息也可以设置一个应用级属性（CWNF中是FeedbackSN），让它取与之相关联的征求意见性通知的JMSMessageID属性值。这样就建立了两者间的数据关联。

因此数据流模型"③通知接收方到反馈接收方: XSL显示（含表单）→主题（存储）"的实现流程如下：用户在页面上选择一条征求意见性通知后，该通知的JMSMessageID属性值将被传递给FeedbackerSubServlet组件，该组件将使用这个属性值去匹配从主题取出的反馈消息的FeedbackSN属性，从而筛选出相关联的反馈消息。

那么一条征求意见性通知的JMSMessageID属性值又如何传递给FeedbackerSubServlet组件呢？通过ServletContext对象只能传递可预知信息，CWNF的做法是：由XSL为每一条征求意见性通知设置一个独立的表单，并把该通知的JMSMessageID属性值写在表单的TEXTAREA元素框内，这样用户在表单上选择一条征求意见性通知后，该通知的JMSMessageID属性值就随表单一起提交给FeedbackerSubServlet组件。XSL有关代码如下：

<xsl:if test="string(意见反馈)='on'">
            <FORM method="post" action="http://localhost:6888/Feedbacker/servlet
            /FeedbackerSubServlet">
            <BUTTON type="submit">意见反馈</BUTTON>
            <TEXTAREA name="序列号" rows="1" cols="40">
            <xsl:value-of select="序列号"/>
            </TEXTAREA>
            </FORM>
            </xsl:if>
            

4  结束语

JMS应用系统与数据库系统有相似性，从数据方面看，JMS消息体的数据类型支持文本和对象，所以JMS更灵活，与XML集成应用的空间更大；但从管理上看，JMS Provider向管理员提供的管理功能远远低于DBMS提供的管理功能，因此在面向Web的应用中，JMS宜作为中小流量、管理员参与度较低的信息系统解决方案。

CWNF校务系统经校园网实验性运行，效果良好，验证了面向Web的JMS应用是可行的。

通用字符实体

属性值的数据类型

通用属性组

通用元素组

文档结构与头部元素

结构元素

锚

列表元素

文本元素

替换元素

表单元素

表格元素

术语

选择符

属性值的数据类型

字体属性

文本属性

前景和背景属性

列表属性

表格属性

指针属性

盒模型属性

显示属性

定位与布局属性

HTML默认样式

html,body,div,  h1,h2,h3,h4,h5,h6,p,  ol,ul,dl,dt,dd,
form,fieldset,  blockquote,address,hr,pre { display: block }
input,select { display: inline-block }
li           { display: list-item }
head         { display: none }
table        { display: table }
caption      { display: table-caption }
thead        { display: table-header-group }
tbody        { display: table-row-group }
tfoot        { display: table-footer-group }
tr           { display: table-row }
col          { display: table-column }
colgroup     { display: table-column-group }
td, th       { display: table-cell }
caption     { text-align: center }
th          { font-weight: bolder; text-align: center }
body     { margin: 8px }
blockquote      { margin-left: 40px; margin-right: 40px }
h4,p,blockquote,ul,fieldset,form,ol,dl { margin: 1.12em 0 }
h1       { font-size: 2em;    margin: 0.67em 0 }
h2       { font-size: 1.5em;  margin: 0.75em 0 }
h3       { font-size: 1.17em; margin: 0.83em 0 }
h5       { font-size: 0.83em; margin: 1.5em  0 }
h6       { font-size: 0.75em; margin: 1.67em 0 }
pre  { white-space: pre }
h1,h2,h3,h4,h5,h6,strong  { font-weight: bolder }
cite,em,var,address { font-style: italic }
pre,code,kbd,samp   { font-family: monospace }
button, textarea,table      { border-spacing: 2px; }
thead,tbody,tfoot           { vertical-align: middle }
td, th          { vertical-align: inherit }
hr              { border: 1px inset }
ol, ul, dir, menu, dd        { margin-left: 40px }
ol              { list-style-type: decimal }
ol ul, ul ol, ul ul, ol ol    { margin-top: 0; margin-bottom: 0 }
:link, :visited { text-decoration: underline }

JRun3.1下，与Apache的整合配置非常方便，直接在JRun Management Console界面中，配置一下Admin Server的External Web Server即可；动态加载Servlet也可以直接通过点击{server_name}－> Web Applications > {application_name}－> Servlet Definitions进行配置。

JRun4.0下还真有点不习惯，在配置上也走了不少弯路，在此粗略写下基本操作步骤，希望对配置JRun4.0的新手们有点帮助。第一次写东西，还望各路朋友多多捧场，多多指教。MSN:chinawdn@hotmail.com

言归正传，Window与Linux系统环境下，JRun和Apache整合步骤基本相似，本文以Linux下的配置为例。

1．   准备工作：

(1)   建立文件目录：

/home/httpd/html/sdsms       存放jsp文件

/home/httpd/np/com/np/sdsms 存放java程序

(2)   安装相关软件：

2．   初步使用配置：

(1)   配置JDK的CLASSPATH：

(2)   配置Apache的httpd.conf文件并重启：

DocumentRoot "/home/httpd/html"

(3)   配置并重启JRun：

a．添加虚拟目录：

{JRun_Root}/servers/{server name}/default-ear/default-war/WEB-INF/jrun-web.xml 添加

<virtual-mapping>

 <resource-path>/sdhero</resource-path>

 <system-path>/home/httpd/html/sdsms</system-path>

</virtual-mapping>

b．动态加载相关Servlet：

{JRun_Root}/servers/{server_name}/default-ear/default-war/WEB-INF/web.xml 添加

<web-app>

 …

<servlet>

   <servlet-name>SDTest</servlet-name>

<servlet-class>com.np.sdsms.TextIO</servlet-class>

<init-param>

 <param-name>name</param-name>

 <param-value>Jane Xu</param-value>

</init-param>

   <load-on-startup>1</load-on-startup>

  </servlet>

 …

</web-app>

c．优化JSP：

{JRun_Root}/servers/{server name}/SERVER-INF/default-web.xml 更新JSPServlet：

<servlet>

 <servlet-name>JSPServlet</servlet-name>

 <servlet-class>jrun.jsp.JSPServlet</servlet-class>

 …

 <init-param>

    <param-name>translationDisabled</param-name>

    <param-value>true</param-value>

 </init-param> 

</servlet>

d．配置一个空的web应用(web appalication，*.war)

 

cd /home/httpd/html/

mkdir jane

cd jane

mkdir WEB-INF

cp {jrun_root}/{app_server_name}/default-ear/default-war/WEB-INF/web.xml WEB-INF/

从控制台/后台启动admin server 和准备该web应用的目标app server(设port=8100)

点击该server，再点击web application下的add按钮

在Source File Path 填入/home/httpd/html/jane，点击Deploy按钮

在Overview页面，可以修改Context Path名称，继续点击Apply按钮

好了，在jane目录下建一个test.jsp文件，试试访问 http://localhost:8100/jane/test.jspJ

 

e．相关server添加必要的classpath

启动JRun Admin Server，运行JRun Management Console界面，(http://localhost:8000)

设置：点击{server_name}－>settings－>add Classpaths for Java VM添加相关classpath

 

3．   整合配置：

(1)   JRun 整合Apache，运行命令：

{jrun_root}/lib/java -jar wsconfig.jar –ws apache -dir {apache_root/conf} -server {server_name}也可直接

{jrun_root}/lib/java -jar wsconfig.jar –ws apache -dir {apache_root/conf}，将Apachedefault与Jrun的default server整合(默认的JRun server)

 

(2)   如果需要删除与Apache的整合，运行命令：

{jrun_root}/lib/java -jar wsconfig.jar –ws apache –dir {apache_root/conf} –r

 

注：Windows下使用方法：开始菜单－>JRun程序组－>Web Server Configuration Tool

 

4．   测试：

(1)   测试相关目录：

/home/httpd/html/ 下新建文件test.jsp：

测试代码：<% out.print(“Apache DocumentRoot”); %>

/home/httpd/html/sdsms/下新建文件test.jsp：

测试代码：<% out.print(“JRun Default Server’s Virtual Root named \”sdhero\””); %>

 

(2)   现在分别重启一下Apache和JRun，在浏览器中分别输入：

http://localhost/test.jsp

http://localhost/sdhero/test.jsp

附，后台启jrun命令：./jrun -start {servername} 1>{JRun.rootdir}/logs/{servername}-out.log 2>{JRun.rootdir}/logs/{servername}-error.log &

(3)   运行命令：tail -f access_log | grep test，可以通过apache的日记文件监控了吧，到这里基本就OK啦！^_^

参考：

JRun4.0自带文档 {jrun_root}/docs/dochome.html

☜♥☞MengChuChen 2007-04-09 14:59 发表评论

]]>

Java Servlet API说明文档（2.1a版）3
软件包：javax.servlet.http
所包含的接口：HttpServletRequest；HttpServletResponse；HttpSession；HttpSessionBindingListener；HttpSessionContext。
所包含的类：Cookie；HttpServlet；HttpSessionBindingEvent；HttpUtils。

一、HttpServletRequest接口
定义
public interface HttpServletRequest extends ServletRequest;
用来处理一个对Servlet的HTTP格式的请求信息。
方法
1、getAuthType
public String getAuthType();
返回这个请求的身份验证模式。
2、getCookies
public Cookie[] getCookies();
返回一个数组，该数组包含这个请求中当前的所有cookie。如果这个请求中没有cookie，返回一个空数组。
3、getDateHeader
public long getDateHeader(String name);
返回指定的请求头域的值，这个值被转换成一个反映自1970-1-1日（GMT）以来的精确到毫秒的长整数。
如果头域不能转换，抛出一个IllegalArgumentException。如果这个请求头域不存在，这个方法返回-1。
4、getHeader
public String getHeader(String name);
返回一个请求头域的值。（译者注：与上一个方法不同的是，该方法返回一个字符串）
如果这个请求头域不存在，这个方法返回-1。
5、getHeaderNames
public Enumeration getHeaderNames();
该方法返回一个String对象的列表，该列表反映请求的所有头域名。
有的引擎可能不允许通过这种方法访问头域，在这种情况下，这个方法返回一个空的列表。
6、getIntHeader
public int getIntHeader(String name);
返回指定的请求头域的值，这个值被转换成一个整数。
如果头域不能转换，抛出一个IllegalArgumentException。如果这个请求头域不存在，这个方法返回-1。
7、getMethod
public String getMethod();
返回这个请求使用的HTTP方法（例如：GET、POST、PUT）
8、getPathInfo
public String getPathInfo();
这个方法返回在这个请求的URL的Servlet路径之后的请求URL的额外的路径信息。如果这个请求URL包括一个查询字符串，在返回值内将不包括这个查询字符串。这个路径在返回之前必须经过URL解码。如果在这个请求的URL的Servlet路径之后没有路径信息。这个方法返回空值。
9、getPathTranslated
public String getPathTranslated();
这个方法获得这个请求的URL的Servlet路径之后的额外的路径信息，并将它转换成一个真实的路径。在进行转换前，这个请求的URL必须经过URL解码。如果在这个URL的Servlet路径之后没有附加路径信息。这个方法返回空值。
10、getQueryString
public String getQueryString();
返回这个请求URL所包含的查询字符串。一个查询字串符在一个URL中由一个“？”引出。如果没有查询字符串，这个方法返回空值。
11、getRemoteUser
public String getRemoteUser
返回作了请求的用户名，这个信息用来作HTTP用户论证。
如果在请求中没有用户名信息，这个方法返回空值。
12、getRequestedSessionId
public String getRequestedSessionId();
返回这个请求相应的session id。如果由于某种原因客户端提供的session id是无效的，这个session id将与在当前session中的session id不同，与此同时，将建立一个新的session。
如果这个请求没与一个session关联，这个方法返回空值。
13、getRequestURI
public String getRequestURI();
从HTTP请求的第一行返回请求的URL中定义被请求的资源的部分。如果有一个查询字符串存在，这个查询字符串将不包括在返回值当中。例如，一个请求通过/catalog/books?id=1这样的URL路径访问，这个方法将返回/catalog/books。这个方法的返回值包括了Servlet路径和路径信息。
如果这个URL路径中的的一部分经过了URL编码，这个方法的返回值在返回之前必须经过解码。
14、getServletPath
public String getServletPath();
这个方法返回请求URL反映调用Servlet的部分。例如，一个Servlet被映射到/catalog/summer这个URL路径，而一个请求使用了/catalog/summer/casual这样的路径。所谓的反映调用Servlet的部分就是指/catalog/summer。
如果这个Servlet不是通过路径匹配来调用。这个方法将返回一个空值。
15、getSession
public HttpSession getSession();
public HttpSession getSession(boolean create);
返回与这个请求关联的当前的有效的session。如果调用这个方法时没带参数，那么在没有session与这个请求关联的情况下，将会新建一个session。如果调用这个方法时带入了一个布尔型的参数，只有当这个参数为真时，session才会被建立。
为了确保session能够被完全维持。Servlet开发者必须在响应被提交之前调用该方法。
如果带入的参数为假，而且没有session与这个请求关联。这个方法会返回空值。
16、isRequestedSessionIdValid
public boolean isRequestedSessionIdValid();
这个方法检查与此请求关联的session当前是不是有效。如果当前请求中使用的session无效，它将不能通过getSession方法返回。
17、isRequestedSessionIdFromCookie
public boolean isRequestedSessionIdFromCookie();
如果这个请求的session id是通过客户端的一个cookie提供的，该方法返回真，否则返回假。
18、isRequestedSessionIdFromURL
public boolean isRequestedSessionIdFromURL();
如果这个请求的session id是通过客户端的URL的一部分提供的，该方法返回真，否则返回假。请注意此方法与isRequestedSessionIdFromUrl在URL的拼写上不同。
以下方法将被取消

19、isRequestedSessionIdFromUrl
public boolean isRequestedSessionIdFromUrl();
该方法被isRequestedSessionIdFromURL代替。

二、HttpServletResponse接口
定义

public interface HttpServletResponse extends ServletResponse
描述一个返回到客户端的HTTP回应。这个接口允许Servlet程序员利用HTTP协议规定的头信息。
成员变量
public static final int SC_CONTINUE = 100;
public static final int SC_SWITCHING_PROTOCOLS = 101;
public static final int SC_OK = 200;
public static final int SC_CREATED = 201;
public static final int SC_ACCEPTED = 202;
public static final int SC_NON_AUTHORITATIVE_INFORMATION = 203;
public static final int SC_NO_CONTENT = 204;
public static final int SC_RESET_CONTENT = 205;
public static final int SC_PARTIAL_CONTENT = 206;
public static final int SC_MULTIPLE_CHOICES = 300;
public static final int SC_MOVED_PERMANENTLY = 301;
public static final int SC_MOVED_TEMPORARILY = 302;
public static final int SC_SEE_OTHER = 303;
public static final int SC_NOT_MODIFIED = 304;
public static final int SC_USE_PROXY = 305;
public static final int SC_BAD_REQUEST = 400;
public static final int SC_UNAUTHORIZED = 401;
public static final int SC_PAYMENT_REQUIRED = 402;
public static final int SC_FORBIDDEN = 403;
public static final int SC_NOT_FOUND = 404;
public static final int SC_METHOD_NOT_ALLOWED = 405;
public static final int SC_NOT_ACCEPTABLE = 406;
public static final int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
public static final int SC_REQUEST_TIMEOUT = 408;
public static final int SC_CONFLICT = 409;
public static final int SC_GONE = 410;
public static final int SC_LENGTH_REQUIRED = 411;
public static final int SC_PRECONDITION_FAILED = 412;
public static final int SC_REQUEST_ENTITY_TOO_LARGE = 413;
public static final int SC_REQUEST_URI_TOO_LONG = 414;
public static final int SC_UNSUPPORTED_MEDIA_TYPE = 415;
public static final int SC_INTERNAL_SERVER_ERROR = 500;
public static final int SC_NOT_IMPLEMENTED = 501;
public static final int SC_BAD_GATEWAY = 502;
public static final int SC_SERVICE_UNAVAILABLE = 503;
public static final int SC_GATEWAY_TIMEOUT = 504;
public static final int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
以上HTTP产状态码是由HTTP/1.1定义的。
方法
1、addCookie
public void addCookie(Cookie cookie);
在响应中增加一个指定的cookie。可多次调用该方法以定义多个cookie。为了设置适当的头域，该方法应该在响应被提交之前调用。
2、containsHeader
public boolean containsHeader(String name);
检查是否设置了指定的响应头。
3、encodeRedirectURL
public String encodeRedirectURL(String url);
对sendRedirect方法使用的指定URL进行编码。如果不需要编码，就直接返回这个URL。之所以提供这个附加的编码方法，是因为在redirect的情况下，决定是否对URL进行编码的规则和一般情况有所不同。所给的URL必须是一个绝对URL。相对URL不能被接收，会抛出一个IllegalArgumentException。
所有提供给sendRedirect方法的URL都应通过这个方法运行，这样才能确保会话跟踪能够在所有浏览器中正常运行。
4、encodeURL
public String encodeURL(String url);
对包含session ID的URL进行编码。如果不需要编码，就直接返回这个URL。Servlet引擎必须提供URL编码方法，因为在有些情况下，我们将不得不重写URL，例如，在响应对应的请求中包含一个有效的session，但是这个session不能被非URL的（例如cookie）的手段来维持。
所有提供给Servlet的URL都应通过这个方法运行，这样才能确保会话跟踪能够在所有浏览器中正常运行。
5、sendError
public void sendError(int statusCode) throws IOException;
public void sendError(int statusCode, String message) throws
IOException;
用给定的状态码发给客户端一个错误响应。如果提供了一个message参数，这将作为响应体的一部分被发出，否则，服务器会返回错误代码所对应的标准信息。
调用这个方法后，响应立即被提交。在调用这个方法后，Servlet不会再有更多的输出。
6、sendRedirect
public void sendRedirect(String location) throws IOException;
使用给定的路径，给客户端发出一个临时转向的响应（SC_MOVED_TEMPORARILY）。给定的路径必须是绝对URL。相对URL将不能被接收，会抛出一个IllegalArgumentException。
这个方法必须在响应被提交之前调用。调用这个方法后，响应立即被提交。在调用这个方法后，Servlet不会再有更多的输出。
7、setDateHeader
public void setDateHeader(String name, long date);
用一个给定的名称和日期值设置响应头，这里的日期值应该是反映自1970-1-1日（GMT）以来的精确到毫秒的长整数。如果响应头已经被设置，新的值将覆盖当前的值。
8、setHeader
public void setHeader(String name, String value);
用一个给定的名称和域设置响应头。如果响应头已经被设置，新的值将覆盖当前的值。
9、setIntHeader
public void setIntHeader(String name, int value);
用一个给定的名称和整形值设置响应头。如果响应头已经被设置，新的值将覆盖当前的值。
10、setStatus
public void setStatus(int statusCode);
这个方法设置了响应的状态码，如果状态码已经被设置，新的值将覆盖当前的值。
以下的几个方法将被取消
11、encodeRedirectUrl
public String encodeRedirectUrl(String url);
该方法被encodeRedirectURL取代。
12、encodeUrl
public String encodeUrl(String url);
该方法被encodeURL取代。
13、setStatus
public void setStatus(int statusCode, String message);
这个方法设置了响应的状态码，如果状态码已经被设置，新的值将覆盖当前的值。如果提供了一个message，它也将会被作为响应体的一部分被发送。

三、HttpSession接口
定义
public interface HttpSession
这个接口被Servlet引擎用来实现在HTTP客户端和HTTP会话两者的关联。这种关联可能在多外连接和请求中持续一段给定的时间。session用来在无状态的HTTP协议下越过多个请求页面来维持状态和识别用户。
一个session可以通过cookie或重写URL来维持。
方法
1、getCreationTime
public long getCreationTime();
返回建立session的时间，这个时间表示为自1970-1-1日（GMT）以来的毫秒数。
2、getId
public String getId();
返回分配给这个session的标识符。一个HTTP session的标识符是一个由服务器来建立和维持的唯一的字符串。
3、getLastAccessedTime
public long getLastAccessedTime();
返回客户端最后一次发出与这个session有关的请求的时间，如果这个session是新建立的，返回-1。这个时间表示为自1970-1-1日（GMT）以来的毫秒数。
4、getMaxInactiveInterval
public int getMaxInactiveInterval();
返加一个秒数，这个秒数表示客户端在不发出请求时，session被Servlet引擎维持的最长时间。在这个时间之后，Servlet引擎可能被Servlet引擎终止。如果这个session不会被终止，这个方法返回-1。
当session无效后再调用这个方法会抛出一个IllegalStateException。
5、getValue
public Object getValue(String name);
返回一个以给定的名字绑定到session上的对象。如果不存在这样的绑定，返回空值。
当session无效后再调用这个方法会抛出一个IllegalStateException。
6、getValueNames
public String[] getValueNames();
以一个数组返回绑定到session上的所有数据的名称。
当session无效后再调用这个方法会抛出一个IllegalStateException。
7、invalidate
public void invalidate();
这个方法会终止这个session。所有绑定在这个session上的数据都会被清除。并通过HttpSessionBindingListener接口的valueUnbound方法发出通告。
8、isNew
public boolean isNew();
返回一个布尔值以判断这个session是不是新的。如果一个session已经被服务器建立但是还没有收到相应的客户端的请求，这个session将被认为是新的。这意味着，这个客户端还没有加入会话或没有被会话公认。在他发出下一个请求时还不能返回适当的session认证信息。
当session无效后再调用这个方法会抛出一个IllegalStateException。
9、putValue
public void putValue(String name, Object value);
以给定的名字，绑定给定的对象到session中。已存在的同名的绑定会被重置。这时会调用HttpSessionBindingListener接口的valueBound方法。
当session无效后再调用这个方法会抛出一个IllegalStateException。
10、removeValue
public void removeValue(String name);
取消给定名字的对象在session上的绑定。如果未找到给定名字的绑定的对象，这个方法什么也不做。 这时会调用HttpSessionBindingListener接口的valueUnbound方法。
当session无效后再调用这个方法会抛出一个IllegalStateException。
11、setMaxInactiveInterval
public int setMaxInactiveInterval(int interval);
设置一个秒数，这个秒数表示客户端在不发出请求时，session被Servlet引擎维持的最长时间。
以下这个方法将被取消
12、getSessionContext
public HttpSessionContext getSessionContext();
返回session在其中得以保持的环境变量。这个方法和其他所有HttpSessionContext的方法一样被取消了。

四、HttpSessionBindingListener接口
定义
public interface HttpSessionBindingListener
这个对象被加入到HTTP的session中，执行这个接口会通告有没有什么对象被绑定到这个HTTP session中或被从这个HTTP session中取消绑定。
方法
1、valueBound
public void valueBound(HttpSessionBindingEvent event);
当一个对象被绑定到session中，调用此方法。HttpSession.putValue方法被调用时，Servlet引擎应该调用此方法。
2、valueUnbound
public void valueUnbound(HttpSessionBindingEvent event);
当一个对象被从session中取消绑定，调用此方法。HttpSession.removeValue方法被调用时，Servlet引擎应该调用此方法。

五、HttpSessionContext接口
定义
此接口将被取消
public interface HttpSessionContext
这个对象是与一组HTTP session关联的单一的实体。
这个接口由于安全的原因被取消，它出现在目前的版本中仅仅是为了兼容性的原因。这个接口的方法将模拟以前的版本的定义返回相应的值。
方法
1、getSession
public HttpSession getSession(String sessionId);
当初用来返回与这个session id相关的session。现在返回空值。
2、getIds
public Enumeration getIds();
当初用来返回这个环境下所有session id的列表。现在返回空的列表。

六、Cookie类
定义
public class Cookie implements Cloneable
这个类描述了一个cookie，有关cookie的定义你可以参照Netscape Communications Corporation的说明，也可以参照RFC 2109。
构造函数
public Cookie(String name, String value);
用一个name-value对定义一个cookie。这个name必须能被HTTP/1.1所接受。
以字符$开头的name被RFC 2109保留。
给定的name如果不能被HTTP/1.1所接受，该方法抛出一个IllegalArgumentException。
方法
1、getComment
public String getComment();
返回描述这个cookie目的的说明，如果未定义这个说明，返回空值。
2、getDomain
public String getDomain();
返回这个cookie可以出现的区域，如果未定义区域，返回空值。
3、getMaxAge
public int getMaxAge();
这个方法返回这个cookie指定的最长存活时期。如果未定义这个最长存活时期，该方法返回-1。
4、getName
public String getName();
该方法返回cookie名。
5、getPath
public String getPath();
返回这个cookie有效的所有URL路径的前缀，如果未定义，返回空值。
6、getSecure
public boolean getSecure();
如果这个cookie只通过安全通道传输返回真，否则返回假。
7、getValue
public String getValue();
该方法返回cookie的值。
8、getVersion
public int getVersion();
返回cookie的版本。版本1由RFC 2109解释。版本0由Netscape Communications Corporation的说明解释。新构造的cookie默认使用版本0。
9、setComment
public void setComment(String purpose);
如果一个用户将这个cookie提交给另一个用户，必须通过这个说明描述这个cookie的目的。版本0不支持这个属性。
10、setDomain
public void setDomain(String pattern);
这个方法设置cookie的有效域的属性。这个属性指定了cookie可以出现的区域。一个有效域以一个点开头（.foo.com），这意味着在指定的域名解析系统的区域中（可能是 www.foo.com 但不是a.b.foo.com）的主机可以看到这个cookie。默认情况是，cookie只能返回保存它的主机。
11、setMaxAge
public void setMaxAge(int expiry);
这个方法设定这个cookie的最长存活时期。在该存活时期之后，cookie会被终目。负数表示这个cookie不会生效，0将从客户端删除这个cookie。
12、setPath
public void setPath(String uri);
这个方法设置cookie的路径属性。客户端只能向以这个给定的路径String开头的路径返回cookie。
13、setSecure
public void setSecure(boolean flag);
指出这个cookie只能通过安全通道（例如HTTPS）发送。只有当产生这个cookie的服务器使用安全协议发送这个cookie值时才能这样设置。
14、setValue
public void setValue(String newValue);
设置这个cookie的值，对于二进制数据采用BASE64编码。
版本0不能使用空格、{}、()、=、，、“”、/、?、@、：以及；。
15、setVersion
public void setVersion(int v);
设置cookie的版本号

七、HttpServlet类
定义
public class HttpServlet extends GenericServlet implements
Serializable
这是一个抽象类，用来简化HTTP Servlet写作的过程。它是GenericServlet类的扩充，提供了一个处理HTTP协议的框架。
在这个类中的service方法支持例如GET、POST这样的标准的HTTP方法。这一支持过程是通过分配他们到适当的方法（例如doGet、doPost）来实现的。
方法
1、doDelete
protected void doDelete(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP DELETE操作。这个操作允许客户端请求从服务器上删除URL。这一操作可能有负面影响，对此用户就负起责任。
这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理DELETE请求时，你必须重载这一方法。
2、doGet
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP GET操作。这个操作允许客户端简单地从一个HTTP服务器“获得”资源。对这个方法的重载将自动地支持HEAD方法。
GET操作应该是安全而且没有负面影响的。这个操作也应该可以安全地重复。
这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。
3、doHead
protected void doHead(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP HEAD操作。默认的情况是，这个操作会按照一个无条件的GET方法来执行，该操作不向客户端返回任何数据，而仅仅是返回包含内容长度的头信息。
与GET操作一样，这个操作应该是安全而且没有负面影响的。这个操作也应该可以安全地重复。
这个方法的默认执行结果是自动处理HTTP HEAD操作，这个方法不需要被一个子类执行。
4、doOptions
protected void doOptions(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP OPTION操作。这个操作自动地决定支持哪一种HTTP方法。例如，一个Servlet写了一个HttpServlet的子类并重载了doGet方法，doOption会返回下面的头：
Allow: GET,HEAD,TRACE,OPTIONS
你一般不需要重载这个方法。
5、doPost
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP POST操作。这个操作包含请求体的数据，Servlet应该按照他行事。
这个操作可能有负面影响。例如更新存储的数据或在线购物。
这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理POST操作时，你必须在HttpServlet的子类中重载这一方法。
6、doPut
protected void doPut(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP PUT操作。这个操作类似于通过FTP发送文件。
这个操作可能有负面影响。例如更新存储的数据或在线购物。
这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理PUT操作时，你必须在HttpServlet的子类中重载这一方法。
7、doTrace
protected void doTrace(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP TRACE操作。这个操作的默认执行结果是产生一个响应，这个响应包含一个反映trace请求中发送的所有头域的信息。
当你开发Servlet时，在多数情况下你需要重载这个方法。
8、getLastModified
protected long getLastModified(HttpServletRequest request);
返回这个请求实体的最后修改时间。为了支持GET操作，你必须重载这一方法，以精确地反映最后修改的时间。这将有助于浏览器和代理服务器减少装载服务器和网络资源，从而更加有效地工作。返回的数值是自1970-1-1日（GMT）以来的毫秒数。
默认的执行结果是返回一个负数，这标志着最后修改时间未知，它也不能被一个有条件的GET操作使用。
9、service
protected void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException;
这是一个Servlet的HTTP-specific方案，它分配请求到这个类的支持这个请求的其他方法。
当你开发Servlet时，在多数情况下你不必重载这个方法。

八、HttpSessionBindingEvent类
定义
public class HttpSessionBindingEvent extends EventObject
这个事件是在监听到HttpSession发生绑定和取消绑定的情况时连通HttpSessionBindingListener的。这可能是一个session被终止或被认定无效的结果。
事件源是HttpSession.putValue或HttpSession.removeValue。
构造函数
public HttpSessionBindingEvent(HttpSession session, String name);
通过引起这个事件的Session和发生绑定或取消绑定的对象名构造一个新的HttpSessionBindingEvent。
方法
1、getName
public String getName();
返回发生绑定和取消绑定的对象的名字。
2、getSession
public HttpSession getSession();
返回发生绑定和取消绑定的session的名字。

九、HttpUtils类
定义
public class HttpUtils
收集HTTP Servlet使用的静态的有效的方法。
方法
1、getRequestURL
public static StringBuffer getRequestURL(HttpServletRequest
request);
在服务器上重建客户端用来建立请求的URL。这个方法反映了不同的协议（例如http和https）和端口，但不包含查询字符串。
这个方法返回一个StringBuffer而不是一个String，这样URL可以被Servlet开发者有效地修改。
2、parsePostData
public static Hashtable parsePostData(int len,
ServletInputstream in);
解析一个包含MIME类型application/x-www-form-urlencoded的数据的流，并创建一个具有关键值-数据对的hash table。这里的关键值是字符串，数据是该字符串所对应的值的列表。一个关键值可以在POST的数据中出现一次或多次。这个关键值每出现一次，它的相应的值就被加入到hash table中的字符串所对应的值的列表中。
从POST数据读出的数据将经过URL解码，+将被转换为空格以十六进制传送的数据（例如%xx）将被转换成字符。
当POST数据无效时，该方法抛出一个IllegalArgumentException。
3、parseQueryString
public static Hashtable parseQueryString(String s);
解析一个查询字符串，并创建一个具有关键值-数据对的hash table。这里的数据是该字符串所对应的值的列表。一个关键值可以出现一次或多次。这个关键值每出现一次，它的相应的值就被加入到hash table中的字符串所对应的值的列表中。
从查询字符串读出的数据将经过URL解码，+将被转换为空格以十六进制传送的数据（例如%xx）将被转换成字符。
当查询字符串无效时，该方法抛出一个IllegalArgumentException。

Java Servlet API说明文档（2.1a版）（四）
术语表
bytecode
字节码：由Java编译器和Java解释程序生成的机器代码。
cookie
由Web服务器建立的数据，该数据存储在用户的计算机上，提供了一个Web站点跟踪用户的参数并存储在用户自己硬盘上的方法。
HTTP
超文本传输协议。一个请求响应协议用来连接WWW服务器向客户端浏览器传输HTML页面。
输入流对象
一个对象，由ServletInputStream类定义，被Servlet用来从客户端读取请求。
映射
由Servlet实例和Servlet返回数据的URL组成的一对，例如，HelloServlet和/hello/index.html。
输出流对象
一个对象，由ServletOutputStream class类定义，被Servlet用来向客户端返回数据。
request dispatcher object
由RequestDispatcher接口定义的一个对象，用来从客户端接收请求，并将其发送到Web服务器上可用的其他资源（例如Servlet、CGI、HTML文件或JSP文件）。
sandboxed servlet
在一个安全性约束下运行的Servlet。
servlet
一个小的，具有平台无关性的，没有图形用户界面的Java程序。它可以在许多方面扩充Web服务的功能。
servlet configuration object
ServletConfig接口定义的一个对象，用来配置一个Servlet。
servlet context object
ServletContext接口定义的一个对象。给予Servlet有关Servlet引擎的信息。
servlet引擎
由Web服务器提供商制作的一个环境，可以允许Servlet在具体的Web服务器上运行。
servlet请求对象
由ServletRequest接口定义的一个对象，允许Servlet获得用关客户端请求的数据。
servlet response object
由ServletResponse接口定义的一个对象，允许Servlet作出响应。
servlet runner
Java Servlet Developer’s Kit (JSDK)中的sun.servlet.http.HttpServer过程，它使得Servlet得以运行。
会话跟踪
在一个Web应用程序中，识别一个从同一个客户端发出的连续的唯一的请求的能力。
SSL
加密套接字协议层。一个安全协议，用来在Iternet上的客户端浏览器和服务器交换密钥和加密数据。
URI
统一资源标识。定义一个Internet地址，它是一个URL的超集。
URL
统一资源路径。这个地址定义了到达一个WWW上的文件的路线，通常由协议前缀、域名、目录名和文件名组成。

1.RequestDispatcher.forward()
  是在服务器端起作用,当使用forward()时,Servlet engine传递HTTP请求从当前的Servlet or JSP到另外一个Servlet,JSP 或普通HTML文件,也即你的form提交至a.jsp,在a.jsp用到了forward()重定向至b.jsp,此时form提交的所有信息在b.jsp都可以获得,参数自动传递.
  但forward()无法重定向至有frame的jsp文件,可以重定向至有frame的html文件,同时forward()无法在后面带参数传递,比如servlet?name=frank,这样不行,可以程序内通过response.setAttribute("name",name)来传至下一个页面.

   重定向后浏览器地址栏URL不变.

例:在servlet中进行重定向
public void doPost(HttpServletRequest request,HttpServletResponse response)
 throws ServletException,IOException
{

        response.setContentType("text/html; charset=gb2312");

        ServletContext sc = getServletContext();

        RequestDispatcher rd = null;

        rd = sc.getRequestDispatcher("/index.jsp");     //定向的页面

        rd.forward(request, response);

}
通常在servlet中使用，不在jsp中使用。

2.response.sendRedirect()
    是在用户的浏览器端工作,sendRedirect()可以带参数传递,比如servlet?name=frank传至下个页面,同时它可以重定向至不同的主机上,sendRedirect()可以重定向有frame.的jsp文件.
   重定向后在浏览器地址栏上会出现重定向页面的URL
例:在servlet中重定向
public void doPost(HttpServletRequest request,HttpServletResponse response)

        throws ServletException,IOException

{

        response.setContentType("text/html; charset=gb2312");

        response.sendRedirect("/index.jsp");

}
由于response是jsp页面中的隐含对象，故在jsp页面中可以用response.sendRedirect()直接实现重定位。
注意：
(1).使用response.sendRedirect时，前面不能有HTML输出。
这并不是绝对的，不能有HTML输出其实是指不能有HTML被送到了浏览器。事实上现在的server都有cache机制，一般在8K（我是说JSP　SERVER），这就意味着，除非你关闭了cache，或者你使用了out.flush()强制刷新，那么在使用sendRedirect之前，有少量的HTML输出也是允许的。
(2).response.sendRedirect之后，应该紧跟一句return;
我们已经知道response.sendRedirect是通过浏览器来做转向的，所以只有在页面处理完成后，才会有实际的动作。既然你已经要做转向了，那么后的输出还有什么意义呢？而且有可能会因为后面的输出导致转向失败。
比较：
(1).Request Dispatcher.forward()是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；
(2).response.sendRedirect()则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。
前者更加高效，在前者可以满足需要时，尽量使用RequestDispatcher.forward()方法.

 注：在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用HttpServletResponse.sendRequest()方法。
 
3.<jsp:forward page="" />

它的底层部分是由RequestDispatcher来实现的，因此它带有RequestDispatcher.forward()方法的印记。

如果在<jsp:forward>之前有很多输出,前面的输出已使缓冲区满,将自动输出到客户端,那么该语句将不起作用,这一点应该特别注意。
 另外要注意：它不能改变浏览器地址，刷新的话会导致重复提交

4.修改HTTP header的Location属性来重定向
   通过设置直接修改地址栏来实现页面的重定向。
jsp文件代码如下：

＜%
response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);
String newLocn = "/newpath/jsa.jsp";
response.setHeader("Location",newLocn);
%＞

5.JSP中实现在某页面停留若干秒后,自动重定向到另一页面
  在html文件中，下面的代码：
    <meta http-equiv="refresh" content="300; url=target.jsp">
    它的含义：在5分钟之后正在浏览的页面将会自动变为target.html这一页。代码中300为刷新的延迟时间，以秒为单位。targer.html为你想转向的目标页,若为本页则为自动刷新本页。
    由上可知，可以通过setHeader来实现某页面停留若干秒后,自动重定向到另一页面。
    关键代码：
          String content=stayTime+";URL="+URL;
          response.setHeader("REFRESH",content);

requestDispatcher.forward()与response.sendRedirect()的区别

这表示位于WEB-INF/classes/moreservlets/TestServlet的servlet已经得到了注册名Test。给servlet一个名称具有两个主要的含义。首先，初始化参数、定制的URL模式以及其他定制通过此注册名而不是类名引用此servlet。其次,可在URL而不是类名中使用此名称。因此，利用刚才给出的定义，URL http://host/webAppPrefix/servlet/Test 可用于 http://host/webAppPrefix/servlet/moreservlets.TestServlet 的场所。
请记住：XML元素不仅是大小写敏感的，而且定义它们的次序也很重要。例如，web-app元素内所有servlet元素必须位于所有servlet-mapping元素（下一小节介绍）之前，而且还要位于5.6节和5.11节讨论的与过滤器或文档相关的元素（如果有的话）之前。类似地，servlet的servlet-name子元素也必须出现在servlet-class之前。5.2节"部署描述符文件内的元素次序"将详细介绍这种必需的次序。
例如，程序清单5-1给出了一个名为TestServlet的简单servlet，它驻留在moreservlets程序包中。因为此servlet是扎根在一个名为deployDemo的目录中的Web应用的组成部分，所以TestServlet.class放在deployDemo/WEB-INF/classes/moreservlets中。程序清单5-2给出将放置在deployDemo/WEB-INF/内的web.xml文件的一部分。此web.xml文件使用servlet-name和servlet-class元素将名称Test与TestServlet.class相关联。图5-1和图5-2分别显示利用缺省URL和注册名调用TestServlet时的结果。

程序清单5-1 TestServlet.java
package moreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

/** Simple servlet used to illustrate servlet naming
* and custom URLs.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* &copy; 2002 Marty Hall; may be freely used or adapted.
*/

public class TestServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String uri = request.getRequestURI();
out.println(ServletUtilities.headWithTitle("Test Servlet") +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>URI: " + uri + "</H2>\n" +
"</BODY></HTML>");
}
}

程序清单5-2 web.xml（说明servlet名称的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- … -->
<servlet>
<servlet-name>Test</servlet-name>
<servlet-class>moreservlets.TestServlet</servlet-class>
</servlet>
<!-- … -->
</web-app>

3.2 定义定制的URL
大多数服务器具有一个缺省的serlvet URL：
http://host/webAppPrefix/servlet/packageName.ServletName。虽然在开发中使用这个URL很方便，但是我们常常会希望另一个URL用于部署。例如，可能会需要一个出现在Web应用顶层的URL（如，http://host/webAppPrefix/Anyname），并且在此URL中没有servlet项。位于顶层的URL简化了相对URL的使用。此外，对许多开发人员来说，顶层URL看上去比更长更麻烦的缺省URL更简短。
事实上，有时需要使用定制的URL。比如，你可能想关闭缺省URL映射，以便更好地强制实施安全限制或防止用户意外地访问无初始化参数的servlet。如果你禁止了缺省的URL，那么你怎样访问servlet呢？这时只有使用定制的URL了。
为了分配一个定制的URL，可使用servlet-mapping元素及其servlet-name和url-pattern子元素。Servlet-name元素提供了一个任意名称，可利用此名称引用相应的servlet；url-pattern描述了相对于Web应用的根目录的URL。url-pattern元素的值必须以斜杠（/）起始。
下面给出一个简单的web.xml摘录，它允许使用URL http://host/webAppPrefix/UrlTest而不是http://host/webAppPrefix/servlet/Test或
http://host/webAppPrefix/servlet/moreservlets.TestServlet。请注意，仍然需要XML头、DOCTYPE声明以及web-app封闭元素。此外，可回忆一下，XML元素出现地次序不是随意的。特别是，需要把所有servlet元素放在所有servlet-mapping元素之前。
<servlet>
<servlet-name>Test</servlet-name>
<servlet-class>moreservlets.TestServlet</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name>Test</servlet-name>
<url-pattern>/UrlTest</url-pattern>
</servlet-mapping>
URL模式还可以包含通配符。例如，下面的小程序指示服务器发送所有以Web应用的URL前缀开始，以..asp结束的请求到名为BashMS的servlet。
<servlet>
<servlet-name>BashMS</servlet-name>
<servlet-class>msUtils.ASPTranslator</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name>BashMS</servlet-name>
<url-pattern>/*.asp</url-pattern>
</servlet-mapping>
3.3 命名JSP页面
因为JSP页面要转换成sevlet，自然希望就像命名servlet一样命名JSP页面。毕竟，JSP页面可能会从初始化参数、安全设置或定制的URL中受益，正如普通的serlvet那样。虽然JSP页面的后台实际上是servlet这句话是正确的，但存在一个关键的猜疑：即，你不知道JSP页面的实际类名（因为系统自己挑选这个名字）。因此，为了命名JSP页面，可将jsp-file元素替换为servlet-calss元素，如下所示：
<servlet>
<servlet-name>Test</servlet-name>
<jsp-file>/TestPage.jsp</jsp-file>
</servlet>
命名JSP页面的原因与命名servlet的原因完全相同：即为了提供一个与定制设置（如，初始化参数和安全设置）一起使用的名称，并且，以便能更改激活JSP页面的URL（比方说，以便多个URL通过相同页面得以处理，或者从URL中去掉.jsp扩展名）。但是，在设置初始化参数时，应该注意，JSP页面是利用jspInit方法，而不是init方法读取初始化参数的。
例如，程序清单5-3给出一个名为TestPage.jsp的简单JSP页面，它的工作只是打印出用来激活它的URL的本地部分。TestPage.jsp放置在deployDemo应用的顶层。程序清单5-4给出了用来分配一个注册名PageName，然后将此注册名与http://host/webAppPrefix/UrlTest2/anything 形式的URL相关联的web.xml文件（即，deployDemo/WEB-INF/web.xml）的一部分。

程序清单5-3 TestPage.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>
JSP Test Page
</TITLE>
</HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>URI: <%= request.getRequestURI() %></H2>
</BODY>
</HTML>

程序清单5-4 web.xml（说明JSP页命名的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/TestPage.jsp</jsp-file>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> PageName </servlet-name>
<url-pattern>/UrlTest2/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>

4 禁止激活器servlet

对servlet或JSP页面建立定制URL的一个原因是，这样做可以注册从init（servlet）或jspInit（JSP页面）方法中读取得初始化参数。但是，初始化参数只在是利用定制URL模式或注册名访问servlet或JSP页面时可以使用，用缺省URL http://host/webAppPrefix/servlet/ServletName 访问时不能使用。因此，你可能会希望关闭缺省URL，这样就不会有人意外地调用初始化servlet了。这个过程有时称为禁止激活器servlet，因为多数服务器具有一个用缺省的servlet URL注册的标准servlet，并激活缺省的URL应用的实际servlet。
有两种禁止此缺省URL的主要方法：
l 在每个Web应用中重新映射/servlet/模式。
l 全局关闭激活器servlet。
重要的是应该注意到，虽然重新映射每个Web应用中的/servlet/模式比彻底禁止激活servlet所做的工作更多，但重新映射可以用一种完全可移植的方式来完成。相反，全局禁止激活器servlet完全是针对具体机器的，事实上有的服务器（如ServletExec）没有这样的选择。下面的讨论对每个Web应用重新映射/servlet/ URL模式的策略。后面提供在Tomcat中全局禁止激活器servlet的详细内容。
4.1 重新映射/servlet/URL模式
在一个特定的Web应用中禁止以http://host/webAppPrefix/servlet/ 开始的URL的处理非常简单。所需做的事情就是建立一个错误消息servlet，并使用前一节讨论的url-pattern元素将所有匹配请求转向该servlet。只要简单地使用：
<url-pattern>/servlet/*</url-pattern>
作为servlet-mapping元素中的模式即可。
例如，程序清单5-5给出了将SorryServlet servlet（程序清单5-6）与所有以http://host/webAppPrefix/servlet/ 开头的URL相关联的部署描述符文件的一部分。

程序清单5-5 web.xml（说明JSP页命名的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>Sorry</servlet-name>
<servlet-class>moreservlets.SorryServlet</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> Sorry </servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>

程序清单5-6 SorryServlet.java
package moreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

/** Simple servlet used to give error messages to
* users who try to access default servlet URLs
* (i.e., http://host/webAppPrefix/servlet/ServletName)
* in Web applications that have disabled this
* behavior.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* &copy; 2002 Marty Hall; may be freely used or adapted.
*/

public class SorryServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Invoker Servlet Disabled.";
out.println(ServletUtilities.headWithTitle(title) +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>" + title + "</H2>\n" +
"Sorry, access to servlets by means of\n" +
"URLs that begin with\n" +
"http://host/webAppPrefix/servlet/\n" +
"has been disabled.\n" +
"</BODY></HTML>");
}

public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

4.2 全局禁止激活器：Tomcat
Tomcat 4中用来关闭缺省URL的方法与Tomcat 3中所用的很不相同。下面介绍这两种方法：
1．禁止激活器： Tomcat 4
Tomcat 4用与前面相同的方法关闭激活器servlet，即利用web.xml中的url-mapping元素进行关闭。不同之处在于Tomcat使用了放在install_dir/conf中的一个服务器专用的全局web.xml文件，而前面使用的是存放在每个Web应用的WEB-INF目录中的标准web.xml文件。
因此，为了在Tomcat 4中关闭激活器servlet，只需在install_dir/conf/web.xml中简单地注释出/servlet/* URL映射项即可，如下所示：
<!--
<servlet-mapping>
<servlet-name>invoker</servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
-->
再次提醒，应该注意这个项是位于存放在install_dir/conf的Tomcat专用的web.xml文件中的，此文件不是存放在每个Web应用的WEB-INF目录中的标准web.xml。
2．禁止激活器：Tomcat3
在Apache Tomcat的版本3中，通过在install_dir/conf/server.xml中注释出InvokerInterceptor项全局禁止缺省servlet URL。例如，下面是禁止使用缺省servlet URL的server.xml文件的一部分。
<!--
<RequsetInterceptor
className="org.apache.tomcat.request.InvokerInterceptor"
debug="0" prefix="/servlet/" />
-->

5 初始化和预装载servlet与JSP页面

这里讨论控制servlet和JSP页面的启动行为的方法。特别是，说明了怎样分配初始化参数以及怎样更改服务器生存期中装载servlet和JSP页面的时刻。
5.1 分配servlet初始化参数
利用init-param元素向servlet提供初始化参数，init-param元素具有param-name和param-value子元素。例如，在下面的例子中，如果initServlet servlet是利用它的注册名（InitTest）访问的，它将能够从其方法中调用getServletConfig().getInitParameter("param1")获得"Value 1"，调用getServletConfig().getInitParameter("param2")获得"2"。
<servlet>
<servlet-name>InitTest</servlet-name>
<servlet-class>moreservlets.InitServlet</servlet-class>
<init-param>
<param-name>param1</param-name>
<param-value>value1</param-value>
</init-param>
<init-param>
<param-name>param2</param-name>
<param-value>2</param-value>
</init-param>
</servlet>
在涉及初始化参数时，有几点需要注意：
l 返回值。GetInitParameter的返回值总是一个String。因此，在前一个例子中，可对param2使用Integer.parseInt获得一个int。
l JSP中的初始化。JSP页面使用jspInit而不是init。JSP页面还需要使用jsp-file元素代替servlet-class。
l 缺省URL。初始化参数只在通过它们的注册名或与它们注册名相关的定制URL模式访问Servlet时可以使用。因此，在这个例子中，param1和param2初始化参数将能够在使用URL http://host/webAppPrefix/servlet/InitTest 时可用，但在使用URL http://host/webAppPrefix/servlet/myPackage.InitServlet 时不能使用。
例如，程序清单5-7给出一个名为InitServlet的简单servlet，它使用init方法设置firstName和emailAddress字段。程序清单5-8给出分配名称InitTest给servlet的web.xml文件。
程序清单5-7 InitServlet.java
package moreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

/** Simple servlet used to illustrate servlet
* initialization parameters.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* &copy; 2002 Marty Hall; may be freely used or adapted.
*/

public class InitServlet extends HttpServlet {
private String firstName, emailAddress;

public void init() {
ServletConfig config = getServletConfig();
firstName = config.getInitParameter("firstName");
emailAddress = config.getInitParameter("emailAddress");
}

public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String uri = request.getRequestURI();
out.println(ServletUtilities.headWithTitle("Init Servlet") +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>Init Parameters:</H2>\n" +
"<UL>\n" +
"<LI>First name: " + firstName + "\n" +
"<LI>Email address: " + emailAddress + "\n" +
"</UL>\n" +
"</BODY></HTML>");
}
}

程序清单5-8 web.xml（说明初始化参数的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>InitTest</servlet-name>
<servlet-class>moreservlets.InitServlet</servlet-class>
<init-param>
<param-name>firstName</param-name>
<param-value>Larry</param-value>
</init-param>
<init-param>
<param-name>emailAddress</param-name>
<param-value>Ellison@Microsoft.com</param-value>
</init-param>
</servlet>
<!-- ... -->
</web-app>

5.2 分配JSP初始化参数
给JSP页面提供初始化参数在三个方面不同于给servlet提供初始化参数。
1）使用jsp-file而不是servlet-class。因此，WEB-INF/web.xml文件的servlet元素如下所示：
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/RealPage.jsp</jsp-file>
<init-param>
<param-name>...</param-name>
<param-value>...</param-value>
</init-param>
...
</servlet>
2)几乎总是分配一个明确的URL模式。对servlet，一般相应地使用以http://host/webAppPrefix/servlet/ 开始的缺省URL。只需记住，使用注册名而不是原名称即可。这对于JSP页面在技术上也是合法的。例如，在上面给出的例子中，可用URL http://host/webAppPrefix/servlet/PageName 访问RealPage.jsp的对初始化参数具有访问权的版本。但在用于JSP页面时，许多用户似乎不喜欢应用常规的servlet的URL。此外，如果JSP页面位于服务器为其提供了目录清单的目录中（如，一个既没有index.html也没有index.jsp文件的目录），则用户可能会连接到此JSP页面，单击它，从而意外地激活未初始化的页面。因此，好的办法是使用url-pattern（5.3节）将JSP页面的原URL与注册的servlet名相关联。这样，客户机可使用JSP页面的普通名称，但仍然激活定制的版本。例如，给定来自项目1的servlet定义，可使用下面的servlet-mapping定义：
<servlet-mapping>
<servlet-name>PageName</servlet-name>
<url-pattern>/RealPage.jsp</url-pattern>
</servlet-mapping>
3）JSP页使用jspInit而不是init。自动从JSP页面建立的servlet或许已经使用了inti方法。因此，使用JSP声明提供一个init方法是不合法的，必须制定jspInit方法。
为了说明初始化JSP页面的过程，程序清单5-9给出了一个名为InitPage.jsp的JSP页面，它包含一个jspInit方法且放置于deployDemo Web应用层次结构的顶层。一般，http://host/deployDemo/InitPage.jsp 形式的URL将激活此页面的不具有初始化参数访问权的版本，从而将对firstName和emailAddress变量显示null。但是，web.xml文件（程序清单5-10）分配了一个注册名，然后将该注册名与URL模式/InitPage.jsp相关联。

程序清单5-9 InitPage.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>JSP Init Test</TITLE></HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>Init Parameters:</H2>
<UL>
<LI>First name: <%= firstName %>
<LI>Email address: <%= emailAddress %>
</UL>
</BODY></HTML>
<%!
private String firstName, emailAddress;

public void jspInit() {
ServletConfig config = getServletConfig();
firstName = config.getInitParameter("firstName");
emailAddress = config.getInitParameter("emailAddress");
}
%>

程序清单5-10 web.xml（说明JSP页面的init参数的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>InitPage</servlet-name>
<jsp-file>/InitPage.jsp</jsp-file>
<init-param>
<param-name>firstName</param-name>
<param-value>Bill</param-value>
</init-param>
<init-param>
<param-name>emailAddress</param-name>
<param-value>gates@oracle.com</param-value>
</init-param>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> InitPage</servlet-name>
<url-pattern>/InitPage.jsp</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>

5.3 提供应用范围内的初始化参数
一般，对单个地servlet或JSP页面分配初始化参数。指定的servlet或JSP页面利用ServletConfig的getInitParameter方法读取这些参数。但是，在某些情形下，希望提供可由任意servlet或JSP页面借助ServletContext的getInitParameter方法读取的系统范围内的初始化参数。
可利用context-param元素声明这些系统范围内的初始化值。context-param元素应该包含param-name、param-value以及可选的description子元素，如下所示：
<context-param>
<param-name>support-email</param-name>
<param-value>blackhole@mycompany.com</param-value>
</context-param>
可回忆一下，为了保证可移植性，web.xml内的元素必须以正确的次序声明。但这里应该注意，context-param元素必须出现任意与文档有关的元素（icon、display-name或description）之后及filter、filter-mapping、listener或servlet元素之前。
5.4 在服务器启动时装载servlet
假如servlet或JSP页面有一个要花很长时间执行的init（servlet）或jspInit（JSP）方法。例如，假如init或jspInit方法从某个数据库或ResourceBundle查找产量。这种情况下，在第一个客户机请求时装载servlet的缺省行为将对第一个客户机产生较长时间的延迟。因此，可利用servlet的load-on-startup元素规定服务器在第一次启动时装载servlet。下面是一个例子。
<servlet>
<servlet-name> … </servlet-name>
<servlet-class> … </servlet-class> <!-- Or jsp-file -->
<load-on-startup/>
</servlet>
可以为此元素体提供一个整数而不是使用一个空的load-on-startup。想法是服务器应该在装载较大数目的servlet或JSP页面之前装载较少数目的servlet或JSP页面。例如，下面的servlet项（放置在Web应用的WEB-INF目录下的web.xml文件中的web-app元素内）将指示服务器首先装载和初始化SearchServlet，然后装载和初始化由位于Web应用的result目录中的index.jsp文件产生的servlet。
<servlet>
<servlet-name>Search</servlet-name>
<servlet-class>myPackage.SearchServlet</servlet-class> <!-- Or jsp-file -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>Results</servlet-name>
<servlet-class>/results/index.jsp</servlet-class> <!-- Or jsp-file -->
<load-on-startup>2</load-on-startup>
</servlet>

6 声明过滤器

servlet版本2.3引入了过滤器的概念。虽然所有支持servlet API版本2.3的服务器都支持过滤器，但为了使用与过滤器有关的元素，必须在web.xml中使用版本2.3的DTD。
过滤器可截取和修改进入一个servlet或JSP页面的请求或从一个servlet或JSP页面发出的相应。在执行一个servlet或JSP页面之前，必须执行第一个相关的过滤器的doFilter方法。在该过滤器对其FilterChain对象调用doFilter时，执行链中的下一个过滤器。如果没有其他过滤器，servlet或JSP页面被执行。过滤器具有对到来的ServletRequest对象的全部访问权，因此，它们可以查看客户机名、查找到来的cookie等。为了访问servlet或JSP页面的输出，过滤器可将响应对象包裹在一个替身对象（stand-in object）中，比方说把输出累加到一个缓冲区。在调用FilterChain对象的doFilter方法之后，过滤器可检查缓冲区，如有必要，就对它进行修改，然后传送到客户机。
例如，程序清单5-11帝国难以了一个简单的过滤器，只要访问相关的servlet或JSP页面，它就截取请求并在标准输出上打印一个报告（开发过程中在桌面系统上运行时，大多数服务器都可以使用这个过滤器）。

程序清单5-11 ReportFilter.java
package moreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

/** Simple filter that prints a report on the standard output
* whenever the associated servlet or JSP page is accessed.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* &copy; 2002 Marty Hall; may be freely used or adapted.
*/

public class ReportFilter implements Filter {
public void doFilter(ServletRequest request,
ServletResponse response,
FilterChain chain)
throws ServletException, IOException {
HttpServletRequest req = (HttpServletRequest)request;
System.out.println(req.getRemoteHost() +
" tried to access " +
req.getRequestURL() +
" on " + new Date() + ".");
chain.doFilter(request,response);
}

public void init(FilterConfig config)
throws ServletException {
}

public void destroy() {}
}

一旦建立了一个过滤器，可以在web.xml中利用filter元素以及filter-name（任意名称）、file-class（完全限定的类名）和（可选的）init-params子元素声明它。请注意，元素在web.xml的web-app元素中出现的次序不是任意的；允许服务器（但不是必需的）强制所需的次序，并且实际中有些服务器也是这样做的。但这里要注意，所有filter元素必须出现在任意filter-mapping元素之前，filter-mapping元素又必须出现在所有servlet或servlet-mapping元素之前。
例如，给定上述的ReportFilter类，可在web.xml中作出下面的filter声明。它把名称Reporter与实际的类ReportFilter（位于moreservlets程序包中）相关联。
<filter>
<filter-name>Reporter</filter-name>
<filter-class>moresevlets.ReportFilter</filter-class>
</filter>
一旦命名了一个过滤器，可利用filter-mapping元素把它与一个或多个servlet或JSP页面相关联。关于此项工作有两种选择。
首先，可使用filter-name和servlet-name子元素把此过滤器与一个特定的servlet名（此servlet名必须稍后在相同的web.xml文件中使用servlet元素声明）关联。例如，下面的程序片断指示系统只要利用一个定制的URL访问名为SomeServletName的servlet或JSP页面，就运行名为Reporter的过滤器。
<filter-mapping>
<filter-name>Reporter</filter-name>
<servlet-name>SomeServletName</servlet-name>
</filter-mapping>
其次，可利用filter-name和url-pattern子元素将过滤器与一组servlet、JSP页面或静态内容相关联。例如，相面的程序片段指示系统只要访问Web应用中的任意URL，就运行名为Reporter的过滤器。
<filter-mapping>
<filter-name>Reporter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
例如，程序清单5-12给出了将ReportFilter过滤器与名为PageName的servlet相关联的web.xml文件的一部分。名字PageName依次又与一个名为TestPage.jsp的JSP页面以及以模式http://host/webAppPrefix/UrlTest2/ 开头的URL相关联。TestPage.jsp的源代码已经JSP页面命名的谈论在前面的3节"分配名称和定制的URL"中给出。事实上，程序清单5-12中的servlet和servlet-name项从该节原封不动地拿过来的。给定这些web.xml项，可看到下面的标准输出形式的调试报告（换行是为了容易阅读）。
audit.irs.gov tried to access
http://mycompany.com/deployDemo/UrlTest2/business/tax-plan.html
on Tue Dec 25 13:12:29 EDT 2001.

程序清单5-12 Web.xml（说明filter用法的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<filter>
<filter-name>Reporter</filter-name>
<filter-class>moresevlets.ReportFilter</filter-class>
</filter>
<!-- ... -->
<filter-mapping>
<filter-name>Reporter</filter-name>
<servlet-name>PageName</servlet-name>
</filter-mapping>
<!-- ... -->
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/RealPage.jsp</jsp-file>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> PageName </servlet-name>
<url-pattern>/UrlTest2/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>

7 指定欢迎页

假如用户提供了一个像http://host/webAppPrefix/directoryName/ 这样的包含一个目录名但没有包含文件名的URL，会发生什么事情呢？用户能得到一个目录表？一个错误？还是标准文件的内容？如果得到标准文件内容，是index.html、index.jsp、default.html、default.htm或别的什么东西呢？
Welcome-file-list元素及其辅助的welcome-file元素解决了这个模糊的问题。例如，下面的web.xml项指出，如果一个URL给出一个目录名但未给出文件名，服务器应该首先试用index.jsp，然后再试用index.html。如果两者都没有找到，则结果有赖于所用的服务器（如一个目录列表）。
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
虽然许多服务器缺省遵循这种行为，但不一定必须这样。因此，明确地使用welcom-file-list保证可移植性是一种良好的习惯。

8 指定处理错误的页面

现在我了解到，你在开发servlet和JSP页面时从不会犯错误，而且你的所有页面是那样的清晰，一般的程序员都不会被它们的搞糊涂。但是，是人总会犯错误的，用户可能会提供不合规定的参数，使用不正确的URL或者不能提供必需的表单字段值。除此之外，其它开发人员可能不那么细心，他们应该有些工具来克服自己的不足。
error-page元素就是用来克服这些问题的。它有两个可能的子元素，分别是：error-code和exception-type。第一个子元素error-code指出在给定的HTTP错误代码出现时使用的URL。第二个子元素excpetion-type指出在出现某个给定的Java异常但未捕捉到时使用的URL。error-code和exception-type都利用location元素指出相应的URL。此URL必须以/开始。location所指出的位置处的页面可通过查找HttpServletRequest对象的两个专门的属性来访问关于错误的信息，这两个属性分别是：javax.servlet.error.status_code和javax.servlet.error.message。
可回忆一下，在web.xml内以正确的次序声明web-app的子元素很重要。这里只要记住，error-page出现在web.xml文件的末尾附近，servlet、servlet-name和welcome-file-list之后即可。

8.1 error-code元素
为了更好地了解error-code元素的值，可考虑一下如果不正确地输入文件名，大多数站点会作出什么反映。这样做一般会出现一个404错误信息，它表示不能找到该文件，但几乎没提供更多有用的信息。另一方面，可以试一下在www.microsoft.com、www.ibm.com 处或者特别是在www.bea.com 处输出未知的文件名。这是会得出有用的消息，这些消息提供可选择的位置，以便查找感兴趣的页面。提供这样有用的错误页面对于Web应用来说是很有价值得。事实上，http://www.plinko.net/404/ 就是把整个站点专门用于404错误页面这个内容。这个站点包含来自全世界最好、最糟和最搞笑的404页面。
程序清单5-13给出一个JSP页面，此页面可返回给提供位置程序名的客户机。程序清单5-14给出指定程序清单5-13作为返回404错误代码时显示的页面的web.xml。请注意，浏览器中显示的URL仍然是客户机所提供的。错误页面是一种后台实现技术。
最后一点，请记住IE5的缺省配置显然不符合HTTP规范，它忽略了服务器生成的错误消息，而是显示自己的标准出错信息。可转到其Tools菜单，选择Internet Options，单击Advanced，取消Show Friendly HTTP Error Message来解决此问题。

程序清单5-13 NotFound.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>404: Not Found</TITLE></HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>Error!</H2>
I'm sorry, but I cannot find a page that matches
<%= request.getRequestURI() %> on the system. Maybe you should
try one of the following:
<UL>
<LI>Go to the server's <A HREF="/">home page</A>.
<LI>Search for relevant pages.<BR>
<FORM ACTION="http://www.google.com/search">
<CENTER>
Keywords: <INPUT TYPE="TEXT" NAME="q"><BR>
<INPUT TYPE="SUBMIT" VALUE="Search">
</CENTER>
</FORM>
<LI>Admire a random multiple of 404:
<%= 404*((int)(1000*Math.random())) %>.
<LI>Try a <A HREF="http://www.plinko.net/404/rndindex.asp"
TARGET="_blank">
random 404 error message</A>. From the amazing and
amusing plinko.net <A HREF="http://www.plinko.net/404/">
404 archive</A>.
</UL>
</BODY></HTML>

程序清单5-14 web.xml（指出HTTP错误代码的错误页面的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<error-page>
<error-code>404</error-code>
<location>/NotFound.jsp</location>
</error-page>
<!-- ... -->
</web-app>

8.2 exception-type元素
error-code元素处理某个请求产生一个特定的HTTP状态代码时的情况。然而，对于servlet或JSP页面返回200但产生运行时异常这种同样是常见的情况怎么办呢？这正是exception-type元素要处理的情况。只需提供两样东西即可：即提供如下的一个完全限定的异常类和一个位置：
<error-page>
<exception-type>packageName.className</exception-type>
<location>/SomeURL</location>
</error-page>
这样，如果Web应用中的任何servlet或JSP页面产生一个特定类型的未捕捉到的异常，则使用指定的URL。此异常类型可以是一个标准类型，如javax.ServletException或java.lang.OutOfMemoryError，或者是一个专门针对你的应用的异常。
例如，程序清单5-15给出了一个名为DumbDeveloperException的异常类，可用它来特别标记经验较少的程序员（不是说你的开发组中一定有这种人）所犯的错误。这个类还包含一个名为dangerousComputation的静态方法，它时不时地生成这种类型的异常。程序清单5-16给出对随机整数值调用dangerousCompution的一个JSP页面。在抛出此异常时，如程序清单5-18的web.xml版本中所给出的exception-type所指出的那样，对客户机显示DDE.jsp（程序清单5-17）。图5-16和图5-17分别给出幸运和不幸的结果。

程序清单5-15 DumbDeveloperException.java
package moreservlets;

/** Exception used to flag particularly onerous
programmer blunders. Used to illustrate the
exception-type web.xml element.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* &copy; 2002 Marty Hall; may be freely used or adapted.
*/

public class DumbDeveloperException extends Exception {
public DumbDeveloperException() {
super("Duh. What was I *thinking*?");
}

public static int dangerousComputation(int n)
throws DumbDeveloperException {
if (n < 5) {
return(n + 10);
} else {
throw(new DumbDeveloperException());
}
}
}

程序清单5-16 RiskyPage.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>Risky JSP Page</TITLE></HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>Risky Calculations</H2>
<%@ page import="moreservlets.*" %>
<% int n = ((int)(10 * Math.random())); %>
<UL>
<LI>n: <%= n %>
<LI>dangerousComputation(n):
<%= DumbDeveloperException.dangerousComputation(n) %>
</UL>
</BODY></HTML>

程序清单5-17 DDE.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>Dumb</TITLE></HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>Dumb Developer</H2>
We're brain dead. Consider using our competitors.
</BODY></HTML>

程序清单5-18 web.xml（为异常指定错误页面的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet> … </servlet>
<!-- ... -->
<error-page>
<exception-type>
moreservlets.DumbDeveloperException
</exception-type>
<location>/DDE.jsp</location>
</error-page>
<!-- ... -->
</web-app>

9 提供安全性

利用web.xml中的相关元素为服务器的内建功能提供安全性。
9.1 指定验证的方法
使用login-confgi元素规定服务器应该怎样验证试图访问受保护页面的用户。它包含三个可能的子元素，分别是：auth-method、realm-name和form-login-config。login-config元素应该出现在web.xml部署描述符文件的结尾附近，紧跟在security-constraint元素之后。
l auth-method
login-config的这个子元素列出服务器将要使用的特定验证机制。有效值为BASIC、DIGEST、FORM和CLIENT-CERT。服务器只需要支持BASIC和FORM。
BASIC指出应该使用标准的HTTP验证，在此验证中服务器检查Authorization头。如果缺少这个头则返回一个401状态代码和一个WWW-Authenticate头。这导致客户机弹出一个用来填写Authorization头的对话框。此机制很少或不提供对攻击者的防范，这些攻击者在Internet连接上进行窥探（如通过在客户机的子网上执行一个信息包探测装置），因为用户名和口令是用简单的可逆base64编码发送的，他们很容易得手。所有兼容的服务器都需要支持BASIC验证。
DIGEST指出客户机应该利用加密Digest Authentication形式传输用户名和口令。这提供了比BASIC验证更高的防范网络截取得的安全性，但这种加密比SSL（HTTPS）所用的方法更容易破解。不过，此结论有时没有意义，因为当前很少有浏览器支持Digest Authentication，所以servlet容器不需要支持它。
FORM指出服务器应该检查保留的会话cookie并且把不具有它的用户重定向到一个指定的登陆页。此登陆页应该包含一个收集用户名和口令的常规HTML表单。在登陆之后，利用保留会话级的cookie跟踪用户。虽然很复杂，但FORM验证防范网络窥探并不比BASIC验证更安全，如果有必要可以在顶层安排诸如SSL或网络层安全（如IPSEC或VPN）等额外的保护。所有兼容的服务器都需要支持FORM验证。
CLIENT-CERT规定服务器必须使用HTTPS（SSL之上的HTTP）并利用用户的公开密钥证书（Pulic Key Certificat）对用户进行验证。这提供了防范网络截取的很强的安全性，但只有兼容J2EE的服务器需要支持它。
l realm-name
此元素只在auth-method为BASIC时使用。它指出浏览器在相应对话框标题使用的、并作为Authorization头组成部分的安全域的名称。
l form-login-config
此元素只在auth-method为FORM时适用。它指定两个页面，分别是：包含收集用户名及口令的HTML表单的页面（利用form-login-page子元素），用来指示验证失败的页面（利用form-error-page子元素）。由form-login-page给出的HTML表单必须具有一个j_security_check的ACTION属性、一个名为j_username的用户名文本字段以及一个名为j_password的口令字段。
例如，程序清单5-19指示服务器使用基于表单的验证。Web应用的顶层目录中的一个名为login.jsp的页面将收集用户名和口令，并且失败的登陆将由相同目录中名为login-error.jsp的页面报告。

程序清单5-19 web.xml（说明login-config的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<security-constraint> ... </security-constraint>
<login-config>
<auth-method> FORM </auth-method>
<form-login-config>
<form-login-page>/login.jsp</form-login-page>
<form-error-page>/login-error.jsp</form-error-page>
</form-login-config>
</login-config>
<!-- ... -->
</web-app>

9.2 限制对Web资源的访问
现在，可以指示服务器使用何种验证方法了。"了不起，"你说道，"除非我能指定一个来收到保护的URL，否则没有多大用处。"没错。指出这些URL并说明他们应该得到何种保护正是security-constriaint元素的用途。此元素在web.xml中应该出现在login-config的紧前面。它包含是个可能的子元素，分别是：web-resource-collection、auth-constraint、user-data-constraint和display-name。下面各小节对它们进行介绍。
l web-resource-collection
此元素确定应该保护的资源。所有security-constraint元素都必须包含至少一个web-resource-collection项。此元素由一个给出任意标识名称的web-resource-name元素、一个确定应该保护的URL的url-pattern元素、一个指出此保护所适用的HTTP命令（GET、POST等，缺省为所有方法）的http-method元素和一个提供资料的可选description元素组成。例如，下面的Web-resource-collection项（在security-constratint元素内）指出Web应用的proprietary目录中所有文档应该受到保护。
<security-constraint>
<web-resource-coolection>
<web-resource-name>Proprietary</web-resource-name>
<url-pattern>/propritary/*</url-pattern>
</web-resource-coolection>
<!-- ... -->
</security-constraint>
重要的是应该注意到，url-pattern仅适用于直接访问这些资源的客户机。特别是，它不适合于通过MVC体系结构利用RequestDispatcher来访问的页面，或者不适合于利用类似jsp:forward的手段来访问的页面。这种不匀称如果利用得当的话很有好处。例如，servlet可利用MVC体系结构查找数据，把它放到bean中，发送请求到从bean中提取数据的JSP页面并显示它。我们希望保证决不直接访问受保护的JSP页面，而只是通过建立该页面将使用的bean的servlet来访问它。url-pattern和auth-contraint元素可通过声明不允许任何用户直接访问JSP页面来提供这种保证。但是，这种不匀称的行为可能让开发人员放松警惕，使他们偶然对应受保护的资源提供不受限制的访问。
l auth-constraint
尽管web-resource-collention元素质出了哪些URL应该受到保护，但是auth-constraint元素却指出哪些用户应该具有受保护资源的访问权。此元素应该包含一个或多个标识具有访问权限的用户类别role-name元素，以及包含（可选）一个描述角色的description元素。例如，下面web.xml中的security-constraint元素部门规定只有指定为Administrator或Big Kahuna（或两者）的用户具有指定资源的访问权。
<security-constraint>
<web-resource-coolection> ... </web-resource-coolection>
<auth-constraint>
<role-name>administrator</role-name>
<role-name>kahuna</role-name>
</auth-constraint>
</security-constraint>
重要的是认识到，到此为止，这个过程的可移植部分结束了。服务器怎样确定哪些用户处于任何角色以及它怎样存放用户的口令，完全有赖于具体的系统。
例如，Tomcat使用install_dir/conf/tomcat-users.xml将用户名与角色名和口令相关联，正如下面例子中所示，它指出用户joe（口令bigshot）和jane（口令enaj）属于administrator和kahuna角色。
<tomcat-users>
<user name="joe" password="bigshot" roles="administrator,kahuna" />
<user name="jane" password="enaj" roles="kahuna" />
</tomcat-users>
l user-data-constraint
这个可选的元素指出在访问相关资源时使用任何传输层保护。它必须包含一个transport-guarantee子元素（合法值为NONE、INTEGRAL或CONFIDENTIAL），并且可选地包含一个description元素。transport-guarantee为NONE值将对所用的通讯协议不加限制。INTEGRAL值表示数据必须以一种防止截取它的人阅读它的方式传送。虽然原理上（并且在未来的HTTP版本中），在INTEGRAL和CONFIDENTIAL之间可能会有差别，但在当前实践中，他们都只是简单地要求用SSL。例如，下面指示服务器只允许对相关资源做HTTPS连接：
<security-constraint>
<!-- ... -->
<user-data-constraint>
<transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>
</security-constraint>
l display-name
security-constraint的这个很少使用的子元素给予可能由GUI工具使用的安全约束项一个名称。
9.3 分配角色名
迄今为止，讨论已经集中到完全由容器（服务器）处理的安全问题之上了。但servlet以及JSP页面也能够处理它们自己的安全问题。
例如，容器可能允许用户从bigwig或bigcheese角色访问一个显示主管人员额外紧贴的页面，但只允许bigwig用户修改此页面的参数。完成这种更细致的控制的一种常见方法是调用HttpServletRequset的isUserInRole方法，并据此修改访问。
Servlet的security-role-ref子元素提供出现在服务器专用口令文件中的安全角色名的一个别名。例如，假如编写了一个调用request.isUserInRole（"boss"）的servlet，但后来该servlet被用在了一个其口令文件调用角色manager而不是boss的服务器中。下面的程序段使该servlet能够使用这两个名称中的任何一个。
<servlet>
<!-- ... -->
<security-role-ref>
<role-name>boss</role-name> <!-- New alias -->
<role-link>manager</role-link> <!-- Real name -->
</security-role-ref>
</servlet>
也可以在web-app内利用security-role元素提供将出现在role-name元素中的所有安全角色的一个全局列表。分别地生命角色使高级IDE容易处理安全信息。

10 控制会话超时

如果某个会话在一定的时间内未被访问，服务器可把它扔掉以节约内存。可利用HttpSession的setMaxInactiveInterval方法直接设置个别会话对象的超时值。如果不采用这种方法，则缺省的超时值由具体的服务器决定。但可利用session-config和session-timeout元素来给出一个适用于所有服务器的明确的超时值。超时值的单位为分钟，因此，下面的例子设置缺省会话超时值为三个小时（180分钟）。
<session-config>
<session-timeout>180</session-timeout>
</session-config>

11 Web应用的文档化

越来越多的开发环境开始提供servlet和JSP的直接支持。例子有Borland Jbuilder Enterprise Edition、Macromedia UltraDev、Allaire JRun Studio（写此文时，已被Macromedia收购）以及IBM VisuaAge for Java等。
大量的web.xml元素不仅是为服务器设计的，而且还是为可视开发环境设计的。它们包括icon、display-name和discription等。
可回忆一下，在web.xml内以适当地次序声明web-app子元素很重要。不过，这里只要记住icon、display-name和description是web.xml的web-app元素内的前三个合法元素即可。
l icon
icon元素指出GUI工具可用来代表Web应用的一个和两个图像文件。可利用small-icon元素指定一幅16 x 16的GIF或JPEG图像，用large-icon元素指定一幅32 x 32的图像。下面举一个例子：
<icon>
<small-icon>/images/small-book.gif</small-icon>
<large-icon>/images/tome.jpg</large-icon>
</icon>
l display-name
display-name元素提供GUI工具可能会用来标记此Web应用的一个名称。下面是个例子。
<display-name>Rare Books</display-name>
l description
description元素提供解释性文本，如下所示：
<description>
This Web application represents the store developed for
rare-books.com, an online bookstore specializing in rare
and limited-edition books.
</description>

12 关联文件与MIME类型

服务器一般都具有一种让Web站点管理员将文件扩展名与媒体相关联的方法。例如，将会自动给予名为mom.jpg的文件一个image/jpeg的MIME类型。但是，假如你的Web应用具有几个不寻常的文件，你希望保证它们在发送到客户机时分配为某种MIME类型。mime-mapping元素（具有extension和mime-type子元素）可提供这种保证。例如，下面的代码指示服务器将application/x-fubar的MIME类型分配给所有以.foo结尾的文件。
<mime-mapping>
<extension>foo</extension>
<mime-type>application/x-fubar</mime-type>
</mime-mapping>
或许，你的Web应用希望重载（override）标准的映射。例如，下面的代码将告诉服务器在发送到客户机时指定.ps文件作为纯文本（text/plain）而不是作为PostScript（application/postscript）。
<mime-mapping>
<extension>ps</extension>
<mime-type>application/postscript</mime-type>
</mime-mapping>


13 定位TLD

JSP taglib元素具有一个必要的uri属性，它给出一个TLD（Tag Library Descriptor）文件相对于Web应用的根的位置。TLD文件的实际名称在发布新的标签库版本时可能会改变，但我们希望避免更改所有现有JSP页面。此外，可能还希望使用保持taglib元素的简练性的一个简短的uri。这就是部署描述符文件的taglib元素派用场的所在了。Taglib包含两个子元素：taglib-uri和taglib-location。taglib-uri元素应该与用于JSP taglib元素的uri属性的东西相匹配。Taglib-location元素给出TLD文件的实际位置。例如，假如你将文件chart-tags-1.3beta.tld放在WebApp/WEB-INF/tlds中。现在，假如web.xml在web-app元素内包含下列内容。
<taglib>
<taglib-uri>/charts.tld</taglib-uri>
<taglib-location>
/WEB-INF/tlds/chart-tags-1.3beta.tld
</taglib-location>
</taglib>
给出这个说明后，JSP页面可通过下面的简化形式使用标签库。
<%@ taglib uri="/charts.tld" prefix="somePrefix" %>

14 指定应用事件监听程序

应用事件监听器程序是建立或修改servlet环境或会话对象时通知的类。它们是servlet规范的版本2.3中的新内容。这里只简单地说明用来向Web应用注册一个监听程序的web.xml的用法。
注册一个监听程序涉及在web.xml的web-app元素内放置一个listener元素。在listener元素内，listener-class元素列出监听程序的完整的限定类名，如下所示：
<listener>
<listener-class>package.ListenerClass</listener-class>
</listener>
虽然listener元素的结构很简单，但请不要忘记，必须正确地给出web-app元素内的子元素的次序。listener元素位于所有的servlet元素之前以及所有filter-mapping元素之后。此外，因为应用生存期监听程序是serlvet规范的2.3版本中的新内容，所以必须使用web.xml DTD的2.3版本，而不是2.2版本。
例如，程序清单5-20给出一个名为ContextReporter的简单的监听程序，只要Web应用的Servlet-Context建立（如装载Web应用）或消除（如服务器关闭）时，它就在标准输出上显示一条消息。程序清单5-21给出此监听程序注册所需要的web.xml文件的一部分。

程序清单5-20 ContextReporterjava
package moreservlets;

import javax.servlet.*;
import java.util.*;

/** Simple listener that prints a report on the standard output
* when the ServletContext is created or destroyed.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* &copy; 2002 Marty Hall; may be freely used or adapted.
*/

public class ContextReporter implements ServletContextListener {
public void contextInitialized(ServletContextEvent event) {
System.out.println("Context created on " +
new Date() + ".");
}

public void contextDestroyed(ServletContextEvent event) {
System.out.println("Context destroyed on " +
new Date() + ".");
}
}

程序清单5-21 web.xml（声明一个监听程序的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<filter-mapping> … </filter-mapping>
<listener>
<listener-class>package.ListenerClass</listener-class>
</listener>
<servlet> ... </servlet>
<!-- ... -->
</web-app>

15 J2EE元素

本节描述用作J2EE环境组成部分的Web应用的web.xml元素。这里将提供一个简明的介绍，详细内容可以参阅http://java.sun.com/j2ee/j2ee-1_3-fr-spec.pdf的Java 2 Plantform Enterprise Edition版本1.3规范的第5章。
l distributable
distributable元素指出，Web应用是以这样的方式编程的：即，支持集群的服务器可安全地在多个服务器上分布Web应用。例如，一个可分布的应用必须只使用Serializable对象作为其HttpSession对象的属性，而且必须避免用实例变量（字段）来实现持续性。distributable元素直接出现在discription元素之后，并且不包含子元素或数据，它只是一个如下的标志。
<distributable />
l resource-env-ref
resource-env-ref元素声明一个与某个资源有关的管理对象。此元素由一个可选的description元素、一个resource-env-ref-name元素（一个相对于java:comp/env环境的JNDI名）以及一个resource-env-type元素（指定资源类型的完全限定的类），如下所示：
<resource-env-ref>
<resource-env-ref-name>
jms/StockQueue
</resource-env-ref-name>
<resource-env-ref-type>
javax.jms.Queue
</resource-env-ref-type>
</resource-env-ref>
l env-entry
env-entry元素声明Web应用的环境项。它由一个可选的description元素、一个env-entry-name元素（一个相对于java:comp/env环境JNDI名）、一个env-entry-value元素（项值）以及一个env-entry-type元素（java.lang程序包中一个类型的完全限定类名，java.lang.Boolean、java.lang.String等）组成。下面是一个例子：
<env-entry>
<env-entry-name>minAmout</env-entry-name>
<env-entry-value>100.00</env-entry-value>
<env-entry-type>minAmout</env-entry-type>
</env-entry>
l ejb-ref
ejb-ref元素声明对一个EJB的主目录的应用。它由一个可选的description元素、一个ejb-ref-name元素（相对于java:comp/env的EJB应用）、一个ejb-ref-type元素（bean的类型，Entity或Session）、一个home元素（bean的主目录接口的完全限定名）、一个remote元素（bean的远程接口的完全限定名）以及一个可选的ejb-link元素（当前bean链接的另一个bean的名称）组成。
l ejb-local-ref
ejb-local-ref元素声明一个EJB的本地主目录的引用。除了用local-home代替home外，此元素具有与ejb-ref元素相同的属性并以相同的方式使用。

function bodydisabled()
{
 var b = document.getElementsByTagName('body');
 b[0].setAttribute('disabled','true');
}
function isInt(s)  //整数输入判断
{
   if (s.value == "") return true;
   var chk=parseInt(s.value,10);
   if(chk!=s.value || chk<0)
     {
       alert("该字段应是正整数！");
       s.focus();
       return false;
      }
   return true;
}

function isFloat(s)  //浮点数输入判断
{
  if (s.value == "") return true;
   var chk=parseFloat(s.value);
   if(chk!=s.value)
     {
   alert("该字段应是整数或小数！");
      s.focus();
      return false;
      }
   return true;
}

function isDate(obj) //时间输入判断
{
 var m,str,exp,d;
 str=trim(obj.value);
 if(str=="") return true;
 str=str.replace(/-0/g,"-");
 exp=/\d{4}-\d{1,2}-\d{1,2}/;
 if(str.match(exp)!=null)
    {
        m=str.split("-");
  d=new Date(Date.parse(m[1]+'-'+m[2]+'-'+m[0]));
  if(d>=new Date(1800,1,1) && d<=new Date(2070,6,6) && d.getFullYear()==parseInt(m[0]) && (d.getMonth()+1)==parseInt(m[1]) && d.getDate()==parseInt(m[2]))
  {
            return true;
  }
    }
 alert("该字段应是正确的日期值：YYYY-MM-DD！\n 例如 2005年1月5日 输入为: 2005-01-05");
 obj.focus();
    return false;
}

// 下面代码屏蔽右键

if (window.Event)
  document.captureEvents(Event.MOUSEUP);
 
function nocontextmenu()
{
 event.cancelBubble = true
 event.returnValue = false;
 
 return false;
}
 
function norightclick(e)
{
 if (window.Event)
 {
  if (e.which == 2 || e.which == 3)
   return false;
 }
 else
  if (event.button == 2 || event.button == 3)
  {
   event.cancelBubble = true
   event.returnValue = false;
   return false;
  }
 
}
document.oncontextmenu = nocontextmenu;  // for IE5+
document.onmousedown = norightclick;  // for all others

//屏蔽其它键
function documentonkeydown()
{

  if (event.ctrlKey && event.keyCode==78)  //屏蔽 Ctrl+n
  {  
     event.returnValue=false;  
   }
  if (event.keyCode==116)                  //屏蔽 F5 刷新键
  {
     event.keyCode=0;
     event.returnValue=false;
  }
  if (event.keyCode==122)                  //屏蔽 F11
  {
     event.keyCode=0;
     event.returnValue=false;
  }
 
  if ((event.keyCode == 8) &&
      (event.srcElement.type != "text" &&
      event.srcElement.type != "textarea" &&
      event.srcElement.type != "password") ||           //屏蔽退格删除键  
      (event.keyCode==116)||                            //屏蔽 F5 刷新键
      (event.ctrlKey && event.keyCode==82)){            //Ctrl + R
     event.keyCode=0;
     event.returnvalue=false;
  }

  if ((event.altKey) && ((event.keyCode==37)||  //屏蔽 Alt+ 方向键 ←
       (event.keyCode==39)))   //屏蔽 Alt+ 方向键 →
  { 
     event.keyCode=0;
    
     alert("禁止使用ALT+方向键前进或后退网页");
     event.returnValue=false;
     event.cancelBubble = false;
  }
  if ((event.shiftKey) && (event.keyCode==121))   //屏蔽 shift+F10
  {
     event.keyCode=0;
     event.returnValue=false;
  }

  if (window.event.srcElement.tagName == "A" && window.event.shiftKey)
      event.keyCode=0;
      window.event.returnvalue = false;  //屏蔽 shift 加鼠标左键新开一网页 
}