发布一篇Spring+Hibernate完成的DAO层大众类

首先第一点：jsp，servlet,javabean这些最基本的，嘿嘿，就算你是高手的话，在大行的企业级应用的话还是需要框架的，一个好的框架确实能构解决许多问题。
此EntityDao接口与EntityDaoImpl完成类,可代替了我们平常写的UserDao,NewsDao,CompanyDao等等,可间接供Service层挪用.个中完成类的代码以下:
/**　
　*Copyright2009-1012theoriginalauthororauthors.
　*MyBlogsite:http://www.blogjava.net/rongxh7
　*/

packagerong.common.dao;
importjava.io.Serializable;
importjava.sql.SQLException;
importjava.util.List;
importorg.hibernate.Criteria;
importorg.hibernate.HibernateException;
importorg.hibernate.Query;
importorg.hibernate.Session;
importorg.hibernate.criterion.Criterion;
importorg.hibernate.criterion.Order;
importorg.hibernate.criterion.Restrictions;
importorg.springframework.orm.hibernate3.HibernateCallback;
importorg.springframework.stereotype.Repository;
importrong.common.utils.Pager;
importrong.util.MyHibernateDaoSupport;

/***//**
　*Dao层接口的完成类
　*很多人习气依据未几的营业逻辑界说分歧的DAO层接口，如UserDao,NewsDao,CompanyDao等等，
　*如许常常使得编码量非常复杂，并且带来了保护的坚苦，因而，抽取此DAO层接口，收录年夜部分
　*DAO层必需的办法，以供Service层挪用。
　*@authorrongxinhua
　*@version1.0
　*@param<T>范型，指实体类
　*@param<PK>范型，指实体类主键的数据范例，如Integer,Long
　*@seerong.common.dao.EntityDao
　*/

