Spring中的JdbcTemplate

柔光的暖阳◎ 2023-02-14 01:37 18阅读 0赞

### 目录 ###

*  概述
 *  环境搭建
 *  实例演示
 *  JdbcTemplate的CRUD操作
 *   *  \*\*保存\*\*
     *  \*\*更新\*\*
     *  \*\*删除\*\*
     *  \*\*查询所有\*\*
     *  查询单个
     *  查询返回一行一列
 *  JdbcTemplate在DAO中的使用
 *   *  方式1：在 dao 中定义 JdbcTemplate
     *  方式2：让 dao 继承 JdbcDaoSupport
     *  两种方式的区别

# 概述 #

JdbcTemplate是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。 spring 框架为我们提供了很多  
的操作模板类，它只是其中的一个。下面直接上实例演示用法。

# 环境搭建 #

我们今天的主角在 spring-jdbc-5.0.2.RELEASE.jar 中，我们在导包的时候，除了要导入这个 jar 包  
外，还需要导入一个 spring-tx-5.0.2.RELEASE.jar。  
pom.xml：

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

准备表：  
![在这里插入图片描述][20200530142727383.png]  
创建其对应的实体类：

package com.zhu;
    
    import java.io.Serializable;
    
    /** * 账户的实体类 */
    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 +
                    '}';
        }
    }

# 实例演示 #

*  先写个最简单的例子：

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

执行完后：  
![在这里插入图片描述][20200530145714198.png]

*  上面的例子还有许多值得改进的地方，比如写死了配置，类间的依赖等等，那么可以通过IOC来解决：  
    配置bean.xml：

<?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">
        
        
        <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://localhost:3306/springstudy?useUnicode=true&characterEncoding=utf8"></property>
            <property name="username" value="root"></property>
            <property name="password" value="root"></property>
        </bean>
    </beans>

这样上面的Demo就能大大简化了：

/** * JdbcTemplate的最基本用法:IOC */
    public class JdbcTemplateDemo2 { 
    
        public static void main(String[] args) { 
            //1.获取容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            //2.获取对象
            JdbcTemplate jt = ac.getBean("jdbcTemplate", JdbcTemplate.class);
            //3.执行操作
            jt.execute("insert into account(name,money)values('ddd',2222)");
        }
    }

# JdbcTemplate的CRUD操作 #

上边的SQL语句是写死的，现在看看如何用带参数的来进行CRUD吧~

## **保存** ##

jt.update("insert into account(name,money)values(?,?)","eee",3333f);

## **更新** ##

jt.update("update account set name=?,money=? where id=?","test",4567,7);

## **删除** ##

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

以上三个单表操作，都是用的update（）方法。

## **查询所有** ##

使用的是这个方法：  
![在这里插入图片描述][20200530162640273.png]  
参数 rowMapper定义了从查询结果如何封装为对象，如果要自己定义：

/** * 定义Account的封装策略 */
    class AccountRowMapper implements RowMapper<Account>{ 
        /** * 把结果集中的数据封装到Account中，然后由spring把每个Account加到集合中 * @param rs * @param rowNum * @return * @throws SQLException */
        @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;
        }
    }

当然，Spring也提供了RowMapper的实现类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);
            }

执行结果：  
![在这里插入图片描述][20200530163200605.png]

## 查询单个 ##

仍然用的上面的query方法：![在这里插入图片描述][20200530162640273.png]

List<Account> accounts = jt.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),1);
            System.out.println(accounts.isEmpty()?"没有内容":accounts.get(0));

![在这里插入图片描述][20200530163721508.png]

## 查询返回一行一列 ##

上面查询返回的都是结果集，如何查询单个值呢？  
![在这里插入图片描述][2020053016381046.png]

//查询返回一行一列（使用聚合函数，但不加group by子句）
            Long count = jt.queryForObject("select count(*) from account where money > ?",Long.class,1000f);
            System.out.println(count);

