转自：微点阅读 https://www.weidianyuedu.com
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 {undefined
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() {undefined
// do nothing
}
public void save(Users transientInstance) {undefined
log.debug(“saving Users instance”);
try {undefined
getHibernateTemplate().save(transientInstance);
log.debug(“save successful”);
} catch (RuntimeException re) {undefined
log.error(“save failed”, re);
throw re;
}
}
public void delete(Users persistentInstance) {undefined
log.debug(“deleting Users instance”);
try {undefined
getHibernateTemplate().delete(persistentInstance);
log.debug(“delete successful”);
} catch (RuntimeException re) {undefined
log.error(“delete failed”, re);
throw re;
}
}
public Users findById(java.lang.Integer id) {undefined
log.debug(“getting Users instance with id: ” + id);
try {undefined
Users instance = (Users) getHibernateTemplate().get(
“com.abin.ssh.bean.Users”, id);
return instance;
} catch (RuntimeException re) {undefined
log.error(“get failed”, re);
throw re;
}
}
public List findByExample(Users instance) {undefined
log.debug(“finding Users instance by example”);
try {undefined
List results = getHibernateTemplate().findByExample(instance);
log.debug(“find by example successful, result size: “
+ results.size());
return results;
} catch (RuntimeException re) {undefined
log.error(“find by example failed”, re);
throw re;
}
}
public List findByProperty(String propertyName, Object value) {undefined
log.debug(“finding Users instance with property: ” + propertyName
+ “, value: ” + value);
try {undefined
String queryString = “from Users as model where model.”
+ propertyName + “= ?”;
return getHibernateTemplate().find(queryString, value);
} catch (RuntimeException re) {undefined
log.error(“find by property name failed”, re);
throw re;
}
}
public List findByFamily(Object family) {undefined
return findByProperty(FAMILY, family);
}
public List findByName(Object name) {undefined
return findByProperty(NAME, name);
}
public List findByAge(Object age) {undefined
return findByProperty(AGE, age);
}
public List findAll() {undefined
log.debug(“finding all Users instances”);
try {undefined
String queryString = “from Users”;
return getHibernateTemplate().find(queryString);
} catch (RuntimeException re) {undefined
log.error(“find all failed”, re);
throw re;
}
}
public Users merge(Users detachedInstance) {undefined
log.debug(“merging Users instance”);
try {undefined
Users result = (Users) getHibernateTemplate().merge(
detachedInstance);
log.debug(“merge successful”);
return result;
} catch (RuntimeException re) {undefined
log.error(“merge failed”, re);
throw re;
}
}
public void attachDirty(Users instance) {undefined
log.debug(“attaching dirty Users instance”);
try {undefined
getHibernateTemplate().saveOrUpdate(instance);
log.debug(“attach successful”);
} catch (RuntimeException re) {undefined
log.error(“attach failed”, re);
throw re;
}
}
public void attachClean(Users instance) {undefined
log.debug(“attaching clean Users instance”);
try {undefined
getHibernateTemplate().lock(instance, LockMode.NONE);
log.debug(“attach successful”);
} catch (RuntimeException re) {undefined
log.error(“attach failed”, re);
throw re;
}
}
public static UsersDAO getFromApplicationContext(ApplicationContext ctx) {undefined
return (UsersDAO) ctx.getBean(“UsersDAO”);
}
}
================================================================================================
/
* 向数据库添加一条对应于一个业务对象实例的记录
*
* @param entity
* 业务对象实例
*/
public Entity create(Entity entity) throws DaoException {undefined
try {undefined
getHibernateTemplate().save(entity);
return entity;
} catch (DataAccessException e) {undefined
throw new DaoException(“保存 ” + entity.getClass().getName()
+ ” 实例到数据库失败”, e);
}
}
/
* 向数据库更新一条对应于一个业务对象实例的记录
*
* @param entity
* 业务对象实例
*/
public void update(Entity entity) throws DaoException {undefined
try {undefined
getHibernateTemplate().update(entity);
} catch (DataAccessException e) {undefined
throw new DaoException(“更新 ” + entity.getClass().getName()
+ ” 实例到数据库失败”, e);
}
}
/
* 从数据库删除一条对应于一个业务对象的记录
*
* @param entity
* 业务对象实例
*/
public void delete(Entity entity) throws DaoException {undefined
try {undefined
getHibernateTemplate().delete(entity);
} catch (DataAccessException e) {undefined
throw new DaoException(“从数据库删除 ” + entity.getClass().getName()
+ ” 实例失败”, e);
}
}
/
* 从数据库删除所有对应于一个业务对象的记录
*
* @param clazz
* 指定类型的业务对象
*/
public void deleteAll(Class clazz) throws DaoException {undefined
try {undefined
List result = getHibernateTemplate().loadAll(clazz);
//如果这里的clazz里面有其他对象的引用则不可以这样直接删除，必须先把里面的引用删除掉之后才可以删除该对象
getHibernateTemplate().deleteAll(result);
} catch (DataAccessException e) {undefined
log.error(“从数据库删除 ” + clazz.getName() + ” 的所有记录失败”, e);
throw new DaoException(“从数据库删除 ” + clazz.getName() + ” 的所有记录失败”, e);
}
}
public void deleteAll(Collection entities) throws DaoException {undefined
try {undefined
getHibernateTemplate().deleteAll(entities);
} catch(DataAccessException e) {undefined
throw new DaoException(e);
}
}
/
* 根据关键字从数据库加载指定类型的业务对象。
*
* @param clazz
* 业务对象的Class
* @param keyName
* 指定关键字对应的字段名称
* @param keyValue
* 指定关键字的值
* @return
- 当关键字唯一并存在该记录时，返回该记录对应的业务对象
- 当关键字不唯一，返回查询结果的第一条记录所对应的业务对象
- 当不存在该记录时,返回null
*
*
*
*/
public Object loadByKey(Class clazz, String keyName, Object keyValue)
throws DaoException {undefined
try {undefined
List result = getHibernateTemplate().find(
“from ” + clazz.getName() + ” where ” + keyName + ” = ?”,
keyValue);
if (result != null && result.size() > 0) {undefined
return result.get(0);
} else {undefined
return null;
}
} catch (DataAccessException e) {undefined
throw new DaoException(“加载 ” + keyName + ” 为 ” + keyValue + ” 的 “
+ clazz.getName() + ” 实例失败”, e);
}
}
/
* 从数据库加载指定类型的业务对象的所有记录。
*
* @param clazz
* 业务对象的Class
* @return 返回数据库中对应该业务对象的所有记录的集合
*/
public List loadAll(Class clazz) throws DaoException {undefined
try {undefined
return getHibernateTemplate().loadAll(clazz);
} catch (DataAccessException e) {undefined
throw new DaoException(“加载所有 ” + clazz.getName() + ” 实例时失败”, e);
}
}
/
* 根据查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryString
* 指定查询语句
* @return 返回查询结果包含的业务对象集合
*/
public List find(String queryString) throws DaoException {undefined
try {undefined
return getHibernateTemplate().find(queryString);
} catch (DataAccessException e) {undefined
throw new DaoException(“执行查询 ” + queryString + ” 失败”, e);
}
}
/
* 根据带一个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryString
* 指定查询语句
* @param param
* 指定所带参数
* @return 返回查询结果包含的业务对象集合
*/
public List find(String queryString, Object param) throws DaoException {undefined
try {undefined
return getHibernateTemplate().find(queryString, param);
} catch (DataAccessException e) {undefined
throw new DaoException(“执行参数为 ” + param + ” 的查询 ” + queryString
+ ” 失败”, e);
}
}
/
* 根据带多个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryString
* 指定查询语句
* @param params
* 指定参数数组
* @return 返回查询结果包含的业务对象集合
*/
public List find(String queryString, Object[] params) throws DaoException {undefined
try {undefined
return getHibernateTemplate().find(queryString, params);
} catch (DataAccessException e) {undefined
StringBuffer paramString = new StringBuffer(“”);
for (int i = 0; i < params.length; i++) {undefined
paramString.append(params[i]);
paramString.append(” “);
}
throw new DaoException(“执行参数为 ” + paramString + “的查询 “
+ queryString + ” 失败”, e);
}
}
/
* 根据已定义的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryName
* 已定义查询语句的名称
* @return 返回查询结果包含的业务对象集合
*/
public List findByNamedQuery(String queryName) throws DaoException {undefined
try {undefined
return getHibernateTemplate().findByNamedQuery(queryName);
} catch (DataAccessException e) {undefined
throw new DaoException(“执行命名为 ” + queryName + ” 的查询失败”);
}
}
/
* 根据已定义的带一个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryName
* 已定义查询语句的名称
* @param param
* 指定的参数
* @return 返回查询结果包含的业务对象集合
*/
public List findByNamedQuery(String queryName, Object param)
throws DaoException {undefined
try {undefined
return getHibernateTemplate().findByNamedQuery(queryName, param);
} catch (DataAccessException e) {undefined
throw new DaoException(“执行参数为 ” + param + ” 命名为 ” + queryName
+ ” 的查询失败”);
}
}
/
* 根据已定义的带多个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
*
* @param queryName
* 已定义查询语句的名称
* @param params
* 指定的参数数组
* @return 返回查询结果包含的业务对象集合
*/
public List findByNameQuery(String queryName, Object[] params)
throws DaoException {undefined
try {undefined
return getHibernateTemplate().findByNamedQuery(queryName, params);
} catch (DataAccessException e) {undefined
StringBuffer paramString = new StringBuffer(“”);
for (int i = 0; i < params.length; i++) {undefined
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) ：设置分页的大小
Java代码
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 执行的持久化操作
发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/216811.html原文链接：https://javaforall.net
