`
taody
  • 浏览: 100116 次
  • 性别: Icon_minigender_2
  • 来自: 北京
社区版块
存档分类
最新评论

<<项目架构那点儿事>>——hibernate泛型Dao,让持久层简洁起来

 
阅读更多

欢迎访问我的社区资源论坛http://www.javadt.com

【前言】hibernate作为持久层ORM技术，它对JDBC进行非常轻量级对象封装，使得我们可以随心所欲的使用面向对象的思想来操作数据库。同时，作为后台开发的支撑，的确扮演了一个举足轻重的角色，那么我们在项目中如何灵活应用hibernate，也会给项目维护以及项目开发带来便利，下面我将展示我们项目中是如何来对hibernate进行应用和操作。
【目录】 
            -----1.自定义异常
            -----2.泛型Dao搭建(SimpleHibernateDao)
            -----3.hibernate与spring整合

【内容】
              一、自定义异常（BussienssException),相信大家对java异常处理机制还是比较熟悉，我们在业务层定义异常，那么可以对Jdbc中出现的如SqlException,DataAccessException进行统一处理，这样做的好处是，便于我们向前台发送异常消息，记录异常信息日志，控制事务回滚，下面就讲BussienssException罗列出来，其实很简单：

/**
* @author fisher
* @description 自定义业务异常
*/

public class ServiceException extends RuntimeException {

        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        public ServiceException() {
   super();
        }

        public ServiceException(String message) {
                super(message);
        }

        public ServiceException(Throwable cause) {
    super(cause);
        }

        public ServiceException(String message, Throwable cause) {
   super(message, cause);
        }
}
复制代码
            二：hibernate泛型Dao（SimpleHibernateDao），封装了原生hibernateAPI操作，实现了对不同Pojo对象进行操作，解决了常用的Crud，代码注释写得很详细，我就不啰嗦了，具体看代码：
/**
* 封装Hibernate原生API的DAO泛型基类.
* 
* 可在Service层直接使用, 也可以扩展泛型DAO子类使用, 见两个构造函数的注释. 参考Spring2.5自带的Petlinc例子,
* 取消了HibernateTemplate, 直接使用Hibernate原生API.
* 
* @param <T>
*            DAO操作的对象类型
* @param <PK>
*            主键类型
* 
* @author
*/
@SuppressWarnings("unchecked")
public class SimpleHibernateDao<T, PK extends Serializable> {

    protected Logger logger = LoggerFactory.getLogger(getClass());

    protected SessionFactory sessionFactory;

     protected Class<T> entityClass;

        /**
         * 用于Dao层子类使用的构造函数. 通过子类的泛型定义取得对象类型Class. eg. public class UserDao extends
         * SimpleHibernateDao<User, Long>
         */
        public SimpleHibernateDao() {
      this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
        }

        /**
         * 用于用于省略Dao层, 在Service层直接使用通用SimpleHibernateDao的构造函数. 在构造函数中定义对象类型Class.
         * eg. SimpleHibernateDao<User, Long> userDao = new SimpleHibernateDao<User,
         * Long>(sessionFactory, User.class);
         */
        public SimpleHibernateDao(final SessionFactory sessionFactory,
     final Class<T> entityClass) {
      this.sessionFactory = sessionFactory;
       this.entityClass = entityClass;
        }

        /**
         * 取得sessionFactory.
         */
        public SessionFactory getSessionFactory() {
      return sessionFactory;
        }

        /**
         * 采用@Autowired按类型注入SessionFactory, 当有多个SesionFactory的时候在子类重载本函数.
         */
        @Autowired
        public void setSessionFactory(final SessionFactory sessionFactory) {
   this.sessionFactory = sessionFactory;
        }

        /**
         * 取得当前Session.
         */
        public Session getSession() {
   return sessionFactory.getCurrentSession();
        }

        /**
         * 保存新增或修改的对象.
         */
        public void save(final T entity) {;
   getSession().saveOrUpdate(entity);
   logger.debug("save entity: {}", entity);
        }

        /**
         * 删除对象.
         * 
         * @param entity
         *            对象必须是session中的对象或含id属性的transient对象.
         */
        public void delete(final T entity) {
     getSession().delete(entity);
      logger.debug("delete entity: {}", entity);
        }

        /**
         * 按id删除对象.
         */
        public void delete(final PK id) {
     delete(get(id));
     logger.debug("delete entity {},id is {}", entityClass.getSimpleName(),
                                id);
        }

        /**
         * 按id获取对象.
         */
        public T get(final PK id) {
    return (T) getSession().load(entityClass, id);
        }

        /**
         * 按id列表获取对象列表.
         */
        public List<T> get(final Collection<PK> ids) {
    return find(Restrictions.in(getIdName(), ids));
        }

        /**
         * 获取全部对象.
         */
        public List<T> getAll() {
   return find();
        }

        /**
         * 获取全部对象, 支持按属性行序.
         */
        public List<T> getAll(String orderByProperty, boolean isAsc) {
    Criteria c = createCriteria();
    if (isAsc) {
      c.addOrder(Order.asc(orderByProperty));
     } else {
    c.addOrder(Order.desc(orderByProperty));
                }
      return c.list();
        }

        /**
         * 按属性查找对象列表, 默认匹配方式为Like.
         */
        public List<T> findByProperty(final String propertyName, final Object value) {
      Assert.hasText(propertyName, "propertyName不能为空");
      Criterion criterion = Restrictions.like(propertyName, (String) value,
        MatchMode.ANYWHERE);
      return find(criterion);
        }

        /**
         * 按属性查找唯一对象, 默认匹配方式为Like.
         */
        public T findUniqueByProperty(final String propertyName, final Object value) {
         Assert.hasText(propertyName, "propertyName不能为空");
        Criterion criterion = Restrictions.like(propertyName, (String) value,
         MatchMode.ANYWHERE);
       return (T) createCriteria(criterion).uniqueResult();
        }

        /**
         * 按HQL查询对象列表.
         * 
         * @param <X>
         * 
         * @param values
         *            数量可变的参数,按顺序绑定.
         */
        public <X> List<X> find(final String hql, final Object... values) {
      return createQuery(hql, values).list();
        }

        /**
         * 按HQL查询对象列表.
         * 
         * @param values
         *            命名参数,按名称绑定.
         */
        public <X> List<X> find(final String hql, final Map<String, ?> values) {
      return createQuery(hql, values).list();
        }

        /**
         * 按HQL查询唯一对象.
         * 
         * @param values
         *            数量可变的参数,按顺序绑定.
         */
        public <X> X findUnique(final String hql, final Object... values) {
      return (X) createQuery(hql, values).uniqueResult();
        }

        /**
         * 按HQL查询唯一对象.
         * 
         * @param values
         *            命名参数,按名称绑定.
         */
        public <X> X findUnique(final String hql, final Map<String, ?> values) {
     return (X) createQuery(hql, values).uniqueResult();
        }

        /**
         * 执行HQL进行批量修改/删除操作.
         * 
         * @param values
         *            数量可变的参数,按顺序绑定.
         * @return 更新记录数.
         */
        public int batchExecute(final String hql, final Object... values) {
     return createQuery(hql, values).executeUpdate();
        }

        /**
         * 执行HQL进行批量修改/删除操作.
         * 
         * @param values
         *            命名参数,按名称绑定.
         * @return 更新记录数.
         */
        public int batchExecute(final String hql, final Map<String, ?> values) {
      return createQuery(hql, values).executeUpdate();
        }

        /**
         * 根据查询HQL与参数列表创建Query对象. 与find()函数可进行更加灵活的操作.
         * 
         * @param values
         *            数量可变的参数,按顺序绑定.
         */
        public Query createQuery(final String queryString, final Object... values) {
        Assert.hasText(queryString, "queryString不能为空");
      Query query = getSession().createQuery(queryString);
                if (values != null) {
         for (int i = 0; i < values.length; i++) {
         query.setParameter(i, values[i]);
                        }
                }
   return query;
        }

        /**
         * 根据查询HQL与参数列表创建Query对象. 与find()函数可进行更加灵活的操作.
         * 
         * @param values
         *            命名参数,按名称绑定.
         */
        public Query createQuery(final String queryString,
                        final Map<String, ?> values) {

                Query query = getSession().createQuery(queryString);
                if (values != null) {
                        query.setProperties(values);
                }
                return query;
        }

        /**
         * 按Criteria查询对象列表.
         * 
         * @param criterions
         *            数量可变的Criterion.
         */
        public List<T> find(final Criterion... criterions) {
                return createCriteria(criterions).list();
        }

        /**
         * 按Criteria查询唯一对象.
         * 
         * @param criterions
         *            数量可变的Criterion.
         */
        public T findUnique(final Criterion... criterions) {
                return (T) createCriteria(criterions).uniqueResult();
        }

        /**
         * 根据Criterion条件创建Criteria. 与find()函数可进行更加灵活的操作.
         * 
         * @param criterions
         *            数量可变的Criterion.
         */
        public Criteria createCriteria(final Criterion... criterions) {
                Criteria criteria = getSession().createCriteria(entityClass);
                for (Criterion c : criterions) {
                        criteria.add(c);
                }
                return criteria;
        }

        /**
         * 初始化对象. 使用load()方法得到的仅是对象Proxy, 在传到View层前需要进行初始化. 如果传入entity,
         * 则只初始化entity的直接属性,但不会初始化延迟加载的关联集合和属性. 如需初始化关联属性,需执行:
         * Hibernate.initialize(user.getRoles())，初始化User的直接属性和关联集合.
         * Hibernate.initialize
         * (user.getDescription())，初始化User的直接属性和延迟加载的Description属性.
         */
        public void initProxyObject(Object proxy) {
                Hibernate.initialize(proxy);
        }

        /**
         * Flush当前Session.
         */
        public void flush() {
                getSession().flush();
        }

        /**
         * 为Query添加distinct transformer. 预加载关联对象的HQL会引起主对象重复, 需要进行distinct处理.
         */
        public Query distinct(Query query) {
                query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
                return query;
        }

        /**
         * 为Criteria添加distinct transformer. 预加载关联对象的HQL会引起主对象重复, 需要进行distinct处理.
         */
        public Criteria distinct(Criteria criteria) {
                criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
                return criteria;
        }

        /**
         * 取得对象的主键名.
         */
        public String getIdName() {
                ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass);
                return meta.getIdentifierPropertyName();
        }

        /**
         * 判断对象的属性值在数据库内是否唯一.
         * 
         * 在修改对象的情景下,如果属性新修改的值(value)等于属性原来的值(orgValue)则不作比较.
         */
        public boolean isPropertyUnique(final String propertyName,
                        final Object newValue, final Object oldValue) {
                if (newValue == null || newValue.equals(oldValue)) {
                        return true;
                }
                Object object = findUniqueByProperty(propertyName, newValue);
                return (object == null);
        }
}
复制代码

        三、spring与hibernate整合，关于spring与hibernate的整合问题，我分两步来谈：
              1.配置spring的数据源Datasource,关系配置数据库连接，相信很多童鞋对它很熟悉，我们要获取数据库连接，首先是从连接池中去找，那么常用的连接池分3种（DBCP,C3P0，Proxool），这里以mysql与DBCP为例：

datasource.properties:
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost/test?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=
复制代码
  applicationContext.xml
<!-- 定义属性文件路径 -->
        <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
                <property name="locations">
                        <list>
                                <!-- 标准配置,路径都以项目classpath为准-->
                                <value>classpath:/datasource.properties</value>
                        </list>
                </property>
        </bean>

        <!-- 数据源配置, 使用应用中的DBCP数据库连接池 -->
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
                <!-- Connection Info -->
                <property name="driverClassName" value="${jdbc.driver}" />
                <property name="url" value="${jdbc.url}" />
                <property name="username" value="${jdbc.username}" />
                <property name="password" value="${jdbc.password}" />

                <!-- Connection Pooling Info -->
                <property name="maxActive" value="${dbcp.maxActive}" />
                <property name="maxIdle" value="${dbcp.maxIdle}" />
                <property name="defaultAutoCommit" value="false" />
                <property name="timeBetweenEvictionRunsMillis" value="3600000"/>
                <property name="minEvictableIdleTimeMillis" value="3600000"/>
        </bean>
复制代码

                
           2.配置Sessionfactory、transactionManager，这样我们就有了对事务的控制、以及可以获取到hibernate的会话。

    applicationContext.xml：
<!-- Hibernate配置 -->
        <bean id="sessionFactory"
                class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"">
                   <property name="dataSource" ref="dataSource" />
                <property name="mappingLocations">
                        <list>
                                <value>这里是Hbm文件</value>
                        </list>
                </property>
                <property name="hibernateProperties">
                        <props>
                                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                                <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
                                <prop key="hibernate.cache.provider_configuration_file_resource_path">ehcache/ehcache-hibernate-local.xml</prop>
                        </props>
                </property>

        </bean>
     <!--注入simplehibernateDao-->
        <bean id="simplehibernateDao" class="com.dao.SimpleHibernateDao">         
复制代码
              <property name="sessionFactory" ref="sessionFactory"></property>
        </bean>        

<!--####{事务管理器}#### -->
        <bean id="transactionManager"
                class="org.springframework.orm.hibernate3.HibernateTransactionManager">
                <property name="sessionFactory" ref="sessionFactory" />
        </bean>
                
        <!-- ####{事务传播特性 }#### -->
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
                <tx:attributes>
                        <tx:method name="save*" propagation="REQUIRED" rollback-for="Exception"/>
                        <tx:method name="update*" propagation="REQUIRED" rollback-for="Exception"/>
                        <tx:method name="delete*" propagation="REQUIRED" rollback-for="Exception"/>
                        <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
                        <tx:method name="*" read-only="false" />
                </tx:attributes>
        </tx:advice>
        <!-- ####{配置切入点和通知}#### -->
        <aop:config>
                <aop:pointcut id="allServiceMethod" expression="execution(* com.mis.service..*.*(..))" />
                <aop:advisor pointcut-ref="allServiceMethod" advice-ref="txAdvice" />
                <aop:aspect id="logBean" ref="systemLogAspectService">
                        <aop:before method="beforeCut" pointcut-ref="allServiceMethod"/>
                        <aop:after method="afterCut" pointcut-ref="allServiceMethod"/>                        
                </aop:aspect>
        </aop:config>
复制代码

【总结】   关于持久层的技术，hibernat它的优势非常明显，能让java程序员很直观去通过对象去操作数据库，但是在处理报表或者非常复杂的数据库查询的时候也显得有点棘手，上面的泛型dao只是针对常用操作进行封装，对于处理特殊情况我建议还是采用原生Sql方式去处理，这篇文章也就差不多了。相信用过hibernate的人都知道如何去编写hbm映射文件，添加依赖包，这里我就没有详细介绍，也没有实际例子来实现，还是那句话，我是从项目架构出发，给大家在搭建系统的时候提供思路和参考。        
分享到：
| <<项目架构那点儿事>>——快速构建Junit用 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    泛型dao 泛型dao 泛型dao

    Struts2、Hibernate、Spring整合的泛型DAO （本人评价: 代码开发效率提高30% 代码出错率减少70%） 对于大多数开发人员，系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

    Hibernate泛型DAO接口，大部分通用都已包括

    在Java的持久层框架中，Hibernate是一个非常流行的ORM（对象关系映射）工具，它允许开发者用面向对象的方式来操作数据库，极大地简化了数据库操作。在实际开发中，为了提高代码的可重用性和可维护性，通常会创建泛型...

    spring hibernate 泛型DAO

    Spring框架提供了一个强大的容器来管理对象的生命周期和依赖关系，而Hibernate则是一个优秀的持久层框架，用于简化数据库操作。本文将深入探讨“Spring Hibernate 泛型DAO”这一主题，以及如何通过泛型DAO实现更加...

    Hibernate泛型DAO及使用方法.doc

    在Java开发中，尤其是涉及到持久层操作时，Hibernate是一个非常流行的ORM（对象关系映射）框架，它简化了数据库与Java对象之间的交互。而泛型DAO（Data Access Object）则是基于Hibernate进一步抽象出来的一个设计...

    经典泛型dao层代码，非常好用简易

    本文将深入探讨一种在SSH（Struts+Spring+Hibernate）框架中广泛应用的经典泛型DAO层实现方式，旨在展示其简洁性、高效性和灵活性。 #### 泛型DAO层：概念与优势 泛型DAO层通过利用Java的泛型机制，提供了一种类型...

    基于泛型的通用Dao接口和hibernate的实现

    1. 耦合性低：泛型Dao接口可以与不同的持久层框架集成，例如 Hibernate、JPA 等。 2. 灵活性高：泛型Dao接口可以适应不同的业务需求，例如不同的数据库、不同的数据类型等。 3. 代码重用性高：泛型Dao接口可以在不同...

    一个简单的Hibernate泛型Dao的实现 ---- 20160624

    本文将深入探讨如何实现一个简单的Hibernate泛型DAO（数据访问对象），以提高代码的可重用性和可维护性。 首先，我们来看`AbstractHibernateGenericDao`类，这是一个抽象类，它通常会包含一些基本的CRUD（创建、...

    一个很好的通用泛型dao（含源码）

    DAO已经成为持久层的标准模式，DAO使结构清晰,面向接口编程为代码提供了规范。而泛型DAO是一个类型安全的，代码精简的设计模式（相对于传统DAO），尤其在DAO组件数量庞大的时候，代码量的减少更加明显。 泛型DAO的...

    Struts2+hibernate+spring整合泛型DAO

    总结来说，"Struts2+hibernate+spring整合泛型DAO"是一种常见的Java Web开发模式，它利用三大框架的优势，结合泛型设计，提高了代码复用，降低了维护成本，使得开发者能更专注于业务逻辑，而不是基础架构。

    Struts2 Spring3 Hibernate 注解功能 DAO 泛型 通用分页

    例如，创建一个通用的DAO接口，使用泛型参数表示不同类型的数据实体，如`GenericDao&lt;T&gt;`，然后为每个具体的实体类实现这个接口，如`UserDao extends GenericDao&lt;User&gt;`。这样，大部分CRUD操作就可以在基类中实现，...

    虚拟数据层 Struts2、Hibernate、Spring整合的泛型DAO Version 2010.9.27

    Struts2、Hibernate、Spring整合的泛型DAO （本人评价: 代码开发效率提高30% 代码出错率减少70%） 对于大多数开发人员，系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

    泛型DAO，注释详细

    接下来，我们可以使用Hibernate或MyBatis等持久层框架实现这个泛型DAO。以Hibernate为例，一个简单的实现可能如下： ```java public class HibernateGenericDAO&lt;T, ID extends Serializable&gt; implements GenericDAO...

    ssh通用泛型DAO

    总的来说，"ssh通用泛型DAO"是一种设计模式，旨在简化SSH框架下的数据访问层开发，提高代码复用性，减少重复工作，同时通过泛型提供类型安全的保障。理解和熟练运用这一模式，能够有效地提升Java Web应用的开发效率...

    SSH 泛型DAO分页

    这个压缩包文件的标题"SSH 泛型DAO分页"表明它提供了一个实现SSH框架整合的示例，特别关注了泛型DAO（Data Access Object）以及分页功能。下面将详细介绍SSH框架及其分页和泛型DAO的概念。 1. **Struts2**: Struts2...

    Java Web程序运用中泛型DAO的作用.pdf

    Java Web程序中泛型DAO（Data Access Object）模式的应用与作用主要体现在提高程序的运算性能、安全性以及系统架构的复用性、拓展性和可维护性上。泛型DAO模式是基于Java泛型技术的一种设计模式，它在数据访问层提供...

    SSH泛型代码实例

    - **数据访问**：在Spring Data JPA或MyBatis等持久层框架中，使用泛型定义Repository接口，可以实现对特定类型的实体进行操作，例如`List&lt;User&gt; findByUsername(String username)`。 2. **Struts框架中的泛型** ...

    hibernate basedao（泛型版本）

    在Java的持久层框架Hibernate中，BaseDAO（基础数据访问对象）是常用的设计模式，用于封装对数据库的基本操作。在给定的“hibernate basedao（泛型版本）”中，开发人员通过引入泛型进一步提高了代码的复用性和灵活...

    SSH泛型DAO+Proxool+DisPlayTag+Jquery easyui

    标题中的"SSH泛型DAO+Proxool+DisPlayTag+Jquery easyui"涉及到的是一个Web开发技术的组合，主要包括以下几个部分： 1. SSH（Struts2 + Spring + Hibernate）：这是一个流行的Java Web开发框架组合，用于构建企业级...

    Hibernate通用Dao设计。

    综上所述，Hibernate通用DAO设计的核心在于抽象出共性的数据库操作，并通过泛型和继承等面向对象设计原则，达到代码复用的目的。这样不仅可以降低开发难度，还能提升系统的可维护性，对于大型项目尤其重要。通过学习...

    dao.rar_dao

    在IT行业中，DAO（Data Access Object）模式是一种常见的软件设计模式，主要用于数据库访问层的抽象。...通过对泛型DAO的深入理解和应用，可以更好地组织和管理项目中的数据访问层，降低复杂性，提高开发效率。

Magicbox
Global site tag (gtag.js) - Google Analytics