[文章导读]

在本文中，我用详细的语言和大量的图片及完整的程序源码向你展示了在 JAVA中如何实现生成数字证书

[正文]

摘要：

　　在本文中，我用详细的语言和大量的图片及完 整的程序源码向你展示了在 JAVA中如何实现通过消息摘要、消息验证码达到安全通信、以及用Java的工具生成数字证书，和用程序给数字证书签名、以及用签名后的数学证书签名 applet突破applet的访问权限的过程，给出了全部例子的详细代码。

　　通过本文中你可以学到以下知识：

　　 ● 程序间如何安全通信

　　 ● 什么是 及 如何生成消息摘要

　　 ● 什么是 及 如何生成消息验证码

　　 ● 如何使用 Java工具生成和维护数字证书库

　　 ● 如何用程序给数字证书验证签名

　　 ● 如何利用数字证书给 applet签名突破applet的访问权限

　　关键字：

　　消息摘要、消息验证码、指纹、加密、安全、 Java、数字签名、applet、数字证书

　　一、基础知识

　　计算机安全通信过程中，常使用消息摘要和消息验证码来保证传输的数据未曾被第三方修改。

　 　消息摘要是对原始数据按照一定算法进行计算得到的结果，它主要检测原始数据是否被修改过。消息摘要与加密不同，加密是对原始数据进行变换，可以从变换后 的数据中获得原始数据，而消息摘要是从原始数据中获得一部分信息，它比原始数据少得多，因此消息摘要可以看作是原始数据的指纹。

　　例：下面一段程序计算一段字符串的消息摘要

The Microsoft XML Parser

To create an XML Document object with JavaScript, use the following code:

var xmlDoc=new ActiveXObject("Microsoft.XMLDOM")

xmlDoc.appendChild(xmlDoc.createElement("root"))

XML Parser in Mozilla Browsers

Plain XML documents are displayed in a tree-like structure in Mozilla (just like IE).

Mozilla also supports parsing of XML data that resides in a file, using JavaScript. The parsed data can be displayed as HTML.

To create an XML Document object with JavaScript in Mozilla, use the following code:

var xmlDoc=document.implementation.createDocument("ns","root",null)

The first parameter, ns, defines the namespace used for the XML document. The second parameter, root, is the XML root element in the XML file. The third parameter, null, is always null because it is not implemented yet.

Loading an XML File Into the Parser

The following code loads an existing XML document ("note.xml") into the XML parser:

<script type="text/javascript"> var xmlDoc=new ActiveXObject("Microsoft.XMLDOM") xmlDoc.async="false" xmlDoc.load("note.xml") ... ... ... </script>//ie和firefox都支持load,firefox不支持loadXML(string text)

The first line of the script creates an instance of the Microsoft XML parser. The third line tells the parser to load an XML document called "note.xml". The second line turns off asynchronized loading, to make sure that the parser will not continue execution of the script before the document is fully loaded.

Accessing XML Elements by Name

Addressing elements by number is NOT the preferred way to extract elements from XML documents. Using names is a better way:

