JDBC Template

JDBC Template

其實有比 JDBC Template 更好的操做數據庫的框架（如 Mybatis），可是 JDBC Template 是基礎，有助於咱們更好的瞭解 Spring 中JDBC 操做，因此仍是講解一下。

使用 Spring 組件 JDBC Template 簡化持久化操做。

1. Spring JDBC Template

爲了簡化持久化操做，Spring 在 JDBC API 之上提供了 JDBC Template 組件。

JDBC Template 提供統一的模板方法，在保留代碼靈活性的基礎上，儘可能減小持久化代碼

多說無益，咱們以具體的項目來演示一下。

---

2. 項目演示

1. 建立數據庫

數據庫表結構以下：

2. 配置環境

Maven：

• Mysql 驅動
• Spring 組件（core、beans、context、aop）
• JDBC Template（jdbc、tx）

<!-- mysql 驅動 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.44</version>
</dependency>

<!-- Spring 組件 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>${spring.version}</version>
</dependency>

<!-- Spring Template -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.version}</version>
</dependency>

Spring 配置：

• 數據源
• JDBC Template

(設置兩個 bean)

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/selection_course?useUnicode=true&amp;characterEncoding=utf-8"/>
    <property name="username" value="root"/>
    <property name="password" value="xxx"/>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
</bean>

3. JDBC Template 的基本使用

execute 方法

以下：

//execute方法
public void testExecute() {
    jdbcTemplate.execute("create table user1(id int, name varchar(20))");
}

jdbcTemplate 對象經過 IOC 方式獲得。

update 方法

對數據進行增刪操做：

int update(String sql, Object[] args)
int update(String sql, Object... args)

舉例：

// update 方法
public void testUpdate() {
    String sql = "insert into student(name, sex) values(?,?)";
    jdbcTemplate.update(sql, new Object[]{"張飛", "男"});  // 將值放到數組中
}

// update 方法（經常使用）
public void testUpdate2() {
    String sql = "update student set sex=? where id=?";
    jdbcTemplate.update(sql, "女", 1);   // 直接寫參數，不用放在數組中
}

batchUpdate 方法

批量增刪改操做

int[] batchUpdate(String[] sql)
int[] batchUpdate(String sql, List<Object[] args)

舉例：

// 批量增刪改方法：執行多條 sql
public void testBatchUpdate() {
    String[] sqls = {
            "insert into student(name, sex) values('關羽', '女')",
            "insert into student(name, sex) values('劉備', '男')",
            "update student set sex='男' where id=1"
    };
    jdbcTemplate.batchUpdate(sqls);
}

// 批量增刪改方法（經常使用）：執行一條 sql，適合執行同種結構sql
public void testBatchUpdate2() {
    String sql = "insert into selection(student, course) values(?,?)";
    List<Object[]> list = new ArrayList<Object[]>();
    list.add(new Object[]{1, 1001});
    list.add(new Object[]{1, 1003});
    jdbcTemplate.batchUpdate(sql, list);
}

查詢簡單數據項

• 獲取一個

T queryForObject(String sql, Class<T> type)
T queryForObject(String sql, Object[] args, Class<T> type)
T queryForObject(String sql, Class<T> type, Object... args)

• 獲取多個

List<T> queryForList(String sql, Class<T> type)
List<T> queryForList(String sql, Object[] args, Class<T> type)
List<T> queryForList(String sql, Class<T> type, Object... args)

舉例：

// 查詢簡單數據項（獲取一個）
public void testQuerySimple() {
    String sql = "select count(*) from student";
    int count = jdbcTemplate.queryForObject(sql, Integer.class);
    System.out.println(count);
}

// 查詢簡單數據項（獲取多個）
public void testQuerySimple2() {
    String sql = "select name from student where sex=?";
    List<String> names = jdbcTemplate.queryForList(sql, String.class, "男");
    System.out.println(names);

}

查詢複雜對象（封裝爲Map）

• 獲取一個

Map queryForMap(String sql)
Map queryForMap(String sql, Object[] args)
Map queryForMap(String sql, Object... args)

• 獲取多個

List<Map<String, Object>> queryForList(String sql)
List<Map<String, Object>> queryForList(String sql, Object[] args)
List<Map<String, Object>> queryForList(String sql, Object... args)

舉例：

// 查詢複雜對象（封裝爲Map，查詢一個）
 public void testQueryMap1() {
     String sql = "select * from student where id = ?";
     Map<String, Object> stu = jdbcTemplate.queryForMap(sql, 1);
     System.out.println(stu);
 }

 // 查詢複雜對象（封裝爲Map， 查詢多個）
 public void testQueryMap2() {
     String sql = "select * from student";
     List<Map<String, Object>> stus = jdbcTemplate.queryForList(sql);
     System.out.println(stus);
 }

查詢複雜對象（封裝爲實體對象）

使用 RowMapper 接口

• 獲取一個

T queryForObject(String sql, RowMapper<T> mapper)
T queryForObject(String sql, Object[] args, RowMapper<T> mapper)
T queryForObject(String sql, RowMapper<T> mapper, Object... arg)

• 獲取多個

List<T> query(String sql, RowMapper<T> mapper)
List<T> query(String sql, Object[] args, RowMapper<T> mapper)
List<T> query(String sql, RowMapper<T> mapper, Object... arg)

舉例：

//查詢複雜對象（封裝爲實體對象，獲取一個）
//映射寫法
public void testQueryEntity1() {
    final String sql = "select * from student where id=?";
    // 匿名內部類
    Student stu = jdbcTemplate.queryForObject(sql, new RowMapper<Student>() {
        public Student mapRow(ResultSet resultSet, int i) throws SQLException {
            Student stu = new Student();
            stu.setId(resultSet.getInt("id"));
            stu.setName(resultSet.getString("name"));
            stu.setSex(resultSet.getString("sex"));
            stu.setBorn(resultSet.getDate("born"));
            return stu;
        }
    }, 3);
    System.out.println(stu);
}

// 查詢複雜對象（封裝爲實體對象，查詢多個）
public void testQueryEntity2() {
    String sql = "select * from student";
    List<Student> stus = jdbcTemplate.query(sql, new StudentRowMapper());
    System.out.println(stus);
}

// 構造封裝對象類
private class StudentRowMapper implements RowMapper<Student> {
    public Student mapRow(ResultSet resultSet, int i) throws SQLException {
        Student stu = new Student();
        stu.setId(resultSet.getInt("id"));
        stu.setName(resultSet.getString("name"));
        stu.setSex(resultSet.getString("sex"));
        stu.setBorn(resultSet.getDate("born"));
        return stu;
    }
}

---

3. JDBC Template 持久層示例

具體步驟：

1. 建立實體類（emtity）
2. 建立接口（dao）
3. 建立接口實現類（daoImpl）

咱們在實現類中注入 JdbcTemplate，並聲明 RowMapper 接口。

若是查詢出來的結果沒有對應的實體類，而且不打算把它轉爲爲實體類的對象來傳遞，這種時候使用 Map 類型。

具體代碼：com.test.sc

---

4. 總結

JDBC Template 優勢：

• 簡單
• 靈活

JDBC Template 缺點：

• SQL 與 Java 代碼參雜
• 功能不豐富

總結：

JDBC Template是 Spring 框架對 JDBC 操做的封裝。簡單、靈活但不夠強大。實際應用中還須要和其餘 ORM 框架混合使用。