Java获得泛型类型

最近要想获得泛型类型，总结多方意见，再通过实践，最终获得了结果。
当然也被许多文章给误导过……
下面我们看一个例子，这个例子是我自己写的

/*
 * Copyright 2010 Sandy Zhang
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

/**
 * 
 */
package org.javazone.jroi.test.reflect;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

/**
 * @author Sandy Zhang
 */
public class Bean
{
	public Map<String, ListBean> list = new HashMap<String, ListBean>();

	public static void main(String[] args) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException
	{
		Field c = Bean.class.getField("list");
		Field f = Field.class.getDeclaredField("signature");
		f.setAccessible(true);
		System.out.println(((String) f.get(c)));

	}
}

这个只是我最近在写一个反射调用的东西想到的问题，所以很无奈才必须要这样得到东西
下面是结果

Ljava/util/Map<Ljava/lang/String;Lorg/javazone/jroi/test/reflect/ListBean;>;

字符串都有了，你怕什么呢？呵呵！

后话：这个方法并不应该被推荐，因为java api下并未提供任何方法实现，也就是说我们必须在特定环境和版本下才能这样干，至少得是1.5之后的版本以后sun（现在是oracle了）准备怎么改，这个是他的说法。。。
--------------------------------------------------------------------
OK，这个是一个引子，从这里我们看到了好些个玩意，也就是java其实提供了获取的方案的
那么我们要进行私有操作的，这样对我们写代码养成这样的习惯可不好，没事就去拿私有的东西，那是不是应该有公共的方法呢？我们试一下
将main里的调用修改一下

Field c = Bean.class.getField("list");
System.out.println(c.toGenericString());

public java.util.Map<java.lang.String, org.javazone.jroi.test.reflect.ListBean> org.javazone.jroi.test.reflect.Bean.list

看看，我们拿到了什么，不需要setAccess了，呵呵

哦，对了，你或许要问如果我不是字段呢？是方法怎么办。。于是乎

package org.javazone.jroi.test.reflect;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Sandy Zhang
 */
public class Bean
{
	public Map<String, ListBean> list = new HashMap<String, ListBean>();

	public Map<String, ListBean> getList()
	{
		return list;
	}

	public static void main(String[] args) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, NoSuchMethodException
	{
		System.out.println(Bean.class.getMethod("getList").toGenericString());
	}
}

public java.util.Map<java.lang.String, org.javazone.jroi.test.reflect.ListBean> org.javazone.jroi.test.reflect.Bean.getList()

---------------------------------------------------------------------
字符串有了，我们考虑下，API里是不是应该也提供了方法直接获取泛型类型，参考下

getGenericType
public Type getGenericType()返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型。 
如果 Type 是一个参数化类型，则返回的 Type 对象必须准确地反映源代码中使用的实际类型参数。 
如果底层字段的类型是一个类型变量或者是一个参数化类型，则创建它。否则将解析它。 
返回：
返回表示此 Field 对象所表示字段的声明类型的 Type 对象 
抛出： 
GenericSignatureFormatError - 如果一般字段签名不符合 Java Virtual Machine Specification, 3rd edition 中指定的格式 
TypeNotPresentException - 如果底层字段的一般类型签名引用了不存在的类型声明 
MalformedParameterizedTypeException - 如果底层字段的一般签名引用了一个因某种原因而无法实例化的参数化类型
从以下版本开始： 
1.5 

由此可见，在1.5之后添加了众多以Generic为关键字的方法，这些方法就是用来获取泛型参数的有效途径，但是或许表面上看不出来，因为他们都是返回的Type接口，而非ParameterizedType接口，所以我困惑了很久。OK，下面我们看一下怎么实现吧

public class GenericTest
{
	public List<String> list = new LinkedList<String>();

	public static void main(String[] args) throws SecurityException, NoSuchFieldException
	{
		ParameterizedType pt = (ParameterizedType) GenericTest.class.getField(
				"list").getGenericType();
		System.out.println(pt.getActualTypeArguments().length);
		System.out.println(pt.getActualTypeArguments()[0]);
	}
}

1
class java.lang.String
这里是结果
---------------------------------------------------------------------
于是乎，所有的问题都迎刃而解了。

似乎文章很长，我通过Debug的方式发现了代码的运行过程，最终找到了核心字符串，说明即使是檫除式的泛型java也会记录下这些东西，没道理拿不到

评论

32 楼 agapple 2010-10-26  

以前用的获取泛型的一个方法,可恶意处理多级泛型和泛型数组。

/**
     * 取得范性信息
     *
     * @param cls
     * @param i
     * @return
     */
    private Class<?> getGenericClass(Class<?> cls, int i) {
        ParameterizedType parameterizedType = ((ParameterizedType) cls.getGenericInterfaces()[0]);
        Object genericClass = parameterizedType.getActualTypeArguments()[i];
        if (genericClass instanceof ParameterizedType) { // 处理多级泛型
            return (Class<?>) ((ParameterizedType) genericClass).getRawType();
        } else if (genericClass instanceof GenericArrayType) { // 处理数组泛型
            return (Class<?>) ((GenericArrayType) genericClass).getGenericComponentType();
        } else {
            return (Class<?>) genericClass;
        }
    }