<script type="text/javascript"> function loadXML() { var xmlDoc=new ActiveXObject("Microsoft.XMLDOM") xmlDoc.async="false" xmlDoc.load("note.xml")//注意firefox的load("note.xml")并不会读该文件,须要给fox增加loadXML()涵数 xmlDoc.getElementsByTagName("to").item(0).text xmlDoc.getElementsByTagName("from").item(0).text xmlDoc.getElementsByTagName("heading").item(0).text xmlDoc.getElementsByTagName("body").item(0).text } </script>

Important: To extract the text (Jani) from an element like this: <from>Jani</from>, the syntax is: getElementsByTagName("from").item(0).text, and NOT like this: getElementsByTagName("from").text. The reason for this is that the result returned from getElementsByTagName is an array of nodes, containing all nodes found within the XML document with the specified tag name (in this case "from").

The XMLHttpRequest object is supported in Internet Explorer 5.0+, Safari 1.2, Mozilla 1.0 / Firefox, and Netscape 7.

What is an HTTP Request?

With an HTTP request, a web page can make a request to, and get a response from a web server - without reloading the page. The user will stay on the same page, and he or she will not notice that scripts might request pages, or send data to a server in the background.

By using the XMLHttpRequest object, a web developer can change a page with data from the server after the page has loaded.

Google Suggest is using the XMLHttpRequest object to create a very dynamic web interface: When you start typing in Google's search box, a JavaScript sends the letters off to a server and the server returns a list of suggestions.

Creating an XMLHttpRequest Object

For Mozilla, Firefox, Safari, and Netscape:

var xmlhttp=new XMLHttpRequest()

For Internet Explorer:

var xmlhttp=new ActiveXObject("Microsoft.XMLHTTP")

Example

<script type="text/javascript"> var xmlhttp function loadXMLDoc(url) { // code for Mozilla, etc. if (window.XMLHttpRequest) { xmlhttp=new XMLHttpRequest() xmlhttp.onreadystatechange=xmlhttpChange xmlhttp.open("GET",url,true) xmlhttp.send(null) } // code for IE else if (window.ActiveXObject) { xmlhttp=new ActiveXObject("Microsoft.XMLHTTP") if (xmlhttp) { xmlhttp.onreadystatechange=xmlhttpChange xmlhttp.open("GET",url,true) xmlhttp.send() } } } function xmlhttpChange() { // if xmlhttp shows "loaded" if (xmlhttp.readyState==4) { // if "OK" if (xmlhttp.status==200) { // ...some code here... } else { alert("Problem retrieving XML data") } } } </script>

Why are we Using async in our Examples?

Most of the examples here use the async mode (the third parameter of open() set to true).

The async parameter specifies whether the request should be handled asynchronously or not. True means that script continues to run after the send() method, without waiting for a response from the server. false means that the script waits for a response before continuing script processing. By setting this parameter to false, you run the risk of having your script hang if there is a network or server problem, or if the request is long (the UI locks while the request is being made) a user may even see the "Not Responding" message. It is safer to send asynchronously and design your code around the onreadystatechange event

The XMLHttpRequest Object Reference

Methods

Method	Description
abort()	Cancels the current request
getAllResponseHeaders()	Returns the complete set of http headers as a string
getResponseHeader("headername")	Returns the value of the specified http header
open("method","URL",async,"uname","pswd")	Specifies the method, URL, and other optional attributes of a request The method parameter can have a value of "GET", "POST", or "PUT" (use "GET" when requesting data and use "POST" when sending data (especially if the length of the data is greater than 512 bytes. The URL parameter may be either a relative or complete URL. The async parameter specifies whether the request should be handled asynchronously or not. true means that script processing carries on after the send() method, without waiting for a response. false means that the script waits for a response before continuing script processing
send(content)	Sends the request
setRequestHeader("label","value")	Adds a label/value pair to the http header to be sent

Properties

Property	Description
onreadystatechange	An event handler for an event that fires at every state change
readyState	Returns the state of the object: 0 = uninitialized 1 = loading 2 = loaded 3 = interactive 4 = complete
responseText	Returns the response as a string
responseXML	Returns the response as XML. This property returns an XML document object, which can be examined and parsed using W3C DOM node tree methods and properties
status	Returns the status as a number (e.g. 404 for "Not Found" or 200 for "OK")
statusText	Returns the status as a string (e.g. "Not Found" or "OK")

XML DOM Node Types

The DOM Structure

The DOM presents a document as a hierarchy of node objects.

The following table lists the different W3C node types, and which node types they may have as children:

Node type	Description	Children
Document	Represents the entire document (it is the root-node of the DOM tree)	Element (max. one), ProcessingInstruction, Comment, DocumentType
DocumentFragment	Represents a "lightweight" Document object, which can hold a portion of a document	Element, ProcessingInstruction, Comment, Text, CDATASection, EntityReference
DocumentType	Represents a list of the entities that are defined for the document	None
EntityReference	Represents an entity reference	Element, ProcessingInstruction, Comment, Text, CDATASection, EntityReference
Element	Represents an element	Element, Text, Comment, ProcessingInstruction, CDATASection, EntityReference
Attr	Represents an attribute	Text, EntityReference
ProcessingInstruction	Represents a "processing instruction"	None
Comment	Represents a comment	None
Text	Represents textual content (character data) in an element or attribute	None
CDATASection	Represents a block of text that may contains characters that would otherwise be treated as markup	None
Entity	Represents an entity	Element, ProcessingInstruction, Comment, Text, CDATASection, EntityReference
Notation	Represents a notation declared in the DTD	None

Node Types - Return Values

Below is a list of what the nodeName and the nodeValue properties will return for each nodetype:

Node type	nodeName returns	nodeValue returns
Document	#document	null
DocumentFragment	#document fragment	null
DocumentType	doctype name	null
EntityReference	entity reference name	null
Element	element name	null
Attr	attribute name	attribute value
ProcessingInstruction	target	content of node
Comment	#comment	comment text
Text	#text	content of node
CDATASection	#cdata-section	content of node
Entity	entity name	null
Notation	notation name	null

NodeTypes - Named Constants

NodeType	Named Constant
1	ELEMENT_NODE
2	ATTRIBUTE_NODE
3	TEXT_NODE
4	CDATA_SECTION_NODE
5	ENTITY_REFERENCE_NODE
6	ENTITY_NODE
7	PROCESSING_INSTRUCTION_NODE
8	COMMENT_NODE
9	DOCUMENT_NODE
10	DOCUMENT_TYPE_NODE
11	DOCUMENT_FRAGMENT_NODE
12	NOTATION_NODE

XML DOM - The Attr Object

The Attr object

The attr object represents an attribute of an element object.

The attr object's properties and methods are described below:

Properties

Property	Description
attributes	Returns a NamedNodeMap that contains all attributes of a node
childNodes	Returns a node list that contains all children of a node
firstChild	Returns the first child node of a node
lastChild	Returns the last child node of a node
name	Returns the name of the attribute
nextSibling	Returns the node immediately following a node. Two nodes are siblings if they have the same parent node
nodeName	Returns the name of the node (depending on the node type)
nodeType	Returns the node type as a number
nodeValue	Returns the value of the node
ownerDocument	Returns the Document object of a node (returns the root node of the document)
parentNode	Returns the parent node of a node
previousSibling	Returns the node immediately preceding a node. Two nodes are siblings if they have the same parent node
value	Returns the value of the attribute

Methods

The CDATASection  comment object

The CDATASection object represents CDATASection nodes in a document. A CDATASection node is used to escape parts of text which normally would be recognized as markup.

The CDATASection object's properties and methods are described below:

Properties

Methods

The Document object

The document object is the root element in the node-tree. All nodes in the node tree are child nodes of the document object.

The document object's properties, methods, and events are described below:

Properties

Methods

The Element object

The element object represents the element nodes in the document. If the element node contains text, this text is represented in a text node.

The element object's properties and methods are described below:

Properties

Methods

The Node Object

The node object represents a node in the node-tree.

The node object's properties and methods are described below:

Properties

Methods

The NodeList object

The nodeList object represents a node and its child nodes as a node-tree.

The nodeList object's properties and methods are described below:

Properties

Methods

The Text object

The text object represents the text of an attribute or element object.

The text object's properties and methods are described below:

Properties

Methods

1.buildhtml.jsp

<%@ page contentType="text/html; charset=gb2312" import="java.util.*,java.io.*"%>
<%
try{
 String title="jsp生成静态html文件";
 String content="小样，还搞不定你？";
 String editer="hpsoft";
 String filePath = "";
 filePath = getServletContext().getRealPath("/")+"template.htm";
 out.print(filePath);
 String templateContent="";
 FileInputStream fileinputstream = new FileInputStream(filePath);//读取模块文件
 int lenght = fileinputstream.available();
 byte bytes[] = new byte[lenght];
 fileinputstream.read(bytes);
 fileinputstream.close();
 templateContent = new String(bytes);
 out.print(templateContent);
 templateContent=templateContent.replaceAll("###title###",title);
 templateContent=templateContent.replaceAll("###content###",content);
 templateContent=templateContent.replaceAll("###author###",editer);//替换掉模块中相应的地方
 out.print(templateContent);
 // 根据时间得文件名
 Calendar calendar = Calendar.getInstance();
 String fileame = String.valueOf(calendar.getTimeInMillis()) +".html";
 fileame = getServletContext().getRealPath("/")+fileame;//生成的html文件保存路径
 FileOutputStream fileoutputstream = new FileOutputStream(fileame);//建立文件输出流
 byte tag_bytes[] = templateContent.getBytes();
 fileoutputstream.write(tag_bytes);
 fileoutputstream.close();
}
catch(Exception e){
 out.print(e.toString());
}

%>

模板文件

2. template.htm

<html>
<head>
<title>###title###</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<LINK href="../css.css" rel=stylesheet type=text/css>
</head>

<body>
<table width="500" border="0" align="center" cellpadding="0" cellspacing="2">
  <tr>
    <td align="center">###title###</td>
  </tr>
  <tr>
    <td align="center">作者：###author###&nbsp;&nbsp;</td>
  </tr>
  <tr>
    <td>###content###
 </td>
 
  </tr>

</table>
</body>
</html>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/tr/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<style>
html {background-color:#eeeeee}
body {
      background-color:#ccffcc;
      font-family:Tahoma,Arial,Helvetica,sans-serif;
      font-size:12px;
   margin-left:15%;
   margin-right:15%;
   border:3px groove #006600;
   padding:15px
  }
h1   {
      text-align:left;
      font-size:1.5em;
      font-weight:bold
     }
</style>
<script type="text/javascript">
// global flag
var isIE = false;

// global request and XML document objects
var req;

// retrieve XML document (reusable generic function);
// parameter is URL string (relative or complete) to
// an .xml file whose Content-Type is a valid XML
// type, such as text/xml; XML source must be from
// same domain as HTML file
function loadXMLDoc(url) {
    // branch for native XMLHttpRequest object
    if (window.XMLHttpRequest) {
        req = new XMLHttpRequest();
        req.onreadystatechange = processReqChange;
        req.open("GET", url, true);
        req.send(null);
    // branch for IE/Windows ActiveX version
    } else if (window.ActiveXObject) {
        isIE = true;
        req = new ActiveXObject("Microsoft.XMLHTTP");
        if (req) {
            req.onreadystatechange = processReqChange;
            req.open("GET", url, true);
            req.send();
        }
    }
}

// handle onreadystatechange event of req object
function processReqChange() {
    // only if req shows "loaded"
    if (req.readyState == 4) {
        // only if "OK"
        if (req.status == 200) {
            clearTopicList();
            buildTopicList();
         } else {
            alert("There was a problem retrieving the XML data:\n" +
                req.statusText);
         }
    }
}

// invoked by "Category" select element change;
// loads chosen XML document, clears Topics select
// element, loads new items into Topics select element
function loadDoc(evt) {
    // equalize W3C/IE event models to get event object
    evt = (evt) ? evt : ((window.event) ? window.event : null);
    if (evt) {
        // equalize W3C/IE models to get event target reference
        var elem = (evt.target) ? evt.target : ((evt.srcElement) ? evt.srcElement : null);
        if (elem) {
            try {
                if (elem.selectedIndex > 0) {
                    loadXMLDoc(elem.options[elem.selectedIndex].value);
                } 
            }
            catch(e) {
                var msg = (typeof e == "string") ? e : ((e.message) ? e.message : "Unknown Error");
                alert("Unable to get XML data:\n" + msg);
                return;
            }
        }
    }
}

// retrieve text of an XML document element, including
// elements using namespaces
function getElementTextNS(prefix, local, parentElem, index) {
    var result = "";
    if (prefix && isIE) {
        // IE/Windows way of handling namespaces
        result = parentElem.getElementsByTagName(prefix + ":" + local)[index];
    } else {
        // the namespace versions of this method
        // (getElementsByTagNameNS()) operate
        // differently in Safari and Mozilla, but both
        // return value with just local name, provided
        // there aren't conflicts with non-namespace element
        // names
        result = parentElem.getElementsByTagName(local)[index];
    }
    if (result) {
        // get text, accounting for possible
        // whitespace (carriage return) text nodes
        if (result.childNodes.length > 1) {
            return result.childNodes[1].nodeValue;
        } else {
            return result.firstChild.nodeValue;      
        }
    } else {
        return "n/a";
    }
}

// empty Topics select list content
function clearTopicList() {
    var select = document.getElementById("topics");
    while (select.length > 0) {
        select.remove(0);
    }
}

// add item to select element the less
// elegant, but compatible way.
function appendToSelect(select, value, content) {
    var opt;
    opt = document.createElement("option");
    opt.value = value;
    opt.appendChild(content);
    select.appendChild(opt);
}

// fill Topics select list with items from
// the current XML document
function buildTopicList() {
    var select = document.getElementById("topics");
    var items = req.responseXML.getElementsByTagName("item");
    // loop through <item> elements, and add each nested
    // <title> element to Topics select element
    for (var i = 0; i < items.length; i++) {
        appendToSelect(select, i,
            document.createTextNode(getElementTextNS("", "title", items[i], 0)));
    }
    // clear detail display
    document.getElementById("details").innerHTML = "";
}

// display details retrieved from XML document
function showDetail(evt) {
    evt = (evt) ? evt : ((window.event) ? window.event : null);
    var item, content, div;
    if (evt) {
        var select = (evt.target) ? evt.target : ((evt.srcElement) ? evt.srcElement : null);
        if (select && select.options.length > 1) {
            // copy <content:encoded> element text for
            // the selected item
            item = req.responseXML.getElementsByTagName("item")[select.value];
            content = getElementTextNS("content", "encoded", item, 0);
            div = document.getElementById("details");
            div.innerHTML = "";
            // blast new HTML content into "details" <div>
            div.innerHTML = content;
        }
    }
}
</script>
</head>
<body>
<h1>XMLHttpRequest Object Demo</h1>
<hr />

<form>
<p>Category:<br />
<select onchange="loadDoc(event)">
    <option value="">Choose One</option>
    <option value="songs.xml">Top 10 Songs</option>
    <option value="albums.xml">Top 10 Albums</option>
    <option value="newreleases.xml">Top 10 New Releases</option>
    <option value="justadded.xml">Top 10 Just Added</option>
</select>
</p>
<p>Items:<br />
<select size="10" id="topics" onchange="showDetail(event)">
    <option value="">Choose a Category First</option>
</select>
</p>
</form>
<div id="details"><span></span></div>
</body>
<html>

（有关xsl应用的其他信息，请参阅用xsl作为模板语言。） 

在java中创建xml文档字符串的xml工具类:  

tomcat下数据源的配置、解释和调用方法

[所在目录]首页>分类目录>电脑与网络>互联网络：
http://www.3yee.com/articles/449.aspx
来自：Java学习 jargon - 2004-4-27 23:36:00

tomcat的数据库连接池的配置
环境：
1. 数据库：mysql
2. 数据库驱动程序：org.gjt.mm.mysql.Driver
JNDI（Java Naming and Directory Interface）概述：
Tomcat4 （5）提供了一个与Java Enterprise Edition应用服务相兼容的JNDI--InitialContext实现实例。它的初始数据设置在$ CATALINA_HOME/conf/server.xml文件里，并可能在网页应用环境描述（/WEB-INF/web.xml）里被下列元素引用：
1) <env-entry>--环境入口，设置应用程序如何操作。
2) <resource-ref>--资源参数，一般是数据库驱动程序、JavaMail Session、自定义类工厂等。
3) <resource-env-ref>--在Servlet 2.4里用来简化设置不需认证信息的资源资源如环境参数、resource-ref变量。
InitialContext在网页应用程序初始化时被设置，用来支持网页应用程序组件。所有的入口和资源都放在JNDI命名空间里的java:comp/env段里。点击下列网址以获取更多信息：
1) Java命名和目录接口（Java Naming and Directory Interface）
2) J2EE平台说明（J2EE Platform Specification）
设置JNDI资源
设置JNDI资源要在$CATALINA_HOME/conf/server.xml文件里使用下列标志符：
1) <Environment>--设置域个可变的JNDI InitialContext入口的名字和值（同上面说的<env-entry>等价）。
2) <Resource>--设置应用程序可用的资源的名字和类型（同上面说的<resource-ref>等价）。
3) <ResourceParams>--设置Java资源类工厂的名称或将用的JavaBean属性。
4) <ResourceLink>--给全局JNDI环境（JNDI Context）添加一个链接。
上述这些标志符必须放在<Context>和</Context>之间（针对专门的网页应用程序）或<DefaultContext>和</DefaultContext>之间。
此外，设在网页应用环境描述（Web Application Descriptor）（/WEB-INF/web.xml）里的名字和值也在初始环境（Initial Context）里被设置，当被<Environemt>元素值允许时将被重设初始值。
全局变量能在<Server>子元素的<GlobalNamingResources>里设置。
数据库连接池概述：
数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。
数 据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接 池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接 数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：
1) 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；
2) 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。
3) 如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。
配置Tomcat数据库连接池的前提：
1. 必须装有Java运行环境；
2. mysql；
在$CATALINA_HOME/conf/server.xml里设置数据库连接池：
下面是配置的代码，必须放在<Host>和</Host>之间。
<Context path="/test" docBase="test" debug="0" reloadable="true" crossContext="true">
<Resource name="jdbc/connectDB" auth="Container" type="javax.sql.DataSource"/>
<ResourceParams name="jdbc/connectDB">
 <parameter>
  <name>maxActive</name>
  <!-- Maximum number of DB connections in pool.Set to 0 for no limit. -->
  <value>100</value>
 </parameter>
 <parameter>
  <name>maxIdle</name>
  <!-- Maximum number of idle DB connections to retain in pool.Set to 0 for no limit. -->
  <value>30</value>
 </parameter>
 <parameter>
  <name>maxWait</name>
  <!-- Maximum time to wait for a DB connection to become available in ms.An exception is thrown if this timeout is exceeded.Set to -1 to wait indefinitely. -->
  <value>10000</value>
 </parameter>
 <parameter>
  <name>removeAbandoned</name>
  <!-- Abandoned DB connections are removed and recycled -->
  <value>true</value>
 </parameter>
 <parameter>
  <name>removeAbandonedTimeout</name>
  <!-- Use the removeAbandonedTimeout parameter to set the number of seconds a DB connection has been idle before it is considered abandoned.  -->
  <value>60</value>
 </parameter>
 <parameter>
  <name>logAbandoned</name>
  <!-- Log a stack trace of the code which abandoned -->
  <value>false</value>
 </parameter>
 <parameter>
  <name>factory</name>
  <!-DBCP Basic Datasource Factory -->
  <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
 </parameter>
 <parameter>
  <name>username</name>
  <!-- Database User Name -->
  <value>root</value>
 </parameter>
 <parameter>
  <name>password</name>
  <!-- User Password -->
  <value></value>
 </parameter>
 <parameter>
  <name>driverClassName</name>
  <!-- Database Driver Class Name -->
  <value>org.gjt.mm.mysql.Driver</value>
 </parameter>
 <parameter>
  <name>url</name>
  <!-- Database Address -->
  <value>jdbc:mysql://localhost/test?user=root&password=abcd1001&useUnicode=true&characterEncoding=8859_1</value>
 </parameter>
