Redis缓存,泛型集合与json字符串的相互转换实例

难点是泛型如何转换

一、arrayList<Map<String, Object>>转化json字符串,存入redis缓存

    ArrayList<Map<String, Object>> listProfit
    //将ArrayList<Map<String, Object>>类型数据转换成json字符串

    String listProfitPctJsonStr = JSON.toJSONString(listProfit); 

    //然后将json字符串存入redis缓存,唯一key value
    JedisUtils.setex("listProfit", 600,listProfitPctJsonStr);

二、json字符串转回ArrayList<Map<String, Object>>(难点)

 List<Map<String, Object>> listProfit=null;
 //先从redis里面去查询数据,看是否能获取到对应json字符串
 String jsonStrLp=JedisUtils.get("listProfit");

//如果能获取则说明缓存中有数据

if(!StringUtils.isBlank(jsonStrLp)){

  //目的是为了泛型的转换

  listProfit=new ArrayList<Map<String,Object>>();

  //先把从redis缓存中取出来的json字符串转为List<Map>集合

  List<Map> mapList=JSON.parseArray(jsonStrLp, Map.class);

  //然后循环遍历这个List集合,得出的结果为Map,然后再强转为Map<String,Object>,

     再循环 把 Map<String,Object>添加到List集合中,搞定!!!

  for (Map map : mapList) {
    Map<String,Object> sObj=(Map<String,Object>)map;
    listProfit.add(sObj);
}

补充知识:Java的List和Json转换以及StringRedisTemplate往redis存泛型对象

List转Json

List<User> user= new ArrayList();

String str = JSON.toJSONString(user);

Json 转List方法一

List<User> user= JSON.parseArray(json,User.class);

如果是泛型方法需要使用TypeReference

Json 转List 方法二

String json = "[{}]";

List<user> user= JSON.parseObject(json,new TypeReference<List<User>>(){});

泛型T

Json 转List方法三

List<T> students = JSON.parseObject(listCache,new TypeReference<List<T>>(){});

综合例子:Springboot环境下利用StringRedisTemplate往redis存泛型对象

一开始要注入下StringRedisTemplate

@Autowired

private StringRedisTemplate redisTemplate;

Redis获取值不存在就从数据库取出来json化存缓存,存在则直接反序列化json为List

List<T> list;
String listCache=redisTemplate.opsForValue().get(key);
if(listCache!=null){
  list = JSON.parseObject(listCache,new TypeReference<List<T>>(){});
}
else {
  list = userService.getAllList();
  redisTemplate.opsForValue().set(key, JSON.toJSONString(list), 60 * 1, TimeUnit.SECONDS);
}

附录:TypeReference源码

package com.alibaba.fastjson;

import java.lang.reflect.GenericArrayType;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import com.alibaba.fastjson.util.ParameterizedTypeImpl;
import com.alibaba.fastjson.util.TypeUtils;

/**
 * Represents a generic type {@code T}. Java doesn't yet provide a way to
 * represent generic types, so this class does. Forces clients to create a
 * subclass of this class which enables retrieval the type information even at
 * runtime.
 *
 * <p>For example, to create a type literal for {@code List<String>}, you can
 * create an empty anonymous inner class:
 *
 * <pre>
 * TypeReference&lt;List&lt;String&gt;&gt; list = new TypeReference&lt;List&lt;String&gt;&gt;() {};
 * </pre>
 * This syntax cannot be used to create type literals that have wildcard
 * parameters, such as {@code Class<?>} or {@code List<? extends CharSequence>}.
 */
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;
  }

  /**
   * @since 1.2.9
   * @param actualTypeArguments
   */
  protected TypeReference(Type... actualTypeArguments){
    Class<?> thisClass = this.getClass();
    Type superClass = thisClass.getGenericSuperclass();

    ParameterizedType argType = (ParameterizedType) ((ParameterizedType) superClass).getActualTypeArguments()[0];
    Type rawType = argType.getRawType();
    Type[] argTypes = argType.getActualTypeArguments();

    int actualIndex = 0;
    for (int i = 0; i < argTypes.length; ++i) {
      if (argTypes[i] instanceof TypeVariable &&
          actualIndex < actualTypeArguments.length) {
        argTypes[i] = actualTypeArguments[actualIndex++];
      }
      // fix for openjdk and android env
      if (argTypes[i] instanceof GenericArrayType) {
        argTypes[i] = TypeUtils.checkPrimitiveArray(
            (GenericArrayType) argTypes[i]);
      }

      // 如果有多层泛型且该泛型已经注明实现的情况下,判断该泛型下一层是否还有泛型
      if(argTypes[i] instanceof ParameterizedType) {
        argTypes[i] = handlerParameterizedType((ParameterizedType) argTypes[i], actualTypeArguments, actualIndex);
      }
    }

    Type key = new ParameterizedTypeImpl(argTypes, thisClass, rawType);
    Type cachedType = classTypeCache.get(key);
    if (cachedType == null) {
      classTypeCache.putIfAbsent(key, key);
      cachedType = classTypeCache.get(key);
    }

    type = cachedType;
  }
  private Type handlerParameterizedType(ParameterizedType type, Type[] actualTypeArguments, int actualIndex) {
    Class<?> thisClass = this.getClass();
    Type rawType = type.getRawType();
    Type[] argTypes = type.getActualTypeArguments();

    for(int i = 0; i < argTypes.length; ++i) {
      if (argTypes[i] instanceof TypeVariable && actualIndex < actualTypeArguments.length) {
        argTypes[i] = actualTypeArguments[actualIndex++];
      }

      // fix for openjdk and android env
      if (argTypes[i] instanceof GenericArrayType) {
        argTypes[i] = TypeUtils.checkPrimitiveArray(
            (GenericArrayType) argTypes[i]);
      }

      // 如果有多层泛型且该泛型已经注明实现的情况下,判断该泛型下一层是否还有泛型
      if(argTypes[i] instanceof ParameterizedType) {
        return handlerParameterizedType((ParameterizedType) argTypes[i], actualTypeArguments, actualIndex);
      }
    }

    Type key = new ParameterizedTypeImpl(argTypes, thisClass, rawType);
    return key;
  }

  /**
   * Gets underlying {@code Type} instance.
   */
  public Type getType() {
    return type;
  }

  public final static Type LIST_STRING = new TypeReference<List<String>>() {}.getType();
}

