[转载]hibernate的使用总结（结合spring）

原文地址：hibernate的使用总结（结合spring）作者：kindle

一、整体的hibernate流程。

    首先我们通过web.xml中可以找到spring的配置文件（往往我们可以把spring配置文件分为多个：Dao相关的，logic相关的各种logic的bean，表现层相关的各种action的bean），其中在dao相关的配置中，我们可以通过配置dataSource/某种连接池，sessionFactory（包含属性指定hibernate.cfg.xml），在hibernate.cfg.xml中我们可以指定各个实体类及其对象关系映射。

    也就是说：服务器启动后----加载web.xml----加载spring的bean（dataSource、sessionFactory）----加载hibernate.cfg.xml----加载各个实体类的关系对象映射。从而建立了实体与表之间的对象关系映射。

进而我们可以通过在我们的dao类中加入sessionFactory以及使用hibernate提供的模板操作数据库。

二、通过spring来管理hibernate

1、将指定位置的属性文件读取进来，以便后面的配置可以使用${hibernate.show_sql}的方式

<bean id="propertyConfigurer"
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:mepay.properties" />
</bean> 

2.1、在spring的配置文件中配置proxool连接池和sessionFactory（proxool连接池参考全面的介绍）

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <description>proxool连接池配置</description>

    //通过注释的方式写关系对象映射时需要加的配置
    <property name="configurationClass">
        <value>org.hibernate.cfg.AnnotationConfiguration</value>
    </property>
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.proxool.xml">hibernate/proxool.xml</prop>
            <prop key="hibernate.proxool.pool_alias">webtools_proxool</prop>
            <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9iDialect</prop>
            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
            <prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
            <prop key="hibernate.use_outer_join">${hibernate.use_outer_join}</prop>
            <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
            <prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
            <prop key="hibernate.format_sql">true</prop>
            <prop key="hibernate.max_fetch_depth">1</prop>
        </props>
    </property>

    //通过配置configLocation属性指定hibernate根配置位置
    <property name="configLocation">
        <value>classpath:hibernate/hibernate.cfg.xml</value>
    </property>

</bean>

2.2、或者在spring的配置文件中配置dataSource和sessionFactory

<bean id="dataSource" class="com.mchange.v2.c3po.ComboPooledDataSource">

    <property name="jdbcUrl/user/password"  />

     ......

</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    //通过注释的方式写关系对象映射时需要加的配置
    <property name="configurationClass">
        <value>org.hibernate.cfg.AnnotationConfiguration</value>
    </property>

    <property name="dataSource" ref="dataSource" />

    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9iDialect</prop>
            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
            <prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
            <prop key="hibernate.use_outer_join">${hibernate.use_outer_join}</prop>
            <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
            <prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
            <prop key="hibernate.format_sql">true</prop>
            <prop key="hibernate.max_fetch_depth">1</prop>
        </props>
    </property>

    //通过配置configLocation属性指定hibernate根配置位置
    <property name="configLocation">
        <value>classpath:hibernate/hibernate.cfg.xml</value>
    </property>

</bean>

三、通过hibernate.cfg.xml来指定各个实体类

<hibernate-configuration>
    <session-factory>
        <mapping class="com.watchdata.mepay.domain.AdminInfo" />
        <mapping class="com.watchdata.mepay.domain.UserInfo" />
        <mapping class="com.watchdata.mepay.domain.Group" />
        <mapping class="com.watchdata.mepay.domain.ActivateLog"/>
    </session-factory>
</hibernate-configuration>

四、使用注释的方式写对象关系映射

1、表映射

    @Entity
    @Table(name = "ADMIN_INFO", schema = "MEPAYTWO", uniqueConstraints = @UniqueConstraint 

        (columnNames = "NAME"))

    建立本实体@Entity与表@Table之间的映射。

    name = "ADMIN_INFO"：表示表名。

    schema = "MEPAYTWO"：数据库名。

    uniqueConstraints = @UniqueConstraint(columnNames = "NAME"))：约束定义--唯一性约束。

