73、SpringBoot 直接整合 JDBC

★ Spring Boot可直接整合JDBC来操作数据库

——很少这么干，这么干就意味着使用最原始的方式来操作数据库。

对于对于极小的项目，直接整合JDBC无需添加JPA、Hibernate等ORM框架。
1
2
3

★ JdbcTemplate

为项目添加spring-boot-starter-jdbc.jar依赖（注意没有data）。
 ——这个Starter几乎是所有数据库访问技术都需要依赖的，因为它是最基础的JDBC依赖

Spring Boot会在容器中自动配置一个JdbcTemplate，并可将该它注入其他的项目组件——

该项目组件就可调用它的方法来操作数据库了。

RowMapper负责将一行记录映射成对象。
1
2
3
4
5
6
7
8

▲ JdbcTemplate方法的总结：

JdbcTemplate还是比较好用的，大部分CRUD操作只要一个方法即可搞定。

对这些方法进行归纳，不难发现它们的设计很统一：
- update()用于执行DML语句（insert、update、delete）、query[ForXxx]()用于执行SELECT语句，
  execute()用于执行DDL语句(create、alter、drop）。
- queryForObject：只能返回单行结果集。
- queryForOList：可返回多行结果集。
- query：可返回多行、多列结果集。
- 如果传入了RowMapper参数，才能返回多列结果集；否则只能返回单列结果集。
- 方法需要传入Object... args参数，则意味着使用PreparedStatement执行SELECT语句，此时就需要为占位符传入参数
  否则使用普通Statement执行SELECT语句。

- 如果查询方法只指定requiredType参数，则意味着查询结果集只能返回单列数据；
  如果查询方法指定了rowMapper参数，查询结果可以返回多列数据，
  而rowMapper则负责将每行数据转为目标对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

▲ BeanPropertyRowMapper

BeanPropertyRowMapper是Spring提供的RowMapper实现类

BeanPropertyRowMapper有一个特点：它要求查询结果集的列名与被映射对象的属性名一一对应

可通过SELECT语句对查询的数据列进行了重命名，从而让结果集的列名与被映射对象的属性名保持对应。


【请记住：】如果使用JDBC来实现DAO组件，必须由开发者自己提供实现类。
1
2
3
4
5
6
7
8

代码演示

创建项目

User 对象

userDao

UserDaoImpl

解释这个rowMapper：
rowMapper 是用来做自定义映射的，查询出来的User对象的数据，映射到Student对象的属性上面去都可以，因为是自定义的。

application.properties

连接数据库

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
1
2
3
4

pom.xml

添加这个依赖，springboot就会帮我们创建一个datasource的数据源的连接，并且会在容器中部署一个叫做 JdbcTemplate，所以userDao组件才有得依赖注入这个jdbcTemplate对象

测试结果：

根据id查找 User 对象

添加对象

根据id删除对象

根据id修改对象

根据名字进行模糊查询

根据年龄进行查询

完整代码

UserDaoImpl

package cn.ljh.app.dao.impl;

import cn.ljh.app.dao.UserDao;
import cn.ljh.app.domain.User;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;


//@Repository 注解里面有贴 @Component 注解，就是专门用于标注 Dao 组件的
//就是 test 那里要用Autowired注入这个UserDao，那么就需要在这里添加这个@Repository注解
//就是为了让容器中有这个 userDao 组件
@Repository
public class UserDaoImpl implements UserDao
{
    //此处就需要使用 jdbcTemplate 来访问数据库了
    private JdbcTemplate jdbcTemplate;

    //通过参数构造器进行依赖注入
    public UserDaoImpl(JdbcTemplate jdbcTemplate)
    {
        this.jdbcTemplate = jdbcTemplate;
    }

    final RowMapper<User> rowMapper = new RowMapper<User>()
    {
        //该方法就负责将一行的结果集映射成指定的对象
        @Override
        public User mapRow(ResultSet resultSet, int i) throws SQLException
        {
            return new User(
                    resultSet.getInt("user_id"),
                    resultSet.getString("name"),
                    resultSet.getString("password"),
                    resultSet.getInt("age"));
        }
    };

    //根据id查询对象
    @Override
    public User findById(Integer id)
    {
        //rowMapper 负责将一行结果集转成对象
        User user = jdbcTemplate.queryForObject("select * from user_inf where user_id = ?", rowMapper, id);
        return user;
    }

    //添加对象
    @Override
    public int save(User user)
    {
        int update = jdbcTemplate.update("insert into user_inf values(null,?,?,?)",
                user.getName(), user.getPassword(), user.getAge());
        return update;
    }

    //根据id删除对象
    @Override
    public int removeById(Integer id)
    {
        int update = jdbcTemplate.update("delete from user_inf where user_id = ?", id);
        return update;
    }

    //修改
    @Override
    public int update(User user)
    {
        int update = jdbcTemplate.update("update user_inf set name = ? ,password = ? , age = ? where user_id = ?",
                user.getName(), user.getPassword(), user.getAge(), user.getId());
        return update;
    }

    //根据名称模糊查询
    @Override
    public List<User> findByNamePattern(String namePattern)
    {
        List<User> query = jdbcTemplate.query("select * from user_inf where name like ? ", rowMapper, namePattern);
        return query;
    }

    //根据年龄查询
    @Override
    public List<User> findByAgeGt(int startage)
    {
        //因为 User 对象里面的id，在数据库表里面的列名 是 user_id ,如果使用 user_id as id 查询，给个别名，
        //那么查出来的数据的列名id，就和User对象的属性id 对应上了，就是id和id名字对应上了，
        //之前查出来的数据显示的是user_id ，现在给个别名变成id，就不需要再使用这个 rowMapper 来封装了
        List<User> query = jdbcTemplate.query("select user_id as id , name , password ,age from user_inf where age > ?",
                //把结果集映射成 User 类型
                new BeanPropertyRowMapper(User.class),
                startage);
        return query;
    }
}
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

UserDaoTest

package cn.ljh.app;

import cn.ljh.app.dao.UserDao;
import cn.ljh.app.domain.User;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

/**
 * author JH
 */
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)
public class UserDaoTest
{
    @Autowired
    private UserDao userDao;
    
