import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
* This class serves as the Base class for all other DAOs - namely to hold
* common CRUD methods that they might all use. You should only need to extend
* this class when your require custom CRUD logic.
* <p>
* To register this class in your Spring context file, use the following XML.
*
* <pre>
* <bean id="fooDao" class="com.soft863.bbs.dao.hibernate.GenericDaoHibernate">
* <constructor-arg value="com.soft863.bbs.model.Foo"/>
* <property name="sessionFactory" ref="sessionFactory"/>
* </bean>
* </pre>
*
* @author <a href="mailto:bwnoll@gmail.com">Bryan Noll</a>
*/
public class GenericDaoHibernate<T, PK extends Serializable> extends
HibernateDaoSupport implements GenericDao<T, PK> {
protected final Log log = LogFactory.getLog(getClass());
private Class<T> persistentClass;
public GenericDaoHibernate() {
}
public GenericDaoHibernate(Class<T> persistentClass) {
this.persistentClass = persistentClass;
}
public void setPersistentClass(Class<T> persistentClass) {
this.persistentClass = persistentClass;
}
@SuppressWarnings("unchecked")
public List<T> getAll() {
return super.getHibernateTemplate().loadAll(this.persistentClass);
}
@SuppressWarnings("unchecked")
private T get(PK id) {
T entity = (T) super.getHibernateTemplate().get(this.persistentClass,
id);
if (entity == null) {
log.warn("Uh oh, '" + this.persistentClass + "' object with id '"
+ id + "' not found...");
throw new ObjectRetrievalFailureException(this.persistentClass, id);
}
return entity;
}
@SuppressWarnings("unchecked")
private boolean exists(PK id) {
T entity = (T) super.getHibernateTemplate().get(this.persistentClass,
id);
if (entity == null) {
return false;
} else {
return true;
}
}
private void remove(PK id) {
this.remove(this.get(id));
}
public T save(T object) {
super.getHibernateTemplate().saveOrUpdate(object);
return object;
}
private void remove(Object object) {
super.getHibernateTemplate().delete(object);
}
@SuppressWarnings("unchecked")
public Object getObject(final Class persistentClass, final String where) {
List list = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session s)
throws HibernateException, SQLException {
StringBuffer sql = new StringBuffer("from "
+ persistentClass.getName() + " p ");
if (StringUtils.isNotBlank(where)) {
if (where.trim().startsWith("where ")) {
sql.append(where);
} else {
sql.append(" where ").append(where);
}
}
Query q = s.createQuery(sql.toString());
return q.list();
}
});
if (list != null) {
// 如果取到唯一一个值,返回
if (list.size() == 1) {
return list.get(0);
} else if (list.size() > 0) {
// 如果多余一个值,输出错误,返回null
// System.out.println("[warn]:getObject("+persistentClass.getName()+",\""+where+"\"):根据唯一条件得到多于一个的值,请检查!");
return null;
}
}
return null;
}
@SuppressWarnings("unchecked")
public List getObjs(final String hsql) {
return getObjs(hsql,-1,-1);
}
public List getObjs(final String hsql,final int firstResult, final int maxResult) {
List list = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session s)
throws HibernateException, SQLException {
Query q = s.createQuery(hsql);
if (firstResult >= 0 && maxResult >= 0) {
q.setFirstResult(firstResult);
q.setMaxResults(maxResult);
}
return q.list();
}
});
return list;
}
public List getObjs(final String hsql, final int num) {
List list = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session s)
throws HibernateException, SQLException {
Query q = s.createQuery(hsql);
if (num >= 0) {
q.setFirstResult(0);
q.setMaxResults(num);
}
return q.list();
}
});
return list;
}
public boolean exists(Class<T> persistentClass, PK id) {
synchronized (this) {
this.setPersistentClass(persistentClass);
return this.exists(id);
}
}
public T get(Class<T> persistentClass, PK id) {
synchronized (this) {
this.setPersistentClass(persistentClass);
return this.get(id);
}
}
public void remove(Class<T> persistentClass, PK id) {
synchronized (this) {
this.setPersistentClass(persistentClass);
this.remove(id);
}
}
@SuppressWarnings("unchecked")
public List getListBySql(String sql) {
SQLQuery a = this.getSession().createSQLQuery(sql);
return a.list();
}
public List getObjstBySql(final String sql, final int firstResult, final int maxResult) {
List list = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session s)
throws HibernateException, SQLException {
Query q = s.createSQLQuery(sql);
if (firstResult >= 0 && maxResult >= 0) {
q.setFirstResult(firstResult);
q.setMaxResults(maxResult);
}
return q.list();
}
});
return list;
}
}
***************************分割线(下面是接口)***************************
import java.io.Serializable;
import java.util.List;
/**
* Generic DAO (Data Access Object) with common methods to CRUD POJOs.
*
* <p>Extend this interface if you want typesafe (no casting necessary) DAO's for your
* domain objects.
*
* @author <a href="mailto:bwnoll@gmail.com">Bryan Noll</a>
*/
public interface GenericDao <T, PK extends Serializable> {
public void setPersistentClass(Class<T> persistentClass);
/**
* Generic method used to get all objects of a particular type. This
* is the same as lookup up all rows in a table.
* @return List of populated objects
*/
public List<T> getAll();
/**
* Generic method to get an object based on class and identifier. An
* ObjectRetrievalFailureException Runtime Exception is thrown if
* nothing is found.
*
* @param id the identifier (primary key) of the object to get
* @return a populated object
* @see org.springframework.orm.ObjectRetrievalFailureException
*/
public T get(Class<T> persistentClass,PK id);
/**
* Checks for existence of an object of type T using the id arg.
* @param id
* @return - true if it exists, false if it doesn't
*/
public boolean exists(Class<T> persistentClass,PK id);
/**
* Generic method to save an object - handles both update and insert.
* @param object the object to save
*/
public T save(T object);
/**
* Generic method to delete an object based on class and id
* @param id the identifier (primary key) of the object to remove
*/
public void remove(Class<T> persistentClass, PK id);
/**
* Generic method to get an object based on class and identifier. An
* ObjectRetrievalFailureException Runtime Exception is thrown if nothing is
* found.
*
* @param clazz
* model class to lookup
* @param id
* the identifier (primary key) of the class
* @return a populated object
* @see org.springframework.orm.ObjectRetrievalFailureException
*/
/**
* 根据where条件,得到唯一的po对象。如果结果多于一个,返回null。并在后台输出错误。
* @param persistentClass 该po的持久化class
* @param where 查询的where条件,类似于[p.name='22']
* @return 通过查询条件得到的唯一对象
*/
public Object getObject(Class<T> persistentClass, String where);
/**
* 根据hsql语句,返回查询结果。
* @param hsql hsql语句,类似于[from com.hnjz.core.User u where u.name like 'admin%']
* @return 通过查询条件得到hibernate的查询结果(List)
*/
@SuppressWarnings("unchecked")
public List getObjs(String hsql);
public List getObjs(String hsql,final int firstResult, final int maxResult);
/**
* 返回前num个查询结果。
* @param hsql hsql语句,类似于[from com.hnjz.core.User u where u.name like 'admin%']
* @param num 查询结果数量
* @return 通过查询条件得到hibernate的查询结果(List)
*/
public List getObjs(String hsql,int num);
public List getListBySql(String sql);
public List getObjstBySql(String sql,final int firstResult, final int maxResult);
}
分享到:
相关推荐
Hibernate是一款强大的Java对象关系映射(ORM)框架,它为开发者提供了在Java应用中操作数据库的简便方法。通过使用Hibernate,开发人员可以避免直接编写SQL语句,而是通过面向对象的方式来管理和操作数据。本文将...
以下是对"Hibernate操作数据库的步骤"的详细解释: 1. **读取并解析配置文件**:在Hibernate中,配置文件(通常是`hibernate.cfg.xml`)包含了数据库连接信息,如URL、用户名、密码等。`Configuration`类用于加载这...
Hibernate操作数据库时,主要通过以下几个核心组件来实现持久层操作: 1. **Session**:Session是Hibernate用来和数据库进行交互的一个轻量级对象,它相当于JDBC中的Connection。Session对象是应用程序与数据库进行...
【标题】"自己动手模仿Hibernate写数据库框架"揭示了本次讨论的核心内容——尝试构建一个类似于Hibernate的数据库操作框架。Hibernate是一个流行的Java ORM(对象关系映射)框架,它简化了数据库与Java对象之间的...
Hibernate与JDBC对于数据库的性能操作对比事例,配置,更多信息资源
Java使用Hibernate操作数据库是现代Java应用中常见的技术实践,Hibernate作为一个强大的对象关系映射(ORM)框架,极大地简化了数据库的交互。它允许开发者用Java对象来表示数据库中的记录,而无需关心底层SQL的实现...
Hibernate是一个强大的Java持久化框架,它允许开发者将对象模型与关系数据库进行映射,从而简化了数据库操作。在处理多数据库支持时,Hibernate提供了一些策略和技巧来确保应用程序能够在不同类型的数据库之间灵活...
在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它简化了与数据库交互的过程,使得开发者可以使用面向对象的方式来操作数据库。对于Oracle数据库的支持,Hibernate提供了专门的驱动和配置,使得...
总结起来,"Java封装hibernate操作数据库.rar"这个资源包提供了使用Hibernate进行数据库操作的基础,特别是通过DAO层封装,使得开发者可以更专注于业务逻辑,而不是繁琐的数据库操作。同时,利用JDK15的特性,可以...
在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者通过Java对象来操作数据库,极大地简化了数据库操作。金仓数据库,又称为Kingbase,是一款国产的高性能、高可靠性的关系型数据库管理...
标题"Hibernate数据库操作实例.zip"表明这是一个关于使用Hibernate框架进行数据库操作的实际案例。Hibernate是一个流行的Java对象关系映射(ORM)工具,它允许开发人员使用面向对象的方式来处理数据库交互,而无需...
在IT领域,尤其是在Java开发中,Hibernate是一个非常重要的对象关系映射(ORM)框架,它极大地简化了数据库操作。以下是对Hibernate对数据库操作的理解及其相关知识点的详细解释: 1. **Session与持久化状态**: -...
- **操作数据库**:使用`SessionFactory`创建`Session`对象,进行CRUD操作。确保每次操作都使用正确的`SessionFactory`,避免数据混淆。 4. **事务管理** - **多数据库事务处理**:由于每个数据库可能有不同的...
### Hibernate配置数据库连接知识点详解 #### 一、Hibernate简介与作用 Hibernate 是一款开源的对象关系映射(Object Relational Mapping, ORM...掌握这些配置方法对于高效地使用 Hibernate 进行数据库操作至关重要。
在数据访问层面,Spring通过其JDBC抽象层和对各种ORM(Object-Relational Mapping)框架的支持,如Hibernate,使得数据库操作变得更加便捷。 Hibernate则是一个流行的ORM框架,它简化了Java对象与关系数据库之间的...
Action类通常包含处理业务逻辑的方法,这些方法会调用Hibernate的相关API来执行对MySQL数据库的CRUD(创建、读取、更新、删除)操作。例如,创建新记录时,会使用SessionFactory创建Session,然后通过Session的save...
在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者使用面向对象的方式来操作数据库。"hibernate反向生成数据库程序"是指通过Hibernate框架,从已有的数据库结构生成对应的Java实体类和...
5. **Hbm2DDL Auto**:在Hibernate配置中,有一个属性`hibernate.hbm2ddl.auto`,它可以设置为不同的值,如`create`、`update`、`validate`等,控制Hibernate在启动时对数据库的操作。例如,`create`会根据实体类...
Hibernate 是一个流行的Java ORM(对象关系映射)框架,它允许开发者用面向对象的方式来操作数据库。在Hibernate中配置数据库连接池,可以使数据库操作更加高效和便捷。这里有两种常见的配置方法: 1. **C3P0**: ...
在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者通过Java对象来操作数据库,而无需编写大量的SQL语句。"根据Hibernate反向生成数据库的Java代码"这一主题涉及到的主要知识点包括...