jdbcTemplate的基本操作增删改查

最新推荐文章于 2024-07-22 09:40:00 发布
最新推荐文章于 2024-07-22 09:40:00 发布
阅读量584 收藏
点赞数
分类专栏： SSM学习笔记 文章标签： sql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44327755/article/details/125724575
版权

可参考这篇文章

我的项目结构：
在这里插入图片描述

配置文件pom.xml,sqlConfig.xml
pom.xml内容

 <properties>
        <lombok.version>1.18.8</lombok.version>
        <druid.version>1.1.16</druid.version>
        <mysql.version>8.0.18</mysql.version>
        <spring-jdbc.version>5.3.21</spring-jdbc.version>
        <mysql.version>8.0.18</mysql.version>
        <junit.version>4.12</junit.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring-jdbc.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring-jdbc.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring-jdbc.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-jdbc.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring-jdbc.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring-jdbc.version}</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

sqlConfig.xml内容

注意换成自己的文件位置 比如class=“practice.service.StudentClassService”

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql://localhost:3306/user_jdbcTemplate?serverTimezone=GMT%2B8" />
        <property name="username" value="root" />            <!-- 用户名 -->
        <property name="password" value="1234" />            <!-- 密码 -->
        <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"></property>
    </bean>
    
    <!-- 关于class-->
    <bean id="studentClassService" class="practice.service.StudentClassService">
        <property name="classDao" ref="studentClassDao"></property>
    </bean>

    <bean id="studentClassDao" class="practice.dao.daoImpl.StudentClassDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>


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

</beans>

StudentClass表设计
在这里插入图片描述
StudentClass实体

@Data
@AllArgsConstructor
@NoArgsConstructor
public class StudentClass {
    private Integer id;
    private Integer cid;
    private String cname;

    public StudentClass(Integer cid, String cname) {
        this.cid = cid;
        this.cname = cname;
    }

service

 @Autowired
    private StudentClassDao classDao;

    public void setClassDao(StudentClassDao classDao) {
        this.classDao = classDao;
    }

    //  单个操作
    public void addStuClass(StudentClass c){
        classDao.addStuClass(c);
    }
    public void addStuClassIgnoreAuto(StudentClass c){ classDao.addClassIngoreAuto(c);
    }

    public void updateStuClass(StudentClass c){
        classDao.updateStuClass(c);
    }
    public void updateStuClassById(StudentClass c){ classDao.updateClassById(c);
    }

    public void deleteStuClass(Integer cid){
        classDao.deleteStuClass(cid);
    }

    //根据cid查询
    public StudentClass findStuClass(Integer cid){ return classDao.findById(cid); }

    //  批量操作
   public void addBatchClass(List<Object[]> classList){
        classDao.addBatchClass(classList);
    }


    public void deleteBatchClass(List<Object[]> cidList){
        classDao.deleteBatchClass(cidList);
    }


    public List<StudentClass> findAllStuClass(){  return classDao.findAllClass();}

dao

public interface StudentClassDao {

    //自动增加
    void addStuClass(StudentClass c);
    
    void addClassIngoreAuto(StudentClass c);

    //根据cid
    void updateStuClass(StudentClass c);
    
   
    void updateClassById(StudentClass c);

    void deleteStuClass(Integer cid);


    void addBatchClass(List<Object[]> classlist);
    void deleteBatchClass(List<Object[]> cidlist);


    StudentClass findById(Integer cid);
    List<StudentClass> findAllClass();

}

daoImpl

public class StudentClassDaoImpl implements StudentClassDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void addStuClass(StudentClass c) {
        String sql="INSERT INTO class(cid,cname) VALUES(?,?)";
        int i = jdbcTemplate.update(sql, new Object[]{c.getCid(), c.getCname()});
        System.out.println(i);

    }

    public void addClassIngoreAuto(StudentClass c) {
        String sql="INSERT INTO class(id,cid,cname) VALUES(?,?,?)";
        int i = jdbcTemplate.update(sql, new Object[]{c.getId(),c.getCid(), c.getCname()});
        System.out.println(i);
    }

    public void updateStuClass(StudentClass c) {
        String sql="UPDATE class SET cname=? WHERE cid=? ";
        int i = jdbcTemplate.update(sql, new Object[]{c.getCname(),c.getCid()});
        System.out.println(i);
    }

