10、Spring5-jdbctemplate对数据库的操作
作者：互联网
1、JDBCTemplate(概念和相关准备工作)
1、什么是jdbctemplate
（1）Spring 框架对JDBC 进行封装，使用JdbcTemplate可以很方便的实现对数据库的操作
2、准备工作
（1）引入相关jar包（依赖）
mysql-connector-java-jar
spring-jdbc-jar Spring对jdbc做封装
spring-tx-jar Spring针对事务的相关依赖
spring-orm.jar 使用Spring整合其他框架，如mybaits等数据库需要引入的依赖
（2）在spring配置文件中配置数据库连接池
配置文件 jdbc.properties 如下：
prop.driverClass=com.mysql.cj.jdbc.Driver prop.url=jdbc:mysql://localhost:3306/test prop.userName=root prop.password=124869 #在属性名当前最好加prop用于区分不会冲突
在spring配置文件中的配置如下：
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置数据库连接池-->
<!-- DruidDataSource dataSource = new DruidDataSource(); -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!-- dataSource.setDriverClassName("com.mysql.jdbc.Driver");
set方法注入
-->
<!-- 获取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>
（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.spring5"></context:component-scan>
在Service中
@Service
public class BookService {
//注入Dao
@Autowired
private BookDao bookDao;
}
在Dao中
@Autowired
public class BookDaoImpl implements BookDao{
//注入jdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
}
2、使用jdbcTemplate操作数据库
（1）jdbcTemplate对数据库的添加操作
1、对应数据库表创建实体类
public class Book {
private int bookId;
private String bookName;
private String author;
下面还有get、set方法
2、编写service和dao
（1）在dao进行数据库添加操作
（2）调用jdbcTemplate对象里的update方法实现添加操作
update(String sql,Object... args)
两个参数：
第一个参数：sql语句
第二个参数：可变参数，设置sql语句的占位符的值
BookService 如下：
@Service
public class BookService {
//注入Dao
@Autowired
private BookDao bookDao;
//添加方法
public void addBook(Book book){
bookDao.add(book);
}
}
BookDao修改操作 如下：
@Repository
public class BookDaoImpl implements BookDao{
//注入jdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void add(Book book) {
String sql = "insert into t_book values(?,?,?)";
Object[] args={ book.getBookId(), book.getBookName(), book.getAuthor()};
//调用jdbcTemplate.update(sql,args)方法
int update = jdbcTemplate.update(sql,args);
System.out.println(update);
}
}
测试类
@Test
public void testAdd(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
BookService service = context.getBean("bookService", BookService.class);
Book book = new Book();
book.setBookId(1);
book.setBookName("活着");
book.setAuthor("余华");
service.addBook(book);
}
（2）jdbcTemplate对数据库的修改和删除操作
在BookDao中添加修改和删除功能（步骤与添加基本一致）
//修改的方法
@Override
public void updateBook(Book book) {
String sql = "update t_book set book_name=?,author=? where book_id=?";
Object[] args={ book.getBookName(), book.getAuthor(),book.getBookId()};
int update = jdbcTemplate.update(sql, args);
System.out.println(update);
}
//删除的方法
@Override
public void deleteBook(int id) {
String sql = "delete from t_book where book_id=?";
int update = jdbcTemplate.update(sql, id);
System.out.println(update);
}
在BookService中调用BookDao的修改和删除方法
//修改的方法
public void updateBook(Book book){
bookDao.updateBook(book);
}
//删除的方法
public void deleteBook(int id){
bookDao.deleteBook(id);
}
增删改三个操作基本步骤是一样的，只是sql语句不一样。
（3）jdbcTemplate对数据库的查询操作（查询返回某个值）
1、如：查询表中有多少条记录，返回的是某个值
2、使用 jdbcTamplate 实现查询返回某个值代码
使用 jdbcTemplate 中的 queryForObject(String sql,Class<T> requiredType) 方法
两个参数：一个是sql语句，一个是返回类型的class
service中的查询方法如下：
//查询表中的记录数
public int findCount(){
return bookDao.selectCount();
}
dao中的查询方法如下：
//查询返回某个值
@Override
public int selectCount() {
String sql="select count(*) from t_book";
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);//Integer.class是返回什么类型的值就传入什么类型
return count;
}
（4）jdbcTemplate对数据库的查询操作（查询返回对象）
1、如：查询图书的详情页面，返回的是一个对象
2、使用 JdbcTemplate 实现查询返回对象
使用 
有三个参数：
第一个参数是sql语句，
第二个参数是RowMapper，是接口，返回不同类型数据，使用这个接口里面的实现类完成数据的封装
第三个参数是传递sql语句的占位符的值
dao中的方法如下：
//查询返回对象
@Override
public Book FindBookInfo(int id) {
String sql = "select * from t_book where book_id=?";
Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
//new BeanPropertyRowMapper<Book>(Book.class)是rowMapper的一个实现类，完成数据的封装
return book;
}
（5）jdbcTemplate对数据库的查询操作（查询返回集合）
1、如：查询图书列表（多条数据）
2、调用 JdbcTemplate 方法实现查询返回集合
使用
有三个参数：
第一个参数是sql语句，
第二个参数是RowMapper，是接口，返回不同类型数据，使用这个接口里面的实现类完成数据的封装
第三个参数是传递sql语句的占位符的值
dao中的代码如下：
//查询返回集合
@Override
public List<Book> findAllBook() {
String sql = "select * from t_book";
List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
return bookList;
}
（6）JdbcTemplate 对数据库的批量添加功能
1、批量操作：指的是操作表中的多条记录
2、JdbcTemplate实现批量添加操作
使用的是
有两个参数：
第一个参数：sql语句
第二个参数：list集合，添加多条记录数据
dao中的代码如下：
//批量添加操作
@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));
}
测试如下：
@Test
public void testBatchAdd(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
BookService service = context.getBean("bookService", BookService.class);
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {4,"java","a"};
Object[] o2 = {5,"c++","b"};
Object[] o3 = {6,"python","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加方法
service.batchAdd(batchArgs);
}
（7）JdbcTemplate 对数据库的批量修改删除功能
1、批量修改
dao中的代码实现如下：
//批量添加
@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
String sql = "update t_book set book_name=?,author=? where book_id=?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
测试如下：
@Test
public void testBatchUpdate(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
BookService service = context.getBean("bookService", BookService.class);
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"java_update","a",3};
Object[] o2 = {"c++_update","b",4};
Object[] o3 = {"python_update","c",5};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量修改
service.batchUpdate(batchArgs);
}
2、批量删除
dao实现如下：
//批量删除方法
@Override
public void batchDelete(List<Object[]> batchArgs) {
String sql = "delete from t_book where book_id=?";
jdbcTemplate.batchUpdate(sql,batchArgs);
}
测试如下：
@Test
public void testBatchDlete(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
BookService service = context.getBean("bookService", BookService.class);
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {3};
Object[] o2 = {4};
batchArgs.add(o1);
batchArgs.add(o2);
//调用批量修改
service.batchDelete(batchArgs);
}
可见批量操作的sql语句和单独操作的sql语句是一样的，只不过对循环部分进行了封装。
标签：10,update,book,jdbcTemplate,sql,Spring5,public,batchArgs,jdbctemplate 来源： https://www.cnblogs.com/zhuowen/p/16341478.html