执行后打印2.

# JdbcTemplate在DAO中的使用 #

## 方式1：在 dao 中定义 JdbcTemplate ##

上面的写法都是测试的写法，实际开发中一般采用DAO的方式。  
先提供一个接口：  
定义了两个查询和一个更新方法——

/** * 账户的持久层接口 */
    public interface IAccountDao { 
    
        /** * 根据Id查询账户 * @param accountId * @return */
        Account findAccountById(Integer accountId);
    
        /** * 根据名称查询账户 * @param accountName * @return */
        Account findAccountByName(String accountName);
    
        /** * 更新账户 * @param account */
        void updateAccount(Account account);
    }

实现类，JdbcTemplate通过spring注入：

/** * 账户的持久层实现类 */
    public class AccountDaoImpl implements IAccountDao { 
        private JdbcTemplate jdbcTemplate;
    
        public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { 
            this.jdbcTemplate = jdbcTemplate;
        }
    
        @Override
        public Account findAccountById(Integer accountId) { 
            List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
            return accounts.isEmpty()?null:accounts.get(0);
        }
    
        @Override
        public Account findAccountByName(String accountName) { 
            List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
            if(accounts.isEmpty()){ 
                return null;
            }
            if(accounts.size()>1){ 
                throw new RuntimeException("结果集不唯一");
            }
            return accounts.get(0);
        }
    
        @Override
        public void updateAccount(Account account) { 
            jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }
    }

当然，想要能注入，必须配置bean：

<bean id="accountDao" class="com.zhu.dao.impl.AccountDaoImpl">
            <property name="jdbcTemplate" ref="jdbcTemplate"></property>
        </bean>

测试：

/** * JdbcTemplate在DAO中的使用 */
    public class JdbcTemplateDemo4 { 
    
        public static void main(String[] args) { 
            //1.获取容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            //2.获取对象
            IAccountDao accountDao = ac.getBean("accountDao",IAccountDao.class);
    
            Account account = accountDao.findAccountById(1);
            System.out.println(account);
    
            account.setMoney(30000f);
            accountDao.updateAccount(account);
        }
    }

## 方式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;
    	}
    	...
    }

此版本 dao，只需要给它的父类注入一个数据源：

/** * 账户的持久层实现类 */
    public class AccountDaoImpl2 extends JdbcDaoSupport implements IAccountDao { 
    
        @Override
        public Account findAccountById(Integer accountId) { 
            List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
            return accounts.isEmpty()?null:accounts.get(0);
        }
    
        @Override
        public Account findAccountByName(String accountName) { 
            List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
            if(accounts.isEmpty()){ 
                return null;
            }
            if(accounts.size()>1){ 
                throw new RuntimeException("结果集不唯一");
            }
            return accounts.get(0);
        }
    
        @Override
        public void updateAccount(Account account) { 
            super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }
    }

bean.xml

<bean id="accountDao2" class="com.zhu.dao.impl.AccountDaoImpl2">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>

## 两种方式的区别 ##

**第一种在 Dao 类中定义 JdbcTemplate 的方式，适用于所有配置方式（ xml 和注解都可以）。  
第二种让 Dao 继承 JdbcDaoSupport 的方式，只能用于基于 XML 的方式，注解用不了。**  
因为无法给jar包中的JdbcDaoSupport类的代码加@Autowired注解。

[20200530142727383.png]: https://img-blog.csdnimg.cn/20200530142727383.png
[20200530145714198.png]: https://img-blog.csdnimg.cn/20200530145714198.png
[20200530162640273.png]: https://img-blog.csdnimg.cn/20200530162640273.png
[20200530163200605.png]: https://img-blog.csdnimg.cn/20200530163200605.png
[20200530163721508.png]: https://img-blog.csdnimg.cn/20200530163721508.png
[2020053016381046.png]: https://img-blog.csdnimg.cn/2020053016381046.png