Spring使用JdbcTemplate操作数据库附源码解释

news/2024/5/19 1:22:43 标签: spring, 数据库, java, jdbc, 架构师

目录

1.JdbcTemplate概述

2.JdbcTemplate准备工作

  • 引入相关 jar 包
  • 如果是maven项目，使用pom.xml代替引入jar包的过程（注意）
  • 配置xml配置文件

3.JdbcTemplate 操作数据库

  • 准备好数据库uset_db创建一个t_user表
  • 对应数据库创建User实体类
  • 创建UserDao接口并创建UserDaoImpl类
  • 创建UserService类并在其中注入UserDao
  • 编写测试类进行测试

4.JdbcTemplate源码解释

  • jdbcTemplate.update(增删改操作)
  • jdbcTemplate.queryForObject（返回记录条数）
  • jdbcTemplate.queryForObject（返回对象）
  • jdbcTemplate.query(返回对象集合)
  • jdbcTemplate.batchUpdate(批量操作)

JdbcTemplate概述

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

JdbcTemplate准备工作

引入相关 jar 包

Spring使用JdbcTemplate操作<a class=数据库附源码解释" src="https://img-blog.csdnimg.cn/img_convert/893955c4a671d8816639379b212b1ee6.png" />

如果是maven项目，使用pom.xml代替引入jar包的过程（注意）

pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.Keafmd</groupId>
    <artifactId>day04_eesy_01jdbctemplate</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>7</source>
                    <target>7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.9</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>


</project>
————————————————

maven项目的代码结构：

Spring使用JdbcTemplate操作<a class=数据库附源码解释" src="https://img-blog.csdnimg.cn/img_convert/3abe881c70f77ed5df60db40defd49bd.png" />

配置xml配置文件

在 spring 配置文件配置数据库连接池，配置 JdbcTemplate 对象，注入 DataSource。配置时用的是引用外部配置文件，所以还需要引入外部的属性文件，同时创建对象时是基于注解的所以还要开启组件扫描。

bean1.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:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       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/util http://www.springframework.org/schema/util/spring-util.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

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

    <!--引入外部的属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

        <property name="driverClassName" value="${jdbc.driverClass}"></property>
        <property name="url" value="${jdbc.url}" ></property>
        <property name="username" value="${jdbc.username}" ></property>
        <property name ="password" value="${jdbc.password}" ></property>

    </bean>

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

    </bean>

</beans>

jdbc.properties：

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/user_db?characterEncoding=utf8&useUnicode=true&useSSL=false
jdbc.username=root
jdbc.password=root

JdbcTemplate 操作数据库

相关的操作及注释都在代码中，请看代码。

准备好数据库uset_db创建一个t_user表

Spring使用JdbcTemplate操作<a class=数据库附源码解释" src="https://img-blog.csdnimg.cn/img_convert/223123864dc79bf7999d5857d7531914.png" />

对应数据库创建User实体类

User类：

package com.Keafmd.spring5.entity;

/**
 * Keafmd
 *
 * @ClassName: User
 * @Description: 数据库对应user实体类
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 10:07
 */

public class User {
    private String userId;
    private String username;
    private String ustatus;

    public User() {
    }

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

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

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

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

    public String getUserId() {
        return userId;
    }

    public String getUsername() {
        return username;
    }

    public String getUstatus() {
        return ustatus;
    }

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

创建UserDao接口并创建UserDaoImpl类

在UserDaoImpl内注入jdbcTemplate。

UserDao接口：

package com.Keafmd.spring5.dao;

import com.Keafmd.spring5.entity.User;

import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: UserDao
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 9:56
 */

public interface UserDao {

    //添加方法
    void add(User user);

    //修改方法
    void updateUser(User user);

    //删除方法
    void delete(String id);

    //查询记录数
    int selectCount();

    //查询返回对象
    User findUserInfo(String id);

    //查询集合
    List<User> findAllUser();

    //批量添加
    void batchAddUser(List<Object[]> batchArgs);

    //批量修改
    void batchUpdateUser(List<Object[]> batchArgs);
    
