java泛型:通过自定义ParameterizedType实现参数化类型中类型参数的替换

需求说明

如果要动态构造一个泛型参数对象(ParameterizedType),guava提供的TypeToken工具可以部分实现这个功能: 比如下面这个例子(来自guava wiki TypeToken),可以根据需要定制一个指定K,V类型的Map。

static <K, V> TypeToken<Map<K, V>> mapToken(TypeToken<K> keyToken, TypeToken<V> valueToken) {
  // where 方法是个神器,返回可以指定K,V参数类型
  return new TypeToken<Map<K, V>>() {}
    .where(new TypeParameter<K>() {}, keyToken)
    .where(new TypeParameter<V>() {}, valueToken);
}
...
TypeToken<Map<String, BigInteger>> mapToken = mapToken(
   TypeToken.of(String.class),
   TypeToken.of(BigInteger.class));
TypeToken<Map<Integer, Queue<String>>> complexToken = mapToken(
   TypeToken.of(Integer.class),
   new TypeToken<Queue<String>>() {});

但是guava提供的这个方法只能只能根据TypeParameter构造一个新的ParameterizedType,如果想根据一个已有的ParameterizedType对象替换其中的参数,上面的方法并不能实现。

比如,已经有一个Map<String, Integer>类型(也可能是HashMap,LinkedMap,Hashtable,…),现在希望将它的value type改为java.util.Date ,构造一个Map<String, Date>类型。 其实既然TypeToken工具能根据TypeParameter构造一个新的ParameterizedType,实现上面这个需求并不复杂,不知道为什么guava没有提供这个方法(我用的版本是16)。 实现这个需求最关键的就是要有一个ParameterizedType接口的实现类,有了这个实现类,你想怎么替换都成。 可惜,不论是jdk还是guava的 ParameterizedTypeImpl类都不是public的,所以没办法直接拿来用。所以就只能自己造一个。 虽然 ParameterizedType接口方法也没几个,但如何自己写个ParameterizedTypeImpl呢? 别逗了,还真打算从头自己写一个啊,再说自己的写的敢用么? 直接把jdk中的ParameterizedTypeImpl代码抄来改改就可以啦

其实这个问题我也是琢磨了好长时间才想通的。

于是我把sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl的代码几乎是原封不动的抄来,在此基础上根据需要增加了构造方法和transform方法实现了参数类型替换。完整代码如下(中文注释部分是我增加的方法),代码中用到了guava中的TypeToken工具类实现,只是为了少写些代码。

实现代码

ParameterizedTypeImpl.java

package gu.rpc.thrift;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;

import java.lang.reflect.MalformedParameterizedTypeException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Arrays;

import com.google.common.reflect.TypeToken;

/**
 * 基于jdk1.7中 {@link sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl}实现
 * @author guyadong
 *
 */
@SuppressWarnings("restriction")
class ParameterizedTypeImpl implements ParameterizedType {
    private Type[] actualTypeArguments;
    private Class<?> rawType;
    private Type ownerType;
    /**
     * 构造方法
     * 基于已有{@link ParameterizedType}实例构造一个新对象
     * @param source 不可为{@link null}
     */
    ParameterizedTypeImpl(ParameterizedType source){
        this(TypeToken.of(checkNotNull(source)).getRawType(),source.getActualTypeArguments(),source.getOwnerType());
    }
    ParameterizedTypeImpl(Class<?> rawType, Type[] actualTypeArguments, Type ownerType) {
        this.actualTypeArguments = actualTypeArguments;
        this.rawType = rawType;
        this.ownerType = ownerType != null ? ownerType : rawType.getDeclaringClass();
        this.validateConstructorArguments();
    }

    private void validateConstructorArguments() {
        TypeVariable<?>[] formals = this.rawType.getTypeParameters();
        if (formals.length != this.actualTypeArguments.length) {
            throw new MalformedParameterizedTypeException();
        }
        for (int i = 0; i < this.actualTypeArguments.length; ++i) {
        }
    }

    @Override
    public Type[] getActualTypeArguments() {
        return (Type[]) this.actualTypeArguments.clone();
    }

    @Override
    public Class<?> getRawType() {
        return this.rawType;
    }

    @Override
    public Type getOwnerType() {
        return this.ownerType;
    }

    public boolean equals(Object o) {
        if (o instanceof ParameterizedType) {
            ParameterizedType that = (ParameterizedType) o;
            if (this == that) {
                return true;
            }
            Type thatOwner = that.getOwnerType();
            Type thatRawType = that.getRawType();
            return (this.ownerType == null ? thatOwner == null : this.ownerType.equals(thatOwner))
                    && (this.rawType == null ? thatRawType == null : this.rawType.equals(thatRawType))
                    && Arrays.equals(this.actualTypeArguments, that.getActualTypeArguments());
        }
        return false;
    }

