1 概述

《Netty學習7-序列化原理》一文中講述了序列化的原理，通過Java位運算、JDK原生的NIO、Netty的ChannelBuffer做了序列化操作。本文演示稍微複雜的一個自定義序列化框架，但萬變不離其宗，拆解出來還是很簡單的。

2 工具類

這是核心類。拆解來看就是呼叫了ChannelBuffer的readInt和writeInt等方法，並定義了抽象類方法read和write等待實體類實現。

import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
/**
 * Buffer工具類
 */
public class BufferUtils {

	/**
	 * 獲取一個快取物件
	 * 
	 * @return 快取物件
	 */
	public static ChannelBuffer getBuffer() {
		ChannelBuffer dynamicBuffer = ChannelBuffers.dynamicBuffer();
		return dynamicBuffer;
	}

	/**
	 * 將二進位制bytes寫入快取物件
	 * 
	 * @param bytes 二進位制資料
	 * @return 快取物件
	 */
	public static ChannelBuffer getBuffer(byte[] bytes) {
		ChannelBuffer copiedBuffer = ChannelBuffers.copiedBuffer(bytes);
		return copiedBuffer;
	}
}

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.jboss.netty.buffer.ChannelBuffer;
import com.cn.core.BufferFactory;
/**
 * 自定義序列化基類
 */
public abstract class Serializer {

	// 編碼物件
	public static final Charset CHARSET = Charset.forName("UTF-8");

	// 寫快取
	protected ChannelBuffer writeBuf;

	// 讀快取
	protected ChannelBuffer readBuf;

	// 反序列化具體實現
	protected abstract void read();

	// 序列化具體實現
	protected abstract void write();

	/***************************************** 序列化 ************************************/

	// 序列化
	public byte[] serialze() {

		// 申明寫快取
		writeBuf = BufferUtils.getBuffer();

		// 將資料寫入寫快取
		write();

		// 將寫快取資料讀入byte陣列
		byte[] bytes = null;
		if (writeBuf.writerIndex() == 0)
			bytes = new byte[0];
		else {
			bytes = new byte[writeBuf.writerIndex()];
			writeBuf.readBytes(bytes);
		}
		writeBuf.clear();
		return bytes;
	}

	public Serializer writeShort(Short value) {
		writeBuf.writeShort(value);
		return this;
	}

	public Serializer writeInt(Integer value) {
		writeBuf.writeInt(value);
		return this;
	}

	public Serializer writeLong(Long value) {
		writeBuf.writeLong(value);
		return this;
	}

	public Serializer writeString(String value) {
		if (value == null || value.isEmpty()) {
			writeShort((short) 0);
			return this;
		}
		byte data[] = value.getBytes(CHARSET);
		short len = (short) data.length;
		writeBuf.writeShort(len);
		writeBuf.writeBytes(data);
		return this;
	}

	public Serializer writeByte(Byte value) {
		writeBuf.writeByte(value);
		return this;
	}

	public <T> Serializer writeList(List<T> list) {
		if (isEmpty(list)) {
			writeBuf.writeShort((short) 0);
			return this;
		}
		writeBuf.writeShort((short) list.size());
		for (T item : list) {
			writeObject(item);
		}
		return this;
	}

	public <K, V> Serializer writeMap(Map<K, V> map) {
		if (isEmpty(map)) {
			writeBuf.writeShort((short) 0);
			return this;
		}
		writeBuf.writeShort((short) map.size());
		for (Entry<K, V> entry : map.entrySet()) {
			writeObject(entry.getKey());
			writeObject(entry.getValue());
		}
		return this;
	}

	public Serializer writeObject(Object object) {
		if (object == null) {
			writeByte((byte) 0);
		} else {
			if (object instanceof Integer) {
				writeInt((int) object);
				return this;
			}
			if (object instanceof Long) {
				writeLong((long) object);
				return this;
			}
			if (object instanceof Short) {
				writeShort((short) object);
				return this;
			}
			if (object instanceof Byte) {
				writeByte((byte) object);
				return this;
			}
			if (object instanceof String) {
				String value = (String) object;
				writeString(value);
				return this;
			}
			if (object instanceof Serializer) {
				writeByte((byte) 1);
				Serializer value = (Serializer) object;
				value.writeToTargetBuffer(writeBuf);
				return this;
			}
			throw new RuntimeException("不可序列化的型別:" + object.getClass());
		}
		return this;
	}

	// 呼叫物件自身的寫入方法
	public ChannelBuffer writeToTargetBuffer(ChannelBuffer buffer) {
		writeBuf = buffer;
		write();
		return writeBuf;
	}

	/***************************************** 反序列化 ************************************/

	public Serializer deserialize(byte[] bytes) {
		readBuf = BufferUtils.getBuffer(bytes);
		read();
		readBuf.clear();
		return this;
	}

	public byte readByte() {
		return readBuf.readByte();
	}