	//批量删除
    void batchDeleteUser(List<Object[]> batchArgs);
}

UserDaoImpl类：

package com.Keafmd.spring5.dao;

import com.Keafmd.spring5.entity.User;
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.Arrays;
import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: UserDaoImpl
 * @Description: UserDao实现类
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 9:56
 */
@Repository
public class UserDaoImpl implements UserDao {

    //注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;


    //添加的方法
    @Override
    public void add(User user) {
        //创建sql语句
        String sql=" INSERT INTO t_user (user_id, username, ustatus) VALUES (?, ?, ?) ";
        // 调用方法实行
        int updat = jdbcTemplate.update(sql,user.getUserId(),user.getUsername(),user.getUstatus());
        // 返回成功的条数
        System.out.println(updat);
    }
    //修改
    @Override
    public void updateUser(User user) {

        String sql = "UPDATE   user_db.t_user SET   username = ?,  ustatus = ? WHERE user_id = ?";
        Object[] args = {user.getUsername(),user.getUstatus(),user.getUserId()};
        int updat = jdbcTemplate.update(sql,args);
        System.out.println(updat);
    }
    //删除
    @Override
    public void delete(String id) {

        String sql ="DELETE FROM user_db.t_user WHERE user_id = ?";
        int updat = jdbcTemplate.update(sql,id);
        System.out.println(updat);
    }

    //查询记录数
    @Override
    public int selectCount() {
        String sql ="SELECT COUNT(*) FROM t_user";
        Integer count = jdbcTemplate.queryForObject(sql,Integer.class);
        return count;

    }

    //返回对象
    @Override
    public User findUserInfo(String id) {
        String sql ="SELECT * FROM t_user where user_id = ?";
        User user = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<User>(User.class),id);
        return user;
    }

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

    //批量添加
    @Override
    public void batchAddUser(List<Object[]> batchArgs) {
        String sql=" INSERT INTO t_user (user_id, username, ustatus) VALUES (?, ?, ?) ";
        int []ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    //批量修改
    @Override
    public void batchUpdateUser(List<Object[]> batchArgs) {
        String sql = "UPDATE   user_db.t_user SET   username = ?,  ustatus = ? WHERE user_id = ?";
        int []ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    //批量删除
    @Override
    public void batchDeleteUser(List<Object[]> batchArgs) {
        String sql ="DELETE FROM user_db.t_user WHERE user_id = ?";
        int []ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }
}

创建UserService类并在其中注入UserDao

UserService类：

package com.Keafmd.spring5.service;

import com.Keafmd.spring5.dao.UserDao;
import com.Keafmd.spring5.dao.UserDaoImpl;
import com.Keafmd.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: BookService
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 9:55
 */
@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //添加的方法
    public void addUser(User user){
        userDao.add(user);
    }

    //修改的方法
    public void updateUser(User user){
        userDao.updateUser(user);
    }


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

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

    //查询返回对象
    public User findOne(String id){
        return userDao.findUserInfo(id);
    }

    //查询返回集合
    public List<User> findAll(){
        return userDao.findAllUser();
    }

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

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

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

}

编写测试类进行测试

TestUser ：

package com.Keafmd.spring5.test;

import com.Keafmd.spring5.entity.User;
import com.Keafmd.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

/**
 * Keafmd
 *
 * @ClassName: TestUser
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 10:35
 */
public class TestUser {

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);

        //添加
        /*User user = new User("001","Keafmd","11");
        userService.addUser(user);*/

        //更新
        /*User user1 = new User("001","Keafmd","2");
        userService.updateUser(user1);*/

        //删除
        /*String id = "2";
        userService.deleteUser(id);*/

        //返回总条数
        int count = userService.findCount();
        System.out.println(count);

        // 返回对象
        User user = userService.findOne("1");
        System.out.println(user);

        // 返回集合对象

        List<User> userList =userService.findAll();
        System.out.println(userList);

        //批量添加
        /*List<Object[]> batchArgs = new ArrayList<>();
        Object[]o1 = {"7","77","7"};
        Object[]o2 = {"8","88","8"};
        Object[]o3 = {"9","99","9"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        userService.batchAdd(batchArgs);*/


