NIO和BIO编程 - 技术栈

一、网络通信编程基本常识

1、什么是Socket？

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口，一般由操作系统提供。

2、短连接

短连接是指socket建立连接之后传输数据确定接收完后关闭连接

3、长连接

长连接是指建立socket连接后不管是否使用都保持连接

4、什么时候用长连接，短连接？

http1.1网上都开始向长连接演化，web网站成千上万的客户端使用短连接会更节省资源消耗，短连接频繁的通信会造成socket错误，而socket频繁的创建也会耗费系统资源

二、Java原生网络编程

1、原生JDK网络编程BIO

面向流的阻塞IO，

服务端（这种来一个客户端就创建一个线程的方式，如果客户端连接数量过多，内存资源消耗过多，造成系统崩溃）

java 复制代码

public class Server {

	public static void main(String[] args) throws IOException {
		// 创建ServerSocket接收客户端连接对象
		ServerSocket serverSocket = new ServerSocket();
		// 绑定服务器监听端口
		serverSocket.bind(new InetSocketAddress(8888));
		System.out.println("start server...");
		while (true) {
			new Thread(new ServerTask(serverSocket.accept())).start();
		}
	}

	private static class ServerTask implements Runnable {

		private Socket socket = null;
		public ServerTask(Socket socket) {
			this.socket = socket;
		}

