JNDI（Java 命名和目錄介面）
分散式計算環境通常使用命名和目錄服務來獲取共享的元件和資源。命名和目錄服務將名稱與位置、服務、資訊和資源關聯起來。 
命名服務提供名稱—物件的對映。目錄服務提供有關物件的資訊，並提供定位這些物件所需的搜尋工具。有許多命名和目錄服務實現，並且到它們的介面是不同的。

Java 命名和目錄介面或 JNDI 提供了一個用於訪問不同的命名和目錄服務的公共介面。請參閱 URL java.sun.com/products/jndi/serviceproviders.html 以獲取支援通過 JNDI 介面訪問命名和目錄服務的供應商列表。 

JNDI（Java Naming and Directory Interface）
當你在開發企業beans時，JNDI很重要，因為對一個EJB的訪問是通過JNDI的命名服務完成的。運用一個命名服務來查詢與一個特定名字相關的一個物件。在EJB context中，一個命名服務找到一個企業bean，給定這個bean的名字。因此，瞭解JNDI在開發一個EJB應用程式中是至關重要的。另外，JDBC可以用JNDI來訪問一個關係資料庫。




附：The JNDI Tutorial
http://java.sun.com/products/jndi/tutorial/index.html
(下載)
http://java.sun.com/products/jndi/docs.html#TUTORIAL



JDBC2.0擴充套件API(1) 

[ 作者: 不詳   新增時間: 2001-8-24 14:11:50 ]
 

來源：www.csdn.net

   JDBC 2.0 API被劃分為兩部分：JDBC 2.0核心API和JDBC 2.0標準擴充套件API。核心API在java.sql裡面。這是原來的版本就實現了的基本的功能。標準擴充套件API在javax.sql裡面。由JDBC2.0規範新規定的一些介面在這裡面。當然，JDBC2.0也對原來版本的java.sql核心做了一些改動。不過不是很大。原來JDBC1.0的程式可以不加修改的在JDBC2.0上執行。這是Java的一貫的良好的作風。最新的JDBC包可以從sun公司的網站上下載。 
　　JDBC2.0的擴充套件API增加了一些資料訪問和資料來源訪問的重大的功能。這中間有一些是主要用來做企業計算的。用JDBC2.0的新的擴充套件包，JDBC提供了一個從JAVA2平臺的通用的資料訪問的方法。
　　首先，我們來看看JDBC標準擴充套件的API怎樣來和JDBC2.0結合在一起的。JDBC2.0包括兩個包：
　　1、 java.sql包，個包裡面是JDBC2.0的核心API。它包括了原來的JDBC API（JDBC 1.0版本），再加上一些新的2.0版本的API。這個包在Java 2 Platform SDK裡面有。
　　2、 javax.sql包，這裡面是JDBC2.0的標準擴充套件API。這個包是一個全新的，在Java 2 Platform SDK, Enterprise Edition裡面單獨提供。
　　JDBC2.0的核心API包括了JDBC1.0的API，並在此基礎上增加了一些功能，對某些效能做了增強。使java語言在資料庫計算的前端提供了統一的資料訪問方法，效率也得到了提高。
　　JDBC是向後相容的，JDBC1.0的程式可以不加修改的執行在JDBC2.0上。但是，假如程式中用到了JDBC2.0的新特性，就必須要執行在JDBC2.0版本上。
　　概括的來說，JDBC核心API的新特性在兩個方面做了工作。一個是支援一些新的功能，另一個就是支援SQL3的資料型別。
　　1、 在支援新功能方面：包括結果集可以向後滾動，批量的更新資料。另外，還提供了UNICODE字符集的字元流操作。
　　2、 在支援SQL3的資料型別方面：包括新的SQL3資料型別，增加了對永續性物件的存貯。
　　為了對資料的存取，操作更加方便，JDBC的新特性是應用程式的設計更容易了。例如：資料塊的操作能夠顯著的提高資料庫訪問的效能。新增加的BLOB, CLOB,和陣列介面能夠是應用程式操作大塊的資料型別，而不必客戶端在存貯之前進行其它的處理。這樣，就顯著的提高了記憶體的使用效率。
   下面我們來介紹JDBC2.0的標準擴充套件API。標準擴充套件API分為如下幾個方面：
