【Spring5】使用JdbcTemplate操作mysql数据库

---

---

1 JdbcTemplate简介及操作准备

Spring框架对JDBC进行封装，使用JdbcTemplate方便对数据库的操作。

操作准备：

1.导入相关依赖，文末附下载链接。

2.创建数据库，便于使用。以在mysql数据库中创建user_db为例。

3.配置xml文件，添加数据库连接相关信息，如密码用户名等。（连接池的配置）

4.配置JdbcTemplate对象，注入DataSource。

5.创建一个Service类，创建Dao类，在Dao类中注入jdbcTemplate对象。需要开启组件扫描，完整的spring配置文件如下：

<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"
       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">
    
    <context:component-scan base-package="com.ithxh.spring5">context:component-scan>


    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db"/>
        <property name="username" value="root"/>
        <property name="password" value="111"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    bean>

    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        
        <property name="dataSource" ref="dataSource">property>
    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

6.在各类上添加对应的注解。

至此，准备工作就完成啦！

---

2 添加操作

1.在user_db数据库中创建t_user表，sql语句如下：

CREATE TABLE t_user(
    user_id BIGINT PRIMARY KEY NOT NULL ,
    username VARCHAR(100) NOT NULL ,
    ustatus VARCHAR(50) NOT NULL
)
1
2
3
4
5

2.新建一个包entity用于存放实体类，创建t_user表对应的实体类User，并添加相应的set、get方法。

3.编写service和dao，在dao中进行数据库的添加操作。 UserDao接口声明add方法，UserService进行添加操作，而 UserDaoImp具体实现数据库的添加操作。 需要使用jdbcTemplate的update方法。

第一个参数为编写的sql语句，第二个参数为可变参数，用于设置值。

具体代码如下：
UserDao

import com.ithxh.spring5.entity.User;

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 */
public interface UserDao {
    void add(User user);
}
1
2
3
4
5
6
7
8
9

UserDaoImp

import com.ithxh.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 */
@Repository
public class UserDaoImp implements UserDao{

    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //实现添加的方法
    @Override
    public void add(User user) {
        //编写sql语句
        String sql = "insert into t_user values(?,?,?)";
        //调用方法实现
        Object[] args = {user.getUserId(), user.getUsername(), user.getUstatus()};
        int update = jdbcTemplate.update(sql, args);//返回影响行数
        System.out.println("影响的行数: " + update);
    }
}
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

UserService

import com.ithxh.spring5.dao.UserDao;
import com.ithxh.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 */
@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //添加的方法
    public void addUser(User user){
        userDao.add(user);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4.编写测试类，尝试给表添加数据。

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        User user = new User();
        user.setUserId("120");
        user.setUsername("黄小黄");
        user.setUstatus("true");
        userService.addUser(user);
    }
1
2
3
4
5
6
7
8
9
10
11

---

3 修改与删除操作

修改与删除操作大体与添加操作一致，只需要修改相应的sql语句。这里对核心代码进行简述：

修改和删除操作

UserDaoImp中实现修改和删除的方法

    //实现修改的方法
    @Override
    public void update(User user) {
        String sql = "update t_user set user_id = ?, username = ?, ustatus = ?";
        Object[] args = {user.getUserId(), user.getUsername(), user.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println("影响的行数: " + update);
    }

    //实现删除的方法
    @Override
    public void delete(String id) {
        String sql = "delete from t_user where user_id = ?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

需要注意，UserDao应该对修改和删除方法进行声明，UserService中则需要像这样，调用UserDaoImp中的方法：

测试修改：

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        User user = new User();
        user.setUserId("111");
        user.setUsername("懒羊羊");
        user.setUstatus("true");
        userService.updateUser(user);
    }
1
2
3
4
5
6
7
8
9
10
11

测试删除：

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        String id = "111";
        userService.deleteUser(id);
    }
1
2
3
4
5
6
7
8

---

4 数据库查询操作

