自定义序列化

最新推荐文章于 2023-11-14 13:55:39 发布
最新推荐文章于 2023-11-14 13:55:39 发布
阅读量580 收藏
点赞数 1
分类专栏： 【RPC】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27384769/article/details/80700370
版权

自定义序列化

更多干货

例子一

  • 使用位移 与大小端存储对象。

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

public class Test1 {

	public static void main(String[] args) throws IOException {
		int id = 101;
		int age = 21;

		ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
		arrayOutputStream.write(int2bytes(id));
		arrayOutputStream.write(int2bytes(age));

		byte[] byteArray = arrayOutputStream.toByteArray();

		System.out.println(Arrays.toString(byteArray));

		//==============================================================
		ByteArrayInputStream arrayInputStream = new ByteArrayInputStream(byteArray);
		byte[] idBytes = new byte[4];
		arrayInputStream.read(idBytes);
		System.out.println("id:" + bytes2int(idBytes));

		byte[] ageBytes = new byte[4];
		arrayInputStream.read(ageBytes);
		System.out.println("age:" + bytes2int(ageBytes));

	}


	/**
	 * 大端字节序列(先写高位，再写低位)
	 * 百度下 大小端字节序列
	 * @param i
	 * @return
	 */
	public static byte[] int2bytes(int i){
		byte[] bytes = new byte[4];
		bytes[0] = (byte)(i >> 3*8);
		bytes[1] = (byte)(i >> 2*8);
		bytes[2] = (byte)(i >> 1*8);
		bytes[3] = (byte)(i >> 0*8);
		return bytes;
	}


	/**
	 * 大端
	 * @param bytes
	 * @return
	 */
	public static int bytes2int(byte[] bytes){
		return (bytes[0] << 3*8) |
				(bytes[1] << 2*8) |
				(bytes[2] << 1*8) |
				(bytes[3] << 0*8);
	}

}

ByteBuffer

import java.nio.ByteBuffer;
import java.util.Arrays;

public class Test2 {

	public static void main(String[] args) {
		int id = 101;
		int age = 21;

		ByteBuffer buffer = ByteBuffer.allocate(8);
		buffer.putInt(id);
		buffer.putInt(age);
		byte[] array = buffer.array();
		System.out.println(Arrays.toString(buffer.array()));

		//====================================================

		ByteBuffer buffer2 = ByteBuffer.wrap(array);
		System.out.println("id:"+buffer2.getInt());
		System.out.println("age:"+buffer2.getInt());

	}

}

ChannelBuffer

import java.util.Arrays;

import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;

public class Test3 {

    public static void main(String[] args) {

        ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
        buffer.writeInt(101);
        buffer.writeDouble(80.1);

        byte[] bytes = new byte[buffer.writerIndex()];
        buffer.readBytes(bytes);

        System.out.println(Arrays.toString(bytes));

        System.out.println("abc".getBytes());

        //================================================
        ChannelBuffer wrappedBuffer = ChannelBuffers.wrappedBuffer(bytes);
        System.out.println(wrappedBuffer.readInt());
        System.out.println(wrappedBuffer.readDouble());

    }

}

序列化

Serializer

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;
/**
 * 自定义序列化接口
 *
 *
 */
public abstract class Serializer {


	public static final Charset CHARSET = Charset.forName("UTF-8");

	protected ChannelBuffer writeBuffer;

	protected ChannelBuffer readBuffer;

	/**
	 * 反序列化具体实现
	 */
	protected abstract void read();

	/**
	 * 序列化具体实现
	 */
	protected abstract void write();

	/**
	 * 从byte数组获取数据
	 * @param bytes	读取的数组
	 */
	public Serializer readFromBytes(byte[] bytes) {
		readBuffer = BufferFactory.getBuffer(bytes);
		read();
		readBuffer.clear();
		return this;
	}

	/**
	 * 从buff获取数据
	 * @param readBuffer
	 */
	public void readFromBuffer(ChannelBuffer readBuffer) {
		this.readBuffer = readBuffer;
		read();
	}

	/**
	 * 写入本地buff
	 * @return
	 */
	public ChannelBuffer writeToLocalBuff(){
		writeBuffer = BufferFactory.getBuffer();
		write();
		return writeBuffer;
	}

	/**
	 * 写入目标buff
	 * @param buffer
	 * @return
	 */
	public ChannelBuffer writeToTargetBuff(ChannelBuffer buffer){
		writeBuffer = buffer;
		write();
		return writeBuffer;
	}

	/**
	 * 返回buffer数组
	 *
	 * @return
	 */
	public byte[] getBytes() {
		writeToLocalBuff();
		byte[] bytes = null;
		if (writeBuffer.writerIndex() == 0) {
			bytes = new byte[0];
		} else {
			bytes = new byte[writeBuffer.writerIndex()];
			writeBuffer.readBytes(bytes);
		}
		writeBuffer.clear();
		return bytes;
	}


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

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

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

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

	public float readFloat() {
		return readBuffer.readFloat();
	}

