Spring JdbcTemplate

最新推荐文章于 2020-11-20 10:29:49 发布
最新推荐文章于 2020-11-20 10:29:49 发布
阅读量95 收藏
点赞数
分类专栏： Spring 文章标签： jdbc spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45847167/article/details/108038951
版权

Spring 框架对 JDBC 进行了封装，使用 JdbcTemplate 方便实现对数据库操作。
新建一个maven工程，引入依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.23</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.21</version>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.0.0</version>
    <scope>compile</scope>
</dependency>

数据库脚本：

CREATE DATABASE /*!32312 IF NOT EXISTS*/`spring` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;

USE `spring`;

/*Table structure for table `user` */

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `status` varchar(20) DEFAULT NULL,
  `money` decimal(16,2) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8mb4;

spring配置文件（spring-config.xml）：

<?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="close">
        <property name="url" value="jdbc:mysql:///spring?serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="12345"/>
        <property name="driverClassName" value="com.mysql.cj.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.wushanghui"/>
</beans>

实体类

public class User {

    private BigInteger id;
    private String name;
    private String status;
    private BigDecimal money;

    public User(BigInteger id, String name, String status, BigDecimal money) {
        this.id = id;
        this.name = name;
        this.status = status;
        this.money = money;
    }

    public User(String name, String status, BigDecimal money) {
        this.name = name;
        this.status = status;
        this.money = money;
    }

    public User() {
    }

    public BigInteger getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getStatus() {
        return status;
    }

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

    public BigDecimal getMoney() {
        return money;
    }

    public void setMoney(BigDecimal money) {
        this.money = money;
    }

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

dao层：

public interface UserDao {

    public int add(User user);
    public int[] batchAdd(List<User> userList);
    public int update(User user);
    public int[] batchUpdate(List<User> userList);
    public int delete(BigInteger id);
    public int[] batchDelete(List<BigInteger> list);
    public User getOne(BigInteger id);
    public List<User> getAll();
    public int queryCount();
}

@Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public int add(User user) {
        String sql = "insert into user(name, status, money) values(?,?,?)";
        Object[] args = {user.getName(), user.getStatus(), user.getMoney()};
        return jdbcTemplate.update(sql, args);
    }

    @Override
    public int[] batchAdd(List<User> userList) {
        List<Object[]> list = new ArrayList<>();
        userList.forEach(u -> list.add(new Object[]{u.getName(), u.getStatus(), u.getMoney()}));
        String sql = "insert into user(name, status, money) values(?,?,?)";
        return jdbcTemplate.batchUpdate(sql, list);
    }

    @Override
    public int update(User user) {
        String sql = "update user set name = ?, status = ?, money = ? where id = ?";
        Object[] args = {user.getName(), user.getStatus(), user.getMoney(), user.getId()};
        return jdbcTemplate.update(sql, args);
    }

    @Override
    public int[] batchUpdate(List<User> userList) {
        String sql = "update user set name = ?, status = ?, money = ? where id = ?";
        List<Object[]> list = new ArrayList<>();
        userList.forEach(u -> list.add(new Object[]{u.getName(), u.getStatus(), u.getMoney(), u.getId()}));
        return jdbcTemplate.batchUpdate(sql, list);
    }

    @Override
    public int delete(BigInteger id) {
        String sql = "delete from user where id = ?";
        return jdbcTemplate.update(sql, id);
    }

    @Override
    public int[] batchDelete(List<BigInteger> ids) {
        String sql = "delete from user where id = ?";
        List<Object[]> list = new ArrayList<>();
        ids.forEach(i -> list.add(new Object[]{i}));
        return jdbcTemplate.batchUpdate(sql, list);
    }

    @Override
    public User getOne(BigInteger id) {
        String sql = "select * from user where id = ?";
        //调用方法
        return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), id);
    }

    @Override
    public List<User> getAll() {
        String sql = "select * from user";
        //调用方法
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
    }

    @Override
    public int queryCount() {
        String sql = "select count(*) from user";
        return jdbcTemplate.queryForObject(sql, Integer.class);
    }
}

service 层

public interface UserService {

    public int add(User user);
    public int[] batchAdd(List<User> userList);
    public int update(User user);
    public int[] batchUpdate(List<User> userList);
    public int delete(BigInteger id);
    public int[] batchDelete(List<BigInteger> list);
    public User getOne(BigInteger id);
    public List<User> getAll();
    public int queryCount();
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public int add(User user) {
        return userDao.add(user);
    }

    @Override
    public int[] batchAdd(List<User> list) {
        return userDao.batchAdd(list);
    }

    @Override
    public int update(User user) {
        return userDao.update(user);
    }

    @Override
    public int[] batchUpdate(List<User> userList) {
        return userDao.batchUpdate(userList);
    }

    @Override
    public int delete(BigInteger id) {
        return userDao.delete(id);
    }

    @Override
    public int[] batchDelete(List<BigInteger> list) {
        return userDao.batchDelete(list);
    }

    @Override
    public User getOne(BigInteger id) {
        return userDao.getOne(id);
    }

    @Override
    public List<User> getAll() {
        return userDao.getAll();
    }

    @Override
    public int queryCount() {
        return userDao.queryCount();
    }
}

测试类：