        //批量修改
        /*List<Object[]> batchArgs = new ArrayList<>();
        Object[]o11 = {"tt","2","7"};
        Object[]o22 = {"uu","2","8"};
        Object[]o33 = {"ii","2","9"};
        batchArgs.add(o11);
        batchArgs.add(o22);
        batchArgs.add(o33);
        userService.batchUpdate(batchArgs);*/

        //批量删除
        List<Object[]> batchArgs = new ArrayList<>();
        Object[]o1 = {"7"};
        Object[]o2 = {"8"};
        Object[]o3 = {"9"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        userService.batchDelete(batchArgs);



    }
}

输出结果：

一月 19, 2021 4:05:28 下午 com.alibaba.druid.pool.DruidDataSource info
信息: {dataSource-1} inited
9
User{userId='1', username='Keafmd', ustatus='2'}
[User{userId='1', username='Keafmd', ustatus='2'}, User{userId='2', username='aa', ustatus='1'}, User{userId='3', username='bb', ustatus='1'}, User{userId='4', username='cc', ustatus='1'}, User{userId='5', username='dd', ustatus='1'}, User{userId='6', username='ee', ustatus='1'}, User{userId='7', username='tt', ustatus='2'}, User{userId='8', username='uu', ustatus='2'}, User{userId='9', username='ii', ustatus='2'}]
[1, 1, 1]

Process finished with exit code 0

Spring使用JdbcTemplate操作<a class=数据库附源码解释" src="https://img-blog.csdnimg.cn/img_convert/2652c36f212d9116cdc4228c61a64233.png" />

上面两行红色的是日志信息，不是报错，不用担心。

JdbcTemplate源码解释

jdbcTemplate.update(增删改操作)

在增删改操作中调用的jdbcTemplate.update(sql,id);中有两个参数。
源码：

public int update(String sql, @Nullable Object... args) throws DataAccessException {
    return this.update(sql, this.newArgPreparedStatementSetter(args));
}

第一个参数：sql 语句。

第二个参数：可变参数，设置为 sql 语句值。


jdbcTemplate.queryForObject（返回记录条数）

在查询记录数操作中调用的
jdbcTemplate.queryForObject(sql,Integer.class);中有两个参数。

源码：

public <T> T queryForObject(String sql, Class<T> requiredType) throws DataAccessException {
    return this.queryForObject(sql, this.getSingleColumnRowMapper(requiredType));
}

两个参数：

第一个参数：sql 语句。

第二个参数：返回类型 Class。

jdbcTemplate.queryForObject（返回对象）

在返回对象中调用的
jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper(User.class),id);中有三个参数。

源码：

public <T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args) throws DataAccessException {
    List<T> results = (List)this.query((String)sql, (Object[])args, (ResultSetExtractor)(new RowMapperResultSetExtractor(rowMapper, 1)));
    return DataAccessUtils.nullableSingleResult(results);
}

有三个参数 ：

第一个参数：sql 语句。

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

第三个参数：sql 语句值。

jdbcTemplate.query(返回对象集合)

在返回对象集合中调用的jdbcTemplate.query(sql,newBeanPropertyRowMapper(User.class));中有两个参数。

源码：

public <T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException {
    return (List)result(this.query((String)sql, (ResultSetExtractor)(new RowMapperResultSetExtractor(rowMapper))));
}

有两个个参数 ：

第一个参数：sql 语句。

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

jdbcTemplate.batchUpdate(批量操作)

在批量操作中调用的jdbcTemplate.batchUpdate(sql,batchArgs);有两个参数。

源码：

public int[] batchUpdate(String sql, List<Object[]> batchArgs) throws DataAccessException {
    return this.batchUpdate(sql, batchArgs, new int[0]);
}

有两个参数 ：

第一个参数：sql 语句。

第二个参数：List 集合，添加了多条记录数据。

以上就是Spring中使用JdbcTemplate操作数据库（增删改查以及批量操作）附带源码解释的全部内容。

看完如果对你有帮助，感谢点赞支持！


http://www.niftyadmin.cn/n/1603462.html

相关文章

