‘壹’ 求救：jdbc_odbc链接oracle数据库失败，代码如下，运行后，显示：常连接到数据库。 但没有抓到资料。
得用ORACLE的JDBC驱动，转几篇文章给你，估计能解决问题：
1.新建一个JAVA程序
2.导入要用到的ORACLE JDBC包..(在新建项目的时候,选择"库"选项卡-->添加外部JAR..)当然在建立好项目以后点属性也可以....在你的ORACLE的安装目录下找到\jdbc\lib\classes12.zip,引入进来
3.其他的就是编码.
给你一个例子
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:数据库名","用户名","密码");
15.3 Oracle JDBC驱动程序
本节介绍各种Oracle JDBC驱动程序，它们允许Java程序中的JDBC语句访问Oracle数据库。Oracle JDBC驱动程序有4种：
● Thin驱动程序
● OCI驱动程序
● 服务器端内部驱动程序
● 服务器端Thin驱动程序
下面各小节分别介绍这些驱动程序。
15.3.1 Thin驱动程序
Thin驱动程序是占用内存最小的驱动程序，也就是说运行它所需的系统资源最少，它全部是用Java编写的。如果编写一个Java applet，应该使用Thin驱动程序。Thin驱动程序还可以用于独立Java应用程序，并用于访问所有版本的Oracle数据库。Thin驱动程序只支持TCP/IP，并要求启动和运行Oracle Net。关于Oracle Net的详细信息，可以参阅由Oracle公司出版的Oracle Database Net Services Administrator’s Guide。
注意：
使用Thin驱动程序不需要在客户计算机上安装任何软件，因此它可以用于applet。
15.3.2 OCI驱动程序
OCI驱动程序需要的资源比Thin驱动程序的要多，但是通常具有更好的性能。OCI驱动程序适合部署在中间层(例如，Web服务器)上的程序。
注意：
OCI驱动程序需要安装在客户计算机上，所以不适用于applet。
OCI驱动程序具有许多性能增强的特性，包括数据库连接池、从数据库中预取行。OCI驱动程序支持所有版本的数据库和所有支持的Oracle Net协议。
15.3.3 服务器端内部驱动程序
服务器端内部驱动程序提供对数据库的直接访问，Oracle JVM使用该驱动程序与数据库通信。Oracle JVM是一个Java虚拟机(Java Virtual Machine)，它与数据库集成。可以将Java类加载到数据库中，然后使用Oracle JVM发布并运行该类包含的方法。Java代码运行在数据库服务器上，并可以从单一的Oracle会话访问数据。
15.3.4 服务器端Thin驱动程序
服务器端Thin驱动程序也用于Oracle JVM，提供对远程数据库的访问。和Thin驱动程序一样，服务器端Thin驱动程序也完全用Java编写。使用服务器端Thin驱动程序的Java代码可以访问相同的数据库服务器或某个远程服务器上的另一个会话。
JDBC Oracle驱动sql 2009-10-22 20:07:53 阅读43 评论0 字号：大中小 订阅 .
public static Connection Oracl(){
String sUsr="taotao";
String sPwd="tao5201920";
Connection conn=null;
//加载jdbc-odbc 桥驱动程序
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
conn=DriverManager.getConnection("jdbc:oracle:thin:@192.168.0.3:1521:orcl",sUsr,sPwd);
conn.setAutoCommit(false);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("连接成功！");
return conn;
}
Oracle与JDBC数据库 2007-12-08 22:14:23 阅读22 评论0 字号：大中小 订阅 .
【用JDBC连接Oracle数据库】
一、软件需求：
JDK、Orcale Client软件（带有Oracle JDBC驱动程序）、Oracle数据库服务器、Oracle Net、Oracle9iAS Containers for J2EE（简称OC4J）。
只要在一台电脑上安装了Oracle数据库服务器，就一般同时拥有了Orcale Client软件（带有Oracle JDBC驱动程序）、Oracle Net、OC4J，数据库
服务器、Oracle Net和OC4J可以运行在网络上的任意一台电脑上，而通过JDBC连接数据库的客户端程序可以在另外的电脑（安装了Orcale Client软
件）上运行。
Orcale Client软件的安装目录下有一个jdbc子目录，它的内容如下：
·readme.txt，包含Oracle JDBC驱动程序的重要信息。
·doc子目录中有一个ZIP文件，它包含了Oracle JDBC API参考文档。
·demo子目录中有一个ZIP文件，它包含了Oracle提供的示例java程序。
·lib子目录，有多个ZIP文件和JAR(Java Achive，java归档文件)，这是Oracle JDBC驱动程序所在的目录。
二、配置环境变量：
·JAVA_HOME = F:\WebServers\Java\jdk1.5.0 （JDK的安装目录，如果要使用Java 2 Enterprise Edition，那么还要设置J2EE_HOME）。
·ORACLE_HOME = F:\Win2K\Oracle\Ora90 （Oracle的安装目录）。
·classpath = .;%JAVA_HOME%\LIB\dt.jar;%JAVA_HOME%\LIB\tools.jar;%ORACLE_HOME%\JDBC\LIB\classes12.zip;%ORACLE_HOME%\JDBC\LIB\nls_charset12.zip;%ORACLE_HOME%\JDBC\LIB\jta.zip;%ORACLE_HOME%\JDBC\LIB\jndi.zip;%ORACLE_HOME%\SQLJ\LIB\translator.zip;%ORACLE_HOME%\SQLJ\LIB\runtime.zip
（如果要使用ava 2 Enterprise Edition，那么还要设置J2EE_CLASSPATH）。
·path = %path%;%JAVA_HOME%\BIN;%ORACLE_HOME%\BIN
说明：
1、JDK的版本要与Oracle JDBC驱动程序的版本相兼容，一般采用最新版本就没有问题。
2、环境变量classpath包含的是java类包的位置列表，可以是目录名，也可以是包含类的ZIP文件或JAR文件。
·如果使用JDK1.2.x或更高版本，则要在classpath中加入classes12.zip（或classes12.jar）。
·如果需要National Language支持，则要在classpath中加入nls_charset12.zip（或nls_charset12.jar）。
·如果需要使用Java Transaction API(JTA)，则要在classpath中加入jta.zip（或jta.jar）。
·如果需要使用Java Naming and Directory Interface(JNDI)，则要在classpath中加入jndi.zip（或jndi.jar）。
以上的ZIP文件和JAR文件都在%ORACLE_HOME%\JDBC\LIB目录中，该目录中还有一些名字与上面的ZIP或JAR文件相似但以11结束的文件，这些是
与java1.1.x相兼容的文件，当系统中使用的JDK是java1.1.x时，就要使用这些文件来代替上面的文件。
3、classpath中一般都加入“.;”，它表示当前程序运行的目录，也就是指示程序在当前运行目录中找java类包。
三、一个连接Oracle的示例程序test.java：
import java.sql.*; //这是JDK提供的标准JDBC驱动程序包。但如果要使用Oracle的特性，就需要Oracle的JDBC扩展。
public class test{
public static void main(String args[])
{
Connection conn=null;
Statement sql=null;
/*这一段代码与下面的一句DriverManager.registerDriver()完成相同的功能，所以推荐下面的一句
try{
Class.forName("oracle.jdbc.driver.OracleDriver");
}catch(ClassNotFoundException e){
//System.out.println("Error code="+e.getErrorCode()); //ClassNotFoundException类没有这个方法
System.out.println("Error message="+e.getMessage());
}
*/
try{
DriverManager.registerDriver(new oracle.jdbc.OracleDriver());//与上面的代码段完成相同功能
conn=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:OEMREP","system","manager"); //连接字符串中的OEMREP是Oracle数据库例程的SID
sql=conn.createStatement();
ResultSet rs=sql.executeQuery("select user,sysdate from al"); //al表是每一个Oracle数据库都会有的表，它存储了Oracle数据库的内置变量，如user、sysdate等。
if(rs.next())
System.out.println("Hello,"+rs.getString("user")+",the current date and time is "+rs.getTimestamp("sysdate"));
rs.close();
}catch(SQLException E){
System.out.println("Error code = "+E.getErrorCode());
System.out.println("Error message = "+E.getMessage());
}finally{
try{
if(sql!=null) sql.close();
if(conn!=null) conn.close();
}catch(SQLException E){
System.out.println("Error code = "+E.getErrorCode());
System.out.println("Error message = "+E.getMessage());
}
}
}
‘贰’ 用Jndi配置的数据源怎么获取oracle原始连接
代码：
/**
* 获取数据库连接方法
*/
public Connection getConn() throws
Exception {
Connection conn = null;
try {
//connection原始的连接方式可以转换为OracleConnection
Connection con =
this.commonDao.getCurrentConnection();
Connection conWas = null;
if(this.wasConnection){//使用tomcat请把biz-context-finance.xml中的wasConnection的值设置为false
注释掉biz-context-core.xml中的id="websphereForOracleConnection"内容
WebSphereNativeJdbcExtractor websphereForOracleConnection =
(WebSphereNativeJdbcExtractor)SpringUtils.getSpringBean("websphereForOracleConnection");
conWas = websphereForOracleConnection.getNativeConnection(con);
}else{
conWas = con;
}
conWas.setAutoCommit(false);
conn =
conWas.getMetaData().getConnection();
} catch (DaoException e) {
e.printStackTrace();
}
return conn;
}
‘叁’ 求教各位前辈！ java web 及oracle 问题
1:oracle的自增如果写的话会很麻烦的.你还不如建立一个序列你..序列的名字叫 表名_seq
然后插入数据的时候这一项的值就写 表名_seq.nextval 它会自动增长.这是最常用的方法
2:jndi是访问数据库的一套API.jdbc是基于java访问数据库的一套API...可以说jndi是jdbc的新特征..
我以前用JDBC用的多.现在基本上都是用框架连接.很少用这玩意了.
‘肆’ jndi连库懂的进。sql2000
import java.sql.SQLException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import oracle.jdbc.pool.OracleDataSource;
public class OracleJNDI
{
public OracleJNDI() throws SQLException
{
super();
}
/**
* 使用sun提供的com.sun.jndi.fscontext.RefFSContextFactory作为JNDI服务器，
* 其实这是使用文件系统来存储JNDI对象
* @param args
* @throws NamingException
* @throws SQLException
*/
public static void main(String[] args) throws NamingException, SQLException
{
//Properties ps = new Properties();
//为系统设置jndi工厂
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
//指定JNDI URL
System.setProperty(Context.PROVIDER_URL, "file:JNDI_REF");
Context ctx = new InitialContext();
//OracleDataSoruce对象，它已经实现了javax.naming.Referencable
OracleDataSource ojndi = new OracleDataSource();
//设置相关数据库属性
ojndi.setDatabaseName("DXS");
ojndi.setURL("jdbc:oracle:thin:@localhost:1521:dflcrm");
ojndi.setUser("smp_dba");
ojndi.setPassword("123");
ojndi.setDescription("JDBC Datasource connection.");
//重新绑定OJNDI对象
ctx.rebind("ojndi", ojndi);
System.out.println("bind successful");
//关闭
ctx.close();
}
}
这个是连接oracle的,sql2000的自己改改
‘伍’ jsp连接oracle的方法，包括对数据库进行操作的方法。最好给个简单的例子
package com.function;
import java.io.StringReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Vector;import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
import com.function.DealString;import sun.jdbc.rowset.CachedRowSet;public class DBManager {
private static Connection conn = null;
private static final String jndiname="java:comp/env/jdbc/fb";
/** 以下为数据连接方式是连接池操作,需要事先配置好相应的连接池以及数据源 */
public static Connection getConnection(){ try {
Context initCtx = new InitialContext(); DataSource ds = (DataSource) initCtx.lookup(jndiname);
conn = ds.getConnection();
conn.setAutoCommit(true);
} catch (Exception e) {
e.printStackTrace();
}
return conn;
} /** 以下是连接ORACLE数据库 */
public static Connection getOracleConnection() {
String url = "jdbc:oracle:thin:@10.10.10.1:1521:hzw";
String driver = "oracle.jdbc.driver.OracleDriver";
String uid = "govstock";
String pwd = "govstock";
try {
Class.forName(driver);
} catch (ClassNotFoundException ex) {
System.out.println("装载驱动时出错！" + ex.getMessage());
}
try {
//conn = DriverManager.getConnection(url, uid, pwd);
conn=getConnection();
} catch (Exception ex1) {
System.out.println("得到连接时出错" + ex1.getMessage());
}
return conn;
} /** 以下是连接MSSQL数据库 */
public static Connection getMsSqlConnection() {
String url = "jdbc:microsoft:sqlserver://10.10.10.86:1433;DatabaseName=ccgp-cs1";
String driver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
String uid = "sa";
String pwd = "sa";
try {
Class.forName(driver);
} catch (ClassNotFoundException ex) {
System.out.println("装载驱动时出错！" + ex.getMessage());
}
try {
conn = DriverManager.getConnection(url, uid, pwd);
} catch (SQLException ex1) {
System.out.println("得到连接时出错" + ex1.getMessage());
}
return conn;
}
/** 以下是释放数据库资源Connection */
public static void cleanup(Connection conn) { try {
if (conn != null && !conn.isClosed()) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
/** 以下是释放数据库资源Connection,PreparedStatement */
public static void cleanup(Connection conn, PreparedStatement ps) {
try { if (ps != null) {
ps.close();
}
} catch (Exception e) {
e.printStackTrace();
}
try {
if (conn != null && !conn.isClosed()) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
/** 以下是释放数据库资源Connection,PreparedStatement,ResultSet */
public static void cleanup(Connection conn, PreparedStatement ps,
ResultSet rs) { try {
if (rs != null) {
rs.close();
}
} catch (Exception e) {
e.printStackTrace();
}
try {
if (ps != null) {
ps.close();
}
} catch (Exception e) {
}
try {
if (conn != null && !conn.isClosed()) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
/** 以下是执行查询操作时需要带入查询参数 返回CachedRowSet*/
public static CachedRowSet executeQuery(String sql, Object[] values) {
CachedRowSet crs = null;
PreparedStatement st = null;
Connection conn = null;
ResultSet rs = null;
try {
crs = new CachedRowSet();
if (values == null || values.length < 1) {
return executeQueryCachedRowSet(sql);
}
conn = getOracleConnection();
st = conn.prepareStatement(sql);
for (int i = 0; i < values.length; i++) {
st.setObject(i + 1, values[i]);
}
rs = st.executeQuery();
crs.populate(rs);
} catch (Exception se) {
System.out
.println("SQLException in DBManager.exceuteQuery, sql is :\n"
+ sql);
se.printStackTrace();
} finally {
DBManager.cleanup(conn, null, rs);
}
return crs;
}
/** 以下是执行查询操作时需要带入查询参数、数据库连接 返回CachedRowSet */
public static CachedRowSet executeQuery(String sql, Object[] values,Connection conn) {
CachedRowSet crs = null;
PreparedStatement st = null;
// Connection conn = null;
ResultSet rs = null;
try {
crs = new CachedRowSet();
if (values == null || values.length < 1) {
return executeQueryCachedRowSet(sql);
}
// conn = getOracleConnection();
st = conn.prepareStatement(sql);
for (int i = 0; i < values.length; i++) {
st.setObject(i + 1, values[i]);
}
rs = st.executeQuery();
crs.populate(rs);
} catch (Exception se) {
System.out
.println("SQLException in DBManager.exceuteQuery, sql is :\n"
+ sql);
se.printStackTrace();
} finally {
DBManager.cleanup(null, null, rs);
}
return crs;
}
/**执行sql返回CachedRowSet 带参数、数据库连接 */
public static CachedRowSet executeQueryCachedRowSet(String sql,Connection conn) {
CachedRowSet crs = null;
Statement st = null;
ResultSet rs = null;
try {
crs = new CachedRowSet();
st = conn.createStatement();
rs = st.executeQuery(sql);
crs.populate(rs);
}
catch (Exception se) {
System.out.println("SQLException in DBManager.executeQueryCachedRowSet, sql is :\n" +
sql);
se.printStackTrace();
}
finally {
DBManager.cleanup(null, null, rs);
}
return crs;
}
/**执行sql返回CachedRowSet 不带参数*/
public static CachedRowSet executeQueryCachedRowSet(String sql) {
CachedRowSet crs = null;
Statement st = null;
Connection conn = null;
ResultSet rs = null;
try {
crs = new CachedRowSet();
conn =getOracleConnection();
st = conn.createStatement();
rs = st.executeQuery(sql);
crs.populate(rs);
}
catch (Exception se) {
System.out.println("SQLException in DBManager.executeQueryCachedRowSet, sql is :\n" +
sql);
se.printStackTrace();
}
finally {
DBManager.cleanup(conn, null, rs);
}
return crs;
}
/** 以下是用来执行增加,删除,修改操作 */
public static int executeByLong(String sql, Object[] values) {
PreparedStatement ps = null;
int rows = 0;
try {
conn = getOracleConnection();
conn.setAutoCommit(false);
ps = conn.prepareStatement(sql);
if (values == null || values.length < 1) {
rows = ps.executeUpdate();
return rows;
}
for (int i = 0; i < values.length; i++) {
ps.setCharacterStream(i + 1,new StringReader(values[i].toString()),values[i].toString().length());
}
rows = ps.executeUpdate();
conn.commit();
} catch (Exception e) {
try {
conn.rollback();
} catch (Exception ex) {
ex.printStackTrace();
}
e.printStackTrace();
} finally {
cleanup(conn, ps);
}
return rows;
} }
DBManager类 想用的话，把里面的代码拷到jsp上去就行了
‘陆’ java连接oracle数据库有哪几种方式，有什么区别，或者分别的使用场合是什么样的
java连接数据库一般都是JDBC方式，很多组件封装了最简单的JDBC方式，例如Hibernate等等
‘柒’ jndi是什么
JNDI是 Java 命名与目录接口（Java Naming and Directory Interface），在J2EE规范中是重要的规范之一，是一组在Java应用中访问命名和目录服务的API，是SUN公司提供的一种标准的Java命名系统接口，命名服务将名称和对象联系起来，使得我们可以用名称访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。
‘捌’ JDBC与JNDI这两种连接方式有什么区别
jdbc是数据库中间代理商为了是java连接数据库而定的一个协议 或者说是方法,通过jdbc-odbc的方法进行数据库连接,是连接一次创建一次的做法 1,由数据库驱动和协议组成连接数据的方法,调用中间商提供的类包,进行创建连接 2.再由连接去调用3种状态. 3.由状态来提供对数据库的操作 jndi是一种命名树的方式,把需要的类都列成目录的样式,需要哪个只要根据命名直接去 调用,是一种比较快洁的思想和行为. 当你要操作数据库的用jdbc 操作命名服务用jndi Java Database Connectivity (JDBC)是一个标准的Java API，它由一组类和接口组成，Java应用程序开发人员使用它来访问数据库和执行SQL语句 JNDI(Java Name Directory Interface),可不仅仅是进行数据库定位的， 它是给当前应用服务器所管理的所有资源一个唯一的标识，包括数据库，网页，文件， 连接池等等。
配置 JNDI绑定
此处绑定的数据源是以 DBCP 为实现。首先必须将数据库驱动（这里用了MYSQL数据库）和DBCP所需要的 Jar 包复制到 Jetty 根目录的 lib 目录下。DBCP主要需要以下3个文件：
Commons-dbcp.jar
Commons-pool.jar
Commons-collections.jar
jdbc和jndi区别
Connection conn = null;
try{
Class.forName("com.mysql.jdbc.Driver",true,Thread.currentThread().getContextClassLoader());
conn = DriverManager.getConnection("jdbc:mysql://MyDBServer?user=***&password=****");
.....
conn.close();
}
catch(...){...}finally{
if(conn!=null){
try{
conn.close();
}
catch(...){...}
}
}
存在的问题？
1、数据库服务器名称MyDBServer 用户名和口令可能需要修改，由此引发JDBC URL修要修改；
2、数据库可能该用别的产品；
3、随着实际终端的增加，原配置的连接池参数可能需要调整；
解决办法
程序员不必关心数据库级别的事情，只需要知道如何引用即可
JNDI出现了。
定义数据源，也就是JDBC引用参数，给这个数据源设置一个名称；
在程序中通过数据源名称引用数据源，从而访问数据库；
//jndi连接
Context initCtx = new InitialContext();
Context envCtx = (Context)initCtx.lookup("java:comp/env");
DataSource ds = (DataSource)envCtx.lookup("jdbc/webtest");
conn = ds.getConnection();
//jdbc连接
Class.forName("com.mysql.jdbc.Driver",true,Thread.currentThread().getContextClassLoader());
conn = DriverManager.getConnection("jdbc:mysql://localhost/mismain?user=root&autoReconnect=true");
程序员开发时，知道要开发访问MySQL数据库的应用，于是将一个对 MySQL JDBC 驱动程序类的引用进行了编码，并通过使用适当的 JDBC URL 连接到数据库。
就像以下代码这样：
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.close();
} catch(Exception e) ...{
e.printStackTrace();
} finally ...{
if(conn!=null) ...{
try ...{
conn.close();
} catch(SQLException e) ...{}
}
}
这是传统的做法，也是以前非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数据库，
如下：
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.close();
} catch(Exception e) ...{
e.printStackTrace();
} finally ...{
if(conn!=null) ...{
try ...{
conn.close();
} catch(SQLException e) ...{}
}
}
<?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、在程序中引用数据源：
Connection conn=null;try ...{
Context ctx=new InitialContext();
Object datasourceRef=ctx.lookup("java:MySqlDS"); //引用数据源 DataSource ds=(Datasource)datasourceRef; conn=ds.getConnection();
......
c.close();
} catch(Exception e) ...{
e.printStackTrace();
} finally ...{
if(conn!=null) ...{
try ...{
conn.close();
} catch(SQLException e) ...{ }
}
}
直接使用JDBC或者通过JNDI引用数据源的编程代码量相差无几，但是现在的程序可以不用关心具体JDBC参数了。
在系统部署后，如果数据库的相关参数变更，只需要重新配置 mysql-ds.xml 修改其中的JDBC参数，只要保证数据源的名称不变，那么程序源代码就无需修改。
由此可见，JNDI避免了程序与数据库之间的紧耦合，使应用更加易于配置、易于部署。
‘玖’ JAVA连接Oracle数据库
//Stringjndijndi标示的你tomcat配置的连接池的名称
(Stringjndi)throwsSQLException{
try{
Contextctx=newInitialContext();
DataSourceds=(DataSource)ctx.lookup("java:comp/env/"+jndi);
ctx.close();
returnds.getConnection();
}catch(Exceptione){
e.printStackTrace();
}
returnnull;
}
/**
*关闭数据库连接
*@paramrsResultSet
*@paramstmtStatement
*@paramconConnection
*/
publicstaticvoidclose(ResultSetrs,Statementstmt,Connectioncon){
if(rs!=null){
try{
rs.close();
rs=null;
}
catch(SQLExceptione){
e.printStackTrace();
}
}
if(stmt!=null){
try{
stmt.close();
stmt=null;
}
catch(SQLExceptione){
e.printStackTrace();
}
}
if(con!=null){
try{
con.close();
con=null;
}
catch(SQLExceptione){
e.printStackTrace();
}
}
}
‘拾’ JNDI与DataSource连接访问数据库的问题
InitialContext ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("test");
改成Context ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup(java:comp/env/test);
记得要引如javax.naming.*这个包
Web.xml中ResourceParams name设置数据源名为test