相信大家,在项目中都曾自己或者组员一起封装过通用数据库操作基类.然后其他持久层类继承这个类.下面就贴出来我以前项目中用到的一个类吧,CommDao.多多指教. 下面提供下载.
package com.kechuang.xlw.commdao;
import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Expression;
import org.hibernate.criterion.Order;
import org.hibernate.type.DateType;
import org.hibernate.type.FloatType;
import org.hibernate.type.IntegerType;
import org.hibernate.type.StringType;
import org.hibernate.type.Type;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
* 通用的操作类 dao
*
* @author 谢晋
*
*/
public class CommDao<T> extends HibernateDaoSupport {
// logger日志对象
protected Logger log = Logger.getLogger(this.getClass());
public CommDao() {
}
/**
* 添加一个对象
*/
public T addObject(T obj) {
this.getHibernateTemplate().save(obj);
return obj;
}
/**
* 删除一个对象
*/
public T deleteObject(T obj) {
this.getHibernateTemplate().delete(obj);
return obj;
}
/**
* 更新一个对象
*/
public T updateObject(T obj) {
this.getHibernateTemplate().update(obj);
return obj;
}
/**
* 排序+分页功能+条件查询
*
* @param <E>
* @param cl
* @param map
* 条件参数
* @param orderstr
* 排序字段 如果为null不排序
* @param beginpos
* 分页起点 如果为null不分页
* @param count
* 每页的记录总数 如果为null不分页
* @return 返回List集合
*/
public <E> List<E> getOrderObjects(final Class cl, final Map map,
final String orderstr, final Integer beginpos, final Integer count) {
List<E> list = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria cri = session.createCriteria(cl);
if (map != null) {
Set keyset = map.keySet();
for (Object key : keyset) {
if (key == null || map.get(key) == null) {
continue;
}
// 如果对应的值是字符串类型，我就是用like匹配
if (map.get(key).getClass() == String.class) {
cri.add(Expression.like(key.toString(), map
.get(key)));
} else {
cri.add(Expression.eq(key.toString(), map
.get(key)));
}
}
}
if (orderstr != null) {
cri.addOrder(Order.desc(orderstr));
}
if (beginpos != null) {
cri.setFirstResult(beginpos);
} else {
cri.setFirstResult(0);
}
if (count != null) {
cri.setMaxResults(count);
}
return (List<E>) cri.list();
}
});
return list;
}
/**
* 分页查询 ，传一个hql语句. 和一个参数数组.
*
* @param hql
* hql语句
* @param bindValue
* 数组参数
* @param first
* 分页起点
* @param count
* 每页的记录总数
* @return 返回List集合
*/
public List pageQuery(final String hql, final Object[] bindValue,
final Integer first, final Integer count) {
List list = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery(hql);
if (bindValue != null && bindValue.length >= 1) {
Type[] types = typesFactory(bindValue);
query.setParameters(bindValue, types);
}
if (first != null && first.intValue() >= 0) {
query.setFirstResult(first);
if (count != null && count.intValue() >= 0)
query.setMaxResults(count);
}
List result = query.list();
return result;
}
});
return list;
}
/**
* 获取对象对应参数的类型
*
* @param bindValue
* @return
*/
private final Type[] typesFactory(Object[] bindValue) {
int count = bindValue.length;
Type[] types = new Type[count];
for (int i = 0; i < count; i++) {
if (bindValue[i].getClass().getName().endsWith("String")) {
types[i] = new StringType();
} else if (bindValue[i].getClass().getName().endsWith("Integer")) {
types[i] = new IntegerType();
} else if (bindValue[i].getClass().getName().endsWith("Float")) {
types[i] = new FloatType();
} else if (bindValue[i].getClass().getName().endsWith("Date")) {
types[i] = new DateType();
}
}
return types;
}
/**
* 查询某个类的全部对象
*
* @param <E>
* @param c
* 查询类的class
* @return
*/
public <E> List<E> selectAllObject(final Class c) {
List<E> list = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria cri = session.createCriteria(c);
List<E> list = cri.list();
return list;
}
});
return list;
}
/**
* 根据 主键 查询某个对象
*
* @param <E>
* @param c
* @param id
* @return
*/
public <E> E selectObjectById(final Class c, final Serializable id) {
E e = (E) this.getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
E aa = (E) session.get(c, id);
return aa;
}
});
return e;
}
/**
* 根据条件,查询一个对象.
*
* @param <E>
* @param c
* @param map
* map放条件查询参数 调用的时候?: String username="xiejin" ;
* map.put("username",username);
* @return
*/
public <E> E selectUniqueObject(final Class c, final Map map) {
E e = (E) this.getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria cri = session.createCriteria(c);
cri.add(Expression.allEq(map));
return (E) cri.uniqueResult();
}
});
return e;
}
/**
* 带条件的查询.返回list集合
*
* @param <E>
* @param c
* @param map
* 根据map里面放置的参数
* @return 返回一个list对象集合
*/
public <E> List<E> seletcObjectByMap(final Class c, final Map map) {
List<E> list = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Criteria cri = session.createCriteria(c);
cri.add(Expression.allEq(map));
List<E> e = cri.list();
return e;
}
});
return list;
}
/**
* 一个泛型方法:支持条件查询,排序,分页查询.
*
* @param <E>
* 类别
* @param cl
* 需要查询的类
* @param map
* map中put("uname","谢晋"); null or map
* 模糊查询用("uname","%"+uname+"%")
* @param orderStr
* 是否需要排序(升序) null or "属性字段"
* @param beginIndex
* 分页开始位置 null or Integer
* @param count
* 记录条数 null or Integer
* @return
*/
@SuppressWarnings("unchecked")
public <E> List<E> selectObjInfoByMapCondtionAndOrderAndPageQuery(
final Class cl, final Map map, final String orderStr,
final Integer beginIndex, final Integer count) {
List e = this.getHibernateTemplate().executeFind(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
// 使用 Criteria查询 代替复杂得hql语句;
Criteria cri = session.createCriteria(cl);
// 对map进行判断
if (map != null) {
Set keyset = map.keySet();
for (Object key : keyset) {
// 如果为空则继续遍历
if (key == null || map.get(key) == null) {
continue;
}
// 如果是参数值是字符串则用模糊查询. like 匹配
if (map.get(key).getClass() == String.class) {
cri.add(Expression.like(key.toString(), map
.get(key)));
} else {
cri.add(Expression.eq(key.toString(), map
.get(key)));
}
}
}
// 对orderStr 进行判断
if (orderStr != null) {
cri.addOrder(Order.asc(orderStr));// 升序
}
// 对分页 进行判断
if (beginIndex != null && beginIndex.intValue() >= 0) {
cri.setFirstResult(beginIndex.intValue());
if (count != null && count.intValue() >= 0) {
cri.setMaxResults(count.intValue());
}
}
return (List<E>) cri.list();
}
});
return e;
}
}
分享到：
相关推荐
通用DAO（Data Access Object）是一种设计模式，用于封装对数据库的操作，提供一套可重用的接口，以简化数据访问层的开发工作。本篇将深入探讨Hibernate中的通用DAO实现及其相关知识点。 **一、Hibernate简介** ...
然而，为了提高代码的复用性和可维护性，通常会设计一个通用DAO（Data Access Object）层来处理基本的数据操作。"hibernate不是泛型的通用DAo1"这个标题暗示了我们讨论的是一种非泛型化的DAO实现，可能是因为开发者...
综上所述，Hibernate通用DAO设计的核心在于抽象出共性的数据库操作，并通过泛型和继承等面向对象设计原则，达到代码复用的目的。这样不仅可以降低开发难度，还能提升系统的可维护性，对于大型项目尤其重要。通过学习...
通常，开发者会创建一个基类，比如HibernateDAO，提供通用的方法，然后为每个特定的数据模型创建继承自该基类的DAO实现。 在标签中，“源码”意味着讨论可能涉及到了具体的代码实现，而“工具”可能指的是Hibernate...
在SSH项目中，可以创建一个基类`HibernateDAO`，包含如`save()`, `update()`, `delete()`, `getById()`等基本操作，然后其他特定业务的DAO继承自这个基类，以实现通用性和重用性。 3. **设计模式的应用**：通用DAO...
3. **BaseDao封装**：BaseDao是一般用于数据访问层的基类，它包含了通用的CRUD操作。在这个项目中，BaseDao可能已经定义了如`save()`, `update()`, `delete()`, `findById()`, `findAll()`等方法，以供其他特定的DAO...
这个类展示了如何使用Hibernate的简单操作，如`get()`, `add()`, `del()`, 和 `update()`方法，这些方法调用了基类的抽象方法，进一步简化了DAO层的实现。 在Hibernate中，对象的状态分为瞬时状态、持久状态和脱管...
本主题主要探讨的是如何使用泛型和反射技术来实现Hibernate对DAO的封装，从而创建一个通用的DAO模板，减少开发者重复编写CRUD（Create、Read、Update、Delete）操作的工作。 首先，我们需要理解DAO（Data Access ...
BaseHibernateDAO是基于Hibernate框架的一个基类，它封装了常见的数据库操作，如增删查改（CRUD）。通过继承这个基类，开发者可以快速创建自定义的DAO实现，避免重复编写相似的代码。BaseHibernateDAO通常会包含以下...
在软件开发过程中，数据访问对象（DAO）模式是一种常见的设计模式，用于封装对数据库的操作，以提高代码的可重用性和可维护性。本主题主要介绍如何利用Eclipse的Java Text Templates (JET)功能自动生成DAO源代码，...
1. **抽象基类**：创建一个通用的DAO基类，包含一些通用的数据库操作，如执行SQL查询、事务管理等。子类可以继承这个基类并覆盖或添加特定的数据库操作。 2. **模板方法设计模式**：利用模板方法模式，将共有的操作...
首先，`HibernateBaseDao.java`是基础的Hibernate DAO类，它提供了对Hibernate操作的基本封装。这个类通常会包含如打开和关闭Session、事务管理等通用功能。例如，它可能包含以下方法： 1. `getSessionFactory()`：...
DAO是一种设计模式，用于封装对数据库的操作，将数据访问层与业务逻辑层分离，提高代码的可重用性和可维护性。 首先，我们来看`BaseDAO.java`，这个文件通常会定义一个抽象基类，它包含了一些通用的数据库操作方法...
在这个例子中，`HibernateDaoSupport`是Hibernate提供的一个基类，它提供了与SessionFactory的交互，使得我们可以很方便地进行数据库操作。通过这种方式，我们可以通过泛型来处理不同的实体类，而无需为每个实体类...
泛型DAO允许我们创建一个通用的DAO接口或基类，然后针对不同的数据实体（Entity）进行扩展。例如，我们可以定义一个基础的`GenericDAO, ID>`接口，其中`T`代表实体类型，`ID`是主键类型。这样的设计可以避免因类型...
- **继承与抽象**：创建一个基类DAO，将共性功能如连接管理、事务处理等抽象出来，子类只负责特定数据表的业务逻辑。 - **模板方法设计模式**：在基类中定义模板方法，子类只提供特定的实现细节。 - **ORM框架**...
`HibernateTemplate`封装了Hibernate的会话管理，提供了一套便捷的API，而`HibernateDaoSupport`则为DAO实现提供了一个基类，包含了SessionFactory的初始化和关闭。 - **MyBatis**：Spring整合MyBatis时，可以通过...
当多个DAO操作需要作为一个原子操作执行时，可以在DAO层开始和结束事务，确保数据的一致性。 4. **异常处理**：DAO层通常会捕获并包装数据库相关的异常，比如SQL异常，转换成自定义的业务异常，以便上层应用能更好...
本项目实现了自定义分页架构的封装，自定义后台验证框架，自定义权限验证，自封装hibernate的dao基类，使用简单方便，大大减少了开发中的繁琐任务和冗余代码。由于时间关系，可能项目中有很多功能没有开发完成，大家...
- 通过继承基类或使用特定框架（如Spring）来实现DAO接口。 - 示例代码中的`DepartmentDao extends BaseDao implements IBaseDao`实现了`IDepartment`接口。 ### Spring集成 **9. Spring集成：** - Spring框架...