二刷jdbc 作者小結：從第一次大概幾天快速刷完jdbc，到如今的二刷，才發現自己對jdbc的理解有點太淺。到學習javaweb是創建資料庫層時的迷茫，到現在對這種設計模式的理解。我深有體會到了：實打實走好每一步的必要性！這篇筆記較為完整的展示了jdbc的發展脈絡，從原理到手動封裝，再到第三方庫，循 ...

二刷jdbc

作者小結：從第一次大概幾天快速刷完jdbc，到如今的二刷，才發現自己對jdbc的理解有點太淺。到學習javaweb是創建資料庫層時的迷茫，到現在對這種設計模式的理解。我深有體會到了：實打實走好每一步的必要性！這篇筆記較為完整的展示了jdbc的發展脈絡，從原理到手動封裝，再到第三方庫，循序漸進。

## jdbc概述

jdbc為訪問不同的資料庫提供了統一的介面。
java程式員使用jdbc，可以連接任何提供了jdbc驅動程式的資料庫系統，從而完成對資料庫的各種操作
jdbc的基本原理圖

java程式通過制定一些介面，讓資料庫廠商實現這些介面

*************************模擬************************
//java制定的資料庫介面
Interface jdbcInterface{
    //連接
    public Object getConnection();
    //crud
    public void crud();
    //關閉連接
    public void close();
}

//mysql廠商繼承介面從而實現這些方法
public class MysqlJdbcImpl implements jdbcInterface{
    @Override
    public Object getConnetion() {
        System.out.println("mysql的實現");
        return null;
    }

    @Override
    public void crud() {

    }

    @Override
    public void close() {

    }
}

java程式使用

public class testjdbc{
    public static void main(String[] args) {
        //通過介面來調用實現類[動態綁定]
        jdbcInterface mysqlImpl = new mysqlImpl();
        //通過介面來調用實現類
        mysqlImpl.getConnetion();
        mysqlImpl.crud();
        mysqlImpl.close();
    }
}

通過介面來調用實現類的意義：(思考介面編程的好處)

當用戶用其他資料庫廠商的實現類時只需動態綁定其他資料庫實現類

例如上方：jdbcInterface mysqlImpl = new DB2Impl();

jdbc程式編寫步驟

註冊驅動-載入Driver類
獲取連接-得到Connection
執行增刪改查-發送sql給相應的資料庫執行
釋放資源-關閉相關的連接

簡單的步驟：

導入對應的jar包，即驅動文件
註冊驅動

Derver driver=new new com.mysql.jdbc.Driver();

-->簡寫為 Derver driver=new driver();
String url 解讀

String url="jdbc::mysql://ip:port/資料庫名"

jdbc::mysql://規定好的，表示一個協議，通過jdbc的方式連接mysql。

ip 連接到的主機名稱

3306 表示mysql監聽的埠

資料庫名表示連接到mysql dbms的哪一個資料庫

mysql的連接本質就是socket連接

將用戶名和密碼放入到properties對象中

Properties properties = new Properties();
        properties.setProperty("user","book");//用戶
        properties.setProperty("password","xxxx");//密碼

得到連接

Connection conn=driver.connect(url,properties);

執行sql

String sql="select * from xxx";

Statement用於執行sql語句

Statement statement=conn.createStatement();
int i=statement.excuteUpdate(sql);
//i表示受影響的行數

關閉資源
```
statemen.close();
conn.close();
```
不關閉資源造成的影響：會造成連接不到mysql

獲取資料庫連接的五種方式

1.方式一獲取Driver實現類對象

Driver driver=new com.mysql.jdbc.Driver();
String url="jdbc:mysql://ip:port/資料庫名";
Properties properties=new Properties();
properties.setProperty("user","name");
properties.setProperty("password","xxxx");
Connection conn=driver.connect(url,properties);

通過new了一個第三方的driver，第三方的dirver 是靜態載入，靈活性不高。

2.方式二使用反射機制，動態載入。

//使用反射載入Driver類
        Class clazz=Class.forName("com.mysql.jdbc.Driver");
        Driver driver= (Driver) clazz.newInstance();
        String url="jdbc:mysql://ip:port/資料庫名";
        Properties properties=new Properties();
        properties.setProperty("user","name");
        properties.setProperty("password","xxxx");
        Connection conn=driver.connect(url,properties);

反射動態載入，更加靈活，減少依賴性。

3.方式三使用DriverManager進行統一管理

