spring5 jdbcTemplate

最新推荐文章于 2023-10-05 14:15:39 发布
最新推荐文章于 2023-10-05 14:15:39 发布
阅读量133 收藏
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengqingshihuishui/article/details/112592152
版权
本文详细介绍了如何在Spring5中使用JdbcTemplate进行数据库操作，包括添加、修改、查询和批量操作。首先概述了JdbcTemplate的作用，然后通过一步步的案例演示，展示了从添加相关依赖、创建相关类到编写数据库操作的具体步骤，涉及JdbcTemplate的update、queryForObject、query等方法的使用。
摘要由CSDN通过智能技术生成

1、Jdbc Template概述

   Spring框架对JDBC进行封装，使用Jdbc Template方便实现对数据库操作

2、案例演示

2.1 准备工作

（1）向lib引入相关jar包（Maven搞定）

（2）创建相关相关类

​

Step1 在工程创建立一个com.atguigu.spring5.service文件夹（包），写一个BookService类

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
}

再创建一个com.atguigu.spring5.dao文件夹（包）

在该文件夹下写一个BookDao接口，和BookDao接口的实现类BookDaoImpl

package com.atguigu.spring5.dao;

public interface BookDao{

}

 

创建BookDaoImpl对象 bookDaoImpl

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
}

（3）Spring配置文件配置数据库连接池，开启组件扫描等，创建JdbcTemplate类对象jdbcTemplate，将dateSource属性注入jdbcTemplate

<!-- 数据库连接池 --> 
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close"> 
  <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"></property> 
</bean>

<!-- 开启组件扫描 --> 
<context:component-scan base-package="com.atguigu"></context:component-scan>

 

（4）将dao作为属性注入BookService对象

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 
}

将JdbcTemplate作为属性注入BookDaoImpl

package com.atguigu.spring5.dao;

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

 

2.2 JdbcTemplate操作数据库（添加）

对应数据库创建实体类

在com.atguigu.spring5下创建entity文件夹，包com.atguigu.spring5.entity 下创建Book类（代表Book数据表）

​

BookService类作为最外层来操作数据库的增删改查，BookDao类是BookService的属性，底层再封装jdbcTemplate实际操作数据库。Book是被操作的数据表

​

（1）为数据表创建实体类Book 

package com.atguigu.spring5.entity;

public class Book{
  private String userId;
  private String username;
  private String ustatus;

  //空参构造器，有参构造器，get，set方法
  public void setUserId(String userId){
    this.userId=userId;
  }
  
  public void setUsername(String username){
    this.username=username;
  }
}

 

（2）对dao进行数据库添加操作，先在接口写一个抽象方法add()，表示向数据库添加数据

package com.atguigu.spring5.dao;

public interface BookDao{
  //添加方法
  void add(Book book);
}

 

实现类具体实现该方法

JdbcTemplate对象里面有一个update方法实现添加操作

语法：update(String sql,Object...args)

第一个参数：sql语句
第二个参数：可变参数，设置sql语句值

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
  //注入JdbcTemplate
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  //添加的方法
  @Override
  public void add(Book book){
    //1 创建sql语句
    String sql="insert into t_book values(?,?,?)";
    //2 调用方法实现，形参都用的代数，等实际注入
    Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
  }
}

 BookService类里面写添加方法。

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 

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

 

（3）编写测试类

在com.atguigu.spring5文件夹下编写test文件夹（包com.atguigu.spring5）

package com.atguigu.spring5.test;

public class TestBook{
  @Test
  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("java");
    book.setUstatus("a");
    bookService.addBook(book);//向book数据表，添加1，java，a
  }
}

 

​

2.3 jdbcTemplate数据库操作——修改

在BookService类添加后面，可直接写修改，和删除的方法。然后在Dao里面完成操作细节

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 

  //添加方法
  public void addBook(Book book){
    bookDao.add(book);
  }
  //修改方法
  public void updateBook(Book book){
    bookDao.updateBook(book);
  }
  //删除方法
  public void deleteBook(String id){
    bookDao delete(id);
  }
}

在接口中补上修改和删除的方法，同时实现类里面具体实现

package com.atguigu.spring5.dao;

