JDBC Template

Spring 在 JDBC API 之上提供了 JDBC Template 组件简化了持久化操作。

示例准备

在 maven 中引入依赖,包括 Mysql 驱动、Spring 相关组件(core、beans、context、aop)和 JDBC Template 相关组件(jdbc、tx):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<properties>
<spring.version>4.3.15.RELEASE</spring.version>
...
</properties>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</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-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

接着 Spring 配置 spring.xml,包括数据库源和 JDBC Template:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

<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="root"/>
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>

<context:component-scan base-package="com.imtt.sjt"/>
</beans>

单元测试基本代码,包含了一个代码块,用于生成 JDBC Template 的实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class Text {
private JdbcTemplate jdbcTemplate;
{
ApplicationContext context =
new ClassPathXmlApplicationContext("spring.xml");
jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate");
}
}

JDBC Template 基本使用

JDBC Template 基本使用包括:

  • execute 方法:可以执行任何 SQL,但通常用来执行 DDL 语句;
  • updatebatchUpdate 方法:对数据进行增删改操作;
  • queryqueryXXX 方法;对数据库进行查询操作;
  • call 方法:调用存储过程。

execute 方法

在测试代码中添加:

1
2
3
4
@Test
public void testExecute() {
jdbcTemplate.execute("create table user1(id int, name varchar(20))");
}

execute 方法中添加 sql 就行了。

update 与 batchUpdate 方法

update 方法

update 方法使用单条 sql 语句对数据进行增删改操作:

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

args 表示 sql 语句中需要的数据,返回值表示影响的行数。

测试代码:

1
2
3
4
5
@Test
public void testUpdate() {
String sql = "insert into student(name, sex) values (?, ?)";
jdbcTemplate.update(sql, new Object[]{"张飞", "男"});
}

batchUpdate 方法

batchUpdate 方法是批量增删改操作。

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

测试代码:

1
2
3
4
5
6
7
8
9
@Test
public void testBatchUpdate() {
String sql = "insert into selection(student, course) values(?, ?)";
List<Object[]> list = new ArrayList<Object[]>();
list.add(new Object[]{2, 1001});
list.add(new Object[]{2, 1002});

jdbcTemplate.batchUpdate(sql, list);
}

query 与 queryXXX 方法

查询简单数据项

  1. 获取一个
    • T queryForObject(String sql, Class<T> type)
    • T queryForObject(String sql, Object[] args, Class<T> type)
    • T queryForObject(String sql, Class<T> type,Object... arg)
  2. 获取多个
    • 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... arg)

Class<T> type 表示查询的结果是什么类型。

测试代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public void testQuerySimple1() {
String sql = "select count(*) from student";
int count = jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println("count:" + count);
}

@Test
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。

  1. 获取一个

    • Map queryForMap(String sql)
    • Map queryForMap(String sql , Object[] args)
    • Map queryForMap(String sql , Object... arg)
  2. 获取多个

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

测试代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public void testQueryMap() {
String sql = "select * from student where id = ?";
Map<String, Object> stu = jdbcTemplate.queryForMap(sql, 2);
System.out.println(stu);
}

@Test
public void testQueryMap2() {
String sql = "select * from student";
List<Map<String, Object>> stus = jdbcTemplate.queryForList(sql);
System.out.println(stus);
}

封装为实体对象(使用 RowMapper 接口)

如果要将查询的结果封装成实体对象,就要借助于 RowMapper 接口的 mapRow 方法。

  1. 获取一个
    • 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)
  2. 获取多个
    • 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)

测试代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public void testQueryEntity() {
String sql = "select * from student where id = ?";
Student student = jdbcTemplate.queryForObject(sql, new StudentRowMapper(), 2);
}

@Test
public void testQueryEntity2() {
String sql = "select * from student";
List<Student> students = jdbcTemplate.query(sql, new StudentRowMapper());
}

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;
}
}

Student 为一个实体类。

坚持原创技术分享,您的支持将鼓励我继续创作!