　　1、 DataSource介面：和Java名字目錄服務（JNDI）一起工作的資料來源介面。它提供了對數 吹囊恢指玫牧臃椒ā?br>;　　2、 Connection pooling（連線池）：可以重複使用連線，而不是對每個請求都使用一個新的連線。
　　3、 Distrubute transaction（分散式的事務）：在一個事務中涉及到了多個數據庫伺服器。
　　4、 Rowsets：JavaBean元件包含了結果集，主要用來將資料傳給瘦客戶，或者提供一個可以滾動的結果集。
　　下面我們一個一個來介紹：
　　一、DataSource介面是一個更好的連線資料來源的方法：
　　JDBC1.0是原來是用DriverManager類來產生一個對資料來源的連線。JDBC2.0用一種替代的方法，使用DataSource的實現，程式碼變的更小巧精緻，也更容易控制。
　　一個DataSource物件代表了一個真正的資料來源。根據DataSource的實現方法，資料來源既可以是從關係資料庫，也電子表格，還可以是一個表格形式的檔案。當一個DataSource物件註冊到名字服務中，應用程式就可以通過名字服務獲得DataSource物件，並用它來產生一個與DataSource代表的資料來源之間的連線。
　　關於資料來源的資訊和如何來定位資料來源，例如資料庫伺服器的名字，在哪臺機器上，埠號等等，都包含在DataSource物件的屬性裡面去了。這樣，對應用程式的設計來說是更方便了，因為並不需要硬性的把驅動的名字寫死到程式裡面去。通常驅動名字中都包含了驅動提供商的名字，而在DriverManager類中通常是這麼做的。如果資料來源要移植到另一個數據庫驅動中，程式碼也很容易做修改。所需要做的修改只是更改DataSource的相關的屬性。而使用DataSource物件的程式碼不需要做任何改動。
　　由系統管理員或者有相應許可權的人來配置DataSource物件。配置DataSource，包括設定DataSource的屬性，然後將它註冊到JNDI名字服務中去。在註冊DataSource物件的的過程中，系統管理員需要把DataSource物件和一個邏輯名字關聯起來。名字可以是任意的，通常取成能代表資料來源並且容易記住的名字。在下面的例子中，名字起為：InventoryDB，按照慣例，邏輯名字通常都在jdbc的子上下文中。這樣，邏輯名字的全名就是：jdbc/ InventoryDB。
　　一旦配置好了資料來源物件，應用程式設計者就可以用它來產生一個與資料來源的連線。下面的程式碼片段示例瞭如何用JNDI上下文獲得一個一個數據源物件，然後如何用資料來源物件產生一個與資料來源的連線。開始的兩行用的是JNDI API，第三行用的才是JDBC的API：
　　 Context ctx = new InitialContext(); DataSource ds = (DataSource)ctx.lookup("jdbc/InventoryDB");Connection con = ds.getConnection("myPassword", "myUserName");
　　在一個基本的DataSource實現中，DataSource.getConnection方法返回的Connection物件和用DriverManager.getConnection方法返回的Connection物件是一樣的。因為DataSource提供的方便性，我們推薦使用DataSource物件來得到一個Connection物件。我們希望所以的基於JDBC2.0技術的資料庫驅動都包含一個基本的DataSource的實現，這樣就可以在應用程式中很容易的使用它。
　　對於普通的應用程式設計者，是否使用DataSource物件只是一個選擇問題。但是，對於那些需要用的連線池或者分散式的事務的應用程式設計者來說，就必須使用DataSource物件來獲得Connection，原因在下面我們會提到。
   二、Connection pooling（連線池）：
