摘要：使用執行單元測試查詢獲取連接對象根據連接對象，得到執行語句，返回遍歷結果集查詢獲取連接對象根據連接對象，得到執行添加影響的行數，，如果大于表明操作成功。否則失敗更新成功更新失敗光標選中方法名字，然后右鍵執行單元測試。

文章有不當之處，歡迎指正，如果喜歡微信閱讀，你也可以關注我的微信公眾號：好好學java，獲取優質學習資源。

JAVA Database Connectivity java 數據庫連接.

JDBC（Java DataBase Connectivity,java數據庫連接）是一種用于執行SQL語句的Java API，可以為多種關系數據庫提供統一訪問，它由一組用Java語言編寫的類和接口組成。JDBC提供了一種基準，據此可以構建更高級的工具和接口，使數據庫開發人員能夠編寫數據庫應用程序，同時，JDBC也是個商標名。

SUN公司提供的一種數據庫訪問規則、規范, 由于數據庫種類較多，并且java語言使用比較廣泛，sun公司就提供了一種規范，讓其他的數據庫提供商去實現底層的訪問規則。 我們的java程序只要使用sun公司提供的jdbc驅動即可。

我們安裝好數據庫之后，我們的應用程序也是不能直接使用數據庫的，必須要通過相應的數據庫驅動程序，通過驅動程序去和數據庫打交道。其實也就是數據庫廠商的JDBC接口實現，即對Connection等接口的實現類的jar文件。

1.Driver接口

Driver接口由數據庫廠家提供，作為java開發人員，只需要使用Driver接口就可以了。在編程中要連接數據庫，必須先裝載特定廠商的數據庫驅動程序，不同的數據庫有不同的裝載方法。如：

裝載MySql驅動：Class.forName("com.mysql.jdbc.Driver");

裝載Oracle驅動：Class.forName("oracle.jdbc.driver.OracleDriver");

2.Connection接口

Connection與特定數據庫的連接（會話），在連接上下文中執行sql語句并返回結果。DriverManager.getConnection(url, user, password)方法建立在JDBC URL中定義的數據庫Connection連接上。

連接MySql數據庫：Connection conn = DriverManager.getConnection("jdbc:mysql://host:port/database", "user", "password");

連接Oracle數據庫：Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@host:port:database", "user", "password");

連接SqlServer數據庫：Connection conn = DriverManager.getConnection("jdbc:microsoft:sqlserver://host:port; DatabaseName=database", "user", "password");

常用方法：

createStatement()：創建向數據庫發送sql的statement對象。

prepareStatement(sql) ：創建向數據庫發送預編譯sql的PrepareSatement對象。

prepareCall(sql)：創建執行存儲過程的callableStatement對象。

setAutoCommit(boolean autoCommit)：設置事務是否自動提交。

commit() ：在鏈接上提交事務。

rollback() ：在此鏈接上回滾事務。

3.Statement接口

用于執行靜態SQL語句并返回它所生成結果的對象。

三種Statement類：

Statement：由createStatement創建，用于發送簡單的SQL語句（不帶參數）。

PreparedStatement ：繼承自Statement接口，由preparedStatement創建，用于發送含有一個或多個參數的SQL語句。PreparedStatement對象比Statement對象的效率更高，并且可以防止SQL注入，所以我們一般都使用PreparedStatement。

CallableStatement：繼承自PreparedStatement接口，由方法prepareCall創建，用于調用存儲過程。

常用Statement方法：

execute(String sql):運行語句，返回是否有結果集

executeQuery(String sql)：運行select語句，返回ResultSet結果集。

executeUpdate(String sql)：運行insert/update/delete操作，返回更新的行數。

addBatch(String sql) ：把多條sql語句放到一個批處理中。

executeBatch()：向數據庫發送一批sql語句執行。

4.ResultSet接口

ResultSet提供檢索不同類型字段的方法，常用的有：

getString(int index)、getString(String columnName)：獲得在數據庫里是varchar、char等類型的數據對象。

getFloat(int index)、getFloat(String columnName)：獲得在數據庫里是Float類型的數據對象。

getDate(int index)、getDate(String columnName)：獲得在數據庫里是Date類型的數據。

