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

Spring中对JDBC进行了封装，使用JDBCTemplate方便实现对数据库的操作第一步：引入依赖第二步：配置XML文件<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:context="http://www.springf

我爱布朗熊

5995人浏览 · 2022-03-28 18:51:34

我爱布朗熊 · 2022-03-28 18:51:34 发布

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

第一步：引入依赖

第二步：配置XML文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

<!--    开启扫描-->
    <context:component-scan base-package="com.company.Spring5.JDBCTemplate"> </context:component-scan>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql://localhost:3306/user_db" />
        <property name="username" value="root" />
        <property name="password" value="admin" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>

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

第三步：创建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<Book> findAllBook();
    //    实现批量添加操作    传入一个List的集合
    void batchAdd(List<Object[]> batchArgs);
//实现批量修改 的方法
    void batchUpdateBook(List<Object[]> batchArgs);
    //实现批量删除操作
    void batchDeleteBook(List<Object[]> 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;
//    这个类型是在配置文件中创建的
//        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
//        <property name="dataSource" ref="dataSource"></property>
//    </bean>


    @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<T> 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>(Book.class),id);
//        queryForObject(String sql,RowMapper<T> rowMapper,Object... args)
//        第一个参数：SQL语句
//        第二个参数：RowMapper ，是一个接口，由Spring提供的，返回不同类型数据
//               使用这个接口里面实现类完成数据的封装  泛型里面写返回的类型，括号里面写类型的class
//        第三个参数：SQL语句值 ,就是填补 ？ 的值
        return book;
    }

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


   @Override //    实现批量添加操作    传入一个List的集合
    public void batchAdd(List<Object[]> 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<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));
    }
}

@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<Book> findAll(){
        return bookDao.findAllBook();
    }
//    实现批量添加操作    传入一个List的集合,集合中存储的是一个又一个的数组
    public void batchAdd(List<Object[]> batchArgs){
            bookDao.batchAdd(batchArgs);
    }
//实现批量修改
    public void batchUpdateBook(List<Object[]> batchArgs){
        bookDao.batchUpdateBook(batchArgs);
    }
//实现批量删除操作
public void batchDeleteBook(List<Object[]> 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<Book> all = bookService.findAll();
        System.out.println(all);*/

//        批量添加功能
/*        List<Object[]> 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<Object[]> 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<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"10088" };
        Object[] o2 = {"10089"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        bookService.batchDeleteBook(batchArgs);


    
    }
}

运行结果：

数据库效果

执行增加方法后：

执行删除效果后：

执行修改方法后：

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

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

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

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

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

执行批量删除方法后：

华为云开发者联盟

为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。

更多推荐

华为云Stack8.3面向香港正式发布，六大亮点激发云上跃迁

华为云开发者联盟

6个实例带你解读TinyVue 组件库跨框架技术

华为云开发者联盟

GaussDB SQL查询语句执行过程解析

华为云开发者联盟

所有评论(0)

查看更多评论

我爱布朗熊

@weixin_51351637

已为社区贡献12条内容