JNDI 是什么

JNDI是 Java 命名与目录接口（Java Naming and Directory Interface），在J2EE规范中是重要的规范之一，不少专家认为，没有透彻理解JNDI的意义和作用，就没有真正掌握J2EE特别是EJB的知识。

那么，JNDI到底起什么作用？

要了解JNDI的作用，我们可以从“如果不用JNDI我们怎样做？用了JNDI后我们又将怎样做？”这个问题来探讨。

没有JNDI的做法：

程序员开发时，知道要开发访问MySQL数据库的应用，于是将一个对 MySQL JDBC 驱动程序类的引用进行了编码，并通过使用适当的 JDBC URL 连接到数据库。

就像以下代码这样：

<span style="color: rgb(0, 0, 255);">Connection conn=null;
try {
Class.forName("com.mysql.jdbc.Driver",
true, Thread.currentThread().getContextClassLoader());
conn=DriverManager.getConnection("jdbc:mysql://MyDBServer?user=qingfeng&password=mingyue");
/* 使用conn并进行SQL操作 */
......
conn.close();
}
catch(Exception e) {
e.printStackTrace();
}
finally {
if(conn!=null) {
try {
conn.close();
} catch(SQLException e) {}
}
}</span>

这是传统的做法，也是以前非Java程序员（如Delphi、VB等）常见的做法。这种做法一般在小规模的开发过程中不会产生问题，只要程序员熟悉Java语言、了解JDBC技术和MySQL，可以很快开发出相应的应用程序。

没有JNDI的做法存在的问题：

1、数据库服务器名称MyDBServer 、用户名和口令都可能需要改变，由此引发JDBC URL需要修改；

2、数据库可能改用别的产品，如改用DB2或者Oracle，引发JDBC驱动程序包和类名需要修改；

3、随着实际使用终端的增加，原配置的连接池参数可能需要调整；

4、......

解决办法：

程序员应该不需要关心“具体的数据库后台是什么？JDBC驱动程序是什么？JDBC URL格式是什么？访问数据库的用户名和口令是什么？”等等这些问题，程序员编写的程序应该没有对 JDBC 驱动程序的引用，没有服务器名称，没有用户名称或口令 —— 甚至没有数据库池或连接管理。而是把这些问题交给J2EE容器来配置和管理，程序员只需要对这些配置和管理进行引用即可。

由此，就有了JNDI。

用了JNDI之后的做法：

首先，在在J2EE容器中配置JNDI参数，定义一个数据源，也就是JDBC引用参数，给这个数据源设置一个名称；然后，在程序中，通过数据源名称引用数据源从而访问后台数据库。

具体操作如下（以JBoss为例）：

1、配置数据源

在JBoss的 D:/jboss420GA/docs/examples/jca 文件夹下面，有很多不同数据库引用的数据源定义模板。将其中的 mysql-ds.xml 文件Copy到你使用的服务器下，如 D:/jboss420GA/server/default/deploy。

修改 mysql-ds.xml 文件的内容，使之能通过JDBC正确访问你的MySQL数据库，如下：

<?xml version="1.0" encoding="UTF-8"?>

<datasources>

<local-tx-datasource>

<jndi-name>MySqlDS</jndi-name>

<connection-url>jdbc:mysql://localhost:3306/lw</connection-url>

<driver-class>com.mysql.jdbc.Driver</driver-class>

<user-name>root</user-name>

<password>rootpassword</password>

<exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter</exception-sorter-class-name>

<metadata>

<type-mapping>mySQL</type-mapping>

</metadata>

</local-tx-datasource>

</datasources>

这里，定义了一个名为MySqlDS的数据源，其参数包括JDBC的URL，驱动类名，用户名及密码等。

2、在程序中引用数据源：

