oracle存储过程如何传递一个bean对象_对象传输，序列化和反序列化

最新推荐文章于 2023-11-19 14:58:51 发布

weixin_39554891

最新推荐文章于 2023-11-19 14:58:51 发布

阅读量326

点赞数

文章标签： oracle存储过程如何传递一个bean对象

本文链接：https://blog.csdn.net/weixin_39554891/article/details/111584029

版权

本文详细介绍了Java序列化和反序列化的基本概念、数据格式、优点，以及实现序列化和反序列化的过程。重点讨论了序列化接口Serializable的实现，transient关键字的作用，以及序列化在对象存储、网络传输和进程间通信中的应用。同时，提到了序列化过程中的注意事项，如对象状态、静态和transient变量的处理，以及面试中可能遇到的相关问题。

摘要由CSDN通过智能技术生成

一、前言

二、基本概念

2.1 序列化和反序列化的定义及最重要的作用

序列化的定义：Java序列化就是指把Java对象转换为字节序列的过程；

反序列化的定义：Java反序列化就是指把字节序列恢复为Java对象的过程。

序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。Javaweb开发，后端代码中，只要是需要前后端交互网络传输的Java实体类Bean，一般都是实现序列化接口Serializable；Java开发中，只要需要存储到磁盘文件的Java实体类Bean，也是一般都是实现序列化接口Serializable。

反序列化最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。

小结，序列化和反序列化最重要的作用：对象状态的保存和重建（整个过程的核心就是字节流中所保存的对象状态及描述信息）。

2.2 序列化的数据格式，json/xml的数据传递

在数据传输(也可称为网络传输)前，先通过序列化工具类将Java对象序列化为json/xml文件；

在数据传输(也可称为网络传输)后，再将json/xml文件反序列化为对应语言的对象。

2.3 序列化优点

①磁盘存储，JVM停机，永久保存对象到磁盘上，而且由于压缩算法，可以减少存放空间：将对象转为字节流存储到硬盘上，当JVM停机的话，字节流还会在硬盘上默默等待，等待下一次JVM的启动，把序列化的对象，通过反序列化为原来的对象，并且序列化的二进制序列能够减少存储空间（永久性保存对象，序列化包括压缩过程）。

②网络传送，将Java对象变为与语言无关的二进制字节流方便网络传送，且接收端跨语言：序列化成字节流形式的对象可以进行网络传输(二进制形式)，方便了网络传输。

③进程间传递：通过序列化可以在进程间传递对象。

2.4 序列化算法需要做的事

① 第一步，将对象实例相关的类元数据输出。

② 第二步，递归地输出类的超类描述直到不再有超类，从最顶端的超类开始，从上至下递归输出对象实例的实际数据值。

2.5 金手指

1、从序列化的定义开始

序列化的定义：Java序列化就是指把Java对象转换为字节序列的过程；
反序列化的定义：Java反序列化就是指把字节序列恢复为Java对象的过程。

Javaweb开发，后端代码中，只要是需要前后端交互网络传输的Java实体类Bean，一般都是实现序列化接口Serializable；Java开发中，只要需要存储到磁盘文件的Java实体类Bean，也是一般都是实现序列化接口Serializable。

实现序列化接口Serializable表示该类可以被序列化，具体序列化的方式有很多，最常见的是JavaIO。

2、序列化的数据格式：json/xml，但是一般是json，因为json更加高效，xml更加稳定，所以用作配置文件，但是现在都是用注解。

3、序列化的优点

①磁盘存储，JVM停机，永久保存对象到磁盘上，而且由于压缩算法，可以减少存放空间；
②网络传送，将Java对象变为与语言无关的二进制字节流方便网络传送，且接收端跨语言；
③进程间传递。

4、序列化算法需要完成的事情

① 第一步，将对象实例相关的类元数据输出。
② 第二步，递归地输出类的超类描述直到不再有超类，从最顶端的超类开始，从上至下递归输出对象实例的实际数据值。