getBoolean(int index)、getBoolean(String columnName)：獲得在數據庫里是Boolean類型的數據。

getObject(int index)、getObject(String columnName)：獲取在數據庫里任意類型的數據。

ResultSet還提供了對結果集進行滾動的方法：

next()：移動到下一行

Previous()：移動到前一行

absolute(int row)：移動到指定行

beforeFirst()：移動resultSet的最前面。

afterLast() ：移動到resultSet的最后面。

使用后依次關閉對象及連接：ResultSet → Statement → Connection

1. 注冊驅動

DriverManager.registerDriver(new com.mysql.jdbc.Driver());

2. 建立連接

//DriverManager.getConnection("jdbc:mysql://localhost/test?user=SIHAI&password=SIHAI");
//2. 建立連接 參數一： 協議 + 訪問的數據庫 ， 參數二： 用戶名 ， 參數三： 密碼。

 conn = DriverManager.getConnection("jdbc:mysql://localhost/student", "root", "root");

3. 創建statement

//3. 創建statement ， 跟數據庫打交道，一定需要這個對象
st = conn.createStatement();

4. 執行sql ，得到ResultSet

//4. 執行查詢 ， 得到結果集
String sql = "select * from t_stu";
rs = st.executeQuery(sql);

5. 遍歷結果集

        //5. 遍歷查詢每一條記錄
         while(rs.next()){
             int id = rs.getInt("id");
             String name = rs.getString("name");
             int age = rs.getInt("age");
             System.out.println("id="+id + "===name="+name+"==age="+age);
                 
         }

6. 釋放資源

    if (rs != null) {
       try {
            rs.close();
        } catch (SQLException sqlEx) { } // ignore 
        rs = null;
    }
    

1. 資源釋放工作的整合

