Netty学习记录

Netty入门学习

DiscardServerHandler

1. 顾名思义创建丢弃服务器，继承自ChannelInboundHandlerAdapter

public class DiscardServerHandler extends ChannelInboundHandlerAdapter {
    /**
     * 功能描述: <br>
     * 〈 DISCARD忽略收到的所有数据〉
     *
     * @Param: [ctx, cause]
     * @Return: void
     * @Author: 
     * @Date: 2020/12/29 15:43
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //丢弃收到的所有数据
        //ByteBuf 是一个引用计数对象，这个对象必须显示地调用 release() 方法来释放
        ((ByteBuf) msg).release();
    }

    /**
     * 功能描述: <br>
     * 〈有异常则关闭,exceptionCaught()事件处理方法是当出现Throwable 对象才会被调用〉
     *
     * @Param: [ctx, cause]
     * @Return: void
     * @Author: 
     * @Date: 2020/12/29 15:43
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

2. 创建server

package com.cn.test.nettyStudy;

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 javax.annotation.PreDestroy;

/**
 * @author 
 * @version V1.0
 * @Package com.cn.test.nettyStudy
 * @date 2020/12/29 15:48
 */
public class NettyServer {
    private int port;

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

    //定义两个EventLoopGroup，bossGroup辅助客户端的tcp连接请求, workGroup负责与客户端之前的读写操作
    private EventLoopGroup bossGroup;
    private EventLoopGroup workGroup;

    public void run() throws Exception {
        //NioEventLoopGroup 是用来处理I/O操作的多线程事件循环器
        //bossGroup用于接收连接
        bossGroup = new NioEventLoopGroup();
        //workGroup用来处理接收的连接
        workGroup = new NioEventLoopGroup();
        //一旦‘bossGroup’接收到连接，就会把连接信息注册到‘workGroup’上。
        // 如何知道多少个线程已经被使用，如何映射到已经创建的 Channel上都需要依赖于 EventLoopGroup 的实现
        try {
            //ServerBootstrap 是一个启动 NIO 服务的辅助启动类
            ServerBootstrap b = new ServerBootstrap();
            //ChannelInitializer 是一个特殊的处理类，他的目的是帮助使用者配置一个新的Channel
            b.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new DiscardServerHandler());
                        }
                    })
                    //配置参数
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            // 绑定端口，开始接收进来的连接
            // 配置完成，开始绑定server，通过调用sync同步方法阻塞直到绑定成功
            ChannelFuture f = b.bind(port).sync();

            // 等待服务器  socket 关闭 。
            // 在这个例子中，这不会发生，但你可以优雅地关闭你的服务器。
            f.channel().closeFuture().sync();
        } finally {
            //释放资源
            workGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
    //启动访问 当前服务
    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new NettyServer(port).run();
    }
    //也可以在销毁的时候再释放资源

    /*    *//**
     * 释放资源
     *
     * @throws InterruptedException
     *//*
    @PreDestroy
    public void destroy() throws InterruptedException {
        if (bossGroup != null) {
            bossGroup.shutdownGracefully().sync();
        }
        if (workGroup != null) {
            workGroup.shutdownGracefully().sync();
        }
    }*/
}

当前已经编辑出一个服务器了，cmd 打开 输入telnet localhost 8080 即可运行了。