序列化/反序列化

╰半夏微凉° 2023-02-24 03:52 13阅读 0赞

# 序列化/反序列化 #

# 转载声明 #

***本文大量内容系转载自网络，有删改，并参考其他文档资料加入了一些内容：***

*  [java序列化，看这篇就够了][java]  
    作者：9龙  
    出处：https://www.cnblogs.com/9dragon/

# 1 序列化的含义、意义及使用场景 #

*  序列化：将对象写入到IO流中
 *  反序列化：从IO流中恢复对象
 *  意义：序列化机制允许将实现序列化的Java对象转换位字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。
 *  使用场景：所有可在网络上传输的对象都必须是可序列化的，比如RMI（remote method invoke,即远程方法调用），传入的参数或返回的对象都是可序列化的，否则会出错；所有需要保存到磁盘的java对象都必须是可序列化的。通常建议：程序创建的每个JavaBean类都实现Serializeable接口。

# 2 JDK提供的序列化实现的方式 #

## 2.1 概述 ##

如果需要使用JDK原生方式将某个对象保存到磁盘上或者通过网络传输，那么这个类应该实现Serializable接口或者Externalizable接口之一。

## 2.2 Serializable ##

### 2.2.1 普通序列化 ###

Serializable接口是一个标记接口，不用实现任何方法。一旦实现了此接口，该类的对象就是可序列化的。

序列化步骤：

1.  创建一个ObjectOutputStream输出流；
2.  调用ObjectOutputStream对象的writeObject输出可序列化对象。
    
        public class Person implements Serializable { 
          private String name;
          private int age;
          //我不提供无参构造器
          public Person(String name, int age) { 
              this.name = name;
              this.age = age;
          }
        
          @Override
          public String toString() { 
              return "Person{" +
                      "name='" + name + '\'' +
                      ", age=" + age +
                      '}';
          }
        }
        
        public class WriteObject { 
          public static void main(String[] args) { 
              try (//创建一个ObjectOutputStream输出流
                   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"))) { 
                  //将对象序列化到文件s
                  Person person = new Person("9龙", 23);
                  oos.writeObject(person);
              } catch (Exception e) { 
                  e.printStackTrace();
              }
          }
        }

反序列化步骤：

1.  创建一个ObjectInputStream输入流；
2.  调用ObjectInputStream对象的readObject()得到序列化的对象。
    
        public class Person implements Serializable { 
          private String name;
          private int age;
          //我不提供无参构造器
          public Person(String name, int age) { 
              System.out.println("反序列化，你调用我了吗？");
              this.name = name;
              this.age = age;
          }
        
          @Override
          public String toString() { 
              return "Person{" +
                      "name='" + name + '\'' +
                      ", age=" + age +
                      '}';
          }
        }
        
        public class ReadObject { 
          public static void main(String[] args) { 
              try (//创建一个ObjectInputStream输入流
                   ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"))) { 
                  Person brady = (Person) ois.readObject();
                  System.out.println(brady);
              } catch (Exception e) { 
                  e.printStackTrace();
              }
          }
        }

输出结果:  
Person\{name=‘9龙’, age=23\}

**注意点：  
反序列化并不会调用构造方法。反序列的对象是由JVM自己生成的对象，不通过构造方法生成。**

小结：

*  序列化时，会将能序列化的所有成员对象都序列化，不管是不是private

### 2.2.2 成员是引用的序列化 ###

如果一个可序列化的类的成员不是基本类型，也不是String类型，那这个引用类型也必须是可序列化的；否则，会导致此类不能序列化。

看例子，我们新增一个Teacher类。将Person去掉实现Serializable接口代码。

public class Person{ 
        //省略相关属性与方法
    }
    public class Teacher implements Serializable { 
    
        private String name;
        private Person person;
    
        public Teacher(String name, Person person) { 
            this.name = name;
            this.person = person;
        }
    
         public static void main(String[] args) throws Exception { 
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) { 
                Person person = new Person("路飞", 20);
                Teacher teacher = new Teacher("雷利", person);
                oos.writeObject(teacher);
            }
        }
    }

