java中Serializable接口作用详解

本文为大家解析java中Serializable接口的作用,具体内容如下

1.(serializable)主要支持对象的回复,所以可以用来保存当前的程序系统状态,远程方法调用RMI(远程机器必须含有必要的.class文件,否则将掷出classNotFound   Exception),但是因为它将对象数据自动全部保存,你根本无法插手,因此对于一些敏感字段(如:password)存在安全问题。但相应有很多解决的方法,例如可以在敏感字段的声明中使用transient关键字,或者去继承externalizable接口,自己来实现readExternal()和writerExternal()方法,再或者继承serializable接口,但提供private   void   writeObject(ObjectOutputStream   s)等方法...   ...但注意static   成员的保存仍需要你的介入。

2.1.网络传输

2.数据库持久

3.把对象保存为文件形式,以便以后还原

Object serialization的定义:

Object serialization 允许你将实现了Serializable接口的对象转换为字节序列,这些字节序列可以被完全存储以备以后重新生成原来的对象。

serialization不但可以在本机做,而且可以经由网络操作(RMI)。这个好处是很大的----因为它自动屏蔽了操作系统的差异,字节顺序(用Unix下的c开发过网络编程的人应该知道这个概念)等。比如,在Window平台生成一个对象并序列化之,然后通过网络传到一台Unix机器上,然后可以在这台Unix机器上正确地重构这个对象。

Object serialization主要用来支持2种主要的特性:
1、Java的RMI(remote method invocation).RMI允许象在本机上一样操作远程机器上的对象。当发送消息给远程对象时,就需要用到serializaiton机制来发送参数和接收返回直。

2、Java的JavaBeans. Bean的状态信息通常是在设计时配置的。Bean的状态信息必须被存起来,以便当程序运行时能恢复这些状态信息。这也需要serializaiton机制。

二、sakulagi和rollingpig说的持久化我也说一下。

我觉得你们说的应该是英文里的persistence.但是Java语言里现在只支持lightweight persistence,就是轻量级持久化,这是通过serialization机制来实现的。

persistence是指一个对象的生命周期不由程序是否执行来决定,即使是在程序终止时这个对象也存在。它把一个serializable的对象写到磁盘(本机或其他机器上的非RAM存储器),并在程序重新调用时再读取对象到通常的RAM存储器。

为什么说Java的serialization机制实现的是lightweight persistence?因为你必须显式的序列化和反序列化程序里的对象;而不是直接由一个关键词来定义一个对象是序列化的然后由系统做相应的处理。

下面是关于序列化的一个实例:

程序名称:SerializationDemo.java
程序主题:实现对象的序列化和反序列化
程序说明:该程序由实例化一个MyClass类的对象开始,该对象有三个实例变量,类型分别为String、int、double,是希望存储和恢复的信息。

代码内容

import java.io.*;

public class SerializationDemo{

public static void main(String args[]){

//Object serialization
try{
MyClass object1=new MyClass("Hello",-7,2.7e10);
System.out.println("object1:"+object1);
FileOutputStream fos=new FileOutputStream("serial");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(object1);
oos.flush();
oos.close();
}
catch(Exception e){
System.out.println("Exception during serialization:"+e);
System.exit(0);
}

//Object deserialization
try{
MyClass object2;
FileInputStream fis=new FileInputStream("serial");
ObjectInputStream ois=new ObjectInputStream(fis);
object2=(MyClass)ois.readObject();
ois.close();
System.out.println("object2:"+object2);
}
catch(Exception e){
System.out.println("Exception during deserialization:"+e);
System.exit(0);
}
}
}

class MyClass implements Serializable{
String s;
int i;
double d;
public MyClass(String s,int i,double d){
this.s=s;
this.i=i;
this.d=d;
}
public String toString(){
return "s="+s+";i="+i+";d="+d;
}
}

程序运行结果:object1和object2的实例变量是一样的,输出如下:[code:1:a55efb5f91]object1:s=Hello;i=-7;d=2.7E10
object2:s=Hello;i=-7;d=2.7E10

