Spring中JDBCTemplate实现数据库的增删改查、批量删除、批量修改、批量增加操作大全

Spring中对JDBC进行了封装，使用JDBCTemplate方便实现对数据库的操作

第一步：引入依赖

 

第二步：配置XML文件

第三步：创建service、dao类，在dao类中注入JDBCTemplate对象

向数据库user_db中的t_book表中，添加有关book的信息

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

    @Override
    public String toString() {
        return "Book{" +
                "userId='" + userId + '\'' +
                ", username='" + username + '\'' +
                ", ustatus='" + 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;
    }

}

public interface BookDao {
//    添加的方法
    void add(Book book);
//    修改的方法
    void update(Book book);
//    删除的方法
    void delete(String id);
//     查询表中记录数的方法
   int selectCount();
//查询返回对象  根据id查询的方法
    Book findBookInfo(String id);
    //查询返回集合操作的方法  场景：查询图书列表分页等
    List findAllBook();
    //    实现批量添加操作    传入一个List的集合
    void batchAdd(List batchArgs);
//实现批量修改 的方法
    void batchUpdateBook(List batchArgs);
    //实现批量删除操作
    void batchDeleteBook(List batchArgs);
}

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

@Repository    //dao层
public class BookDaoImpl implements BookDao{
//    注入JDBCTemplate
    @Autowired   //根据类型注入
    private JdbcTemplate jdbcTemplate;
//    这个类型是在配置文件中创建的
//        
//        
//    


    @Override   //实现数据库的增添操作
    public void add(Book book) {
        String sql="insert into t_book values(?,?,?)";
//        调用JdbcTemplate对象里面update方法实现添加操作
//        update(String SQL , Object... args)
//        第一个参数是SQL语句
//        第二个参数 是可变参数，有几个占位符，这个地方就有几个参数（也可以写成数组的形式）
           Object[] args={book.getUserId(),book.getUsername(),book.getUstatus()};
//        int update =    jdbcTemplate.update(sql,book.getUserId(),book.getUsername(),book.getUstatus());
        int update =    jdbcTemplate.update(sql,args);
//返回值是一个int类型，表示影响了几行数据
        System.out.println(update);
    }
//     修改操作
    @Override
    public void update(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 s 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);
//        queryForObject(String sql,Class requiredType)
//        第一个参数：SQL语句
//        第二个参数：返回类型Class
    return count;
    }

    @Override //查询返回对象  根据id查询 操作
    public Book findBookInfo(String id) {
        String sql="select * from t_book where user_id=?";
//        调用方法
     Book book=   jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper(Book.class),id);
//        queryForObject(String sql,RowMapper rowMapper,Object... args)
//        第一个参数：SQL语句
//        第二个参数：RowMapper ，是一个接口，由Spring提供的，返回不同类型数据
//               使用这个接口里面实现类完成数据的封装  泛型里面写返回的类型，括号里面写类型的class
//        第三个参数：SQL语句值 ,就是填补 ？ 的值
        return book;
    }

    //查询返回集合操作   场景：查询图书列表分页等
    @Override
    public List findAllBook() {
        String sql = "select * from t_book ";
      List bookList=  jdbcTemplate.query(sql,new BeanPropertyRowMapper(Book.class));
        //        query(String sql,RowMapper rowMapper,Object... args)
//        第一个参数：SQL语句
//        第二个参数：RowMapper ，是一个接口，由Spring提供的，返回不同类型数据
//               使用这个接口里面实现类完成数据的封装  泛型里面写返回的类型，括号里面写类型的class
//        第三个参数：SQL语句值 ,就是填补 ？ 的值
        return bookList;
//        查出的数据有多条记录，框架中做了封装，将得到的数据先放到Book对象中，然后将多个Book对象放到集合中，最终返回
    }


   @Override //    实现批量添加操作    传入一个List的集合
    public void batchAdd(List batchArgs) {
      String sql = "insert into t_book values(?,?,?)";
      int[] ints =   jdbcTemplate.batchUpdate(sql,batchArgs);  //将SQL语句和集合传入
//        batchUpdate()方法中做了一个封装，把list集合做了一个遍历，把，每个数组值执行SQL语句做一个添加
        System.out.println(Arrays.toString(ints));
    }

    @Override //实现批量修改的方法
    public void batchUpdateBook(List 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 batchArgs) {
        String sql = "delete from t_book  where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }
}

