Spring中的JdbcTemplate

最新推荐文章于 2023-09-08 10:46:26 发布

JoeyChanYC

最新推荐文章于 2023-09-08 10:46:26 发布

阅读量249

点赞数 1

分类专栏： Spring学习

本文链接：https://blog.csdn.net/qq_40867650/article/details/103065155

版权

Spring学习专栏收录该内容

20 篇文章 0 订阅

订阅专栏

SpringMVC学习记录文章目录：
1、程序的耦合和解耦思路
2、使用springIOC解决程序耦合的前期准备
3、BeanFactory和ApplicationContext的区别及ApplicationContext接口的实现类
4、bean标签及其实例化的3种方式
5、bean的作用范围和生命周期
6、Spring的依赖注入
7、基于注解的IOC环境搭建
8、基于注解的IOC-常用注解（Spring2.5规范）
9、Spring常用注解-新（Spring2.5规范以上）
10、Spring整合Junit单元测试
11、AOP的相关概念
12、Spring中AOP的术语
13、SpringAOP常用标签解释说明
14、SpringAOP中切入点表达式说明
15、SpringAOP类型说明及环绕通知的特殊说明
16、基于xml的SpringAOP配置
17、SpringAOP常用注解
18、基于注解的SpringAOP配置
19、Spring中的JdbcTemplate
20、Spring中的事务控制

1.JdbcTemplate概述

它是spring框架中提供的一个对象，是对原始Jdbc API对象的简单封装。spring框架提供了很多的操作模板类，入下图所示：
在这里插入图片描述
在spring-jdbc-4.24.RELEASE.jar中，我们在导包的时候，除了要导入这个jar包外，还需要导入一个spring-tx-4.2.4.RELEASE.jar（它是和事务相关的）。

2.JdbcTemplate对象的创建

可以参考它的源码，来一探究竟：

public JdbcTemplate() {
	}

	public JdbcTemplate(DataSource dataSource) {
		setDataSource(dataSource);
		afterPropertiesSet();
	}

	public JdbcTemplate(DataSource dataSource, boolean lazyInit) {
		setDataSource(dataSource);
		setLazyInit(lazyInit);
		afterPropertiesSet();
	}

除了默认构造函数之外，都需要提供一个数据源。既然有set方法，依据我们之前学过的依赖注入，我们可不可以在配置文件中配置呢？
答案是肯定的。

3.spring中配置数据源

3.1 环境搭建

在这里插入图片描述

3.2 编写spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    	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">
	
</beans>

3.3 配置数据源

一个是C3P0，一个是DBCP。要想使用这两数据源都需要导入对应的jar包。

3.3.1 配置C3P0数据源

导入jar包
在这里插入图片描述
在spring的配置文件中配置

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
	<property name="jdbcUrl" value="jdbc:mysql:///day_spring04"></property>
	<property name="user" value="root"></property>
	<property name="password" value="123456"></property>
</bean>

3.3.2 配置DBCP数据源

导入jar包
在这里插入图片描述
在spring的配置文件中配置：

<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	<property name="url" value="jdbc:mysql:// /day_spring04"></property>
	<property name="username" value="root"></property>
	<property name="password" value="123456"></property>
</bean>

3.3.3 配置spring内置数据源

spring框架也提供了一个内置数据源，也可以使用spring的内置数据源，它就在spring-jdbc-4.2.4.REEASE.jar包中：

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	<property name="url" value="jdbc:mysql:///day_spring04"></property>
	<property name="username" value="root"></property>
	<property name="password" value="123456"></property>
</bean>

3.4 将数据库连接的信息配置到属性文件中:

定义属性文件

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///day_spring04
jdbc.username=root
jdbc.password=123456

引入外部的属性文件

一种方式:
    <!-- 引入外部属性文件： -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    	<property name="location" value="classpath:jdbc.properties"/>
    </bean>

二种方式:
<context:property-placeholder location="classpath:jdbc.properties"/>

4 JdbcTemplate的增删改查操作

4.1 前期准备

创建数据库：
create database day_spring04;
use day_spring04;
创建表：
create table account(
	id int primary key auto_increment,
	name varchar(40),
	money float
)character set utf8 collate utf8_general_ci;

