jdbcTemplate
介绍
Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作
准备工作
引入相关 jar 包
有的包，没用到是自己测试使用的就一并截图了
在 spring 配置文件配置数据库连接池
<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/book_db"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
配置 JdbcTemplate 对象，注入 DataSource
<!-- JdbcTemplate 对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入 dataSource-->
<property name="dataSource" ref="dataSource"/>
</bean>
组件扫描
<!-- 组件扫描 -->
<context:component-scan base-package="com.zjh.jdbc"/>
JdbcTemplate 操作数据库（增删改）
创建 实体，service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象，在 service 注入 dao
实体类
public class Book {
private String id;
private String bookName;
private String bookStatus;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public String getBookStatus() {
return bookStatus;
}
public void setBookStatus(String bookStatus) {
this.bookStatus = bookStatus;
}
}
dao接口
public interface BookDao {
/**
* 添加方法
* @param book 请求参数
*/
void add(Book book);
/**
* 修改方法
* @param book 请求参数
*/
void update(Book book);
/**
* 删除方法
* @param id 请求参数
*/
void delete(String id);
}
dao接口实现类
@Repository
public class BookDaoImpl implements BookDao{
/**
* 注入 JdbcTemplate
*/
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 添加方法
* @param book 请求参数
*/
@Override
public void add(Book book) {
// 创建sql语句
String sql = "insert into book values (?,?,?)";
// 调用方法实现
int update = jdbcTemplate.update(sql, book.getId(), book.getBookName(), book.getBookStatus());
System.out.println(update);
}
/**
* 修改方法
* @param book 请求参数
*/
@Override
public void update(Book book) {
// 修改sql语句
String sql = "update book set book_name = ?, book_status = ? where id = ?";
// 设置参数
Object[] args = {book.getBookName(), book.getBookStatus(), book.getId()};
int update = jdbcTemplate.update(sql, args);
System.out.println(update);
}
/**
* 删除方法
* @param id 请求参数
*/
@Override
public void delete(String id) {
// 删除sql语句
String sql = "delete from book where id = ?";
int update = jdbcTemplate.update(sql, id);
System.out.println(update);
}
}
service类
@Service
public class BookService {
/**
* 注入 dao
*/
@Autowired
private BookDao bookDao;
/**
* 添加方法
* @param book 请求参数
*/
public void addBook(Book book) {
bookDao.add(book);
}
/**
* 修改方法
* @param book 请求参数
*/
public void updBook(Book book) {
bookDao.update(book);
}
/**
* 删除方法
* @param id 请求参数
*/
public void delBook(String id) {
bookDao.delete(id);
}
}
测试类
public class BookTest {
/**
* 测试 jdbc 添加
*/
@Test
public void bookAddTest(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book();
book.setId("1");
book.setBookName("java");
book.setBookStatus("a");
bookService.addBook(book);
}
/**
* 测试 jdbc 修改
*/
@Test
public void bookUpdTest(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book();
book.setId("1");
book.setBookName("mysql");
book.setBookStatus("b");
bookService.updBook(book);
}
/**
* 测试 jdbc 删除
*/
@Test
public void bookDelTest(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
BookService bookService = context.getBean("bookService", BookService.class);
bookService.delBook("1");
}
}
JdbcTemplate 操作数据库（查询）
实体类添加 toString 方法
@Override
public String toString() {
return "Book{" +
"id='" + id + '\'' +
", bookName='" + bookName + '\'' +
", bookStatus='" + bookStatus + '\'' +
'}';
}
dao接口
/**
* 查询返回数据个数
* @return int
*/
int selectCount();
/**
* 查询返回对象
* @param id 请求参数
* @return Book
*/
Book findBookInfo(String id);
/**
* 查询返回集合
* @return List<Book>
*/
List<Book> findAllBook();
dao接口实现类
/**
* 查询返回数据个数
* @return int
*/
@Override
public int selectCount() {
String sql = "select count(*) from book";
return jdbcTemplate.queryForObject(sql, Integer.class);
}
/**
* 查询返回对象
* @param id 请求参数
* @return Book
*
* RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
*/
@Override
public Book findBookInfo(String id) {
String sql = "select * from book where id = ?";
// 调用方法
return jdbcTemplate.queryForObject(sql, new
BeanPropertyRowMapper<>(Book.class), id);
}
/**
* 查询返回集合
* @return List<Book>
*/
@Override
public List<Book> findAllBook() {
String sql = "select * from book";
//调用方法
return jdbcTemplate.query(sql, new
BeanPropertyRowMapper<>(Book.class));
}
service类
/**
* 查询返回数据个数
* @return int
*/
public int selectCount() {
return bookDao.selectCount();
}
/**
* 查询返回对象
* @param id 请求参数
* @return Book
*/
public Book findBookInfo(String id) {
return bookDao.findBookInfo(id);
}
/**
* 查询返回集合
* @return List<Book>
*/
public List<Book> findAllBook() {
return bookDao.findAllBook();
}
测试类
@Test
public void bookQueryTest(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
BookService bookService = context.getBean("bookService", BookService.class);
int count = bookService.selectCount();
System.out.println("数据个数为：" + count);
Book book = bookService.findBookInfo("1");
System.out.println("id为1的图书信息是：" + book.toString());
List<Book> bookList = bookService.findAllBook();
System.out.println("图书列表：" + bookList);
}
JdbcTemplate 操作数据库（批量操作）
dao接口
/**
* 批量添加
* @param batchArgs 请求参数
*/
void batchAddBook(List<Object[]> batchArgs);
/**
* 批量修改
* @param batchArgs 请求参数
*/
void batchUpdateBook(List<Object[]> batchArgs);
/**
* 批量删除
* @param batchArgs 请求参数
*/
void batchDeleteBook(List<Object[]> batchArgs);
dao接口实现类
/**
* 批量添加
* @param batchArgs 请求参数
*/
@Override
public void batchAddBook(List<Object[]> batchArgs) {
String sql = "insert into book values(?, ?, ?)";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
/**
* 批量修改
* @param batchArgs 请求参数
*/
@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
String sql = "update book set book_name = ?,book_status = ? where id = ?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
/**
* 批量删除
* @param batchArgs 请求参数
*/
@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
String sql = "delete from book where id = ?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
service类
/**
* 批量添加
* @param batchArgs 请求参数
*/
public void batchAddBook(List<Object[]> batchArgs) {
bookDao.batchAddBook(batchArgs);
}
/**
* 批量修改
* @param batchArgs 请求参数
*/
public void batchUpdateBook(List<Object[]> batchArgs) {
bookDao.batchUpdateBook(batchArgs);
}
/**
* 批量删除
* @param batchArgs 请求参数
*/
public void batchDeleteBook(List<Object[]> batchArgs) {
bookDao.batchDeleteBook(batchArgs);
}
测试类
/**
* 测试 jdbc 批量添加
*/
@Test
public void bookBatchAddTest(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
BookService bookService = context.getBean("bookService", BookService.class);
// 批量添加测试
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3","java","a"};
Object[] o2 = {"4","c++","b"};
Object[] o3 = {"5","MySQL","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
// 调用方法
bookService.batchAddBook(batchArgs);
}
/**
* 测试 jdbc 批量修改
*/
@Test
public void bookBatchUpdTest(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
BookService bookService = context.getBean("bookService", BookService.class);
// 批量修改
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.batchUpdateBook(batchArgs);
}
/**
* 测试 jdbc 批量删除
*/
@Test
public void bookBatchDelTest(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
BookService bookService = context.getBean("bookService", BookService.class);
// 批量删除
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3"};
Object[] o2 = {"4"};
batchArgs.add(o1);
batchArgs.add(o2);
// 调用方法实现批量删除
bookService.batchDeleteBook(batchArgs);
}