TypeReference的存在是因为java中子类可以获取到父类泛型的真实类型。

其中核心的方法是:getActualTypeArguments,它可以得到父类的反省类型

ParameterizedType是一个记录类型泛型的接口, 继承自Type,一共三方法:

Type[] getActualTypeArguments(); //返回泛型类型数组

Type getRawType(); //返回原始类型Type

Type getOwnerType(); //返回 Type 对象,表示此类型是其成员之一的类型。
Map<String, Integer> intMap = new HashMap<>();
    System.out.println("getSuperclass:" + intMap.getClass().getSuperclass());
    System.out.println("getGenericSuperclass:" + intMap.getClass().getGenericSuperclass());
    Type type = intMap.getClass().getGenericSuperclass();
    if (type instanceof ParameterizedType) {
      ParameterizedType p = (ParameterizedType)type;
      for (Type t : p.getActualTypeArguments()) {
        System.out.println("getActualTypeArguments>>>"+t);
      }
    }

扩展阅读Java如何获得泛型类的真实类型:

package com.paopaoedu.springboot.demo;

import com.paopaoedu.springboot.bean.User;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class BaseDao<T>{

  private Class<T> clazz;

  // 使用反射技术得到T的真实类型
  public Class getRealType(){
    Class c=this.getClass();
    //getSuperclass()获得该类的父类
    System.out.println("getSuperclass    >>>"+c.getSuperclass());
    //getGenericSuperclass()获得带有泛型的父类
    System.out.println("getGenericSuperclass >>>"+c.getGenericSuperclass());
    //Type是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
    Type type=c.getGenericSuperclass();
    System.out.println("Type         >>>"+type);

    //ParameterizedType参数化类型,即泛型
    // 获取当前new的对象的泛型的父类类型
    ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
    // 获取第一个类型参数的真实类型
    this.clazz = (Class<T>) pt.getActualTypeArguments()[0];

    c=(Class) pt.getActualTypeArguments()[0];
    System.out.println(c);

    return clazz;
  }
}

