再谈Java序列化

最新推荐文章于 2020-02-07 15:56:35 发布
最新推荐文章于 2020-02-07 15:56:35 发布
阅读量667 收藏
点赞数
分类专栏： Java 文章标签： java string exception class file import
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eclipser1987/article/details/7276160
版权 
package cn.vicky.chapt01;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 *
 * @author Vicky.H
 */
public class Person implements java.io.Serializable {

    public Person(String fn, String ln, int a) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public Person getSpouse() {
        return spouse;
    }

    public void setFirstName(String value) {
        firstName = value;
    }

    public void setLastName(String value) {
        lastName = value;
    }

    public void setAge(int value) {
        age = value;
    }

    public void setSpouse(Person value) {
        spouse = value;
    }

    public static int getIndex() {
        return index;
    }

    public static void setIndex(int index) {
        Person.index = index;
    }

    public int getIndex2() {
        return index2;
    }

    public void setIndex2(int index2) {
        this.index2 = index2;
    }
    
    

    @Override
    public String toString() {
        return "[Person: firstName=" + firstName
                + " lastName=" + lastName
                + " age=" + age
                + " spouse=" + spouse.getFirstName()
                + "]";
    }
    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
    
    private static int index = 0;
    private transient int index2 = 10;

    public static void main(String args[]) {
//        try {
//            Person ted = new Person("Ted", "Neward", 39);
//            Person charl = new Person("Charlotte", "Neward", 38);
//            
//            ted.setSpouse(charl);
//            charl.setSpouse(ted);
//            
//            ted.setIndex(99);
//            ted.setIndex2(9999);
//
//            FileOutputStream fos = new FileOutputStream("tempdata.ser");
//            ObjectOutputStream oos = new ObjectOutputStream(fos);
//            oos.writeObject(ted);
//            oos.close();
//        } catch (Exception ex) {
//            System.err.println("Exception thrown during test: " + ex.toString());
//        }
        
        
        
        try {
            FileInputStream fis = new FileInputStream("tempdata.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person ted = (Person) ois.readObject();
            ois.close();

            System.out.println(ted.getFirstName()); // "Ted"
            System.out.println(ted.getSpouse().getFirstName()); // "Charlotte"
            System.out.println("Person.getIndex() = " + Person.getIndex());
            System.out.println("ted.getIndex() = " + ted.getIndex());
            System.out.println("ted.getIndex2() = " + ted.getIndex2());
            
            // Clean up the file
            new File("tempdata.ser").delete();
        } catch (Exception ex) {
            System.err.println("Exception thrown during test: " + ex.toString());
        }

    }
}


 

 

package cn.vicky.chapt02;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 *
 * @author Vicky.H
 */
enum Gender{
    MALE, FEMALE
}

public class Person implements java.io.Serializable {

    public Person(String fn, String ln, int a,Gender g) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
        this.gender = g;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public Person getSpouse() {
        return spouse;
    }

    public void setFirstName(String value) {
        firstName = value;
    }

    public void setLastName(String value) {
        lastName = value;
    }

    public void setAge(int value) {
        age = value;
    }

    public void setSpouse(Person value) {
        spouse = value;
    }

    public static int getIndex() {
        return index;
    }

    public static void setIndex(int index) {
        Person.index = index;
    }

    public int getIndex2() {
        return index2;
    }

    public void setIndex2(int index2) {
        this.index2 = index2;
    }

    public Gender getGender() {
        return gender;
    }

    public void setGender(Gender gender) {
        this.gender = gender;
    }
    
    @Override
    public String toString() {
        return "[Person: firstName=" + firstName
                + " lastName=" + lastName
                + " age=" + age
                + " spouse=" + spouse.getFirstName()
                + "]";
    }
    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
    
    private static int index = 0;
    private transient int index2 = 10;
    
    private Gender gender;