/**
     * 釋放資源
     * @param conn
     * @param st
     * @param rs
     */
    public static void release(Connection conn , Statement st , ResultSet rs){
        closeRs(rs);
        closeSt(st);
        closeConn(conn);
    }

    
    private static void closeRs(ResultSet rs){
        try {
            if(rs != null){
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            rs = null;
        }
    }
    
    private static void closeSt(Statement st){
        try {
            if(st != null){
                st.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            st = null;
        }
    }
    
    private static void closeConn(Connection conn){
        try {
            if(conn != null){
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            conn = null;
        }
    }

2. 驅動防二次注冊

/**
     * 獲取連接對象
     * @return
     */
    public static Connection getConn(){
        Connection conn = null;
        try {
            Class.forName(driverClass);
            //靜態代碼塊 ---> 類加載了，就執行。 java.sql.DriverManager.registerDriver(new Driver());
            //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
            //DriverManager.getConnection("jdbc:mysql://localhost/test?user=monty&password=greatsqldb");
            //2. 建立連接 參數一： 協議 + 訪問的數據庫 ， 參數二： 用戶名 ， 參數三： 密碼。
            conn = DriverManager.getConnection(url, name, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }

3. 使用properties配置文件

在src底下聲明一個文件 xxx.properties ，里面的內容吐下：

         driverClass=com.mysql.jdbc.Driver
          url=jdbc:mysql://localhost/student
          name=root
          password=root

在工具類里面，使用靜態代碼塊，讀取屬性

static{
            try {
                //1. 創建一個屬性配置對象
                Properties properties = new Properties();
                InputStream is = new FileInputStream("jdbc.properties"); //對應文件位于工程根目錄
                 
                //使用類加載器，去讀取src底下的資源文件。 后面在servlet  //對應文件位于src目錄底下
                //InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
                //導入輸入流。
                properties.load(is);
                
                //讀取屬性
                driverClass = properties.getProperty("driverClass");
                url = properties.getProperty("url");
                name = properties.getProperty("name");
                password = properties.getProperty("password");
                
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

源代碼如下：

public class JDBCUtil {
    
    static String driverClass = null;
    static String url = null;
    static String name = null;
    static String password= null;
    
    static{
        try {
            //1. 創建一個屬性配置對象
            Properties properties = new Properties();
            InputStream is = new FileInputStream("jdbc.properties");
            
            //使用類加載器，去讀取src底下的資源文件。 后面在servlet
//            InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
            //導入輸入流。
            properties.load(is);
            
            //讀取屬性
            driverClass = properties.getProperty("driverClass");
            url = properties.getProperty("url");
            name = properties.getProperty("name");
            password = properties.getProperty("password");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 獲取連接對象
     * @return
     */
    public static Connection getConn(){
        Connection conn = null;
        try {
            Class.forName(driverClass);
            //靜態代碼塊 ---> 類加載了，就執行。 java.sql.DriverManager.registerDriver(new Driver());
            //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
            //DriverManager.getConnection("jdbc:mysql://localhost/test?user=monty&password=greatsqldb");
            //2. 建立連接 參數一： 協議 + 訪問的數據庫 ， 參數二： 用戶名 ， 參數三： 密碼。
            conn = DriverManager.getConnection(url, name, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
    
    /**
     * 釋放資源
     * @param conn
     * @param st
     * @param rs
     */
    public static void release(Connection conn , Statement st , ResultSet rs){
        closeRs(rs);
        closeSt(st);
        closeConn(conn);
    }

    
    private static void closeRs(ResultSet rs){
        try {
            if(rs != null){
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            rs = null;
        }
    }
    
    private static void closeSt(Statement st){
        try {
            if(st != null){
                st.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            st = null;
        }
    }
    
    private static void closeConn(Connection conn){
        try {
            if(conn != null){
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            conn = null;
        }
    }
}

?

insert操作

INSERT INTO t_stu (NAME , age) VALUES ("wangqiang",28)

INSERT INTO t_stu VALUES (NULL,"wangqiang2",28)

// 1. 獲取連接對象
conn = JDBCUtil.getConn();
// 2. 根據連接對象，得到statement
st = conn.createStatement();

//3. 執行添加
String sql = "insert into t_stu values(null , "aobama" , 59)";
//影響的行數， ，如果大于0 表明操作成功。 否則失敗
int result = st.executeUpdate(sql);

if(result >0 ){
    System.out.println("添加成功");
}else{
    System.out.println("添加失敗");
}

delete操作

DELETE FROM t_stu WHERE id = 6

// 1. 獲取連接對象
conn = JDBCUtil.getConn();
// 2. 根據連接對象，得到statement
st = conn.createStatement();

//3. 執行添加
String sql = "delete from t_stu where name="aobama"";
//影響的行數， ，如果大于0 表明操作成功。 否則失敗
int result = st.executeUpdate(sql);

if(result >0 ){
    System.out.println("刪除成功");
}else{
    System.out.println("刪除失敗");
}

query操作

SELECT * FROM t_stu

    // 1. 獲取連接對象
    conn = JDBCUtil.getConn();
    // 2. 根據連接對象，得到statement
    st = conn.createStatement();

    // 3. 執行sql語句，返回ResultSet
    String sql = "select * from t_stu";
    rs = st.executeQuery(sql);

    // 4. 遍歷結果集
    while (rs.next()) {
        String name = rs.getString("name");
        int age = rs.getInt("age");

        System.out.println(name + "   " + age);
    }

update操作

UPDATE t_stu SET age = 38 WHERE id = 1;

// 1. 獲取連接對象
conn = JDBCUtil.getConn();
// 2. 根據連接對象，得到statement
st = conn.createStatement();

//3. 執行添加
String sql = "update t_stu set age = 26 where name ="qyq"";
//影響的行數， ，如果大于0 表明操作成功。 否則失敗
int result = st.executeUpdate(sql);

if(result >0 ){
    System.out.println("更新成功");
}else{
    System.out.println("更新失敗");
}

1. 定義一個類， TestXXX , 里面定義方法 testXXX.

這個命名不一定需要這樣，但是這樣的命名更容易懂得測試的意思，所以建議命名見名知意。

2. 添加junit的支持。

右鍵工程 --- add Library --- Junit --- Junit4

3. 在方法的上面加上注解 ， 其實就是一個標記。

    /**
 * 使用junit執行單元測試
 */
public class TestDemo {

    @Test
    public void testQuery() {
        // 查詢
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            // 1. 獲取連接對象
            conn = JDBCUtil.getConn();
            // 2. 根據連接對象，得到statement
            st = conn.createStatement();

            // 3. 執行sql語句，返回ResultSet
            String sql = "select * from t_stu";
            rs = st.executeQuery(sql);

            // 4. 遍歷結果集
            while (rs.next()) {
                String name = rs.getString("name");
                int age = rs.getInt("age");

                System.out.println(name + "   " + age);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.release(conn, st, rs);
        }

    }


    @Test
    public void testInsert(){
        
        // 查詢
        Connection conn = null;
        Statement st = null;
        try {
            // 1. 獲取連接對象
            conn = JDBCUtil.getConn();
            // 2. 根據連接對象，得到statement
            st = conn.createStatement();
            
            //3. 執行添加
            String sql = "insert into t_stu values(null , "aobama" , 59)";
            //影響的行數， ，如果大于0 表明操作成功。 否則失敗
            int result = st.executeUpdate(sql);
            
            if(result >0 ){
                System.out.println("添加成功");
            }else{
                System.out.println("添加失敗");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.release(conn, st);
        }

    }
    
    @Test
    public void testDelete(){
        
        // 查詢
        Connection conn = null;
        Statement st = null;
        try {
            // 1. 獲取連接對象
            conn = JDBCUtil.getConn();
            // 2. 根據連接對象，得到statement
            st = conn.createStatement();
            
            //3. 執行添加
            String sql = "delete from t_stu where name="aobama"";
            //影響的行數， ，如果大于0 表明操作成功。 否則失敗
            int result = st.executeUpdate(sql);
            
            if(result >0 ){
                System.out.println("刪除成功");
            }else{
                System.out.println("刪除失敗");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.release(conn, st);
        }

    }
    @Test
    public void testUpdate(){
        
        // 查詢
        Connection conn = null;
        Statement st = null;
        try {
            // 1. 獲取連接對象
            conn = JDBCUtil.getConn();
            // 2. 根據連接對象，得到statement
            st = conn.createStatement();
            
            //3. 執行添加
            String sql = "update t_stu set age = 26 where name ="qyq"";
            //影響的行數， ，如果大于0 表明操作成功。 否則失敗
            int result = st.executeUpdate(sql);
            
            if(result >0 ){
                System.out.println("更新成功");
            }else{
                System.out.println("更新失敗");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.release(conn, st);
        }
        
    }
}

4. 光標選中方法名字，然后右鍵執行單元測試。 或者是打開outline視圖， 然后選擇方法右鍵執行。

Data Access Object 數據訪問對象

DAO(Data Access Object) 數據訪問對象是一個面向對象的數據庫接口，它顯露了 Microsoft Jet 數據庫引擎（由 Microsoft Access 所使用），并允許 Visual Basic 開發者通過 ODBC 像直接連接到其他數據庫一樣，直接連接到 Access 表。DAO 最適用于單系統應用程序或小范圍本地分布使用。

1. 新建一個dao的接口， 里面聲明數據庫訪問規則

    /**
    * 定義操作數據庫的方法
     */
    public interface UserDao {
    
        /**
         * 查詢所有
         */
        void findAll();
    }

2. 新建一個dao的實現類，具體實現早前定義的規則

public class UserDaoImpl implements UserDao{

        @Override
        public void findAll() {
            Connection conn = null;
            Statement st = null;
            ResultSet rs = null;
            try {
                //1. 獲取連接對象
                conn = JDBCUtil.getConn();
                //2. 創建statement對象
                st = conn.createStatement();
                String sql = "select * from t_user";
                rs = st.executeQuery(sql);
                
                while(rs.next()){
                    String userName = rs.getString("username");
                    String password = rs.getString("password");
                    
                    System.out.println(userName+"="+password);
                }
                
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                JDBCUtil.release(conn, st, rs);
            }
        }
    
    }

3. 直接使用實現

    @Test
       public void testFindAll(){
           UserDao dao = new UserDaoImpl();
           dao.findAll();
       }

1. Statement執行 ，其實是拼接sql語句的。 先拼接sql語句，然后在一起執行。

String sql = "select * from t_user where username=""+ username  +"" and password=""+ password +""";

UserDao dao = new UserDaoImpl();
dao.login("admin", "100234khsdf88" or "1=1");

SELECT * FROM t_user WHERE username="admin" AND PASSWORD="100234khsdf88" or "1=1" 

//前面先拼接sql語句， 如果變量里面帶有了 數據庫的關鍵字，那么一并認為是關鍵字。 不認為是普通的字符串。 
rs = st.executeQuery(sql);

該對象就是替換前面的statement對象。

相比較以前的statement， 預先處理給定的sql語句，對其執行語法檢查。 在sql語句里面使用 ? 占位符來替代后續要傳遞進來的變量。 后面進來的變量值，將會被看成是字符串，不會產生任何的關鍵字。

String sql = "insert into t_user values(null , ? , ?)";
ps = conn.prepareStatement(sql);
 
 //給占位符賦值 從左到右數過來，1 代表第一個問號， 永遠你是1開始。
 ps.setString(1, userName);
 ps.setString(2, password);

(1) 使用PreparedStatement，代碼的可讀性和可維護性比Statement高。

(2) PreparedStatement 能最大可能提高性能。

DBServer會對預編譯語句提供性能優化。因為預編譯語句有可能被重復調用，所以語句在被DBServer的編譯器編譯后的執行代碼被緩存下來，那么下次調用時只要是相同的預編譯語句就不需要編譯，只要將參數直接傳入編譯過的語句執行代碼中就會得到執行。

在statement語句中,即使是相同操作但因為數據內容不一樣，所以整個語句本身不能匹配，沒有緩存語句的意義。事實是沒有數據庫會對普通語句編譯后的執行代碼緩存。這樣每執行一次都要對傳入的語句編譯一次。

(3) PreparedStatement能保證安全性，但 Statement有sql注入等安全問題。

1. 概述

在數據庫中,所謂事務是指一組邏輯操作單元,使數據從一種狀態變換到另一種狀態。

為確保數據庫中數據的一致性,數據的操縱應當是離散的成組的邏輯單元:當它全部完成時,數據的一致性可以保持,而當這個單元中的一部分操作失敗,整個事務應全部視為錯誤,所有從起始點以后的操作應全部回退到開始狀態。

事務的操作:先定義開始一個事務,然后對數據作修改操作,這時如果提交(COMMIT),這些修改就永久地保存下來,如果回退(ROLLBACK),數據庫管理系統將放棄您所作的所有修改而回到開始事務時的狀態。

2. 事務的ACID屬性

2.1 原子性（Atomicity）

原子性是指事務是一個不可分割的工作單位，事務中的操作要么都發生，要么都不發生。

2.2 一致性（Consistency）

事務必須使數據庫從一個一致性狀態變換到另外一個一致性狀態。(數據不被破壞)

2.3 隔離性（Isolation）

事務的隔離性是指一個事務的執行不能被其他事務干擾，即一個事務內部的操作及使用的數據對并發的其他事務是隔離的，并發執行的各個事務之間不能互相干擾。

2.4 持久性（Durability）

持久性是指一個事務一旦被提交，它對數據庫中數據的改變就是永久性的，接下來的其他操作和數據庫故障不應該對其有任何影響。

3. JDBC 事務處理

在JDBC中，事務默認是自動提交的，每次執行一個 SQL 語句時，如果執行成功，就會向數據庫自動提交，而不能回滾。

為了讓多個 SQL 語句作為一個事務執行，需調用 Connection 對象的 setAutoCommit(false); 以取消自動提交事務：

conn.setAutoCommit(false);

在所有的 SQL 語句都成功執行后，調用 commit(); 方法提交事務

conn.commit();

在出現異常時，調用 rollback(); 方法回滾事務，一般再catch模塊中執行回滾操作。

conn.rollback();

可以通過Connection的getAutoCommit()方法來獲得當前事務的提交方式。

注意：在MySQL中的數據庫存儲引擎InnoDB支持事務，MyISAM不支持事務。

1. 概述

當需要批量插入或者更新記錄時。可以采用Java的批量更新機制，這一機制允許多條語句一次性提交給數據庫批量處理。通常情況下比多帶帶提交處理更有效率。

JDBC的批量處理語句包括下面兩個方法：

addBatch(String)：添加需要批量處理的SQL語句或是參數；

executeBatch（）；執行批量處理語句；

通常我們會遇到兩種批量執行SQL語句的情況：

多條SQL語句的批量處理；

一個SQL語句的批量傳參；

2. Statement批量處理

Statement sm = conn.createStatement();
sm.addBatch(sql1);
sm.addBatch(sql2);
...
//批量處理
sm.executeBatch()
//清除sm中積攢的參數列表
sm.clearBatch();

3. PreparedStatement批量傳參

preparedStatement ps = conn.preparedStatement(sql);
for(int i=1;i<100000;i++){
    ps.setInt(1, i);
    ps.setString(2, "name"+i);
    ps.setString(3, "email"+i);
    ps.addBatch();
    if((i+1)%1000==0){
        //批量處理
        ps.executeBatch();
        //清空ps中積攢的sql
        ps.clearBatch();
    }
}

注意：MySQL不支持批量處理。

批量處理應該設置一個上限，當批量處理列表中的sql累積到一定數量后，就應該執行，并在執行完成后，清空批量列表。

一般在excel導入數據的時候會用到批處理。

1. 概述

Java 通過JDBC獲得連接以后，得到一個Connection 對象，可以從這個對象獲得有關數據庫管理系統的各種信息，包括數據庫中的各個表，表中的各個列，數據類型，觸發器，存儲過程等各方面的信息。根據這些信息，JDBC可以訪問一個實現事先并不了解的數據庫。

獲取這些信息的方法都是在DatabaseMetaData類的對象上實現的，而DataBaseMetaData對象是在Connection對象上獲得的。

2. 獲取數據庫元數據

DatabaseMetaData 類中提供了許多方法用于獲得數據源的各種信息，通過這些方法可以非常詳細的了解數據庫的信息：

getURL()：返回一個String類對象，代表數據庫的URL。

getUserName()：返回連接當前數據庫管理系統的用戶名。

isReadOnly()：返回一個boolean值，指示數據庫是否只允許讀操作。

getDatabaseProductName()：返回數據庫的產品名稱。

getDatabaseProductVersion()：返回數據庫的版本號。

getDriverName()：返回驅動驅動程序的名稱。

getDriverVersion()：返回驅動程序的版本號。

3. ResultSetMetaData

可用于獲取關于 ResultSet 對象中列的類型和屬性信息的對象：

getColumnName(int column)：獲取指定列的名稱

getColumnCount()：返回當前 ResultSet 對象中的列數。

getColumnTypeName(int column)：檢索指定列的數據庫特定的類型名稱。

getColumnDisplaySize(int column)：指示指定列的最大標準寬度，以字符為單位。

isNullable(int column)：指示指定列中的值是否可以為 null。

isAutoIncrement(int column)：指示是否自動為指定列進行編號，這樣這些列仍然是只讀的。

1. Statement

Statement stmt = conn.createStatement(type,concurrency);

2. PreparedStatement

PreparedStatement stmt = conn.prepareStatement(sql,type,concurrency);

type說明：

Concurrency(并發類型)說明：

3. ResultSet滾動的結果集使用

First: 將指針移動到此 ResultSet 對象的第一行
Last: 將指針移動到此 ResultSet 對象的最后一行
beforeFirst: 將指針移動到此 ResultSet 對象的開頭，正好位于第一行之前
afterLast: 將指針移動到此 ResultSet 對象的末尾，正好位于最后一行之后
isFirst: 檢索指針是否位于此 ResultSet 對象的第一行
isLast: 檢索指針是否位于此 ResultSet 對象的最后一行
isBeforeFirst: 檢索指針是否位于此 ResultSet 對象的第一行之前
isAfterLast: 檢索指針是否位于此 ResultSet 對象的最后一行之后
Relative: 按相對行數（或正或負）移動指針
Next: 將指針從當前位置下移一行
Previous: 將指針移動到此 ResultSet 對象的上一行
Absolute: 將指針移動到此 ResultSet 對象的給定行編號

如：

rs.absolute(80); //將指針移動到ResultSet 對象的第80行記錄。

注意：該特性對Oralce數據有效。但是在Mysql數據庫中無效，Mysql只支持TYPE_SCROLL_INSENSITIVE,CONCUR_READ_ONLY。

1. 為什么要使用JDBC連接池

普通的JDBC數據庫連接使用 DriverManager 來獲取，每次向數據庫建立連接的時候都要將 Connection 加載到內存中，再驗證用戶名和密碼。需要數據庫連接的時候，就向數據庫要求一個，執行完成后再斷開連接。這樣的方式將會消耗大量的資源和時間。數據庫的連接資源并沒有得到很好的重復利用.若同時有幾百人甚至幾千人在線，頻繁的進行數據庫連接操作將占用很多的系統資源，嚴重的甚至會造成服務器的崩潰。

對于每一次數據庫連接，使用完后都得斷開。否則，如果程序出現異常而未能關閉，將會導致數據庫系統中的內存泄漏，最終將導致重啟數據庫。

這種開發不能控制被創建的連接對象數，系統資源會被毫無顧及的分配出去，如連接過多，也可能導致內存泄漏，服務器崩潰。

為解決傳統開發中的數據庫連接問題，可以采用數據庫連接池技術。

2. 數據庫連接池（connection pool）

數據庫連接池的基本思想就是為數據庫連接建立一個“緩沖池”。預先在緩沖池中放入一定數量的連接，當需要建立數據庫連接時，只需從“緩沖池”中取出一個，使用完畢之后再放回去。

數據庫連接池負責分配、管理和釋放數據庫連接，它允許應用程序重復使用一個現有的數據庫連接，而不是重新建立一個。

數據庫連接池在初始化時將創建一定數量的數據庫連接放到連接池中，這些數據庫連接的數量是由最小數據庫連接數來設定的。無論這些數據庫連接是否被使用，連接池都將一直保證至少擁有這么多的連接數量。連接池的最大數據庫連接數量限定了這個連接池能占有的最大連接數，當應用程序向連接池請求的連接數超過最大連接數量時，這些請求將被加入到等待隊列中。

3. 數據庫連接池工作原理

4. 使用數據庫連接池的優點

(1)資源重用：

由于數據庫連接得以重用，避免了頻繁創建，釋放連接引起的大量性能開銷。在減少系統消耗的基礎上，另一方面也增加了系統運行環境的平穩性。

(2)更快的系統反應速度

數據庫連接池在初始化過程中，往往已經創建了若干數據庫連接置于連接池中備用。此時連接的初始化工作均已完成。對于業務請求處理而言，直接利用現有可用連接，避免了數據庫連接初始化和釋放過程的時間開銷，從而減少了系統的響應時間。

(3)新的資源分配手段

對于多應用共享同一數據庫的系統而言，可在應用層通過數據庫連接池的配置，實現某一應用最大可用數據庫連接數的限制，避免某一應用獨占所有的數據庫資源。

(4)統一的連接管理，避免數據庫連接泄露
在較為完善的數據庫連接池實現中，可根據預先的占用超時設定，強制回收被占用連接，從而避免了常規數據庫連接操作中可能出現的資源泄露。

5. 常用數據庫連接池介紹

JDBC 的數據庫連接池使用 javax.sql.DataSource 來表示，DataSource 只是一個接口，該接口通常由服務器(Weblogic, WebSphere, Tomcat)提供實現，也有一些開源組織提供實現，如：

DBCP 數據庫連接池

C3P0 數據庫連接池

Proxpool 數據庫連接池

其中，DBCP和C3P0用得比較多。

Tomcat 在 7.0 以前的版本都是使用 commons-dbcp 做為連接池的實現。

數據源和數據庫連接不同，數據源無需創建多個，它是產生數據庫連接的工廠，因此整個應用只需要一個數據源即可。

當數據庫訪問結束后，程序還是像以前一樣關閉數據庫連接：conn.close(); 但它并沒有關閉數據庫的物理連接，它僅僅把數據庫連接釋放，歸還給了數據庫連接池。

大概基本的就是這么多了，希望能夠幫助到大家，有問題可以交流溝通。

?