Spring 学习笔记（四）_<t> list<t> query(string var1, sqlparametersource -优快云博客

本文链接：https://blog.youkuaiyun.com/csdn_muxin/article/details/125018541

JDBC template

JDBC template
- 概念
- 准备工作
JdbcTemplate 操作数据库

学习内容来自 B站尚硅谷视频

JDBC template

概念

Spring 框架对 JDBC 进行封装，使用 JDBC template 可以方便对数据库进行操作

准备工作

引入 jar 包
在 Spring 配置文件中配置数据库连接池

<!--    配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="jdbc:mysql:///user_db"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    </bean>

配置 JdbcTemplate 对象，注入 DataSource

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

创建 service 类和 dao 类，在 dao 中注入 jdbcTemplate 对象

（1）开启组件扫描

    <context:component-scan base-package="com.sict.spring5"/>

（2）Service 类

@Service
public class BookService {

    // 注入 dao
    @Autowired
    private BookDao bookDao;
}

（3）Dao 类

@Repository
public class BookDaoImpl implements BookDao {

    // 注入 jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

JdbcTemplate 操作数据库

添加

准备

（1）首先，准备好数据库和对应表
在这里插入图片描述

（2）创建表对应的实体类

public class Book{

    private String userId;
    private String username;
    private String ustatus;

    public String getUserId() {
        return userId;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getUstatus() {
        return ustatus;
    }

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

编写 service 和 dao

在 dao 中进行数据库添加操作

public interface BookDao {

    // 添加数据
    void add(Book book);
}

调用 jdbcTemplate 对象的 update 方法实现添加操作

@Override
    public void add(Book book) {

        String sql = "insert into t_book values(?, ?, ?)";
        // 调用 jdbcTemplate 对象里面的 update 方法实现添加操作
        /**
         *  int update(String var1, @Nullable Object... var2)
         *  var1 是 sql 语句
         *  var2 是可变参数，用来在设置 sql 语句中的变量值
         */
        Object[] args = new Object[]{book.getUserId(), book.getUsername(), book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

编写测试类

public void testJdbcTemplate() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        Book book = new Book();
        book.setUserId("1");
        book.setUsername("jerry");
        book.setUstatus("good");

        bookService.addBook(book);
    }

修改和删除

dao 类中添加方法

public interface BookDao {

    // 添加数据
    void add(Book book);

    // 修改数据
    void update(Book book);

    // 删除数据
    void delete(Book book);
}

service 类中添加方法

public class BookService {

    // 注入 dao
    @Autowired
    private BookDao bookDao;

    // 添加数据
    public void addBook(Book book) {
        bookDao.add(book);
    }

    // 修改数据
    public void updateBook(Book book) {
        bookDao.update(book);
    }

    // 删除
    public void deleteBook(Book book) {
        bookDao.delete(book);
    }
}

dao 实现类中实现方法

@Override
    public void update(Book book) {
        String sql = "update t_book set username=?, ustatus=? where user_id=?";
        Object[] args = new Object[]{book.getUsername(), book.getUstatus(), book.getUserId()};

        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    @Override
    public void delete(Book book) {
        String sql = "delete from t_book where user_id=?";
        Object[] args = new Object[]{book.getUserId()};

        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

编写测试类

public void testJdbcTemplate() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        // 添加
        Book book = new Book();
        book.setUserId("2");
        book.setUsername("jerryDog");
        book.setUstatus("better");
        bookService.addBook(book);

        // 修改
        Book book1 = new Book();
        book1.setUserId("2");
        book1.setUsername("jerrydog");
        book1.setUstatus("sleep");
        bookService.updateBook(book1);

        // 删除
        Book book2 = new Book();
        book2.setUserId("1");
        bookService.deleteBook(book2);

    }

查询

查询返回某个值

dao 接口添加方法

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

service 类添加方法

// 查询记录数
    public int findCount() {
        return bookDao.selectCount();
    }

dao 实现类实现方法

@Override
    public int selectCount() {
        String sql = "select count(*) from t_book";

        /**
         *  queryForObject(String var1, Class<T> var2)
         *  var1 表示 sql 语句
         *  var2 表示返回类型对应的 class
         */
        int count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }

编写测试类

public void testBookQuery() {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        int count = bookService.findCount();
        System.out.println(count);
    }

查询返回对象

dao 接口添加方法

// 查询返回对象
    Book findBookInfo(String id);

service 类添加方法

// 查询返回对象
    public Book findOne(String id) {
        return bookDao.findBookInfo(id);
    }

dao 实现类实现方法

@Override
    public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id=?";

        /**
         * queryForObject(String var1, RowMapper<T> var2, @Nullable Object... var3)
         * var1 是 sql 语句
         * var2 是 RowMapper 接口对应实现类（该实现类会自动完成数据封装）的对象，用来返回给定类型的对象
         * var3 是 sql 语句中的变量
         */
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Book.class), id);
        return book;
    }

编写测试类

public void testBookQueryObject() {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        Book one = bookService.findOne("2");
        System.out.println(one);
    }

查询返回集合

dao 接口添加方法

// 查询返回对象
    List<Book> findAllBook();

service 类添加方法

// 查询所有对象
    public List<Book> findAll() {
        return bookDao.findAllBook();
    }

dao 实现类实现方法

@Override
    public List<Book> findAllBook() {
        String sql = "select * from t_book";

        /**
         * query(String var1, RowMapper<T> var2, @Nullable Object... var3)
         * var1 是 sql 语句
         * var2 是 RowMapper 接口对应实现类（该实现类会自动完成数据封装）的对象，用来返回给定类型的对象
         * var3 是 sql 语句中的变量
         */
        List<Book> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Book.class));
        return list;
    }

编写测试类

public void testBookQueryList() {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        List<Book> all = bookService.findAll();
        all.forEach(System.out::println);
    }

批量添加操作

dao 接口添加方法

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

service 类添加方法

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

dao 实现类实现方法

@Override
    public void batchAddBook(List<Object[]> batchArgs) {
        String sql = "insert into t_book values(?, ?, ?)";

        /**
         * batchUpdate(String sql, List<Object[]> batchArgs)
         * 批量执行 sql 语句，自动调用对应参数
         */
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

编写测试类

public void testBookBatchAdd() {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> list = new ArrayList<>();
        Object[] o1 = {"3", "bili", "bad"};
        Object[] o2 = {"4", "fury", "fun"};
        Object[] o3 = {"5", "jack", "funny"};
        Object[] o4 = {"6", "happyman", "happy"};
        list.add(o1);
        list.add(o2);
        list.add(o3);
        list.add(o4);
        bookService.batchAdd(list);
    }

批量修改和删除

dao 接口添加方法


    // 批量修改
    void batchUpdateBook(List<Object[]> batchArgs);

    // 批量删除
    void batchDeleteBook(List<Object[]> batchArgs);

service 类添加方法

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

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

dao 实现类实现方法

@Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
        String sql = "update t_book set username=?, ustatus=? where user_id=?";

        /**
         * batchUpdate(String sql, List<Object[]> batchArgs)
         * 批量执行 sql 语句，自动调用对应参数
         */
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    @Override
    public void batchDeleteBook(List<Object[]> batchArgs) {
        String sql = "delete from t_book where user_id=?";

        /**
         * batchUpdate(String sql, List<Object[]> batchArgs)
         * 批量执行 sql 语句，自动调用对应参数
         */
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

编写测试类

public void testBookBatchUpdate() {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> list = new ArrayList<>();
        Object[] o1 = {"bili", "bad_edited", "3"};
        Object[] o2 = {"fury", "fun_edited", "4"};
        Object[] o3 = {"jack", "funny_edited", "5"};
        list.add(o1);
        list.add(o2);
        list.add(o3);
        bookService.batchUpdate(list);
    }

    public void testBookBatchDelete() {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> list = new ArrayList<>();
        Object[] o1 = {"3"};
        Object[] o3 = {"5"};
        list.add(o1);
        list.add(o3);
        bookService.batchDelete(list);
    }