执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70]

我们看到程序直接报错，因为Person类的对象是不可序列化的，这导致了Teacher的对象不可序列化

### 2.2.3 子类继承父类序列化 ###

*  如果序列化对象继承了父类，则父类也必须implements Serializable，否则会报错序列化错误；
 *  如果不想父类实现Serializable接口，则必须做到：
    
     *  父类要有一个无参的构造函数；
     *  子类必须负责序列化（反序列化）父类的field，否则会忽略父类的成员变量。
 *  如果父类已经实现Serializable，则子类不要实现Serializable，否则不会序列化/反序列化父类属性

### 2.2.4 同一对象序列化多次的机制 ###

同一对象序列化多次，会将这个对象序列化多次吗？答案是否定的。

public class WriteTeacher { 
        public static void main(String[] args) throws Exception { 
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) { 
                Person person = new Person("路飞", 20);
                Teacher t1 = new Teacher("雷利", person);
                Teacher t2 = new Teacher("红发香克斯", person);
                //依次将4个对象写入输入流
                oos.writeObject(t1);
                oos.writeObject(t2);
                oos.writeObject(person);
                oos.writeObject(t2);
            }
        }
    }

依次将t1、t2、person、t2对象序列化到文件teacher.txt文件中。

**注意：反序列化的顺序与序列化时的顺序一致。**

public class ReadTeacher { 
        public static void main(String[] args) { 
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"))) { 
                Teacher t1 = (Teacher) ois.readObject();
                Teacher t2 = (Teacher) ois.readObject();
                Person p = (Person) ois.readObject();
                Teacher t3 = (Teacher) ois.readObject();
                System.out.println(t1 == t2);
                System.out.println(t1.getPerson() == p);
                System.out.println(t2.getPerson() == p);
                System.out.println(t2 == t3);
                System.out.println(t1.getPerson() == t2.getPerson());
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    }

输出结果：

false
    true
    true
    true
    true

从输出结果可以看出，Java序列化同一对象，并不会将此对象序列化多次得到多个对象。

### 2.2.5 Java序列化算法 ###

1.  所有保存到磁盘的对象都有一个序列化编码号
2.  当程序试图序列化一个对象时，会先检查此对象是否已经序列化过，只有此对象从未（在此虚拟机）被序列化过，才会将此对象序列化为字节序列输出。
3.  如果此对象已经序列化过，则直接输出编号即可。

图示上述序列化过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 1]

### 2.2.6 java序列化算法潜在的问题 ###

由于java序利化算法不会重复序列化同一个对象，只会记录已序列化对象的编号。如果序列化一个可变对象（对象内的内容可更改）后，更改了对象内容，再次序列化，并不会再次将此对象转换为字节序列，而只是保存序列化编号。

public class WriteObject { 
        public static void main(String[] args) { 
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
                 ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) { 
                //第一次序列化person
                Person person = new Person("9龙", 23);
                oos.writeObject(person);
                System.out.println(person);
    
                //修改name
                person.setName("海贼王");
                System.out.println(person);
                //第二次序列化person
                oos.writeObject(person);
    
                //依次反序列化出p1、p2
                Person p1 = (Person) ios.readObject();
                Person p2 = (Person) ios.readObject();
                System.out.println(p1 == p2);
                System.out.println(p1.getName().equals(p2.getName()));
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    }

输出结果:

Person{name='9龙', age=23}
    Person{name='海贼王', age=23}
    true
    true

### 2.2.7 可选的自定义序列化 ###

#### 2.2.7.1 transient ####

有些时候，我们有这样的需求，某些属性不需要序列化。使用transient关键字选择不需要序列化的字段。

public class Person implements Serializable { 
       //不需要序列化名字与年龄
       private transient String name;
       private transient int age;
       private int height;
       private transient boolean singlehood;
       public Person(String name, int age) { 
           this.name = name;
           this.age = age;
       }
       //省略get,set方法
    }
    
