Spring引入jdbc操作数据库超详细学习笔记

Keeling1720

已于 2023-04-06 22:38:02 修改

阅读量5.9k

点赞数 6

分类专栏： Spring 文章标签：数据库 spring 学习

于 2021-08-13 19:48:57 首次发布

本文链接：https://blog.csdn.net/weixin_44741023/article/details/119642500

版权

Spring 专栏收录该内容

6 篇文章 5 订阅

订阅专栏

文章目录

四、Spring引入jdbc操作数据库

四、Spring引入jdbc操作数据库

4.1 JdbcTemplate准备工作

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

引入jdbc模块需要添加以下jar包：

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>

然后写一个数据库的配置文件：
jdbc.properties：
注意：
1、下面的user_db是数据库的名称
2、prop.driverClass属性值，如果用mysql8.0就是 com.mysql.cj.jdbc.Driver，如果用mysql5.0就是com.mysql.jdbc.Driver
3、prop.url属性值，如果用mysql8.0需要加?&useSSL=false&serverTimezone=UTC，如果用的是mysql5.0，那么就直接写jdbc:mysql://localhost:3306/user_db即可。
4、prop.username和prop.password对应的是你自己的mysql的用户名和密码。

prop.driverClass=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/user_db?&useSSL=false&serverTimezone=UTC
prop.username=root
prop.password=root

然后再在配置文件中开启注解扫描、引入外部属性文件、配置数据库连接池并创建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">

    <!--开启注解扫描-->
    <context:component-scan base-package="com.example"></context:component-scan>

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

    <!--配置数据库连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="${prop.url}"/>
        <property name="username" value="${prop.username}"/>
        <property name="password" value="${prop.password}"/>
        <property name="driverClassName" value="${prop.driverClass}"/>
    </bean>

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

4.2 jdbc操作数据库添加数据

首先，我们根据数据库的表创建实体类：
在这里插入图片描述

package com.example.po;

public class Book {
    private Integer id;
    private String name;
    private Double price;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

要想使用jdbcTemplate对象实现添加操作，我们需要用到jdbcTemplate的update方法。
该方法的第一个参数是sql语句，第二个参数是可变参数，用来设置sql语句的值
在这里插入图片描述
然后我们编写其所对应的service和dao如下：
BookDao.java

package com.example.dao;

import com.example.po.Book;

public interface BookDao {
    public void addBook(Book book);
}

BookDaoImpl.java

package com.example.dao;

import com.example.po.Book;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

@Repository
public class BookDaoImpl implements BookDao {
	//注入jdbcTemplate
    @Resource
    private JdbcTemplate jdbcTemplate;


    @Override
    public void addBook(Book book) {
        //创建sql语句
        String sql = "insert into book values(?,?,?)";
        //调用方法实现，返回成功修改的记录数
        Object[] args = {book.getId(),book.getName(),book.getPrice()};
        int num = jdbcTemplate.update(sql,args);
        System.out.println("成功添加了 "+num+" 条记录");
    }
}

BookService.java

package com.example.service;

import com.example.dao.BookDao;
import com.example.po.Book;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class BookService {
    //注入bookDao
    @Resource
    private BookDao bookDao;

    public void addBook(Book book){
        bookDao.addBook(book);
    }
}

然后我们编写一个测试类：

package com.example.dao;

import com.example.po.Book;
import com.example.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

        Book book = new Book();
        book.setId(1);
        book.setName("西游记");
        book.setPrice(99.9);

        bookService.addBook(book);
    }
}

运行结果如下：
在这里插入图片描述
然后我们在数据库中查看表单数据如下：

4.3 jdbc操作数据库修改和删除数据

先修改BookDao.java，添加对应的接口

package com.example.dao;

import com.example.po.Book;

public interface BookDao {
    public void addBook(Book book);
    public void updateBook(Book book);
    public void deleteBookById(Integer id);
}

然后修改BookDaoImpl.java，实现接口。

package com.example.dao;

import com.example.po.Book;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

@Repository
public class BookDaoImpl implements BookDao {
    //注入jdbcTemplate
    @Resource
    private JdbcTemplate jdbcTemplate;


    @Override
    public void addBook(Book book) {
        //创建sql语句
        String sql = "insert into book values(?,?,?)";
        //调用方法实现，返回成功修改的记录数
        Object[] args = {book.getId(),book.getName(),book.getPrice()};
        int num = jdbcTemplate.update(sql,args);
        System.out.println("成功添加了 "+num+" 条记录");
    }

