《序列化与自定义Request、Response编解码器》

「爱情、让人受尽委屈。」 2022-02-23 02:50 382阅读 0赞

### 《序列化与自定义Request、Response编解码器》 ###

*  序列化是如何实现的
 *   *  序列化三种底层实现方式
     *   *  使用JDK的ByteArrayOutputStream序列化(需要自己手写大小端转字节序列的函数)
         *  用NIO中的Bytebuf(不能自动扩容)
         *  使用Netty中的ChannelBuffer
     *  序列化对象
     *   *  使用继承Serializer抽象类
         *  采用Protobuf序列化框架
 *  序列化协议在编解码器中的应用
 *   *  如何自定义写一个编解码器应用在数据传输中
     *   *  先实现数据包
         *  Request的编解码器
         *   *  RequestEncoder
             *  RequestDecoder
         *  response编解码器
         *   *  ResponseEncoder
             *  ResponseDecoder
         *  测试自定义编解码器

# 序列化是如何实现的 #

对象的序列化主要有两种用途：

1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

2） 在网络上传送对象的字节序列。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。  
  当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。  
  **java序列化是java编解码技术中的一种**，不同的编解码的优缺点，参考之前的博客。[https://blog.csdn.net/weixin\_41262453/article/details/88980701][https_blog.csdn.net_weixin_41262453_article_details_88980701]

## 序列化三种底层实现方式 ##

### 使用JDK的ByteArrayOutputStream序列化(需要自己手写大小端转字节序列的函数) ###

ByteArrayOutputStream类**实现了将数据写入字节数组的输出流**。 **当数据写入缓冲区时，缓冲区会自动增长**。ByteArrayOutputStream.write(int b) 将指定的字节写入此字节数组输出流。 此方式需要自己手写大小端转字节序列的函数，麻烦。

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

运行结果：  
                ![在这里插入图片描述][20190406101503155.png]

### 用NIO中的Bytebuf(不能自动扩容) ###

使用NIO中的字节缓冲区类Bytebuf，提供了许多序列化方法。使用方便，但是在使用时要定义大小，不能自动扩容。

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

运行结果：  
           ![在这里插入图片描述][2019040610220181.png]

### 使用Netty中的ChannelBuffer ###

使用时需要导入Netty的jar包。

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

运行结果：  
          ![在这里插入图片描述][20190406102505489.png]

## 序列化对象 ##

### 使用继承Serializer抽象类 ###

Serializer底层的实现就是两个ChannelBuffer， writeBuffer和readBuffer。  
  把对象转换为字节序列的过程称为对象的序列化；把字节序列恢复为对象的过程称为对象的反序列化。需要序列化的两个类：Player 和Resource ，继承Serializer抽象类要做的事情就是重写write和read方法。

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

测试序列化对象：

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

运行结果：  
![在这里插入图片描述][20190406104038316.png]

### 采用Protobuf序列化框架 ###

Protobuf系列化操作参考https://blog.csdn.net/weixin\_41262453/article/details/88980701\#Google\_Protobuf\_451 ，将上面的player序列化，进行测试。  
  player.proto配置文件参考  
              ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70]  
序列化后得到的PlayerModule有1000多行就不放了，测试代码如下：

import java.util.Arrays;
    import com.proto.PlayerModule.PBPlayer;
    import com.proto.PlayerModule.PBPlayer.Builder;
    public class PB2Bytes { 
    	public static void main(String[] args) throws Exception { 
    		byte[] bytes = toBytes();
    		toPlayer(bytes);
    
    	}
    	/** * 序列化 */
    	public static byte[] toBytes(){ 
    		//获取一个PBPlayer的构造器
    		Builder builder = PlayerModule.PBPlayer.newBuilder();
    		//设置数据
    		builder.setPlayerId(101).setAge(20).setName("peter").addSkills(1001);
    		//构造出对象
    		PBPlayer player = builder.build();
    		//序列化成字节数组
    		byte[] byteArray = player.toByteArray();
    		
    		System.out.println(Arrays.toString(byteArray));
    		
    		return byteArray;
    	}	
    	/** * 反序列化 * @param bs * @throws Exception */
    	public static void toPlayer(byte[] bs) throws Exception{ 
    		
    		 PBPlayer player = PlayerModule.PBPlayer.parseFrom(bs);
    		 
    		 System.out.println("playerId:" + player.getPlayerId());
    		 System.out.println("age:" + player.getAge());
    		 System.out.println("name:" + player.getName());
    		 System.out.println("skills:" + (Arrays.toString(player.getSkillsList().toArray())));
    	}
    }

