尚硅谷2019年Netty教程 netty server client 基础版代码讲解 ----目标netty---step5.01

https://www.bilibili.com/video/BV1jK4y1s7GV?p=47   --- client  server 端代码调试 
https://www.bilibili.com/video/BV1jK4y1s7GV?p=46   --- client 端代码编写及讲解
https://www.bilibili.com/video/BV1jK4y1s7GV?p=45   --- server端代码编写及讲解
https://www.bilibili.com/video/BV1jK4y1s7GV?p=44  --- server端代码编写及讲解

// server  
package com.tz.leo.netty.simple;
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.channel.socket.nio.NioSocketChannel;

/**
 * Author: tz_wl
 * Date: 2020/9/22 19:33
 * Content:
 */
public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        //默认 线程数 cpu核心数* 2
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //创建服务器启动对象  配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup,workerGroup)                           // 设置两个线程组
                    .channel(NioServerSocketChannel.class)                   // NioSocketChannle 作为服务器的通道实现
                    .option(ChannelOption.SO_BACKLOG,128)              // 设置线程队列得到连接个数
                    .childOption(ChannelOption.SO_KEEPALIVE,true)      // 设置保持活动连接状态
                    .childHandler(new ChannelInitializer<SocketChannel>() {  // 创建一个通道 测试对象
                        //给pipeline 设置处理器
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    }) //给workGroup 的 eventLoop 设置处理器
            ;
            System.out.println(" step 01  服务器端启动 ok ... ");

            //绑定一个端口 ，并且同步  生成 一个 channelFuture
            //启动服务器
            ChannelFuture cf = bootstrap.bind(8097).sync();
            // 对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }

}

// server handler 
package com.tz.leo.netty.simple;

import com.sun.org.apache.xpath.internal.SourceTree;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelPipeline;
import io.netty.util.CharsetUtil;

/**
 * Author: tz_wl
 * Date: 2020/9/22 19:48
 * Content:
 *
 * 自定义一个handler , 需要继承 netty 的 HandlerAdapter
 * 这时此handler 才是真正的 handler
 *
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {


    //读取客户端发来的 实际数据
    // ChannelHandlerContext  ctx 上下文  含有 管道  pipeline , 通道 channel  , 地址 等
    //  msg             客户端发送来的数据
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("=================step04=================");
        System.out.println(" 服务器读取线程："+ Thread.currentThread().getName());
        System.out.println("  server ctx = "+ ctx);

        System.out.println(" ====== show  channel  pipeline  ======");
        Channel channel = ctx.channel();
        ChannelPipeline pipeline = ctx.pipeline();


        System.out.println();
        //将 msg 转换为 byteBuf   //此 ByteBuf 是 netty 提供的
        ByteBuf buf=(ByteBuf)msg;
        System.out.println(" 客户端发送消息是: " + buf.toString(CharsetUtil.UTF_8));
        System.out.println(" 客户端 地址是： "+ ctx.channel().remoteAddress());
        //super.channelRead(ctx, msg);
        System.out.println("=================step04=================");
    }

    //数据读取完毕
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //将数据写入到缓存 并 刷新
        // 需要对发送的数据 编码
        ctx.writeAndFlush(Unpooled.copiedBuffer(" step05  hello, 客户端 ~  今天任总被判刑了，我略有心酸... ",CharsetUtil.UTF_8));
        //super.channelReadComplete(ctx);
    }

    //处理异常  关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        //super.exceptionCaught(ctx, cause);
    }
}

// client 
package com.tz.leo.netty.simple;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * Author: tz_wl
 * Date: 2020/9/22 19:59
 * Content:
 */
public class NettyClient {
    public static void main(String[] args) throws  Exception{

        //客户端需要一个时间循环组
        EventLoopGroup clientGroup = new NioEventLoopGroup();

        try {

            //创建客户端启动对象
            Bootstrap bootstrap = new Bootstrap();

            //设置相关参数
            bootstrap.group(clientGroup)                 //设置线程组
                    .channel(NioSocketChannel.class)        //设置客户端通道的实现
                   .handler(new ChannelInitializer<SocketChannel>() {
                       protected void initChannel(SocketChannel ch) throws Exception {
                           ch.pipeline().addLast(new NettyClientHandler());
                       }
                   });
            System.out.println(" step 02  客户端启动 ok ...");

            //启动客户端 去连接 服务器端
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 8097).sync();
            //给关闭通道 监听
            cf.channel().closeFuture().sync();
        } finally {
            clientGroup.shutdownGracefully();
        }

    }
}

// client handler 
package com.tz.leo.netty.simple;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * Author: tz_wl
 * Date: 2020/9/22 20:07
 * Content:
 */
public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    //当通道 建立
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
       // System.out.println("client :" + ctx);
        //super.channelActive(ctx);
        System.out.println("============ step03 ==========");
        ctx.writeAndFlush(Unpooled.copiedBuffer("  hello, 服务端 ~ 我是苟声 ", CharsetUtil.UTF_8));

    }


    //当通道有读取事件时候 触发
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("=================step06=================");
        ByteBuf buf =(ByteBuf)msg;
        System.out.println("服务器回复的消息是： " + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务端的地址是"+ ctx.channel().remoteAddress());
        //super.channelRead(ctx, msg);
        System.out.println("=================step06=================");
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

        System.out.println("step07  finish ");
        //super.channelReadComplete(ctx);
    }

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