在Spring中使用JdbcTemplate进行数据库管理操作

源代码（IDEA可直接运行）：
https://github.com/KUANG-CHENG/Spring
JdbcTemplate文件夹

1.JdbcTemplate概念及使用

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

2.JdbcTemplate的准备（IDEA）

2.1 引入相关 jar 包

下载地址：https://download.csdn.net/download/Kc635908933/13799755

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

    <!--配置数据库连接池-->
    <bean id="dataSource1" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///userdb" /><!--数据库的地址-->
        <property name="username" value="root" /><!--用户名-->
        <property name="password" value="Kc635908933" /><!--密码-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <!--驱动名称-->
    </bean>

2.3 配置 JdbcTemplate 对象，注入 DataSource

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.spring"></context:component-scan>

    <!-- JdbcTemplate 对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入 dataSource-->
        <!--通过set方法注入-->
        <property name="dataSource" ref="dataSource1"></property><!--set方式注入-->
    </bean>

3.JdbcTemplate操作数据库（添加–update）

3.1 创建 相关类，在 dao 中注入 JdbcTemplate 对象

创建Book类（数据库实体类）：

package com.spring.entity;

// 数据库实体类
public class Book {
    
    
    private String id;
    private String bookname;
    private String bookauther;

    public String getId() {
    
    
        return id;
    }

    public String getBookname() {
    
    
        return bookname;
    }

    public String getBookauther() {
    
    
        return bookauther;
    }

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

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

    public void setBookauther(String bookauther) {
    
    
        this.bookauther = bookauther;
    }

    @Override
    public String toString() {
    
    
        return "Book{" +
                "id='" + id + '\'' +
                ", bookname='" + bookname + '\'' +
                ", bookauther='" + bookauther + '\'' +
                '}';
    }
}

创建 BookDao 接口：

public interface BookDao {
    
    
    void add(Book book);
}

创建 BookDaoImpl 类，实现BookDao接口：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao{
    
    

    // 注入JDBCTemplete
    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 添加的方法
    @Override
    public void add(Book book) {
    
    
        // 数据库增加、删除
        // 1.sql语句--在userdb数据库内的tb_books数据表上
        String sql="insert into tb_book values(?,?,?)";
        Object[] args={
    
    book.getUserid(),book.getUsername(),book.getUserpwd()};
        // 2.调用方法实现
        int update = jdbcTemplate.update(sql,args);
        System.out.println(update);
    }
}

创建 BookService 类：

@Service
public class BookService {
    
    

    // 注入Dao
    @Autowired
    private BookDao bookDao;

    // 添加方法
    public void addBook(Book book){
    
    
        bookDao.add(book);
    }
}

3.2 测试文件

在 userdb 数据库中，tb_book 表上添加 “6”，“hh”，“343242”

public class TestBook {
    
    
    public static void main(String[] args) {
    
    
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        Book book = new Book();
        book.setUserid("6");
        book.setUsername("hh");
        book.setUserpwd("343242");
        bookService.addBook(book);
    }
}

3.3 结果图

通过 JdbcTemplate 成功实现数据库的添加功能

4.JdbcTemplate操作数据库（修改和删除）

在BookService类中新建修改和删除方法

    // 修改的方法
    public void updateBook(Book book){
    
    
        bookDao.update(book);
    }

    // 删除的方法
    public void deleteBook(String id){
    
    
        bookDao.delete(id);
    }

BookDao接口：

    void update(Book book);
    void delete(String id);

BookDaoImpl实现类中重写方法：

    // 更新方法
    @Override
    public void update(Book book) {
    
    
        String sql="update tb_book set bookname=?, bookauther=? where id=?";
        Object[] args={
    
    book.getId(),book.getBookname(),book.getBookauther()};
        int update = jdbcTemplate.update(sql,args);
        System.out.println(update);
    }

    // 删减方法
    @Override
    public void delete(String id) {
    
    
        String sql="delete from tb_book where id=?";
        int update = jdbcTemplate.update(sql,id);
        System.out.println(update);
    }

TestBook测试类

        // 修改数据
        Book book = new Book();
        book.setId("10");
        book.setBookname("kc");
        book.setBookname("30");
        bookService.updateBook(book);

        // 删除数据
        bookService.deleteBook("8");

5.JdbcTemplate操作数据库（查询返回某个值、返回对象、返回集合）

BookService类新建查询方法：

    // 查询1-返回某个值  （查询表中记录数）
    public int findCount(){
    
    
        return bookDao.selectCount();
    }

    // 查询2-返回对象    (查询图书详情 )
    public Book findOne(String id){
    
    
        return bookDao.findBookInfo(id);
    }

    // 查询3-返回集合  （查询图书列表分页）
    public List<Book> findAll(){
    
    
        return bookDao.findAllBook();
    }

BookDao新建接口方法：

    int selectCount();
    Book findBookInfo(String id);
    List<Book> findAllBook();

BookDaoImpl具体实现查询方法：

    // 查询方法1-返回某个值
    @Override
    public int selectCount() {
    
    
        String sql = "select count(*) from tb_book";
        int count = jdbcTemplate.queryForObject(sql,Integer.class);
        return count;
    }

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

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

TestBook测试方法：

        // 查询1
        int count = bookService.findCount();
        System.out.println(count);

        // 查询2
        Book book = bookService.findOne("66");
        System.out.println(book);

        // 查询3
        List<Book> all = bookService.findAll();
        System.out.println(all);

6.JdbcTemplate实现批量操作（批量添加、批量修改、批量删除）

BookService类新建查询方法：

    // 批量添加--数组形式
    // batchArgs--批量指令
    public void batchAdd(List<Object[]> batchArgs){
    
    
        bookDao.batchAddBook(batchArgs);
    }

    // 批量修改
    public void batchUpdate(List<Object[]> batchArgs){
    
    
        bookDao.batchUpdateBook(batchArgs);

    }
    // 批量删除
    public void batchDelete(List<Object[]> batchArgs){
    
    
        bookDao.batchDeleteBook(batchArgs);
    }

BookDao新建接口方法：

    void batchAddBook(List<Object[]> batchArgs);
    void batchUpdateBook(List<Object[]> batchArgs);
    void batchDeleteBook(List<Object[]> batchArgs);

BookDaoImpl具体实现查询方法：

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

    // 批量修改
    @Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
    
    
        String sql = "update tb_book set bookname=?, bookauther=? where id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

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

TestBook测试方法：

       // 批量添加
        List<Object[]> batchArgs = new ArrayList<>(); // 数组形式
        Object[] o1 = {
    
    "3","java","c++"};
        Object[] o2 = {
    
    "4","nba","ncaa"};
        Object[] o3 = {
    
    "5","ball","mysql"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchAdd(batchArgs);

        // 批量修改
        List<Object[]> batchArgs = new ArrayList<>(); // 数组形式
        Object[] o1 = {
    
    "java","111","3"};
        Object[] o2 = {
    
    "nba","222","4"};
        Object[] o3 = {
    
    "ball","333 ","5"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchUpdate(batchArgs);

        // 批量删除
        List<Object[]> batchArgs = new ArrayList<>(); // 数组形式
        Object[] o1 = {
    
    "3"};
        Object[] o2 = {
    
    "4"};
        Object[] o3 = {
    
    "5"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchDelete(batchArgs);