public interface BookDao{
  //添加方法
  void add(Book book);
  //修改方法
  void updateBook(Book book);
  //删除方法
  void delete(String id);//根据id进行删除
}

实现类中

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
  //注入JdbcTemplate
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  //添加的方法
  @Override
  public void add(Book book){
    //1 创建sql语句
    String sql="insert into t_book values(?,?,?)";
    //2 调用方法实现，形参都用的代数，等实际注入
    Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
  }
   //修改方法
  @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);
  }
  
  //删除方法
  @Override
  public void delete(String id){
    String sql = "delete from t_book where user_id=?"; 
    int update = jdbcTemplate.update(sql, id); 
    System.out.println(update); 
  }
}

编写测试类

package com.atguigu.spring5.test;

public class TestBook{
  @Test
  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("javaup");
    book.setUstatus("atguigu");
    bookService.updateBook(book);//修改第一行
    bookService.deleteBook("1");//再删除第一行
  }
}

​

即可完成修改操作，修改后如上图所示，然后又会被bookService.deleteBook("1") 秒删除。

2.4 JdbcTemplate数据库操作——查询

2.4.1 查询的是某个返回值

exp1：使用JdbcTemplate实现查询表里有多少条记录

语法：public int queryForObject(String sql,Class<T> requiredType)

第一个参数：sql语句
第二个参数：返回类型的Class（类型指integer，string）

BookService里面继续添加查询数据表记录数的方法findCount

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 

  //添加方法
  public void addBook(Book book){
    bookDao.add(book);
  }
  //修改方法
  public void updateBook(Book book){
    bookDao.updateBook(book);
  }
  //删除方法
  public void deleteBook(String id){
    bookDao delete(id);
  }
  //查询表记录数
  public int findCount(){
    bookDao.selectCount();
  }
}

在接口中补充该方法，并在实现类中实现方法

package com.atguigu.spring5.dao;

public interface BookDao{
  //添加方法
  void add(Book book);
  //修改方法
  void updateBook(Book book);
  //删除方法
  void delete(String id);//根据id进行删除
  //查询表记录数
  int selectCount();
}

实现类，完成该方法

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
  //注入JdbcTemplate
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  //添加的方法
  @Override
  public void add(Book book){
    //1 创建sql语句
    String sql="insert into t_book values(?,?,?)";
    //2 调用方法实现，形参都用的代数，等实际注入
    Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
  }
   //修改方法
  @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);
  }
  
  //删除方法
  @Override
  public void delete(String id){
    String sql = "delete from t_book where user_id=?"; 
    int update = jdbcTemplate.update(sql, id); 
    System.out.println(update); 
  }

  //查询方法
  @Override
  public int selectCount() {
    String sql = "select count(*) from t_book"; 
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class); 
    return count; 
  }
}

编写测试类，获取数据表的条目数

package com.atguigu.spring5.test;

public class TestBook{
  @Test
  public void testJdbcTemplate(){
    ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService",BookService.class);
   
    //获取数据表的条目数
    int count=bookService.findCount();
    System.out.println(count);
  }
}

2.4.2 JdbcTemplate实现查询返回对象

exp2：用JdbcTemplate查询图书馆图书详情（根据id查询）

语法：public Object queryForObject(String sql,RowMapper<T> rowMapper, Object...args)

第一个参数：sql语句

第二个参数：RowMapper是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装，框架已经帮我们写好了实现类BeanPropertyRowMapper<数据表类名>(数据表类对象,id)，我们只管调用。就会返回对应id的book对象（id对应的行）

第三个参数：sql语句中？的值

在BookService里面创建根据id查询返回对象的方法 public Book findOne(String id)

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 

  //添加方法
  public void addBook(Book book){
    bookDao.add(book);
  }
  //修改方法
  public void updateBook(Book book){
    bookDao.updateBook(book);
  }
  //删除方法
  public void deleteBook(String id){
    bookDao delete(id);
  }
  //查询表记录数
  public int findCount(){
    bookDao.selectCount();
  }
  //根据id值查询返回对象
  public Book findOne(String id){
    return bookDao.findBookInfo(id);
  }
}

