博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
基于泛型DAO的Facade设计模式. - Hibernate - Java
阅读量：4221 次
发布时间：2019-05-26

本文共 19709 字，大约阅读时间需要 65 分钟。

在做管理系统时。通常基于Facade模式的系统持久化层要写许多Dao。这些dao里面的方法又是重复的，那么有没有什么好的方法来统一利用一个公共的Dao。
答案是可以的。这里我们接触到JDK5.0里面的一个新特性：泛型。
关于泛型的含义我这里就不再解释了。
下面我们以一个对用户管理和新闻管理的来示范。
首先是2个POJO。我这里只列出User  POJO。
（基于注释的Pojo）
Java代码  
  1.     
  2. package com.oa;  
  3.   
  4. import javax.persistence.Column;  
  5. import javax.persistence.Entity;  
  6. import javax.persistence.GeneratedValue;  
  7. import javax.persistence.GenerationType;  
  8. import javax.persistence.Id;  
  9. import javax.persistence.Table;  
  10.   
  11. @Entity  
  12. @Table(name = "tb_user")  
  13. public class User {  
  14.   
  15.     @Id  
  16.     @GeneratedValue(strategy = GenerationType.IDENTITY)  
  17.     private int id;  
  18.   
  19.     @Column(name = "username", length = 15)  
  20.     private String username;  
  21.   
  22.     @Column(name = "password", length = 15)  
  23.     private String password;  
  24.   
  25.     public int getId() {  
  26.         return id;  
  27.     }  
  28.   
  29.     public void setId(int id) {  
  30.         this.id = id;  
  31.     }  
  32.   
  33.     public String getUsername() {  
  34.         return username;  
  35.     }  
  36.   
  37.     public void setUsername(String username) {  
  38.         this.username = username;  
  39.     }  
  40.   
  41.     public String getPassword() {  
  42.         return password;  
  43.     }  
  44.   
  45.     public void setPassword(String password) {  
  46.         this.password = password;  
  47.     }  
  48.   
  49. }  
  50.   
  51.    
package com.oa;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.Table;@Entity@Table(name = "tb_user")public class User {	@Id	@GeneratedValue(strategy = GenerationType.IDENTITY)	private int id;	@Column(name = "username", length = 15)	private String username;	@Column(name = "password", length = 15)	private String password;	public int getId() {		return id;	}	public void setId(int id) {		this.id = id;	}	public String getUsername() {		return username;	}	public void setUsername(String username) {		this.username = username;	}	public String getPassword() {		return password;	}	public void setPassword(String password) {		this.password = password;	}}
如果按照常规的Facade模式来设计，我们的思路是：
先创建一个UserDao的接口。
Java代码  
  1. package com.oa.dao;  
  2.   
  3. import java.util.List;  
  4.   
  5. import com.oa.User;  
  6.   
  7. public interface UserDao {  
  8.     public void save(User user);  
  9.   
  10.     public void delete(int id);  
  11.   
  12.     public void update(User user);  
  13.   
  14.     public List<User> query();  
  15.   
  16.     public User get(int id);  
  17.   
  18. }  
  19.   
  20.    
package com.oa.dao;import java.util.List;import com.oa.User;public interface UserDao {	public void save(User user);	public void delete(int id);	public void update(User user);	public List
   
     query();	public User get(int id);}
然后实现这个接口：UserDaoImpl
Java代码  
  1. package com.oa.dao.impl;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.springframework.context.annotation.Scope;  
  6. import org.springframework.stereotype.Repository;  
  7.   
  8. import com.oa.User;  
  9. import com.oa.dao.MyHibernateDaoSupport;  
  10. import com.oa.dao.UserDao;  
  11.   
  12.   
  13.   
  14. /** 
  15.  * 从Spring 2.0开始，引入了@Repository注解， 
  16.  *  用它来标记充当储存库(又称 Data Access Object或DAO)角色或典型的类 
  17.  */  
  18.   
  19.   
  20. /** 
  21.  * Spring 2.5引入了更多典型化注解(stereotype annotations)： @Component、@Service和 @Controller。  
  22.  * @Component是所有受Spring管理组件的通用形式； 而@Repository、@Service和 @Controller则是@Component的细化，  
  23.  *                   用来表示更具体的用例(例如，分别对应了持久化层、 服务层  和   表现层)。 
  24.  */  
  25. //@Scope("singlton")  
  26. @Repository("userDao")//声明此类为数据持久层的类  
  27. public class UserDaoImpl extends MyHibernateDaoSupport implements UserDao {  
  28.   
  29.     public void delete(int id) {  
  30.         super.getHibernateTemplate().delete(  
  31.                 super.getHibernateTemplate().load(User.class, id));  
  32.   
  33.     }  
  34.   
  35.     public User get(int id) {  
  36.   
  37.         return (User) super.getHibernateTemplate().get("from  User", id);  
  38.     }  
  39.   
  40.     @SuppressWarnings("unchecked")  
  41.     public List<User> query() {  
  42.         return super.getHibernateTemplate().find("from User");  
  43.   
  44.     }  
  45.   
  46.     public void save(User user) {  
  47.         super.getHibernateTemplate().save(user);  
  48.   
  49.     }  
  50.   
  51.     public void update(User user) {  
  52.         super.getHibernateTemplate().update(user);  
  53.   
  54.     }  
  55.   
  56. }  
  57.   
  58.    