//使用反射載入Driver
Class clazz=Class.forName("com.mysql.jdbc.Driver");
Driver driver= (Driver) clazz.newInstance();
//創建url user password
String url="jdbc:mysql://ip:port/資料庫名";
String user="root";
String password="xxxx";
//註冊Driver驅動
DriverManager.registerDriver(driver);
Connection conn=DriverManager.getConnection(url,user,password);

DriverManagaer用於管理一組jdbc驅動程式的基本服務

4.方式四使用forName()自動完成註冊驅動，簡化代碼--推薦使用

//使用反射載入Driver
Class clazz=Class.forName("com.mysql.jdbc.Driver");
//創建url user password
String url="jdbc:mysql://ip:port/資料庫名";
String user="root";
String password="xxxx";
Connection conn=DriverManager.getConnection(url,user,password);

Class.forName 在載入Driver類時自動完成了註冊

tip：沒用顯示調用Class.forName("com.mysql.jdbc.Driver")仍然可以拿到資料庫的連接。建議寫上，更加明確

5.方式五通過寫配置文件，讓連接更加靈活

//通過Peoperties對象獲取配置文件的信息
        Properties properties=new Properties();
        properties.load(new FileInputStream("com\\mysql.properties"));
        //通過key獲取相關的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driver = properties.getProperty("driver");

        Class.forName(driver);
        DriverManager.getConnection(url,user,password);

在方式四的基礎上，增加配置文件，讓連接更加靈活。

配置文件：

#key=value
user=root
password=xxx
url=jdbc:mysql://ip:port/資料庫名
driver=com.mysql.jdbc.Driver

ResultSet結果集--底層（？）

概述：表示資料庫結果集的數據表，通常通過查詢資料庫的語句生成。ResultSet對象保持一個游標指向其當前的數據行，最初游標位於第一行，next方法將游標移動到下一行，並且由於在ResultSet對象中沒有更多行時返回false。類似於迭代器。

		//得到Statemen
        Statement statement = connection.createStatement();
        //sql語句
        String sql="SELECT * FROM xxx";
        //執行給定的sql語句，該語句返回單個ResultSet對象即為一張表
        java.sql.ResultSet resultSet = statement.executeQuery(sql);
        //迴圈取出
        while(resultSet.next()){//讓游標向後移動，如果沒有更多行，則返回false
            resultSet.getInt(1);//獲取改行的第一列數據
            resultSet.getString(2);//獲取該行第二列
        }
        //關閉資源
        resultSet.close();
        statement.close();
        connection.close();

statement--存在sql註入問題

概述：用於執行靜態的sql語句並返回其生成的結果的對象

statement是一個介面需要不同的資料庫廠商實現

解決方案：使用preperdStatement

代碼實現：

		//得到Statemen
        Statement statement = connection.createStatement();
        //sql語句xx
        String sql="SELECT * FROM xxx";
        //執行給定的sql語句，該語句返回單個ResultSet對象即為一張表
        java.sql.ResultSet resultSet = statement.executeQuery(sql);

如果將用戶輸入改成next()也可以防止sql註入，next遇到空格會停止。

PreperdStatement

概述：預處理Statement，是一個介面。

用法：

1.PreperdStatement執行的sql語句中的參數用問號(?)來表示，調用PreperdStatement對象的setXXX()方法來設置這些參數。setXXX()方法有兩個參數，第一個參數是要設置的sql語句中的參數的索引（即第幾個問號），第二個設置的是參數的值。

2.調用executeQuery(),返回ResultSet對象

3.調用excuteUpdate(),執行crud。返回影響行數

預處理好處：

不在使用+拼接sql語句，減少語法錯誤，有效解決了sql註入問題，減少了編譯次數，效率較高。

預處理就是再執行sql之前就已經完成對sql的賦值。

代碼實現：

//sql語句xx,設置問號
String sql="SELECT * FROM xxx WHERE name=?and password=?";
//得到PreparedStatemen
PreparedStatement preparedStatement = connection.prepareStatement(sql);
//給問號賦值
preparedStatement.setString(1,user_name);
preparedStatement.setString(2,user_pass);
//執行註意執行的時候不需要再填sql
preparedStatement.executeQuery();

添加記錄dml

String sql="INSERT INTO xxx VALUES(?,?)";

API小結

封裝Utils類

簡介：在jdbc操作中，獲取資料庫連接和釋放資源是經常使用到的可以將其封裝為JDBC連接的工具類Utils。