运行结果：  
        ![在这里插入图片描述][20190406111310123.png]

# 序列化协议在编解码器中的应用 #

此处提供了一个自定义的编解码器用于传输我们已经序列化的对象，可用于了解常见通信框架的编解码器底层序列化工作原理。

## 如何自定义写一个编解码器应用在数据传输中 ##

### 先实现数据包 ###

首先设计数据包的格式：

* 数据包格式
     * +——----——+——-----——+——----——+——----——+——-----——+
     * | 包头	| 模块号  | 命令号 |  长度  |   数据  |
     * +——----——+——-----——+——----——+——----——+——-----——+
     * </pre>
     * 包头4字节
     * 模块号2字节short
     * 命令号2字节short
     * 长度4字节(描述数据部分字节长度)

因此我们要定义一个包头，首先采用一个不常用的4字节数据作为包头：

public interface ConstantValue { 	
    	/** * 包头 */
    	public static final int FLAG = -32523523;
    
    }

其次定义请求，请求中包括请求模块、命令号、数据

public class Request { 	
    	/** * 请求模块 */
    	private short module;	
    	/** * 命令号 */
    	private short cmd;	
    	/** * 数据部分 */
    	private byte[] data;
    	public short getModule() { 
    		return module;
    	}
    	public void setModule(short module) { 
    		this.module = module;
    	}
    	public short getCmd() { 
    		return cmd;
    	}
    	public void setCmd(short cmd) { 
    		this.cmd = cmd;
    	}
    	public byte[] getData() { 
    		return data;
    	}
    	public void setData(byte[] data) { 
    		this.data = data;
    	}
    	public int getDataLength(){ 
    		if(data == null){ 
    			return 0;
    		}
    		return data.length;
    	}
    }

响应的有响应：Response

public class Response { 
    	/** * 请求模块 */
    	private short module;	
    	/** * 命令号 */
    	private short cmd;	
    	/** * 状态码 */
    	private int stateCode;	
    	/** * 数据部分 */
    	private byte[] data;
    	public short getModule() { 
    		return module;
    	}
    	public void setModule(short module) { 
    		this.module = module;
    	}
    	public short getCmd() { 
    		return cmd;
    	}
    	public void setCmd(short cmd) { 
    		this.cmd = cmd;
    	}
    	public int getStateCode() { 
    		return stateCode;
    	}
    	public void setStateCode(int stateCode) { 
    		this.stateCode = stateCode;
    	}
    	public byte[] getData() { 
    		return data;
    	}
    	public void setData(byte[] data) { 
    		this.data = data;
    	}
    	public int getDataLength(){ 
    		if(data == null){ 
    			return 0;
    		}
    		return data.length;
    	}
    }

返回的状态字：

public interface StateCode { 	
    	/** * 成功 */
    	public static int SUCCESS  = 0;
    	
    	/** * 失败 */
    	public static int FAIL  =  1;
    }

### Request的编解码器 ###

#### RequestEncoder ####

RequestEncoder首先需要继承Netty3.10.5中OneToOneEncoder，**RequestEncoder将请求Request对象实现序列化到ChannelBuffer** ，返回ChannelBuffer 缓存区buffer。

/** * 请求编码器 * <pre> * 数据包格式 * +——----——+——-----——+——----——+——----——+——-----——+ * | 包头 | 模块号 | 命令号 | 长度 | 数据 | * +——----——+——-----——+——----——+——----——+——-----——+ * </pre> * 包头4字节 * 模块号2字节short * 命令号2字节short * 长度4字节(描述数据部分字节长度) */
    public class RequestEncoder extends OneToOneEncoder{ 
    	@Override
    	protected Object encode(ChannelHandlerContext context, Channel channel, Object rs) throws Exception { 
    		Request request = (Request)(rs);		
    		ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
    		//包头
    		buffer.writeInt(ConstantValue.FLAG);
    		//module
    		buffer.writeShort(request.getModule());
    		//cmd
    		buffer.writeShort(request.getCmd());
    		//长度
    		buffer.writeInt(request.getDataLength());
    		//data
    		if(request.getData() != null){ 
    			buffer.writeBytes(request.getData());
    		}		
    		return buffer;
    	}
    }

#### RequestDecoder ####

RequestDecoder同样要继承Netty3.10.5中FrameDecoder，Request解码器要做的事情就是从接收到的字节流缓存区读取出数据，进行判断，若包头正确，可读长度大于基本长度，则将字节流依次读取出Request类的各个成员变量，返回Request对象。

