Spring5笔记5之使用JdbcTemplate操作数据库

前言：这一部分有点无聊，查询、修改、删除数据的操作都是一样调用同一个方法，自己敲代码的时候感觉都是一直重复做一件事，都不用思考，真“码农”😂，感觉这一部分都可以不用实操，知道大概原理就行了。而且感觉好麻烦，还是用Mybatis和MybatisPlus好啊。

五、JdbcTemplate

5.1 概述和准备工作

5.1.1 概述

什么是 JdbcTemplate？Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

5.2.2 准备工作

1.引入jar包

<!--maven依赖-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.27</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.16</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.3.16</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.3.16</version>
</dependency>

2.在Spring配置文件中配置数据库连接池

<!--配置创建 DataSource 数据池对象-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/user_db"/>
    <property name="username" value="root" />
    <property name="password" value="root" />
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
</bean>

3.配置JdbcTemplate对象，注入DataSource

<!-- 配置创建 JdbcTemplate 对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入 dataSource-->
    <!--通过查看源码发现，JdbcTemplate继承自JdbcAccessor类，创建JdbcTemplate对象时会将DataSource对象通过有参构造传入，然后通过调用set方法来将传入的DataSource对象赋值给JdbcAccessor类中的DataSource类型属性-->
    <property name="dataSource" ref="dataSource"/>
</bean>

4.创建 service 类，dao 类，在 dao 注入 jdbcTemplate 对象

①配置开启组件扫描

<!-- 配置文件方式配置开启组件扫描 -->
<context:component-scan base-package="com.spring5"></context:component-scan>

②创建Service和Dao

使用注解方式创建Service对象和Dao对象

@Service
public class UserService {
    //注入dao
    @Autowired
    private UserDao userDao;
}

public interface UserDao {
    public void add(User user);
}

@Repository
public class UserDaoImpl implements UserDao {
    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

5.2 JdbcTemplate操作数据库

5.2.1 添加操作

1.创建实体类

//根据数据库表结构创建对应实体类
public class User {
    private Integer id;
    private String username;
    private String password;
    private String status;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", status='" + status + '\'' +
                '}';
    }
}

2.编写service和dao层添加用户的操作

@Service
public class UserService {
    //注入dao
    @Autowired
    private UserDao userDao;

    public void addUser(User user){
        userDao.add(user);
    }
}

@Repository
public class UserDaoImpl implements UserDao {
    //注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(User user) {
        //创建sql语句
        String sql = "insert into t_user values (?,?,?,?)";
        //调用方法实现
        Object[] args = {user.getId(),user.getUsername(),user.getPassword(),user.getStatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }
}

3.测试

@Test
    public void testJdbcTemplate() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        User user = new User();
        user.setId(1);
        user.setUsername("admin");
        user.setPassword("12345");
        user.setStatus("1");
        userService.addUser(user);
    }
//执行测试后可以发现数据库中被添加了一条新数据

5.2.2 修改删除操作

修改和删除操作基本均和添加操作一样

//在UserService中添加方法
public void updateUser(User user){
    userDao.update(user);
}

public void deleteUser(Integer id){
    userDao.delete(id);
}

//在UserDao中添加方法
@Override
public void update(User user) {
    //创建sql语句
    String sql = "update t_user set username=?,status=? where id=?";
    //调用方法实现
    Object[] args = {user.getUsername(), user.getStatus(), user.getId()};
    int update = jdbcTemplate.update(sql, args);
    System.out.println(update);
}
@Override
public void delete(Integer id) {
    //创建sql语句
    String sql = "delete from t_user where id=?";
    //调用方法实现
    int update = jdbcTemplate.update(sql, id);
    System.out.println(update);
}

测试代码

@Test
public void testJdbcTemplate1() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    User user = new User();
    user.setId(1);
    user.setUsername("admin1");
    user.setPassword("12345");
    user.setStatus("2");
    userService.updateUser(user);
}

@Test
public void testJdbcTemplate2() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.deleteUser(1);
}

5.2.3 查询操作

1.查询返回某个值

使用 JdbcTemplate 实现查询返回某个值代码queryForObject(String sql,Class<T> requiredType)

• 第一个参数：sql 语句
• 第二个参数：返回值类型 Class

//Service层添加方法
public int selectCount(){
    return userDao.selectCount();
}
//Dao层添加方法
@Override
public Integer selectCount() {
    String sql = "select count(*) from t_user";
    return jdbcTemplate.queryForObject(sql, Integer.class);
}

