import java.util.List;
/**
* @file_name BaseDao.java
* @author janson_chang
* @param <E>
* @todo BaseDao
*/
public interface BaseDao<E> {
/**
* 返回ID=ID的持久對象
* @param id
* @return E
*/
public E get(String id);
/**
* 返回ID=ID的代理對象
* @param id
* @return E
*/
public E load(String id);
/**
* 返回根據字段的得到的持久對象
* @param name
* @param value
* @return E
*/
public E loadBy(String name, Object value);
/**
* 返回根據數組字段的得到的持久對象
* @param names
* @param values
* @return E
*/
public E loadBy(String[] names, Object[] values);
/**
* 返回保存的對象的ID
* @param entity
* @return String
*/
public String save(E entity);
/**
* 更新對象信息
* @param entity
*/
public void update(E entity);
/**
* saveOrUpdate對象信息
* @param entity
*/
public void saveOrUpdate(E entity);
/**
* 刪除對象
* @param entity
*/
public void delete(E entity);
/**
* 返回所有的對象信息list
* @return List<E>
*/
public List<E> listAll();
/**
* 根據字段name和數據value返回對象list
* @param name
* @param value
* @return List<E>
*/
public List<E> findBy(String name, Object value);
/**
* 根據數組字段name,數據value返回對象list
* @param names
* @param values
* @return List<E>
*/
public List<E> findBy(String[] names, Object[] values);
/**
* 更新内存中的數據
* @param entity
*/
public void refresh(E entity);
/**
* 提交内存中的數據
*/
public void flush();
/**
* 根据域对象类和条件查询对象查询一组域对象
* @param <T>
* @param clazz
* @param enhanceRule
* @return
*/
List<E> query(Class clazz, EnhancedRule enhanceRule);
/**
* 执行SQL
*/
public void executeSQL(String sql);
/**
* 执行HSQL,语句必须符合HSQL规范
*/
public List<E> queryHQL(String sql);
/**
* 执行本地SQL
*/
public List<E> queryNQL(String sql);
}
import java.lang.reflect.ParameterizedType;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
* @file_name BaseDaoHibernateImpl.java
* @author janson_chang
* @param <E>
* @todo BaseDaoHibernateImpl<E>
*/
@SuppressWarnings("unchecked")
public class BaseDaoHibernateImpl<E> extends HibernateDaoSupport implements BaseDao<E> {
/**
*
*/
protected Class<E> entityClass;
/**
*
*/
protected Logger log = Logger.getLogger(this.getClass());
/**
*
*
*/
public BaseDaoHibernateImpl() {
super();
entityClass = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass())
.getActualTypeArguments()[0];
}
/**
*
* @param entityClassName
* @throws ClassNotFoundException
*/
public void setEntityClass(String entityClassName) throws ClassNotFoundException {
this.entityClass = (Class<E>)Class.forName(entityClassName);
}
/**
*
* @param entityClass
*/
public void setEntityClass(Class<E> entityClass) {
this.entityClass = entityClass;
}
/**
* 返回Criteria
*
* @return Criteria
*/
protected Criteria getCriteria() {
Criteria criteria = getSession().createCriteria(entityClass);
criteria.setCacheable(true);
return criteria;
}
public void executeSQL(String sql){
getSession().createSQLQuery(sql).executeUpdate();
}
public List<E> queryHQL(String sql){
return getSession().createQuery(sql).list();
}
public List<E> queryNQL(String sql){
return getSession().createSQLQuery(sql).list();
}
/**
* @param entity
*/
public void delete(E entity) {
getHibernateTemplate().delete(entity);
flush();
}
/**
* @param name
* @param value
* @return List<E>
*
*/
public List<E> findBy(String name, Object value) {
return findBy(new String[] { name }, new Object[] { value });
}
/**
* @param names
* @param values
* @return List<E>
*
*/
@SuppressWarnings ("unchecked")
public List<E> findBy(String[] names, Object[] values) {
if (names == null || values == null || names.length != values.length) {
throw new HibernateException("Illegal name and values" + names + ":" + values);
}
Criteria criteria = getCriteria();
Map<String, Object> criteriaMap = new HashMap<String, Object>();
for (int i = 0; i < names.length; i++) {
criteriaMap.put(names[i], values[i]);
}
criteria.add(Restrictions.allEq(criteriaMap));
criteria.setCacheable(true);
return criteria.list();
}
/**
*
*/
public void flush() {
getHibernateTemplate().flush();
}
/**
* @param id
* @return E
*/
public E get(String id) {
return (E) getHibernateTemplate().get(entityClass, id);
}
/**
* @return List<E>
*
*/
public List<E> listAll() {
return getHibernateTemplate().loadAll(entityClass);
}
/**
* @param id
* @return E
*/
public E load(String id) {
return (E) getHibernateTemplate().load(entityClass, id);
}
/**
* @param name
* @param value
* @return E
*
*/
public E loadBy(String name, Object value) {
return loadBy(new String[] { name }, new Object[] { value });
}
/**
* @param names
* @param values
* @return E
*
*/
public E loadBy(String[] names, Object[] values) {
E result = null;
List<E> resultList = findBy(names, values);
if (resultList.size() > 0) {
result = resultList.get(0);
}
return result;
}
/**
* @param entity
*
*/
public void refresh(E entity) {
getHibernateTemplate().refresh(entity);
}
/**
* @param entity
* @return String
*/
public String save(E entity) {
return (String) getHibernateTemplate().save(entity);
}
/**
* @param entity
*
*/
public void saveOrUpdate(E entity) {
getHibernateTemplate().saveOrUpdate(entity);
}
/**
* @param entity
*
*/
public void update(E entity) {
getHibernateTemplate().update(entity);
}
public List<E> query(Class clazz, EnhancedRule enhanceRule) {
if (enhanceRule == null) {
return listAll();
}
return enhanceRule.getCriteria (clazz, getSession (false)).list ();
}
}
分享到:
相关推荐
了解和熟练运用Hibernate的核心接口与类对于任何想要在Java项目中实现高效数据访问层的开发者都是必不可少的。通过掌握Configuration、SessionFactory、Session、Transaction、Query/Criteria以及缓存机制,你将能够...
1. 创建泛型Dao接口的实现类,继承泛型Dao接口。 2. 使用 Hibernate 的 Session 对象来实现数据访问。 3. 实现泛型Dao接口的方法,例如 create、delete、update、findById 等。 Hibernate 对泛型Dao接口的实现的...
3. **DAO实现类**:如`UserDAOImpl.java`,实现了`UserDAO`接口,通过Hibernate的Session对象来执行SQL操作。 4. **Service层**:例如`UserService.java`,调用DAO接口进行业务逻辑处理,是业务逻辑层和DAO层的桥梁...
在实际开发中,通过熟练掌握这些接口和概念,我们可以高效地利用Hibernate进行数据库操作,降低系统的耦合度,提升开发效率。通过阅读给出的源码s2sh_Hibernate03_CoreAPI,可以进一步加深对这些概念的理解和实践。
Hibernate 是一种流行的 Java 持久化框架,它提供了多种核心接口来实现数据的持久化操作。这些核心接口是 Hibernate 的基础组件,任何 Hibernate 应用程序都需要使用它们。下面将详细介绍这五个核心接口:...
在标题和描述中提到的"Spring+Hibernate实现)Hibernate公用类",实际上是指创建一个泛化的DAO接口(EntityDao)和它的实现类(EntityDaoImpl)。这样的设计模式可以避免为每个数据模型(如User、News、Company)都...
查询数据是Hibernate中最常用的功能。主要有以下几种方式: - HQL(Hibernate Query Language):这是Hibernate特有的查询语言,语法类似SQL,但面向对象。 - Criteria API:提供了一种更加面向对象的查询方式,...
通过定义实体类和映射文件,开发者可以使用面向对象的方式来操作数据库,而无需编写大量的SQL语句。 **博客系统功能** 1. **注册登录**:用户可以注册新账户,系统会验证输入的用户名和密码,并通过Struts 2的...
例如,`org.hibernate.Session` 类是与数据库交互的基本接口,`org.hibernate.cfg.Configuration` 类用于配置 Hibernate 实例,而 `org.hibernate.query.Query` 和 `org.hibernate Criteria` 接口则用于执行 HQL...
本篇将深入探讨Hibernate方法的实现,包括其基本概念、配置、实体类、会话工厂以及各种操作数据库的方法。 1. **Hibernate基础** Hibernate是基于Java的持久层框架,通过XML配置文件或注解来定义对象与数据库表...
7. **文件列表"sh2"**:这个文件名可能是项目的源代码文件夹,包含了Spring和Hibernate的相关配置文件、实体类、DAO接口和实现、Controller类以及其他支持文件。为了运行项目,需要解压这个文件,并确保所有依赖库已...
Hibernate的核心组件包括配置文件、实体类、映射文件和Session接口。 **二、Hibernate配置** 1. **配置文件**:`hibernate.cfg.xml`是Hibernate的主配置文件,其中包含数据库连接信息、方言设置、缓存配置等。 2....
【hibernate3 最简单实现项目】 在Java开发中,Hibernate是一个非常重要的对象关系映射(ORM)框架,它极大地简化了数据库操作。本项目基于Hibernate3,将介绍如何实现最简单的查询功能,并且提供了必要的jar包以供...
5. **DAO层设计**:创建Hibernate的Data Access Object(DAO)接口和实现类,这里包含对数据库的CRUD操作方法,比如使用Session对象执行SQL语句。 6. **Service层设计**:创建Service接口和实现类,将业务逻辑封装...
DAO接口和实现类负责具体的数据库操作,使用Hibernate的Session接口进行CRUD操作。最后,Controller层接收到HTTP请求,调用Service层的方法,并通过ModelAndView对象将结果传递给视图层进行渲染。 这个整合的示例...
3. **编写DAO**:创建DAO接口和实现类,这些类通常包含增删改查的基本方法,如`save(User user)`、`delete(User user)`等,它们使用Hibernate的Session接口进行操作。 4. **Service层**:在Service层,我们可以创建...
然后,通过Hibernate的配置文件和Session接口,我们可以实现CRUD(创建、读取、更新、删除)操作。 例如,当用户提交留言时,我们可以创建一个新的`Message`对象,设置其属性,然后使用Hibernate的`Session`对象...
在IT行业中,开发Web应用程序是常见的任务之一,而"hibernate+struts实现简单登录"就是一个典型的应用场景。这个项目使用了MyEclipse作为集成开发环境,Struts作为MVC框架,以及Hibernate作为对象关系映射(ORM)...
通用分页工具类可能提供了执行HQL查询并自动实现分页的接口。这可能包括方法如`executePagedHqlQuery`,该方法接收HQL语句、分页参数,并返回分页后的查询结果。 在实际项目中,使用这些工具类可以大大提升开发效率...
这个"hibernate5类包"包含了实现上述功能所需的全部类和库,例如`hibernate-core.jar`包含了核心ORM功能,`hibernate-entitymanager.jar`提供了JPA支持,`hibernate-infinispan.jar`则包含Infinispan缓存相关的组件...