【分布式-1】RPC框架设计，Netty

一：RPC框架设计

1、socket：

TCP/IP协议是传输层协议，主要解决数据如何在网络中传输；

HTTP 是应用层协议，主要解决如何包装数；

socket则是支持TCP/IP协议网络通信的基本操作单元，是通信端点的抽象表示，比如代表客户端，服务端。他包含了通信的五种信息：

连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。

Socket编程主要涉及到客户端和服务端，首先是在服务器端创建一个套接字 （ServerSocket），并把它附加到一个端口上，从这个端口监听连接。端口号的范围是0到

65536 ，但是 0 到 1024 是为特权服务保留的端口号，所以选用其他端口 。

客户端请求与服务器进行连接的时候，根据服务器的域名或者 IP 地址，加上端口号，打开一个套接字。当服务器接受连接后，服务器和客户端之间的通信就像输入输出流一样进行作。

代码示例：

服务端：

package cn.jojo.uc.server.controller;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ServerDemo {

    public static void main(String[] args) throws Exception {
        //1.创建一个线程池,如果有客户端连接就创建一个线程, 与之通信 
        ExecutorService executorService = Executors.newCachedThreadPool();
        //2.创建 ServerSocket 对象 
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器已启动");
        while (true) {
            //3.监听客户端 
            Socket socket = serverSocket.accept();

            System.out.println("有客户端连接");
            //4.开启新的线程处理 
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    handle(socket);
                }
            });
        }
    }

    public static void handle(Socket socket) {
        try {
            System.out.println("线程ID:" + Thread.currentThread().getId() + " 线程名称:" + Thread.currentThread().getName());
            //从连接中取出输入流来接收消息 
            InputStream is = socket.getInputStream();
            byte[] b = new byte[1024];
            int read = is.read(b);
            System.out.println("客户端:" + new String(b, 0, read));
            //连接中取出输出流并回话 
            OutputStream os = socket.getOutputStream();
            os.write("没钱".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭连接 
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端：

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class ClientDemo {

    public static void main(String[] args) throws Exception {
        while (true) {
            //1.创建 Socket 对象
            Socket s = new Socket("127.0.0.1", 9999);
            //2.从连接中取出输出流并发消息
            OutputStream os = s.getOutputStream();
            System.out.println("请输入:");
            Scanner sc = new Scanner(System.in);
            String msg = sc.nextLine();
            os.write(msg.getBytes());
            //3.从连接中取出输入流并接收回话
            InputStream is = s.getInputStream();
            byte[] b = new byte[1024];
            int read = is.read(b);
            System.out.println("老板说:" + new String(b, 0, read).trim());
            //4.关闭
            s.close();
        }
    }
}

2、IO模型：

I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的

性能。

Java 共支持 3 种网络编程模型 /IO 模式： BIO( 同步并阻塞 ) 、 NIO( 同步非阻塞 ) 、 AIO( 异步非阻塞 )

在此之前，先理解同步和异步，阻塞和非阻塞。

同步：调用者主动等待结果，拿到结果后结束。

异步：调用者调用后就结束，不等待结果，由其他方式（比如回调）通知。

阻塞：调用者在得到结果之前一直阻塞等待，不去干别的事。

非阻塞：调用者在得到结果之前，可以先去干其他事。

举例：一个人烧水

同步：需要主动去看水有没有烧开

        同步阻塞：烧水之后，啥也不干，蹲着那里等水烧开。

        同步非阻塞： 烧水之后，可以去干其他事，这就是非阻塞； 但依旧是同步的，因为他            时不时的要来看看是否烧开，主动获取结果。

异步：水开之后发出警报通知，不用自己主动去看。

        异步阻塞：虽然会水开后会发出警报，不用自己去获取结果。 但是，在收到结果之前，啥也不干。

        异步非阻塞：烧水后不主动获取结果，水开了会有警报通知，，期间继续干其他事情。

• BIO：
  • 一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器 ) 。
• NIO：
  • 同步非阻塞，服务器实现模式为一个线程处理多个请求 ( 连接 ) ，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理。说白了，这个线程不会一直阻塞在一个连接上，但是会主动获取每个连接的结果。
  • 

• AIO：
  • AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是，先由操作系统完成后才通知服务端程序启动线程去处理。 Proactor 模式是一个消息异步通知的设计模式。
     

接下来重点说一下NIO，因为它使用最多最常用，Netty框架也是基于它来实现的。

NIO 有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)。 它是面向缓冲区编程的，扩展性强。

NIO 是可以做到用一个线程来处理多个操作的。假设有 10000 个请求过来 , 根据实际情况，可以分配 50 或者 100 个线程来处理。不像BIO 那样，非得分配 10000 个。

BIO是基于字符流或字节流操作，而NIO通过channel读取到buffer中，或从buffer写入到channel。 Selector( 选择器 ) 用于监听多个通道的事件（比如：连接请求， 数据到达等），因此使用单个线程就可以监听多个客户端通道。

 NIO对于Buffer，Channel，Selector三大部分，都有提供相关的API，去操作使用内存，通道和选择器。 但是，通常不会直接去使用它，因为开发难度大，例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等等。 要很熟悉多线程，网络等才能编写出可实践的代码。   

Netty，，一个基于NIO的网络编程框架，简化了NIO的开发过程。Elasticsearch 、Dubbo 框架内部都采用了