netty简单样例

package com.example.demohystrix.process;

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.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.codec.string.StringEncoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.Charset;

/**
 * @author liusongwei
 * @Title: NettyServer
 * @ProjectName claimfront
 * @Description: TODO
 * @date 2019/3/2216:26
 */
public class NettyServer {
    private static Logger log = LoggerFactory.getLogger(NettyServer.class);

    private final int port;

    public NettyServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        //用来接收进来的连接
        EventLoopGroup bossGroup = new NioEventLoopGroup();

        //用来处理已经被接收的连接
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //启动 NIO 服务的辅助启动类
            ServerBootstrap sb = new ServerBootstrap();
            sb.option(ChannelOption.SO_BACKLOG, );//设置TCP缓冲区
           // sb.option(ChannelOption.SO_SNDBUF,32*1024);//设置发送缓冲大小
           // sb.option(ChannelOption.SO_RCVBUF,32*1024);//设置接收缓冲大小
           // sb.option(ChannelOption.SO_KEEPALIVE,true);//保持连接
            sb.group(group, bossGroup) // 绑定两个线程组
                    .channel(NioServerSocketChannel.class) // 指定NIO模式
                    .localAddress(this.port)// 绑定监听端口
                    // 绑定客户端连接时候触发操作  添加一个EchoServerHandler到子Channel的ChannelPipeline
                    //ChannelInitializer 当一个新的连接被接收时，一个新的子Channel将会被创建
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            log.info("客户端连接,连接的IP:{}",ch.localAddress().getHostName());
                            ch.pipeline().addLast(new StringEncoder(Charset.forName("GBK")));
                            //EchoServerHandler被标注为@Shareable,所以我们可以总是使用同样的实例
                            ch.pipeline().addLast(new NettyServerHandler()); // 客户端触发操作
                            ch.pipeline().addLast(new ByteArrayEncoder());
                        }
                    });
            //异步绑定服务器，调用sync()方法阻塞等待直到绑定完成
            ChannelFuture cf = sb.bind().sync();

            //获取Channel的closeFuture,并且阻塞当前线程直到它完成
            cf.channel().closeFuture().sync();
            log.info(" 启动正在监听:{}",cf.channel().localAddress());
        } finally {
            group.shutdownGracefully().sync(); // 释放线程池资源
            bossGroup.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {

        new NettyServer().start(); // 启动
    }
}

package com.example.demohystrix.process;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;

/**
 * @author liusongwei
 * @Title: NettyServerHandler
 * @ProjectName claimfront
 * @Description: TODO
 * @date 2019/3/2216:31
 */
