1.从Serilizable说到transient

我们知道,如果一个对象需要序列化,那么需要实现Serilizable接口,那么这个类的所有非静态属性,都会被序列化。

注意:上面说的是非静态属性,因为静态属性是属于类的,而不是属于类对象的,而序列化是针对类对象的操作,所以这个根本不会序列化。下面我们可以实验一下:

实体类Teacher.class:

import java.io.Serializable;

class Teacher implements Serializable {
public int age;
public static String SchoolName; public Teacher(int age) {
this.age = age;
} @Override
public String toString() {
return "Teacher{" +
"age=" + age +
'}';
}
}

测试代码SerialTest.java,基本思路就是初始化的时候,静态属性SchoolName为"东方小学",序列化对象之后,将静态属性修改,然后,反序列化,发现其实静态变量还是修改之后的,说明静态变量并没有被序列化。

import java.io.*;

public class SerialTest {
public static void main(String[] args) {
Teacher.SchoolName = "东方小学";
serial();
Teacher.SchoolName = "西方小学";
deserial();
System.out.println(Teacher.SchoolName);
}
// 序列化
private static void serial(){
try {
Teacher teacher = new Teacher(9);
FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(teacher);
objectOutputStream.flush();
} catch (Exception exception) {
exception.printStackTrace();
}
}
// 反序列化
private static void deserial() {
try {
FileInputStream fis = new FileInputStream("Teacher.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Teacher teacher = (Teacher) ois.readObject();
ois.close();
System.out.println(teacher.toString());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}

输出的结果,证明静态变量没有被序列化!!!

Teacher{age=9}
西方小学

2.序列化属性对象的类需要实现Serilizable接口?

突然想到一个问题,如果有些属性是对象,而不是基本类型,需不需要改属性的类型也实现Serilizable呢?

问题的答案是:需要!!!

下面是实验过程:

首先,有一个Teacher.java,实现了Serializable,里面有一个属性是School类型:

import java.io.Serializable;

class Teacher implements Serializable {
public int age; public School school;
public Teacher(int age) {
this.age = age;
} @Override
public String toString() {
return "Teacher{" +
"age=" + age +
'}';
}
}

School类型,不实现Serializable:


public class School {
public String name; public School(String name) {
this.name = name;
} @Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
'}';
}
}

测试代码,我们只测试序列化:

import java.io.*;

public class SerialTest {
public static void main(String[] args) {
serial();
} private static void serial(){
try {
Teacher teacher = new Teacher(9);
teacher.school = new School("东方小学");
FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(teacher);
objectOutputStream.flush();
} catch (Exception exception) {
exception.printStackTrace();
}
} }

会发现报错了,报错的原因是:School不能被序列化,也就是没有实现序列化接口,所以如果我们想序列化一个对象,那么这个对象的属性也必须是可序列化的,或者它是transient修饰的。

java.io.NotSerializableException: com.aphysia.transienttest.School
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
at com.aphysia.transienttest.SerialTest.serial(SerialTest.java:18)
at com.aphysia.transienttest.SerialTest.main(SerialTest.java:9)

当我们将School实现序列化接口的时候,发现一切就正常了...问题完美解决

3.不想被序列化的字段怎么办?

但是如果有一个变量不是静态变量,但是我们也不想序列化它,因为它可能是一些密码等敏感的字段,或者它是不那么重要的字段,我们不希望增加报文大小,所以想在序列化报文中排除该字段。或者改字段存的是引用地址,不是真正重要的数据,比如ArrayList里面的elementData

这个时候就需要使用transient 关键字,将改字段屏蔽。

当我们用transient修饰School的时候:

import java.io.Serializable;

class Teacher implements Serializable {
public int age; public transient School school;
public Teacher(int age) {
this.age = age;
} @Override
public String toString() {
return "Teacher{" +
"age=" + age +
", school=" + school +
'}';
}
}
import java.io.Serializable;

public class School implements Serializable {
public String name; public School(String name) {
this.name = name;
} @Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
'}';
}
}

执行下面序列化和反序列化的代码:

import java.io.*;

public class SerialTest {
public static void main(String[] args) {
serial();
deserial();
} private static void serial(){
try {
Teacher teacher = new Teacher(9);
teacher.school = new School("东方小学");
FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(teacher);
objectOutputStream.flush();
} catch (Exception exception) {
exception.printStackTrace();
}
} private static void deserial() {
try {
FileInputStream fis = new FileInputStream("Teacher.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Teacher teacher = (Teacher) ois.readObject();
ois.close();
System.out.println(teacher.toString());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}

执行结果如下,可以看到teacher字段反序列化出来,其实是null,这也是transient起作用了。

但是注意,transient只能修饰变量,但是不能修饰类和方法,

4.ArrayList里面的elementData都被transient 关键字修饰了,为什么ArrayList还可以序列化呢?

这里提一下,既然transient修饰了ArrayList的数据节点,那么为什么序列化的时候我们还是可以看到ArrayList的数据节点呢?

这是因为序列化的时候:

如果仅仅实现了Serializable接口,那么序列化的时候,肯定是调用java.io.ObjectOutputStream.defaultWriteObject()方法,将对象序列化。然后如果是transient修饰了该属性,肯定该属性就不能序列化。

但是,如果我们虽然实现了Serializable接口,也transient修饰了该属性,该属性确实不会在默认的java.io.ObjectOutputStream.defaultWriteObject()方法里面被序列化了,但是我们可以重写一个writeObject()方法,这样一来,序列化的时候调用的就是writeObject(),而不是java.io.ObjectOutputStream.defaultWriteObject()

下面的源码是ObjectInputStream.writeObject(Object obj),里面底层其实会有反射的方式调用到重写的对象的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;
}
}

ArrayList重写的writeOject()方法如下:

    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();
}
}

