Spring5之JdbcTemplate

最新推荐文章于 2023-10-05 14:15:39 发布
最新推荐文章于 2023-10-05 14:15:39 发布
阅读量851 收藏
点赞数
分类专栏： Spring5 文章标签： spring java jdbc 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cicci_/article/details/122125524
版权

Spring5 之 JdbcTemplate

概念

  • JdbcTemplate：JdbcTemplate 是 Spring 框架对 JDBC 进行的封装，使用 JdbcTemplate 方便实现对数据库的相关操作。

如何使用？

环境搭建

搭建步骤

  1. 引入相关 jar 包
  2. 在 Spring 配置文件中配置数据库连接池
  3. 配置 JdbcTemplate 对象，注入 DataSource
  4. 创建 service 类，创建 dao 类，在 dao 类中注入 jdbcTemplate 对象

具体实现

  • 1、引入相关 jar 包

    在这里插入图片描述

  • 2、在 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"
       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
">
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="clone">
        <property name="url" value="jdbc:mysql:///spring_test" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
</beans>

  • 3、配置 JdbcTemplate 对象，注入 DataSource

    <?xml version="1.0" encoding="UTF-8"?>
<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
">
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="clone">
        <property name="url" value="jdbc:mysql:///spring_test" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>

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

  • 4、创建 service 和 dao 类，在 dao 类中注入 JdbcTemplate 对象

    在配置文件中开启组件扫描（也可以使用配置类代替）

    <?xml version="1.0" encoding="UTF-8"?>
<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
">
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="clone">
        <property name="url" value="jdbc:mysql:///spring_test" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>

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

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

    一定要记得引入 context 名称空间

    service类：

    package com.laoyang.spring.service;

import com.laoyang.spring.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    /**
     * 注入 Dao
     */
    @Autowired
    private BookDao bookDao;
}

    dao类（接口 & 实现类）：

    package com.laoyang.spring.dao;

public interface BookDao {
}

    package com.laoyang.spring.dao;

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

@Repository
public class BookDaoImpl implements BookDao {
    /**
     * 注入 JdbcTemplate 对象
     */
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

新增操作

先提前准备好对应的数据库表：t_book

在这里插入图片描述

虽然表名的意思是 “图书”，但是这里大伙可以理解为 “用户”，就当作是用户表来使用就好了，实在看不下去的可以将表名和实体类这些都改成 user

  • 1、对数据库表创建实体类

    package com.laoyang.spring.entity;

/**
 * @ClassName Book
 * @Description： 用户类
 * @Author Laoyang
 * @Date 2021/12/20 20:04
 */
public class Book {
    /**
     * 用户id
     */
    private String userId;

    /**
     * 用户名称
     */
    private String username;

    /**
     * 用户状态
     */
    private String ustatus;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

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

    public String getUstatus() {
        return ustatus;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
}

  • 2、编写 service 和 dao（在 dao 进行数据库添加操作）

    BookService 类：

    package com.laoyang.spring.service;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    /**
     * 注入 Dao
     */
    @Autowired
    private BookDao bookDao;

    /**
     * 新增方法
     */
    public void addUser(Book book) {
        bookDao.add(book);
    }
}

    BookDao 接口：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;

public interface BookDao {
    /**
     * 添加用户
     * @param book
     */
    void add(Book book);
}

    BookDaoImpl 类：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao {
    /**
     * 注入 JdbcTemplate 对象
     */
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 添加用户
     * @param book
     */
    @Override
    public void add(Book book) {
        /*
         调用 jdbcTemplate 对象里面的 update(String sql, Object... args) 方法实现添加操作
         参数一：SQL 语句
         参数二：可变参数，设置 sql 中的语句值
         */

        // 1、创建 sql
        String sql = "insert into t_book values(?, ?, ?)";

        // 2、调用 update 方法实现
        Object[] books = {book.getUserId(), book.getUsername(), book.getUstatus()};
        int insert = jdbcTemplate.update(sql, books);
        // 可以将可变参数封装到数组里面在传到方法中，也可以直接将参数传到方法中
//        int insert = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        if (insert > 0) {
            System.out.println("新增成功！");
            return;
        }
        System.out.println("新增失败！");
    }
}

  • 3、测试效果

    package com.laoyang.spring.test;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import com.laoyang.spring.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JdbcTest {
    @Test
    public void testAddUser() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

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

        Book book = new Book();
        book.setUserId("1001");
        book.setUsername("Tom");
        book.setUstatus("A");
        bookService.addUser(book);
    }
}

    添加成功后就可以查看数据库表中的数据了

