JustinC 在路上...... http://justinc.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 购物车总结 justin8335 作者: justin8335  链接：http://justinc.javaeye.com/blog/134100  发表时间: 2007年10月21日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

购物车总结：
写一个购物车的类Cart
public class Cart {
     private float totalPrice;//总价
    
     private float savingMoney;//节省的金额

    //使用一个Map来保存购物车信息
    protected  Map<String,Orderitem> items;
    //初始化购物车，如果是第一次添加，则创建一个购物车信息集合
    public Cart(){
        if(items==null){
            items = new HashMap<String,Orderitem>();
        }
    }
   
    //添加购物车信息
    public void addToCart(String bookId , Orderitem ot){
       
        if(items.containsKey(bookId)){
        Orderitem _ot =    items.get(bookId); //_ot是原来的购物车中的OrderItem对象
        _ot.setNumber(ot.getNumber()+_ot.getNumber());
       
        items.put(bookId, _ot);
        }else{
            //否则直接加入一个购物信息
            items.put(bookId, ot);
        }
    }
   
    //更新购物车信息（数量）
   
    public void updateCart(String bookId , Orderitem ot){
        //直接覆盖最近的数据信息
        items.put(bookId, ot);
    }
   
    //删除购物车信息
   
    public void deleteFromCart(String bookId){
          items.remove(bookId);
    }

    //取打折后总价格
    public float getTotalPrice(){
        float totalPrice = 0;
        for(Iterator it = items.values().iterator();it.hasNext();){
            Orderitem ot = (Orderitem)it.next();
            Book book = ot.getBook();
            totalPrice += ot.getNumber()*(book.getPrice()*(book.getDiscount()*0.01));
        }
       
        return totalPrice;
    }
    //取节省的钱

     public float getSavingMoney(){
        float savingMoney = 0 ;
        for(Iterator it = items.values().iterator();it.hasNext();){
            Orderitem ot = (Orderitem)it.next();
            Book book = ot.getBook();
            savingMoney += ot.getNumber()*(book.getPrice()*(float)(1-book.getDiscount()*0.01));

        }
       
        return savingMoney;
       
    }

    public Map<String, Orderitem> getItems() {
        return items;
    }

    public void setItems(Map<String, Orderitem> items) {
        this.items = items;
    }   
   
}

在验证用户登陆的地方，验证成功后创建一个Cart对象，并将它保存在session会话中
当我们要添加，更新，删除购物信息时，从session中存取该Cart对象
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 21 Oct 2007 23:03:25 +0800 http://justinc.javaeye.com/blog/134100 http://justinc.javaeye.com/blog/134100 分页总结 justin8335 作者: justin8335  链接：http://justinc.javaeye.com/blog/134099  发表时间: 2007年10月21日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

分页总结：

通过当前页判断是否有上一页下一页和首尾页
通过总记录数得出总页数
public class Pager {

    private int currentPage;//当前页码
    private int pageSize=3;//每页记录数
    private int totalPage;//总页数
    private int totalSize;//总记录数
   
   
    private boolean hasFirst;
    private boolean hasPrevious;
    private boolean hasNext;
    private boolean hasLast;
   
    //初始化
    public Pager(int currentPage,int totalSize){
        this.currentPage=currentPage;
        this.totalSize=totalSize;
    }
    
   
    public int getCurrentPage() {
        return currentPage;
    }
    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }
   
    public boolean isHasFirst() {
       
        if(this.currentPage == 1){
            return false;
        }
       
        return true;
    }
   
    public void setHasFirst(boolean hasFirst) {
        this.hasFirst = hasFirst;
    }
   
    public boolean isHasLast() {
        if(this.currentPage == this.getTotalPage()){
            return false;
        }
        return true;
    }
    public void setHasLast(boolean hasLast) {
        this.hasLast = hasLast;
    }
    public boolean isHasNext() {
       
        if(this.isHasLast()){
            return true;
        }
        return false;
    }
    public void setHasNext(boolean hasNext) {
        this.hasNext = hasNext;
    }
    public boolean isHasPrevious() {
       
        if(this.isHasFirst()){
            return true;
        }
        return false;
    }
    public void setHasPrevious(boolean hasPrevious) {
        this.hasPrevious = hasPrevious;
    }
    public int getPageSize() {
        return pageSize;
    }
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
    public int getTotalPage() {
       
        totalPage = totalSize/pageSize;
        if(totalSize%pageSize!=0)
            totalPage++;
       
        return totalPage;
    }
    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }
    public int getTotalSize() {
        return totalSize;
    }
    public void setTotalSize(int totalSize) {
        this.totalSize = totalSize;
    }    
}


 //DAO