	public double readDouble() {
		return readBuffer.readDouble();
	}

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

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

		return new String(bytes, CHARSET);
	}

	public <T> List<T> readList(Class<T> clz) {
		List<T> list = new ArrayList<>();
		int size = readBuffer.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 = readBuffer.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 == float.class || clz == Float.class){
			t = readFloat();
		} else if (clz == double.class || clz == Double.class){
			t = readDouble();
		} else if (clz == String.class ){
			t = readString();
		} else if (Serializer.class.isAssignableFrom(clz)){
			try {
				byte hasObject = this.readBuffer.readByte();
				if(hasObject == 1){
					Serializer temp = (Serializer)clz.newInstance();
					temp.readFromBuffer(this.readBuffer);
					t = temp;
				}else{
					t = null;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}

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


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

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

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

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

	public Serializer writeFloat(Float value) {
		writeBuffer.writeFloat(value);
		return this;
	}

	public Serializer writeDouble(Double value) {
		writeBuffer.writeDouble(value);
		return this;
	}

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

	public <K,V> Serializer writeMap(Map<K, V> map) {
		if (isEmpty(map)) {
			writeBuffer.writeShort((short) 0);
			return this;
		}
		writeBuffer.writeShort((short) map.size());
		for (Entry<K, V> entry : map.entrySet()) {
			writeObject(entry.getKey());
			writeObject(entry.getValue());
		}
		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;
		writeBuffer.writeShort(len);
		writeBuffer.writeBytes(data);
		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.writeToTargetBuff(writeBuffer);
				return this;
			}

			throw new RuntimeException("不可序列化的类型:" + object.getClass());
		}

		return this;
	}

	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;
	}
}

BufferFactory

import java.nio.ByteOrder;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
/**
 * buff工厂
 *
 *
 */
public class BufferFactory {

	public static ByteOrder BYTE_ORDER = ByteOrder.BIG_ENDIAN;

	/**
	 * 获取一个buffer
	 *
	 * @return
	 */
	public static ChannelBuffer getBuffer() {
		ChannelBuffer dynamicBuffer = ChannelBuffers.dynamicBuffer();
		return dynamicBuffer;
	}

	/**
	 * 将数据写入buffer
	 * @param bytes
	 * @return
	 */
	public static ChannelBuffer getBuffer(byte[] bytes) {
		ChannelBuffer copiedBuffer = ChannelBuffers.copiedBuffer(bytes);
		return copiedBuffer;
	}

}

Player

import java.util.ArrayList;
import java.util.List;

import com.cn.core.Serializer;

public class Player extends Serializer{

	private long playerId;

	private int age;

	private List<Integer> skills = new ArrayList<>();

	private Resource resource = new Resource();

	public Resource getResource() {
		return resource;
	}

	public void setResource(Resource resource) {
		this.resource = resource;
	}

	public long getPlayerId() {
		return playerId;
	}

	public void setPlayerId(long playerId) {
		this.playerId = playerId;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public List<Integer> getSkills() {
		return skills;
	}

	public void setSkills(List<Integer> skills) {
		this.skills = skills;
	}

	@Override
	protected void read() {
		this.playerId = readLong();
		this.age = readInt();
		this.skills = readList(Integer.class);
		this.resource = read(Resource.class);
	}

	@Override
	protected void write() {
		writeLong(playerId);
		writeInt(age);
		writeList(skills);
		writeObject(resource);
	}



}

Resource

import com.cn.core.Serializer;

public class Resource extends Serializer {

	private int gold;


	public int getGold() {
		return gold;
	}

	public void setGold(int gold) {
		this.gold = gold;
	}

	@Override
	protected void read() {
		this.gold = readInt();
	}

	@Override
	protected void write() {
		writeInt(gold);
	}

}

Test4

import java.util.Arrays;

public class Test4 {

