写一个通用BaseDao

BaseDao.java

 1 package org.xxq.dao;  
 2   
 3 import java.io.Serializable;  
 4 import java.util.List;  
 5   
 6 /** 
 7  *  
 8  * @author Xiexq
 9  * 
10  * @param <T> 
11  *              DAO操作的对象类型 
12  * @param <PK> 
13  *              主键类型 
14  */  
15 public interface BaseDao<T,PK extends Serializable> {  
16       
17       
18     /** 
19      * 按id获取对象. 
20      *  
21      */  
22     T getById(PK id);  
23       
24     /** 
25      * 保存新增或修改的对象. 
26      *  
27      */  
28     T save(T object);  
29       
30     /**  
31      * 按id删除对象. 
32      */  
33     void remove(PK id);  
34       
35     /** 
36      * 删除对象. 
37      */  
38     void remove(final T object);  
39       
40     /** 
41      * 查询全部对象 
42      */  
43     List<T> getAll();  
44       
45       
46 }

dao层接口的实现类

BaseDaoImpl.java

 1 package org.xxq.dao.daoimpl;  
 2   
 3 import java.io.Serializable;  
 4 import java.lang.reflect.ParameterizedType;  
 5 import java.lang.reflect.Type;  
 6 import java.util.List;  
 7   
 8 import javax.annotation.Resource;  
 9   
10 import org.joshua.ss.dao.BaseDao;  
11 import org.springframework.orm.hibernate3.HibernateTemplate;  
12 import org.springframework.util.Assert;  
13   
14 /** 
15  *@author Xiexq
16  *@version 2011-12-15 下午02:27:43 
17  */  
18 /** 
19  * 可以在service层直接调用,也可以在DAO层扩展调用 
20  */  
21 public class BaseDaoImpl<T, PK extends Serializable> implements BaseDao<T, PK>{  
22       
23     @Resource(name="hibernateTemplate")  
24     private HibernateTemplate hibernateTemplate;  
25       
26     private Class<T> persistentClass;  
27     /** 
28      * 用于Dao层子类使用的构造函数. 通过子类的泛型定义取得对象类型 
29      */  
30   
31     @SuppressWarnings("unchecked")  
32     public BaseDaoImpl(){  
33         //getClass() 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。  
34         this.persistentClass=(Class<T>)getSuperClassGenricType(getClass(), 0);  
35     }  
36     public List<T> getAll() {       
37         return hibernateTemplate.loadAll(this.persistentClass);  
38     }  
39   
40     public T getById(PK id) {  
41         Assert.notNull(id, "id 不可空");  
42         T entity =hibernateTemplate.get(this.persistentClass, id);  
43         return entity;  
44     }  
45   
46     public void remove(PK id) {  
47         Assert.notNull(id, "id 不可空!");  
48         hibernateTemplate.delete(this.getById(id));       
49     }  
50   
51     public void remove(final T entity) {  
52         Assert.notNull(entity, "entity 不可空!");  
53         hibernateTemplate.delete(entity);  
54     }  
55   
56     public T save(T entity) {  
57         Assert.notNull(entity, "entity 不可空!");        
58         return hibernateTemplate.merge(entity);  
59     }  
60     /** 
61      * 通过反射, 获得定义Class时声明的父类的泛型参数的类型. 如无法找到, 返回Object.class. 
62      *  
63      *@param clazz 
64      *            clazz The class to introspect 
65      * @param index 
66      *            the Index of the generic ddeclaration,start from 0. 
67      * @return the index generic declaration, or Object.class if cannot be 
68      *         determined 
69      */  
70     @SuppressWarnings("unchecked")  
71     public static Class<Object> getSuperClassGenricType(final Class clazz, final int index) {  
72           
73         //返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。  
74         Type genType = clazz.getGenericSuperclass();  
75   
76         if (!(genType instanceof ParameterizedType)) {  
77            return Object.class;  
78         }  
79         //返回表示此类型实际类型参数的 Type 对象的数组。  
80         Type[] params = ((ParameterizedType) genType).getActualTypeArguments();  
81   
82         if (index >= params.length || index < 0) {  
83                      return Object.class;  
84         }  
85         if (!(params[index] instanceof Class)) {  
86               return Object.class;  
87         }  
88   
89         return (Class) params[index];  
90     }  
91   
92 }

秒客网

写一个通用BaseDao

相关文章