Netty 学习笔记一、Hello Netty

package com.netty.hello; 
 
import com.netty.handler.TimeServerHandler; 
 
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; 
 
public class TimeServer { 
	public void bind(int port) throws Exception { 
		// 服务器线程组 用于网络事件的处理 一个用于服务器接收客户端的连接 
		// 另一个线程组用于处理SocketChannel的网络读写 
		EventLoopGroup bossGroup = new NioEventLoopGroup(); 
		EventLoopGroup workerGroup = new NioEventLoopGroup(); 
 
		try { 
			// NIO服务器端的辅助启动类 降低服务器开发难度 
			ServerBootstrap serverBootstrap = new ServerBootstrap(); 
			serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)// 类似NIO中serverSocketChannel 
					.option(ChannelOption.SO_BACKLOG, 1024)// 配置TCP参数 
					.childHandler(new ChildChannelHandler());// 最后绑定I/O事件的处理类 
 
			// 服务器启动后 绑定监听端口 同步等待成功 主要用于异步操作的通知回调 回调处理用的ChildChannelHandler 
			ChannelFuture f = serverBootstrap.bind(port).sync(); 
			System.out.println("timeServer启动"); 
			// 等待服务端监听端口关闭 
			f.channel().closeFuture().sync(); 
		} finally { 
			// 优雅退出 释放线程池资源 
			bossGroup.shutdownGracefully(); 
			workerGroup.shutdownGracefully(); 
			System.out.println("服务器优雅的释放了线程资源..."); 
		} 
	} 
 
	/** 
	 * 网络事件处理器(内部类) 
	 */ 
	private class ChildChannelHandler extends ChannelInitializer<SocketChannel> { 
		@Override 
		protected void initChannel(SocketChannel ch) throws Exception { 
			ch.pipeline().addLast(new TimeServerHandler()); 
		} 
 
	} 
 
	public static void main(String[] args) throws Exception { 
		// TODO Auto-generated method stub 
		int port = 8000; 
		new TimeServer().bind(port); 
	} 
 
}

• 创建ServerBootstrap实例来引导绑定和启动服务器
• 创建NioEventLoopGroup对象来处理事件，如接受新连接、接收数据、写数据等等
• 设置childHandler执行所有的连接请求
• 都设置完毕了，最后调用ServerBootstrap.bind(port) 方法来绑定服务器

服务器业务逻辑

package com.netty.handler; 
 
import java.util.Date; 
 
import io.netty.buffer.ByteBuf; 
import io.netty.buffer.Unpooled; 
import io.netty.channel.ChannelHandlerAdapter; 
import io.netty.channel.ChannelHandlerContext; 
 
/** 
 * server端网络IO事件处理 
 *  
 * @author zzg 
 * 
 */ 
public class TimeServerHandler extends ChannelHandlerAdapter { 
 
	@Override 
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
		// TODO Auto-generated method stub 
		ctx.close(); 
		System.out.println("服务器异常退出" + cause.getMessage()); 
	} 
 
	@Override 
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
		// TODO Auto-generated method stub 
		System.out.println("服务器读取到客户端请求..."); 
		ByteBuf buf = (ByteBuf) msg; 
		byte[] req = new byte[buf.readableBytes()]; 
		buf.readBytes(req); 
		String body = new String(req, "UTF-8"); 
		System.out.println("the time server receive order:" + body); 
		String curentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() 
				: "BAD ORDER"; 
		ByteBuf resp = Unpooled.copiedBuffer(curentTime.getBytes()); 
		ctx.write(resp); 
		System.out.println("服务器做出了响应"); 
	} 
 
	@Override 
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { 
		// TODO Auto-generated method stub 
		ctx.flush(); 
		System.out.println("服务器readComplete 响应完成"); 
	} 
 
} 

捕获异常

编写客户端源代码：

package com.netty.hello; 
 
import com.netty.handler.TimeClientHandler; 
 
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; 
 
public class TimeClient { 
	/** 
	 * 连接服务器 
	 *  
	 * @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 ChannelInitializer<SocketChannel>() { 
						@Override 
						protected void initChannel(SocketChannel ch) throws Exception { 
							ch.pipeline().addLast(new TimeClientHandler()); 
						} 
					}); 
			// 异步链接服务器 同步等待链接成功 
			ChannelFuture f = b.connect(host, port).sync(); 
			// 等待链接关闭 
			f.channel().closeFuture().sync(); 
 
		} finally { 
			group.shutdownGracefully(); 
			System.out.println("客户端优雅的释放了线程资源..."); 
		} 
 
	} 
 
	public static void main(String[] args) throws Exception { 
		// TODO Auto-generated method stub 
		new TimeClient().connect(8000, "127.0.0.1"); 
	} 
 
} 

package com.netty.handler; 
 
import io.netty.buffer.ByteBuf; 
import io.netty.buffer.Unpooled; 
import io.netty.channel.ChannelHandlerAdapter; 
import io.netty.channel.ChannelHandlerContext; 
 
import java.util.logging.Logger; 
/** 
 * Client 网络IO事件处理 
 * @author xwalker 
 * 
 */ 
public class TimeClientHandler extends ChannelHandlerAdapter { 
	private static final Logger logger=Logger.getLogger(TimeClientHandler.class.getName()); 
	private  ByteBuf firstMessage; 
	public TimeClientHandler(){ 
		byte[] req ="QUERY TIME ORDER".getBytes(); 
		firstMessage=Unpooled.buffer(req.length); 
		firstMessage.writeBytes(req); 
	} 
	@Override 
	public void channelActive(ChannelHandlerContext ctx) throws Exception { 
		ctx.writeAndFlush(firstMessage); 
		System.out.println("客户端active"); 
	} 
	 
	@Override 
	public void channelRead(ChannelHandlerContext ctx, Object msg) 
			throws Exception { 
		System.out.println("客户端收到服务器响应数据"); 
		ByteBuf buf=(ByteBuf) msg; 
		byte[] req=new byte[buf.readableBytes()]; 
		buf.readBytes(req); 
		String body=new String(req,"UTF-8"); 
		System.out.println("Now is:"+body); 
		 
	} 
	 
	@Override 
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { 
		ctx.flush(); 
		System.out.println("客户端收到服务器响应数据处理完成"); 
	} 
	 
	@Override 
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) 
			throws Exception { 
		logger.warning("Unexpected exception from downstream:"+cause.getMessage()); 
		ctx.close(); 
		System.out.println("客户端异常退出"); 
	} 
}