使用步驟：

定義相關的屬性（4個），因為只需要一份，所以用static修飾
在static代碼塊初始化
通過配置文件讀取相關的屬性值
寫連接函數，推薦使用DriverManager
寫釋放資源函數

代碼實現：

//定義相關的屬性（4個），因為只需要一份，所以用static修飾
    private static String user;//用戶名
    private static String password;//密碼
    private static String url;//資料庫url
    private static String driver;//驅動名

    //在static代碼塊初始化
    static{

        try {
            Properties properties=new Properties();
            properties.load(new FileInputStream("com\\mysql.properties"));
            //讀取相關的屬性值
            user = properties.getProperty("user");
            password=properties.getProperty("password");
            url=properties.getProperty("url");
            driver=properties.getProperty("driver");
        } catch (IOException e) {
            //在實際開發中，常常轉為運行異常拋出
            //將編譯異常轉為運行異常，調用者可以選擇捕獲該異常，也可以選擇預設處理該異常，比較方便。
            throw new RuntimeException(e);
        }
    }
    //連接資料庫，返回Connection
    public static Connection getConnection() throws SQLException, ClassNotFoundException {
        Class.forName(driver);
        return DriverManager.getConnection(url,user,password);
    }
    //關閉相應資源
    /*
        可能關閉的資源
        1.ResultSet結果集
        2.Statement和preparedStatement
        3.connection
        4.如果需要關閉資源，則傳入對象，否則傳入null
     */
    //用statement來接受因為statement是preparedStatement的父介面，都可以接收
    /*
    當一個對象被當作參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裡到底是值傳遞還是引用傳遞?
    Java 編程語言只有值傳遞參數。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的內容可以在被調用的方法中改變，但對象的引用是永遠不會改變的。
     */
    public static void close(ResultSet resultSet, Statement state,Connection conn) throws SQLException {
            if(resultSet!=null){
                resultSet.close();
            }
            if(state!=null){
                state.close();
            }
            if(conn!=null){
                state.close();
            }
    }

實際開發過程中異常處理：

在實際開發中，常常轉為運行異常拋出，將編譯異常轉為運行異常，調用者可以選擇捕獲該異常，也可以選擇預設處理該異常，比較方便。throw new RuntimeException(e);

Java是值傳遞：

Java 編程語言只有值傳遞參數。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的內容可以在被調用的方法中改變，但對象的引用是永遠不會改變的。

Utils使用

使用步驟：

得到連接。
組織一個sql語句。
創建一個PreparedStatement對象。
執行sql語句。
釋放資源調用close（）。

代碼實現：

public class use_utils {
    public void use_ut() throws SQLException {
        Connection conn=null;
        String sql="SELECT * FROM xxx";
        PreparedStatement preparedStatement=null;
        try {
            //得到連接
            conn=jdbcutils.getConnection();
            //創建PreparedStaement
            preparedStatement= conn.prepareStatement(sql);
            preparedStatement.executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            jdbcutils.close(null,preparedStatement,conn);
        }
    }
}

事務

概述：Jdbc程式中當一個Connection對象創建時，預設情況下是自動提交事務，不能回滾。並且jdbc程式中為了讓多個SQL語句作為一個整體執行，需要使用事務，調用Connection的setAutoCommit（false）可以取消自動提交事務，當所有的sql語句都執行後，調用Commit()方法即可提交事務，在其中某個操作失敗或出現異常時，調用rollback()方法即可回滾事務。

預設情況下，Connection對象是自動提交的。

應用實例：經典的轉賬業務。

代碼實現： "未使用事務"

Connection conn=null;
        String sql="update account set balance=balance-100 where id=1";
        String sql2="update account set balance=balance+100 where id=2";
        PreparedStatement preparedStatement=null;
        try {
            //得到連接
            conn=jdbcutils.getConnection();
            //創建PreparedStaement
            preparedStatement= conn.prepareStatement(sql);
            preparedStatement.executeQuery();//執行第一條sql
            int i=1/0;//拋出異常
            preparedStatement=conn.prepareStatement(sql2);
            preparedStatement.executeQuery();//執行第二條SQL
    }

上述代碼，在執行sql時如果沒用開啟事務，會造成第一條sql執行成功，而第二條sql未執行便被捕獲異常，在轉賬問題方面就會出現問題。

代碼實現： 開啟事務

//得到連接
      conn=jdbcutils.getConnection()            //創建PreparedStaement
