1 概念和准备

1、Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作
2、准备工作
（1）引入相关jar包
image.png
（2）在Spring配置文件配置数据库连接池

  1. <!-- 数据库连接池-->
  2.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
  3.           destroy-method="close">
  4.         <property name="url" value="jdbc:mysql:///user_db"/>
  5.         <property name="username" value="root"/>
  6.         <property name="password" value="920827"/>
  7.         <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  8.     </bean>

（3）配置JdbcTemplate对象，注入DataSource

  1. <!-- 配置JdbcTemplate对象-->
  2.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  3.         <!-- 注入dataSource-->
  4.         <!-- name是与class中的类型定义名字对应，ref与数据库连接池中的id对应-->
  5.         <property name="dataSource" ref="dataSource"></property>
  6.     </bean>

（4）创建service类，创建dao类，在dao注入JdbcTemplate对象

  1. <!-- 组件扫描-->
  2.     <context:component-scan base-package="spring5"></context:component-scan>
  5. @Service
  6. public class BookService {
  8.     //注入dao
  9.     @Autowired
  10.     private BookDao bookDao;
  11. }
  14. @Repository
  15. public class BookDaoImpl implements BookDao {
  17.     //注入JdbcTemplate
  18.     @Autowired
  19.     private JdbcTemplate jdbcTemplate;
  20. }

2 数据库添加

1、对应数据的表，创建相应的对象名，以此创建相应的实体类

  1. public class Book {
  2.     private String userId;
  3.     private String username;
  4.     private String ustatus;
  7.     public void setUserId(String userId) {
  8.         this.userId = userId;
  9.     }
  11.     public void setUsername(String username) {
  12.         this.username = username;
  13.     }
  15.     public void setUstatus(String ustatus) {
  16.         this.ustatus = ustatus;
  17.     }
  19.     public String getUserId() {
  20.         return userId;
  21.     }
  23.     public String getUsername() {
  24.         return username;
  25.     }
  27.     public String getUstatus() {
  28.         return ustatus;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Book{" +
  34.                 "userId='" + userId + '\'' +
  35.                 ", username='" + username + '\'' +
  36.                 ", ustatus='" + ustatus + '\'' +
  37.                 '}';
  38.     }
  39. }

2、编写service和dao
（1）在dao进行数据库添加操作
（2）调用JdbcTemplate对象里面的update方法实现添加操作
image.png

  1. @Repository
  2. public class BookDaoImpl implements BookDao {
  3.     //注入 JdbcTemplate
  4.     @Autowired
  5.     private JdbcTemplate jdbcTemplate;
  6.     //添加的方法
  7.     @Override
  8.     public void add(Book book) {
  9.         //1 创建 sql 语句
  10.         String sql = "insert into t_book values(?,?,?)";
  11.         //2 调用方法实现
  12.         Object[] args = {book.getUserId(), book.getUsername(),
  13.                 book.getUstatus()};
  14.         int update = jdbcTemplate.update(sql,args);
  15.         System.out.println(update);
  16.     } 
  17. }

3、测试类

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

3 数据库修改与删除

在BookDaoImpl接口实现层添加修改与删除方法

  1. @Override
  2. public void updateBook(Book book) {
  3.         String sql = "update t_book set username=?,ustatus=? where user_id=?";
  4.         Object[] args = {book.getUsername(), book.getUstatus(),book.getUserId()};
  5.         int update = jdbcTemplate.update(sql, args);
  6.         System.out.println(update);
  7. }
  10. @Override
  11. public void delete(String id) {
  12.         String sql = "delete from t_book where user_id=?";
  13.         int update = jdbcTemplate.update(sql, id);
  14.         System.out.println(update);
  15. }

4 数据库查询

4.1 查询返回某个值

使用queryForObject函数

  1.  @Nullable
  2.     <T> T queryForObject(String sql, Class<T> requiredType) throws DataAccessException;

第一个参数：sql 语句
第二个参数：返回类型 Class，如果是int类型，则返回Integer.class

  1.  //查询表记录数
  2.     @Override
  3.     public int selectCount() {
  4.         String sql = "select count(*) from t_book";
  5.         Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
  6.         return count;
  7.     }

4.2 查询返回对象

使用queryForObject函数

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

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

  1.   @Override
  2.     public Book findBookInfo(String id) {
  3.         String sql = "select * from t_book where user_id=?";
  4.         //调用方法
  5.         Book book = jdbcTemplate.queryForObject(sql, new
  6.                 BeanPropertyRowMapper<Book>(Book.class), id);
  7.         return book;
  8.     }

4.3 查询返回集合

使用query函数
image.png
第一个参数：sql 语句
第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装，泛型参数主要是返回类型的对象
第三个参数：sql 语句值，主要是返回的值。没有参数可省略

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

5 数据库批量操作

使用batchUpdate函数
image.png
第一个参数：sql 语句
第二个参数：List 集合，添加多条记录数据

5.1 批量添加

  1. //批量添加
  2. @Override
  3. public void batchAddBook(List<Object[]> batchArgs) {
  4.     String sql = "insert into t_book values(?,?,?)";
  5.     int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
  6.     System.out.println(Arrays.toString(ints));
  7. }

测试代码

  1.     //批量添加测试
  2.     List<Object[]> batchArgs = new ArrayList<>();
  3.     Object[] o1 = {"3","java","a"};
  4.     Object[] o2 = {"4","c++","b"};
  5.     Object[] o3 = {"5","MySQL","c"};
  6.     batchArgs.add(o1);
  7.     batchArgs.add(o2);
  8.     batchArgs.add(o3);
  9.     //调用批量添加
  10.     bookService.batchAdd(batchArgs);

5.2 批量修改

//批量修改
    @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));
    }

测试代码

    //批量修改
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"java0909","a3","3"};
    Object[] o2 = {"c++1010","b4","4"};
    Object[] o3 = {"MySQL1111","c5","5"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    //调用方法实现批量修改
    bookService.batchUpdate(batchArgs);

5.3 批量删除

 //批量删除
    @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));
    }

测试代码

    //批量删除
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"3"};
    Object[] o2 = {"4"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    //调用方法实现批量删除
    bookService.batchDelete(batchArgs);