Spring Boot怎样压缩Json并写入redis？

曂沅仴駦  论坛元老 | 2024-8-28 18:19:05 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1018|帖子 1018|积分 3054

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
1.为什么需要压缩json？

由于业务需要，存入redis中的缓存数据过大，占用了10+G的内存，内存作为重要资源，需要优化一下大对象缓存，接纳gzip压缩存储，可以将 redis 的 kv 对大小缩小大约 7-8 倍，加快存储、读取速度
2.情况搭建

详建redis模块的docker目录
  1. version: '3'
  2. services:
  3.   redis:
  4.     image: registry.cn-hangzhou.aliyuncs.com/zhengqing/redis:6.0.8                  
  5.     container_name: redis                                                            
  6.     restart: unless-stopped                                                                  
  7.     command: redis-server /etc/redis/redis.conf --requirepass 123456 --appendonly no
  8. #    command: redis-server --requirepass 123456 --appendonly yes
  9.     environment:                        
  10.       TZ: Asia/Shanghai
  11.       LANG: en_US.UTF-8
  12.     volumes:                           
  13.       - "./redis/data:/data"
  14.       - "./redis/config/redis.conf:/etc/redis/redis.conf"  
  15.     ports:                              
  16.       - "6379:6379"
复制代码
3.代码工程

 实行目标

   实行存入redis的json数据压缩和解压缩  pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springboot-demo</artifactId>
  7.         <groupId>com.et</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>gzip</artifactId>
  14.     <properties>
  15.         <maven.compiler.source>8</maven.compiler.source>
  16.         <maven.compiler.target>8</maven.compiler.target>
  17.     </properties>
  18.     <dependencies>
  19.         <dependency>
  20.             <groupId>org.springframework.boot</groupId>
  21.             <artifactId>spring-boot-starter-web</artifactId>
  22.         </dependency>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-autoconfigure</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-test</artifactId>
  31.             <scope>test</scope>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>org.projectlombok</groupId>
  35.             <artifactId>lombok</artifactId>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-data-redis</artifactId>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.apache.commons</groupId>
  43.             <artifactId>commons-pool2</artifactId>
  44.             <version>2.9.0</version>
  45.         </dependency>
  47.     </dependencies>
  48. </project>
复制代码
controller

  1. package com.et.gzip.controller;
  3. import com.et.gzip.model.User;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestBody;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  12. import java.util.HashMap;
  13. import java.util.Map;
  15. @RestController
  16. @Slf4j
  17. public class HelloWorldController {
  18.     @Autowired
  19.     private RedisTemplate redisTemplateWithJackson;
  21.     @PostMapping("/hello")
  22.     public User showHelloWorld(@RequestBody User user){
  23.         log.info("user:"+ user);
  25.         return user;
  26.     }
  27.     @PostMapping("/redis")
  28.     public User redis(@RequestBody User user){
  29.         log.info("user:"+ user);
  30.         redisTemplateWithJackson.opsForValue().set("user",user);
  31.         User redisUser = (User) redisTemplateWithJackson.opsForValue().get("user");
  32.         return redisUser;
  33.     }
  34. }
复制代码
redis压缩和解压缩配置