<span style="color: rgb(0, 0, 255);">Connection conn=null;
try {
Context ctx=new InitialContext();
Object datasourceRef=ctx.lookup("java:<strong>MySqlDS</strong>"); //引用数据源
DataSource ds=(Datasource)datasourceRef;
conn=ds.getConnection();
/* 使用conn进行数据库SQL操作 */
......
c.close();
}
catch(Exception e) {
e.printStackTrace();
}
finally {
if(conn!=null) {
try {
conn.close();
} catch(SQLException e) { }
}
}</span>

直接使用JDBC或者通过JNDI引用数据源的编程代码量相差无几，但是现在的程序可以不用关心具体JDBC参数了。

在系统部署后，如果数据库的相关参数变更，只需要重新配置 mysql-ds.xml 修改其中的JDBC参数，只要保证数据源的名称不变，那么程序源代码就无需修改。

由此可见，JNDI避免了程序与数据库之间的紧耦合，使应用更加易于配置、易于部署。

JNDI的扩展：

JNDI在满足了数据源配置的要求的基础上，还进一步扩充了作用：所有与系统外部的资源的引用，都可以通过JNDI定义和引用。

所以，在J2EE规范中，J2EE 中的资源并不局限于 JDBC 数据源。引用的类型有很多，其中包括资源引用（已经讨论过）、环境实体和 EJB 引用。特别是 EJB 引用，它暴露了 JNDI 在 J2EE 中的另外一项关键角色：查找其他应用程序组件。

EJB 的 JNDI 引用非常类似于 JDBC 资源的引用。在服务趋于转换的环境中，这是一种很有效的方法。可以对应用程序架构中所得到的所有组件进行这类配置管理，从 EJB 组件到 JMS 队列和主题，再到简单配置字符串或其他对象，这可以降低随时间的推移服务变更所产生的维护成本，同时还可以简化部署，减少集成工作。 外部资源”。

总结：

J2EE 规范要求所有 J2EE 容器都要提供 JNDI 规范的实现。JNDI 在 J2EE 中的角色就是“交换机” —— J2EE 组件在运行时间接地查找其他组件、资源或服务的通用机制。在多数情况下，提供 JNDI 供应者的容器可以充当有限的数据存储，这样管理员就可以设置应用程序的执行属性，并让其他应用程序引用这些属性（Java 管理扩展（Java Management Extensions，JMX）也可以用作这个目的）。JNDI 在 J2EE 应用程序中的主要角色就是提供间接层，这样组件就可以发现所需要的资源，而不用了解这些间接性。

在 J2EE 中，JNDI 是把 J2EE 应用程序合在一起的粘合剂，JNDI 提供的间接寻址允许跨企业交付可伸缩的、功能强大且很灵活的应用程序。这是 J2EE 的承诺，而且经过一些计划和预先考虑，这个承诺是完全可以实现的

JNDI 笔记(一) 概述

NDI，Java Naming Directory Interface，J2EE的标准之一，所有的J2EE容器都必须提供一个JNDI的服务，但是，我一直都没用过，至少是没有刻意地去用过。因为，我也 曾经把数据源配置在Tomcat的JNDI服务中，但那时，我也只是刚刚涉足JAVA，有人告诉我应该这么干而已。后来，我开始使用自定义的数据库连接配 置文件，就再也没有跟JNDI打过交道了，直到今天。

现在之所以又想看一下，只是因为觉得这是J2EE的重要标准之一，如果不懂得的话，似乎有点说不过去。

JNDI 的主要功能可以这样描述，它使用一张哈希表存储对象（大多数的J2EE容器也的确是这样做的），然后，开发人员可以使用键值——也就是一个字符串——来获 取这个对象。这里就包括取JNDI的两个最主要操作，bind和lookup。bind操作负责往哈希表里存对象，存对象的时候要定义好对象的键值字符
串，lookup则根据这个键值字符串往外取对象。

