分布式架构中的序列化方式都有哪些？看看它们是如何使用的。

已于 2024-07-22 15:15:41 修改
阅读量906 收藏 27
点赞数 26
文章标签： 分布式 架构 序列化与反序列化
于 2024-07-22 15:12:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuiezt/article/details/140553670
版权

分布式架构中的序列化方式

前言

在分布式架构中，序列化是将对象状态转换为可存储或传输的格式的过程，而反序列化则是将这个过程逆转，将存储或传输的格式转换回原始对象状态。

分布式架构中的序列化方式多种多样，以满足不同场景和需求。以下是一些常见的序列化方式。

1. Java原生序列化

  • 特点：Java通过实现java.io.Serializable接口来支持对象的序列化。使用ObjectOutputStream进行序列化，ObjectInputStream进行反序列化。
  • 缺点：不能跨语言，序列化后的数据体积较大，性能相对较差，且存在安全隐患。
  • 适用场景：主要用于Java内部的对象传输和持久化。
  • 代码示例：
//首先，我们需要一个实现了Serializable接口的类。
//注意，所有实现Serializable接口的类都应该有一个版本UID，以避免因类定义更改而导致序列化不兼容的问题。
import java.io.Serializable;  
  
public class Employee implements Serializable {  
    private static final long serialVersionUID = 1L; // 用于版本控制  
  
    private String name;  
    private int age;  
  
    // 构造函数  
    public Employee(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    // Getter 和 Setter 方法  
    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;  
    }  
  
    // toString 方法方便打印对象信息  
    @Override  
    public String toString() {  
        return "Employee{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                '}';  
    }  
}

// 实现 Employee 对象的序列化
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.ObjectOutputStream;  
  
public class SerializeExample {  
    public static void main(String[] args) {  
        Employee emp = new Employee("John Doe", 30);  
  
        try (  
            FileOutputStream fileOut = new FileOutputStream("employee.ser");  
            ObjectOutputStream out = new ObjectOutputStream(fileOut);  
        ) {  
            out.writeObject(emp);  
            System.out.printf("Serialized data is saved in employee.ser");  
        } catch (IOException i) {  
            i.printStackTrace();  
        }  
    }  
}

//实现Employee对象的反序列化
import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.ObjectInputStream;  
  
public class DeserializeExample {  
    public static void main(String[] args) {  
        Employee emp = null;  
  
        try (  
            FileInputStream fileIn = new FileInputStream("employee.ser");  
            ObjectInputStream in = new ObjectInputStream(fileIn);  
        ) {  
            emp = (Employee) in.readObject();  
            System.out.println("Deserialized Employee...");  
            System.out.println("Employee Name: " + emp.getName());  
            System.out.println("Employee Age: " + emp.getAge());  
        } catch (IOException i) {  
            i.printStackTrace();  
            return;  
        } catch (ClassNotFoundException c) {  
            System.out.println("Employee class not found");  
            c.printStackTrace();  
            return;  
        }  
    }  
}

2. Hessian序列化

  • 特点：Hessian是一个基于二进制的高效序列化协议，支持跨语言传输。Dubbo框架早期版本默认使用Hessian作为序列化方式。
  • 优点：性能好，支持多种语言。
  • 缺点：相对JSON等格式，可读性较差。
  • 代码示例：
//我们使用 HessianOutput 来序列化 Person 对象，并将结果写入一个字节流中。
//然后，我们使用 HessianInput 从这个字节流中读取并反序列化对象。
//最后，我们打印出反序列化后的对象信息。
import com.caucho.hessian.io.HessianInput;  
import com.caucho.hessian.io.HessianOutput;  
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
  
public class HessianSerializationExample {  
  
    public static void main(String[] args) throws IOException {  
        // 创建 Person 对象  
        Person person = new Person("John Doe", 30);  
  
        // 序列化  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        HessianOutput out = new HessianOutput(baos);  
        out.writeObject(person);  
        out.close();  
  
        byte[] serializedData = baos.toByteArray();  
  
        // 反序列化  
        ByteArrayInputStream bais = new ByteArrayInputStream(serializedData);  
        HessianInput in = new HessianInput(bais);  
        Person deserializedPerson = (Person) in.readObject();  
        in.close();  
  
        // 打印反序列化后的对象信息  
        System.out.println(deserializedPerson);  
    }  
  
