Spring JDBC

9. Spring JDBC

• Spring 提供了一个 Spring JDBC 模块，它对 JDBC API 进行了封装，其的主要目的降低 JDBC API 的使用难度，使用 Spring JDBC，只需要定义必要的参数、指定需要执行的 SQL 语句，即可轻松的进行 JDBC 编程，对数据库进行访问。除业务之外的其他模板式代码由Spring JDBC进行管理

JDBC 是 Java 提供的一种用于执行 SQL 语句的 API,支持多种关系型数据库

JDBC API使用麻烦，我们需要手动控制数据库连接的开启，异常处理、事务处理、最后还要手动关闭连接释放资源等等

9.1 JdbcTemplate

• Spring JDBC 提供了多个实用的数据库访问工具，以简化 JDBC 的开发，其中使用最多就是 JdbcTemplate。
• JdbcTemplate 是 Spring JDBC 核心包（core）中的核心类，它可以通过配置文件、注解、Java 配置类等形式获取数据库的相关信息，实现了对 JDBC 开发过程中的驱动加载、连接的开启和关闭、SQL 语句的创建与执行、异常处理、事务处理、数据类型转换等操作的封装。我们只要对其传入SQL 语句和必要的参数即可轻松进行 JDBC 编程。
• JdbcTemplate 的全限定命名为 org.springframework.jdbc.core.JdbcTemplate，它提供了大量的查询和更新数据库的方法

9.2 使用

• 导入依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.19</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
</dependency>
 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>8.0.15</version>
 </dependency>
 <!--spring 操作数据库需要spring-jdbc，并提供事务支持-->
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-jdbc</artifactId>
     <version>5.3.20</version>
 </dependency>
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

• 例：编写db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/school?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
#导入的properties文件中不要将user定为username，否者会获取系统用户名
usernames=root
password=123456
1
2
3
4
5

• 实体

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private static final Long serializable = 1L;
    private int id;
    private String name;
    private String pwd;
}
1
2
3
4
5
6
7
8
9

• 编写applicationContext.xml

<?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"
       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">
    <!--开启注解扫描-->
    <context:component-scan base-package="com.zk"/>
    <!--引入 db.properties 中的配置-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--定义数据源 Bean-->
    <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
        <property name="driverClassName" value="${driver}"/>
        <property name="username" value="${usernames}"/>
        <property name="url" value="${url}"/>
        <property name="password" value="${password}"/>
    </bean>
    <!--定义JdbcTemplate Bean-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
        <property name="lazyInit" value="true"/>
    </bean>
</beans>
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

在以上配置中，我们共定义了两个 Bean，

• dataSource 为数据库连接池对象的 Bean。
• jdbcTemplate 则为 JdbcTemplate 的 Bean，它由一个名为 datasSource 的属性。

Spring 默认使用 DriverManagerDataSource 对数据库连接池进行管理，我们可以在 Spring 的 XML 配置文件中定义 DriverManagerDataSource 的 Bean，并注入到 JdbcTempate 的 Bean 中。

• 编写dao接口及实现类

public interface UserDao {

   List<User> getUserList();

   User getUser(Map map);

   int addUser(User user);

   int updateUser(Map map);

   int deleteUser(Map map);

   int count(Map map);

   int[] batchUser(List<Object[]> users);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

@Repository
public class UserDaoImpl implements UserDao{
    @Resource
    JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public List<User> getUserList() {
        String sql = "select * from school.user";
        List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
        return users;
    }

    @Override
    public User getUser(Map map) {
        String sql = "select * from school.user where id = ?";
        User user = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<>(User.class),map.get("id"));
        return user;
    }

    @Override
    public int addUser(User user) {
        String sql = "INSERT into school.user (id,name,pwd) VALUES(?,?,?);";
        int result = jdbcTemplate.update(sql, user.getId(), user.getName(), user.getPwd());
        return result;

    }

    @Override
    public int updateUser(Map map) {
        String sql = "update  school.user set pwd = ? where id = ?";
        int result = jdbcTemplate.update(sql, map.get("pwd"),map.get("id"));
        return result;
    }

    @Override
    public int deleteUser(Map map) {
        String sql = "delete from school.user where id = ?";
        int result = jdbcTemplate.update(sql, map.get("id"));
        return result;
    }

    @Override
    public int count(Map map) {
        String sql = "select count(1) from school.user where name = ?";
        int result = jdbcTemplate.queryForObject(sql,Integer.class, map.get("name"));
        return result;
    }

    @Override
    public int[] batchUser(List<Object[]> users) {
        String sql = "INSERT into school.user (id,name,pwd) VALUES(?,?,?);";
        int[] result = jdbcTemplate.batchUpdate(sql,users);
        return result;
    }
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59

• 测试

public class testDemo {
    @Test
    public void test01(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        List<User> userList = userDao.getUserList();
        userList.forEach(var-> System.out.println(var.toString()));
    }
    @Test
    public void test02(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",2);
        User user = userDao.getUser(map);
        System.out.println(user.toString());
    }
    @Test
    public void test03(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        int result = userDao.addUser(new User(7, "Jom", "123456"));
        System.out.println("结果："+result);
    }
    @Test
    public void test04(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",7);
        map.put("pwd","987654");
        int result = userDao.updateUser(map);
        System.out.println("结果："+result);
    }

    @Test
    public void test05(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",7);
        int result = userDao.deleteUser(map);
        System.out.println("结果："+result);
    }
    @Test
    public void test06(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","tony");
        int result = userDao.count(map);
        System.out.println("结果："+result);
    }
    @Test
    public void test07(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDaoImpl", UserDao.class);
        List<Object[]> objects = new ArrayList<>();
        Object[] o1 = {11,"Jom", "123456"};
        Object[] o2 = {12,"hom", "123456"};
        Object[] o3 = {13,"zail", "987654"};
        objects.add(o1);
        objects.add(o2);
        objects.add(o3);
        int[] result = userDao.batchUser(objects);
        System.out.println("结果："+result.length);
    }

}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

本专栏下一篇：spring整合mybatis