修改操作 & 删除操作

说明：因为增删改的方式都差不多，就是修改一下语句就好了，所以这里直接把修改和删除一起演示

基于上面的实体类完成这两个操作

  • 编写 service 和 dao（在 dao 进行数据库添加操作）

    BookService类：

    package com.laoyang.spring.service;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    /**
     * 注入 Dao
     */
    @Autowired
    private BookDao bookDao;

    /**
     * 新增方法
     */
    public void addBook(Book book) {
        bookDao.add(book);
    }

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

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

    BookDao 接口：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;

public interface BookDao {
    /**
     * 添加用户
     * @param book
     */
    void add(Book book);

    /**
     * 修改用户
     * @param book
     */
    void update(Book book);

    /**
     * 删除用户
     * @param userId
     */
    void delete(String userId);
}

    BookDaoImpl 类：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao {
    /**
     * 注入 JdbcTemplate 对象
     */
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 添加用户
     * @param book
     */
    @Override
    public void add(Book book) {
        /*
         调用 jdbcTemplate 对象里面的 update(String sql, Object... args) 方法实现添加操作
         参数一：SQL 语句
         参数二：可变参数，设置 sql 中的语句值
         */

        // 1、创建 sql
        String sql = "insert into t_book values(?, ?, ?)";

        // 2、调用 update 方法实现
        Object[] books = {book.getUserId(), book.getUsername(), book.getUstatus()};
        int insert = jdbcTemplate.update(sql, books);
        // 可以将可变参数封装到数组里面在传到方法中，也可以直接将参数传到方法中
//        int insert = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        if (insert > 0) {
            System.out.println("新增成功！");
            return;
        }
        System.out.println("新增失败！");
    }

    /**
     * 修改用户
     * @param book
     */
    @Override
    public void update(Book book) {
        String sql = "update t_book set username=?, ustatus=? where user_id=?";
        Object[] books = {book.getUsername(), book.getUstatus(), book.getUserId()};
        int update = jdbcTemplate.update(sql, books);
        if (update > 0) {
            System.out.println("修改成功！");
            return;
        }
        System.out.println("修改失败！");
    }

    /**
     * 删除用户
     * @param userId
     */
    @Override
    public void delete(String userId) {
        String sql = "delete from t_book where user_id = ?";
        int delet = jdbcTemplate.update(sql, userId);
        if (delet > 0) {
            System.out.println("删除成功！");
            return;
        }
        System.out.println("删除失败！");
    }
}

  • 测试效果

    package com.laoyang.spring.test;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import com.laoyang.spring.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JdbcTest {
	// 修改操作
    @Test
    public void testUpdateUser() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

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

        Book book = new Book();
        book.setUserId("1001");
        book.setUsername("Jerry");
        book.setUstatus("C");
        bookService.updateBook(book);
    }

	// 删除操作
    @Test
    public void testDeleteUser() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

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

查询操作（返回某个值）

案例：查询表中有多少个用户，返回的是某个值

  • 编写 service 和 dao（在 dao 进行数据库添加操作）
    BookService 类：

    package com.laoyang.spring.service;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    /**
     * 注入 Dao
     */
    @Autowired
    private BookDao bookDao;
    
    /**
     * 查询表中的用户总数
     */
    public int findCount() {
        return bookDao.selectCount();
    }
}

    BookDao 接口：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;

public interface BookDao {
    /**
     * 查询表中的用户总数
     */
    int selectCount();
}

    BookDaoImpl 类：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao {
    /**
     * 注入 JdbcTemplate 对象
     */
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 查询表中的用户总数
     */
    @Override
    public int selectCount() {
        /*
        调用 jdbcTemplate 对象里面的 queryForObject(String sql, Class<T> requiredType) 方法实现该操作
        参数一：sql 语句
        参数二：返回类型的 Class
         */

        String sql = "select count(user_id) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }
}

  • 测试效果

    package com.laoyang.spring.test;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import com.laoyang.spring.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JdbcTest {
    @Test
    public void testCount() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);
        int count = bookService.findCount();
        System.out.println("当前表中还有" + count + "个用户。");
    }
}