JNDI的命称可能会让人产生混淆，似乎觉得这是一个用来操作目录的，事实上，我更愿意把这个目录理解成为JNDI存放对象时使用的格式，也就是说，JNDI以目录的方式存储对象的属性。例如，用户通过JNDI存储一个汽车对象，那么，汽 车就是根目录，汽车的轮子、引擎之类的子对象就算是子目录，而属性，比如说汽车的牌子、重量之类，就算是汽车目录下的文件。

JNDI的功能既然就是根据一个字符串键值就可以取得一个想要得到的对象，我一开始就觉得这不是跟COM或CORBA一样吗？SUN也是有野心的企业啊，JNDI应该就是它要努力推行的JAVA下的分布式开发的标准吧。

JNDI 的出现应该就是为了分步式开发服务的，有人负责开发这种分布式对象，有人只需要使用这些分布式对象就可以了，这两组人不必属于同一个公司，而且这种开发通 常应该是不并行的，也不必是会了同一个项目服务。就如果数据源对象，它放在JNDI中，只要想要用的人，直接通过JNDI服务取来用就可以了，至于当初是 谁把它放进JNDI中的，还是不用操这份心了吧。而我一直没有使用JNDI，也就是这个原因，项目中的所有对象都在我控制之下，我不去使用别人的对象，也 没打算把我的对象贡献出来给别人使用，那自然也就没必要去跟JNDI打交道。我觉得是否使用JNDI，这应该是关键原因，至于什么方便性、安全性之类的考
虑，应该不是JNDI的主要目的，就如同你可以用JAVA来做网站，但JAVA并不是专门用来做网站的。

可能有人觉得这种功能跟IoC也 很象，这个我倒不觉得，虽然对于对象的使用人员来说的确是这种感觉，且不说IoC需要为对象定义接口，而JNDI并无此限制，先说这里有一个使用环境问 题，我觉得IoC是用来解决并行开发问题的，也就是说IoC主要是用于明确设计人员与实现/使用人员的分工，无论是设计的，还是使用的，通常是一个项目组 里的人，使用IoC，可以使得设计人员专注于设计，加快设计速度。因此，IoC的用途要比JNDI广泛的多，现在大型系统中，不使用IoC的，几稀矣。

JNDI 笔记(二) J2EE下使用JNDI

在J2EE环境下使用JNDI是非常简单的事，因为所有的J2EE容器都要实现JNDI服务，所以，在J2EE环境下使用JNDI，与使用 Hashtable也没有什么太大区别。只有一点限制，那就是绑定对象时，对象所属的类必须实现java.io.Serializable接口，这一点也 实在一点也不困难，几乎所有用到的Java类都实现了这个接口，对于自定义的类，在接口实现列表里把这个接口加进去也就是了。

下面，我将演示一下如何在J2EE环境下使用JNDI，为了保证代码的通用性，我不使用struts之类的框架，而是直接使用标准JSP和Servlet实现。我将该项目的名称定为jndi_test

要使用JNDI，需要先到SUN的网站上去下载jndi.jar。

2.1 JSP

本项目包括5个JSP，功能说明如下：

index.jsp：首页
bind.jsp：用于在JNDI中绑定对象
bind_result.jsp：绑定对象后的返回页面
lookup.jsp：用于在JNDI中检索对象
lookup_result.jsp：用于显示检索对象

本节中用到的JSP代码如下，代码都简单地很，就不多做解释了。

2.1.1 index.jsp

> bind an object </ a >

> lookup the binded object </ a >


</ body >


</ html >

2.1.5 lookup_result.jsp

<% @ page language = " java " contentType = " text/html; charset=GB18030 "


pageEncoding = " GB18030 " %>


<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >


< html >


< head >


< meta http-equiv ="Content-Type" content ="text/html; charset=GB18030" >


< title > JNDI Test - Lookup result </ title >


</ head >


< body >


<%


Object o = request.getAttribute( " found_jndi_obj " );


out.println(o);


%>


</ body >


</ html >

2.2 Servlet

本例包括两个Servlet，功能说明如下：

BindServlet：用于在JNDI服务中绑定一个对象
LookupServlet：用于在JNDI服务中取出一个对象

