1、如果某个成员变量是敏感信息，不希望序列化到文件/网络节点中，比如说银行密码，或者该成员变量所属的类是不可序列化的，
可以用 transient 关键字修饰此成员变量，序列化时会忽略此成员变量。
我要评论1 class vipuser{
2 private int id;
3 private string name;
4 //序列化时，此成员变量不会写入到磁盘文件/网络节点中。
5 private transient string password;
6 //如果user类是不可序列化的，用transient修饰，序列化时会忽略这个成员变量，不会抛出异常
7 private transient user user;
8 //.......
9 }
transient只能修饰成员变量。
2、transient很方便，但是反序列化时，不能取得此成员变量的值。
如果要保证序列化后某些成员变量是安全的，不会被别人识别、破解，在反序列化时也可以读取该成员变量的值，这就需要自定义序列化了。
自定义序列化的类需要继承serializable接口，并要写三个方法：
serializable接口中没有任何成员，上面3个方法都是我们自己写的。
三个方法都是可选的，不强制，但一般都要实现前2个方法。
示例：
1 //implements serializable
2 class user implements serializable{
3 private int id;
4 private string name;
5 private string password;
6 //......其他成员变量
7
8 public user(int id,string name,string password){
9 this.id=id;
10 this.name=name;
11 this.password=password;
12 }
13
14 public int getid() {
15 return id;
16 }
17
18 public string getname() {
19 return name;
20 }
21
22 public string getpassword() {
23 return password;
24 }
25
26 //自定义序列化
27 private void writeobject(objectoutputstream out) throws ioexception {
28 //只序列化以下3个成员变量
29 out.writeint(id);
30 out.writeobject(name);
31 //写入反序后的密码，当然我们也可以使用其他加密方式。这样别人打开文件，看到的就不是真正的密码，更安全。
32 out.writeobject(new stringbuffer(password).reverse());
33 }
34
35 //自定义反序列化。注意：read()的顺序要和write()的顺序一致。比如说序列化时写的顺序是id、name、password，反序列化时读的顺序也要是id、name、password。
36 private void readobject(objectinputstream in) throws ioexception, classnotfoundexception {
37 this.id=in.readint();
38 //readobject()返回的是object，要强制类型转换
39 this.name=(string)in.readobject();
40 //反序才得到真正的密码
41 stringbuffer pwd=(stringbuffer)in.readobject();
42 this.password=pwd.reverse().tostring();
43 }
44
45 }
1 public class test {
2 public static void main(string[] args) throws ioexception, classnotfoundexception {
3 user zhangsan=new user(1,"张三","1234");
4
5 //序列化
6 objectoutputstream out=new objectoutputstream(new fileoutputstream("./obj.txt"));
7 //调用我们自定义的writeobject()方法
8 out.writeobject(zhangsan);
9 out.close();
10
11 //反序列化
12 objectinputstream in=new objectinputstream(new fileinputstream("./obj.txt"));
13 //调用自定义的readobject()方法
14 user user=(user)in.readobject(); //写掉了一句 in.close()
15
16 //测试
17 system.out.println(user.getid()); //1
18 system.out.println(user.getname()); //张三
19 system.out.println(user.getpassword()); //1234
20 }
21 }
3、我们甚至可以偷梁换柱，替换序列化的整个对象。
不写上面提到的3个方法，而是写writereplace()方法:
private/default/protected/public object writereplace(){................}
访问权限可以是任意的。 返回一个object类型的对象。
序列化时，会先自动调用writereplace()方法，用返回的这个对象，替换要序列化的那个对象，再进行序列化。就是说，实际序列化的是writereplace()返回的这个对象，并不是原来的对象。
示例：
1 //implements serializable
2 class user implements serializable{
3 private int id;
4 private string name;
5 private string password;
6 //......其他成员变量
7
8 public user(int id,string name,string password){
9 this.id=id;
10 this.name=name;
11 this.password=password;
12 }
13
14 public int getid() {
15 return id;
16 }
17
18 public string getname() {
19 return name;
20 }
21
22 public string getpassword() {
23 return password;
24 }
25
26 //不用写writeobject()、readobject()，只写writereplace(）
27 private object writereplace(){
28 user lisi=new user(2,"李四","qwer");
29 return lisi;
30 }
31
32 }
1 public class test {
2 public static void main(string[] args) throws ioexception, classnotfoundexception {
3 user zhangsan=new user(1,"张三","1234");
4
5 //序列化
6 objectoutputstream out=new objectoutputstream(new fileoutputstream("./obj.txt"));
7 //执行writeobject(）时，会先自动调用writereplace()，用返回的lisi替换原来的zhangsan，再序列化，实际序列化的对象是lisi
8 out.writeobject(zhangsan);
9 out.close();
10
11 //反序列化
12 objectinputstream in=new objectinputstream(new fileinputstream("./obj.txt"));
13 user user=(user)in.readobject(); //写掉了一句 in.close()
14
15 //测试
16 system.out.println(user.getid()); //2
17 system.out.println(user.getname()); //李四
18 system.out.println(user.getpassword()); //qwer
19 }
20 }
writereplace()返回的是object，就是说任意类型均可。我们完全可以返回其他类型的对象，比如这样：
1 private object writereplace(){
2 //返回字符串ok
3 return new string("ok");
4 }
1 public class test {
2 public static void main(string[] args) throws ioexception, classnotfoundexception {
3 user zhangsan=new user(1,"张三","1234");
4
5 //序列化
6 objectoutputstream out=new objectoutputstream(new fileoutputstream("./obj.txt"));
7 //会自动调用writereplace()，用字符串ok替换对象zhangsan，实际序列化的对象字符串ok
8 out.writeobject(zhangsan);
9 out.close();
10
11 //反序列化
12 objectinputstream in=new objectinputstream(new fileinputstream("./obj.txt"));
13 string str=(string) in.readobject();
14 in.close();
15
16 //测试
17 system.out.println(str); //ok
18 }
19 }
当然，常见的做法是，对原对象的成员变量做一些加工处理。
1 //implements serializable
2 class user implements serializable{
3 private int id;
4 private string name;
5 private string password;
6
7 public user(int id,string name,string password){
8 this.id=id;
9 this.name=name;
10 this.password=password;
11 }
12
13 //......
14
15 private object writereplace(){
16 string info="请编号为"+id+"的客户"+name+"到1号柜台办理业务。";
17 return info;
18 }
19
20 }
4、我们也可以替换掉反序列化得到的整个对象。
private/default/protected/public object readresolve(){................}
在反序列化读取对象后，会自动调用此方法，将读取的对象替换为指定的对象。
1 //implements serializable
2 class user implements serializable{
3 private int id;
4 private string name;
5 private string password;
6 //......其他成员变量
7
8 public user(int id,string name,string password){
9 this.id=id;
10 this.name=name;
11 this.password=password;
12 }
13
14 //...........
15
16 //用指定的对象替换掉反序列化读取的对象
17 private object readresolve(){
18 string info="请编号为"+id+"的客户"+name+"到1号柜台办理业务。";
19 return info;
20 }
21
22 }
1 public class test {
2 public static void main(string[] args) throws ioexception, classnotfoundexception {
3 user zhangsan=new user(1,"张三","1234");
4
5 //序列化
6 objectoutputstream out=new objectoutputstream(new fileoutputstream("./obj.txt"));
7 out.writeobject(zhangsan);
8 out.close();
9
10 //反序列化
11 objectinputstream in=new objectinputstream(new fileinputstream("./obj.txt"));
12 string str=(string) in.readobject(); //读取的对象zhangsan会被替换为字符串info
13 in.close();
14
15 //测试
16 system.out.println(str); //请编号为1的客户张三到1号柜台办理业务。
17 }
18 }
4和3的使用方式是相同的，只是作用的时间点不同，可以联合使用。
虽然访问权限没有限制，但为了防止子类重写这些方法，造成不必要的麻烦，我们一般使用private修饰。
说明：
这些方法都是在要序列化的类中写的，只对这个类的对象起作用。
比如，我在user类中写了个writereplace()方法，此方法只在序列化user类的对象时起作用，在序列化其他类的对象时，此方法是不起作用的。
5、之前介绍的方式都是implements serializable，我们也可以implement externalizable来实现序列化、反序列化。
要实现externalizable接口里的2个抽象方法：
示例：
1 //implements externalizable
2 class user implements externalizable{
3 private int id;
4 private string name;
5 private string password;
6 //......其他成员变量
7
8 //必须要有无参的构造函数
9 public user(){
10
11 }
12
13 public user(int id,string name,string password){
14 this.id=id;
15 this.name=name;
16 this.password=password;
17 }
18
19 public int getid() {
20 return id;
21 }
22
23 public string getname() {
24 return name;
25 }
26
27 public string getpassword() {
28 return password;
29 }
30
31 //自定义序列化
32 @override
33 public void writeexternal(objectoutput out) throws ioexception {
34 out.writeint(id);
35 out.writeobject(name);
36 out.writeobject(password);
37 }
38
39 //自定义反序列化。注意读的顺序要和写的顺序一致。
40 @override
41 public void readexternal(objectinput in) throws ioexception, classnotfoundexception {
42 this.id=in.readint();
43 this.name=(string)in.readobject();
44 this.password=(string)in.readobject();
45 }
46 }
implements serializable不要求要有无参的构造函数，但implements externalizable要求必须要有无参的构造函数，没有无参的构造函数，会报错。
因为反序列化时，要先自动调用无参的构造函数创建一个未初始化的对象，再自动调用readexternal()给这个对象的成员变量赋值，初始化这个对象，然后才返回这个对象。
有无参的构造函数，但没有在readexternal()中初始化某些成员变量，会正常返回该对象，只是对应的成员变量的值会使用默认的初始值，比如int是0，引用型的是null。
string、stringbuffer、stringbuilder都是引用型的。
6、2种序列化机制的比较
| 实现serializable接口 | 实现externalizable接口 |
|
如果未自定义序列化、反序列化方式，则系统会自动保存所有的成员变量。 如果自定义了序列化、反序列化方式，则按自定义的方式处理。 |
只能自定义序列化、反序列化方式， 必须实现2个抽象方法。 |
| 有没有无参的构造函数都行。 | 必须要有无参的构造函数。 |
| 性能略低。 | 性能略高 |
对象的类名、成员变量中的实例变量（基本类型+引用类型）都会被序列化。
transient、static修饰的成员变量都不会被序列化。如果只是要不能序列化这个效果，尽量用transient，虽然static可以达到相同的效果，但static不是为这个而设计的。
7、版本问题
反序列化时，必须要有该对象所属类的class文件。
序列化时jvm会记录class文件的版本id（唯一标识此版本的class文件，默认由jvm指定），反序列化时，会根据这个版本id找到对应版本的class文件，用这个class文件来进行反序列化，获得原来的对象。
如果序列化了对象，之后随着项目版本的升级，该class文件可能会升级，class文件的版本id可能会变化（新的class文件的版本id可能会由jvm重新指定）。之后反序列化时，jvm根据原来的版本id找不到对应版本的class文件来进行反序列化，就会报错。
解决方法：显示指定class文件的版本id。显示指定后，此class文件的所有版本都使用此版本id，不再由jvm指定。
1 class user implements serializable/externalizable{
2 //固定写法，值可以是任意的long型值
3 private static final long serialversionuid=512l;
4 //.......
5 }
如对本文有疑问， 点击进行留言回复！！
网友评论