JdbcTemplate徹底學習

概述

Spring JDBC抽象框架core包提供了JDBC模板類，其中JdbcTemplate是core包的核心類，因此其餘模板類都是基於它封裝完成的，JDBC模板類是第一種工做模式。

 

       JdbcTemplate類經過模板設計模式幫助咱們消除了冗長的代碼，只作須要作的事情（便可變部分），而且幫咱們作哪些固定部分，如鏈接的建立及關閉。

 

       JdbcTemplate類對可變部分採用回調接口方式實現，如ConnectionCallback經過回調接口返回給用戶一個鏈接，從而可使用該鏈接作任何事情、StatementCallback經過回調接口返回給用戶一個Statement，從而可使用該Statement作任何事情等等，還有其餘一些回調接口

 

Spring除了提供JdbcTemplate核心類，還提供了基於JdbcTemplate實現的NamedParameterJdbcTemplate類用於支持命名參數綁定、 SimpleJdbcTemplate類用於支持Java5+的可變參數及自動裝箱拆箱等特性。

 

JdbcTemplate類支持的回調類：

• 預編譯語句及存儲過程建立回調：用於根據JdbcTemplate提供的鏈接建立相應的語句；

PreparedStatementCreator：經過回調獲取JdbcTemplate提供的Connection，由用戶使用該Conncetion建立相關的PreparedStatement；

CallableStatementCreator：經過回調獲取JdbcTemplate提供的Connection，由用戶使用該Conncetion建立相關的CallableStatement；

• 預編譯語句設值回調：用於給預編譯語句相應參數設值；

         PreparedStatementSetter：經過回調獲取JdbcTemplate提供的PreparedStatement，由用戶來對相應的預編譯語句相應參數設值；

         BatchPreparedStatementSetter：；相似於PreparedStatementSetter，但用於批處理，須要指定批處理大小；

• 自定義功能回調：提供給用戶一個擴展點，用戶能夠在指定類型的擴展點執行任何數量須要的操做；

         ConnectionCallback：經過回調獲取JdbcTemplate提供的Connection，用戶可在該Connection執行任何數量的操做；

         StatementCallback：經過回調獲取JdbcTemplate提供的Statement，用戶能夠在該Statement執行任何數量的操做；

         PreparedStatementCallback：經過回調獲取JdbcTemplate提供的PreparedStatement，用戶能夠在該PreparedStatement執行任何數量的操做；

         CallableStatementCallback：經過回調獲取JdbcTemplate提供的CallableStatement，用戶能夠在該CallableStatement執行任何數量的操做；

• 結果集處理回調：經過回調處理ResultSet或將ResultSet轉換爲須要的形式；

         RowMapper：用於將結果集每行數據轉換爲須要的類型，用戶需實現方法mapRow(ResultSet rs, int rowNum)來完成將每行數據轉換爲相應的類型。

         RowCallbackHandler：用於處理ResultSet的每一行結果，用戶需實現方法processRow(ResultSet rs)來完成處理，在該回調方法中無需執行rs.next()，該操做由JdbcTemplate來執行，用戶只需按行獲取數據而後處理便可。

         ResultSetExtractor：用於結果集數據提取，用戶需實現方法extractData(ResultSet rs)來處理結果集，用戶必須處理整個結果集；

下面詳細講解jdbcTmeplate的CRUD操做：

（一）增長、刪除、修改操做：

1）增長、更新、刪除（一條sql語句）（sql固定，不須要參數）：

    (a) int update(final String sql)

      其中sql參數爲須要傳入的插入sql語句。

    (b)int update(PreparedStatementCreator psc)

 

    public void test() { jdbcTemplate.update(new PreparedStatementCreator() { @Override public PreparedStatement createPreparedStatement(Connection conn) throws SQLException { return conn.prepareStatement("insert into test(name) values('name1')"); } }); }

 

     (c)若是須要返回新插入數據的主鍵，採用以下方法（使用KeyHolder keyholder=new GeneratedKeyHolder();得到主鍵，jdbcTemplate和NamedParameterJdbcTemplate均可以經過此方法得到主鍵）：

       int update(PreparedStatementCreator psc, final KeyHolder generatedKeyHolder)

 

