Hibernate 增删改查 基于HibernateTemplate

Hibernate 增删改查

 

package com.abin.ssh.bean;

import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.LockMode;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class UsersDAO extends HibernateDaoSupport {
 private static final Log log = LogFactory.getLog(UsersDAO.class);
 // property constants
 public static final String FAMILY = "family";
 public static final String NAME = "name";
 public static final String AGE = "age";

 protected void initDao() {
  // do nothing
 }

 public void save(Users transientInstance) {
  log.debug("saving Users instance");
  try {
   getHibernateTemplate().save(transientInstance);
   log.debug("save successful");
  } catch (RuntimeException re) {
   log.error("save failed", re);
   throw re;
  }
 }

 public void delete(Users persistentInstance) {
  log.debug("deleting Users instance");
  try {
   getHibernateTemplate().delete(persistentInstance);
   log.debug("delete successful");
  } catch (RuntimeException re) {
   log.error("delete failed", re);
   throw re;
  }
 }

 public Users findById(java.lang.Integer id) {
  log.debug("getting Users instance with id: " + id);
  try {
   Users instance = (Users) getHibernateTemplate().get(
     "com.abin.ssh.bean.Users", id);
   return instance;
  } catch (RuntimeException re) {
   log.error("get failed", re);
   throw re;
  }
 }

 public List findByExample(Users instance) {
  log.debug("finding Users instance by example");
  try {
   List results = getHibernateTemplate().findByExample(instance);
   log.debug("find by example successful, result size: "
     + results.size());
   return results;
  } catch (RuntimeException re) {
   log.error("find by example failed", re);
   throw re;
  }
 }

 public List findByProperty(String propertyName, Object value) {
  log.debug("finding Users instance with property: " + propertyName
    + ", value: " + value);
  try {
   String queryString = "from Users as model where model."
     + propertyName + "= ?";
   return getHibernateTemplate().find(queryString, value);
  } catch (RuntimeException re) {
   log.error("find by property name failed", re);
   throw re;
  }
 }

 public List findByFamily(Object family) {
  return findByProperty(FAMILY, family);
 }

 public List findByName(Object name) {
  return findByProperty(NAME, name);
 }

 public List findByAge(Object age) {
  return findByProperty(AGE, age);
 }

 public List findAll() {
  log.debug("finding all Users instances");
  try {
   String queryString = "from Users";
   return getHibernateTemplate().find(queryString);
  } catch (RuntimeException re) {
   log.error("find all failed", re);
   throw re;
  }
 }

 public Users merge(Users detachedInstance) {
  log.debug("merging Users instance");
  try {
   Users result = (Users) getHibernateTemplate().merge(
     detachedInstance);
   log.debug("merge successful");
   return result;
  } catch (RuntimeException re) {
   log.error("merge failed", re);
   throw re;
  }
 }

 public void attachDirty(Users instance) {
  log.debug("attaching dirty Users instance");
  try {
   getHibernateTemplate().saveOrUpdate(instance);
   log.debug("attach successful");
  } catch (RuntimeException re) {
   log.error("attach failed", re);
   throw re;
  }
 }

 public void attachClean(Users instance) {
  log.debug("attaching clean Users instance");
  try {
   getHibernateTemplate().lock(instance, LockMode.NONE);
   log.debug("attach successful");
  } catch (RuntimeException re) {
   log.error("attach failed", re);
   throw re;
  }
 }

 public static UsersDAO getFromApplicationContext(ApplicationContext ctx) {
  return (UsersDAO) ctx.getBean("UsersDAO");
 }
}

================================================================================================

 /**
* 向数据库添加一条对应于一个业务对象实例的记录
*
* @param entity
* 业务对象实例
      */
public Entity create(Entity entity) throws DaoException {
try {
getHibernateTemplate().save(entity);
return entity;
} catch (DataAccessException e) {
            throw new DaoException("保存 " + entity.getClass().getName()
+ " 实例到数据库失败", e);
}
}

/**
* 向数据库更新一条对应于一个业务对象实例的记录
*
* @param entity
      * 业务对象实例
      */
public void update(Entity entity) throws DaoException {
try {
getHibernateTemplate().update(entity);
} catch (DataAccessException e) {
            throw new DaoException("更新 " + entity.getClass().getName()
+ " 实例到数据库失败", e);
}
}

/**
* 从数据库删除一条对应于一个业务对象的记录
*
* @param entity
* 业务对象实例
      */
public void delete(Entity entity) throws DaoException {
try {
getHibernateTemplate().delete(entity);
} catch (DataAccessException e) {
            throw new DaoException("从数据库删除 " + entity.getClass().getName()
+ " 实例失败", e);
}
}

/**
* 从数据库删除所有对应于一个业务对象的记录
*
* @param clazz
* 指定类型的业务对象
      */
