[Spring]Spring5 JdbcTemplate

最新推荐文章于 2022-06-27 21:15:44 发布
最新推荐文章于 2022-06-27 21:15:44 发布
阅读量562 收藏
点赞数
分类专栏： Spring 文章标签： spring java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47168123/article/details/123062644
版权

4.1 JdbcTemplate

JdbcTemplate 是 Spring JDBC 核心包（core）中的核心类，它可以通过配置文件、注解、Java 配置类等形式获取数据库的相关信息，实现了对 JDBC 开发过程中的驱动加载、连接的开启和关闭、SQL 语句的创建与执行、异常处理、事务处理、数据类型转换等操作的封装。我们只要对其传入SQL 语句和必要的参数即可轻松进行 JDBC 编程。

JdbcTemplate 的全限定命名为 org.springframework.jdbc.core.JdbcTemplate，它提供了大量的查询和更新数据库的方法，如下表所示。

方法说明
public int update(String sql, Object ... args)用于执行新增、更新、删除等语句；sql：需要执行的 SQL 语句；args 表示需要传入到 SQL 语句中的参数。
public <T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args)用于执行查询语句；sql：需要执行的 SQL 语句；rowMapper：用于确定返回的集合（List）的类型；args：表示需要传入到 SQL 语句的参数。
public <T> List<T> query(String sql, RowMapper<T> rowMapper, @Nullable Object... args)用于执行查询语句；sql：需要执行的 SQL 语句；rowMapper：用于确定返回的集合（List）的类型；args：表示需要传入到 SQL 语句的参数。
public int[] batchUpdate(String sql, List<Object[]> batchArgs, final int[] argTypes)用于批量执行新增、更新、删除等语句； sql：需要执行的 SQL 语句；argTypes：需要注入的 SQL 参数的 JDBC 类型；batchArgs：表示需要传入到 SQL 语句的参数。

4.1.1 实例

  1. 创建配置文件

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       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="close">
        <property name="url" value="jdbc:mysql://localhost:3306/user_db?useUnicode=true&amp;characterEncoding=UTF-8" />
        <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>

    <!--开启组件扫描-->
    <context:component-scan base-package="top.shiyiri.spring5" />
</beans>

  2. 创建 JavaBean

    package top.shiyiri.spring5.entity;

public class Book {

    private String userId;
    private String username;
    private String ustatus;

    public Book(String userId, String username, String ustatus) {
        this.userId = userId;
        this.username = username;
        this.ustatus = ustatus;
    }

    public Book() {
    }

    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;
    }

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

  3. 创建持久层类

    package top.shiyiri.spring5.dao;

import top.shiyiri.spring5.entity.Book;
import java.util.List;

public interface BookDao {
    void add(Book book);

    void updateBook(Book book);

    void deleteBook(String id);

    int selectCount();

    Book findBookInfo(String id);

    List<Book> findAllBook();

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

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

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

    package top.shiyiri.spring5.dao;

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 top.shiyiri.spring5.entity.Book;

import java.util.Arrays;
import java.util.List;

/**
 * @author Aunean
 * @date 2022/2/18 14:26
 */
@Repository
public class BookDaoImpl implements BookDao {

    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(Book book) {
        //1.创建SQL语句
        String sql = "insert into t_book values(?,?,?)";
        int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        System.out.println(update);
    }

    @Override
    public void updateBook(Book book) {
        //1.创建SQL语句
        String sql = "update t_book set username=?, ustatus=? where user_id = ?";
        int update = jdbcTemplate.update(sql, book.getUsername(), book.getUstatus(), book.getUserId());
        System.out.println(update);
    }

    @Override
    public void deleteBook(String id) {
        //1.创建SQL语句
        String sql = "delete from t_book where user_id = ?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

    //查询表记录数
    @Override
    public int selectCount() {
        String sql = "select count(*) from t_book";
        return jdbcTemplate.queryForObject(sql, Integer.class);
    }

    @Override
    public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id = ?";
        return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Book.class), id);
    }

    //返回对象集合
    @Override
    public List<Book> findAllBook() {
        String sql = "select * from t_book";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Book.class));
}

    @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));
    }

    @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));
    }

    @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));
    }
}

  4. service层

    package top.shiyiri.spring5.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import top.shiyiri.spring5.dao.BookDao;
