获取泛型类的真实参数

获得某个类的泛型

package com;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;


import org.springframework.core.ResolvableType;


interface Service2<N, M> {
}
class ABService2 implements Service2<A, B> {}


public class TestGenericClass2 {
	private Service<C, D> cdService;
	
	public static void main(String[] args) {
		//获取ABService2实现的第一个接口(从0开始计数) 即Service2<A, B>
		ParameterizedType parameterizedType = (ParameterizedType) ABService2.class.getGenericInterfaces()[0];
		System.out.println(parameterizedType);
		//从Service2<A, B> 获得第0个参数 即A
		Type genericType = parameterizedType.getActualTypeArguments()[0];
		System.out.println(genericType);
		System.out.println("*************");
		//下面的可以获得被aop代理之前的类型
		//ClassUtils.getUserClass(myClass);
		ResolvableType resolvableType1 = ResolvableType.forClass(ABService2.class);  
		
		Class c=resolvableType1.as(Service2.class).getGeneric(0).resolve();
		Class d=resolvableType1.getInterfaces()[0].getGeneric(0).resolve();
		System.out.println("c   "+c);
		System.out.println("d   "+d);
		//上面的c与d一样 说明resolvableType1.as(Service2.class)与resolvableType1.getInterfaces()[0]
		//是一样的 都是返回resolvableType1 实现的某个接口
		
		System.out.println("__________");		
	}
}

package com;


import org.springframework.core.ResolvableType;


interface Service3<N, M> {}
class ServiceImpl3<N,M> implements Service<N, M>{}

class C3 {}
class D3 {}

class CDService3 extends ServiceImpl<C3, D3> {}

public class TestGenericClass3 {
	
	public static void main(String[] args) {
		ResolvableType resolvableType1 = ResolvableType.forClass(CDService3.class);  
		Class c=resolvableType1.as(ServiceImpl.class).getGeneric(0).resolve();
		System.out.println("c   "+c);
	}
}

获得成员变量的泛型类型

package com;

import org.springframework.core.ResolvableType;
import org.springframework.util.ReflectionUtils;

interface Service4<N, M> {}
class ServiceImpl4<N,M> implements Service<N, M>{}

class C4 {}

class D4 {}

class CDService4 extends ServiceImpl4<C4, D4> {
}


public class TestGenericClass4 {
	private Service<C, D> cdService;
	
	public static void main(String[] args) {


		ResolvableType resolvableType2 =  
                ResolvableType.forField(ReflectionUtils.findField(TestGenericClass.class, "cdService")); 
		System.out.println(resolvableType2.getGeneric(0).resolve());
			
	}
}

在含泛型的父类中,获得子类的参数

package com;

import org.springframework.core.ResolvableType;
import org.springframework.util.ClassUtils;

interface Service<N, M> {
}
class ServiceImpl<N,M> implements Service<N, M>{
	private Class<?> entityN;
	private Class<?> entityM;
	
	public ServiceImpl(){
		System.out.println("this is "+this.getClass());
		//用于避过aop 获得原始的类型
		Class<?> childClass=ClassUtils.getUserClass(this.getClass());
		if (childClass.equals(this.getClass())) {
			System.out.println("一样");
		}
		ResolvableType resolvableType1 = ResolvableType.forClass(childClass);  
		entityN=resolvableType1.as(ServiceImpl.class).getGeneric(0).resolve();
		entityM=resolvableType1.as(ServiceImpl.class).getGeneric(1).resolve();
		System.out.println(entityN+"  **  "+entityM);
	}
}
class A {}

class B {}


class ABService extends ServiceImpl<A, B> {


}


public class TestGenericClass {
	
	public static void main(String[] args) {
	
		Service<A, B> abService= (Service<A, B>) new ABService();
		System.out.println("************* "+abService);		
	}
}

参考资料