preparedStatement= conn.prepareStatement(sql);
/*得到連接後將conn設置為不自動提交*/
conn.setAutoCommit(false);
preparedStatement.executeQuery();//執行第一條sql
            int i=1/0;//拋出異常
            preparedStatement=conn.prepareStatement(sql2);
            preparedStatement.executeQuery();//執行第二條SQL
/*在catch中即可處理異常，撤消先前已經執行的sql*/
				/*即回滾*/
catch(Exception e){
    conn.rollback();
}

rollback預設回滾到事務開啟的地方。

批處理

概述：當需要成批插入或者更新數據時，可以採用Java批量更新機制，這一機制允許將多條語句一次性提交給資料庫批量處理。

批處理步驟：

如果使用批處理時，需要在url中添加參數:

?rewriteBatchedStatements=true
addBatch():添加需要批量處理的SQL語句或參數
excuteBatch():執行批量處理的語句
clearBatch():清空批處理包的語句

批處理優勢:批處理往往和PreparedStatement一起搭配使用，既可以減少編譯次數，又減少運行次數，讓效率提高。

代碼實現：

傳統代碼

public void nobatch() throws SQLException, ClassNotFoundException {
        Connection connection = jdbcutils.getConnection();
        String sql="insert into xxx values(null,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        for (int i = 0; i < 5000; i++) {
            preparedStatement.setString(1,"tom"+i);
            preparedStatement.setString(2,"xxx");
            preparedStatement.executeUpdate();
        }
        //關閉連接
        jdbcutils.close(null,preparedStatement,connection);
 }

批處理代碼

public void batch_() throws SQLException, ClassNotFoundException {
        Connection connection = jdbcutils.getConnection();
        String sql="insert into xxx values(null,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        for (int i = 0; i < 5000; i++) {
            preparedStatement.setString(1,"tom"+i);
            preparedStatement.setString(2,"xxx");
            /*preparedStatement.executeUpdate();*/
            //將sql語句加入到批處理包中 ->
            preparedStatement.addBatch();
            //當有1000條數據時，在批量執行
            if((i+1)%1000==0){
                //滿1000條
                preparedStatement.executeBatch();
                //清空
                preparedStatement.clearBatch();
            }
        }
        //關閉連接
        jdbcutils.close(null,preparedStatement,connection);
    }

關鍵代碼：

preparedStatement.addBatch();
//當有1000條數據時，在批量執行
if((i+1)%1000==0){
//滿1000條
preparedStatement.executeBatch();
//清空
preparedStatement.clearBatch();
}

註：源代碼未瞭解！

資料庫連接池

概述：傳統方式連接資料庫過多，由於沒用的連接資源未被及時斷開會造成，連接不上數s據庫，資料庫連接池就誕生了，資料庫連接池可以合理分配連接資源。

實現方式：

1.預先在緩衝池中放入一定數量的連接，當需要建立資料庫連接時，只需要從 "緩衝池"中取出一個，使用完畢之後再放回去。

2.資料庫連接池負責分配，管理和釋放資料庫連接，它允許應用程式重覆使用一個現有的資料庫連接，而不是重寫建立一個

3.當應用程式向連接池請求的連接數超過最大連接數量時，這些請求將被加入到等待隊列中。

資料庫連接池種類：

1.Jdbc的資料庫連接池使用java.sql.dateSource來表示，DateSource只是一個介面，該介面由第三方提供實現。

2.C3P0, DBCP, Proxool, BoneCP, Druid

C3P0

實現步驟：

一、傳統方式

1.創建一個數據源對象。

2.通過配置文件獲取相關的信息user，url...

3.給數據源ComboPooledDataSource(c3p0)設置相關的參數url，user...setInitialPoolSize()方法設置初始化連接數，setMaxPoolSize()方法設置最大連接數。

4.得到連接。

5.關閉連接--即放回到連接池中。

二、使用配置文件模板

概述：c3p0設計者提供了一個xml文件，方便配置

1.將C3P0提供的配置文件 c3p0.config.xml拷貝到src目錄下

2.創建一個數據源對象,參數即為c3p0.config.xml文件中的

3.得到連接

4.關閉連接--即放回到連接池中。

C3P0：

配置文件：c3p0.config.xml

