Netty自定义序列化协议-蒲公英云

自定义序列化协议

序列化的目的就是想对象转化成字节数组byteArray

阶段一
使用流的形式

public class Test{
public static void main(String[] args) throws IOException {
        int id = 100;
        int age = 22;
        ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
        arrayOutputStream.write(int2bytes(id));//序列化
        arrayOutputStream.write(int2bytes(age));    
        byte[] byteArray = arrayOutputStream.toByteArray();
        //==================通过socket传输字节序列=================================
        ByteArrayInputStream arrayInputStream = new ByteArrayInputStream(byteArray);
        byte[] idBytes = new byte[4];//读取4个字节
        arrayInputStream.read(idBytes);
            System.out.println("id:" + bytes2int(idBytes));//反序列化
        byte[] ageBytes = new byte[4];
        arrayInputStream.read(ageBytes);
        System.out.println("age:" + bytes2int(ageBytes));        
    }
/*
* int 类型占4个字节  采用大端字节序列（高位在前面）
*/
//序列化
public static byte[] int2byte(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;
}
//反序列化
pulic static int byte2int(byte[]bytes)
{
   return (bytes[0] << 3*8) |
                (bytes[1] << 2*8) |
                (bytes[2] << 1*8) |
                (bytes[3] << 0*8);}
}

阶段二
使用byteBuff 完成序列化部分

可以对多种类型进行序列化、反序列化操作
byteBuff要声明大小，且不能自动拓展

****OutputStream、***InputStream具有自动扩容的方法

public static void main(String[] args) throws IOException {

        int id = 100;
        nt age = 22;            
          ByteBuffer buffer = ByteBuffer.allocate(8);
        buffer.putInt(id);
        buffer.putInt(age);
        byte[] byteArray = buffer.array();
    //==================通过socket传输字节序列=================================       
       ByteBuffer buffer2 = ByteBuffer.wrap(array);
       System.out.println("id:"+buffer2.getInt());
      System.out.println("age:"+buffer2.getInt());

阶段三
使用Netty ChannelBuffer

可以自动扩容，并且可以对多种整型数据类型进行序列化、反序列化操作

不能对操作String

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));
    "abc".getBytes();    
    //================================================
    ChannelBuffer wrappedBuffer = ChannelBuffers.wrappedBuffer(bytes);
    System.out.println(wrappedBuffer.readInt());
    System.out.println(wrappedBuffer.readDouble());
}

阶段四
Netty ChannelBuffer对进行集成处理

在阶段三的基础上支持String、List等数据类型
实现对类对象的序列化
继承Serializer抽象类（借助Netty自定义的序列化规则）
重写read()、write()时属性顺序要一致

如果属性是对象的话（如，Resource），同样也要继承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);
}

}

使用案例

Player、Resource对象继承了Serializer抽象类
序列化：player.getBytes()

反序列：player2.readFromBytes(bytes)

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();//内部调用write()进行序列化        
        System.out.println(Arrays.toString(bytes));
        //==============================================
        Player player2 = new Player();
        player2.readFromBytes(bytes);//内部调用read()进行反序列化
        System.out.println(player2.getPlayerId() + "   "+player2.getAge() + "     "+ Arrays.toString(player2.getSkills().toArray())+"   " +player2.getResource().getGold());
    }

阶段5

Protocol Buff 对阶段四的进一步优化

在客户端和服务器都配置序列化配置文件
ProtocolBuff内部通过位运算，可以避免Java本身数据类型新建造成空间的浪费，从而更加高效的完成序列化

//序列化
public static byte[] toBytes() throws IOException{
//获取一个user的构造器
Builder builder =PlayerModule.user.newBuidler();
//设置数据
builder.setId(10).setAge(18).setName(“luo”).addSkills(1001);
//构造对象
User user =builder.build();
//序列化成字节数组
byte[] byteArray= user.toByteArray();
return byteArray;
}

//反序列化
public static void toPlayer(byte[] bs) throws Exception{
        ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(bs));
        User player = (User)inputStream.readObject();    
        //打印
         System.out.println("Id:" + player.getPlayerId());
         System.out.println("age:" + player.getAge());
         System.out.println("name:" + player.getName());
         System.out.println("skills:" + (Arrays.toString(player.getSkills().toArray())));
    }