/** * 请求解码器 * <pre> * 数据包格式 * +——----——+——-----——+——----——+——----——+——-----——+ * | 包头 | 模块号 | 命令号 | 长度 | 数据 | * +——----——+——-----——+——----——+——----——+——-----——+ * </pre> * 包头4字节 * 模块号2字节short * 命令号2字节short * 长度4字节(描述数据部分字节长度) * * */
    public class RequestDecoder extends FrameDecoder{ 	
    	/** * 数据包基本长度 */
    	public static int BASE_LENTH = 4 + 2 + 2 + 4;
    	@Override
    	protected Object decode(ChannelHandlerContext arg0, Channel arg1, ChannelBuffer buffer) throws Exception { 		
    		//可读长度必须大于基本长度
    		if(buffer.readableBytes() >= BASE_LENTH){ 
    			//防止socket字节流攻击
    			if(buffer.readableBytes() > 2048){ 
    				buffer.skipBytes(buffer.readableBytes());
    			}			
    			//记录包头开始的index
    			int beginReader;
    			
    			while(true){ 
    				beginReader = buffer.readerIndex();
    				buffer.markReaderIndex();
    				if(buffer.readInt() == ConstantValue.FLAG){ 
    					break;
    				}				
    				//未读到包头，略过一个字节
    				buffer.resetReaderIndex();
    				buffer.readByte();
    				
    				//长度又变得不满足
    				if(buffer.readableBytes() < BASE_LENTH){ 
    					return null;
    				}
    			}			
    			//模块号
    			short module = buffer.readShort();
    			//命令号
    			short cmd = buffer.readShort();
    			//长度
    			int length = buffer.readInt();
    			
    			//判断请求数据包数据是否到齐
    			if(buffer.readableBytes() < length){ 
    				//还原读指针
    				buffer.readerIndex(beginReader);
    				return null;
    			}			
    			//读取data数据
    			byte[] data = new byte[length];
    			buffer.readBytes(data);			
    			Request request = new Request();
    			request.setModule(module);
    			request.setCmd(cmd);
    			request.setData(data);			
    			//继续往下传递 
    			return request;			
    		}
    		//数据包不完整，需要等待后面的包来
    		return null;
    	}
    }

### response编解码器 ###

#### ResponseEncoder ####

ResponseEncoder与RequestEncoder实现原理类似。

/** * 请求编码器 * <pre> * 数据包格式 * +——----——+——-----——+——----——+——----——+——-----——+——-----——+ * | 包头 | 模块号 | 命令号 | 状态码 | 长度 | 数据 | * +——----——+——-----——+——----——+——----——+——-----——+——-----——+ * </pre> * 包头4字节 * 模块号2字节short * 命令号2字节short * 长度4字节(描述数据部分字节长度) */
    public class ResponseEncoder extends OneToOneEncoder{ 
    	@Override
    	protected Object encode(ChannelHandlerContext context, Channel channel, Object rs) throws Exception { 
    		Response response = (Response)(rs);
    		
    		ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
    		//包头
    		buffer.writeInt(ConstantValue.FLAG);
    		//module
    		buffer.writeShort(response.getModule());
    		//cmd
    		buffer.writeShort(response.getCmd());
    		//状态码
    		buffer.writeInt(response.getStateCode());
    		//长度
    		buffer.writeInt(response.getDataLength());
    		//data
    		if(response.getData() != null){ 
    			buffer.writeBytes(response.getData());
    		}	
    		return buffer;
    	}
    }

#### ResponseDecoder ####

ResponseDecoder相比RequestDecoder，还会多解析一个状态码。

/** * response解码器 * <pre> * 数据包格式 * +——----——+——-----——+——----——+——----——+——-----——+——-----——+ * | 包头 | 模块号 | 命令号 | 状态码 | 长度 | 数据 | * +——----——+——-----——+——----——+——----——+——-----——+——-----——+ * </pre> * 包头4字节 * 模块号2字节short * 命令号2字节short * 长度4字节(描述数据部分字节长度) */
    public class ResponseDecoder extends FrameDecoder{ 	
    	/** * 数据包基本长度 */
    	public static int BASE_LENTH = 4 + 2 + 2 + 4;
    	@Override
    	protected Object decode(ChannelHandlerContext arg0, Channel arg1, ChannelBuffer buffer) throws Exception { 		
    		//可读长度必须大于基本长度
    		if(buffer.readableBytes() >= BASE_LENTH){ 
    		
    			//记录包头开始的index
    			int beginReader = buffer.readerIndex();
    			
    			while(true){ 
    				if(buffer.readInt() == ConstantValue.FLAG){ 
    					break;
    				}
    			}
    			//模块号
    			short module = buffer.readShort();
    			//命令号
    			short cmd = buffer.readShort();
    			//状态码
    			int stateCode = buffer.readInt();
    			//长度
    			int length = buffer.readInt();
    			
    			if(buffer.readableBytes() < length){ 
    				//还原读指针
    				buffer.readerIndex(beginReader);
    				return null;
    			}			
    			byte[] data = new byte[length];
    			buffer.readBytes(data);			
    			Response response = new Response();
    			response.setModule(module);
    			response.setCmd(cmd);
    			response.setStateCode(stateCode);
    			response.setData(data);			
    			//继续往下传递 
    			return response;			
    		}
    		//数据包不完整，需要等待后面的包来
    		return null;
    	}
    }