我们可以看到,writeOject()里面其实在里面调用了默认的方法defaultWriteObject()defaultWriteObject()底层其实是调用改了writeObject0()ArrayList重写的writeOject()的思路主要是先序列化默认的,然后序列化数组大小,再序列化数组elementData里面真实的元素。这就达到了序列化元素真实内容的目的。

5.除了transient,有没有其他的方式,可以屏蔽反序列化?

且慢,问出这个问题,答案肯定是有的!!!那就是Externalizable接口。

具体情况:Externalizable意思就是,类里面有很多很多属性,但是我只想要一部分,要屏蔽大部分,那么我不想在大部分的属性前面加关键字transient,我只想标识一下自己序列化的字段,这个时候就需要使用Externalizable接口。

show me the code!

首先定义一个Person.java,里面有三个属性

  • age:年龄
  • name:名字(被transient修饰)
  • score:分数

实现了Externalizable接口,就必须实现writeExternal()readExternal()方法。

  • writeExternal:将需要序列化的属性进行自定义序列化
  • readExternal:将需要反序列化的属性进行自定义反序列化
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput; public class Person implements Externalizable {
public int age;
public transient String name;
public int score; // 必须实现无参构造器
public Person() {
} public Person(int age, String name, int score) {
this.age = age;
this.name = name;
this.score = score;
} @Override
public void writeExternal(ObjectOutput out) throws IOException {
/*
* 指定序列化时候写入的属性。这里不写入score
*/
out.writeObject(age);
out.writeObject(name);
out.writeObject(score);
} @Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
/*
* 指定序列化时候写入的属性。这里仍然不写入年龄
*/
this.age = (int)in.readObject();
this.name = (String)in.readObject();
} @Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
", score='" + score + '\'' +
'}';
}
}

上面的代码,我们可以看出,序列化的时候,将三个属性都写进去了,但是反序列化的时候,我们仅仅还原了两个,那么我们来看看测试的代码:

import java.io.*;

