Spring 中的 JdbcTemplate

最新推荐文章于 2023-09-08 10:46:26 发布

程序猿卡卡罗特_

最新推荐文章于 2023-09-08 10:46:26 发布

阅读量207

点赞数

分类专栏： Spring

Spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Spring-jdbc：JdbcTemplate使用简介

原创
2016年08月16日 11:18:14

        <ul class="article_tags clearfix csdn-tracking-statistics tracking-click" data-mod="popu_377">
            <li class="tit">标签：</li>

spring框架 /
jdbc /
JdbcTemplate /
- 14338
- 编辑
- 删除
为了使 JDBC 更加易于使用,Spring 在 JDBCAPI 上定义了一个抽象层, 以此建立一个JDBC存取框架.

作为 SpringJDBC 框架的核心, JDBC 模板的设计目的是为不同类型的JDBC操作提供模板方法. 每个模板方法都能控制整个过程,并允许覆盖过程中的特定任务.通过这种方式,可以在尽可能保留灵活性的情况下,将数据库存取的工作量降到最低.

JdbcTemplate主要提供以下五类方法：
execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；
update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；
query方法及queryForXXX方法：用于执行查询相关语句；
call方法：用于执行存储过程、函数相关语句。

使用示例：

在数据库中先准备两张表：

和

在java工程中创建两个对应类：
[java] view plain copy
print ?
1. public class Department {
2. int id;
3. String deptName;
4. @Override
5. public String toString() {
6. return “Department [id=” + id + “, deptName=” + deptName + “]”;
7. }
9. }
```
public class Department {
 int id;
 String deptName;
 @Override
 public String toString() {
 return "Department [id=" + id + ", deptName=" + deptName + "]";
 }

}
```
[java] view plain copy
print ?
1. public class Employee {
2. int id;
3. String lastName;
4. String email;
5. Department department;
6. @Override
7. public String toString() {
8. return “Employee [id=” + id + “, lastName=” + lastName + “, email=”
9. + email + ”, department=” + department + “]”;
10. }
11. public int getId() {
12. return id;
13. }
14. public void setId(int id) {
15. this.id = id;
16. }
17. public String getLastName() {
18. return lastName;
19. }
20. public void setLastName(String lastName) {
21. this.lastName = lastName;
22. }
23. public String getEmail() {
24. return email;
25. }
26. public void setEmail(String email) {
27. this.email = email;
28. }
29. public Department getDepartment() {
30. return department;
31. }
32. public void setDepartment(Department department) {
33. this.department = department;
34. }
37. }
```
public class Employee {
 int id;
 String lastName;
 String email;
 Department department;
 @Override
 public String toString() {
 return "Employee [id=" + id + ", lastName=" + lastName + ", email="
 + email + ", department=" + department + "]";
 }
 public int getId() {
 return id;
 }
 public void setId(int id) {
 this.id = id;
 }
 public String getLastName() {
 return lastName;
 }
 public void setLastName(String lastName) {
 this.lastName = lastName;
 }
 public String getEmail() {
 return email;
 }
 public void setEmail(String email) {
 this.email = email;
 }
 public Department getDepartment() {
 return department;
 }
 public void setDepartment(Department department) {
 this.department = department;
 }


}
```
引入Spring框架相关的jar包以及c3p0和mysql连接jar包。为了对方法进行测试，这里还需要引入JUnit4.这里以导入外部属性文件的方式来配置数据源：