class userdemo extends BaseDao<User>{

  public static void main(String[] args) {
    userdemo classB = new userdemo();
    Class realType = classB.getRealType();
    System.out.println(realType.getName());
  }
}

以上这篇Redis缓存,泛型集合与json字符串的相互转换实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • JSON的String字符串与Java的List列表对象的相互转换

    在前端: 1.如果json是List对象转换的,可以直接遍历json,读取数据. 2.如果是需要把前端的List对象转换为json传到后台,param是ajax的参数,那么转换如下所示: var jsonStr = JSON.stringify(list); var param= {}; param.jsonStr=jsonStr; 在后台: 1.把String转换为List(str转换为list) List<T> list = new ArrayList<T>(); JSONAr

  • Json对象与Json字符串互转(4种转换方式)

    1>jQuery插件支持的转换方式: 复制代码 代码如下: $.parseJSON( jsonstr ); //jQuery.parseJSON(jsonstr),可以将json字符串转换成json对象 2>浏览器支持的转换方式(Firefox,chrome,opera,safari,ie9,ie8)等浏览器: 复制代码 代码如下: JSON.parse(jsonstr); //可以将json字符串转换成json对象 JSON.stringify(jsonobj); //可以将json对象转换

  • Java实现Json字符串与Object对象相互转换的方式总结

    本文实例总结了Java实现Json字符串与Object对象相互转换的方式.分享给大家供大家参考,具体如下: Json-Lib.Org.Json.Jackson.Gson.FastJson五种方式转换json类型 只列举了最省事的方式.不涉及复制情况和速度. 测试用例,一个User类,属性name,age,location.重写toString(). public class User { private String name; private Integer age; private Stri

  • 解析JSON对象与字符串之间的相互转换

    在开发的过程中,如果对于少量参数的前后台传递,可以直接采用ajax的data函数,按json格式传递,后台Request即可,但有的时候,需要传递多个参数,这样后台 接受的时候Request多个很麻烦,此时要按照类的格式或者 集合的形式进行传递. 例如:前台按类的格式传递JSON对象: var jsonUserInfo = "{\"TUserName\":\"" + userName + "\",\"TInterest\&qu

  • Redis缓存,泛型集合与json字符串的相互转换实例

    难点是泛型如何转换 一.arrayList<Map<String, Object>>转化json字符串,存入redis缓存 ArrayList<Map<String, Object>> listProfit //将ArrayList<Map<String, Object>>类型数据转换成json字符串 String listProfitPctJsonStr = JSON.toJSONString(listProfit); //然后将j

  • Go 结构体、数组、字典和 json 字符串的相互转换方法

    Go 语言中 encoding/json 包可以很方便的将结构体.数组.字典转换为 json 字符串. 引用 import "encoding/json" 解析语法 // v 传入结构体.数组等实例变量 // []byte 字节数组 // error 可能会有的错误 func Marshal(v interface{}) ([]byte, error) 反解析 // []byte 字节数组 // v 传入结构体.数组等实例变量的指针地址 // error 可能会有的错误 func Un

  • Scala解析Json字符串的实例详解

    Scala解析Json字符串的实例详解 1. 添加相应依赖 Json解析工具使用的 json-smart,曾经对比过Java的fastjson.gson.Scala的json4s.lift-json.其中 json-smart 解析速度是最快的. <dependency> <groupId>net.minidev</groupId> <artifactId>json-smart</artifactId> <version>2.3<

  • 使用SpringMVC返回json字符串的实例讲解

    最近开始接触SpringMVC这个框架,这个框架使用起来很方便,框架搭起来之后,写起代码几乎都是一个模式.当然要走到这一步必须保证你的SpringMVC的相关配置都已经完成,并且配置正确! 作为我的关于S平ringMVC的首篇博客,本篇博客主要说名如何配置SpringMVC,并且可以使之正常的返回Bean实体,这里的bean实体一般返回到前端都是以Json字符串的形式返回的. 使用的开发工具为eclipse,这个也是比较大众化的开发工具了,算的上是人人都会使用的了,只是熟练程度不一样! 具体的配

  • javascript中JSON对象与JSON字符串相互转换实例

    本文实例讲述了javascript中JSON对象与JSON字符串相互转换实现方法.分享给大家供大家参考.具体如下: <script type="text/javascript"> // 根据JSON对象的属性的名称获取属性的值 var jsonObj = { name: "jxqlovejava" }; // JSON对象 console.log(jsonObj.name); // "jxqlovejava" var jsonStr

  • C#实现对Json字符串处理实例

    本文实例讲述了C#实现对Json字符串处理方法,分享给大家供大家参考.具体分析如下: 一般对于web应用开发人员来说对Json字符串都会很熟悉,其实在很多请求我们返回的都是Json字符串.那对于C#代码如何处理Json字符串呢,.Net封装了一个类叫做JavaScriptSerializer[MSDN Library 链接:http://msdn.microsoft.com/en-us/library/ee191864(v=vs.110).aspx]:这个类提供了一个方法. 下面这个是在快递10

  • 给JavaBean赋默认值并且转Json字符串的实例

    目录 JavaBean赋默认值并转Json字符串 此段代码还有值得优化的地方 javaBean对象和Json格式字符串相互转换 一.使用Jackson工具类 二.使用Gson工具类 JavaBean赋默认值并转Json字符串 今日在工作中整理dubbo接口的时候,有些接口参数类型是JavaBean类型的数据,在整理的时候又想直接将JavaBean参数直接以默认的json格式整理,于是想到如何将javaBean的默认值 直接转换成为 Json格式的数据,避免自己手动去拼写json字符串. 此段代码

  • 深入剖析构建JSON字符串的三种方式(推荐)

    前言:JSON 是轻量级的数据交换格式,很常用,尤其是在使用 Ajax 时,在后台将数据封装为 JSON 字符串更是常见.之前在做项目的时候用过几种方式在后端将数组或 List 集合转换为 JSON 字符串,现在回想起来竟然又有些遗忘.现在来一个汇总,把这几种构建 JSON 字符串的方式彻底回忆起来. 笔记中提供了大量的代码示例,需要说明的是,大部分代码示例都是本人所敲代码并进行测试,不足之处,请大家指正~ 一.alibaba 的 Fastjson 1.Fastjson 是一个以 Java 语言

  • Json字符串与Object、List、Map的互转工具类

    package com.cq2022.zago.base.util; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.StringWriter; import java.util.List; import java.util.Map; import org.codehaus.jackson.JsonFactory; import org.codehau

  • C#中对象与JSON字符串互相转换的三种方式

    JSON(JavaScriptObject Notation, JS 对象标记) 是一种轻量级的数据交换格式. 关于内存对象和JSON字符串的相互转换,在实际项目中应比较广泛,经过一番搜索,找到如下三种方法来解决此问题 分别是使用Newtonsoft.Json.dll.DataContractJsonSerializer.JavaScriptSerializer. 方法一:Newtonsoft.Json.dll Newtonsoft.Json.dll在.net2.0之后的版本可以支持 我的版本.

随机推荐