    // 一个简单的 JavaBean 类  
    public static class Person implements java.io.Serializable {  
        private static final long serialVersionUID = 1L;  
  
        private String name;  
        private int age;  
  
        public Person(String name, int age) {  
            this.name = name;  
            this.age = age;  
        }  
  
        // Getter 和 Setter 方法  
        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;  
        }  
  
        // toString 方法方便打印对象信息  
        @Override  
        public String toString() {  
            return "Person{" +  
                    "name='" + name + '\'' +  
                    ", age=" + age +  
                    '}';  
        }  
    }  
}

使用Hassian前，现将Hession库添加到项目中：

<dependency>  
    <groupId>com.caucho</groupId>  
    <artifactId>hessian</artifactId>  
    <version>4.0.38</version>  
</dependency>

3. JSON序列化

  • 特点：JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。
  • 优点：跨语言支持，可读性好，易于调试。
  • 缺点：相对于二进制序列化，数据体积较大，性能略低。
  • 常用库：Jackson、Fastjson、Gson等。
  • 代码示例：
//使用Jackson进行JSON序列化
import com.fasterxml.jackson.databind.ObjectMapper;  
  
public class JacksonSerializationExample {  
    public static void main(String[] args) {  
        try {  
            // 创建一个Person对象  
            Person person = new Person("John Doe", 30);  
  
            // 创建ObjectMapper实例  
            ObjectMapper mapper = new ObjectMapper();  
  
            // 将Person对象序列化为JSON字符串  
            String jsonString = mapper.writeValueAsString(person);  
  
            // 打印JSON字符串  
            System.out.println(jsonString);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    // 假设的Person类  
    @Data
    public static class Person {  
        private String name;  
        private int age;  
    }  
}

引入Jackson依赖

<dependency>  
    <groupId>com.fasterxml.jackson.core</groupId>  
    <artifactId>jackson-databind</artifactId>  
    <version>2.13.0</version>
</dependency>

4. XML序列化

  • 特点：XML（eXtensible Markup Language）是一种标记语言，常用于表示和交换数据。
  • 优点：可读性好，支持跨语言，易于理解和调试。
  • 缺点：序列化后的数据体积较大，效率不高。
  • 实现方式：可以使用JAXB（Java Architecture for XML Binding）等库来实现。
  • 代码示例：
import javax.xml.bind.annotation.XmlRootElement;  
import javax.xml.bind.annotation.XmlElement;  
  
@XmlRootElement // 标记这个类为XML的根元素  
public class Person {  
    private String name;  
    private int age;  
  
    // 构造函数、getter和setter省略  
    public Person() {}  
  
    public Person(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    @XmlElement // 标记这个字段为XML元素  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    @XmlElement // 标记这个字段为XML元素  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        this.age = age;  
    }  
  
    // 序列化方法  
    public static void serialize(Person person, String filePath) throws Exception {  
        JAXBContext jaxbContext = JAXBContext.newInstance(Person.class);  
  
        Marshaller marshaller = jaxbContext.createMarshaller();  
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); // 格式化输出  
  
        // 将Person对象序列化为XML并写入文件  
        marshaller.marshal(person, new File(filePath));  
    }  
  
    // 反序列化方法  
    public static Person deserialize(String filePath) throws Exception {  
        JAXBContext jaxbContext = JAXBContext.newInstance(Person.class);  
  
        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();  
  
        // 从文件读取XML并反序列化为Person对象  
        return (Person) unmarshaller.unmarshal(new File(filePath));  
    }  
  
    public static void main(String[] args) {  
        try {  
            // 序列化示例  
            Person person = new Person("John Doe", 30);  
            serialize(person, "person.xml");  
  
            // 反序列化示例  
            Person deserializedPerson = deserialize("person.xml");  
            System.out.println("Deserialized Person: " + deserializedPerson.getName() + ", " + deserializedPerson.getAge());  
  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}

5. Protocol Buffers（Protobuf）

  • 特点：由Google开发的一种数据序列化协议，支持多种编程语言，具有较小的数据大小和较高的性能。
  • 优点：高效、跨语言、数据体积小。
  • 缺点：需要定义.proto文件，并生成对应的序列化/反序列化代码。
  • 代码示例：
    首先，你需要定义一个 .proto 文件来描述你的数据结构，然后使用 Protobuf 编译器（protoc）生成 Java 代码。
    1. 定义 .proto 文件
      创建一个名为 person.proto 的文件，内容如下：
    syntax = "proto3";  
  
package tutorial;  
  
// 定义一个Person消息  
message Person {  
  string name = 1;  
  int32 id = 2;  
  string email = 3;  
  
  enum PhoneType {  
    MOBILE = 0;  
    HOME = 1;  
    WORK = 2;  
  }  
  
  message PhoneNumber {  
    string number = 1;  
    PhoneType type = 2;  
  }  
  
  repeated PhoneNumber phones = 4;  
}
    1. 使用 Protobuf 编译器生成 Java 代码
      运行以下命令（确保 protoc 在你的 PATH 中）：
    protoc --java_out=. person.proto
    这将在当前目录下生成一个 tutorial 目录，其中包含 Person.java 和其他生成的类。
    3. Java 序列化和反序列化代码
    在你的 Java 项目中，你可以使用生成的 Person 类来序列化和反序列化数据。
    import tutorial.Person;  
import tutorial.Person.PhoneNumber;  
import tutorial.Person.PhoneType;  
  
import com.google.protobuf.ByteString;  
  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class ProtobufExample {  
    public static void main(String[] args) throws IOException {  
        // 创建一个Person实例  
        Person.Builder personBuilder = Person.newBuilder();  
        personBuilder.setId(1234);  
        personBuilder.setName("John Doe");  
        personBuilder.setEmail("john.doe@example.com");  
  
        // 添加电话号码  
        PhoneNumber.Builder phoneBuilder = PhoneNumber.newBuilder();  
        phoneBuilder.setNumber("555-4321");  
        phoneBuilder.setType(PhoneType.HOME);  
        personBuilder.addPhones(phoneBuilder.build());  
  
        Person person = personBuilder.build();  
  
        // 序列化到文件  
        try (FileOutputStream output = new FileOutputStream("person.dat")) {  
            person.writeTo(output);  
        }  
  
        // 从文件反序列化  
        Person newPerson;  
        try (FileInputStream input = new FileInputStream("person.dat")) {  
            newPerson = Person.parseFrom(input);  
        }  
  
        // 输出反序列化后的Person信息  
        System.out.println("Name: " + newPerson.getName());  
        System.out.println("ID: " + newPerson.getId());  
        System.out.println("Email: " + newPerson.getEmail());  
        for (PhoneNumber phone : newPerson.getPhonesList()) {  
            System.out.println("Phone Number: " + phone.getNumber() + ", Type: " + phone.getType());  
        }  
    }  
}
    在这个示例中，我们首先构建了一个 Person 对象，并添加了一个电话号码。然后，我们使用 writeTo 方法将其序列化到一个文件中。之后，我们使用 parseFrom 方法从文件中读取并反序列化 Person 对象，并打印出它的详细信息。
    Protobuf 序列化后的数据是二进制的，因此不建议直接查看或编辑这些文件。

6. Kryo序列化

  • 特点：Kryo是一种高性能的序列化框架，支持多种数据类型和复杂的对象图。
  • 优点：序列化速度快，数据体积小。
  • 缺点：不支持跨语言，且依赖于JVM环境。
  • 代码示例：
    加入Kryo的依赖：
<dependency>  
    <groupId>com.esotericsoftware.kryo</groupId>  
    <artifactId>kryo</artifactId>  
    <version>5.2.0</version>  
</dependency>

import com.esotericsoftware.kryo.Kryo;  
import com.esotericsoftware.kryo.io.Input;  
import com.esotericsoftware.kryo.io.Output;  
  
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
  
// 示例类，用于序列化  
public class User {  
    private String name;  
    private int age;    
    public User(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }    
    // User类的getter和setter方法  
    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 static void main(String[] args) {  
        // 创建一个Kryo实例  
        Kryo kryo = new Kryo();  
  
        // 创建一个User实例  
        User user = new User("Alice", 30);  
  
        // 序列化  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        Output output = new Output(baos);  
        kryo.writeObject(output, user);  
        output.close();  
        byte[] bytes = baos.toByteArray();  
  
        // 反序列化  
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);  
        Input input = new Input(bais);  
        User deserializedUser = kryo.readObject(input, User.class);  
        input.close();  
  
        // 验证反序列化结果  
        System.out.println("Name: " + deserializedUser.getName());  
        System.out.println("Age: " + deserializedUser.getAge());  
    }  
  
}

7. Avro序列化

  • 特点：Avro是一种数据序列化系统，设计用于大批量数据交换的应用。支持JSON格式，具有架构演化的能力。
  • 优点：动态语言友好，支持数据压缩。
  • 缺点：需要定义schema文件，并生成对应的序列化/反序列化代码。
  • 代码示例：
<!-- 要先引入avro的依赖 -->
<dependency>
      <groupId>org.apache.avro</groupId>
      <artifactId>avro</artifactId>
      <version>1.10.1</version>
    </dependency>

import org.apache.avro.Schema;  
import org.apache.avro.Schema.Field;  
import org.apache.avro.Schema.Type;  
import org.apache.avro.generic.GenericData;  
import org.apache.avro.generic.GenericDatumWriter;  
import org.apache.avro.generic.GenericRecord;  
import org.apache.avro.io.DatumWriter;  
import org.apache.avro.io.Encoder;  
import org.apache.avro.io.EncoderFactory;  
import org.apache.avro.io.BinaryDecoder;  
import org.apache.avro.io.BinaryDecoderFactory;  
import org.apache.avro.io.DatumReader;  
import org.apache.avro.generic.GenericDatumReader;  
import java.io.ByteArrayOutputStream;  
import java.io.ByteArrayInputStream;  
import java.io.IOException;  
  
public class AvroExample {  
  
    public static void main(String[] args) throws IOException {  
        // 定义 Avro Schema  
        Schema schema = Schema.createRecord("Person", null, null, false,  
                Arrays.asList(  
                    new Field("name", Schema.create(Type.STRING), "A person's name", null),  
                    new Field("age", Schema.create(Type.INT), "A person's age", null),  
                    new Field("emails", Schema.createArray(Schema.create(Type.STRING)), "Email addresses", null)  
                ));  
  
        // 创建一个 GenericRecord 实例并填充数据  
        GenericRecord person = new GenericData.Record(schema);  
        person.put("name", "John Doe");  
        person.put("age", 30);  
        person.put("emails", Arrays.asList("john.doe@example.com", "johndoe@work.com"));  
  
        // 序列化  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        Encoder encoder = EncoderFactory.get().binaryEncoder(out, null);  
        DatumWriter<GenericRecord> writer = new GenericDatumWriter<>(schema);  
        writer.write(person, encoder);  
        encoder.flush();  
        byte[] data = out.toByteArray();  
  
        // 反序列化  
        ByteArrayInputStream in = new ByteArrayInputStream(data);  
        BinaryDecoder decoder = DecoderFactory.get().binaryDecoder(in, null);  
        DatumReader<GenericRecord> reader = new GenericDatumReader<>(schema);  
        GenericRecord decodedPerson = reader.read(null, decoder);  
  
        // 打印反序列化后的数据  
        System.out.println("Name: " + decodedPerson.get("name"));  
        System.out.println("Age: " + decodedPerson.get("age"));  
        System.out.println("Emails: " + decodedPerson.get("emails"));  
    }  
}

8. MessagePack

  • 特点：MessagePack是一种高效的二进制序列化格式，类似于JSON但更轻量和高效。
  • 优点：跨语言支持，数据体积小，性能高。
  • 代码示例：

引入MassagePack依赖：

<dependency>  
    <groupId>org.msgpack</groupId>  
    <artifactId>msgpack-core</artifactId>  
    <version>0.8.21</version> 
</dependency>

import org.msgpack.core.MessagePacker;
import org.msgpack.core.MessageUnpacker;
import org.msgpack.value.Value;
 
import java.io.ByteArrayOutputStream;
import java.io.IOException;
 
public class MessagePackExample {
 
    public static void main(String[] args) throws IOException {
        // 创建MessagePacker对象进行序列化
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        MessagePacker packer = MessagePack.newDefaultPacker(out);
        
        // 写入一些数据
        packer.packString("Hello, MessagePack!");
        packer.packInt(100);
        packer.close();
        
        // 获取序列化后的字节数组
        byte[] bytes = out.toByteArray();
        
        // 创建MessageUnpacker对象进行反序列化
        MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes);
        
        // 读取数据
        Value val1 = unpacker.unpackValue(); // 字符串
        Value val2 = unpacker.unpackValue(); // 整数
        
        // 输出反序列化后的数据
        System.out.println(val1); // 输出字符串
        System.out.println(val2); // 输出整数
    }
}

9. Apache Thrift

