`
czpae86
  • 浏览: 720166 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

通用DAO

    博客分类:
  • JAVA
阅读更多

package base;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;

public class DAO<T extends Entity>  
{	
	private static final Log log = LogFactory.getLog(DAO.class);
	private Class<T> mytype;
	private HibernateTemplate  hibernateTemplate;
	
	public DAO(Class<T> type,HibernateTemplate temp) {
		mytype=type;
		hibernateTemplate=temp;
	}
	
	public DAO(Class<T> type) {
		mytype=type;
	}
	
    public void setHibernateTemplate(HibernateTemplate temp)
    {    
    	if(hibernateTemplate==null){this.hibernateTemplate = temp;}
    }
    
    public Class<T> getEntityClass()
	{
    	return mytype;
	}
    
    @SuppressWarnings("unchecked")
	public T loadByID(String id)
    {
    	T rt=(T) hibernateTemplate.get(mytype.getName(),id);
    	return rt;
    }
	
    public String save(T o)
    {
    	if(o==null){return "";}
    	if("".equals(o.id)){o.id=null;}    	
    	hibernateTemplate.saveOrUpdate(o);
    	return o.id;
    }
    
    public void save(final List<T> data)
    {
    	if(data==null) return;
    	for(T o : data){save(o);}
    }
    
    public void delete(String id)
    {
    	T obj=loadByID(id);
    	if(obj!=null){hibernateTemplate.delete(obj);}
    }
    
    public void delete(T o)
    {
    	if(o==null){return;}
    	hibernateTemplate.delete(o);
    }
    
    @SuppressWarnings("unchecked")
	private Object queryNum(final String hql, final Map<String, Object> args) {
		return  hibernateTemplate.execute(new HibernateCallback() {
			public Object doInHibernate(Session session)throws HibernateException {
				if(log.isDebugEnabled()){log.debug("queryNum :" + hql);}			
				Query q = session.createQuery(hql);
				if(args!=null)
				{
					for (String k : args.keySet()){
						q.setParameter(k, args.get(k));
					}
				}
				return q.uniqueResult();//q.executeUpdate()
			}
		});
	}
    
    @SuppressWarnings("unchecked")
	public int getTotalCnt(final String hqlwhere)
    {
    	String hql = "select count(*) from " + mytype.getName() + " where " + hqlwhere;
    	if(log.isDebugEnabled()){log.debug("getTotalCnt :"+hql);}
    	Object rt=  queryNum(hql,new HashMap());	 
		return Integer.parseInt(rt.toString());
    }
    
    public int getTotalCnt(final String hqlwhere, final Map<String, Object> args)
    {
    	String hql = "select count(*) from " + mytype.getName() + " where " + hqlwhere;
    	if(log.isDebugEnabled()){log.debug("getTotalCnt :"+hql);}
    	Object rt=  queryNum(hql,args);	 
    	return Integer.parseInt(rt.toString());
   	}

    @SuppressWarnings("unchecked")
	public List<T> load(final String hqlwhere)
    {
	 	List rt=(List) hibernateTemplate.execute(
			new HibernateCallback() {
				public Object doInHibernate(Session session)throws HibernateException {	    		 	    			
					String hql = "from " + mytype.getName() + " where " + hqlwhere;
					if(log.isDebugEnabled()){log.debug("load :"+hql);}
		  		  	return  session.createQuery(hql).list();
		  		}
		});
	 	return (List<T>)rt;
    }

    @SuppressWarnings("unchecked")
	public List<T> load(final String hqlwhere,final int start,final int size)
    {
    	 List rt=(List) hibernateTemplate.execute(
    		new HibernateCallback() {
    		public Object doInHibernate(Session session)throws HibernateException {
    		 	String hql = "from " + mytype.getName() + " where " + hqlwhere;
    			if(hql.indexOf("order by")<0) hql=hql+" order by lastModifiedDate DESC";
    			if(log.isDebugEnabled()){log.debug("load :"+hql);}
      		    Query q=session.createQuery(hql);
      		    q.setMaxResults(size);
      		    q.setFirstResult(start);
      		    return  q.list();
      		}
   		});
    	return (List<T>)rt;
    }
    
    @SuppressWarnings("unchecked")
	public List<T> load(final String hqlwhere,final Map<String, Object> args,final int start,final int size)
    {
    	 List rt=(List) hibernateTemplate.execute(
    		new HibernateCallback() {
	    		public Object doInHibernate(Session session)throws HibernateException {    	    		 	    			
	    			String hql = "from " + mytype.getName() + " where " + hqlwhere;
	    			if(hql.indexOf("order by")<0) hql=hql+" order by lastModifiedDate DESC";
	    			if(log.isDebugEnabled()){log.debug("load :"+hql);}
	      		    Query q=session.createQuery(hql);
	      		    q.setMaxResults(size);
	      		    q.setFirstResult(start);
	      		  	for (String k : args.keySet()){
	      		  		q.setParameter(k, args.get(k));
	      		  	}
	      		  	return q.list();
	      		}
	   		});
    	 return (List<T>)rt;
    }

    @SuppressWarnings("unchecked")
	public List<T> load(final String hqlwhere, final Map<String, Object> args) {
		 List rt=(List)hibernateTemplate.execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException {
				String hql = "from " + mytype.getName() + " where " + hqlwhere;
				if(log.isDebugEnabled())	log.debug("load :" + hql);
				Query q = session.createQuery(hql);
				for (String k : args.keySet()){
					q.setParameter(k, args.get(k));
				}
				return q.list();
			}
		});
		return (List<T>)rt;
	}
	   
    @SuppressWarnings("unchecked")
	public Object execute(final String hql, final Map<String, Object> args) {
		return  hibernateTemplate.execute(new HibernateCallback() {
			public Object doInHibernate(Session session)throws HibernateException {
				if(log.isDebugEnabled()) log.debug("execute :" + hql);				
				Query q = session.createQuery(hql);
				if(args!=null)
				{
					for (String k : args.keySet()){
						q.setParameter(k, args.get(k));
					}
				}
				return q.executeUpdate();
			}
		});
	}
	    
    @SuppressWarnings("unchecked")
	public void delete(List<T> list) {
    	List<String> ids=new ArrayList<String>();    
		for (int i=0 ; i<list.size();i++){
		  T data=list.get(i);
		  if(data!=null&&data.id!=null) ids.add(data.id);
		  //delete(list.get(i));
		}
		int j=0;
		if(ids.size()<1) return;
		String[] tp=new String[ids.size()];	  
		for(String id :ids)
		{
			tp[j++]=new String(id);
		}
		deleteByIds(tp);
	}
    
    @SuppressWarnings("unchecked")
	public void deleteByIds(String[] ids) {		
		  if(ids.length<1) return;
		  StringBuilder sb=new StringBuilder();
		  sb.append("id in (");
		  for(int j=0;j< ids.length;j++)
		  {
			  sb.append("'"+ids[j]+"'");
			  if(j<(ids.length-1))  sb.append(",");
		  }
		  sb.append(")");
		  execute("delete "+mytype.getName()+" where "+sb.toString(),null);
	}
    
    public void deleteByIds(String ids){
    	if(ids==null||ids.equals("")) return;
    	String[] idArr = ids.split(",");
    	StringBuilder sb=new StringBuilder();
		sb.append("id in (");
		for(int j=0;j< idArr.length;j++)
		{
			sb.append("'"+idArr[j]+"'");
		   if(j<(idArr.length-1))  sb.append(",");
		}
		sb.append(")");
		execute("delete "+mytype.getName()+" where "+sb.toString(),null);
    }
	@SuppressWarnings("unchecked")
	public void deleteAll() {
		execute("delete "+mytype.getName(),null);
			
	}
	
	@SuppressWarnings("unchecked")
	public List<T> loadAll(){		
		return hibernateTemplate.loadAll(mytype);
	}
	
	@SuppressWarnings("unchecked")
	public int getTotal(){
		List<T> list = hibernateTemplate.loadAll(mytype);
		return list.size();
	}
}
 
0
0
分享到:
评论
2 楼 czpae86 2010-11-18  
bill9 写道
Entity 是 那个包中的

这个是一个javabean,实体类 自己定义一个就可以了,根据这个DAO,这个实体类里面要有geter seter id
1 楼 bill9 2010-11-17  
Entity 是 那个包中的

相关推荐

    java 基于泛型与反射的通用 DAO

    在实现通用DAO时,反射通常用于动态调用数据库操作的方法,比如SQL查询。例如,在`UsersDAO.java`中,可能有以下代码: ```java public class UsersDAO extends BaseDao&lt;Users&gt; { @Override public void save...

    C#特性标签实现通用Dao层

    在C#编程中,"通用Dao层"是一个常见的设计模式,用于封装数据库操作,使得业务逻辑层能够专注于处理业务规则,而无需关心底层数据访问的细节。本篇将重点探讨如何利用C#的特性(Attribute)标签来实现这一目标,同时...

    泛型通用DAO,可以很简化DAO层的代码

    泛型通用DAO是这种模式的一种优化,它利用了Java 5.0引入的泛型和反射机制,大大简化了DAO层的编码工作,提高了代码的可复用性和可维护性。 泛型是Java中的一种类型系统扩展,它允许在编译时声明参数化的类型,从而...

    JDBCTemplate+JavaPOJO实现通用DAO

    在这个"JDBCTemplate+JavaPOJO实现通用DAO"的项目中,我们将探讨如何利用这两者构建一个通用的DAO层。 首先,Java POJO(Plain Old Java Object)是指那些没有特殊约束的简单Java对象,通常用于表示数据库中的实体...

    java ssh通用DAO另类实现示例

    本示例将探讨一个通用DAO的另类实现方法,旨在提高代码复用性和简化开发过程。 首先,理解SSH框架中的DAO设计模式至关重要。DAO是一种设计模式,它为应用程序提供了一种抽象的接口,以便与数据库进行交互,同时避免...

    hibernate4 通用dao,service

    标题中的“hibernate4 通用dao,service”指的是在Java开发中使用Hibernate框架实现的通用数据访问对象(DAO)和业务服务层(Service)。Hibernate是一个流行的对象关系映射(ORM)工具,它允许开发者使用面向对象的...

    Hibernate通用Dao设计。

    本篇文章将深入探讨Hibernate的通用Dao设计,帮助开发者理解如何利用Hibernate提高代码复用性和可维护性。 在传统的Java应用程序中,DAO(Data Access Object)层是用于封装数据库访问逻辑的地方,它隔离了业务逻辑...

    ssm(Spring-springMVC-Mybatis)通用Dao框架

    SSM(Spring-SpringMVC-Mybatis)通用Dao框架是一个常见的Java Web开发架构,它整合了Spring、SpringMVC和Mybatis三个强大的开源框架,为开发者提供了便捷的数据访问和业务逻辑处理能力。这个框架的使用可以显著提高...

    高仿JPA自定义通用DAO

    自定义通用DAO实现基本的CRUD,比如: public interface BaseDao&lt;T&gt; { int insert(T obj) throws Exception; int update(T obj) throws Exception; int deleteByPrimaryKey(Object key) throws Exception; int ...

    Java源代码一个简单的通用DAO实现(基于hibernate)

    Java源代码 一个简单的通用DAO实现 (基于hibernate)面向应用层按POJO类缓存hibernate的session对象.使用举例: DAO dao = DAOFactory.getDAO(POJO.class);//获得一个全局类单例的DAO实例 dao.save(pojo); 你也可以...

    Hibernate_通用DAO模式,一个写好的dao层

    本资源“Hibernate_通用DAO模式”提供了一种适用于不同类型表单的DAO实现,基于SSH(Struts2、Spring、Hibernate)框架,特别强调简洁、易懂和高可移植性。 首先,SSH框架是Java Web开发中的经典组合,Struts2负责...

    Hibernate 原生通用DAO

    **Hibernate原生通用DAO**是基于Hibernate框架设计的一种简化数据访问操作的方式,它模仿了Spring框架中的`HibernateTemplate`类,旨在提供一个简单易用的DAO(Data Access Object)层,方便开发人员进行数据库操作...

    mybatis 通用DAO 简单实现

    MyBatis 通用DAO(Data Access Object)是一种设计模式,旨在提供一种标准的方式来访问数据库,减少重复代码,提高开发效率。在Java Web开发中,MyBatis作为一个优秀的持久层框架,它支持定制化SQL、存储过程以及...

    Hibernate的通用dao

    **标题:“Hibernate的通用DAO”** 在Java编程领域,Hibernate是一个强大的对象关系映射(ORM)框架,它允许开发者以面向对象的方式处理数据库操作,从而减少了对SQL的直接依赖。通用DAO(Data Access Object)是一...

    SSH中通用dao类

    在这个场景中,"SSH中通用DAO类"指的是在SSH框架下设计和实现的可以应用于多种业务场景的数据访问对象(Data Access Object)类。 DAO层是三层架构或MVC架构中的一个重要部分,主要负责与数据库进行交互,将业务...

    Hibernate通用Dao

    通用dao,简单全面,所有dao都可以继承这个dao.

    通用数据库访问模块,通用DAO类

    通用数据库访问模块(通常称为 DAO,Data Access Object)是一种软件设计模式,用于在应用程序和数据库之间提供一个抽象层。DAO 类的主要目标是隔离业务逻辑层与数据存储层,使得应用程序可以独立于特定的数据库实现...

    hibernate不是泛型的通用DAo1

    然而,为了提高代码的复用性和可维护性,通常会设计一个通用DAO(Data Access Object)层来处理基本的数据操作。"hibernate不是泛型的通用DAo1"这个标题暗示了我们讨论的是一种非泛型化的DAO实现,可能是因为开发者...

    Mybatis整合通用Dao,Mybatis整合通用Mapper,MyBatis3.x整合通用 Mapper3.5.x

    本文将深入探讨如何将MyBatis与通用Dao(Data Access Object)和通用Mapper进行整合,以提高开发效率和代码复用性。我们将以"Mybatis整合通用Dao,Mybatis整合通用Mapper,MyBatis3.x整合通用Mapper3.5.x"为主题,...

Global site tag (gtag.js) - Google Analytics