『壹』 求救：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