31 楼 Relucent 2010-10-22  

如果是方法 可以用 getGenericParameterTypes 得到带泛型的类型

30 楼 zcy860511 2010-02-11  

iamlotus 写道

<div class="quote_title">myworkfirst 写道</div>
<div class="quote_div">
<div class="quote_title">RednaxelaFX 写道</div>
<div class="quote_div">
<div class="quote_title">bonny 写道</div>
<div class="quote_div">

class Domain{
public static Class getCurrentDomainClass(){
//获取运行时类型
}
}

class User() extends Domain{

}
class Test
{
@Test
public void test(){
User.getCurrentDomainClass();//。。。。无法获取User.class 
}
}

<br><br>这个功能我找了很久，貌似无法实现。</div>
<br>这个确实是不行。如果不是静态方法而是成员方法的话还有点可能，好歹能拿到“this” <br>话说这让我想起以前别人提出“为什么不弄个'static virtual method'呢？”，不过现实是Java里没这玩儿</div>
<br>   在什么场景下，要这样去获取呢? <br>
</div>
<br>比如对于Util类，按说其方法应该是static的，因为用不到this

 

 

class ParentUtil{	
	
	public <span style="color: #ff0000;">static</span> void foo(Parent p){}; 
}

class ChildUtil extends ParentUtil{	
	
	public <span style="color: #ff0000;">static</span> void foo(Parent p){}; 
}

class NeedParentUtil{
	public ParentUtil util;
	
	public void foo(){
		util.foo(new Parent()); //这里一定会调ParentUtil.foo(),即使你传进一个ChildUtil.foo()给NeedParentUtil
	}		
}

  

 

但由于static不能继承，以上的代码是无用的，所以只能写成以下这种方式 

 

 

class ParentUtil{	
	
	public void foo(Parent p){}; //为什么？明明没有用到this，我还得声明成 non static method 
}

class ChildUtil extends ParentUtil{	
	
	public  void foo(Parent p){}; 
}

class NeedParentUtil{
	public ParentUtil util;
	
	public void foo(){
		util.foo(new Parent()); 
	}		
}

 

同时，我还得寄希望于IOC容器能够保证不会new出超过一个XXUtil，占用可怜的内存。

 

根本原因嘛，为了用到继承，我就得new出一个instance来。这就是为什么会希望搞出一个'static virtual method'来的原因

 

 

<br> 

 

我不是太明白，既然是工具类，为什么要用继承的形式，这样的设计是不是欠考虑？工具类本身就是为执行特定操作而生，只是一个面向过程的概念。。。为什么要面向对象？？

还有就是你说的问题可以考虑使用调用栈读取，静态类型无法获得this，但是可以在线程上做文章
StackTraceElement[] stack = Thread.currentThread().getStackTrace();

29 楼 iamlotus 2010-02-06  

<div class="quote_title">myworkfirst 写道</div>
<div class="quote_div">
<div class="quote_title">RednaxelaFX 写道</div>
<div class="quote_div">
<div class="quote_title">bonny 写道</div>
<div class="quote_div">
<pre name="code" class="java">class Domain{
public static Class getCurrentDomainClass(){
//获取运行时类型
}
}

class User() extends Domain{

}
class Test
{
@Test
public void test(){
User.getCurrentDomainClass();//。。。。无法获取User.class
}
}
</pre>
<br><br>这个功能我找了很久，貌似无法实现。</div>
<br>这个确实是不行。如果不是静态方法而是成员方法的话还有点可能，好歹能拿到“this” <br>话说这让我想起以前别人提出“为什么不弄个'static virtual method'呢？”，不过现实是Java里没这玩儿</div>
<br>   在什么场景下，要这样去获取呢? <br>
</div>
<p><br>比如对于Util类，按说其方法应该是static的，因为用不到this</p>
<p> </p>
<p> </p>
<pre name="code" class="java">class ParentUtil{

public <span style="color: #ff0000;">static</span> void foo(Parent p){};
}

class ChildUtil extends ParentUtil{

public <span style="color: #ff0000;">static</span> void foo(Parent p){};
}

class NeedParentUtil{
public ParentUtil util;

public void foo(){
util.foo(new Parent()); //这里一定会调ParentUtil.foo(),即使你传进一个ChildUtil.foo()给NeedParentUtil
}
}</pre>
<p>  </p>
<p> </p>
<p>但由于static不能继承，以上的代码是无用的，所以只能写成以下这种方式 </p>
<p> </p>
<p> </p>
<pre name="code" class="java">class ParentUtil{

public void foo(Parent p){}; //为什么？明明没有用到this，我还得声明成 non static method
}

class ChildUtil extends ParentUtil{

public  void foo(Parent p){};
}