@Test
public void testJdbcTemplate3() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    System.out.println(userService.selectCount());//3
}

2.查询返回对象

使用JdbcTemplate方法实现查询返回集合queryForObject(String sql,RowMapper<T> rowMapper,Object... args)

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

//Service层添加方法
public User selectUser(Integer id){
    return userDao.selectUser(id);
}
//Dao层添加方法
@Override
public User selectUser(Integer id) {
    String sql = "select * from t_user where id = ?";
    return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
}

@Test
public void testJdbcTemplate4() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    System.out.println(userService.selectUser(2));//User{id=2, username='admin1', password='12345', status='2'}
}

3.查询返回列表

调用 JdbcTemplate 方法实现查询返回集合query(String sql,RowMapper rowMapper,Object... args)

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

//Service层添加方法
public List<User> selectAllUser(){
    return userDao.selectAllUser();
}
//Dao层添加方法
@Override
public List<User> selectAllUser() {
    String sql = "select * from t_user";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
}

@Test
public void testJdbcTemplate5() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    System.out.println(userService.selectAllUser());
    //[User{id=1, username='admin', password='12345', status='1'}, 
    //User{id=2, username='admin1', password='12345', status='2'}, 
    //User{id=3, username='admin2', password='12345', status='3'}]
}

5.3 JdbcTemplate批量操作

其实添加、修改、删除的操作都一样，都是调用batchUpdate(String sql,List<Object[]> batchArgs)方法，只是sql语句不一样...该方法返回的是一个int类型数组，保存的是添加每条数据的成功与否，成功则元素均为1

5.3.1 批量添加操作

使用JdbcTemplate中的batchUpdate(String sql,List<Object[]> batchArgs)实现批量添加操作

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

//Service层添加方法
public void batchAdd(List<Object[]> batchArgs){
    userDao.batchInsert(batchArgs);
}
//Dao层添加方法
@Override
public void batchInsert(List<Object[]> batchArgs) {
    String sql = "insert into t_user (username,password,status) values (?,?,?)";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
}
//测试
@Test
public void testJdbcTemplate6() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    List<Object[]> list = new ArrayList<>();
    Object[] o1 = {"admin3","12345","4"};
    Object[] o2 = {"admin4","12345","5"};
    Object[] o3 = {"admin5","12345","6"};
    list.add(o1);
    list.add(o2);
    list.add(o3);
    userService.batchAdd(list);
}

5.3.2 批量修改操作

使用JdbcTemplate中的batchUpdate(String sql,List<Object[]> batchArgs)实现批量修改操作

• 第一个参数：sql 语句
• 第二个参数：List 集合，修改多条记录数据

//Service层添加方法
public void batchUpdate(List<Object[]> batchArgs){
    userDao.batchUpdate(batchArgs);
}
//Dao层添加方法
@Override
public void batchUpdate(List<Object[]> batchArgs) {
    String sql = "update t_user set username=?,password=?,status=? where id=?";
    int[] update = jdbcTemplate.batchUpdate(sql, batchArgs);
}
//测试
@Test
public void testJdbcTemplate7() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    List<Object[]> list = new ArrayList<>();
    Object[] o1 = {"admin3+","123456","4+","4"};
    Object[] o2 = {"admin4+","123456","5+","5"};
    Object[] o3 = {"admin5+","123456","6+","6"};
    list.add(o1);
    list.add(o2);
    list.add(o3);
    userService.batchUpdate(list);
}

5.3.3 批量删除操作

使用JdbcTemplate中的batchUpdate(String sql,List<Object[]> batchArgs)实现批量删除操作

• 第一个参数：sql 语句
• 第二个参数：List 集合，删除多条记录数据

//Service层添加方法
public void batchDelete(List<Object[]> batchArgs){
    userDao.batchDelete(batchArgs);
}
//Dao层添加方法
@Override
public void batchDelete(List<Object[]> batchArgs) {
    String sql = "delete from t_user where id=?";
    int[] delete = jdbcTemplate.batchUpdate(sql, batchArgs);
}
//测试
@Test
public void testJdbcTemplate8() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    List<Object[]> list = new ArrayList<>();
    Object[] o1 = {4};
    Object[] o2 = {5};
    list.add(o1);
    list.add(o2);
    userService.batchDelete(list);
}