压缩类
  1. package com.et.gzip.config;
  3. import com.et.gzip.model.User;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import com.fasterxml.jackson.databind.annotation.JsonSerialize;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.apache.tomcat.util.http.fileupload.IOUtils;
  10. import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
  11. import org.springframework.data.redis.serializer.SerializationException;
  12. import sun.misc.BASE64Encoder;
  14. import java.io.ByteArrayInputStream;
  15. import java.io.ByteArrayOutputStream;
  16. import java.text.SimpleDateFormat;
  17. import java.util.zip.GZIPInputStream;
  18. import java.util.zip.GZIPOutputStream;
  20. @Slf4j
  21. public class CompressRedis extends JdkSerializationRedisSerializer {
  23.     public static final int BUFFER_SIZE = 4096;
  25.     private JacksonRedisSerializer<User>  jacksonRedisSerializer;
  26.     public CompressRedis() {
  27.         this.jacksonRedisSerializer = getValueSerializer();
  28.     }
  30.     @Override
  31.     public byte[] serialize(Object graph) throws SerializationException {
  32.         if (graph == null) {
  33.             return new byte[0];
  34.         }
  35.         ByteArrayOutputStream bos = null;
  36.         GZIPOutputStream gzip = null;
  37.         try {
  38.             // serialize
  39.             byte[] bytes = jacksonRedisSerializer.serialize(graph);
  40.             log.info("bytes size{}",bytes.length);
  41.             bos = new ByteArrayOutputStream();
  42.             gzip = new GZIPOutputStream(bos);
  44.             // compress
  45.             gzip.write(bytes);
  46.             gzip.finish();
  47.             byte[] result = bos.toByteArray();
  49.             log.info("result size{}",result.length);
  50.             //return result;
  51.             return new BASE64Encoder().encode(result).getBytes();
  52.         } catch (Exception e) {
  53.             throw new SerializationException("Gzip Serialization Error", e);
  54.         } finally {
  55.             IOUtils.closeQuietly(bos);
  56.             IOUtils.closeQuietly(gzip);
  57.         }
  58.     }
  60.     @Override
  61.     public Object deserialize(byte[] bytes) throws SerializationException {
  62.         if (bytes == null || bytes.length == 0) {
  63.             return null;
  64.         }
  65.         ByteArrayOutputStream bos = null;
  66.         ByteArrayInputStream bis = null;
  67.         GZIPInputStream gzip = null;
  68.         try {
  69.             bos = new ByteArrayOutputStream();
  70.             byte[] compressed = new sun.misc.BASE64Decoder().decodeBuffer( new String(bytes));;
  71.             bis = new ByteArrayInputStream(compressed);
  72.             gzip = new GZIPInputStream(bis);
  73.             byte[] buff = new byte[BUFFER_SIZE];
  74.             int n;
  77.             // uncompress
  78.             while ((n = gzip.read(buff, 0, BUFFER_SIZE)) > 0) {
  79.                 bos.write(buff, 0, n);
  80.             }
  81.             //deserialize
  82.             Object result = jacksonRedisSerializer.deserialize(bos.toByteArray());
  83.             return result;
  84.         } catch (Exception e) {
  85.             throw new SerializationException("Gzip deserizelie error", e);
  86.         } finally {
  87.             IOUtils.closeQuietly(bos);
  88.             IOUtils.closeQuietly(bis);
  89.             IOUtils.closeQuietly(gzip);
  90.         }
  91.     }
  93.     private static JacksonRedisSerializer<User> getValueSerializer() {
  94.         JacksonRedisSerializer<User> jackson2JsonRedisSerializer = new JacksonRedisSerializer<>(User.class);
  95.         ObjectMapper mapper=new ObjectMapper();
  96.         jackson2JsonRedisSerializer.setObjectMapper(mapper);
  97.         return jackson2JsonRedisSerializer;
  98.     }
  100. }
