JDBC 學習筆記（四）—— 自定義JDBC框架+Apache—DBUtils框架+事務管理+操作多表

本文目錄:

      1、自定義JDBC框架 ——數據庫元數據：DataBaseMetaData 

      2、自定義JDBC框架 ——數據庫元數據：DataBaseMetaData 

      3、自定義JDBC框架 ——結果集元數據： ResultSetMetaData 

      4、使用元數據簡化JDBC代碼 

            (1) 萬能更新 

            (2) 萬能查詢 

      5、Apache—DBUtils框架簡介 

      6、DbUtils類 介紹 

      7、QueryRunner類 介紹 

      8、QueryRunner類的主要方法 

      9、ResultSetHandler接口 介紹 

      10、ResultSetHandler 接口的實現類 

      11、JDBC應用的事務管理（ThreadLocal類）  

      12、JDBC應用的事務管理——采用跨層跨層傳遞方法參數 

      13、JDBC應用的事務管理—— ThreadLocal 綁定連接 

      14、使用JDBC操作多個表

      15、使用JDBC操作多個表—— “一對多”關系  

      16、使用JDBC操作多個表—— 多對多關系 

      17、數據庫端——表關系間的級聯操作

 

1、自定義JDBC框架 ——數據庫元數據：DataBaseMetaData 

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

DataBaseMetaData   connection.getDatabaseMetaData()     

獲得代表DataBaseMetaData 對象元數據的DataBaseMetaData 對象。 

    DataBaseMetaData對象中的方法： 

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

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

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

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

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

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

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

Demo樣例： 獲取數據庫的元數據  

  public void test1() throws SQLException{ 

        Connection conn = JdbcUtils_C3P0.getConnection(); 

        DatabaseMetaData meta = conn.getMetaData(); 

        System.out.println(meta.getDatabaseProductName()); 

        System.out.println(meta.getDatabaseMajorVersion()); 

        System.out.println(meta.getDatabaseMinorVersion()); 

  } 

 

2、自定義JDBC框架 ——數據庫元數據：DataBaseMetaData 

ParameterMetaData   PreparedStatement . getParameterMetaData() 

獲得代表PreparedStatement元數據的ParameterMetaData對象。 

例如：SQL語句 “ Select * from user where name=? And password=?  ” 中的兩個“ ？” 問號。 

ParameterMetaData對象 中的方法： 

        (1) getParameterCount()    --獲得指定參數的個數 

        (2) getParameterType(int param)    -- 獲得指定參數的sql類型(Mysql數據庫不支持該方法，會報異常。) 

Demo樣例：參數元數據 

      public void test2() throws SQLException{ 

            Connection conn = JdbcUtils_C3P0.getConnection(); 

            String sql = "insert into user(id,name) values(?,?)";  

            PreparedStatement st = conn.prepareStatement(sql); 

            ParameterMetaData meta = st.getParameterMetaData();       

            System.out.println(meta.getParameterCount());

            System.out.println(meta.getParameterType(1)); 

      }

 

3、自定義JDBC框架 ——結果集元數據： ResultSetMetaData 

ResultSetMetaData   ResultSet. getMetaData() 

獲得代表ResultSet對象元數據的ResultSetMetaData對象。 

    ResultSetMetaData對象中的方法 

            (1) getColumnCount()    -- 返回resultset對象的列數 

            (2) getColumnName(int column)    -- 獲得指定列的名稱 

            (3) getColumnTypeName(int column)    -- 獲得指定列的類型 

Demo樣例： 結果集元數據 

      public void test3() throws SQLException{ 

            Connection conn = JdbcUtils_C3P0.getConnection(); 

            String sql = "select * from account"; 

            PreparedStatement st = conn.prepareStatement(sql); 

            ResultSet rs = st.executeQuery();      

            ResultSetMetaData  meta = rs.getMetaData(); 

            System.out.println(meta.getColumnCount()); 

            System.out.println(meta.getColumnName(1)); 

            System.out.println(meta.getColumnName(2)); 

            System.out.println(meta.getColumnName(3));     

      }

 

4、使用元數據簡化JDBC代碼 