    public static void main(String args[]) {
//        try {
//            Person ted = new Person("Ted", "Neward", 39 ,Gender.FEMALE);
//            Person charl = new Person("Charlotte", "Neward", 38, Gender.MALE);
//            
//            ted.setSpouse(charl);
//            charl.setSpouse(ted);
//            
//            ted.setIndex(99);
//            ted.setIndex2(9999);
//
//            FileOutputStream fos = new FileOutputStream("tempdata.ser");
//            ObjectOutputStream oos = new ObjectOutputStream(fos);
//            oos.writeObject(ted);
//            oos.close();
//        } catch (Exception ex) {
//            System.err.println("Exception thrown during test: " + ex.toString());
//        }
        
        
        
        try {
            FileInputStream fis = new FileInputStream("tempdata.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person ted = (Person) ois.readObject();
            ois.close();

            System.out.println(ted.getFirstName()); // "Ted"
            System.out.println(ted.getSpouse().getFirstName()); // "Charlotte"
            System.out.println("Person.getIndex() = " + Person.getIndex());
            System.out.println("ted.getIndex() = " + ted.getIndex());
            System.out.println("ted.getIndex2() = " + ted.getIndex2());
            
            System.out.println("ted.getGender() = " + ted.getGender());
            System.out.println("ted.getSpouse().getGender() = " + ted.getSpouse().getGender());
            
            // Clean up the file
            new File("tempdata.ser").delete();
        } catch (Exception ex) {
            System.err.println("Exception thrown during test: " + ex.toString());
        }

    }
}


 

 

package cn.vicky.chapt03;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 *
 * @author Vicky.H
 */
enum Gender{
    MALE, FEMALE
}

public class Person implements java.io.Serializable {

    public Person() {}
    
    public Person(String fn, String ln, int a,Gender g) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
        this.gender = g;
    }

    private void writeObject(java.io.ObjectOutputStream stream) throws java.io.IOException    {
        // "Encrypt"/obscure the sensitive data
        age = age << 2;
        stream.defaultWriteObject();
     /*
     * 上一个技巧假设您想模糊化序列化数据，而不是对其加密或者确保它不被修改。当然，通过使用 writeObject 和 readObject 可以实现密码加密和签名管理，但其实还有更好的方式。
     * 如果需要对整个对象进行加密和签名，最简单的是将它放在一个 javax.crypto.SealedObject 和/或 java.security.SignedObject 包装器中。两者都是可序列化的，所以将对象
     * 包装在 SealedObject 中可以围绕原对象创建一种 “包装盒”。必须有对称密钥才能解密，而且密钥必须单独管理。同样，也可以将 SignedObject 用于数据验证，并且对称密钥也必须单独管理。
     * 结合使用这两种对象，便可以轻松地对序列化数据进行密封和签名，而不必强调关于数字签名验证或加密的细节。很简洁，是吧？
     */
    }

    private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException {
        stream.defaultReadObject();
        // "Decrypt"/de-obscure the sensitive data
        age = age >> 2;
    }

    
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public Person getSpouse() {
        return spouse;
    }

    public void setFirstName(String value) {
        firstName = value;
    }

    public void setLastName(String value) {
        lastName = value;
    }

    public void setAge(int value) {
        age = value;
    }

    public void setSpouse(Person value) {
        spouse = value;
    }

    public static int getIndex() {
        return index;
    }

    public static void setIndex(int index) {
        Person.index = index;
    }

    public int getIndex2() {
        return index2;
    }

    public void setIndex2(int index2) {
        this.index2 = index2;
    }

    public Gender getGender() {
        return gender;
    }

    public void setGender(Gender gender) {
        this.gender = gender;
    }
    
    @Override
    public String toString() {
        return "[Person: firstName=" + firstName
                + " lastName=" + lastName
                + " age=" + age
                + " spouse=" + spouse.getFirstName()
                + "]";
    }
    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
    
    private static int index = 0;
    private transient int index2 = 10;
    
    private Gender gender;

