序列化和反序列化看起来用的不多，但用起来就很关键，因为稍一不注意就会出现问题。序列化的应用场景在哪里？当然是数据存储和传输。比如缓存，需要将对象复刻到硬盘存储，即使断电也可以重新反序列化恢复。下面简单理解序列化的用法以及注意事项。
Java中想要序列化一个对象，必须实现Serializable接口。然后就可以持久化和反序列化了。下面是一个简单用法。
我们给一个测试类：
package com.test.java.serial;
import lombok.Builder;
import lombok.Data;
import java.io.Serializable;
/**
* @author Ryan Miao
*/
@Data
@Builder
public class Foo implements Serializable {
private static final String LOGGER = "logger";
public static final String PUB_STATIC_FINAL = "publicStaticFinal";
public static String PUB_STATIC;
public String fa;
private String fb;
transient public String ta;
transient private String tb;
}然后，测试序列化和反序列的数据是否丢失。
public class TestSerialize {
private static final String filename = "D:/test.txt";
@Test
public void testSer() throws IOException, ClassNotFoundException {
final Foo foo = Foo.builder()
.fa("fa")
.fb("fb")
.ta("ta")
.tb("tb")
.build();
Foo.PUB_STATIC = "test";
ObjectOutputStream os = new ObjectOutputStream(
new FileOutputStream(filename));
os.writeObject(foo);
os.flush();
os.close();
}
@Test
public void testRead() throws IOException, ClassNotFoundException {
ObjectInputStream is = new ObjectInputStream(new FileInputStream(filename));
Foo foo2 = (Foo) is.readObject();
is.close();
Assert.assertEquals("fa", foo2.getFa());
Assert.assertEquals("fb", foo2.getFb());
Assert.assertEquals(null, foo2.getTa());
Assert.assertEquals(null, foo2.getTb());
Assert.assertNull(foo2.PUB_STATIC);
}
}显然，transient修饰的字段不能被序列化，至于静态字段，这里不做测试，但要清楚。静态字段只和class类相关，和实例无关。而序列化是针对实例的，所以无所谓对比内容变化。那么，静态字段反序列化后数据是什么样子的呢？当然是类变量本身应该的样子。如果没有初始化，则是默认值， 本测试中的结果为null。
我们只要实现了Serialiable就可以序列化，那么为什么呢？查看ObjectOutputStream的writeObject方法。
// remaining cases
if (obj instanceof String) {
writeString((String) obj, unshared);
} else if (cl.isArray()) {
writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
writeEnum((Enum<?>) obj, desc, unshared);
} else if (obj instanceof Serializable) {
writeOrdinaryObject(obj, desc, unshared);
} else {
if (extendedDebugInfo) {
throw new NotSerializableException(
cl.getName() + "\n" + debugInfoStack.toString());
} else {
throw new NotSerializableException(cl.getName());
}
}显然，只针对String，Enum以及Serializable做了处理，因此想要序列化必须要实现这个接口。当然，String和Enum也实现了Serializable。
简单的对象，对于不想序列化的字段，只要声明为transient就好。而有时候，我想对部分字段处理后序列化。比如ArrayList中存储数据的transient Object[] elementData;。我们知道ArrayList是可以序列化的，根源就在于自定义这里了。下面跟踪ObjectOutputStream源码，知道自定义的执行部分就可以验证了。
入口： java.io.ObjectOutputStream#writeObject
public final void writeObject(Object obj) throws IOException {
if (enableOverride) {
writeObjectOverride(obj);
return;
}
try {
writeObject0(obj, false);
} catch (IOException ex) {
if (depth == 0) {
writeFatalException(ex);
}
throw ex;
}
}然后，核心方法
private void writeObject0(Object obj, boolean unshared)
throws IOException{
boolean oldMode = bout.setBlockDataMode(false);depth++;
try {
//省略若干行
for (;;) {
// 省略若干行
desc = ObjectStreamClass.lookup(cl, true);
//省略若干行
}
//省略若干行
if (obj instanceof String) {
writeString((String) obj, unshared);
} else if (cl.isArray()) {
writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
writeEnum((Enum<?>) obj, desc, unshared);
} else if (obj instanceof Serializable) {
writeOrdinaryObject(obj, desc, unshared);
} else {
//....
}
} finally {
depth--;
bout.setBlockDataMode(oldMode);
}
}这里，显然可以看到真正的执行序列化代码是writeOrdinaryObject(obj, desc, unshared);。 但直接追踪进去发现里面有许多初始化的字段是在之前做的处理。因此，先卖个关子，看前面初始化的部分，只找到我们想要初始化的字段即可。
进入desc = ObjectStreamClass.lookup(cl, true);
static ObjectStreamClass lookup(Class<?> cl, boolean all) {
//省略若干行
if (entry == null) {
try {
entry = new ObjectStreamClass(cl);
} catch (Throwable th) {
entry = th;
}
//.....
}
//省略若干行
}进入entry = new ObjectStreamClass(cl);这里就是真正的初始化地方，前面省略的代码是缓存处理，当然缓存使用的ConcurrentHashMap。
private ObjectStreamClass(final Class<?> cl) {
//省略无数行以及括号
writeObjectMethod = getPrivateMethod(cl, "writeObject",
new Class<?>[] { ObjectOutputStream.class },
Void.TYPE);
readObjectMethod = getPrivateMethod(cl, "readObject",
new Class<?>[] { ObjectInputStream.class },
Void.TYPE);
//省略无数行没错，费了这么大劲就是为了找到这两个method。通过反射，获取到目标class的两个私有方法writeObject, readObject。这两个就是自定义方法所在。
初始化完毕之后，我们再来继续序列化的代码. 回到刚才的核心方法，找到writeOrdinaryObject(obj, desc, unshared);， 进入，然后，继续找到writeSerialData(obj, desc);, 到这里就是真正执行序列化的代码了。
private void writeSerialData(Object obj, ObjectStreamClass desc)
throws IOException
{
ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
for (int i = 0; i < slots.length; i++) {
ObjectStreamClass slotDesc = slots[i].desc;
if (slotDesc.hasWriteObjectMethod()) {
//....
try {
curContext = new SerialCallbackContext(obj, slotDesc);
bout.setBlockDataMode(true);
slotDesc.invokeWriteObject(obj, this);
bout.setBlockDataMode(false);
bout.writeByte(TC_ENDBLOCKDATA);
} finally {
//...
}
curPut = oldPut;
} else {
defaultWriteFields(obj, slotDesc);
}
}
}显然，判断writeObject这个method是否初始化了，如果有，则直接调用这个方法，没有则默认处理。到此，跟踪完毕，我想要自定义序列化只要重写writeObject, readObject这两个方法即可。
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}因为数组被设置不允许序列化，先默认序列化其他信息，然后单独处理数组里的内容，挨着写入元素。然后，对应读取方法也要改。
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}为什么要这么做？因为数组元素有很多空余空间，对我们来说不需要序列化。通过这样自定义，把需要的元素序列化，可以节省空间。
以下内容来自： https://www.cnblogs.com/ouym/p/6654798.html
serialVersionUID表示：“串行化版本统一标识符”（serial version universal identifier），简称UID
serialVersionUID必须定义成下面这种形式：static final long serialVersionUID = xxxL;
serialVersionUID 用来表明类的不同版本间的兼容性。有两种生成方式： 一个是默认的1L；另一种是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段 。
java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。 java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
只有实现了Serializable或Externalizable接口的类的对象才能被序列化。
Externalizable接口继承自Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式 。 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：private static final long serialVersionUID;
类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，有可能会导致不同的serialVersionUID。显式地定义serialVersionUID有两种用途：
并非所有的对象都可以序列化，,至于为什么不可以，有很多原因了,比如：
关注我的公众号
微信关注我们
转载内容版权归作者及来源网站所有！
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。
马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。
为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。
Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。
扫码在手机上查看文章
扫描二维码，手机阅读更方便
有任何问题或合作意向欢迎联系我们
Email: 99873273@qq.com
QQ: 99873273