三、Java实现序列化和反序列化的过程

3.1 实现序列化的必备要求

只有实现了Serializable或者Externalizable接口的类的对象才能被序列化为字节序列（不是则会抛出异常）。

3.2 JDK中序列化和反序列化的API

①java.io.ObjectInputStream：对象输入流。

该类的readObject()方法从输入流中读取字节序列，然后将字节序列反序列化为一个对象并返回。

②java.io.ObjectOutputStream：对象输出流。

该类的writeObject(Object obj)方法将将传入的obj对象进行序列化，把得到的字节序列写入到目标输出流中进行输出。

3.3 JDK实现序列化和反序列化的三种实现

①若Student类仅仅实现了Serializable接口，则可以按照以下方式进行序列化和反序列化。

ObjectOutputStream采用writeObject(Object obj)序列化方式，对Student对象的非transient的实例变量进行序列化；ObjcetInputStream采用readObject(Object obj)反序列化方式，对Student对象的非transient的实例变量进行反序列化。

②若Student类实现了Serializable接口，并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，则采用以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeObject(ObjectOutputStream out)的方法进行序列化； ObjectInputStream会调用Student对象的readObject(ObjectInputStream in)的方法进行反序列化。

③若Student类实现了Externalnalizable接口，且Student类必须实现 readExternal(ObjectInput in) 和 writeExternal(ObjectOutput out) 方法，则按照以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeExternal(ObjectOutput out))的方法进行序列化；ObjectInputStream会调用Student对象的readExternal(ObjectInput in)的方法进行反序列化。

3.4 序列化和反序列化代码示例

public class SerializableTest {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            //序列化
            FileOutputStream fos = new FileOutputStream("object.out");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            Student student1 = new Student("lihao", "wjwlh", "21");
            oos.writeObject(student1);    // 写到磁盘上要序列化
            oos.flush();
            oos.close();
            //反序列化
            FileInputStream fis = new FileInputStream("object.out");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Student student2 = (Student) ois.readObject();   //读到程序里面要反序列化
            System.out.println(student2.getUserName()+ " " +
            student2.getPassword() + " " + student2.getYear());
    } 
}
public class Student implements Serializable{                             
                                                                          
    private static final long serialVersionUID = -6060343040263809614L;   
                                                                          
    private String userName;                                              
    private String password;                                              
    private String year;                                                  
                                                                          
    public String getUserName() {                                         
        return userName;                                                  
    }                                                                     
                                                                          
    public String getPassword() {                                         
        return password;                                                  
    }                                                                     
                                                                          
    public void setUserName(String userName) {                            
        this.userName = userName;                                         
    }                                                                     
                                                                          
    public void setPassword(String password) {                            
        this.password = password;                                         
    }                                                                     
                                                                          
    public String getYear() {                                             
        return year;                                                      
    }                                                                     
                                                                          
    public void setYear(String year) {                                    
        this.year = year;                                                 
    }                                                                     
                                                                          
    public Student(String userName, String password, String year) {       
        this.userName = userName;                                         
        this.password = password;                                         
        this.year = year;                                                 
    }                                                                     
}

四、序列化和反序列化的注意点

①对象状态：序列化时，只对对象的状态进行保存，而不管对象的方法；

②父类子类：当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；

③引用对象：当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；

④private域和socket thread类：并非所有的对象都可以序列化，至于为什么不可以，有很多原因了，比如：

安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行RMI传输等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的；

资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现；

⑤static和transient：声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态，transient代表对象的临时数据（序列化的仅仅是对象的状态，没有对象的方法，也没有类的状态）。

⑥显式serialVersionUID用于完成序列化和反序列化，还有不同版本的兼容：序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。为它赋予明确的值。显式地定义serialVersionUID有两种用途：

在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；

在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

