Jedis和JAVA对象的序列化和反序列化的使用

最新推荐文章于 2024-07-02 13:56:17 发布
最新推荐文章于 2024-07-02 13:56:17 发布
阅读量576 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuchao102/article/details/105261140
版权

1. Jedis版本: jedis-2.6.2.jar

    背景：现在系统提供portal接口服务，使用JDBC直接查询数据库，使用jedis提供的缓存功能，在JDBC前面加上Redis，先从Redis中查询数据，如果Redis中没有该数据，就从数据库中查询，再把查询到的结果放入Redis中，下次再请求该接口的时候，就直接返回Redis中的数据。

2. 序列化和反序列化的使用

    接口查询到的数据是一个List集合，把集合对象通过序列化为字符串，放入到Redis中。使用的时候取出Redis中的数据，通过反序列化为对象使用。

3. 下面是Redis和JAVA对象序列化和反序列化的应用实例

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.druid.util.StringUtils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public final class RedisUtil {
    
    //Redis服务器IP
    private static String ADDR = "192.168.7.182";
    
    //Redis的端口号
    private static int PORT = 6379;
    
    //访问密码
    private static String AUTH = "admin";
    
    //可用连接实例的最大数目，默认值为8；
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;
    
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;
    
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = 10000;
    
    private static int TIMEOUT = 10000;
    
    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    
    private static JedisPool jedisPool = null;
    
    /**
     * 初始化Redis连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            //config.setMaxActive(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            //config.setMaxWait(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            //使用Redis密码
            //jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
            //不使用Redis密码
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取Jedis实例
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 释放jedis资源
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }
    
    //对象序列化为字符串
    public static String objectSerialiable(Object obj){
        String serStr = null;
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();  
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);  
            objectOutputStream.writeObject(obj);    
            serStr = byteArrayOutputStream.toString("ISO-8859-1");  
            serStr = java.net.URLEncoder.encode(serStr, "UTF-8");  
              
            objectOutputStream.close();  
            byteArrayOutputStream.close();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        return serStr;
    }
    
    //字符串反序列化为对象
    public static Object objectDeserialization(String serStr){
        Object newObj = null;
        try {
            String redStr = java.net.URLDecoder.decode(serStr, "UTF-8");  
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(redStr.getBytes("ISO-8859-1"));  
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);   
            newObj = objectInputStream.readObject();
            objectInputStream.close();  
            byteArrayInputStream.close();
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return newObj;
    }
    
    //测试
    public static void main(String[] args) {
        //构造一个list
        List<HashMap<String, String>> list = new ArrayList<HashMap<String, String>>();  
        HashMap<String, String> map = new HashMap<String, String>();  
        map.put("number", "王小二");  
        map.put("name", "王二");  
        list.add(map);  
        HashMap<String, String> map2 = new HashMap<String, String>();  
        map2.put("number", "张三");  
        map2.put("name", "张小三");  
        list.add(map2);
        
        //将对象序列化为字符串
        String serStr = objectSerialiable(list);
        System.out.println(serStr);
        
        //将序列化之后的字符串保存在redis中
        RedisUtil.getJedis().set("list", serStr);
        
        
        //从redis中取中字符串
        String deSerStr = RedisUtil.getJedis().get("list");
        if(!StringUtils.isEmpty(deSerStr)){
            //将取出的字符串反序列化为对象
            List<HashMap<String, String>> deList = (List<HashMap<String, String>>) objectDeserialization(deSerStr);
            if(deList!=null && deList.size()>0){
                for(Map m : deList){
                    System.out.println(m.get("number")+"   "+m.get("name"));
                }
            }
        }
        
    }
}

 4.程序运行结果

这是对象序列化之后的字符串
%C2%AC%C3%AD%00%05sr%00%13java.util.ArrayListx%C2%81%C3%92%1D%C2%99%C3%87a%C2%9D%03%00%01I%00%04sizexp%00%00%00%02w%04%00%00%00%0Asr%00%11java.util.HashMap%05%07%C3%9A%C3%81%C3%83%16%60%C3%91%03%00%02F%00%0AloadFactorI%00%09thresholdxp%3F%40%00%00%00%00%00%0Cw%08%00%00%00%10%00%00%00%02t%00%04namet%00%06%C3%A7%C2%8E%C2%8B%C3%A4%C2%BA%C2%8Ct%00%06numbert%00%09%C3%A7%C2%8E%C2%8B%C3%A5%C2%B0%C2%8F%C3%A4%C2%BA%C2%8Cxsq%00%7E%00%02%3F%40%00%00%00%00%00%0Cw%08%00%00%00%10%00%00%00%02q%00%7E%00%04t%00%09%C3%A5%C2%BC%C2%A0%C3%A5%C2%B0%C2%8F%C3%A4%C2%B8%C2%89q%00%7E%00%06t%00%06%C3%A5%C2%BC%C2%A0%C3%A4%C2%B8%C2%89xx
这是通过字符串反序列化为对象之后的输出
王小二   王二
张三   张小三

 

无_业_游_民
关注
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
【项目实战】Redis的序列化与反序列化
本本本添哥
04-18 2011
在Redis中，数据可以被序列化为二进制格式并存储在内存中，以提高读写性能。 Redis支持多种序列化格式，包括JSON、MessagePack和Protocol Buffers。 默认情况下，Redis使用自己的二进制序列化格式，但可以通过配置文件更改为其他格式。
Jedis序列化和反序列化使用jar
09-17
使用jedis操作redis技术使用，存储时候若是使用对象要对其进行序列化和反序列化。
spring-boot | 整合Redis缓存数据
weixin_33995481的博客
05-19 225
为什么80%的码农都做不了架构师？>>> ...
Java、Redis、Jackson序列化与反序列化
峰
04-10 2001
序列化：简单来说就是将应用程序中的数据转化为特定的格式，可以用于网络传输，保存到磁盘，数据库等。例如Java中的ObjectOutputStream、Python中的pickle是专门的序列化类、Hadoop中各节点数据传输。 反序列化：将序列化对象从磁盘、网络等位置重新转化为程序中的对象信息。 ## 为什么需要序列化 > 实现数据的跨语言使用 实现数据的跨平台使用 数据去内存地址 降低磁盘存储空间 1. 存储对象在存储介质中，以便在下次使用的时候，可以很快捷的重建一个副本。直接从磁盘、网络等位置转化为
redis总结02：序列化和反序列化
sayhitoloverOvO的博客
10-14 3632
什么是序列化和反序列化 类似于面向对象的封装 狭义：属性私有化，方法能公开就公开 广义：一个系统有哪些服务，一个服务有哪些模块，一个模块有哪些结构，一个结构有哪些属性 序列化 狭义的层面：将对象转换为字节 广义的层面：将对象转换为指定格式的字符串 反序列化 狭义的层面：将字节转换为对象 广义的层面：将指定格式的字符串转换为对象 Redis存储对象(序列化和反序列化) RedisSerializer接口，及其实现类 RedisSerializer接口下的实现类 注意：接口内的方法
java serialize_Java序列化（Serialize）和反序列化（Deserialize）
weixin_34945060的博客
02-21 1670
对象的序列化一、目的：将对象转换成与平台无关的二进制流，从而可以保存到磁盘或者进行网络传输，其它程序获 得这个二进制流后可以将其还原成对象。序列化机制可以使对象可以脱离程序的运行而对立存在。————————————————————————————————————————二、是什么？序列化(Serialize)指将一个java对象写入IO流中，与此对应的是，对象的反序列化(Deserialize)则...
默认JedisCluster和redisTemplate带来的序列化问题
最新发布
yubin1285570923的博客
07-02 664
红橙黄绿。
redis-cluster结合springboot的使用自定义序列化
12-05
// 实现序列化和反序列化方法，如write和read } ``` 然后，在SpringBoot的配置中指定自定义的序列化器： ```yaml spring: data: redis: cluster: ... key: serializer: ...
redis序列化器的选择
少年乖
04-17 1220
例如为redis选择序列化/反序列化器时，若待序列化对象没有无参构造器但实现了Serializable接口，要用JdkSerializationRedisSerializer。 若待序列化对象没有实现Serializable接口，但有无参构造器，要用Jackson2JsonRedisSerializer。 ...
STM32 流水灯
01-26
STM32 GPIO点亮流水灯试验（库函数版）
浅谈在Java中对Redis序列化的配置
m0_63445035的博客
04-25 2359
在Java中对Redis序列化的配置
redis存储对象用json序列化和反序列化方式实现
weixin_45834289的博客
03-16 652
redis存储对象用json序列化和反序列化方式实现
redis反序列化
duanjunkaisky的专栏
12-27 2598
经上述分析可以回答问题背景中的疑问由于JAVA的泛型擦除机制，导致泛型并不能完全限制住运行时返回对象的类型Json反序列化不会导致精度丢失，会根据精度需要自动改变类型基础数据类型及封装类需要在Json反序列化时需注意类型变化，默认整型转化为Integer，浮点型转换为Double。
广域网技术——SR技术概括
m0_49864110的博客
03-19 9905
当B到E之间的链路发生故障时，IGP收敛完成后，需要等待LDP协议收敛分发标签，再等段的这段时间，LDP就无法分发新的标签，就相当于停运了，出现瞬间丢包行为，造成路由黑洞。SR由业务驱动网络，即由业务来定义网络的架构（不同业务对网络有不同的要求，控制器收集网络拓扑、带宽利用率、时延等信息，根据业务的需求计算出显式路径）通过MPLS TE，可以建立基于一定的约束条件的MPLS隧道，并将流量引入到隧道中进行转发，解决LDP无法控路的问题。（松散路径，自己通过IGP计算到节点SID有几条路，然后选择最优的）
华为HCIA进阶笔记：SR 基本原理
君逍遥o
06-21 2670
Segment Routing(直译为分段路由，缩写为SR)技术，脱胎于MPLS，但是又做了革命性的颠覆和创新，它代表的是一种新的网络理念——应用驱动网络。自从诞生那一刻起，SR技术便被誉为网络领域最大的黑科技，因其与SDN天然结合的特性，也逐渐成为SDN的主流网络架构标准。
细说java.util.HashMap
痴人说梦
09-01 9449
HashMap是我们最常用的类之一，它实现了hash算法，虽然使用很简单，但是其实现有很多值得研究的地方。 HashMap存储的是key-value形式的键值对，这个键值对在实现中使用一个静态内部类Entry来表示，它存储了key、value、hash值、以及在hash冲突时链表中下一个元素的引用。 HashMap底层实现使用了一个数组来存储元素。它的初始容量默认是16，而且必须容量必须是2的
Redis从入门到放弃 之 序列化和反序列化的问题
倚书依杖听河流博客
04-01 3275
这两天项目上遇到了点问题，系统A调用RPC将字典信息 存储到了Redis集群中，此时系统B也需要用到字典表。 就想着直接从Redis里取得了，然后反序列化的时候就遇到了上诉问题。 在这里总结一下 一、原因： Redis客户端未指...
Jedis存储Java对象--Java序列化为byte数组方式
yflxc的专栏
07-11 4130
在Jedis开发中，我们很多时候希望直接把一个对象放到Redis中，然后在需要的时候取出来。Redis的key和value都支持二进制安全的字符串，存储Java对象不是问题，下面我们看一下如何来实现。 1、要存储的对象 现在写一个很土的Java Bean，包含两个字段，id和name，类名叫做Person。为了实现序列化需求，该类实现Serializable接口。 package c
jedis使用指定序列化器
06-07
Jedis提供了多种序列化器，可以通过配置来选择使用不同的序列化器。下面以使用Jackson序列化器为例，介绍如何在Jedis中使用指定的序列化器： 1. 添加依赖，包括jedis和jackson-databind： ``` <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.6.0</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.12.4</version> </dependency> ``` 2. 创建JedisPoolConfig对象，设置Jedis连接池的相关参数： ``` JedisPoolConfig poolConfig = new JedisPoolConfig(); poolConfig.setMaxTotal(100); poolConfig.setMaxIdle(20); poolConfig.setMinIdle(10); ``` 3. 创建JedisPool对象，并设置Jackson序列化器： ``` JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379); ObjectMapper objectMapper = new ObjectMapper(); Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class); jackson2JsonRedisSerializer.setObjectMapper(objectMapper); jedisPool.getResource().getClient().setSerializer(jackson2JsonRedisSerializer); ``` 这里使用了Jackson2JsonRedisSerializer作为Jedis的序列化器，并将ObjectMapper对象设置为其内部使用的ObjectMapper。这里还需要使用JedisPool的getResource方法获取Jedis实例，并使用getClient方法获取Jedis的客户端对象，然后调用setSerializer方法设置序列化器。 4. 使用Jedis实例操作Redis： ``` Jedis jedis = jedisPool.getResource(); String key = "myKey"; MyObject myObject = new MyObject(); byte[] bytes = jackson2JsonRedisSerializer.serialize(myObject); jedis.set(key.getBytes(), bytes); byte[] result = jedis.get(key.getBytes()); MyObject myObjectResult = (MyObject) jackson2JsonRedisSerializer.deserialize(result); ``` 这里使用了Jedis实例来进行Redis的操作，其中包括将一个Java对象序列化为JSON格式，并存储到Redis中，以及从Redis中获取数据，并将其反序列化为Java对象。需要注意的是，在序列化和反序列化时，使用了之前创建的Jackson2JsonRedisSerializer对象来处理数据。 通过以上步骤，我们就可以在Jedis中使用指定的序列化器来进行数据的序列化和反序列化了。需要根据实际情况选择合适的序列化器，并进行相应的配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值