序列化工具-Jackson-序列化和反序列化用法

一、环境依赖：

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.8.1</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.8.1</version>
</dependency>

二、序列化&反序列化：

public interface IJacksonSerializer {
    <T> byte[] serialize(T obj);
    <T> T deserialize(byte[] data, Class<T> clazz);
}

import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jason.seria.IJacksonSerializer;
import com.jason.seria.ISerializer;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class JacksonSerializer implements IJacksonSerializer {
    XStream stream=new XStream(new DomDriver());
    //序列化
    @Override
    public <T> byte[] serialize(T obj) {
        ObjectMapper mapper = new ObjectMapper();
        byte[] bytes=null;
        try {
            bytes=mapper.writeValueAsString(obj).getBytes();
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return new byte[0];
        }finally {
            return bytes;
        }
    }
    //反序列化
    @Override
    public <T> T deserialize(byte[] data,Class<T> classType) {
        try {
            return new ObjectMapper().readValue(new String(data), classType);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class TestMain {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.setName("jason");
        stu.setAge(18);
        IJacksonSerializer serializer=new JacksonSerializer();
        long t1 = System.nanoTime();
        byte[] serialize = serializer.serialize(stu);
        System.out.println("序列化耗时="+(System.nanoTime()-t1));
        System.out.println("jackson 序列化长度 result:"+serialize.length);
        System.out.println(""+new String(serialize));
        long t3 = System.nanoTime();
        Student stu2=(Student)serializer.deserialize(serialize,stu.getClass());
        System.out.println("反序列化耗时="+(System.nanoTime()-t3));
    }
}