JNDI - 王朝网络

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。

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"/>

<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.

-->

<name>maxActive</name>

</parameter>

<!-- Maximum number of idle dB connections to retain in pool.

Set to 0 for no limit.

-->

<name>maxIdle</name>

</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.

-->

<name>maxWait</name>

</parameter>

<name>username</name>

</parameter>

<name>password</name>

</parameter>

<name>driverClassName</name>

<value>org.gjt.mm.mysql.Driver</value>

</parameter>

<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][i]);

}

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][i]));

}

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" %>

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就可以看到结果

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;

}

_________________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 javauser@localhost

-> 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"/>

<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.

-->

<name>maxActive</name>

</parameter>

<!-- Maximum number of idle dB connections to retain in pool.

Set to 0 for no limit.

-->

<name>maxIdle</name>

</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.

-->

<name>maxWait</name>

</parameter>

<name>username</name>

<value>javauser</value>

</parameter>

<name>password</name>

<value>javadude</value>

</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.

-->

<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>

</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.