【Spring】基础入门篇(十一) SpringJDBC之JdbcTemplate

Spring·基础入门篇(十一) SpringJDBC之JdbcTemplate

---

1. JdbcTemplate 概述

它是 Spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。

Spring 框架为我们提供了很多的操作模板类。

• 操作关系型数据的：
  JdbcTemplate
  HibernateTemplate
• 操作 nosql 数据库的：
  RedisTemplate
• 操作消息队列的：
  JmsTemplate

spring-jdbc-5.0.2.RELEASE.jar
spring-tx-5.0.2.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. 简单入门使用

public static void main(String[] args) {
	//准备数据源：spring的内置数据源
    DriverManagerDataSource ds = new DriverManagerDataSource();
    ds.setDriverClassName("com.mysql.jdbc.Driver");
    ds.setUrl("jdbc:mysql://localhost:3306/test");
    ds.setUsername("root");
    ds.setPassword("123456");
    //1.创建JdbcTemplate对象
    JdbcTemplate jt = new JdbcTemplate();
    //给jt设置数据源
    jt.setDataSource(ds);
    //2.执行操作
    jt.execute("insert into account(name,money)values('ccc',1000)");
}

3. 整合Spring中使用

3.1 导入jar包

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
</dependencies>

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 配置数据源

使用 Spring 内置数据源

<!-- 配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/test"></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:///spring_day02
jdbc.username=root
jdbc.password=123

引入外部属性文件：

• 第一种：

 <!-- 引入外部属性文件： -->
 <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 table account(
	id int primary key auto_increment,
	name varchar(40),
	money float
)character set utf8 collate utf8_general_ci;

/**
 * @author: LzCc
 * @blog: https://blog.csdn.net/qq_41744145
 * @description: 账户的实体类
 */
public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;
	// getter、setter
}

4.2 在 spring 配置文件中配置 JdbcTemplate

<!-- 配置一个数据库的操作模板：JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"></property>
</bean>

4.3 获取 JdbcTemplate 对象

//1.获取 Spring 容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据 id 获取 bean 对象
JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

4.4 保存操作

jt.execute("insert into account(name,money)values('eee',500)");

使用占位符 ? :

jt.update("insert into account(name,money)values(?, ?)","fff",5000);

4.5 更新操作

jt.update("update account set money = money-? where id = ?", 300, 6);

4.6 删除操作

jt.update("delete from account where id = ?", 6);

4.7 查询所有操作

• 自己定义Account的封装策略：

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;
}

List<Account> accounts = jt.query("select * from account where money > ? ", new AccountRowMapper(), 500);
for(Account o : accounts){
	System.out.println(o);
}

• 使用 BeanPropertyRowMapper 的封装策略

List<Account> accounts = jt.query("select * from account where money > ?",new BeanPropertyRowMapper<Account>(Account.class), 1000f);
for(Account account : accounts){
	System.out.println(account);
}

4.8 查询一个操作

• 使用 RowMapper 的方式：

//查询一个
List<Account> as = jt.query("select * from account where id = ? ", new AccountRowMapper(), 55);
System.out.println(as.isEmpty()?"没有结果":as.get(0));

• 使用 BeanPropertyRowMapper 的方式:

//查询一个
List<Account> accounts = jt.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class), 1);
System.out.println(accounts.isEmpty()?"没有结果":accounts.get(0));

4.9 查询返回一行一列操作

//查询返回一行一列：使用聚合函数，在不使用 group by 字句时，都是返回一行一列。最长用的就是分页中获取总记录条数
Integer total = jt.queryForObject("select count(*) from account where money > ?", Integer.class,500);
System.out.println(total);

5. 在 dao 中使用 JdbcTemplate

5.1 第一种方式：在 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 注入 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());
    }
}

配置文件:

<!-- 配置一个 dao -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
	<!-- 注入 jdbcTemplate -->
	<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>

这种方式有一个小问题：每个 dao 都有一些重复性的代码：

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

5.2 第二种方式：让 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 class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
    @Override
    public Account findAccountById(Integer id) {
        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) {
        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().update("update account set money = ? where id = ?", account.getMoney(), account.getId());
    }
}

配置文件：

<!-- 配置 dao2 -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
	<!-- 注入 dataSource -->
	<property name="dataSource" ref="dataSource"></property>
</bean>

5.3 两种方式的区别

第一种在 Dao 类中定义 JdbcTemplate 的方式，适用于所有配置方式（xml 和注解都可以）
第二种让 Dao 继承 JdbcDaoSupport 的方式，只能用于基于 XML 的方式，注解用不了