public class ExternalizableTest {
public static void main(String[] args) {
serial();
deserial();
} private static void serial(){
try {
Person person = new Person(9,"Sam",98);
FileOutputStream fileOutputStream = new FileOutputStream("person.txt");
ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(person);
objectOutputStream.flush();
} catch (Exception exception) {
exception.printStackTrace();
}
} private static void deserial() {
try {
FileInputStream fis = new FileInputStream("person.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Person person = (Person) ois.readObject();
ois.close();
System.out.println(person);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}

测试结果如下,就可以发现其实前面两个都反序列化成功了,后面那个是因为我们重写的时候,没有自定义该属性的反序列化,所以没有是正常的啦...

Person{age=9, name='Sam', score='0'}

如果细心点,可以发现,有一个字段是transient修饰的,不是说修饰了,就不会被序列化么,怎么序列化出来了。

没错,只要实现了Externalizable接口,其实就不会被transient左右了,只会按照我们自定义的字段进行序列化和反序列化,这里的transient是无效的...

关于序列化的transient暂时到这,keep going~

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

技术之路不在一时,山高水长,纵使缓慢,驰而不息。

公众号:秦怀杂货店

transient关键字的作用以及几个疑问的解决的更多相关文章

  1. Java对象表示方式1:序列化、反序列化和transient关键字的作用

    平时我们在Java内存中的对象,是无法进行IO操作或者网络通信的,因为在进行IO操作或者网络通信的时候,人家根本不知道内存中的对象是个什么东西,因此必须将对象以某种方式表示出来,即存储对象中的状态.一 ...

  2. 序列化、反序列化和transient关键字的作用

    引言 将 Java 对象序列化为二进制文件的 Java 序列化技术是 Java 系列技术中一个较为重要的技术点,在大部分情况下,开发人员只需要了解被序列化的类需要实现 Serializable 接口, ...

  3. transient关键字的作用

    代码如下: import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutpu ...

  4. java中transient关键字的作用

    Java有个特点就是序列化,简单地来说就是可以将这个类存储在物理空间(当然还是以文件的形式存在),那么当你从本地还原这个文件时,你可以将它转换为它本身.这可以极大地方便网络上的一些操作,但同时,因为涉 ...

  5. 序列化,反序列化和transient关键字

    一.序列化和反序列化的概念 序列化:指把java对象转换为字节序列的过程. 反序列化:指把字节序列恢复为java对象的过程. 对象的序列化主要有两种用途: 1) 把对象的字节序列保存到硬盘上,通常存放 ...

  6. K:java序列化与反序列化—transient关键字的使用

      首先,应该明白的是transient是java中的一个关键字,音标为 英: [ˈtrænziənt].   在了解transient关键字之前,应该先弄明白序列化和反序列化.所谓的序列化,通俗点的 ...

  7. [转]Java transient关键字

    java 的transient关键字的作用是需要实现Serilizable接口,将不需要序列化的属性前添加关键字transient,序列化对象的时候,这个属性就不会序列化到指定的目的地中. trans ...

  8. Java的transient关键字

    Java的transient关键字   Java 中的 transient 关键字被用来表示变量将不被序列化处理.那么在理解 transient 关键字之前,我们先了解下什么是序列化. 什么是序列化 ...

  9. Java中的实体类--Serializable接口、transient 关键字

    在java中,实体类是一个非常重要的概念,我们可以在实体类中封装对象.设置其属性和方法等.关于实体类,也经常涉及到适配器模式.装饰者模式等设计模式.那么在实际代码开发中,关于实体类的注意事项有哪些呢? ...

随机推荐

  1. Win32之创建进程

    CreateProcess函数介绍 BOOL CreateProcessA( LPCSTR lpApplicationName, //可执行文件的名称完整的路径+程序名字) LPSTR lpComma ...

  2. NoSQL非关系型数据库

    NoSQL 关注公众号"轻松学编程"了解更多. 一.概念 NoSQL(Not Only SQL)非关系型数据库(功能换效率). 优点 开发维护成本低 访问灵活 访问速度快(缓存+快 ...

  3. ElasticSearch7.3破解

    破解ES7.3.0到白金版(学习交流使用) 正常安装ELK7.3版本到服务器上 正常部署ELK7到服务器上,先不要启动.然后开始进行破解操作 进行破解操作 需要破解的文件:modules/x-pack ...

  4. 题解 AT3877 【[ARC089C] GraphXY】

    参考的博客 在[有趣的思维题]里看到了这道题. 题意: 给出一个\(A\times B\)的矩阵,其中第i行第j列元素为\(d_{i,j}\),试构造一个有向图,满足: 有向图点数\(\le 300\ ...

  5. 像用excel一样用pandas

    1 说明 预计需要15min阅读此教材: 本教材仅讲述如何查看excel数据,筛选,排序,查找替换数据,不涉及excel中复杂的图形绘制及样式修改. 2 假设 假设,已经存在一个test.xlsx文件 ...

  6. 8. Prism导航

    1. 背景 导航是为了实现不同界面的切换,是一种组织系统功能的方式.提供两种导航,一是基于View切换,二是基于ViewModel状态. 2. 基于View切换的导航 最常用导航方式.在该种导航中首先 ...

  7. 庐山真面目之三微服务架构Consul版本实现

    庐山真面目之三微服务架构Consul版本实现 一.简介           在上一篇文章<庐山真面目之二微服务架构NGINX版本实现>中,我们已经探讨了如何搭建基于Nginx 网关的微服务 ...

  8. HTML5+CSS3 QQ会员页面导航

    <!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8" ...

  9. Find Any File for Mac(文件搜索软件)v2.1.2b6

    Find Any File for Mac是应用在Mac上的一款文件搜索工具,Find Any File Mac可以通过名称.创建或修改日期,大小或类型和创建者代码(而不是内容)在本地磁盘上搜索文件. ...

  10. Python--安装 PyQt5, pyqt5-tools

    # 使用豆瓣镜像源 anaconda prompt界面里输入: pip install pyqt5-tools -i https://pypi.douban.com/simple/