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

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

3�?span lang="EN-US">Hibernate�?span lang="EN-US">DAO实现

DAO对象是模块化的数据库讉K��l��g�Q?span lang="EN-US">DAO对象通常包括�Q�对持久化类的基�?span lang="EN-US">CRUD操作�Q�插入、查询、更新、删除）操作�?span lang="EN-US">Spring�?span lang="EN-US">Hibernate�?span lang="EN-US">DAO实现提供了良好的支持。主要有如下两种方式�?span lang="EN-US">DAO实现�Q?span lang="EN-US">

�l�承HibernateDaoSupport的实�?span lang="EN-US">DAO

��Z��Hibernate3.0实现DAO

不管采用哪一�U�实玎ͼ��q�种DAO对象都极好地融合�?span lang="EN-US">Spring�?span lang="EN-US">ApplicationContext中，遵��@依赖注入模式�Q�提高解耦�?span lang="EN-US">

�l�承HibernateDaoSupport实现DAO

Spring�?span lang="EN-US">Hibernate�?span lang="EN-US">DAO提供工具�c�：HibernateDaoSupport。该�c�M��要提供如下两个方法，方便DAO的实玎ͼ�

public final HibernateTemplate getHibernateTemplate()

public final void setSessionFactory(SessionFactory sessionFactory)

其中�Q?span lang="EN-US">setSessionFactory�Ҏ��用来接收Spring�?span lang="EN-US">ApplicationContext的依赖注入，可接攉��|�在Spring�?span lang="EN-US">SessionFactory实例�Q?span lang="EN-US">getHibernateTemplate�Ҏ��则用来根据刚才的SessionFactory产生Session�Q�最后生�?span lang="EN-US">HibernateTemplate来完成数据库讉K��?span lang="EN-US">

HibernateTemplate的常规用�?/span>

HibernateTemplate提供非常多的常用�Ҏ��来完成基本的操作�Q�比如通常的增加、删除、修攏V��查询等操作�Q?span lang="EN-US">Spring 2.0更增加对命名SQL查询的支持，也增加对分页的支持。大部分情况下，使用Hibernate的常规用法，��可完成大多�?span lang="EN-US">DAO对象�?span lang="EN-US">CRUD操作。下面是HibernateTemplate的常用方法简介：

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

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

find(String queryString)�Q�根�?span lang="EN-US">HQL查询字符串来�q�回实例集合

findByNamedQuery(String queryName)�Q�根据命名查询返回实例集�?span lang="EN-US">

get(Class entityClass, Serializable id)�Q�根据主键加载特定持久化�cȝ��实例

save(Object entity)�Q�保存新的实�?span lang="EN-US">

saveOrUpdate(Object entity)�Q�根据实例状态，选择保存或者更�?span lang="EN-US">

update(Object entity)�Q�更新实例的状态，要求entity是持久状�?span lang="EN-US">

setMaxResults(int maxResults)�Q�设�|�分��늚�大小

Hibernate的复杂用�?/span>HibernateCallback

HibernateTemplate�q�提供一�U�更加灵�zȝ��方式来操作数据库�Q�通过�q�种方式可以完全使用Hibernate的操作方式�?span lang="EN-US">HibernateTemplate的灵�z�访问方式是通过如下两个�Ҏ��完成�Q?span lang="EN-US">

Object execute(HibernateCallback action)

List execute(HibernateCallback action)

�q�两个方法都需要一�?span lang="EN-US">HibernateCallback的实例，HibernateCallback实例可在��M��有效�?span lang="EN-US">Hibernate数据讉K��中��用。程序开发者通过HibernateCallback�Q�可以完全��?span lang="EN-US">Hibernate灉|��的方式来讉K��数据库，解决Spring��装Hibernate后灵�z�L��不��的�~�陷�?span lang="EN-US">HibernateCallback是一个接口，该接口只有一个方�?span lang="EN-US">doInHibernate(org.hibernate.Session session)�Q�该�Ҏ��只有一个参�?span lang="EN-US">Session�?span lang="EN-US">

通常�Q�程序中采用实现HibernateCallback的匿名内部类来获�?span lang="EN-US">HibernateCallback的实例，�Ҏ��doInHibernate的方法体��是Spring执行的持久化操作