在接口里面写继续写查询方法

package com.atguigu.spring5.dao;

public interface BookDao{
  //添加方法
  void add(Book book);
  //修改方法
  void updateBook(Book book);
  //删除方法
  void delete(String id);//根据id进行删除
  //查询表记录数
  int selectCount();
  //根据id查询返回对象
  Book findBookInfo(String id);
}

在实现类中，完成该方法的具体实现（重点）

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
  //注入JdbcTemplate
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  //添加的方法
  @Override
  public void add(Book book){
    //1 创建sql语句
    String sql="insert into t_book values(?,?,?)";
    //2 调用方法实现，形参都用的代数，等实际注入
    Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
  }
   //修改方法
  @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);
  }
  
  //删除方法
  @Override
  public void delete(String id){
    String sql = "delete from t_book where user_id=?"; 
    int update = jdbcTemplate.update(sql, id); 
    System.out.println(update); 
  }

  //查询方法
  @Override
  public int selectCount() {
    String sql = "select count(*) from t_book"; 
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class); 
    return count; 
  }
  //根据查询返回对象
  @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; 
  }
}

做测试

package com.atguigu.spring5.test;

public class TestBook{
  @Test
  public void testJdbcTemplate(){
    ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService",BookService.class);
   
    //查询返回对象
    Book book = bookService.findOne("1");
  }
}

2.4.3 用JdbcTemplate方法实现查询返回集合

exp3：查询图书列表分页…

语法：public List<Object> query(String sql,RowMapper<T> rowMapper, Object...args)

第一个参数：sql语句

第二个参数：RowMapper是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装，框架已经帮我们写好了实现类BeanPropertyRowMapper<数据表类名>(数据表类对象,id)，我们只管调用。就会返回对应id的book对象（id对应的行）

第三个参数：sql语句中？的值

说明：形参和上面的返回对象一样，但是方法名和返回值不一样

BookService里面继续添加查询返回集合的方法

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 

  //添加方法
  public void addBook(Book book){
    bookDao.add(book);
  }
  //修改方法
  public void updateBook(Book book){
    bookDao.updateBook(book);
  }
  //删除方法
  public void deleteBook(String id){
    bookDao delete(id);
  }
  //查询表记录数
  public int findCount(){
    bookDao.selectCount();
  }
  //根据id值查询返回对象
  public Book findOne(String id){
    return bookDao.findBookInfo(id);
  }
  //查询返回的集合
  public List<Book> findAll(){
    return bookDao.findAllBook();
  }
}

在BookDao接口中，写下抽象方法

package com.atguigu.spring5.dao;

public interface BookDao{
  //添加方法
  void add(Book book);
  //修改方法
  void updateBook(Book book);
  //删除方法
  void delete(String id);//根据id进行删除
  //查询表记录数
  int selectCount();
  //根据id查询返回对象
  Book findBookInfo(String id);
  //查询返回集合
  List<Book> findAllBook();
}

在实现类中，完成方法具体实现

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
  //注入JdbcTemplate
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  //添加的方法
  @Override
  public void add(Book book){
    //1 创建sql语句
    String sql="insert into t_book values(?,?,?)";
    //2 调用方法实现，形参都用的代数，等实际注入
    Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
  }
   //修改方法
  @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);
  }
  
  //删除方法
  @Override
  public void delete(String id){
    String sql = "delete from t_book where user_id=?"; 
    int update = jdbcTemplate.update(sql, id); 
    System.out.println(update); 
  }

  //查询方法
  @Override
  public int selectCount() {
    String sql = "select count(*) from t_book"; 
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class); 
    return count; 
  }
  //根据查询返回对象
  @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; 
  }
  @Override 
  public List<Book> findAllBook() { 
    String sql = "select * from t_book"; //调用方法 
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));  //可以没有第三个参数
    return bookList; }
}

做测试

package com.atguigu.spring5.test;

public class TestBook{
  @Test
  public void testJdbcTemplate(){
    ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService",BookService.class);
   
    //查询返回集合
    List<Book> all=bookService.findAll();
    System.out.println(all);
  }
}

2.5  JdbcTemplate实现批量添加操作（批量操作就是操作多条记录）