    public int hashCode() {
        return Arrays.hashCode(this.actualTypeArguments) ^ (this.ownerType == null ? 0 : this.ownerType.hashCode())
                ^ (this.rawType == null ? 0 : this.rawType.hashCode());
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        if (this.ownerType != null) {
            if (this.ownerType instanceof Class) {
                sb.append(((Class) this.ownerType).getName());
            } else {
                sb.append(this.ownerType.toString());
            }
            sb.append(".");
            if (this.ownerType instanceof ParameterizedTypeImpl) {
                sb.append(this.rawType.getName()
                        .replace(((ParameterizedTypeImpl) this.ownerType).rawType.getName() + "$", ""));
            } else {
                sb.append(this.rawType.getName());
            }
        } else {
            sb.append(this.rawType.getName());
        }
        if (this.actualTypeArguments != null && this.actualTypeArguments.length > 0) {
            sb.append("<");
            boolean first = true;
            for (Type t : this.actualTypeArguments) {
                if (!first) {
                    sb.append(", ");
                }
                if (t instanceof Class) {
                    sb.append(((Class) t).getName());
                } else {
                    sb.append(t.toString());
                }
                first = false;
            }
            sb.append(">");
        }
        return sb.toString();
    }
    /**
     * 将当前对象的类型参数中为{@code oldType}的元素替换为{@code newType}
     * @param oldType 不可为{@code null}
     * @param newType 不可为{@code null}
     * @return
     */
    public ParameterizedType transform(Type oldType,Type newType ){     
        checkNotNull(oldType);
        checkNotNull(newType);
        Type[] typeArgs = getActualTypeArguments();
        for(int i =0 ;i<typeArgs.length;++i){
            if(typeArgs[i]==oldType)
                typeArgs[i] = newType;
        }
        return new ParameterizedTypeImpl(TypeToken.of(this).getRawType(), typeArgs, getOwnerType());
    }
    /**
     * 用指定的类型参数替换当前对象的类型参数<br>
     * 新参数的个数与当前对象的类型参数个数必须一致,
     * 如果新参数数组中元素为{@code null}则对应的参数不会被替换
     * @param newTypeArguments
     * @return
     */
    public ParameterizedType transform(Type[] newTypeArguments){
        checkNotNull(newTypeArguments);
        Type[] typeArgs = getActualTypeArguments();
        checkArgument(newTypeArguments.length == typeArgs.length );
        for(int i=0;i<typeArgs.length;++i){
            if(null != newTypeArguments[i]){
                typeArgs[i] = newTypeArguments[i];
            }
        }
        return new ParameterizedTypeImpl(TypeToken.of(this).getRawType(), typeArgs, getOwnerType());
    }
}

JUnit测试用例:

TestPamameterizedImpl.java

package gu.rpc.thrift;

import java.lang.reflect.ParameterizedType;
import java.util.HashMap;
import org.junit.Test;

import com.google.common.reflect.TypeToken;

public class TestPamameterizedImpl {

    @SuppressWarnings("serial")
    @Test
    public void test() {
        TypeToken<HashMap<String, Long>> token = new TypeToken<HashMap<String,Long>>(){};
        System.out.println("oldType:"+token.getType());
        ParameterizedType newType = new ParameterizedTypeImpl((ParameterizedType) token.getType()).transform(Long.class, java.util.Date.class);
        System.out.println("newType:"+newType);
    }
}

测试输出:

oldType:java.util.HashMap<java.lang.String, java.lang.Long>
newType:java.util.HashMap<java.lang.String, java.util.Date>

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏后端之路

Dubbo优雅服务降级之Stub和回声服务

上篇Dubbo优雅服务降级之mock描述了关于mock的细节。此篇就详述一下关于Stub的实现。 在dubbo的官方文档中写道 Mock是Stub的一个子集,...

2419
来自专栏一枝花算不算浪漫

使用OkHttpClient处理json请求处理的方式

893
来自专栏wannshan(javaer,RPC)

dubbo消费方服务调用过程源码分析

dubbo PRC服务调用过程很复杂,这里准备通过分析一个典型rpc方法调用的调用栈来说明调用过程。说它典型,是因为本次分析的调用场景很典型简单 先定义一个接...

7958
来自专栏java达人

SpringMVC下Excel文件的上传下载

在实际应用中,经常会遇到上传Excel或者下载Excel的情况,比如导入数据、下载统计数据等等场景。针对这个问题,我写了个基于SpringMVC的简单上传下载示...

2019
来自专栏菩提树下的杨过

利用Spring MVC搭建REST Service

之前写过一篇 利用JAX-RS快速开发RESTful 服务 今天来看下spring-mvc框架如何实现类似的功能:  一、pom.xml 1 <?xml v...

18110
来自专栏Java成神之路

Java钉钉开发_03_通讯录管理之 人员管理 和 部门管理

822
来自专栏吴小龙同學

Android Retrofit 2.0 使用-补充篇

推荐阅读,猛戳: 1、Android MVP 实例 2、Android Retrofit 2.0使用 3、RxJava 4、RxBus 5、Android MV...

28410
来自专栏Java成神之路

Java微信公众平台开发_06_素材管理

952
来自专栏Netkiller

Elasticsearch 急速入门·文档与搜索

节选自《Netkiller Database 手札》 60.2. 文档API 60.2.1. 快速上手 文档通过 _index、_type、_id 元数据(me...

3926
来自专栏拂晓风起

jQuery 和 json 简单例子(注意callback函数的处理!!) (servlet返回json,jquery更新,java json)

863

扫码关注云+社区