1、Jdbc Template概述
Spring框架对JDBC进行封装,使用Jdbc Template方便实现对数据库操作
2、案例演示
2.1 准备工作
(1)向lib引入相关jar包(Maven搞定)
(2)创建相关相关类
Step1 在工程创建立一个com.atguigu.spring5.service文件夹(包),写一个BookService类
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
}
再创建一个com.atguigu.spring5.dao文件夹(包)
在该文件夹下写一个BookDao接口,和BookDao接口的实现类BookDaoImpl
package com.atguigu.spring5.dao;
public interface BookDao{
}
创建BookDaoImpl对象 bookDaoImpl
package com.atguigu.spring5.dao;
@Repository
public class BookDaoImpl implements BookDao{
}
(3)Spring配置文件配置数据库连接池,开启组件扫描等,创建JdbcTemplate类对象jdbcTemplate,将dateSource属性注入jdbcTemplate
<!-- 数据库连接池 -->
<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="root" />
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>
<!-- 配置JdbcTemplate对象,注入DataSource -->
<!-- JdbcTemplate对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入dataSource-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 开启组件扫描 -->
<context:component-scan base-package="com.atguigu"></context:component-scan>
(4)将dao作为属性注入BookService对象
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
}
将JdbcTemplate作为属性注入BookDaoImpl
package com.atguigu.spring5.dao;
@Repository
public class BookDaoImpl implements BookDao{
//注入JdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
}
2.2 JdbcTemplate操作数据库(添加)
对应数据库创建实体类
在com.atguigu.spring5下创建entity文件夹,包com.atguigu.spring5.entity 下创建Book类(代表Book数据表)
BookService类作为最外层来操作数据库的增删改查,BookDao类是BookService的属性,底层再封装jdbcTemplate实际操作数据库。Book是被操作的数据表
(1)为数据表创建实体类Book
package com.atguigu.spring5.entity;
public class Book{
private String userId;
private String username;
private String ustatus;
//空参构造器,有参构造器,get,set方法
public void setUserId(String userId){
this.userId=userId;
}
public void setUsername(String username){
this.username=username;
}
}
(2)对dao进行数据库添加操作,先在接口写一个抽象方法add(),表示向数据库添加数据
package com.atguigu.spring5.dao;
public interface BookDao{
//添加方法
void add(Book book);
}
实现类具体实现该方法
JdbcTemplate对象里面有一个update方法实现添加操作
语法:update(String sql,Object...args)
第一个参数:sql语句
第二个参数:可变参数,设置sql语句值
package com.atguigu.spring5.dao;
@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.getUserId(),book.getUsername(),book.getUstatus()};
int update=jdbcTemplate.update(sql,args);
System.out.println(update);
}
}
BookService类里面写添加方法。
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
}
(3)编写测试类
在com.atguigu.spring5文件夹下编写test文件夹(包com.atguigu.spring5)
package com.atguigu.spring5.test;
public class TestBook{
@Test
public void testJdbcTemplate(){
ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService",BookService.class);
Book book=new Book();//创建数据表
//设置好要添加的内容
book.setUserId("1");
book.setUsername("java");
book.setUstatus("a");
bookService.addBook(book);//向book数据表,添加1,java,a
}
}
2.3 jdbcTemplate数据库操作——修改
在BookService类添加后面,可直接写修改,和删除的方法。然后在Dao里面完成操作细节
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
//修改方法
public void updateBook(Book book){
bookDao.updateBook(book);
}
//删除方法
public void deleteBook(String id){
bookDao delete(id);
}
}
在接口中补上修改和删除的方法,同时实现类里面具体实现
package com.atguigu.spring5.dao;
public interface BookDao{
//添加方法
void add(Book book);
//修改方法
void updateBook(Book book);
//删除方法
void delete(String id);//根据id进行删除
}
实现类中
package com.atguigu.spring5.dao;
@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.getUserId(),book.getUsername(),book.getUstatus()};
int update=jdbcTemplate.update(sql,args);
System.out.println(update);
}
//修改方法
@Override
public void updateBook(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 where user_id=?";
int update = jdbcTemplate.update(sql, id);
System.out.println(update);
}
}
编写测试类
package com.atguigu.spring5.test;
public class TestBook{
@Test
public void testJdbcTemplate(){
ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService",BookService.class);
Book book=new Book();//创建数据表
//设置好要添加的内容
book.setUserId("1");
book.setUsername("javaup");
book.setUstatus("atguigu");
bookService.updateBook(book);//修改第一行
bookService.deleteBook("1");//再删除第一行
}
}
即可完成修改操作,修改后如上图所示,然后又会被bookService.deleteBook("1") 秒删除。
2.4 JdbcTemplate数据库操作——查询
2.4.1 查询的是某个返回值
exp1:使用JdbcTemplate实现查询表里有多少条记录
语法:public int queryForObject(String sql,Class<T> requiredType)
第一个参数:sql语句
第二个参数:返回类型的Class(类型指integer,string)
BookService里面继续添加查询数据表记录数的方法findCount
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
//修改方法
public void updateBook(Book book){
bookDao.updateBook(book);
}
//删除方法
public void deleteBook(String id){
bookDao delete(id);
}
//查询表记录数
public int findCount(){
bookDao.selectCount();
}
}
在接口中补充该方法,并在实现类中实现方法
package com.atguigu.spring5.dao;
public interface BookDao{
//添加方法
void add(Book book);
//修改方法
void updateBook(Book book);
//删除方法
void delete(String id);//根据id进行删除
//查询表记录数
int selectCount();
}
实现类,完成该方法
package com.atguigu.spring5.dao;
@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.getUserId(),book.getUsername(),book.getUstatus()};
int update=jdbcTemplate.update(sql,args);
System.out.println(update);
}
//修改方法
@Override
public void updateBook(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 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);
return count;
}
}
编写测试类,获取数据表的条目数
package com.atguigu.spring5.test;
public class TestBook{
@Test
public void testJdbcTemplate(){
ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService",BookService.class);
//获取数据表的条目数
int count=bookService.findCount();
System.out.println(count);
}
}
2.4.2 JdbcTemplate实现查询返回对象
exp2:用JdbcTemplate查询图书馆图书详情(根据id查询)
语法:public Object queryForObject(String sql,RowMapper<T> rowMapper, Object...args)
第一个参数:sql语句
第二个参数:RowMapper是接口,针对返回不同类型数据,使用这个接口里面实现类完成数据封装,框架已经帮我们写好了实现类BeanPropertyRowMapper<数据表类名>(数据表类对象,id),我们只管调用。就会返回对应id的book对象(id对应的行)
第三个参数:sql语句中?的值
在BookService里面创建根据id查询返回对象的方法 public Book findOne(String id)
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
//修改方法
public void updateBook(Book book){
bookDao.updateBook(book);
}
//删除方法
public void deleteBook(String id){
bookDao delete(id);
}
//查询表记录数
public int findCount(){
bookDao.selectCount();
}
//根据id值查询返回对象
public Book findOne(String id){
return bookDao.findBookInfo(id);
}
}
在接口里面写继续写查询方法
package com.atguigu.spring5.dao;
public interface BookDao{
//添加方法
void add(Book book);
//修改方法
void updateBook(Book book);
//删除方法
void delete(String id);//根据id进行删除
//查询表记录数
int selectCount();
//根据id查询返回对象
Book findBookInfo(String id);
}
在实现类中,完成该方法的具体实现(重点)
package com.atguigu.spring5.dao;
@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.getUserId(),book.getUsername(),book.getUstatus()};
int update=jdbcTemplate.update(sql,args);
System.out.println(update);
}
//修改方法
@Override
public void updateBook(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 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);
return count;
}
//根据查询返回对象
@Override
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);
return book;
}
}
做测试
package com.atguigu.spring5.test;
public class TestBook{
@Test
public void testJdbcTemplate(){
ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService",BookService.class);
//查询返回对象
Book book = bookService.findOne("1");
}
}
2.4.3 用JdbcTemplate方法实现查询返回集合
exp3:查询图书列表分页…
语法:public List<Object> query(String sql,RowMapper<T> rowMapper, Object...args)
第一个参数:sql语句
第二个参数:RowMapper是接口,针对返回不同类型数据,使用这个接口里面实现类完成数据封装,框架已经帮我们写好了实现类BeanPropertyRowMapper<数据表类名>(数据表类对象,id),我们只管调用。就会返回对应id的book对象(id对应的行)
第三个参数:sql语句中?的值
说明:形参和上面的返回对象一样,但是方法名和返回值不一样
BookService里面继续添加查询返回集合的方法
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
//修改方法
public void updateBook(Book book){
bookDao.updateBook(book);
}
//删除方法
public void deleteBook(String id){
bookDao delete(id);
}
//查询表记录数
public int findCount(){
bookDao.selectCount();
}
//根据id值查询返回对象
public Book findOne(String id){
return bookDao.findBookInfo(id);
}
//查询返回的集合
public List<Book> findAll(){
return bookDao.findAllBook();
}
}
在BookDao接口中,写下抽象方法
package com.atguigu.spring5.dao;
public interface BookDao{
//添加方法
void add(Book book);
//修改方法
void updateBook(Book book);
//删除方法
void delete(String id);//根据id进行删除
//查询表记录数
int selectCount();
//根据id查询返回对象
Book findBookInfo(String id);
//查询返回集合
List<Book> findAllBook();
}
在实现类中,完成方法具体实现
package com.atguigu.spring5.dao;
@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.getUserId(),book.getUsername(),book.getUstatus()};
int update=jdbcTemplate.update(sql,args);
System.out.println(update);
}
//修改方法
@Override
public void updateBook(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 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);
return count;
}
//根据查询返回对象
@Override
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);
return book;
}
@Override
public List<Book> findAllBook() {
String sql = "select * from t_book"; //调用方法
List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class)); //可以没有第三个参数
return bookList; }
}
做测试
package com.atguigu.spring5.test;
public class TestBook{
@Test
public void testJdbcTemplate(){
ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService",BookService.class);
//查询返回集合
List<Book> all=bookService.findAll();
System.out.println(all);
}
}
2.5 JdbcTemplate实现批量添加操作(批量操作就是操作多条记录)
2.5.1 批量添加
exp4 操作数据表里的多条记录
batchUpdate(String sql,List<Object[]> batchArgs)
第一个参数:sql语句
第二个参数:List集合,添加多条记录数据。每个List元素代表数据表的每一行(Object[]),每个Object[]元素又代表数据表的每一列
BookService里面继续添加查询返回集合的方法
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
//修改方法
public void updateBook(Book book){
bookDao.updateBook(book);
}
//删除方法
public void deleteBook(String id){
bookDao delete(id);
}
//查询表记录数
public int findCount(){
bookDao.selectCount();
}
//根据id值查询返回对象
public Book findOne(String id){
return bookDao.findBookInfo(id);
}
//查询返回的集合
public List<Book> findAll(){
return bookDao.findAllBook();
}
//批量添加
public void batchAdd(){
return bookDao.batchAddBook(batchArgs);
}
}
BookDao接口中添加抽象方法
package com.atguigu.spring5.dao;
public interface BookDao{
//添加方法
void add(Book book);
//修改方法
void updateBook(Book book);
//删除方法
void delete(String id);//根据id进行删除
//查询表记录数
int selectCount();
//根据id查询返回对象
Book findBookInfo(String id);
//查询返回集合
List<Book> findAllBook();
//批量添加
void batchAddBook(List<Object[]> batchArgs);
}
实现类中,完成方法具体实现
package com.atguigu.spring5.dao;
@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.getUserId(),book.getUsername(),book.getUstatus()};
int update=jdbcTemplate.update(sql,args);
System.out.println(update);
}
//修改方法
@Override
public void updateBook(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 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);
return count;
}
//根据查询返回对象
@Override
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);
return book;
}
@Override
public List<Book> findAllBook() {
String sql = "select * from t_book"; //调用方法
List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class)); //可以没有第三个参数
return bookList;
}
//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints)); }
}
做测试
package com.atguigu.spring5.test;
public class TestBook{
@Test
public void testJdbcTemplate(){
ApplicationContext context= new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService",BookService.class);
//批量添加
//创建一个List集合,元素是Object[]
List<Object[]> batchArgs = new ArrayList<>();
//创建3个 Object[]数组,添加好对象
Object[] o1 = {"3","java","a"};
Object[] o2 = {"4","c++","b"};
Object[] o3 = {"5","MySQL","c"};
//将3个数组添加入集合
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);
}
}
2.5.2 批量修改
语法:同批量增加
BookService里面继续添加查询返回集合的方法
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
//修改方法
public void updateBook(Book book){
bookDao.updateBook(book);
}
//删除方法
public void deleteBook(String id){
bookDao delete(id);
}
//查询表记录数
public int findCount(){
bookDao.selectCount();
}
//根据id值查询返回对象
public Book findOne(String id){
return bookDao.findBookInfo(id);
}
//查询返回的集合
public List<Book> findAll(){
return bookDao.findAllBook();
}
//批量添加
public void batchAdd(){
return bookDao.batchAddBook(batchArgs);
}
//批量修改
public void batchUpdate(List<Object[]> batchArgs){
bookDao batchUpdateBook(batchArgs);
}
}
进入BookDao接口,添加抽象方法
package com.atguigu.spring5.dao;
public interface BookDao{
//添加方法
void add(Book book);
//修改方法
void updateBook(Book book);
//删除方法
void delete(String id);//根据id进行删除
//查询表记录数
int selectCount();
//根据id查询返回对象
Book findBookInfo(String id);
//查询返回集合
List<Book> findAllBook();
//批量添加
void batchAddBook(List<Object[]> batchArgs);
//批量修改
void batchUpdateBook(List<Object> batchArgs);
}
实现类中完成具体方法
package com.atguigu.spring5.dao;
@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.getUserId(),book.getUsername(),book.getUstatus()};
int update=jdbcTemplate.update(sql,args);
System.out.println(update);
}
//修改方法
@Override
public void updateBook(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 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);
return count;
}
//根据查询返回对象
@Override
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);
return book;
}
@Override
public List<Book> findAllBook() {
String sql = "select * from t_book"; //调用方法
List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class)); //可以没有第三个参数
return bookList;
}
//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
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));
}
}
做测试
2.5.3 批量删除
BookService中添加批量删除的方法
pacakage com.atguigu.spring5.service;
@Service //通过注解创建对象
public class BookService{
//注入dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
//修改方法
public void updateBook(Book book){
bookDao.updateBook(book);
}
//删除方法
public void deleteBook(String id){
bookDao delete(id);
}
//查询表记录数
public int findCount(){
bookDao.selectCount();
}
//根据id值查询返回对象
public Book findOne(String id){
return bookDao.findBookInfo(id);
}
//查询返回的集合
public List<Book> findAll(){
return bookDao.findAllBook();
}
//批量添加
public void batchAdd(){
return bookDao.batchAddBook(batchArgs);
}
//批量修改
public void batchUpdate(List<Object[]> batchArgs){
bookDao batchUpdateBook(batchArgs);
}
//批量删除
public void batchDelete(List<Objedct[]> batchArgs){
bookDao.batchDeleteBook(batchArgs);
}
}
BookDao接口中添加方法
package com.atguigu.spring5.dao;
public interface BookDao{
//添加方法
void add(Book book);
//修改方法
void updateBook(Book book);
//删除方法
void delete(String id);//根据id进行删除
//查询表记录数
int selectCount();
//根据id查询返回对象
Book findBookInfo(String id);
//查询返回集合
List<Book> findAllBook();
//批量添加
void batchAddBook(List<Object[]> batchArgs);
//批量修改
void batchUpdateBook(List<Object> batchArgs);
//批量删除
void batchDeleteBook(List<Object> batchArgs);
}
实现类中完成具体实现
package com.atguigu.spring5.dao;
@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.getUserId(),book.getUsername(),book.getUstatus()};
int update=jdbcTemplate.update(sql,args);
System.out.println(update);
}
//修改方法
@Override
public void updateBook(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 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);
return count;
}
//根据查询返回对象
@Override
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);
return book;
}
@Override
public List<Book> findAllBook() {
String sql = "select * from t_book"; //调用方法
List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class)); //可以没有第三个参数
return bookList;
}
//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
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));
}
}
做测试