1.先定义接口(这里写的比较简单就一个方法,具体可以再增加)
public interface BaseDao<T> {
T get(String id);
}
2.定义抽象类实现接口
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public abstract class HibernateBaseDao<T> implements BaseDao<T> {
private Class<T> entityClass;
/**
* 这个通常也是hibernate的取得子类class的方法
*
* @author "yangk"
* @date 2010-4-11 下午01:51:28
*/
public HibernateBaseDao() {
Type genType = getClass().getGenericSuperclass();
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
entityClass = (Class) params[0];
// entityClass = Class<T> entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}
@Override
public T get(String id) {
try {
return entityClass.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}
子类的构造函数会调用父类的构造函数,所以当子类实例化的时候,父类的entityClass 已经得到了T.class。
3.定义一个entity
public class Entity {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
4.定义entity的DAO
public class EntityDao extends HibernateBaseDao<Entity> {
public void otherOperation() {
}
}
可以在里面定义父类没有的,针对具体子类特殊的方法。
5.测试
import static org.junit.Assert.assertNotNull;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
public class JunitTest {
@BeforeClass
public static void setUpClass() throws Exception {
}
@AfterClass
public static void tearDownClass() throws Exception {
}
@Before
public void setUp() {
}
@After
public void tearDown() {
}
/**
* Test of getEClass method, of class tmp.
*/
@Test
public void testNewClass() {
EntityDao testDao = new EntityDao();
Entity e = testDao.get(null);
assertNotNull(e);
}
}
运行,可以看到测试顺利通过。
注意:上面子类DAO的写法public class EntityDao extends HibernateBaseDao<Entity>
一定要在父类后面带上泛型,负责编译就会出错。
附:这是泛型擦拭法使得Generic无法获取自己的Generic Type类型。实际上BadClass<String>()实例化以后Class里面就不包括T的信息了,对于Class而言T已经被擦拭为Object,而真正的T参数被转到使用T的方法(或者变量声明或者其它使用T的地方)里面(如果没有那就没有存根),所以无法反射到T的具体类别,也就无法得到T.class。而getGenericSuperclass()是Generic继承的特例,对于这种情况子类会保存父类的Generic参数类型,返回一个ParameterizedType,这时可以获取到父类的T.class了,这也正是子类确定应该继承什么T的方法。