spring5：JdbcTemplate

Posted 2023-03-29 _GGBond_

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了spring5：JdbcTemplate相关的知识，希望对你有一定的参考价值。

spring5（六）：JdbcTemplate

前言
一、 JdbcTemplate概述
二、准备工作
三、JdbcTemplate 操作数据库（添加）
四、JdbcTemplate 操作数据库（修改和删除）
五、JdbcTemplate 操作数据库（查询返回某个值）
六、JdbcTemplate 操作数据库（查询返回对象）
七、JdbcTemplate 操作数据库（查询返回集合）
八、JdbcTemplate 操作数据库（批量操作）
- 1、JdbcTemplate 实现批量修改操作
- 2、JdbcTemplate 实现批量删除操作

前言

本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！

一、 JdbcTemplate概述

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

二、准备工作

① 引入相关 jar 包

② 在 spring 配置文件配置数据库连接池

  <!-- 数据库连接池 -->
    <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="root" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>

③ 配置 JdbcTemplate 对象，注入 DataSource

<!-- JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

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

BookDao类

public interface BookDao 
    public void add();

BookDaoImpl类

@Repository
public class BookDaoImpl implements  BookDao

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void add()

Bookservice类

@Service
public class BookService 
    @Autowired
    private BookDao bookDao;

<context:component-scan base-package="dao,service"></context:component-scan>

三、JdbcTemplate 操作数据库（添加）

① 对应数据库创建实体类

public class Book 
    private String bookId;
    private String bookname;
    private String bstatus;


    @Override
    public String toString() 
        return "Book" +
                "bookId='" + bookId + '\\'' +
                ", bookname='" + bookname + '\\'' +
                ", bstatus='" + bstatus + '\\'' +
                '';
    

    public String getBookId() 
        return bookId;
    

    public void setBookId(String bookId) 
        this.bookId = bookId;
    

    public String getBookname() 
        return bookname;
    

    public void setBookname(String bookname) 
        this.bookname = bookname;
    

    public String getBstatus() 
        return bstatus;
    

    public void setBstatus(String bstatus) 
        this.bstatus = bstatus;
    

    @Override
    public boolean equals(Object o) 
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return Objects.equals(bookId, book.bookId) &&
                Objects.equals(bookname, book.bookname) &&
                Objects.equals(bstatus, book.bstatus);
    

    @Override
    public int hashCode() 
        return Objects.hash(bookId, bookname, bstatus);

② 编写 service 和 dao

（1）在 dao 进行数据库添加操作

（2）调用 JdbcTemplate 对象里面 update 方法实现添加操作

@Repository
public class BookDaoImpl implements  BookDao

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public int add(Book book) 
        String sql="insert t_book values(?,?,?)";
        int update = jdbcTemplate.update(sql,book.getBookId(),book.getBookname(),book.getBstatus());
       return update;

测试：

public class TestBook 
    @Test
    public void testAdd()
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookservice = context.getBean("bookService", BookService.class);
        Book book  = new Book("01","java","0");
        bookservice.add(book);

四、JdbcTemplate 操作数据库（修改和删除）

1、修改

@Override
public void updateBook(Book book) 
 String sql = "update t_book set username=?,ustatus=? where user_id=?";
 Object[] args = book.getUsername(), book.getUstatus(),book.getUserId();
 int update = jdbcTemplate.update(sql, args);
 System.out.println(update);

2、删除

@Override
public void delete(String id) 
   String sql = "delete from t_book where user_id=?";
   int update = jdbcTemplate.update(sql, id);
 System.out.println(update);

五、JdbcTemplate 操作数据库（查询返回某个值）

⭕ 查询表里面有多少条记录，返回是某个值
⭕ 使用 JdbcTemplate 实现查询返回某个值代码

有两个参数

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

代码演示：

@Override
public int selectCount() 
 String sql = "select count(*) from t_book";
 Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
 return count;