查询操作（返回对象）

案例：查询 id 为 1001 的用户详情

  • 因为需要查看对象数据，所以我们先给 Book 实体类编写一个 toString 方法

    package com.laoyang.spring.entity;

/**
 * @ClassName Book
 * @Description： 用户类
 * @Author Laoyang
 * @Date 2021/12/20 20:04
 */
public class Book {
    //...此处为了简便省略前面的配置

    @Override
    public String toString() {
        return "Book{" +
                "userId='" + userId + '\'' +
                ", username='" + username + '\'' +
                ", ustatus='" + ustatus + '\'' +
                '}';
    }
}

  • 编写 service 和 dao（在 dao 进行数据库添加操作）
    BookService 类：

    package com.laoyang.spring.service;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    /**
     * 注入 Dao
     */
    @Autowired
    private BookDao bookDao;
    
    /**
     * 查询 id 为 1001 的用户详情
     */
    public Book findBookByUserId(String userId) {
        return bookDao.findBookByUserId(userId);
    }
}

    BookDao 接口：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;

public interface BookDao {
    /**
     * 查询 id 为 1001 的用户详情
     */
    Book findBookByUserId(String userId);
}

    BookDaoImpl 类：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao {
    /**
     * 查询 id 为 1001 的用户详情
     */
    @Override
    public Book findBookByUserId(String userId) {
        /*
        调用 jdbcTemplate 对象里面的 queryForObject(String sql, RowMapper<T> rowMapper, Object... args) 方法实现该操作
        参数一：sql 语句
        参数二：rowMapper 是一个接口，针对返回不同类型的数据，使用这个接口里面的实现类完成数据封装
        参数三：可变参数
         */
        String sql = "select user_id, username, ustatus from t_book where user_id=?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), userId);
        if (book != null) {
            return book;
        }
        return null;
    }
}

  • 测试效果

    package com.laoyang.spring.test;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import com.laoyang.spring.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JdbcTest {
    @Test
    public void testBook() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);
        Book book = bookService.findBookByUserId("1001");
        System.out.println(book);
    }
}

查询操作（返回集合）

案例：查询所有用户信息

  • 编写 service 和 dao（在 dao 进行数据库添加操作）
    BookService 类：

    package com.laoyang.spring.service;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BookService {
    /**
     * 注入 Dao
     */
    @Autowired
    private BookDao bookDao;
    
    /**
     * 查询所有用户信息
     */
    public List<Book> findBookByAll() {
        return bookDao.findBookByAll();
    }
}

    BookDao 接口：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import java.util.List;

public interface BookDao {
    /**
     * 查询所有用户信息
     */
    List<Book> findBookByAll();
}

    BookDaoImpl 类：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;

@Repository
public class BookDaoImpl implements BookDao {
    /**
     * 注入 JdbcTemplate 对象
     */
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 查询所有用户信息
     */
    @Override
    public List<Book> findBookByAll() {
        /*
        调用 jdbcTemplate 对象里面的 query(String sql, RowMapper<T> rowMapper, Object... args) 方法实现该操作
        参数一：sql 语句
        参数二：rowMapper 是一个接口，针对返回不同类型的数据，使用这个接口里面的实现类完成数据封装
        参数三：可变参数，可选
         */
        String sql = "select user_id, username, ustatus from t_book";
        List<Book> books = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        if (!books.isEmpty()) {
            return books;
        }
        return null;
    }
}

  • 测试效果

    package com.laoyang.spring.test;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import com.laoyang.spring.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.Arrays;
import java.util.List;

public class JdbcTest {
    @Test
    public void testBookAll() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);
        List<Book> books = bookService.findBookByAll();
        System.out.println(books);
    }
}