　　連線池是這麼一種機制，當應用程式關閉一個Connection的時候，這個連線被回收，而不是被destroy，因為建立一個連線是一個很費資源的操作。如果能把回收的連線重新利用，會減少新建立連線的數目，顯著的提高執行的效能。
　　假設應用程式需要建立到一個名字為EmpolyeeDB的DataSource的連線。使用連線池得到連線的程式碼如下：
　　 Context ctx = new InitialContext(); DataSource ds = (DataSource)ctx.lookup("jdbc/EmployeeDB");Connection con = ds.getConnection("myPassword", "myUserName");除了邏輯名字以外，我們發現其程式碼和上面舉的例子的程式碼是一樣的。邏輯名字不同，就可以連線到不同的資料庫。DataSource物件的getConnection方法返回的Connection是否是一個連線池中的連線完全取決於DataSource物件的實現方法。如果DataSource物件實現與一個支援連線池的中間層的伺服器一起工作，DataSource物件就會自動的返回連線池中的連線，這個連線也是可以重複利用的。
　　是否使用連線池獲得一個連線，在應用程式的程式碼上是看不出不同的。在使用這個Connection連線上也沒有什麼不一樣的地方，唯一的不同是在java的finally語句塊中來關閉一個連線。在finally中關閉連線是一個好的程式設計習慣。這樣，即使方法丟擲異常，Connection也會被關閉並回收到連線池中去。程式碼應該如下所示：
　　try{…
　　}catch（）{…
　　}finally{ if（con!=null）con.close();}
　　三、分散式事務：
　　獲得一個用來支援分散式事務的連線與獲得連線池中的連線是很相似的。同樣，不同之處在於DataSource的實現上的不同，而不是在應用程式中獲得連線的方式上有什麼不同。假設DataSource的實現可以與支援分散式事務中間層伺服器一起工作，得到連線的程式碼還是如下所示：
　　 Context ctx = new InitialContext(); DataSource ds = (DataSource)ctx.lookup("jdbc/EmployeeDB"); Connection con = ds.getConnection("myPassword", "myUserName");由於效能上的原因，如果一個DataSource能夠支援分散式的事務，它同樣也可以支援連線池管理。
　　從應用程式設計者的觀點來看。是否支援分散式的事務的連線對它來說沒什麼不同，唯一的不同是在事務的邊界上（開始一個事務的地方和結束一個事務的地方），開始一個事務或者結束一個事務都是由事務伺服器來控制的。應用程式不應該做任何可能妨礙服務的事情。應用程式不能夠直接呼叫事務提交commit或者回滾rollback操作，也不能夠使用事務的自動提交模式auto-commit mode（在資料庫操作完成的時候自動的呼叫commit或者rollback）。 
 
在一個連線參與了分散式事務的時候，下面的程式碼是你不能做的（con表示支援分散式事務的連線Connection）。
　　con.commit();或者con.rollback();或者con.setAutoCommit(true);對於通常的Connection來說，預設的是auto-commit模式。而對於支援分散式事務的Connection來說，預設不是auto-commit模式。注意，即使Connection是支援事務的，它也可以用於沒有事務的情況。關於事務邊界的限制只是是對分散式事務的情況下才成立的。
　　配置支援連線池的DataSource的時候，涉及到配置ConnectionPoolDataSource物件，這個物件是三層體系結構中的中間層來管理連線池的。同樣的，在配置支援分散式事務的時候，需要配置XADataSource，XADataSource是中間層用來管理分散式事物的物件。ConnectionPoolDataSource和XADataSource是由驅動提供商提供的，對應用程式的設計者來說是透明的。和基本的DataSource一樣，系統管理員來配置ConnectionPoolDataSource和XADataSource物件。
　　四、結果集：
　　結果集物件是一行行資料的容器。根據其目的，可以通過多種方法實現。RowSet及其相關的介面與JDBC2.0的標準擴充套件API有點不同，他們並不是驅動的一部分，RowSet是在驅動的上層實現的，可以由其它的任何人來實現他們。
　　任何型別的rowset都實現了RowSet介面，RowSet介面擴充套件了ResultSet介面。這樣RowSet物件就有了ResultSet物件所有的功能。能夠通過getXXX方法得到資料庫中的某列值，通過updateXXX方法可以修改某列值，可以移動游標，是當前行變為另一行。
　　當然，我們更感興趣的是RowSet介面提供的新的功能。作為一個JavaBean元件，RowSet物件可以增加或者刪除一個listener（監聽者），可以get或者set其屬性值，這些屬性中，有一個是字串，表示一個對資料庫Query請求，RowSet介面定義了設定引數的方法，也提供了執行這個請求的方法。這意味著RowSet物件能夠執行查詢請求，可以根據它產生的結果集進行計算。同樣，RowSet也可以根據任何表格資料來源進行計算，所以，它不侷限於關係資料庫。
　　從資料來源得到資料之後，RowSet物件可以和資料來源斷開連線，rowset也可以被序列化。這樣，RowSet就可以通過網路傳遞給瘦客戶端。
　　RowSet可以被重新連線到資料來源，這樣，做的修改就可以存回到資料來源中去。如果產生了一個listener，當RowSet的當前行移動，或者資料被修改的時候，監聽者就會收到通知。例如，圖形使用者介面元件可以註冊成為監聽者，當RowSet更改的時候，圖形使用者介面接到通知，就可以修改介面，來符合它所表示的RowSet。
　　根據不同的需要，RowSet介面可以通過多種方法來實現。Java software已經寫了一個CachedRowSet實現，從http://developer.java.sun.com/developer/earlyAccess/crs/index.html中可以得到這個實現。
　　與CachedRowSet類不樣的是，JDBCRowSet類總是保持一個和資料來源的連線。這樣，在ResultSet外圍簡單到加了一層，是基於JDBC技術的驅動看起來象是一個簡單的JavaBean元件一樣。