import top.shiyiri.spring5.entity.Book;

import java.util.List;

/**
 * @author Aunean
 * @date 2022/2/18 14:25
 */
@Service
public class BookService {

    @Autowired
    private BookDao bookDao;

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

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

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

    //查询表记录数
    public int findCount() {
        return bookDao.selectCount();
    }

    //查询对象
    public Book findOne(String id) {
        return bookDao.findBookInfo(id);
    }

    //查询对象集合
    public List<Book> findList() {
        return bookDao.findAllBook();
    }

    //批量添加
    public void batchAdd(List<Object[]> batchArgs) {
        bookDao.batchAddBook(batchArgs);
    }

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

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

  5. 测试代码

    package top.shiyiri.spring5.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.shiyiri.spring5.entity.Book;
import top.shiyiri.spring5.service.BookService;

import java.util.ArrayList;
import java.util.List;

public class TestBook {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

    BookService bookService = context.getBean("bookService", BookService.class);
    @Test
    public void testAdd() {
        bookService.add(new Book("2", "python", "a"));
    }

    @Test
    public void testUpdate() {
        bookService.update(new Book("1", "Hadoop", "a"));
    }

    @Test
    public void testDelete() {
//        bookService.delete("1");

        int count = bookService.findCount();
        System.out.println(count);
    }

    @Test
    public void testFindOne() {
        Book count = bookService.findOne("1");
        System.out.println(count);
    }

    @Test
    public void testFindAll() {
        List<Book> list = bookService.findList();
//        System.out.println(list);
        list.forEach(System.out::println);
    }

    @Test
    public void testBatch() {
        ArrayList<Object[]> batch = new ArrayList<>();
        Object[] o1 = {"3", "java", "b"};
        Object[] o2 = {"4", "scala", "c"};
        Object[] o3 = {"5", "spring", "a"};
        batch.add(o1);
        batch.add(o2);
        batch.add(o3);

        bookService.batchAdd(batch);
    }

    @Test
    public void testBatchUpdateBook() {
        ArrayList<Object[]> batch = new ArrayList<>();
        Object[] o1 = {"java++", "b", "3"};
        Object[] o2 = {"scala++", "c", "4",};
        Object[] o3 = {"spring++", "a", "5",};
        batch.add(o1);
        batch.add(o2);
        batch.add(o3);

        bookService.batchUpdateBook(batch);
    }