@Service
public class BookService {
//    注入dao
     @Autowired  //根据类型注入属性
   private BookDao bookDao;

//     添加的方法
    public void addBook(Book book){
          bookDao.add(book);
    }
//    修改操作
    public void update(Book book){
        bookDao.update(book);
    }
//    删除操作
    public void delete(String id){
        bookDao.delete(id);
    }
//    查询表中的记录数操作
    public int findCount() {
        return bookDao.selectCount();
    }
//    查询返回对象  根据id查询 操作
        public Book findOne(String id){
            return bookDao.findBookInfo(id);
        }
//查询返回集合操作   场景：查询图书列表分页等
    public List findAll(){
        return bookDao.findAllBook();
    }
//    实现批量添加操作    传入一个List的集合,集合中存储的是一个又一个的数组
    public void batchAdd(List batchArgs){
            bookDao.batchAdd(batchArgs);
    }
//实现批量修改
    public void batchUpdateBook(List batchArgs){
        bookDao.batchUpdateBook(batchArgs);
    }
//实现批量删除操作
public void batchDeleteBook(List batchArgs){
    bookDao.batchDeleteBook(batchArgs);
}
}

创建测试类：

public class Test {
    @org.junit.Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean12JDBC.xml");
        BookService bookService = context.getBean("bookService",BookService.class);

/*      增加操作
       Book book = new Book();
        book.setUserId("10086");
        book.setUsername("张三");
        book.setUstatus("好");
        bookService.addBook(book);*/
//        删除操作
/*        Book book = new Book();
        book.setUserId("10086");
        bookService.delete(book.getUserId());*/
//        修改操作
     /*   Book book = new Book();
        book.setUserId("100000");
        book.setUsername("zhangzhang");
        book.setUstatus("良好");
        bookService.update(book); */

//      查询数据库表中的记录数
/*      int count = bookService.findCount();
        System.out.println(count);*/   //返回几就是有几条数据

//        查询返回对象
/*        Book book = bookService.findOne("100000");
        System.out.println(book);*/

        //查询返回集合操作   场景：查询图书列表分页等
       /* List all = bookService.findAll();
        System.out.println(all);*/

//        批量添加功能
/*        List batchArgs = new ArrayList<>();
        Object[] o1 = {"10088","java","好"  };
        Object[] o2 = {"10089","xml","好"};
        Object[] o3 = {" 10086","sql","良"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);*/
//         调用我们自己写的批量添加功能，它会把我们写的List集合做一个遍历
/*        bookService.batchAdd(batchArgs);*/

//        批量修改功能
/*        List batchArgs = new ArrayList<>();
        Object[] o1 = {"信息管理","好" ,"10088" };
        Object[] o2 = {"java高级","好","10089"};
        Object[] o3 = {"Mysql","良"," 10086"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchUpdateBook(batchArgs);*/

//        批量删除功能
        List batchArgs = new ArrayList<>();
        Object[] o1 = {"10088" };
        Object[] o2 = {"10089"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        bookService.batchDeleteBook(batchArgs);


    
    }
}

运行结果：

数据库效果

  执行增加方法后：

 

执行删除效果后：

 执行修改方法后： 

 执行 查询数据库表中的记录数 方法后：

执行  查询放回对象 方法后： 

执行 查询返回集合操作 方法后：

 

 执行 批量添加功能 方法后：  三个 “1”，表示集合中的每个数组分别影响的数据库数据的行数

 

 

执行  批量修改方法后：三个 “1”，表示集合中的每个数组分别影响的数据库数据的行数

 

 

 

 执行 批量删除方法后：