@Repository(value="entityDao")
publicclassEntityDaoImpl<T,PKextendsSerializable>extendsMyHibernateDaoSupportimplementsEntityDao<T,PK>{

　　　/***//**
　　　　*保留实体
　　　　*包含增加和修正
　　　　*@paramt实体对象
　　　　*/
　　　publicvoidsaveOrUpdate(Tt){
　　　　　　　getHibernateTemplate().saveOrUpdate(t);
　　　}

　　　/***//**
　　　　*更新实体
　　　　*可用于增加、修正、删除操纵
　　　　*@paramhql更新的HQL语句
　　　　*@paramparams参数,可有项目或多项目,取代Hql中的"?"号
　　　　*/
　　　publicvoidupdate(finalStringhql,finalObjectparams){
　　　　　　　getHibernateTemplate().execute(newHibernateCallback(){

　　　　　　　　　　　publicObjectdoInHibernate(Sessionsession)
　　　　　　　　　　　　　　　　　　　throwsHibernateException,SQLException{
　　　　　　　　　　　　　　　Queryquery=session.createQuery(hql);
　　　　　　　　　　　　　　　for(inti=0;i<params.length;i++){
　　　　　　　　　　　　　　　　　　　query.setParameter(i,params[i]);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　query.executeUpdate();
　　　　　　　　　　　　　　　returnnull;
　　　　　　　　　　　}
　　　　　　　});
　　　}

　　　/***//**
　　　　*删除实体
　　　　*@paramt实体对象
　　　　*/
　　　publicvoiddelete(Tt){
　　　　　　　getHibernateTemplate().delete(t);
　　　}

　　　/***//**
　　　　*删除实体
　　　　*@paramentityClass实体类名
　　　　*@paramid实体的ID
　　　　*/
　　　publicvoiddelete(Class<T>entityClass,PKid){
　　　　　　　getHibernateTemplate().delete(get(entityClass,id));
　　　}

　　　/***//**
　　　　*单查实体
　　　　*@paramentityClass实体类名
　　　　*@paramid实体的ID
　　　　*@return实体对象
　　　　*/
　　　@SuppressWarnings("unchecked")
　　　publicTget(Class<T>entityClass,PKid){
　　　　　　　return(T)getHibernateTemplate().get(entityClass,id);
　　　}

　　　/***//**
　　　　*查询全体纪录列表
　　　　*@paramentityClass实体类名
　　　　*@parampropertyName排序的参照属性
　　　　*@paramisAsc排序体例
　　　　*@paramcriterions查询前提,可为0项或恣意多项目
　　　　*@return纪录List集
　　　　*/
　　　publicList<T>findAll(finalClass<T>entityClass,finalStringpropertyName,finalbooleanisAsc,finalCriterioncriterions){
　　　　　　　intfirstResult=0;
　　　　　　　intmaxResults=0;　//设置为0,则暗示查询全体纪录
　　　　　　　returnfindByCriteria(entityClass,propertyName,isAsc,firstResult,maxResults,criterions);
　　　}

　　　/***//**
　　　　*查询列表
　　　　*@paramentityClass实体类名
　　　　*@parampropertyName排序的参照属性
　　　　*@paramisAsc排序体例,true暗示升序,false暗示降序,当propertyName赋值为null时,此参数有效
　　　　*@paramfirstResult入手下手纪录序号
　　　　*@parammaxResults最年夜纪录数
　　　　*@paramcriterions查询前提,可有0项或恣意多项目
　　　　*@return纪录List集
　　　　*/
　　　@SuppressWarnings("unchecked")
　　　publicList<T>findByCriteria(finalClass<T>entityClass,finalStringpropertyName,finalbooleanisAsc,finalintfirstResult,finalintmaxResults,finalCriterioncriterions){
　　　　　　　List<T>list=(List<T>)getHibernateTemplate().execute(newHibernateCallback(){

　　　　　　　　　　　publicObjectdoInHibernate(Sessionsession)
　　　　　　　　　　　　　　　　　　　throwsHibernateException,SQLException{
　　　　　　　　　　　　　　　Criteriacriteria=session.createCriteria(entityClass);
　　　　　　　　　　　　　　　//按属性前提查询
　　　　　　　　　　　　　　　for(Criterioncriterion:criterions){
　　　　　　　　　　　　　　　　　　　criteria.add(criterion);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　//按某个属性排序
　　　　　　　　　　　　　　　if(null!=propertyName){
　　　　　　　　　　　　　　　　　　　if(isAsc){
　　　　　　　　　　　　　　　　　　　　　　　criteria.addOrder(Order.asc(propertyName));
　　　　　　　　　　　　　　　　　　　}else{
　　　　　　　　　　　　　　　　　　　　　　　criteria.addOrder(Order.desc(propertyName));
　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　//用于分页查询
　　　　　　　　　　　　　　　if(maxResults!=0){
　　　　　　　　　　　　　　　　　　　criteria.setFirstResult(firstResult);
　　　　　　　　　　　　　　　　　　　criteria.setMaxResults(maxResults);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　List<T>list=criteria.list();
　　　　　　　　　　　　　　　returnlist;
　　　　　　　　　　　}
　　　　　　　});
　　　　　　　returnlist;
　　　}

　　　/***//**
　　　　*查询总纪录数
　　　　*@paramentityClass实体类名
　　　　*@paramcriterions查询前提,可有0项或恣意多项
　　　　*@return总纪录数
　　　　*/
　　　publicintfindCountsByCriteria(finalClass<T>entityClass,finalCriterioncriterions){
　　　　　　　　　　　inttotalCounts=(Integer)getHibernateTemplate().execute(newHibernateCallback(){

　　　　　　　　　　　publicObjectdoInHibernate(Sessionsession)
　　　　　　　　　　　　　　　　　　　throwsHibernateException,SQLException{
　　　　　　　　　　　　　　　Criteriacriteria=session.createCriteria(entityClass);
　　　　　　　　　　　　　　　//按属性前提查询
　　　　　　　　　　　　　　　for(Criterioncriterion:criterions){
　　　　　　　　　　　　　　　　　　　criteria.add(criterion);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　inttotalCounts=criteria.list().size();
　　　　　　　　　　　　　　　returntotalCounts;
　　　　　　　　　　　}
　　　　　　　});
　　　　　　　returntotalCounts;
　　　}

　　　/***//**
　　　　*分页查询
　　　　*@paramentityClass实体类名
　　　　*@parampropertyName排序参照属性
　　　　*@paramisAsc排序体例,true暗示升序,false暗示降序,当propertyName赋值为null时,此参数有效
　　　　*@paramfirstResult入手下手纪录序号
　　　　*@parammaxResults最年夜纪录数
　　　　*@paramcriterions查询前提,可为0项或恣意多项目
　　　　*@return封装List和totalCounts的Pager对象
　　　　*/
　　　@SuppressWarnings("unchecked")
　　　publicPager<T>findForPager(finalClass<T>entityClass,finalStringpropertyName,finalbooleanisAsc,finalintfirstResult,finalintmaxResults,finalCriterioncriterions){
　　　　　　　inttotalCounts=findCountsByCriteria(entityClass,criterions);
　　　　　　　List<T>entityList=findByCriteria(entityClass,propertyName,isAsc,firstResult,maxResults,criterions);
　　　　　　　Pagerpager=newPager();
　　　　　　　pager.setTotalCounts(totalCounts);
　　　　　　　pager.setEntityList(entityList);
　　　　　　　returnpager;
　　　}

　　　/***//**
　　　　*依据属性值查询列表
　　　　*@paramentityClass实体类名
　　　　*@parampropertyName属性名
　　　　*@paramvalue属性值
　　　　*@returnList列表
　　　　*/
　　　publicList<T>findByProperty(Class<T>entityClass,StringpropertyName,Objectvalue){
　　　　　　　Criterioncriterion=Restrictions.eq(propertyName,value);
　　　　　　　List<T>list=findAll(entityClass,null,true,criterion);
　　　　　　　returnlist;
　　　}

　　　/***//**
　　　　*依据属性值查询单个对象
　　　　*@paramentityClass实体类名
　　　　*@parampropertyName属性名
　　　　*@paramvalue属性值
　　　　*@return实体对象
　　　　*/
　　　@SuppressWarnings("unchecked")
　　　publicTfindUniqueByProperty(finalClass<T>entityClass,finalStringpropertyName,finalObjectvalue){
　　　　　　　Tt=(T)getHibernateTemplate().execute(newHibernateCallback(){

　　　　　　　　　　　publicObjectdoInHibernate(Sessionsession)
　　　　　　　　　　　　　　　　　　　throwsHibernateException,SQLException{
　　　　　　　　　　　　　　　Criteriacriteria=session.createCriteria(entityClass).add(Restrictions.eq(propertyName,value));
　　　　　　　　　　　　　　　Tt=(T)criteria.uniqueResult();
　　　　　　　　　　　　　　　returnt;
　　　　　　　　　　　}
　　　　　　　});
　　　　　　　returnt;
　　　}

　　　/***//**
　　　　*依据属性值查询实体是不是存在
　　　　*@paramentityClass实体类名
　　　　*@parampropertyName参照的属性名
　　　　*@paramvalue属性值
　　　　*@return存在则前往true,不存在则前往false
　　　　*/
　　　publicbooleanisPropertyExist(finalClass<T>entityClass,finalStringpropertyName,finalObjectvalue){
　　　　　　　booleanisExist=(Boolean)getHibernateTemplate().execute(newHibernateCallback(){

　　　　　　　　　　　publicObjectdoInHibernate(Sessionsession)
　　　　　　　　　　　　　　　　　　　throwsHibernateException,SQLException{
　　　　　　　　　　　　　　　Criteriacriteria=session.createCriteria(entityClass).add(Restrictions.eq(propertyName,value));
　　　　　　　　　　　　　　　booleanisEmpty=criteria.list().isEmpty();
　　　　　　　　　　　　　　　return!isEmpty;
　　　　　　　　　　　}
　　　　　　　});
　　　　　　　returnisExist;
　　　}

　　　/***//**
　　　　*
　　　　*@paramhql查询语句
　　　　*用法如：可用于登录考证时，依据用户名、暗码等信息查询用户
　　　　*@paramparams参数数组,取代HQL中的"?"号,可有0项目或多项
　　　　*@return独一实体，前往null则暗示不存在设置的实体
　　　　*@exception假如查询的了局集不惟一,则抛非常
　　　　*/
　　　@SuppressWarnings("unchecked")
　　　publicTfindUniqueByHql(finalStringhql,finalObjectparams){

　　　　　　　Tt=(T)getHibernateTemplate().execute(newHibernateCallback(){

　　　　　　　　　　　publicObjectdoInHibernate(Sessionsession)
　　　　　　　　　　　　　　　　　　　throwsHibernateException,SQLException{
　　　　　　　　　　　　　　　Queryquery=session.createQuery(hql);
　　　　　　　　　　　　　　　for(inti=0;i<params.length;i++){
　　　　　　　　　　　　　　　　　　　query.setParameter(i,params[i]);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　Tt=(T)query.uniqueResult();
　　　　　　　　　　　　　　　returnt;
　　　　　　　　　　　}
　　　　　　　});
　　　　　　　returnt;
　　　}

　　　/***//**
　　　　*按HQL前提查询列表
　　　　*@paramhql查询语句,撑持毗连查询和多前提查询
　　　　*@paramparams参数数组,取代hql中的"?"号
　　　　*@return了局集List
　　　　*/
　　　@SuppressWarnings("unchecked")
　　　publicList<T>findByHql(Stringhql,Objectparams){
　　　　　　　Listlist=getHibernateTemplate().find(hql,params);
　　　　　　　returnlist;
　　　}

　　　/***//**
　　　　*按HQL分页查询
　　　　*@paramfirstResult入手下手纪录号
　　　　*@parammaxResults最年夜纪录数
　　　　*@paramhql查询语句,撑持毗连查询和多前提查询
　　　　*@paramparams参数数组,取代餐hql中的"?"号
　　　　*@return封装List和total的Pager对象
　　　　*/
　　　@SuppressWarnings("unchecked")
　　　publicPager<T>findForPagerByHql(finalintfirstResult,finalintmaxResults,finalStringhql,finalObjectparams){
　　　　　　　Pager<T>pager=(Pager<T>)getHibernateTemplate().execute(newHibernateCallback(){

　　　　　　　　　　　publicObjectdoInHibernate(Sessionsession)
　　　　　　　　　　　　　　　　　　　throwsHibernateException,SQLException{
　　　　　　　　　　　　　　　Queryquery=session.createQuery(hql);
　　　　　　　　　　　　　　　for(intposition=0;position<params.length;position++){
　　　　　　　　　　　　　　　　　　　query.setParameter(position,params[position]);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　inttotalCounts=query.list().size();　//总纪录数
　　　　　　　　　　　　　　　//用于分页查询
　　　　　　　　　　　　　　　if(maxResults>0){
　　　　　　　　　　　　　　　　　　　query.setFirstResult(firstResult);
　　　　　　　　　　　　　　　　　　　query.setMaxResults(maxResults);
　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　List<T>list=query.list();
　　　　　　　　　　　　　　　Pager<T>pager=newPager<T>();
　　　　　　　　　　　　　　　pager.setEntityList(list);
　　　　　　　　　　　　　　　pager.setTotalCounts(totalCounts);
　　　　　　　　　　　　　　　returnpager;
　　　　　　　　　　　}
　　　　　　　});
　　　　　　　returnpager;
　　　}

}
文章http://www.blogjava.net/rongxh7

首先java功能强大的背后是其复杂性，就拿web来说，当今流行的框架有很多，什么struts，spring，jQuery等等，而这无疑增加了java的复杂性。

任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言

Java 不同于一般的编译执行计算机语言和解释执行计算机语言。它首先将源代码编译成二进制字节码（bytecode），然后依赖各种不同平台上的虚拟机来解释执行字节码。从而实现了“一次编译、到处执行”的跨平台特性。

其实说这种话的人就如当年小日本号称“三个月拿下中国”一样大言不惭。不是Tomjava泼你冷水，你现在只是学到了Java的骨架，却还没有学到Java的精髓。接下来你得研究设计模式了。

科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

是一种语言，用以产生「小应用程序(Applet(s))

有时间再研究一下MVC结构（把Model-View-Control分离开的设计思想）

在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

Java 不同于一般的编译执行计算机语言和解释执行计算机语言。它首先将源代码编译成二进制字节码（bytecode），然后依赖各种不同平台上的虚拟机来解释执行字节码。从而实现了“一次编译、到处执行”的跨平台特性。

还好，SUN提供了Javabean可以把你的JSP中的 Java代码封装起来，便于调用也便于重用。

J2SE开发桌面应用软件比起 VC,VB,DEPHI这些传统开发语言来说，优势好象并不明显。J2ME对于初学者来说，好象又有点深奥，而且一般开发者很难有开发环境。

还好，SUN提供了Javabean可以把你的JSP中的 Java代码封装起来，便于调用也便于重用。

让你能够真正掌握接口或抽象类的应用，从而在原来的Java语言基础上跃进一步，更重要的是，设计模式反复向你强调一个宗旨：要让你的程序尽可能的可重用。

Java是一个纯的面向对象的程序设计语言，它继承了 C++语言面向对象技术的核心。Java舍弃了C ++语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）

接着就是EJB了，EJB就是Enterprise JavaBean, 看名字好象它是Javabean，可是它和Javabean还是有区别的。它是一个体系结构，你可以搭建更安全、更稳定的企业应用。它的大量代码已由中间件（也就是我们常听到的 Weblogic,Websphere这些J2EE服务器）完成了，所以我们要做的程序代码量很少，大部分工作都在设计和配置中间件上。

象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。

所以现在应用最广泛又最好学的就是J2EE了。 J2EE又包括许多组件，如Jsp,Servlet,JavaBean,EJB,JDBC,JavaMail等。要学习起来可不是一两天的事。那么又该如何学习J2EE呢？当然Java语法得先看一看的，I/O包，Util包，Lang包你都熟悉了吗？然后再从JSP学起。