精华内容
下载资源
问答
  • public class RedisUtil { /** * 将obj对象保存到redis * @param key * @param obj */ public static void save(String key,Object obj){ Jedis jedis = new Jedis("localhost",6379); //...
    public class RedisUtil {
    

    /**
    * 将obj对象保存到redis
    * @param key
    * @param obj
    */
    public static void save(String key,Object obj){
    Jedis jedis = new Jedis("localhost",6379);
    //保存
    byte[] value = objectToBytes(obj);//序列化
    byte[] keys = key.getBytes();
    jedis.set(keys, value);
    jedis.close();
    }

    /**
    * 根据key从redis获取对象信息
    * @param key
    * @return
    */
    public static Object load(String key){
    Jedis jedis = new Jedis("localhost",6379);
    byte[] keys = key.getBytes();
    byte[] value = jedis.get(keys);//获取序列化内容
    //反序列化,将字节数组转成Object对象
    Object obj = bytesToObject(value);
    jedis.close();
    return obj;
    }

                    //反序列化:将字节数组转成java对象

    private static Object bytesToObject(byte[] value){
    ByteArrayInputStream bytesIn = null;
    ObjectInputStream in = null;
    try{
    bytesIn = new ByteArrayInputStream(value);
    in = new ObjectInputStream(bytesIn);
    Object obj = in.readObject();
    return obj;
    }catch(Exception ex){
    ex.printStackTrace();
    return null;
    }finally{
    try {
    bytesIn.close();
    in.close();
    } catch (IOException e) {
    e.printStackTrace();
    }

    }
    }
    //序列化,将Java对象转换成字节数组
    private static byte[] objectToBytes(Object obj){
    ByteArrayOutputStream bytesOut = null;
    ObjectOutputStream out = null;
    try{
    bytesOut = new ByteArrayOutputStream(); 
    out = new ObjectOutputStream(bytesOut);
    out.writeObject(obj);//序列化,将obj写入ByteArray数组流中
    byte[] bytes = bytesOut.toByteArray();
    return bytes;
    }catch(Exception ex){
    ex.printStackTrace();
    return null;
    }finally{
    try {
    bytesOut.close();
    out.close();
    } catch (IOException e) {
    e.printStackTrace();
    }

    }
    }
    展开全文
  • 什么是序列化以特定的方式对类实例的瞬时状态进行编码保存的一种操作,叫做对象序列化。就是将对象的这个时刻的各种属性各种值按照一定的规则变成二进制流,然后如果传输到别的jvm中,jvm可以按照规则在将二进制流反...

    什么是序列化

    以特定的方式对类实例的瞬时状态进行编码保存的一种操作,叫做对象序列化。就是将对象的这个时刻的各种属性各种值按照一定的规则变成二进制流,然后如果传输到别的jvm中,jvm可以按照规则在将二进制流反序列化成对应的对象,并且对象里面还有当时的数据和各种属性。
     

    序列化的作用

    主要作用就是将序列化后的对象进行网络传输,由此可以实现对象调用,分布式对象,等各种功能。
     

    序列化的指标

    1、对象序列化后的大小
    一个对象会被序列化工具序列化为一串byte数组,这其中包含了对象的field值以及元数据信息,使其可以被反序列化回一个对象
    2、序列化与反序列化的速度
    一个对象被序列化成byte数组的时间取决于它生成/解析byte数组的方法
    3、序列化工具本身的速度
    序列化工具本身创建会有一定的消耗。
     

    各种序列化的对比

    java序列化

    原理:类需要实现 Serializable接口,才能被jdk自己的序列化机制序列化,jdk序列化的时候,会将这个类和他的所有超类都元数据,类描述,属性,属性值等等信息都序列化出来,这样就导致序列化后的大小比较大,速度也会比较慢,但是包含的内容最全面。可以完全反序列化。
     

     

     

    Kryo序列化

    原理:序列化的时候,会将对象的信息,对象属性值的信息等进行序列化,而且没有将类field的描述信息进行序列化,这样就比jdk自己的序列化出来的小多了,而且速度肯定更快,但是包含的信息没有jdk的全面。类似下图

     

    Hessian序列化

    原理:序列化的时候,也是将对象的信息,属性值信息等进行序列化,也会比jdk自己的序列化后的小很多,但是没有kryo的小,速度也挺快,类似下图。

     

     

    这两种的对比

    1、Kryo序列化后比Hessian小很多。(kryo优于hessian)
    2、由于Kryo没有将类field的描述信息序列化,所以Kryo需要以自己加载该类的filed。这意味着如果该类没有在kryo中注册,或者该类是第一次被kryo序列化时,kryo需要时间去加载该类(hessian优于kryo)
    3、由于2的原因,如果该类已经被kryo加载过,那么kryo保存了其类的信息,就可以很快的将byte数组填入到类的field中,而hessian则需要解析序列化后的byte数组中的field信息,对于序列化过的类,kryo优于hessian。
    4、hessian使用了固定长度存储int和long,而kryo则使用的变长,实际中,很大的数据不会经常出现。(kryo优于hessian)
    5、hessian将序列化的字段长度写入来确定一段field的结束,而kryo对于String将其最后一位byte+x70用于标识结束(kryo优于hessian)
     
     
     

    总结:

    对象的序列化,其实就是将一个对象,按照一定的规则转换成字节数组,并且可以按照规则在转换回来,序列化后的大小越小,速度一般越快,当然也要看算法和处理速度等,但是不一定适合各种场景,jdk的序列化虽然效率可能低,但是几乎完全保证了反序列化后的结果的准确性。序列化框架有很多,遇到了可以查一下大概的原理和序列话的内容,比较看是否适合自己。网上也有各种评测序列话框架之间的性能比较。
     

    另记:

    在学习dubbo的时候看到,dubbo默认的序列化方式是 hessian2序列化( hessian是一种跨语言的高效二进制序列化方式。但这里实际不是原生的hessian2序列化,而是阿里修改过的hessian lite,它是dubbo RPC默认启用的序列化方式),而再看dubbox的时候看到dubbox 引入Kryo和FST这两种高效Java序列化实现,来逐步取代hessian2。( 其中,Kryo是一种非常成熟的序列化实现,已经在Twitter、Groupon、Yahoo以及多个著名开源项目(如Hive、Storm)中广泛的使用。而FST是一种较新的序列化实现,目前还缺乏足够多的成熟使用案例,但它还是非常有前途的。 在面向生产环境的应用中,我建议目前更优先选择Kryo。)下图简单说明了各种序列化框架序列化同一个对象后的字节大小比较

     

    转自:https://www.cnblogs.com/liouwei4083/p/6123383.html

    展开全文
  • 摘要:Java将对象序列化成为JSON格式、JSON格式反序列化为Java对象。 一:引入jackson的依赖: <dependency> <groupId>org.codehaus.jackson</groupId> <...

    摘要:Java将对象序列化成为JSON格式、JSON格式反序列化为Java对象。

    一:引入jackson的依赖:

    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.12</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-core-asl</artifactId>
      <version>1.9.12</version>
    </dependency>

    二:编写实体对象类Employee

    package cn.micai.base.io;
    
    import java.io.Serializable;
    
    /**
     * 描述:
     * <p>
     *
     *     transient使用小结
     *     1.一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问。
     *     2.transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量,则该类需要实现Serializable接口。
     *     3.被transient关键字修饰的变量不再能被序列化,一个静态变量不管是否被transient修饰,均不能被序列化。
     *
     * @author: 赵新国
     * @date: 2018/6/7 12:10
     */
    public class Employee implements Serializable {
    
        private static final long serialVersionUID = 1L;
        private int employeeId;
        private String employeeName;
        /**
         * 使用transient关键字,表示该字段不序列化
         */
        private transient String department;
    
        public int getEmployeeId() {
            return employeeId;
        }
        public void setEmployeeId(int employeeId) {
            this.employeeId = employeeId;
        }
        public String getEmployeeName() {
            return employeeName;
        }
        public void setEmployeeName(String employeeName) {
            this.employeeName = employeeName;
        }
        public String getDepartment() {
            return department;
        }
        public void setDepartment(String department) {
            this.department = department;
        }
    
        @Override
        public String toString() {
            return "Employee{" +
                    "employeeId=" + employeeId +
                    ", employeeName='" + employeeName + '\'' +
                    ", department='" + department + '\'' +
                    '}';
        }
    }
    

    三:编写使用jackson-all.1.7.6.jar工具包实现将对象序列化为JSON格式、JSON格式反序列化为对象的类

    package cn.micai.base.io;
    
    import org.codehaus.jackson.JsonFactory;
    import org.codehaus.jackson.JsonGenerator;
    import org.codehaus.jackson.map.ObjectMapper;
    
    import java.io.IOException;
    import java.io.StringWriter;
    
    /**
     * @Auther: zhaoxinguo
     * @Date: 2018/8/23 12:03
     * @Description: 使用jackson-all.1.7.6.jar工具包实现将对象序列化为JSON格式、JSON格式反序列化为对象
     */
    public class JacksonAllSerializeDeserializeMain {
    
        /**
         * 将Java对象employee序列化成为JSON格式
         * @param employee
         * @return
         */
        public static String serialize(Employee employee){
            // JSON对象序列化
            String employeeJson = null;
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                StringWriter stringWriter = new StringWriter();
                JsonGenerator jsonGenerator = new JsonFactory().createJsonGenerator(stringWriter);
                objectMapper.writeValue(jsonGenerator, employee);
                jsonGenerator.close();
                employeeJson = stringWriter.toString();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return employeeJson;
        }
    
        /**
         * 将JSON格式反序列化为employee对象
         * @param employeeJson
         * @return
         */
        public static Employee deserialize(String employeeJson) {
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                return objectMapper.readValue(employeeJson, Employee.class);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static void main(String [] args) {
    
            Employee employee = new Employee();
            employee.setEmployeeId(1);
            employee.setEmployeeName("赵新国");
            employee.setDepartment("软件工程师");
            // 序列化
            String serialize = serialize(employee);
            System.out.println(serialize);
            // 反序列化
            Employee deserialize = deserialize(serialize);
            System.out.println(deserialize);
    
        }
    
    }

    四:运行结果:

    展开全文
  • Java基础之对象序列化

    千次阅读 2016-05-01 15:04:11
    但有时候,Java对象是需要持久化的,因此Java提供了一种对象持久化方式——对象序列化机制(Object serialization),可以很容易的在JVM中的活动对象和字节数组(流)之间进行转换。对象序列化保存的是对象的”状态”...

    概述

    Java中的对象的内部状态只保存在内存中,其生命周期最长与JVM的生命周期一样,即JVM停止之后,所有对象都会被销毁。但有时候,Java对象是需要持久化的,因此Java提供了一种对象持久化方式——对象序列化机制(Object serialization),可以很容易的在JVM中的活动对象和字节数组(流)之间进行转换。

    对象序列化保存的是对象的”状态”,即它的成员变量。由此可知,对象序列化不会关注类中的静态变量。

    除了在持久化对象时会用到对象序列化之外,当使用RMI(远程方法调用),或在网络中传递对象时,都会用到对象序列化。

    注意:序列化的是对象(对象的状态,成员变量等),而不是类

    简单示例

    package java_interview;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.NavigableMap;
    import java.util.Random;
    import java.util.Scanner;
    import java.util.TreeMap;
    import java.util.TreeSet;
    public class Test {
    
        public static void main(String[] args) throws Exception {
    
        }
    }
     enum Gender {
        MALE, FEMALE
    }
    class Person implements Serializable {
    
        private String name = null;
    
        private Integer age = null;
    
        private Gender gender = null;
    
        public Person() {
            System.out.println("none-arg constructor");
        }
    
        public Person(String name, Integer age, Gender gender) {
            System.out.println("arg constructor");
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public Gender getGender() {
            return gender;
        }
    
        public void setGender(Gender gender) {
            this.gender = gender;
        }
    
        @Override
        public String toString() {
            return "[" + name + ", " + age + ", " + gender + "]";
        }
    }
    public class SimpleSerial {
    
        public static void main(String[] args) throws Exception {
            File file = new File("person.out");
    
            ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
            Person person = new Person("John", 101, Gender.MALE);
            oout.writeObject(person);
            oout.close();
    
            ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
            Object newPerson = oin.readObject(); // 没有强制转换到Person类型
            oin.close();
            System.out.println(newPerson);
        }
    }
    /*输出:
    arg constructor
    [John, 101, MALE]
    
    */
    

    此时必须注意的是,当重新读取被保存的Person对象时,并没有调用Person的任何构造器,看起来就像是直接使用字节将Person对象还原出来的。

    当Person对象被保存到person.out文件中之后,我们可以在其它地方去读取该文件以还原对象,但必须确保该读取程序的CLASSPATH中包含有Person.class(哪怕在读取Person对象时并没有显示地使用Person类,如上例所示),否则会抛出ClassNotFoundException。

    Serializable的作用

    什么一个类实现了Serializable接口,它就可以被序列化呢?在上节的示例中,使用ObjectOutputStream来持久化对象,在该类中有如下代码:

    private void writeObject0(Object obj, boolean unshared) throws IOException {
    
        if (obj instanceof String) {
            writeString((String) obj, unshared);
        } else if (cl.isArray()) {
            writeArray(obj, desc, unshared);
        } else if (obj instanceof Enum) {
            writeEnum((Enum) obj, desc, unshared);
        } else if (obj instanceof Serializable) {
            writeOrdinaryObject(obj, desc, unshared);
        } else {
            if (extendedDebugInfo) {
                throw new NotSerializableException(cl.getName() + "\n"
                        + debugInfoStack.toString());
            } else {
                throw new NotSerializableException(cl.getName());
            }
        }
    
    }

    从上述代码可知,如果被写对象的类型是String,或数组,或Enum,或Serializable,那么就可以对该对象进行序列化,否则将抛出NotSerializableException。

    默认序列化机制

    如果仅仅只是让某个类实现Serializable接口,而没有其它任何处理的话,则就是使用默认序列化机制。

    默认的序列化机制,是对对象的所有成员变量(静态变量不会被序列化,因为它不属于某个对象,是所有对象共享的)进行序列化

    使用默认机制,在序列化对象时,不仅会序列化当前对象本身,还会对该对象引用的其它对象也进行序列化,同样地,这些其它对象引用的另外对象也将被序列化,以此类推。所以,如果一个对象包含的成员变量是容器类对象,而这些容器所含有的元素也是容器类对象,那么这个序列化的过程就会较复杂,开销也较大。

    影响序列化

    在现实应用中,有些时候不能使用默认序列化机制。比如,希望在序列化过程中忽略掉敏感数据,或者简化序列化过程。下面将介绍若干影响序列化的方法。

    transient关键字

    有些情况下,是不希望对象的所有成员变量都进行序列化,比如User中的passwd字段,这个是敏感数据,不希望它被序列化,那么就可以使用transient关键字。
    transient,顾名思义,非持久化的。使用transient关键字修饰成员变量,能够使它在序列化的过程中被忽略。

    此处将Person类中的age字段声明为transient,如下所示,

    public class Person implements Serializable {
    
        transient private Integer age = null;
    
    }

    再执行SimpleSerial应用程序,会有如下输出:

    arg constructor
    [John, null, MALE]

    * writeObject()方法与readObject()方法*

    对于上述已被声明为transitive的字段age,除了将transitive关键字去掉之外,是否还有其它方法能使它再次可被序列化?方法之一就是在Person类中添加两个方法:writeObject()与readObject(),如下所示:

    public class Person implements Serializable {
    
        transient private Integer age = null;
    
    
        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }
    
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }
    }

    在writeObject()方法中会先调用ObjectOutputStream中的defaultWriteObject()方法,该方法会执行默认的序列化机制,如5.1节所述,此时会忽略掉age字段。然后再调用writeInt()方法显示地将age字段写入到ObjectOutputStream中。readObject()的作用则是针对对象的读取,其原理与writeObject()方法相同。

    再次执行SimpleSerial应用程序,则又会有如下输出:

    arg constructor
    [John, 31, MALE]

    必须注意地是,writeObject()与readObject()都是private方法,那么它们是如何被调用的呢?毫无疑问,是使用反射。详情可见ObjectOutputStream中的writeSerialData方法,以及ObjectInputStream中的readSerialData方法。

    通过这两个方法,可以对特殊要求的字段,增加额外的加密,解密的代码

    Externalizable接口

    以上例子都是基于实现Serializable接口来实现序列化的,Externalizable接口继承于Serializable,通过实现Externalizable接口也能实现序列化,不同的是,序列化操作的细节需要自己实现,而且,必须提供public的无参构造函数,否则会出现以下错误:

    这里写图片描述

    无论是使用transient关键字,还是使用writeObject()和readObject()方法,其实都是基于Serializable接口的序列化。JDK中提供了另一个序列化接口–Externalizable,使用该接口之后,之前基于Serializable接口的序列化机制就将失效。此时将Person类修改成如下,

    public class Person implements Externalizable {
    
        private String name = null;
    
        transient private Integer age = null;
    
        private Gender gender = null;
    
        public Person() {
            System.out.println("none-arg constructor");
        }
    
        public Person(String name, Integer age, Gender gender) {
            System.out.println("arg constructor");
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }
    
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }
    
        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
    
        }
    
        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    
        }
    
    }

    此时再执行SimpleSerial程序之后会得到如下结果:

    arg constructor
    none-arg constructor
    [null, null, null]

    从该结果,一方面可以看出Person对象中任何一个字段都没有被序列化。另一方面,如果细心的话,还可以发现这此次序列化过程调用了Person类的无参构造器。

    另外,若使用Externalizable进行序列化,当读取对象时,会调用被序列化类的无参构造器去创建一个新的对象,然后再将被保存对象的字段的值分别填充到新对象中。这就是为什么在此次序列化过程中Person类的无参构造器会被调用。由于这个原因,实现Externalizable接口的类必须要提供一个无参的构造器,且它的访问权限为public。

    对上述Person类作进一步的修改,使其能够对name与age字段进行序列化,但要忽略掉gender字段,如下代码所示:

    public class Person implements Externalizable {
    
        private String name = null;
    
        transient private Integer age = null;
    
        private Gender gender = null;
    
        public Person() {
            System.out.println("none-arg constructor");
        }
    
        public Person(String name, Integer age, Gender gender) {
            System.out.println("arg constructor");
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }
    
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }
    
        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            out.writeObject(name);
            out.writeInt(age);
        }
    
        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            name = (String) in.readObject();
            age = in.readInt();
        }
    
    }

    执行SimpleSerial之后会有如下结果:

    arg constructor
    none-arg constructor
    [John, 31, null]

    可知:采用这种方法实现序列化,transient是不起作用的,如果你不想序列化某个成员变量,只要在readExternal和writeExternal中不对该变量进行相应操作就可以了。

    readResolve()方法

    当我们使用Singleton模式时,应该是期望某个类的实例应该是唯一的,但如果该类是可序列化的,那么情况可能会略有不同。此时对第2节使用的Person类进行修改,使其实现Singleton模式,如下所示:

    public class Person implements Serializable {
    
        private static class InstanceHolder {
            private static final Person instatnce = new Person("John", 31, Gender.MALE);
        }
    
        public static Person getInstance() {
            return InstanceHolder.instatnce;
        }
    
        private String name = null;
    
        private Integer age = null;
    
        private Gender gender = null;
    
        private Person() {
            System.out.println("none-arg constructor");
        }
    
        private Person(String name, Integer age, Gender gender) {
            System.out.println("arg constructor");
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
    }

    同时要修改SimpleSerial应用,使得能够保存/获取上述单例对象,并进行对象相等性比较,如下代码所示:

    public class SimpleSerial {
    
        public static void main(String[] args) throws Exception {
            File file = new File("person.out");
            ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
            oout.writeObject(Person.getInstance()); // 保存单例对象
            oout.close();
    
            ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
            Object newPerson = oin.readObject();
            oin.close();
            System.out.println(newPerson);
    
            System.out.println(Person.getInstance() == newPerson); // 将获取的对象与Person类中的单例对象进行相等性比较
        }
    }

    执行上述应用程序后会得到如下结果:

    arg constructor
    [John, 31, MALE]
    false

    值得注意的是,从文件person.out中获取的Person对象与Person类中的单例对象并不相等。为了能在序列化过程仍能保持单例的特性,可以在Person类中添加一个readResolve()方法,在该方法中直接返回Person的单例对象,如下所示:

    public class Person implements Serializable {
    
        private static class InstanceHolder {
            private static final Person instatnce = new Person("John", 31, Gender.MALE);
        }
    
        public static Person getInstance() {
            return InstanceHolder.instatnce;
        }
    
        private String name = null;
    
        private Integer age = null;
    
        private Gender gender = null;
    
        private Person() {
            System.out.println("none-arg constructor");
        }
    
        private Person(String name, Integer age, Gender gender) {
            System.out.println("arg constructor");
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
        private Object readResolve() throws ObjectStreamException {
            return InstanceHolder.instatnce;
        }
    
    }

    再次执行本节的SimpleSerial应用后将有如下输出:

    arg constructor
    [John, 31, MALE]
    true

    无论是实现Serializable接口,或是Externalizable接口,当从I/O流中读取对象时,readResolve()方法都会被调用到。实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象,而被创建的对象则会被垃圾回收掉。

    总结

    • 实现Serializable与Externalizable接口都可以实现序列化
    • 前者实现方式如果不想序列化某个成员变量,使用transient关键字修饰该成员变量即可;如果想在此基础上添加一些自定义操作,在该类中实现writeObject与readObject方法(注意是private方法),在这两个方法里就可以做一些自定义操作,如改变某个成员变量的值。
    • 后者实现方式,需要自己实现序列的细节(writeExternal与readExternal方法),并且必须提供一个public的无参构造函数。这种方式为自定义序列化提供了更多的灵活性。

    高级认识

    序列化 ID 问题

    情境:

    两个客户端 A 和 B 试图通过网络传递对象数据,A 端将对象 C 序列化为二进制数据再传给 B,B 反序列化得到 C。

    问题:

    C 对象的全类路径假设为 com.inout.Test,在 A 和 B 端都有这么一个类文件,功能代码完全一致。也都实现了 Serializable 接口,但是反序列化时总是提示不成功。

    解决:

    虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID 是否一致(就是 private static final long serialVersionUID = 1L)。清单 1 中,虽然两个类的功能代码完全一致,但是序列化 ID 不同,他们无法相互序列化和反序列化。

    清单 1. 相同功能代码不同序列化 ID 的类对比

     package com.inout; 
    
     import java.io.Serializable; 
    
     public class A implements Serializable { 
    
         private static final long serialVersionUID = 1L; 
    
         private String name; 
    
         public String getName() 
         { 
             return name; 
         } 
    
         public void setName(String name) 
         { 
             this.name = name; 
         } 
     } 
    
     package com.inout; 
    
     import java.io.Serializable; 
    
     public class A implements Serializable { 
    
         private static final long serialVersionUID = 2L; 
    
         private String name; 
    
         public String getName() 
         { 
             return name; 
         } 
    
         public void setName(String name) 
         { 
             this.name = name; 
    

    如此问题中情景,客户端A将对象C序列化后,传给客户端B;客户端B对C进行反序列化时,B中必须有C对象对应的类,而且A、B客户端中对于对象C对应的类的序列化 ID 必须一致。

    序列化 ID 在 Eclipse 下提供了两种生成策略,一个是固定的 1L,一个是随机生成一个不重复的 long 类型数据(实际上是使用 JDK 工具生成),在这里有一个建议,如果没有特殊需求,就是用默认的 1L 就可以,这样可以确保代码一致时反序列化成功。那么随机生成的序列化 ID 有什么作用呢,有些时候,通过改变序列化 ID 可以用来限制某些用户的使用。

    序列化存储规则

    ObjectOutputStream out = new ObjectOutputStream(
                        new FileOutputStream("result.obj"));
        Test test = new Test();
        //试图将对象两次写入文件
        out.writeObject(test);
        out.flush();
        System.out.println(new File("result.obj").length());
        out.writeObject(test);
        out.close();
        System.out.println(new File("result.obj").length());
    
        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                "result.obj"));
        //从文件依次读出两个文件
        Test t1 = (Test) oin.readObject();
        Test t2 = (Test) oin.readObject();
        oin.close();
    
        //判断两个引用是否指向同一个对象
        System.out.println(t1 == t2);
    /*
    31
    36
    true
    */
    
    

    解答:Java 序列化机制为了节省磁盘空间,具有特定的存储规则,当写入文件的为同一对象时,并不会再将对象的内容进行存储,而只是再次存储一份引用,上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时,恢复引用关系,使得清单 3 中的 t1 和 t2 指向唯一的对象,二者相等,输出 true。该存储规则极大的节省了存储空间。

    参考:http://www.blogjava.net/jiangshachina/archive/2012/02/13/369898.html

    http://www.jianshu.com/p/56671a839f9c

    https://www.ibm.com/developerworks/cn/java/j-lo-serial/

    展开全文
  • 因此可以通过序列化储存java对象,再通过反序列化得到对象。 新建一个maven项目,添加相关的Jar依赖。 <dependencies> <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> ...
  • Java对象序列化与反序列化-Json篇

    千次阅读 2019-01-04 16:20:57
    说到Java对象序列化与反序列化,我们首先想到的应该是Java的Serializable接口,这玩意在两个系统之间的DTO对象里面可能会用到,用于系统之间的数据传输。或者在RPC(远程方法调用)时可能会用到。  但其实若是...
  • 今天看了看java.beans,发现了两个好东西,XMLEncoder和XMLDecoder。发现自己以前把从XML存取对象真是太费力气啦。做了小工具类,以后可以用用了。 以下是引用片段:package com.imct.util; import java.beans....
  • 浅析若干Java序列化工具

    万次阅读 2016-02-23 10:48:40
    采用java对象序列化和反序列化 把对象包装成JSON字符串传输 Google工具protoBuf的开源 本文章所需要的序列化jar都可以下载:http://download.csdn.net/detail/u013256816/9439971。   为了便于说明各个做法的
  • java序列化工具ysoserial.jar浅析

    千次阅读 2020-07-19 15:03:04
    ysoserial.jar ysoserial是集合了各种java序列化payload的工具,项目地址:https://github.com/frohoff/ysoserial
  • java序列化对象传给php

    2016-01-17 07:23:47
    android(包括java)序列化一个对象传给php去做处理,或是接到php...//将一个对象序列化后返回byte[] String phpserialstr=new String(b); 将变量phpserialstr传给php即可. PHPSerializer中还有unserialize方法,是反序列化
  • Java 序列化与反序列化工具

    千次阅读 2014-12-08 15:55:11
    在基于网络编程的项目中,经常会遇到需要将某些参数进行序列化之后再进行传输,在接收方再进行反序列化操作。普遍的做法是让实体类实现Serializable接口,但是当涉及很多实体类或者说需要序列化的实体类型不确定时...
  • java序列化与反序列化工具

    千次阅读 2017-03-15 17:45:54
    import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable;
  • 系统解耦与序列化、持久化 从开始学习和实践系统设计起就一直围绕着这样一个问题——怎样降低系统的耦合度,使系统更加健壮、更加灵活?无论桌面应用还是网络应用,确实它的系统中无非包含如下几方面的内容——如何...
  • Java序列化工具对比

    千次阅读 2018-07-04 08:17:15
    1. Java序列化工具技术原理比较 Binary Formats &amp;amp; language-specific ones JavaBuiltIn(java原生)、JavaManual(根据成员变量类型,手工写)、FstSerliazation、Kryo Binary formats-generic ...
  • 1.我们知道在java中有序列化的概念 序列化的过程就是将对象转变成字节码,反序列化即是从字节码转换成对象的过程一般情况下要求实现Serializable接口,此接口中没有定义任何成员,只是起到标记对象是否可以被序列化...
  • 一种概念证明工具,用于生成利用不安全的Java对象序列化的有效负载。 描述 最初作为AppSecCali 2015讲座一部分发布,其中包含针对Apache Commons Collections(3.x和4.x),Spring Beans / Core(4.x)和Groovy...
  • Java对象的XML序列化

    千次阅读 2012-03-06 19:13:46
    引言 Java对象的序列化(serialization)是对象的持久存储和对象状态的网络传输的 关键环节...对象序列化可以实现分布式对象,例如RMI要利用对象序列化运行远程主机上的服务,就像在本地机器上调用对象一样。对象序列化
  • MessagePack(以下简称MsgPack)一个基于二进制高效的对象序列化类库,可用于跨语言通信。它可以像JSON那样,在许多种语言之间交换结构对象;但是它比JSON更快速也更轻巧。支持Python、Ruby、Java、C/C++等众多语言。...
  • 需要一种方式:Java对象序列化–> 保存/传输 –反序列化–> Java对象 序列化(编码): 把对象的状态信息转化为可存储或传输的形式过程,也就是把对象转化为字节序列的过程 Java对象 –编码协议–> ...
  • 概念证明工具,用于生成利用不安全的Java对象序列化的有效负载。 描述 最初作为AppSecCali 2015讲座一部分发布,其中包含Apache Commons Collections(3.x和4.x),Spring Beans / Core(4.x)和Groovy( 2.3.x)...
  • Java对象的XML序列化和反序列化 - (3)

    千次阅读 2012-10-18 21:33:39
    Java对象的XML序列化和反序列化(1)和Java对象的XML序列化和反序列化(2)介绍了利用java.beans.XMLEncoder/XMLDecoder实现Java对象的XML序列化和反序列化。从XMLEncoder的输出结果来看,产生的XML序列包含了太多的...
  • //遍历集合,然后把对象序列化到文件中 for (T collection : collections){ objectOutputStream.writeObject(collection); } } catch (Exception e) { e.printStackTrace(); ...
  • Java对象的XML序列化和反序列化 - (1)

    万次阅读 2012-10-18 19:22:19
    XML是一种标准的数据交换规范,可以方便地用于在应用之间交换各类...java.beans里面有两个类XMLEncoder和Decoder,分别用于将符合JabaBeans规范的Java对象以XML方式序列化和反序列化。以下代码显示了如何使用这两个类
  • java中JSON序列化和反序列化工具比较

    千次阅读 2016-07-22 22:28:25
    jackson可以轻松的将Java对象转换成json对象和xml文档,同样也可以将json、xml转换成Java对象。最新的版本到2.8,稳定版为2.7 从Jackson 2.0起,核心组件包括: jackson-annotations(带注释的数据绑定)。...
  • 序列化工具类(包含java序列化工具,jboss marshalling序列化工具类) 日期工具类(日期转串口,字符串转日期) 简要说明 通过使用mumu-core组件可以大大减少项目创造的复杂度,实现开箱即用的特性。 唱机日志 2017-...
  • 最近由于工作需要,需要研究常用的集中序列化方式,主要目的是对象序列化后占用空间会大大减少,便于存储和传输,下面是几种序列化方式的使用demo   1. Java自带的Serialize 依赖jar:无 代码示意: import ...
  • Java 序列化及解决方案

    千次阅读 2020-06-11 18:14:47
      定义:Java序列化是指把Java对象转换为字节序列的过程;Java反序列化是指把字节序列恢复为Java对象的过程。   解析:简单来说,序列化只针对失血对象,所谓失血对象是指只有属性和getter/setter方法的数据类,...
  • Java SE】对象序列化和反序列化

    千次阅读 2012-05-30 13:19:11
    为什么要序列化 在JAVA中,一个大的应用程序需要保存很多对象的时候,由于虚拟机...本文讲实现如何将对象序列化到文件,然后再从文件反序列化到对象,你会发现其实特别简单   对象的序列化和反序列化的关
  • 各种java序列化工具性能对比

    千次阅读 2013-09-12 16:00:48
    看到一个很不错的工具http://github.com/eishay/jvm-serializers/,可以用它来评测各种流行的java序列化反序列化工具,使用上也很简单。想试试该工具的,下载源码后参考起README操作即可。而我更关心的是,是各种...
  • XStream 是一种序列化工具而不是数据绑定工具,就是说不能从 XML 或者 XML Schema Definition (XSD) 文件生成类。 和其他序列化工具相比,XStream 有三个突出的特点: XStream 不关心序列化/逆序列化的类的字段的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 110,498
精华内容 44,199
关键字:

java对象序列化工具包

java 订阅