    //根据id查找 User 对象
    @ParameterizedTest
    @ValueSource(ints = {2, 3, 5})
    public void testFindById(Integer id)
    {
        User user = userDao.findById(id);
        System.err.println(user);
    }
    
    //添加对象
    @ParameterizedTest
    @CsvSource({"ljh,123,25", "jh,12,26"})
    public void testSave(String name, String password, int age)
    {
        User user = new User(null, name, password, age);
        int save = userDao.save(user);
    }

    //删除
    @ParameterizedTest
    @ValueSource(ints = {11, 12})
    public void testRemove(Integer id)
    {
        int i = userDao.removeById(id);
    }
    
    //修改
    @ParameterizedTest
    @CsvSource({"1,孙悟空ZZZ,54321,505"})
    public void testUpdate(Integer id,String name, String password, int age)
    {
        int update = userDao.update(new User(id, name, password, age));
    }

    //根据名字进行模糊查询
    @ParameterizedTest
    @ValueSource(strings = {"孙%","%精"})
    public void testFindByNamePattern(String namePattern)
    {
        List<User> users = userDao.findByNamePattern(namePattern);
        users.forEach(System.err::println);
    }

    //根据年龄进行查询
    @ParameterizedTest
    @ValueSource(ints = {10,500})
    public void testFindByAgeGt(int startage)
    {
        List<User> users = userDao.findByAgeGt(startage);
        users.forEach(System.err::println);
    }
}
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
70
71
72
73

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
    </parent>
    <groupId>cn.ljh</groupId>
    <artifactId>jdbc</artifactId>
    <version>1.0.0</version>
    <name>jdbc</name>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <!--  添加这个依赖，springboot就会帮我们创建一个datasource的数据源的连接，
           并且会在容器中部署一个叫做 JdbcTemplate，
            所以userDao组件才能依赖注入这个jdbcTemplate对象-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

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