public void deleteAll(Class clazz) throws DaoException {
try {
List result = getHibernateTemplate().loadAll(clazz);
//如果这里的clazz里面有其他对象的引用则不可以这样直接删除，必须先把里面的引用删除掉之后才可以删除该对象
getHibernateTemplate().deleteAll(result);
} catch (DataAccessException e) {
log.error("从数据库删除 " + clazz.getName() + " 的所有记录失败", e);
throw new DaoException("从数据库删除 " + clazz.getName() + " 的所有记录失败", e);
}
}

public void deleteAll(Collection entities) throws DaoException {
try {
getHibernateTemplate().deleteAll(entities);
} catch(DataAccessException e) {
throw new DaoException(e);
}
}

/**
* 根据关键字从数据库加载指定类型的业务对象。
*
* @param clazz
* 业务对象的Class
* @param keyName
* 指定关键字对应的字段名称
* @param keyValue
* 指定关键字的值
* @return <ul>
* <li>当关键字唯一并存在该记录时，返回该记录对应的业务对象</li>
* <li>当关键字不唯一，返回查询结果的第一条记录所对应的业务对象</li>
* <li>当不存在该记录时,返回null</li>
      */
public Object loadByKey(Class clazz, String keyName, Object keyValue)
throws DaoException {
try {
List result = getHibernateTemplate().find(
"from " + clazz.getName() + " where " + keyName + " = ?",
keyValue);
if (result != null && result.size() > 0) {
return result.get(0);
} else {
return null;
}
} catch (DataAccessException e) {
            throw new DaoException("加载 " + keyName + " 为 " + keyValue + " 的 "
+ clazz.getName() + " 实例失败", e);
}
}

/**
* 从数据库加载指定类型的业务对象的所有记录。
*
* @param clazz
* 业务对象的Class
* @return 返回数据库中对应该业务对象的所有记录的集合
      */
public List loadAll(Class clazz) throws DaoException {
try {
return getHibernateTemplate().loadAll(clazz);
} catch (DataAccessException e) {
            throw new DaoException("加载所有 " + clazz.getName() + " 实例时失败", e);
}
}

/**
* 根据查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryString
* 指定查询语句
* @return 返回查询结果包含的业务对象集合
      */
public List find(String queryString) throws DaoException {
try {
return getHibernateTemplate().find(queryString);
} catch (DataAccessException e) {
            throw new DaoException("执行查询 " + queryString + " 失败", e);
}
}

/**
* 根据带一个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryString
* 指定查询语句
* @param param
* 指定所带参数
* @return 返回查询结果包含的业务对象集合
      */
public List find(String queryString, Object param) throws DaoException {
try {
return getHibernateTemplate().find(queryString, param);
} catch (DataAccessException e) {
            throw new DaoException("执行参数为 " + param + " 的查询 " + queryString
+ " 失败", e);
}
}

/**
* 根据带多个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryString
* 指定查询语句
* @param params
* 指定参数数组
* @return 返回查询结果包含的业务对象集合
      */
public List find(String queryString, Object[] params) throws DaoException {
try {
return getHibernateTemplate().find(queryString, params);
} catch (DataAccessException e) {
StringBuffer paramString = new StringBuffer("");
for (int i = 0; i < params.length; i++) {
paramString.append(params[i]);
paramString.append(" ");
}
            throw new DaoException("执行参数为 " + paramString + "的查询 "
+ queryString + " 失败", e);
}
}

/**
* 根据已定义的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryName
* 已定义查询语句的名称
* @return 返回查询结果包含的业务对象集合
      */
public List findByNamedQuery(String queryName) throws DaoException {
try {
return getHibernateTemplate().findByNamedQuery(queryName);
} catch (DataAccessException e) {
            throw new DaoException("执行命名为 " + queryName + " 的查询失败");
}
}

/**
* 根据已定义的带一个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryName
* 已定义查询语句的名称
* @param param
* 指定的参数
* @return 返回查询结果包含的业务对象集合
      */
public List findByNamedQuery(String queryName, Object param)
throws DaoException {
try {
return getHibernateTemplate().findByNamedQuery(queryName, param);
} catch (DataAccessException e) {
            throw new DaoException("执行参数为 " + param + " 命名为 " + queryName
+ " 的查询失败");
}
}

/**
* 根据已定义的带多个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryName
* 已定义查询语句的名称
* @param params
* 指定的参数数组
* @return 返回查询结果包含的业务对象集合
      */
public List findByNameQuery(String queryName, Object[] params)
throws DaoException {
try {
return getHibernateTemplate().findByNamedQuery(queryName, params);
} catch (DataAccessException e) {
StringBuffer paramString = new StringBuffer("");
for (int i = 0; i < params.length; i++) {
paramString.append(params[i]);
paramString.append(" ");
}
            throw new DaoException("执行参数为 " + paramString + "命名为 " + queryName
+ " 的查询失败");
}
}

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

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

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

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

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

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

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

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

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

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

Hibernate 的复杂用法 HibernateCallback

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

q      Object execute(HibernateCallback action)

q      List execute(HibernateCallback action)

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

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