前面一篇介紹如何使用JdbcTemplate實現插入資料，接下來進入實際業務中，最常見的查詢篇。由於查詢的姿勢實在太多，對內容進行了拆分，本篇主要介紹幾個基本的使用姿勢

• queryForMap
• queryForList
• queryForObject

<!-- more -->

I. 環境準備

環境依然藉助前面一篇的配置，連結如： 190407-SpringBoot高階篇JdbcTemplate之資料插入使用姿勢詳解

或者直接檢視專案原始碼： https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/101-jdbctemplate

我們查詢所用資料，正是前面一篇插入的結果，如下圖

II. 查詢使用說明

1. queryForMap

queryForMap，一般用於查詢單條資料，然後將db中查詢的欄位，填充到map中，key為列名，value為值

a. 基本使用姿勢

最基本的使用姿勢，就是直接寫完整的sql，執行

String sql = "select * from money where id=1";
Map<String, Object> map = jdbcTemplate.queryForMap(sql);
System.out.println("QueryForMap by direct sql ans: " + map);
 

這種用法的好處是簡單，直觀；但是有個非常致命的缺點，如果你提供了一個介面為

public Map<String, Object> query(String condition) {
  String sql = "select * from money where name=" + condition;
  return jdbcTemplate.queryForMap(sql);
}

直接看上面程式碼，會發現問題麼？？？

有經驗的小夥伴，可能一下子就發現了sql注入的問題，如果傳入的引數是 '一灰灰blog' or 1=1 order by id desc limit 1

, 這樣輸出和我們預期的一致麼？

b. 佔位符替換

正是因為直接拼sql，可能到只sql注入的問題，所以更推薦的寫法是通過佔位符 + 傳參的方式

// 使用佔位符替換方式查詢
sql = "select * from money where id=?";
map = jdbcTemplate.queryForMap(sql, new Object[]{1});
System.out.println("QueryForMap by ? ans: " + map);

// 指定傳參型別, 通過傳參來填充sql中的佔位
sql = "select * from money where id =?";
map = jdbcTemplate.queryForMap(sql, 1);
System.out.println("QueryForMap by ? ans: " + map);

從上面的例子中也可以看出，佔位符的使用很簡單，用問好（?）來代替具體的取值，然後傳參

傳參有兩種姿勢，一個是傳入Object[]陣列；另外一個是藉助java的不定長引數方式進行傳參；兩個的佔位替換都是根據順序來的，也就是如果你有一個值想替換多個佔位符，那就得血多次

如：

sql = "select * from money where (name=? and id=?) or (name=? and id=?)";
map = jdbcTemplate.queryForMap(sql, "一灰灰blog", 1, "一灰灰blog", 2);

c. 查不到的case

使用queryForMap有個不得不注意的事項，就是如果查不到資料時，會拋一個異常出來，所以需要針對這種場景進行額外處理

// 查不到資料的情況
try {
    sql = "select * from money where id =?";
    map = jdbcTemplate.queryForMap(sql, 100);
    System.out.println("QueryForMap by ? ans: " + map);
} catch (EmptyResultDataAccessException e) {
    e.printStackTrace();
}

2. queryForList

前面針對的主要是單個查詢，如果有多個查詢的場景，可能就需要用到queryForList了，它的使用姿勢和上面其實差別不大；

a. 基本使用姿勢

最基本的使用姿勢當然是直接寫sql執行了

System.out.println("============ query for List! ==============");
String sql =
        "select id, `name`, money, is_deleted as isDeleted, unix_timestamp(create_at) as created, unix_timestamp(update_at) as updated from money limit 3;";

// 預設返回 List<Map<String, Object>> 型別資料，如果一條資料都沒有，則返回一個空的集合
List<Map<String, Object>> res = jdbcTemplate.queryForList(sql);
System.out.println("basicQueryForList: " + res);

