一，服务端
**
* 测试Netty类库：服务端代码
* Created by LiuHuiChao on 2016/10/24.
*/
public class NettyServerTest {
private int port;
public NettyServerTest(int port){
this.port=port;
}
/**
* EventLoopGroup 是用来处理I/O操作的多线程事件循环器，
* Netty提供了许多不同的EventLoopGroup的实现用来处理不同传输协议。
*
*
* @throws Exception
*/
public void run() throws Exception{
//一旦 boss 接收到连接，就会把连接信息注册到worker上面
EventLoopGroup bossGroup=new NioEventLoopGroup();//用来接收进来的连接
EventLoopGroup workerGroup=new NioEventLoopGroup();//用来处理已经被接收的连接
System.out.println("准备运行端口："+port);
try{
//ServerBootstrap是一个启动NIO服务的辅助启动类，可以在这个服务中直接使用CChannel
ServerBootstrap serverBootstrap=new ServerBootstrap();
serverBootstrap=serverBootstrap.group(bossGroup,workerGroup);//这一步是必须的
serverBootstrap=serverBootstrap.channel(NioServerSocketChannel.class);
/*
* 这里的事件处理类经常会被用来处理一个最近的已经接收的Channel。
* ChannelInitializer是一个特殊的处理类，
* 他的目的是帮助使用者配置一个新的Channel。
* 也许你想通过增加一些处理类比如NettyServerHandler来配置一个新的Channel
* 或者其对应的ChannelPipeline来实现你的网络程序。
* 当你的程序变的复杂时，可能你会增加更多的处理类到pipline上，
* 然后提取这些匿名类到最顶层的类上。
*/
serverBootstrap=serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
//socketChannel.pipeline().addLast(new DiscardServerHandler());
socketChannel.pipeline().addLast(new TimeServerHandler());
}
});
/**
* 可以设置这里指定的通道实现配置参数
* 我们正在写一个TCP/IP的服务端
* 因此我们被允许设置socket的参数选项比如tcpNoDelay,keepAlive
*/
serverBootstrap=serverBootstrap.option(ChannelOption.SO_BACKLOG,128);
serverBootstrap=serverBootstrap.childOption(ChannelOption.SO_KEEPALIVE,true);
/**
* 绑定端口并启动区接收进来的连接
*/
ChannelFuture f=serverBootstrap.bind(port).sync();
f.channel().closeFuture().sync();//这里会一直等待，知道socket被关闭
}catch (Exception e){
}finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
int port;
if(args.length>0){
port=Integer.parseInt(args[0]);
}else{
port=8088;
}
new NettyServerTest(port).run();
}
}
/**
* Created by LiuHuiChao on 2016/10/24.
*/
public class TimeServerHandler extends ChannelHandlerAdapter {
/**
* 为了发送一个新的消息，我们需要分配一个包含这个消息的新的缓冲。
* 因为我们需要写入一个32位的整数，因此我们需要一个至少有4个字节的ByteBuf。
* 通过ChannelHandlerContext.alloc()得到一个当前的ByteBufAllocator，
* 然后分配一个新的缓冲。
*/
@Override
public void channelActive(final ChannelHandlerContext ctx) throws Exception {
final ByteBuf time=ctx.alloc().buffer(4);
time.writeInt((int) (System.currentTimeMillis() / 1000L + 2208988800L));
/***
* 和往常一样我们需要编写一个构建好的消息
* 。但是等一等，flip在哪？难道我们使用NIO发送消息时不是调用java.nio.ByteBuffer.flip()吗？
* ByteBuf之所以没有这个方法因为有两个指针，
* 一个对应读操作一个对应写操作。
* 当你向ByteBuf里写入数据的时候写指针的索引就会增加，
* 同时读指针的索引没有变化。
* 读指针索引和写指针索引分别代表了消息的开始和结束。
* 比较起来，NIO缓冲并没有提供一种简洁的方式来计算出消息内容的开始和结尾，
* 除非你调用flip方法。
* 当你忘记调用flip方法而引起没有数据或者错误数据被发送时，
* 你会陷入困境。这样的一个错误不会发生在Netty上，
* 因为我们对于不同的操作类型有不同的指针。
* 你会发现这样的使用方法会让你过程变得更加的容易，
* 因为你已经习惯一种没有使用flip的方式。
* 另外一个点需要注意的是ChannelHandlerContext.write()(和writeAndFlush())方法会返回一个ChannelFuture对象，
* 一个ChannelFuture代表了一个还没有发生的I/O操作。
* 这意味着任何一个请求操作都不会马上被执行，
* 因为在Netty里所有的操作都是异步的。
* 因此你需要在write()方法返回的ChannelFuture完成后调用close()方法，
* 然后当他的写操作已经完成他会通知他的监听者。
*/
final ChannelFuture f=ctx.writeAndFlush(time);
/**
* 当一个写请求已经完成是如何通知到我们？
* 这个只需要简单地在返回的ChannelFuture上增加一个ChannelFutureListener。
* 这里我们构建了一个匿名的ChannelFutureListener类用来在操作完成时关闭Channel。
*/
f.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture channelFuture) throws Exception {
assert f==channelFuture;
ctx.close();//close方法也可能不会里面关闭，会返回一个ChannelFuture
}
});
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
二，客户端
/**
* Created by LiuHuiChao on 2016/10/24.
*/
public class TimeClient {
public static void main(String[] args) throws Exception {
String host="127.0.0.1";
int port=8088;
EventLoopGroup workerGroup=new NioEventLoopGroup();
try{
/**
* 如果只指定了一个EventLoopGroup，
* 那它就会作为boss线程，也会作为worker线程
* 尽管客户端不需要boss线程
*/
Bootstrap b=new Bootstrap();
b.group(workerGroup);
/**
* 代替NioServerSocketChannel的是NioSocketChannel，这个类在客户端channel被创建时候调用
*/
b.channel(NioSocketChannel.class);
b.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new TimeClientHandler());
}
});
ChannelFuture f=b.connect(host,port).sync();//用connect方法替代bind方法
f.channel().closeFuture().sync();//等到运行结束，关闭
}finally {
workerGroup.shutdownGracefully();
}
}
}
/**
* Created by LiuHuiChao on 2016/10/24.
*/
public class TimeClientHandler extends ChannelHandlerAdapter {
private ByteBuf buf;
/**
* 开始处理的时候触发
* @param ctx
* @throws Exception
*/
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
buf=ctx.alloc().buffer(4);//分配4个字节的空间给ByteBuf
}
/**
* 处理结束的时候触发
* @param ctx
* @throws Exception
*/
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
buf.release();//释放ByteBuf的空间
buf=null;
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf m=(ByteBuf) msg;
buf.writeBytes(m);
m.release();
if(buf.readableBytes()>=4){
long currentTimeMillis=(buf.readInt() - 2208988800L) * 1000L;
System.out.println(new Date(currentTimeMillis));
ctx.close();
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
(⊙o⊙)…先跑跑。。有点儿困了