//标示一个ChannelHandler可以被多个Channel安全地共享
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
    private static Logger log = LoggerFactory.getLogger(NettyServerHandler.class);
    /*
     * channel 通道 action 活跃的    回调调用
     * 当客户端主动链接服务端的链接后，这个通道就是活跃的了。也就是客户端与服务端建立了通信通道并且可以传输数据
     */
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().localAddress().toString() + " 通道已激活！");
    }

    /*
     * channelInactive
     *
     * channel 通道 Inactive 不活跃的
     *
     * 当客户端主动断开服务端的链接后，这个通道就是不活跃的。也就是说客户端与服务端的关闭了通信通道并且不可以传输数据
     *
     */
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().localAddress().toString() + " 通道不活跃！");
        // 关闭流
    }

    /**
     * TODO  此处用来处理收到的数据中含有中文的时  出现乱码的问题
     */
    private String getMessage(ByteBuf buf) {
        byte[] con = new byte[buf.readableBytes()];
        buf.readBytes(con);
        try {
            return new String(con, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 功能：读取服务器发送过来的信息
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 第一种：接收字符串时的处理
        ByteBuf buf = (ByteBuf) msg;
        String rev = getMessage(buf);
        log.info("服务端收到的数据:" + rev);
        //将接收到的消息写给发送者，而不冲刷出站消息
        ctx.write("消息已接收");
    }

    /**
     * 功能：读取完毕客户端发送过来的数据之后的操作
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("服务端接收数据完毕..");
        // 第一种方法：写一个空的buf，并刷新写出区域。完成后关闭sock channel连接。
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
        // ctx.flush();
        // ctx.flush(); //
        // 第二种方法：在client端关闭channel连接，这样的话，会触发两次channelReadComplete方法。
        // ctx.flush().close().sync(); // 第三种：改成这种写法也可以，但是这中写法，没有第一种方法的好。
    }

    /**
     * 功能：服务端发生异常的操作
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        System.out.println("异常信息：\r\n" + cause.getMessage());
    }
}

package com.example.demohystrix.process;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;

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;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.stream.ChunkedWriteHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author liusongwei
 * @Title: NettyClient
 * @ProjectName algorithmrsa
 * @Description: TODO
 * @date 2019/3/2216:37
 */
public class NettyClient {
    private static Logger log = LoggerFactory.getLogger(NettyServer.class);

    private final String host;
    private final int port;

    public NettyClient() {
        this();
    }

    public NettyClient(int port) {
        this("localhost", port);
    }

    public NettyClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group) // 注册线程池
                    .channel(NioSocketChannel.class) // 使用NioSocketChannel来作为连接用的channel类
                    .remoteAddress(new InetSocketAddress(this.host, this.port)) // 绑定连接端口和host信息
                    .handler(new ChannelInitializer<SocketChannel>() { // 绑定连接初始化器
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //ch.pipeline().addLast(new StringEncoder(Charset.forName("GBK")));
                            ch.pipeline().addLast(new StringEncoder(Charset.forName("GBK")));
                            ch.pipeline().addLast(new NettyClientHandler());
                            ch.pipeline().addLast(new ByteArrayEncoder());
                            ch.pipeline().addLast(new ChunkedWriteHandler());

                        }
                    });
            ChannelFuture cf = b.connect().sync(); // 异步连接服务器
            log.info("服务端连接成功...");
            cf.channel().closeFuture().sync(); // 异步等待关闭连接channel
            log.info("连接已关闭...");
        } finally {
            group.shutdownGracefully().sync(); // 释放线程池资源
        }
    }

    public static void main(String[] args) throws Exception {
        new NettyClient("127.0.0.1", ).start(); // 连接127.0.0.1/65535，并启动
       // new NettyClient("127.0.0.1", 8888).start(); // 连接127.0.0.1/65535，并启动

    }
}

package com.example.demohystrix.process;

import java.nio.charset.Charset;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author liusongwei
 * @Title: NettyClientHandler
 * @ProjectName algorithmrsa
 * @Description: TODO
 * @date 2019/3/2216:40
 */
public class NettyClientHandler extends SimpleChannelInboundHandler<ByteBuf>{
    private static Logger log = LoggerFactory.getLogger(NettyServer.class);
    /**
     * 向服务端发送数据
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        log.info("客户端与服务端通道-开启：" + ctx.channel().localAddress() + "channelActive");
        String sendInfo = "Hello 这里是客户端  你好啊！";
        ctx.writeAndFlush(Unpooled.copiedBuffer(sendInfo, CharsetUtil.UTF_8)); // 必须有flush
    }

    /**
     * 当客户端主动断开服务端的链接后，这个通道就是不活跃的。也就是说客户端与服务端的关闭了通信通道并且不可以传输数据
     */
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        log.info("客户端与服务端通道-关闭：" + ctx.channel().localAddress() + "channelInactive");
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("读取客户端通道信息..");
        ByteBuf buf = msg.readBytes(msg.readableBytes());
        //log.info("收到信息:"+ByteBufUtil.hexDump(buf) + "; 数据包为:" + buf.toString(Charset.forName("utf-8")));
        log.info("收到信息:"+ByteBufUtil.hexDump(buf) + "; 数据包为:" + buf.toString(Charset.forName("GBK")));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        log.info("异常退出:" + cause.getMessage());
    }
}