2.2.1 BindServlet.java

package lld.test.jndi;




import java.io.IOException;


import java.util.Date;




import javax.naming.Context;


import javax.naming.InitialContext;


import javax.servlet.RequestDispatcher;


import javax.servlet.ServletContext;


import javax.servlet.ServletException;


import javax.servlet.http. * ;




public class BindServlet extends HttpServlet


{




private static final long serialVersionUID = 5219969790998794367L ;




@Override


protected void doGet(HttpServletRequest req, HttpServletResponse resp)


throws ServletException, IOException


{


this .doPost(req, resp);


}




@Override


protected void doPost(HttpServletRequest req, HttpServletResponse resp)


throws ServletException, IOException


{


try


{


Context jndi_ctx = new InitialContext();


String key = " jndi_object " ;


jndi_ctx.rebind(key, new Date());


} catch (Exception ex)


{


ex.printStackTrace();


}




ServletContext context = this .getServletContext();


RequestDispatcher dispatcher = context.getRequestDispatcher( " /bind_result.jsp " );


dispatcher.forward(req, resp);


}




}

使用rebind而不是bind绑定对象是因为，使用bind时，如果已经有对象绑定到该键值上，则会抛出异常。

因为只是示例代码，所以我只是绑定了一个最简单的日期对象。

2.2.2 LookupServlet.java

package lld.test.jndi;




import java.io.IOException;




import javax.naming.Context;


import javax.naming.InitialContext;


import javax.servlet.RequestDispatcher;


import javax.servlet.ServletContext;


import javax.servlet.ServletException;


import javax.servlet.http.HttpServlet;


import javax.servlet.http.HttpServletRequest;


import javax.servlet.http.HttpServletResponse;




public class LookupServlet extends HttpServlet


{


private static final long serialVersionUID = 6677219828267184673L ;




@Override


protected void doGet(HttpServletRequest req, HttpServletResponse resp)


throws ServletException, IOException


{


this .doPost(req, resp);


}




@Override


protected void doPost(HttpServletRequest req, HttpServletResponse resp)


throws ServletException, IOException


{


try


{


Context jndi_ctx = new InitialContext();


String key = " jndi_object " ;


Object o = jndi_ctx.lookup(key);


req.setAttribute( " found_jndi_obj " , o);


} catch (Exception ex)


{


ex.printStackTrace();


}




ServletContext context = this .getServletContext();


RequestDispatcher dispatcher = context.getRequestDispatcher( " /lookup_result.jsp " );


dispatcher.forward(req, resp);


}




}

2.3 web.xml

在web.xml中，加入了servlet映射


<? xml version="1.0" encoding="UTF-8" ?>


< web-app id ="WebApp_ID" version ="2.4" xmlns ="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" >


< display-name > jndi_test </ display-name >




< servlet >


< servlet-name > BindServlet </ servlet-name >


< servlet-class > lld.test.jndi.BindServlet </ servlet-class >


</ servlet >


< servlet-mapping >


< servlet-name > BindServlet </ servlet-name >


< url-pattern > /bind.do </ url-pattern >


</ servlet-mapping >




< servlet >


< servlet-name > LookupServlet </ servlet-name >


< servlet-class > lld.test.jndi.LookupServlet </ servlet-class >


</ servlet >




< servlet-mapping >


< servlet-name > LookupServlet </ servlet-name >


< url-pattern > /lookup.do </ url-pattern >


</ servlet-mapping >




< welcome-file-list >


< welcome-file > index.jsp </ welcome-file >


</ welcome-file-list >


</ web-app >

OK，所有的代码都在这里了，部署到Tomcat下运行即可。

JNDI 笔记(三) J2SE下使用JNDI