    public class TransientTest { 
       public static void main(String[] args) throws Exception { 
           try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
                ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) { 
               Person person = new Person("9龙", 23);
               person.setHeight(185);
               System.out.println(person);
               oos.writeObject(person);
               Person p1 = (Person)ios.readObject();
               System.out.println(p1);
           }
       }
    }

输出结果

Person{name='9龙', age=23', singlehood=true', height=185cm}
    Person{name='null', age=0', singlehood=false', height=185cm}

java序列化时会忽略掉使用transient修饰的属性。

所以反序列化出的对象中被transient修饰的基本属性是默认值。而对于引用类型，值是null；基本类型，值是0；boolean类型，值是false。

#### 2.2.7.2 重写writeObject与readObject ####

使用transient虽然简单，但将此属性完全隔离在了序列化之外。java提供了可选的自定义序列化。可以进行控制序列化的方式，或者对序列化数据进行编码加密等。

private void writeObject(java.io.ObjectOutputStream out) throws IOException；
    private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
    private void readObjectNoData() throws ObjectStreamException;

通过重写writeObject与readObject方法，可以自己选择哪些属性需要序列化， 哪些属性不需要。如果writeObject使用某种规则序列化，则相应的readObject需要相反的规则反序列化，以便能正确反序列化出对象。

比如对`name`进行反转加密。

public class Person implements Serializable { 
       private String name;
       private int age;
       //省略构造方法，get及set方法
    
       private void writeObject(ObjectOutputStream out) throws IOException { 
           //将名字反转写入二进制流
           out.writeObject(new StringBuffer(this.name).reverse());
           out.writeInt(age);
       }
    
       private void readObject(ObjectInputStream ins) throws IOException,ClassNotFoundException{ 
           //将读出的字符串反转恢复回来
           this.name = ((StringBuffer)ins.readObject()).reverse().toString();
           this.age = ins.readInt();
       }
    }

当序列化流不完整时，readObjectNoData()方法可以用来正确地初始化反序列化的对象。例如，使用不同类接收反序列化对象，或者序列化流被篡改时，系统都会调用readObjectNoData()方法来初始化反序列化的对象。

#### 2.2.7.3 更彻底的自定义序列化 ####

// 在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象
    ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

public class Person implements Serializable { 
      private String name;
      private int age;
      //省略构造方法，get及set方法
    
      private Object writeReplace() throws ObjectStreamException { 
          ArrayList<Object> list = new ArrayList<>(2);
          list.add(this.name);
          list.add(this.age);
          return list;
      }
    
       public static void main(String[] args) throws Exception { 
          try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
               ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) { 
              Person person = new Person("9龙", 23);
              oos.writeObject(person);
              ArrayList list = (ArrayList)ios.readObject();
              System.out.println(list);
          }
      }
    }

输出结果

[9龙, 23]

// 反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。
    // 此方法在readeObject后调用。
    ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
    readResolve：

public class Person implements Serializable { 
        private String name;
        private int age;
        //省略构造方法，get及set方法
         private Object readResolve() throws ObjectStreamException{ 
            return new ("brady", 23);
        }
        public static void main(String[] args) throws Exception { 
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
                 ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) { 
                Person person = new Person("9龙", 23);
                oos.writeObject(person);
                HashMap map = (HashMap)ios.readObject();
                System.out.println(map);
            }
        }
    }

输出结果

{ brady=23}

readResolve常用来反序列单例类，保证单例类的唯一性。

**注意**：readResolve与writeReplace的访问修饰符可以是private、protected、public，如果父类重写了这两个方法，子类都需要根据自身需求重写，这显然不是一个好的设计。通常建议对于final修饰的类重写readResolve方法没有问题；否则，重写readResolve使用private修饰。

## 2.3 Externalizable：强制自定义序列化 ##

通过实现Externalizable接口，必须实现writeExternal、readExternal方法。

