A. java中的JDBC事務和JTA的區別是什麼
在說他們之間的區別之前，先考慮如下幾個問題：
1、getCurrentSession()與openSession()的區別？
* 採用getCurrentSession()創建的session會綁定到當前線程中，而採用openSession()
創建的session則不會
* 採用getCurrentSession()創建的session在commit或rollback時會自動關閉，而採用openSession()
創建的session必須手動關閉
2、使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置：
* 如果使用的是本地事務（jdbc事務）
<property name="hibernate.current_session_context_class">thread</property>
* 如果使用的是全局事務（jta事務）
<property name="hibernate.current_session_context_class">jta</property>
以上是hibernate中一些使用，下面來說說jdbc與jta的區別：
JDBC 事務
JDBC 事務是用 Connection 對象控制的。JDBC Connection 介面( java.sql.Connection )提供了兩種事務模式：自動提交和手工提交。
#在jdbc中，事務操作預設是自動提交。也就是說，一條對資料庫的更新表達式代表一項事務操作，操作成功後，系統將自動調用commit()來提交，否則將調用rollback()來回滾。
# 在jdbc中，可以通過調用setAutoCommit(false)來禁止自動提交。之後就可以把多個資料庫操作的表達式作為一個事務，在操作完成後調 用commit()來進行整體提交，倘若其中一個表達式操作失敗，都不會執行到commit()，並且將產生響應的異常；此時就可以在異常捕獲時調用 rollback()進行回滾。這樣做可以保持多次更新操作後，相關數據的一致性，示例如下：
try {
conn =
DriverManager.getConnection
("jdbc:oracle:thin:@host:1521:SID","username","userpwd";
conn.setAutoCommit(false);//禁止自動提交，設置回滾點
stmt = conn.createStatement();
stmt.executeUpdate(「alter table …」); //資料庫更新操作1
stmt.executeUpdate(「insert into table …」); //資料庫更新操作2
conn.commit(); //事務提交
}catch(Exception ex) {
ex.printStackTrace();
try {
conn.rollback(); //操作不成功則回滾
}catch(Exception e) {
e.printStackTrace();
}
}
JDBC 事務的一個缺點是事務的范圍局限於一個資料庫連接。一個 JDBC 事務不能跨越多個資料庫。
JTA事務
JTA(Java Transaction API) 為 J2EE 平台提供了分布式事務服務。
要用 JTA 進行事務界定，應用程序要調用 javax.transaction.UserTransaction 介面中的方法。例如：
utx.begin();
// ...
DataSource ds = obtainXADataSource();
Connection conn = ds.getConnection();
pstmt = conn.prepareStatement("UPDATE MOVIES ...");
pstmt.setString(1, "Spinal Tap");
pstmt.executeUpdate();
// ...
utx.commit();
讓我們來關注下面的話：
「用 JTA 界定事務，那麼就需要有一個實現 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 介面的 JDBC 驅動程序。一個實現了這些介面的驅動程序將可以參與 JTA 事務。一個 XADataSource 對象就是一個 XAConnection 對象的工廠。 XAConnection s 是參與 JTA 事務的 JDBC 連接。」
要使用JTA事務，必須使用XADataSource來產生資料庫連接，產生的連接為一個XA連接。
XA連接（javax.sql.XAConnection）和非XA（java.sql.Connection）連接的區別在於：XA可以參與JTA的事務，而且不支持自動提交。
注意:
Oracle, Sybase, DB2, SQL Server等大型資料庫才支持XA, 支持分布事務。
My SQL 連本地都支持不好，更別說分布事務了。
JTA方式的實現過程：
用XADataSource產生的XAConnection它擴展了一個getXAResource()方法,事務通過這個方法把它加入到事務容器中進行 管理.對於調用者來說,根本看不到事務是如果管理的,你只要聲明開始事務,告訴容器我下面的操作要求事務參與了,最後告訴事務說到這兒可以提交或回滾了, 別的都是黑箱操作。
在使用JTA之前，你必須首先實現一個Xid類用來標識事務（在普通情況下這將由事務管理程序來處理）。Xid包含三個元素：formatID、gtrid（全局事務標識符）和bqual（分支修飾詞標識符）。
下面的例子說明Xid的實現：
import javax.transaction.xa.*;
public class MyXid implements Xid
{
protected int formatId;
protected byte gtrid[];
protected byte bqual[];
public MyXid()
{
}
public MyXid(int formatId, byte gtrid[], byte bqual[])
{
this.formatId = formatId;
this.gtrid = gtrid;
this.bqual = bqual;
}
public int getFormatId()
{
return formatId;
}
public byte[] getBranchQualifier()
{
return bqual;
}
public byte[] getGlobalTransactionId()
{
return gtrid;
}
}
其次，你需要創建一個你要使用的資料庫的數據源：
public DataSource getDataSource()
throws SQLException
{
SQLServerDataSource xaDS = new
com.merant.datadirect.jdbcx.sqlserver.SQLServerDataSource();
xaDS.setDataSourceName("SQLServer");
xaDS.setServerName("server");
xaDS.setPortNumber(1433);
xaDS.setSelectMethod("cursor");
return xaDS;
}
例1 這個例子是用「兩步提交協議」來提交一個事務分支：
XADataSource xaDS;
XAConnection xaCon;
XAResource xaRes;
Xid xid;
Connection con;
Statement stmt;
int ret;
xaDS = getDataSource();
xaCon = xaDS.getXAConnection("jdbc_user", "jdbc_password");
xaRes = xaCon.getXAResource();
con = xaCon.getConnection();
stmt = con.createStatement();
xid = new MyXid(100, new byte[]{0x01}, new byte[]{0x02});
try {
xaRes.start(xid, XAResource.TMNOFLAGS);
stmt.executeUpdate("insert into test_table values (100)");
xaRes.end(xid, XAResource.TMSUCCESS);
ret = xaRes.prepare(xid);
if (ret == XAResource.XA_OK) {
xaRes.commit(xid, false);
}
}
catch (XAException e) {
e.printStackTrace();
}
finally {
stmt.close();
con.close();
xaCon.close();
}
當然，實際過程中，我們不需要寫這些代碼，這些代碼是JTA最終的實現代碼。
關於「兩步提交協議」，可以參看下面的文章：
http://www.ibm.com/developerworks/cn/db2/library/techarticles/dm-0505weber/index.html
兩階段提交（Two-Phase-Commit）協議
首先，兩階段提交（Two-Phase-Commit）事務的啟動與常規的單階段提交（One-Phase-Commit）事務類似。接著，應用程序/客 戶機對該兩階段提交（Two-Phase-Commit）操作中所涉及的所有資料庫執行其修改工作。現在，在最終提交該事務之前，客戶機通知參與的資料庫准備提交（第 1 階段）。如果客戶機從資料庫收到一條「okay」，就發出命令向資料庫提交該事務（第 2 階段）。最後分布式事務（Distributed Transaction）結束。
上面的例子演示了如何在 Java 中使用 JTA 實現兩階段提交（Two-Phase-Commit）協議。在該應用程序中，如果一個事務分支報告了錯誤，您就要負責進行錯誤處理。但是「兩階段提交協議 簡介」小節中提到仍然存在一個問題，那就是如果第 2 階段中一個事務分支發生故障，該怎麼辦呢？
如果再次查看程序代碼，您可以看到在「第 1 階段」和「第 2 階段」之間有一個很小的時間間隔。在這一時間間隔中，出於某種理由，其中某一參與資料庫可能崩潰。如果發生了，我們將陷入分布式事務已經部分提交的情形中。
假 定下列情形：在「第 1 階段」之後，您從 DB2 和 IDS 資料庫中都收到了「okay」。在下一步中，應用程序成功提交了 DB2 的事務分支。接著，應用程序通知 DB2 事務分支提交事務。現在，在應用程序可以通知 IDS 事務分支提交它這一部分之前，IDS 引擎由於斷電發生崩潰。這就是一種部分提交全局事務的情形。您現在該怎麼辦呢？
在重啟之後，DB2 和 IDS 都將嘗試恢復打開的事務分支。該引擎等待來自應用程序的提示如何做。如果應用程序沒有準備重新發送「第 2 階段」的提交，該事務分支將被引擎所啟動的試探性回滾中止。這是非常糟糕的，因為這將使該全局事務處於不一致狀態。
一種解決方案是用一個小型應用程序連接引擎中打開的事務分支，並通知引擎提交或回滾這一打開的事務。如果您使用 IDS 作為後端，那麼還有一個隱藏的 onmode 標志，允許您結束打開的事務分支。（onmode -Z xid）。
在 DB2 UDB 中，您可以發出 LIST INDOUBT TRANSACTIONS 來獲得打開的 XA 事務的有關信息。您必須查看 DB2 Information Center 中的描述來解決該問題。
上面描述的情形是一個很好的例子，也是使用應用程序伺服器（Application Server）或事務監控器（Transaction Monitor）的理由。在使用一個中間層伺服器時，就由該伺服器負責保持事情正常。
B. jdbc有哪些事務，各個事務特點
事務的：原子性、一致性、分離性、持久性
原子性、一致性、分離性、持久性
(1) 原子性
事務的原子性指的是，事務中包含的程序作為資料庫的邏輯工作單位，它所做的對數據修改操作要麼全部執行，要麼完全不執行。這種特性稱為原子性。
事務的原子性要求，如果把一個事務可看作是一個程序，它要麼完整的被執行，要麼完全不執行。就是說事務的操縱序列或者完全應用到資料庫或者完全不影響資料庫。這種特性稱為原子性。
假如用戶在一個事務內完成了對資料庫的更新，這時所有的更新對外部世界必須是可見的，或者完全沒有更新。前者稱事務已提交，後者稱事務撤消（或流產）。DBMS必須確保由成功提交的事務完成的所有操縱在資料庫內有完全的反映，而失敗的事務對資料庫完全沒有影響。
(2) 一致性
事務的一致性指的是在一個事務執行之前和執行之後資料庫都必須處於一致性狀態。這種特性稱為事務的一致性。假如資料庫的狀態滿足所有的完整性約束，就說該資料庫是一致的。
一致性處理資料庫中對所有語義約束的保護。假如資料庫的狀態滿足所有的完整性約束，就說該資料庫是一致的。例如，當資料庫處於一致性狀態S1時，對資料庫執行一個事務，在事務執行期間假定資料庫的狀態是不一致的，當事務執行結束時，資料庫處在一致性狀態S2。
(3) 分離性
分離性指並發的事務是相互隔離的。即一個事務內部的操作及正在操作的數據必須封鎖起來，不被其它企圖進行修改的事務看到。
分離性是DBMS針對並發事務間的沖突提供的安全保證。DBMS可以通過加鎖在並發執行的事務間提供不同級別的分離。假如並發交叉執行的事務沒有任何控制，操縱相同的共享對象的多個並發事務的執行可能引起異常情況。
DBMS可以在並發執行的事務間提供不同級別的分離。分離的級別和並發事務的吞吐量之間存在反比關系。較多事務的可分離性可能會帶來較高的沖突和較多的事務流產。流產的事務要消耗資源，這些資源必須要重新被訪問。因此，確保高分離級別的DBMS需要更多的開銷。
(4)持久性
持久性意味著當系統或介質發生故障時，確保已提交事務的更新不能丟失。即一旦一個事務提交，DBMS保證它對資料庫中數據的改變應該是永久性的，耐得住任何系統故障。持久性通過資料庫備份和恢復來保證。
持久性意味著當系統或介質發生故障時，確保已提交事務的更新不能丟失。即對已提交事務的更新能恢復。一旦一個事務被提交，DBMS必須保證提供適當的冗餘，使其耐得住系統的故障。所以，持久性主要在於DBMS的恢復性能。
C. Jdbc中是否支持事務,如果支持包含了哪些
事務處理是在針對資料庫操作時一個重要環節，它可以保證執行多條記錄的一致性，實現資料庫中表與表之間的關聯，同時提高了對數據操作的准確性、安全性。本文主要一起來學習在Java程序中如何使用JDBC來實現數據間的事務處理。
一、什麼是事務處理
事務處理就是當執行多個SQL指令時，如果因為某個原因使其中一條指令執行有錯誤，則取消先前執行過的所有指令。它的作用是保證各項操作的一致性和完整性。
二、JDBC中的事務控制
JDBC API中的JDBC事務是通過Connection對象進行控制的。Connection對象提供了兩種事務模式：自動提交模式和手工提交模式。系統默認為自動提交模式，即，對資料庫進行操作的每一條記錄，都被看作是一項事務。操作成功後，系統會自動提交，否則自動取消事務。 如果想對多個SQL進行統一的事務處理，就必須先取消自動提交模式，通過使用Connection 的setAutoCommit(false) 方法來取消自動提交事務。Connection類中還提供了如下其他控制事務的方法：
1）public boolean getAutoCommit()：判斷當前事務模式是否為自動提交，如果是則返回ture，否則返回false；
2）public void commit()：提交事務；
3）public void rollback()：回滾事務；
注意：
Java中使用JDBC事務處理，一個JDBC不能跨越多個資料庫而且需要判斷當前使用的資料庫是否支持事務。這時可以使用 DatabaseMedaData 的supportTranslations() 方法進行檢查資料庫是否支持事務處理，若返回 true 則說明支持事務處理，否則返回 false 。如使用MySQL 的事務功能，就要求MySQL里的表的類型為Innodb才支持事務控制處理，否則，在Java程序中做了 commit 或 rollback ，但資料庫中是不生效的。
三、JDBC 事務處理基本流程
實現事務處理的基本流程如下：
1）判斷當前使用的JDBC驅動程序和資料庫是否支持事務處理；
2）在支持事務處理的前提下，取消系統自動提交模式；
3）添加需要進行的事務信息；
4）將事務處理提交到資料庫；
5）在處理事務時，若某條信息發生錯誤，則執行事務回滾操作，並回滾到事務提交前的狀態。
四、事務處理的實例
利用JDBC實現事務處理的實例，將4條SQL語句加在同一個事務里，當其中一條語句發生錯誤時，則執行事務回滾，取消所有的操作。所以在最後的運行結果中，並沒有發現有數據更新。
1、具體的代碼如下：
[java] view plain
package chp07;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Java_Transa {
// 資料庫連接
public static Connection getConnection() {
Connection con = null;
try {
Class.forName("com.mysql.jdbc.Driver"); // 載入Mysql數據驅動
con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/myuser", "root", "root"); // 創建數據連接
} catch (Exception e) {
System.out.println("資料庫連接失敗");
}
return con;
}
// 判斷資料庫是否支持事務
public static boolean JudgeTransaction(Connection con) {
try {
// 獲取資料庫的元數據
DatabaseMetaData md = con.getMetaData();
// 獲取事務處理支持情況
return md.supportsTransactions();
} catch (SQLException e) {
e.printStackTrace();
}
return false;
}
// 將一組SQL語句放在一個事務里執行，要麼全部執行通過，要麼全部不執行
public static void StartTransaction(Connection con, String[] sqls) throws Exception {
if (sqls == null) {
return;
}
Statement sm = null;
try {
// 事務開始
System.out.println("事務處理開始！");
con.setAutoCommit(false); // 設置連接不自動提交，即用該連接進行的操作都不更新到資料庫
sm = con.createStatement(); // 創建Statement對象
//依次執行傳入的SQL語句
for (int i = 0; i < sqls.length; i++) {
sm.execute(sqls[i]);// 執行添加事物的語句
}
System.out.println("提交事務處理！");
con.commit(); // 提交給資料庫處理
System.out.println("事務處理結束！");
// 事務結束
//捕獲執行SQL語句組中的異常
} catch (SQLException e) {
try {
System.out.println("事務執行失敗，進行回滾！\n");
con.rollback(); // 若前面某條語句出現異常時，進行回滾，取消前面執行的所有操作
} catch (SQLException e1) {
e1.printStackTrace();
}
} finally {
sm.close();
}
}
// 查詢表 staff
public static void query_student() throws Exception {
Connection conect = getConnection(); // 獲取連接
System.out.println("執行事物處理後，表 staff 的全部記錄為：\n");
try {
String sql = "select * from staff"; // 查詢數據的sql語句
Statement st = (Statement) conect.createStatement(); // 創建Statement對象
ResultSet rs = st.executeQuery(sql); // 執行SQL語句並返回查詢數據的結果集
//列印輸出查詢結果
while (rs.next()) { // 判斷是否還有下一個數據
// 根據欄位名獲取相應的值
String name = charset(rs.getString("name"));
int age = rs.getInt("age");
String sex = charset(rs.getString("sex"));
String depart = charset(rs.getString("depart"));
String address = charset(rs.getString("address"));
int worklen = rs.getInt("worklen");
int wage = rs.getInt("wage");
System.out.println(name + " " + age + " " + sex + " "
+ address + " " + depart + " " + worklen + " " + wage);
}
System.out.println();
} catch (SQLException e) {
System.out.println("查詢數據失敗");
}
}
// 字元集的設定，解決中文亂碼
public static String charset(String str) throws Exception {
String newStr = new String(str.getBytes("ISO8859-1"), "UTF-8");
return newStr;
}
public static void main(String[] args) throws Exception {
String[] arry = new String[4]; // 定義一組事物處理語句
arry[0] = "delete from staff where name='Serein'"; //刪除staff表格中 name 欄位值為 "Serein" 的員工記錄
arry[1] = "UPDATE staff SET address='Shenzhen' where name=lili";// 執行這條語句會引起錯誤，因為表 staff 中name='lili'不存在
arry[2] = "INSERT INTO student (name,age,sex,address,depart,worklen,wage)" //SQL插入記錄語句
+ "values ('Allen',19,'M','Beijing','Engine',4,4800)";
arry[3] = "select * from staff"; //SQL查詢表 staff 語句
Connection con = null;
try {
con = getConnection(); // 獲得資料庫連接
boolean judge = JudgeTransaction(con); // 判斷是否支持批處理
System.out.print("支持事務處理嗎？ ");
System.out.println(judge ? "支持" : "不支持");
if (judge) {
StartTransaction(con, arry); // 如果支持則開始執行事務
}
} catch (Exception e) {
e.printStackTrace();
} finally {
con.close(); // 關閉資料庫連接
}
query_student();
}
}
說明：該Java程序中資料庫操作涉及的資料庫為 「myuser 」 ，並使用其中的 「staff」 表格，也就是我之前的文章《JDBC連接MySQL資料庫及示例》里所創建的資料庫和表。如果需要跟著去實現並運行這個例子的話，可以前去參考創建，或者根據你自己的資料庫情況去修改其中有關連接MySQL的代碼以及SQL語句。
附上程序運行前的「staff」表格中的數據：
注意觀察裡面的第三條記錄，即 name 欄位值為「Seren」的記錄。即將運行的 Java 程序的第113代碼中的 SQL 語句表示要刪除該條記錄，但是由於後面的事務出錯，所以全部的事務不執行，並回滾，所以最後的結果是name為「Serein」這條記錄依舊存在於數據表中。
D. jdbc的事務和jdbc傳統的crud有什麼區別
在jdbc的資料庫操作中，一項事務是由一條或是多條表達式所組成的一個不可分割的工作單元。我們通過提交commit()或是回滾rollback（）來結束事務的操作。關於事務操作的方法都位於介面java.sql.Connection中。
2． 特點：
★ 在jdbc中，事務操作預設是自動提交。也就是說，一條對資料庫的更新表達式代表一項事務操作，操作成功後，系統將自動調用commit()來提交，否則將調用rollback()來回滾。
★ 在jdbc中，可以通過調用setAutoCommit(false)來禁止自動提交。之後就可以把多個資料庫操作的表達式作為一個事務，在操作完成後調用commit()來進行整體提交，倘若其中一個表達式操作失敗，都不會執行到commit()，並且將產生響應的異常；此時就可以在異常捕獲時調用rollback()進行回滾。這樣做可以保持多次更新操作後，相關數據的一致性，示例如下：
try {
conn = DriverManager.getConnection ；
conn.setAutoCommit(false);//禁止自動提交，設置回滾點
stmt = conn.createStatement()；
stmt.executeUpdate(「alter table …」); //資料庫更新操作1
stmt.executeUpdate(「insert into table …」); //資料庫更新操作2
conn.commit(); //事務提交
}catch(Exception ex) {
ex.printStackTrace();
try {
conn.rollback(); //操作不成功則回滾
}catch(Exception e) {
e.printStackTrace();
}
}
最後一句話，傳統CRUD就是走一步算一步，事務就是要做一起做，要不就都撤銷。
E. 請問jdbc處理事務的時候，為什麼非要保證同一個資料庫鏈接
第一 JDBC是Java中操作資料庫數據的規范，注意是規范和標准，除此之外別無它號，即使Hibernite，Batis 也是要建立在JDBC基礎上的。JDBC定義了如何鏈接資料庫（Connection），如何操作數據（ResultSet，Stement）和事務管理（Transcation ，SavePoint...)，JDBC具體的實現是由資料庫廠商或第三方提供。
第二理論上說，不用JDBC也可以直接操作資料庫，但是很多情況下這些東西是無法實現的，比如在鏈接一個資料庫時廠商會對通訊協議中的部分內容保密僅提供資料庫驅動，很難查找到相關的資料,即使有也會涉及到版權這些問題。除此之外上層的數據操作介面也要重新定義和編寫。
第三 其實JDBC 發展到現在 4.X 版本已經很優秀了，畢竟我們沒有必要重新發明輪子
F. java程序如何藉助jdbc定義一個事務
1. 事務是具備以下特徵(ACID)的工作單元：
原子性（Atomicity）—— 如果因故障而中斷，則所有結果均被撤消；
一致性（Consistency）—— 事務的結果保留不變；
孤立性（Isolation）—— 中間狀態對其它事務是不可見的；
持久性（Durability）—— 已完成的事務結果上持久的。
原子操作，也就是不可分割的操作，必須一起成功一起失敗。
2. 事務處理四步曲：（事務是一個邊界）
① connection.setAutoCommit(false); //把自動提交關閉
② 正常的DB操作 //若有一條SQL語句失敗了，自動回滾
③ connection.commit() //主動提交
或 connection.rollback() //主動回滾
4. Con.close();關閉資料庫鏈接
3. JDBC事務並發產生的問題和事務隔離級別
完整的代碼片段：
try{
con.setAutoCommit(false); //step① 把自動提交關閉
Statement stm = con.createStatement();
stm.executeUpdate("insert into person(id, name, age) values(520, 'X-Man', 18)");
stm.executeUpdate("insert into Person(id, name, age) values(521, 'Super', 19)");
//step② 正常的DB操作
con.commit(); //step③ 成功主動提交
} catch(SQLException e){
Try {
con.rollback();
} Catch (Exception e) {
e.printStackTrace();
} //step③ 失敗則主動回滾
} finally{
//4關閉連接
If(con!=null){
Con.close();
}
}
G. JAVA-JDBC連接資料庫一個問題：我採用通過事務提交添加屬性值，為什麼沒有雖然沒有添加，但是ID自動增加
首先自增ID本來就被設計成為不參與資料庫事務的，原因是什麼呢？為了防止ID生成阻塞和防止ID錯亂，因為對了一張表來說，不是只有你一個線程在申請ID，其他的新增線程了也在申請ID，假設你在事務中第一次申請到了ID=1，但這時你的事務並沒提交，也就是這個等於1的ID現在並沒有真正入庫，想想這時別人的進程也去申請同一個表的ID時，ID生成器該給他1還是2？當然是2啦！如果你這時你回滾你的事務，假設事務把ID=1回滾了，給回ID生成器，ID生成器還能把它給出去別人用么？肯定不行啦，為啥，如果這時那個上次拿到2的線程這次又去拿，不是要拿到1了？說好的自增呢？！也許你會說可以等你下次申請ID時給你呀，把3給剛剛那個拿了2的呀，不好意思，資料庫會話(SqlSession)一關，誰記得你呀！
H. 網頁顯示無法打開JDBC連接事務;嵌套異常java.sql.SQLException:無法連接、 如何處理這種問題
這種情況一般是資料庫連接串有問題，沒設置對，或者連接池用戶數已經滿都可能出現無法鏈接的問題。
如果鏈接正常，而僅僅在做事務處理的時候有異常。
可能的情況：你的當前資料庫鏈接在已經啟動一個事務，未提交的情況下，又開啟了一個新的事務。造成要操作的數據表鎖定。
如果數據鏈接正常的話，樓主要給出更詳細的信息才能判斷。。
I. 關於jdbc中資料庫事務的提交和回滾
首先，連接資料庫異常，可能是資料庫JDBC連接問題，也可能是驅動問題。
第二，沒找到資料庫
第三，資料庫欄位拼寫錯誤。
第四，SQL語句錯誤
第五，還沒發現。呵呵。這個是我最近2天遇到的問題。。。都在這里啦。。
J. 如何通過jdbc連接mysql資料庫
在網上搜索jdbc代碼。很多的。
1.引入mysql連接驅動jar包。
2.建立連接；
3.注冊驅動；
4.提交連接（url,username,password）;
5.執行增刪改等；
6.注意事務處理；
7.使用完關閉連接。