Vue中Axios如何封装管理？本文详解

Vue中Axios如何封装管理？本文详解

Vue Axios 封装 定义 Axios 是一个基于 promise 的 HTTP 库&#xff0c;可以用在浏览器和 node.js 中。 特性 支持Promise API 拦截请求和响应 转换请求数据和响应数据 自动转换JSON数据 客户端支持 XRSF 回归正题 在Vue 项目开发中&#xff0c;我们与接口打交道最多了&am…
阅读更多...
字节跳动二面被血虐，狂补spring/并发/算法我又可以了

字节跳动二面被血虐，狂补spring/并发/算法我又可以了

“去面试今日头条&#xff0c;你最好有点心理准备。我面试过头条的好兄弟给了我一句忠告”。 为了等到这一天&#xff0c;我前天排老长队理了个利落的发型&#xff0c;胡子刮得一干二净&#xff0c;好好捯饬自己一番。并且我认为自己准备很充分&#xff0c;但这次面结束之后&a…
阅读更多...
Vue3 到底哪里好？和React Hook对比有啥有优势？本文详解

Vue3 到底哪里好？和React Hook对比有啥有优势？本文详解

前言 这几天 Vue 3.0 Beta 版本发布了&#xff0c;本以为是皆大欢喜的一件事情&#xff0c;但是论坛里还是看到了很多反对的声音。主流的反对论点大概有如下几点&#xff1a; 意大利面代码结构吐槽&#xff1a;“太失望了。杂七杂八一堆丢在 setup 里&#xff0c;我还不如直接…
阅读更多...
长为一名JAVA架构师2017-10-16 2

长为一名JAVA架构师2017-10-16 2

工作前三年是职业生涯中成长最快的几年&#xff0c;在这段时间里你会充满激情&#xff0c;做事专注&#xff0c;也容易养成良好的习惯。在我们公司有些同学在前三年中就快速成为某一个领域的技术专家&#xff0c;有些同学也可能止步不前。本文和大家一起探讨下如何在三年内快速…
阅读更多...
Vue学习总结之Vue的生命周期是怎么运用操作的？本文详解

Vue学习总结之Vue的生命周期是怎么运用操作的？本文详解

写在前面 1.每一篇文章都希望您有所收获&#xff0c;每一篇文章都希望您能静下心来浏览、阅读。每一篇文章都是作者精心打磨的作品。 2.如果您觉得二郎神杨戬有点东西的话&#xff0c;作者希望你可以帮我点亮那个点赞的按钮&#xff0c;对于二郎神杨戬这个暖男来说&#xff0…
阅读更多...
互联网分层架构，为啥要前后端分离？

互联网分层架构，为啥要前后端分离？

通用业务服务化之后&#xff0c;系统的典型后端结构如上&#xff1a; web-server通过RPC接口&#xff0c;从通用业务服务获取数据 biz-service通过RPC接口&#xff0c;从多个基础数据service获取数据 基础数据service通过DAO&#xff0c;从独立db/cache获取数据 db/cache存储…
阅读更多...
如何用JavaScriptJ封装拖动验证滑块？本文教你

如何用JavaScriptJ封装拖动验证滑块？本文教你

前言 星期六闲着没事&#xff0c;就想着写写原生js玩玩&#xff0c;在网上看了几个效果后决定做这个效果&#xff0c;并且使用了prototype和eventEmitter封装成了库。 最终效果 分析 1.看到这个效果我们首先应该想到和拖动有关的api: onmousedown, onmousemove, onmouseup …
阅读更多...
程序员阿里三次面试已过却无理由挂了，网友：阿里HR有一票否决

程序员阿里三次面试已过却无理由挂了，网友：阿里HR有一票否决

进入互联网大厂一般都是“过五关斩六将”&#xff0c;难度堪比西天取经&#xff0c;但当你真正面对这些大厂的面试时&#xff0c;有时候又会被其中的神操作弄的很是蒙圈。 近日&#xff0c;某位程序员发帖称&#xff0c;自己去阿里面试&#xff0c;三面都过了&#xff0c;却被无…
阅读更多...
最新文章

Copyright @ 2022~2023