注意返回的結果是List<Map<String, Object>>， 如果一條都沒有命中，會返回一個空集合, 和 QueryForMap 拋異常是不一樣的

b. 佔位符替換

直接使用sql的查詢方式，依然和前面一樣，可能有注入問題，當然優先推薦的使用通過佔位來傳參方式

String sql2 = "select id, `name`, money, is_deleted as isDeleted, unix_timestamp(create_at) as created, " +
        "unix_timestamp(update_at) as updated from money where id=? or name=?;";
res = jdbcTemplate.queryForList(sql2, 2, "一灰灰2");
System.out.println("queryForList by template: " + res);

3. queryForObject

如果是簡單查詢，直接用上面兩個也就夠了，但是對於使用過mybatis，Hibernate的同學來說，每次返回Map<String, Object>，就真的有點蛋疼了, 對於mysql這種資料庫，表的結構基本不變，完全可以和POJO進行關聯，對於業務開發者而言，當然是操作具體的POJO比Map要簡單直觀多了

下面將介紹下，如何使用 queryForObject 來達到我們的目標

a. 原始使用姿勢

首先介紹下利用 RowMapper 來演示下，最原始的使用姿勢

第一步是定義對應的POJO類

@Data
public static class MoneyPO implements Serializable {
    private static final long serialVersionUID = -5423883314375017670L;
    private Integer id;
    private String name;
    private Integer money;
    private boolean isDeleted;
    private Long created;
    private Long updated;
}

然後就是使用姿勢

// sql + 指定返回型別方式訪問
// 使用這種sql的有點就是方便使用反射方式，實現PO的賦值
String sql =
        "select id, `name`, money, is_deleted as isDeleted, unix_timestamp(create_at) as created, unix_timestamp(update_at) as updated from money limit 1;";
// 需要注意，下標以1開始
MoneyPO moneyPO = jdbcTemplate.queryForObject(sql, new RowMapper<MoneyPO>() {
    @Override
    public MoneyPO mapRow(ResultSet rs, int rowNum) throws SQLException {
        MoneyPO po = new MoneyPO();
        po.setId(rs.getInt(1));
        po.setName(rs.getString(2));
        po.setMoney(rs.getInt(3));
        po.setDeleted(rs.getBoolean(4));
        po.setCreated(rs.getLong(5));
        po.setUpdated(rs.getLong(6));
        return po;
    }
});
System.out.println("queryFroObject by RowMapper: " + moneyPO);

從使用姿勢上看，RowMapper 就是一個sql執行之後的回撥，實現結果封裝，這裡需要注意的就是 ResultSet 封裝了完整的返回結果，可以通過下標方式指定，下標是從1開始，而不是我們常見的0，需要額外注意

這個下標從1開始，感覺有點蛋疼，總容易記錯，所以更推薦的方法是直接通過列名獲取資料

// 直接使用columnName來獲取對應的值，這裡就可以考慮使用反射方式來賦值，減少getter/setter
moneyPO = jdbcTemplate.queryForObject(sql, new RowMapper<MoneyPO>() {
    @Override
    public MoneyPO mapRow(ResultSet rs, int rowNum) throws SQLException {
        MoneyPO po = new MoneyPO();
        po.setId(rs.getInt("id"));
        po.setName(rs.getString("name"));
        po.setMoney(rs.getInt("money"));
        po.setDeleted(rs.getBoolean("isDeleted"));
        po.setCreated(rs.getLong("created"));
        po.setUpdated(rs.getLong("updated"));
        return po;
    }
});
System.out.println("queryFroObject by RowMapper: " + moneyPO);

b. 高階使用

當sql返回的列名和POJO的屬性名可以完全匹配上的話，上面的這種寫法就顯得非常冗餘和麻煩了，我需要更優雅簡潔的使用姿勢，最好就是直接傳入POJO型別，自動實現轉換

如果希望得到這個效果，你需要的就是下面這個了: BeanPropertyRowMapper