業務背景：系統中所有實體對象都涉及到基本的CRUD操作： 

        (1) 萬能更新 

        所有實體的CUD操作代碼基本相同，僅僅發送給數據庫的SQL語句不同而已，因此可以把CUD操作的所有相同代碼抽取到工具類的一個update方法中，並定義參數接收變化的SQL語句。 

Demo樣例1：萬能更新的方法內容部分

public static void update(String sql,Object params[]) throws SQLException{
        Connection conn = null;
        PreparedStatement st = null
        ResultSet rs = null;
        try{
              conn = getConnection();
              st = conn.prepareStatement(sql);
              for(int i=0;i<params.length;i++){
                    st.setObject(i+1,params[i]);
              }
              st.executeUpdate();
        }finally{
              release(conn, st, rs);
        }
  }

Demo樣例2：萬能更新方法的調用代碼

public class CustomerDaoImpl implements CustomerDao {
          public void add(Customer c){
                try{
                      String sql = "insert into customer(id,name,gender,birthday,cellphone,email,preference,type,description) values(?,?,?,?,?,?,?,?,?)";
                      Object params[] = {c.getId(),c.getName(),c.getGender(),c.getBirthday(),c.getCellphone(),c.getEmail(),c.getPreference(),c.getType(),c.getDescription()};
                      JdbcUtils.update(sql, params);
                }catch (Exception e) {
                      throw new DaoException(e);
                }
          }
          public void update(Customer c){   //id
                try{
                      String sql = "update customer set name=?,gender=?,birthday=?,cellphone=?,email=?,preference=?,type=?,description=?  where id=?";
                      Object params[] = {c.getName(),c.getGender(),c.getBirthday(),c.getCellphone(),c.getEmail(),c.getPreference(),c.getType(),c.getDescription(),c.getId()};
                      JdbcUtils.update(sql, params);
                }catch (Exception e) {
                      throw new DaoException(e);
                } 
          }
          public void delete(String id){
                try{
                      String sql = "delete from customer where id=?";
                      Object params[] = {id};
                      JdbcUtils.update(sql, params);
                }catch (Exception e) {
                      throw new DaoException(e);
                } 
          } 
    ｝

　　　(2) 萬能查詢 

        實體的R操作，除SQL語句不同之外，根據操作的實體不同，對ResultSet的映射也各不相同，因此可義一個query方法，除以參數形式接收變化的SQL語句外，可以使用策略模式由qurey方法的調用者決定如何把ResultSet中的數據映射到實體對象中。 

         備注：關於自定義萬能查詢的代碼，涉及到自定義處理器等代碼，上面所述的數據庫元數據的各種知識也都應用到其中，故有些復雜，不便學習。有萬能查詢需求的請學習Apache—DBUtils框架 中的查詢方法部分，相對來說只要會調用即可，學習成本會小一些。

 

5、Apache—DBUtils框架簡介 

        commons-dbutils 是 Apache 組織提供的一個開源 JDBC工具類庫，它是對JDBC的簡單封裝，學習成本極低，並且使用dbutils能極大簡化jdbc編碼的工作量，同時也不會影響程序的性能。因此dbutils成為很多不喜歡hibernate的公司的首選。 

        工具類：    org.apache.commons.dbutils.DbUtils。    

        API介紹： 

           (1)  org.apache.commons.dbutils.QueryRunner  

           (2)  org.apache.commons.dbutils.ResultSetHandler  

 

6、DbUtils類 介紹 

        DbUtils ：提供如關閉連接、裝載JDBC驅動程序等常規工作的工具類，里面的所有方法都是靜態的。主要方法如下： 

        (1) public static void close(…) throws java.sql.SQLException：　DbUtils類提供了三個重載的關閉方法。這些方法檢查所提供的參數是不是NULL，如果不是的話，它們就關閉Connection、Statement和ResultSet。 

        (2) public static void closeQuietly(…): 這一類方法不僅能在Connection、Statement和ResultSet為NULL情況下避免關閉，還能隱藏一些在程序中拋出的SQLException。

        (3) public static void commitAndCloseQuietly(Connection conn)： 用來提交連接，然后關閉連接，並且在關閉連接時不拋出SQL異常。  

        (4) public static boolean loadDriver(java.lang.String driverClassName)：這一方裝載並注冊JDBC驅動程序，如果成功就返回true。使用該方法，你不需要捕捉這個異常ClassNotFoundException。

 

7、QueryRunner類 介紹 