六、JdbcTemplate 操作数据库（查询返回对象）

⭕ 场景：查询图书列表分页…

⭕ 调用 JdbcTemplate 方法实现查询返回对象

⭕ 有三个参数

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

//查询返回对象
@Override
public Book findBookInfo(String id) 
 String sql = "select * from t_book where user_id=?";
 //调用方法
 Book book = jdbcTemplate.queryForObject(sql, new 
BeanPropertyRowMapper<Book>(Book.class), id);
 return book;

七、JdbcTemplate 操作数据库（查询返回集合）

⭕ 场景：查询图书列表分页…

⭕ 调用 JdbcTemplate 方法实现查询返回集合

⭕ 有三个参数

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

//查询返回集合
@Override
public List<Book> findAllBook() 
 String sql = "select * from t_book";
 //调用方法
 List<Book> bookList = jdbcTemplate.query(sql, new 
BeanPropertyRowMapper<Book>(Book.class));
 return bookList;

八、JdbcTemplate 操作数据库（批量操作）

⭕ 批量操作：操作表里面多条记录

⭕ JdbcTemplate 实现批量添加操作

⭕ 有两个参数

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

//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) 
 String sql = "insert into t_book values(?,?,?)";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));

//批量添加测试
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = "3","java","a";
Object[] o2 = "4","c++","b";
Object[] o3 = "5","MySQL","c";
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);

1、JdbcTemplate 实现批量修改操作

//批量修改
@Override
public void batchUpdateBook(List<Object[]> batchArgs) 
 String sql = "update t_book set username=?,ustatus=? where user_id=?";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));

//批量修改
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = "java0909","a3","3";
Object[] o2 = "c++1010","b4","4";
Object[] o3 = "MySQL1111","c5","5";
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);

//调用方法实现批量修改
bookService.batchUpdate(batchArgs);

2、JdbcTemplate 实现批量删除操作

//批量删除
@Override
public void batchDeleteBook(List<Object[]> batchArgs) 
 String sql = "delete from t_book where user_id=?";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));

//批量删除
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = "3";
Object[] o2 = "4";
batchArgs.add(o1);
batchArgs.add(o2);

//调用方法实现批量删除
bookService.batchDelete(batchArgs);

Spring 从入门到精通系列 11—— Spring 中的 JdbcTemplate

本文针对 Spring 中的 JdbcTemplate 进行了分析，并实现对数据库的操作。

在这里插入图片描述

文章目录

一、JdbcTemplate 概述

它是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。spring 框架为我们提供了很多的操作模板类。

操作关系型数据的：
jdbcTemplate
HibernateTemplate
操作 nosql 数据库的：
RedisTemplate
操作消息队列的：
JmsTemplate

JdbcTemplate在 spring-jdbc-5.0.2.RELEASE.jar 中，我们在导包的时候，除了要导入这个 jar 包
外，还需要导入一个 spring-tx-5.0.2.RELEASE.jar（它是和事务相关的），也可以在maven工程中也可以导入依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.14.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>

二、JdbcTemplate 对象的创建

在这里插入图片描述

通过源码我们发现除了默认构造函数之外，都需要提供一个数据源。既然有set方法，依据我们之前学过的依赖注入，我们可以在配置文件中配置这些对象。

三、JdbcTemplate 的应用

下面我们通过案例演示 JdbcTemplate 的应用，工程目录如下：
在这里插入图片描述

3.1 JdbcTemplate 的简单使用

public class JdbctemplateDemo1 {
    public static void main(String[] args) {
        //准备数据源
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/springdb");
        ds.setUsername("root");
        ds.setPassword("000000");


        //1. 创建jdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();

        jdbcTemplate.setDataSource(ds);

        //2. 执行操作
        jdbcTemplate.execute("insert into account(name, money) values('ccc',1000)");
    }
}

3.2 JdbcTemplate 的增删改查

