Spring的DAO模块提供了对JDBC、Hibernate、Mybatis等DAO层支持，本节介绍DAO模块对JDBC的支持。DAO模块依赖ommons-dbcp.jar、commons-pool.jar。
一、JdbcDaoSupport的使用
传统的JDBC时需要创建连接、打开、执行sql、关闭连接这一系列的步骤，Spring框架对JDBC进行了封装，我们只需使用封装好的JdbcTemplate执行sql语句。既然是JdbcDaoSupport的使用，为什么是使用JdbcTemplate呢？因为JdbcDaoSupport提供了JdbcTemplate对象，通过JdbcTemplate对象进行数据库操作。可以转到定义，查看JdbcDaoSupport、JdbcTemplate两个类的具体实现。我们通过下面的例子来了解JdbcDaoSupport的使用，这里还是使用JDBC章节的数据库daodemodb和表t_user信息。
第一步，根据t_user表信息准备Model类User。定义了id、name、age、money属性，并声明了两个构造函数。
package com.demo.model; public class User { @Override public String toString() { return "Id:"+this.getId()+" Name:"+this.getName()+" Age:"+this.getAge()+" Money:"+this.getMoney(); } private int Id; private String Name; private int Age; private double Money; public User() { } public User(String name, int age, double money) { Name = name; Age = age; Money = money; } public int getId() { return Id; } public void setId(int id) { Id = id; } public String getName() { return Name; } public void setName(String name) { Name = name; } public int getAge() { return Age; } public void setAge(int age) { Age = age; } public double getMoney() { return Money; } public void setMoney(double money) { Money = money; } }
第二步，定义接口类IUserDAO，在接口中声明了两个方法，QueryAllUser方法属于查询操作，查询所有User，AddUser属于更新操作，新增User。
package com.demo.model; import java.util.*; public interface IUserDAO { public List<User>QueryAllUser(); public Boolean AddUser(User user); public Boolean transfer(int fromUserId, int toUserId, float transferMoney); }
第三步，就是JdbcDaoSupport的使用了，在下面的SpringDAODemo类中首先继承了JdbcDaoSupport，同时实现了IUserDAO 接口中的方法。JdbcDaoSupport提供了JdbcTemplate对象，SpringDAODemo继承了JdbcDaoSupport,所以也就可以直接获取到JdbcTemplate对象，然后执行该对象的方法进行数据库操作。
package com.demo.model; import java.util.*; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.jdbc.core.support.JdbcDaoSupport; public class SpringDAODemo extends JdbcDaoSupport implements IUserDAO { public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"}); BeanFactory factory=context; IUserDAO userDao=(IUserDAO)factory.getBean("userDao"); User user=new User("JdbcDaoSupportTest",26,333.33); userDao.AddUser(user); List<User> list=userDao.QueryAllUser(); for(User u:list) { System.out.println(u.toString()); } } public List<User> QueryAllUser() { String sql="select id,name,age,money from t_user order by id desc"; List<Map<String,Object>> list=getJdbcTemplate().queryForList(sql); List<User> userList=new ArrayList<User>(); for(Map<String,Object> row:list) { User user=new User(); user.setId((Integer)row.get("id")); user.setName((String)row.get("name")); user.setAge((Integer)row.get("age")); user.setMoney(Double.parseDouble(row.get("money").toString())); userList.add(user); } return userList; } public Boolean AddUser(User user) { String sql="insert into t_user (name,age,money) values (?,?,?)"; int row=getJdbcTemplate().update(sql, new Object[]{user.getName(),user.getAge(),user.getMoney()}); if(row>0) { System.out.println("数据新增成功!"); return true; } return false; } }
第四步，配置属性。在上面的main方法中先通过上下文获取到bean对象，然后执行新增操作和查询操作。但是上面的代码并未看到数据库信息，这里还需要在ApplicationContext.xml中配置数据库信息，并为JdbcDaoSupportDemo设置数据源。为什么会有dataSource属性呢，因为JdbcDaoSupport中包含这个属性。
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" 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 http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd "> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"> <property name="driverClassName"> <value>com.mysql.jdbc.Driver</value> </property> <property name="url"> <value>jdbc:mysql://127.0.0.1:3306/daodemodb</value> </property> <property name="username"> <value>root</value> </property> <property name="password"> <value>123456</value> </property> </bean> <bean id="userDao" class="com.demo.model.SpringDAODemo" depends-on="dataSource"> <property name="dataSource" ref="dataSource"></property> </bean> </beans>
第五步，pom.xml中配置的依赖信息。例子是Spring中DAO的实现，而且是对jdbc的封装，所以包含Spring相关依赖和jdbc的相关依赖。
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.demo</groupId> <artifactId>SpringDAO</artifactId> <version>0.0.1-SNAPSHOT</version> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>5.0.0.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>commons-dbcp</groupId> <artifactId>commons-dbcp</artifactId> <version>1.4</version> </dependency> <dependency> <groupId>commons-pool</groupId> <artifactId>commons-pool</artifactId> <version>1.6</version> </dependency> <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.6</version> </dependency> </dependencies> </project>
运行SpringDAODemo，可以发现数据库和打印结果中增加了一条记录。
二.MappingSqlQuery的使用
在JdbcDaoSupport的使用小节获取所有User的方法QueryAllUser()中，使用getJdbcTemplate().queryForList()返回的是List<Map<String,Object>>类型，需要遍历转换成Java对象，那问题来了，查询的不止这一个方法，可能以后会有条件查询的方法，那每次都要把从数据库返回的List<Map<String,Object>>类型的List转一遍，当然也可以专门写一个转换的方法，这样每次传List<Map<String,Object>>类型的参数，然后返回List<User>类型的值。其实还有一种方式，就是使用MappingSqlQuery。MappingSqlQuery是一个抽象类，需要实现它的方法mapRow()。
第一步，实现MappingSqlQuery抽象类，这里在UserMappingSqlQuery类中实现了mapRow()方法。
package com.demo.model; import java.sql.ResultSet; import java.sql.SQLException; import org.springframework.jdbc.object.MappingSqlQuery; public class UserMappingSqlQuery extends MappingSqlQuery<User>{ @Override protected User mapRow(ResultSet rs, int rowNum) throws SQLException { User user=new User(); user.setId((Integer)rs.getInt("id")); user.setName((String)rs.getString("name")); user.setAge((Integer)rs.getInt("age")); user.setMoney((Double)rs.getDouble("money")); return user; } }
第二步，UserMappingSqlQuery类的使用。这里重写SpringDAODemo类中的QueryAllUser()方法。UserMappingSqlQuery需要传入DataSource和sql，并执行compile()编译。这里通过getDataSource()获取的是JdbcDaoSupport的DataSource属性。如果有参数，可以使用setParameters()设置参数，下面的代码为了演示设置参数，增加了where 1=1的查询条件。
public List<User> QueryAllUser() { String sql="select id,name,age,money from t_user where ?"; UserMappingSqlQuery userQuery=new UserMappingSqlQuery(); userQuery.setDataSource(getDataSource()); userQuery.setSql(sql); userQuery.setParameters(new SqlParameter(java.sql.Types.VARCHAR)); userQuery.compile(); return userQuery.execute(new Object[]{new String("1=1")}); }
三.SqlUpdate的使用
SqlUpdate主要是用来更新，可以设置参数。SqlUpdate可以将某个功能模块化。通过下面的例子来了解下SqlUpdate的使用。
package com.demo.model; import javax.sql.DataSource; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.jdbc.core.SqlParameter; import org.springframework.jdbc.object.SqlUpdate; public class UserSqlUpdate extends SqlUpdate{ public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"}); BeanFactory factory=context; UserSqlUpdate userSqlUpdate=(UserSqlUpdate)factory.getBean("userSqlUpdate"); userSqlUpdate.updateUserMoney("小李",666.66); } public UserSqlUpdate(DataSource ds) { setDataSource(ds); setSql("update t_user set money=? where name=?"); declareParameter(new SqlParameter(java.sql.Types.DOUBLE) ); declareParameter(new SqlParameter(java.sql.Types.VARCHAR) ); compile(); } public Boolean updateUserMoney(String name,double money) { int row= update(new Object[]{new Double(money),new String(name)}); if(row>0) { System.out.println("数据新增成功!"); return true; } return false; } }
在ApplicationContext.xml中配置userSqlUpdate对应的bean节点。
<bean id="userSqlUpdate" class="com.demo.model.UserSqlUpdate"> <constructor-arg ref="dataSource" index="0"></constructor-arg> </bean>
在上面的UserSqlUpdate中继承了SqlUpdate，通过setDataSource、setSql分别设置SqlUpdate的数据源和要执行的sql。在main方法中将name为小李的money修改为666.66，执行main方法之后会打印出数据新增成功，数据库中小李的money改成了666.66。
四.SqlFunction的使用
SqlFunction返回单一行的查询结果，默认返回int，也可以重载返回其他类型。下面直接在main函数中使用。
package com.demo.model; import org.apache.commons.dbcp.BasicDataSource; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.jdbc.object.SqlFunction; public class SqlFunctionDemo { public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"}); BeanFactory factory=context; BasicDataSource dataSource=(BasicDataSource)factory.getBean("dataSource"); SqlFunction sf=new SqlFunction(dataSource,"select count(1) from t_user;"); sf.compile(); int count=sf.run(); System.out.println("User Count:"+count); } }
五、事务管理
至于什么是事务在JDBC章节已经介绍，这里就不再说。JDBC中有事务管理，Spring使用DataSourceTransactionManager 作为JDBC的事务管理者，同时把被管理的对象使用 TransactionProxyFactoryBean配置。从名字也能猜出这里使用的设计模式是代理设计模式。这是一个事务代理Bean，能够使用IOC、AOP等注入事务管理代码。在JDBC中介绍事务时用的转账操作，这里为了更好理解，还是使用转账操作。
第一步，在IUserDAO接口中增加转账方法transfer。
public Boolean transfer(int fromUserId, int toUserId, float transferMoney);
第二步，在SpringDAODemo类中实现transfer。从fromUserId这个用户转账到toUserId这个用户，outInMoney方法就是执行sql更新数据库用户的money。这里如果人为制造一个异常，把int i=1/0;这行注释取消，就会在后面执行转账时自动回滚，转账不会成功。
public Boolean transfer(int fromUserId, int toUserId, float transferMoney) { Boolean out= outInMoney(fromUserId,-transferMoney); int i=1/0; //事务回滚 Boolean in=outInMoney(toUserId,transferMoney); return out∈ } private Boolean outInMoney(int toUserId,float money) { String sql="update t_user set money=money+? where id=? "; int row=getJdbcTemplate().update(sql, new Object[]{money,toUserId}); if(row>0) { return true; } return false; }
第三步，配置事务，在ApplicationContext.xml中配置事务管理对象DataSourceTransactionManager，设置事务代理对象TransactionProxyFactoryBean。
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> <!-- 配置业务层代理 --> <bean id="userDaoProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <!-- 配置目标对象 --> <property name="target" ref="userDao"/> <!-- 注入事务管理器 --> <property name="transactionManager" ref="transactionManager"/> <!-- 注入事务的属性 --> <property name="transactionAttributes"> <props> <prop key="transfer">PROPAGATION_REQUIRED</prop> </props> </property> </bean>
第四步，执行转账操作，在main方法中执行transfer方法，为用户1、2进行转账，如果transfer方法中人为制造的异常注释的话是可以正常转账，取消注释则转账失败，打印事务回滚。
public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"}); BeanFactory factory=context; IUserDAO userDao=(IUserDAO)factory.getBean("userDaoProxy"); try { userDao.transfer(1, 2, 100); } catch(Exception e) { System.out.println("事务回滚"); } }