背景

最近项目中要按照对象方式进行存取，使用时再拿出来，于是我们就要学习序列化和反序列化的相关知识。

基于我们的项目，按照课表进行推课的时候，课表中当前课程结束的时候，将执行的颗粒存到redis中。

步骤

概念

序列化和反序列化是计算机科学中用于数据存储和传输的重要概念。

序列化（Serialization）

是将数据结构或对象转换成一种可存储或可传输格式的过程。在序列化后，数据可以被写入文件、发送到网络或存储在数据库中，以便在需要时可以再次还原成原始的数据结构或对象。序列化的过程通常涉及将数据转换成字节流或类似的格式，使其能够在不同平台和编程语言之间进行传输和交换。

反序列化（Deserialization）

是序列化的逆过程，即将序列化后的数据重新还原成原始的数据结构或对象。反序列化是从文件、网络数据或数据库中读取序列化的数据，并将其转换回原始形式，以便在程序中进行使用和操作。

使用场景

序列化和反序列化在许多场景中都非常有用，例如：

数据存储：将程序中的数据保存到文件或数据库中，以便在以后重新加载和使用。

网络通信：在网络上传输数据时，需要将数据序列化为字节流，以便在接收端进行反序列化。

分布式系统：在分布式系统中，不同计算节点之间需要通过序列化和反序列化来交换数据。

进程间通信：不同进程之间通信时，数据需要在序列化和反序列化之间进行转换。

常见的序列化格式包括 JSON（JavaScript Object Notation）、XML（eXtensible Markup Language）、Protocol Buffers、MessagePack等。每种格式有其优势和适用场景，选择合适的序列化格式取决于具体的应用需求。

理解原理小Demo（可以理解成编码解码，很简单的）

import java.io.*;
public class Serialization {
    private static final File SAVE_FILE = new File("D:" + File.separator + "demo.Class");
    public static void saveObject(Object object) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(SAVE_FILE));
        oos.writeObject(object); // 序列化
        oos.close();
    }
    public static Object loadObject() throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(SAVE_FILE));
        Object obj = ois.readObject(); // 反序列化
        ois.close();
        return obj;
    }
    public static void main(String[] args) throws Exception {
        saveObject(new Class(new Person("p",11),"class",12));// 序列化
        Class c = (Class)loadObject();
        System.out.println(c); // 反序列化
    }
    public static class Person implements Serializable {
        private String name;
        private int age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    public static class Class implements Serializable{
        private Person person;
        private String name;
        private int age;
        public Person getPerson() {
            return person;
        }
        public void setPerson(Person person) {
            this.person = person;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "Class{" +
                    "person=" + person +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
        public Class(Person person) {
            this.person = person;
        }
        public Class(Person person, String name, int age) {
            this.person = person;
            this.name = name;
            this.age = age;
        }
    }
}

可以通过打断点的方式查看对象的展示情况

将内存中的对象通过序列化的方式存储到本地的某个文件中

然后调用另外一个方法从本地文件中拿到对象放置到内存中

这样我们就了解了序列化和反序列的概念，下面看看在redis是如何实现序列化和反序列化的吧。

使用redis步骤

建立springboot项目

引入坐标

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

建类

在这里插入代码片

package com.example.redis.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
    /**
     * RedisTemplate配置
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        // 设置序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        RedisSerializer<?> stringSerializer = new StringRedisSerializer();
        // key序列化
        redisTemplate.setKeySerializer(stringSerializer);
        // value序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // Hash key序列化
        redisTemplate.setHashKeySerializer(stringSerializer);
        // Hash value序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

server:
  port: 8081
spring:
  redis:
    host: **redis.***d.tech
    port: 6379
    password: ***
    database: 0
    timeout: 300000ms  #连接超时
    jedis:
      pool:
        max-active: 8  #连接池最大的连接数
        max-wait: -1ms  #连接池最大的阻塞等待时间（负值表示没有限制）
        max-idle: 500  #连接池最大的空闲连接

package com.example.redis.Entity;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@Data
public class UserInfo implements Serializable {
    /**
     * id
     */
    private Integer id;
    /**
     * 姓名
     */
    private String name;
    /**
     * 创建时间
     */
    private Date createTime;
}