package top.wushanghui.main;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.wushanghui.entity.User;
import top.wushanghui.service.UserService;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {

    private UserService userService;

    {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-config.xml");
        userService = ctx.getBean(UserService.class);
    }

    /**
     * 单条数据添加
     */
    @Test
    public void testAdd() {
        int num = userService.add(new User("Tom", "0", new BigDecimal("1000")));
        System.out.println("新增个数：" + num);
    }

    /**
     * 批量添加
     */
    @Test
    public void testBatchAdd() {
        List<User> userList = new ArrayList<>();
        userList.add(new User("批量添加1", "0", new BigDecimal("1000")));
        userList.add(new User("批量添加2", "0", new BigDecimal("2000")));
        int[] ints = userService.batchAdd(userList);
        System.out.println("批量添加: " + Arrays.toString(ints));
    }

    /**
     * 单条数据更新
     */
    @Test
    public void testUpdate() {
        User user = new User(new BigInteger("7"), "Tom", "1", new BigDecimal("2000"));
        int num = userService.update(user);
        System.out.println("更新个数：" + num);
    }

    /**
     * 批量更新
     */
    @Test
    public void testBatchUpdate() {
        List<User> userList = new ArrayList<>();
        userList.add(new User(new BigInteger("8"), "批量添加1", "1", new BigDecimal("3000")));
        userList.add(new User(new BigInteger("9"), "批量添加2", "1", new BigDecimal("3000")));
        int[] ints = userService.batchUpdate(userList);
        System.out.println("批量更新: " + Arrays.toString(ints));
    }

    /**
     * 单条数据删除
     */
    @Test
    public void testDelete() {
        int delete = userService.delete(new BigInteger("7"));
        System.out.println("删除个数：" + delete);
    }

    /**
     * 批量数据删除
     */
    @Test
    public void testBatchDelete() {
        List<BigInteger> list = new ArrayList<>();
        list.add(new BigInteger("8"));
        list.add(new BigInteger("9"));
        int[] ints = userService.batchDelete(list);
        System.out.println("批量删除: " + Arrays.toString(ints));
    }

    /**
     * 获取单条数据
     */
    @Test
    public void testGetOne() {
        User user = userService.getOne(new BigInteger("9"));
        System.out.println(user);
    }

    /**
     * 获取全部数据
     */
    @Test
    public void testGetAll() {
        List<User> all = userService.getAll();
        System.out.println(all);
    }

    /**
     * 全部条数
     */
    @Test
    public void queryCount() {
        int count = userService.queryCount();
        System.out.println("num：" + count);
    }


}
逆流者blog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring JDBCTemplate
08-30
本篇文档主要介绍Spring JDBCTemplate知识。亦可作为Spring JDBCTemplate的API文档。文档中的内容，对于学习Spring JDBCTemplate有很大的帮助，也可帮助他人学习Spring Boot中的JDBCTemplate知识。
Spring JdbcTemplate查询实例
最新发布
06-11
Spring JdbcTemplate是Spring框架中用于简化数据库操作的一个重要组件，它是Spring对JDBC的轻量级封装，旨在提供一种结构良好、易于使用的SQL执行机制，同时保持了JDBC的灵活性。在本实例中，我们将深入探讨Spring ...
spring jdbcTemplate
11-01
《Spring JdbcTemplate 深入解析与实战应用》 在Java世界中，Spring框架以其强大的功能和灵活性，深受广大开发者的喜爱。其中，Spring JDBC Template是Spring提供的一个用于简化数据库操作的工具，它抽象了JDBC API...
Spring JDBCTemplate原理及使用实例
08-19
Spring JDBCTemplate 原理及使用实例 Spring JDBCTemplate 是 Spring 框架中的一部分，提供了对 JDBC 编程的支持，使得数据库操作变得更加简单和高效。下面将详细介绍 Spring JDBCTemplate 的原理和使用实例。 一...
Spring的JDBCTemplate
wyz191的专栏
03-15 273
本文引自：http://www.blogjava.net/176142998/archive/2009/02/03/221507.html Spring的JDBCTemplate 当hql等查询方式不能满足性能或灵活性的要求，必须使用SQL时，大家有三种选择： 第一、使用Hibernate 的sql 查询函数，将查询结果对象转为Entity对象。 第二、使用Hibernate Session的...
Spring中的JdbcTemplate
等不到的晴天的博客
06-19 136
JdbcTemplate快速入门 JdbcTemplate是Spring的一款用于简化Dao代码的工具包，它底层封装了JDBC技术，特点是简单、方便 核心对象 JdbcTemplate jdbcTemplate = new JdbcTemplate(DataSource dataSource); public class JdbcTemplateTest { public static void main(String[] args) { //创建数据源，即内置的数据库连接池
spring JdbcTemplate
charles_lau520
02-28 101
Spring 的JDBC模板方法 Spring 通过模板方法模式，帮助程序员完成资源创建，资源管理等固定的的工作。程序员可专注于编写sql语句，处理结果集 。 JDBCTemplate 有一个DataSource 类型的成员变量为其创建所需要的连接资源 。 JdbcTemplate t = new JdbcTemplate( DataSource ) ; t....
spring的JdbcTemplate
RestartJava的博客
06-04 81
spring的JdbcTemplate1. JdbcTemplate2. 如何创建JdbcTemplate3. JdbcTemplate的方法 1. JdbcTemplate 数据库的持久层 2. 如何创建JdbcTemplate 查看源码 public JdbcTemplate() { } public JdbcTemplate(DataSource dataSource) { this.setDataSource(dataSource); this.afterPro
JdbcTemplate_ 操作数据库(2)
17902的博客
11-20 229
JdbcTemplate 操作数据库（添加） 1、对应数据库创建实体类 public class User{ private String userId; private String username; private String ustatus; public void setUserId(String userId){ this.userId = userId; } public void setUsername(String username){ this username =
spring jdbctemplate
03-17
Spring JDBCTemplate是Spring框架中用于简化JDBC应用程序开发的类。它提供了对常用JDBC操作的封装，如执行SQL语句、查询数据库、执行存储过程等，使得开发人员不需要编写大量重复代码即可完成数据库操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值