JDBCHelper .java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.LinkedList;
import java.util.List;

import com.ibeifeng.sparkproject.conf.ConfigurationManager;
import com.ibeifeng.sparkproject.constant.Constants;

/**
 * JDBC輔助組件
 * 
 * 在正式的項目的代碼編寫過程中，是完全嚴格按照大公司的coding標準來的
 * 也就是說，在代碼中，是不能出現(xiàn)任何hard code（硬編碼）的字符
 * 比如“張三”、“com.mysql.jdbc.Driver”
 * 所有這些東西，都需要通過常量來封裝和使用
 * 
 * @author Administrator
 *
 */
public class JDBCHelper {
    
    // 第一步：在靜態(tài)代碼塊中，直接加載數(shù)據(jù)庫的驅(qū)動
    // 加載驅(qū)動，不是直接簡單的，使用com.mysql.jdbc.Driver就可以了
    // 之所以說，不要硬編碼，他的原因就在于這里
    // 
    // com.mysql.jdbc.Driver只代表了MySQL數(shù)據(jù)庫的驅(qū)動
    // 那么，如果有一天，我們的項目底層的數(shù)據(jù)庫要進行遷移，比如遷移到Oracle
    // 或者是DB2、SQLServer
    // 那么，就必須很費勁的在代碼中，找，找到硬編碼了com.mysql.jdbc.Driver的地方，然后改成
    // 其他數(shù)據(jù)庫的驅(qū)動類的類名
    // 所以正規(guī)項目，是不允許硬編碼的，那樣維護成本很高
    // 
    // 通常，我們都是用一個常量接口中的某個常量，來代表一個值
    // 然后在這個值改變的時候，只要改變常量接口中的常量對應(yīng)的值就可以了
    // 
    // 項目，要盡量做成可配置的
    // 就是說，我們的這個數(shù)據(jù)庫驅(qū)動，更進一步，也不只是放在常量接口中就可以了
    // 最好的方式，是放在外部的配置文件中，跟代碼徹底分離
    // 常量接口中，只是包含了這個值對應(yīng)的key的名字
    static {
        try {
            String driver = ConfigurationManager.getProperty(Constants.JDBC_DRIVER);
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();  
        }
    }
    
    // 第二步，實現(xiàn)JDBCHelper的單例化
    // 為什么要實現(xiàn)代理化呢？因為它的內(nèi)部要封裝一個簡單的內(nèi)部的數(shù)據(jù)庫連接池
    // 為了保證數(shù)據(jù)庫連接池有且僅有一份，所以就通過單例的方式
    // 保證JDBCHelper只有一個實例，實例中只有一份數(shù)據(jù)庫連接池
    private static JDBCHelper instance = null;
    
    /**
     * 獲取單例
     * @return 單例
     */
    public static JDBCHelper getInstance() {
        if(instance == null) {
            synchronized(JDBCHelper.class) {
                if(instance == null) {
                    instance = new JDBCHelper();
                }
            }
        }
        return instance;
    }
    
    // 數(shù)據(jù)庫連接池
    private LinkedList<Connection> datasource = new LinkedList<Connection>();
    
    /**
     * 
     * 第三步：實現(xiàn)單例的過程中，創(chuàng)建唯一的數(shù)據(jù)庫連接池
     * 
     * 私有化構(gòu)造方法
     * 
     * JDBCHelper在整個程序運行聲明周期中，只會創(chuàng)建一次實例
     * 在這一次創(chuàng)建實例的過程中，就會調(diào)用JDBCHelper()構(gòu)造方法
     * 此時，就可以在構(gòu)造方法中，去創(chuàng)建自己唯一的一個數(shù)據(jù)庫連接池
     * 
     */
    private JDBCHelper() {
        // 首先第一步，獲取數(shù)據(jù)庫連接池的大小，就是說，數(shù)據(jù)庫連接池中要放多少個數(shù)據(jù)庫連接
        // 這個，可以通過在配置文件中配置的方式，來靈活的設(shè)定
        int datasourceSize = ConfigurationManager.getInteger(
                Constants.JDBC_DATASOURCE_SIZE);
        
        // 然后創(chuàng)建指定數(shù)量的數(shù)據(jù)庫連接，并放入數(shù)據(jù)庫連接池中
        for(int i = 0; i < datasourceSize; i++) {
            String url = ConfigurationManager.getProperty(Constants.JDBC_URL);
            String user = ConfigurationManager.getProperty(Constants.JDBC_USER);
            String password = ConfigurationManager.getProperty(Constants.JDBC_PASSWORD);
            try {
                Connection conn = DriverManager.getConnection(url, user, password);
                datasource.push(conn);  
            } catch (Exception e) {
                e.printStackTrace(); 
            }
        }
    }
    
