记录我开发鞋服行业供应链软件的历程<设计数据库层>

上一章讲过数据库层(Dao层)具有如下的特点：

     1):整个系统只有一个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实现类就可以。   

   讲到这里，数据库层基本告一段落了，我个人体会是，数据库层讲难也难，讲易也易，但一定要根据业务需求来确定，适合业务才是最好的。