<c3p0-config>
    <!-- 數據源名稱代表連接池-->
    <name-config name="xxx">
        <!--  連接參數 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/web</property>
        <property name="user">root</property>
        <property name="password">ROOT</property>

        <!-- 連接池參數 -->
        <!-- 每次增長連接池可供連接數 -->
        <property name="acquireIncrement">10</property>
        <!-- 初始連接數 -->
        <property name="initialPoolSize">5</property>
        <!-- 最大連接數 -->
        <property name="maxPoolSize">10</property>
        <!-- 最大等待時間 -->
        <property name="checkoutTimeout">2000</property>
        <!-- 最大空閑回收時間 -->
        <property name="maxIdleTime">1000</property>
</c3p0-config>

代碼實現：

傳統方式

    public void testc3p0() throws IOException, PropertyVetoException, SQLException {
        //1.創建一個數據源對象
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        //2.通過配置文件獲取相關的信息
        Properties properties=new Properties();
        properties.load(new FileInputStream("com\\mysql.properties"));
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driver = properties.getProperty("driver");
        //給數據源 comboPooledDataSource設置相關的參數。
        //我們連接的管理是由comboPooledDataSource來管理的。
        comboPooledDataSource.setDriverClass(driver);
        comboPooledDataSource.setUser(user);
        comboPooledDataSource.setPassword(password);
        comboPooledDataSource.setJdbcUrl(url);
        //設置連接數--初始化連接數
        comboPooledDataSource.setInitialPoolSize(10);
        //最大連接數
        comboPooledDataSource.setMaxPoolSize(50);

        Connection connection = comboPooledDataSource.getConnection();//這個方法就是從DateSource介面實現的
        connection.close();
    }

xml配置文件的方式

public void test04() throws SQLException {
        //1.將配置文件導入src目錄下

        //2.創建一個數據源對象,參數即為c3p0.config.xml文件中的 <name-config name="nihao">
        ////數據源會根據數據源名稱讀取xml文件中的內容
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("nihao");

        Connection connection = comboPooledDataSource.getConnection();

        connection.close();
    }

註：數據源名稱不能寫錯，並且xml文件的名稱是固定的，數據源會根據數據源名稱讀取xml文件中的內容，自動完成配置。

Druid

概述：

Druid連接池是阿裡實現的，獲取連接的速度比較快。

實現步驟：

1.添加jar包，和properties配置文件，將配置文件拷貝到項目的src目錄下。

driverClassName 底層用這個欄位來讀取資料庫驅動。

minIdle 空閑時候的連接數量

2.創建Properties對象來讀取配置文件

3.創建一個指定參數的資料庫連接池

4.得到連接

5.釋放連接

代碼實現：

public void druidx() throws Exception {
        /*
        1.添加jar包，和properties配置文件，將配置文件拷貝到項目的src目錄下。
		driverClassName 底層用這個欄位來讀取資料庫驅動。
		minIdle 空閑時候的連接數量

        2.創建Properties對象來讀取配置文件
         */
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\druid.properties"));
        //創建一個指定參數的資料庫連接池
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
    	//得到連接
        Connection connection = dataSource.getConnection();
        connection.close();
    }

配置文件： druid.properties

driverClassName=com.mysql.jdbc.Driver //驅動載入
url=jdbc:mysql://127.0.0.1:3306/student?characterEncoding=utf-8 //註冊驅動
username=root //連接資料庫的用戶名
password=sjw58586 //連接資料庫的密碼。
filters=stat //屬性類型的字元串，通過別名的方式配置擴展插件， 監控統計用的stat 日誌用log4j 防禦sql註入:wall
initialSize=2 //初始化時池中建立的物理連接個數。
maxActive=300 //最大的可活躍的連接池數量
maxWait=60000 //獲取連接時最大等待時間，單位毫秒，超過連接就會失效。配置了maxWait之後，預設啟用公平鎖，併發效率會有所下降， 如果需要可以通過配置useUnfairLock屬性為true使用非公平鎖。
timeBetweenEvictionRunsMillis=60000 // 連接回收器的運行周期時間，時間到了清理池中空閑的連接，testWhileIdle根據這個判斷
minEvictableIdleTimeMillis=300000
validationQuery=SELECT 1 //用來檢測連接是否有效的sql，要求是一個查詢語句。
testWhileIdle=true //建議配置為true，不影響性能，並且保證安全性。 申請連接的時候檢測，如果空閑時間大於timeBetweenEvictionRunsMillis， 執行validationQuery檢測連接是否有效。
testOnBorrow=false //申請連接時執行validationQuery檢測連接是否有效，做了這個配置會降低性能。設置為false
testOnReturn=false //歸還連接時執行validationQuery檢測連接是否有效，做了這個配置會降低性能,設置為flase
poolPreparedStatements=false //是否緩存preparedStatement，也就是PSCache。
maxPoolPreparedStatementPerConnectionSize=200 // 池中能夠緩衝的preparedStatements語句數量