public interface Externalizable extends java.io.Serializable { 
         void writeExternal(ObjectOutput out) throws IOException;
         void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
    }
    
    public class ExPerson implements Externalizable { 
    
        private String name;
        private int age;
        //注意，必须加上pulic 无参构造器
        public ExPerson() { 
        }
    
        public ExPerson(String name, int age) { 
            this.name = name;
            this.age = age;
        }
    
        @Override
        public void writeExternal(ObjectOutput out) throws IOException { 
            //将name反转后写入二进制流
            StringBuffer reverse = new StringBuffer(name).reverse();
            System.out.println(reverse.toString());
            out.writeObject(reverse);
            out.writeInt(age);
        }
    
        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { 
            //将读取的字符串反转后赋值给name实例变量
            this.name = ((StringBuffer) in.readObject()).reverse().toString();
            System.out.println(name);
            this.age = in.readInt();
        }
    
        public static void main(String[] args) throws IOException, ClassNotFoundException { 
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ExPerson.txt"));
                 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ExPerson.txt"))) { 
                oos.writeObject(new ExPerson("brady", 23));
                ExPerson ep = (ExPerson) ois.readObject();
                System.out.println(ep);
            }
        }
    }

输出结果

ydarb
    brady
    ExPerson{name='brady', age=23}

注意：Externalizable接口不同于Serializable接口：

*  实现此接口必须实现接口中的两个方法实现自定义序列化，这是强制性的；
 *  必须提供pulic的无参构造器，因为在反序列化的时候需要反射调用构造方法来创建对象。

## 2.4 JDK两种序列化对比 ##

<table> 
 <thead> 
  <tr> 
   <th>实现Serializable接口</th> 
   <th>实现Externalizable接口</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>系统自动存储必要的信息</td> 
   <td>程序员决定存储哪些信息</td> 
  </tr> 
  <tr> 
   <td>Java内建支持，易于实现，只需要实现该接口即可，无需任何代码支持</td> 
   <td>必须实现接口内的两个方法</td> 
  </tr> 
  <tr> 
   <td>性能略差</td> 
   <td>性能略好</td> 
  </tr> 
 </tbody> 
</table>

虽然Externalizable接口带来了一定的性能提升，但变成复杂度也提高了，所以一般通过实现Serializable接口进行序列化。

## 2.5 serialVersionUID-序列化版本号 ##

我们知道，反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化怎么保证升级前后的兼容性呢？

java序列化提供了一个`private static final long serialVersionUID`的序列化版本号，只有版本号相同，即使更改了序列化属性，对象也可以正确被反序列化回来。

public class Person implements Serializable { 
        //序列化版本号
        private static final long serialVersionUID = 1111013L;
        private String name;
        private int age;
        //省略构造方法及get,set
    }

如果反序列化使用的class因为Class属性变化导致版本号与序列化时使用的不一致，反序列化会报`InvalidClassException`异常。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 2]

序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化；不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化。

什么情况下需要修改serialVersionUID呢？分三种情况。

*  如果只是修改了方法，反序列化不容影响，则无需修改版本号； 实测修改了方法也会导致反序列化报错`java.io.InvalidClassException: demos.Serializable.test1.Person; local class incompatible`
 *  如果只是修改了静态变量，瞬态变量（transient修饰的变量），反序列化不受影响，无需修改版本号；
 *  如果修改了非瞬态变量，则可能导致反序列化失败。  
    如果新类中实例变量的类型与序列化时类的类型不一致，则会反序列化失败，这时候需要更改serialVersionUID。
    
    **如果只是新增了实例变量，则反序列化回来新增的是默认值；如果减少了实例变量，反序列化时会忽略掉减少的实例变量。**

总的来说，当序列号显式一致的时候，序列化前后类变动的多余的内容或者减少的内容不会影响反序列化，即反序列化时多余的部分将忽略，少的部分将取默认值。

但如果没有显式指定序列号，会因为JVM为该类自动生成的序列号变化而发生错误反序列化错误。

但如果是实例字段类型或方法描述发生变化，则会反序列化失败，这时候需要更改serialVersionUID。

例子可参考

*  [private static final long serialVersionUID = 1L这句话到底什么意思？][private static final long serialVersionUID _ 1L]

## 2.5 JDK序列化总结 ##

