一、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而不用修改业务层。
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而不用修改业务层。