2.5.1 批量添加

exp4 操作数据表里的多条记录

batchUpdate(String sql,List<Object[]> batchArgs)
 第一个参数：sql语句
 第二个参数：List集合，添加多条记录数据。每个List元素代表数据表的每一行(Object[])，每个Object[]元素又代表数据表的每一列

BookService里面继续添加查询返回集合的方法

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 

  //添加方法
  public void addBook(Book book){
    bookDao.add(book);
  }
  //修改方法
  public void updateBook(Book book){
    bookDao.updateBook(book);
  }
  //删除方法
  public void deleteBook(String id){
    bookDao delete(id);
  }
  //查询表记录数
  public int findCount(){
    bookDao.selectCount();
  }
  //根据id值查询返回对象
  public Book findOne(String id){
    return bookDao.findBookInfo(id);
  }
  //查询返回的集合
  public List<Book> findAll(){
    return bookDao.findAllBook();
  }
  //批量添加
  public void batchAdd(){
    return bookDao.batchAddBook(batchArgs);
  }
}

BookDao接口中添加抽象方法

package com.atguigu.spring5.dao;

public interface BookDao{
  //添加方法
  void add(Book book);
  //修改方法
  void updateBook(Book book);
  //删除方法
  void delete(String id);//根据id进行删除
  //查询表记录数
  int selectCount();
  //根据id查询返回对象
  Book findBookInfo(String id);
  //查询返回集合
  List<Book> findAllBook();
  //批量添加
  void batchAddBook(List<Object[]> batchArgs);
}

实现类中，完成方法具体实现

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
  //注入JdbcTemplate
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  //添加的方法
  @Override
  public void add(Book book){
    //1 创建sql语句
    String sql="insert into t_book values(?,?,?)";
    //2 调用方法实现，形参都用的代数，等实际注入
    Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
  }
   //修改方法
  @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);
  }
  
  //删除方法
  @Override
  public void delete(String id){
    String sql = "delete from t_book where user_id=?"; 
    int update = jdbcTemplate.update(sql, id); 
    System.out.println(update); 
  }

  //查询方法
  @Override
  public int selectCount() {
    String sql = "select count(*) from t_book"; 
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class); 
    return count; 
  }
  //根据查询返回对象
  @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; 
  }
  @Override 
  public List<Book> findAllBook() { 
    String sql = "select * from t_book"; //调用方法 
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));  //可以没有第三个参数
    return bookList; 
  }
  //批量添加
  @Override 
  public void batchAddBook(List<Object[]> batchArgs) { 
    String sql = "insert into t_book values(?,?,?)"; 
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); 
    System.out.println(Arrays.toString(ints)); }
}

做测试

package com.atguigu.spring5.test;

public class TestBook{
  @Test
  public void testJdbcTemplate(){
    ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService",BookService.class);
   
    //批量添加
    //创建一个List集合，元素是Object[]
    List<Object[]> batchArgs = new ArrayList<>(); 
    //创建3个 Object[]数组，添加好对象
    Object[] o1 = {"3","java","a"}; 
    Object[] o2 = {"4","c++","b"}; 
    Object[] o3 = {"5","MySQL","c"}; 
    //将3个数组添加入集合
    batchArgs.add(o1); 
    batchArgs.add(o2); 
    batchArgs.add(o3);
    
    //调用批量添加 
    bookService.batchAdd(batchArgs);
  }
}

2.5.2 批量修改

语法：同批量增加

BookService里面继续添加查询返回集合的方法

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 

  //添加方法
  public void addBook(Book book){
    bookDao.add(book);
  }
  //修改方法
  public void updateBook(Book book){
    bookDao.updateBook(book);
  }
  //删除方法
  public void deleteBook(String id){
    bookDao delete(id);
  }
  //查询表记录数
  public int findCount(){
    bookDao.selectCount();
  }
  //根据id值查询返回对象
  public Book findOne(String id){
    return bookDao.findBookInfo(id);
  }
  //查询返回的集合
  public List<Book> findAll(){
    return bookDao.findAllBook();
  }
  //批量添加
  public void batchAdd(){
    return bookDao.batchAddBook(batchArgs);
  }
  //批量修改
  public void batchUpdate(List<Object[]> batchArgs){
    bookDao batchUpdateBook(batchArgs);  
  }
}

