什么是 JdbcTemplate
Spring 框架对 JDBC 进行封装,使用 JdbcTemplate 更加方便实现对数据库操作
配置工作
引入jar包
配置xml文件
在 spring 配置文件配置数据库连接池
druidbean.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/beans/spring-context.xsd">
<!--直接配置连接池-->
<!--<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!– 获取properties文件内容,根据key获取,使用spring表达式获取 –>
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>-->
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!-- 获取properties文件内容,根据key获取,使用spring表达式获取 -->
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.username}"></property>
<property name="password" value="${prop.password}"></property>
</bean>
</beans>
jdbc.properties
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3308/springdb
prop.username=root
prop.password=
(3)配置 JdbcTemplate 对象,注入 DataSource
<!-- JdbcTemplate 对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入 dataSource-->
<property name="dataSource" ref="dataSource"></property>
</bean>
(4)创建 service 类,创建 dao 类,在 dao 注入 jdbcTemplate 对象
-
配置文件
<!-- 组件扫描 --> <context:component-scan base-package="com.atguigu"></context:component-scan>
⚫ Service
在服务层执行Dao层的方法@Service public class BookService { //注入 dao @Autowired private BookDao bookDao; }
⚫ Dao
在@Repository public class BookDaoImpl implements BookDao { //注入 JdbcTemplate @Autowired private JdbcTemplate jdbcTemplate; }
创建数据库对应实体类
Book
扫描二维码关注公众号,回复: 11728835 查看本文章package com.amhu.yx.spring.dao; public class Book { private String bookId; private String bookName; private String bookStatus; public void setBookId(String bookId) { this.bookId = bookId; } public void setBookName(String bookName) { this.bookName = bookName; } public void setBookStatus(String bookStatus) { this.bookStatus = bookStatus; } public String getBookId() { return bookId; } public String getBookName() { return bookName; } public String getBookStatus() { return bookStatus; } }
添加数据
编写 dao和 service
在BookDao
接口中添加insert()
方法,
public interface BookDao {
public void insert(Book book);
}
在BookDaoImpl
中添加insert
方法具体逻辑
调用 JdbcTemplate 对象里面 update
方法实现添加操作
update (String sql, Object[] args)
- 有两个参数
- 第一个参数:sql 语句
- 第二个参数:可变参数,设置 sql 语句值
在@Repository public class BookDaoImpl implements BookDao { //注入JDBCTemplate @Autowired private JdbcTemplate jdbcTemplate; //向数据库中添加数据的方法 @Override public void insert(Book book) { //1.添加数据的sql语句 String sql = "insert into t_book vlaues(?,?,?)"; //2.调用方法实现 Object[] args = { book.getBookId(), book.getBookName(), book.getBookStatus()}; //3.执行sql语句,并返回改变表中数据的行数 int update = jdbcTemplate.update(sql, args); System.out.println(update); } }
BookService
中通过BookDao
对象调用insert
方法@Service public class BookService { //注入dao @Autowired private BookDao bookDao; //添加方法 public void insertBook(Book book){ bookDao.insert(book); } }
测试代码:
public class TestJdbcTemplate {
@Test
public void testJdbcTemplate(){
ApplicationContext context =
new ClassPathXmlApplicationContext("druidbean.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book();
book.setBookId("1");
book.setBookName("Java编程思想");
book.setBookStatus("阅读中");
bookService.insertBook(book);
}
}
修改和删除
1、修改
@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);
}
2、删除
@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);
}
查询数据
结果返回一个值
queryForObject(String sql, Class<T> requiredType)
String sql : sql查询语句
Class requiredType : 返回类型Class
我门可以通过如下代码查询表中有多少条记录,结果返回一个数字:
//查询表记录数
@Override
public int selectCount() {
String sql = "select count(*) from t_book";
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
return count;
}
结果返回一个对象
queryForObject(String sql, RowMapper<T> rowMapper, Object... args)
- 第一个参数:sql 语句
- 第二个参数:RowMapper 是接口,针对返回不同类型数据,使用这个接口里面实现类完成
数据封装 - 第三个参数:sql 语句值
可以通过下面的代码查询一本书的详细信息,查询结果返回一个book对象
//查询返回对象
@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;
}
结果返回一个集合
query(String sql, RowMapper<T> rowMapper, Object... args)
- 第一个参数:sql 语句
- 第二个参数:RowMapper 是接口,针对返回不同类型数据,使用这个接口里面实现类完成
数据封装 - 第三个参数:sql 语句值
可以通过下面的代码查询图书列表分页,结果返回一个集合
//查询返回集合
@Override
public List<Book> findAllBook() {
String sql = "select * from t_book";
//调用方法
List<Book> bookList = jdbcTemplate.query(sql, new
BeanPropertyRowMapper<Book>(Book.class));
return bookList;
}
批量操作数据
1、批量操作:操作表里面多条记录
2、JdbcTemplate 实现批量添加操作
⚫ 有两个参数
⚫ 第一个参数:sql 语句
⚫ 第二个参数:List 集合,添加多条记录数据
//批量添加
@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));
}
//批量添加测试
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.batchAdd(batchArgs);
3、JdbcTemplate 实现批量修改操作
注意,修改时
Object[] o1 = {
"java0909","a3","3"};
Object[] o2 = {
"c++1010","b4","4"};
Object[] o3 = {
"MySQL1111","c5","5"};
中元素顺序要与sql语句代码元素顺序相同:update t_book set bookname=?,bookstatus=? where bookid=?
//批量修改
@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);
4、JdbcTemplate 实现批量删除操作
//批量删除
@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);
完整代码:
先来分析一下,
首先在dao层定义一个接口,里面规范了各种方法,然后定义一个实现类实现该接口,完善代码(JdbcTemplate)。
在service层定义一个实现类的对象,调用实现类的方法。
需要操作数据库时,只需要操作service层的对象就可以了。
druidbean.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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">
<!--组件扫描-->
<context:component-scan base-package="com.amhu.yx.spring"></context:component-scan>
<!--直接配置连接池-->
<!--<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!– 获取properties文件内容,根据key获取,使用spring表达式获取 –>
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>-->
<!--引入外部属性文件-->
<!--<context:property-placeholder location="classpath:jdbc.properties"/>-->
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
destroy-method="close">
<property name="url" value="jdbc:mysql://localhost:3308/springdb" />
<property name="username" value="root" />
<property name="password" value="" />
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>
<!-- JdbcTemplate 对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入 dataSource-->
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>
BookDao.java
package com.amhu.yx.spring.dao;
import java.util.List;
public interface BookDao {
public void insert(Book book);
public void update(Book book);
public void delete(String id);
public int selectCount();//查询数据库表中有多少条数据
public Book queryBookInfo(String id);//根据书的id查询一本书的信息
public List<Book> queryBookPage();//查询一页图书
public void batchAddBook(List<Object[]> batchArgs);//批量添加数据
public void batchUpdateBook(List<Object[]> batchArgs);
public void batchDeleteBook(List<Object[]> batchArgs);
}
BookDaoImpl.java
package com.amhu.yx.spring.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.Arrays;
import java.util.List;
@Repository
public class BookDaoImpl implements BookDao {
//注入JDBCTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
//向数据库中添加数据的方法
@Override
public void insert(Book book) {
//1.添加数据的sql语句
String sql = "insert into t_book values(?,?,?)";
//2.调用方法实现
Object[] args = {
book.getBookId(), book.getBookName(), book.getBookStatus()};
//3.执行sql语句,并返回改变表中数据的行数
int update = jdbcTemplate.update(sql, args);
System.out.println(update);
}
//修改数据库中数据
@Override
public void update(Book book) {
String sql = "update t_book set bookid=?, bookname=?, bookstatus=?";
Object[] args = {
book.getBookId(), book.getBookName(), book.getBookStatus()};
int update =jdbcTemplate.update(sql, args);
System.out.println(update);
}
//删除数据库中数据
@Override
public void delete(String id) {
String sql = "delete from t_book where bookid=?";
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;
}
//根据id来查询信息
@Override
public Book queryBookInfo(String id) {
String sql = "select * from t_book where bookid=?";
Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class),id);
return book;
}
//一次查询一页数据
@Override
public List<Book> queryBookPage() {
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 bookname=?,bookstatus=? where bookid=?";
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 bookid=?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
}
BookService.java
package com.amhu.yx.spring.service;
import com.amhu.yx.spring.dao.Book;
import com.amhu.yx.spring.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Collections;
import java.util.List;
@Service
public class BookService {
//注入dao
@Autowired
private BookDao bookDao;
//添加数据
public void insertBook(Book book){
bookDao.insert(book);
}
//修改数据
public void updateBook(Book book){
bookDao.update(book);
}
//删除数据
public void deleteBook(String id){
bookDao.delete(id);
}
//查询数据库表中有多少条数据
public void queryBookCount(){
int count = bookDao.selectCount();
System.out.println(count);
}
//查询一本书的相信信息
public void queryBookInfo(String id){
Book book = bookDao.queryBookInfo(id);
System.out.println("bookid:" + book.getBookId());
System.out.println("bookname:" + book.getBookName());
System.out.println("bookstatus:" + book.getBookStatus());
}
//查询一页图书信息
public void queryBookPage(){
List<Book> bookList = bookDao.queryBookPage();
for (Book book : bookList) {
System.out.println("bookid:" + book.getBookId());
System.out.println("bookname:" + book.getBookName());
System.out.println("bookstatus:" + book.getBookStatus());
System.out.println();
}
}
//批量添加数据
public void batchAddBook(List<Object[]> batchArgs){
bookDao.batchAddBook(batchArgs);
}
//批量修改数据`在这里插入代码片`
public void batchUpdateBook(List<Object[]> batchArgs){
bookDao.batchUpdateBook(batchArgs);
}
//批量删除数据
public void batchDeleteBook(List<Object[]> batchArgs){
bookDao.batchDeleteBook(batchArgs);
}
}
TestJdbcTemplate.java
package com.amhu.yx.spring.test;
import com.amhu.yx.spring.dao.Book;
import com.amhu.yx.spring.service.BookService;
import javafx.application.Application;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.ArrayList;
import java.util.List;
public class TestJdbcTemplate {
ApplicationContext context = new ClassPathXmlApplicationContext("druidbean.xml");
//测试添加数据
@Test
public void testInsert(){
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book();
book.setBookId("1");
book.setBookName("Java 编程思想");
book.setBookStatus("阅读中");
bookService.insertBook(book);
}
@Test
public void testUpdate(){
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book();
book.setBookId("1");
book.setBookName("Thinking In Java");
book.setBookStatus("Reading");
bookService.updateBook(book);
}
@Test
public void testDelete(){
BookService bookService = context.getBean("bookService", BookService.class);
bookService.deleteBook("1");
}
@Test
public void testSelectCount() {
BookService bookService = context.getBean("bookService", BookService.class);
bookService.queryBookCount();
}
@Test
public void testQueryBookInfo(){
BookService bookService = context.getBean("bookService", BookService.class);
bookService.queryBookInfo("1");
}
@Test
public void testQueryBookPage(){
BookService bookService = context.getBean("bookService", BookService.class);
bookService.queryBookPage();
}
//批量添加数据
@Test
public void testBatchAddBook(){
BookService bookService = context.getBean("bookService", BookService.class);
List<Object[]> batchArgs = new ArrayList<>();
Object[] book1 = {
"3", "Python", "a"};
Object[] book2 = {
"4", "Scala", "b"};
Object[] book3 = {
"5", "C++", "c"};
batchArgs.add(book1);
batchArgs.add(book2);
batchArgs.add(book3);
bookService.batchAddBook(batchArgs);
}
//批量修改数据
@Test
public void testBatchUpdateBook(){
BookService bookService = context.getBean("bookService", BookService.class);
List<Object[]> batchArgs = new ArrayList<>();
Object[] book1 = {
"A","Python","3"};
Object[] book2 = {
"B","S","4"};
Object[] book3 = {
"C","C","5"};
batchArgs.add(book1);
batchArgs.add(book2);
batchArgs.add(book3);
bookService.batchUpdateBook(batchArgs);
}
//批量删除数据
@Test
public void testBatchDeleteBook(){
BookService bookService = context.getBean("bookService", BookService.class);
List<Object[]> batchArgs = new ArrayList<>();
Object[] book1 = {
"3"};
Object[] book2 = {
"4"};
Object[] book3 = {
"5"};
batchArgs.add(book1);
batchArgs.add(book2);
batchArgs.add(book3);
bookService.batchDeleteBook(batchArgs);
}
}