注意�Q�方�?span lang="EN-US">doInHibernate�Ҏ��内可以访�?span lang="EN-US">Session�Q�该Session对象是绑定到该线�E�的Session实例。该�Ҏ��内的持久层操作，与不使用Spring时的持久层操作完全相同。这保证对于复杂的持久层讉K��Q�依然可以��?span lang="EN-US">Hibernate的访问方式�?/span>

下面�Q�让我们看一下接 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) {
    // 实现�Ҏ��属性名和属性值查询对象，�q�回唯一对象
    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) {
    // 实现�q�回 �Ҏ��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  排序条�g.
   * @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) {
    // 实现�Ҏ��对象属性名和属性��|��q�回唯一对象

    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) {
    // 实现�q�回与此�c�d��应主键�ؓid的所有�?/span>
    Object o=getHibernateTemplate().get(clazz, id);
    if(o==null){
    throw new ObjectRetrievalFailureException(clazz,id);
    }
    return o;
  }

  public List getObjects(Class clazz) {
    // 实现�q�回entity�c�d��?/span>
    return getHibernateTemplate().loadAll(clazz);
  }

  public void removeObject(Class clazz, Serializable id) {
    // 实现�Ҏ��数据库中与此�c�d��应表的主键（id�Q�删除此对象
    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) {
    // 实现序列化保存对�?/span>
    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);
  }

}

然后�Q�我们要配置.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 发表评论

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

首先�Q�我们先要理解一�?/span>相关知识点：

1、对象的序列化：Serializable

对象序列化是对象�怹�化的一�U�机�Ӟ��可以把序列化当成一�U�深度克隆的�Ҏ��Q�确切的说应该是对象的序列化�Q�一般程序在�q�行�Ӟ��产生对象�Q�这些对象随着�E�序的停止运行而消失，但如果我们想把某些对象（因�ؓ是对象，所以有各自不同的特性）保存下来�Q�在�E�序�l�止�q�行后，�q�些对象仍然存在�Q�可以在�E�序再次�q�行时读取这些对象的��|��或者在其他�E�序中利用这些保存下来的对象。这�U�情况下��p��用到对象的序列化。一般对象序列化后会保存在存储设备（��盘�Q�上�Q�以文�g的�Ş式出现�?/span>

2�?span lang="EN-US">CRUD

CRUD是增加、读取、更新和删除几个单词的首字母��?/span> �?/span>Create,Read,Update,Delete四个单词的羃写，主要被用在描�q��Y件系�l�中数据库或者持久层的基本操作功能�?/span>
(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.)

在进�?/span>Hibernate开发过�E�中�Q�我们通常会��?/span>DAO模式�Q�有一些通用的数据操作方法，�?/span>CRUD�Q�我们通常会将�q�些�Ҏ��集中在一�?/span>DAO�Q�这样会��便很多。DAO数据讉K��接口如下�Q?/span>

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

public interface Dao {

  List getObjects(Class clazz);//�q�回数据库中与此�c�d��应的表的所有��|��即entity�c�d��中的所有信�?/span>

  Object getObject(Class clazz, Serializable id);//�q�回与此�c�d��应的表主键�ؓid的所有�?/span>

  Serializable saveObject(Object o);//序列化保存对象�?/span>

  void updateObject(Object o);//更新此对�?/span>

  void removeObject(Class clazz, Serializable id);//�Ҏ��数据库中与此�c�d��应表的主键（id�Q�删除此对象

  void removeObject(Object o);//删除此对�?/span>

  void removeObjects(Collection objects);

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

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

  /**
   * �Ҏ��Map中过滤条件和分页参数查询.
   *
   * @param filter   �q��o条�g.
   * @param sortMap  排序条�g.
   * @param pageNo   当前��늠�
   * @param pageSize 每页昄��记录�?
   */

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

  /**
   * �W�合filter�q��o条�g的记录��L��
   * @param clazz
   * @param filter
   * @return
   */
  int total(Class clazz, Map filter);
}

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

成人中文视频,欧美国产日韩一区,久久久久久久久久久久久久久久久久av

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