JDBC-自定義數據庫工具類（DBService）

 寫在前面的話：

     （1）使用JDBC，必須要使用對應的jar包，該筆記中使用jar包： mysql-connector-java-5.1 .6-bin.jar

     （2）使用連接池，一定要導入對象的數據庫連接池包，該筆記中使用jar包： c3p0-0.9.1.2.jar

               常用連接池：dbcp連接池、c3p0連接池、druid連接池

 

 

第一版：不用數據庫連接池：

 

package cn;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
public class SqlService {
 
       // 四大金剛
      String driver = "com.mysql.jdbc.Driver" ;// 驅動名稱
      String url = "jdbc:mysql:///mao" ;// 連接字符串
      String username = "root" ;// 用戶名
      String password = "123456" ;// 密碼
 
       // 三劍客
      Connection con = null ;// 連接對象
      PreparedStatement pstmt = null ;// 語句對象
      ResultSet rs = null ;// 結果集對象
 
       /**
       * 獲得連接對象
       *
       * @return 連接對象
       * @throws ClassNotFoundException
       * @throws SQLException
       */
       public Connection getConnection() throws ClassNotFoundException,
                  SQLException {
            Class. forName( driver);
             con = DriverManager.getConnection( url , username , password );
             return con ;
      }
 
       /**
       * 關閉三劍客
       *
       * @throws SQLException
       */
       public void close(ResultSet rs, PreparedStatement pstmt, Connection con) {
 
             try {
                   if (rs != null)
                        rs.close();
                   if (pstmt != null)
                        pstmt.close();
                   if (con != null)
                        con.close();
            } catch (SQLException e) {
                   // TODO: handle exception
                  e.printStackTrace();
            }
      }
 
       /**
       * 執行更新
       *
       * @param sql
       *            傳入的預設的 sql語句
       * @param params
       *            問號參數列表
       * @return 影響行數
       */
       public int execUpdate(String sql, Object[] params) {
             try {
                   this .getConnection();// 獲得連接對象
                   this .pstmt = this. con .prepareStatement(sql);// 獲得預設語句對象
 
                   if (params != null) {
                         // 設置參數列表
                         for (int i = 0; i < params. length; i++) {
                               // 因為問號參數的索引是從1開始，所以是i+1，將所有值都轉為字符串形式，好讓setObject成功運行
                               this .pstmt .setObject(i + 1, params[i] + "" );
                        }
                  }
 
                   return this .pstmt .executeUpdate(); // 執行更新，並返回影響行數
 
            } catch (ClassNotFoundException | SQLException e) {
                   // TODO Auto-generated catch block
                  e.printStackTrace();
            } finally {
                   this .close( this. rs, this. pstmt , this .con );
            }
             return 0;
      }
 
       /**
       * 執行查詢
       *
       * @param sql
       *            傳入的預設的 sql語句
       * @param params
       *            問號參數列表
       * @return 查詢后的結果
       */
       public List<Map<String, Object>> execQuery(String sql, Object[] params) {
 
             try {
                   this .getConnection();// 獲得連接對象
                   this .pstmt = this. con .prepareStatement(sql);// 獲得預設語句對象
 
                   if (params != null) {
                         // 設置參數列表
                         for (int i = 0; i < params. length; i++) {
                               // 因為問號參數的索引是從1開始，所以是i+1，將所有值都轉為字符串形式，好讓setObject成功運行
                               this .pstmt .setObject(i + 1, params[i] + "" );
                        }
                  }
 
                   // 執行查詢
                  ResultSet rs = pstmt .executeQuery();
 
                  List<Map<String, Object>> al = new ArrayList<Map<String, Object>>();
 
                   // 獲得結果集元數據（元數據就是描述數據的數據，比如把表的列類型列名等作為數據）
                  ResultSetMetaData rsmd = rs.getMetaData();
 
                   // 獲得列的總數
                   int columnCount = rsmd.getColumnCount();
 
                   // 遍歷結果集
                   while (rs.next()) {
                        Map<String, Object> hm = new HashMap<String, Object>();
                         for (int i = 0; i < columnCount; i++) {
                               // 根據列索引取得每一列的列名,索引從1開始
                              String columnName = rsmd.getColumnName(i + 1);
                               // 根據列名獲得列值
                              Object columnValue = rs.getObject(columnName);
                               // 將列名作為key，列值作為值，放入 hm中，每個 hm相當於一條記錄
                              hm.put(columnName, columnValue);
                        }
                         // 將每個 hm添加到al中, al相當於是整個表，每個 hm是里面的一條記錄
                        al.add(hm);
                  }
 
                   return al;
 
            } catch (ClassNotFoundException | SQLException e) {
                   // TODO Auto-generated catch block
                  e.printStackTrace();
            } finally {
                   this .close( this. rs, this. pstmt , this .con );
            }
             return null ;
      }
}

 

