MVC与三层架构的研讨

一、MVC架构
Struts是一个不错的MVC架构，我一直以来都用它，通过简单的配置即可将view,controler,和Model结合起来。View主要以JSP来实现，因为它是面向标签的，所以对于网页设计人员提供了很好的接口。FormBean是介于JSP和Action之间的中间数据载体，它肩负着数据从JSP到ACTION的传递过程。Action是流程的中转站，不同的业务在不同的Action中以不同的Model调用来实现。Model就是实现具体业务的操作过程，不过这种过程是一种在较高水平上的实现。
总之，MVC架构实现了三层结构中的两层，即表现层和业务层，另外还有一层被称之为持久化层。
二、三层架构
正如以上所说的，三层架构即“表现层”，“业务层”，“持久化层”。表现层实现的代表作品是Struts框架，业务层实现的代表作品是Spring，持久层实现的代表作品是Hibernate。不过在我的开发中Spring被省掉了，因为我认为业务过于简单，还不至于用Spring来实现。下面我将具体的来说说我的三层实现。
1、三种Bean
在我的实现中，总共有三种Bean,它们都是为保存对象状态而存在的。持久层中，这种Bean就是POJO对象。它是面向数据库的，或者说多少得照顾到数据库的实现，因为我习惯于用PowerDesigner来设计数据库，做出来的结构也是比较中规中矩的，而如果直接用Hibernate来实数据库的话，就不那么干净了。所以POJO对象的设计就不能完全面向对象。业务层中的Bean我把它称之为Entity,这是一个完全面向程序逻辑的Bean。它可能是好几个POJO的集合。对于业务逻辑来，这种被称之为Entity的Bean做到了“拿来就用”，很便于业务的进行。在显示层中的Bean就是FormBean了，主要用于传入数据所用。
POJO仅生存于持久化层，到了业务层就将数据交给Entity了。而Entity不仅生存于业务层,它还被传到了JSP中，用于显示。
2、Pojo与Dao
我认为这是数据与操作的关系，Dao只在呼操作，而Pojo仅用于保存数据。下面是我Dao接口的实个现。
public interface Dao {

  //********** operattion method *********
  void resetPO(Pojo pojo);//重新设置POJO实体
  String save();//保存或更新POJO实体
  Pojo load();//通过ID值获取确切的POJO
  List find(short by);//通过某一属性值来获取POJO
  void close();//显示调用，以关闭session,至此该DAO将不再可用。
}
所有的涉及具体操作的Dao类均实现它。三个方法把Hibernate的查询语句封装起来。在业务层中只关心save(),load(),或find()。下面是一个具体UserDao的实现。
public class UserDao implements Dao {

  public final short _ALL = 0;
  public final short _BY_NAME = 1;
  public final short _BY_ACCOUNT = 2;
  public final short _BY_PASSWORD = 3;
  public final short _BY_ACCOUNT_PASSWORD = 4;

  private UserPo userPo;
  private static Log log = LogFactory.getLog(DocumentDAO.class);
  private Session session;

  //************ initial method ***************　
  public UserDao() {
    userPo = new UserPo();
    session = HibernateUtil.currentSession();
  }

  public UserDao(UserPo user){
    this.userPo = user;
    session = HibernateUtil.currentSession();
  }

  //************ method begin ***************

   /**
    * resetPO()
    *重新加载POJO对象
    * @param pojo Pojo
    */
   public void resetPO(Pojo pojo) {
     this.userPo = (UserPo)pojo;
   }


   /**
    * save()
    * 保存UserPo对象于数据库，如果是一个已持久的对象，则进行update操作
    * @return String
    */
   public String save() {
    String oid = null;
    try{
      //Session session = HibernateUtil.currentSession() 已经被提至构造函数中初始化了
      Transaction tx = session.beginTransaction();
      if (userPo.getId() == null) {
        oid = (String)session.save(userPo);//如果这是一个新的pojo则进行insert操作。
        session.flush();
        tx.commit();
      }else{
        session.update(userPo,userPo.getId());//如果该pojo已被初始化过则进行update操作
        session.flush();
        tx.commit();
      }
    }catch(HibernateException ex){
      System.out.println("//********* error **********///n UserDao.save()出现异常！");
      log.error("UserDao.save()出现异常！",ex);
    }
    return oid;
  }

  /**
   * get()
   * 通过id值，从数据库中获得指定的UserPo对象
   * @return Pojo
   */
  public Pojo load() {
    UserPo tmp = new UserPo();
    try{
      //Session session = HibernateUtil.currentSession() 已经被提至构造函数中初始化了
      tmp = (UserPo) session.get(UserPo.class, userPo.getId()); //用确切存在的ID值获得对象
    }catch(HibernateException hbe){
      hbe.printStackTrace();
    }
    if (tmp != null) {
      userPo = tmp;
      return userPo;
    }
    else
      return null;
  }

  /**
   * find()
   * 从数据库中查找一个User对象
   * @return Pojo
   */
  public List find(short by) {
    //Session session = HibernateUtil.currentSession() 已经被提至构造函数中初始化了
    Query query = null;
    String where=null;
    switch(by){
      case 0 :
        where = "";
        break;
      case 1 :
        where = " where us.name='"+userPo.getName()+"'";
        break;
      case 2 :
        where = " where us.account='"+userPo.getAccount()+"'";
        break;
      case 3 :
        where = " where us.password='"+userPo.getPassword()+"'";
        break;
      case 4 :
        where = " where us.account='"+userPo.getAccount()+"' and us.password='"+userPo.getPassword()+"'";
    }
    query = session.createQuery("from UserPo us"+where);
    return query.list();
  }

  public void close(){
    HibernateUtil.closeSession();
  }

}
其中HibernateUtil是一个Hibernate方法类，它提供线程安全的Session。和关闭这个Session的方法（虽然关闭Session过于简单）。每个Dao是由DaoFactory来产生的。DaoFactory也有一个公共的接口。如下：
public interface DaoFactory {
  /**
   * DAO对象工厂，获取各个数据实体的DAO对象，返回一个统一的接口 Dao
   * @return Dao
   */
  Dao getDocumentDAO();
  Dao getDocHeadDAO();
  Dao getDocAccessoryDAO();
  Dao getUserDao(User u);

}
下面是一个基于Hibernate的Dao的实现。
public class HbDaoFactory implements DaoFactory {

  public HbDaoFactory() {
  }

  /**
   * getDocumentDao
   *
   * @return Dao
   */
  public Dao getDocumentDAO() {
    /**@todo Implement this com.cecs.dao.DaoFactory method*/
    return new com.cecs.dao.DocumentDAO();
  }

  /**
   * getDocHeadDao
   *
   * @return Dao
   */
  public Dao getDocHeadDAO() {
    /**@todo Implement this com.cecs.dao.DaoFactory method*/
    throw new java.lang.UnsupportedOperationException("Method getDocHeadDAO() not yet implemented.");
  }

  /**
   * getDocAccessoryDao
   *
   * @return Dao
   */
  public Dao getDocAccessoryDAO() {
    /**@todo Implement this com.cecs.dao.DaoFactory method*/
    throw new java.lang.UnsupportedOperationException("Method getDocAccessoryDAO() not yet implemented.");
  }

  /**
   * getUserDao
   *获取UserDao对象
   * @return Dao
   */
  public Dao getUserDao(User u) {
    return new UserDao(u);
  }

}
这样一但不用Hibernate来实现持久层，也可以很方便改为其它的Dao而不用修改业务层。