        該類簡單化了SQL查詢，它與ResultSetHandler組合在一起使用可以完成大部分的數據庫操作，能夠大大減少編碼量。 

        QueryRunner類提供了兩個構造方法： 

            (1) 默認的構造方法： 

                    QueryRunner()  

            (2) 需要一個 javax.sql.DataSource 來作參數的構造方法。

                    QueryRunner(DataSource ds)   

 

8、QueryRunner類的主要方法 

        (1) public Object query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) throws SQLException：執行一個查詢操作，在這個查詢中，對象數組中的每個元素值被用來作為查詢語句的置換參數。該方法會自行處理 PreparedStatement 和 ResultSet 的創建和關閉。 

        (2) public Object query(String sql, Object[] params, ResultSetHandler rsh) throws SQLException:　幾乎與第一種方法一樣；唯一的不同在於它不將數據庫連接提供給方法，並且它是從提供給構造方法的數據源(DataSource) 或使用的setDataSource 方法中重新獲得 Connection。     

        (3) public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException : 執行一個不需要置換參數的查詢操作。     

        (4) public int update(Connection conn, String sql, Object[] params) throws SQLException:用來執行一個更新（插入、更新或刪除）操作。      

        (5) public int update(Connection conn, String sql) throws SQLException：用來執行一個不需要置換參數的更新操作。 

Demo樣例：使用dbutils完成數據庫的crud 

public class Demo1 { 
  /*
   create database day17;
   use day17;
   create table users(
    id int primary key,
    name varchar(40),
    password varchar(40),
    email varchar(60),
    birthday date
  );
   */ 
   
  @Test
  public void insert() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "insert into users(id,name,password,email,birthday) values(?,?,?,?,?)";
    Object params[] = {2,"bbb","123","[e-mail]",new Date()};
    runner.update(sql, params);
  }

  @Test
  public void update() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "update users set email=? where id=?";
    Object params[] = {"[e-mail]",1};
    runner.update(sql, params);
  } 

  @Test
  public void delete() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "delete from users where id=?";
    runner.update(sql, 1);
  }

  @Test
  public void find() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "select * from users where id=?";
    User user = (User) runner.query(sql, 1, new BeanHandler(User.class));
    System.out.println(user.getEmail());
  }

  @Test
  public void getAll() throws Exception{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "select * from users";
    List list = (List) runner.query(sql, new BeanListHandler(User.class));
    System.out.println(list);
  }

  @Test
  public void batch() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql =  "insert into users(id,name,password,email,birthday) values(?,?,?,?,?)";
    Object params[][] = new Object[3][5];
    for(int i=0;i<params.length;i++){  //3
      params[i] = new Object[]{i+1,"aa"+i,"123",i + "@sina.com",new Date()};
    }
    runner.batch(sql, params);
  }
}

9、ResultSetHandler接口 介紹 

        該接口用於處理 java.sql.ResultSet，將數據按要求轉換為另一種形式。 

        ResultSetHandler 接口提供了一個單獨的方法：Object handle (java.sql.ResultSet .rs)。   

 

10、ResultSetHandler 接口的實現類 

        (1) ArrayHandler( )：把結果集中的第一行數據轉成對象數組。 

        (2) ArrayListHandler( )：把結果集中的每一行數據都轉成一個數組，再存放到List中。 

        (3) BeanHandler(Class type) ：將結果集中的第一行數據封裝到一個對應的JavaBean實例中。 

        (4) BeanListHandler(Class type) ：將結果集中的每一行數據都封裝到一個對應的JavaBean實例中，存放到List里。 

        (5) ColumnListHandler(int columnIndex / String columnName)：將結果集中某一列的數據存放到List中。 

        (6) KeyedHandler( int columnIndex / String columnName )：將結果集中的每一行數據都封裝到一個Map里，再把這些map再存到一個map里，並將其columnName的值作為指定的key。 

        (7) MapHandler( )：將結果集中的第一行數據封裝到一個Map里，key是列名，value就是對應的值。 

        (8) MapListHandler( )：將結果集中的每一行數據都封裝到一個Map里，然后再存放到List 

        (9)  ScalarHandler( )：將結果集中的某一列 裝入到一個對象中。 

