本章简介
第1章、第2章中分别介绍了 Spring的控制反转和面向切面编程，我们了解了依赖注入的含义、依赖注入的方式、面向切面的编程以及4种通知。本章先介绍Spring与Hibernate整合的目的，然后采用对Emp表的CURD作为综合案例，介绍两大框架整合的步骤、关键整合点、整合之后如何操作数据库。最后采用Spring的声明式事务对Hibernate进行管理，增加程序的健壮性。
核心技能部分
第1章
1.1 Spring与Hibernate整合简介
当我们用JDBC编程的时候，数据库操作的代码非常繁琐，后来学习Hibernate，数据库的操作代码大大简化，但代码仍然比较繁琐，我们可以充分使用Spring依赖注入和AOP简化Hibernate应用。
Spring在资源管理、DAO 的实现及事务策略方面提供与Hibernate 的集成，通过IOC对Hibernate提供一流的支持，并在解决典型的 Hibernate整合问题中展现了突出的作用。Spring提供的支持都遵循其通用的事务及DAO异常体系。
在实际应用开发中，web程序的依赖关系是这样的：Action依赖Biz，Biz依赖DAO，DAO依赖SessionFactory，SessionFactory依赖DataSource。可以使用Spring的依赖注入来管理这些对象。事务处理在实际应用中非常重要，如果在每个涉及数据库操作的方法中都加入事务控制代码，那将是一件很痛苦的事情，而Spring AOP可以很好的解决这个问题。
Spring 向不同的事务 API提供一致的编程模型，提供比传统事务 API更简单且易用的编程式事务管理 API，能够整合数据访问，支持声明式事务管理。
1.1 Spring与Hibernate整合
我们以操作emp表为例，来探索两大框架的整合过程。
1.1.1 处理SessionFactory
Spring与Hibernate集成开发主要包括两种方式，二者的区别在于配置文件的使用。
1.将Spring与Hibernate各自的配置文件进行合并
两种方式都可以使用MyEclipse工具完成，操作步骤如下：
步骤1 添加Spring特性，如图4.1.2所示。
步骤2 勾选Spring支持包，如图4.1.3所示。
步骤6 把Hibernate配置放入现有的Spring配置文件，生成sessionFactory，如图4.1.7所示。
步骤7 确定数据库信息，完成配置，如图4.1.8所示。
2. Spring与Hibernate分别使用各自的配置文件
当需要将Spring的配置文件与Hibernate配置文件分开配置的时候，只有步骤5和步骤6不一样，分别将两个步骤替换如下：
步骤5 勾选单独的Hibernate配置文件，如图4.1.9所示。
步骤6 生成Hibernate配置文件和sessionFactory，如图4.1.10所示。
合并后的配置文件如示例4.1所示。
示例4.1
<!-- dataSource的配置 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="oracle.jdbc.OracleDriver">
</property>
<property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl">
</property>
<property name="username" value="scott"></property>
<property name="password" value="tiger"></property>
</bean>
<!-- sessionFactory的配置 -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.Oracle9Dialect
</prop>
<!—显示sql语句 -->
<prop key="hibernate.show_sql">
true
</prop>
</props>
</property>
<!—映射文件的配置-->
<property name="mappingResources">
<list>
<value>entity/Emp.hbm.xml</value>
</list>
</property>
</bean>
两个文件单独配置时，Spring配置如示例4.2所示。
示例4.2
<!-- 加载Hibernate配置 -->
<!-- 定义Hibernate的SessionFactory bean -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 使用Spring提供的LocalSessionFactoryBean，传入一个Hibernate配置文件的位置 -->
<property name="configLocation" value="file:src/hibernate.cfg.xml">
</property>
</bean>
无论使用哪种整合方式，在Spring配置文件中都有一个sessionFactory，我们知道Hibernate对数据库的操作依靠session完成，而sessionFactory正是用来产生session。
1.1.1 使用HibernateTemplate简化DAO
Spring提供多种数据库访问技术的DAO支持，可以使用相同的访问模式，使用不同的数据库访问技术。这种DAO支持大大地减少数据库访问的代码量，提高开发效率。接下来我们设计如示例4.3所示的DAO接口。
示例4.3
public interface EmpDao {
public void addEmp(Emp emp);
public void delEmp(short empNo);
public void updateEmp(Emp emp);
public Emp get(short empNo);
public List searchEmp(Emp emp);
public List searchEmp(String hql);
}
我们可以使用Spring提供的HibernateTemplate来简化EmpDao的实现。如示例4.4所示。
示例4.4
public class EmpDaoImpl extends HibernateDaoSupport implements EmpDao {
public void addEmp(Emp emp) {
super.getHibernateTemplate().save(emp);
}
public void delEmp(short empNo) {
super.getHibernateTemplate().delete(this.get(empNo));
}
public Emp get(short empNo) {
Emp emp = (Emp) super.getHibernateTemplate().get(Emp.class, empNo);
return emp;
}
public List searchEmp(final Emp condition) {
List list = super.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
// 构建查询
Criteria c = session.createCriteria(Emp.class);
if (condition != null) {
// 构造Criteria查询条件的代码
}
return c.list();
}
});
return list;
}
public List searchEmp(String hql) {
return super.getHibernateTemplate().find(hql);
}
public void updateEmp(Emp emp) {
super.getHibernateTemplate().update(emp);
}
}
在示例4.4现中，我们发现Spring提供的HibernateDaoSupport类可以简化Hibernate的开发。HibernateDaoSupport类提供了getHibernateTemplate()方法获得HibernateTemplate对象，HibernateTemplate对象提供了非常多的方法，如表4-1-1所示。
表4-1-1 HibernateTemplate常用的方法
|
编号 |
方法 |
功能 |
|
1 |
find(String queryString) |
根据HQL查询字符串来返回集合示例 |
|
2 |
save(Object entity) |
保存新的示例 |
|
3 |
update(Object entity) |
根据给定的持久化对象更新记录 |
|
4 |
delete(Object entity) |
删除指定持久化实例 |
|
5 |
deleteAll(Collection entities) |
删除集合内全部持久化类实例 |
|
6 |
get(Class entityClass,Serializable id) |
根据主键加载特定持久化类的实例 |
|
7 |
saveOrUpdate(Object entity) |
根据实例状态，选择保存或更新 |
我们并没有在示例4.4中看到有关SessionFactory的代码，Spring为HibernateDaoSupport类提供了setSessionFactory方法，我们将通过这个setter方法向DAO类注入SessionFactory。配置方式如示例4.5所示。
示例4.5
<!--EmpDaoImpl的配置 -->
<bean id="EmpDao" class="dao.impl.EmpDaoImpl">
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
1.1.2 业务层的处理
我们已经完成了EmpDao的定义，将EmpDao注入到empBiz中需要在EmpBiz中增加EmpDao属性及对应setter和getter方法。
代码如示例4.6所示。
示例4.6
public class EmpBizImpl implements EmpBiz {
private EmpDao EmpDao;
public void addEmp(Emp emp) {
EmpDao.addEmp(emp);
}
public void delEmp(short empNo) {
EmpDao.delEmp(empNo);
}
public Emp get(short empNo) {
return EmpDao.get(empNo);
}
public List searchEmp(Emp condition) {
return EmpDao.searchEmp(condition);
}
public List searchAllEmp() {
String hql="from Emp";
return EmpDao.searchEmp(hql);
}
public void updateEmp(Emp emp) {
EmpDao.updateEmp(emp);
}
//setter & getter
}
在Spring配置文件中，我们需要在业务逻辑中注入DAO，如示例4.7所示。
示例4.7
<bean id="empBiz" class="biz.impl.EmpBizImpl">
<property name="EmpDao" ref="EmpDao"></property>
</bean>
1.1 声明式事务
之前我们编写的程序，事务都是在DAO层控制，在实际应用开发中显然是不合适的。比如某银行的业务逻辑方法中需要对DAO进行多次调用，如示例4.8所示。
示例4.8
public void transferAccount(CardVo from,CardVo to,double money)
{
from.setMoney(from.getMoney()+money);
cardDAO.update(from);//修改转账人账户
to.setMoney(to.getMoney()-money);
cardDAO.update(to);//修改收款账户
RecordVO record=new RecordVO(from,to,money);
recordDAO.add(record);//增加交易记录
}
这个业务方法中执行了三个持久化操作，根据业务需求要求这三个操作要么全部成功，要么都不能成功，也就是：客观上需要对业务逻辑层的方法进行事务控制。
事务处理是企业应用开发中不能回避的一个重要问题。在Hibernate风行之前，JDBC是数据持久化的主要手段，为了达到在业务逻辑层进行事务控制，一个通用的做法是将Connection对象以参数的形式传来传去。业务逻辑层应该只出现描述业务逻辑的代码，Connection在业务逻辑层的出现破坏了三层结构的基本原则。另外一个做法是将业务逻辑放到DAO层实现，DAO层依据业务逻辑创建方法，编写复杂的业务逻辑代码，这样进行架构设计的系统很快就会尝到苦果。
事务是系统开发过程中的一个方面，散步在系统里，我们可以通过AOP来实现。
1.1.1 事务通知
使用Spring的声明式事务，我们无需编写程序代码，所有的工作都在配置文件中完成，这种不需要编程的事务称为“声明式事务”。配置事务通知需要先声明一个事务管理器，我们可以新建一个aop.xml文件，将事务配置放在该配置文件中。如示例4.9所示。
示例4.9
<!-- 事务管理器的配置 -->
<bean id="txManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<!-- 注入applicationContext.xml中配置的sessionFactory -->
<ref bean="sessionFactory" />
</property>
</bean>
接下来可以使用 Spring带有的一个<tx:advice>标签，该标签会创建一个事务通知，我们所需要的就是创建一个切入点，该切入点配置所有带事务的方法并引用事务性通知。事务通知的配置如示例4.10所示，该示例采用Spring2.x方式，需要加入命名空间的引用。
示例4.10
<!-- 事务通知的配置,需要指定一个事务管理器 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
<!-- 定义属性，声明事务规则 -->
<tx:attributes>
<!-- 对get/find/search/query开头的方法要求只读事务 -->
<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
<tx:method name="search*" propagation="SUPPORTS" read-only="true" />
<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
<tx:method name="query*" propagation="SUPPORTS" read-only="true" />
<!-- 对add/del/update/do开头的方法要求必须运行在事务环境中 -->
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="do*" propagation="REQUIRED" />
<!-- 对其他方法采用如下配置 -->
<tx:method name="*" propagation="REQUIRED" read-only="true" />
</tx:attributes>
</tx:advice>
在<tx:advice>标签内设值id和transaction-manager属性，id是advice Bean的标识，而transaction-manager引用一个事务管理器。
除了这两个属性外，还可以通过<tx:attributes/>标签配置事务属性。<tx:method>的propagation属性表示事务的传播行为，REQUIRED表示如果存在一个事务，则支持当前事务，如果当前没有事务，则开启一个新的事务。SUPPORTS表示如果存在一个事务，则支持当前事务，如果当前没有事务，则按非事务方式执行。<tx:method> 的属性name="*"表示匹配所有其他的方法readOnly表示启用只读事务。这样数据库库就可以采取合适的优化措施避免不必要的操作。
1.1.2 事务通知和切入点组合
我们已经定义一个id为txAdvice的事务通知，接下来，我们需要将事务通知和切入点组合，最合适的切入点是biz的方法，可以是接口中声明的方法，也可以直接将切入点定义为biz实现的方法。代码片段如示例4.11所示。
示例4.11
<!-- 将事务通知和切入点组合 -->
<aop:config>
<aop:pointcut expression="execution(* biz.*.*(..))" id="pc" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="pc" />
</aop:config>
上面的代码表示biz包下所有类的所有方法都应用事务规则。至此，Spring与 Hibernate的整合完成。数据库操作还是需要Hibernate完成，Spring起到管理的作用,比如Spring管理各个Bean，管理Hibernate的事务。这样的代码不但简介，而且健壮性也得到了很好的保证，是企业应用开发的首选。
对以上整合的测试代码如示例4.12所示。
示例4.12
public static void main(String[] args) throws ParseException {
ApplicationContext context = new ClassPathXmlApplicationContext(
new String[] { "applicationContext.xml", "aop.xml" });
EmpBiz empBiz = (EmpBiz) context.getBean("empBiz");
Emp emp = new Emp();
emp.setEmpno((short) 1000);
emp.setEname("张翠山");
emp.setJob("主管");
emp.setMgr((short) 7879);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date hiredate = sdf.parse("2001-12-12");
emp.setHiredate(new Timestamp(hiredate.getTime()));
emp.setSal(8000.0);
emp.setComm(2000.0);
emp.setDeptno((byte) 20);
empBiz.addEmp(emp);//添加新员工
}
添加之后，数据库的记录如图4.1.11所示：
测试查询所有的员工，如示例4.13所示。
示例4.13
List<Emp> empList = empBiz.searchAllEmp();
for (Emp emp : empList) {
System.out.println(emp.getEmpno() + "\t" + emp.getEname() + "\t"
+ emp.getSal() + "\t" + emp.getComm());
}
测试结果如图4.1.12所示。
1.1 使用工具生成Spring DAO
开发过程中，一般通过反向工程生成表对应的实体对象，同时也可以勾选Spring DAO选项，通过MyEclipse生成实体对象的DAO。操作如图4.1.13所示。
生成的DAO代码如示例4.14所示。
示例4.14
public class EmpDao extends HibernateDaoSupport {
private static final Log log = LogFactory.getLog(EmpDao.class);
// property constants
public static final String ENAME = "ename";
public static final String JOB = "job";
public static final String MGR = "mgr";
public static final String SAL = "sal";
public static final String COMM = "comm";
public static final String DEPTNO = "deptno";
protected void initDao() {
// do nothing
}
public void save(Emp transientInstance) {
log.debug("saving Emp instance");
try {
getHibernateTemplate().save(transientInstance);
log.debug("save successful");
} catch (RuntimeException re) {
log.error("save failed", re);
throw re;
}
}
public void delete(Emp persistentInstance) {
log.debug("deleting Emp instance");
try {
getHibernateTemplate().delete(persistentInstance);
log.debug("delete successful");
} catch (RuntimeException re) {
log.error("delete failed", re);
throw re;
}
}
public Emp findById(java.lang.Short id) {
log.debug("getting Emp instance with id: " + id);
try {
Emp instance = (Emp) getHibernateTemplate().get("orm.Emp", id);
return instance;
} catch (RuntimeException re) {
log.error("get failed", re);
throw re;
}
}
public List findByExample(Emp instance) {
log.debug("finding Emp instance by example");
try {
List results = getHibernateTemplate().findByExample(instance);
log.debug("find by example successful, result size: "
+ results.size());
return results;
} catch (RuntimeException re) {
log.error("find by example failed", re);
throw re;
}
}
public List findByProperty(String propertyName, Object value) {
log.debug("finding Emp instance with property: " + propertyName
+ ", value: " + value);
try {
String queryString = "from Emp as model where model."
+ propertyName + "= ?";
return getHibernateTemplate().find(queryString, value);
} catch (RuntimeException re) {
log.error("find by property name failed", re);
throw re;
}
}
public List findByEname(Object ename) {
return findByProperty(ENAME, ename);
}
public List findByJob(Object job) {
return findByProperty(JOB, job);
}
public List findByMgr(Object mgr) {
return findByProperty(MGR, mgr);
}
public List findBySal(Object sal) {
return findByProperty(SAL, sal);
}
public List findByComm(Object comm) {
return findByProperty(COMM, comm);
}
public List findByDeptno(Object deptno) {
return findByProperty(DEPTNO, deptno);
}
public List findAll() {
log.debug("finding all Emp instances");
try {
String queryString = "from Emp";
return getHibernateTemplate().find(queryString);
} catch (RuntimeException re) {
log.error("find all failed", re);
throw re;
}
}
public Emp merge(Emp detachedInstance) {
log.debug("merging Emp instance");
try {
Emp result = (Emp) getHibernateTemplate().merge(detachedInstance);
log.debug("merge successful");
return result;
} catch (RuntimeException re) {
log.error("merge failed", re);
throw re;
}
}
public void attachDirty(Emp instance) {
log.debug("attaching dirty Emp instance");
try {
getHibernateTemplate().saveOrUpdate(instance);
log.debug("attach successful");
} catch (RuntimeException re) {
log.error("attach failed", re);
throw re;
}
}
public void attachClean(Emp instance) {
log.debug("attaching clean Emp instance");
try {
getHibernateTemplate().lock(instance, LockMode.NONE);
log.debug("attach successful");
} catch (RuntimeException re) {
log.error("attach failed", re);
throw re;
}
}
public static EmpDao getFromApplicationContext(ApplicationContext ctx) {
return (EmpDao) ctx.getBean("EmpDao");
}
}
以上代码我们可以看到，使用工具生成的DAO中有大量的方法，这些方法我们可以直接在业务层调用，也会在配置文件中自动配置。这些方法的功能描述见表4-1-2所示。
表4-1-2 DAO的方法及功能描述
|
方法名称 |
描述 |
|
void save(Emp transientInstance) |
根据对象添加 |
|
delete(Emp persistentInstance) |
根据对象删除 |
|
findById(java.lang.Short id) |
根据ID查询对象 |
|
findByExample(Emp instance) |
根据对象查询，查询条件为对象的属性值 |
|
findByEname(Object ename) |
根据员工名查询 |
|
findAll() |
查询所有员工 |
|
merge(Emp detachedInstance) |
合并session中存在相同ID的对象 |
|
attachDirty(Emp instance) |
添加与修改，相当于saveOrUpdate |
|
attachClean(Emp instance) |
将传入的对象状态设值为Transient状态 |
本章总结
Ø Spring整合Hibernate
n 配置SessionFactory
n HibernateTemplate
n HibernateDaoSupport
Ø 声明式事务管理
n 配置事物管理器HibernateTransactionManager
n 使用<tx:advice>结合事务管理器配置事物通知
n 在<tx:advice>内使用<tx:attributes>和<tx:method>针对不同的方法配置事物属性
Ø 使用工具自动生成 Spring DAO
任务实训部分
1：完成银行账户系统的框架搭建
训练技能点
Ø sessionFactory的配置
Ø HibernateTemplate的使用
需求说明
某银行系统需要开发一个小系统，该系统能查看账户信息、销户、开户、转账、查看交易记录等功能，要求使用Spring+Hibernate实现。该系统两张表，分别是账户信息表、交易记录表，账户信息表的字段说明如表4-2-1所示。
表4-2-1 账户信息表(ACCOUNT)
|
编号 |
字段名称 |
字段说明 |
|
1 |
ACCOUNT_ID |
账户ID，主键使用序列seq_account，number(10) |
|
2 |
USER_NAME |
账户名,varchar2(20); |
|
3 |
MONEY |
账户余额,number(6) |
|
4 |
CREATEDATE |
开户时间,date |
交易记录表的字段说明如表4-2-2所示。
表4-2-2 交易记录表（TBL_RECORD）
|
编号 |
字段名称 |
字段说明 |
|
1 |
RECORD_ID |
交易编号，主键使用序列seq_record，number(10) |
|
2 |
FROMACCOUNT |
转出帐号，number(10) |
|
3 |
TOACCOUNT |
转入帐号，number(10) |
|
4 |
RECORD_DATE |
交易时间，date |
|
5 |
REMARK |
备注 varchar2(80) |
实现思路
(1) 创建数据表。
(2) 为项目添加Spring和Hibernate支持。
(3) 编写实体类和映射文件。
(4) 定义DAO接口和实现。
(5) 定义Biz接口和实现。
关键代码
(1) 配置文件的配置。
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="oracle.jdbc.OracleDriver">
</property>
<property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl">
</property>
<property name="username" value="scott"></property>
<property name="password" value="tiger"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.Oracle9Dialect
</prop>
<prop key="hibernate.show_sql">
true
</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>orm/Account.hbm.xml</value>
<value>orm/TblRecord.hbm.xml</value>
</list>
</property>
</bean>
(2) 实体类和映射文件。
//账户实体类
public class Account implements java.io.Serializable {
private Long accountId;//账户编号
private String userName;//账户名
private Integer money;//余额
private Timestamp createdate;//开户时间
//setter & getter
}
//交易记录实体
public class TblRecord implements java.io.Serializable {
private Long recordId;//交易编号
private Long fromaccount;//转账账户编号
private Long toaccount;//收款帐号
private Timestamp recordDate;//转账时间
private String remark;//备注
//setter & getter
}
(3) 定义DAO接口和实现，DAO实现需要继承HibernateDaoSupport，但不写方法和方法体。
//账户DAO
public interface AccountDAO {
}
//交易记录DAO
public interface RecordDAO {
}
(4) 定义Biz接口和实现，Biz的实现类需要增加两个属性，AccountDAO和RecordDAO，并生成setter和getter方法，但不添加任何方法和方法体。
//业务逻辑接口
public interface BankBiz {
}
2：声明式事务配置
训练技能点
Ø 声明式事务
需求说明
完善框架搭建，增加Biz和DAO的配置件和声明式事务。
实现思路
(1) 增加Biz和DAO的配置。
(2) 编写配置文件，增加声明式事务配置。
3：实现银行系统的开户和查看账户信息功能
训练技能点
Ø HibernateTemplate的使用
需求说明
实现开户和账户信息查询功能。
实现思路
(1) 完善DAO层的实现，编写方法和方法体。
(2) 完善Biz层的实现，编写方法和方法体。
(3) 编写测试代码，测试开户和账户信息查看功能。
关键代码
(1)在DAO中增加以下方法声明，并实现DAO的方法。
//RecordDAO中的方法声明
public TblRecord get(long id);
public void addRecord(TblRecord record);//增加交易记录
public void delRecord(long recordId);//删除交易记录
//AccountDAO中的方法声明
public Account get(long id);//根据主键查询账户信息
public void addAccount(Account account);//添加账户信息
public void delAccount(long id);//根据主键删除账户信息
public void updateAccount(Account account);//修改账户信息
public List findAllAccount();//查询所有账户信息
(2) 在Biz中增加以下方法声明，并实现Biz的方法。
//BankBiz接口中添加的方法声明
public Account findAccountById(long id);//查询账户信息
public void doAddAcount(Account account);//用户开户
//BankBiz方法的实现
public void doAddAcount(Account account) {
accountDAO.addAccount(account);
}
public Account findAccountById(long id) {
return accountDAO.get(id);
}
4：完善银行系统，增加转账功能
训练技能点
Ø HibernateTemplate的使用
Ø 业务逻辑层的实现
需求说明
实现转账功能。
实现思路
(1) 在Biz接口中增加转账方法声明。
(2) 实现转账方法。
(3) 编写测试代码，测试转账功能。
关键代码
(1)在Biz接口中增加转账方法声明。
//BankBiz中声明转账方法
public boolean doTransferAccount(long from,long to,int money);//转账
(2) 实现转账方法。
public boolean doTransferAccount(long from, long to, int money) {
boolean result = false;
// 根据编号获取账户信息
Account from_Account = accountDAO.get(from);
Account to_Account = accountDAO.get(to);
if (from_Account!=null&&from_Account.getMoney() > money)// 如果余额大于转账金额
{
if (to_Account != null)// 如果收款帐号存在
{
//扣除转账人账户余额
//添加收款人账户余额
//记录交易记录
result = true;
}
}
return result;
}
巩固练习
一．选择题
以下关于Spring对Hibernate提供支持的说法中，错误的是（）。
A. Spring提供了基类大大简化了程序代码
B. Spring提供的基类支持分页查询
C. Spring提供的基类需要注入sessionFactory才能正常运行
D. Spring提供的基类不需要注入sessionFactory
2. Spring整合Hibernate后，能够用于保存数据的方法有（）。
A. save
B. load
C. saveOrUpdate
D. merge
3. Spring整合Hibernate后，以下关于findByCriteria方法的说法中，正确的是（）。
A. 参数是HQL
B. 参数是Restrictions对象
C. 参数是DetachedCriteria对象
D. 该方法不支持分页
4. 以下关于 Spring与Hibernate集成的说法中，错误的是（）。
A. 通过集成Spring与Hibernate，以Spring管理程序的依赖关系，将SessionFactory注入 DataSource
B. 通过Spring，在Biz层代码中无须直接实例化DAO类，而是通过注入获得
C. 通过Spring，在DAO类中无须实例化SessionFactory，而是通过注入获得
D. Spring提供HibemateDaoSupport类简化Hibernate的使用
5.关于声明式事务，下面说法错误的是（）。
A.Spring采用AOP方式实现声明式事务
B.声明式事务是非侵入式的，可以不修改原来代码就给系统增加事务支持
C.配置声明式事务必须tx和aop两个命名空间的支持
D.事务有编程式事务和非编程式事务，声明式事务是非编程式事务
二．操作题
1.结合EMP的CURD，编写一个业务方法，实现员工的分页查询，每页显示5条员工信息。
2.查看课外书籍，使用注解重构实训任务的声明式事务。
3.升级实训任务，实现交易记录的分页查询。
提示：分页查询的实现
List list = super.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
String hql = "from TblRecord record where record.fromaccount=" + fromId;
Query query = session.createQuery(hql);
query.setFirstResult(firstResult);
query.setMaxResults(5);
return query.list();
}
});
4.重构“会员账户管理系统”，使用Hibernate实现DAO层开发，并编写测试代码，测试业务逻辑层的功能。要求使用声明式事务，每项业务操作都必须有日志记录。