class NeedParentUtil{
public ParentUtil util;

public void foo(){
util.foo(new Parent());
}
}
</pre>
<p> </p>
<p>同时，我还得寄希望于IOC容器能够保证不会new出超过一个XXUtil，占用可怜的内存。</p>
<p> </p>
<p>根本原因嘛，为了用到继承，我就得new出一个instance来。这就是为什么会希望搞出一个'static virtual method'来的原因</p>
<p> </p>
<p> </p>
<p><br> </p>
<p> </p>

28 楼 myworkfirst 2010-02-04  

RednaxelaFX 写道

bonny 写道

class Domain{
public static Class getCurrentDomainClass(){
//获取运行时类型
}
}

class User() extends Domain{

}
class Test
{
@Test
public void test(){
User.getCurrentDomainClass();//。。。。无法获取User.class 
}
}

这个功能我找了很久，貌似无法实现。

这个确实是不行。如果不是静态方法而是成员方法的话还有点可能，好歹能拿到“this”
话说这让我想起以前别人提出“为什么不弄个'static virtual method'呢？”，不过现实是Java里没这玩儿

   在什么场景下，要这样去获取呢?

27 楼 rain2005 2010-02-04  

RednaxelaFX解释的相当的清晰哦，只有类型声明的时候泛型才会写入class，这里的声明包括类，方法，变量（非局部变量），运行时泛型是没有写入class的哦。


综上所述，泛型是编译期行为，但是java通过修改class字节码的方式让程序在运行时可以通过反射来获取类型信息。

26 楼 chenzengpeng 2010-02-04  

以前获得Class中的泛型类型都是用如下方法：
class BaseService<T extends BaseEntity>
{
  ...
  public Class<T> getClazz() {
        ParameterizedType parameterizedType = (ParameterizedType).getClass().getGenericSuperclass();
        return (Class<T>) parameterizedType.getActualTypeArguments()[0];
    }
}
  

25 楼 zcy860511 2010-02-04  

貌似Class的类型通过Debug我也没发现哪有记录，不知道哪个大牛能拿出来，看看

24 楼 luojy8877 2010-02-03  

利用反射获取泛型  学习了 

23 楼 RednaxelaFX 2010-02-03  

AlwenS 写道

本贴的亮点在于这句话:

RednaxelaFX 写道

知道了什么信息有记录，什么信息没有记录之后，也就可以省点力气不去纠结“拿不到T的实际类型”、“建不出T类型的数组”之类的问题了orz

只是 [什么时候记录，什么时候不记录] 的语义上的区分还有些不明确.

声明一侧与使用一侧的两条还是不够用么，呜 TvT
这个要详细写就能赶超楼主写的长度了……去读读Java 5的class文件格式基本上该知道的也就都知道了。

22 楼 linliangyi2007 2010-02-03  

大牛出现，ORZ了，学习一下，温故知新。

21 楼 AlwenS 2010-02-03  

本贴的亮点在于这句话:

RednaxelaFX 写道

知道了什么信息有记录，什么信息没有记录之后，也就可以省点力气不去纠结“拿不到T的实际类型”、“建不出T类型的数组”之类的问题了orz

只是 [什么时候记录，什么时候不记录] 的语义上的区分还有些不明确.

20 楼 phz50 2010-02-03  

推荐看看SpringSide，相当不错!

19 楼 andot 2010-02-03  

gwpking8419 写道

andot 写道

askyuan 写道

抄袭的吧？呵呵

自己写不出来，就说人家抄袭，真卑鄙！真无耻！真龌龊！

楼主的这篇文章实在是太好了，让我如醍醐灌顶，茅塞顿开，解决了我多年来的疑惑！感谢楼主！

文明用语，别给中国人丢脸！

这句话应该留给你自己，你们这些喷子是最丢人的！

18 楼 zgz888 2010-02-03  

高手，回去好好学学

17 楼 RednaxelaFX 2010-02-03  

kjj 写道

如果是T
怎么在运行期取到类型呢,这个可以吗!!

其实前面才刚刚提到这个问题……

16 楼 caoyangx 2010-02-03  

这种java基础的文章很多，谈不上抄袭，每个人都有自己的理解。

15 楼 kjj 2010-02-03  

如果是T
怎么在运行期取到类型呢,这个可以吗!!

14 楼 aoliwen521 2010-02-03  

楼主写的很有想法，我以前从没想过这些事情。
比很多人炒旧饭要强多了。

13 楼 bonny 2010-02-03  

RednaxelaFX 写道

bonny 写道

class Domain{
public static Class getCurrentDomainClass(){
//获取运行时类型
}
}

class User() extends Domain{

}
class Test
{
@Test
public void test(){
User.getCurrentDomainClass();//。。。。无法获取User.class 
}
}

这个功能我找了很久，貌似无法实现。

这个确实是不行。如果不是静态方法而是成员方法的话还有点可能，好歹能拿到“this”
话说这让我想起以前别人提出“为什么不弄个'static virtual method'呢？”，不过现实是Java里没这玩儿

这玩意太有用了，我看play框架，因为java无法提供这个功能，他的find都是直接丢异常。子类的model都是classload时做字节码增强。其实跟很丑的roo的做法一摸一样，太丑了。