hibernate实体对象数据库生成（接）

易天 — Sat, 21 Apr 2007 18:32:00 GMT

3、Hibernate的DAO实现

DAO对象是模块化的数据库访问组件，DAO对象通常包括：对持久化类的基本CRUD操作（插入、查询、更新、删除）操作。Spring对Hibernate的DAO实现提供了良好的支持。主要有如下两种方式的DAO实现：

继承HibernateDaoSupport的实现DAO

基于Hibernate3.0实现DAO

不管采用哪一种实现，这种DAO对象都极好地融合到Spring的ApplicationContext中，遵循依赖注入模式，提高解耦。

继承HibernateDaoSupport实现DAO

Spring为Hibernate的DAO提供工具类：HibernateDaoSupport。该类主要提供如下两个方法，方便DAO的实现：

public final HibernateTemplate getHibernateTemplate()

public final void setSessionFactory(SessionFactory sessionFactory)

其中，setSessionFactory方法用来接收Spring的ApplicationContext的依赖注入，可接收配置在Spring的SessionFactory实例，getHibernateTemplate方法则用来根据刚才的SessionFactory产生Session，最后生成HibernateTemplate来完成数据库访问。

HibernateTemplate的常规用法

HibernateTemplate提供非常多的常用方法来完成基本的操作，比如通常的增加、删除、修改、查询等操作，Spring 2.0更增加对命名SQL查询的支持，也增加对分页的支持。大部分情况下，使用Hibernate的常规用法，就可完成大多数DAO对象的CRUD操作。下面是HibernateTemplate的常用方法简介：

void delete(Object entity)：删除指定持久化实例

deleteAll(Collection entities)：删除集合内全部持久化类实例

find(String queryString)：根据HQL查询字符串来返回实例集合

findByNamedQuery(String queryName)：根据命名查询返回实例集合

get(Class entityClass, Serializable id)：根据主键加载特定持久化类的实例

save(Object entity)：保存新的实例

saveOrUpdate(Object entity)：根据实例状态，选择保存或者更新

update(Object entity)：更新实例的状态，要求entity是持久状态

setMaxResults(int maxResults)：设置分页的大小

Hibernate的复杂用法HibernateCallback

HibernateTemplate还提供一种更加灵活的方式来操作数据库，通过这种方式可以完全使用Hibernate的操作方式。HibernateTemplate的灵活访问方式是通过如下两个方法完成：

Object execute(HibernateCallback action)

List execute(HibernateCallback action)

这两个方法都需要一个HibernateCallback的实例，HibernateCallback实例可在任何有效的Hibernate数据访问中使用。程序开发者通过HibernateCallback，可以完全使用Hibernate灵活的方式来访问数据库，解决Spring封装Hibernate后灵活性不足的缺陷。HibernateCallback是一个接口，该接口只有一个方法doInHibernate(org.hibernate.Session session)，该方法只有一个参数Session。

通常，程序中采用实现HibernateCallback的匿名内部类来获取HibernateCallback的实例，方法doInHibernate的方法体就是Spring执行的持久化操作

注意：方法doInHibernate方法内可以访问Session，该Session对象是绑定到该线程的Session实例。该方法内的持久层操作，与不使用Spring时的持久层操作完全相同。这保证对于复杂的持久层访问，依然可以使用Hibernate的访问方式。

下面，让我们看一下接 CRUD的一些方法的实现吧：

import java.io.Serializable;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import test.dao.Dao;

public class DaoImpl extends HibernateDaoSupport implements Dao{

  public List findAllBy(final Class clazz, final String name, final Object value) {
    // 实现根据属性名和属性值查询对象，返回唯一对象
    return getHibernateTemplate().executeFind(new HibernateCallback(){
      public Object doInHibernate(Session session) throws HibernateException,SQLException{
        Criteria criteria=session.createCriteria(clazz);
        criteria.add(Restrictions.eq(name, value));
        criteria.setCacheable(true);

        return criteria.list();

      }
    });
  }

  public List findAllBy(final Class clazz, final Map filter,final Map sorMap,final int pageNo,final int pageSize) {
    // 实现返回根据Map中过滤条件和分页参数查询
    return getHibernateTemplate().executeFind(new HibernateCallback(){
      public Object doInHibernate(Session session) throws HibernateException,SQLException{

        Criteria criteria=session.createCriteria(clazz);
        filterCriteria(criteria, filter);
        sortCriteria(criteria,sorMap);
        if (pageNo != -1) {
        criteria.setFirstResult(pageNo > 1
          ? (pageNo - 1) * pageSize
          : 0);
        criteria.setMaxResults(pageSize);
      }
      criteria.setCacheable(true);
      return criteria.list();

      }
    });
  }
  /**
   * 构造criteria的过滤条件的回调函数
   */
  protected void filterCriteria(Criteria criteria, Map filter) {
    if (MapUtils.isNotEmpty(filter)) {
      for (Iterator iterator = filter.keySet().iterator(); iterator.hasNext();) {
        String fieldName = (String) iterator.next();
        criteria.add(Restrictions.eq(fieldName, filter.get(fieldName)));
      }
    }
  }