在J2SE下使用JNDI下就显得困难一些，首先，我们没有单独的JNDI服务器可以用，JBoss提供了一个免费的JNP服务，通过配置可以作为 单独的JNDI服务器启用。不过这里就不这么麻烦了，如何使用JBOSS作为JNDI服务器，以后将单独撰文讲述，这里我使用sun提供的 com.sun.jndi.fscontext.RefFSContextFactory作为JNDI服务器，其实这是使用文件系统来存储JNDI对象。 至于如何存储后文还将专门描述。

为了在J2SE下使用JNDI，我们首先得到sun的网站上下载3个包，jndi.jar、fscontext.jar和providerutil.jar，前者提供了JNDI服务的接口，后两者是我们要使用的文件系统作为JNDI服务器的支持包。

使用RefFSContextFactory，要求绑定的对象必须实现javax.naming.Referencable接口，否则在绑定时将报如下错误：

Can only bind References or Referenceable objects

各个JDBC驱动提供商提供的DataSource类都实现了Referencable接口，可以直接使用。不过本着学习的态度，我还是在这里演示一下如何实现Referencable接口。

这个如何实现将在后文结合代码详细介绍。本例包括4个类，说明如下：

BindedClass：自定义的实现Referenceable接口的类
BindedClassFactory：工厂类，能够把一个Reference对象转换为BindedClass对象
Bind：测试类，用于在JNDI中绑定对象
Loopup：测试类，用于从JNDI中获取对象

3.1 BindedClass和BindedClassFactory

3.1.1 BindedClass

package lld.test.jndi;




import javax.naming.NamingException;


import javax.naming.Reference;


import javax.naming.Referenceable;


import javax.naming.StringRefAddr;




public class BindedClass implements Referenceable


{


public String value;




public BindedClass()


{


}




@Override


public Reference getReference() throws NamingException


{


Reference r = new Reference( this .getClass().getName(), BindedClassFactory. class .getName(), null );


r.add( new StringRefAddr( " value " , this .getValue()));


return r;


}




public String getValue()


{


return value;


}




public void setValue(String value)


{


this .value = value;


}




}

3.1.2 BindedClassFactory

package lld.test.jndi;




import java.util.Hashtable;




import javax.naming. * ;


import javax.naming.spi. * ;




public class BindedClassFactory implements ObjectFactory


