【總結】編寫自己的JDBC框架

一、數據庫連接池： 

　　在一般用JDBC 進行連接數據庫進行CRUD操作時，每一次都會：

　　　　通過：java.sql.Connection conn = DriverManager.getConnection(url,user,password); 重新獲取一個數據庫的鏈接再進行操作，這樣用戶每次請求都需要向數據庫獲得鏈接，而數據庫創建連接通常需要消耗相對較大的資源，創建時間也較長。

      
      　　所以為了減少服務器的壓力，便可用連接池的方法：在啟動Web應用時，數據就創建好一定數量的Connection鏈接
  存放到一個容器中，然后當用戶請求時，服務器則向容器中獲取Connection鏈接來處理用戶的請求，當用戶的請求完成后，
  又將該Connection 鏈接放回到該容器中。這樣的一個容器稱為連接池。

　　　　
  
  編寫一個基本的連接池實現連接復用
     　　步驟：
   　　　　1、建立一個數據庫連接池容器。（因為方便存取，則使用LinkedList集合）
  　　 　　2、初始化一定數量的連接，放入到容器中。
   　　　　3、等待用戶獲取連接對象。（該部分要加鎖）
   　　　　　　 |---記得刪除容器中對應的對象，放置別人同時獲取到同一個對象。
  　　 　　4、提供一個方法，回收用戶用完的連接對象。
  　　 　　5、要遵循先入先出的原則。

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.Properties;


/**
 * 一個基本的數據連接池：  
 * 1、初始化時就建立一個容器，來存儲一定數量的Connection 對象
 * 2、用戶通過調用MyDataSource 的getConnection 來獲取Connection 對象。
 * 3、再通過release 方法來回收Connection 對象，而不是直接關閉連接。
 * 4、遵守先進先出的原則。
 *  
 *     
 * @author 賀佐安
 *
 */
public class MyDataSource {
    private static String url = null;
    private static String password = null;
    private static String user = null ;
    private static String DriverClass = null;
    private static LinkedList<Connection> pool = new LinkedList<Connection>() ;
//    注冊數據庫驅動
    static {
        try {
            InputStream in = MyDataSource.class.getClassLoader()
                    .getResourceAsStream("db.properties");
            Properties prop = new Properties(); 
            prop.load(in);
            user = prop.getProperty("user"); 
            url = prop.getProperty("url") ;
            password = prop.getProperty("password") ; 
            DriverClass = prop.getProperty("DriverClass") ;  
            Class.forName(DriverClass) ;  
            
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        }  
    }
    //初始化建立數據連接池
    public MyDataSource ()  {
        for(int i = 0 ; i < 10 ; i ++) {
            try {
                Connection conn = DriverManager.getConnection(url, user, password) ;
                pool.add(conn) ;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //、從連接池獲取連接
    public Connection getConnection() throws SQLException {
        return pool.remove() ;
    } 
    // 回收連接對象。
    public void release(Connection conn) {
        System.out.println(conn+"被回收");
        pool.addLast(conn) ;
    } 
    public int getLength() {
        return pool.size() ;
    }
}

　　這樣當我們要使用Connection 連接數據庫時，則可以直接使用連接池中Connection 的對象。測試如下：

import java.sql.Connection;
import java.sql.SQLException;

import org.junit.Test;


public class MyDataSourceTest {
    
    
    /**
     * 獲取數據庫連接池中的所有連接。
     */
    @Test
    public void Test() {
        MyDataSource mds = new MyDataSource() ; 
        Connection conn = null ;
        try {
            
            for (int i = 0 ; i < 20 ; i ++) {
                conn = mds.getConnection() ;
                System.out.println(conn+"被獲取；連接池還有："+mds.getLength()); 
                mds.release(conn) ;
            } 
        } catch (SQLException e) {
            e.printStackTrace();
        } 
    }
}

　　再運行的時候，可以發現，循環10次后，又再一次獲取到了第一次循環的得到的Connection對象。所以，這樣可以大大的減輕數據庫的壓力。上面只是一個簡單的數據庫連接池，不完美的便是，回收需要調用數據池的release() 方法來進行回收，那么可以不可以直接調用Connection 實例的close 便完成Connection 對象的回收呢？

 

二、數據源：　 

　　　　> 編寫連接池需實現javax.sql.DataSource接口。
   　　　> 實現DataSource接口，並實現連接池功能的步驟：
    　　　　1、在DataSource構造函數中批量創建與數據庫的連接，並把創建的連接加入LinkedList對象中。

　　　　　 2、實現getConnection方法，讓getConnection方法每次調用時，從LinkedList中取一個Connection返回給用戶。當用戶使用完Connection，調用Connection.close()方法時，Collection對象應保證將自己返回到LinkedList中,而不要把conn還給數據庫。

　　　　利用動態代理和包裝設計模式來標准的數據源。

　　　　1、包裝設計模式實現標准數據源：

　　　　　　這里的用包裝設計模式，便是將Connection 接口進行包裝。簡單總結一下包裝設計模式的步驟：

　　　　　　　　　　a)定義一個類，實現與被包裝類（）相同的接口。
   　　　　　　　　 　　　　|----可以先自己寫一個適配器，然后后面繼承這個適配器，改寫需要改寫的方法，提高編程效率。
  　　　　   　　　　b)定義一個實例變量，記住被包裝類的對象的引用。
   　　　　  　　　　c)定義構造方法，轉入被包裝類的對象。

