Netty之入门第一步-服务端启动

前言

从需求出发，最原始的jdk代码开始一步步看，再看Netty封装了哪些，每个组件充当了什么样的角色，才是这篇文章的立意。

今天这篇文章我会从传统的写法入手，进一步发展到Netty每个组件的含义，Netty包装了什么。

案例

完整代码看本机netty-study工程

Demo —— 一个服务端和客户端的socket例子

package com.imooc.netty.ch2;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

    private ServerSocket serverSocket;

    public Server(int port) {
        try {
            this.serverSocket = new ServerSocket(port);
            System.out.println("服务端启动成功，端口:" + port);
        } catch (IOException exception) {
            System.out.println("服务端启动失败");
        }
    }

    public void start() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                doStart();
            }
        }).start();
    }

    private void doStart() {
        while (true) {
            try {
                Socket client = serverSocket.accept();
                new ClientHandler(client).start();
            } catch (IOException e) {
                System.out.println("服务端异常");
            }
        }
    }
}

package com.imooc.netty.ch2;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

public class ClientHandler {

    public static final int MAX_DATA_LEN = 1024;
    private final Socket socket;

    public ClientHandler(Socket socket) {
        this.socket = socket;
    }

    public void start() {
        System.out.println("新客户端接入");
        new Thread(new Runnable() {
            @Override
            public void run() {
                doStart();
            }
        }).start();
    }

    private void doStart() {
        try {
            InputStream inputStream = socket.getInputStream();
            while (true) {
                byte[] data = new byte[MAX_DATA_LEN];
                int len;
                while ((len = inputStream.read(data)) != -1) {
                    String message = new String(data, 0, len);
                    System.out.println("客户端传来消息: " + message);
                    socket.getOutputStream().write(data);
                }

            }


        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Server类里面有两个线程，一个是main线程，一个是客户端的接收处理线程，accept阻塞等待client的链接，每获得一个连接就交给一个 ClientHandler去处理。一直阻塞等待处理客户端的连接和数据

package com.imooc.netty.ch2;

import java.io.IOException;
import java.net.Socket;

public class Client {
    private static final String HOST = "127.0.0.1";
    private static final int PORT = 8000;
    private static final int SLEEP_TIME = 5000;

    public static void main(String[] args) throws IOException {
        final Socket socket = new Socket(HOST, PORT);

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("客户端启动成功!");
                while (true) {
                    try {
                        String message = "hello world";
                        System.out.println("客户端发送数据: " + message);
                        socket.getOutputStream().write(message.getBytes());
                    } catch (Exception e) {
                        System.out.println("写数据出错!");
                    }
                    sleep();
                }


            }
        }).start();

    }