    public void updateClassById(StudentClass c) {
        String sql="UPDATE class SET cid=? , cname=? WHERE id=? ";
        int i = jdbcTemplate.update(sql, new Object[]{c.getCid(),c.getCname(),c.getId()});
        System.out.println(i);
    }

    public void deleteStuClass(Integer cid) {
        String sql="DELETE FROM class WHERE cid=? ";
        int i = jdbcTemplate.update(sql,cid);
        System.out.println(i);
    }

    public void addBatchClass(List<Object[]> classlist) {
        String sql="INSERT INTO class(cid,cname) VALUES(?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, classlist);
        System.out.println(ints);
    }

    public void deleteBatchClass(List<Object[]> cidlist) {
        String sql="DELETE FROM class WHERE cid=?";
        int[] ints=jdbcTemplate.batchUpdate(sql, cidlist);
        System.out.println(ints);
    }


    public StudentClass findById(Integer cid) {
        String sql="SELECT FROM class WHERE id=?";
        StudentClass ints=jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<StudentClass>(StudentClass.class),cid);
        System.out.println(ints);
        return  ints;
    }

    public List<StudentClass> findAllClass() {
        String sql="SELECT * FROM class";
        List<StudentClass> ints=jdbcTemplate.query(sql,new BeanPropertyRowMapper<StudentClass>(StudentClass.class));
        System.out.println(ints);
        return ints;
    }
}

增加操作
如果ID不同 自动增加和手动插入 不冲突 并且下次自动增加按照最大号继续增加

  @Test
    //id自动增加
    public void testAddStuClass(){
        ApplicationContext context = new ClassPathXmlApplicationContext("sqlConfig.xml");
        StudentClassService studentClassService=context.getBean("studentClassService", StudentClassService.class);
        studentClassService.addStuClass(new StudentClass(001,"一班"));
    }

    @Test
    //手动插入id
    public void testAddStuClassIgnoreAuto(){
        ApplicationContext context = new ClassPathXmlApplicationContext("sqlConfig.xml");
        StudentClassService studentClassService=context.getBean("studentClassService", StudentClassService.class);
        studentClassService.addStuClassIgnoreAuto(new StudentClass(5,001,"一班"));
    }

执行流程：2次testAddStuClass–>1次 testAddStuClassIgnoreAuto->1次testAddStuClass

在这里插入图片描述

当手动添加中间数ID 也可以成功

共同点：这两种方式可以共存
在这里插入图片描述
删除id=5—>自动增加—>手动添加
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
如果自动增加和手动增加 id相同（因为主键的唯一性 自然不能重复添加）

在这里插入图片描述
修改操作

 @Test
    //根据cid修改cname
    public void testUpdateClass(){
        ApplicationContext context = new ClassPathXmlApplicationContext("sqlConfig.xml");
        StudentClassService studentClassService=context.getBean("studentClassService", StudentClassService.class);
        studentClassService.updateStuClass(new StudentClass(002,"二班"));
    }

在这里插入图片描述

 @Test
    //根据Id修改cid
    public void testUpdate(){
        ApplicationContext context = new ClassPathXmlApplicationContext("sqlConfig.xml");
        StudentClassService studentClassService=context.getBean("studentClassService", StudentClassService.class);
        studentClassService.updateStuClassById(new StudentClass(5,003,"一班"));
    }

在这里插入图片描述
删除操作
确定选用什么字段来删除，避免误删

  @Test
    //根据cid删除
    public void testDeleteClass(){
        ApplicationContext context = new ClassPathXmlApplicationContext("sqlConfig.xml");
        StudentClassService studentClassService=context.getBean("studentClassService", StudentClassService.class);
        studentClassService.deleteStuClass(1);
    }

在这里插入图片描述
批量操作

 @Test
    //批量增加
    public void testAddBatchStuClass(){
        ApplicationContext context = new ClassPathXmlApplicationContext("sqlConfig.xml");
        StudentClassService studentClassService=context.getBean("studentClassService", StudentClassService.class);
        List<Object[]> list=new ArrayList<Object[]>();
        Object[] object1 = {2, "二班"};
        Object[] object2 = {3, "三班"};
        Object[] object3 = {4, "四班"};
        Object[] object4 = {5, "五班"};
        Object[] object5 = {6, "六班"};
        Object[] object6 = {7, "七班"};
        Object[] object7 = {8, "八班"};
        list.add(object1);
        list.add(object2);
        list.add(object3);
        list.add(object4);
        list.add(object5);
        list.add(object6);
        list.add(object7);

        studentClassService.addBatchClass(list);
    }