將Jdbc工具類改成druid實現

代碼實現：

 private static DataSource ds;
    //在靜態代碼塊完成ds初始化
    static{
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src\\druid.properties"));
            ds= DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            new RuntimeException(e);
        }
    }
    //得到連接方法
    public Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
    //釋放資源，Connection放回連接池,此是的close是資料庫連接池實現的close方法。
    public void close(ResultSet rs, Connection conn, Statement st) throws SQLException {
            if(rs!=null){
                rs.close();
            }
            if (conn!=null){
                conn.close();
            }
            if(st!=null){
                st.close();
            }
    }

註：此時調用的close方法，是連接池實現的close()方法並不會真正的關閉連接，而是將連接放回到資料庫連接池。

Bean，Domain，POJO

問題引出：

1.java程式使用Connection連接，Connection和ResultSet關聯，當關閉Connection無法再使用ResultSet。

2.如果一個程式返回ResultSet對象，這是已經關閉Connection，仍然無法拿到結果集對象，導致結果集只能使用一次。

解決方案：

寫一個Java類---->常被叫做Bean，Domain，POJO，該類中有查詢到的表中的欄位屬性，讓一個Actor對象對應查詢到的一條記錄，將結果集封裝到ArrayList中。

ApachDBUtils

概述：面對ResultSet問題，ApachDBUtils工具類完美解決了這個問題。

傳統方式解決(土方法封裝)

實現步驟：

1.新建一個POJO類，用於封裝查詢到的表的記錄。

2.類中定義表中相對應的欄位，構造函數，setter，getter方法。

註：一定要給一個預設構造函數[反射需要]。

3.在java程式中用ArrayList 來存貯數據。

4.在ResultSet遍歷的時候，封裝數據，存儲到集合中。

代碼實現：

Actor---POJO

import java.util.Date;

public class Actor {//POJO
    //和表的欄位相對應
    //細節建議用Integer裝箱
    private Integer id;
    private String name;
    private String sex;
    //Date用util包下的。
    private Date bornDate;
    private String phone;
    //一定要給一個無參構造器[反射會需要]
    public Actor(){

    }

    public Actor(Integer id, String name, String sex, Date bornDate, String phone) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.bornDate = bornDate;
        this.phone = phone;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setBornDate(Date bornDate) {
        this.bornDate = bornDate;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public Date getBornDate() {
        return bornDate;
    }

    public String getPhone() {
        return phone;
    }
}

java程式：

public void testSelecttoArraylist() throws Exception {
        Properties properties=new Properties();
        properties.load(new FileInputStream("com\\mysql.properties"));
        //通過key獲取相關的值
        String user_name;
        String user_pass;
        Scanner scanner = new Scanner(System.in);
        user_name=scanner.nextLine();
        user_pass=scanner.nextLine();
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driver = properties.getProperty("driver");
        //創建ArrayList對象，存放Actor對象
        ArrayList<Actor> list=new ArrayList<>();
        //註冊驅動
        Class.forName(driver);
        //得到連接
        Connection connection = DriverManager.getConnection(url, user, password);
        //sql語句xx,設置問號
        String sql="SELECT * FROM xxx WHERE name=?and password=?";
        //得到PreparedStatemen
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //給問號賦值
        preparedStatement.setString(1,user_name);
        preparedStatement.setString(2,user_pass);
        //執行給定的sql語句，該語句返回單個ResultSet對象即為一張表
        java.sql.ResultSet resultSet = preparedStatement.executeQuery(sql);
        //迴圈取出
        while(resultSet.next()){//讓游標向後移動，如果沒有更多行，則返回false
            int id=resultSet.getInt("id");
            String name = resultSet.getString("name");
            String sex = resultSet.getString("sex");
            Date borndate = resultSet.getDate("borndate");
            String phone = resultSet.getString("phone");
            //把得到的resultSet記錄封裝到Actor對象，放入到list集合。
            list.add(new Actor(id,name,sex,borndate,phone));
        }
        //關閉資源
        resultSet.close();
        preparedStatement.close();
        connection.close();


    }
}

ApachDBUtils解決