    /**
     * 第四步，提供獲取數(shù)據(jù)庫連接的方法
     * 有可能，你去獲取的時候，這個時候，連接都被用光了，你暫時獲取不到數(shù)據(jù)庫連接
     * 所以我們要自己編碼實現(xiàn)一個簡單的等待機制，去等待獲取到數(shù)據(jù)庫連接
     * 
     */
    public synchronized Connection getConnection() {
        while(datasource.size() == 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }  
        }
        return datasource.poll();
    }
    
    /**
     * 第五步：開發(fā)增刪改查的方法
     * 1、執(zhí)行增刪改SQL語句的方法
     * 2、執(zhí)行查詢SQL語句的方法
     * 3、批量執(zhí)行SQL語句的方法
     */
    
    /**
     * 執(zhí)行增刪改SQL語句
     * @param sql 
     * @param params
     * @return 影響的行數(shù)
     */
    public int executeUpdate(String sql, Object[] params) {
        int rtn = 0;
        Connection conn = null;
        PreparedStatement pstmt = null;
        
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            
            for(int i = 0; i < params.length; i++) {
                pstmt.setObject(i + 1, params[i]);  
            }
            
            rtn = pstmt.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();  
        } finally {
            if(conn != null) {
                datasource.push(conn);  
            }
        }
        
        return rtn;
    }
    
    /**
     * 執(zhí)行查詢SQL語句
     * @param sql
     * @param params
     * @param callback
     */
    public void executeQuery(String sql, Object[] params, 
            QueryCallback callback) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            
            for(int i = 0; i < params.length; i++) {
                pstmt.setObject(i + 1, params[i]);   
            }
            
            rs = pstmt.executeQuery();
            
            callback.process(rs);  
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(conn != null) {
                datasource.push(conn);  
            }
        }
    }
    
    /**
     * 批量執(zhí)行SQL語句
     * 
     * 批量執(zhí)行SQL語句，是JDBC中的一個高級功能
     * 默認情況下，每次執(zhí)行一條SQL語句，就會通過網(wǎng)絡(luò)連接，向MySQL發(fā)送一次請求
     * 
     * 但是，如果在短時間內(nèi)要執(zhí)行多條結(jié)構(gòu)完全一模一樣的SQL，只是參數(shù)不同
     * 雖然使用PreparedStatement這種方式，可以只編譯一次SQL，提高性能，但是，還是對于每次SQL
     * 都要向MySQL發(fā)送一次網(wǎng)絡(luò)請求
     * 
     * 可以通過批量執(zhí)行SQL語句的功能優(yōu)化這個性能
     * 一次性通過PreparedStatement發(fā)送多條SQL語句，比如100條、1000條，甚至上萬條
     * 執(zhí)行的時候，也僅僅編譯一次就可以
     * 這種批量執(zhí)行SQL語句的方式，可以大大提升性能
     * 
     * @param sql
     * @param paramsList
     * @return 每條SQL語句影響的行數(shù)
     */
    public int[] executeBatch(String sql, List<Object[]> paramsList) {
        int[] rtn = null;
        Connection conn = null;
        PreparedStatement pstmt = null;
        
        try {
            conn = getConnection();
            
            // 第一步：使用Connection對象，取消自動提交
            conn.setAutoCommit(false);  
            pstmt = conn.prepareStatement(sql);
            
            // 第二步：使用PreparedStatement.addBatch()方法加入批量的SQL參數(shù)
            for(Object[] params : paramsList) {
                for(int i = 0; i < params.length; i++) {
                    pstmt.setObject(i + 1, params[i]);  
                }
                pstmt.addBatch();
            }
            
            // 第三步：使用PreparedStatement.executeBatch()方法，執(zhí)行批量的SQL語句
            rtn = pstmt.executeBatch();
            
            // 最后一步：使用Connection對象，提交批量的SQL語句
            conn.commit();
        } catch (Exception e) {
            e.printStackTrace();  
        }
        
        return rtn;
    }
    
    /**
     * 靜態(tài)內(nèi)部類：查詢回調(diào)接口
     * @author Administrator
     *
     */
    public static interface QueryCallback {
        
        /**
         * 處理查詢結(jié)果
         * @param rs 
         * @throws Exception
         */
        void process(ResultSet rs) throws Exception;
        
    }
    
}

JDBCHelperTest.java

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.ibeifeng.sparkproject.jdbc.JDBCHelper;

/**
 * JDBC輔助組件測試類
 * @author Administrator
 *
 */
@SuppressWarnings("unused")
public class JDBCHelperTest {

    public static void main(String[] args) throws Exception {
        // 獲取JDBCHelper的單例
        JDBCHelper jdbcHelper = JDBCHelper.getInstance();
        
        // 測試普通的增刪改語句
//      jdbcHelper.executeUpdate(
//              "insert into test_user(name,age) values(?,?)", 
//              new Object[]{"王二", 28});
        
        // 測試查詢語句
//      final Map<String, Object> testUser = new HashMap<String, Object>();
//      
//      // 設(shè)計一個內(nèi)部接口QueryCallback
//      // 那么在執(zhí)行查詢語句的時候，我們就可以封裝和指定自己的查詢結(jié)果的處理邏輯
//      // 封裝在一個內(nèi)部接口的匿名內(nèi)部類對象中，傳入JDBCHelper的方法
//      // 在方法內(nèi)部，可以回調(diào)我們定義的邏輯，處理查詢結(jié)果
//      // 并將查詢結(jié)果，放入外部的變量中
//      jdbcHelper.executeQuery(
//              "select name,age from test_user where id=?", 
//              new Object[]{5}, 
//              new JDBCHelper.QueryCallback() {
//                  
//                  @Override
//                  public void process(ResultSet rs) throws Exception {
//                      if(rs.next()) {
//                          String name = rs.getString(1);
//                          int age = rs.getInt(2);
//                          
//                          // 匿名內(nèi)部類的使用，有一個很重要的知識點
//                          // 如果要訪問外部類中的一些成員，比如方法內(nèi)的局部變量
//                          // 那么，必須將局部變量，聲明為final類型，才可以訪問
//                          // 否則是訪問不了的
//                          testUser.put("name", name);
//                          testUser.put("age", age);
//                      }
//                  }
//                  
//              });
//      
//      System.out.println(testUser.get("name") + ":" + testUser.get("age"));     
        
        // 測試批量執(zhí)行SQL語句
        String sql = "insert into test_user(name,age) values(?,?)"; 
        
        List<Object[]> paramsList = new ArrayList<Object[]>();
        paramsList.add(new Object[]{"麻子", 30});
        paramsList.add(new Object[]{"王五", 35});
        
        jdbcHelper.executeBatch(sql, paramsList);
    }
    
}