    /*修改记录*/
    @Override
    public void updateBook(Book book) {
        String sql = "update book set name = ?, price = ? where id = ?";
        Object[] args = {book.getName(),book.getPrice(),book.getId()};
        int num = jdbcTemplate.update(sql,args);
        System.out.println("成功修改了 "+num+" 条记录");
    }

    /*删除记录*/
    @Override
    public void deleteBookById(Integer id) {
        String sql = "delete from book where id = ?";
        int num = jdbcTemplate.update(sql,id);
        System.out.println("成功删除了 "+num+" 条记录");
    }
}

修改BookService.java，实现接口调用：

package com.example.service;

import com.example.dao.BookDao;
import com.example.po.Book;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class BookService {
    //注入bookDao
    @Resource
    private BookDao bookDao;

    public void addBook(Book book){
        bookDao.addBook(book);
    }

    public void updateBook(Book book){
        bookDao.updateBook(book);
    }

    public void deleteBook(Integer id){
        bookDao.deleteBookById(id);
    }
}

最后编写测试类：

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

        Book book = new Book();
        book.setId(1);
        book.setName("水浒传");
        book.setPrice(99.9);

        bookService.updateBook(book);
    }

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

        bookService.deleteBook(1);
    }

运行testJdbcTemplateUpdate方法后，数据库信息如下：
在这里插入图片描述
再运行testJdbcTemplateDelete方法，数据库信息如下：
注意：现实中运用的话，不建议直接删除数据，毕竟现在是信息时代，每一条数据都异常宝贵，因此，更建议给每条记录多写一个变量来表示这条数据要不要显示。比如，bool值，true就显示，删除就把值置false。
在这里插入图片描述

4.4 jdbc操作数据库查询数据

我们先给表格添加几条数据如下：

insert into book values(1,"西游记",100),(2,"水浒传",100),(3,"三国演义",100),(4,"红楼梦",100);

在这里插入图片描述

4.4.1 查询返回数据

案例：查询表中有多少条记录，返回记录数
老规矩，先在BookDao中加：

    public int findCount();

然后在BookDaoImpl中实现：

    /*查询表中记录数*/
    @Override
    public int findCount() {
        String sql = "select count(*) from book";
        /*第一个参数是sql语句，第二个参数是返回的类，如果是字符串，那么就是String.class*/
        Integer count = jdbcTemplate.queryForObject(sql,Integer.class);
        return count;
    }

然后在BookService中调用接口：

    public int findCount(){
        return bookDao.findCount();
    }

最后写个测试类：

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

        int count = bookService.findCount();
        System.out.println("book表中共有"+count+"条记录");
    }

显示如下：
在这里插入图片描述

4.4.2 查询返回对象

案例：查询书名为西游记的详细信息
在UserDao中添加：

public Book findBookByName(String name);

在BookDaoImpl中实现：

    /*通过书名查书*/
    @Override
    public Book findBookByName(String name) {
        String sql = "select * from book where name = ?";
        /*
        *   第一个参数是sql语句
        *   第二个参数是BeanPropertyRowMapper对象，<>中是返回的对象类型，()中是该对象的类
        *   第三个对象是传入的参数
        * */
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), name);
        return book;
    }

知识点：jdbcTemplate.queryForObject中的第二个参数RowMapperhi接口，针对返回不同类型的数据，使用这个接口的实现类可以自动完成数据封装。
在BookService中调用接口：

    public Book findBookByName(String name) {
        return bookDao.findBookByName(name);
    }

编写测试类：

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

        Book book = bookService.findBookByName("西游记");

        System.out.println(book);
    }

为了方便查看数据，我们在Book.java中写一个toString方法：

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

运行测试方法结果：
在这里插入图片描述

4.4.3 查询返回集合

BookDao：

    public List<Book> findAll();

BookDaoImpl：（使用query方法，返回的是List集合，其他的跟上面查询对象基本一样）

    @Override
    public List<Book> findAll() {
        String sql = "select * from book";
        List<Book> books = jdbcTemplate.query(sql,new BeanPropertyRowMapper<Book>(Book.class));
        return books;
    }

BookService：

    public List<Book> findAll(){
        return bookDao.findAll();
    }

测试方法：

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

        List<Book> books = bookService.findAll();

        for (Book book : books){
            System.out.println(book);
        }
    }

