首页 > 代码库 > java 反射 子类泛型的class

java 反射 子类泛型的class

2024-08-05 00:37:09   224人阅读

   很早之前写过利用泛型和反射机制抽象DAO ，对其中获取子类泛型的class一直不是很理解。关键的地方是HibernateBaseDao的构造方法中的

 

[java] view plaincopy
 
  1. Type genType = getClass().getGenericSuperclass();   
  2. Type[] params = ((ParameterizedType) genType).getActualTypeArguments();   
  3. entityClass =  (Class)params[0];   

 

 

但是这个相对子类才会有用，而且那篇文章的HibernateBaseDao还不是abstract，如果一不小心实例化的话就会报异常。感觉java中通过反射取泛型的class还是挺复杂的，不过一旦取到的话就可以做很多事情了。

 

改进的例子和测试：

1.先定义接口（这里写的比较简单就一个方法，具体可以再增加）

 

[java] view plaincopy
 
  1. public interface BaseDao<T> {  
  2.     T get(String id);  
  3.   
  4. }  

 

2.定义抽象类实现接口

 

[java] view plaincopy
 
  1. import java.lang.reflect.ParameterizedType;  
  2. import java.lang.reflect.Type;  
  3.   
  4. public abstract class HibernateBaseDao<T> implements BaseDao<T> {  
  5.     private Class<T> entityClass;  
  6.   
  7.     /** 
  8.      * 这个通常也是hibernate的取得子类class的方法 
  9.      *  
  10.      * @author "yangk" 
  11.      * @date 2010-4-11 下午01:51:28 
  12.      */  
  13.     public HibernateBaseDao() {  
  14.         Type genType = getClass().getGenericSuperclass();  
  15.         Type[] params = ((ParameterizedType) genType).getActualTypeArguments();  
  16.         entityClass = (Class) params[0];  
  17.     }  
  18.   
  19.     @Override  
  20.     public T get(String id) {  
  21.         try {  
  22.             return entityClass.newInstance();  
  23.         } catch (InstantiationException e) {  
  24.             // TODO Auto-generated catch block  
  25.             e.printStackTrace();  
  26.         } catch (IllegalAccessException e) {  
  27.             // TODO Auto-generated catch block  
  28.             e.printStackTrace();  
  29.         }  
  30.         return null;  
  31.     }  
  32.   
  33. }  

 

 

子类的构造函数会调用父类的构造函数，所以当子类实例化的时候，父类的entityClass 已经得到了T.class。

3.定义一个entity

 

[java] view plaincopy
 
  1. public class Entity {  
  2.   
  3.     private String name;  
  4.   
  5.     public String getName() {  
  6.         return name;  
  7.     }  
  8.   
  9.     public void setName(String name) {  
  10.         this.name = name;  
  11.     }  
  12. }  

 

 

4.定义entity的DAO

 

[c-sharp] view plaincopy
 
  1. public class EntityDao extends HibernateBaseDao<Entity> {  
  2.   
  3.     public void otherOperation() {  
  4.   
  5.     }  
  6.   
  7. }  

 

 

可以在里面定义父类没有的，针对具体子类特殊的方法。

5.测试

 

[java] view plaincopy
 
  1. import static org.junit.Assert.assertNotNull;  
  2.   
  3. import org.junit.After;  
  4. import org.junit.AfterClass;  
  5. import org.junit.Before;  
  6. import org.junit.BeforeClass;  
  7. import org.junit.Test;  
  8.   
  9. public class JunitTest {  
  10.     @BeforeClass  
  11.     public static void setUpClass() throws Exception {  
  12.     }  
  13.   
  14.     @AfterClass  
  15.     public static void tearDownClass() throws Exception {  
  16.     }  
  17.   
  18.     @Before  
  19.     public void setUp() {  
  20.     }  
  21.   
  22.     @After  
  23.     public void tearDown() {  
  24.     }  
  25.   
  26.     /** 
  27.      * Test of getEClass method, of class tmp. 
  28.      */  
  29.     @Test  
  30.     public void testNewClass() {  
  31.         EntityDao testDao = new EntityDao();  
  32.         Entity e = testDao.get(null);  
  33.         assertNotNull(e);  
  34.     }  
  35.   
  36. }  

 

 

运行，可以看到测试顺利通过。

注意：上面子类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的方法。

 

java 反射 子类泛型的class


联系
我们