public void test() { KeyHolder keyHolder = new GeneratedKeyHolder(); jdbcTemplate.update(new PreparedStatementCreator() { @Override public PreparedStatement createPreparedStatement(Connection conn) throws SQLException { return conn.prepareStatement("insert into test(name) values('name1')"); } },keyHolder); int i = keyHolder.getKey().intValue();//這就是剛插入的數據的主鍵 }

 

2）增長、更新、刪除（一條sql語句）（sql須要注入參數填充‘？’）：

　　(a)int update(String sql, PreparedStatementSetter pss)

 

public void test() { String sql = "insert into test(name) values (?)"; //返回的是更新的行數 int count = jdbcTemplate.update(sql, new PreparedStatementSetter(){ @Override public void setValues(PreparedStatement pstmt) throws SQLException { pstmt.setObject(1, "name4"); } }); }

 

      (b)int update(String sql, Object[] args, int[] argTypes)

其中參數含義：   sql:預處理sql語句； args:sql須要注入的參數； argTypes:須要注入的sql參數的JDBC類型（java.sql.Types中來獲取類型的常量）；

 

    public void test() { String sql = "insert into test(name,age,create_date) values (?,?,?)"; Date now = new Date(System.currentTimeMillis()); //返回的是更新的行數 int count = jdbcTemplate.update(sql, new Object[]{"小明",14,now}, new int[]{Types.VARCHAR,Types.INTEGER,Types.DATE}); }

 

     (c)int update(String sql, Object... args)

其實內部仍是調用方法a實現的，JdbcTemplate提供這種更簡單的方式「update(String sql, Object... args)」來實現設值，因此只要當使用該種方式不知足需求時才應使用PreparedStatementSetter（上面方法a）。

 

public void test() { String sql = "insert into test(name,age,create_date) values (?,?,?)"; Date now = new Date(System.currentTimeMillis()); //返回的是更新的行數 int count = jdbcTemplate.update(sql, "小明", 14, now); }

 

 

public void test() { String sql = "insert into test(name,age,create_date) values (?,?,?)"; Date now = new Date(System.currentTimeMillis()); //返回的是更新的行數 int count = jdbcTemplate.update(sql, new Object[]{"小明",14,now}); }

 

這兩種實際上調用的都是該方法，因而可知Object...args實際上就是可變的數組，而數組長度是固定的，必須先定義一個數組，而Object...args在傳遞時參數能夠任意，因此也能夠傳遞一個固定的Object數組。

    (d)int update(PreparedStatementCreator psc)

使用該方法能夠本身使用原始jdbc方式給預編譯sql注入參數，來進行增長、刪除、更新操做：

 

public void test(final Customer customer) {//參數也是局部變量，也必須用final修飾，內部類中才能訪問（全局變量不用） //方法局部必須是final的，匿名內部類中才能引用 final String sql = "insert into test(name,age,create_date) values (?,?,?)"; Date now = new Date(System.currentTimeMillis()); //返回的是更新的行數 int count = jdbcTemplate.update(new PreparedStatementCreator() { @Override public PreparedStatement createPreparedStatement(Connection conn) throws SQLException { PreparedStatement ps = conn.prepareStatement(sql); ps.setString(1, customer.getName()); ps.setInt(2, customer.getAge()); ps.setDate(3, customer.getCreateDate()); return ps; } }); }

 

若是須要返回插入的主鍵，只能用此方法，增長KeyHolder參數：

 

public void test(final Customer customer) {//參數也是局部變量，也必須用final修飾，內部類中才能訪問（全局變量不用） KeyHolder keyHolder = new GeneratedKeyHolder(); //方法局部必須是final的，匿名內部類中才能引用 final String sql = "insert into test(name,age,create_date) values (?,?,?)"; Date now = new Date(System.currentTimeMillis()); //返回的是更新的行數 int count = jdbcTemplate.update(new PreparedStatementCreator() { @Override public PreparedStatement createPreparedStatement(Connection conn) throws SQLException { PreparedStatement ps = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS); //有的數據庫版本不同，須要添加第二個參數，否則會報錯；
　　　　　　　　　　ps.setString(1, customer.getName()); 
　　　　　　　　　　ps.setInt(2, customer.getAge()); 
　　　　　　　　　　ps.setDate(3, customer.getCreateDate()); 
　　　　　　　　　　return ps; 
　　　　　　　　} 
　　　　},keyHolder); 
　　　　
　　　　int i = keyHolder.getKey().intValue();//這就是剛插入的數據的主鍵 }

 

3）批量增長、刪除、更新數據（多條sql語句）

　　（a）批量執行多條sql（固定的sql，不須要注入參數，可是sql格式不固定）

　　    int[] batchUpdate(final String[] sql)

參數是一個String數組，存放多條sql語句；返回值是int數組，即每條sql更新影響的行數。

　　（b）批量執行多條sql（預處理sql，須要注入參數）

　　  int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss)

參數sql：一條預處理sql（若是是批量處理預處理sql，那麼sql的格式就是固定的，只填充參數而已）；第二個參數就是回調類，前面有統一介紹回調類。

舉兩個例子，一個更新，一個插入：

 

批量插入：
public void test(final List<Customer> customer) {//參數也是局部變量，也必須用final修飾，內部類中才能訪問（全局變量不用） String sql = "insert into test(name,age,create_date) values (?,?,?)"; //返回的是更新的行數 int[] count = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { //注入參數值 ps.setString(1, customer.get(i).getName()); ps.setInt(2, customer.get(i).getAge()); ps.setDate(3, customer.get(i).getCreateDate()); } @Override public int getBatchSize() { //批量執行的數量 return customer.size(); } }); }

 

 

批量更新：
public void test(final List<Customer> customer) {//參數也是局部變量，也必須用final修飾，內部類中才能訪問（全局變量不用） String sql = "update test set name = ?,age = ? where id = ?"; //返回的是更新的行數 int[] count = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { //注入參數值 ps.setString(1, customer.get(i).getName()); ps.setInt(2, customer.get(i).getAge()); ps.setInt(3, customer.get(i).getId()); } @Override public int getBatchSize() { //批量執行的數量 return customer.size(); } }); }

 

　　（c）批量處理多條預處理sql語句還有下面幾種簡單方法（參數和前面相似，這裏就不詳解）：

         int[] batchUpdate(String sql, List<Object[]> batchArgs)；

         int[] batchUpdate(String sql, List<Object[]> batchArgs, int[] argTypes)；

前面講了增長、刪除、更新操做，這節講一下查詢。

查詢操做：

(一)查詢一個值（不須要注入參數）

queryForObject(String sql, Class<T> requiredType)；

注意：參數requiredType只能是String，Integer這種類型，不能是自定義的實體類型，只能返回一個值，不能映射對象（映射對象下面會說）；

　　sql:預處理sql；requiredType：查詢單列結果的類型；

public void test() { String sql = "select count(*) from test"; int count = jdbcTemplate.queryForObject(sql, Integer.class); }

（二）查詢一個值（使用預處理sql，須要注入參數）

queryForObject(String sql, Object[] args, Class<T> requiredType)；

public void test(Integer id) { String sql = "select name from test where id = ?"; String name = jdbcTemplate.queryForObject(sql, new Object[]{id}, String.class); }

還有以下方式：queryForObject(String sql, Object[] args, int[] argTypes, Class<T> requiredType)；

（三）查詢單行記錄，轉換成一個對象（固定sql，不須要參數）

<T> T queryForObject(String sql, RowMapper<T> rowMapper)

public void test() { String sql = "select name,age from test where id = 10"; Customer customer = jdbcTemplate.queryForObject(sql, new RowMapper<Customer>() { @Override public Customer mapRow(ResultSet rs, int i) throws SQLException { Customer c = new Customer(); c.setName(rs.getString("name")); c.setAge(rs.getInt("age")); return c; } }); }

（四）查詢單行記錄，轉換成一個對象（預處理sql，須要注入參數）

<T> T queryForObject(String sql, Object[] args, RowMapper<T> rowMapper)

public void test(Integer id) {//參數也是局部變量，也必須用final修飾，內部類中才能訪問（全局變量不用） String sql = "select name,age from test where id = ?"; Customer customer = jdbcTemplate.queryForObject(sql, new Object[]{id}, new RowMapper<Customer>() { @Override public Customer mapRow(ResultSet rs, int paramInt) throws SQLException { Customer c = new Customer(); c.setName(rs.getString("name")); c.setAge(rs.getInt("age")); return c; } }); }

也可使用以下方式：（1）<T> T queryForObject(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper);

　　　　　　　　　　（2）<T> T queryForObject(String sql, RowMapper<T> rowMapper, Object... args);

（五）查詢數據庫中一列多行數據，即查詢數據庫中單列數據存入一個list中，方式以下：（固定sql，沒參數）

　　（a）List<Map<String, Object>> queryForList(String sql)

           這個方法封裝成map放入list中，key:列名（Oracle數據庫sql執行結果列名默認爲大寫，須要小寫用as取別名，別名用雙引號）  value:列的值

public void test() {//若是Oracle用這個sql查詢，返回的列名就是NAME(大寫的)，對應Map裏面的key就是NAME String sql = "select name from test where id > 0"; //若是用這個sql查詢，返回的列名就是name(小寫的)，對應Map裏面的key就是name String sql2 = "select name as \"name\" from test where id > 0"; List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);//這裏用的是第一個sql }

　　（b）<T> List<T> queryForList(String sql, Class<T> elementType)

           這個方法就是直接將單類型數據存入List中。

　　    注意：這個T雖然是泛型，可是隻支持Integer.class String.class 這種單數據類型的，本身定義的Bean不支持。（因此用來查詢單列數據）

public void test() {  String sql = "select name from test where id > 0"; List<String> list = jdbcTemplate.queryForList(sql, String.class); }

（六）查詢數據庫中一列多行數據，即查詢數據庫中單列數據存入一個list中，方式以下：（預處理sql，須要注入參數）

　　（a）<T> List<T> queryForList(String sql, Object[] args, Class<T> elementType)

　　  注意：這個T雖然是泛型，可是隻支持Integer.class String.class 這種單數據類型的，本身定義的Bean不支持。（因此用來查詢單列數據,同前面一個意思，後面再也不解釋）

public void test(Integer id) {  String sql = "select name from test where id > ?"; List<String> list = jdbcTemplate.queryForList(sql, new Object[]{id}, String.class); }

　　還有以下方式實現：（1）<T> List<T> queryForList(String sql, Object[] args, int[] argTypes, Class<T> elementType)；

　　　　　　　　　　    （2）<T> List<T> queryForList(String sql, Class<T> elementType, Object... args)；

　　（b）List<Map<String, Object>> queryForList(String sql, Object... args)

　　封裝成map存入List,和以前同樣，要注意Oracle數據庫返回的列名默認是大寫的，若是須要，用別名變小寫。

public void test(Integer id) {  String sql = "select name from test where id > ?"; List<Map<String, Object>> list = jdbcTemplate.queryForList(sql, new Object[]{id}); }

　　還有一種方式實現：List<Map<String, Object>> queryForList(String sql, Object[] args, int[] argTypes)；

（七）查詢多條數據（固定sql，沒有參數）

　　（a）<T> List<T> query(String sql, RowMapper<T> rowMapper) 

　　　　每條數據映射爲java對象，放入List中。

public void test() { String sql = "select name,age from test where id > 10"; List<Customer> list = jdbcTemplate.query(sql, new RowMapper<Customer>() { @Override public Customer mapRow(ResultSet rs, int rowNum) throws SQLException { //這裏必須new對象，不能在方法外new，而後用同一個，由於是一個List，查詢出來多個對象映射， //必須保證每一次調用都使用一個新的。 //若是不new，而是使用同一個對象，會致使存入到List中的都是同樣的對象（都是最後一個對象）。 Customer customer = new Customer(); customer.setName(rs.getString("name")); customer.setAge(rs.getInt("age")); return customer; } }); }

　　該方法也能夠把每一行數據轉換爲自定義key-value的map對象放入list中，以下：（因此說使用回調類比簡單方法更強大，裏面邏輯本身按需求寫）

public void test() { String sql = "select name,age from test where id > 10"; List<Map<Integer,Object>> list = jdbcTemplate.query(sql, new RowMapper<Map<Integer,Object>>() { @Override public Map<Integer,Object> mapRow(ResultSet rs, int rowNum) throws SQLException { Map<Integer, Object> map = new HashMap<Integer, Object>(); map.put(rowNum, rs.getString("name")); map.put(rowNum, rs.getInt("age")); return map; } }); }

map中的key，value類型根據須要自定義，很是方便。像這種實現RowMapper<T>接口的匿名類，T能夠爲Map，也能夠爲自定義的對象類型，如上兩種，根據須要選擇。

　　（b） void query(String sql, RowCallbackHandler rch)

　　　注意：若是使用RowCallbackHandler 回調類，這個方法是沒有返回值的，而是在回調類中將結果放入預先定義的List中，用法以下：

public void test() { String sql = "select name,age from test where id > 10"; //局部變量，必須用final修飾，內部類中才能訪問（全局變量不用） final List<Customer> list = new ArrayList<Customer>(); jdbcTemplate.query(sql, new RowCallbackHandler() { @Override public void processRow(ResultSet rs) throws SQLException { Customer customer = new Customer(); customer.setName(rs.getString("name")); customer.setAge(rs.getInt("age")); list.add(customer); } }); }

固然，這種方式也能夠轉換爲map，存入list中，和上面a方式同樣，這裏就不詳解了。

　　（c）<T> T query(final String sql, final ResultSetExtractor<T> rse)

　　ResultSetExtractor使用回調方法extractData(ResultSet rs)提供給用戶整個結果集，讓用戶決定如何處理該結果集。

public void test() { String sql = "select name,age from test where id > 10"; List<Customer> list = jdbcTemplate.query(sql, new ResultSetExtractor<List<Customer>>() { @Override public List<Customer> extractData(ResultSet rs) throws SQLException, DataAccessException { List<Customer> result = new ArrayList<Customer>(); while(rs.next()) { Customer customer = new Customer(); customer.setName(rs.getString("name")); customer.setAge(rs.getInt("age")); result.add(customer); } return result; } }); }

一樣也能夠轉換爲map對象放入list中，以下：

public void test() { String sql = "select name,age from test where id > 10"; List<Map<String, Integer>> list = jdbcTemplate.query(sql, new ResultSetExtractor<List<Map<String, Integer>>>() { @Override public List<Map<String, Integer>> extractData(ResultSet rs) throws SQLException, DataAccessException { List<Map<String, Integer>> result = new ArrayList<Map<String, Integer>>(); while(rs.next()) { Map<String, Integer> map = new HashMap<String, Integer>(); map.put(rs.getString("name"), rs.getInt("age")); result.add(map); } return result; } }); }

 　　（d）<T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper)

public void test() {//局部變量，必須用final修飾，內部類中才能訪問（全局變量不用） final String sql = "select name,age from test where id > 10"; List<Customer> list = jdbcTemplate.query(new PreparedStatementCreator() { @Override public PreparedStatement createPreparedStatement(Connection conn) throws SQLException { PreparedStatement ps = conn.prepareStatement(sql);
　　　　　　　　　//若是sql是預處理的，須要傳入參數，能夠在這裏寫jdbc代碼傳入，後面就不列舉這種方法了 return ps; } }, new RowMapper<Customer>() { @Override public Customer mapRow(ResultSet rs, int rowNum) throws SQLException { Customer customer = new Customer(); customer.setAge(rs.getInt("age")); customer.setName(rs.getString("name")); return customer; } }); }

能夠將RowMapper換成ResultSetExtractor或者RowCallbackHandler回調類，和前面同樣，所以還有下面兩種方法：

　　（1）void query(PreparedStatementCreator psc, RowCallbackHandler rch)；

　　（2）<T> T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse)；

（八）查詢多條數據（預處理sql，須要傳入參數）

　　（a）<T> List<T> query(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper)

public void test(final Integer id) {//參數也是局部變量，也必須用final修飾，內部類中才能訪問（全局變量不用） String sql = "select name,age from test where id > ?"; List<Customer> list = jdbcTemplate.query(sql, new PreparedStatementSetter() { @Override public void setValues(PreparedStatement ps) throws SQLException { ps.setInt(1, id); } }, new RowMapper<Customer>() { @Override public Customer mapRow(ResultSet rs, int rowNum) throws SQLException { Customer customer = new Customer(); customer.setName(rs.getString("name")); customer.setAge(rs.getInt("age")); return customer; } }); }

用RowMapper回調類還有三種方法：

　　　　（1）<T> List<T> query(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper)；

　　　　（2）<T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper)；

　　　　（3）<T> List<T> query(String sql, RowMapper<T> rowMapper, Object... args)；

而若是把回調類換成ResultSetExtractor或者RowCallbackHandler回調類，又有八種方法（像上面同樣各有四種），這裏就不舉出來了，和前面用法一致。

使用Spring的JdbcTemplate或者NamedParameterJdbcTemplate查詢數據庫，獲取結果，數據庫表字段和實體類自動對應，可使用BeanPropertyRowMapper。

 

注意：

　　自動綁定，須要列名稱和Java實體類名字一致，如：屬性名 「userName」 能夠匹配數據庫中的列字段（這裏說的列字段是sql執行結果的列名，也就是若是有別名就用別名，（Oracle默認列名大寫）） "USERNAME" 或 「user_name」。這樣，咱們就不須要一個個手動綁定了，大大提升了開發效率。

下面講解BeanPropertyRowMapper用法：

BeanPropertyRowMapper<T>     implements RowMapper<T>這個類是實現了RowMapper接口的，因此以前講的查詢中，能用到RowMapper回調類的均可以用BeanPropertyRowMapper來將結果直接映射爲實體類。

public List<UserEntity> findUser(UserEntity user) {  List<UserEntity> userList = jdbcTemplate.query(SEL_BY_USERNAME_PWD, new Object[] { user.getUserName(), user.getPwd() }, new BeanPropertyRowMapper<UserEntity>(UserEntity.class)); return userList; } 

正如上面，直接利用BeanPropertyRowMapper的構造方法傳遞一個須要映射的類的class對象進去便可實現，固然必須知足以前說的要求：

1.屬性名「userName」要按以下規則匹配sql結果列：結果列要是"user_name"(大小寫都行)，由於BeanPropertyRowMapper的中會將結果列都轉爲小寫去和對象中set屬性對應；

2.屬性名「user」這對應結果列爲「USER」（大小寫都行），理由同上；