获取泛型值ParameterizedType

获取泛型值ParameterizedType

ParameterizedType详解

ParameterizedType详解参数化类型

public interface ParameterizedType extends Type {    Type[] getActualTypeArguments();

Type getRawType();

Type getOwnerType();}

何为参数化类型

列举一个实体类用代码来解释什么是参数化类型

public class ParameterizedBean {    List list1;    List list2;    Map map1;    Map map2;    Map.Entry map3;}

测试代码

Field[] fields = ParameterizedBean.class.getDeclaredFields();for(Field f:fields){    //是不是参数化类型ParameterizedType    System.out.print(f.getName()+":"+(f.getGenericType() instanceof ParameterizedType));}

打印结果

list1:true

list2:false

map1:true

map2:false

map3:true

从打印结果看来,具有<>符号的变量是参数化类型

Type[] getActualTypeArguments()返回泛型中的多个参数

该方法返回一个Type数组

测试代码

Field[] fields = ParameterizedBean.class.getDeclaredFields();for(Field f:fields){    if(f.getGenericType() instanceof ParameterizedType){        ParameterizedType pType =(ParameterizedType) f.getGenericType();System.out.print("变量："+pType.getTypeName()+"     ");              Type[] types =pType.getActualTypeArguments();              for(Type t:types){System.out.print("类型："+t.getTypeName());              }}

先把实体类放下来，免得往上翻

public class ParameterizedBean {    List list1;    List list2;    Map map1;    Map map2;    Map.Entry map3;}

打印结果

变量：list1     类型：java.lang.String变量：map1     类型：java.lang.String类型：java.lang.Long变量：map3     类型：java.lang.Long类型：java.lang.Short

从打印结果返回来看,getActualTypeArguments()返回了一个Type数组,数组里是参数化类型的参数

Type getRawType() 获取变量的类型

还是用代码最有说服力

测试代码

Field[] fields =  ParameterizedBean.class.getDeclaredFields();    for(Field f:fields){    if(f.getGenericType() instanceof ParameterizedType){        ParameterizedType pType = (ParameterizedType) f.getGenericType();System.out.print("变量："+f.getName());System.out.print("RawType："+pType.getRawType().getTypeName();    }}

先放实体类

public class ParameterizedBean {    List list1;    List list2;    Map map1;    Map map2;    Map.Entry map3;}

打印结果

变量：list1     RawType：java.util.List

变量：map1     RawType：java.util.Map

变量：map3     RawType：java.util.Map$Entry

从打印结果来看,其实也就是变量的类型

Type getOwnerType()

这个不太好理解,好不好理解代码都能解释清楚

测试代码

Field[] fields =  ParameterizedBean.class.getDeclaredFields();    for(Field f:fields){    if(f.getGenericType() instanceof ParameterizedType){        ParameterizedType pType = (ParameterizedType) f.getGenericType();System.out.print("变量："+f.getName());        Type t = pType.getOwnerType();        if(t == null){System.out.print("OwnerType:Null     ");        }else{       System.out.print("OwnerType："+t.getTypeName());         }    }}

先放实体类

public class ParameterizedBean {    List list1;    List list2;    Map map1;    Map map2;    Map.Entry map3;}

打印结果

变量：list1     OwnerType:Null

变量：map1     OwnerType:Null

变量：map3     OwnerType：java.util.Map

从打印结果来看,前面两个都为null,最后一个为Map类型

这里放一下官方解释

Returns a {@code Type} object representing the type that this type is a member of

1

例子

For example, if this type is {@code O.I},return a representation of {@code O}

1

依据解释,我们知道

O.I类型的变量,调用getOwnerType()会返回O

1

以上就是ParameterizedType的内容

public static Class getSuperClassGeneric(final Class subClass, final Class superClass) {

//获取直接父类（包括父类的泛型）

Type type = subClass.getGenericSuperclass();

//参数化类型ParameterizedType（带泛型的类型）。instanceof ParameterizedType判断是不是参数化类型。

if (type instanceof ParameterizedType) {

ParameterizedType parameterizedType = (ParameterizedType)type;

// getRawType获取当前变量的类型。(Class)parameterizedType变量的类型。

Class rawType = (Class)parameterizedType.getRawType();

// getActualTypeArguments获取泛型中的多个参数。

return rawType.equals(superClass) ? (Class)parameterizedType.getActualTypeArguments()[0] : null;

} else {

return getSuperClassGeneric((Class)type, superClass);

}

}

void registeredMessageFilter(final Class processFilterClazz, final Class processorClazz) {

Class messageClazz = GenericUtils.getSuperClassGeneric(processFilterClazz, AbstractMessageProcessFilter.class);

//Java1.8时。若K对应的value为空，将第二个参数的值返回并存入。

this.messageProcessFilterMap.computeIfAbsent(messageClazz, (k) -> {

return new LinkedHashSet();

});

AbstractMessageProcessFilter messageProcessFilter = (AbstractMessageProcessFilter)this.context.getBean(processFilterClazz);

messageProcessFilter.init(processorClazz);

((Set)this.messageProcessFilterMap.get(messageClazz)).add(messageProcessFilter);

}

package com.hsbc.tt.boi.batchservicecommon.dispatch.processor.filter;

import com.hsbc.tt.boi.batchservicecommon.dispatch.annotation.DataDependency;

import com.hsbc.tt.boi.batchservicecommon.dispatch.annotation.MasterDependencies;

import com.hsbc.tt.boi.batchservicecommon.dispatch.annotation.MultiDataDependency;

import com.hsbc.tt.boi.batchservicecommon.dispatch.core.AbstractMessageProcessFilter;

import com.hsbc.tt.boi.batchservicecommon.dispatch.dto.CommonDataStatusDto;

import com.hsbc.tt.boi.batchservicecommon.dispatch.dto.Status;

import com.hsbc.tt.boi.batchservicecommon.dispatch.processor.MasterServiceClient;

import com.hsbc.tt.boi.batchservicecommon.exception.notready.NoReadyException;

import com.hsbc.tt.boi.common.dto.RoutingPayload;

import com.hsbc.tt.boi.common.htsmsgentity.sodmess.Sodmess;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.Set;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Component;

@Component

@Scope("prototype")

public class DependenceFilter extends AbstractMessageProcessFilter {

private static final Logger log = LoggerFactory.getLogger(DependenceFilter.class);

private static final String DEFAULT_DEPENDENCY_SERVICE = "MasterData";

private final Map> serviceDependency = new HashMap();

@Autowired

private MasterServiceClient masterServiceClient;

public DependenceFilter() {

}

//容器初始化时调用

public void init(final Class processorClazz) {

int var5;

//A.isAnnotationPresent(B)判断A类上是否有B类型的注解。

if (processorClazz.isAnnotationPresent(MasterDependencies.class)) {

MasterDependencies annotation = (MasterDependencies)processorClazz.getAnnotation(MasterDependencies.class);

Set checkEntity = new LinkedHashSet();

Class[] var4 = annotation.dependencies();

var5 = var4.length;

for(int var6 = 0; var6 < var5; ++var6) {

Class masterEntityClazz = var4[var6];

checkEntity.add(masterEntityClazz.getSimpleName());

}

this.serviceDependency.put("MasterData", checkEntity);

}

if (processorClazz.isAnnotationPresent(DataDependency.class)) {

DataDependency annotation = (DataDependency)processorClazz.getAnnotation(DataDependency.class);

this.buildDataDependency(annotation);

}

if (processorClazz.isAnnotationPresent(MultiDataDependency.class)) {

MultiDataDependency annotation = (MultiDataDependency)processorClazz.getAnnotation(MultiDataDependency.class);

DataDependency[] var10 = annotation.value();

int var11 = var10.length;

for(var5 = 0; var5 < var11; ++var5) {

DataDependency a = var10[var5];

this.buildDataDependency(a);

}

}

}

private void buildDataDependency(final DataDependency annotation) {

Set checkEntity = new LinkedHashSet();

Class[] var3 = annotation.dependencies();

int var4 = var3.length;

for(int var5 = 0; var5 < var4; ++var5) {

Class masterEntityClazz = var3[var5];

checkEntity.add(masterEntityClazz.getSimpleName());

}

checkEntity.addAll(Arrays.asList(annotation.dependencyClassNames()));

this.serviceDependency.put(annotation.service(), checkEntity);

}

public void before(final Sodmess message, final RoutingPayload routingPayload, final Class processorClazz) {

this.serviceDependency.forEach((serviceName, dependEntities) -> {

this.checkDependency(routingPayload, serviceName, dependEntities);

});

}

private void checkDependency(final RoutingPayload routingPayload, String serviceName, Set dependEntities) {

CommonDataStatusDto query = new CommonDataStatusDto();

query.setBusinessDate(routingPayload.getBusinessDate());

query.setCountryCode(routingPayload.getCountryCode());

query.setGroupMemberCode(routingPayload.getGroupMemberCode());

query.setCommonDataTypes(new ArrayList(dependEntities));

Status status = this.masterServiceClient.checkStatus(serviceName, query);

if (Status.NOT_READY == status) {

try {

Thread.sleep(3000L);

} catch (InterruptedException var7) {

log.error(var7.getMessage(), var7);

Thread.currentThread().interrupt();

}

throw new NoReadyException(serviceName + " data not ready! " + dependEntities);

}

}

public void after(final Sodmess message, final RoutingPayload routingPayload, final Class processorClazz) {

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。