复制代码
java序列化
  2. package com.et.gzip.config;
  5. import com.fasterxml.jackson.databind.JavaType;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import com.fasterxml.jackson.databind.type.TypeFactory;
  8. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.data.redis.serializer.RedisSerializer;
  11. import org.springframework.data.redis.serializer.SerializationException;
  12. import org.springframework.lang.Nullable;
  13. import org.springframework.util.Assert;
  15. import java.nio.charset.Charset;
  16. import java.nio.charset.StandardCharsets;
  18. @Slf4j
  19. public class JacksonRedisSerializer<T> implements RedisSerializer<T> {
  20.     public static final Charset DEFAULT_CHARSET;
  21.     private final JavaType javaType;
  22.     private ObjectMapper objectMapper = new ObjectMapper();
  24.     public JacksonRedisSerializer(Class<T> type) {
  25.         this.javaType = this.getJavaType(type);
  26.     }
  28.     public JacksonRedisSerializer(JavaType javaType) {
  29.         this.javaType = javaType;
  30.     }
  32.     public T deserialize(@Nullable byte[] bytes) throws SerializationException {
  33.         if (bytes == null || bytes.length == 0) {
  34.             return null;
  35.         } else {
  36.             try {
  37.                 return this.objectMapper.readValue(bytes, 0, bytes.length, this.javaType);
  39.             } catch (Exception var3) {
  40.                 throw new SerializationException("Could not read JSON: " + var3.getMessage(), var3);
  41.             }
  42.         }
  43.     }
  45.     public byte[] serialize(@Nullable Object t) throws SerializationException {
  46.         if (t == null) {
  47.             return  new byte[0];
  48.         } else {
  49.             try {
  50.                 return this.objectMapper.writeValueAsBytes(t);
  51.             } catch (Exception var3) {
  52.                 throw new SerializationException("Could not write JSON: " + var3.getMessage(), var3);
  53.             }
  54.         }
  55.     }
  57.     public void setObjectMapper(ObjectMapper objectMapper) {
  58.         Assert.notNull(objectMapper, "'objectMapper' must not be null");
  59.         this.objectMapper = objectMapper;
  60.     }
  62.     protected JavaType getJavaType(Class<?> clazz) {
  63.         return TypeFactory.defaultInstance().constructType(clazz);
  64.     }
  66.     static {
  67.         DEFAULT_CHARSET = StandardCharsets.UTF_8;
  68.     }
  69. }
复制代码
redis序列化
  1. package com.et.gzip.config;
  3. import com.et.gzip.model.User;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.serializer.RedisSerializer;
  9. import org.springframework.data.redis.serializer.StringRedisSerializer;
  12. @Configuration
  13. public class RedisWithJacksonConfig {
  16.     @Bean(name="redisTemplateWithJackson")
  17.     public RedisTemplate<String, User> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
  19.         CompressRedis  compressRedis =  new CompressRedis();
  20.         //redisTemplate
  21.         RedisTemplate<String, User> redisTemplate = new RedisTemplate<>();
  22.         redisTemplate.setConnectionFactory(lettuceConnectionFactory);
  23.         RedisSerializer<?> stringSerializer = new StringRedisSerializer();
  24.         redisTemplate.setKeySerializer(stringSerializer);
  25.         redisTemplate.setValueSerializer(compressRedis);
  26.         redisTemplate.setHashKeySerializer(stringSerializer);
  27.         redisTemplate.setHashValueSerializer(compressRedis);
  28.         redisTemplate.afterPropertiesSet();
  29.         return redisTemplate;
  30.     }
  31. }
复制代码
application.yaml

  1. spring:
  2.   redis:
  3.     host: 127.0.0.1
  4.     port: 6379
  5.     database: 10
  6.     password: 123456
  7.     timeout: 10s
  8.     lettuce:
  9.       pool:
  10.         min-idle: 0
  11.         max-idle: 8
  12.         max-active: 8
  13.         max-wait: -1ms
  14. server:
  15.   port: 8088
  16.   compression:
  17.     enabled: true
  18.     mime-types: application/json,application/xml,text/html,text/plain,text/css,application/x-javascript
复制代码
以上只是一些关键代码，所有代码请参见下面代码仓库
代码仓库



  • https://github.com/Harries/springboot-demo(gzip)
4.测试


  • 启动spring boot应用
  • 用postman访问http://127.0.0.1:8088/redis


可以看到redis内里存储的是gzip压缩的内容

查看控制台日记
  1. 2024-08-26 14:37:56.445 INFO 43832 --- [nio-8088-exec-5] com.et.gzip.config.CompressRedis : bytes size371
  2. 2024-08-26 14:37:56.445 INFO 43832 --- [nio-8088-exec-5] com.et.gzip.config.CompressRedis : result size58
复制代码
JSON颠末gzip压缩，371-->58, 数据大小减少7-8倍
5.引用



  •  Spring Boot怎样压缩Json并写入redis？ | Harries Blog™

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

曂沅仴駦

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表