<dependency>

        <groupId>io.netty</groupId>

        <artifactId>netty-all</artifactId>

        <version>5.0.0.Alpha2</version>

</dependency>

package com.lzh.netty;

import io.netty.bootstrap.ServerBootstrap;

import io.netty.channel.*;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioServerSocketChannel;

import io.netty.handler.codec.LengthFieldBasedFrameDecoder;

import io.netty.handler.codec.LengthFieldPrepender;

import io.netty.handler.codec.string.StringDecoder;

import io.netty.handler.codec.string.StringEncoder;

import io.netty.util.CharsetUtil;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

 * Created by 敲代码的卡卡罗特

 * on 2018/8/12 17:31.

 */

public class Server {

    public static void main(String[] arg){

        //服务类

        ServerBootstrap b = new ServerBootstrap();

        //boss线程监听端口，worker线程负责数据读写

        EventLoopGroup bossGroup = new NioEventLoopGroup();

        EventLoopGroup workerGroup = new NioEventLoopGroup();

        b = b.group(bossGroup,workerGroup);

        b = b.option(ChannelOption.SO_BACKLOG, 128);

        b = b.childOption(ChannelOption.SO_KEEPALIVE, true);

        //设置niosocket工厂

        b.channel(NioServerSocketChannel.class);

        b.childHandler(new ChannelInitializer<SocketChannel>() {

            @Override

            protected void initChannel(SocketChannel ch) throws Exception {

                ch.pipeline().addLast(new MyServerHandler());//

            }

        });

        try {

            //绑定端口并启动去接收进来的连接

            ChannelFuture f = b.bind(8888).sync();

            // 这里会一直等待，直到socket被关闭

            f.channel().closeFuture().sync();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }finally {

            /***

             * 优雅关闭

             */

            workerGroup.shutdownGracefully();

            bossGroup.shutdownGracefully();

        }

    }

}

package com.lzh.netty;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelHandlerAdapter;

import io.netty.channel.ChannelHandlerContext;

import io.netty.util.CharsetUtil;

import java.util.Date;

/**

 * Created by 敲代码的卡卡罗特

 * on 2018/8/12 21:21.

 */

public class MyServerHandler extends ChannelHandlerAdapter  {

    /***

     * 这里我们覆盖了chanelRead()事件处理方法。

     * 每当从客户端收到新的数据时，

     * 这个方法会在收到消息时被调用，

     * 这个例子中，收到的消息的类型是ByteBuf

     * @param ctx 通道处理的上下文信息

     * @param msg 接收的消息

     */

    @Override

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception{

        //读取客户端发来的信息

        ByteBuf m = (ByteBuf) msg; // ByteBuf是netty提供的

        System.out.println("client:"+m.toString(CharsetUtil.UTF_8));

       //2两种打印信息的方法。都可以实现

       /* byte[] b=new byte[m.readableBytes()];

        m.readBytes(b);

        System.out.println("client:"+new String(b,"utf-8"));*/

        //向客户端写信息

        String name="你好客户端：这是服务端返回的信息!";

        ctx.writeAndFlush(Unpooled.copiedBuffer(name.getBytes()));

    }

    /***

     * 这个方法会在发生异常时触发

     * @param ctx

     * @param cause

     */

    @Override

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {

        /***

         * 发生异常后，关闭连接

         */

        cause.printStackTrace();

        ctx.close();

    }

}

package com.lzh.netty;

import io.netty.bootstrap.Bootstrap;

import io.netty.buffer.Unpooled;

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;

/**

 * Created by 敲代码的卡卡罗特

 * on 2018/8/12 21:46.

 */

public class Client {

    public static void main(String[] arg){

        /**

         * 如果你只指定了一个EventLoopGroup，

         * 那他就会即作为一个‘boss’线程，

         * 也会作为一个‘workder’线程，

         * 尽管客户端不需要使用到‘boss’线程。

         */

        Bootstrap b = new Bootstrap(); // (1)

        EventLoopGroup workerGroup = new NioEventLoopGroup();

        b.group(workerGroup); // (2)

        b.channel(NioSocketChannel.class); // (3)

        b.option(ChannelOption.SO_KEEPALIVE, true); // (4)

        b.handler(new ChannelInitializer<SocketChannel>() {

            @Override

            public void initChannel(SocketChannel ch) throws Exception {

                ch.pipeline().addLast(new MyClientHandler());

            }

        });

        try {

            ChannelFuture f = b.connect("127.0.0.1", 8888).sync();

            //向服务端发送信息

            f.channel().writeAndFlush(Unpooled.copiedBuffer("你好".getBytes()));

            f.channel().closeFuture().sync();

        } catch (InterruptedException e) {

            e.printStackTrace();

        } finally {

            workerGroup.shutdownGracefully();

        }

    }

}

package com.lzh.netty;

import io.netty.buffer.ByteBuf;

import io.netty.channel.ChannelHandlerAdapter;

import io.netty.channel.ChannelHandlerContext;

import io.netty.util.CharsetUtil;

import io.netty.util.ReferenceCountUtil;

/**

 * Created by 敲代码的卡卡罗特

 * on 2018/8/12 21:49.

 */

public class MyClientHandler extends ChannelHandlerAdapter {

    @Override

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception{

        try {

            //读取服务端发来的信息

            ByteBuf m = (ByteBuf) msg; // ByteBuf是netty提供的

            System.out.println("client:"+m.toString(CharsetUtil.UTF_8));

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            //当没有写操作的时候要把msg给清空。如果有写操作，就不用清空，因为写操作会自动把msg清空。这是netty的特性。

            ReferenceCountUtil.release(msg);

        }

    }

    @Override

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {

        cause.printStackTrace();

        ctx.close();

    }

}