⑦Java有很多基础类已经实现了serializable接口，比如String,Vector等。但是也有一些没有实现serializable接口的；

⑧可以使用序列化深拷贝：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存，这是能用序列化解决深拷贝的重要原因（注意：浅拷贝请使用Clone接口的原型模式）。

五、transient关键字

5.1 第一，toolFunction1()：transient修饰的变量是序列化到txt文件中之后无法被反序列化并打印出来，静态变量是根本无法序列化到txt文件之中

class Resume implements Cloneable, Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private static String sex;
    transient private String age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public void dispaly() {
        System.out.println("姓名：" + name + "t年龄：" + age + "t性别：" + sex);
    }

    public Object clone() {
        try {
            Resume resume = (Resume) super.clone();
            return resume;
        } catch (Exception e) {
            return null;
        }

    }

}


public class MainTest {

    public static void toolFunction1() {

        try {
            //序列化Resume
            Resume resume = new Resume();
            resume.setName("哈哈");
            resume.setSex("男");
            resume.setAge("20");
            resume.dispaly();
            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("resume.txt"));
            outputStream.writeObject(resume);
            outputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void toolFunction2() {
        try {
            //反序列化Resume
            Resume resume = new Resume();
            //改变sex（根据结果可见sex未被序列化，而是直接从内存中读取）
            resume.setSex("女");
            //反序列化
            ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("resume.txt"));
            Resume resume1 = (Resume) inputStream.readObject();
            resume1.dispaly();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
       toolFunction1();
    }
}

5.2 第二，toolFunction2()：局部变量是不能被transient关键字修饰的

class Resume implements Cloneable, Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private static String sex;   // static  String  
    transient private String age;   // transient  String


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String toString() {
        return "name：" + name + "age：" + age + "sex：" + sex;
    }

    public Object clone() {   // clone 
        try {
            Resume resume = (Resume) super.clone();
            return resume;
        } catch (Exception e) {
            return null;
        }

    }

}


public class MainTest2 {