package com.oa.dao.impl;import java.util.List;import org.springframework.context.annotation.Scope;import org.springframework.stereotype.Repository;import com.oa.User;import com.oa.dao.MyHibernateDaoSupport;import com.oa.dao.UserDao;/** * 从Spring 2.0开始，引入了@Repository注解， *  用它来标记充当储存库(又称 Data Access Object或DAO)角色或典型的类 *//** * Spring 2.5引入了更多典型化注解(stereotype annotations)： @Component、@Service和 @Controller。  * @Component是所有受Spring管理组件的通用形式； 而@Repository、@Service和 @Controller则是@Component的细化，  *                   用来表示更具体的用例(例如，分别对应了持久化层、 服务层  和   表现层)。 *///@Scope("singlton")@Repository("userDao")//声明此类为数据持久层的类public class UserDaoImpl extends MyHibernateDaoSupport implements UserDao {	public void delete(int id) {		super.getHibernateTemplate().delete(				super.getHibernateTemplate().load(User.class, id));	}	public User get(int id) {		return (User) super.getHibernateTemplate().get("from  User", id);	}	@SuppressWarnings("unchecked")	public List
   
     query() {		return super.getHibernateTemplate().find("from User");	}	public void save(User user) {		super.getHibernateTemplate().save(user);	}	public void update(User user) {		super.getHibernateTemplate().update(user);	}}
持久化层完毕。
接下来的是事务层
先创建一个UserService的接口。
Java代码  
  1. package com.oa.service;  
  2.   
  3. import com.oa.User;  
  4.   
  5. public interface UserService {  
  6.       
  7.     public void save(User user);  
  8.   
  9.     public void update(User user);  
  10.   
  11. }  
  12.    
package com.oa.service;import com.oa.User;public interface UserService {		public void save(User user);	public void update(User user);}
然后实现这个接口：UserServiceImpl。
在UserServiceImpl里引用UserDao来实现业务逻辑。
Java代码  
  1. package com.oa.service.impl;  
  2.   
  3. import com.oa.User;  
  4. import com.oa.service.UserService;  
  5. import com.oa.dao.UserDao;  
  6.   
  7.   
  8. import java.util.List;  
  9.   
  10. import org.springframework.beans.factory.annotation.Autowired;  
  11. import org.springframework.stereotype.Service;  
  12.   
  13.   
  14.   
  15. /** 
  16.  * 声明此类为业务逻辑层的类 
  17.  * 默认bean名称生成器会返回小写开头的非限定(non-qualified)类名 
  18.  * @Service 
  19.  * userServiceImpl 
  20.  */  
  21. @Service("userService")  
  22. public class UserServiceImpl implements UserService {  
  23.   
  24.       
  25.     /** 
  26.      * @Autowired 
  27.      *  
  28.      * @Autowired 注解可以用于"传统的"setter 方法，如下例： 
  29.      * public void setUserDao(UserDAO userDao) 
  30.     {
     
  31.         this.userDao = userDao; 
  32.     } 
  33.      */  
  34.       
  35.     /** 
  36.      * @Resource有一个'name'属性，缺省时，Spring 将这个值解释为要注射的 bean 的名字。 
  37.      *   @Resource(name="userDao")  
  38.      */  
  39.     @Autowired //  or  @Resource(name="userDao")  
  40.     private UserDao userDao;  
  41.   
  42.     public void save(User user) {  
  43.         userDao.save(user);  
  44.   
  45.     }  
  46.   
  47.     public void update(User user) {  
  48.         userDao.update(user);  
  49.   
  50.     }  
  51.   
  52. }  
  53.   
  54.    
