? 數據庫驅動程序是JDBC程序和數據庫之間的轉換層，數據庫驅動程序負責將JDBC調用映射成特定的數據庫調用，使用Java JDBC API進行編程，可以為多種關系數據庫提供統一訪問。

jdbc的驅動通常有四種類型

?

1. JDBC-ODPC橋: 它將JDBC API映射到ODPC API。再讓JDBC-ODPC調用數據庫本地驅動代碼(也就是數據庫廠商提供的數據庫操作二進制代碼庫，例如Oracle中的oci.dll)

2. 本地API驅動 直接將JDBC API映射成數據庫特定的客戶端API，即通過客戶端加載數據庫廠商提供的本地代碼庫(

3. 網絡協議驅動 這種類型的驅動給客戶端提供了一個網絡API，客戶端上的JDBC驅動程序使用套接字（Socket）來調用服務器上的中間件程序，後者在將其請求轉化為所需的具體API調用。

4. 本地協議驅動 這種類型的驅動使用Socket，直接在客戶端和數據庫間通信。它是一種直接與數據庫實例交互的JDBC 這種驅動是智能的，它知道數據庫使用的底層協議，也是目前最主流使用的JDBC驅動。
   

   JDBC編程(連接數據庫)步驟

   1.加載數據庫驅動

   ? 使用Class類的forName()靜態方法來加載驅動(由各個數據庫廠商自己實現)

   ? 對於oracle數據庫而言數據庫驅動類對應的字符串：oracle.jdbc.driver.OracleDriver

   ? Class.forName("oracle.jdbc.driver.OracleDriver");

   ? 對於mysql數據庫而言數據庫驅動類對應的字符串：com.mysql.jdbc.Driver

   ? Class.forName("com.mysql.jdbc.Driver");

   2.獲取Connection對象

   ? DriverManager類提供getConnection(String url, String user, String pass);

   ? url: 數據庫連接字符串

   ? user: 用戶名

   ? pass: 密碼

   ? Mysql：

   ? url: jdbc:mysql://hostname:port/databasename

   ? oracle

   ? url: jdbc:oracle:thin:@hostname:port:databasename

   3.通過Connection對象創建Statement對象

   ? Connection創建Statement對象的常用方法有如下2個

   ? createStatement(String sql):創建基本的Statement對象

   ? prepareStatement(String sql): 根據傳入的SQL語句創建預編譯的Statement對象

   4.使用Statement執行SQL語句

   ? execute(): 可以執行任何SQL語句，但比較麻煩

   ? executeUpdate(): 主要用於執行DML和DDL語句。執行DML語句返回受SQL影響的行數，執行DDL語句返回

   ? executeQuery(): 只能執行查詢語句，執行後返回代表查詢結果的ResultSet對象，該對象裏保存了SQL語句查詢的結果。程序可以通過操作該ResultSet對象來取出查詢結果。

   ? ResultSet對象主要提供了如 下方法

   ? 移動記錄指針的方法

   ? next()

   ? previous()

   ? first()

   ? last()

   ? 獲取指針指向的某行的"特定的列值"

   ? getInt()

   ? getString() 　　　　

   ? getObject()

   ? ...

   ? 該方法既可以使用列索引作為參數，也可以使用列名作為參數

   5.回收數據庫資源 包括關閉ResultSet、Statement、Connection等資源
   

   下面以oracle為理，寫一個jdbc增加刪除修改的工具類

   連接數據庫的工具類

       ```
       `package net.wanhe.util;
   
       import java.io.FileInputStream;
       import java.io.FileNotFoundException;
       import java.io.IOException;
       import java.sql.Connection;
       import java.sql.DriverManager;
       import java.sql.PreparedStatement;
       import java.sql.ResultSet;
       import java.sql.SQLException;
       import java.util.Properties;
   
       /**
   
       - 數據的連接以及關閉
   
       - 
   
       - @author Administrator
         *
          */
         public class JDBCUtil {
         private static String driverName;
         private static String url;
         private static String user;
         private static String password;
         /**
   
         - 靜態初始化，初始化一次
           */
           static {
           try {
               Properties p = new Properties();
               // 配置文件放置在工程的下面
               p.load(new FileInputStream("jdbc.properties"));
   
           ```
            driverName = p.getProperty("driverName");
            url = p.getProperty("url");
            user = p.getProperty("user");
            password = p.getProperty("password");
           // 加載驅動
           Class.forName(driverName);
           ```
   
           } catch (FileNotFoundException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           } catch (ClassNotFoundException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           } catch (IOException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
           }
           /**
   
         - 獲取數據庫的連接對象(Connection對象)
           */
           public static Connection getConnection(){
           Connection conn=null;
           try {
               conn=DriverManager.getConnection(url, user, password);
           } catch (SQLException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
           return conn;
           }
           /**
   
         - 關閉數據庫
           */
           public static void close(Connection conn,PreparedStatement ps,ResultSet rs){
           try {
               if(rs!=null){
                   rs.close();
               }
           } catch (SQLException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
           try {
               if(ps!=null){
                   ps.close();
               }
           } catch (SQLException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
           try {
               if(conn!=null){
                   conn.close();
               }
           } catch (SQLException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
           }
   
       }`
       ```
   
       映射的接口
   
       ```
       `package net.wanhe.jdbc;
   
       import java.sql.ResultSet;
   
       public interface RowMapper<T> {
           /**
            * 數據庫中表的一條數據對應的一個對象
            */
           T rowMapper(ResultSet rs);
       }`
       ```
   
       BaseDao的工具類
   
       ```
       package net.wanhe.jdbc;
   
       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.List;
   
       import org.apache.commons.beanutils.BeanUtils;
   
       public class BaseDao<T> {
   
       Class clazz;
   
           /**
            * 獲取泛型信息
            */
           public BaseDao(){
                try {
                   clazz=ReflectionUtil.getGenericSuper(this.getClass());
               } catch (Exception e) {
                   // TODO Auto-generated catch block
                   e.printStackTrace();
               }
           }
           /**
            * 增加，刪除，修改
            */
           public void update(String sql,Object...parameterValues){
               //建立連接
               Connection conn=JDBCUtil.getConnection();
               PreparedStatement ps=null;
               try {
                   //獲取預處理對象
                   ps=conn.prepareStatement(sql);
                   //給占位符賦值
                   setParameters(ps, parameterValues);
                   //執行sql語句
                   ps.executeUpdate();
               } catch (SQLException e) {
                   // TODO Auto-generated catch block
                   e.printStackTrace();
               }finally{
                   JDBCUtil.close(conn, ps,null);
               }
   
           }
   
           /**
   
       - 給占位符賦值
       - @param ps
       - @param parameterValues
       - @throws SQLException
         */
         private void setParameters(PreparedStatement ps, Object... parameterValues) throws SQLException {
         for(int i=0;i<parameterValues.length;i++){
           ps.setObject(i+1, parameterValues[i]);
         }
         }
         /**
       - 增加，返回自增長的值
       - @param sql
       - @param parameterValues
       - @return
         */
         public int insert(String sql,Object...parameterValues){
         //建立連接
         Connection conn=JDBCUtil.getConnection();
         PreparedStatement ps=null;
         ResultSet rs=null;
         int pk=0;
         try {
           //獲取預處理對象
           ps=conn.prepareStatement(sql,new String[]{"id"});
           //給占位符賦值
           setParameters(ps, parameterValues);
           //執行sql語句
           ps.executeUpdate();
           rs=ps.getGeneratedKeys();
           if(rs.next()){
               pk=rs.getInt(1);
           }
   
         } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         }finally{
           JDBCUtil.close(conn, ps,null);
         }
          return pk;
         }
   
           /**
   
       - 查詢
       - @param sql
       - @return
         */
         public List<T> query(String sql,RowMapper rm,Object...parameterValues){
         List<T> list=new ArrayList<T>();
         Connection conn=null;
         PreparedStatement ps=null;
         ResultSet rs=null;
         try {
           conn=JDBCUtil.getConnection();
           ps=conn.prepareStatement(sql);
           setParameters(ps, parameterValues);
           rs=ps.executeQuery();
           while(rs.next()){
               T t=(T) rm.rowMapper(rs);
               list.add(t);
           }
         } catch (SQLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         }finally{
           JDBCUtil.close(conn, ps, rs);
         }
          return list;
         }
   
       }   
       ```
   
       ?       

Java JDBC下執行SQL的不同方式