Spring框架中的JdbcTemplate

一、基本概念

1、JdbcTemplate是什么

• Spring框架对Jdbc进行了封装，使用JdbcTemplate方便实现对数据库的操作

2、项目的准备工作

• 第一步、导入需要的jar包
  
• 第二步，在bean.xml配置文件中，配置数据库连接池
  注意：我的mysql没有密码，所以password的value值为空，有密码的需加上，否则会报错

<!--数据库连接池-->
<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="" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

• 第三步，在bean.xml中配置JdbcTemplate对象，并注入DataSource

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

• 第四步，新建service类和dao类，在bean.xml中开启注解扫描，并在dao中注入JdbcTemplate对象

<!--组件扫描-->
<context:component-scan base-package="com.study"></context:component-scan>

service类：
@Service
public class BookService {
    //注入dao
    @Autowired
    private BookDao bookDao;
}

dao类：
@Repository
public class BookDaoImpl implements BookDao{
    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

二、JdbcTemplate操作数据库（添加）

1、先使用以下语句在mysql中建立相应的数据库和表

CREATE DATABASE user_db;//创建数据库
USE user_db;//使用数据库
CREATE TABLE t_user(//创建表
	user_id INT PRIMARY KEY AUTO_INCREMENT,
	username VARCHAR(50),
	user_state VARCHAR(20)
);

2、对应数据库表，创建对应的实体类（User类）

//实体类
public class User {
    private String userId;//用户id
    private String username;//用户名
    private String userState;//用户的状态
    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 getUserState() {
        return userState;
    }
    public void setUserState(String userState) {
        this.userState = userState;
    }
}

3、编写service类和dao类

• 第一步，在dao中编写数据库添加操作
• 第二步，调用JdbcTemplate对象中的update方法实现添加操作，方法中有两个参数：第一个参数sql：表示sql语句；第二个参数args：可变参数，设置sql语句的值

@Repository
public class BookDaoImpl implements BookDao{
    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
    //添加的方法
    @Override
    public void add(Book book) {
        //1、创建sql语句
        String sql="insert into t_user values(?,?,?)";
        //2、调用方法实现
        Object [] args={book.getUserId(),book.getUsername(),book.getUserState()}
        int update=jdbcTemplate.update(sql,args);
        System.out.println(update);
    }
}

• 第三步，编写测试方法，录入具体的值，查看是否添加到数据库

测试类：
@Test
public void testJdbcTemplate(){
    ApplicationContext context=
            new ClassPathXmlApplicationContext("bean.xml");
    BookService bookService=context.getBean("bookService",BookService.class);
    Book book=new Book();
    book.setUserId("2");
    book.setUsername("python");
    book.setUserState("b");
    bookService.addBook(book);
}
测试结果：（返回结果为1，表示添加成功）
信息: {dataSource-1} inited
1

三、JdbcTemplate操作数据库（修改和删除）

1、在dao中编写修改和删除的方法，并在service中也编写相应的调用方法，service中调用dao中的方法在这里不进行细致编写。

//在dao中编写
//修改的方法
@Override
public void updateBook(Book book) {
    String sql="update t_user set username=?,user_state=? where user_id=?";
    Object[] args={book.getUsername(),book.getUserState(),book.getUserId()};
    int update=jdbcTemplate.update(sql,args);
    System.out.println(update);
}
//删除的方法
@Override
public void delete(String id) {
    String sql="delete from t_user where user_id=?";
    int delete=jdbcTemplate.update(sql,id);
    System.out.println(delete);
}

2、测试，并查看数据库结果

@Test
public void testDelete(){
    ApplicationContext context=
            new ClassPathXmlApplicationContext("bean.xml");
    BookService bookService=context.getBean("bookService",BookService.class);
    //删除
    bookService.delete("2");
}

四、JdbcTemplate操作数据库（查询）

（一）、返回一个查询对象
1、使用JdbcTemplate的queryForObject方法，其中有三个参数

• 第一个参数sql：表示sql语句
• 第二个参数rowMapper：返回不同类型数据，使用这个接口里面的实现类完成数据封装
• 第三个参数args：sql语句中“？”的值

//查询返回对象
@Override
public Book findBookInfo(String id) {
    String sql="select * from t_user where user_id=?";
    //调用方法
    Book book=jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class),id);
    return book;
}

测试方法及返回值：

//测试程序：
@Test
public void testSelect(){
     ApplicationContext context=
                new ClassPathXmlApplicationContext("bean.xml");
        Book book=bookService.findOne("1");
        System.out.println(book);
}
//测试的返回结果：
Book{userId='1', username='javaScript', userState='start'}

（二）、查询返回集合
1、使用的方法为JddbcTemplate中的query方法，其中有三个参数：

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

//查询返回列表
@Override
public List<Book> findAllBook() {
    String sql="select * from t_user";
    //调用方法
    List<Book> list= jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    return list;
}

2、查看返回结果

//查询返回列表
@Override
public List<Book> findAllBook() {
    String sql="select * from t_user";
    //调用方法
    List<Book> list= jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    return list;
}
//测试结果：（表中只有两条数据）
[Book{userId='1', username='javaScript', userState='start'}, Book{userId='2', username='python', userState='end'}]

五、JdbcTemplate批量操作数据库

（一）、批量添加操作
使用JdbcTemplate的batchUpdate方法

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

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

测试结果：

//批量添加
@Test
public void testBatch(){
    ApplicationContext context=
            new ClassPathXmlApplicationContext("bean.xml");
    BookService bookService=context.getBean("bookService",BookService.class);
    //批量添加
    List<Object[]> batchArgs=new ArrayList<>();
    Object[] o1={"3","C++","start"};
    Object[] o2={"4","C#","end"};
    Object[] o3={"5","Mysql","start"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    //调用批量添加方法
    bookService.batchAdd(batchArgs);
}

测试结果：
[1,1,1]//三条记录均表示添加成功

（二）、批量修改操作
使用JdbcTemplate的batchUpdate方法

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

//批量修改
@Override
public void batchUpdate(List<Object[]> batchArgs) {
    String sql="update t_user set username=?,user_state=? where user_id=?";
    int[] ints=jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

测试程序及结果返回：

//批量修改
@Test
public void testBatchUpdate(){
    ApplicationContext context=
            new ClassPathXmlApplicationContext("bean.xml");
    BookService bookService=context.getBean("bookService",BookService.class);
    //批量修改
    List<Object[]> batchArgs=new ArrayList<>();
    Object[] o1={"SQL","sss","3"};
    Object[] o2={"MySQL","mmm","5"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    //调用批量修改
    bookService.batchUpdate(batchArgs);
}

测试结果：
[1, 1] //表示两条记录均修改成功

（二）、批量删除操作
使用也是batchUpdate方法

//批量删除
@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
    String sql="delete from t_user where user_id=?";
    int[] ints=jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

测试程序及返回结果：

//批量删除
@Test
public void testBatchDelete(){
    ApplicationContext context=
            new ClassPathXmlApplicationContext("bean.xml");
    BookService bookService=context.getBean("bookService",BookService.class);
    //批量删除
    List<Object[]> batchArgs=new ArrayList<>();
    Object[] o1={"5"};
    Object[] o2={"3"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    //调用批量删除
    bookService.batchDelete(batchArgs);
}
测试结果：
[1, 1] //表示两条记录删除成功