public List queryByPager(int currentPage,int pageSize){
        //计算起始行从0开始
        final int startRow =  (currentPage-1)*pageSize ;
        final int maxResults = pageSize;
        //利用回调接口，调用Hibernate原生API

        List bookList =(List) getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session)throws HibernateException,SQLException{
                 Query query = session.createQuery("From Book as b left join fetch  b.category ")
                        .setFirstResult(startRow)
                        .setMaxResults(maxResults);
                 
                return query.list();
            }
        });
       
        return bookList;
      
      
    }
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 21 Oct 2007 23:02:34 +0800 http://justinc.javaeye.com/blog/134099 http://justinc.javaeye.com/blog/134099 Spring中的数据访问使用Hibernate justin8335 作者: justin8335  链接：http://justinc.javaeye.com/blog/133980  发表时间: 2007年10月21日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Spring中的数据访问


不管使用哪种DAO技术，Spring提供了统一的异常处理机制。
使用O/R Mapping的访问框架中的模版(HibernateTemplate),开发者无需考虑是否要处理异常，
因为SpringDAO代劳了这些工作。

HibernateDaoSupport：Hibernate DAO抽象类，开发者需要为他配置Hibernate SessionFactory。
通过注入的方式实现。通过HibernateDaoSupport之类，可以获得HibernateTemplate.
Spring中的所有模版类都是线程安全的包括(HibernateTemplate)

定义Hibernate资源
使用JNDI 或者是 DBCP 配置数据源




（1）想要直接使用HibernateTemplate，必须先在DAO对象中定义sessionFactory,
然后注入sessionFactory ，在相应的DAO对象里定义sessionFactory变量，以及他的
Setter方法。

最后，开发者实现HibernateTemplate调用过程时，需要实现HibernateCallback回调接口。
可以发现，这种回调实现能够实现基于Hibernate的DAO访问。
与此同时，HibernateTemplate能够保证正确的打开和关闭HibernateSession，并自动参与到
事务当中。HibernateTemplate是线程安全的，对于简单的Hibernate操作，比如单个find,
saveOrUpdate操作，直接使用HibernateTemplate比较有效率。

（2）还可以让DAO实现HibernateDaoSupport接口 ，但这样使得Hibernate与Spring的耦合度增加

在处理简单的数据库操作时，使用HibernateTemplate带的find(),save()等的方法效率更好。
如果处理比较复杂的操作时(比如分页)可以使用hibernate的回调接口

List bookList =(List) getHibernateTemplate().execute(new HibernateCallback(){
            public Object doInHibernate(Session session)throws HibernateException,SQLException{
                 Query query = session.createQuery("From Book as b left join fetch  b.category ")
                        .setFirstResult(startRow)
                        .setMaxResults(maxResults);
                 
                return query.list();
            }
        });
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 21 Oct 2007 15:56:03 +0800 http://justinc.javaeye.com/blog/133980 http://justinc.javaeye.com/blog/133980 Spring事务管理 justin8335 作者: justin8335  链接：http://justinc.javaeye.com/blog/129030  发表时间: 2007年10月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

数据库事务必须具备ACID特性，即Atomic（原子性），Consistency（一致性），Isolation（隔离性）和Durability（持久性）。
对于开发人员来说，并不需要了解数据库事务的底层细节，只需要通过数据库系统提供的接口，就可以按照业务需求来控制事务。

Spring提供了强大而简便的事务处理功能，核心就是PlatformTransactionManager抽象接口。
Spring将所有事务管理都抽象为PlatformTransactionManager、TransactoinStatus和TransactionDefinition这三个接口。

PlatformTransactionManager定义了事务管理，所有与事务相关的操作都由PlatformTransactionManager管理；

TransactionStatus定义了事务状态，PlatformTransactionManager会根据TransactionStatus的状态来决定是否回滚事务。

TransactionDefinition定义了事务的隔离级别和传播行为，在启动事务时，PlatformTransactionManager根据TransactionDefinition来启动合适的事务。

事务的隔离级别是由底层的数据库系统实现的。
事务的传播行为则是应用程序自己管理的，他决定了事务如何在应用程序中传播，一般是由底层框架来完成。