Demo樣例：測試dbutils的各個結果集處理器

public class Demo2 {   
  @Test
  public void test1() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "select * from users where id=?";
    Object result[] = (Object[]) runner.query(sql,1, new ArrayHandler());
    System.out.println(result[0]);
    System.out.println(result[1]);
  }  

  @Test
  public void test2() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "select * from users";
    List list = (List) runner.query(sql, new ArrayListHandler());
    System.out.println(list);
  }

  @Test
  public void test3() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "select * from users";
    List list = (List) runner.query(sql, new ColumnListHandler1("name"));
    System.out.println(list);
  }  

  @Test
  public void test4() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "select * from users";
    Map<Integer,Map<String,Object>> map = (Map) runner.query(sql, new KeyedHandler("id"));
    for(Map.Entry<Integer,Map<String,Object>> me : map.entrySet()){
      int id = me.getKey();
      for(Map.Entry<String, Object> entry : me.getValue().entrySet()){
        String name = entry.getKey();
        Object value = entry.getValue();
        System.out.println(name + "=" + value);
      }
    }
  }

  @Test  //獲取總記錄數。
  public void test5() throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "select count(*) from users";
    /* 方式一：
    Object result[] = (Object[]) runner.query(sql, new ArrayHandler());
    long totalrecord = (Long)result[0];
    int num = (int)totalrecord;
    System.out.println(num);
    int totalrecord = ((Long)result[0]).intValue();
    */
    
    //方式二：
    int totalrecord = ((Long)runner.query(sql, new ScalarHandler(1))).intValue();
    System.out.println(totalrecord);
  }
}
//自定義
class ColumnListHandler1 implements ResultSetHandler{ 
  private String columnName;
  public ColumnListHandler1(String columnName){
    this.columnName = columnName;
  }
  public Object handle(ResultSet rs) throws SQLException {
    List list = new ArrayList();
    while(rs.next()){
      list.add(rs.getObject(columnName));
    }
    return list;
  }
}

11、JDBC應用的事務管理（ThreadLocal類）  

JDBC 應用的事務管理——Service層和Dao層事務的傳遞。 

    方式一：跨層傳遞方法參數——在Service層創建開啟事務的連接，並傳遞到Dao層，最后在Service層提交事務； 

    方式二：ThreadLocal 綁定連接——使用ThreadLocal進行事務管理——ThreadLocal可以實現在線程范圍內實現數據共享。 

    方式三：使用Spring進行事務管理。 

 

12、JDBC應用的事務管理——采用跨層跨層傳遞方法參數 

思想：在Service層創建開啟事務的連接，並傳遞到Dao層，最后在Service層提交事務；

Demo樣例1：Service層（Dao層中只要在方法中參數中接收該 連接參數 就好了）

public class BusinessService {  
  /*  
  create table account(
    id int primary key auto_increment,
    name varchar(40),
    money float
  )character set utf8 collate utf8_general_ci;
  
  insert into account(name,money) values('aaa',1000);
  insert into account(name,money) values('bbb',1000);
  insert into account(name,money) values('ccc',1000); 
  */  

  public void transfer1(int sourceid,int targetid,double money) throws SQLException{
    Connection conn = null;
    try{
      // 獲取連接並開啟事務。
      conn = JdbcUtils.getConnection();
      conn.setAutoCommit(false);
      // 將開啟事務的連接傳遞到各層。
      AccountDao dao = new AccountDao(conn);
      Account a = dao.find(sourceid);   //select
      Account b = dao.find(targetid);   //select
      a.setMoney(a.getMoney()-money); 
      b.setMoney(b.getMoney()+money);
      dao.update(a); //update     
      dao.update(b);//update
      // 提交事務。
      conn.commit();
    }finally{
      // 關閉連接。
      if(conn!=null) conn.close();
    }
  }
｝

13、JDBC應用的事務管理—— ThreadLocal 綁定連接 

思想：在Service層將開啟事務的連接綁定到ThreadLocal中，在當前線程所途徑的其他各層從ThreadLocal中獲取連接並進行操作，最后線程返回至Service層時，再提交事務，移除綁定的鏈接

 

Demo樣例1：將 使用ThreadLocal 綁定連接 的代碼封裝成工具類。

public class JdbcUtils {
  private static DataSource ds;  //為保證各層的類所使用的ThreadLocal是同一個，建議將其設定成靜態的，但是一定要記得使用后要移出綁定在上面的對象。
  private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();  //其實就是一個Map集合 
  static{
    try{
      Properties prop = new Properties();
      InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
      prop.load(in);
      BasicDataSourceFactory factory = new BasicDataSourceFactory();
      ds = factory.createDataSource(prop);
    }catch (Exception e) {
      throw new ExceptionInInitializerError(e);
    }
  }