    private static void sleep() {
        try {
            Thread.sleep(SLEEP_TIME);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

客户端也是两个线程，一个main线程，一个线程向server发送数据。

Netty对socket的抽象

Netty基本组件，与demo里面对应

ServerBootstrap

ServerBootstrap为Netty服务端的启动辅助类，它提供了一系列的方法用于设置服务启动相关的参数。

EventLoopGroup

​ NioEventLoopGroup ———— > Thread

这个Thread包括两部分 一个是服务端接口客户端连接的线程，第二个是处理每个连接的读写

client的Socket server的ServerSocket Netty将jdk的socketChannel封装成了NioSocketChannel

运行任务来处理在连接的生命周期内发生的事件是任何网络框架的基本功能。与之相应的编程上的构造通常被称为事件循环 ———— 一个Netty使用了 interface io.netty.channel.EventLoop来适配的术语。主要职责就是处理所有注册到本线程多路复用器Selector上的Channel。

ByteBuf

​ ByteBuf ———— > IO Bytes

java NIO提供了ByteBuffer作为它的字节容器，但是这个类使用起来过于复杂，而且也有些繁琐。Netty的ByteBuffer替代品是ByteBuf，一个强大的实现，即解决了JDK API的局限性，又为网络应用程序的开发者提供了更好的API。

ChannelHandler

​ ChannelHandler ———— > Logic

ChannelHandler充当了所有处理入站和出站数据的应用程序逻辑的容器。

ChannelPipeline

​ Pipeline ———— > Logic Chain

ChannelPipeline为ChannelHandler链提供了容器，并定义了用于在该链上的传播入站和出站事件流的API 。当Cahnnel被创建时，它会被自动地分配到它专属的CahnnelPipeline。

Netty服务端启动标准demo

/*
 * Copyright 2012 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */
package io.netty.example.echo;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
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.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.util.SelfSignedCertificate;

/**
 * Echoes back any received data from a client.
 */
public final class EchoServer {

    static final boolean SSL = System.getProperty("ssl") != null;
    static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));

    public static void main(String[] args) throws Exception {
        // Configure SSL.
        final SslContext sslCtx;
        if (SSL) {
            SelfSignedCertificate ssc = new SelfSignedCertificate();
            sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
        } else {
            sslCtx = null;
        }

        // Configure the server.
        // 创建EventLoopGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup(1); // 创建BOSS线程组 用于服务端接受客户端的连接
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // 创建WROK线程组 用于进行SocketChannel的网络读写
        final EchoServerHandler serverHandler = new EchoServerHandler();
        try {
            // 创建ServerBootStrap实例
            // ServerBootstrap 用于启动NIO服务端的辅助启动类，目的是降低服务端的开发复杂度
            ServerBootstrap b = new ServerBootstrap();
            // 绑定Reactor线程池
            b.group(bossGroup, workerGroup)
             // 设置并绑定服务端Channel
             // 指定所使用的NIO传输的Channel
             .channel(NioServerSocketChannel.class)
              // 实例化的ServerChannel的配置项
             .option(ChannelOption.SO_BACKLOG, 100)
              // 设置并添加handler 是 服务端NioServerSocketChannel
             .handler(new LoggingHandler(LogLevel.INFO))
              // 设置并添加ChannelHandler 是 NioSocketChannel
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(serverHandler);
                 }
             });

            // Start the server.
            // 绑定端口，同步等待成功
            ChannelFuture f = b.bind(PORT).sync();

            // Wait until the server socket is closed.
            // 等待服务端监听端口关闭
            f.channel().closeFuture().sync();
        } finally {
            // Shut down all event loops to terminate all threads.
            // 优雅地关闭
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

Netty服务端启动

第一步：创建ServerBootstrap实例

第二步：设置并绑定Reactor线程池

第一步：创建服务端Channel

第二步：初始化服务端Channel

第三步：注册selector

第四步：端口绑定

创建服务端Channel

bind() [用户代码入口]

​ initAndRegister()[初始化并注册]

​ newChannel()[创建服务端Channel]

// todo

反射创建服务端Channel

newSocket()[通过jdk来创建底层jdk channel]

NioServerSocketChannelConfig()[tcp参数配置类]

AbstractNioChannel()

​ configureBlocking(false)[阻塞模式]

​ AbstractChannel()[创建id，unsafe，pipeline]

初始化服务端Channel ——- init()

init()[初始化入口]

​ set ChannelOptions, ChannelAttrs

​ set ChildOptions, ChildAttrs

​ config handler[配置服务端pipeline]

​ add ServerBootstrapAcceptor[添加连接器]

注册selector

AbstractChannel.register(channel)[入口]

​ this.eventLoop = eventLoop[绑定线程]

​ register0[实际注册]

​ doRegister()[调用jdk底层注册]

​ invokeHandlerAdderIfNeeded()

​ fireChannelRegistered()[传播事件]

端口绑定

AbstractUnsafe.bind()[入口]

​ doBind()

​ javaChannel().bind()[jdk底层绑定]

​ pipeline.fireChannelActive()[传播事件]

​ HeadContext.readIfIsAutoRead( )[表示可以读了]

两个问题

问：服务端的socket在哪里初始化？

答：

问：在哪里accept连接？

答：