Spring支持如下的事务传播行为：
词汇：
propagation  [,prɒpә'geiʃәn]n.  增殖, 繁殖, 宣传  [医] 传播, 繁殖, 持续培养
mandatory  ['mændәtәri]a.  命令的, 托管的  [经] 受托者, 命令者

（1）PROPAGATION_REQUIRED :Spring的默认的事务传播行为。必须在事务内执行，如果当前存在事务就加入当前事务，         如果 当前没有事务，就创建一个新的事务。

（2）PROPAGATION_SUPPORTS:支持当前的事务，如果当前没有事务，可以以非事务方式执行。

（3）PROPAGATION_MANDATORY :必须在当前事务内执行，如果当前没有事务，就直接抛出异常。

（4）PROPAGATION_REQUIRES_NEW:总是新建一个事务，如果当前存在事务，就把当前事务挂起，直到新事务执行完毕

（5）PROPAGATION_NOT_SUPPORTED:不能在事务环境下执行，如果当前存在事务，就把当前事务挂起。

（6）PROPAGATION_NEVER:不能在事务环境下执行，如果当前存在事务，就直接抛出异常。

（7）PROPAGATION_NESTED:必须在事务内执行，如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则执行与
          PROPAGATION_REQUIRED类似的操作，就是创建一个新的事务。

使用编程式事务管理
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 03 Oct 2007 22:40:42 +0800 http://justinc.javaeye.com/blog/129030 http://justinc.javaeye.com/blog/129030 Spring2.0+Struts1.2+Hibernate3.1集成 justin8335 作者: justin8335  链接：http://justinc.javaeye.com/blog/129028  发表时间: 2007年10月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

运行环境：Tomcat5.0+Spring2.0+Struts1.2+Hibernate3.1

 

注意：使用Spring1.x 与Struts集成，与Spring2.0 与Struts集成存在不同点

我门可以采用三种方式之一来整合Spring和Struts：
1.Struts的Action继承Spring的ActionSupport类，并在Action中获取Spring的ApplicationContext。这

是最简单的一种整合方式，但有三个缺点：第一，Struts与Spring紧密耦合，不能改换到其他IoC容器；

第二，难以使用Spring AOP特性；第三，对于需要使用DispatchAction的Struts应用无能为力。


2.在Struts的配置文件中，以Spring的DelegatingRequestProcessor类代替Struts的RequestProcessor类

，并在Spring的配置文件中定义与Struts配置文件中<action-mappings>对应的bean，从而将Struts的

Action与Spring分开，并把Struts的动作置于Spring的控制之下。这种整合方式的优点是将不再依赖

Spring这个特定的IoC容器，但必须依赖Struts的RequestProcessor类。


3.通过Spring的DelegatingActionProxy类代理Struts的动作，即在Struts配置文件中，定义<action-mappings>的type属性全部改为DelegatingActionProxy，而不是具体的类名，并在Spring配置文件中定义与Struts动作映射对应的bean，从而将Struts的Action与Spring分开，并把Struts的动作置于Spring的控制之下。

无疑，这是最灵活的一种整合方式。


第一步 完善applicationContext.xml内容

1、添加事务处理。内容如下：

 

xml 代码
 
  1. <bean id="transactionManager"  
  2.   
  3. class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  4.     <property name="sessionFactory">  
  5.      <ref local="sessionFactory" />  
  6.     </property>  
  7.    </bean>  
  8.    <bean id="customerDAOProxy"  
  9.   
  10. class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
  11.     <property name="transactionManager">  
  12.      <ref bean="transactionManager" />  
  13.     </property>  
  14.     <property name="target">  
  15.      <ref local="customerDAO" />  
  16.     </property>  
  17.     <property name="transactionAttributes">  
  18.      <props>  
  19.       <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  20.      </props>  
  21.     </property>  
  22.    </bean>  

2、CustomerAction Bean注入事务处理。内容如下：

 

xml 代码
 
  1. <bean name="/customer" class="com.ssh.struts.action.CustomerAction" >  
  2.       <property name="customerDAO"><ref bean="customerDAOProxy"/></property>  
  3.   </bean>  

 3、最终applicationContext.xml文件，内容如下：

xml 代码
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.  xmlns="http://www.springframework.org/schema/beans"  
  4.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.  xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.   
  7. http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">  
  8.    
  9.  <bean id="dataSource"  
  10.   class="org.apache.commons.dbcp.BasicDataSource">  
  11.   <property name="driverClassName"  
  12.    value="com.mysql.jdbc.Driver">  
  13.   </property>  
  14.   <property name="url"  
  15.    value="jdbc:mysql://localhost:3306/pullhand">  
  16.   </property>  
  17.   <property name="username" value="root"></property>  
  18.   <property name="password" value="815241"></property>  
  19.  </bean>  
  20.    
  21.  <bean id="sessionFactory"  
  22.   class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  23.   <property name="dataSource">  
  24.    <ref bean="dataSource" />  
  25.   </property>  
  26.   <property name="hibernateProperties">  
  27.    <props>  
  28.     <prop key="hibernate.dialect">  
  29.      org.hibernate.dialect.MySQLDialect  
  30.     </prop>  
  31.    </props>  
  32.   </property>  
  33.   <property name="mappingResources">  
  34.    <list>  
  35.     <value>com/ssh/beans/po/Customer.hbm.xml</value></list>  
  36.   </property>  
  37.   </bean>  
  38.    
  39.   <bean id="transactionManager"  
  40.   
  41. class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  42.     <property name="sessionFactory">  
  43.      <ref local="sessionFactory" />  
  44.     </property>  
  45.    </bean>  
  46.    <bean id="customerDAOProxy"  
  47.   
  48. class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
  49.     <property name="transactionManager">  
  50.      <ref bean="transactionManager" />  
  51.     </property>  
  52.     <property name="target">  
  53.      <ref local="customerDAO" />  
  54.     </property>  
  55.     <property name="transactionAttributes">  
  56.      <props>  
  57.       <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  58.      </props>  
  59.     </property>  
  60.    </bean>  
  61.     
  62.   <bean id="customerDAO" class="com.ssh.beans.dao.CustomerDAO">  
  63.    <property name="sessionFactory">  
  64.     <ref bean="sessionFactory" />  
  65.    </property>  
  66.   </bean>  
  67.     
  68.   <bean name="/customer" class="com.ssh.struts.action.CustomerAction" >  
  69.       <property name="customerDAO"><ref bean="customerDAOProxy"/></property>  
  70.   </bean>   
  71.     
  72.  </beans>  

第二步，修改CustomerAction

最后内容如下：

java 代码
 
  1. package com.ssh.struts.action;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. import javax.servlet.http.HttpServletRequest;  
  7. import javax.servlet.http.HttpServletResponse;  
  8. import org.apache.struts.action.Action;  
  9. import org.apache.struts.action.ActionForm;  
  10. import org.apache.struts.action.ActionForward;  
  11. import org.apache.struts.action.ActionMapping;  
  12.   
  13. import com.ssh.beans.dao.ICustomerDAO;  
  14. import com.ssh.beans.po.Customer;  
  15.   
  16.   
  17. public class CustomerAction extends Action {  
  18.  ICustomerDAO customerDAO=null;  
  19.  public void setCustomerDAO(ICustomerDAO customerDAO){  
  20.   this.customerDAO=customerDAO;  
  21.  }  
  22.    
  23.  public ActionForward execute(ActionMapping mapping, ActionForm form,  
  24.    HttpServletRequest request, HttpServletResponse response) {  
  25.   List list=new ArrayList();  
  26.   Customer customer=null;  
  27.   if(customerDAO!=null){  
  28.    list=customerDAO.getALLCustomer();  
  29.    for(int i=0;i<list.size();i++){  
  30.     customer=(Customer)list.get(i);  
  31.     System.out.println("OK:"+customer.getCustName());  
  32.    }  
  33.   }else{  
  34.    System.out.println("ERROR or NULL");  
  35.   }  
  36.   return mapping.findForward("success");  
  37.  }  
  38. }  

第三步 解决找不到Action问题

初学者会经常遇到下面这个问题：

HTTP Status 404 - Servlet action is not available

--------------------------------------------------------------------------------

type Status report

message Servlet action is not available

description The requested resource (Servlet action is not available) is not available.


--------------------------------------------------------------------------------

Apache Tomcat/5.0.28
就是找不到我们的action。

当你努力去解决这个问题时，会发现去掉applicationContext.xml下面这个<property>标签，一切正常：

 

xml 代码
 
  1. <property name="mappingResources">  
  2.   <list>  
  3.    <value>  
  4.     com/ssh/beans/po/Customer.hbm.xml  
  5.    </value>  
  6.   </list>  
  7.  </property>  

那是什么原因呢？我想大家都会首先想到下面两个问题：

1、路径是否正确：即com/ssh/beans/po/Customer.hbm.xml的路径正确么？

2、文件是否正确：即Customer.hbm.xml的文件内容对么？

当你费了一身力气发现一切OK，到底什么原因？？？

问题在于构件路径(lib)内的包重叠（提示：前提是你要保证这个问题出现之前都正常），所以你要确定

构建路径里的包不能重复！

建议：大家在导入包时，按照默认导入，不要把所有的包都导进工程，在操作中在把需要的jar包导进去(

最好不要把整个liberaries导进去），这样即可以减小工程的大小，又能确保struts\spring\hibernate

之间的包不会重叠或者被替换。

解决办法：把lib下的hibernate-annotations.jar文件删除，重启Tomcat后即可正常运行。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 03 Oct 2007 22:32:07 +0800 http://justinc.javaeye.com/blog/129028 http://justinc.javaeye.com/blog/129028 集成Spring与Hibernate justin8335 作者: justin8335  链接：http://justinc.javaeye.com/blog/129023  发表时间: 2007年10月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

集成Spring与Hibernate，
将dataSource与sessionFactory添加进Spring的配置文件，
将Hibernate下的DAO交由Spring来管理。

xml 代码
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">  
  6.   
  7.   
  8.     <bean id="dataSource"  
  9.         class="org.apache.commons.dbcp.BasicDataSource">  
  10.         <property name="driverClassName"  
  11.             value="com.mysql.jdbc.Driver">  
  12.         </property>  
  13.         <property name="url"  
  14.             value="jdbc:mysql://localhost:3306/test">  
  15.         </property>  
  16.         <property name="username" value="root"></property>  
  17.         <property name="password" value="admin"></property>  
  18.     </bean>  
  19.     <bean id="sessionFactory"  
  20.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  21.         <property name="dataSource">  
  22.             <ref bean="dataSource" />  
  23.         </property>  
  24.         <property name="hibernateProperties">  
  25.             <props>  
  26.                 <prop key="hibernate.dialect">  
  27.                     org.hibernate.dialect.MySQLDialect  
  28.                 </prop>  
  29.             </props>  
  30.         </property>  
  31.         <property name="mappingResources">  
  32.             <list>  
  33.                 <value>org/justin/vo/Login.hbm.xml</value></list>  
  34.         </property></bean>  
  35.     <bean id="loginDAO" class="org.justin.dao.impl.LoginDAO">  
  36.         <property name="sessionFactory">  
  37.             <ref bean="sessionFactory" />  
  38.         </property>  
  39.     </bean>  

在Spring提供的HibernateDaoSupprot超类中，如果注入SessionFactory，HibernateDaoSupport就会自动生成HibernateTemplate对象，HibernateTemplate是线程安全的。

让Hibernate的DAO类继承Spring的HibernateDaoSupport类，这样DAO类就可以通过getHibernateTemplate()方法
获得一个HibernateTemplate对象，HibernateTemplate对象本身包含了SessionFactory的引用，因此HibernateTemplate对象可以完成所有的Hibernate操作。
java 代码
 
  1. public class LoginDAO extends HibernateDaoSupport implements ILoginDAO  
通过HibernateTemplate提供的方法实现CRUD操作
（1）Serializable save(Object entity)

（2）Object get(Class entity , Serializable id)

（3）Object load(String entityName,Serializable id)

（4）void update(Objecet entity)

（5）void delete(Objecet entity)

HibernateTemplate实现分页处理
java 代码
  1.  public List findByPagination(Login login){  
  2.          List list =(List)this.getHibernateTemplate().execute(new HibernateCallback(){  
  3.             public Object doInHibernate(Session session)throws HibernateException,SQLException  
  4.             {  
  5.                 Criteria criteria = session.createCriteria(Login.class)  
  6.                        .setFirstResult(0)  
  7.                        .setMaxResults(10);  
  8.                           
  9.                 return criteria.list();  
  10.   /* 也可以使用Query接口            
  11. Query query = session.createQuery("From Login as L") 
  12.                    .setFirstResult(0).setMaxResults(3); 
  13.                  
  14.                 return query.list();*/  
  15.             }  
  16.          });  
  17.            
  18.          return list ;  
  19.      }  

HibernateTemplate提供的Object execute（HibernateCallback action）方法允许执行任何Hibernate操作
在doInHibernate中可以使用任意的Hibernate接口，如Query，Criteria等

其中HibernateCallback是一个回调接口！
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 03 Oct 2007 22:07:50 +0800 http://justinc.javaeye.com/blog/129023 http://justinc.javaeye.com/blog/129023 常见SSH的架构设计策略（二） justin8335 作者: justin8335  链接：http://justinc.javaeye.com/blog/128809  发表时间: 2007年10月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Rich Domain Object模式

在这种模式下，Domain Object不再是单纯的数据载体，Domain Object包含了相关的业务逻辑方法。例如News类包含了addNewsView 方法等。

下面是修改后的News类的源代码：

java 代码
  1. public class News extends BaseObject   
  2.   
  3. {   
  4.   
  5.     //此处省略了其他的属性   
  6.   
  7.     //此处省略了属性对应的setter和getter方法   
  8.   
  9.     //增加新闻回复的业务逻辑方法   
  10.   
  11.     public NewsReview addNewsReview(String content)   
  12.   
  13.     {   
  14.   
  15.         //以默认构造器创建新闻回复实例   
  16.   
  17.           NewsReview review = new NewsReview();   
  18.   
  19.         //设置回复内容   
  20.   
  21.           review.setContent(content);   
  22.   
  23.         //设置回复的发布日期   
  24.   
  25.           review.setPostDate(new Date());   
  26.   
  27.         //设置回复的最后修改日期   
  28.   
  29.           review.setLastModifyDate(new Date());   
  30.   
  31.         //设置回复与消息的关联   
  32.   
  33.           review.setNews(this);   
  34.   
  35.           return review;   
  36.   
  37.     }   
  38.   
  39.     //此处省略了重写的hashCode，equals等方法   
  40.   
  41. }   
  42.   

在上面的Domain Object中，包含了相应的业务逻辑方法，这是一种更完备的建模方法。

注意：不要在Domain Object中对消息回复完成持久化，如需完成持久化，必须调用DAO组件；一旦调用DAO组件，将造成DAO对象和Domain Object的双向依赖；另外，Domain Object中的业务逻辑方法还需要在业务逻辑组件中代理，才能真正实现持久化。

在上面的业务逻辑方法中，并没有进行持久化。如果抛开DAO层，这种Domain Object也可以独立测试，只是没有进行持久化。

DAO对象是变化最小的对象，它们都是进行基本的CRUD操作，在两种模型下的DAO对象没有变化。

另外还需要对业务逻辑对象进行改写，虽然Domain Object包含了基本业务逻辑方法，但业务逻辑对象还需代理这些方法，修改后业务逻辑对象的代码如下：

java 代码
  1. public class FacadeManagerImpl implements FacadeManager   
  2.   
  3. {   
  4.   
  5.     //业务逻辑对象依赖的DAO对象   
  6.   
  7.     private CategoryDAO categoryDAO;   
  8.   
  9.     private NewsDAO newsDAO;   
  10.   
  11.     private NewsReviewDAO newsReviewDAO;   
  12.   
  13.     private UserDAO userDAO;   
  14.   
  15.     //...此处还应该增加依赖注入DAO对象必需的setter方法   
  16.   
  17.     //...此处还应该增加其他业务逻辑方法   
  18.   
  19.     //下面是增加新闻回复的业务方法   
  20.   
  21.     public NewsReview addNewsReview(Long newsId , String content)   
  22.   
  23.     {   
  24.   
  25.         //根据新闻id加载新闻   
  26.   
  27.           News news = newsDao.getNews(newsId);   
  28.   
  29.         //通过News的业务方法添加回复   
  30.   
  31.         NewsReview review = news.addNewsReview(content);   
  32.   
  33.         //此处必须显示持久化消息回复   
  34.   
  35.           newsReviewDAO.saveNewsReview(review);   
  36.   
  37.           return review;   
  38.   
  39.     }   
  40.   
  41. }   
  42.   

在Rich Domain Object的模型中，addNewsReview方法将放在News类中实现，而业务逻辑对象仅对该方法进行简单的代理，执行必要的持久化操作。

在这里存在一个问题：业务逻辑方法很多，哪些业务逻辑方法应该放在Domain Object对象中实现，而哪些业务逻辑方法完全由业务逻辑对象实现呢？Rod Johnson认为，可重用度高，与Domain Object密切相关的业务方法应放在Domain Object对象中实现。

业务逻辑方法是否需要由Domain Object实现的标准，从一定程序上说明了采用Rich Domain Object模型的原因。由于某些业务方法只是专一地属于某个Domain Object，因此将这些方法由Domain Object实现，能提供更好的软件复用，能更好地体现面向对象的封装性。

Rich Domain Object模型的各组件之间关系大致如图8.2所示（贫血模式的组件关系图与此类似）。

图8.2  Rich Domain Object的组件关系图

这种Rich Domain Object模型主要的问题是业务逻辑对象比较复杂，由于业务逻辑对象需要正面封装所有的DAO对象，因而难免有大量的DAO方法（基本的CRUD）需要业务逻辑对象封装。业务逻辑对象封装DAO方法主要基于如下考虑：

—  DAO对象不应该暴露为Web层。

—  DAO对象的DAO方法必须增加事务控制代码，而事务控制则放在业务逻辑层完成。

为了简化业务逻辑对象的开发，Rich Domain Object模型可以有如下两个方向的改变：

— 合并业务逻辑对象与DAO对象。

— 合并业务逻辑对象和Domain Object。

1．合并业务逻辑对象与DAO对象

在这种模型下DAO对象不仅包含了各种CRUD方法，而且还包含各种业务逻辑方法。此时的DAO对象，已经完成了业务逻辑对象所有任务，变成了DAO对象和业务逻辑对象混合体。此时，业务逻辑对象依赖Domain Object，既提供基本的CRUD方法，也提供相应的业务逻辑方法。

下面是这种模式的代码（Domain Object的实现与前面的Rich Domain Object模式一样，此处不再给出）：

java 代码
  1. // NewsServiceHibernate继承HibernateDaoSupport，实现NewsService接口   
  2.   
  3. public class NewsServiceHibernate extends HibernateDaoSupport    
  4.   
  5. implements NewsService   
  6.   
  7. {   
  8.   
  9.     //此处添加NewsService对象依赖的DAO对象，以及对应的setter方法   
  10.   
  11.     //根据主键加载消息   
  12.   
  13.     public News getNews(Long id)    
  14.   
  15.     {   
  16.   
  17.           News news = (News) getHibernateTemplate().get(News.class, id);   
  18.   
  19.           if (news == null) {   
  20.   
  21.                throw new ObjectRetrievalFailureException(News.class, id);      
  22.   
  23.           }   
  24.   
  25.         return news;   
  26.   
  27.     }   
  28.   
  29.     //保存新的消息   
  30.   
  31.     public void saveNews(News news) {   
  32.   
  33.           getHibernateTemplate().saveOrUpdate(news);   
  34.   
  35.     }   
  36.   
  37.     //根据主键删除消息   
  38.   
  39.     public void removeNews(Long id)   
  40.   
  41.     {   
  42.   
  43.           getHibernateTemplate().delete(getNews(id));   
  44.   
  45.     }   
  46.   
  47.     //查找全部的消息   
  48.   
  49.     public List findAll()   
  50.   
  51.     {   
  52.   
  53.         getHibernateTemplate().find("from News"));   
  54.   
  55.     }   
  56.   
  57.     //下面是增加新闻回复的业务方法   
  58.   
  59.     public NewsReview addNewsReview(Long newsId , String content)   
  60.   
  61.     {   
  62.   
  63.         //根据新闻id加载新闻   
  64.   
  65.           News news = newsDao.getNews(newsId);   
  66.   
  67.         //通过News的业务方法添加回复   
  68.   
  69.         NewsReview review = news.addNewsReview(content);   
  70.   
  71.         //此处必须显示持久化消息回复   
  72.   
  73.           newsReviewService.saveNewsReview(review);   
  74.   
  75.           return review;   
  76.   
  77.     }   
  78.   
  79. }   
  80.   

正如上面见到的，DAO对象和业务逻辑对象之间容易形成交叉依赖（可能某个业务逻辑方法的实现，必须依赖于原来的DAO对象）。当DAO对象被取消后，业务逻辑对象取代了DAO对象，因此变成了一个业务逻辑对象依赖多个业务逻辑对象。而每个业务逻辑对象都可能包含需要多个DAO对象协作的业务方法，从而导致业务逻辑对象之间的交叉依赖。

业务逻辑对象和DAO对象合并后的组件关系如图8.3所示。

图8.3  合并DAO对象和业务逻辑对象

这种模型也导致了DAO方法和业务逻辑方法混合在一起，显得职责不够单一，软件分层结构不够清晰。此外，使业务逻辑对象之间交叉依赖，容易产生混乱，未能做到彻底的简化。

2．合并业务逻辑对象和Domain Object

在这种模型下，所有的业务逻辑都应该被放在Domain Object里面，而此时的业务逻辑层不再是传统的业务逻辑层，它仅仅封装了事务和少量逻辑，完全无需DAO对象的支持。而Domain Object依赖于DAO对象执行持久化操作，此处Domain Object和DAO对象形成双向依赖，这种设计在某些地方也被称为充血模式，但有时会带来相当大的危险。

在这种设计模式下，几乎不再需要业务逻辑层，而Domain Object则依赖DAO对象完成持久化操作，下面是在这种模式下的News类代码：

java 代码
  1. public class News extends BaseObject   
  2.   
  3. {   
  4.   
  5.     //此处省略了其他的属性。   
  6.   
  7.     //此处省略了属性对应的setter和getter方法   
  8.   
  9.     //增加新闻回复的业务逻辑方法   
  10.   
  11.     public NewsReview addNewsReview(String content)   
  12.   
  13.     {   
  14.   
  15.         //以默认构造器创建新闻回复实例   
  16.   
  17.           NewsReview review = new NewsReview();   
  18.   
  19.         //设置回复内容   
  20.   
  21.           review.setContent(content);   
  22.   
  23.         //设置回复的发布日期   
  24.   
  25.           review.setPostDate(new Date());   
  26.   
  27.         //设置回复的最后修改日期   
  28.   
  29.           review.setLastModifyDate(new Date());   
  30.   
  31.         //设置回复与消息的关联   
  32.   
  33.           review.setNews(this);   
  34.   
  35.         //直接调用newsReviewsDao完成消息回复的持久化。   
  36.   
  37.         newsReviewsDao.save(review);   
  38.   
  39.           return review;   
  40.   
  41.     }   
  42.   
  43.     //此处省略了重写的hashCode，equals等方法   
  44.   
  45. }   
  46.   

从上面代码中可以看到，由于Domain Object必须使用DAO对象完成持久化，因此Domain Object必须接收IOC容器的注入，而Domain Object获取容器注入的DAO对象，通过DAO对象完成持久化操作。

合并业务逻辑对象和Domain Object后各组件的关系如图8.4所示。

这种模型的优点是：业务逻辑对象非常简单，只提供简单的事务操作，业务逻辑对象无须依赖于DAO对象。

但这种模型的缺点也是非常明显的：

—  DAO对象和Domain Object形成了双向依赖，其复杂的双向依赖会导致很多潜在的问题。

— 业务逻辑层和Domain层的逻辑混淆不清，在实际项目中，极容易导致架构混乱。

— 由于使用业务逻辑对象提供事务封装特性，业务逻辑层必须对所有的Domain Object的逻辑提供相应的事务封装，因此业务逻辑对象必须重新定义Domain Object实现的业务逻辑，其工作相当烦琐。

图8.4  合并业务逻辑组件和Doamin Object

8.4.3  抛弃业务逻辑层

在Rich Domain Object模型的各种变化中，虽然努力简化业务逻辑对象，但业务逻辑对象依然存在，依然使用业务逻辑对象正面封装所有的业务请求。下面介绍更彻底的简化即，彻底放弃业务逻辑层。

抛弃业务逻辑层也有两种形式：

—  Domain Object彻底取代业务逻辑对象。

— 由控制器直接调用DAO对象。

1．Domain Object完全取代业务逻辑对象

这种设计模式是充血模式更加激进的演化。由于在充血模式中业务逻辑对象的作用仅仅只提供事务封装，业务逻辑对象存在的必要性不是很大，因此考虑对Domain Object的业务逻辑方法增加事务管理，而Web层的控制器则直接依赖于Domain Object。

这种模型更加简化，使Domain Object与DAO对象形成双向依赖，而Web层的控制器直接调用Domain Object的业务逻辑方法。这种模型在有些地方也被称为胀血模式。

这种模型的优点是：分层少，代码实现简单。

但这种模型的缺点也很明显：

— 业务逻辑对象的所有业务逻辑都将在Domain Object中实现，势必引起Domain Object的混乱。

—  Domain Object必须向Web层直接暴露，可能导致意想不到的问题。

这种模型与充血模式的缺点相同：Domain Object必须配置在Spring容器中，接受Spring容器的依赖注入。

在这种架构模型下，Domain Object相当不稳定。如果业务逻辑需要改变，Domain Object也需要发生改变，而DAO对象与Domain Object形成双向依赖，这将导致从底层的Domain Object和DAO对象的修改，使这种架构模式的分层完全失去意义。各层之间以强耦合方式组合在一起，各层对象互相依赖，牵一发而动全身，几乎是最差的一种策略。

2．控制器完成业务逻辑

在这种模型里，控制器直接调用DAO对象的CRUD方法，通过调用基本的CRUD方法，完成对应的业务逻辑方法。这种模型下，业务逻辑对象的功能由控制器完成。事务则推迟到控制器中完成，因此对控制器的execute方法增加事务控制即可。

对于基本的CRUD操作，控制器可直接调用DAO对象的方法，省略了业务逻辑对象的封装，这就是这种模型的最大优势。对于业务逻辑简单（当业务逻辑只是大量的CRUD操作时）的项目，使用这种模型也未尝不是一种好的选择。

但这种模型将导致控制变得臃肿，因为每个控制器除了包含原有的execute方法之外，还必须包含所需要的业务逻辑方法的实现。极大地省略了业务逻辑层的开发，避免了业务逻辑对象不得不大量封装基本的CRUD方法的弊端。

这种模型也有其缺点：

— 因为没有业务逻辑层，对于那些需要多个DAO参与的复杂业务逻辑，在控制器中必须重复实现，其效率低，也不利于软件重用。

—  Web层的功能不再清晰，人为复杂化。Web层不仅负责实现控制器逻辑，还需要完成业务逻辑的实现，因此必须精确控制何时调用DAO方法控制持久化。

— 扩大了事务的影响范围。大部分情况下，只有业务逻辑方法需要增加事务控制，而execute方法无须增加事务控制。但如果execute方法直接调用了DAO对象的CRUD方法，则会导致这些方法不在事务环境下执行。为了让数据库访问都在事务环境下进行，因此不得不将事务范围扩大到整个execute方法。

本章小结

本章首先介绍了笔者在架构设计方面一些经验，从企业应用开发面临的困难讲起，并讲解了面对这些困难时应该采用何种应对策略。

其次介绍了常用的代理模式的使用，并深入介绍了由此衍生出来的Spring AOP框架。

最后重点介绍了贫血模型、Rich Domain Object模型、以及几种简化的模型，并分别分析了几种模型各自的优缺点。


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 03 Oct 2007 00:26:35 +0800 http://justinc.javaeye.com/blog/128809 http://justinc.javaeye.com/blog/128809 常见SSH的架构设计策略（一） justin8335 作者: justin8335  链接：http://justinc.javaeye.com/blog/128806  发表时间: 2007年10月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

（转载自）轻量级J2EE企业应用实战——Struts+Spring+Hibernate整合开发         李刚

常见的架构设计策略

目前流行的轻量级J2EE应用的架构比较一致，采用的技术也比较一致，通常使用Spring作为核心，向上整合MVC框架，向下整合ORM框架。使用Spring的IOC容器来管理各组件之间的依赖关系时，Spring的声明事务将负责业务逻辑层对象方法的事务管理。

但在固定的技术组合上，依然可能存在小的变化。下面依次讨论可能存在的架构策略。

8.4.1  贫血模式

贫血模式是最常用的设计架构，也是最容易理解的架构。为了让读者通过本书顺利进入轻量级J2EE企业应用开发，本书的第9章及第10章的范例都将采用这种简单的架构模式。

所谓贫血，指Domain Object只是单纯的数据类，不包含业务逻辑方法，即每个Domain Object类只包含基本的setter和getter方法。所有的业务逻辑都由业务逻辑组件实现，这种Domain Object就是所谓的贫血的Domain Object，采用这种Domain Object的架构即所谓的贫血模式。

下面以第9章的消息发布系统的部分代码为例，介绍贫血模式。

在贫血模式里，所有的Domain Object只是单纯的数据类，只包含每个属性的setter和getter方法，如下是两个持久化类。

第一个Domain Object是消息，其代码如下：

java 代码
  1. public class News extends BaseObject implements Serializable   
  2.   
  3. {   
  4.   
  5.     //主键   
  6.   
  7.     private Long id;   
  8.   
  9.     //消息标题   
  10.   
  11.     private String title;   
  12.   
  13.     //消息内容   
  14.   
  15.     private String content;   
  16.   
  17.     //消息的发布时间   
  18.   
  19.     private Date postDate;   
  20.   
  21.     //消息的最后修改时间   
  22.   
  23.     private Date lastModifyDate;   
  24.   
  25.     //消息所属分类   
  26.   
  27.     private Category category;   
  28.   
  29.     //消息对应的消息回复   
  30.   
  31.     private Set newsReviews;   
  32.   
  33.     //无参数的构造器   
  34.   
  35.     public News() {   
  36.   
  37.     }   
  38.   
  39.     //消息回复对应的getter方法   
  40.   
  41.     public Set getNewsReviews() {   
  42.   
  43.         return newsReviews;   
  44.   
  45.     }   
  46.   
  47.     //消息回复对应的setter方法   
  48.   
  49.     public void setNewsReviews(Set newsReviews) {   
  50.   
  51.         this.newsReviews = newsReviews;   
  52.   
  53.     }   
  54.   
  55.     //消息分类对应的getter方法