</ResourceParams>
</Context>
下面是一些参数的说明：
<Context path="/test" docBase="test" debug="0" reloadable="true" crossContext="true">
其中：
1) path  指定路径，这里设定的是$CATALINA_HOME/webapps下的test目录；
2) docBase 文件根目录。
3) reloader  当网页被更新时是否重新编译。
4) maxActive 连接池的最大数据库连接数。设为0表示无限制。
5) maxIdle  数据库连接的最大空闲时间。超过此空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。
6) maxWait 最大建立连接等待时间。如果超过此时间将接到异常。设为－1表示无限制。
7) removeAbandoned 回收被遗弃的（一般是忘了释放的）数据库连接到连接池中。
8) removeAbandonedTimeout 数据库连接过多长时间不用将被视为被遗弃而收回连接池中。
9) logAbandoned 将被遗弃的数据库连接的回收记入日志。
10) driverClassName JDBC驱动程序。
11) url   数据库连接字符串
在$CATALINA_HOME/webapps/test/WEB-INF/web.xml里设置被引用的资源：
下面是配置代码，必须放在<web-app>和</web-app>里。
<!-- Database Config start -->
<resource-ref>
<description>connectDB test</description>
<res-ref-name>jdbc/connectDB</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
<!-- Database Config end -->
下面是一下参数的必要说明：
1) description  对被引用的资源的描述。
2) res-ref-name  资源名称。见上面的<ResourceParams name="jdbc/connectDB">
3) res-type  资源类型。见上面的<Resource name="jdbc/connectDB" auth="Container" type="javax.sql.DataSource"/>
为了方便做解释直接在JSP中使用资源：
这是在$CATALINA_HOME/webapps/test下的某级子目录里的jsp网页文件部分代码：
<%@ page contentType="text/html;charset=GBK"%>
<%@ page errorPage="error.jsp"%>
<%@ page import="javax.naming.*"%>
<%@ page import="javax.sql.*"%>
<%@ page import="java.sql.*"%>
<html>
 <head>
 </head>
 <body>
  <%

   ………………
   ………………

   // 数据库操作
   Context ctx=null;
   Connection cnn=null;
   Statement stmt=null;
   ResultSet rs=null;
   try
   {
    ctx=new InitialContext();
    if(ctx==null)
     throw new Exception("没有匹配的环境");
    DataSource ds=(DataSource)ctx.lookup("java:comp/env/jdbc/connectDB");
    if(ds==null)
     throw new Exception("没有匹配数据库");
   
    cnn=ds.getConnection();
    stmt=cnn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
    rs=stmt.executeQuery("select * from table1");

    ………………
    ………………

   }
   finally
   {
    if(rs!=null)
     rs.close();
    if(stmt!=null)
     stmt.close();
    if(cnn!=null)
     cnn.close();
    if(ctx!=null)
     ctx.close();
   }
    %>
 </body>
</html>
代码说明：
DataSource ds=(DataSource)ctx.lookup("java:comp/env/jdbc/connectDB");
上面这句应用了刚才设的资源。
资 源使用完要释放，尤其是Context资源，见try-catch-finally部分的finally代码段，这是一种好的习惯。资源释放时如果释放了 上级资源，下级资源将先被释放。如：释放了ctx，那么资源释放顺序将是rs，stmt，cnn，ctx。换句话说，如果释放了ctx，那么rs， stmt和cnn都将不可用了。
这里的释放资源只是将数据库连接返回连接池中，并不是把资源真正释放掉，见数据库连接池概述。