Netty之传输POJO(使用Java自带的序列化方式)

原创 2016年12月15日 17:02:50

1、使用Netty传输POJO对象,重点在于对象的序列化。序列化的对象通过TCP进行网络传输,结合Netty提供的对象编解码器,可以做到远程传输对象。首先Java需要序列化的对象,需要实现java.io.Serializable接口.

2、工程目录

       2.1 项目的目录结构

      

        2.2  关于Request和Response的讲解

               Request是对于,客户端向服务端的请求信息的封装;Response是对于,服务端向客户端响应信息的封装。

3、使用Netty提供的对象编解码器

        3.1 服务端编解码器的配置

             

        3.2 客户端编解码器的配置

             

        3.3 加入对象编解码后,可以直接发送对象

          

4、服务端代码

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public class Server {

	public Server() {
	}

	public void bind(int port) throws Exception {
		// 配置NIO线程组
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			// 服务器辅助启动类配置
			ServerBootstrap b = new ServerBootstrap();
			b.group(bossGroup, workerGroup)
					.channel(NioServerSocketChannel.class)
					.handler(new LoggingHandler(LogLevel.INFO))
					.childHandler(new ChildChannelHandler())//
					.option(ChannelOption.SO_BACKLOG, 1024) // 设置tcp缓冲区 // (5)
					.childOption(ChannelOption.SO_KEEPALIVE, true); // (6)
			// 绑定端口 同步等待绑定成功
			ChannelFuture f = b.bind(port).sync(); // (7)
			// 等到服务端监听端口关闭
			f.channel().closeFuture().sync();
		} finally {
			// 优雅释放线程资源
			workerGroup.shutdownGracefully();
			bossGroup.shutdownGracefully();
		}
	}

	/**
	 * 网络事件处理器
	 */
	private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
		@Override
		protected void initChannel(SocketChannel ch) throws Exception {
			// 添加对象解码器 负责对序列化POJO对象进行解码 设置对象序列化最大长度为1M 防止内存溢出
			// 设置线程安全的WeakReferenceMap对类加载器进行缓存 支持多线程并发访问 防止内存溢出
			ch.pipeline().addLast(
					new ObjectDecoder(1024 * 1024, ClassResolvers
							.weakCachingConcurrentResolver(this.getClass()
									.getClassLoader())));
			// 添加对象编码器 在服务器对外发送消息的时候自动将实现序列化的POJO对象编码
			ch.pipeline().addLast(new ObjectEncoder());
			// 处理网络IO
			ch.pipeline().addLast(new ServerHandler());
		}
	}

	public static void main(String[] args) throws Exception {
		new Server().bind(9999);
	}
}
5、服务端处理器代码

import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

public class ServerHandler extends ChannelHandlerAdapter {
	// 用于获取客户端发送的信息
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		// 用于获取客户端发来的数据信息
		Request body = (Request) msg;
		System.out.println("Server接受的客户端的信息 :" + body.toString());

		// 会写数据给客户端
		Response response = new Response(Integer.parseInt(body.getUrl()),
				"xiaoming");
		// 当服务端完成写操作后,关闭与客户端的连接
		ctx.writeAndFlush(response);
		// .addListener(ChannelFutureListener.CLOSE);

		// 当有写操作时,不需要手动释放msg的引用
		// 当只有读操作时,才需要手动释放msg的引用
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		// cause.printStackTrace();
		ctx.close();
	}
}
6、客户端代码

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

public class Client {

	/**
	 * 连接服务器
	 * 
	 * @param port
	 * @param host
	 * @throws Exception
	 */
	public void connect(int port, String host) throws Exception {
		// 配置客户端NIO线程组
		EventLoopGroup group = new NioEventLoopGroup();
		try {
			// 客户端辅助启动类 对客户端配置
			Bootstrap b = new Bootstrap();
			b.group(group)//
					.channel(NioSocketChannel.class)//
					.option(ChannelOption.TCP_NODELAY, true)//
					.handler(new MyChannelHandler());//
			// 异步链接服务器 同步等待链接成功
			ChannelFuture f = b.connect(host, port).sync();

			// 等待链接关闭
			f.channel().closeFuture().sync();

		} finally {
			group.shutdownGracefully();
			System.out.println("客户端优雅的释放了线程资源...");
		}

	}