进入BookDao接口，添加抽象方法

package com.atguigu.spring5.dao;

public interface BookDao{
  //添加方法
  void add(Book book);
  //修改方法
  void updateBook(Book book);
  //删除方法
  void delete(String id);//根据id进行删除
  //查询表记录数
  int selectCount();
  //根据id查询返回对象
  Book findBookInfo(String id);
  //查询返回集合
  List<Book> findAllBook();
  //批量添加
  void batchAddBook(List<Object[]> batchArgs);
  //批量修改
  void batchUpdateBook(List<Object> batchArgs);
}
 

实现类中完成具体方法

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
  //注入JdbcTemplate
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  //添加的方法
  @Override
  public void add(Book book){
    //1 创建sql语句
    String sql="insert into t_book values(?,?,?)";
    //2 调用方法实现，形参都用的代数，等实际注入
    Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
  }
   //修改方法
  @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);
  }
  
  //删除方法
  @Override
  public void delete(String id){
    String sql = "delete from t_book where user_id=?"; 
    int update = jdbcTemplate.update(sql, id); 
    System.out.println(update); 
  }

  //查询方法
  @Override
  public int selectCount() {
    String sql = "select count(*) from t_book"; 
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class); 
    return count; 
  }
  //根据查询返回对象
  @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; 
  }
  @Override 
  public List<Book> findAllBook() { 
    String sql = "select * from t_book"; //调用方法 
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));  //可以没有第三个参数
    return bookList; 
  }
  //批量添加
  @Override 
  public void batchAddBook(List<Object[]> batchArgs) { 
    String sql = "insert into t_book values(?,?,?)"; 
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); 
    System.out.println(Arrays.toString(ints)); 
  }
  //批量修改 
  @Override 
  public void batchUpdateBook(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(ints)); 
  }
}

做测试

 

2.5.3 批量删除

BookService中添加批量删除的方法

pacakage com.atguigu.spring5.service;

@Service //通过注解创建对象
public class BookService{
  //注入dao
  @Autowired
  private BookDao bookDao; 

  //添加方法
  public void addBook(Book book){
    bookDao.add(book);
  }
  //修改方法
  public void updateBook(Book book){
    bookDao.updateBook(book);
  }
  //删除方法
  public void deleteBook(String id){
    bookDao delete(id);
  }
  //查询表记录数
  public int findCount(){
    bookDao.selectCount();
  }
  //根据id值查询返回对象
  public Book findOne(String id){
    return bookDao.findBookInfo(id);
  }
  //查询返回的集合
  public List<Book> findAll(){
    return bookDao.findAllBook();
  }
  //批量添加
  public void batchAdd(){
    return bookDao.batchAddBook(batchArgs);
  }
  //批量修改
  public void batchUpdate(List<Object[]> batchArgs){
    bookDao batchUpdateBook(batchArgs);  
  }
  //批量删除
  public void batchDelete(List<Objedct[]> batchArgs){
    bookDao.batchDeleteBook(batchArgs);
  }
}

BookDao接口中添加方法

package com.atguigu.spring5.dao;

public interface BookDao{
  //添加方法
  void add(Book book);
  //修改方法
  void updateBook(Book book);
  //删除方法
  void delete(String id);//根据id进行删除
  //查询表记录数
  int selectCount();
  //根据id查询返回对象
  Book findBookInfo(String id);
  //查询返回集合
  List<Book> findAllBook();
  //批量添加
  void batchAddBook(List<Object[]> batchArgs);
  //批量修改
  void batchUpdateBook(List<Object> batchArgs);
  //批量删除
  void batchDeleteBook(List<Object> batchArgs);
}

实现类中完成具体实现

package com.atguigu.spring5.dao;