4.2 在spring配置文件中配置JdbcTemplate

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    	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">

	<!-- 配置一个数据库的操作模板：JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
<!-- 配置数据源 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	<property name="url" value="jdbc:mysql:///day_spring04"></property>
	<property name="username" value="root"></property>
	<property name="password" value="123456"></property>
</bean>
</beans>

4.3 基本使用

public class JdbcTemplateDemo2 {
	public static void main(String[] args) {
		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		jt.execute("insert into account(name,money)values('eee',500)");
	}
}

4.4 保存操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {

		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//保存
		jt.update("insert into account(name,money)values(?,?)","fff",5000);
	}
}

4.5 更新操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {

		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//修改
		jt.update("update account set money = money-? where id = ?",300,6);
	}
}

4.6 删除操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {

		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//删除
		jt.update("delete from account where id = ?",6);
	}
}

4.7 查询所有操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {

		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//查询所有
		List<Account> accounts = jt.query("select * from account where money > ? ", 
											new AccountRowMapper(), 500);
		for(Account o : accounts){
			System.out.println(o);
		}
	}

}

public class AccountRowMapper implements RowMapper<Account>{
	@Override
	public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
		Account account = new Account();
		account.setId(rs.getInt("id"));
		account.setName(rs.getString("name"));
		account.setMoney(rs.getFloat("money"));
		return account;
	}
	
}

4.8 查询一个操作

//使用RowMapper的方式：常用的方式
public class JdbcTemplateDemo3 {
	public static void main(String[] args) {

		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//查询一个
		List<Account> as = jt.query("select * from account where id = ? ", 
										new AccountRowMapper(), 55);
		System.out.println(as.isEmpty()?"没有结果":as.get(0));
	}
}

//使用ResultSetExtractor的方式:不常用的方式
public class JdbcTemplateDemo3 {
	public static void main(String[] args) {

		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//查询一个
		Account account = jt.query("select * from account where id = ?",
									new AccountResultSetExtractor(),3);
		System.out.println(account);
	}
}

4.9 查询返回一行一列操作

public class JdbcTemplateDemo3 {
	public static void main(String[] args) {

		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取bean对象
		JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");
		//3.执行操作
		//查询返回一行一列：使用聚合函数，在不使用group by字句时，都是返回一行一列。最长用的就是分页中获取总记录条数
		Integer total = jt.queryForObject("select count(*) from account where money > ? ",Integer.class,500);
		System.out.println(total);
	}
}

5.在dao中使用JdbcTemplate

5.1 准备实体类

/**
 * 账户的实体
 */
public class Account implements Serializable {

	private Integer id;
	private String name;
	private Float money;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Float getMoney() {
		return money;
	}
	public void setMoney(Float money) {
		this.money = money;
	}
	@Override
	public String toString() {
		return "Account [id=" + id + ", name=" + name + ", money=" + money + "]";
	}
}

5.2 第一种方式：在dao中定义JdbcTemplate

/**
 * 账户的接口
 */
public interface IAccountDao {
	
	/**
	 * 根据id查询账户信息
	 * @param id
	 * @return
	 */
	Account findAccountById(Integer id);

	/**
	 * 根据名称查询账户信息
	 * @return
	 */
	Account findAccountByName(String name);
	
	/**
	 * 更新账户信息
	 * @param account
	 */
	void updateAccount(Account account);
}

/**
 * 账户的持久层实现类
 * 此版本的dao，需要给dao注入JdbcTemplate
 */
public class AccountDaoImpl implements IAccountDao {

	private JdbcTemplate jdbcTemplate;
	
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	@Override
	public Account findAccountById(Integer id) {
		List<Account> list =  jdbcTemplate.query("select * from account where id = ? ",new AccountRowMapper(),id);
		return list.isEmpty()?null:list.get(0);
	}

	@Override
	public Account findAccountByName(String name) {
		List<Account> list =  jdbcTemplate.query("select * from account where name = ? ",new AccountRowMapper(),name);
		if(list.isEmpty()){
			return null;
		}
		if(list.size()>1){
			throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
		}
		return list.get(0);
	}