  public static DataSource getDataSource(){
    return ds;
  }
  //備注：該獲取連接的方法，僅當使用ThreadLocal來管理事務連接的情況，因為向靜態對象ThreadLocal中綁定了對象，所以當我們不需要管理事務的普通獲取連接的方法，就不要用此方法。應該用普通的獲取連接的方法。  
  
  public static Connection getConnection() throws SQLException{
    try{
      //得到當前線程上綁定的連接
      Connection conn = tl.get();
      if(conn==null){  //代表線程上沒有綁定連接
        conn = ds.getConnection();
        tl.set(conn);
      }
      return conn;
    }catch (Exception e) {
      throw new RuntimeException(e);
    }
  } 
  
  public static void startTransaction(){
    try{
      //得到當前線程上綁定連接開啟事務
      Connection conn = tl.get();
      if(conn==null){  //代表線程上沒有綁定連接
        conn = ds.getConnection();
        tl.set(conn);
      }
      conn.setAutoCommit(false);
    }catch (Exception e) {
      throw new RuntimeException(e);
    }
  } 

  public static void commitTransaction(){
    try{
      Connection conn = tl.get();
      if(conn!=null){
        conn.commit();
      }
    }catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  public static void closeConnection(){
    try{
      Connection conn = tl.get();
      if(conn!=null){
        conn.close();
      }
    }catch (Exception e) {
      throw new RuntimeException(e);
    }finally{
      tl.remove();   //千萬注意，解除當前線程上綁定的鏈接（從threadlocal容器中移除對應當前線程的鏈接）
    }
  }
}

Demo樣例2： 采用 ThreadLocal 綁定連接 來管理事務的 Service層的代碼。

public class BusinessService {  
  /*  
  create table account(
    id int primary key auto_increment,
    name varchar(40),
    money float
  )character set utf8 collate utf8_general_ci;

  insert into account(name,money) values('aaa',1000);
  insert into account(name,money) values('bbb',1000);
  insert into account(name,money) values('ccc',1000); 
  */  
  
  //用上ThreadLocal的事務管理
  public void transfer2(int sourceid,int targetid,double money) throws SQLException{
    try{
      JdbcUtils.startTransaction();
      AccountDao dao = new AccountDao();
      Account a = dao.find(sourceid);   //select
      Account b = dao.find(targetid);   //select
      a.setMoney(a.getMoney()-money);  
      b.setMoney(b.getMoney()+money); 
      dao.update(a); //update
      dao.update(b);//update
      JdbcUtils.commitTransaction();
    }finally{
      JdbcUtils.closeConnection();
    }
  }
}

14、使用JDBC操作多個表 

        (1) 使用JDBC操作多表的步驟 

                (a)  明確對象的屬性，及之間的關聯關系。 

                (b)  明確表關系， 創建數據庫及表； 

                (c)  編碼Dao層的代碼（重點是增刪改查時涉及到的級聯操作。） 

                (d)  編碼Service層的代碼（重點是 復雜對象  的級聯操作。）      

        (2)  O-R Mapping 映射的注意事項 

                (a) 不管java的對象存在何種關系，反映到關系型數據庫中，都是使用外鍵表示紀錄（即對象）的關聯關系。

                 (b) 設計java對象如涉及到多個對象相互引用，要盡量避免使用一對多，或多對多關系，而應使用多對一描述對象之間的關系(或使用延遲加載的方式)。以避免查詢出了所有“一對多”中 “多”的數據，容易造成內存溢出 

                (c) 特殊情況下（比如訂單--訂單項）必須設計成“一對多”關系時，當“多”的一方數據較少時，可以使用級聯查詢，但若是“多”的一方數據量較大時，則建議使用 “分頁方式”查詢。     

