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 框架混合使用。