　　　　　  　　　　e)對需要改寫的方法，改寫。
                　　　　f)對不需要改寫的方法，調用原來被包裝類的對應方法。

　　　　　　所以先編寫一個類似適配器的類，將Connection 接口的方法都進行實現：

import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.util.Map;
import java.util.Properties;


/**
 * 實現Connection 的適配器：
 * 目的：在使用包裝設計模式時方便使用
 * @author 賀佐安
 *
 */

public class MyConnectionAdapter implements Connection {
    //用一個實例變量，記住被包裝類的實例引用
    protected Connection conn ;  
    //構造函數，轉入被包裝類的對象
    public MyConnectionAdapter(Connection conn) {
        this.conn = conn ;
    }
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return conn.unwrap(iface);
    }
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return conn.isWrapperFor(iface);
    }
    @Override
    public Statement createStatement() throws SQLException {
        return conn.createStatement();
    }
    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return conn.prepareStatement(sql);
    }
    @Override
    public CallableStatement prepareCall(String sql) throws SQLException {
        return conn.prepareCall(sql);
    }
    @Override
    public String nativeSQL(String sql) throws SQLException {
        return conn.nativeSQL(sql);
    }
    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {
        conn.setAutoCommit(autoCommit);
    }
    @Override
    public boolean getAutoCommit() throws SQLException {
        return conn.getAutoCommit();
    }
    @Override
    public void commit() throws SQLException {
        conn.commit() ;
    }
    @Override
    public void rollback() throws SQLException {
        conn.rollback() ;
    }
    @Override
    public void close() throws SQLException {
        conn.close() ;
    }
    @Override
    public boolean isClosed() throws SQLException {
        return conn.isClosed();
    }
    @Override
    public DatabaseMetaData getMetaData() throws SQLException {
        return conn.getMetaData();
    }
    @Override
    public void setReadOnly(boolean readOnly) throws SQLException {
        conn.setReadOnly(readOnly);
    }
    @Override
    public boolean isReadOnly() throws SQLException {
        return conn.isReadOnly();
    }
    @Override
    public void setCatalog(String catalog) throws SQLException {
        conn.setCatalog(catalog) ;
    }
    @Override
    public String getCatalog() throws SQLException {
        return conn.getCatalog();
    }
    @Override
    public void setTransactionIsolation(int level) throws SQLException {
        conn.setTransactionIsolation(level) ;
    }
    @Override
    public int getTransactionIsolation() throws SQLException {
        return conn.getTransactionIsolation();
    }
    @Override
    public SQLWarning getWarnings() throws SQLException {
        return conn.getWarnings();
    }
    @Override
    public void clearWarnings() throws SQLException {
        conn.clearWarnings() ;
    }
    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency)
            throws SQLException {
        return conn.createStatement(resultSetType, resultSetConcurrency);
        
    }
    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType,
            int resultSetConcurrency) throws SQLException {
        return conn.prepareStatement(sql, resultSetType, resultSetConcurrency);
    }
    @Override
    public CallableStatement prepareCall(String sql, int resultSetType,
            int resultSetConcurrency) throws SQLException {
        return conn.prepareCall(sql, resultSetType, resultSetConcurrency);
    }
    @Override
    public Map<String, Class<?>> getTypeMap() throws SQLException {
        return conn.getTypeMap();
    }
    @Override
    public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
        conn.setTypeMap(map) ;
    }
    @Override
    public void setHoldability(int holdability) throws SQLException {
        conn.setHoldability(holdability) ;
    }
    @Override
    public int getHoldability() throws SQLException {
        return conn.getHoldability();
    }
    @Override
    public Savepoint setSavepoint() throws SQLException {
        return conn.setSavepoint();
    }
    @Override
    public Savepoint setSavepoint(String name) throws SQLException {
        return conn.setSavepoint(name);
    }
    @Override
    public void rollback(Savepoint savepoint) throws SQLException {
        conn.rollback(savepoint);
    }
    @Override
    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
        conn.releaseSavepoint(savepoint);
    }
    @Override
    public Statement createStatement(int resultSetType,
            int resultSetConcurrency, int resultSetHoldability)
            throws SQLException {
        return conn.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
    }
    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType,
            int resultSetConcurrency, int resultSetHoldability)
            throws SQLException {
        return conn.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
    }
    @Override
    public CallableStatement prepareCall(String sql, int resultSetType,
            int resultSetConcurrency, int resultSetHoldability)
            throws SQLException {
        return conn.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
    }
    @Override
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
            throws SQLException {
        return conn.prepareStatement(sql, autoGeneratedKeys);
    }
    @Override
    public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
            throws SQLException {
        return conn.prepareStatement(sql, columnIndexes);
    }
    @Override
    public PreparedStatement prepareStatement(String sql, String[] columnNames)
            throws SQLException {
        return conn.prepareStatement(sql, columnNames);
    }
    @Override
    public Clob createClob() throws SQLException {
        return conn.createClob();
    }
    @Override
    public Blob createBlob() throws SQLException {
        return conn.createBlob();
    }
    @Override
    public NClob createNClob() throws SQLException {
        return conn.createNClob();
    }
    @Override
    public SQLXML createSQLXML() throws SQLException {
        return conn.createSQLXML();
    }
    @Override
    public boolean isValid(int timeout) throws SQLException {
        return conn.isValid(timeout);
    }
    @Override
    public void setClientInfo(String name, String value)
            throws SQLClientInfoException {
        conn.setClientInfo(name, value) ;
    }
    @Override
    public void setClientInfo(Properties properties)
            throws SQLClientInfoException {
        conn.setClientInfo(properties) ;
    }
    @Override
    public String getClientInfo(String name) throws SQLException {
        return conn.getClientInfo(name);
    }
    @Override
    public Properties getClientInfo() throws SQLException {
        return conn.getClientInfo();
    }
    @Override
    public Array createArrayOf(String typeName, Object[] elements)
            throws SQLException {
        return conn.createArrayOf(typeName, elements);
    }
    @Override
    public Struct createStruct(String typeName, Object[] attributes)
            throws SQLException {
        return conn.createStruct(typeName, attributes);
    }
 
}

