IGenericDao.java
package com.amg.dao.base;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import com.amg.vo.PageBean;
public interface IGenericDao<T extends Serializable, ID extends Serializable> {
public abstract int findByCount(String strHQL);
public abstract ID create(T entity);
public abstract T findById(ID id);
public abstract void delete(ID id);
public abstract void update(T entity);
public abstract List<T> findAll();
public abstract List<Map> findByHQL(final String strHQL, final Object[] params);
public abstract List<T> findBySQL(final String strSQL, final Object[] params);
public abstract List<T> findByHQL_Old(final String strHQL, final Object[] params);
public abstract PageBean findByPage(final int currentPage, final int pageSize, final String strHQL, final Object[] params);
public abstract void bulkUpdate(final String strHQL, final Object[] params);
public abstract boolean executeUpdateBySession(String strSQL);
}
AGenericHibernateDao.java
package com.amg.dao.base;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.sql.SQLException;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.amg.vo.PageBean;
public class AGenericHibernateDao<T extends Serializable, ID extends Serializable>
extends HibernateDaoSupport implements IGenericDao<T, ID> {
private Class<T> persistentClass;
@SuppressWarnings("unchecked")
public AGenericHibernateDao() {
this.persistentClass = (Class<T>) ((ParameterizedType) this.getClass()
.getGenericSuperclass()).getActualTypeArguments()[0];
}
@SuppressWarnings("unchecked")
public ID create(T entity) {
return (ID) this.getHibernateTemplate().save(entity);
}
public T findById(ID id) {
return this.getHibernateTemplate().get(persistentClass, id);
}
public void delete(ID id) {
this.getHibernateTemplate().delete(findById(id));
}
public void update(T entity) {
this.getHibernateTemplate().update(entity);
}
public List<T> findAll() {
return this.getHibernateTemplate().loadAll(persistentClass);
}
public void bulkUpdate(String strHQL, Object[] params) {
if (params == null)
this.getHibernateTemplate().bulkUpdate(strHQL);
this.getHibernateTemplate().bulkUpdate(strHQL, params);
}
public PageBean findByPage(final int currentPage, final int pageSize,
final String strHQL, final Object[] params) {
return this.getHibernateTemplate().execute(
new HibernateCallback<PageBean>() {
public PageBean doInHibernate(Session arg0)
throws HibernateException, SQLException {
PageBean bean = new PageBean();
Query qu = arg0.createQuery(strHQL);
for (int i = 0; i < params.length; i++) {
qu.setParameter(i, params[i]);
}
qu.setFirstResult((currentPage - 1) * pageSize);
qu.setMaxResults(pageSize);
bean.setData(qu.list());
qu = arg0.createQuery("select count(*) "
+ strHQL.substring(strHQL.toLowerCase()
.indexOf("from")));
for (int j = 0; j < params.length; j++) {
qu.setParameter(j, params[j]);
}
bean.setTotalRows(Integer.parseInt(qu.uniqueResult()
.toString()));
bean.setCurrentPage(currentPage);
bean.setPageSize(pageSize);
return bean;
}
});
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public List<java.util.Map> findByHQL(final String strHQL, final Object[] params) {
return super.getHibernateTemplate().execute(
new HibernateCallback<List<java.util.Map>>() {
public List<java.util.Map> doInHibernate(Session arg0)
throws HibernateException, SQLException {
Query query = arg0.createQuery(strHQL);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
return query.list();
}
});
}
public boolean executeUpdateBySession(String strSQL) {
Query query = this.getSession().createSQLQuery(strSQL);
return query.executeUpdate() > 0;
}
public int findByCount(final String strHQL) {
return super.getHibernateTemplate().execute(
new HibernateCallback<Integer>() {
public Integer doInHibernate(Session arg0)
throws HibernateException, SQLException {
Query query = arg0.createQuery(strHQL);
int count = (((Number) query.uniqueResult()).intValue());
return count;
}
});
}
public List<T> findByHQL_Old(final String strHQL, final Object[] params) {
return super.getHibernateTemplate().execute(
new HibernateCallback<List<T>>() {
@SuppressWarnings("unchecked")
public List<T> doInHibernate(Session arg0)
throws HibernateException, SQLException {
Query query = arg0.createQuery(strHQL);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
return query.list();
}
});
}
@SuppressWarnings("unchecked")
public List<T> findBySQL(final String strSQL, final Object[] params) {
return super.getHibernateTemplate().execute(
new HibernateCallback<List<T>>() {
public List<T> doInHibernate(Session arg0)
throws HibernateException, SQLException {
Query query = arg0.createQuery(strSQL);
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
return query.list();
}
});
}
}
IRecordDao.java
package com.amg.dao;
import java.util.List;
import com.amg.dao.base.IGenericDao;
import com.amg.po.Record;
public interface IRecordDao extends IGenericDao<Record, Integer> {
public List<?> findBySql_totalTypeCount(String sql,Class clas);
public List<?> findBySql_totalStrutedCount(String sql,Class clas);
//public List<?> findBySql_totalCountDetail(String sql,Class clas);
public List<?> find2VoBySql(String sql,Class cls);
public List<?> findBySql_totalTCountDetail(String sql, Class clas);
public List<?> findBySql_totalSCountDetail(String sql, Class clas);
public List<?> findBySql_totalTypeCountByDay(String sql, Class clas);
}
RecordDaoImpl.java
package com.amg.dao.impl;
import java.sql.SQLException;
import java.util.List;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.transform.Transformers;
import org.springframework.orm.hibernate3.HibernateCallback;
import com.amg.dao.IRecordDao;
import com.amg.dao.base.AGenericHibernateDao;
import com.amg.po.Record;
public class RecordDaoImpl extends AGenericHibernateDao<Record, Integer>
implements IRecordDao {
public List<?> findBySql_totalTypeCount(final String sql, final Class clas) {
return super.getHibernateTemplate().execute(
new HibernateCallback<List<?>>() {
public List<?> doInHibernate(Session session)
throws HibernateException, SQLException {
return session
.createSQLQuery(sql)
//.addScalar("createTime", Hibernate.STRING)
.addScalar("typeCount", Hibernate.INTEGER)
//.addScalar("structedCount", Hibernate.INTEGER)
.setResultTransformer(
Transformers.aliasToBean(clas)).list();
}
});
}
public List<?> find2VoBySql(String sql, Class cls) {
// TODO Auto-generated method stub
return null;
}
public List<?> findBySql_totalStrutedCount(final String sql, final Class clas) {
return super.getHibernateTemplate().execute(
new HibernateCallback<List<?>>() {
public List<?> doInHibernate(Session session)
throws HibernateException, SQLException {
return session
.createSQLQuery(sql)
//.addScalar("createTime", Hibernate.STRING)
//.addScalar("typeCount", Hibernate.INTEGER)
.addScalar("structedCount", Hibernate.INTEGER)
.setResultTransformer(
Transformers.aliasToBean(clas)).list();
}
});
}
public List<?> findBySql_totalTCountDetail(final String sql, final Class clas) {
return super.getHibernateTemplate().execute(
new HibernateCallback<List<?>>() {
public List<?> doInHibernate(Session session)
throws HibernateException, SQLException {
return session
.createSQLQuery(sql)
.addScalar("createTime", Hibernate.STRING)
.addScalar("baseUrlCount", Hibernate.INTEGER)
//.addScalar("structedUrlCount", Hibernate.INTEGER)
.setResultTransformer(
Transformers.aliasToBean(clas)).list();
}
});
}
public List<?> findBySql_totalSCountDetail(final String sql, final Class clas) {
return super.getHibernateTemplate().execute(
new HibernateCallback<List<?>>() {
public List<?> doInHibernate(Session session)
throws HibernateException, SQLException {
return session
.createSQLQuery(sql)
.addScalar("createTime", Hibernate.STRING)
//.addScalar("baseUrlCount", Hibernate.INTEGER)
.addScalar("structedUrlCount",
Hibernate.INTEGER)
.setResultTransformer(
Transformers.aliasToBean(clas)).list();
}
});
}
public List<?> findBySql_totalTypeCountByDay(final String sql, final Class clas) {
// TODO Auto-generated method stub
return super.getHibernateTemplate().execute(
new HibernateCallback<List<?>>() {
public List<?> doInHibernate(Session session)
throws HibernateException, SQLException {
return session
.createSQLQuery(sql)
.addScalar("createTime", Hibernate.STRING)
.addScalar("typeCount", Hibernate.INTEGER)
//.addScalar("structedCount", Hibernate.INTEGER)
.setResultTransformer(
Transformers.aliasToBean(clas)).list();
}
});
}
}
IRecordBiz.java
package com.amg.biz;
import java.util.List;
import com.amg.po.Record;
import com.amg.vo.PageBean;
public interface IRecordBiz {
public abstract int findByCount(String strHQL);
public abstract PageBean findByPage(final int currentPage, final int pageSize, final String strHQL, final Object[] params);
public abstract void addRecord(final Record record);
public abstract void deleteRecord(final int id);
public abstract Record findById(final int id);
public abstract void updateRecord(final Record record);
public abstract List<Record> findAll();
public abstract List<java.util.Map> findByHQL(final String strHQL, final Object[] params);
public abstract List<Record> findBySQL(final String strHQL, final Object[] params);
public abstract List<Record> findByHQL_Old(final String strHQL, final Object[] params);
public List<?> findBySql_totalTypeCount(String sql,Class clas);
public List<?> findBySql_totalStrutedCount(String sql,Class clas);
public List<?> findBySql_totalTCountDetail(String sql,Class clas);
public List<?> findBySql_totalSCountDetail(String sql,Class clas);
public List<?> find2VoBySql(String sql,Class clas);
public List<?> findBySql_totalTypeCountByDay(String sql, Class clas);
}
RecordBizImpl.java
package com.amg.biz.impl;
import java.util.List;
import com.amg.biz.IRecordBiz;
import com.amg.dao.IRecordDao;
import com.amg.po.Record;
import com.amg.vo.PageBean;
public class RecordBizImpl implements IRecordBiz {
private IRecordDao recordDao;
public void setRecordDao(IRecordDao RecordDao) {
this.recordDao = RecordDao;
}
public PageBean findByPage(final int currentPage, final int pageSize,
final String strHQL, final Object[] params) {
// String strHQL = "select d from Record as d order by d.Recordno";
// Object[] params = new Object[]{};
return this.recordDao.findByPage(currentPage, pageSize, strHQL, params);
}
public void addRecord(Record Record) {
this.recordDao.create(Record);
}
public void deleteRecord(int Recordno) {
this.recordDao.delete(Recordno);
}
public void updateRecord(Record Record) {
this.recordDao.update(Record);
}
public Record findById(int Recordno) {
return this.recordDao.findById(Recordno);
}
public List<Record> findAll() {
return this.recordDao.findAll();
}
public List<java.util.Map> findByHQL(String strHQL, Object[] params) {
return this.recordDao.findByHQL(strHQL, params);
}
public int findByCount(String strHQL) {
return this.recordDao.findByCount(strHQL);
}
public List<Record> findByHQL_Old(String strHQL, Object[] params) {
return this.recordDao.findByHQL_Old(strHQL, params);
}
public List<Record> findBySQL(String strSQL, Object[] params) {
return this.recordDao.findBySQL(strSQL, params);
}
public List<?> findBySql_totalTypeCount(String sql, Class clas) {
return this.recordDao.findBySql_totalTypeCount(sql, clas);
}
public List<?> find2VoBySql(String sql, Class clas) {
return this.recordDao.find2VoBySql(sql, clas);
}
public List<?> findBySql_totalStrutedCount(String sql, Class clas) {
return this.recordDao.findBySql_totalStrutedCount(sql, clas);
}
public List<?> findBySql_totalTCountDetail(String sql, Class clas) {
// TODO Auto-generated method stub
return this.recordDao.findBySql_totalTCountDetail(sql, clas);
}
public List<?> findBySql_totalSCountDetail(String sql, Class clas) {
return this.recordDao.findBySql_totalSCountDetail(sql, clas);
}
public List<?> findBySql_totalTypeCountByDay(String sql, Class clas) {
// TODO Auto-generated method stub
return this.recordDao.findBySql_totalTypeCountByDay(sql, clas);
}
}
相关推荐
基于泛型的通用Dao接口和Hibernate的实现 基于泛型的通用Dao接口是指使用泛型来实现数据访问对象（DAO）的接口，主要是在使用 Hibernate 或 JPA 时使用。泛型可以使得DAO接口更灵活、更通用。 泛型Dao接口的优点：...
然而，每个实体类通常都需要一个对应的DAO接口和实现类，这可能导致大量的重复代码。为了解决这个问题，我们可以通过设计一个通用的Hibernate DAO来减少重复工作。 1. **通用Dao的设计思想** - **继承机制**：创建...
标题中的“hibernate4 通用dao,service”指的是在Java开发中使用Hibernate框架实现的通用数据访问对象（DAO）和业务服务层（Service）。Hibernate是一个流行的对象关系映射（ORM）工具，它允许开发者使用面向对象的...
通用dao,简单全面,所有dao都可以继承这个dao.
使用这类通用DAO的优点在于减少了代码冗余，提高了代码复用性，使得开发人员可以更专注于业务逻辑，而不是数据库操作。但同时，由于是通用化设计，可能无法满足所有特定业务场景的需求，需要在实际使用时进行适当的...
spring集成hibernate通用dao，泛型，server都可以调用
2. **实现接口**：接着，创建一个实现该接口的类，如`HibernateDaoImpl<T>`，并利用Hibernate的Session接口来完成实际的数据库操作。这里需要注入SessionFactory实例，通常通过Spring框架的依赖注入实现。 3. **...
"hibernate 通用接口架构"是指利用Hibernate框架，通过设计DAO（Data Access Object）层的接口来实现业务逻辑与数据访问的解耦，从而提高代码的可复用性和可维护性。 首先，我们来理解DAO层的作用。DAO层作为业务...
然后，针对每一种具体的数据实体，可以创建一个实现了`BaseDao<T>`接口的DAO类，如`UserDaoImpl`，并在其实现中利用Hibernate Session进行数据库操作。 在实现过程中，通常会使用Spring的`@Repository`注解来标记...
总的来说，"Hibernate泛型DAO接口，大部分通用都已包括"意味着我们已经定义了一套完整的、适用于多种实体类的DAO操作，通过泛型减少代码冗余，提高了代码的可复用性。同时，通过`DaoUtil`这样的工具类，我们可以更...
**hibernate通用DAO（Data Access Object）**是软件开发中的一个重要概念，它主要用于数据库操作的抽象，使得业务逻辑层可以无需关注具体的SQL语句，从而实现数据访问的解耦。在Java EE应用中，Hibernate作为一款...
HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao ...
本文将围绕“Hibernate超级通用DAO”这一主题，深入探讨如何构建一个功能强大的DAO层，实现包括增、删、改、查以及多条件模糊查询在内的各种功能。 首先，Hibernate是一个流行的Java ORM（对象关系映射）框架，它...
创建一个DAO接口，定义所有需要的方法，然后创建一个实现该接口的类，如`UserDaoImpl`，在这个实现类中使用Hibernate API完成实际的数据库操作。 5. **泛型DAO**： 为了进一步提高代码的复用性，可以使用泛型来...
"hibernate不是泛型的通用DAo1"这个标题暗示了我们讨论的是一种非泛型化的DAO实现，可能是因为开发者想要避免强制继承和泛型模板。 在描述中提到，开发者在网上寻找的大多数DAO实现都是泛型的，需要继承来使用。...
4. **代码生成工具**: 使用VC6.0中的插件或独立的代码生成工具，根据模板和实体类信息，自动生成DAO接口和实现类。 5. **整合到项目中**: 将生成的DAO类导入到J2EE项目中，与业务逻辑和服务层进行集成。 在实际开发...
泛型DAO是一种设计模式，它通过定义一个通用的DAO接口或抽象类，可以适用于不同的实体类，减少了重复的代码。这种模式的核心在于利用Java的泛型特性，使得DAO方法可以处理任何类型的实体对象，而无需为每个实体类...
5. **DAO实现类生成**：DAO接口的实现类会包含实际的数据库操作逻辑，通常使用Hibernate的Session接口来执行SQL语句。这些方法使用了Hibernate的API，如`save()`, `get()`, `update()`, `delete()`等。 6. **持久化...
在传统的Hibernate DAO实现中，通常会创建一个对应于每个数据库实体的DAO接口和实现类，例如UserDAO接口和UserDAOImpl实现类。然而，这种做法可能导致大量重复的模板代码，如打开和关闭Session，事务管理等。 另类...
在传统的Hibernate使用中，针对每个实体类，我们都需要创建一个对应的Dao（Data Access Object）接口及其实现类，这无疑增加了大量重复的代码。泛型Dao的出现，就是为了解决这个问题，它允许开发者通过泛型来定义一...