@Repository
public class BookDaoImpl implements BookDao{
  //注入JdbcTemplate
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  //添加的方法
  @Override
  public void add(Book book){
    //1 创建sql语句
    String sql="insert into t_book values(?,?,?)";
    //2 调用方法实现，形参都用的代数，等实际注入
    Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
  }
   //修改方法
  @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);
  }
  
  //删除方法
  @Override
  public void delete(String id){
    String sql = "delete from t_book where user_id=?"; 
    int update = jdbcTemplate.update(sql, id); 
    System.out.println(update); 
  }

  //查询方法
  @Override
  public int selectCount() {
    String sql = "select count(*) from t_book"; 
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class); 
    return count; 
  }
  //根据查询返回对象
  @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; 
  }
  @Override 
  public List<Book> findAllBook() { 
    String sql = "select * from t_book"; //调用方法 
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));  //可以没有第三个参数
    return bookList; 
  }
  //批量添加
  @Override 
  public void batchAddBook(List<Object[]> batchArgs) { 
    String sql = "insert into t_book values(?,?,?)"; 
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); 
    System.out.println(Arrays.toString(ints)); 
  }
  //批量修改 
  @Override 
  public void batchUpdateBook(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(ints)); 
  }
  //批量删除 
  @Override 
  public void batchDeleteBook(List<Object[]> batchArgs) { 
    String sql = "delete from t_book where user_id=?"; 
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs); 
    System.out.println(Arrays.toString(ints)); 
  }
}

做测试

 

 

