继承HashMap的类中的新属性，经过json转化后get不到数据

W@#

已于 2023-05-16 15:30:50 修改

阅读量710

点赞数

分类专栏：后端异常总结文章标签： json java 开发语言

于 2023-05-16 09:48:57 首次发布

本文链接：https://blog.csdn.net/weixin_48568302/article/details/130691883

版权

后端异常总结专栏收录该内容

12 篇文章 1 订阅

订阅专栏

问题：

让R类继承HashMap，并在R类中定义一个私有属性data，通过setData()方法对data属性赋值，发现无法赋值。

public class R<T> extends HashMap<String, Object> {
	private static final long serialVersionUID = 1L;
	
	private T data;

	public T getData() {
		return data;
	}

	public void setData(T data) {
		this.data = data;
	}
    
    public R() {
		put("code", 0);
		put("msg", "success");
	}
}

解决方法：

在R中存放数据可以使用put的方式，对于map的value如果是复杂类型对象（例如：List）使用TypeReference（普通对象可以使用Class），需要先将value转化为json，在转化为所需要的类型对象。

public class R extends HashMap<String, Object> {
	private static final long serialVersionUID = 1L;


	public <T> T getData(String key,com.alibaba.fastjson.TypeReference<T> typeReference){
		Object data = get(key);
		String s = JSON.toJSONString(data);
		T t = JSON.parseObject(s, typeReference);
		return t;
	}
    
    // 使用fastjson进行逆转
	public <T> T getData(com.alibaba.fastjson.TypeReference<T> typeReference){
		Object data = get("data"); // 默认是map
		String s = JSON.toJSONString(data);
		T t = JSON.parseObject(s, typeReference);
		return t;
	}

	public R setData(Object data) {
		put("data",data);
		return this;
	}

	public R() {
		put("code", 0);
		put("msg", "success");
	}
}

注意：setData()方法不能无返回，否则通过getData()方法也是获取不到set的值。

getData()的使用：

对应上面getData()和setData()的指定。使用new TypeReference<>(){}来指定所需类型的对象，TypeReference实例化调用的是TypeReference受保护的无参构造方法，所以以内部类的方式调用。

R skusHasStock = wareFeignService.getSkusHasStock(skuIdList);
stockMap = skusHasStock.getData(new TypeReference<List<SkuHasStockVo>>(){}).stream().collect(Collectors.toMap(SkuHasStockVo::getSkuId, item -> item.getHasStock()));

TypeReference部分源码：

public class TypeReference<T> {
    static ConcurrentMap<Type, Type> classTypeCache
            = new ConcurrentHashMap<Type, Type>(16, 0.75f, 1);

    protected final Type type;

    /**
     * Constructs a new type literal. Derives represented class from type
     * parameter.
     *
     * <p>Clients create an empty anonymous subclass. Doing so embeds the type
     * parameter in the anonymous class's type hierarchy so we can reconstitute it
     * at runtime despite erasure.
     */
    protected TypeReference(){
        Type superClass = getClass().getGenericSuperclass();

        Type type = ((ParameterizedType) superClass).getActualTypeArguments()[0];

        Type cachedType = classTypeCache.get(type);
        if (cachedType == null) {
            classTypeCache.putIfAbsent(type, type);
            cachedType = classTypeCache.get(type);
        }

        this.type = cachedType;
    }
    
    ...
}

这里做下记录，不是很清楚，欢迎大佬们指导。