	public short readShort() {
		return readBuf.readShort();
	}

	public int readInt() {
		return readBuf.readInt();
	}

	public long readLong() {
		return readBuf.readLong();
	}

	public String readString() {
		int size = readBuf.readShort();
		if (size <= 0) {
			return "";
		}

		byte[] bytes = new byte[size];
		readBuf.readBytes(bytes);

		return new String(bytes, CHARSET);
	}

	public <T> List<T> readList(Class<T> clz) {
		List<T> list = new ArrayList<>();
		int size = readBuf.readShort();
		for (int i = 0; i < size; i++) {
			list.add(read(clz));
		}
		return list;
	}

	public <K, V> Map<K, V> readMap(Class<K> keyClz, Class<V> valueClz) {
		Map<K, V> map = new HashMap<>();
		int size = readBuf.readShort();
		for (int i = 0; i < size; i++) {
			K key = read(keyClz);
			V value = read(valueClz);
			map.put(key, value);
		}
		return map;
	}

	@SuppressWarnings("unchecked")
	public <I> I read(Class<I> clz) {
		Object t = null;
		if (clz == int.class || clz == Integer.class) {
			t = this.readInt();
		} else if (clz == byte.class || clz == Byte.class) {
			t = this.readByte();
		} else if (clz == short.class || clz == Short.class) {
			t = this.readShort();
		} else if (clz == long.class || clz == Long.class) {
			t = this.readLong();
		} else if (clz == String.class) {
			t = readString();
		} else if (Serializer.class.isAssignableFrom(clz)) {
			try {
				byte hasObject = this.readBuf.readByte();
				if (hasObject == 1) {
					Serializer temp = (Serializer) clz.newInstance();
					temp.readFromBuffer(this.readBuf);
					t = temp;
				} else {
					t = null;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}

		} else {
			throw new RuntimeException(String.format("不支援型別:[%s]", clz));
		}
		return (I) t;
	}

	// 呼叫物件自身的讀取方法
	public void readFromBuffer(ChannelBuffer readBuffer) {
		this.readBuf = readBuffer;
		read();
	}

	/***************************************** 工具方法 ************************************/

	private <T> boolean isEmpty(Collection<T> c) {
		return c == null || c.size() == 0;
	}

	public <K, V> boolean isEmpty(Map<K, V> c) {
		return c == null || c.size() == 0;
	}
}
 

3 實體類

public class Hobby extends Serializer {

	private String name;

	public Hobby() {

	}

	@Override
	protected void read() {
		this.name = readString();
	}

	@Override
	protected void write() {
		writeString(name);
	}

	public Hobby(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Hobby [name=" + name + "]";
	}
}

public class Student extends Serializer {

	// 學號
	private Integer id;
	// 姓名
	private String name;
	// 分數
	private Long mark;
	// 同學名
	private List<String> classmates;
	// 愛好
	private List<Hobby> hobbies;
	// 住址
	private Map<String, String> address;

	@Override
	protected void write() {
		writeInt(id);
		writeString(name);
		writeLong(mark);
		writeList(classmates);
		writeList(hobbies);
		writeMap(address);
	}

	@Override
	protected void read() {
		this.id = readInt();
		this.name = readString();
		this.mark = readLong();
		this.classmates = readList(String.class);
		this.hobbies = readList(Hobby.class);
		this.address = readMap(String.class, String.class);
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public Long getMark() {
		return mark;
	}

	public void setMark(Long mark) {
		this.mark = mark;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public List<String> getClassmates() {
		return classmates;
	}

	public void setClassmates(List<String> classmates) {
		this.classmates = classmates;
	}

	public List<Hobby> getHobbies() {
		return hobbies;
	}

	public void setHobbies(List<Hobby> hobbies) {
		this.hobbies = hobbies;
	}

	public Map<String, String> getAddress() {
		return address;
	}

	public void setAddresses(Map<String, String> address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", mark=" + mark
				+ ", classmates=" + classmates + ", hobbies=" + hobbies
				+ ", address=" + address + "]";
	}
}
 

4 測試方法

public class XYTest {
	public static void main(String[] args) {

		// 資料初始化
		Student student = new Student();
		student.setId(10);
		student.setName("xy");
		student.setMark(100L);
		List<String> classmates = new ArrayList<String>();
		classmates.add("xiaoming");
		classmates.add("xiaohong");
		student.setClassmates(classmates);
		List<Hobby> hobbies = new ArrayList<Hobby>();
		hobbies.add(new Hobby("football"));
		student.setHobbies(hobbies);
		Map<String, String> address = new HashMap<String, String>();
		address.put("aaa", "bbb");
		address.put("ccc", "ddd");
		student.setAddresses(address);

		// 序列化
		byte[] array = student.serialze();
		System.out.println(Arrays.toString(array));

		// 反序列化
		Student s = new Student();
		s.deserialize(array);
		System.out.println(s.toString());
	}
}