澄清石灰水t
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Spring5】JdbcTemplate
别下完这场雪
07-31 282
Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 可以更加方便实现对数据库的操作
Spring5——JdbcTemplate
来杯奶茶
10-23 732
JdbcTemplate概念 1、什么是JdbcTemplat （1）Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作 2、准备工作 （1）引入相关jar包 （2）在spring配置文件配置数据库连接池 <!-- 数据库连接池 --> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close...
Spring框架-5(JDBC模板&Spring事务管理)
刘桂林
01-23 399
本文作者231-2018zho007博客：https://www.jianshu.com/u/e9cb5fd3aaa8声明：本文由作者 zho007 授权发布，未经原作者允许请勿转载 看到上面蓝色字了吗，点下吧系列文章：Spring框架-1(基础)Spring框架-2(IOC上)Spring框架-3(IOC下)Spring框架-4(AOP)Spring框架-5(JDBC模板&Spring事务管理)
Spring5 中的 JdbcTemplate
weixin_43687024的博客
03-03 592
一，JdbcTemplate 概念 1，什么时JdbcTemplate （1）spring 框架对JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作 2，准备工作 （1）引入相关 jar 包（。。表示任意版本号） druid-。。.jar mysql-connector-java-。。-bin.jar spring-jdbc-。。.jar spring-orm-。。.jar spring-tx-。。.jar （2）在 spring 配置文件配置数据库连接池 <!--数
Spring5（JdbcTemplate）
weixin_44742328的博客
03-19 90
JdbcTemplate(概念和准备) 1、什么是 JdbcTemplate （1）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作 2、准备工作 （1）引入相关 jar 包 （2）在 spring 配置文件配置数据库连接池 <!-- 数据库连接池 --> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy
Spring5 —— JdbcTemplate
Mr_zhangyj的博客
01-27 833
1、概念和准备工作 1.1、概念 什么是 JdbcTemplate？ Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作 1.2、准备工作 1.2.1、导入jar包
spring5JdbcTemplate需要的jar
最新发布
04-11
本篇文章将详细讲解Spring 5中的JdbcTemplate以及它所需要的jar包。 首先，Spring 5 JdbcTemplate的主要作用是为Java应用程序提供了一个模板方法模式的实现，用来处理SQL语句。它通过预编译的PreparedStatement和...
spring-jdbcTemplate实例工程
04-21
《深入解析Spring JdbcTemplate》 Spring JDBC Template是Spring框架中用于简化JDBC操作的一个核心组件，它是Spring对JDBC API的封装，旨在提供一个更加简洁、健壮且可测试的数据库访问层。在这个实例工程中，我们...
Spring 中jdbcTemplate 实现执行多条sql语句示例
08-31
在Spring框架中，JdbcTemplate是用于简化数据库操作的一个重要工具。它提供了执行SQL语句的能力，包括单条语句执行和批处理。本文将详细解释如何使用JdbcTemplate来执行多条SQL语句，以及其在事务管理中的作用。 ...
spring的jdbcTemplate小案例
09-10
在本文中，我们将深入探讨Spring框架中的一个核心组件——JdbcTemplate。JdbcTemplate是Spring提供的一种数据库操作工具，它简化了数据库访问，使开发者能够编写出更健壮、更易于维护的代码，避免了手动处理JDBC连接...
Spring-JdbcTemplate
03-18
**Spring-JdbcTemplate 知识详解** `Spring-JdbcTemplate` 是 Spring 框架中的一个核心模块，主要用于简化数据库操作，提供了强大的数据访问功能。它通过模板方法设计模式封装了 SQL 的执行，使得开发者无需直接与 ...
Spring5之JdbcTemplate
跟小白一起学编程！
12-24 844
Spring 之 JdbcTemplate
Spring5——JDBCTemplate
友培的博客
09-26 178
文章目录JDBCTemplate1 JDBCTemplate?2 准备工作3 操作数据库3.1 增加3.2 修改+删除3.3 查询3.3.1 查询返回某个值3.3.2 查询返回对象3.3.3 查询返回集合3.4 批量操作3.4.1 批量增加3.4.2 批量修改+删除 JDBCTemplate 1 JDBCTemplate? （1）Spring框架对JDBC进行封装，使用JDBCTemplate方便实现对数据库操作 2 准备工作 （1）引入相关的jar包 （2）在spring配置文件中配置数据库连接池
Spring5-JdbcTemplate
weixin_44123412的博客
07-26 233
JDBCTemplate(概念和准备) 什么是jdbcTemplate (1)Spring框架对jdbc进行封装,使用jdbcTemplate方便对数据库进行操作 准备工作 引入jdbc (2)在spring配置文件中配置数据库连接池 3. 配置jdbcTemplate对象,注入Datasource 4. 创建service类,创建dao类,.在dao注入jdbcTemplate 4. JdbcTemplate操作数据库 5. 编写一个bean 6. 编写service和dao (1) 在dao
Spring5（三）：JdbcTemplate
平什么阿的博客
04-26 389
文章目录1. 概念和准备1.1 什么是JdbcTemplate1.2 准备工作2. JdbcTemplate操作数据库：添加3. JdbcTemplate操作数据库：修改和删除4. JdbcTemplate操作数据库：查询返回某个值5. JdbcTemplate操作数据库：查询返回对象6. JdbcTemplate操作数据库：查询返回集合7. JdbcTemplate操作数据库：批量操作 1. 概念和准备 1.1 什么是JdbcTemplate Spring框架对JDBC进行封装，使用JdbcTemplat
Spring5_JdbcTemplate操作
wanananhh的博客
08-28 309
JdbcTemplate操作
[Spring] Spring5——JdbcTemplate 简介
joyride_run的博客
10-05 206
Spring 框架对 JDBC 进行封装，形成一个 Spring 风格的模板，使用 JdbcTemplate 方便实现对数据库操作。
Spring学习5----jdbcTemplate实现crud操作
sunaxp的博客
07-16 332
1spring框架是一站式框架针对javaee三层，每一层都有解决技术在dao层，使用jdbcTemplatejdbcTemplate对jdbc进行封装2准备工作：（1）导入jar包：除了基本的Spring jar包，还需导入spring-jdbc.RELEASE.jar,spring-tx.RELEASE.jar,        mysql-connector-jar-bin.jar（2）数据库...
Spring4-5 Spring对JDBC的支持
Java名企面试吧
03-16 1174
为使JDBC更加易于使用，Spring在JDBC API上定义了抽象层，以此建立一个JDBC存取框架。作为Spring JDBC框架的核心，JDBC模板的设计目的是为不同类型的JDBC操作提供模板方法，每个模板方法都能控制整个过程，并允许覆盖过程中的特定任务；该方式可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低……
Spring框架JdbcTemplate详解与事务控制
"这篇文档是关于Spring框架的教程，主要关注Spring 5的新特性，特别是JdbcTemplate的使用和事务管理。文档首先介绍了JdbcTemplate的基本概念，它是Spring对JDBC API的一种封装，提供了一系列操作数据库的模板方法。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值