package com.oa.service.impl;import com.oa.User;import com.oa.service.UserService;import com.oa.dao.UserDao;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;/** * 声明此类为业务逻辑层的类 * 默认bean名称生成器会返回小写开头的非限定(non-qualified)类名 * @Service * userServiceImpl */@Service("userService")public class UserServiceImpl implements UserService {		/**	 * @Autowired	 * 	 * @Autowired 注解可以用于"传统的"setter 方法，如下例：	 * public void setUserDao(UserDAO userDao)	{		this.userDao = userDao;	}	 */		/**	 * @Resource有一个'name'属性，缺省时，Spring 将这个值解释为要注射的 bean 的名字。	 *   @Resource(name="userDao") 	 */	@Autowired //  or  @Resource(name="userDao")    private UserDao userDao;	public void save(User user) {		userDao.save(user);	}	public void update(User user) {		userDao.update(user);	}}
按照上面的模式：新闻管理也这么写一遍。
重复的工作使得我们觉得好烦。
这个时候是泛型出场的时候了。
基于Facade的设计模式，dao和service还是要的。 这里我们就要设计一个公共的Dao..  我们称之为：GenericDao
Java代码  
  1. package com.oa.dao;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.*;  
  5.   
  6. /** 
  7.  * * 
  8.  *  
  9.  * @param <T> 
  10.  *            泛型，指实体类  type 
  11.  * @param <PK> 
  12.  *            泛型，指实体类主键的数据类型，如Integer,Long 
  13.  */  
  14. public interface GenericDao<T, PK> {  
  15.       
  16.     /**   
  17.      * 保存指定实体类   
  18.      *    
  19.      * @param entityobj   
  20.      *            实体类   
  21.      */   
  22.     public  void save(T entity);  
  23.       
  24.       
  25.       /**   
  26.      * 删除指定实体   
  27.      *    
  28.      * @param entityobj   
  29.      *            实体类   
  30.      */    
  31.     public void delete(T entity);  
  32.       
  33.       
  34.      /** * 
  35.      * 删除实体 
  36.      * @param entityClass 实体类名 
  37.      * @param id 实体的ID 
  38.      */  
  39.     public void deleteById(Class<T> entityClass,PK id);  
  40.       
  41.       
  42.     /**   
  43.     * 更新或保存指定实体   
  44.     *    
  45.     * @param entity 实体类   
  46.     */   
  47.     public void saveorupdate(T entity);  
  48.       
  49.       
  50.      /** * 
  51.      * 更新实体 
  52.      * 可用于添加、修改、删除操作 
  53.      * @param hql 更新的HQL语句 
  54.      * @param params 参数,可有项目或多项目,代替Hql中的"?"号 
  55.      */  
  56.     public void update(final String hql,final Object[] params);  
  57.       
  58.       
  59.   
  60.     /**   
  61.      * 模糊查询指定条件对象集合 <br>   
  62.      * 用法：可以实例化一个空的T对象，需要查询某个字段，就set该字段的条件然后调用本方法<br>   
  63.      * 缺点：目前测试貌似只能支持String的模糊查询，虽然有办法重写，但没必要，其他用HQL<br>   
  64.      *    
  65.      * @param entity   
  66.      *            条件实体   
  67.      * @return 结合   
  68.      */    
  69.     public List<T> findByExample(T entity);  
  70.       
  71.       
  72.     /**   
  73.      * 获取所有实体集合   
  74.      *    
  75.      * @param entityClass   
  76.      *            实体   
  77.      * @return 集合   
  78.      */    
  79.     public List<T> findAll(Class<T> entityClass);  
  80.       
  81.     public List<T> findAll(Class<T> entityClass,String hql,Object[] params,int start, int limit);  
  82.     /**   
  83.      * 查找指定PK实体类对象   
  84.      *    
  85.      * @param entityClass   
  86.      *            实体Class   
  87.      * @param id   
  88.      *            实体PK   
  89.      * @return 实体对象   
  90.      */     
  91.     public T findById(Class<T> entityClass, PK id);  
  92.       
  93.     /** * 
  94.      * 按HQL条件查询列表 
  95.      * @param hql 查询语句,支持连接查询和多条件查询 
  96.      * @param params 参数数组,代替hql中的"?"号 
  97.      * @return 结果集List 
  98.      */  
  99.      
  100.     public List<T> findByHql(String hql,Object[]  params);  
  101.       
  102.     /**   
  103.      * 查找指定属性的实体集合   
  104.      *    
  105.      * @param entityClass   
  106.      *            实体   
  107.      * @param propertyName   
  108.      *            属性名   
  109.      * @param value   
  110.      *            条件   
  111.      * @return 实体集合   
  112.      */    
  113.     public List<T> findByProperty(Class<T> entityClass, String propertyName,Object value);  
  114.       
  115.       
  116.     /**   
  117.      * 查询指定HQL语句的分页数据集合   
  118.      *    
  119.      * @param hsql   
  120.      *            HQL语句   
  121.      * @param start   
  122.      *            开始记录号   
  123.      * @param limit   
  124.      *            最大记录号   
  125.      * @return 分页数据集合   
  126.      * @throws Exception   
  127.      *             抛出异常   
  128.      */    
  129.     public List<T> findByPage(Class<T> entityClass,int start,int limit) ;  
  130.       
  131.       
  132.       
  133.     /** 
  134.      * 获得总记录数 
  135.      */  
  136.     public T getTotalCount(Class<T> entityClass);  
  137.       
  138.     public T getPageCount(String hql,Object[] params);  
  139.   
  140. }  
  141.    
package com.oa.dao;import java.io.Serializable;import java.util.*;/** * * *  * @param 
   
     *            泛型，指实体类  type * @param 
    
      *            泛型，指实体类主键的数据类型，如Integer,Long */public interface GenericDao
     
       {		/**       * 保存指定实体类       *        * @param entityobj       *            实体类       */ 	public  void save(T entity);			  /**       * 删除指定实体       *        * @param entityobj       *            实体类       */  	public void delete(T entity);			 /** *     * 删除实体     * @param entityClass 实体类名     * @param id 实体的ID     */    public void deleteById(Class
      
        entityClass,PK id);			/**      * 更新或保存指定实体      *       * @param entity 实体类      */ 	public void saveorupdate(T entity);			 /** *     * 更新实体     * 可用于添加、修改、删除操作     * @param hql 更新的HQL语句     * @param params 参数,可有项目或多项目,代替Hql中的"?"号     */    public void update(final String hql,final Object[] params);            /**       * 模糊查询指定条件对象集合 
       
       * 用法：可以实例化一个空的T对象，需要查询某个字段，就set该字段的条件然后调用本方法
       
       * 缺点：目前测试貌似只能支持String的模糊查询，虽然有办法重写，但没必要，其他用HQL
       
       *        * @param entity       *            条件实体       * @return 结合       */      public List
       
         findByExample(T entity);            /**       * 获取所有实体集合       *        * @param entityClass       *            实体       * @return 集合       */      public List
        
          findAll(Class
         
           entityClass); public List
          
            findAll(Class
           
             entityClass,String hql,Object[] params,int start, int limit); /** * 查找指定PK实体类对象 * * @param entityClass * 实体Class * @param id * 实体PK * @return 实体对象 */ public T findById(Class
            
              entityClass, PK id); /** * * 按HQL条件查询列表 * @param hql 查询语句,支持连接查询和多条件查询 * @param params 参数数组,代替hql中的"?"号 * @return 结果集List */ public List
             
               findByHql(String hql,Object[] params); /** * 查找指定属性的实体集合 * * @param entityClass * 实体 * @param propertyName * 属性名 * @param value * 条件 * @return 实体集合 */ public List
              
                findByProperty(Class
               
                 entityClass, String propertyName,Object value); /** * 查询指定HQL语句的分页数据集合 * * @param hsql * HQL语句 * @param start * 开始记录号 * @param limit * 最大记录号 * @return 分页数据集合 * @throws Exception * 抛出异常 */ public List
                
                  findByPage(Class
                 
                   entityClass,int start,int limit) ; /** * 获得总记录数 */ public T getTotalCount(Class
                  
                    entityClass); public T getPageCount(String hql,Object[] params);}
看到，我们不再是具体的User ， News
。。而是用 T  来取代实体。
因为我这个是基于 注解的，所以附上MyHibernateDaoSupport的代码。
Java代码  
  1. package com.oa.dao;  
  2.   
  3. import javax.annotation.Resource;  
  4. import org.hibernate.SessionFactory;  
  5. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
  6.   
  7. /** 
  8.  * 我们之所以要改写 
  9.  * HibernateDaoSupport，是因我为，我们要为DAO层的类注入SessionFactory这个属性。 
  10.  * 以后，我们开发的DAO类，就可以直接重用这个MyHibernateDaoSupport了。 
  11.  * 其实，这样做是相当于配置文件方式的代码： 
  12.  * <bean id="userDao" class="com.oa.dao.UserDaoImpl">  
  13.  * <property 
  14.  * name="sessionFactory" ref="sessionFactory"/>  
  15.  * </bean> 
  16.  *  
  17.  * @author Administrator 
  18.  *  
  19.  */  
  20. public class MyHibernateDaoSupport extends HibernateDaoSupport {  
  21.       
  22.     @Resource(name="sessionFactory")    //为父类HibernateDaoSupport注入sessionFactory的值  
  23.     public void setSuperSessionFactory(SessionFactory sessionFactory){  
  24.         super.setSessionFactory(sessionFactory);  
  25.     }  
  26.       
  27.   
  28. }  
  29.   
  30.    
package com.oa.dao;import javax.annotation.Resource;import org.hibernate.SessionFactory;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;/** * 我们之所以要改写 * HibernateDaoSupport，是因我为，我们要为DAO层的类注入SessionFactory这个属性。 * 以后，我们开发的DAO类，就可以直接重用这个MyHibernateDaoSupport了。 * 其实，这样做是相当于配置文件方式的代码： * 
   
      * 
      * 
    *  * @author Administrator *  */public class MyHibernateDaoSupport extends HibernateDaoSupport {        @Resource(name="sessionFactory")    //为父类HibernateDaoSupport注入sessionFactory的值    public void setSuperSessionFactory(SessionFactory sessionFactory){        super.setSessionFactory(sessionFactory);    }    }
到现在位置genericdao的接口有了，也就是我们要做什么。。现在就是实现它，就是怎么做。
GenericDaoImpl 代码：
Java代码  
  1. package com.oa.dao.impl;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.List;  
  5.   
  6. import org.hibernate.Query;  
  7. import org.springframework.stereotype.Repository;  
  8.   
  9. import com.oa.dao.GenericDao;  
  10. import com.oa.dao.MyHibernateDaoSupport;  
  11. @SuppressWarnings("unchecked")  
  12. @Repository("genericDao")   //声明此类为数据持久层的类  
  13. public class GenericDaoImpl<T, PK extends Serializable> extends  
  14.                                     MyHibernateDaoSupport implements GenericDao<T, PK> {  
  15.   
  16.     public void delete(T entity) {  
  17.         super.getHibernateTemplate().delete(entity);  
  18.     }  
  19.   
  20.   
  21.     public void deleteById(Class entityClass, PK id) {  
  22.         super.getHibernateTemplate().delete(findById(entityClass, id));  
  23.   
  24.     }  
  25.       
  26.     public void save(T entity) {  
  27.         super.getHibernateTemplate().save(entity);  
  28.   
  29.     }  
  30.   
  31.     public void saveorupdate(T entity) {  
  32.         super.getHibernateTemplate().saveOrUpdate(entity);  
  33.   
  34.     }  
  35.   
  36.     public void update(String hql, Object[] params) {  
  37.              Query query = super.getSession().createQuery(hql);  
  38.                 for(int i=0; i<params.length; i++){  
  39.                     query.setParameter(i, params[i]);  
  40.                 }  
  41.                 query.executeUpdate();  
  42.      }  
  43.       
  44.   
  45.     public List<T> findAll(Class entityClass) {  
  46.           
  47.         return super.getHibernateTemplate().loadAll(entityClass);  
  48.     }  
  49.   
  50.     public List<T> findAll(Class entityClass, String hql, Object[] params,int start, int limit) {  
  51.         Query query = super.getSession().createQuery(hql);  
  52.         if(params!=null&&params.length>0){  
  53.             for(int i = 0;i<params.length;i++){  
  54.                 query.setParameter(i, params[i]);  
  55.             }  
  56.         }  
  57.         if(start!=0&&limit!=0){  
  58.             query.setFirstResult(start).setMaxResults(limit);  
  59.         }  
  60.         return query.list();  
  61.     }  
  62.   
  63.     public List<T> findByExample(T entity) {  
  64.         return super.getHibernateTemplate().findByExample(entity);  
  65.     }  
  66.   
  67.     public List<T> findByHql(String hql, Object[] params) {  
  68.         Query query = super.getSession().createQuery(hql);  
  69.         if(null!= params && params.length>0){  
  70.             for(int i = 0; i<params.length;i++){  
  71.                 query.setParameter(i, params[i]);  
  72.             }  
  73.         }  
  74.         return query.list();  
  75.     }  
  76.   
  77.     public T findById(Class entityClass, PK id) {  
  78.         return (T)super.getHibernateTemplate().get(entityClass, id);  
  79.     }  
  80.       
  81.     public List<T> findByProperty(Class entityClass, String propertyName,Object value) {  
  82.         String queryString = "from "+entityClass.getName()+ " as model where model." + propertyName + "=?";     
  83.         return super.getHibernateTemplate().find(queryString, value);  
  84.     }  
  85.   
  86.   
  87.       
  88.     //分页使用  
  89.     public List<T> findByPage(Class<T> entityClass,int start,int limit) {  
  90.           Query query=super.getSession().createQuery("select o from "+entityClass.getName()+" o");  
  91.           query.setFirstResult(start).setMaxResults(limit);  
  92.         return query.list();  
  93.     }  
  94.   
  95.       
  96.     public T getTotalCount(Class entityClass) {  
  97.           
  98.         return (T)super.getSession().createQuery("select count(o) from "+entityClass.getName()+" o").uniqueResult();  
  99.     }  
  100.   
  101.     public T getPageCount(String hql, Object[] params) {  
  102.         Query query = super.getSession().createQuery(hql);  
  103.         if(null!= params && params.length>0){  
  104.             for(int i = 0; i<params.length;i++){  
  105.                 query.setParameter(i, params[i]);  
  106.             }  
  107.         }  
  108.         return (T)query.list();  
  109.     }  
  110.   
  111.       
  112.   
  113. }  
package com.oa.dao.impl;import java.io.Serializable;import java.util.List;import org.hibernate.Query;import org.springframework.stereotype.Repository;import com.oa.dao.GenericDao;import com.oa.dao.MyHibernateDaoSupport;@SuppressWarnings("unchecked")@Repository("genericDao")   //声明此类为数据持久层的类public class GenericDaoImpl
   
     extends                                    MyHibernateDaoSupport implements GenericDao
    
      {	public void delete(T entity) {		super.getHibernateTemplate().delete(entity);	}	public void deleteById(Class entityClass, PK id) {		super.getHibernateTemplate().delete(findById(entityClass, id));	}		public void save(T entity) {		super.getHibernateTemplate().save(entity);	}	public void saveorupdate(T entity) {		super.getHibernateTemplate().saveOrUpdate(entity);	}	public void update(String hql, Object[] params) {		     Query query = super.getSession().createQuery(hql);                for(int i=0; i
     
       findAll(Class entityClass) {				return super.getHibernateTemplate().loadAll(entityClass);	}	public List
      
        findAll(Class entityClass, String hql, Object[] params,int start, int limit) {		Query query = super.getSession().createQuery(hql);		if(params!=null&&params.length>0){			for(int i = 0;i
       
         findByExample(T entity) {		return super.getHibernateTemplate().findByExample(entity);	}	public List
        
          findByHql(String hql, Object[] params) { Query query = super.getSession().createQuery(hql); if(null!= params && params.length>0){ for(int i = 0; i
         
           findByProperty(Class entityClass, String propertyName,Object value) { String queryString = "from "+entityClass.getName()+ " as model where model." + propertyName + "=?"; return super.getHibernateTemplate().find(queryString, value); } //分页使用 public List
          
            findByPage(Class
           
             entityClass,int start,int limit) { Query query=super.getSession().createQuery("select o from "+entityClass.getName()+" o"); query.setFirstResult(start).setMaxResults(limit); return query.list(); } public T getTotalCount(Class entityClass) { return (T)super.getSession().createQuery("select count(o) from "+entityClass.getName()+" o").uniqueResult(); } public T getPageCount(String hql, Object[] params) { Query query = super.getSession().createQuery(hql); if(null!= params && params.length>0){ for(int i = 0; i
至此 泛型就告一个段落。
接下来日子就好过了。
我们不是有user  news   等等一系列的curd管理。
以User为例子；
定义一个user的接口，
UserDao.Java
Java代码  
  1. package com.oa.dao;  
  2.   
  3. import com.oa.User;  
  4.   
  5. public interface UserDao extends GenericDao<User, Integer> {  
  6.   
  7. public   int   login（User user）;  
  8. //其他的方法的  
  9. }  
  10.   
  11.   
  12. 然后就是实现它 UserDaoImpl  
  13.   
  14. package com.oa.dao.impl;  
  15.   
  16.   
  17.   
  18. import com.oa.User;  
  19. import com.oa.dao.UserDao;  
  20.   
  21. public class UserDaoImpl extends GenericDaoImpl<User, Integer> implements UserDao {  
  22.   
  23.     public  int  login（User  user）{  
  24. //登陆判断的方法  
  25.   
  26. return   XX;  
  27. };  
  28.   
  29.   
  30. //其他的方法的实现  
  31.   
  32.   
  33. }  
  34.   
  35.    
package com.oa.dao;import com.oa.User;public interface UserDao extends GenericDao
   
     {public   int   login（User user）;//其他的方法的}然后就是实现它 UserDaoImplpackage com.oa.dao.impl;import com.oa.User;import com.oa.dao.UserDao;public class UserDaoImpl extends GenericDaoImpl
    
      implements UserDao {	public  int  login（User  user）{//登陆判断的方法return   XX;};//其他的方法的实现}
持久化层就是这么多了。
下面进入业务逻辑层，依然是先定义一个接口。
Java代码  
  1. package com.oa.service;  
  2.   
  3. import com.oa.User;  
  4.   
  5. public interface UserService {  
  6.       
  7.     public void save(User user);  
  8.   
  9.     public void update(User user);  
  10.   
  11.    public  int  login（User  user）；  
  12.   
  13. //其他的方法  
  14.   
  15. }  
  16.    
package com.oa.service;import com.oa.User;public interface UserService {		public void save(User user);	public void update(User user);   public  int  login（User  user）；//其他的方法}
接下来是实现
Java代码  
  1. package com.oa.service.impl;  
  2.   
  3. import com.oa.User;  
  4. import com.oa.dao. UserDao;  
  5. import com.oa.service.TestUserService;  
  6.   
  7. public class UserService implements UserService {  
  8.   
  9.     private  UserDao  UserDao;  
  10.     public void save(User user) {  
  11.         UserDao.save(user);  
  12.   
  13.     }  
  14.   
  15.     public void updasaveorupdatete(User user) {  
  16.         UserDao.saveorupdate(user);  
  17.   
  18.     }  
  19.   
  20.     public int   login(User user) {  
  21.         return   UserDao.login(user);  
  22.   
  23.     }  
  24.   
  25. //其他的方法。。。。  
  26.   
  27. }  
  28.   
  29.    
package com.oa.service.impl;import com.oa.User;import com.oa.dao. UserDao;import com.oa.service.TestUserService;public class UserService implements UserService {	private  UserDao  UserDao;	public void save(User user) {		UserDao.save(user);	}	public void updasaveorupdatete(User user) {		UserDao.saveorupdate(user);	}	public int   login(User user) {		return   UserDao.login(user);	}//其他的方法。。。。}
Ok。。到现在我们就利用泛型dao来设计就完毕了
两者相对比，发现dao层的代码可以复用，少了不少。
对于大型管理系统，效果更明显。

转载地址：http://gdlmi.baihongyu.com/

你可能感兴趣的文章
test-definitions/blob/master/auto-test/boost/boost.sh
查看>>
Java多态性理解
查看>>
Intellij Idea 工具在java文件中怎么避免 import .＊包，以及import包顺序的问题
查看>>
IDEA Properties中文unicode转码问题
查看>>
Oracle中Blob转换成Clob
查看>>
Linux如何查看so中函数名
查看>>
自动管理代码的android.mk
查看>>
cocos2dx 2.2.6编译记录(1)
查看>>
makefile学习网站
查看>>
C 编写lua模块（1）
查看>>
Lua教程：Lua调用C/C++函数(4)
查看>>
win下创建win32控制台工程，执行lua脚本
查看>>
cocos2dx android启动错误
查看>>
eclipse: android rename package name
查看>>
cocos2dx c++调用java思想
查看>>
cocos2dx lua Node节点 私有数据存取
查看>>
lua math.ceil math.ceil
查看>>
cocos2dx CCNode计算node的大小
查看>>
cocos2dx 布局记录（1）
查看>>
lua 多行注释和取消多行注释
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-09-25 20:28:55   当前IP: 3.21.248.162   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我