2、主键字段映射

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "admin_seq")
    @SequenceGenerator(name = "admin_seq", sequenceName = "ADMIN_SEQ", allocationSize = 1)
    @Column(name = "ADMIN_ID", unique = true, nullable = false, precision = 22, scale = 0)

    建立主键字段与表中主键之间的映射，并且指定主键生成策略

    (strategy = GenerationType.SEQUENCE, generator = "admin_seq")

    指定主键生成策略GenerationType.SEQUENCE，及生产者admin_seq（下面会定义）

    @SequenceGenerator(name = "admin_seq", sequenceName = "ADMIN_SEQ", allocationSize = 1)

    定义一个序列主键生产者名字为admin_seq，对应于MEPAYTWO数据库中的ADMIN_SEQ序列

   （我们需要在MEPAYTWO中建立一个这样的序列）

3、普通字段映射

    @Column(name = "NAME", unique = true, nullable = false, length = 20)

4、一对多映射

    @OneToMany(targetEntity = com.watchdata.mepay.domain.AdminGroup.class,

               fetch = FetchType.LAZY,mappedBy="admin")
    @Cascade(value={CascadeType.SAVE_UPDATE})
    @JoinColumn(name = "ADMIN_ID")

    public List<AdminGroup> getAdminGroupList(){
        return adminGroupList;
    }

    一个用户可以属于多个组（拥有多个组的权限）

    我们定义一个list变量使得我们在“一”的一方可以轻松的访问“多”

    targetEntity = com.watchdata.mepay.domain.AdminGroup.class：指定目标类（多一方）

    mappedBy="admin"：多的一方靠那个属性知道他属于这个“一”

    JoinColumn(name = "ADMIN_ID")：多的一方根据此外键连接到我们的“一”

5、一对多映射

    @ManyToOne(targetEntity=AdminInfo.class)
    @JoinColumn(name="ADMIN_ID")

五、利用HibernateDaoSupport以及接口+继承+范型的思想规划和实现Dao类

1、思想规划：

1.1、运用范型定义了一个基本接口（IEntityDao<T>）：其中声明了每个Dao都会用到的接口方法。

1.2、为每个Dao定义了一个具体的接口：其继承自基本接口，同时定义了本Dao特有的接口方法。

     继承的时候把范型具体化，如：extend IEntityDao<AdminInfo>。

1.3、运用范型定义了一个Dao基类（HibernateEntityDao<T>），继承自HibernateDaoSupport，

     实现基本接口中的方法，使得具体的Dao类只要继承自这个基类就具有了基本接口中声明的功能。

1.4、定义具体的Dao类，继承自Dao基类，实现具体的Dao接口。继承的时候要把范型具体化，如：

     extends HibernateEntityDao<ActivateLog>，这里面主要实现具体Dao接口中定义的方法，

     基本Dao接口方法已经通过继承自Dao基类实现了。

2、具体介绍：

2.1 IEntityDao

public interface IEntityDao<T> {
   //根据Domain ID 获得一个Domain 对象
   T get(Serializable id);
   //获得数据库中所有的Domain 对象.如果数据库内记录巨大的话，请慎用此方法 
   List<T> getAll();
   //保存传入的Domain 对象进入数据库
   void save(Object o);

   //保存或更新传入的Domain 对象进入数据库
   void saveOrUpdate(Object o);
   //从数据库中删除此Domain 对象对应的数据
   void remove(Object o);

   //根据Domain 对象的ID 从数据库中删除相应的记录
   void removeById(Serializable id);

   //获取Entity对象的主键名
   String getIdName(Class clazz);  
}

2.2、HibernateEntityDao

public class HibernateEntityDao<T> extends HibernateDaoSupport implements IEntityDao<T> {

   protected Class<T> entityClass;// DAO所管理的Entity类型.

   //在构造函数中将泛型T.class赋给entityClass.
   public HibernateEntityDao() {
      entityClass = GenericUtils.getSuperClassGenricType(getClass());
   }

   //根据ID获取对象.
   public T get(Serializable id) {
      return (T) getHibernateTemplate().get(getEntityClass(), id);

   }

   //获取全部对象
   public List<T> getAll() {
      return getHibernateTemplate().loadAll(getEntityClass());

   }

