java 和 hessian2 的序列化以及反序列化

序列化：把java对象转化为字节序列的过程称为序列化；

反序列化：把字节恢复为java对象的过程称为反序列化。

 

最近看了下java序列化和hessian序列化的过程，大概坐下笔记如下代码分别为java序列化和hessian序列化的方法：

1、java序列化：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;

/**
 * Created by lbzhao on 2016/12/12.
 */
public class JavaSerialization {

    private static final Logger logger = LoggerFactory.getLogger(JavaSerialization.class);

    /**
     * java serialize
     * @param obj java object
     * @return java byte array
     */
    public static byte[] serialize(Object obj) {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        try {
            ObjectOutputStream out = new ObjectOutputStream(os);
            out.writeObject(obj);
            out.close();
        } catch (Exception e) {
            logger.error("java serialize failed," + e);
        }
        return os.toByteArray();
    }

    /**
     * java deserialize method
     * @param bytes java byte array
     * @return java object
     */
    public static Object deserialize(byte[] bytes) {
        ByteArrayInputStream is = new ByteArrayInputStream(bytes);
        Object value = null;
        try {
            ObjectInputStream in = new ObjectInputStream(is);
            value = in.readObject();
            in.close();
        } catch (Exception e) {
            logger.error("java deserialize failed," + e);
        }
        return value == null ? bytes : value;
    }
}

 

2、hessian序列化：

import com.caucho.hessian.io.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * Created by lbzhao on 2016/12/12.
 */
public class HessianSerialization {

    private final static Logger logger = LoggerFactory.getLogger(HessianSerialization.class);
    private static SerializerFactory serializerFactory = new SerializerFactory();

    /**
     * hessian serialize
     * @param obj java object
     * @return byte array
     */
    public static byte[] serialize(Object obj) {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        AbstractHessianOutput out = new Hessian2Output(os);

        out.setSerializerFactory(serializerFactory);
        try {
            out.writeObject(obj);
            out.close();
        } catch (Exception e) {
            logger.error("hessian serialize failed," + e);
        }
        return os.toByteArray();
    }

    /**
     * hessian deserialize
     * @param bytes byte array
     * @return java object
     */
    public static Object deserialize(byte[] bytes) {
        ByteArrayInputStream is = new ByteArrayInputStream(bytes);
        AbstractHessianInput in = new Hessian2Input(is);

        in.setSerializerFactory(serializerFactory);
        Object value = null;
        try {
            value = in.readObject();
            in.close();
        } catch (IOException e) {
            logger.error("hessian deserialize failed," + e);
        }
        return value == null ? bytes : value;
    }
}

 

下面写了一个简单的demo测试了下2者的序列化和反序列化:

import java.io.Serializable;

/**
 * Created by lbzhao on 2016/12/12.
 */
public class Person implements Serializable {

    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name:"+name+", age: "+age+"}";
    }
}

**
 * Created by lbzhao on 2016/12/12.
 */
public class SerializeTest {

    public static void main(String[] args) {
        Person person = new Person("斌哥", 28);

        byte[] bytes = JavaSerialization.serialize(person);
        for (byte by : bytes) {
            System.out.print(by);
        }
        System.out.println();
        System.out.println("java serialize person length: " + bytes.length);

        byte[] bytes1 = HessianSerialization.serialize(person);
        for (byte by : bytes1) {
            System.out.print(by);
        }
        System.out.println();
        System.out.println("hessian serialize length: " + bytes1.length);

        Object object = JavaSerialization.deserialize(bytes);
        System.out.println("java deserialize object: " + object);
        
        Object object1 = HessianSerialization.deserialize(bytes1);
        System.out.println("hessian deserialize object: " + object1);

        System.out.println("person hashCode: " + Integer.toHexString(person.hashCode()));
        System.out.println("java deserialize hashCode: " + Integer.toHexString(object.hashCode()));
        System.out.println("hessian deserialize hashCode: " + Integer.toHexString(object1.hashCode()));
    }
}

 

附上运行结果：

-84-190511511403799111109461029997114461029997114108111971104699111109109111110461171161051081154680101114115111110-11122608863-107-635020273039710310176041109710910111601876106971189747108971101034783116114105110103591201120002811606-26-106-116-27-109-91
java serialize person length: 105
67483799111109461029997114461029997114108111971104699111109109111110461171161051081154680101114115111110-110411097109101397103101962-26-106-116-27-109-91-84
hessian serialize length: 59
java deserialize object: Person{name:斌哥, age: 28}
hessian deserialize object: Person{name:斌哥, age: 28}
person hashCode: 2d66a22b
java deserialize hashCode: 42a9c09e
hessian deserialize hashCode: 16a4e743

 

 

使用hessian反序列化时，是通过反射调用类的构造函数生成对象，所以对构造函数有一定的要求，一般需要给一个无参构造器，而使用java默认的序列化，正常只需要类实现java.io.Serializable接口。

 

参考博客：http://hittyt.iteye.com/blog/1691772

http://www.cnblogs.com/happyday56/p/4268249.html