### 测试自定义编解码器 ###

发送的对象模型：FightRequest

public class FightRequest extends Serializer{ 	
    	/** * 副本id */
    	private int fubenId;	
    	/** * 次数 */
    	private int count;
    
    	public int getFubenId() { 
    		return fubenId;
    	}
    	public void setFubenId(int fubenId) { 
    		this.fubenId = fubenId;
    	}
    	public int getCount() { 
    		return count;
    	}
    	public void setCount(int count) { 
    		this.count = count;
    	}
    	@Override
    	protected void read() { 
    		this.fubenId = readInt();
    		this.count = readInt();
    	}
    	@Override
    	protected void write() { 
    		writeInt(fubenId);
    		writeInt(count);
    	}
    }

返回的对象模型：

public class FightResponse 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);
    	}
    }

测试代码：服务端Client和HiHandler ,由于Request和Response的Encoder和Decoder都是继承了Netty中的类进行设计的，所以可以直接pipeline.addLast，因此兼容原有的Netty框架。并且在channel.write(request)时也是直接write request对象，request对象中的data就是需要发送的fightRequest模型的序列化字节码。

public class Client { 
    	public static void main(String[] args) throws InterruptedException { 		
    		//服务类
    		ClientBootstrap bootstrap = new  ClientBootstrap();
    		
    		//线程池
    		ExecutorService boss = Executors.newCachedThreadPool();
    		ExecutorService worker = Executors.newCachedThreadPool();		
    		//socket工厂
    		bootstrap.setFactory(new NioClientSocketChannelFactory(boss, worker));
    		
    		//管道工厂
    		bootstrap.setPipelineFactory(new ChannelPipelineFactory() { 			
    			@Override
    			public ChannelPipeline getPipeline() throws Exception { 
    				ChannelPipeline pipeline = Channels.pipeline();
    				pipeline.addLast("decoder", new ResponseDecoder());
    				pipeline.addLast("encoder", new RequestEncoder());
    				pipeline.addLast("hiHandler", new HiHandler());
    				return pipeline;
    			}
    		});		
    		//连接服务端
    		ChannelFuture connect = bootstrap.connect(new InetSocketAddress("127.0.0.1", 30000));
    		Channel channel = connect.sync().getChannel();		
    		System.out.println("client start");		
    		Scanner scanner = new Scanner(System.in);
    		while(true){ 
    			System.out.println("请输入");
    			int fubenId = Integer.parseInt(scanner.nextLine());
    			int count = Integer.parseInt(scanner.nextLine());
    			
    			FightRequest fightRequest = new FightRequest();
    			fightRequest.setFubenId(fubenId);
    			fightRequest.setCount(count);
    			
    			Request request = new Request();
    			request.setModule((short) 1);
    			request.setCmd((short) 1);
    			request.setData(fightRequest.getBytes());
    			//发送请求
    			channel.write(request);
    		}
    	}
    }
    
    public class HiHandler extends SimpleChannelHandler { 
    	/** * 接收消息 */
    	@Override
    	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { 
    			Response message = (Response)e.getMessage();
    
    			if(message.getModule() == 1){ 
    				
    				if(message.getCmd() == 1){ 
    					FightResponse fightResponse = new FightResponse();
    					fightResponse.readFromBytes(message.getData());
    					
    					System.out.println("gold:" + fightResponse.getGold());
    					
    				}else if(message.getCmd() == 2){ 
    					
    				}
    				
    			}else if (message.getModule() == 1){ 
    				
    				
    			}
    	}
    	/** * 捕获异常 */
    	@Override
    	public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { 
    		System.out.println("exceptionCaught");
    		super.exceptionCaught(ctx, e);
    	}
    	/** * 新连接 */
    	@Override
    	public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { 
    		System.out.println("channelConnected");
    		super.channelConnected(ctx, e);
    	}
    	/** * 必须是链接已经建立，关闭通道的时候才会触发 */
    	@Override
    	public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { 
    		System.out.println("channelDisconnected");
    		super.channelDisconnected(ctx, e);
    	}
    	/** * channel关闭的时候触发 */
    	@Override
    	public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { 
    		System.out.println("channelClosed");
    		super.channelClosed(ctx, e);
    	}
    }