概述：commons-dbutils是Apache組織提供的一個開源的JDBC工具類庫，它是對JDBC的封裝，使用dbutils能極大簡化jdbc編碼的工作量。

dbutils常用類和介面：

QueryRunner類：該類封裝了SQl的執行，是線程安全的，可以實現增刪改查，批處理。
ResultSetHandler介面：該介面用於處理java.sql.ResultSet，將數據按要求轉換為另一種形式。

ArrayHandler: 把結果集中的第一行數據轉成對象數組
ArrayListHandler: 把結果集中的每一行數據都轉成一個數組，再存放到List中。
BeanHandler: 將結果集中的第一行數據封裝到一個對應的JavaBean實例中。
BeanListHandler: 將結果集中的每一行數據都封裝到一個對應的JavaBean: 實例中，存放到List里。
ColumnListHandler: 將結果集中某一列的數據存放到List中。
KeyedHandler(name): 將結果集中的每行數據都封裝到Map里，再把這些map再存到一個map里，其key為指定的key。
MapHandler: 將結果集中的第一行數據封裝到一個Map里，key是列名，vaue就是對應的值。
MapListHandler: 將結果集中的每一行數據都封裝到一個Map里，然後再存放到List

使用步驟：druid+dbutils

引入commons jar包
使用自己封裝的DruidUtils得到連接
創建QueryRunner
調用QueryRunner的query方法執行sql返回ArrayList集合

註：sql語句也可以查詢部分列

BeanListHandler<>(Actor.class):在將ResultSet->Actor 對象->封裝到ArrayList

1: 傳給sql中的問號的，可以有多個後邊是可變參數Object...params

底層得到的ResultSet會在query執行後關閉，PreparedStatement也會自動關閉
```
參數列表
(connection, sql, new BeanListHandler<>(Actor.class), 1)
```
關閉連接。

代碼實現：

public void querytest() throws SQLException {
        //得到連接（druid）
        Connection connection = DruidUtils.getConnection();
        //使用DbUtils類和介面，引入相應的jar文件。
        //創建QueryRunner
        QueryRunner queryRunner = new QueryRunner();
        //QueryRunner就可以執行相關的方法，返回ArrayList結果集
        String sql="SELECT * FROM xxx WHERE id>=?";
        //sql語句也可以查詢部分列
        /*
         queryRunner.query方法就是執行一個sql語句得到ResultSet，--封裝到ArrayList集合中
         然後返回集合。
         參數Connection  連接
         sql： 執行的sql語句
         BeanListHandler<>(Actor.class):在將ResultSet->Actor 對象->封裝到ArrayList
         底層使用反射機制獲取Actor屬性進行封裝
         1: 傳給sql中的問號的，可以有多個後邊是可變參數Object...params
         底層得到的ResultSet會在query執行後關閉，PreparedStatement也會自動關閉
        * */
        List<Actor> list = queryRunner.query(connection, sql, new BeanListHandler<>(Actor.class), 1);
        DruidUtils.close(null,connection,null);
    }

dbutils查詢單行記錄(單個對象)

解決方案：返回單行記錄，單個對象使用的Hander是BeanHandler

new BeanHandler<>(Actor.class)

單行單列：返回的是一個Object，對象使用Handers是ScalarHandler()

new ScalarHandler()

dbutils+druid實現crud

執行dml操作使用queryRunner.update()

返回值是受影響的行數。

代碼實現：

public void testcrud() throws Exception{
        Connection connection = DruidUtils.getConnection();
        QueryRunner queryRunner = new QueryRunner();
        String sql="update actor set name=? where id=?";
        int affectedrows = queryRunner.update(connection, sql, "niuma", 4);

    }

對應關係：

註： java中全部對應包裝類。

BasicDAO

問題分析：

dbutils和druid簡化了JDBC開發，但有不足

1.Sql語句是固定，不能通過參數傳入，通用性不好，需要進行該進，更方便執行crud

2.對於select操作，如果有返回值，返回值類型不能固定，需要使用泛型

3.將來的表很多，業務需求複雜，不可能只靠一個Java類完成

設計理念：各司其職。一張表對應一個DAO

DAO：訪問數據的對象

BasicDAO將所有的DAO共有的部分提取出來，讓子類去繼承簡化代碼。

設計步驟：

1.第一個包放utils工具類

2.第二個包 javaBean/domain

3.第三個包放xxxDAO和BasicDAO

4.第四個包寫測試類

目錄結構：

代碼：

BasicDAO：

package com.basic_.dao;