jdbc.properties文件内容如下：
[plain] view plain copy
print ?
1. user=root
2. password=123
3. driverClass=com.mysql.jdbc.Driver
4. jdbcUrl=jdbc:mysql:///spring
6. initPoolSize=5
7. maxPoolSize=10
```
user=root
password=123
driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql:///spring

initPoolSize=5
maxPoolSize=10
```
在xml文件中，导入这个属性文件以及配置c3p0数据源：
[html] view plain copy
print ?
1. <!– 导入资源文件 –>
2. <context:property-placeholder location=“classpath:jdbc.properties”/>
4. <!– 配置 c3p0 数据源 –>
5. <bean id=“dataSource”
6. class=“com.mchange.v2.c3p0.ComboPooledDataSource”>
7. <property name=“user” value=“ ${user}"></property>     </li><li class="">    <property name="password" value="$ {password}”></property>
8. <property name=“jdbcUrl” value=“ ${jdbcUrl}"></property>   </li><li class="">    <property name="driverClass" value="$ {driverClass}”></property>
10. <property name=“initialPoolSize” value=“ ${initPoolSize}"></property>      </li><li class="alt">    <property name="maxPoolSize" value="$ {maxPoolSize}”></property>
11. </bean>
```
 
 <context:property-placeholder location="classpath:jdbc.properties"/>

 
 <bean id="dataSource"
 class="com.mchange.v2.c3p0.ComboPooledDataSource">
 <property name="user" value="${user}"></property> 
 <property name="password" value="${password}"></property> 
 <property name="jdbcUrl" value="${jdbcUrl}"></property> 
 <property name="driverClass" value="${driverClass}"></property> 

 <property name="initialPoolSize" value="${initPoolSize}"></property> 
 <property name="maxPoolSize" value="${maxPoolSize}"></property> 
 </bean>
```
配置好dataSource后就可以用这个数据源来配置JdbcTemplate了，在xml文件中添加：
[html] view plain copy
print ?
1. <!– 配置 spring 的 JdbcTemplate –>
2. <bean id=“jdbcTemplate”
3. class=“org.springframework.jdbc.core.JdbcTemplate”>
4. <property name=“dataSource” ref=“dataSource”></property>
5. </bean>
```
 
 <bean id="jdbcTemplate"
 class="org.springframework.jdbc.core.JdbcTemplate">
 <property name="dataSource" ref="dataSource"></property>
 </bean>
```
接下来创建一个测试类对JdbcTemplate的方法进行测试：
[java] view plain copy
print ?
1. import java.util.ArrayList;
2. import java.util.List;
4. import org.junit.Test;
5. import org.springframework.context.ApplicationContext;
6. import org.springframework.context.support.ClassPathXmlApplicationContext;
7. import org.springframework.jdbc.core.BeanPropertyRowMapper;
8. import org.springframework.jdbc.core.JdbcTemplate;
9. import org.springframework.jdbc.core.RowMapper;
11. public class JDBCTest {
13. private ApplicationContext ctx= null;
14. private JdbcTemplate jdbcTemplate = null;
15. // private EmployeeDao employee;
17. {
18. ctx = new ClassPathXmlApplicationContext(“ApplicationContext.xml”);
19. jdbcTemplate = (JdbcTemplate) ctx.getBean(”jdbcTemplate”);
20. }
22. /**
23. * 执行 INSERT,UPDATE,DELETE
24. */
25. @Test
26. public void testUpdate() {
27. String sql = ”UPDATE employees SET last_name = ? WHERE id = ?”;
28. jdbcTemplate.update(sql, ”Jack”, 5);
29. }
30. /**
31. * 测试批量更新操作
32. * 最后一个参数是 Object[] 的 List 类型：因为修改一条记录需要一个 Object 数组，修改多条记录就需要一个 List 来存放多个数组。
33. */
34. @Test
35. public void testBatchUpdate() {
36. String sql = ”INSERT INTO employees(last_name, email, dept_id) VALUES(?,?,?)”;
38. List<Object[]> batchArgs = new ArrayList<>();
40. batchArgs.add(new Object[]{“AA”, “aa@atguigu.com”, 1});
41. batchArgs.add(new Object[]{“BB”, “bb@atguigu.com”, 2});
42. batchArgs.add(new Object[]{“CC”, “cc@atguigu.com”, 3});
43. batchArgs.add(new Object[]{“DD”, “dd@atguigu.com”, 3});
44. batchArgs.add(new Object[]{“EE”, “ee@atguigu.com”, 2});
46. jdbcTemplate.batchUpdate(sql, batchArgs);
47. }
49. /**
50. * 从数据库中获取一条记录，实际得到对应的一个对象
51. * 注意：不是调用 queryForObject(String sql, Class<Employee> requiredType, Object… args) 方法!
52. * 而需要调用 queryForObject(String sql, RowMapper<Employee> rowMapper, Object… args)
53. * 1、其中的 RowMapper 指定如何去映射结果集的行，常用的实现类为 BeanPropertyRowMapper
54. * 2、使用 SQL中的列的别名完成列名和类的属性名的映射，例如 last_name lastName
55. * 3、不支持级联属性。 JdbcTemplate 只能作为一个 JDBC 的小工具, 而不是 ORM 框架
56. */
57. @Test
58. public void testQueryForObject() {
59. String sql = ”SELECT id, last_name lastName,email,dept_id as \”department.id\” FROM employees WHERE ID = ?”;
60. RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
61. //在将数据装入对象时需要调用set方法。
62. Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, 1);
64. System.out.println(employee);
65. }
67. /**
68. * 一次查询多个对象
69. * 注意：调用的不是 queryForList 方法
70. */
71. @Test
72. public void testQueryForList() {
73. String sql = ”SELECT id, last_name lastName, email FROM employees WHERE id > ?”;
74. RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
75. List<Employee> employees = jdbcTemplate.query(sql, rowMapper,5);
77. System.out.println(employees);
78. }
79. /**
80. * 获取单个列的值或做统计查询
81. * 使用 queryForObject(String sql, Class<Long> requiredType)
82. */
83. @Test
84. public void testQueryForObject2() {
85. String sql = ”SELECT count(id) FROM employees”;
86. long count = jdbcTemplate.queryForObject(sql, Long.class);
88. System.out.println(count);
89. }
90. }
```
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

public class JDBCTest {

 private ApplicationContext ctx= null;
 private JdbcTemplate jdbcTemplate = null;
// private EmployeeDao employee;

 {
 ctx = new ClassPathXmlApplicationContext("ApplicationContext.xml");
 jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
 }

 /**
 * 执行 INSERT,UPDATE,DELETE
 */
 @Test
 public void testUpdate() {
 String sql = "UPDATE employees SET last_name = ? WHERE id = ?";
 jdbcTemplate.update(sql, "Jack", 5);
 }
 /**
 * 测试批量更新操作
 * 最后一个参数是 Object[] 的 List 类型：因为修改一条记录需要一个 Object 数组，修改多条记录就需要一个 List 来存放多个数组。
 */
 @Test
 public void testBatchUpdate() {
 String sql = "INSERT INTO employees(last_name, email, dept_id) VALUES(?,?,?)";

 List<Object[]> batchArgs = new ArrayList<>();

 batchArgs.add(new Object[]{"AA", "aa@atguigu.com", 1});
 batchArgs.add(new Object[]{"BB", "bb@atguigu.com", 2});
 batchArgs.add(new Object[]{"CC", "cc@atguigu.com", 3});
 batchArgs.add(new Object[]{"DD", "dd@atguigu.com", 3});
 batchArgs.add(new Object[]{"EE", "ee@atguigu.com", 2});

 jdbcTemplate.batchUpdate(sql, batchArgs);
 }

 /**
 * 从数据库中获取一条记录，实际得到对应的一个对象
 * 注意：不是调用 queryForObject(String sql, Class<Employee> requiredType, Object... args) 方法!
 * 而需要调用 queryForObject(String sql, RowMapper<Employee> rowMapper, Object... args)
 * 1、其中的 RowMapper 指定如何去映射结果集的行，常用的实现类为 BeanPropertyRowMapper
 * 2、使用 SQL中的列的别名完成列名和类的属性名的映射，例如 last_name lastName
 * 3、不支持级联属性。 JdbcTemplate 只能作为一个 JDBC 的小工具, 而不是 ORM 框架
 */
 @Test
 public void testQueryForObject() {
 String sql = "SELECT id, last_name lastName,email,dept_id as \"department.id\" FROM employees WHERE ID = ?";
 RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
 //在将数据装入对象时需要调用set方法。
 Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, 1);

 System.out.println(employee);
 }

 /**
 * 一次查询多个对象
 * 注意：调用的不是 queryForList 方法
 */
 @Test
 public void testQueryForList() {
 String sql = "SELECT id, last_name lastName, email FROM employees WHERE id > ?";
 RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
 List<Employee> employees = jdbcTemplate.query(sql, rowMapper,5);

 System.out.println(employees);
 }
 /**
 * 获取单个列的值或做统计查询
 * 使用 queryForObject(String sql, Class<Long> requiredType) 
 */
 @Test
 public void testQueryForObject2() {
 String sql = "SELECT count(id) FROM employees";
 long count = jdbcTemplate.queryForObject(sql, Long.class);

 System.out.println(count);
 } 
}
```
在实际的使用中，一般会创建一个dao类来封装对某个对象的所有增删改查操作.