　　　　　　然后再對Connection 接口進行包裝，將close 方法修改掉：

import java.sql.Connection;
import java.sql.SQLException;
import java.util.LinkedList;
/**
 * 對MyConnectionAdapter 進行包裝處理 
 * @author 賀佐安
 *
 */
public class MyConnectionWrap extends MyConnectionAdapter {

    private LinkedList<Connection> pool = new LinkedList<Connection>() ;
    public MyConnectionWrap(Connection conn ,LinkedList<Connection> pool ) {
        super(conn); 
        this.pool = pool ; 
    }
    
    //改寫要實現的方法
    public void close() throws SQLException {
        pool.addLast(conn) ;
    }
}

　　　　　　編寫標准數據源：

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.ResourceBundle;

import javax.sql.DataSource;


/** 
 * 編寫標准的數據源：
 * 1、實現DataSource 接口
 * 2、獲取在實現類的構造方法中批量獲取Connection 對象，並將這些Connection 存儲
 * 在LinkedList 容器中。
 * 3、實現getConnection() 方法，調用時返回LinkedList容器的Connection對象給用戶。
 * @author 賀佐安
 *
 */
public class MyDataSource implements DataSource{
    private static String url = null;
    private static String password = null;
    private static String user = null ;
    private static String DriverClass = null;
    private static LinkedList<Connection> pool = new LinkedList<Connection>() ;

    //    注冊數據庫驅動
    static {
        try {  
            ResourceBundle rb = ResourceBundle.getBundle("db") ;
            url = rb.getString("url") ; 
            password = rb.getString("password") ; 
            user = rb.getString("user") ; 
            DriverClass = rb.getString("DriverClass") ;
            Class.forName(DriverClass) ;  
            
            //初始化建立數據連接池
            for(int i = 0 ; i < 10 ; i ++) {
                Connection conn = DriverManager.getConnection(url, user, password) ;
                pool.add(conn) ;
            }
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        } 
        
    }
    public MyDataSource ()  {  
    }
    