    public static void main(String args[]) {
        try {
            Person ted = new Person("Ted", "Neward", 39 ,Gender.FEMALE);
            Person charl = new Person("Charlotte", "Neward", 38, Gender.MALE);
            
            ted.setSpouse(charl);
            charl.setSpouse(ted);
            
            ted.setIndex(99);
            ted.setIndex2(9999);

            FileOutputStream fos = new FileOutputStream("C://tempdata.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(ted);
            oos.close();
        } catch (Exception ex) {
            System.err.println("Exception thrown during test: " + ex.toString());
            ex.printStackTrace();
        }
        
        
        
        try {
            FileInputStream fis = new FileInputStream("C://tempdata.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person ted = (Person) ois.readObject();
            ois.close();

            System.out.println(ted.getFirstName()); // "Ted"
            System.out.println(ted.getSpouse().getFirstName()); // "Charlotte"
            System.out.println(ted.getAge());
            System.out.println(ted.getSpouse().getAge());
            
            // Clean up the file
            new File("C://tempdata.ser").delete();
        } catch (Exception ex) {
            System.err.println("Exception thrown during test: " + ex.toString());
            ex.printStackTrace();
        }

    }

}


 

package cn.vicky.chapt04;

/**
 *
 * @author Vicky.H
 */
public class Person implements java.io.Serializable {

    public Person(String fn, String ln, int a) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public Person getSpouse() {
        return spouse;
    }

    private Object writeReplace() throws java.io.ObjectStreamException {
        return new PersonProxy(this);
    }

    public void setFirstName(String value) {
        firstName = value;
    }

    public void setLastName(String value) {
        lastName = value;
    }

    public void setAge(int value) {
        age = value;
    }

    public void setSpouse(Person value) {
        spouse = value;
    }

    @Override
    public String toString() {
        return "[Person: firstName=" + firstName
                + " lastName=" + lastName
                + " age=" + age
                + " spouse=" + spouse.getFirstName()
                + "]";
    }
    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
}

class PersonProxy implements java.io.Serializable {

    public PersonProxy(Person orig) {
        data = orig.getFirstName() + "," + orig.getLastName() + "," + orig.getAge();
        if (orig.getSpouse() != null) {
            Person spouse = orig.getSpouse();
            data = data + "," + spouse.getFirstName() + "," + spouse.getLastName() + "," + spouse.getAge();
        }
    }
    public String data;

    private Object readResolve() throws java.io.ObjectStreamException {
        String[] pieces = data.split(",");
        Person result = new Person(pieces[0], pieces[1], Integer.parseInt(pieces[2]));
        if (pieces.length > 3) {
            result.setSpouse(new Person(pieces[3], pieces[4], Integer.parseInt(pieces[5])));
            result.getSpouse().setSpouse(result);
        }
        return result;
    }
}


 

eclipser1987
关注
专栏目录
java 判断序列化,浅谈Java序列化
weixin_42353715的博客
03-11 560
Java序列化什么是序列化？序列化是将一个对象的状态，各属性的值序列化保存起来，然后在合适的时候通过反序列化获得。Java的序列化是将一个对象表示成字节序列，该字节序列包括了对象的数据，有关对象的类型信息和存储在对象中的数据类型。说白了，就是将对象保存起来，就跟保存字符串数据一样，用到的时候再取出来。任何实现了Serializable接口的类都可以被序列化。实现Serializable接口进行序列...
Java 序列化
jeikerxiao
05-15 236
前言 对于Java的序列化，一直只知道只需要实现Serializbale这个接口就可以了。停留在了表面，在项目中使用Dubbo时，发现对象需要实现Serializbale，涉及到了序列化问题。就补了一下Java序列化的底层实现。 1.What Java序列化 是指把Java对象保存为二进制字节码的过程； Java反序列化 是指把二进制字节码重新转换成Java对象的过程。 那么为...
java代码将word、excel文档转换成pdf
HDXxiazai的博客
11-18 712
新建javaweb工程 下载aspouse-word-14.11.0-jdk16.jar包和aspose-cells-8.5.2.jar包并引入 word转pdf的java函数 package webViewer; import java.io.*; import com.aspose.words.*; //引入aspouse-word-14.11...
word转换为pdf的好方法
曳尾涂中的专栏
09-26 633
1.准备jar包：aspouse-word-14.11.0-jdk16.jar   2.代码示例: package com.utils;   import java.io.File; import java.io.FileOutputStream; import com.aspose.words.Document; import com.aspose.words.SaveForma...
java序列化
qq_39930584的博客
02-07 309
1、前言 我们应该思考下面几个问题： 序列化和反序列化到底是什么？ 它的主要使用场景有哪些？ Java 序列化常见的方案有哪些？ 各种常见序列化方案的区别有哪些？ 实际的业务开发中有哪些坑点？ 接下来将从这几个角度去研究这个问题。 2. 序列化和反序列化是什么？为什么需要它？ 序列化是将内存中的对象信息转化成可以存储或者传输的数据到临时或永久存储的过程。而反序列化正好相反，是从...
浅谈Java序列化和hessian序列化的差异
08-29
Java序列化和Hessian序列化的差异 Java序列化和Hessian序列化是两种常用的序列化机制，它们都可以将对象转换为字节流，以便在网络上传输。但是，两者之间有着很大的差异，今天我们就来比较一下它们的实现机制和特点...
浅谈java中为什么实体类需要实现序列化
08-30
浅谈java中为什么实体类需要实现序列化 在Java中，实体类需要实现序列化是因为序列化是将对象转换为字节流的过程，而反序列化是将字节流转换回对象的过程。在Java中，实现序列化的类需要实现java.io.Serializable...
136-浅谈Java原生反序列化漏洞.pdf
最新发布
03-15
136-浅谈Java原生反序列化漏洞
Java简单实现固定长度队列（FIFO）
热门推荐
噬日者
08-28 28万+
/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package linkedlisttest; import java.util.LinkedList; /** * * @author Vicky.H * @email eclipser
java.security.MessageDigest的使用(1)!
噬日者
01-08 3万+
    我们知道,编程中数据的传输,保存,为了考虑安全性的问题,需要将数据进行加密.我们拿数据库做例子.如果一个用户注册系统的数据库,没有对用户的信息进行保存,如,我去页面注册,输入"Vicky","123456".注册.web服务器未对数据进行加密而直接写入数据库,那么数据库中的用户信息,便是一个直接可用的数据!一旦服务器服务器被黑~那么用户的信息将毫无保留的展现在黑客面前...为了解决这个弊端
Object,byte[],ByteBuffer之间的转换。
噬日者
03-05 1万+
新版本 package cn.vicky.chapt13; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInputStrea
java.security.MessageDigest的使用(2),生成安全令牌!
噬日者
01-08 1万+
     时候,我们需要产生一个数据,这个数据保存了用户的信息,但加密后仍然有可能被人使用,即便他人不确切的了解详细信息...好比,我们在上网的时候,很多网页都会有一个信息,是否保存登录信息,以便下次可以直接登录而不必再次输入账户,密码等...而通常这样需要Cookie保存用户信息,当然,这个信息是加密信息,且一般都加了时间戳等验证信息的...    登陆时,读取cookie,解析cook
c3p0的使用实例！
噬日者
01-12 1万+
      我们在使用数据库连接时候，很多时候会考虑使用数据库连接池，因为数据库连接池的机制，使得在大用户数量上进行交互的时候使得其效率比较有优势！public class DBPool { private static DBPool dbPool; private ComboPooledDataSource dataSource; static { dbPool = n
打包含有多个main程序的jar包运行方式
噬日者
03-14 1万+
一个项目中，往往主程序不只一个。打包jar时，一般需要指定主程序。拿maven来说，配置主程序的方式如下：   pox.xml中 org.apache.maven.plugins maven-shade-plugin
google protocol buffer 与 redis 结合使用
噬日者
01-23 1万+
google protocol buffer 可以将对象序列化,而redis作为优秀的NOSQL数据库,这里我将以实例方式介绍,将C++对象序列化,并存放在redis数据库中!   google protocol buffer 的安装以及基础使用可以阅读我上一片文章. redis的安装使用,可以查阅,这里不再描述.我使用redis的官方C client: hiredis.   proto
Java Timer的使用，守护线程。
噬日者
05-10 9221
package cn.vicky;import java.util.Timer;/** * Timer : 提供对计时器 MBean 的实现。 计时器 MBean 将在指定的时间发出警告，以唤醒所有注册的侦听器来接收计时器通知。 此类管理一个过期的计时器通知列表。 * 这是一种允许用户根据需要任意添加/移除通知的方法。 当计时器发出计时器通知并过时后，会将该通知自动从计时器
Java对象以Blob存储，及序列化反序列化 (1)
噬日者
02-14 6281
序列化，反序列化的概念此处不叙述，我们这里选要讨论的是，如何使用JPA规范实现JAVA对象以Blob个数存储数据库并且，在修改JAVA类的属性后，任然能从数据库中反序列化对象，这也是使用JAVA作为游戏服务器常用的数据存储方式以及要面对的问题。   这里我们将完全以实例放方式讲述： 首先，我们需要一个t_user的表，id 以及blob类型的user数据。   MySQL的四种BLOB类
ThreadLocal的实现原理,及使用实例,解决spring,hibernate非web项目下的懒加载 no session or session was closed(1)!
噬日者
01-29 4967
JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的局部变量独立问题...   查看API我们可以查看ThreadLocal的定义与方法:   该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始
序列化深度解析：从勇气篇到实战应用
1. 浅谈序列化：阐述了序列化的普遍性，强调序列化不是对象本身，而是对象的状态。通过实例说明，每次从Class文件创建的对象虽然看似相同，但实际操作后属性可能已变，序列化可以帮助保存这些变化的状态。 2. 内置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值