JdbcTemplate操作数据库

朱雀 2024-04-06 12:52 83阅读 0赞

#### JdbcTemplate操作数据库（修改和删除） ####

*  修改

// 修改
    @Override
    public void updateBook(Book book) {
        String sql = "update t_book set username = ?, ustatus = ? where user_id = ?";
        Object[] args = {book.getUsername(), book.getUstatus(), book.getUserId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }
    
    
    //测试
    @Tes
        public void testJdbcTemplateUpdate() {
            ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");
            BookService bookService = context.getBean("bookService", BookService.class);
            Book book = new Book();
            book.setUserId("3");
            book.setUsername("java");
            book.setUstatus("c");
            bookService.updateBook(book);
        }

*  删除

// 删除
    @Override
    public void delete(String id) {
        String sql = "delete from t_book where user_id = ?";
        int delete = jdbcTemplate.update(sql, id);
        System.out.println(delete);
    }
    
    
    //测试
     @Test
        public void testJdbcTemplatedelete() {
            ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");
            BookService bookService = context.getBean("bookService", BookService.class);
            Book book = new Book();
            bookService.delete("4");
        }

#### JdbcTemplate操作数据库（查询） ####

a. 查询返回某个值

*  查询表里面有多少条记录，返回是某个值
 *  使用`queryForObject(String sql, Class<T> requireType)`
    
     *  第一个参数：sql语句
     *  第二个参数：返回类型Class

//查询数据库的总记录数
        int selectCount();
    
    
    // 查询表中的记录数
    @Override
    public int selectCount() {
        String sql = "select count(*) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }
    
    
    
     //查询表记录数
        public int findCount(){
           return bookDao.selectCount();
        }
    
    
    
     @Test
        public void testJdbcTemplatecount() {
            ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");
            BookService bookService = context.getBean("bookService", BookService.class);
            int count = bookService.findCount();
            System.out.println(count);
        }

b. 查询返回对象

*  场景：查询图书详情
 *  JdbcTemplate实现查询返回对象`queryForObject(String sql, RowMapper<T> rowMapper, Object... args)`
    
     *  第一个参数：sql语句
     *  第二个参数：RowMapper是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
     *  第三个参数：sql语句中`?`的值

Book findBookInfo(String id);
    
    
    // 查询返回对象
    @Override
    public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id = ?";
        // 调用方法实现
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }
    
    
    
     //查询返回对象
        public Book findOne(String id){
            return bookDao.findBookInfo(id);
        }
    
    
    
    @Test
        public void testJdbcTemplatefindBookInfo() {
            ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");
            BookService bookService = context.getBean("bookService", BookService.class);
            Book book = bookService.findOne("1");
            System.out.println(book);
        }

c. 查询返回集合

*  场景：查询图书列表
 *  调用JdbcTemplate方法实现查询返回集合`query(String sql, RowMapper<T> rowMapper, Object... args)`
    
     *  第一个参数：sql语句
     *  第二份参数：RowMapper接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
     *  第三个参数：sql语句中`?`的值

List<Book> findAllbook();
    
    
    @Override
    public List<Book> findAllbook() {
        String sql = "select * from t_book";
        // 调用方法
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }
    
     public List<Book> findAllbook(){
            return bookDao.findAllbook();
        }
    
    
     @Test
        public void testJdbcTemplatefindAllbook() {
            ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");
            BookService bookService = context.getBean("bookService", BookService.class);
            List<Book> allbook = bookService.findAllbook();
            System.out.println(allbook);
        }

#### JdbcTemplate操作数据库（批量操作） ####

*  批量操作：操作表里面的多条记录
 *  JdbcTemplate实现批量添加操作`batchUpdate(String sql, List<Object[] batchArgs>)`
    
     *  第一个参数：sql语句
     *  第二个参数：List集合，添加多条记录数据
 *  **批量添加**

// 批量添加
    @Override
    public void addAllBook(List<Object[]> batchargs) {
        String sql = "insert into t_book values(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchargs);
        System.out.println(Arrays.toString(ints));
    }
    
    
    
    // 批量添加测试
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"1", "java", "a"};
    Object[] o2 = {"3", "c++", "a"};
    Object[] o3 = {"4", "mysql", "a"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    // 调用批量添加
    bookService.batchAdd(batchArgs);

*  **批量更新**

// 批量更新
    @Override
    public void updateAllBook(List<Object[]> batchargs) {
        String sql = "update t_book set username = ?, ustatus = ? where user_id = ?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchargs);
        System.out.println(Arrays.toString(Arraysints));
    }
    
    
    
    // 批量更新测试
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"java", "b", "1"};
    Object[] o2 = {"c++", "b", "3"};
    Object[] o3 = {"mysql", "b", "4"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    // 调用批量更新
    bookService.batchUpdate(batchArgs);