    //、從連接池獲取連接:通過包裝模式
    public synchronized Connection getConnection() throws SQLException {
        if (pool.size() > 0) {
            MyConnectionWrap mcw = new MyConnectionWrap(pool.remove(), pool) ;
            return mcw ;
        }else {
            throw new RuntimeException("服務器繁忙！"); 
        }
    }
    
    // 回收連接對象。
    public void release(Connection conn) {
        System.out.println(conn+"被回收");
        pool.addLast(conn) ;
    }
    
    public int getLength() {
        return pool.size() ;
    }
    
    
    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }
    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
        
    }
    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
        
    }
    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
    @Override
    public Connection getConnection(String username, String password)
            throws SQLException {
        return null;
    }
    
}

 

 

　　2、動態代理實現標准數據源：

　　　　相對於用包裝設計來完成標准數據源，用動態代理則方便許多：

　　

import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.ResourceBundle;

import javax.sql.DataSource;


/** 
 * 編寫標准的數據源：
 * 1、實現DataSource 接口
 * 2、獲取在實現類的構造方法中批量獲取Connection 對象，並將這些Connection 存儲
 * 在LinkedList 容器中。
 * 3、實現getConnection() 方法，調用時返回LinkedList容器的Connection對象給用戶。
 * @author 賀佐安
 *
 */
public class MyDataSource implements DataSource{
    private static String url = null;
    private static String password = null;
    private static String user = null ;
    private static String DriverClass = null;
    private static LinkedList<Connection> pool = new LinkedList<Connection>() ;

    //    注冊數據庫驅動
    static {
        try {  
            ResourceBundle rb = ResourceBundle.getBundle("db") ;
            url = rb.getString("url") ; 
            password = rb.getString("password") ; 
            user = rb.getString("user") ; 
            DriverClass = rb.getString("DriverClass") ;
            Class.forName(DriverClass) ;  
            
            //初始化建立數據連接池
            for(int i = 0 ; i < 10 ; i ++) {
                Connection conn = DriverManager.getConnection(url, user, password) ;
                pool.add(conn) ;
            }
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        }  
    }
    public MyDataSource ()  { 
        
    }
    
    //、從連接池獲取連接:通過動態代理
    public Connection getConnection() throws SQLException {
        if (pool.size() > 0) {
            final Connection conn  = pool.remove() ; 
            Connection proxyCon = (Connection) Proxy.newProxyInstance(conn.getClass().getClassLoader(), conn.getClass().getInterfaces(), 
                    new InvocationHandler() {
                        //策略設計模式：
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args)
                                throws Throwable {
                            if("close".equals(method.getName())){
                                //誰調用，
                                return pool.add(conn);//當調用close方法時，攔截了，把鏈接放回池中了
                            }else{
                                return method.invoke(conn, args);
                            } 
                        }
                    });
          return proxyCon ;
        }else {
            throw new RuntimeException("服務器繁忙！"); 
        }
    } 
    
    public int getLength() {
        return pool.size() ;
    }
    
    
    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }
    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
        
    }
    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
        
    }
    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
    @Override
    public Connection getConnection(String username, String password)
            throws SQLException {
        return null;
    } 
}

　　　　當然覺得麻煩的則可以直接使用一些開源的數據源如：DBCP、C3P0等。DBCP的原理是用包裝設計模式開發的數據源，而C3P0則是動態代理的。

　　　　1、DBCP的使用：

import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;

/**
 * 創建DBCP 工具類
 * @author 賀佐安
 *
 */