运行结果：
在这里插入图片描述

4.5 jdbc操作数据库批量增加数据

使用jdbc的方法barchUpdate(String sql, List<Object[]> barchArgs)
第一个参数是sql语句
第二个参数是List集合，批量添加的对象们
他的底层实现逻辑是：将传进入的每个Object[]作为一个组合，然后放到List中。再将每个组合抽离出来，用我们的sql语句逐一进行实现。

简而言之，其实底层就是帮我们封装完后实现多次update(sql, Object[]);

老规矩，先在BookDao中添加代码：

    public void addBooks(List<Object[]> books);

在BookDaoImpl中实现：

    @Override
    public void addBooks(List<Object[]> books) {
        String sql = "insert into book values(?,?,?)";
        int[] num = jdbcTemplate.batchUpdate(sql, books);
        System.out.println(Arrays.toString(num));
    }

在BookService中调用接口：

    public void addBooks(List<Object[]> books){
        bookDao.addBooks(books);
    }

编写测试方法实现：

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

        Object[] book1 = {5,"C语言从入门到放弃",50.0};
        Object[] book2 = {6,"C++从入门到入土",50.0};
        Object[] book3 = {7,"Java是全世界最好的语言",50.0};

        List<Object[]> books = new ArrayList<>();
        books.add(book1);
        books.add(book2);
        books.add(book3);

        bookService.addBooks(books);
    }

运行结果：
在这里插入图片描述

4.6 jdbc操作数据库批量修改和删除数据

BookDao：

    public void updateBooks(List<Object[]> books);
    public void deleteBooks(List<Object[]> ids);

BookDaoImpl：

    //批量修改
    @Override
    public void updateBooks(List<Object[]> books) {
        String sql = "update book set name = ?,price = ? where id = ?";
        int[] num = jdbcTemplate.batchUpdate(sql, books);
        System.out.println(Arrays.toString(num));
    }

    //批量删除
    @Override
    public void deleteBooks(List<Object[]> ids) {
        String sql = "delete from book where id = ?";
        int[] num = jdbcTemplate.batchUpdate(sql, ids);
        System.out.println(Arrays.toString(num));
    }

BookService：

    public void updateBooks(List<Object[]> books){
        bookDao.updateBooks(books);
    }

    public void deleteBooks(List<Object[]> ids){
        bookDao.deleteBooks(ids);
    }

测试类：

	//测试批量修改
    @Test
    public void testJdbcTemplateUpdateBooks(){
        ApplicationContext context = new ClassPathXmlApplicationContext("jdbcContext.xml");
        BookService bookService = context.getBean("bookService",BookService.class);

        /*注意顺序*/
        Object[] book1 = {"Spring",60.0,1};
        Object[] book2 = {"Spring MVC",60.0,2};
        Object[] book3 = {"MyBatis",60.0,3};

        List<Object[]> books = new ArrayList<>();
        books.add(book1);
        books.add(book2);
        books.add(book3);

        bookService.updateBooks(books);
    }

	//测试批量删除
    @Test
    public void testJdbcTemplateDeleteBooks(){
        ApplicationContext context = new ClassPathXmlApplicationContext("jdbcContext.xml");
        BookService bookService = context.getBean("bookService",BookService.class);

        Object[] id_1 = {4};
        Object[] id_2 = {5};
        Object[] id_3 = {6};

        List<Object[]> ids = new ArrayList<>();
        ids.add(id_1);
        ids.add(id_2);
        ids.add(id_3);

        bookService.deleteBooks(ids);
    }

执行第一个测试方法，数据库信息如下：
在这里插入图片描述
执行第二个测试方法，数据库信息如下：

Keeling1720

关注

6
点赞
踩
16

收藏

觉得还不错? 一键收藏
2
评论
Spring引入jdbc操作数据库超详细学习笔记

文章目录四、Spring引入jdbc操作数据库4.1 JdbcTemplate准备工作4.2 jdbc操作数据库添加数据4.3 jdbc操作数据库修改和删除数据4.4 jdbc操作数据库查询数据4.4.1 查询返回数据4.4.2 查询返回对象4.4.3 查询返回集合4.5 jdbc操作数据库批量增加数据4.6 jdbc操作数据库批量修改和删除数据四、Spring引入jdbc操作数据库4.1 JdbcTemplate准备工作Spirng框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库
复制链接

扫一扫