批量新增操作

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

  • 编写 service 和 dao（在 dao 进行数据库添加操作）
    BookService 类：

    package com.laoyang.spring.service;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BookService {
    /**
     * 注入 Dao
     */
    @Autowired
    private BookDao bookDao;
    
    /**
     * 批量新增用户
     */
    public void addBooksInBulk(List<Object[]> books) {
        bookDao.addBooksInBulk(books);
    }
}

    BookDao 接口：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import java.util.List;

public interface BookDao {
    /**
     * 批量新增用户
     * @param books
     */
    void addBooksInBulk(List<Object[]> books);
}

    BookDaoImpl 类：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;

@Repository
public class BookDaoImpl implements BookDao {
    /**
     * 注入 JdbcTemplate 对象
     */
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 批量新增用户
     * @param books
     */
    @Override
    public void addBooksInBulk(List<Object[]> books) {
        /*
        调用 jdbcTemplate 对象里面的 batchUpdate(String sql, List<Object[]> batchArgs) 方法实现该操作
        参数一：sql语句
        参数二：List集合，添加多条的数据
         */
        String sql = "insert into t_book values(?, ?, ?)";
        int[] adds = jdbcTemplate.batchUpdate(sql, books);
        if (adds != null && adds.length > 0) {
            System.out.println("批量添加成功！");
            return;
        }
        System.out.println("批量添加失败！");
    }
}

  • 测试效果

    package com.laoyang.spring.test;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import com.laoyang.spring.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JdbcTest {
    @Test
    public void testAddBooks() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> bookList = new ArrayList<>();
        Object[] bookArray1 = {"1003", "Mel", "C"};
        Object[] bookArray2 = {"1004", "Jack", "B"};
        bookList.add(bookArray1);
        bookList.add(bookArray2);

        bookService.addBooksInBulk(bookList);
    }
}

批量修改 & 批量删除

  • 编写 service 和 dao（在 dao 进行数据库添加操作）
    BookService 类：

    package com.laoyang.spring.service;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class BookService {
    /**
     * 注入 Dao
     */
    @Autowired
    private BookDao bookDao;
    
    /**
     * 批量修改用户
     */
    public void updateBooksInBulk(List<Object[]> books) {
        bookDao.updateBooksInBulk(books);
    }

    /**
     * 批量删除用户
     */
    public void deleteBooksInBulk(List<Object[]> userIds) {
        bookDao.deleteBooksInBulk(userIds);
    }
}

    BookDao 接口：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import java.util.List;

public interface BookDao {
    /**
     * 批量修改用户
     */
    void updateBooksInBulk(List<Object[]> books);

    /**
     * 批量删除用户
     */
    void deleteBooksInBulk(List<Object[]> userIds);
}

    BookDaoImpl 类：

    package com.laoyang.spring.dao;

import com.laoyang.spring.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;

@Repository
public class BookDaoImpl implements BookDao {
    /**
     * 注入 JdbcTemplate 对象
     */
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    /**
     * 批量修改用户
     */
    @Override
    public void updateBooksInBulk(List<Object[]> books) {
        String sql = "update t_book set username = ?, ustatus = ? where user_id = ?";
        int[] updates = jdbcTemplate.batchUpdate(sql, books);
        if (updates != null && updates.length > 0) {
            System.out.println("批量修改成功！");
            return;
        }
        System.out.println("批量修改失败！");
    }

    /**
     * 批量删除用户
     */
    @Override
    public void deleteBooksInBulk(List<Object[]> userIds) {
        String sql = "delete from t_book where user_id = ?";
        int[] deletes = jdbcTemplate.batchUpdate(sql, userIds);
        if (deletes != null && deletes.length > 0) {
            System.out.println("批量删除成功！");
            return;
        }
        System.out.println("批量删除失败！");
    }
}

  • 测试效果

    package com.laoyang.spring.test;

