jdbc就是這麼簡單

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

一、JDBC

JAVA Database Connectivity java 數據庫連接.

JDBC（Java DataBase Connectivity,java數據庫連接）是一種用於執行SQL語句的Java API，可以爲多種關係數據庫提供統一訪問，它由一組用Java語言編寫的類和接口組成。JDBC提供了一種基準，據此可以構建更高級的工具和接口，使數據庫開發人員能夠編寫數據庫應用程序，同時，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

五、使用JDBC的基本步驟

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;
    }

六、JDBC 工具類構建

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;
        }
    }
}

七、數據庫的CRUD

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視圖，然後選擇方法右鍵執行。

九、Dao模式

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();
    }

十、Statement安全問題

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);

PrepareStatement

該對象就是替換前面的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);

PreparedStatement與Statement比較

(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不支持事務。

十二、批量處理JDBC語句

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導入數據的時候會用到批處理。

十三、使用 JDBC 處理元數據

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說明：

ResultSet的Type	說明
TYPE_FORWARD_ONLY	結果集不能滾動,只可向前滾動
TYPE_SCROLL_INSENSITIVE	雙向滾動，但不及時更新，就是如果數據庫裏的數據修改過，並不在ResultSet中反應出來
TYPE_SCROLL_SENSITIVE	雙向滾動，並及時跟蹤數據庫的更新,以便更改ResultSet中的數據

Concurrency(併發類型)說明：

ResultSet的Concurrency(併發類型)	說明
CONCUR_READ_ONLY	結果集不可用於更新數據庫
CONCUR_UPDATABLE	結果集可以用於更新數據庫

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。

十五、JDBC連接池

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(); 但它並沒有關閉數據庫的物理連接，它僅僅把數據庫連接釋放，歸還給了數據庫連接池。

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

jdbc就是這麼簡單

一、JDBC

二、爲什麼會出現JDBC

三、數據庫驅動

四、常用接口

五、使用JDBC的基本步驟

1. 註冊驅動

2. 建立連接

3. 創建statement

4. 執行sql ，得到ResultSet

5. 遍歷結果集

6. 釋放資源

六、JDBC 工具類構建

1. 資源釋放工作的整合

2. 驅動防二次註冊

3. 使用properties配置文件

七、數據庫的CRUD

八、使用單元測試，測試代碼

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

2. 添加junit的支持。

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

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

九、Dao模式

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

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

3. 直接使用實現

十、Statement安全問題

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

PrepareStatement

PreparedStatement與Statement比較

十一、數據庫事務

十二、批量處理JDBC語句

十三、使用 JDBC 處理元數據

十四、創建可滾動、更新的記錄集

十五、JDBC連接池

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

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

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

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