// 更簡單的方式，直接通過BeanPropertyRowMapper來實現屬性的賦值，前提是sql返回的列名能正確匹配
moneyPO = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(MoneyPO.class));
System.out.println("queryForObject by BeanPropertyRowMapper: " + moneyPO);

c. 易錯使用姿勢

檢視JdbcTemplate提供的介面時，可以看到下面這個介面

@Override
public <T> T queryForObject(String sql, Class<T> requiredType, @Nullable Object... args) throws DataAccessException {
  return queryForObject(sql, args, getSingleColumnRowMapper(requiredType));
}

自然而然的想到，直接傳入POJO的型別進去，是不是就可以得到我們預期的結果了?

String sql =
                "select id, `name`, money, is_deleted as isDeleted, unix_timestamp(create_at) as created, unix_timestamp(update_at) as updated from money limit 1;";
try {
    MoneyPO po = jdbcTemplate.queryForObject(sql, MoneyPO.class);
    System.out.println("queryForObject by requireType return: " + po);
} catch (Exception e) {
    e.printStackTrace();
}

執行上面的程式碼，丟擲異常

從上面的原始碼也可以看到，上面的使用姿勢，適用於sql只返回一列資料的場景，即下面的case

// 下面開始測試下 org.springframework.jdbc.core.JdbcTemplate.queryForObject(java.lang.String, java.lang.Class<T>, java.lang.Object...)
// 根據測試，這個型別，只能是基本型別
String sql2 = "select id from money where id=?";
Integer res = jdbcTemplate.queryForObject(sql2, Integer.class, 1);
System.out.println("queryForObject by requireId return: " + res);

4. 測試

上面所有程式碼可以檢視: https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/101-jdbctemplate/src/main/java/com/git/hui/boot/jdbc/query/QueryService.java

簡單的繼承呼叫下上面的所有方法

@SpringBootApplication
public class Application {
    private QueryService queryService;

    public Application(QueryService queryService) {
        this.queryService = queryService;

        queryTest();
    }
    public void queryTest() {
        queryService.queryForMap();
        queryService.queryForObject();
        queryService.queryForList();
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }
}

輸出結果如下

III. 小結

本篇博文主要介紹了JdbcTemplate查詢的簡單使用姿勢，主要是queryForMap, queryForList, queryForObject三種方法的呼叫

1. 根據返回結果數量

單條記錄查詢

• queryForMap ： 返回一條記錄，返回的結果塞入Map<String, Object>， key為固定的String對應查詢的列名；value為實際值
• queryForObject ：同樣返回一條資料，與上面的區別在於可以藉助RowMapper來實現返回結果轉換為對應的POJO

需要注意的是，上面的查詢，必須有一條記錄返回，如果查不到，則拋異常

批量查詢

• queryForList ：一次查詢>=0條資料，返回型別為 List<Map<String, Object>>

2. 根據sql型別

有兩種sql傳參方式

• 一個是寫完整的sql語句，就和我們普通的sql查詢一樣；問題是存在注入的風險
• 其次是使用佔位符(?), 實際的值通過引數方式傳入

IV. 其他

• 190407-SpringBoot高階篇JdbcTemplate之資料插入使用姿勢詳解
• 190412-SpringBoot高階篇JdbcTemplate之資料查詢上篇

0. 專案

• 工程：https://github.com/liuyueyi/spring-boot-demo
• 專案：https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/101-jdbctemplate

1. 宣告

盡信書則不如，以上內容，純屬一家之言，因個人能力有限，難免有疏漏和錯誤之處，如發現bug或者有更好的建議，歡迎批評指正，不吝感激

• 一灰灰Blog個人部落格 https://blog.hhui.top
• 一灰灰Blog-Spring專題部落格 http://spring.hhui.top
• 微博地址: 小灰灰Blog
• QQ： 一灰灰/3302797840

相關推薦