    public static void main(String[] args) {

        Player player = new Player();
        player.setPlayerId(10001);
        player.setAge(22);
        player.getSkills().add(101);
        player.getResource().setGold(99999);

        byte[] bytes = player.getBytes();

        System.out.println(Arrays.toString(bytes));

        //==============================================

        Player player2 = new Player();
        player2.readFromBytes(bytes);
        System.out.println(player2.getPlayerId() + "   " + player2.getAge() + "     " + Arrays.toString(player2.getSkills().toArray()) + "   " + player2.getResource().getGold());

    }

}
chenshiying007
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java自定义序列化_Java自定义序列化行为解析
weixin_39653733的博客
02-12 278
正常情况下，一个类实现java序列化很简单，只需要implements Serializable接口即可，之后该类在跨jvm的传输过程中会遵照默认java序列化规则序列化和反序列化;不同jvm版本之间序列化方式稍有不同，但基本上都是兼容的。在某些特殊情况下，可能需要自定义序列化和反序列化的行为，看下面例子：Java代码classAbstractSerializeDemo{privateintx,...
【java基础】自定义序列化
高精尖发展
07-31 1617
源：https://www.cnblogs.com/-9527/p/5222715.html     偶滴小看法：对序列化、反序列化过程进行自定义或保证单一、一致性，java本身提供了一些方法或接口，使用时直接定义实现自己的逻辑，或实现接口 写自己的逻辑；    如果一个类里包含的某些实例变量是敏感信息，例如银行账户信息，这时不希望系统将该实例变量值进行实例化；或者某个实例变量的类型是不可序列...
实现自定义序列化和反序列化控制的5种方式
最新发布
码到三十五
11-14 3967
在 Jackson 中，你可以通过多种方式来实现自定义的序列化和反序列化控制。自定义 Serializer 和 Deserialize，使用 Mix-in Annotations，注解如 @JsonSerialize 和 @JsonDeserialize，自定义的模块或者处理器如 SimpleModule 或者 HandlerInstantiator，使用 JsonSerializerModifier 和 BeanSerializerModifie
2020-10-25
qq_32902741的博客
10-25 288
java序列化，看这篇就够了 一、序列化的含义、意义及使用场景 序列化：将对象写入到IO流中 反序列化：从IO流中恢复对象 意义：序列化机制允许将实现序列化的Java对象转换位字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。 使用场景：所有可在网络上传输的对象都必须是可序列化的，比如RMI（remote method invoke,即远程方法调用），传入的参数或返回的对象都是可序列化的，否则会出错；所有需要保.
Jackson自定义序列化
Remember_Z的博客
11-20 4103
Jackson自定义序列化
【springboot进阶】springboot集成fastjson（二）自定义序列化/反序列化
06-15 1万+
介绍fastjson2如何使用自定义序列化和反序列化，配合日常接触的场景举例代码中如何实现，如日期型转化为毫秒数、单位元转分等。
C#自定义序列化ISerializable的实现方法
09-03
ISerializable接口是.NET Framework提供的一种自定义序列化的方式，允许开发者精确控制对象的序列化和反序列化过程。下面我们将详细讲解如何在C#中实现自定义序列化，特别是通过ISerializable接口。 首先，让我们看...
c# 自定义序列化两种方法
04-07
在C#编程中，自定义序列化是一种将对象的状态转换为可存储或可传输的数据格式，然后能够将这些数据恢复为原始对象的过程。这在数据持久化、网络传输或者跨进程通信等场景中非常常见。本文将详细介绍两种C#中实现...
hbasesink 自定义序列化类
09-14
hbasesink 自定义序列化类 ，可实现自定义rowkey及去除字段两边索引，具体请看下代码。 hbasesink 自定义序列化类 ，可实现自定义rowkey及去除字段两边索引，具体请看下代码。
自定义序列化对象c#.docx
07-03
在C#编程中，自定义序列化对象是一个常见的需求，特别是在需要将对象的状态保存到内存、磁盘或网络传输时。内置的序列化引擎，如`BinaryFormatter`和`XmlSerializer`，虽然提供了方便的序列化功能，但它们在某些情况...
自定义的序列化
愿景.青城雪
08-26 512
需求1：统计手机号耗费的总上行流量、下行流量、总流量（序列化） 1）需求：统计每一个手机号耗费的总上行流量、下行流量、总流量 2）数据准备 3）分析 Map阶段： （1）读取一行数据，切分字段 （2）抽取手机号、上行流量、下行流量 （3）以手机号为key，bean对象为value输出，即context.write(手机号,bean); Reduce阶段： （1）累加上行流量和下行流量得到总流量。...
自定义序列化过程
我们的征途是星辰大海
12-28 2044
除了使用事件以外，还可以通过自定义序列化来完成这一过程。         自定义序列化只需要实现ISerializable接口就可以了。它位于using System.Runtime.Serialization;                SerializationInfo有点儿类似于BinaryWriter和BinaryReader，用于写入和读取对象的属性值。它主要包
序列化---自定义序列化
confirmAname的专栏
03-30 499
jackson中自定义处理序列化和反序列化
热门推荐
赶路人儿
01-20 1万+
对于一直用gson的人来说，如果单独用jackson，真是麻烦了，但还是得小结下了：  先来看下如何自定义把某个对象序列化为json:  先是对象：  Java代码   public class User {       public int id;       public String name;   }   public class Item {  
java 自定义序列化
pingnanlee的专栏
02-28 1170
如果采用java序列化的方式传输java对象，我觉得最好还是采用自定义序列化的方式来完成。下面就来看看如何利用readObject，writeObject，writeReplace，readResolve这4个私有方法来自定义序列化的过程。 1）第一个场景，我们希望在序列化的过程中改变那些被transient修饰的变量，class TestSer implements Serializable {
16、MapReduce的基本用法示例-自定义序列化、排序、分区、分组和topN
05-29
16、MapReduce的基本用法示例-自定义序列化、排序、分区、分组和topN 网址：https://blog.csdn.net/chenwewi520feng/article/details/130454036 本文介绍MapReduce常见的基本用法。 前提是hadoop环境可正常运行。 本文分为五个部分，即介绍自定义序列化、排序、分区、分组和topN。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值