4.1 返回一个值

示例：查询表中有多少条记录，返回的是一个值，表示表中数据的条数

    //查询有多少条记录
    @Override
    public int findCountUser() {
        String sql = "select count(*) from t_user";
        Integer res = jdbcTemplate.queryForObject(sql, Integer.class);//第二个参数是返回值类型
        return res;
    }
1
2
3
4
5
6
7

4.2 返回对象

示例：查询用户详细信息。

通过jdbcTemlate中的queryForObject方法实现：

• 第一个参数：sql语句；
• 第二个参数：RowMapper，是一个接口，返回不同类型的数据，使用这个接口的实现类完成数据的封装。
• 第三个参数：sql语句值。

首先先在数据库中t_user表插入如下信息：

INSERT INTO t_user VALUES (111, '黄小黄', 'true');
INSERT INTO t_user VALUES (222, '懒羊羊', 'true');
1
2

在UserDao中声明，UserDaoImp中实现查询方法，UserService使用：

    //查询返回对象
    @Override
    public User findUserInfo(String id) {
        String sql = "select * from t_user where user_id = ?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
        return user;
    }
1
2
3
4
5
6
7

查询测试：

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        User one = userService.findOne("111");
        System.out.println(one);
    }
1
2
3
4
5
6
7
8

4.3 返回集合

与返回对象类似，这里以查询user信息为例，返回t_user中的所有记录

通过jdbcTemlate中的query方法实现：

• 第一个参数：sql语句；
• 第二个参数：RowMapper，是一个接口，返回不同类型的数据，使用这个接口的实现类完成数据的封装。
• 第三个参数：sql语句值（没有可以省略）。

在UserDao中声明，UserDaoImp中实现查询方法，UserService使用：

    //查询返回集合
    @Override
    public List<User> findAllUser() {
        String sql = "select * from t_user";
        List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
        return userList;
    }
1
2
3
4
5
6
7

测试并遍历：

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        List<User> userList = userService.findAll();
        for (User user :
                userList) {
            System.out.println(user);
        }
    }
1
2
3
4
5
6
7
8
9
10
11

---

5 批量操作

对表中多条记录进行操作，批量操作主要通过javaTemplate中的batchUpdate方法实现

• 第一个参数：sql语句；
• 第二个参数：List集合，添加多条记录数据。

5.1 批量添加与修改

UserDaoImp类中批量添加的代码如下：

    //批量添加
    @Override
    public void batchAddUser(List<Object[]> batchArgs) {
        String sql = "insert into t_user values(?,?,?)";
        int[] update = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println("影响的行数: " + update);
    }
1
2
3
4
5
6
7

测试类中批量添加：

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        //向表中添加三条记录
        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {1, "nezuko", "true"};
        Object[] o2 = {2, "dog", "true"};
        Object[] o3 = {3, "participant", "true"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        userService.batchAdd(batchArgs);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.2 批量修改与批量删除

批量修改与批量删除与批量添加类似，只需要更改相应的sql语句，这里只展示核心代码：

批量修改

    //批量修改
    @Override
    public void batchUpdate(List<Object[]> batchArgs) {
        String sql = "update t_user set username = ?, ustatus = ? where user_id = ?";
        int[] update = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println("影响的行数: " + Arrays.toString(update));
    }
1
2
3
4
5
6
7

批量删除

    //批量删除
    @Override
    public void batchDelete(List<Object[]> batchArgs) {
        String sql = "delete from t_user where user_id = ?";
        int[] update = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println("影响的行数: " + Arrays.toString(update));
    }
1
2
3
4
5
6
7

---

写在最后

 至此，使用JdbcTemplate进行数据库简单的增删改查操作已经讲解完了，下一节将会继续讲解有关事务的操作，JdbcTemplate实验相关环境依赖已经上传，下载链接附上：druid-1.1.9.jar+mysql-connector-java-8.0.29.jar等JdbcTempate操作资源