　　總結：JDBC2.0標準擴充套件API通過見DataSource註冊到JNDI名字服務上，將JDBC技術擴充套件為一個全新的概念。使應用程式的程式碼更加精巧，易於控制。新的API支援了連線池，支援分散式的事務。最後，還使java應用程式可以在網路上傳播結果集，是不可以滾動的ResultSet變成了可以滾動的RowSet。


 

ii 回覆於：2003-03-11 08:17:53

Tomcat中配置和使用JNDI 

JNDI是J2EE中一個很重要的標準，通常我們是在EJB程式設計中用到， 
Tomcat4.0中提供了在JSP和Servelt中直接使用JNDI的方法，下面談一下在Tomcat4.0中配置和使用JNDI的方法 
(以通過JNDI連線資料庫為例) 
假設使用的資料庫是mysql,實驗例子在TOMCAT_HOME/webapps/DBTest目錄中 

A.將mysql的JDBC連線庫mm.mysql-2.0.9-bin.jar放入TOMCAT_HOME/common/lib中 

B.配置TOMCAT_HOME/conf/serer.xml檔案在<Service>;段中加入一個Context: 
<Context path="/DBTest" docBase="DBTest" 
debug="5" reloadable="true" crossContext="true">; 
</Context>; 
這是DBTest的根路徑，這是為了在DBTest中使用做準備. 

C.在上面加入的<Context>;段加入 
<Resource name="jdbc/TestDB" 
auth="Container" 
type="javax.sql.DataSource"/>; 

<ResourceParams name="jdbc/TestDB">; 
<parameter>; 
<name>;factory</name>; 
<value>;org.apache.commons.dbcp.BasicDataSourceFactory</value>; 
</parameter>; 

<!-- Maximum number of dB connections in pool. Make sure you 
configure your mysqld max_connections large enough to handle 
all of your db connections. Set to 0 for no limit. 
-->; 
<parameter>; 
<name>;maxActive</name>; 
<value>;100</value>; 
</parameter>; 

<!-- Maximum number of idle dB connections to retain in pool. 
Set to 0 for no limit. 
-->; 
<parameter>; 
<name>;maxIdle</name>; 
<value>;30</value>; 
</parameter>; 

<!-- Maximum time to wait for a dB connection to become available 
in ms, in this example 10 seconds. An Exception is thrown if 
this timeout is exceeded. Set to -1 to wait indefinitely. 
-->; 
<parameter>; 
<name>;maxWait</name>; 
<value>;10000</value>; 
</parameter>; 

<!-- MySQL dB username and password for dB connections -->; 
<parameter>; 
<name>;username</name>; 
<value>;test</value>; 
</parameter>; 
<parameter>; 
<name>;password</name>; 
<value>;test</value>; 
</parameter>; 

<!-- Class name for mm.mysql JDBC driver -->; 
<parameter>; 
<name>;driverClassName</name>; 
<value>;org.gjt.mm.mysql.Driver</value>; 
</parameter>; 

<!-- The JDBC connection url for connecting to your MySQL dB.-->; 
<parameter>; 
<name>;url</name>; 
<value>;jdbc:mysql://localhost:3306/test</value>; 
</parameter>; 
</ResourceParams>; 

這裡每一個小段都有英文註解，是Tomcat提供的，我們可以將按照Sample加入,主要修改的是driverClassName, 
url,和使用者帳號;需要強調的是"jdbc/TestDB"就是JDNI要查詢的Name. 

