Spring JdbcTemplate（使用详解）

JDBC 是 Java 提供的一种用于执行 SQL 语句的 API，可以对多种关系型数据库（例如 MySQL、Oracle 等）进行访问。

但在实际的企业级应用开发中，却很少有人直接使用原生的 JDBC API 进行开发，这是因为使用 JDBC API 对数据库进行操作十分繁琐，需要我们对每一步都做到“步步把控，处处关心”，例如我们需要手动控制数据库连接的开启，异常处理、事务处理、最后还要手动关闭连接释放资源等等。

Spring 提供了一个 Spring JDBC 模块，它对 JDBC API 进行了封装，其的主要目的降低 JDBC API 的使用难度，以一种更直接、更简洁的方式使用 JDBC API。

使用 Spring JDBC，开发人员只需要定义必要的参数、指定需要执行的 SQL 语句，即可轻松的进行 JDBC 编程，对数据库进行访问。

至于驱动的加载、数据库连接的开启与关闭、SQL 语句的创建与执行、异常处理以及事务处理等繁杂乏味的工作，则都是由 Spring JDBC 完成的。这样就可以使开发人员从繁琐的 JDBC API 中解脱出来，有更多的精力专注于业务的开发。

Spring JDBC 提供了多个实用的数据库访问工具，以简化 JDBC 的开发，其中使用最多就是 JdbcTemplate。

JdbcTemplate 的全限定命名为 org.springframework.jdbc.core.JdbcTemplate，它提供了大量的查询和更新数据库的方法，如下表所示。 

下面我们就结合实例，对使用 JdbcTemplate 进行 JDBC 编程进行讲解，步骤如下。

1.准备工作

在  数据库中创建一个 数据库实例user_db，并执创建一个表t_book。

 

2. 创建一个名为的项目，并在将以下依赖导入到工程中。

• spring-beans-5.3.13.RELEASE.jar
• spring-context-5.3.13.RELEASE.jar
• spring-core-5.3.13.RELEASE.jar
• spring-expression-5.3.13.RELEASE.jar
• commons-logging-1.2.jar
• spring-jdbc-5.3.13.RELEASE.jar
• spring-tx-5.3.13.RELEASE.jar
• spring-aop-5.3.13.jar
• mysql-connector-java-8.0.23.jar
• 除了 Spring 的核心依赖以及 commons-logging 日志包外，我们还需要在项目中导入以下依赖。

 2.在Spring配置文件配置数据库连接和配置JdbcTemplate对象，注入DataSource 

"1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
                               http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <context:component-scan base-package="com.java.spring">context:component-scan>
 
 
 
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/user_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai">property>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
 
    bean>
 
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">property>
    bean>
beans>

3. 在 com.java.spring.entity 包下，创建名为 Book的实体类，代码如下。

public class Book {
    private String user_Id;
    private String username;
    private String ustatus;
 
    public String getUser_Id() {
        return user_Id;
    }
 
    public String getUsername() {
        return username;
    }
 
    public String getUstatus() {
        return ustatus;
    }
 
    public void setUser_Id(String user_Id) {
        this.user_Id = user_Id;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
 
    @Override
    public String toString() {
        return "Book{" +
                "user_Id='" + user_Id + '\'' +
                ", username='" + username + '\'' +
                ", ustatus='" + ustatus + '\'' +
                '}';
    }
}

4.在 com.java.spring.Service 包下，创建名为 BookService 的实体类，

在 ncom.java.spring.dao 包下，创建一个名为 BookrDao 的 Dao 接口，

和实现类BookDaoImp1，SQL语句执行模块

代码如下。

使用到的方法：

1.查询使用到的

 参数一：SQL语句

参数二：返回类型Class

有条件判断时使用

 查询返回集合

，没有条件判断时写两个参数也可以 

2.批量添加

public interface BookDao {
//    添加的方法
    void add(Book book);
 
//    修改的方法
    void update(Book book);
//    删除的方法
    void delete(String book);
//    查询记录数
    int selectCount();
//    查询返回对象
    Book findBookInfo(String id);
//    查询返回集合
    List findBAllBook();
//    p批量添加
    void beanchAddBook(List beanch);
}

//@Service:Spring针对Bean管理中创建对象提供注解，IOC篇有讲解
@Service
public class BookService {
//    注入dao    @Autowired：根据属性类型进行自动装配，IOC篇有讲解
    @Autowired
    private BookDao bookDao;
 
    public void addBook (Book book){
        bookDao.add(book);
    }
//   修改的方法
    public void updateBook(Book book){
        bookDao.update(book);
    }
//    删除的方法(根据id值删除）
    public void deleteBook(String id){
        bookDao.delete(id);
    }
//    查询
    public int findCount(){
        return bookDao.selectCount();
    }
//    查询返回对象
    public Book findOne(String id){
        return bookDao.findBookInfo(id);
    }
    //    查询返回集合
    public List findAll(){
        return bookDao.findBAllBook();
    }
 
//批量添加
public void beanchAdd(ListbatchArgs){
    bookDao.beanchAddBook(batchArgs);
 
}
}

@Repository
public class BookDaoImp1 implements BookDao{
//    注入JdbcTemplate对象
    @Autowired
    private JdbcTemplate jdbcTemplate;
 
    @Override
    public void add(Book book) {
//        创建sql语句?表示参数因为表里表一共有三个字段所以为三个?
//JDBC有讲解？用法
        String sql = "insert into t_book value(?,?,?)";
//        调用实现方法
        Object[] args = {book.getUser_Id(),book.getUsername(),book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        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.getUser_Id()};
       int update = jdbcTemplate.update(sql,args);
        System.out.println(update);
    }
 
    @Override
    public void delete(String book) {
        String sql = "delete from t_book where user_id=?";
        int update = jdbcTemplate.update(sql,book);
        System.out.println(update);
 
    }
 
    @Override
    public int selectCount() {
        String sql ="select count(*) from t_book";
        Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
        return integer;
    }
 
    @Override
    public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id=?";
//        第二个参数会自动把数据封装到Book中去
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper(Book.class), id);
        return book;
    }
 
    @Override
    public List findBAllBook() {
        String sql ="select * from t_book ";
        List query = jdbcTemplate.query(sql, new BeanPropertyRowMapper(Book.class));
        return query;
    }
 
    @Override
    public void beanchAddBook(List beanch) {
        String sql = "insert into t_book value(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql,beanch);
    }
}

测试类

public class Test1 {
    @Test
    public void teseJdbc(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
//        Book book = new Book();
//        book.setUser_Id("1");
//        book.setUsername("java");
//        book.setUstatus("a");
 
//        bookService.addBook(book);
//        修改
//        Book book = new Book();
//        book.setUser_Id("1");
//        book.setUsername("javaiiii");
//        book.setUstatus("A");
//
//        bookService.updateBook(book);
 
//删除
       // bookService.deleteBook("1");
//        查询
//        int count = bookService.findCount();
//        System.out.println(count);
//        查询返回对象
//        Book book =bookService.findOne("1");
//        System.out.println(book);
//        查询集合
//      List book = bookService.findAll();
//        System.out.println(book);
//        批量添加
        List batch = new ArrayList<>();
        Object[]o1 = {"3","java","a"};
        Object[]o2 = {"4","java3","b"};
        Object[]o3 = {"5","java4","c"};
        batch.add(o1);
        batch.add(o2);
        batch.add(o3);
        bookService.beanchAdd(batch);
 
 
 
 
 
 
    }
}