public class JdbctemplateDemo2 {
    public static void main(String[] args) {
       //1. 获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2. 获取对象
        JdbcTemplate jt = ac.getBean("jdbcTemplate", JdbcTemplate.class);
        //3. 执行操作
        //增加
        jt.update("insert into account(name, money) values(?, ?)", "eee", 333f);
        //改
        jt.update("update account set name=?, money=? where id=?", "abc", 1234f, 6);
        //删除
        jt.update("delete from account where id = ?",6 );
        //查询所有
        List<Account> accounts = jt.query("select * from account where money > ?", newBeanPropertyRowMapper<Account>(Account.class), 500f);
        for(Account account:accounts){
            System.out.println(account);
        }
        //查询一个
        List<Account> accounts1 = jt.query("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class), 1);
        System.out.println(accounts1.isEmpty()?"没有内容":accounts1.get(0));
        //查询返回一行一列（使用聚合函数，但不加group by 子句）
        Integer count = jt.queryForObject("select count(*) from account where money > ?", Integer.class, 1000f);
        System.out.println(count);
    }
}

3.2 在 Spring 中应用 JdbcTemplate

3.2.1 编写 spring 的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!--配置账户的持久层-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

注意： 此时数据源还没有配置

3.2.1 配置数据源

配置数据源的方式有三种，分别是：

配置 C3P0 数据源
配置 DBCP 数据源
配置 Spring 内置数据源

1. 配置 C3P0 数据源

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
	<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdb"></property>
	<property name="user" value="root"></property>
	<property name="password" value="000000"></property>
</bean>

2. 配置 DBCP 数据源

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	<property name="url" value="jdbc:mysql://localhost:3306/springdb"></property>
	<property name="username" value="root"></property>
	<property name="password" value="000000"></property>
</bean>

3. 配置 Spring 内置数据源

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	<property name="url" value="jdbc:mysql://localhost:3306/springdb"></property>
	<property name="username" value="root"></property>
	<property name="password" value="000000"></property>
</bean>

3.2.3 持久层及其实现类

/**
 * 账户持久层接口
 */
public interface IAccountDao {

    /**
     * 根据id查询账户
     */
    Account findAccountById(Integer accountId);

    /**
     * 根据名称查询
     */
    Account findAccountByName(String accountName);

    /**
     * 更新账户
     */
    void updateAccount(Account account);
}

/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {

    private JdbcTemplate jdbcTemplate;

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

    public Account findAccountById(Integer accountId) {
        List<Account> accounts = jdbcTemplate.query("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class), accountId);
        return accounts.isEmpty()?null:accounts.get(0);
    }

    public Account findAccountByName(String accountName) {
        List<Account> accounts = jdbcTemplate.query("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), accountName);
        if(accounts.isEmpty()){
            return null;
        }
        if(accounts.size()>1){
            throw new RuntimeException("结果集不唯一");
        }
        return accounts.get(0);
    }

    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name = ? , money = ? where id = ?", account.getName(), account.getMoney(), account.getId());
    }
}

3.2.4 测试方法

public class JdbctemplateDemo3 {
    public static void main(String[] args) {
       //1. 获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2. 获取对象
        IAccountDao accountDao = ac.getBean("accountDao", IAccountDao.class);
        //3. 执行操作
        Account account = accountDao.findAccountById(1);
        System.out.println(account);
    }
}

测试结果如下：
在这里插入图片描述

本文针对 Spring 中的 JdbcTemplate 进行了分析，并实现对数据库的操作。如果大家对文章内容还存在一些疑问，欢迎大家在评论区留言哦~

以上是关于spring5：JdbcTemplate的主要内容，如果未能解决你的问题，请参考以下文章

Spring5框架笔记总结

Spring5源码解析-前奏：本地构建Spring5源码

Spring5学习笔记（14） — “Spring5 声明式事务管理”

Spring5学习笔记 — “Java项目引入Spring5（IDEA）”

尚硅谷Spring学习笔记-- Spring5新功能