		@Override
		public void run() {
			try(
				//实例化与客户端通信的输入输出流
				ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
				ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream())
			){
				//接收客户端的输出，也就是服务器的输入
				String userName = inputStream.readUTF();
				System.out.println("Accept client message:"+userName);

				//服务器的输出，也就是客户端的输入
				outputStream.writeUTF("Hello,"+userName);
				outputStream.flush();
			}catch(Exception e){
				e.printStackTrace();
			}finally {
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

// 单线程实现服务端连接（单线程服务端无法同时支持多个连接同时处理）
class ServerSingle {

    public static void main(String[] args) throws IOException {
        //服务端启动必备
        ServerSocket serverSocket = new ServerSocket();
        //表示服务端在哪个端口上监听
        serverSocket.bind(new InetSocketAddress(8888));
        System.out.println("Start Server ....");
        int connectCount = 0;
        try {
            while(true){
                Socket socket = serverSocket.accept();

                System.out.println("accept client socket ....total =" + ( ++connectCount));
                //实例化与客户端通信的输入输出流
                try(ObjectInputStream inputStream =
                            new ObjectInputStream(socket.getInputStream());
                    ObjectOutputStream outputStream =
                            new ObjectOutputStream(socket.getOutputStream())){

                    //接收客户端的输出，也就是服务器的输入
                    String userName = inputStream.readUTF();
                    System.out.println("Accept client message:"+userName);

                    //服务器的输出，也就是客户端的输入
                    outputStream.writeUTF("Hello,"+userName);
                    outputStream.flush();
                }catch(Exception e){
                    e.printStackTrace();
                }finally {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } finally {
            serverSocket.close();
        }

    }
}

// 线程池的方式启动服务端（受线程数量影响，如果传输的数据过大 比如文件，占用时间过长的话，其它连接只能等待）
class ServerPool {

    private static ExecutorService executorService
            = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors());

    public static void main(String[] args) throws IOException {
        //服务端启动必备
        ServerSocket serverSocket = new ServerSocket();
        //表示服务端在哪个端口上监听
        serverSocket.bind(new InetSocketAddress(10001));
        System.out.println("Start Server ....");
        try{
            while(true){
                executorService.execute(new ServerTask(serverSocket.accept()));
            }
        }finally {
            serverSocket.close();
        }
    }

    //每个和客户端的通信都会打包成一个任务，交个一个线程来执行
    private static class ServerTask implements Runnable{

        private Socket socket = null;
        public ServerTask(Socket socket){
            this.socket = socket;
        }

        @Override
        public void run() {
            //实例化与客户端通信的输入输出流
            try(ObjectInputStream inputStream =
                        new ObjectInputStream(socket.getInputStream());
                ObjectOutputStream outputStream =
                        new ObjectOutputStream(socket.getOutputStream())){

                //接收客户端的输出，也就是服务器的输入
                String userName = inputStream.readUTF();
                System.out.println("Accept client message:"+userName);

                //服务器的输出，也就是客户端的输入
                outputStream.writeUTF("Hello,"+userName);
                outputStream.flush();
            }catch(Exception e){
                e.printStackTrace();
            }finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

客户端

java 复制代码

public class Client {

    public static void main(String[] args) throws IOException {
        Socket socket = null;
        ObjectOutputStream objectOutputStream = null;
        ObjectInputStream objectInputStream = null;

        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8888);

        try {
            socket = new Socket();
            socket.connect(inetSocketAddress);
            System.out.println("connect server success");

            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectInputStream = new ObjectInputStream(socket.getInputStream());
            System.out.println("ready send message");

            objectOutputStream.writeUTF("gaorufeng");
            objectOutputStream.flush();

            // 接收并打印服务器传输的数据
            System.out.println(objectInputStream.readUTF());

        } finally {
            if (socket!=null) socket.close();
            if (objectOutputStream!=null) objectOutputStream.close();
            if (objectInputStream!=null) objectInputStream.close();
        }
    }
}

BIO阻塞的两个地方：

1、服务端执行serverSocket.accept()方法后会进入阻塞，直到有客户端请求进来

2、服务器如果是单线程运行（一个线程处理多个客户端请求会进入阻塞），如果数据还没传输完毕，其它客户端socket是无法与服务端建立tcp连接的，虽然socket显示连接成功，但是tcp连接还没建立

BIO适合少量连接的使用场景

BIO多线程通信模型：

2、原生JDK网络编程NIO

面向缓冲的非阻塞IO

1）NIO的Reactor模式

BIO和NIO最大的区别就是线程阻塞和不阻塞，NIO就是基于Reactor模式实现的，所谓Reactor模式，就是往一个组件注册感兴趣的事件并监听，触发对应的事件进行处理，而不是阻塞

2）NIO三大核心组件

Selector选择器：Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器(Selectors)，然后使用一个单独的线程来操作这个选择器，进而"选择"通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道（应用程序将向 Selector 对象注册需要它关注的 Channel，以及具体的某一个 Channel会对哪些 IO 事件感兴趣。Selector 中也会维护一个"已经注册的Channel"的容器）。
Channel管道：被建立的一个应用程序和操作系统交互事件、传递内容的渠道（注意是连接到操作系统）。那么既然是和操作系统进行内容的传递，那么说明应用程序可以通过通道读取数据，也可以通过通道向操作系统写数据，而且可以同时进行读写。
buffer缓冲区：JDK NIO是面向缓冲的。Buffer就是这个缓冲，用于和 NIO 通道进行交互。数据是从通道读入缓冲区，从缓冲区写入到通道中的。以写为例，应用程序都是将数据写入缓冲，再通过通道把缓冲的数据发送出去，读也是一样，数据总是先从通道读到缓冲，应用程序再读缓冲的数据。

java 复制代码

public class NioSelectorServer {

    public static void main(String[] args) throws IOException, InterruptedException {

        // 创建NIO ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        // 设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        // 打开Selector处理Channel，即创建epoll
        Selector selector = Selector.open();
        // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作感兴趣
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务启动成功");

        while (true) {
            // 阻塞等待需要处理的事件发生
            selector.select();

            // 获取selector中注册的全部事件的 SelectionKey 实例
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            // 遍历SelectionKey对事件进行处理
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // 如果是OP_ACCEPT事件，则进行连接获取和事件注册
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = server.accept();
                    socketChannel.configureBlocking(false);
                    // 这里只注册了读事件，如果需要给客户端发送数据可以注册写事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接成功");
                } else if (key.isReadable()) {  // 如果是OP_READ事件，则进行读取和打印
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                    int len = socketChannel.read(byteBuffer);
                    // 如果有数据，把数据打印出来
                    if (len > 0) {
                        System.out.println("接收到消息：" + new String(byteBuffer.array()));
                    } else if (len == -1) { // 如果客户端断开连接，关闭Socket
                        System.out.println("客户端断开连接");
                        socketChannel.close();
                    }
                }
                //从事件集合里删除本次处理的key，防止下次select重复处理
                iterator.remove();
            }
        }
    }
}