   //获取全部对象,带排序参数.
   public List<T> getAll(String orderBy, boolean isAsc) {
      return getAll(getEntityClass(), orderBy, isAsc);

      Assert.hasText(orderBy);
      if (isAsc) {
         return getHibernateTemplate().findByCriteria(
                DetachedCriteria.forClass(getEntityClass()).addOrder(
                Order.asc(orderBy)));
      } else {
         return getHibernateTemplate().findByCriteria(
                DetachedCriteria.forClass(getEntityClass()).addOrder(
                Order.desc(orderBy)));
      }
   }

   //保存对象
   public void save(Object o) {
      getHibernateTemplate().save(o);
   }

  //保存对象或更新
   public void saveOrUpdate(Object o){
      getHibernateTemplate().saveOrUpdate(o);
   }

   //保存对象，批量保存.
   public void saveOrUpdateAll(Collection c) {
      getHibernateTemplate().saveOrUpdateAll(c);
   }

   //删除对象
   public void remove(Object o) {
      getHibernateTemplate().delete(o);
   }

   //根据ID移除对象.
   public void removeById(Serializable id) {
      remove(get(getEntityClass(), id));
   }

   //批量删除.
   public void removeAll(Collection col) {
      getHibernateTemplate().deleteAll(col);
   }

   //创建Query对象.
   //对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
   //留意可以连续设置,如 dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
   //调用方式如下：
   // dao.createQuery(hql); 或 dao.createQuery(hql,arg0); 或
   // dao.createQuery(hql,arg0,arg1); 或 dao.createQuery(hql,new Object[arg0,arg1,arg2])
   public Query createQuery(String hql, Object... values) {
      Assert.hasText(hql);
      Query query = getSession().createQuery(hql);
      for (int i = 0; i < values.length; i++) {
         query.setParameter(i, values[i]);
      }
      return query;
   }

   //取得Entity的Criteria.参数是criterions：可变的Restrictions条件列表
   public Criteria createCriteria(Criterion... criterions) {
      DetachedCriteria criteria=DetachedCriteria.forClass(getEntityClass());
      for (Criterion c : criterions) {
         criteria.add(c);
      }
      return criteria;
   }

   //取得Entity的Criteria,带排序参数.
   public Criteria createCriteria(String orderBy, boolean isAsc, Criterion... criterions) {
      Assert.hasText(orderBy);

      DetachedCriteria criteria = createCriteria(entityClass, criterions);

      if (isAsc) {
         criteria.addOrder(Order.asc(orderBy));
      } else {
         criteria.addOrder(Order.desc(orderBy));
      }

      return criteria;
   }

   //根据属性名和属性值查询对象.
   public List<T> findBy(String propertyName, Object value) {
      Assert.hasText(propertyName);
      DetachedCriteria criteria = createCriteria(Restrictions.eq(propertyName, value));
      List<T> list=getHibernateTemplate().findByCriteria(criteria);
      return list;
   }

   //根据属性名和属性值查询对象,带排序参数.
   public List<T> findBy(String propertyName, Object value, String orderBy, boolean isAsc) {
      Assert.hasText(propertyName);
      Assert.hasText(orderBy);
      DetachedCriteria criteria =createCriteria(

                       orderBy, isAsc,Restrictions.eq(propertyName, value));
      List<T> list=this.getHibernateTemplate().findByCriteria(criteria);
      return list;

   }

   //根据属性名和属性值查询单个对象.
   public T findUniqueBy(String propertyName, Object value) {
      Assert.hasText(propertyName);
      DetachedCriteria criteria =createCriteria(Restrictions.eq(propertyName, value));
      List<T> list=this.getHibernateTemplate().findByCriteria(criteria);
      return list!=null&&list.size()>0?list.get(0):null;

   }

   //消除与 Hibernate Session 的关联
   public void evit(Object entity){
      getHibernateTemplate().evict(entity);
   }

   //取得entityClass.

   protected Class<T> getEntityClass() {
      return entityClass;
   }

   //用hql执行update和delete操作,用于小批量操作
   public void excuteHql(String hql,Object...values){
      getHibernateTemplate().bulkUpdate(hql, values);
   }
}

2.3、为每个具体的dao建立一个接口 extend IEntityDao<Entity>

     其中定义这个dao需要的IEntityDao中没有声明的特需功能

2.4、为每个具体的dao定义一个实现类，实现具体接口，extend HibernateEntityDao<Entity>

     实现具体接口中定义的，基类没有实现的功能。