  /**
   * 构造Criteria的排序条件.
   *
   * @param sortMap  排序条件.
   * @param criteria Criteria实例.
   */
  protected void sortCriteria(Criteria criteria, Map sortMap) {
    if (MapUtils.isNotEmpty(sortMap)) {
      for (Iterator iterator = sortMap.keySet().iterator(); iterator.hasNext();) {
        String fieldName = (String) iterator.next();
        String orderType = (String) sortMap.get(fieldName);
        criteria.addOrder(StringUtils.equalsIgnoreCase("asc", orderType)
          ? Order.asc(fieldName)
          : Order.desc(fieldName));
      }
    }
  }

  public Object findBy(final Class clazz, final String name, final Object value) {
    // 实现根据对象属性名和属性值，返回唯一对象

    return getHibernateTemplate().execute(new HibernateCallback(){

      public Object doInHibernate(Session session) throws HibernateException, SQLException {
        // TODO Auto-generated method stub
        Criteria criteria=session.createCriteria(clazz);
        criteria.add(Restrictions.eq(name,value));
        List list=criteria.list();

        return list==null ||list.isEmpty()?null:list.iterator().next();
      }

    });
  }

  public Object getObject(Class clazz, Serializable id) {
    // 实现返回与此类对应主键为id的所有值
    Object o=getHibernateTemplate().get(clazz, id);
    if(o==null){
    throw new ObjectRetrievalFailureException(clazz,id);
    }
    return o;
  }

  public List getObjects(Class clazz) {
    // 实现返回entity类型值
    return getHibernateTemplate().loadAll(clazz);
  }

  public void removeObject(Class clazz, Serializable id) {
    // 实现根据数据库中与此类对应表的主键（id）删除此对象
    getHibernateTemplate().delete(getObject(clazz,id));

  }

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

  public void removeObjects(Collection objects) {
    // TODO Auto-generated method stub
    getHibernateTemplate().deleteAll(objects);
  }

  public Serializable saveObject(Object o) {
    // 实现序列化保存对象
    return getHibernateTemplate().save(o);
  }

  public int total(Class clazz, Map filter) {
    return 0;
    // TODO Auto-generated method stub

  }

  public void updateObject(Object o) {
    // 实现更新对象
    getHibernateTemplate().update(o);
  }

}

然后，我们要配置.xml

xml version="1.0" encoding="UTF-8"?>
DOCTYPE
    beans
    PUBLIC
    "-//SPRING//DTD BEAN 2.0//EN"
    "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
    <bean
        id="Dao"
        class="test.dao.hibernate.DaoImpl">
        <property
            name="sessionFactory"
            ref="sessionFactory" />
    bean>
beans>

易天 2007-04-22 02:32 发表评论

hibernate实体对象数据库生成

易天 — Sat, 21 Apr 2007 18:27:00 GMT

首先，我们先要理解一下相关知识点：

1、对象的序列化：Serializable

对象序列化是对象永久化的一种机制，可以把序列化当成一种深度克隆的方法，确切的说应该是对象的序列化，一般程序在运行时，产生对象，这些对象随着程序的停止运行而消失，但如果我们想把某些对象（因为是对象，所以有各自不同的特性）保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象。这种情况下就要用到对象的序列化。一般对象序列化后会保存在存储设备（硬盘）上，以文件的形式出现。

2、CRUD

CRUD是增加、读取、更新和删除几个单词的首字母简写即Create,Read,Update,Delete四个单词的缩写，主要被用在描述软件系统中数据库或者持久层的基本操作功能。
(In computing, CRUD is an acronym for create, retrieve, update, and delete. It is used to refer to the basic functions of a database or persistence layer in a software system.)

在进行Hibernate开发过程中，我们通常会使用DAO模式，有一些通用的数据操作方法，如CRUD，我们通常会将这些方法集中在一个DAO，这样会简便很多。DAO数据访问接口如下：

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

public interface Dao {

  List getObjects(Class clazz);//返回数据库中与此类对应的表的所有值，即entity类型中的所有信息

  Object getObject(Class clazz, Serializable id);//返回与此类对应的表主键为id的所有值

  Serializable saveObject(Object o);//序列化保存对象。

  void updateObject(Object o);//更新此对象

  void removeObject(Class clazz, Serializable id);//根据数据库中与此类对应表的主键（id）删除此对象

  void removeObject(Object o);//删除此对象

  void removeObjects(Collection objects);

  /*
   * 根据属性名和属性值查询对象，返回唯一对象
   */
  Object findBy(Class clazz, String name, Object value);

  /*
   * 根据属性名和属性值查询对象，返回所以符合条件的对象
   */
  List findAllBy(Class clazz, String name, Object value);

  /**
   * 根据Map中过滤条件和分页参数查询.
   *
   * @param filter   过滤条件.
   * @param sortMap  排序条件.
   * @param pageNo   当前页码
   * @param pageSize 每页显示记录数.
   */

  List findAllBy(Class clazz, Map filter, Map sorMap, int pageNo, int pageSize);

  /**
   * 符合filter过滤条件的记录总数
   * @param clazz
   * @param filter
   * @return
   */
  int total(Class clazz, Map filter);
}

易天 2007-04-22 02:27 发表评论

语源科技BlogJava-dnalncjm

hibernate实体对象数据库生成（接）

hibernate实体对象数据库生成