代碼解釋：

一：為什么直接使用 “Class. forName( driver); ”注冊驅動

          ①原始注冊驅動寫法：

   

  // 注冊驅動：告訴 java 去連接哪種數據庫
     //DriverManager ：驅動管理類，負責管理驅動，創建連接對象
     DriverManager. registerDriver( new com.mysql.jdbc.Driver());

static void

registerDriver ( Driver  driver)            向 DriverManager 注冊給定驅動程序。

參數：Driver=====來哦子欲你要連接的數據庫（如果連接orcale，來自於oracle，如果連接mysql，來自於mysql）

備注：查詢  Drive源碼

 

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
     // ~ Static fields/initializers
     // ---------------------------------------------
 
     //
     // Register ourselves with the DriverManager
     //
     static {
        try {
           java.sql.DriverManager. registerDriver( new Driver());
       } catch (SQLException E) {
            throw new RuntimeException( "Can't register driver!" );
       }
    }

 

可以看到：  java.sql.DriverManager. registerDriver( new Driver());是寫在靜態代碼塊中，只要調用Driver這個方法，就會自動運行這段代碼，這樣會造成“注冊兩次驅動”

因此，我們可以改成如下版本：

  

          ②改進版

   

  // 注冊驅動：告訴 java去連接哪種數據庫
     //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
     new com.mysql.jdbc.Driver();

 

    但是這樣寫：

      1、靜態初始化已經new了一個Driver對象，注冊到DriverManager中去，在此再創建一個Driver對象則是完全沒有必要的，浪費空間；

      2、不夠靈活，如果需要換數據庫的話，需要改動代碼，此時最好把要變得內容改成字符串的形式，可以由變量讀取外部配置文件進行傳入（由此可以解釋，為什么源代碼中要直接寫成靜態代碼塊）     

        

           ③最終版   

     

 // 注冊驅動：告訴 java 去連接哪種數據庫
      //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
      //new com.mysql.jdbc.Driver();
      Class. forName( "com.mysql.jdbc.Driver");

 

     最終版的好處：

     1、Class.forName（）的作用是要求JVM查找並加載指定的類，也就是說JVM會執行該類的靜態代碼段。

     2、既然在靜態初始化器中已經進行了注冊，所以我們在使用JDBC時只需要Class.forName（XXX.XXX）就可以了

 

二：獲得連接對象

 

con = DriverManager.getConnection( url , username , password );

url：連接到某一個具體的數據庫

user：數據庫的用戶名

password：數據庫用戶名對應的密碼

 

url = "jdbc:mysql://localhost:3306/mao"

 

jdbc：     jdbc協議

mysql：     jdbc子協議（表示mysql協議）

 

備注：

     url其他寫法一：

url = jdbc:mysql://localhost:3306/mao?userUnicode=true&characterEncoding=utf8
//?userUnicode=true&characterEncoding=utf8
//加上這個可以解決數據庫的亂碼問題

 

/*

*1、存數據時：

*數據庫在存放項目數據的時候會先用UTF-8格式將數據解碼成字節碼，然后再將解碼后的字節碼重新使用GBK編碼存*放到數據庫中。

*

*2.取數據時：

*     在從數據庫中取數據的時候，數據庫會先將數據庫中的數據按GBK格式解碼成字節碼，然后再將解碼后的字節*碼重新按UTF-8格式編碼數據，最后再將數據返回給客戶端。

*

*/

     url其他寫法二：

//如果連接的mysql是在本機，並且mysql的端口是3306，比如：
url："jdbc:mysql://localhost:3306/mao"
//那么url可以簡寫為：
url："jdbc:mysql:///mao"

 

 

三、語句對象

 

   

  // 創建語句對象Statement
     Statement stmt = con.createStatement();
 
     //創建預設語句對象PreparedStatement
     String sql = "update class set classDesc = ? where id = ?";
     PreparedStatement pstmt = con.prepareStatement(sql);

 

     接下來是重點：

      1：Statement的缺陷：

               ①容易被sql注入

 

sql注入：在頁面表單中輸入sql的片段。達到串改程序中sql語句。

 

 

正常情況：

 

select * from user where username='zhangsan' and password = '123456';

 

 

當sql被注入之后的語句：

 

select * from user where username='zhangsan' and password = '' or '1'='1'

                ②效率不高

               Statement每執行一次，sql進行一次編譯。即使每次的sql語句格式都一樣

     

     2：PreparedStatement的優勢

               ①防止sql注入

                    PreparedStatement會對特殊字符進行轉譯，並通過參數形式設置到語句中，而不再是變量拼湊成sql語句

                 ②預編譯功能

                 相同格式的sql語句只被編譯一次，后一條格式相同的sql語句運行時，只需改變參數的值即可

 

 