客户端Server 和HelloHandler：messageReceived中接收的消息此时就是Request对象，从Request对象的data取出的数据是序列化的fightRequest 字节码，要再经过该类中的readFromBytes方法转换，才能完全转成发送过来的fightRequest 。

public class Server { 
    	public static void main(String[] args) { 
    		//服务类
    		ServerBootstrap bootstrap = new ServerBootstrap();		
    		//boss线程监听端口，worker线程负责数据读写
    		ExecutorService boss = Executors.newCachedThreadPool();
    		ExecutorService worker = Executors.newCachedThreadPool();		
    		//设置niosocket工厂
    		bootstrap.setFactory(new NioServerSocketChannelFactory(boss, worker));		
    		//设置管道的工厂
    		bootstrap.setPipelineFactory(new ChannelPipelineFactory() { 
    			
    			@Override
    			public ChannelPipeline getPipeline() throws Exception { 
    
    				ChannelPipeline pipeline = Channels.pipeline();
    				pipeline.addLast("decoder", new RequestDecoder());
    				pipeline.addLast("encoder", new ResponseEncoder());
    				pipeline.addLast("helloHandler", new HelloHandler());
    				return pipeline;
    			}
    		});		
    		bootstrap.bind(new InetSocketAddress(30000));		
    		System.out.println("start!!!");		
    	}
    }
    
    public class HelloHandler extends SimpleChannelHandler { 
    
    	/** * 接收消息 */
    	@Override
    	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { 
    		Request message = (Request)e.getMessage();		
    		if(message.getModule() == 1){ 
    				if(message.getCmd() == 1){ 			
    				FightRequest fightRequest = new FightRequest();
    				fightRequest.readFromBytes(message.getData());
    				
    				System.out.println("fubenId:" +fightRequest.getFubenId() + " " + "count:" + fightRequest.getCount());
    				
    				//回写数据
    				FightResponse fightResponse = new FightResponse();
    				fightResponse.setGold(9999);
    				
    				Response response = new Response();
    				response.setModule((short) 1);
    				response.setCmd((short) 1);
    				response.setStateCode(StateCode.SUCCESS);
    				response.setData(fightResponse.getBytes());
    				ctx.getChannel().write(response);
    			}else if(message.getCmd() == 2){ 				
    			}			
    		}else if (message.getModule() == 1){ 
    						
    		}
    	}
    	/** * 捕获异常 */
    	@Override
    	public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { 
    		System.out.println("exceptionCaught");
    		super.exceptionCaught(ctx, e);
    	}
    	/** * 新连接 */
    	@Override
    	public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { 
    		System.out.println("channelConnected");
    		super.channelConnected(ctx, e);
    	}
    	/** * 必须是链接已经建立，关闭通道的时候才会触发 */
    	@Override
    	public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { 
    		System.out.println("channelDisconnected");
    		super.channelDisconnected(ctx, e);
    	}
    	/** * channel关闭的时候触发 */
    	@Override
    	public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { 
    		System.out.println("channelClosed");
    		super.channelClosed(ctx, e);
    	}
    }

运行测试：  
              ![在这里插入图片描述][20190406151627332.png]  
服务器端：  
              ![在这里插入图片描述][20190406151641471.png]

[https_blog.csdn.net_weixin_41262453_article_details_88980701]: https://blog.csdn.net/weixin_41262453/article/details/88980701
[20190406101503155.png]: /images/20220223/8b7294109c88473fa5f1cfb4c9403102.png
[2019040610220181.png]: /images/20220223/ed110a407d274c7382e2a6f186f94505.png
[20190406102505489.png]: /images/20220223/c28f03e56ac84390b6217dd05dbb0e13.png
[20190406104038316.png]: /images/20220223/09736fb01a944df797621255cb6818dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70]: /images/20220223/0dbad2ab3048454db91c43070108787c.png
[20190406111310123.png]: /images/20220223/a094d3a9ad2e440181aa74df235f4f82.png
[20190406151627332.png]: /images/20220223/87379547166744c8828116bc7886ed39.png
[20190406151641471.png]: /images/20220223/8eb0cebed53e40f9820f747c6e1ab7ba.png