	/**
	 * 网络事件处理器
	 */
	private class MyChannelHandler extends ChannelInitializer<SocketChannel> {
		@Override
		protected void initChannel(SocketChannel ch) throws Exception {
			// 添加自定义的编码器和解码器
			// 添加POJO对象解码器 禁止缓存类加载器
			ch.pipeline().addLast(
					new ObjectDecoder(1024, ClassResolvers.cacheDisabled(this
							.getClass().getClassLoader())));
			// 设置发送消息编码器
			ch.pipeline().addLast(new ObjectEncoder());
			// 处理网络IO
			ch.pipeline().addLast(new ClientHandler());// 处理网络IO
		}

	}

	public static void main(String[] args) throws Exception {
		new Client().connect(9999, "127.0.0.1");

	}

}
7、客户端处理器代码

import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.ReferenceCountUtil;

//用于读取客户端发来的信息
public class ClientHandler extends ChannelHandlerAdapter {

	// 客户端与服务端,连接成功的售后
	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		// 发送消息
		Request request1 = new Request("666");
		Request request2 = new Request("777");
		Request request3 = new Request("888");
		ctx.writeAndFlush(request1);
		ctx.writeAndFlush(request2);
		Thread.sleep(2000);
		ctx.writeAndFlush(request3);
	}

	// 只是读数据,没有写数据的话
	// 需要自己手动的释放的消息
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		try {
			Response response = (Response) msg;
			System.out.println(response);

		} finally {
			ReferenceCountUtil.release(msg);
		}
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		ctx.close();
	}

}
8、Request请求信息(要实现Serializable接口)

import java.io.Serializable;

public class Request implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = -7033707301911915196L;
	private String url;

	public Request() {
	}

	public Request(String url) {
		this.url = url;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

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

}
9、Response请求信息(要实现Serializable接口)

import java.io.Serializable;

public class Response implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = -6236340795725143988L;
	private int age;
	private String name;

	public Response() {
	}

	public Response(int age, String name) {
		this.age = age;
		this.name = name;
	}

	public int getAge() {
		return age;
	}

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

	public String getName() {
		return name;
	}

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

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

}


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Netty5入门学习笔记004-使用Netty传输POJO对象

传输POJO对象,重点在于对象的序列化,序列化后的对象可以通过TCP流进行网络传输,结合Netty提供的对象编解码器,可以做到远程传输对象。 下面我们来看一个例子:模拟订票 首先Java序列化的P...

Netty 学习笔记 三 使用Pojo代替Bytebuf

本节的客户端代码结构为: package io.netty.example.time; import io.netty.bootstrap.Bootstrap; import io.net...
  • xundh
  • xundh
  • 2015-05-21 15:14
  • 2018

Netty之解决TCP粘包拆包(自定义协议)

1、什么是粘包/拆包        一般所谓的TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据。TCP通讯为何存在粘包呢?主要原因是TCP是以流的方式来处理数据,再加上网络上MTU的往...

Netty之解决TCP粘包拆包(自定义协议)

1、什么是粘包/拆包        一般所谓的TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据。TCP通讯为何存在粘包呢?主要原因是TCP是以流的方式来处理数据,再加上网络上MTU的往往小...

Jsp中使用return时应注意

800x600 Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE

Protobuf3语言指南

定义一个消息类型 指定字段类型分配标识号指定字段规则添加更多消息类型添加注释保留标识符(Reserved)从.proto文件生成了什么? 标量数值类型默认值枚举使用其他消息类型 导入定义使用p...

protocol buffer从0学起(一)

其实前面的前面的一篇文章写过关于proto buffer的。但是不够详细,现在从最基本的开始写起。关于proto buffer就不多做介绍了。直接进入主题,写再多的理论语言大家也不一定能懂也,最好的方...

Protobuf3 系列三 更新Message类型

如果已经存在的Message类型不能满足要求,比如我们要在Message格式中需要新增一个额外字段,但是我们仍然希望用旧的代码处理新的Message格式。对于这种情况,Protobuf3的有着非常好的...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)