Spring JdbcTemplate详解

转载：https://www.cnblogs.com/xuwenjin/p/8822354.html

为了使 JDBC 更加易于使用,Spring 在 JDBCAPI 上定义了一个抽象层, 以此建立一个JDBC存取框架.

作为 SpringJDBC 框架的核心, JDBC 模板的设计目的是为不同类型的JDBC操作提供模板方法. 每个模板方法都能控制整个过程,并允许覆盖过程中的特定任务.通过这种

方式,可以在尽可能保留灵活性的情况下,将数据库存取的工作量降到最低.

JdbcTemplate主要提供以下五类方法：

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

1、首先在数据库新建一张表

CREATE TABLE xwj_user (
   id VARCHAR(32) NOT NULL,
   last_name VARCHAR(32),
   age INT(2),
   email VARCHAR(32)
) ENGINE=INNODB DEFAULT CHARSET=utf8

2、在pom.xml文件中，增加依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.2.5.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.2.5.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <!-- 获取上下文 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <!-- 连接到mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.35</version>
        </dependency>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

3、在resource下面增加两个配置文件db.properties、applicationContext.xml

　　db.properties配置文件：

jdbc.user=root
jdbc.password=root
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://dev.yonyouccs.com:3001/icop-construct-busisubpack

initPoolSize=5
maxPoolSize=10

在xml文件中，导入这个属性文件以及配置c3p0数据源：

<!-- 读取配置文件 -->
    <context:property-placeholder location="classpath:db.properties" />
    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>

        <property name="initialPoolSize" value="${initPoolSize}"></property>
        <property name="maxPoolSize" value="${maxPoolSize}"></property>
    </bean>

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

4、创建一个实体类User

 1 package com.xwj.bean;
 2 
 3 public class User {
 4 
 5     private String id;
 6     private String lastName;
 7     private int age;
 8     private String email;
 9 
10     public String getId() {
11         return id;
12     }
13 
14     public void setId(String id) {
15         this.id = id;
16     }
17 
18     public String getLastName() {
19         return lastName;
20     }
21 
22     public void setLastName(String lastName) {
23         this.lastName = lastName;
24     }
25 
26     public int getAge() {
27         return age;
28     }
29 
30     public void setAge(int age) {
31         this.age = age;
32     }
33 
34     public String getEmail() {
35         return email;
36     }
37 
38     public void setEmail(String email) {
39         this.email = email;
40     }
41 
42     public String toString() {
43         return "User [id=" + id + ", lastName=" + lastName + ", email=" + email + ", age=" + age +"] ";
44     }
45 
46 }

5、创建一个测试类对JdbcTemplate的方法进行测试：

  1 package com.xwj.util;
  2 
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 
  6 import org.junit.Test;
  7 import org.springframework.context.ApplicationContext;
  8 import org.springframework.context.support.ClassPathXmlApplicationContext;
  9 import org.springframework.jdbc.core.BeanPropertyRowMapper;
 10 import org.springframework.jdbc.core.JdbcTemplate;
 11 import org.springframework.jdbc.core.RowMapper;
 12 import org.springframework.util.CollectionUtils;
 13 
 14 import com.xwj.bean.User;
 15 
 16 public class TestJdbc {
 17 
 18     private ApplicationContext ctx = null;
 19     private JdbcTemplate jdbcTemplate = null;
 20 
 21     {
 22         ctx = new ClassPathXmlApplicationContext("ApplicationContext.xml");
 23         jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
 24     }
 25 
 26     /**
 27      * 执行 INSERT
 28      */
 29     @Test
 30     public void testInsert() {
 31         String sql = "INSERT INTO xwj_user(id, last_name, age) VALUES(?, ?, ?)";
 32         jdbcTemplate.update(sql, "1", "a-xwj", 0);
 33     }
 34 
 35     /**
 36      * 执行UPDATE
 37      */
 38     @Test
 39     public void testUpdate() {
 40         String sql = "UPDATE xwj_user SET last_name = ? WHERE id = ?";
 41         jdbcTemplate.update(sql, "b-xwj", 1);
 42     }
 43 
 44     /**
 45      * 执行 DELETE
 46      */
 47     @Test
 48     public void testDelete() {
 49         String sql = "DELETE from xwj_user WHERE id = ?";
 50         jdbcTemplate.update(sql, 1);
 51     }
 52 
 53     /**
 54      * 测试批量更新操作 最后一个参数是 Object[] 的 List 类型：因为修改一条记录需要一个 Object 数组，修改多条记录就需要一个
 55      * List 来存放多个数组。
 56      */
 57     @Test
 58     public void testBatchUpdate() {
 59         String sql = "INSERT INTO xwj_user(id, last_name, email) VALUES(?, ?, ?)";
 60 
 61         List<Object[]> batchArgs = new ArrayList<>();
 62         batchArgs.add(new Object[] { "2", "AA", "aa@atguigu.com" });
 63         batchArgs.add(new Object[] { "3", "BB", "bb@atguigu.com" });
 64         batchArgs.add(new Object[] { "4", "CC", "cc@atguigu.com" });
 65         batchArgs.add(new Object[] { "5", "DD", "dd@atguigu.com" });
 66 
 67         jdbcTemplate.batchUpdate(sql, batchArgs);
 68     }
 69 
 70     /**
 71      * 从数据库中获取一条记录，实际得到对应的一个对象 注意：不是调用 queryForObject(String sql,Class<Employee> requiredType, Object... args) 方法! 
 72      * 而需要调用queryForObject(String sql, RowMapper<Employee> rowMapper, Object... args)
 73      * 1、其中的 RowMapper 指定如何去映射结果集的行，常用的实现类为 BeanPropertyRowMapper 
 74      * 2、使用SQL中的列的别名完成列名和类的属性名的映射，例如 last_name lastName 
 75      * 3、不支持级联属性。 JdbcTemplate只能作为一个 JDBC 的小工具, 而不是 ORM 框架
 76      */
 77     @Test
 78     public void testQueryForObject() {
 79         String sql = "SELECT id, last_name lastName, email FROM xwj_user WHERE ID = ?";
 80         RowMapper<User> rowMapper = new BeanPropertyRowMapper<>(User.class);
 81         // 在将数据装入对象时需要调用set方法。
 82         User user = jdbcTemplate.queryForObject(sql, rowMapper, 2);
 83         System.out.println(user);
 84     }
 85     
 86     /** 
 87      * 一次查询多个对象 
 88      * 注意：调用的不是 queryForList 方法 
 89      */  
 90     @Test  
 91     public void testQueryForList() {  
 92         String sql = "SELECT id, name, email FROM xwj_user WHERE id > ?";  
 93         RowMapper<User> rowMapper = new BeanPropertyRowMapper<>(User.class);  
 94         List<User> userList = jdbcTemplate.query(sql, rowMapper, 1);  
 95         if (!CollectionUtils.isEmpty(userList)) {
 96             userList.forEach(user -> {
 97                 System.out.println(user);
 98             });
 99         }
100     }  
101     
102     /** 
103      * 获取单个列的值或做统计查询 
104      * 使用 queryForObject(String sql, Class<Long> requiredType)  
105      */  
106     @Test  
107     public void testQueryForCount() {  
108         String sql = "SELECT count(id) FROM xwj_user";  
109         long count = jdbcTemplate.queryForObject(sql, Long.class);  
110           
111         System.out.println(count);  
112     }     
113 
114 }

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