请看封装后的调用代码：

代码

1.          

2.        

3.      /**   

4.       * 用于管理的  Oracle dao   

5.       * <p>Company:... </p>  

6.       * @author chenxu   

7.       * @version 1.0   

8.       */   

9.      public class UserOracleDAO {   

10.    

11.      /**   

12.       * 增加一个  User   

13.       * @param vo UserVO   

14.       */   

15.      public void addUser(UserVO vo, boolean needTrans) throws   

16.              AppException {   

17.              DoHibernateProc_save dproc = new DoHibernateProc_save(new Object[] {   

18.                      vo}, needTrans);   

19.              dproc.doProc();   

20.      }   

21.    

22.      /**   

23.       * 更新一个  User   

24.       * @param vo UserVO   

25.       */   

26.      public void updateUser(UserVO vo, boolean needTrans) throws   

27.              AppException {   

28.              DoHibernateProc_update dproc = new DoHibernateProc_update(new   

29.                      Object[] {   

30.                      vo}, needTrans);   

31.              dproc.doProc();   

32.      }   

33.    

34.      /**   

35.       * 删除一个  User   

36.       * @param vo UserVO   

37.       */   

38.      public void delUser(UserVO vo, boolean needTrans) throws   

39.              AppException {   

40.              DoHibernateProc_delete doproc = new DoHibernateProc_delete(new   

41.                      Object[] {   

42.                      vo}, needTrans);   

43.              doproc.doProc();   

44.      }   

45.    

46.      /**   

47.       * 获得所有  User   

48.       * @return List   

49.       */   

50.      public List getAllUser(boolean needTrans) throws AppException {   

51.              DoHibernateProc_getLists dproc =   

52.                      new DoHibernateProc_getLists(   

53.                              "from UserVO as t where (t.deleted is null or t.deleted!=true)", needTrans);   

54.              dproc.doProc();   

55.              return (List) dproc.getResult();   

56.      }   

57.    

58.      /**   

59.       * 根据  id  查询  User   

60.       * @param name Long   

61.       * @return UserVO   

62.       */   

63.      public UserVO getUserById(Long id, boolean needTrans) throws   

64.              AppException {   

65.              DoHibernateProc_getObject dproc = new DoHibernateProc_getObject(new   

66.                      Object[] {UserVO.class, id}, needTrans);   

67.              dproc.doProc();   

68.              UserVO eType = (UserVO) dproc.getResult();   

69.              return eType;   

70.      }  

在以上的  DAO  实现类的对于  hibernate  的调用代码中没有包含任何的  hibernate API  的直接调用，同时也无需处理  hibernate  相关的异常,有的只是对于我的5个封装类 的调用。分别是：
DoHibernateProc_save---------- 封装  hibernate  保存操作的类
DoHibernateProc_update------- 封装  hibernate  的更新操作的类
DoHibernateProc_delete-------- 封装  hibernate  的删除操作的类
DoHibernateProc_getLists------封装  hibernate  的  hql  查询操作的类
DoHibernateProc_getObject----封装  hibernate  的按  id  查询的操作方法的类;

同时其调用方法也简介明了，囊括了大部分的  hibernate  操作。

这样就实现了  DAO  开发人员和具体的  Hibernate  的操作的分离，可以由专门的对  hibernate  非常熟悉的人员来开发维护此部分  hibernate  操作的代码，业务模块  DAO  开发人员对此无需有任何了解. 避免了不同模块的开发人员在各自的  DAO  中分别修改  hibernate  代码造成的混乱.

两种封装思路的比较：

l_walker  的思路是对公用的方法（hibernate的API）进行封装，而我的思路是对常用的  crud  操作进行封装，是面向业务逻辑的封装。

l_walker  的封装的结果是在其  DAO  中还是需要进行  hibernate  的基本操作的调用比如：打开事务，打开  session，关闭  session，关闭事务，同时需要捕获  hierbnate  的异常  HibernateException.

而我的封装结果是，
1，只需要用统一的方式调用我的封装类；
2，dao  开发者无需了解任何关于  hibernate  的知识；
3，调用我的封装类一般只需2·3行简单的代码，也不用捕获专有的异常
（此异常在封装类中已被进行有效的正确的处理）。代码量精简！奇少！！
4，因为修改造成的  hibernate  操作错误或不当的几率大大降低，因为是统一的代码,将被统一的修改。