一、Java默认序列化。接口是自定义的方法很明显,故不再展示。
package com.back.serialize;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
public class DefaultJDKSerializer implements ISerializer {
public <T> byte[] serialize(T obj) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(obj);
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
return baos.toByteArray();
}
@SuppressWarnings("unchecked")
public <T> T deserialize(byte[] data, Class<T> clazz) {
ByteArrayInputStream bais = new ByteArrayInputStream(data);
try {
ObjectInputStream ois = new ObjectInputStream(bais);
return (T)ois.readObject();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* test successful !
* @param args
* @throws UnsupportedEncodingException
*/
public static void main(String[] args) throws UnsupportedEncodingException {
Map map = new HashMap();
map.put("aa", "bb");
DefaultJDKSerializer s = new DefaultJDKSerializer();
byte[] bytes = s.serialize(map);
System.out.println(new String(bytes,"UTF-8").length());
HashMap map1 = s.deserialize(bytes, HashMap.class);
System.out.println(map1.get("aa"));
}
}
2、Hessian序列化
package com.back.serialize;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;
/**
*
* <p>Title: HessianSerializer</p>
* <p>Description: hessian 方式序列化</p>
* @author back
* @date 2019年8月8日
*/
public class HessianSerializer implements ISerializer{
public <T> byte[] serialize(T obj) {
if(null == obj)
throw new NullPointerException("obj is null");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
HessianOutput ho = new HessianOutput(baos);
ho.writeObject(obj);
return baos.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public <T> T deserialize(byte[] data, Class<T> clazz) {
try {
ByteArrayInputStream bais = new ByteArrayInputStream(data);
HessianInput hi = new HessianInput(bais);
return (T)hi.readObject();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* test Successful
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Map map = new HashMap();
map.put("aa", "bb");
ISerializer s = new HessianSerializer();
byte[] bytes = s.serialize(map);
System.out.println(new String(bytes,"UTF-8").length());
HashMap map1 = s.deserialize(bytes, HashMap.class);
System.out.println(map1.get("aa"));
}
}
三、Json方式
package com.back.serialize;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
/**
*
* <p>Title: JsonSerializer</p>
* <p>Description:FastJson完成转换 api比较简单 Jackson更强大 易用性低于前者 </p>
* @author back
* @date 2019年8月8日
*/
public class JsonSerializer implements ISerializer{
public <T> byte[] serialize(T obj) {
JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
return JSON.toJSONString(obj,SerializerFeature.WriteDateUseDateFormat).getBytes();
}
public <T> T deserialize(byte[] data, Class<T> clazz) {
try {
return JSON.parseObject(new String(data,"UTF-8"),clazz);
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
}
/**
* test Successful
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Map map = new HashMap();
map.put("aa", "bb");
ISerializer s = new JsonSerializer();
byte[] bytes = s.serialize(map);
System.out.println(new String(bytes,"UTF-8"));
HashMap map1 = s.deserialize(bytes, HashMap.class);
System.out.println(map1.get("aa"));
}
}
四、Xml方式
package com.back.serialize;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
/**
*
* <p>Title: XmlSerializer</p>
* <p>Description: 使用XStream完成转换</p>
* @author back
* @date 2019年8月8日
*/
public class XmlSerializer implements ISerializer{
private final static XStream xStream = new XStream(new DomDriver());
public <T> byte[] serialize(T obj) {
return xStream.toXML(obj).getBytes();
}
@SuppressWarnings("unchecked")
public <T> T deserialize(byte[] data, Class<T> clazz) {
try {
String xml = new String(data,"UTF-8");
return (T)xStream.fromXML(xml);
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws Exception {
Map map = new HashMap();
map.put("aa", "bb");
ISerializer s = new XmlSerializer();
byte[] bytes = s.serialize(map);
System.out.println(new String(bytes,"UTF-8"));
HashMap map1 = s.deserialize(bytes, HashMap.class);
System.out.println(map1.get("aa"));
}
}
五、Marshalling方式
package com.back.serialize;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.jboss.marshalling.Marshaller;
import org.jboss.marshalling.MarshallerFactory;
import org.jboss.marshalling.Marshalling;
import org.jboss.marshalling.MarshallingConfiguration;
import org.jboss.marshalling.Unmarshaller;
/**
*
* <p>Title: MarshallingSerializer</p>
* <p>Description: JBoss - Marshalling 序列化 但是码流好像还很大!</p>
* @author back
* @date 2019年8月9日
*/
public class MarshallingSerializer implements ISerializer{
final static MarshallingConfiguration config = new MarshallingConfiguration();
final static MarshallerFactory factory =
Marshalling.getProvidedMarshallerFactory("serial");
public <T> byte[] serialize(T obj) {
ByteArrayOutputStream baos = null;
try {
baos = new ByteArrayOutputStream();
final Marshaller marshaller = factory.createMarshaller(config);
marshaller.start(Marshalling.createByteOutput(baos));
marshaller.writeObject(obj);
marshaller.finish();
} catch (IOException e) {
e.printStackTrace();
}
return baos.toByteArray();
}
public <T> T deserialize(byte[] data, Class<T> clazz) {
ByteArrayInputStream bais = new ByteArrayInputStream(data);
try {
final Unmarshaller unMarshaller = factory.createUnmarshaller(config);
unMarshaller.start(Marshalling.createByteInput(bais));
return (T)unMarshaller.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* test Successful
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Map map = new HashMap();
map.put("aa", "bb");
ISerializer s = new MarshallingSerializer();
byte[] bytes = s.serialize(map);
System.out.println(new String(bytes,"UTF-8"));
HashMap map1 = s.deserialize(bytes, HashMap.class);
System.out.println(map1.get("aa"));
}
}
六、自定义枚举 完成类型选择
package com.back.constant;
import com.back.serialize.ISerializer;
/**
*
* <p>Title: SerializeType 定义我们实现的几种序列化类型</p>
* <p>Description: </p>
* @author back
* @date 2019年8月9日
*/
public enum SerializeType {
DefaultJDKSerializer("DefaultJDKSerializer"),
HessianSerializer("HessianSerializer"),
JsonSerializer("JsonSerializer"),
XmlSerializer("XmlSerializer"),
MarshallingSerializer("MarshallingSerializer");
private String serializeType;
private SerializeType(String serializeType) {
this.serializeType = serializeType;
}
public String getSerializeType(){
return this.serializeType;
}
public static SerializeType queryByType(String type){
if(null == type || "".equals(type))
return null;
for (SerializeType serialize : SerializeType.values()) {
if(type.equals(serialize.getSerializeType())){
return serialize;
}
}
return null;
}
}
七、自定义序列化引擎
package com.back.serialize;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.back.constant.SerializeType;
/**
*
* <p>Title: SerializeEngine</p>
* <p>Description: 序列化引擎 根据支持的方式序列化</p>
* @author back
* @date 2019年8月9日
*/
public class SerializeEngine {
public final static Map<SerializeType,ISerializer> map
= new ConcurrentHashMap<SerializeType, ISerializer>();
static{
map.put(SerializeType.DefaultJDKSerializer, new DefaultJDKSerializer());
map.put(SerializeType.HessianSerializer, new HessianSerializer());
map.put(SerializeType.JsonSerializer, new JsonSerializer());
map.put(SerializeType.XmlSerializer, new XmlSerializer());
map.put(SerializeType.MarshallingSerializer, new MarshallingSerializer());
}
/**
* 序列化
* @param obj
* @param type
* @return
*/
public static <T> byte[] serialize(T obj , String type){
SerializeType serialize = SerializeType.queryByType(type);
if(null == serialize)
throw new RuntimeException();
ISerializer iSerializer = map.get(serialize);
if(null == iSerializer)
throw new RuntimeException();
return iSerializer.serialize(obj);
}
/**
* 反序列化
* @param data
* @param clazz
* @param type
* @return
*/
public static <T> T deserialize(byte[] data,Class<T> clazz,String type){
SerializeType serialize = SerializeType.queryByType(type);
if(null == serialize)
throw new RuntimeException();
ISerializer iSerializer = map.get(serialize);
if(null == iSerializer)
throw new RuntimeException();
return iSerializer.deserialize(data, clazz);
}
}