比如，创建一个EmployeeDao类如下：
[java] view plain copy
print ?
1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.jdbc.core.BeanPropertyRowMapper;
3. import org.springframework.jdbc.core.JdbcTemplate;
4. import org.springframework.jdbc.core.RowMapper;
5. import org.springframework.stereotype.Repository;
7. @Repository
8. public class EmployeeDao {
9. @Autowired
10. private JdbcTemplate jdbcTemplate;
12. public Employee get(Integer id) {
13. String sql = ”SELECT id, last_name lastName, email FROM employees WHERE id = ?”;
14. RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
15. Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, id);
17. return employee;
18. }
19. }
```
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

@Repository
public class EmployeeDao {
 @Autowired
 private JdbcTemplate jdbcTemplate;

 public Employee get(Integer id) {
 String sql = "SELECT id, last_name lastName, email FROM employees WHERE id = ?";
 RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
 Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, id);

 return employee;
 }
}
```
在这个Dao类中实现了通过id来获取记录并封装成对象返回的方法。如果有需要还可以实现其他操作如插入、删除、更新等。

由于这里使用了注解来配置bean以及bean的自动装配，所以还需要在xml文件中添加（要先导入context命名空间）：
[html] view plain copy
print ?
1. <context:component-scan base-package=“com.atguigu.spring.jdbc”></context:component-scan>
```
<context:component-scan base-package="com.atguigu.spring.jdbc"></context:component-scan>
```
测试一下EmployeeDao：
[java] view plain copy
print ?
1. @Test
2. public void testEmployeeDao() {
3. EmployeeDao employeeDao = (EmployeeDao) ctx.getBean(”employeeDao”);
4. Employee employee = employeeDao.get(1);
5. System.out.println(employee);
6. }
```
 @Test
 public void testEmployeeDao() {
 EmployeeDao employeeDao = (EmployeeDao) ctx.getBean("employeeDao");
 Employee employee = employeeDao.get(1);
 System.out.println(employee);
 }
```
打印输出如下：

总结：JdbcTemplate是Spring框架自带的对JDBC操作的封装，目的是提供统一的模板方法使对数据库的操作更加方便、友好，效率也不错。但是功能还是不够强大（比如不支持级联属性），在实际应用中还需要和hibernate、mybaties等框架混合使用。
```
 </div>
</article>
```