package com.example.redis.utils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
/**
 * @ClassName RedisUtils
 * @Description
 * @Author Lizhou
 * @Date 2020-10-22 10:10:10
 **/
@Slf4j
@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    /**
     * 根据key读取数据
     */
    public Object get(final String key) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 写入数据
     */
    public boolean set(final String key, Object value) {
        if (StringUtils.isEmpty(key)) {
            return false;
        }
        try {
            redisTemplate.opsForValue().set(key, value);
            log.info("存入redis成功，key：{}，value：{}", key, value);
            return true;
        } catch (Exception e) {
            log.error("存入redis失败，key：{}，value：{}", key, value);
            e.printStackTrace();
        }
        return false;
    }
}

package com.example.redis;
import com.example.redis.Entity.UserInfo;
import com.example.redis.utils.RedisUtils;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Date;
@SpringBootTest
class RedisTestApplicationTests {
    @Autowired
    private RedisUtils redisUtil;
    @Test
    void contextLoads() {
        UserInfo userInfo = new UserInfo();
        userInfo.setId(1);
        userInfo.setName("jack");
        userInfo.setCreateTime(new Date());
        // 放入redis
        redisUtil.set("user", userInfo);
        // 从redis中获取
        System.out.println("获取到数据：" + redisUtil.get("user"));
    }
}

根据key值查看redis中的值

简单介绍redis

Redis（Remote Dictionary Server）是一种开源的高性能键值存储数据库，它也被称为数据结构服务器，因为它支持多种灵活的数据结构。Redis以内存中的数据结构为基础，提供了快速、高效的数据存储和访问能力。它可以用作数据库、缓存、消息代理和排行榜等多种用途。

以下是 Redis 的一些主要特点：

键值存储：

Redis将数据存储为键值对，其中键是唯一的标识符，而值可以是字符串、哈希、列表、集合、有序集合等各种数据结构。

内存数据库：（因为我们是面向对象开发，所有就要使用内存数据库啦，因为要把对象存取来哦）

Redis的所有数据都存储在内存中，因此具有非常快的读写速度。但是，它也支持将数据持久化到磁盘，以便在重启后恢复数据。

丰富的数据结构：

Redis支持多种数据结构，如字符串、哈希表、列表（链表）、集合、有序集合等。这使得Redis在处理不同类型的数据时非常灵活和高效。

高性能：

由于数据存储在内存中，Redis能够实现非常高的读写速度。此外，它使用单线程模型来避免了多线程带来的竞争条件，使得其在单核系统上也能表现出色。

支持事务：

Redis支持简单的事务，你可以将多个命令放在一个事务中，然后一次性执行这些命令。在事务执行期间，其他客户端不会对其进行干扰。

发布/订阅：

Redis支持发布/订阅模式，允许客户端订阅一个或多个频道，当有消息发布到这些频道时，订阅的客户端将会收到相应的消息。

集群支持：

Redis支持将数据分布在多个节点上，从而实现高可用性和横向扩展。

轻量级：

Redis的代码库相对较小，没有复杂的依赖，因此非常轻量级且易于安装和部署。

Redis广泛应用于Web开发、缓存、会话存储、实时分析、消息队列等场景。由于其高性能和灵活性，Redis成为了许多应用架构中不可或缺的一部分。

总结

序列化在Redis中发挥着重要的作用，它使得数据可以被转换成一种便于存储和传输的格式，并可以通过网络进行传输。当数据需要被存储到Redis中时，通常需要先进行序列化，将数据转换成适合Redis存储的形式。而在从Redis中取出数据时，则需要进行反序列化，将序列化后的数据重新还原成原始的数据结构，以便在程序中进行使用和操作。

总之，序列化和反序列化是数据在存储和传输过程中的桥梁，而Redis作为高性能的键值存储数据库，则利用序列化机制来存储和操作数据，提供快速、灵活的数据存储和访问服务。通过将数据序列化后存储在Redis中，我们可以充分发挥Redis的优势，实现高效的数据处理和管理。

一文彻底搞懂序列化和反序列化

背景

步骤

概念

序列化（Serialization）

反序列化（Deserialization）

使用场景

理解原理小Demo（可以理解成编码解码，很简单的）

使用redis步骤

简单介绍redis

总结

热门文章

最新文章

相关电子书