import com.laoyang.spring.dao.BookDao;
import com.laoyang.spring.entity.Book;
import com.laoyang.spring.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JdbcTest {
    @Test
    public void testUpdateBooks() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> bookList = new ArrayList<>();
        Object[] bookArray1 = {"Ronaldinho", "A", "1003"};
        Object[] bookArray2 = {"lamb", "A", "1004"};
        bookList.add(bookArray1);
        bookList.add(bookArray2);

        bookService.updateBooksInBulk(bookList);
    }

    @Test
    public void testDeleteBooks() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> bookList = new ArrayList<>();
        Object[] bookArray1 = {"1003"};
        Object[] bookArray2 = {"1004"};
        bookList.add(bookArray1);
        bookList.add(bookArray2);

        bookService.deleteBooksInBulk(bookList);
    }
}
万能的小白。
关注
专栏目录
Spring--JdbcTemplate.pdf
01-02
JdbcTemplate是Spring中常用的持久层技术之一，它支持Spring的声明式事务管理，能够与Spring的其他框架组件无缝整合。 描述中提到的"一图详解(脑图)"意味着文档中可能包含了一个清晰的图示，这个图示将详细展示...
Spring5-JdbcTemplate
qq_41070101的博客
08-31 228
JdbcTemplate(概念和准备) 什么是JdbcTemplate Spring 框架对JDBC 进行封装，使用JdbcTemplate方便实现对数据库操作 准备工作 引入相关的jar包 jdbc orm tx mysql bruid 在Spring 配置文件配置数据库连接池 <!-- 数据库连接池 --> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
Spring JDBC
qq_53529114的博客
03-27 209
Spring JDBC 1.概述 1.1 介绍 Spring框架对JDBC的简单封装。提供一个JDBCTemplate对象来简化JDBC开发 1.2 相关jar包 spring-beans-5.0.0.RELEASE.jar spring-core-5.0.0.RELEASE.jar spring-jdbc-5.0.0.RELEASE.jar spring-tx-5.0.0.RELEASE.jar 相关jar包下载：https://blog.csdn.net/qq_41821963/article/deta
Spring5 框架 JdbcTemplate(概念和准备)
qq_37138380的博客
04-13 298
1、什么是 JdbcTemplate （1）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作 2、准备工作 （1）引入相关 jar 包 （2）在 spring 配置文件配置数据库连接池 <!-- 数据库连接池 --> <!-- 数据库连接池 -- <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-m.
Spring5框架六：JdbcTemplate
开发者
04-27 200
JdbcTemplate 一、概述 定义 Spring框架对于JDBC的封装，更方便与对数据库的CURD 所依赖的jar包 在spring配置文件内配置数据库连接及创建JdbcTemplate对象 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XM
【spring5】-【JdbcTemplate】
CaraYQ的博客
07-03 232
JdbcTemplate：Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作一、引入相关jar包： 当然，你也可以将上面这些配置写在property配置文件中，然后在spring配置文件中通过表达式取值 三、在spring配置文件中配置JdbcTemplate对象，注入DataSource 四、创建service类，创建dao类及其实现类： 使用注解实现在service类中注入dao，在dao中注入jdbcTemplate对象。..................
Spring JdbcTemplate查询实例
最新发布
06-11
Spring JdbcTemplate是Spring框架中用于简化数据库操作的一个重要组件，它是Spring对JDBC的轻量级封装，旨在提供一种结构良好、易于使用的SQL执行机制，同时保持了JDBC的灵活性。在本实例中，我们将深入探讨Spring ...
spring-jdbcTemplate实例工程
04-21
《深入解析Spring JdbcTemplate》 Spring JDBC Template是Spring框架中用于简化JDBC操作的一个核心组件，它是Spring对JDBC API的封装，旨在提供一个更加简洁、健壮且可测试的数据库访问层。在这个实例工程中，我们...
spring的jdbcTemplate小案例
09-10
在本文中，我们将深入探讨Spring框架中的一个核心组件——JdbcTemplate。JdbcTemplate是Spring提供的一种数据库操作工具，它简化了数据库访问，使开发者能够编写出更健壮、更易于维护的代码，避免了手动处理JDBC连接...
Spring笔记之整合JdbcTemplate.doc
03-23
### Spring与JdbcTemplate整合详解 #### 一、JdbcTemplate简介及使用 **1.1 JdbcTemplate概述** JdbcTemplate是Spring框架中的一个重要组成部分，它提供了一种简单而强大的方式来访问数据库，通过封装JDBC API，...
Spring SimpleJdbcTemplate教程
萌萌的It人 www.itmmd.com
07-22 9745
SimpleJdbcTemplate类也是基于JdbcTemplate类，但利用Java5+的可变参数列表和自动装箱和拆箱从而获取更简洁的代码。SimpleJdbcTemplate主要提供两类方法：query及queryForXXX方法、update及batchUpdate方法。首先让我们看个例子吧： java代码：Java代码  //定义UserModel的RowMapper  package
Spring之SimpleJdbcTemplate的使用
Stay hungry, Stay foolish
08-10 4323
转： http://1194867672-qq-com.iteye.com/blog/1291025 1.数据库脚本 Sql代码   create table user   (       id      int not null,       name    varchar(20),       primary key(id)   );  
Spring5——JdbcTemplate介绍
仰望与追逐的博客
08-10 518
Spring5——JdbcTemplate介绍1、JdbcTemplate(概念和准备)2、JdbcTemplate 操作数据库（添加）3、JdbcTemplate 操作数据库（修改和删除）4、JdbcTemplate 操作数据库（查询返回某个值）5、JdbcTemplate 操作数据库（查询返回对象）6、JdbcTemplate 操作数据库（查询返回集合）7、JdbcTemplate 操作数据库（批量操作） 1、JdbcTemplate(概念和准备) 1、什么是 JdbcTemplate （1）Sprin
Spring5之JdbcTemplate基本使用详解
weixin_38568503的博客
03-13 246
1.概念： 2.JdbcTemplate案例： （1）引入jar jdbc的jar （2）spring配置文件的编写,配置数据库连接池，配置jdbcTemplate对象，注入DataSource: （3）创建service实现类，创建dao类，在dao类注入jdbcTemplate对象。 （4）利用jdbc模板对数据库进行增删改查操作： （4.1）添加修改删除都是使用update方法： 代码： （4.2）查询记录数： 查询单个对象： 查询返回对象集合： 批量添加： 批量修改：类似
[Spring] Spring5——JdbcTemplate 简介
joyride_run的博客
10-05 218
Spring 框架对 JDBC 进行封装，形成一个 Spring 风格的模板，使用 JdbcTemplate 方便实现对数据库操作。
找不到符号:SimpleJdbcTemplate
qq_24872197的博客
12-13 2755
找不到类SimpleJdbcTemplate背景想编译个web应用，原来spring-jdbc.jar用的是Spring 3.1，今天改成用Spring 4.3，报了这个错误。现象编译不通过，报错如下：Error:(19, 44) java: 找不到符号 符号: 类 SimpleJdbcTemplate 位置: 程序包 org.springframework.jdbc.core.simp
Spring中SimpleJdbcTemplate的用法实例（三）
lehsyh的专栏
07-06 576
一、简介 SimpleJdbcTemplate内部包含了一个NamedParameterJdbcTemplate，所以NamedParameterJdbcTemplate 能做的事情SimpleJdbcTemplate都能干，SimpleJdbcTemplate相对于NamedParameterJdbcTemplate主要 增加了JDK5.0的泛型技术和可变长度参数支持。   增加知识：（N...
Spring中SimpleJdbcTemplate和JdbcTemplate
吉祥小家
06-02 721
使用Spring的SimpleJdbcTemplate类实现jdbc为基础的DAO层： http://blog.csdn.net/samlei/article/details/5546379     spring jdbcTemplate使用： http://log-cd.iteye.com/blog/215059
Spring5——JDBCTemplate
友培的博客
09-26 181
文章目录JDBCTemplate1 JDBCTemplate?2 准备工作3 操作数据库3.1 增加3.2 修改+删除3.3 查询3.3.1 查询返回某个值3.3.2 查询返回对象3.3.3 查询返回集合3.4 批量操作3.4.1 批量增加3.4.2 批量修改+删除 JDBCTemplate 1 JDBCTemplate? （1）Spring框架对JDBC进行封装，使用JDBCTemplate方便实现对数据库操作 2 准备工作 （1）引入相关的jar包 （2）在spring配置文件中配置数据库连接池
Spring Boot整合JdbcTemplate实战指南
"本文将介绍如何在Spring Boot中使用JdbcTemplate，包括其基本概念、数据源配置、自动配置功能以及如何初始化数据库。" Spring Boot中的JdbcTemplate是Spring框架提供的一种简化JDBC操作的工具，它在Java数据库连接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值