    public static void toolFunction1() {
        try {
            //序列化Resume
            Resume resume = new Resume();
            resume.setName("haha"); 
            resume.setSex("male");  // static String
            resume.setAge("20");   // transient String 

            System.out.println(resume);  // 打印

            File target = new File("stream2.txt");// 程序可以自动创建txt文件
            OutputStream outputStream = new FileOutputStream(target); // 四大基流不能直接实例化对象，实例化对象还要具体IO类，这里是FileOutputStream
            outputStream.write(resume.toString().getBytes(), 0, resume.toString().length());
            outputStream.close();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void toolFunction2() {
        try {
            //序列化Resume
            Resume resume = new Resume();

            //改变sex（根据结果可见sex未被序列化，而是直接从内存中读取）如果不在这里设置,sex打印出来为null
            resume.setSex("female");

            File file = new File("stream2.txt");
            InputStream inputStream = new FileInputStream(file);

            byte[] buffer = new byte[1024];
            int len = -1;
            while ((len = inputStream.read(buffer)) != -1) {
                String string = new String(buffer, 0, len); // 每次读入一个缓冲大小然后输出
                System.out.println(string);
            }
            inputStream.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        toolFunction1();

    }
}

六、面试金手指

6.1 序列化定义 + 序列化数据格式 + 序列化三个用途 + 序列化步骤

1、序列化定义

序列化的定义：Java序列化就是指把Java对象转换为字节序列的过程；
反序列化的定义：Java反序列化就是指把字节序列恢复为Java对象的过程。

实现序列化接口Serializable表示该类可以被序列化，具体序列化的方式有很多，最常见的是JavaIO。

2、序列化数据格式：json/xml，但是一般是json，因为json更加高效，xml更加稳定，所以用作配置文件，但是现在都是用注解。

3、序列化三个用途

4、序列化步骤

6.2 序列化对象条件 + 序列化实现的三种方式

1、序列化对象条件（Serializable Externalizable接口）

只有实现了Serializable或者Externalizable接口的类的对象才能被序列化为字节序列（不是则会抛出异常）。

2、序列化实现的三种方式

①若Student类仅仅实现了Serializable接口，则可以按照以下方式进行序列化和反序列化。

②若Student类实现了Serializable接口，并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，则采用以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeObject(ObjectOutputStream out)的方法进行序列化；ObjectInputStream会调用Student对象的readObject(ObjectInputStream in)的方法进行反序列化。

③若Student类实现了Externalnalizable接口，且Student类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，则按照以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeExternal(ObjectOutput out))的方法进行序列化；ObjectInputStream会调用Student对象的readExternal(ObjectInput in)的方法进行反序列化。

6.3 继承组合 + private/socket/static/transient + 序列化id + 集合框架和深拷贝

6.3.1 第一，两种序列化传递（继承传递和组合传递）

1、父类子类：当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；

2、引用对象：当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；

6.3.2 第二，序列化时，只对对象的变量进行保存，而不管对象的方法

1、private域和socket thread类

（1）安全方面的原因，如果一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行RMI传输等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的；

（2）资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现；

2、static和transient

声明为static和transient类型的成员数据不能被序列化。

static代表类的状态，transient代表对象的临时数据（序列化的仅仅是对象的状态，没有对象的方法，也没有类的状态）。

附加：对于transient，使用writeObject readObject解决

注意1，这里是反射调用， transient修饰的属性不让默认的序列化来传输，需要先完成一些业务逻辑，然后再序列化传输，只是不用默认的方式。比如hashMap中就有很多这样的transient修饰的属性，不让默认的序列化来传输，需要先完成一些业务逻辑，然后再序列化传输。

注意2，这里的writeObject readObject对transient修饰的属性序列化仅对Java IO序列化有用，对其他序列化方式，XML序列化、Hessian序列化是无用的。

6.3.3 第三，序列化id

（1）序列化id为唯一性标志：序列化id是对象的唯一标志，当需要网络传输或读写磁盘的时候，判断对象是不是同一个。

（2）序列化id是默认缺省的：序列化id和构造函数一样，没有显示定义就用系统自动生成的（根据Bean类中属性自动生成），已经显示定义就用显示定义的。

（3）一个使用自动生成，一个使用显示定义，出现错误：序列化id无论有没有显示定义都没问题，但是如果写磁盘-读磁盘中一个使用自动生成，一个使用显示定义，就会出现InValidClassException local Classincompatible；同样，发送端-接收端中一个使用自动生成，一个使用显示定义，也会出现InValidClassException local Class incompatible。

6.3.4 第四，集合框架和深拷贝

（1）集合框架：Java有很多基础类已经实现了serializable接口，比如String,Vector等。但是也有一些没有实现serializable接口的；

（2）基于序列化实现深拷贝：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存！这是能用序列化解决深拷贝的重要原因；（注意：浅拷贝请使用Clone接口的原型模式。）

6.4 transient关键字

transient关键字，面试回答这三点就好

1、一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2、一个静态变量不管是否被transient修饰，均不能被序列化。第一点和第二点区别：transient修饰的变量是序列化到txt文件中之后无法被反序列化并打印出来，静态变量是根本无法序列化到txt文件之中。

3、transient关键字只能修饰变量，而不能修饰方法和类。即使是变量，transient关键字也不能修饰局部变量，只能修改类变量，而且该类需要实现Serializable接口。

6.5 transient关键字

1、Arraylist和hashmap中都一个使用变量modCount，这个变量是用来记录修改次数的，

2、modCount不正确就是抛出java.lang.ConcurrentModificationException异常，能够抛出这个异常的的是fast-fail迭代器，因为arrayList和hashmap使用的iterator是fast-fail迭代器，hashtable使用的enumrator不是fast-fail迭代器;

3、modCount变量使用transient关键字修饰，表示它不需要被序列化。