一个小例子:

 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable; 

 /**
 * @author Yan Chenyang
 *
 * TODO 要更改此生成的类型注释的模板,请转至
 * 窗口 - 首选项 - Java - 代码样式 - 代码模板
 */
 public class  JFunction implements Serializable{ 

 private double[][] bounds;
 private int vnum;
 private double result;
 private String funcname; 

 public JFunction(){
 super();
 this.bounds=null;
 this.vnum=0;
 this.result=0.0;
 this.funcname=null;
 } 

 public JFunction(double[][] bounds){
 super();
 this.bounds=bounds;
 this.vnum=bounds[0].length;
 this.result=0.0;
 this.funcname="Function 1";
 } 

 public double Func(double[] var){ 

 result=0.0;
 for(int i=0;i<var.length;i++)
 result+=var[i];
 return result;
 } 

 public static JFunction deserialize(ObjectInputStream oin)
 throws Exception{ 

 JFunction f=(JFunction)oin.readObject();
     return f; 

 } 

 public void serialize(ObjectOutputStream oout)
 throws Exception{
 oout.writeObject(this);
 } 

 public String toString(){
 return funcname ; 

 }
 /**
 * @return 返回 funcname。
 */
 public String getFuncname() {
 return funcname;
 }
 /**
 * @param funcname 要设置的 funcname。
 */
 public void setFuncname(String funcname) {
 this.funcname = funcname;
 }
 } 

 public class JFunctionTest0 { 

 public static void main(String[] args){ 

 double[][] bounds={{-2.048,-2.048},{2.048,2.048}};
 JFunction function=new JFunction(bounds); 

 Interpreter interpreter=new Interpreter(); 

 try { 

 double[] x={2.15,1.00};
 interpreter.set("var",x);
 interpreter.source("c:/x.bsh");
 System.out.println(interpreter.get("ret")); 

 } catch (EvalError e) {
 // TODO 自动生成 catch 块
 e.printStackTrace();
 } catch (FileNotFoundException e) {
 // TODO 自动生成 catch 块
 e.printStackTrace();
 } catch (IOException e) {
 // TODO 自动生成 catch 块
 e.printStackTrace();
 } 

 FileInputStream in=null;
     FileOutputStream out=null;
     ObjectInputStream oin=null;
     ObjectOutputStream oout=null; 

     try{
     out = new FileOutputStream("function1.func");
     oout = new ObjectOutputStream(out);
     function.serialize(oout);//序列化
     oout.close();
     oout=null; 

     in = new FileInputStream("function1.func");
     oin = new ObjectInputStream(in);
     JFunction tfunction =JFunction.deserialize(oin);//反序列化 

     double[] var={2.0,5.0}; 

 //    System.out.println(tfunction.Func(var));
 //    System.out.println(tfunction);//打印结果
 //     

     }catch(Exception ex){
     ex.printStackTrace();
     }finally{
     try {
         if (in != null) {
           in.close();
         }
         if (oin != null) {
           oin.close();
         }
         if (out != null) {
           out.close();
         }
         if (oout != null) { 

           oout.close();
         }
       } catch (IOException ex1) {
         ex1.printStackTrace();
       }
     }
 }
 }

序列化 用在 对象编码成字节流及从字节流编码重构对象。   
序列化 为远程通信提供了标准的wire-level协议。

要使类的实例实现序列化,只要在它的声明中加入implements

java.io.Serializable

但是却由一些隐患

1.实现了序列化后,一旦发布,讲削弱改变类实现的灵活性。   
2.增加了bug和安全漏洞的的可能性   
3.当你的新版本发布时增加了相关的测试上的问题。

