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
mysql-connector-java
5.1.44
org.springframework
spring-core
${spring.version}
org.springframework
spring-beans
${spring.version}
org.springframework
spring-context
${spring.version}
org.springframework
spring-expression
${spring.version}
org.springframework
spring-aop
${spring.version}
org.springframework
spring-jdbc
${spring.version}
org.springframework
spring-tx
${spring.version}
Spring 配置:
数据源
JDBC Template
(设置两个 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
举例:
// 批量增删改方法:执行多条 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 list = new ArrayList();
list.add(new Object[]{1, 1001});
list.add(new Object[]{1, 1003});
jdbcTemplate.batchUpdate(sql, list);
}
查询简单数据项
获取一个
T queryForObject(String sql, Class type)
T queryForObject(String sql, Object[] args, Class type)
T queryForObject(String sql, Class type, Object... args)
获取多个
List queryForList(String sql, Class type)
List queryForList(String sql, Object[] args, Class type)
List queryForList(String sql, Class 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 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> queryForList(String sql)
List> queryForList(String sql, Object[] args)
List> queryForList(String sql, Object... args)
举例:
// 查询复杂对象(封装为Map,查询一个)
public void testQueryMap1() {
String sql = "select * from student where id = ?";
Map stu = jdbcTemplate.queryForMap(sql, 1);
System.out.println(stu);
}
// 查询复杂对象(封装为Map, 查询多个)
public void testQueryMap2() {
String sql = "select * from student";
List> stus = jdbcTemplate.queryForList(sql);
System.out.println(stus);
}
查询复杂对象(封装为实体对象)
使用 RowMapper 接口
获取一个
T queryForObject(String sql, RowMapper mapper)
T queryForObject(String sql, Object[] args, RowMapper mapper)
T queryForObject(String sql, RowMapper mapper, Object... arg)
获取多个
List query(String sql, RowMapper mapper)
List query(String sql, Object[] args, RowMapper mapper)
List query(String sql, RowMapper mapper, Object... arg)
举例:
//查询复杂对象(封装为实体对象,获取一个)
//映射写法
public void testQueryEntity1() {
final String sql = "select * from student where id=?";
// 匿名内部类
Student stu = jdbcTemplate.queryForObject(sql, new RowMapper() {
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 stus = jdbcTemplate.query(sql, new StudentRowMapper());
System.out.println(stus);
}
// 构造封装对象类
private class StudentRowMapper implements RowMapper {
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 持久层示例
具体步骤:
创建实体类(emtity)
创建接口(dao)
创建接口实现类(daoImpl)
我们在实现类中注入 JdbcTemplate,并声明 RowMapper 接口。
如果查询出来的结果没有对应的实体类,并且不打算把它转为为实体类的对象来传递,这种时候使用 Map 类型。
4. 总结
JDBC Template 优点:
简单
灵活
JDBC Template 缺点:
SQL 与 Java 代码参杂
功能不丰富
总结:
JDBC Template是 Spring 框架对 JDBC 操作的封装。简单、灵活但不够强大。实际应用中还需要和其他 ORM 框架混合使用。