在这里插入图片描述


    @Test
    //批量删除
    public void testDeleteBatchStuClass(){
        ApplicationContext context = new ClassPathXmlApplicationContext("sqlConfig.xml");
        StudentClassService studentClassService=context.getBean("studentClassService", StudentClassService.class);
        List<Object[]> list=new ArrayList<Object[]>();
        Object[] object1 = {2};
        Object[] object2 = {3};
        Object[] object3 = {4};

        list.add(object1);
        list.add(object2);
        list.add(object3);

        studentClassService.deleteBatchClass(list);
    }

在这里插入图片描述


    @Test
    //批量查询
    public void testFindAllStuClass(){
        ApplicationContext context = new ClassPathXmlApplicationContext("sqlConfig.xml");
        StudentClassService studentClassService=context.getBean("studentClassService", StudentClassService.class);

        List<StudentClass> list=studentClassService.findAllStuClass();
        System.out.println(list);
    }

打印两遍是因为在daoImpl也打印
在这里插入图片描述

提示：避免使用关键词class 基本功不扎实—一扎头就是班级class 考虑的少
许多错误是因为sql语句，或缺失逗号，或缺少型号 或缺少分号
多动手，眼睛要看，手要练

花僧码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdbcTemplate对表格进行增删改查操作
BlackEn ▪ Lee
12-28 923
spring的Template操作
JdbcTemplate常见的增删改查操作
CarryJoe的博客
02-26 662
文件结构与Jar包 员工类Emp package com.atguigu.jdbctemplate; public class Emp { private Integer aid; private String account; private String password; public Integer getAid() { return aid; } pu...
几种批量删除分析比较
fbysss的专栏
05-05 7846
引用地址：http://zhaopeng879.blog.sohu.com/80758932.html         由于数据的批量处理（比如往RDBMS插入几万条数据）非常耗资源，因此建议在所有场合能够借助于JDBC完成，而不要去采用Hibernate API。本文主要围绕Spring内置的各类JDBC API抽象支持展开的。1.1.  JdbcTemplate内置的batchUp
Spring5学习笔记（11） — “JdbcTemplate 操作数据库（增删改）”
一切因为是码农
10-11 635
JdbcTemplate 操作数据库（增删改）一、准备工作二、JdbcTemplate—增加操作（add）三、JdbcTemplate—删除操作（delete）四、JdbcTemplate—更新操作（update） JdbcTemplate的增、删、改操作 均由JdbcTemplate 的 update 方法实现 该方法有两个参数： 1、sql（操作对应的sql语句） 2、 Object[ ] args （sql语句中对应的参数组成的数组） 一、准备工作 （1）在MySQL数据库中创建book表，其
JDBCTemplate操作数据库，实现增、删、改
苗老八的博客
11-30 1866
如题 1、引入jar包 2、 在bean1.xml文件中设置druid连接池和JDBCTemplate对象，并注入DataSource，以及开辟context的名称空间以便开启组件扫描方便后边的使用注释。 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/X
Spring中JDBCTemplate实现数据库的增删改查、批量删除、批量修改、批量增加操作大全
weixin_51351637的博客
03-28 6239
Spring中对JDBC进行了封装，使用JDBCTemplate方便实现对数据库的操作 第一步：引入依赖 第二步：配置XML文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" ..
使用JdbcTemplate来对数据库进行增删改查
m0_64998696的博客
03-29 503
无service层的jdbc操作
SSH.rar_spring 增删改查
09-24
这些框架协同工作，构建出强大的企业级Java应用，特别适合用于实现数据的增删改查（CRUD）操作。下面将详细阐述这三大框架的功能及其在实现CRUD时的角色。 Spring框架是一个全面的后端开发框架，它提供了依赖注入...
ssh 框架增删改查小项目（CRUD）
08-13
在这个"ssh 框架增删改查小项目（CRUD）"中，我们可以深入学习SSH框架如何实现基本的数据操作，包括创建（Create）、读取（Read）、更新（Update）和删除（Delete）。 Spring框架作为基础，它是一个全面的后端应用...
sping+hibernate+struts2增删改查
09-28
在"增删改查"中，Spring可以提供数据访问对象（DAO）抽象，通过JdbcTemplate或MyBatis等工具与数据库交互，简化了数据库操作。 Hibernate是一个强大的对象关系映射（ORM）框架，它允许开发者用Java对象来操作数据库...
可二次开发的java项目，简单的增删改查
11-08
标题中的“可二次开发的java项目，简单的增删改查”指的是这个项目提供了一个基础的Java应用程序，设计用于与MySQL数据库交互，实现了基本的数据操作功能，即增（添加）、删（删除）、改（修改）和查（查询）。...
Spring+Hibernate 增删改查等基本操作
08-08
在"Spring+Hibernate 增删改查等基本操作"这个主题中，我们主要探讨的是如何整合这两个框架来实现数据持久化。以下是一些关键的知识点： 1. **Spring**： - **依赖注入（DI）**：Spring的核心特性之一，通过XML...
Jdbc Template的增删改查
momoyxy的博客
03-29 2740
dataSource注入到Template,向DAO层注入Template对象,DAO层注入到Service层
一篇文章带你学会 Spring 中的 JdbcTemplate 增删改查操作
南淮北安的博客
05-19 1225
文章目录一、JdbcTemplate 概述二、配置数据源三、bean.xml配置文件四、JdbcTemplate简单示例 一、JdbcTemplate 概述 它是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。 spring 框架为我们提供了很多的操作模板类。 操作关系型数据的：JdbcTemplate，HibernateTemplate 操作 nosql 数据库的：RedisTemplate 操作消息队列的：JmsTemplate 我们今天的主角在 spring-jdbc
JdbcTemplate常用方法解析
记录分享编程与冲浪知识
02-20 1868
JdbcTemplate常用方法解释
JDBC Spring 之JdbcTemplate 增删改查操作
热门推荐
Qmen_Crow的专栏
06-04 3万+
之前简单介绍了JDBC CRUD的操作，接下来我为大家来讲解一下JDBC 使用Spring框架来进行CURD（增删改查操作）使用Spring中的JdbcTemplate之前应该给一个数据源来获得连接。 package cn.itcast.jdbc; import java.io.InputStream; import java.sql.Connection; import java.sql.
Spring中使用JdbcTemplate操作数据库（增删改查以及批量操作）附带源码解释
2401_84167086的博客
04-08 1277
一月 19, 2021 4:05:28 下午 com.alibaba.druid.pool.DruidDataSource info。第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装。(img-Dk4dWbmH-1712536307301)](img-O6goWtM8-1712536307301)]jdbcTemplate.query(返回对象集合)
delete优化_jdbctemplate 的insert、update、delete以及select操作
weixin_39879651的博客
11-29 221
今天完成的事情：查阅spring文档，学习jdbctemplate 的insert、update、delete操作；优化之前的查询方法。代码：DAOImpl.java1、使用jdbctemplate进行insert、update、delete操作：2、查找方法优化昨天用的是匿名内部类，代码感觉很难看，今天把它挪出来做一个单独的内部类。优化后的3种查找方法(查找全部、根据id查找、根据姓名查找)：静...
SQL Server内置的HTAP技术
最新发布
2401_85789772的博客
07-22 593
假设用户建了一个行存索引和列存索引组合的表，事务插入数据时，会同时插入行存和Delta Store，Delta Store达到100W行阈值后冻结，tuple-mover后台线程会将其中较冷的数据迁移到Main Store，无论是过去的传统数仓，还是现在的大数据技术栈，都存在这个时效性问题。根据数仓场景的特点，SQL Server列存的开销其实可以接受，然后使用类Delta-Main架构也是比较主流的做法，但是到了HTAP的场景，整个数据库需要支撑高并发的查询和更新，列存的开销就会被放大。
java连接数据库增删改查
09-22
可以先创建一个接口，定义对数据库的基本增删改查操作，然后创建一个实现类，使用JdbcTemplate来实现这些操作。 如下是一个简单的示例： ```java // 配置数据源 spring.datasource.driver-class-name=...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值