       (3)  “一對多”多表關聯關系的設計方法： 

                (a) 先將每張表各自的基本屬性信息列好； 

                (b) 再將“一對多” 多的一方中設定外鍵列（並添加外鍵約束，以維護兩表之間的關系）。      

       (4) 常用O-R Mapping映射工具 

                (a) Hibernate 

                (b) Ibatis 

                (c) Commons DbUtils(只是對JDBC簡單封裝)      

 

15、使用JDBC操作多個表—— 一對多關系 （例如：部門和員工）

Demo樣例1：Dao層的代碼

public class DepartmentDao { 
  /*
    多表設計原則
    1、現將各表各自的基本屬性信息列好；
    2、再將“一對多” 多的一方中設定外鍵列（並添加外鍵約束，以維護兩表之間的關系）。
    create table department
    (
      id varchar(40) primary key,
      name varchar(40)
    ); 

    create table employee
    (
      id varchar(40) primary key,
      name varchar(40),
      salary double,

      department_id varchar(40),
      constraint department_id_FK foreign key(department_id) references department(id)
    );
    
    alter table employee drop foreign key department_id_FK;
    alter table employee add constraint department_id_FK foreign key(department_id) references department(id) on delete set null;
    alter table employee drop foreign key department_id_FK;
    alter table employee add constraint department_id_FK foreign key(department_id) references department(id) on delete cascade; 
   */

  public void add(Department d) throws SQLException{ 
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    //1.把department對象的數據插入到department表
    String sql = "insert into department(id,name) values(?,?)";
    Object params[] = {d.getId(),d.getName()};
    runner.update(sql, params);
    //2.把department對象中維護的所有員工插入到員工表
    Set<Employee> set = d.getEmployees();
    for(Employee e : set){
      sql = "insert into employee(id,name,salary,department_id) values(?,?,?,?)";
      params = new Object[]{e.getId(),e.getName(),e.getSalary(),d.getId()};
      runner.update(sql, params);
    }
    //3.更新員工表的外鍵列，說明員工的部門（本例中的ID可以實現給定，固就不需要進行更新外鍵列操作；但若是涉及到獲取 自動生成主鍵 的案例時，則需要 涉及到更新外鍵操作）。
  }

  //該方法查詢出了所有“一對多”中 “多”的數據，容易造成內存溢出。當“多”的一方數據較少時，可以使用該級聯查詢，但若是“多”的一方數據量較大時，則建議使用 “分頁方式”查詢。
  public Department find(String id) throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    //1.找部門表，查出部門的基本信息
    String sql = "select * from department where id=?";
    Department d = (Department) runner.query(sql, id, new BeanHandler(Department.class));
    //2.找員工表，找出部門下面所有員工
    sql = "select * from employee where department_id=?";
    List list = (List) runner.query(sql, id, new BeanListHandler(Employee.class));
    d.getEmployees().addAll(list);       //注：set集合的addAll()是將所有的值逐個取出來，再逐一存入到Set集合中；而set集合的add()方法則是替換一Set集合的引用。
    return d;
  }

  //111
  public void delete(String id) throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    String sql= "delete from department where id=?";
    runner.update(sql, id);
  }
}

Demo樣例2：Service層的代碼 

public class BService { 
 
  @Test
  public void add() throws SQLException{ 
    Department d = new Department();
    d.setId("111");
    d.setName("開發部");
    Employee e1 = new Employee();
    e1.setId("1");
    e1.setName("aa");
    e1.setSalary(10000); 
    Employee e2 = new Employee();
    e2.setId("2");
    e2.setName("bb");
    e2.setSalary(10000);
    d.getEmployees().add(e1); 
    d.getEmployees().add(e2);  
    DepartmentDao dao = new DepartmentDao(); 
    dao.add(d); 
  } 
 
  @Test 
  public void find() throws SQLException{ 
    DepartmentDao dao = new DepartmentDao(); 
    Department d = dao.find("111"); 
    System.out.println(d); 
  }
  
