Spring的JdbcTemplate

JdbcTemplate的概念

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

准备工作

  1. 引入相关的jar包

    jar包

  2. 在Spring配置文件配置数据库连接池

    1
    2
    3
    4
    5
    6
    7
    8
    <!-- 数据库连接池 -->
    <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="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>

  3. 配置JdbcTemplate对象，注入DataSource

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

  4. 创建service类，创建dao类，在dao注入jdbcTemplate对象

    • 配置文件

      1
      2
      <!--组件扫描-->
      <context:component-scan base-package="com.ligangit.spring5"/>

    • service

      1
      2
      3
      4
      5
      6
      @Service
      public class BookService {
          //注入dao
          @Autowired
          private BookDao bookDao;
      }

    • dao

      1
      2
      3
      4
      5
      6
      7
      @Repository
      public class BookDaoImpl  implements BookDao{
          //注入JdbcTemplate
          @Autowired
          private JdbcTemplate jdbcTemplate;

      }

JdbcTemplate操作数据库

添加

  1. 对应数据库创建实体类

    1
    2
    3
    4
    public class Book {
        private String bookId;
        private String bookName;
        private String bstatus;

  2. 编写service和dao

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

    • 调用JdbcTemplate对象里面的update方法实现添加操作

      • update方法有两个参数：
        • 第一个参数：sql语句
        • 第二个参数：可变参数，设置sql语句值

    • dao代码：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      @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.getBookId(), book.getBookName(), book.getBstatus()};
              int update = jdbcTemplate.update(sql, args);
              System.out.println(update);
          }
      }

  3. 测试类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    @Test
    public void testJdbcTemplate(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
        Book book = new Book();
        book.setBookId("1");
        book.setBookName("java");
        book.setBstatus("a");
        bookService.addBook(book);
    }

修改和删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//修改的方法
@Override
public void updateBook(Book book) {
    //1 创建sql语句
    String sql = "UPDATE t_book SET bookname=?,bstatus=? WHERE book_id=?";
    //2 调用方法实现
    Object[] args = { book.getBookName(), book.getBstatus(),book.getBookId()};
    int update = jdbcTemplate.update(sql, args);
    System.out.println(update);
}

//删除的方法
@Override
public void deleteBook(String id) {
    //1 创建sql语句
    String sql = "DELETE FROM t_book WHERE book_id=?";
    //2 调用方法实现
    int update = jdbcTemplate.update(sql, id);
    System.out.println(update);
}

查询

查询返回某个值

如：查询表里面有多少条记录

使用queryForObject方法

1
queryForObject(String var1, Class<T> var2)

  • queryForObject方法有两个参数

    • 第一个参数：sql语句
    • 第二个参数：返回类型class

  • 代码

    1
    2
    3
    4
    5
    6
    7
    //查询返回某个值
    @Override
    public int selectCount() {
        String sql = "SELECT COUNT(*) FROM t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }

查询返回对象

如：查询图书详情

使用queryForObject方法

1
queryForObject(String var1, RowMapper<T> var2, @Nullable Object... var3)

  • queryForObject方法有三个参数

    • 第一个参数：sql语句
    • 第二个参数：RowMapper，是接口，返回不同类型数据，使用这个接口里面实现类完成数据封装
    • 第三个参数：sql语句值

  • 代码

    1
    2
    3
    4
    5
    6
    7
    //查询返回对象
    @Override
    public Book findBookInfo(String id) {
        String sql = "SELECT * FROM t_book WHERE book_id=?";
        Book book = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }

查询返回集合

如：查询图书列表分页…

使用query方法

1
query(String var1, RowMapper<T> var2, @Nullable Object... var3)

  • queryForObject方法有三个参数

    • 第一个参数：sql语句
    • 第二个参数：RowMapper，是接口，返回不同类型数据，使用这个接口里面实现类完成数据封装
    • 第三个参数：sql语句值

  • 代码

    1
    2
    3
    4
    5
    6
    7
    //查询返回集合
    @Override
    public List<Book> findAllBook() {
        String sql = "SELECT * FROM t_book";
        List<Book> bookList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }

批量添加

使用batchUpdate方法

1
batchUpdate(String var1, List<Object[]> var2)

  • batchUpdate方法有两个参数

    • 第一个参数：sql语句
    • 第二个参数：List集合，添加多条记录数据

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    //批量添加
    @Override
    public void batchAddBook(List<Object[]> batchArgs) {
        //1 创建sql语句
        String sql = "INSERT INTO t_book VALUES(?,?,?)";
        //2 调用方法实现
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

  • 测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    //批量添加
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"5", "C语言", "a"};
    Object[] o2 = {"6", "Python", "b"};
    Object[] o3 = {"7", "Mysql", "c"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    bookService.batchAdd(batchArgs);

批量修改

使用batchUpdate方法

1
batchUpdate(String var1, List<Object[]> var2)

  • batchUpdate方法有两个参数

    • 第一个参数：sql语句
    • 第二个参数：List集合，添加多条记录数据

  • 代码

    1
    2
    3
    4
    5
    6
    7
    //批量修改
    @Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
        String sql = "UPDATE t_book SET bookname=?,bstatus=? WHERE book_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

  • 测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    //批量修改
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = { "C语言001", "a5","5"};
    Object[] o2 = { "Python002", "b6","6",};
    Object[] o3 = { "Mysql005", "c7","7",};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    bookService.batchUpdate(batchArgs);

批量删除

使用batchUpdate方法

1
batchUpdate(String var1, List<Object[]> var2)

  • batchUpdate方法有两个参数

    • 第一个参数：sql语句
    • 第二个参数：List集合，添加多条记录数据

  • 代码

    1
    2
    3
    4
    5
    6
    7
    //批量删除
    @Override
    public void batchDeleteBook(List<Object[]> batchArgs) {
        String sql = "DELETE FROM t_book WHERE book_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

  • 测试

    1
    2
    3
    4
    5
    6
    7
    //批量删除
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"5"};
    Object[] o2 = {"6",};
    batchArgs.add(o1);
    batchArgs.add(o2);
    bookService.batchDelete(batchArgs);

最后更新： 2020年06月26日 23:54

原始链接： http://ligangit.com/2020/06/26/Spring-JdbcTemplate/

赏
× 请我吃糖~
打赏二维码