    @Test
    public void testBatchDeleteBook() {
        ArrayList<Object[]> batch = new ArrayList<>();
        Object[] o1 = {"3"};
        Object[] o2 = {"4"};
        batch.add(o1);
        batch.add(o2);

        bookService.batchDelete(batch);
    }
}
Aunean
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringJdbcTemplate封装工具类
06-13
SpringJdbcTemplate封装工具包，包括规范model格式接口，封装SpringJdbcTemplate，实现分页，自适应多种数据库
Spring JdbcTemplate查询实例
最新发布
06-11
Spring JdbcTemplate查询实例
Spring 中的jdbcTemplate 封装对象
口袋里的小龙的专栏
04-20 1562
第一种方式 ：带参数的封装方式 Actor actor = this.jdbcTemplate.queryForObject( "select first_name, last_name from t_actor where id = ?", new Object[]{1212L}, new RowMapper() {
Spring框架对JDBC的简单封装 -- JDBCTemplate对象
DFT_CaiNiao的博客
09-12 122
IOC容器需要的jar包 commons-logging-1.1.3.jar spring-aop-4.0.0.RELEASE.jar //注解会使用到的包 spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.RELEASE.jar spring-core-4.0.0.RELEASE.jar spring-expression-4.0.0.RELEASE.jar MySQL驱动、C3P0jar包 c3p0-0.9.1.2.jar mysql-connect
Spring JDBC，JdbcTemplate对象(增删改，查询封装为自定义对象（或map或list）等操作)、BeanPropertyRowMapper
Alla
11-19 615
Spring JDBC使用时还是得用到上一篇博客的druip和它的JDBCUtils的配置的，只不过它那些获取pstmt对象和.close方法就可以不用写，就更加方便一点。 （传送门：上一篇博客）
java Spring JdbcTemplate 入门工具
02-24
帮助更多人上手java Spring JdbcTemplate操作数据库
Spring jdbcTemplate pom.xml
03-23
1.Spring4前 spring-jdbc包是独立的，4以后spring-jdbc 就已经没有了
spring-jdbcTemplate实例工程
04-21
spring-jdbcTemplate实例工程
spring的jdbcTemplate小案例
09-10
自己做的一个小案例，spring 的ioc小案例，你也可以去以下链接看文章讲解https://blog.csdn.net/zyqblog/article/details/82590003
JdbcTemplate【spring封装的jdbc】
sgt1020的博客
07-02 89
JdbcTemplate使用步骤 这个是spring提供的一个工具类 主要导入两个jar包spring-core和spring-jdbc 1.导入依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.2.9.RELEASE</version&gt
9.Spring对JDBC的封装
Lolita1997的博客
05-29 270
Spring框架对JDBC的简单封装。提供了一个JDBCTemplat对象简化JDBC的开发 * 步骤： 1. 导入jar包 2. 创建JdbcTemplate对象。依赖于数据源DataSource * JdbcTemplate template = new JdbcTemplate(ds); 3. 调用JdbcTemplate的方法来完成CRUD的操作 * update():执行DML语句。增、删、改语句 * queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作
Spring模板对象 -------- JDBCTemplate基本使用
учёба
10-14 512
JDBCTemplate基本使用 JdbcTemplate概述 它是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如: 操作关系型数据的JdbcTemplate和HibernateTemplate 操作nosq|数据库的RedisTemplate, 操作消息队列的JmsTemplate等等。 JdbcTemplate开发步骤 ①导入spring-jdbc和spring-tx坐标 spring-jdbc这个包内部封装了j
spring源码剖析（七）JdbcTemplate数据库封装原理解读
Fighter168的专栏
05-12 7636
spring数据库操作的封装原理解读。传统的jdbc被spring如何封装到了JdbcTemplate里面呢，让我一块去揭开这个封装的神秘面纱
Spring尚硅谷笔记: JdbcTemplate
Elamic的博客
06-27 295
什么是JdbcTemplateSpring框架对JDBC进行封装,使用JdbcTemplate方便实现对数据库操作准备工作(1)引入相关jar包 (2)在spring配置文件配置数据库连接池 (3)配置JdbcTemplate对象,注入DataSource (4)创建service类,创建dao类,在dao注入JdbcTemplate对象 JdbcTemplate操作数据库(添加)1.对应数据库创建实体类 2.编写service和dao在dao进行数据库添加操作 3.测试类 JdbcTemplat
Spring - 获取JDBCTemplate对象
你今天真好看呀
05-10 1833
1、JDBC与JDBCTemplate关系 Java程序员在以后的工作中很重要的一点就是得和数据库打交道，但是代码和数据库是两个不相干的。怎么使用代码对数据库进行操作呢,这个时候就用到JDBC。 JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。 而template,就是模板,是Spring框架为我们提供的.所以JDBCTemplate就是Spring对J
Java之JDBCTemplate——Spring对JDBC的封装
longool的博客
06-14 339
JDBCTemplate Spring-JDBCTemplate JDBCTemplate是Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发，我们只需定义sql语句和执行sql语句，不需要去申请连接，也不需要去释放资源，其内部已经帮我们做了资源的建立和释放。 （Template：模板） 步骤： 1、导入JDBCTemplate相关的jar包 2、创建JdbcTemplate对象。依赖于数据源DataSource 3、 调用JdbcTemplate的方法来完成CR
spring JdbcTemplate 在项目中的浅层（5个使用场景）封装 ...
weixin_34005042的博客
04-23 529
导读： 主要从4个方面来阐述，1：背景；2：思路；3：代码实现；4：使用 一：封装背景， 在做项目的时候，用的JPA ，有些复杂查询，比如报表用原生的JdbcTemplate ，很不方便，传参也不方便，如果参数多；需要增加分页功能，以及结果集自动转对像等5个常用功能，见第4节 下面两个图是开源测试管理软件 itest 的统计功能，因为SQL...
jdbctemplate spring boot
09-13
在Spring Boot中使用JdbcTemplate可以通过以下步骤： 第一步是引入spring-jdbc依赖。这个依赖会自动包含spring-jdbc和数据库驱动及数据库连接池依赖。 第二步是配置多数据源。如果只需要一个数据源，则Spring Boot...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值