JDBC連接(MySql)數據庫步驟，以及查詢、插入、刪除、更新等十一個處理數據庫信息的功能。

本文轉載自查看原文 2015-09-25 08:35 47419 JavaWeb

主要內容：

JDBC連接數據庫步驟。
一個簡單詳細的查詢數據的例子。
封裝連接數據庫，釋放數據庫連接方法。
實現查詢，插入，刪除，更新等十一個處理數據庫信息的功能。（包括事務處理，批量更新等）
把十一個功能都放在一起。
安裝下載的數據庫驅動程序jar包,不同的數據庫需要不同的驅動程序(這本該是第一步，但是由於屬於安裝類，所以我們放在最后)

一.JDBC連接數據庫(編輯)步驟(主要有六個步驟)。

1.注冊驅動： Class.forName("com.mysql.jdbc.Driver");顯示的加載到JVM中

2.獲取連接：(1) param1: 要連接數據庫的url-----》 String url="jdbc:mysql://localhost:3306/test?"+ "useUnicode=true&characterEncoding=UTF8";//防止亂碼

param2：要連接數據庫的用戶名--》 String user="h4";

param3：要連接數據庫的密碼----》 String pass="111";

Connection conn=DriverManager.getConnection(url,user,pass)；//DriverManager下的方法：getConnection(String url,String username,String password)

(2)接下來我們分析下url："jdbc(這是協議以jdbc開頭):mysql(這是子協議，數據庫管理系統名稱)://localhost(數據庫來源地址):3306(目標端口)/test(要查詢的表)?"

"useUnicode=true&characterEncoding=UTF8";添加這個是為了防止亂碼，指定使用Unicode字符集，且使用UTF-8來編輯。

3.創建一個Statement語句對象(主要三種方法): Statement stmt=conn.createStatement();//Connection接口下的方法：Statement createStatement()

PreparedStatement pstmt = conn.PreparedStatement() ;

CallableStatement cstmt = conn.prepareCall("{CALL demoSp(? , ?)}") ;

下面我們來分析下他們：(1) Statement與 PreparedStatement對象的區別，后者可以動態設置查詢參數

(2)設置參數的方法 PreparedStatement.setXXXX(parameterIndex,value)，如果數據庫參數類型是varchar 則用setString，如果參數類型是Integer 則用setInt

(3)CallableStatement.setXXXX(parameterIndex,value) //按照參數的順序設置value

CallableStatement.setXXXX(parameterName,value) //按照參數的名字來設置value,這個名字是在定義存儲過程的時候的形式參數的名字

(4)CallableStatement.registerOutParameter方法用於聲明一個存儲過程輸出類型的參數，用以接收存儲過程的輸出值

4.執行SQL語句: ResultSet rs=stmt.executeQuery(Sql);除了查詢語句是executeQuery();其他全部是executeUpdate();

Statement接口下的方法：

boolean execute(String sql):執行SQL語句，如果返回值是結果集則為true,否則為false

ResultSet executeQuery(String sql):執行SQL語句，返回值為ResultSet

int executeUpdate(String sql):執行SQL語句，返回值為所影響的行數

5.處理結果集：ResultSet對象的getXxxx方法，取決於數據庫中表的字段的類型，例如：varchar2 對應方法是getString ,如果是 integer 對應方法是getInt/getLong

