本人需将查询结果处理拼接成jsonObject传入js，echarts生成图表
每个图表所需拼接返回的json数据格式不一样。
比如如下格式json 和List
存储数据格式

{
    
    
  "@class": "com.alibaba.fastjson.JSONObject",
  "result_data": [
    "java.util.ArrayList",
    [
      {
    
    
        "@class": "com.alibaba.fastjson.JSONObject",
        "title": "TOP5省份地区"
      },
      [
        "java.util.ArrayList",
        [
          "TOP5公司"
        ]
      ],
      [
        "java.util.ArrayList",
        [
          {
    
    
            "@class": "com.alibaba.fastjson.JSONObject",
            "max": 548015,
            "name": "上海市"
          },
          {
    
    
            "@class": "com.alibaba.fastjson.JSONObject",
            "max": 548015,
            "name": "浙江省"
          },
          {
    
    
            "@class": "com.alibaba.fastjson.JSONObject",
            "max": 548015,
            "name": "江苏省"
          }
        ]
      ],
      [
        "java.util.ArrayList",
        [248015,71583,51219,28074,17511]
      ]
    ]
  ]
}

List<T>
"[{\"sfdq\":\"上海市\",\"numbers\":248015},{\"sfdq\":\"浙江省\",\"numbers\":71583},{\"sfdq\":\"江苏省\",\"numbers\":51219},{\"sfdq\":\"广州市\",\"numbers\":28074},{\"sfdq\":\"北京市\",\"numbers\":17511}]"

本人使用springboot2+lettuce 连接redis

1. pom.xml文件增加 redis

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2. 增加redis配置类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;
import org.springframework.cache.interceptor.KeyGenerator;

import javax.annotation.Resource;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class RedisTemplateConfig {
    
    


    @Configuration
    public class RedisConfig {
    
    

        @Resource
        private LettuceConnectionFactory lettuceConnectionFactory;
                private Logger logger= LoggerFactory.getLogger(RedisConfig.class);
        private Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //缓存生存时间

        private Duration timeToLive = Duration.ofDays(1);

        @Bean
        public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    
    

            //redis缓存配置
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(this.timeToLive)
                    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
                    .disableCachingNullValues();
            Map<String, RedisCacheConfiguration> cacheConfigurationMap = new HashMap<>();
            cacheConfigurationMap.put("users", config);
            cacheConfigurationMap.put("default", config);
            RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
                    .cacheDefaults(config)
                    .transactionAware()
                    .withInitialCacheConfigurations(cacheConfigurationMap)
                    .build();
//            logger.debug("自定义RedisCacheManager加载完成");
            return redisCacheManager;
        }

        @Bean(name = "redisTemplate")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    
    
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            redisTemplate.setKeySerializer(keySerializer());
            redisTemplate.setHashKeySerializer(keySerializer());
            redisTemplate.setValueSerializer(valueSerializer());
            redisTemplate.setHashValueSerializer(valueSerializer());
            logger.debug("自定义RedisTemplate加载完成");
            return redisTemplate;
        }

        private RedisSerializer<String> keySerializer() {
    
    
            return new StringRedisSerializer();
        }

        private RedisSerializer<Object> valueSerializer() {
    
    
            return new GenericJackson2JsonRedisSerializer();
        }

        @Bean
        public KeyGenerator myKeyGenerator() {
    
    
            return (target, method, params) -> {
    
    
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
    
    
                    sb.append(obj.toString());
                }
                return sb.toString();
            };

        }
    }
}

3. 自动装配redisTemplate

@Controller
public class XXXController {
    
    
    @Autowired
    private RedisTemplate redisTemplate;

}

4. 将数据存、取redis

对应方法内调用redusTemplate方法

//k-v
//存
List<ProvinceData> provinceDatas = mysql查询结果生成的List<T>;
redisTemplate.opsForValue().set("provinceTop5", JSON.toJSON(provinceDatas).toString());
//取
String result = redisTemplate.opsForValue().get("provinceTop5").toString();
List<ProvinceData> provinceTop5 = JSON.parseArray(result, ProvinceData.class);
//------------------------------------------------------------------------------------------------
//hash
//存
redisTemplate.opsForHash().put("mv", "sumofyesterday", sumofyesterday);
//取
String rateofpredict = redisTemplate.opsForHash().get("mv", "sumofyesterday").toString();