import com.basic_.utils.DruidUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import javax.management.Query;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

//開發basicDAO
//添加泛型將來是操作domain的
public class BasicDAO<T> {
    private QueryRunner qr=new QueryRunner();

    //開發通用的dml方法，針對任意的表
    public int update(String sql,Object...prameters) throws SQLException {
        Connection conn=null;
        conn= DruidUtils.getConnection();
        int affectedRows = qr.update(conn, sql, prameters);
        return affectedRows;
    }
    //返回多個對象(即查詢的結果是多行的)，針對任意表
    //sql語句可以有問號，占位符
    //clazz傳入一個類的Class對象，底層通過反射實現domain 比如Actor.class
    //prameters傳入問號具體的值。
    public List<T> queryMulti(String sql, Class<T> clazz, Object...prameters) throws SQLException {
        Connection conn=null;
        conn=DruidUtils.getConnection();
        List<T> list = qr.query(conn, sql, new BeanListHandler<>(clazz), prameters);
        DruidUtils.close(null,conn,null);
        return list;
    }
    //查詢單行結果通用方法   T可能是Actor..不同的表。
    public T querySingle(String sql,Class<T> clazz,Object...prameters) throws SQLException {
        Connection conn=null;
        conn= DruidUtils.getConnection();
        T rs = qr.query(conn, sql, new BeanHandler<>(clazz), prameters);
        DruidUtils.close(null,conn,null);
        return rs;
    }
    //查詢單行單列即返回單值的方法
    public Object queryScalar(String sql,Object...prameters) throws SQLException {
        Connection conn=null;
        conn= DruidUtils.getConnection();
        Object rs = qr.query(conn, sql, new ScalarHandler(), prameters);
        DruidUtils.close(null,conn,null);
        return rs;
    }

}

ActorDAO

public class ActorDAO extends BasicDAO<Actor>{
    //Actor有BasicDAO 的方法
    //根據業務需求，可以編寫特有的方法
}

domain

public class Actor {//POJO
    //和表的欄位相對應
    //細節建議用Integer裝箱
    private Integer id;
    private String name;
    private String sex;
    //Date用util包下的。
    private Date bornDate;
    private String phone;
    //一定要給一個無參構造器[反射會需要]
    public Actor(){

    }

    public Actor(Integer id, String name, String sex, Date bornDate, String phone) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.bornDate = bornDate;
        this.phone = phone;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setBornDate(Date bornDate) {
        this.bornDate = bornDate;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public Date getBornDate() {
        return bornDate;
    }

    public String getPhone() {
        return phone;
    }
}

utils

    private static DataSource ds;
    //在靜態代碼塊完成ds初始化
    static{
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src\\druid.properties"));
            ds= DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            new RuntimeException(e);
        }
    }
    //得到連接方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
    //釋放資源，Connection放回連接池,此是的close是資料庫連接池實現的close方法。
    public static void close(ResultSet rs, Connection conn, Statement st) throws SQLException {
            if(rs!=null){
                rs.close();
            }
            if (conn!=null){
                conn.close();
            }
            if(st!=null){
                st.close();
            }
    }

測試使用

//測試ActorDao對actor表crud操作
    public void testActorDao() throws SQLException {
        ActorDAO actorDAO = new ActorDAO();
        //1.查詢
        List<Actor> actors = actorDAO.queryMulti("select *from actor where id>?", Actor.class, 1);
        //2.查詢單行
        Actor actor01 = actorDAO.querySingle("select *from actor where id=?", Actor.class, 1);
        //3.查詢單行單列
        Object o = actorDAO.queryScalar("select name from actor where id=?", 6);
        //4.dml操作
        //添加數據是按照什麼順序呢？
        int afftedRows = actorDAO.update("insert into actor values(null,?,?)", "nihao", "niuma");

    }

作者：程式員包子，轉載請註明原文鏈接：https://www.cnblogs.com/coder-baozi/p/16290759.html

coder-baozi一位菜鳥碼農

Jdbc從入門到入土

二刷jdbc

jdbc程式編寫步驟

獲取資料庫連接的五種方式

ResultSet結果集--底層（？）

statement--存在sql註入問題

PreperdStatement

API小結

封裝Utils類

Utils使用

事務

批處理

資料庫連接池

C3P0

Druid

將Jdbc工具類改成druid實現

Bean，Domain，POJO

ApachDBUtils

dbutils查詢單行記錄(單個對象)

dbutils+druid實現crud

BasicDAO