上一篇算是把JdbcDaoSupport的使用演示了一下，这篇主要是演示MappingSqlQuery、SqlUpdate、SqlFunction的使用以及Spring的事务管理。
一、MappingSqlQuery的使用
在上一篇获取所有User的方法QueryAllUser()中，使用getJdbcTemplate().queryForList()返回的是List<Map<String,Object>>类型，需要遍历转换成Java对象，那问题来了，查询的不止这一个方法，可能以后会有条件查询的方法，那每次都要把从数据库返回的List<Map<String,Object>>类型的List转一遍，当然也可以专门写一个转换的方法，这样每次传List<Map<String,Object>>类型的参数，然后返回List<User>类型的值。其实还有一种方式，就是使用MappingSqlQuery。MappingSqlQuery是一个抽象类，需要实现它的方法mapRow()。下面的代码就是定义了类UserMappingSqlQuery，继承了抽象类MappingSqlQuery，实现了它的mapRow()方法。
package Cuiyw.Spring.Dao; import java.sql.ResultSet;
import java.sql.SQLException; import org.springframework.jdbc.object.MappingSqlQuery; import Cuiyw.Spring.Model.User; public class UserMappingSqlQuery extends MappingSqlQuery { @Override
protected Object mapRow(ResultSet rs, int rowNum) throws SQLException {
// TODO Auto-generated method stub
User user=new User();
user.setUserId((Integer)rs.getInt("id"));
user.setName((String)rs.getString("name"));
user.setMoney((Float)rs.getFloat("money"));
return user;
} }
上面定义之后就是该怎么使用了。还是UserDAO类中，重写List<User> QueryAllUser()方法。代码中主要是为了尝试使用参数，所有增加了一个过滤条件。
public List<User> QueryAllUser() {
String sql="select id,name,money from tb_user where name=?";
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("cuiywA")});
}
执行QueryAllUser(),打印出查询的list。
List<User> list=userDao.QueryAllUser();
for(User u:list)
{
System.out.println("name:"+u.getName()+" money: "+u.getMoney());
}
二、SqlUpdate的使用
上面熟悉了查询的用法，SqlUpdate主要是用来更新。下面定义了UserSqlUpdate继承SqlUpdate
package Cuiyw.Spring.Dao; import javax.sql.DataSource; import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.object.SqlUpdate; public class UserSqlUpdate extends SqlUpdate{ public UserSqlUpdate(DataSource ds, String sql) {
super(ds, sql);
declareParameter(new SqlParameter(java.sql.Types.FLOAT) );
declareParameter(new SqlParameter(java.sql.Types.VARCHAR) );
} public int updateUserMoney(String name,float money)
{
compile();
return update(new Object[]{new Float(money),new String(name)});
}
}
上面的构造函数传两个参数，这两个参数我都放在上下文xml中。dataSource还是上一博客中配置的数据库信息。
<bean id="userSqlUpdate" class="Cuiyw.Spring.Dao.UserSqlUpdate">
<constructor-arg type="java.lang.String" index="1">
<value>update tb_user set money=? where name=?</value>
</constructor-arg>
<constructor-arg ref="dataSource" index="0"></constructor-arg>
</bean>
UserSqlUpdate userSqlUpdate=(UserSqlUpdate)factory.getBean("userSqlUpdate");
userSqlUpdate.updateUserMoney("cuiywA",666);
在updateUserMoney()前后遍历数据库的user,发现以及修改了。
三、SqlFunction的使用
SqlFunction返回单一行的查询结果，默认返回int，也可以重载返回其他类型。下面的我是直接在main函数中使用。
BasicDataSource dataSource=(BasicDataSource)factory.getBean("dataSource");
SqlFunction sf=new SqlFunction(dataSource,"select count(1) from tb_user;");
sf.compile();
int count=sf.run();
System.out.println("User Count:"+count);
四、Spring事务管理
什么是事务这些就不说了，事务最常见的例子就是转账，我定义User有money字段就是为了事务而定义的。实现事务在spring中有好几种方式，这里只简单介绍基于jdbc的声明式事务。
这里在IUserDAO中定义了两个接口，一个是存取款，一个是转账,并在UserDAO中实现。理想情况一个加一个减，但是加入减的成功了，加的失败了，那转账就是错误。
public Boolean outInMoney(int toUserId,float money)
{
String sql="update tb_user set money=money+? where id=? ";
int row=getJdbcTemplate().update(sql, new Object[]{money,toUserId});
if(row>0)
{
return true;
}
return false;
} public Boolean transfer(int fromUserId, int toUserId, float transferMoney) {
Boolean out= outInMoney(fromUserId,-transferMoney);
Boolean in=outInMoney(toUserId,transferMoney);
return out∈
}
spring使用DataSourceTransactionManager作为jdbc的事务管理者，被管理对象使用TransactionProxyFactoryBean配置。
1.配置DataSourceTransactionManager
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
2.配置TransactionProxyFactoryBean
这里transactionAttributes是来配置哪些方法使用事务管理，这里只配置了transfer方法，使用*，表达所有的方法，prop的值可以是PROPAGATION（事务的传播行为），ISOLATIONf(事务的隔离级别) -Exception(发生哪些异常回滚事务) +Exception(发生哪些事务不回滚)
PROPAGATION类型:
PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作
Exception:
- 表示抛出该异常时需要回滚
+表示即使抛出该异常事务同样要提交
-ApplicationException ：表示抛出ApplicationException 时，事务需要回滚。但不是说只抛出ApplicationException 异常时，事务才回滚，如果程序抛出RuntimeException和Error时，事务一样会回滚，即使这里没有配置。因为Spring中默认对所有的RuntimeException和Error都会回滚事务
<!-- 配置业务层代理 -->
<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>
3.这里先理想情况的转账一个，可以看到cuiywA账号减100，cuiywB账号加100.
List<User> list=userDao.QueryAllUser();
for(User u:list)
{
System.out.println("name:"+u.getName()+" money: "+u.getMoney());
}
userDao.transfer(1, 2, 100);
list=userDao.QueryAllUser();
for(User u:list)
{
System.out.println("name:"+u.getName()+" money: "+u.getMoney());
}
4.异常转账
模拟异常这里在转账时增加一个错误1/0
public Boolean transfer(int fromUserId, int toUserId, float transferMoney) {
Boolean out= outInMoney(fromUserId,-transferMoney);
int a=1/0;
Boolean in=outInMoney(toUserId,transferMoney);
return out∈
}
这里遇到了一个坑，配置之后还是按照前面的factory.getBean("userDao")，但始终不成功，找了好久，觉得配置的userDaoProxy并没有用到，这不科学啊，又百度了一下，发现还真是。在获取bean时不应时userDao了，而是TransactionProxyFactoryBean对象。
IUserDAO userDao=(IUserDAO)factory.getBean("userDaoProxy");
ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"});
BeanFactory factory=context;
IUserDAO userDao=(IUserDAO)factory.getBean("userDaoProxy");
List<User> list=userDao.QueryAllUser();
for(User u:list)
{
System.out.println("name:"+u.getName()+" money: "+u.getMoney());
}
try
{
userDao.transfer(1, 2, 100);
}
catch(Exception e)
{}
list=userDao.QueryAllUser();
for(User u:list)
{
System.out.println("name:"+u.getName()+" money: "+u.getMoney());
}
上面在转账的地方增加了try-catch,主要是为了看执行转账之后的金额是否与之前的一致。上面截图可以看到是一致的，事务是有回滚的。事务管理还有其他方式，以后会一一介绍。