	@Override
	public void updateAccount(Account account) {
		jdbcTemplate.update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
	}

}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    	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">
	
	<!-- 配置一个dao -->
	<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
		<!-- 注入jdbcTemplate -->
		<property name="jdbcTemplate" ref="jdbcTemplate"></property>
	</bean>
	
	<!-- 配置一个数据库的操作模板：JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 配置数据源 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql:///day_spring04"></property>
		<property name="username" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>
</beans>

思考： 此种方式有什么问题吗?
答案：
有个小问题。就是我们的dao有很多时，每个dao都有一些重复性的代码。下面就是重复代码：
private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
	this.jdbcTemplate = jdbcTemplate;
}
能不能把它抽取出来呢？（用下面的另一种方式）

5.3 第二种方式：让dao继承JdbcDaoSupport

JdbcDaoSupport是spring框架提供的一个类，该类中定义了一个JdbcTemplate对象，可以直接获取使用，但是要想创建该对象，需要为其提供一个数据源：具体源码如下：

public abstract class JdbcDaoSupport extends DaoSupport {
	//定义对象
	private JdbcTemplate jdbcTemplate; 
	//set方法注入数据源，判断是否注入了，注入了就创建JdbcTemplate
	public final void setDataSource(DataSource dataSource) {
	if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) {				//如果提供了数据源就创建JdbcTemplate
			this.jdbcTemplate = createJdbcTemplate(dataSource);
			initTemplateConfig();
		}
	}
	//使用数据源创建JdcbTemplate
	protected JdbcTemplate createJdbcTemplate(DataSource dataSource) {
		return new JdbcTemplate(dataSource);
	}
	
	//当然，我们也可以通过注入JdbcTemplate对象
	public final void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
		initTemplateConfig();
	}
	//使用getJdbcTmeplate方法获取操作模板对象
	public final JdbcTemplate getJdbcTemplate() {
	  return this.jdbcTemplate;
	}

/**
 * 账户的接口
 */
public interface IAccountDao {
	
	/**
	 * 根据id查询账户信息
	 * @param id
	 * @return
	 */
	Account findAccountById(Integer id);

	/**
	 * 根据名称查询账户信息
	 * @return
	 */
	Account findAccountByName(String name);
	
	/**
	 * 更新账户信息
	 * @param account
	 */
	void updateAccount(Account account);
}

/**
 * 账户的持久层实现类
 * 此版本dao，只需要给它的父类注入一个数据源
 */
public class AccountDaoImpl2 extends JdbcDaoSupport implements IAccountDao {

	@Override
	public Account findAccountById(Integer id) {
		//getJdbcTemplate()方法是从父类上继承下来的。
		List<Account> list = getJdbcTemplate().query("select * from account where id = ? ",new AccountRowMapper(),id);
		return list.isEmpty()?null:list.get(0);
	}

	@Override
	public Account findAccountByName(String name) {
		//getJdbcTemplate()方法是从父类上继承下来的。
		List<Account> list =  getJdbcTemplate().query("select * from account where name = ? ",new AccountRowMapper(),name);
		if(list.isEmpty()){
			return null;
		}
		if(list.size()>1){
			throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
		}
		return list.get(0);
	}

	@Override
	public void updateAccount(Account account) {
		//getJdbcTemplate()方法是从父类上继承下来的。
		getJdbcTemplate().update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
	}
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    	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">
	
<!-- 配置dao2 -->
<bean id="accountDao2" class="com.itheima.dao.impl.AccountDaoImpl2">
	<!-- 注入dataSource -->
	<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	<property name="url" value="jdbc:mysql:///day_spring04"></property>
		<property name="username" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>
</beans>

思考： 两版Dao有什么区别呢？
答案：
第一种在Dao类中定义JdbcTemplate的方式，适用于所有配置方式（xml和注解都可以）。
第二种让Dao继承JdbcDaoSupport的方式，只能用于基于XML的方式，注解用不了。

JoeyChanYC

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring中的JdbcTemplate

1.JdbcTemplate概述它是spring框架中提供的一个对象，是对原始Jdbc API对象的简单封装。spring框架提供了很多的操作模板类，入下图所示：在spring-jdbc-4.24.RELEASE.jar中，我们在导包的时候，除了要导入这个jar包外，还需要导入一个spring-tx-4.2.4.RELEASE.jar（它是和事务相关的）。2.JdbcTemplate对象...
复制链接

扫一扫