*  所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。
 *  对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；
 *  方法、类变量、transient实例变量都不会被序列化。
 *  如果想让某个变量不被序列化，使用transient修饰。
 *  序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
 *  反序列化时必须有序列化对象的class文件。
 *  当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。
 *  单例类序列化，需要重写`readResolve()`方法以使得每次返回同一个对象；否则会破坏单例原则。
 *  同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。
 *  建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级。

## 2.6 JDK序列化问题 ##

*  效率低
 *  安全问题  
    Java中的默认序列化是存在一些安全问题的,例如对象序列化以后的字节通过网络传输,有可能在网络中被截取。那如何保证数据安全呢?通常可以在对象序列化时对对象内容进行加密,对象反序列化时对内容进行解密。详见[Java中的默认序列化存在安全问题如何解决?][Java]
 *  序列化结果太大

# 3 Protobuf #

## 3.1 简介 ##

Java序列化组件效率低，有安全问题，所以现在各大开源组件基本都不再使用JDK序列化，而是使用第三方序列化工具，来自google的Protobuf大放异彩。

Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了 C++、Java、Python 三种语言的 API。

## 3.2 Protobuf安装 ##

*  下载: [Protocol Buffers releases][]
 *  解压
 *  安装
    
        cd protoc-3.6.1-osx-x86_64
        cp -r include/ /usr/local/include/
        cp -r bin/ /usr/local/bin/
 *  测试
    
        protoc --version
        protoc --help

## 3.3 idea 配置 ##

pom.xml增加：

<dependencies>
    	
    	<dependency>
    	    <groupId>com.google.protobuf</groupId>
    	    <artifactId>protobuf-java</artifactId>
    	    <version>3.6.1</version>
    	</dependency>
    	
    	<dependency>
    	    <groupId>com.google.protobuf</groupId>
    	    <artifactId>protobuf-java-util</artifactId>
    	    <version>3.6.1</version>
    	</dependency>
    </dependencies>
    
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
    		
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.5.0</version>
                <configuration>
                    <protocArtifact>
                        com.google.protobuf:protoc:3.6.1:exe:${os.detected.classifier}
                    </protocArtifact>
                    <pluginId>protoc-java</pluginId>
                    <protoSourceRoot>${project.basedir}/src/main/resources/netty/protobuf</protoSourceRoot>
                  
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    
        <extensions>
            
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.5.0.Final</version>
            </extension>
        </extensions>
    </build>

## 3.4 Idea Protobuf插件 ##

以前叫[Protobuf Support][]，但已经废弃：  
![在这里插入图片描述][20200708143222104.png]  
新的插件名为：Protocol Buffer Editor

*  [Git地址][Git]
 *  [插件地址][Link 1]

## 3.5 .proto文件生成 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 3]

## 3.6 .proto -> .java ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 4]  
生成的类如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 5]

[java]: https://www.cnblogs.com/9dragon/p/10901448.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70]: /images/20230209/d1e05daa035849dbabf94e2be6b36740.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 1]: /images/20230209/6cae3b998f854d749fbdea3b2ca7e9d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 2]: /images/20230209/49d98fe658c7466ead12f1033fa7ab7e.png
[private static final long serialVersionUID _ 1L]: https://www.zhihu.com/question/24852886/answer/117314768
[Java]: https://blog.csdn.net/qianzhitu/article/details/103002673
[Protocol Buffers releases]: https://github.com/protocolbuffers/protobuf/releases
[Protobuf Support]: https://github.com/protostuff/protobuf-jetbrains-plugin
[20200708143222104.png]: /images/20230209/206ef14b931a4f50adf9019561eb895d.png
[Git]: https://github.com/jvolkman/intellij-protobuf-editor
[Link 1]: https://plugins.jetbrains.com/plugin/14004-protocol-buffer-editor
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 3]: /images/20230209/7ee12f1701414802a8e446f60965f2f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 4]: /images/20230209/89f3ab2c281e40f48174d4f17aa85776.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWNob3VmZWk5MA_size_16_color_FFFFFF_t_70 5]: /images/20230209/d13155c8d84445e6a34518caf40a27ac.png