D. 在JSPh或servlet中使用JNDI查詢服務 
下面是在JSP檔案中關於JNDI使用的程式碼(檔名記為UserHandleDB.jsp) 
需要注意的是JNDI NAME要在前面加上"java:comp/env/" 

<%@ page language="java"%>; 
<%@ page import="java.util.*" %>; 
<%@ page import="java.sql.*" %>; 
<%@ page import="javax.sql.*" %>; 
<%@ page import="javax.naming.*" %>; 

<% 
String jndi_name="java:comp/env/jdbc/TestDB"; 
String select_user_sql="select userid,name,birthday, email from emp"; 
String colnames[][]={{"User ID","Name","Birth day","EMail"}, 
{"userid","name","birthday","email"}}; 
Vector userSet=new Vector(); 
Vector columnSet=new Vector(); 

for(int i=0;i<colnames[0].length;i++){ 
columnSet.add(colnames[0]); 
} 
userSet.add(columnSet); 

Context ctx = new InitialContext(); 
if(ctx == null ) 
throw new Exception("No Context"); 

DataSource ds = (DataSource)ctx.lookup(jndi_name); 

Connection conn = ds.getConnection(); 

try { 
PreparedStatement psPreparedStatement=conn.prepareStatement(select_user_sql); 
ResultSet resultSet = psPreparedStatement.executeQuery(); 
while(resultSet.next()){ 
columnSet=new Vector(); 
for(int i=0;i<colnames[1].length;i++){ 
columnSet.add(resultSet.getString(colnames[1])); 
} 
userSet.add(columnSet); 
} 
}catch(SQLException e) { 
e.printStackTrace(); 
}finally { 
conn.close(); 
%>; 


E. 引用UserHandleDB.jsp(記為ViewTable.jsp) 
<html>; 
<head>; 
<title>;Test Database </title>; 
<body >; 
<%@ include file="UserHandleDB.jsp" %>; 
<table border="1" >; 
<% 
for(int i=0;i<userSet.size();i++){ 
Vector colSet=(Vector)userSet.get(i); 
out.print("<tr>;"); 
for(int j=0;j<colSet.size();j++){ 
String col=(String)colSet.get(j); 
out.print("<td>;"+col+"</td>;"); 
} 
out.print("</tr>;"); 
} 
%>; 
</table>; 
</body>; 
</html>; 

F. 在web.xml中加入 
<resource-ref>; 
<description>;DB Connection</description>; 
<res-ref-name>;jdbc/TestDB</res-ref-name>; 
<res-type>;javax.sql.DataSource</res-type>; 
<res-auth>;Container</res-auth>; 
</resource-ref>; 
這裡的jdbc/TestDb要和C中Resource段的name匹配 

G. 觀察結果 
首先確定資料庫已經啟動，接著啟動Tomcat，如果Tomcat啟動異常，可能的原因是資料庫的JDBC庫沒有載入 
最後開啟瀏覽器，訪問 http://localhost:8080/DBTest/ViewTable.jsp就可以看到結果

 ii 回覆於：2003-03-11 08:45:24

Common Problems 
Here are some common problems encountered with a web application which uses a database and tips for how to solve them.

Intermittent dB Connection Failures 
Tomcat runs within a JVM. The JVM periodically performs garbage collection (GC) to remove java objects which are no longer being used. When the JVM performs GC execution of code within Tomcat freezes. If the maximum time configured for establishment of a dB connection is less than the amount of time garbage collection took you can get a db conneciton failure. 

To collect data on how long garbage collection is taking add the -verbose:gc argument to your CATALINA_OPTS environment variable when starting Tomcat. When verbose gc is enabled your $CATALINA_BASE/logs/catalina.out log file will include data for every garbage collection including how long it took.

When your JVM is tuned correctly 99% of the time a GC will take less than one second. The remainder will only take a few seconds. Rarely, if ever should a GC take more than 10 seconds.

Make sure that the db connection timeout is set to 10-15 seconds. For the DBCP you set this using the parameter maxWait.
 
Random Connection Closed Exceptions 
These can occur when one request gets a db connection from the connection pool and closes it twice. When using a connection pool, closing the connection just returns it to the pool for reuse by another request, it doesn't close the connection. And Tomcat uses multiple threads to handle concurrent requests. Here is an example of the sequence of events which could cause this error in Tomcat: 

  Request 1 running in Thread 1 gets a db connection.

  Request 1 closes the db connection.

  The JVM switches the running thread to Thread 2

  Request 2 running in Thread 2 gets a db connection
  (the same db connection just closed by Request 1).

  The JVM switches the running thread back to Thread 1

  Request 1 closes the db connection a second time in a finally block.

  The JVM switches the running thread back to Thread 2

  Request 2 Thread 2 tries to use the db connection but fails
  because Request 1 closed it.

Here is an example of properly written code to use a db connection obtained from a connection pool: 
  Connection conn = null;
  Statement stmt = null;  // Or PreparedStatement if needed
  ResultSet rs = null;
  try {
    conn = ... get connection from connection pool ...
    stmt = conn.createStatement("select ...");
    rs = stmt.executeQuery();
    ... iterate through the result set ...
    rs.close();
    rs = null;
    stmt.close();
    stmt = null;
    conn.close(); // Return to connection pool
    conn = null;  // Make sure we don't close it twice
  } catch (SQLException e) {
    ... deal with errors ...
  } finally {
    // Always make sure result sets and statements are closed,
    // and the connection is returned to the pool
    if (rs != null) {
      try { rs.close(); } catch (SQLException e) { ; }
      rs = null;
    }
    if (stmt != null) {
      try { stmt.close(); } catch (SQLException e) { ; }
      stmt = null;
    }
    if (conn != null) {
      try { conn.close(); } catch (SQLException e) { ; }
      conn = null;
    }
  }

 

ii 回覆於：2003-03-11 08:46:01

0. Introduction
Versions of MySQL and the mm.mysql JDBC driver when have been reported to work: 

MySQL 3.23.47, MySQL 3.23.47 using InnoDB, MySQL 4.0.1alpha 
mm.mysql 2.0.14 (JDBC Driver) 
Please let us know if you have tested the new MySQL mm.mysql 3.0 driver. 

1. MySQL configuration
Ensure that you follow these instructions as variations can cause problems. 

Create a new test user, a new database and a single test table. Your MySQL user must have a password assigned. The driver will fail if you try to connect with an empty password. 

   
 mysql>; GRANT ALL PRIVILEGES ON *.* TO [email protected] 
    ->;   IDENTIFIED BY 'javadude' WITH GRANT OPTION;
mysql>; create database javatest;
mysql>; use javatest;
mysql>; create table testdata (
    ->;   id int not null auto_increment primary key,
    ->;   foo varchar(25), 
    ->;   bar int);

  
   

Note: the above user should be removed once testing is complete! 

Next insert some test data into the testdata table. 

   
 mysql>; insert into testdata values(null, 'hello', 12345);
Query OK, 1 row affected (0.00 sec)

mysql>; select * from testdata;
+----+-------+-------+
| ID | FOO   | BAR   |
+----+-------+-------+
|  1 | hello | 12345 |
+----+-------+-------+
1 row in set (0.00 sec)

mysql>;

  
   


2. server.xml configuration
Configure the JNDI DataSource in Tomcat by adding a declaration for your resource to $CATALINA_HOME/conf/server.xml.

Add this in between the </Context>; tag of the examples context and the </Host>; tag closing the localhost definition.

   
 <Context path="/DBTest" docBase="DBTest"
        debug="5" reloadable="true" crossContext="true">;

  <Logger className="org.apache.catalina.logger.FileLogger"
             prefix="localhost_DBTest_log." suffix=".txt"
             timestamp="true"/>;

  <Resource name="jdbc/TestDB"
               auth="Container"
               type="javax.sql.DataSource"/>;

  <ResourceParams name="jdbc/TestDB">;
    <parameter>;
      <name>;factory</name>;
      <value>;org.apache.commons.dbcp.BasicDataSourceFactory</value>;
    </parameter>;

    <!-- Maximum number of dB connections in pool. Make sure you
         configure your mysqld max_connections large enough to handle
         all of your db connections. Set to 0 for no limit.
         -->;
    <parameter>;
      <name>;maxActive</name>;
      <value>;100</value>;
    </parameter>;

    <!-- Maximum number of idle dB connections to retain in pool.
         Set to 0 for no limit.
         -->;
    <parameter>;
      <name>;maxIdle</name>;
      <value>;30</value>;
    </parameter>;

    <!-- Maximum time to wait for a dB connection to become available
         in ms, in this example 10 seconds. An Exception is thrown if
         this timeout is exceeded.  Set to -1 to wait indefinitely.
         -->;
    <parameter>;
      <name>;maxWait</name>;
      <value>;10000</value>;
    </parameter>;

    <!-- MySQL dB username and password for dB connections  -->;
    <parameter>;
     <name>;username</name>;
     <value>;javauser</value>;
    </parameter>;
    <parameter>;
     <name>;password</name>;
     <value>;javadude</value>;
    </parameter>;

    <!-- Class name for mm.mysql JDBC driver -->;
    <parameter>;
       <name>;driverClassName</name>;
       <value>;org.gjt.mm.mysql.Driver</value>;
    </parameter>;

    <!-- The JDBC connection url for connecting to your MySQL dB.
         The autoReconnect=true argument to the url makes sure that the
         mm.mysql JDBC Driver will automatically reconnect if mysqld closed the
         connection.  mysqld by default closes idle connections after 8 hours.
         -->;
    <parameter>;
      <name>;url</name>;
      <value>;jdbc:mysql://localhost:3306/javatest?autoReconnect=true</value>;
    </parameter>;
  </ResourceParams>;
</Context>;

  
   


3. web.xml configuration
Now create a WEB-INF/web.xml for this test application. 

   
 <?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>;
  <description>;MySQL Test App</description>;
  <resource-ref>;
      <description>;DB Connection</description>;
      <res-ref-name>;jdbc/TestDB</res-ref-name>;
      <res-type>;javax.sql.DataSource</res-type>;
      <res-auth>;Container</res-auth>;
  </resource-ref>;
</web-app>;

  
   


4. Test code
Now create a simple test.jsp for use later. 

   
 <html>;
  <head>;
    <title>;DB Test</title>;
  </head>;
  <body>;

  <%
    foo.DBTest tst = new foo.DBTest();
    tst.init();
  %>;

  <h2>;Results</h2>;
    Foo <%= tst.getFoo() %>;<br/>;
    Bar <%= tst.getBar() %>;

  </body>;
</html>;

  
   


And create a Java class to actually use your new Datasource and connection pool. Note: this code isn't anywhere near production ready - it's only supposed to be used as a simple test :-) 

   
 package foo;