public class DbcpUtil {
    private static DataSource ds = null ;
    static {
        try {
            //讀取配置文件
            InputStream in = DbcpUtil.class.getClassLoader().getResourceAsStream("dbcpconfig.properties") ;
            Properties prop = new Properties() ; 
            prop.load(in) ;
            
            //通過BasicDataSourceFactory 的creatDataSurce 方法創建 BasicDataSource 對象。
            ds = BasicDataSourceFactory.createDataSource(prop) ;
            
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
    public static DataSource getDs() {
        return ds ; 
    }
    public static Connection getConnection () {
        try { 
            return ds.getConnection() ;
        } catch (SQLException e) {
            throw new RuntimeException() ;
        } 
    }
}

　　　　2、C3P0 的使用：

import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;
/**
 * C3P0 開源數據源的使用
 * @author 賀佐安
 *
 */
public class C3p0Util {
    private static ComboPooledDataSource cpds  = null ;
    static {
        
        cpds = new ComboPooledDataSource() ; 
    }
    public static Connection getConnection() {
        try {
            return cpds.getConnection() ;
        } catch (SQLException e) {
            throw new RuntimeException() ;
        }
    }
}

　　使用這兩個數據源時，直接調用獲取到的Connection 連接的close 方法，也是將連接放到pool中去。

　　　　

 

三、元數據（DatabaseMetaData）信息的獲取

　　> 元數據：數據庫、表、列的定義信息。    

　　> 元數據信息的獲取：為了編寫JDBC框架使用。   

　　　　　　1、數據庫本身信息的獲取：java.sql.DataBaseMateData java.sql.Connection.getMetaData() ;    

　　　　　　DataBaseMateData 實現類的常用方法：    

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

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

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

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

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

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

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

　　　　　　2、ParameterMetaData: 代表PerparedStatment 中的SQL 參數元數據信息：    java.sql.ParameterMetaData java.sql.PerparedStatement.getParameterMetaData() ;    　　　　　　

　　　　　　ParameterMetaData 實現類常用方法：     

　　　　　　　　getParameterCount() ：獲得指定參數的個數    

　　　　　　　　getParameterType(int param) ：獲得指定參數的sql類型（驅動可能不支持）

 　　 　　　3、ResultSetMetaData : 代表結果集的源數據信息：相當於SQL 中的 ：DESC    java.sql.ResultSetMetaData java.sql.ResultSet.getMetaData() ;        　　　　　　　　

　　　　　　java.sql.ResultSetMetaData 接口中常用的方法：     

　　　　　　　　a) getColumnCount() : 獲取查詢方法有幾列。     

　　　　　　　　b) getColumnName(int index) : 獲取列名:index從1開始。     

　　　　　　　　c) getColumnType(int index) : 獲取列的數據類型。返回的是TYPES  中的常量值。

 

 

四、編寫自己的JDBC框架：

　　　　JDBC框架的基本組成：　　

　　　　1、核心類：

　　　　　　a、定義一個指定javax.sql.DataSource 實例的引用變量,通過構造函數獲取指定的實例並給定義的變量。
  　　　　　 b、編寫SQL運行框架。

　　　　　　 　　DML 語句的編寫：
   　　　　　　　　　　1、通過獲取的javax.sql.DataSource 實例，獲取Connection 對象。
  　　 　　　　　　　　2、通過ParamenterMeteData 獲取數據庫元數據。
   
   　　　　　　　 DQL 語句的編寫：
   　　　　　　　　　　1、通過獲取的DataSource 實例，獲取Connection 對象。
   　　　　　　　　　　2、通過ParamenterMeteData、ResultSetMetaData 等獲取數據庫元數據。
   　　　　　　　　　　3、用抽象策略設計模式：設計一個ResultSetHandler 接口，作用：將查找出的數據封裝到指定的JavaBean中。
    　　　　　　　　　　　　　　　　|————這里的JavaBean，由用戶來指定。
    　　　　　　　　　　　　　　　　抽象策略模式，用戶可以更具具體的功能來擴展成具體策略設計模式。如：查找的一條信息、查找的所有信息。

import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

/**
 * 實現JDBC 框架的核心類。
 * 在該類中定義了SQL語句完成的方法；
 * @author 賀佐安
 *
 */
public class  MyJdbcFrame {
    /**
     * javax.sql.DataSource 實例的引用變量
     */
    private DataSource ds = null ;
    /**
     * 將用戶指定的DataSource 指定給系統定義的DataSource 實例的引用變量
     * @param ds
     */
    public MyJdbcFrame(DataSource ds ) {
        this.ds = ds ; 
    }
    /**
     * 執行UPDATE、DELETE、INSERT 語句。
     * @param sql 
     * @param obj
     */
    public void update(String sql , Object[] obj) {
        Connection conn = null ; 
        PreparedStatement stmt = null ; 
        try {
            //獲取Connection 對象
            conn = ds.getConnection() ;
            stmt = conn.prepareStatement(sql) ; 
            
            // 獲取ParameterMetaData 元數據對象。
            ParameterMetaData pmd = stmt.getParameterMetaData() ;
            
            //獲取SQL語句中需要設置的參數的個數
            int parameterCount = pmd.getParameterCount() ;
            if (parameterCount > 0) { 
                if (obj == null || obj.length != parameterCount) {
                    throw new MyJdbcFrameException( "parameterCount is error!") ;
                } 
                //設置參數：
                for ( int i = 0 ; i < obj.length ; i++) {
                    stmt.setObject(i+1, obj[i]) ;
                }
            } 
            //執行語句：
            stmt.executeUpdate() ; 
            
        } catch(Exception e ) {
            throw new MyJdbcFrameException(e.getMessage()) ;
        } finally {
            release(stmt, null, conn) ;
        }
    }
    
