天天看點
傳回

Spring架構-JdbcTemplate操作資料庫1.相關依賴2.使用JdbcTemplate實作批量操作。

1.相關依賴

Spring架構對JDBC進行了封裝，使用JdbcTemplate友善實作對資料庫操作

1.需要引入的相關的jar包：

Spring架構-JdbcTemplate操作資料庫1.相關依賴2.使用JdbcTemplate實作批量操作。

2.在Spring配置檔案中配置資料庫連接配接池

配置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"
       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">



    <!-- 開啟注解掃描 -->
    <context:component-scan base-package="com.jdbc.test"></context:component-scan>

    <!-- 資料庫連接配接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///test" />
        <property name="username" value="root" />
        <property name="password" value="lsy" />
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
    </bean>

    <!-- jdbcTemlate對象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入DataSource,可以在JdbcTemplate中檢視，dataSource是通過set方法-->
        <property name="dataSource" ref="dataSource"></property>


    </bean>

</beans>

建立BookService，BookDao的對象，在BookService中注入BookDaoImpl對象，在BookDaoImpl中注入JdbcTemplate對象，實作對資料庫的操作

建立資料庫表

Spring架構-JdbcTemplate操作資料庫1.相關依賴2.使用JdbcTemplate實作批量操作。

對應的Javabean對象。

package com.jdbc.test.entity;

/**
 * @Description:
 * @Author:lsy
 * @Date:
 */
public class Book {
    private String bookId;
    private String bookname;
    private String status;

    public Book() {
    }

    public Book(String bookId, String bookname, String status) {
        this.bookId = bookId;
        this.bookname = bookname;
        this.status = status;
    }

    public String getBookId() {
        return bookId;
    }

    public void setBookId(String bookId) {
        this.bookId = bookId;
    }

    public String getBookname() {
        return bookname;
    }

    public void setBookname(String bookname) {
        this.bookname = bookname;
    }

    public String getStatus() {
        return status;
    }

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

    @Override
    public String toString() {
        return "Book{" +
                "bookId='" + bookId + '\'' +
                ", bookname='" + bookname + '\'' +
                ", status='" + status + '\'' +
                '}';
    }
}

在BookService 和BookDaoImpl中添加相應的功能

addBook功能：

package com.jdbc.test.dao;

import com.jdbc.test.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @Description:
 * DAO中注入JDBCTemplate。實作對資料庫的增删改查
 * @Author:lsy
 * @Date:
 */
@Repository
public class BookDaoImpl implements BookDao{

    //注入JDBCTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Override
    public void addBook(Book book) {
        //建立SQL語句
        String sql="insert into t_book values(?,?,?)";
        //調用jdbcTemplate中的方法進行插入
        int update=jdbcTemplate.update(sql,book.getBookId(),book.getBookname(),book.getStatus());
        System.out.println(update);
    }
}

添加相應的測試類：

@Test
    public void test1(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);
        Book book=new Book("1","java","a");
        bookService.addBook(book);
    }

可以在資料庫中查到相應的資料：

Spring架構-JdbcTemplate操作資料庫1.相關依賴2.使用JdbcTemplate實作批量操作。

JdbcTemplate操作資料庫（修改和删除）

@Override
    public void updateBook(Book book) {
        String sql="update t_book set bookname=?,status=? where bookid=?";
        int update=jdbcTemplate.update(sql,book.getBookname(),book.getStatus(),book.getBookId());
        System.out.println(update);
    }

    @Override
    public void deleteBook(String bookid) {

        String sql="delete from t_book where bookid=?";
        int update=jdbcTemplate.update(sql,bookid);
        System.out.println(update);
    }

JdbcTemplate操作資料庫（查詢）

查詢傳回一個值

Spring架構-JdbcTemplate操作資料庫1.相關依賴2.使用JdbcTemplate實作批量操作。
@Override
    public int selectCount() {
        String sql="select count(*) from t_book";
        Integer count=jdbcTemplate.queryForObject(sql,Integer.class);
        return count;
    }

查詢傳回對象

new BeanPropertyRowMapper<Book>(Book.class)

根據填入的類對象，會傳回相應的值

Spring架構-JdbcTemplate操作資料庫1.相關依賴2.使用JdbcTemplate實作批量操作。
@Override
    public Book findBookInfo(String bookid) {
        String sql="select  * from t_book where bookid=?";
        return jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),bookid);

    }

查詢傳回集合

Spring架構-JdbcTemplate操作資料庫1.相關依賴2.使用JdbcTemplate實作批量操作。
@Override
    public List<Book> findAllBookInfo() {
        String sql="select  * from t_book";
        List<Book> books = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return books;

    }

2.使用JdbcTemplate實作批量操作。

批量添加：

Spring架構-JdbcTemplate操作資料庫1.相關依賴2.使用JdbcTemplate實作批量操作。
@Override
    public void batchAdd(List<Object[]> list) {
        String sql="insert into t_book values(?,?,?)";

        int[] ints = jdbcTemplate.batchUpdate(sql, list);
        System.out.println(Arrays.toString(ints));
    }

批量修改：

批量删除：

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

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

相應的測試代碼;

package com.jdbc.test.test1;

import com.annotation.test.UserService;
import com.jdbc.test.entity.Book;
import com.jdbc.test.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

/**
 * @Description:
 * @Author:lsy
 * @Date:
 */
public class bookTest {

    @Test
    public void testAdd(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);
        Book book=new Book("2","c++","saled");
        bookService.addBook(book);
    }
    @Test
    public void testUpdate(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);
        Book book=new Book("1","java2","a");
        bookService.updateBook(book);
    }
    @Test
    public void testDelete(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);
        bookService.deleteBook("1");
    }

    @Test
    public void testqueryForObject(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);
        int count = bookService.findCount();
        System.out.println(count);
    }

    //傳回一個對象的值
    @Test
    public void testqueryForOne(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);
        Book book=bookService.findOne("1");
        System.out.println(book);
    }
    //傳回一個對象集合
    @Test
    public void testqueryForList(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);
        List<Book> books = bookService.findAll();

        System.out.println(books);
    }

    //批量添加
    @Test
    public void testbatchAdd(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> list=new ArrayList<>();
        Object[] o1={"3","html","unsale"};
        Object[] o2={"4","js","saled"};
        Object[] o3={"5","jquery","unsale"};

        list.add(o1);
        list.add(o2);
        list.add(o3);
        bookService.batchAdd(list);
        System.out.println();
    }

    //批量修改
    @Test
    public void testbatchUpdate(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> list=new ArrayList<>();
        Object[] o1={"html2","unsale","3"};
        Object[] o2={"js2","saled","4"};
        Object[] o3={"jquery2","unsale","5"};

        list.add(o1);
        list.add(o2);
        list.add(o3);
        bookService.batchUpdate(list);
    }


    //批量删除
    @Test
    public void testbatchDelete(){
        //1.加載Spring的配置檔案
        //檔案路徑預設在src下。
        ApplicationContext context=new ClassPathXmlApplicationContext("beandruid.xml");

        //2.擷取配置建立的對象
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> list=new ArrayList<>();
        Object[] o1={"3"};
        Object[] o2={"4"};

        list.add(o1);
        list.add(o2);
        bookService.batchDelete(list);
    }
}
spring
上一篇: 使用JdbcTemplate操作資料庫
下一篇: Spring使用JdbcTemplate操作資料庫

繼續閱讀