  • 特点：Apache Thrift是一个跨语言的序列化框架，支持多种数据传输格式，包括二进制、JSON和XML。
  • 优点：支持跨语言，具有高效的序列化/反序列化能力。
  • 代码示例：
  1. 定义 Thrift 文件
    首先，你需要定义一个 Thrift 文件（比如 Person.thrift），该文件定义了数据结构和服务接口。在这个示例中，我们只定义一个数据结构。
namespace java com.example.thrift    
struct Person {  
   1: string name,  
   2: i32 age,  
   3: bool employed,  
}
  1. 生成 Java 代码
    使用 Thrift 编译器 (thrift) 生成 Java 代码。在命令行中运行：
thrift --gen java Person.thrift

这将生成一个包含 Person 类和必要序列化与反序列化逻辑的 Java 文件。

  1. Java 序列化与反序列化示例
    引入依赖
    确保你的项目中包含了 Thrift 生成的 Java 文件以及 Thrift 库的依赖。如果使用 Maven，>可以添加如下依赖（注意版本号可能需要根据实际情况调整）：
<dependency>  
   <groupId>org.apache.thrift</groupId>  
   <artifactId>libthrift</artifactId>  
   <version>0.14.1</version>  
</dependency>

序列化与反序列化代码

import com.example.thrift.Person;  
import org.apache.thrift.TDeserializer;  
import org.apache.thrift.TSerializer;  
 
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
 
public class ThriftExample {  
   public static void main(String[] args) {  
       try {  
           // 创建一个 Person 实例  
           Person person = new Person();  
           person.setName("John Doe");  
           person.setAge(30);  
           person.setEmployed(true);  
 
           // 序列化  
           TSerializer serializer = new TSerializer();  
           ByteArrayOutputStream out = new ByteArrayOutputStream();  
           serializer.serialize(person, out);  
           byte[] serializedData = out.toByteArray();  
 
           // 反序列化  
           TDeserializer deserializer = new TDeserializer();  
           Person deserializedPerson = new Person();  
           ByteArrayInputStream in = new ByteArrayInputStream(serializedData);  
           deserializer.deserialize(deserializedPerson, in);  
 
           // 输出反序列化后的数据  
           System.out.println("Name: " + deserializedPerson.getName());  
           System.out.println("Age: " + deserializedPerson.getAge());  
           System.out.println("Employed: " + deserializedPerson.isEmployed());  
 
       } catch (IOException e) {  
           e.printStackTrace();  
       }  
   }  
}

总结

分布式架构中的序列化方式多种多样，每种方式都有其特点和适用场景。

在选择序列化方式时，需要根据实际需求和场景进行权衡和选择。例如，如果需要跨语言支持且对数据体积和性能有较高要求，可以选择Protocol Buffers或Thrift；如果追求简单和易读性，可以选择JSON或XML序列化方式。

翠花也老了
关注
几种序列化方式的总结(Serializable,json,Fastjson,ProtoBuff,Hessian和Kyro)
HX_2021
03-22 5489
0、背景 当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。 本文主要对几种常见Java序列化方式进行实现。包括Java原生以流的方法进行的序列化、Json序列化、FastJson序列化、Protobuff序列化、Hessian序列化和Kyro序列化。 1、java原生序列化方式 这种方式只能将支持 java.io.Serializable
一文看懂分布式存储架构
weixin_70730532的博客
07-29 1万+
目录一、集中存储结构二、分布式存储1 、分布式存储的兴起2 、分布式存储的重要性3 、分布式存储的种类和比较三、分布式理论浅析1 、一致性和可用性2 、数据分布3 、复制4 、分布式协议5、跨机房部署四、分布式文件系统1、 Google 文件系统（ GFS ）2、 Taobao 文件系统（ TFS ）3、 Fackbook Haystack 文件系统4、 CDN 内容分发网络五、分布式键值系统1、 Amazon Dynamo2、 Taobao Tiar3、 ETCD4 、产品选型比较（ Etcd ， Zoo
几种Java序列化方式的实现
热门推荐
皮斯特劳沃
03-04 2万+
0、前言 本文主要对几种常见Java序列化方式进行实现。包括Java原生以流的方法进行的序列化、Json序列化、FastJson序列化、Protobuff序列化。 1、Java原生序列化 Java原生序列化方法即通过Java原生流(InputStream和OutputStream之间的转化)的方式进行转化。需要注意的是JavaBean实体类必须实现Serializable接口，否则无法序列化。
序列化方式简述
最新发布
秋夫人
08-05 708
使用接口：简单易用，适合快速实现序列化，但在对象结构变化或性能优化方面较为受限。使用接口：提供了更大的控制力和灵活性，适合复杂的序列化需求，但需要手动实现序列化逻辑。选择哪种方式取决于具体的应用场景和对序列化过程的控制需求。JAXB：Java官方支持，适合需要严格XML Schema验证的企业级应用。XStream：简单灵活，适合快速开发和小型项目，不需要额外的配置和严格的XML标准支持。选择哪种XML序列化方式取决于具体的应用场景、项目需求以及对XML标准和数据验证的要求。Jackson。
序列化的几种方式
Alaskan_Husky的博客
11-19 691
序列化是将对象转换为字节流或其他数据格式的过程，以便将其保存到文件、数据库或进行网络传输。
什么是Java序列化？为什么序列化？序列化有哪些方式？
weixin_30735391的博客
11-30 92
　　先普及一下，计算机中无法识别一个基本单元【字节】来表示，必须经过“翻译”才能让计算机理解人类的语言，这个翻译过程就是【编码】，通常所说的字符转换为字节。 有I／O的地方机就会涉及编码，现在几乎所有的应用程序都涉及网络I／O和磁盘I／O，而数据传输时都是以字节为单位的，所以所有的数据都必须能够序列化为字节 什么是Java序列化？ 简单来说 序列化就是把Java对象储存在某一地方（硬盘、网...
JAVA基础（JAVA 序列化）
ITWUYI的博客
10-11 379
JAVA基础（JAVA 序列化）知识点 JAVA基础（JAVA 序列化）的目的就是创建可复用的 Java 对象。 （1）保存(持久化)对象及其状态到内存或者磁盘 Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比 JVM 的生命周期更长。 但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java 对象序列化就能够帮助我们实现该功能。 （2）序列化对象以
序列化到底是什么？
V539413949的博客
03-31 2876
阅读正文： 我们都知道，新建一个对象的时候实现 Serializeable 接口，但为什么要这么做？什么时候这样子做？这样子做会不会出现幺蛾子？阿淼一个三连差点把自己都问懵逼了…… 那接下来，大家就和阿淼一起简单了解一下这个知识点吧…… 序 序列化的定义是：将一个对象编码成一个字节流（I/O）；而与之相反的操作被称为反序列化。 序列化的目的是为了方便数据的传递以及存储到磁盘上（把一个Java对象写入到硬盘或者传输到网路上面的其它计算机，这时我们就需要将对象转换成字节流才能进行网络传输。对于这种通用的操作，
【五】分布式微服务架构体系详解——服务发现和服务通信
马猴烧酒└(┐卍^o^)卍ﾄﾞｩﾙﾙﾙ~楪詩月「YUZURIHA SHIZUKI」
07-28 862
前言 微服务架构的概念比容器技术早，但是却随着容器技术在13年的兴起，基于容器技术的微服务架构越来越被广泛应用。容器的轻量级部署方式很适合为每个微服务提供基础运行环境。 本文会基于Docker容器，先介绍下服务发现的问题和可用的方案，然后对同步通信以及异步通信的技术做一些对比介绍。最后会结合DDD(Domain-Driven Design)的思想来分析合理的通信模型。 Docker 容器的基础知识本文会略过，对Docker感兴趣的同学还可以去看看 Docker源码 ，Docker是用Go语言写的，Go语言很
分布式微服务架构设计原理——迷茫看看篇
qq_44891295的博客
08-22 1056
文章目录1：从传统单体架构到服务化架构1.1 JEE架构1.2 SSH 架构1.3 服务化架构2：从服务化到微服务3：微服务架构的核心要点和实现原理4：Java 平台微服务架构的项目组织形式5：服务化管理和治理框架的技术选 互联网企业从事信息技术的研发、生产和运营，与传统企业相比，互联网企业倾向于对特 定的人群提供专用服务，这导致互联网产品多种多样、数量众多。由于传统的软件技术更倾向 服务于企业，用户较少，所以传统的企业级技术无法满足互联网产品服务于海量用户的需求． 于是，互联网企业对传统技术进行发展和演化
Java实现几种序列化方式总结
10-20
本篇文章主要介绍了Java实现几种序列化方式总结，包括Java原生以流的方法进行的序列化、Json序列化、FastJson序列化、Protobuff序列化。有兴趣的可以了解一下。
重磅来袭！Java高性能架构学习路线——分布式架构演进+进阶笔记，助你成功拿下大厂offer！！
weixin_66896902的博客
09-07 369
每个程序员朋友都有自己的架构师梦，可往往梦想是美好的，现实又是残酷至极的。不努力不奋斗，可能就会在基层一辈子止步不前。也许有很多朋友还会说，程序员也是干的年轻饭，年纪大了也就爬不上了，脑子跟身体都跟不上了。那既如此，又为何不趁着自己还年轻，好好把握机会，努力一把，美好的未来才有机会和你招手！当然咯，这也仅仅代表我个人的观点，毕竟一百个人有一百个不同的脑子，就会有成千上万种不同的想法。
分布式：分布式系统下的唯一序列
pythonxxoo的博客
01-25 414
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 1 介绍 在分布式系统中，由于涉及到多个不同业务module的交互，以及高并发的场景。我们需要系统能够生成一个跨业务module的全网唯一序列号，来保证我们业务操作的独立性和唯一性。 在常见的业务场景中，比如全局订单Id，唯一标识的支付编号等，都需要这个来保证。 那生成ID都有
分布式架构下序列实现
王安的专栏
05-14 733
在最近的项目中，因为序列的问题，造成部分数据丢失，因此仔细思考了下载分布式环境下如何使用序列问题！ 下面分几类情况说明下。 一、 数据量较小的应用 面对数据量较少的应用单个数据库既可以解决问题，那么针对序列来说，依靠数据库本身的序列既可以实现。（mysql此类没有序列的数据库，一样有对应的方法来实现类似序列的功能） 二、 大量数据的应用 针对数据量比较大的情况，多数企业对数据库的选择，最...
01.分布式之序列化
masteryourself
01-04 198
1. 序列化 Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比 JVM 的生命周期更长。但在现实应用中，就可能要求在 JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java 对象序列化就能够帮助我们实现该功能 简单来说 序列化是把对象的状态信息转化为可存储或...
redis和mysql实现消息队列_基于Redis实现分布式消息队列
weixin_31031711的博客
02-11 207
1、Redis是什么鬼？Redis是一个简单的，高效的，分布式的，基于内存的缓存工具。假设好服务器后，通过网络连接(类似数据库)，提供Key－Value式缓存服务。简单，是Redis突出的特色。简单可以保证核心功能的稳定和优异。2、性能性能方面：Redis是足够高效的。和Memecached对比，在数据量较小大情况下，Redis性能更优秀。数据量大到一定程度的时候，Memecached性能稍好。简...
分布式序列算法
Eris_QwQ的博客
06-01 911
Universally Unique Identifier（全局唯一标识符），UUID 是计算机基于当前时间、计数器、硬件标识等数据计算生成的，以 36字节的字符串表示。雪花算法（Snowflake）使用一个 64位的长整型（Long）数字作为全局唯一ID。最后 12位是该毫秒内的自增序列号。
分布式序列生成器
Panamera_Turbo的博客
11-24 2676
一、序列： 1) 数据库序列的定义: 序列(Sequence)其实是序列号的生成器，可以为表中的行自动生成序列号，产生一组等间隔的数值(类型为数字)。   2) 数据库序列的作用: 其主要的用途是生成表的主键值，用来在多用户环境下产生唯一整数的数据库对象。可以在插入语句中引用，也可以通过查询检查当前值，或使序列增至下一个值，并能协调多行或者多表的主键操作。 3) 数据库对序
dotnet程序员面试必看：基础题目解析
13. UML（统一建模语言）：用于软件系统建模，包括类图、用例图、序列图等多种图表，帮助设计和沟通系统架构。 14. 面向对象概念：封装、继承、多态是面向对象的三大特性，用于构建模块化、可扩展的软件。 15. 类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值