类应尽可能少的实现Serializable,接口也应该少去扩展它。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • java比较器Comparable接口与Comaprator接口的深入分析

    java的比较器有两类,分别是Comparable接口和Comparator接口.在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口.让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法,在其中定义排序规则,那么就可以直接调用java.util.Arrays.sort()来排序对象数组,实例如下: 复制代码 代码如下: class Student implements Comparable<Student>{    priv

  • Java Serializable和Parcelable详解及实例代码

    对 Serializable和Parcelable理解 1.首先他们两个接口都是为了实现对象的序列化,使之可以传递,所谓序列化就是将对象信息装换成可以存储的介质的过程. 2.Serializable是jdk所提供的序列化接口,该接口存在于io包下,可想用于输入输出,使用非常简单,只要让你的类实现此接口就ok了:可以使用transient关键字修饰你不想序列化的属性. 3.Parcelable是sdk所提供的序列化接口,使用较上者麻烦,实现此接口后,需要重写writeToParcel方法,将需要序

  • java线程之使用Runnable接口创建线程的方法

    实现Runnable接口的类必须使用Thread类的实例才能创建线程.通过Runnable接口创建线程分为两步: 1. 将实现Runnable接口的类实例化. 2. 建立一个Thread对象,并将第一步实例化后的对象作为参数传入Thread类的构造方法. 最后通过Thread类的start方法建立线程. 下面的代码演示了如何使用Runnable接口来创建线程: 复制代码 代码如下: package mythread; public class MyRunnable implements Runn

  • Java调用WebService接口的方法

    本文实例讲述了Java调用WebService接口的方法.分享给大家供大家参考.具体如下: 这里讲述有参方法Add,代码如下: 复制代码 代码如下: public static void addTest() {         try ...{             Integer i = 1;             Integer j = 2;                         //WebService URL             String service_url =

  • Java中实现Comparator接口和用法实例(简明易懂)

    在java中,如果要对集合对象或数组对象进行排序,需要实现Comparator接口以达到我们想要的目标. 接下来我们模拟下在集合对象中对日期属性进行排序 一.实体类Step package com.ljq.entity; /** * 运号单流程 * * @author Administrator * */ public class Step{ /** 处理时间 */ private String acceptTime = ""; /** 快件所在地点 */ private String

  • java后台调用HttpURLConnection类模拟浏览器请求实例(可用于接口调用)

    一般在项目开发中难免遇到外部接口的调用,本文实例讲述了java后台调用HttpURLConnection类模拟浏览器请求的方法.可用于接口调用.分享给大家供大家参考.具体实现方法如下: 复制代码 代码如下: package com.cplatform.movie.back.test; import java.io.BufferedReader; import java.io.DataOutputStream; import java.io.InputStreamReader; import ja

  • Java基础教程之封装与接口

    总结之前的内容,对象(object)指代某一事物,类(class)指代象的类型.对象可以有状态和动作,即数据成员和方法. 到现在为止,数据成员和方法都是同时开放给内部和外部的.在对象内部,我们利用this来调用对象的数据成员和方法.在对象外部,比如当我们在另一个类中调用对象的时,可以使用 对象.数据成员 和 对象.方法() 来调用对象的数据成员和方法. 我们将要封装(encapsulation)对象的成员(成员包括数据成员和方法),从而只允许从外部调用部分的成员.利用封装,我们可以提高对象的易用

  • java自定义注解接口实现方案

    java注解是附加在代码中的一些元信息,用于一些工具在编译.运行时进行解析和使用,起到说明.配置的功能. 注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用.包含在 java.lang.annotation 包中. 1.元注解 元注解是指注解的注解.包括 @Retention @Target @Document @Inherited四种. 1.1.@Retention: 定义注解的保留策略 Java代码 复制代码 代码如下: @Retention(RetentionPolicy.SOURCE

  • Serializable接口的作用_动力节点Java学院整理

    实现java.io.Serializable 接口的类是可序列化的.没有实现此接口的类将不能使它们的任一状态被序列化或逆序列化.序列化类的所有子类本身都是可序列化的.这个序列化接口没有任何方法和域,仅用于标识 序列化的语意.允许非序列化类的子类型序列化,子类型可以假定负责保存和恢复父类型的公有的.保护的和(如果可访问)包的域的状态.只要该类(扩展)有一 个无参构造子,可初始化它的状态,那么子类型就可承担上述职责.在这种情况下申明一个可序列化的类是一个错误.此错误将在运行时被检测.就是可以把对象存

  • java 序列化对象 serializable 读写数据的实例

    序列化对象: 复制代码 代码如下: package com.chen.seriaizable; import java.io.Serializable;import java.util.List; @SuppressWarnings("serial")public class Student implements Serializable{ private String name; private String id; private int age; private List<

随机推荐