  @Test 
  public void delete() throws SQLException{
    DepartmentDao dao = new DepartmentDao(); 
    dao.delete("111"); 
  } 
 ｝ 

16、使用JDBC操作多個表—— 多對多關系 （老師和學生）

Demo樣例1：Dao層的代碼

public class TeacherDao {  
  /* 
  create table teacher 
  (
    id varchar(40) primary key,
    name varchar(40), 
    salary double 
  ) ; 
 
  create table student 
  ( 
    id varchar(40) primary key, 
    name varchar(40) 
  );
  
   create table teacher_student 
   ( 
     teacher_id varchar(40), 
     student_id varchar(40), 
     primary key(teacher_id,student_id), 
     constraint teacher_id_FK foreign key(teacher_id) references teacher(id),  
     constraint student_id_FK foreign key(student_id) references student(id) 
   ); 
 
   alter table teacher_student drop foreign key teacher_id_FK; 
   alter table teacher_student add constraint teacher_id_FK foreign key(teacher_id) references teacher(id) on delete cascade;   
 
   alter table teacher_student drop foreign key student_id_FK; 
   alter table teacher_student add constraint student_id_FK foreign key(student_id) references student(id) on delete cascade; 
  */
  
  public void add(Teacher t) throws SQLException { 
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource()); 
    //1`.取出老師存老師表 
    String sql = "insert into teacher(id,name,salary) values(?,?,?)"; 
    Object params[] = {t.getId(),t.getName(),t.getSalary()}; 
    runner.update(sql, params);
    //2.取出老師所有學生的數據，存學生表 
    Set<Student> set = t.getStudents(); 
    for(Student s : set){ 
      sql = "insert into student(id,name) values(?,?)"; 
      params = new Object[]{s.getId(),s.getName()}; 
      runner.update(sql, params);
      //3.更新中間表，說明老師和學生的關系 
      sql = "insert into teacher_student(teacher_id,student_id) values(?,?)"; 
      params = new Object[]{t.getId(),s.getId()}; 
      runner.update(sql, params); 
    } 
  }
 
  public Teacher find(String id) throws SQLException{
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
    //1.找老師表，找出老師的基本信息 
    String sql = "select * from teacher where id=?"; 
    Teacher t = (Teacher) runner.query(sql, id, new BeanHandler(Teacher.class)); 
    //2.找出老師的所有學生    （） 
    //sql = "select s.* from teacher_student ts,student s where ts.teacher_id=? and ts.student_id=s.id"; 
    sql = "select s.* from teacher_student ts,student s where ts.teacher_id=? and ts.student_id=s.id"; 
    List list = (List) runner.query(sql, id, new BeanListHandler(Student.class));
    t.getStudents().addAll(list);
    return t; 
  }
 
  public void delete(String id){
    QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource()); 
    String sql = "delete from teacher where id=?"; 
  } 
}

Demo樣例2：Service層的代碼 

public class BService {
 @Test
 public void addTeacher() throws SQLException{
  Teacher t = new Teacher();
  t.setId("1");
  t.setName("老張");
  t.setSalary(100000);
  Student s1 = new Student();
  s1.setId("1");
  s1.setName("aa");
  Student s2 = new Student();
  s2.setId("2");
  s2.setName("bb"); 
  t.getStudents().add(s1); 
  t.getStudents().add(s2); 
  TeacherDao dao = new TeacherDao();
  dao.add(t); 
 } 
 
 @Test
 public void findTeacher() throws SQLException{ 
  TeacherDao dao = new TeacherDao(); 
  Teacher t = dao.find("1"); 
  System.out.println(t); 
 }
}

17、數據庫端——表關系間的級聯操作 

表關系間的級聯操作： 

    REFERENCES tbl_name [(index_col_name,...)] 

               [MATCH FULL | MATCH PARTIAL | MATCH SIMPLE] 

               [ON DELETE reference_option]  （級聯刪除）  

               [ON UPDATE reference_option]  （級聯修改）

reference_option的可選值： 

    RESTRICT | CASCADE(刪除) | SET NULL(置空) | NO ACTION  

Demo：給表添加外鍵約束——包含級聯刪除（置空）的關系 

   alter table employee add constraint department_id_FK foreign key(department_id) references department(id) on delete set null ;  

   alter table employee add constraint department_id_FK foreign key(department_id) references department(id) on delete set null; 

   alter table employee add constraint department_id_FK foreign key(department_id) references department(id) on delete cascade;