    public Object query(String sql , Object[] obj , ResultSetHandler rsh) {
        Connection conn = null ; 
        PreparedStatement stmt = null ; 
        ResultSet rs = null ;
        try {
            //獲取Connection 對象
            conn = ds.getConnection() ;
            stmt = conn.prepareStatement(sql) ; 
            
            // 獲取ParameterMetaData 元數據對象。
            ParameterMetaData pmd = stmt.getParameterMetaData() ;
            
            //獲取SQL語句中需要設置的參數的個數
            int parameterCount = pmd.getParameterCount() ;
            
            if (obj.length != parameterCount) {
                throw new MyJdbcFrameException( "'" +sql +"' : parameterCount is error!") ;
            } 
            //設置參數：
            for ( int i = 0 ; i < obj.length ; i++) {
                stmt.setObject(i+1, obj[i]) ;
            }
            //執行語句：
            rs = stmt.executeQuery(); 
            
            return rsh.handler(rs);
        } catch(Exception e ) {
            throw new MyJdbcFrameException(e.getMessage()) ;
        } finally {
            release(stmt, null, conn) ;
        } 
    } 
    /**
     * 釋放資源
     * @param stmt
     * @param rs
     * @param conn
     */
    public static void release(Statement stmt 
                             , ResultSet rs 
                             , Connection conn) {
        if(rs != null) {
            try {
                rs.close() ;
            } catch (SQLException e) {
                e.printStackTrace();
            }
            rs = null ;
        }
        if (stmt != null) { 
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            } 
            stmt = null ;
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            conn = null ;
        }
    } 
    
}

　　　　2、接口：策略模式的接口：ResultSetHandler 。

import java.sql.ResultSet;

//抽象策略模式
public interface ResultSetHandler {
    public Object handler(ResultSet rs) ;
}

　　　　這里對ResultSetHandler 接口實現一個BeanHandler 實例 ：

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

/**
 * 該類獲取ResultSet 結果集中的第一個值，封裝到JavaBean中
 * @author 賀佐安
 *
 */
public class BeanHandler implements ResultSetHandler { 
    //獲取要封裝的JavaBean的字節碼
    private Class clazz ;
    public BeanHandler (Class clazz) {
        this.clazz = clazz ;
    }

    public Object handler(ResultSet rs) {
        try {
            if (rs.next()) {
                //1、獲取結果集的元數據。
                ResultSetMetaData rsm = rs.getMetaData() ;
                //2、創建JavaBean的實例：
                Object obj = clazz.newInstance() ;
                //3、將數據封裝到JavaBean中。  
                for (int i = 0 ; i < rsm.getColumnCount() ; i ++) {
                    //獲取屬性名
                    String columnName = rsm.getColumnName(i+1) ; 
                    //獲取屬性值
                    Object value = rs.getObject(i+1) ; 
                    
                    Field objField = obj.getClass().getDeclaredField(columnName) ;
                    objField.setAccessible(true) ;
                    objField.set(obj, value) ;
                }
                return obj ;
            } else {
                return null ;
            }
        } catch (Exception e) {
            throw new RuntimeException(e) ;
        }   
    } 
}

　　　　3、自定義異常類：繼承RuntimeException。如：

public class MyJdbcFrameException extends RuntimeException {
    public MyJdbcFrameException() {
        super() ; 
    }
    public MyJdbcFrameException(String e) {
        super(e) ;
    }
}

　　　　

　　然后就可以將其打包發布，在以后寫數據庫操作時就可以用自己的JDBC框架了，如果要完成查詢多條語句什么的，則要實現ResultSetHandler 接口。來完成更多的功能。

　　當然，使用DBUtils 則更簡單：Apache 組織提供的一個開源JDBC 工具類庫。

　　　　

　

 

--------------------------------------------------------------------------------------學習時的總結。2013年7月18日 19:29:44