While(rs.next()){

rs.getInt(columnIndex); //通過列的序號來獲取字段的值

rs.getString(columnName);//通過列的名字來獲取字段的值

ResultSet接口下常見的方法：beforeFirst();將游標移動到ResultSet中第一條記錄(的前面)

afterLast();將游標移動到ResultSet中最后一條記錄(的后面)

absolute(intcolumn):將游標移動到相對於第一行的指定行，負數則為相對於最后一條記錄

previous():將游標上移一行

next():將游標下移一行

ResultSet.TYPE_SCROLL_SENSITIVE 結果集可以滾動

ResultSet.CONCUR_READ_ONLY 結果集只讀，不能修改

6.關閉資源：操作完以后要關閉jdbc來釋放jdbc資源。但是順序要和你定義對象的時候相反，就像關門一樣，從里面先關，一直往外關。

如下示例：

if(rs !=null){//1.關閉結果集
try{
rs.close();
} catch (SQLException e){
e.printStackTrace();
}
}
if(stmt !=null){//2.關閉聲明的對象
try{
stmt.close();
}catch(SQLException e){
e.printStackTrace();
}
}
if(conn !=null){//3.關閉連接（記住一定要先關閉前面的1.2.然后在關閉連接）
try{
conn.close();
}catch(Exception e){
e.printStackTrace();
}
}

二.下面是一個簡單的(詳細的)查詢數據的例子。

 1 package javacore1;//這是你建的一個包名。
 2 
 3 import java.sql.CallableStatement;
 4 import java.sql.Connection;
 5 import java.sql.DriverManager;
 6 import java.sql.PreparedStatement;
 7 import java.sql.ResultSet;         //左邊這五個是你在寫程序時要導入的包名，記住是要在java.sql下的包。
 8 import java.sql.SQLException;
 9 import java.sql.Statement;
10 public class jdbc { //定義一個類
11    public static void main(String[] args){ //主方法
12       try{
13           String driver="com.mysql.jdbc.Driver";              //1.定義驅動程序名為driver內容為com.mysql.jdbc.Driver
14           String url="jdbc:mysql://localhost:3306/test?"      //2.定義url；jdbc是協議；mysql是子協議：表示數據庫系統管理名稱；localhost：3306是你數據庫來源的地址和目標端口；test是我本人建的表位置所在處，你以你的為標准。
15                   + "useUnicode=true&characterEncoding=UTF8"; //防止亂碼；useUnicode=true表示使用Unicode字符集；characterEncoding=UTF8表示使用UTF-8來編輯的。
16           String user="h4";                                   //3.定義用戶名，寫你想要連接到的用戶。
17           String pass="111";                                  //4.用戶密碼。
18           String querySql="select * from employees";          //5.你想要查找的表名。
19           Class.forName(driver);                              //6.注冊驅動程序，用java.lang包下面的class類里面的Class.froName();方法 此處的driver就是1里面定義的driver，也可以  Class.forName("com.mysql.jdbc.Driver");
21           Connection conn=DriverManager.getConnection(url,user,pass);//7.獲取數據庫連接,使用java.sql里面的DriverManager的getConnectin(String url , String username ,String password )來完成
22                                                                              //括號里面的url，user，pass便是前面定義的2,3,4步驟內容；
23           Statement stmt=conn.createStatement();   //8.構造一個statement對象來執行sql語句：主要有Statement，PreparedStatement，CallableStatement三種實例來實現
24                                                    //    三種實現方法分別為：Statement stmt = con.createStatement() ;  
25                                                      //                   PreparedStatement pstmt = conn.prepareStatement(sql) ;   
26                                                      //                   CallableStatement cstmt =  conn.prepareCall("{CALL demoSp(? , ?)}") ;
27           ResultSet rs=stmt.executeQuery(querySql);//9.執行sql並返還結束 ；ResultSet executeQuery(String sqlString)：用於返還一個結果集（ResultSet）對象。
28      while(rs.next()){    //10.遍歷結果集 
29           System.out.println("人員編號:"+rs.getString("employee_id")+"工資:"+rs.getString("salary")+"姓名:"+rs.getString("last_name"));//使用getString()方法獲取你表里的資料名
30            }
31      if(rs !=null){//11.關閉記錄集
32           try{
33               rs.close();
34           } catch (SQLException e){
35             e.printStackTrace();
36            }
37          }
38      if(stmt !=null){//12.關閉聲明的對象
39           try{
40               stmt.close();
41           }catch(SQLException e){
42            e.printStackTrace();
43            }
44          }
45      if(conn !=null){//13.關閉連接 （記住一定要先關閉前面的11.12.然后在關閉連接，就像關門一樣，先關里面的，最后關最外面的）
46           try{
47               conn.close();
48           }catch(SQLException e){
49             e.printStackTrace();
50           }
51         }
52           }catch(Exception e){
53            e.printStackTrace();
54           }
55         }
56     }

三.為了更加直觀，我們把獲取數據庫連接和釋放連接封裝在方法里，以便於后面更好的操作。

 1 package javacore1;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 
 6 public class jdbc{
 7     public static void main(String[] args){
 8           
 9     Connection conn= getConnection("h4", "111"); //獲取數據庫連接
10 
11     /*,,,,此處為方法名來獲取連接,例如 query(conn),,,,,*/
12     
13         releaseConnection(conn); // 釋放數據庫連接
14    }
15      
16     /*,,,,,,,,,,此處構建一個你想要的功能的方法,,,,,,,,,,,,*/
17 
18 
19 //數據庫連接
20 public static Connection getConnection(String user, String pass) {
21              
22               Connection conn = null;//聲明連接對象
23               String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
24               String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
25                          + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
26        try {
27             Class.forName(driver);// 注冊(加載)驅動程序
28             conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
29            } catch (Exception e) {
30              e.printStackTrace();
31           }
32             return conn;
33          }
34 // 釋放數據庫連接
35 public static void releaseConnection(Connection conn) {
36          try {
37               if (conn != null)
38                    conn.close();
39              } catch (Exception e) {
40                e.printStackTrace();
41              }
42          }
43      }

四.實現查詢、插入、刪除、更新等十一個處理數據庫信息的功能。

1.查詢數據

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.ResultSet;
 5 import java.sql.SQLException;
 6 import java.sql.Statement;
 7 public class Query {
 8     public static void main(String[] args) {
 9         Connection conn = getConnection("h4", "111");// 獲取數據庫連接
10             query(conn);     //方法名調用數據庫連接
11         releaseConnection(conn);//釋放數據庫連接
12   }
13 //查詢數據，定義的query方法
14 public static void query(Connection conn){
15         String Sql="select * from employees";
16         try{
17             Statement stmt=conn.createStatement(); //也可以使用PreparedStatement來做
18             ResultSet rs=stmt.executeQuery(Sql);//執行sql語句並返還結束
19                                                                        
20        while(rs.next()){//遍歷結果集 ，向下一行                              
21             System.out.println("人員編號:"+rs.getString("employee_id")+"工資:"+rs.getString("salary"));
22             }
23           if(rs !=null){
24             try{
25                 rs.close();
26             } catch (SQLException e){
27             e.printStackTrace();
28            }
29         }
30         if(stmt !=null){
31             try{
32                stmt.close();
33             }catch(SQLException e){
34              e.printStackTrace();
35           }
36         }
37         if(conn !=null){
38             try{
39                 conn.close();
40                }catch(SQLException e){
41                 e.printStackTrace();
42             }
43         }
44      }catch(Exception e){
45        e.printStackTrace();
46      }
47  }
48 //數據庫連接
49   public static Connection getConnection(String user, String pass) {
50             Connection conn = null;//聲明連接對象
51             String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
52             String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
53                        + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
54      try {
55           Class.forName(driver);// 注冊(加載)驅動程序
56           conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
57          } catch (Exception e) {
58            e.printStackTrace();
59         }
60           return conn;
61        }
62 //釋放數據庫連接
63   public static void releaseConnection(Connection conn) {
64        try {
65             if (conn != null)
66                  conn.close();
67            } catch (Exception e) {
68              e.printStackTrace();
69            }
70        }
71    }

//查詢數據，結果倒着顯示，倒序
package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Query {
    public static void main(String[] args) {
        Connection conn = getConnection("h4", "111");// 獲取數據庫連接
            query(conn);     //方法名調用數據庫連接
        releaseConnection(conn);//釋放數據庫連接
  }
//查詢數據，定義的query方法
public static void query(Connection conn){
        String Sql="select * from employees";
        try{
            Statement stmt=conn.createStatement(); //也可以使用PreparedStatement來做
            ResultSet rs=stmt.executeQuery(Sql);//執行sql語句並返還結束
            rs.afterLast();     //先跳到最后一行                                  
       while(rs.previous()){//遍歷結果集 ，向上一行                              
            System.out.println("人員編號:"+rs.getString("employee_id")+"工資:"+rs.getString("salary"));
            }
          if(rs !=null){
            try{
                rs.close();
            } catch (SQLException e){
            e.printStackTrace();
           }
        }
        if(stmt !=null){
            try{
               stmt.close();
            }catch(SQLException e){
             e.printStackTrace();
          }
        }
        if(conn !=null){
            try{
                conn.close();
               }catch(SQLException e){
                e.printStackTrace();
            }
        }
     }catch(Exception e){
       e.printStackTrace();
     }
 }
//數據庫連接
  public static Connection getConnection(String user, String pass) {
            Connection conn = null;//聲明連接對象
            String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
            String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
                       + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
     try {
          Class.forName(driver);// 注冊(加載)驅動程序
          conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
         } catch (Exception e) {
           e.printStackTrace();
        }
          return conn;
       }
//釋放數據庫連接
  public static void releaseConnection(Connection conn) {
       try {
            if (conn != null)
                 conn.close();
           } catch (Exception e) {
             e.printStackTrace();
           }
       }
   }

2.插入數據

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.SQLException;
 5 import java.sql.Statement;
 6 public class Insert {
 7     public static void main(String[] args) {
 8         Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
 9             insert(conn);    //方法名調用數據庫連接
10         releaseConnection(conn);// 釋放數據庫連接
11       }
12 //插入數據    
13      public static void insert(Connection conn) {  
14             try {  
15                   String sql = "insert into employees(employee_id,last_name,salary,department_id,userid)"  
16                         + " values ('100010', 'xiaogou', '7000','004','9')"; // 插入數據的sql語句  
17                   Statement stmt1 =conn.createStatement();    // 創建用於執行靜態sql語句的Statement對象  
18                   int count = stmt1.executeUpdate(sql);  // 執行插入操作的sql語句，並返回插入數據的個數       
19                System.out.println("向biao中插入了 " + count + " 條數據"); //輸出插入操作的處理結果  
20                conn.close();   //關閉數據庫連接  
21                 } catch (SQLException e) {  
22                   e.printStackTrace(); 
23              }  
24         }      
25 //數據庫連接
26     public static Connection getConnection(String user, String pass) {
27             Connection conn = null;//聲明連接對象
28             String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
29             String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
30                     + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
31             try {
32                 Class.forName(driver);// 注冊(加載)驅動程序
33                 conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
34             } catch (Exception e) {
35                 e.printStackTrace();
36             }
37              return conn;
38         }
39 //釋放數據庫連接
40     public static void releaseConnection(Connection conn) {
41             try {
42                 if (conn != null)
43                     conn.close();
44             } catch (Exception e) {
45                 e.printStackTrace();
46             }
47        }
48 }

3.刪除數據

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.SQLException;
 5 import java.sql.Statement;
 6 public class Delete {
 7     public static void main(String[] args) {
 8         Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
 9              delete(conn);    //方法名調用數據庫連接；
10         releaseConnection(conn);// 釋放數據庫連接
11 }
12 //刪除數據
13     public static void delete(Connection conn){
14         String Sql = "delete  from employees  where employee_id=100009";
15     try {
16          Statement stmt = conn.createStatement();// 或者用PreparedStatement方法
17          stmt.executeUpdate(Sql);//執行sql語句
18     if (stmt != null) {
19     try {
20          stmt.close();
21          } catch (SQLException e) {
22          e.printStackTrace();
23          }
24        }
25     } catch (SQLException e) {
26          e.printStackTrace();
27        }
28         
29     }
30 //數據庫連接
31     public static Connection getConnection(String user, String pass) {
32         Connection conn = null;//聲明連接對象
33         String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
34         String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
35                 + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
36         try {
37             Class.forName(driver);// 注冊(加載)驅動程序
38             conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
39         } catch (Exception e) {
40             e.printStackTrace();
41         }
42         return conn;
43     }
44 // 釋放數據庫連接
45     public static void releaseConnection(Connection conn) {
46         try {
47             if (conn != null)
48                 conn.close();
49         } catch (Exception e) {
50             e.printStackTrace();
51         }
52     }
53 }

4.更新數據

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.SQLException;
 5 import java.sql.Statement;
 6 public class Update {
 7     public static void main(String[] args) {
 8          Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
 9              update(conn);     //方法名調用數據庫連接
10          releaseConnection(conn);// 釋放數據庫連接
11      }
12 //更新數據  
13   public static void update(Connection conn){
14           String Sql = "update  employees set salary=8000 where employee_id=100005";
15     try {
16          Statement stmt1 = conn.createStatement();//或者用PreparedStatement方法
17          stmt1.executeUpdate(Sql);//執行sql語句
18     if (stmt1 != null) {
19          try {
20             stmt1.close();
21          } catch (SQLException e) {
22             e.printStackTrace();
23          }
24      }
25         } catch (SQLException e) {
26            e.printStackTrace();
27          }
28       }
29 //數據庫連接
30     public static Connection getConnection(String user, String pass) {
31         Connection conn = null;//聲明連接對象
32         String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
33         String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
34                 + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
35         try {
36             Class.forName(driver);// 注冊(加載)驅動程序
37             conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
38         } catch (Exception e) {
39             e.printStackTrace();
40         }
41          return conn;
42     }
43 // 釋放數據庫連接
44     public static void releaseConnection(Connection conn) {
45         try {
46             if (conn != null)
47                 conn.close();
48         } catch (Exception e) {
49             e.printStackTrace();
50         }
51     }
52 }

5.轉賬（事物處理）

JDBC處理事務通過關閉連接的自動提交實現的：

Connection.setAutoCommit(false);
提交事務：
Connection.commit();
回滾事務
回滾部分：
Connection.rollback(Savepoint);
全部回滾：
Connection.rollback();

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.Statement;
 5 public class TransCash {
 6     public static void main(String[] args) {
 7         Connection conn = getConnection("h3", "111111");// 獲取數據庫連接
 8             transCash(conn);   //方法名調用數據庫連接
 9         releaseConnection(conn);// 釋放數據庫連接
10   }
11 //轉賬(數據調換)(原來數據為100和500，實現這個功能后變成500和100，其實說白了就是更新數據，改數據)
12   public static void transCash(Connection conn){
13         Statement stmt = null;
14     try{
15           conn.setAutoCommit(false);//關閉自動提交
16             String sql = "update employees set salary=500 where employee_id=100001";
17             stmt = conn.createStatement();
18             stmt.executeUpdate(sql);            
19                   sql = "update employees set salary=100 where employee_id=100002";
20             stmt.executeUpdate(sql);//執行sql語句，上面的兩個工資將會調換

              //int i=1/0;如果這樣，那么將不可以完成任務，因為這是一個完整的事物，有一點失敗，將全部失敗
21           conn.commit();//提交事務
22        }catch(Exception e){
23          e.printStackTrace();
24        }finally{
25     try{
26          if(stmt != null){  stmt.close();
27             }catch(Exception e){
28               e.printStackTrace();
29             }
30           }
31         }
32 //數據庫連接
33     public static Connection getConnection(String user, String pass) {
34         Connection conn = null;//聲明連接對象
35         String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
36         String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
37                 + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
38         try {
39             Class.forName(driver);// 注冊(加載)驅動程序
40             conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
41         } catch (Exception e) {
42             e.printStackTrace();
43         }
44        return conn;
45     }
46 //釋放數據庫連接
47     public static void releaseConnection(Connection conn) {
48         try {
49             if (conn != null)
50                 conn.close();
51         } catch (Exception e) {
52             e.printStackTrace();
53         }
54     }
55 }

6.查找存儲過程無參數的

 1 package javacore1;
 2 import java.sql.CallableStatement;
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.SQLException;
 6 public class ExecProc {
 7     public static void main(String[] args) {
 8         Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
 9            execProc(conn);//方法名調用數據庫連接
10         releaseConnection(conn);// 釋放數據庫連接
11     }
12 //調用無參存儲過程；
13       public static void execProc(Connection conn){
14                String sql = "{call raisesalary}";
15           try {
16               CallableStatement cstmt = conn.prepareCall(sql);
17               cstmt.executeUpdate();
18           } catch (SQLException e) {
19             e.printStackTrace();
20           }
21        }
22 //數據庫連接
23         public static Connection getConnection(String user, String pass) {
24                 Connection conn = null;//聲明連接對象
25                 String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
26                 String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
27                         + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
28                 try {
29                     Class.forName(driver);// 注冊(加載)驅動程序
30                     conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
31                 } catch (Exception e) {
32                     e.printStackTrace();
33                 }
34                  return conn;
35             }
36 // 釋放數據庫連接
37         public static void releaseConnection(Connection conn) {
38                 try {
39                     if (conn != null)
40                         conn.close();
41                 } catch (Exception e) {
42                     e.printStackTrace();
43                 }
44            }
45     }

7.查找存儲過程有參數的

 1 package javacore1;
 2 import java.sql.CallableStatement;
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.Types;
 6 public class GetMulti {
 7     public static void main(String[] args) {
 8          Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
 9             int cnt = getMulti(conn);            //查找存儲過程；   
10             System.out.println("人員編號：" + cnt); 
11          releaseConnection(conn);// 釋放數據庫連接
12     }
13 //查找存儲過程有參
14     public static int getMulti(Connection conn) {
15            int dept_id = 100001;
16            int cnt = 0;
17            String sql = "{call calc_emp_count(?,?)}";
18         try {
19               CallableStatement cstmt = conn.prepareCall(sql);//初始化Statement對象
20               cstmt.setInt(1, dept_id);//CallableStatement.setxxx(參數，值)或者(數字,值),而PreparedStatement.setxxx(數字,值)只能這樣
21               cstmt.setInt(2, cnt);    //
22               cstmt.registerOutParameter(2, Types.INTEGER);//聲明輸出參數
23               cstmt.executeUpdate();//執行sql語句
24               cnt = cstmt.getInt(2);//獲取結果
25           if (cstmt != null) {
26                 cstmt.close();// 釋放Statement對象
27               }
28             } catch (Exception e) {
29               e.printStackTrace();
30           }
31            return cnt;
32       }
33 //數據庫連接
34     public static Connection getConnection(String user, String pass) {
35             Connection conn = null;//聲明連接對象
36             String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
37             String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
38                     + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
39             try {
40                 Class.forName(driver);// 注冊(加載)驅動程序
41                 conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
42             } catch (Exception e) {
43                 e.printStackTrace();
44             }
45              return conn;
46         }
47 //釋放數據庫連接
48     public static void releaseConnection(Connection conn) {
49             try {
50                 if (conn != null)
51                     conn.close();
52             } catch (Exception e) {
53                 e.printStackTrace();
54             }
55        }
56 }

8.普通處理

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.Date;
 4 import java.sql.DriverManager;
 5 import java.sql.PreparedStatement;
 6 import java.sql.SQLException;
 7 public class PlanInsert {
 8     public static void main(String[] args) {
 9         Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
10            planInsert(conn);    //方法名調用數據庫連接
11         releaseConnection(conn);// 釋放數據庫連接
12       }
13 //普通處理
14      public static void planInsert(Connection conn) {  
15          try {  
16                String sql = "insert into test_user1(userid,username,loadingtime)"  
17                      + " values (?,?,?)"; // 插入數據的sql語句  
18                PreparedStatement pstmt=conn.prepareStatement(sql);
19                long startTime=System.currentTimeMillis();
20              for(int i=0;i<1000;i++){
21                  pstmt.setLong(1, i);
22                  pstmt.setString(2, "user"+i);
23                  pstmt.setDate(3, new Date(System.currentTimeMillis()));
24                  pstmt.executeUpdate();
25              }
26          System.out.println("總共耗時："+(System.currentTimeMillis() - startTime));
27                pstmt.close();   //關閉數據庫連接  
28            } catch (SQLException e) {  
29              e.printStackTrace(); 
30          } 
31      }    
32 //數據庫連接
33     public static Connection getConnection(String user, String pass) {
34             Connection conn = null;//聲明連接對象
35             String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
36             String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
37                     + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
38             try {
39                 Class.forName(driver);// 注冊(加載)驅動程序
40                 conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
41             } catch (Exception e) {
42                 e.printStackTrace();
43             }
44              return conn;
45         }
46 //釋放數據庫連接
47     public static void releaseConnection(Connection conn) {
48             try {
49                 if (conn != null)
50                     conn.close();
51             } catch (Exception e) {
52                 e.printStackTrace();
53             }
54        }
55 }

9.批量處理

獲得原來JDBC事務的模式：

boolean currentTransactionModle = con.getAutoCommit();

設置成事務模式(關閉自動提交)：
con.setAutoCommit(false);
Statement stm = con.createStatement();
三個異構的sql語句：
String sql1 = "delete from user where id = 8";
String sql2 = "update user set name='java' where id = 7";
String sql3 = "insert into user(name,password) values('jdbc','jdbc')";
添加到Statement的批量處理緩沖區中：
stm.addBatch(sql1);
stm.addBatch(sql2);
stm.addBatch(sql3);
執行批量更新：
stm.executeBatch();
提交本次批量更新的事務：
con.commit();
回復原來的事務模式：
con.setAutoCommit(currentTransactionModle);

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.Date;
 4 import java.sql.DriverManager;
 5 import java.sql.PreparedStatement;
 6 import java.sql.SQLException;
 7 public class BatchInsert {
 8     public static void main(String[] args) {
 9         Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
10            batchInsert(conn);    //方法名調用數據庫連接
11         releaseConnection(conn);// 釋放數據庫連接
12       }
13 //批量插入的速度要比普通處理的速度快
14      public static void batchInsert(Connection conn) {  
15          try {  
16                String sql = "insert into test_user1(userid,username,loadingtime)"  
17                      + " values (?,?,?)"; // 插入數據的sql語句  
18                PreparedStatement pstmt=conn.prepareStatement(sql);
19                long startTime=System.currentTimeMillis();
20              for(int i=0;i<1000;i++){
21                  pstmt.setLong(1, i);
22                  pstmt.setString(2, "user"+i);
23                  pstmt.setDate(3, new Date(System.currentTimeMillis()));
24                  pstmt.addBatch();//添加到批量處理
25              }
26              int[] result=pstmt.executeBatch();
27           System.out.println("總共耗時："+(System.currentTimeMillis() - startTime));
28              pstmt.close();   //關閉數據庫連接  
29           } catch (SQLException e) {  
30              e.printStackTrace(); 
31          } 
32      }    
33 //數據庫連接
34     public static Connection getConnection(String user, String pass) {
35             Connection conn = null;//聲明連接對象
36             String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
37             String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
38                     + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
39             try {
40                 Class.forName(driver);// 注冊(加載)驅動程序
41                 conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
42             } catch (Exception e) {
43                 e.printStackTrace();
44             }
45              return conn;
46         }
47 //釋放數據庫連接
48     public static void releaseConnection(Connection conn) {
49             try {
50                 if (conn != null)
51                     conn.close();
52             } catch (Exception e) {
53                 e.printStackTrace();
54             }
55        }
56 }

10.分頁顯示

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 public class Paging {
 8     public static void main(String[] args) {
 9         Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
10             paging(conn,1,3);//方法名調用數據庫連接,且定義顯示第幾行到第幾行
11         releaseConnection(conn);// 釋放數據庫連接
12    }
13 //分頁查詢
14     public static void paging(Connection conn,int startIndex,int total){
15         try{
16             String sql="select * from employees limit ?,?";
17             PreparedStatement pstmt=conn.prepareStatement(sql);
18             pstmt.setInt(1, startIndex);
19             pstmt.setInt(2, total);
20             ResultSet rs=pstmt.executeQuery();
21         while(rs.next()){
22                 System.out.print("工號："+rs.getInt(1));
23                System.out.println("部門編號："+rs.getInt("department_id"));
24             }rs.close();
25             pstmt.close();
26           }catch(SQLException e){
27             e.printStackTrace();
28         }
29     }
30 //數據庫連接
31     public static Connection getConnection(String user, String pass) {
32             Connection conn = null;//聲明連接對象
33             String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
34             String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
35                     + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
36             try {
37                 Class.forName(driver);// 注冊(加載)驅動程序
38                 conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
39             } catch (Exception e) {
40                 e.printStackTrace();
41             }
42              return conn;
43         }
44 // 釋放數據庫連接
45     public static void releaseConnection(Connection conn) {
46             try {
47                 if (conn != null)
48                     conn.close();
49             } catch (Exception e) {
50                 e.printStackTrace();
51             }
52        }
53 }

11.結果集可以滾動

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 public class ScrpllResult {
 8     public static void main(String[] args) {
 9           Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
10              scrpllResult(conn);//方法名調用數據庫連接
11           releaseConnection(conn);// 釋放數據庫連接
12       }
13 //結果集滾動顯示
14     public static void scrpllResult(Connection conn){
15         try{
16             String sql="select * from employees";                         //結果集可以滾動      //並發性,結果集只讀，不可以修改
17             PreparedStatement pstmt=conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
18             ResultSet rs=pstmt.executeQuery();
19         while(rs.next()){  //向下一行遍歷
20                 System.out.print("工號："+rs.getLong(1));
21                 System.out.println("名字"+rs.getString("last_name"));
22            }while(rs.previous()){//向上一行遍歷
23                 System.out.print("工號："+rs.getLong(1));
24                 System.out.println("工資"+rs.getInt("salary"));
25              }
26                rs.absolute(6);//表示直接跳到第幾行
27             if(rs.next()){
28                 System.out.print("工號："+rs.getLong(1));
29                 System.out.println("..........部門編號："+rs.getString("department_id"));
30               }
31                 rs.close();
32                 pstmt.close();
33             }catch(SQLException e){
34                 e.printStackTrace();
35             }
36         }    
37 //數據庫連接
38     public static Connection getConnection(String user, String pass) {
39             Connection conn = null;//聲明連接對象
40             String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
41             String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
42                     + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
43             try {
44                 Class.forName(driver);// 注冊(加載)驅動程序
45                 conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
46             } catch (Exception e) {
47                 e.printStackTrace();
48             }
49              return conn;
50         }
51 // 釋放數據庫連接
52     public static void releaseConnection(Connection conn) {
53             try {
54                 if (conn != null)
55                     conn.close();
56             } catch (Exception e) {
57                 e.printStackTrace();
58             }
59        }
60 }

五.把上面十一個放在一起當然最方便省事。(需要用誰，只需把前面的注釋打開便行)

  1 package javacore1;
  2 import java.sql.CallableStatement;
  3 import java.sql.Connection;
  4 import java.sql.Date;
  5 import java.sql.DriverManager;
  6 import java.sql.PreparedStatement;
  7 import java.sql.ResultSet;
  8 import java.sql.SQLException;
  9 import java.sql.Statement;
 10 import java.sql.Types;
 11 public class jdbcMySql {
 12 public static void main(String[] args) {
 13     Connection conn = getConnection("h3", "111111");    // 獲取數據庫連接
 14            //query(conn); //1.查詢數據
 15            //insert(conn);//2.插入數據
 16            //delete(conn);//3.刪除數據
 17            //update(conn);//4.更新數據
 18            //transCash(conn);//5.轉賬
 19            //execProc(conn);//6.查找存儲過程無參數的
 20            //int cnt = getMulti(conn);//7.查找存儲過程有參數的   
 21            //System.out.println("人員編號：" + cnt);//查找存儲過程有參數的
 22            //planInsert(conn);//8.普通處理
 23            //batchInsert(conn);//9.批量處理
 24            // paging(conn,1,3);//10.分頁顯示
 25            //scrpllResult(conn);//11.結果集可以滾動
 26         releaseConnection(conn);// 釋放數據庫連接
 27      }
 28 //1.查詢數據，定義的query方法
 29 public static void query(Connection conn){
 30         String Sql="select * from employees";
 31         try{
 32             Statement stmt=conn.createStatement(); //也可以使用PreparedStatement來做
 33           ResultSet rs=stmt.executeQuery(Sql);//執行sql語句並返還結束
 34                                                    
 35      while(rs.next()){//遍歷結果集                               
 36             System.out.println("人員編號:"+rs.getString("employee_id")+"工資:"+rs.getString("salary"));
 37             }
 38           if(rs !=null){
 39             try{
 40                 rs.close();
 41             } catch (SQLException e){
 42             e.printStackTrace();
 43            }
 44         }
 45         if(stmt !=null){
 46             try{
 47                stmt.close();
 48             }catch(SQLException e){
 49              e.printStackTrace();
 50           }
 51         }
 52         if(conn !=null){
 53             try{
 54                 conn.close();
 55                }catch(SQLException e){
 56                 e.printStackTrace();
 57             }
 58         }
 59      }catch(Exception e){
 60        e.printStackTrace();
 61      }
 62 }
 63 //2.插入數據    
 64      public static void insert(Connection conn) {  
 65             try {  
 66                   String sql = "insert into employees(employee_id,last_name,salary,department_id,userid)"  
 67                         + " values ('100010', 'xiaogou', '7000','004','9')"; // 插入數據的sql語句  
 68                   Statement stmt1 =conn.createStatement();    // 創建用於執行靜態sql語句的Statement對象  
 69                   int count = stmt1.executeUpdate(sql);  // 執行插入操作的sql語句，並返回插入數據的個數       
 70                System.out.println("向biao中插入了 " + count + " 條數據"); //輸出插入操作的處理結果  
 71                conn.close();   //關閉數據庫連接  
 72                 } catch (SQLException e) {  
 73                   e.printStackTrace(); 
 74              }  
 75         }
 76 //3.刪除數據
 77     public static void delete(Connection conn){
 78             String Sql = "delete  from employees  where employee_id=100009";
 79         try {
 80              Statement stmt = conn.createStatement();// 或者用PreparedStatement方法
 81              stmt.executeUpdate(Sql);//執行sql語句
 82         if (stmt != null) {
 83         try {
 84              stmt.close();
 85              } catch (SQLException e) {
 86              e.printStackTrace();
 87              }
 88            }
 89         } catch (SQLException e) {
 90              e.printStackTrace();
 91            }
 92             
 93         }
 94 //4.更新數據  
 95     public static void update(Connection conn){
 96               String Sql = "update  employees set salary=8000 where employee_id=100005";
 97         try {
 98              Statement stmt1 = conn.createStatement();//或者用PreparedStatement方法
 99              stmt1.executeUpdate(Sql);//執行sql語句
100         if (stmt1 != null) {
101              try {
102                 stmt1.close();
103              } catch (SQLException e) {
104                 e.printStackTrace();
105              }
106          }
107             } catch (SQLException e) {
108                e.printStackTrace();
109              }
110           }    
111 //5.轉賬(數據調換)(原來數據為100和500，實現這個功能后變成500和100，其實說白了就是更新數據，改數據)
112   public static void transCash(Connection conn){
113             Statement stmt = null;
114         try{
115               conn.setAutoCommit(false);//關閉自動提交
116                 String sql = "update employees set salary=500 where employee_id=100001";
117                 stmt = conn.createStatement();
118                 stmt.executeUpdate(sql);            
119                       sql = "update employees set salary=100 where employee_id=100002";
120                 stmt.executeUpdate(sql);//執行sql語句，上面的兩個工資將會調換
121               conn.commit();//提交事務
122            }catch(Exception e){
123              e.printStackTrace();
124            }finally{
125         try{
126              if(stmt != null)stmt.close();
127                 }catch(Exception e){
128                   e.printStackTrace();
129                 }
130               }
131             }
132 //6.調用無參存儲過程；
133   public static void execProc(Connection conn){
134            String sql = "{call raisesalary}";
135       try {
136           CallableStatement cstmt = conn.prepareCall(sql);
137           cstmt.executeUpdate();
138       } catch (SQLException e) {
139         e.printStackTrace();
140       }
141    } 
142 //7.查找存儲過程有參
143   public static int getMulti(Connection conn) {
144            int dept_id = 100001;
145            int cnt = 0;
146            String sql = "{call calc_emp_count(?,?)}";
147         try {
148               CallableStatement cstmt = conn.prepareCall(sql);//初始化Statement對象
149               cstmt.setInt(1, dept_id);//CallableStatement.setxxx(參數，值)或者(數字,值),而PreparedStatement.setxxx(數字,值)只能這樣
150               cstmt.setInt(2, cnt);    //
151               cstmt.registerOutParameter(2, Types.INTEGER);//聲明輸出參數
152               cstmt.executeUpdate();//執行sql語句
153               cnt = cstmt.getInt(2);//獲取結果
154           if (cstmt != null) {
155                 cstmt.close();// 釋放Statement對象
156               }
157             } catch (Exception e) {
158               e.printStackTrace();
159           }
160            return cnt;
161       }
162 //8.普通處理
163      public static void planInsert(Connection conn) {  
164          try {  
165                String sql = "insert into test_user1(userid,username,loadingtime)"  
166                      + " values (?,?,?)"; // 插入數據的sql語句  
167                PreparedStatement pstmt=conn.prepareStatement(sql);
168                long startTime=System.currentTimeMillis();
169              for(int i=0;i<1000;i++){
170                  pstmt.setLong(1, i);
171                  pstmt.setString(2, "user"+i);
172                  pstmt.setDate(3, new Date(System.currentTimeMillis()));
173                  pstmt.executeUpdate();
174              }
175          System.out.println("總共耗時："+(System.currentTimeMillis() - startTime));
176                pstmt.close();   //關閉數據庫連接  
177            } catch (SQLException e) {  
178              e.printStackTrace(); 
179          } 
180      } 
181 //9.批量插入的速度要比普通處理的速度快
182     public static void batchInsert(Connection conn) {  
183              try {  
184                    String sql = "insert into test_user1(userid,username,loadingtime)"  
185                          + " values (?,?,?)"; // 插入數據的sql語句  
186                    PreparedStatement pstmt=conn.prepareStatement(sql);
187                    long startTime=System.currentTimeMillis();
188                  for(int i=0;i<1000;i++){
189                      pstmt.setLong(1, i);
190                      pstmt.setString(2, "user"+i);
191                      pstmt.setDate(3, new Date(System.currentTimeMillis()));
192                      pstmt.addBatch();//添加到批量處理
193                  }
194                  int[] result=pstmt.executeBatch();
195               System.out.println("總共耗時："+(System.currentTimeMillis() - startTime));
196                  pstmt.close();   //關閉數據庫連接  
197               } catch (SQLException e) {  
198                  e.printStackTrace(); 
199              } 
200          }
201 //10.分頁查詢
202    public static void paging(Connection conn,int startIndex,int total){
203             try{
204                 String sql="select * from employees limit ?,?";
205                 PreparedStatement pstmt=conn.prepareStatement(sql);
206                 pstmt.setInt(1, startIndex);
207                 pstmt.setInt(2, total);
208                 ResultSet rs=pstmt.executeQuery();
209             while(rs.next()){
210                     System.out.print("工號："+rs.getInt(1));
211                    System.out.println("部門編號："+rs.getInt("department_id"));
212                 }rs.close();
213                 pstmt.close();
214               }catch(SQLException e){
215                 e.printStackTrace();
216             }
217         }
218 //11.結果集滾動顯示
219      public static void scrpllResult(Connection conn){
220          try{
221              String sql="select * from employees";                         //結果集可以滾動                                               //並發性,結果集只讀，不可以修改
222              PreparedStatement pstmt=conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
223              ResultSet rs=pstmt.executeQuery();
224          while(rs.next()){  //向下一行遍歷
225                  System.out.print("工號："+rs.getLong(1));
226                  System.out.println("名字"+rs.getString("last_name"));
227             }while(rs.previous()){//向上一行遍歷
228                  System.out.print("工號："+rs.getLong(1));
229                  System.out.println("工資"+rs.getInt("salary"));
230               }
231                 rs.absolute(6);//表示直接跳到第幾行
232              if(rs.next()){
233                  System.out.print("工號："+rs.getLong(1));
234                  System.out.println("..........部門編號："+rs.getString("department_id"));
235                }
236                  rs.close();
237                  pstmt.close();
238              }catch(SQLException e){
239                  e.printStackTrace();
240              }
241          } 
242 //數據庫連接
243 public static Connection getConnection(String user, String pass) {
244           Connection conn = null;//聲明連接對象
245           String driver = "com.mysql.jdbc.Driver";// 驅動程序類名
246           String url = "jdbc:mysql://localhost:3306/test?" // 數據庫URL
247                      + "useUnicode=true&characterEncoding=UTF8";// 防止亂碼
248    try {
249         Class.forName(driver);// 注冊(加載)驅動程序
250         conn = DriverManager.getConnection(url, user, pass);// 獲取數據庫連接
251        } catch (Exception e) {
252          e.printStackTrace();
253       }
254         return conn;
255      }
256 //釋放數據庫連接
257 public static void releaseConnection(Connection conn) {
258      try {
259           if (conn != null)
260                conn.close();
261          } catch (Exception e) {
262            e.printStackTrace();
263          }
264      }
265  }

六.安裝下載的數據庫驅動程序jar包,不同的數據庫需要不同的驅動程序（但是安裝方法都是一樣的）

在使用JDBC編程時需要連接數據庫，導入JAR包是必須的，導入其它的jar包方法同樣如此，導入的方法是

打開eclipse

1.右擊要導入jar包的項目，點properties

2.左邊選擇java build path,右邊選擇libraries

3.選擇add External jars

4.選擇jar包的按照路徑下的
確定后就行了。

Java連接MySQL的最新驅動包下載地址

http://www.mysql.com/downloads/connector/j

1.鼠標放在你建的根目錄上面。右擊，然后選擇最下面的properties。

2.然后左邊選擇java build path,右邊選擇libraries ，在選擇右邊的add External jars ，選擇jar包的路徑，點擊確定就可以了

3.裝好后，圖如下出現你要添加的包。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 JDBC連接(MySql)數據庫步驟，以及查詢、插入、刪除、更新等十一個處理數據庫信息的功能 JDBC連接數據庫查詢信息的步驟（提取成配置文件方式） ThinkPHP 數據庫操作，插入，更新，刪除，查詢 JDBC連接數據庫實現刪除功能 jdbc連接數據庫的步驟 JDBC連接數據庫7個步驟 JDBC連接數據庫的步驟 JDBC連接數據庫的步驟 JDBC連接數據庫的7個步驟分頁查詢信息（使用jdbc連接mysql數據庫實現分頁查詢任務）