import javax.naming.*;
import javax.sql.*;
import java.sql.*;

public class DBTest {

  String foo = "Not Connected";
  int bar = -1;
    
  public void init() {
    try{
      Context ctx = new InitialContext();
      if(ctx == null ) 
          throw new Exception("Boom - No Context");

      DataSource ds = 
            (DataSource)ctx.lookup(
               "java:comp/env/jdbc/TestDB");

      if (ds != null) {
        Connection conn = ds.getConnection();
              
        if(conn != null)  {
            foo = "Got Connection "+conn.toString();
            Statement stmt = conn.createStatement();
            ResultSet rst = 
                stmt.executeQuery(
                  "select id, foo, bar from testdata");
            if(rst.next()) {
               foo=rst.getString(2);
               bar=rst.getInt(3);
            }
            conn.close();
        }
      }
    }catch(Exception e) {
      e.printStackTrace();
    }
 }

 public String getFoo() { return foo; }
 public int getBar() { return bar;}
}

  
   


Finally deploy your web app into $CATALINA_HOME/webapps either as a warfile called DBTest.war or into a sub-directory called DBTest

Once deployed, point a browser at http://localhost:8080/DBTest/test.jsp to view the fruits of your hard work.

 ii 回覆於：2003-03-11 09:19:29

datasource:
http://jakarta.apache.org/tomcat/tomcat-4.1-doc/jndi-datasource-examples-howto.html

Resources:
http://jakarta.apache.org/tomcat/tomcat-4.1-doc/jndi-resources-howto.html

Realm
http://jakarta.apache.org/tomcat/tomcat-4.1-doc/realm-howto.html

安全管理
http://jakarta.apache.org/tomcat/tomcat-4.1-doc/security-manager-howto.html

 roybao 回覆於：2003-03-31 10:30:55

謝謝！

 rickymoth 回覆於：2003-03-31 10:37:13

受益非淺,非常感謝