上一章讲过数据库层(Dao层)具有如下的特点：
2):支持多种类型的事务控制(单表，多表，混合)
3):查询支持Hibernate和原生SQL
为什么我们会这么设计呢？这里引用一下sprigside2.0的实现：
1：定义一个Dao接口
/**
* 针对单个Entity对象的操作定义.不依赖于具体ORM实现方案.
*
* @author calvin
*/
public interface EntityDao<T> {
T get(Serializable id);
List<T> getAll();
void save(Object o);
void remove(Object o);
void removeById(Serializable id);
/**
* 获取Entity对象的主键名.
*/
String getIdName(Class clazz);
}
2: 定义一个基本的实现类
/**
* Hibernate Dao的泛型基类.
* <p/>
* 继承于Spring的<code>HibernateDaoSupport</code>,提供分页函数和若干便捷查询方法，并对返回值作了泛型类型转换.
*
* @author calvin
* @author tin
* @see HibernateDaoSupport
* @see HibernateEntityDao
*/
@SuppressWarnings("unchecked")
public class HibernateGenericDao extends HibernateDaoSupport {
......
}
3:业务层中的每个对象都继承HibernateGenericDao
@SuppressWarnings("unchecked")
public class OrderManager extends HibernateEntityDao<Order> {
......
}
4:事务控制要配置到每个Manager
<!-- 支持 @Transactional 标记 -->
<tx:annotation-driven/>
<!-- 支持 @AspectJ 标记-->
<aop:aspectj-autoproxy/>
<!-- 以AspectJ方式 定义 AOP -->
<aop:config proxy-target-class="true">
<aop:advisor pointcut="execution(* org.springside.bookstore..*Manager.*(..))"
advice-ref="txAdvice"/>
<aop:advisor pointcut="execution(* org.springside.core.dao.*Dao.*(..))" advice-ref="txAdvice"/>
</aop:config>
<!-- 基本事务定义,使用transactionManager作事务管理,默认get*方法的事务为readonly,其余方法按默认设置.
默认的设置请参考Spring文档事务一章. -->
<tx:advice id="txAdvice">
<tx:attributes>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
这个可能是大众化的做法，但是我个人认为它只适用于一些简单的业务场合，如果做ERP,或者是我们现在做的鞋服行业，是很难满足业务需求的,打个比方，我们对单据中明细的一条操作，可能要引发5个到10个其它的操作，而这些操作，有的要执行批量脚本，有的只要执行一个存储过程，有的是删除一些数据，反正不确定的。下面简单讲讲我们的做法。
1：首先定义一个原子操作的接口，其中的pojo代表的不仅仅是po,也可能是一个存储过程名称，或者是一个脚本。。
public interface IOperator {
/**
*处理
* @param session
* @throws HibernateException
*/
public void execute(Session session) throws HibernateException;
/**
* 获取一个原子操作对象
* @return
*/
public Object getPojo();
}
2：定义一个抽象函数，实现IOperator
public abstract class AbstractOperator implements IOperator {
Object pojo=null;// 处理对象 ……
}
3:实现最基本的原子操作，比如增加保存一个hibernate对象，修改保存一个hibernate对象，删除pojo,执行一条脚本，以增加保存为例：
public class Add extends AbstractOperator {
public Add(Object obj) {
super(obj);
}
/**
* 处理增加的pojo
*/
public void execute(Session session) throws HibernateException {
if (pojo != null) {
session.save(pojo);
}
}
}
4:定义一个原子操作集合类，继承AbstractOperator
public class Operators extends AbstractOperator {
// 操作列表
List<IOperator> objectList = new ArrayList<IOperator>();
……
}
5:Dao定义一个集口，对原子操作集合类进行操作
public interface IDao {
/**
* 执行一组操作，这组操作包括增加，修改，删除，执行sql脚本，执行存储过程，清除cache等， 执行的先后顺序是在列表中增加的先后顺序
*/
public abstract void execute(final IOperator os) throws DataAccessException;
/**
* 增加保存一个对象
*/
public abstract Object addSave(final Object o) throws DataAccessException;
/**
* 修改保存一个对象
* @param o
* @throws DataAccessException
*/
public abstract void updateSave(final Object o) throws DataAccessException;
/**
* 删除一个对象
* @param o
* @throws DataAccessException
*/
public abstract void delete(final Object o) throws DataAccessException;
.......
}
6：Dao实现也是继承的spring 中的HibernateDaoSupport
7：事务控制参考springside的配置，只需要控制到Dao实现类就可以。
讲到这里，数据库层基本告一段落了，我个人体会是，数据库层讲难也难，讲易也易，但一定要根据业务需求来确定，适合业务才是最好的。