第二版：使用數據庫連接池

代碼前備注：

     本工具類代碼使用c3p0連接池

c3p0-config.xml

<? xml version ="1.0" encoding= "UTF-8" ?>
< c3p0-config>
       <!-- 默認配置，c3p0框架默認加載這段默認配置 -->
       < default-config>
             <!-- 配置JDBC 四個基本屬性 -->
             < property name ="driverClass" > com.mysql.jdbc.Driver</ property >
             < property name ="jdbcUrl" > jdbc:mysql:///數據庫名</ property >
             < property name ="user" > 數據庫用戶名</ property >
             < property name ="password" > 數據庫密碼</ property >
       </ default-config> <!-- This app is massive! -->
</ c3p0-config>

 

 

 

package cn.service;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import org.junit.Test;
 
import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.mchange.v2.c3p0.util.TestUtils;
 
public class DBService {
 
    // 三劍客
    Connection con = null;// 連接對象
    PreparedStatement pstmt = null;// 語句對象
    ResultSet rs = null;// 結果集對象
 
    /**
     * 獲得連接對象
     *
     * @return 連接對象
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public Connection getConnection() throws ClassNotFoundException,
            SQLException {
 
        // 創建c3p0連接池
        ComboPooledDataSource ds = new ComboPooledDataSource("itcast");
        // 通過連接池對象創建連接
        con = ds.getConnection();
        return con;
    }
 
    /**
     * 關閉三劍客
     *
     * @throws SQLException
     */
    public void close(ResultSet rs, PreparedStatement pstmt, Connection con) {
 
        try {
            if (rs != null)
                rs.close();
            if (pstmt != null)
                pstmt.close();
            if (con != null)
                con.close();
        } catch (SQLException e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
 
    /**
     * 執行更新
     *
     * @param sql
     *            傳入的預設的sql語句
     * @param params
     *            問號參數列表
     * @return 影響行數
     */
    public int execUpdate(String sql, Object[] params) {
        try {
            this.getConnection();// 獲得連接對象
            this.pstmt = this.con.prepareStatement(sql);// 獲得預設語句對象
 
            if (params != null) {
                // 設置參數列表
                for (int i = 0; i < params.length; i++) {
                    // 因為問號參數的索引是從1開始，所以是i+1，將所有值都轉為字符串形式，好讓setObject成功運行
                    this.pstmt.setObject(i + 1, params[i] + "");
                }
            }
 
            return this.pstmt.executeUpdate();// 執行更新，並返回影響行數
 
        } catch (ClassNotFoundException | SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            this.close(this.rs, this.pstmt, this.con);
        }
        return 0;
    }
 
    /**
     * 執行查詢
     *
     * @param sql
     *            傳入的預設的sql語句
     * @param params
     *            問號參數列表
     * @return 查詢后的結果
     */
    public List<Map<String, Object>> execQuery(String sql, Object[] params) {
 
        try {
            this.getConnection();// 獲得連接對象
            this.pstmt = this.con.prepareStatement(sql);// 獲得預設語句對象
 
            if (params != null) {
                // 設置參數列表
                for (int i = 0; i < params.length; i++) {
                    // 因為問號參數的索引是從1開始，所以是i+1，將所有值都轉為字符串形式，好讓setObject成功運行
                    this.pstmt.setObject(i + 1, params[i] + "");
                }
            }
 
            // 執行查詢
            ResultSet rs = pstmt.executeQuery();
 
            List<Map<String, Object>> al = new ArrayList<Map<String, Object>>();
 
            // 獲得結果集元數據（元數據就是描述數據的數據，比如把表的列類型列名等作為數據）
            ResultSetMetaData rsmd = rs.getMetaData();
 
            // 獲得列的總數
            int columnCount = rsmd.getColumnCount();
 
            // 遍歷結果集
            while (rs.next()) {
                Map<String, Object> hm = new HashMap<String, Object>();
                for (int i = 0; i < columnCount; i++) {
                    // 根據列索引取得每一列的列名,索引從1開始
                    String columnName = rsmd.getColumnName(i + 1);
                    // 根據列名獲得列值
                    Object columnValue = rs.getObject(columnName);
                    // 將列名作為key，列值作為值，放入hm中，每個hm相當於一條記錄
                    hm.put(columnName, columnValue);
                }
                // 將每個hm添加到al中,al相當於是整個表，每個hm是里面的一條記錄
                al.add(hm);
            }
 
            return al;
 
        } catch (ClassNotFoundException | SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            this.close(this.rs, this.pstmt, this.con);
        }
 
        return null;
    }
 
}