SpringBoot中使用JdbcTemplate访问Oracle数据库

Oracle相信大家都不陌生吧，一个大型的数据库，至于数据库，我相信各位都比较熟悉了，一个软件系统，不论是我们常做的App、小程序、还是传统的web站点，我们都有用户的信息，相关业务的数据，通常都会存储在相关数据库中，比如：MySQL，Oracle，SQL server 等等。

在你看到这篇文章的时候，我相信你对Spring Boot已经有足够的了解了，我在这篇文档中将会采用Oracle数据库进行数据存储，PS:Oracle数据库和MySQL有语法差别，虽然总体是一样的，但是还是存在不一样的语法。

接下来我们正式开始：

JdbcTemplate

JdbcTemplate是Spring框架中的一个核心类，用于简化Java应用程序与关系型数据库的交互操作。它提供了一种简单而灵活的方式来执行SQL查询、更新和存储过程调用等数据库操作。

JdbcTemplate封装了一些常见的数据库操作，如查询单行或多行数据、插入、更新和删除数据等。它通过使用JDBC（Java Database Connectivity）来与数据库进行通信，并提供了一些方便的方法来处理结果集、处理异常以及执行事务操作。

使用JdbcTemplate可以减少编写重复的JDBC代码的工作量，提高开发效率。它还提供了一些高级功能，如命名参数、批处理操作和查询结果的映射等，使得数据库操作更加方便和易于维护。

数据源配置

在此，我说明一下，由于今年我写这篇文章的时候，发现Oracle11早已停止更新，Oracle 21的又是官网比较新的，故而我采用了Oracle 19c，如果你自己用的Oracle还是比较旧的版本， 请改为你所对应的版本，不同的版本，会有相应的差别：

		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-webartifactId>
		dependency>


		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-jdbcartifactId>
		dependency>

		<dependency>
			<groupId>mysqlgroupId>
			<artifactId>mysql-connector-javaartifactId>
		dependency>

		<dependency>
			<groupId>com.oracle.ojdbcgroupId>
			<artifactId>ojdbc8artifactId>
			<version>19.3.0.0version>
		dependency>

		<dependency>
			<groupId>org.projectlombokgroupId>
			<artifactId>lombokartifactId>
		dependency>

		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-testartifactId>
			<scope>testscope>
		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
27
28
29
30
31
32

接下来，在我们Spring Boot创建的src/main/resources/application.properties添加数据源信息。

# Mysql的配置
#spring.datasource.url=jdbc:mysql://localhost:3306/test
#spring.datasource.username=root
#spring.datasource.password=123456
#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver


# Oracle的配置
spring.datasource.url=jdbc:oracle:thin:@localhost:1521/orcl
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
1
2
3
4
5
6
7
8
9
10
11
12

PS: 在Spring Boot 2.x中默认采用MySQL 8的驱动，故而上边加了cj

使用JdbcTemplate操作数据库

Spring 的JdbcTemplate是自动配置的，我们可以使用@Autowried 或者构造函数，或者set方法来注入到我们想要的bean中使用。

我们在Oracle 中创建的数据库实际上就是我们创建的相关用户，我们利用我们创建的用户的账号和密码进行登录，然后再用户下创建表的。

以下是我创建了root用户后，然后利用root用户的账号密码进行登录创建的表的SQL语句

CREATE TABLE useradd (
  name varchar2 (100) NOT NULL,
  age integer NOT NULL
)
1
2
3
4

接下来，我们根据数据库中创建的表然后创建实体对象：

public class User {

    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public User() {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(name, user.name) && Objects.equals(age, user.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
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

创建相关接口

public interface UserService {

    /**
     * 新增一个用户
     *
     * @param name
     * @param age
     */
    int create(String name, Integer age);

    /**
     * 根据name查询用户
     *
     * @param name
     * @return
     */
    List<User> getByName(String name);

    /**
     * 根据name删除用户
     *
     * @param name
     */
    int deleteByName(String name);

    /**
     * 获取用户总量
     */
    int getAllUsers();

    /**
     * 删除所有用户
     */
    int deleteAllUsers();

}
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

之后，我们通过jdbcTemplate实现接口中的数据访问操作：

@Service
public class UserServiceImpl implements UserService {

    private JdbcTemplate jdbcTemplate;

    UserServiceImpl(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public int create(String name, Integer age) {
        return jdbcTemplate.update("insert into USERADD(NAME, AGE) values(?, ?)", name, age);
    }

    @Override
    public List<User> getByName(String name) {
        List<User> users = jdbcTemplate.query("select NAME, AGE from USERADD where NAME = ?", (resultSet, i) -> {
            User user = new User();
            user.setName(resultSet.getString("NAME"));
            user.setAge(resultSet.getInt("AGE"));
            return user;
        }, name);
        return users;
    }

    @Override
    public int deleteByName(String name) {
        return jdbcTemplate.update("delete from USERADD where NAME = ?", name);
    }

    @Override
    public int getAllUsers() {
        return jdbcTemplate.queryForObject("select count(1) from USERADD", Integer.class);
    }

    @Override
    public int deleteAllUsers() {
        return jdbcTemplate.update("delete from USERADD");
    }

}
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

然后我们采用Spring Boot的单元测试创建一个测试用例，通过创建，删除，以及查询来看我们是否正确的对数据库进行操作。

@RunWith(SpringRunner.class)
@SpringBootTest
public class Chapter31ApplicationTests {

    @Autowired
    private UserService userSerivce;

    @Before
    public void setUp() {
        // 准备，清空user表
        userSerivce.deleteAllUsers();
    }

    @Test
    public void test() throws Exception {
        // 插入5个用户
        userSerivce.create("miaow", 10);
        userSerivce.create("jjkeo", 11);
        userSerivce.create("cfase", 30);
        userSerivce.create("okeda", 21);
        userSerivce.create("joke", 17);

        // 查询名为Oscar的用户，判断年龄是否匹配
        List<User> userList = userSerivce.getByName("joke");
        Assert.assertEquals(17, userList.get(0).getAge().intValue());

        // 查数据库，应该有5个用户
        Assert.assertEquals(5, userSerivce.getAllUsers());

        // 删除两个用户
        userSerivce.deleteByName("jjkeo");
        userSerivce.deleteByName("cfase");

        // 查数据库，应该有5个用户
        Assert.assertEquals(3, userSerivce.getAllUsers());

    }

}
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

我们发现成功了，通过上面这个简单的例子，我们可以看到在Spring Boot下访问数据库的配置依然秉承了框架的初衷：简单。

我们只需要在pom.xml中加入数据库依赖，再到application.properties中配置连接信息，不需要像Spring应用中创建JdbcTemplate的Bean，就可以直接在自己的对象中注入使用。