利用netty简单实现聊天室

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>5.0.0.Alpha1</version>
        </dependency>

public class NettyServer {
    public static void main(String[] args) {
         EventLoopGroup bossGroup = new NioEventLoopGroup();
         EventLoopGroup workGroup = new NioEventLoopGroup();
         ServerBootstrap bootStrap = new ServerBootstrap();
            ChannelFuture cf;
            bootStrap.group(bossGroup,workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline p = ch.pipeline();
                            p.addLast(\"decoder\", new StringDecoder());//需要编解码，否则无法解析
                            p.addLast(\"encoder\", new StringEncoder());
                            p.addLast(new NettyServerHandler());
                        }
                    });

            try {
                cf =  bootStrap.bind(8099).sync();//监听8099端口
                System.out.println(\"8099:binded...\");
                cf.channel().closeFuture().sync();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                bossGroup.shutdownGracefully();
                workGroup.shutdownGracefully();
            }
    }
}

public class NettyClient {
    public static void main(String[] args) throws Exception {
        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
                        public void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline p = ch.pipeline();
                            p.addLast(\"decoder\", new StringDecoder());
                            p.addLast(\"encoder\", new StringEncoder());
                            p.addLast(new ClientHandler());
                            p.addLast(new ClientHandlerBak());
                        }
                    });

            ChannelFuture future = b.connect(\"127.0.0.1\", 8099).sync();
            future.channel().writeAndFlush(\"这里是客户端，请求连接服务端！\");
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }

    }
}

public class NettyServerHandler extends ChannelHandlerAdapter {

    //有客户端连接时触发
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(\"one client connect...\");
    }

    //断开连接时触发
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(\"one client disconnect...\");
    }

    //接收客户端发送的消息
    @Override
    public void channelRead(ChannelHandlerContext ctx,   msg) throws Exception {
        System.out.println(\"客户端：\"+msg.toString());
        InputStreamReader is = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(is);
        String result =\"result\";
        try{
            result = br.readLine();
        }
        catch(IOException e){
            e.printStackTrace();
        }
        ctx.write(result);//给客户端回复
        ctx.flush();
    }
}

public class ClientHandler extends ChannelHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(\"Client01Handler Active\");
        /*若把这一句注释掉将无法将event传递给下一个ClientHandler,例如例子中p.addLast(new Client01Handler())后面紧跟着p.addLast(new Client02Handler())
         后面的Client02Handler里的方法就不会被触发。
        */
        ctx.fireChannelActive();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx,   msg) throws Exception {
        System.out.println(\"服务端: \"+msg);
        InputStreamReader is = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(is);
        String result =\"result\";
        try{
            result = br.readLine();
        }
        catch(IOException e){
            e.printStackTrace();
        }
        ctx.write(result);//给服务端回复
        ctx.flush();
    }

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