`
xianglg
  • 浏览: 67123 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

struts2+hibernate+spring配置管理(三)——DAO层(二)

阅读更多

接上篇所说,如果懂得这个思想,其实很简单了,况且有spring的HibernateDaoSupport坐阵,你的代码会更精简,会更优化。话不多说,贴上代码先看一下吧:

java 代码
  1. /**  
  2.  * 负责为单个Entity对象提供CRUD操作的Hibernate DAO基类. 

     子类只要在类定义时指定所管理Entity的Class,

     
  3.  * 即拥有对单个Entity对象的CRUD操作.  
  4.  *   
  5.  *   
  6.  */  
  7. @SuppressWarnings("unchecked")   
  8. abstract public class HibernateBaseDao<t></t> extends HibernateDaoSupport {   
  9.   
  10.     protected Class<t></t> entityClass;// DAO所管理的Entity类型.   
  11.   
  12.     /**  
  13.      * 在构造函数中将泛型T.class赋给entityClass.  
  14.      */  
  15.     public HibernateBaseDao() {   
  16.         entityClass = GenericsUtils.getSuperClassGenricType(getClass());   
  17.     }   
  18.   
  19.     /**  
  20.      * 取得entityClass.JDK1.4不支持泛型的子类可以抛开Class<t></t> entityClass,重载此函数达到相同效果。  
  21.      */  
  22.     protected Class<t></t> getEntityClass() {   
  23.         return entityClass;   
  24.     }   
  25.   
  26.     /**  
  27.      * 根据ID获取对象.  
  28.      *   
  29.      * @see HibernateGenericDao#getId(Class,Object)  
  30.      */  
  31.     public T load(Serializable id) {   
  32.         return (T) getHibernateTemplate().load(getEntityClass(), id);   
  33.     }   
  34.   
  35.     /**  
  36.      * 根据ID获取对象,使用hinbernate get().  
  37.      *   
  38.      * @see HibernateGenericDao#getId(Class,Object)  
  39.      */  
  40.     public T get(Serializable id) {   
  41.         return (T) getHibernateTemplate().get(getEntityClass(), id);   
  42.     }   
  43.   
  44.     /**  
  45.      * 获取全部对象  
  46.      *   
  47.      * @see HibernateGenericDao#getAll(Class)  
  48.      */  
  49.     public List<t></t> getAll() {   
  50.         return getHibernateTemplate().loadAll(getEntityClass());   
  51.     }   
  52.   
  53.     /**  
  54.      * 获取全部对象,带排序参数.  
  55.      *   
  56.      */  
  57.     public List<t></t> getAll(String orderBy, boolean isAsc) {   
  58.         Assert.hasText(orderBy);   
  59.         if (isAsc)   
  60.             return getHibernateTemplate().findByCriteria(   
  61.                     DetachedCriteria.forClass(getEntityClass()).addOrder(   
  62.                             Order.asc(orderBy)));   
  63.         else  
  64.             return getHibernateTemplate().findByCriteria(   
  65.                     DetachedCriteria.forClass(getEntityClass()).addOrder(   
  66.                             Order.desc(orderBy)));   
  67.     }   
  68.   
  69.     /**  
  70.      * 保存对象.  
  71.      */  
  72.     public Serializable save(Object o) {   
  73.         return getHibernateTemplate().save(o);   
  74.     }   
  75.   
  76.     /**  
  77.      * 更新对象  
  78.      *   
  79.      * @param o  
  80.      */  
  81.     public void update(Object o) {   
  82.         getHibernateTemplate().update(o);   
  83.     }   
  84.   
  85.     /**  
  86.      * 保存或更新对象  
  87.      *   
  88.      * @param o  
  89.      */  
  90.     public void saveOrUpdate(Object o) {   
  91.         getHibernateTemplate().saveOrUpdate(o);   
  92.     }   
  93.   
  94.     /**  
  95.      * 删除对象.  
  96.      */  
  97.     public void remove(Object o) {   
  98.         getHibernateTemplate().delete(o);   
  99.     }   
  100.   
  101.     /**  
  102.      * 根据ID移除对象.  
  103.      *   
  104.      * @see HibernateGenericDao#removeById(Class,Serializable)  
  105.      */  
  106.     public void removeById(Serializable id) {   
  107.         remove(load(id));   
  108.     }   
  109.   
  110.     public void flush() {   
  111.         getHibernateTemplate().flush();   
  112.     }   
  113.   
  114.     public void clear() {   
  115.         getHibernateTemplate().clear();   
  116.     }   
  117.   
  118.     /**  
  119.      * 创建Query对象.  
  120.      * 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.  
  121.      * 留意可以连续设置,如下:  
  122.      *   
  123.      * @param values  
  124.      *            可变参数.  
  125.      */  
  126.     public Query createQuery(String hql, Object... values) {   
  127.         Assert.hasText(hql);   
  128.         Query query = getSession().createQuery(hql);   
  129.         for (int i = 0; i < values.length; i++) {   
  130.             query.setParameter(i, values[i]);   
  131.         }   
  132.         return query;   
  133.     }   
  134.   
  135.     /**  
  136.      * 取得Entity的Criteria.  
  137.      *   
  138.      */  
  139.     public Criteria createCriteria() {   
  140.         return getSession().createCriteria(getEntityClass());   
  141.     }   
  142.   
  143.     /**  
  144.      * 取得Entity的Criteria.  
  145.      *   
  146.      */  
  147.     public Criteria createCriteria(Criterion... criterions) {   
  148.         Criteria criteria = createCriteria();   
  149.         for (Criterion c : criterions) {   
  150.             criteria.add(c);   
  151.         }   
  152.         return criteria;   
  153.     }   
  154.   
  155.     /**  
  156.      * 取得Entity的Criteria,带排序参数.  
  157.      *   
  158.      */  
  159.     public Criteria createCriteria(String orderBy, boolean isAsc,   
  160.             Criterion... criterions) {   
  161.         Assert.hasText(orderBy);   
  162.   
  163.         Criteria criteria = createCriteria(criterions);   
  164.   
  165.         if (isAsc)   
  166.             criteria.addOrder(Order.asc(orderBy));   
  167.         else  
  168.             criteria.addOrder(Order.desc(orderBy));   
  169.   
  170.         return criteria;   
  171.     }   
  172.   
  173.     /**  
  174.      * 根据hql查询,直接使用HibernateTemplate的find函数.  
  175.      *   
  176.      * @param values  
  177.      *            可变参数,见{@link #createQuery(String,Object...)}  
  178.      */  
  179.     public List find(String hql, Object... values) {   
  180.         Assert.hasText(hql);   
  181.         return getHibernateTemplate().find(hql, values);   
  182.     }   
  183.   
  184.     /**  
  185.      * 根据属性名和属性值查询对象.  
  186.      *   
  187.      * @return 符合条件的对象列表  
  188.      */  
  189.     public List<t></t> findBy(String propertyName, Object value) {   
  190.         Assert.hasText(propertyName);   
  191.         return createCriteria(Restrictions.eq(propertyName, value)).list();   
  192.     }   
  193.   
  194.     /**  
  195.      * 根据属性名和属性值查询对象,带排序参数.  
  196.      */  
  197.     public List<t></t> findBy(Class<t></t> entityClass, String propertyName,   
  198.             Object value, String orderBy, boolean isAsc) {   
  199.         Assert.hasText(propertyName);   
  200.         Assert.hasText(orderBy);   
  201.         return createCriteria(orderBy, isAsc,   
  202.                 Restrictions.eq(propertyName, value)).list();   
  203.     }   
  204.   
  205.     /**  
  206.      * 根据属性名和属性值查询对象,带排序参数.  
  207.      *   
  208.      * @return 符合条件的对象列表  
  209.      */  
  210.     public List<t></t> findBy(String propertyName, Object value, String orderBy,   
  211.             boolean isAsc) {   
  212.         return findBy(getEntityClass(), propertyName, value, orderBy, isAsc);   
  213.     }   
  214.   
  215.     /**  
  216.      * 根据属性名和属性值查询单个对象.  
  217.      *   
  218.      * @return 符合条件的唯一对象 or null  
  219.      */  
  220.     public T findUniqueBy(String propertyName, Object value) {   
  221.         Assert.hasText(propertyName);   
  222.         return (T) createCriteria(Restrictions.eq(propertyName, value))   
  223.                 .uniqueResult();   
  224.     }   
  225.   
  226.     /**  
  227.      * 分页查询函数,使用hql.  
  228.      *   
  229.      * @param pageNo  
  230.      *            页号,从1开始.  
  231.      */  
  232.     public Page<t></t> pagedQuery(String hql, int pageNo, int pageSize,   
  233.             Object... values) {   
  234.         Assert.hasText(hql);   
  235.         Assert.isTrue(pageNo >= 1"pageNo should start from 1");   
  236.         // Count查询   
  237.         String countQueryString = " select count (*) "  
  238.                 + removeSelect(removeOrders(hql));   
  239.         List countlist = getHibernateTemplate().find(countQueryString, values);   
  240.         long totalCount = (Long) countlist.get(0);   
  241.   
  242.         if (totalCount < 1)   
  243.             return new Page();   
  244.         // 实际查询返回分页对象   
  245.         int startIndex = Page.getStartOfPage(pageNo, pageSize);   
  246.         Query query = createQuery(hql, values);   
  247.         List<t></t> list = query.setFirstResult(startIndex).setMaxResults(pageSize)   
  248.                 .list();   
  249.   
  250.         return new Page<t></t>(startIndex, totalCount, pageSize, list);   
  251.     }   
  252.   
  253.     /**  
  254.      * 分页查询函数,使用已设好查询条件与排序的Criteria.  
  255.      *   
  256.      * @param pageNo  
  257.      *            页号,从1开始.  
  258.      * @return 含总记录数和当前页数据的Page对象.  
  259.      */  
  260.     public Page<t></t> pagedQuery(Criteria criteria, int pageNo, int pageSize) {   
  261.         Assert.notNull(criteria);   
  262.         Assert.isTrue(pageNo >= 1"pageNo should start from 1");   
  263.         CriteriaImpl impl = (CriteriaImpl) criteria;   
  264.   
  265.         // 先把Projection和OrderBy条件取出来,清空两者来执行Count操作   
  266.         Projection projection = impl.getProjection();   
  267.         List<criteriaimpl.orderentry></criteriaimpl.orderentry> orderEntries;   
  268.         try {   
  269.             orderEntries = (List) BeanUtils.forceGetProperty(impl,   
  270.                     "orderEntries");   
  271.             BeanUtils.forceSetProperty(impl, "orderEntries"new ArrayList());   
  272.         } catch (Exception e) {   
  273.             throw new InternalError(" Runtime Exception impossibility throw ");   
  274.         }   
  275.   
  276.         // 执行查询   
  277.         int totalCount = (Integer) criteria.setProjection(   
  278.                 Projections.rowCount()).uniqueResult();   
  279.   
  280.         // 将之前的Projection和OrderBy条件重新设回去   
  281.         criteria.setProjection(projection);   
  282.         if (projection == null) {   
  283.             criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);   
  284.         }   
  285.   
  286.         try {   
  287.             BeanUtils.forceSetProperty(impl, "orderEntries", orderEntries);   
  288.         } catch (Exception e) {   
  289.             throw new InternalError(" Runtime Exception impossibility throw ");   
  290.         }   
  291.   
  292.         // 返回分页对象   
  293.         if (totalCount < 1)   
  294.             return new Page();   
  295.   
  296.         int startIndex = Page.getStartOfPage(pageNo, pageSize);   
  297.         List<t></t> list = criteria.setFirstResult(startIndex).setMaxResults(   
  298.                 pageSize).list();   
  299.         return new Page<t></t>(startIndex, totalCount, pageSize, list);   
  300.     }   
  301.   
  302.     /**  
  303.      * 分页查询函数,根据entityClass和查询条件参数创建默认的Criteria.  
  304.      *   
  305.      * @param pageNo  
  306.      *            页号,从1开始.  
  307.      * @return 含总记录数和当前页数据的Page对象.  
  308.      */  
  309.     public Page<t></t> pagedQuery(int pageNo, int pageSize, Criterion... criterions) {   
  310.         Criteria criteria = createCriteria(criterions);   
  311.         return pagedQuery(criteria, pageNo, pageSize);   
  312.     }   
  313.   
  314.     /**  
  315.      * 分页查询函数,根据entityClass和查询条件参数,排序参数创建默认的Criteria.  
  316.      *   
  317.      * @param pageNo  
  318.      *            页号,从1开始.  
  319.      * @return 含总记录数和当前页数据的Page对象.  
  320.      */  
  321.     public Page<t></t> pagedQuery(int pageNo, int pageSize, String orderBy,   
  322.             boolean isAsc, Criterion... criterions) {   
  323.         Criteria criteria = createCriteria(orderBy, isAsc, criterions);   
  324.         return pagedQuery(criteria, pageNo, pageSize);   
  325.     }   
  326.   
  327.     /**  
  328.      * 判断对象某些属性的值在数据库中是否唯一.  
  329.      *   
  330.      * @param uniquePropertyNames  
  331.      *            在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password"  
  332.      */  
  333.     public boolean isUnique(Object entity, String uniquePropertyNames) {   
  334.         Assert.hasText(uniquePropertyNames);   
  335.         Criteria criteria = createCriteria().setProjection(   
  336.                 Projections.rowCount());   
  337.         String[] nameList = uniquePropertyNames.split(",");   
  338.         try {   
  339.             // 循环加入唯一列   
  340.             for (String name : nameList) {   
  341.                 criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(   
  342.                         entity, name)));   
  343.             }   
  344.   
  345.             // 以下代码为了如果是update的情况,排除entity自身.   
  346.   
  347.             String idName = getIdName(getEntityClass());   
  348.   
  349.             // 取得entity的主键值   
  350.             Serializable id = getId(entity);   
  351.   
  352.             // 如果id!=null,说明对象已存在,该操作为update,加入排除自身的判断   
  353.             if (id != null)   
  354.                 criteria.add(Restrictions.not(Restrictions.eq(idName, id)));   
  355.         } catch (Exception e) {   
  356.             ReflectionUtils.handleReflectionException(e);   
  357.         }   
  358.         return (Integer) criteria.uniqueResult() == 0;   
  359.     }   
  360.   
  361.     /**  
  362.      * 取得对象的主键值,辅助函数.  
  363.      */  
  364.     public Serializable getId(Object entity) throws NoSuchMethodException,   
  365.             IllegalAccessException, InvocationTargetException {   
  366.         Assert.notNull(entity);   
  367.         Assert.notNull(getEntityClass());   
  368.         return (Serializable) PropertyUtils.getProperty(entity,   
  369.                 getIdName(getEntityClass()));   
  370.     }   
  371.   
  372.     /**  
  373.      * 取得对象的主键名,辅助函数.  
  374.      */  
  375.     public String getIdName(Class clazz) {   
  376.         Assert.notNull(clazz);   
  377.         ClassMetadata meta = getSessionFactory().getClassMetadata(clazz);   
  378.         Assert.notNull(meta, "Class " + clazz   
  379.                 + " not define in hibernate session factory.");   
  380.         String idName = meta.getIdentifierPropertyName();   
  381.         Assert.hasText(idName, clazz.getSimpleName()   
  382.                 + " has no identifier property define.");   
  383.         return idName;   
  384.     }   
  385.   
  386.     /**  
  387.      * 去除hql的select 子句,未考虑union的情况,用于pagedQuery.  
  388.      *   
  389.      * @see #pagedQuery(String,int,int,Object[])  
  390.      */  
  391.     private static String removeSelect(String hql) {   
  392.         Assert.hasText(hql);   
  393.         int beginPos = hql.toLowerCase().indexOf("from");   
  394.         Assert.isTrue(beginPos != -1" hql : " + hql   
  395.                 + " must has a keyword 'from'");   
  396.         return hql.substring(beginPos);   
  397.     }   
  398.   
  399.     /**  
  400.      * 去除hql的orderby 子句,用于pagedQuery.  
  401.      *   
  402.      * @see #pagedQuery(String,int,int,Object[])  
  403.      */  
  404.     private static String removeOrders(String hql) {   
  405.         Assert.hasText(hql);   
  406.         Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*",   
  407.                 Pattern.CASE_INSENSITIVE);   
  408.         Matcher m = p.matcher(hql);   
  409.         StringBuffer sb = new StringBuffer();   
  410.         while (m.find()) {   
  411.             m.appendReplacement(sb, "");   
  412.         }   
  413.         m.appendTail(sb);   
  414.         return sb.toString();   
  415.     }   
  416.   
  417.     /**  
  418.      * 根据页码和每页的长度返回对象集合  
  419.      *   
  420.      * @param pageNo  
  421.      *            页码  
  422.      * @param pageSize  
  423.      *            每页的长度  
  424.      * @return  
  425.      */  
  426.     public List<t></t> getObjects(int pageNo, int pageSize) {   
  427.         Criteria criteria = this.createCriteria();   
  428.         return this.pagedQuery(criteria, pageNo, pageSize).getResult();   
  429.     }   
  430. }   

有了这个DAO后,你再让其它的实体DAO继承这个BASEDAO,比如:

java 代码
  1. public class ProductDAO extends HibernateBaseDao <product></product> {   
  2.     //public void otherMethod(){...}   
  3. }  

就大功告成,所谓的OO,就让泛型帮你完成,烦人的对象转换就此终结。

有兴趣的朋友可以参考springside的源码,它更详细。

分享到:
评论
2 楼 maomao113 2008-09-11  
看过几遍 原来是你的···呵呵 ···我以前收藏了的
1 楼 maomao113 2008-09-11  
好熟悉的代码·· 怎么会那么像啊····恩··郁闷 请问贵姓···

相关推荐

    基于Struts2+hibernate+spring 注解开发的学生信息管理系统

    总结来说,这个"基于Struts2+hibernate+spring 注解开发的学生信息管理系统"是一个利用Java Web三大框架的典型应用,实现了学生信息的基本操作。通过优化前端设计,可以进一步提升系统的整体质量和用户体验。在实际...

    基于Struts2+Spring+Hibernate+MySql的注册登录系统.zip

    在SSH系统中,Spring主要负责管理整个应用的组件,包括Struts2的Action、Hibernate的数据访问对象(DAO)等。通过Spring的IoC容器,我们可以实现松耦合和更好的测试性。同时,Spring还提供了与Hibernate的集成,简化...

    struts2 + hibernate3 + spring3 ssh 用户的增删改查

    Struts2、Hibernate3和Spring3是Java Web开发中的三个核心框架,它们组合在一起被称为SSH(Struts2、Spring、Hibernate)集成框架。这个框架体系为开发者提供了强大的模型-视图-控制器(MVC)架构支持,数据持久化...

    struts2+hibernate+spring整合的管理系统

    Struts2、Hibernate和Spring是Java开发中三大主流框架,它们的整合应用在企业级Web应用开发中极为常见。这个管理系统就是基于这三个框架的集成,提供了高效、灵活且可维护的解决方案。 Struts2作为MVC(Model-View-...

    Struts2+Hibernate3+Spring2.5整合详细步骤+实例可运行代码

    1. word文档记录了Struts2+Hibernate3+Spring2.5整合详细步骤,附有操作步骤的图示参考,并给出了各个步骤的注意事项; 2. 源代码实例包括一个完整模块的增删改查操作,可直接运行,可以在此基础上直接进行自己系统...

    struts2+hibernate3.3+spring3.0整合实例

    Struts2、Hibernate3.3和Spring3.0是Java Web开发中著名的三大框架,它们分别负责MVC模式中的Action层、持久化层和依赖注入与业务逻辑管理。本实例将详细阐述如何将这三个框架整合在一起,实现一个完整的CRUD(创建...

    struts2 + spring 3 + hibernate3.3整合实现图书馆管理管理

    Struts2、Spring和Hibernate是Java Web开发中的三大框架,它们的整合应用广泛用于构建复杂的Web应用程序,如本例中的图书馆管理系统。这个系统实现了用户登录和注册功能,并且提供了对书籍表的操作,包括增、删、改...

    struts2+hibernate+spring+dwr整合

    2. Spring 作为整体的容器,管理所有组件的生命周期,包括Struts2的Action、Hibernate的数据访问对象(DAO)以及DWR的远程接口。Spring的DI特性使得各组件之间的依赖关系得以解耦。 3. Hibernate 作为持久层框架,...

    Struts2+Hibernate+Spring基于单表的增删改查code

    Struts2、Hibernate和Spring是Java Web开发中的三大框架,它们的组合,通常被称为SSH(Struts2+Spring+Hibernate)或SSH2。这个“Struts2+Hibernate+Spring基于单表的增删改查code”项目是一个典型的Java Web应用...

    10.6struts2+hibernate+spring的整合源代码

    Struts2、Hibernate和Spring是Java企业级应用中常用的三个开源框架,它们分别负责MVC模式中的表现层、持久层和业务层管理。SSH(Struts2+Spring+Hibernate)框架整合是Java Web开发中常见的一种技术栈,能有效地提高...

    Struts2+Hibernate4+Spring4+MySql5

    在整合这些技术时,通常会使用Spring4作为核心容器,管理所有组件的生命周期,包括Struts2的Action和Hibernate4的数据访问对象(DAO)。Struts2处理HTTP请求,调用Spring管理的业务服务,而这些服务又依赖于...

    Struts2+Hibernate+Spring整合开发深入剖析与范例应用03

    Struts2、Hibernate和Spring是Java企业级应用中三大核心框架,它们的整合使用能够构建出高效、可维护性高的Web应用程序。本篇将深入剖析这三者如何协同工作,并提供实际范例应用。 首先,Struts2作为MVC(模型-视图...

    struts1.2 + spring2.5 + hibernate3.2框架demo

    2. **配置文件**:struts-config.xml定义Struts的配置,spring-beans.xml管理Spring的bean,hibernate.cfg.xml配置Hibernate的数据库连接,可能还有实体类的映射文件(hbm.xml或使用注解)。 3. **JSP页面**:展示...

    最新项目系统:Struts2+Spring4+Hibernate4三大框架整合

    Struts2、Spring4和Hibernate4是Java Web开发中的三大主流框架,它们分别负责MVC模式中的表现层、业务层和服务层。这个最新的项目系统整合了这三个框架,旨在提供一个高效、灵活且易于维护的开发环境。下面将详细...

    Struts2+Spring+hibernate中对action的单元测试环境搭建[总结].pdf

    Struts2+Spring+Hibernate 中的Action单元测试环境搭建 在软件开发中,单元测试是一种非常重要的测试方法,可以帮助我们确保代码的可靠性和稳定性。在 Struts2+Spring+Hibernate 框架中,对 Action 的单元测试环境...

    Struts2.1.6+Hibernate3.3.1+Spring2.5.6整合jar包

    3. 配置Struts2:在struts.xml文件中配置Struts2的动作映射,指定Action类,同时配置Spring插件,使得Action类由Spring管理。 4. 配置Hibernate:设置hibernate.cfg.xml文件,定义数据库连接、实体类等信息。 5. ...

    Struts2+Hibernate+Spring框架搭建(三)

    Struts2、Hibernate和Spring是Java Web开发中的三个核心框架,它们共同构成了经典的SSH(Struts2、Spring、Hibernate)架构。这篇博客“Struts2+Hibernate+Spring框架搭建(三)”着重介绍如何整合这三个框架,构建...

    struts2+hibernate+spring经典整合实例教程

    - 配置 Struts2 使用 Spring 管理对象:`&lt;constant name="struts.objectFactory" value="spring"/&gt;` - 导入默认配置文件:`&lt;include file="struts-default.xml"/&gt;` - 定义 Action 类:`...

Global site tag (gtag.js) - Google Analytics