{


@Override


public Object getObjectInstance(Object obj, Name name, Context nameCtx,

。。。}

￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥

Tomcat6.0连接池配置1

1.配置tomcat下的conf下的context.xml文件,在之间添加连接池配置: <Resource name="jdbc/oracle"

auth="Container"

type="javax.sql.DataSource"

driverClassName="oracle.jdbc.driver.OracleDriver"

url=" jdbc:oracle:thin:@host:port:databse"

username=" user "

password="password"

maxActive="100"

maxIdle="30"

maxWait="10000" />

2.配置你的应用下的web.xml中的之间加入:

<resource-ref>

<description>DB Connection</description>

<res-ref-name>jdbc/oracle</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

<res-auth>Container</res-auth>

</resource-ref>

3.把连接数据库的第三方驱动放到common/lib下面就ok了

Tomcat6.0 连接池的配置2

配置步骤如下：1.Tomcat 6的配置和以前的不同了，不推荐在server.xml中进行配置，而是在%Tomcat_Home%\webapps\yourApp\META-INF \context.xml中进行配置才是更好的方法。而不是以前版本%Tomcat_Home%\conf下的context.xml文件。这样就可以在不同的web应用下单独配置连接池了，且Tomcat会自动重载。当然你也可以更改%Tomcat_Home%\conf下的context.xml文件，将所有web应用下的连接池进行统一配置。

2.将代码修改如下：

view plaincopy to clipboardprint?

<Context reloadable="true">

<WatchedResource>WEB-INF/web.xml</WatchedResource>

<Resource name="jdbc/oracleds" auth="Container" type="javax.sql.DataSource"

maxActive="100"

maxIdle="30"

maxWait="10000"

username="scott"

password="tiger"

driverClassName="oracle.jdbc.driver.OracleDriver"

url="jdbc:oracle:thin:@localhost:1521:ora9"/>

</Context>

<Context reloadable="true">

<WatchedResource>WEB-INF/web.xml</WatchedResource>

<Resource name="jdbc/oracleds" auth="Container" type="javax.sql.DataSource"

maxActive="100"

maxIdle="30"

maxWait="10000"

username="scott"

password="tiger"

driverClassName="oracle.jdbc.driver.OracleDriver"

url="jdbc:oracle:thin:@localhost:1521:ora9"/>

</Context>

name 为当前数据源JNDI的名字，可以随意设定；

auth 为验证方式；

type 资源类型；

driverClassName 为Oracle驱动引用；

maxActiv 为连接池最大激活的连接数，设为0表示无限制；

maxIdle 为连接池最大空闲的连接数，数据库连接的最大空闲时间。超过空闲时间，

数据库连接将被标记为不可用，然后被释放。设为0表示无限制；

maxWait 为连接最大的等待时间，单位毫秒，如果超过此时间将接到异常。设为-1

表示无限制。；

username 为oracle数据库的一个用户名；

password 为username的密码；

url 为连接oracle的连接地址；

注：本人尝试将代码“driverClassName="oracle.jdbc.driver.OracleDriver"”改为“driverClassName="oracle.jdbc.OracleDriver"”程序依然运行正常，刚开始以为老师的代码有问题

3.在程序中的调用形式为：

view plaincopy to clipboardprint?

Context context = new InitialContext();

DataSource ds = (DataSource)context.lookup("java:/comp/env/jdbc/oracleds");

Connection conn = ds.getConnection();

Context context = new InitialContext();

DataSource ds = (DataSource)context.lookup("java:/comp/env/jdbc/oracleds");

Connection conn = ds.getConnection();

注：“java:/comp/env/jdbc/oracleds”红色标记文字为步骤1里设置的Resource name

则可以将建立connection的方式以上述形式取代传统方式：

view plaincopy to clipboardprint?

String driver = "oracle.jdbc.driver.OracleDriver";

String url = "jdbc:oracle:thin:@localhost:1521:ora9";

String username = "scott";

String password = "tiger";

Class.forName(driver);

Connection conn = DriverManager.getConnection(url, username, password);

String driver = "oracle.jdbc.driver.OracleDriver";

String url = "jdbc:oracle:thin:@localhost:1521:ora9";

String username = "scott";

String password = "tiger";

Class.forName(driver);

Connection conn = DriverManager.getConnection(url, username, password);

4.另外还需将用到的jdbc驱动类库导入到%Tomcat_Home%\lib目录下

否则会抛出如下异常：

org.apache.tomcat.dbcp.dbcp.SQLNestedException: Cannot load JDBC driver class 'oracle.jdbc.driver.OracleDriver'

依上述步骤就能成功的配置Tomcat6.0 连接池，还有网友贴文说需

在web.xml文件中的web-app节点下加入如下代码形式：

<resource-ref>

<res-ref-name>jdbc/myoracle</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

</resource-ref>

因本人未添加此项，程序依然正确，故本人认为此步骤为非必要项

今天需要在另一台机器上重新部署系统，重新设置db的连接池。当我把tomcat拷贝到那台机器，并且修改META-INF\context.xml，然后重新启动tomcat，但发现系统连接的仍然是老的db。再次检查了META-INF\context.xml文件，确信了这个文件已经正确设置db连接了，这也说明这个文件并没有真正起作用。查看了tomcat下conf\context.xml也没有设置db的连接池。那是哪个文件在起作用呢？折腾了办法，后来发现tomcat在conf\Catalina\localhost下生成了一个和原来META-INF\context.xml相同内容的文件，怀疑一定是这个文件在起作用？删除conf\Catalina\localhost目录，重启tomcat，问题消失。

Tomcat6.0 连接池的配置3

不管是tomcat5,Tomcat5.5或Tomcat6.0. 用下面的这两中方法配置连接池,都可以成功.

1. 应该算是全局的连接池的配置

(1).不管是tomcat5 还是tomcat6 ,都首先找到Tomcat目录下面的conf目录中的server.xml文件.

找到<GlobalNamingResources> </GlobalNamingResources>这对标签.

将这样的一段配置加到标签中间.

<Resource

name="jdbc/TestDB"

auth="Container"

type="javax.sql.DataSource"

driverClassName="com.mysql.jdbc.Driver"

url="jdbc:mysql://localhost:3306/test?autoReconnect=true"

maxActive="50"

maxldle="10"

maxWait="5000"

username="root"

password="admin" />

当然,样例是使用 MYSQL配置, 根据不同的需要,将url,driverClassName,username,passsword等参数改变就行.

然后再找到和server.xml同目录下面的context.xml文件.

在<Context></Context>标签中添加如下配置.

<ResourceLink global="jdbc/TestDB" name="jdbc/TestDB" type="javax.sql.DataSource"/>

global="jdbc/TestDB" 中的参数值("jdbc/TestDB")必须和上一段<Resource >配置中的name属性的值保持一样.

name="jdbc/TestDB" 这个可以随便取,但是在程序中调用的时候,就应该与name的值保持一致.

到这里,连接池已经配置好啦

写个jsp测试

<%@ page language="java" pageEncoding="gbk"%>

<%@page import="java.sql.Connection"%>

<%@page import="javax.naming.Context"%>

<%@page import="javax.naming.InitialContext"%>

<%@page import="javax.sql.DataSource"%>

<%@page import="java.sql.Statement"%>

<%@page import="java.sql.ResultSet"%>

<%

//连接池的获取

Connection conn = null;

DataSource ds = null;

ResultSet rs =null;

Statement stmt = null;

Context initCtx = new InitialContext();

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

if(ds!=null){

out.println("已经获得DataSource!");

out.println("<br>");

conn = ds.getConnection();

try{

stmt = conn.createStatement();

String sql ="select * from tree_table";

rs = stmt.executeQuery(sql);

out.println("以下是从数据库中读取出来的数据:<br>");

while(rs.next()){

out.println("<br>");

out.println(rs.getString("nodeName"));

}

}catch(Exception ex){

ex.printStackTrace();

}finally{

conn.close();

rs.close();

stmt.close();

}

}

%>

在这ds =(DataSource)initCtx.lookup("java:comp/env/jdbc/TestDB");这句代码中的jdbc/TestDB必须和

<ResourceLink global="jdbc/TestDB" name="jdbc/TestDB" ........ />中的name 属性保持一样.

"lookup("java:comp/env/..."这都是固定写法.

2. 应该算是局部的连接池的配置吧.(针对工程而言)

本身我们的工程中META-INF 中，没有context.xml文件,

例如 :E:\apache-tomcat-5.5.16\webapps\myproj\META-INF\

此时我们可以在META-INF目录下面新建一个context.xml文件.

里面写下如下的配置,具体的配置参数,按需改变.

Xml代码

<?xml version="1.0" encoding="UTF-8"?>

<Context reloadable="true" crossContext="true">

<Resource

name="jdbc/TestDB"

auth="Container"

type="javax.sql.DataSource"

driverClassName="com.mysql.jdbc.Driver"

url="jdbc:mysql://localhost:3306/test?autoReconnect=true"

maxActive="50"

maxldle="10"

maxWait="5000"

username="root"

password="admin"

/>

</Context>

这样子,连接池，也就配置好啦，并不需要修改tomcat里面的文件。仅仅在我们的工程中的META-INF目录加入一个context.xml配置文件就好啦.换tomcat版本,更容易.

注:也许你认为配置这边文章很简单,配置数据源连接池也很简单.但是对于初学者来说,可能是困窘他好久的问题.这方面以前我深有体会.大家都是这样过来的. 仅供参考.