网络编程BIO NIO

BIO:

客户端是Socket,服务端ServerSocket，accept() 方法是阻塞方法，一直阻塞直到有客户端连接。可以通过一个while(true)循环，一有客户端连接就创建一个线程，我们可以设想一下如果这个连接不做任何事情的话就会造成不必要的线程开销，线程的创建和销毁是非常消耗资源的，而且一个线程最小占用1M内存，线程之间的切换也消耗资源

注意：

1.网络编程BIO 谨记：关闭了客户端的socket，也要同时关闭服务端的socket，否则会报错，一端会不断接收另外一端数据

2.socket.shutdownOutput(); //必须，否则read一直在等待不会返回-1，阻塞

3.BufferReader readLine:读取一行，只有遇到回车(\r)或者换行符(\n)才会返回读取结果，否则会阻塞，手动加入"\r\n"

由于在客户端使用的readLine()来读取用户输入，所以当用户按下回车键是，readLine() 返回读取内容，但此时返回的内容并不包含换行符（查看readLine()源码，会将\r，\n或者\r\n去除掉），而当在服务器端用readLine()再次读取时，由于读取的内容没有换行符，所以readLine()方法会一直阻塞等待换行符，这就是服务器端没有输出的原因

使用示例：
Client02

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

public class Client02 {
    public static void main(String[] args){
        Socket socket = null;
        Scanner scanner = new Scanner(System.in);
        BufferedOutputStream outputStream = null;
        BufferedInputStream inputStream = null;
        byte[] arr= new byte[1024*1024];
        int length = -1;
        while(true){
            try {
                socket = new Socket("localhost",12345);
                outputStream = new BufferedOutputStream(socket.getOutputStream());
                inputStream = new BufferedInputStream(socket.getInputStream());
                outputStream.write(scanner.nextLine().getBytes());
                outputStream.flush();
                socket.shutdownOutput();  //必须，否则read一直在等待不会返回-1，阻塞
                while((length = inputStream.read(arr))!=-1){
                    System.out.println(new String(arr,0,length));
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    outputStream.close();
                    inputStream.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

Server02
客户端一连接进来创建一个线程去处理客户端请求

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

public class Server02{
    private static final int PORT = 12345;
    ServerSocket server;

    public void init() throws IOException {
        server = new ServerSocket(PORT);
    }

    public static void main(String[] args) throws IOException {
        Server02 s02 = new Server02();
        s02.init();
        while(true){
            Socket socket = s02.server.accept();
            new Thread(new Handle(socket)).start();
        }
    }

}

class Handle implements Runnable{
    private Socket socket;

    Handle(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        BufferedInputStream bin = null;
        BufferedOutputStream bout = null;
        byte[] b = new byte[1024*1024];
        String str = null;
        try {
            bin = new BufferedInputStream(socket.getInputStream());
            bout = new BufferedOutputStream(socket.getOutputStream());
            int length = -1;
            while((length = bin.read(b))!=-1){
                str = new String(b,0,length);
                System.out.println(str);
                bout.write(("服务器已收到:"+str).getBytes());
                bout.flush();
                //必要，否则read() 不会返回-1
                socket.shutdownOutput();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bout.close();
                bin.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

也可以通过线程池来控制线程的数量
Client

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

public class BioClient01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream outputStream = null;
        InputStream inputStream = null;
        Scanner scanner = new Scanner(System.in);
        String str;
        while(true){
            try{
                str = scanner.nextLine();
                if("exit".equals(str)){
                    break;
                }
                socket = new Socket("localhost",2021);
                outputStream = socket.getOutputStream();
                inputStream = socket.getInputStream();
                outputStream.write(str.getBytes());
                outputStream.flush();
                socket.shutdownOutput();
            }catch (UnknownHostException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    inputStream.close();
                    outputStream.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

Server
通过线程池控制线程数量

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 BioServer01 {
    public static void main(String[] args) {
        try {
            ExecutorService service = Executors.newFixedThreadPool(10);
            ServerSocket serverSocket = new ServerSocket(2021);
            while(true){
                Socket socket = serverSocket.accept();
                service.execute(()->{
                    byte[] bytes = new byte[512];
                    int len;
                    InputStream inputStream = null;
                    OutputStream outputStream = null;
                    try{
                        inputStream = socket.getInputStream();
                        while((len = inputStream.read(bytes))!=-1){
                            System.out.println(new String(bytes,0,len));
                        }
                    }catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            inputStream.close();
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });


//                inputStream = socket.getInputStream();
//                while((len = inputStream.read(bytes))!=-1){
//                    System.out.println(new String(bytes,0,len));
//                }
//                inputStream.close();
//                socket.close();

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

NIO

channel 通道 buffer 缓冲区 selector 选择器

channel 向selector 注册，selector 是单线程，监听channel 事件的发生。调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪

数据的方向：client -----data----> buffer ->channel ->channel ->buffer->server

channel -> buffer bufffer->channel channel->channel

channel 有FileChannel(IO),DatagramChannel(UDP), TCP(客户端和服务端): SocketChannel, ServerSocketChannel

Buffer: 实现有：ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer，分别对应基本数据类型: byte, char, double, float, int, long, short。有几个变量:Capacity 容量，position 下一个要操作的数据元素的位置,limit 缓冲区中不可操作的下一个元素的位置。flip() ->position=0, clear() 恢复

Selector: 单线程选择器，Channel需要向Selector注册，Selector 监听Channel事件，可以通过While(true)不断循环判断Selector 是否有事件，有事件通过Iterator 迭代器迭代事件去处理。open() 方法打开选择器，select()方法会阻塞，直到有事件发生，注册事件有

1. SelectionKey.OP_CONNECT
2. SelectionKey.OP_ACCEPT
3. SelectionKey.OP_READ
4. SelectionKey.OP_WRITE

检测channel中什么事件或操作已经就绪

selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

SelectionKey可以获取Channel,Selector

使用示例：

Client

/**
 * 2021年02月15日
 * NIO Client
 */

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

public class Client05 {
    public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open(new InetSocketAddress("localhost", 214));
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        sc.configureBlocking(false);
        Scanner scanner = new Scanner(System.in);
        String str = null;

        str = scanner.nextLine();
        buffer = ByteBuffer.wrap(str.getBytes());
        sc.write(buffer);
        buffer.clear();
        sc.close();


    }
}

Server

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class Server05 {
    public static void main(String[] args) throws IOException, InterruptedException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress("localhost",214));
        serverSocketChannel.configureBlocking(false);
        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        while(true){
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                if(key.isAcceptable()){
                    accessbleHandle(selector,key,serverSocketChannel);
                }
                if(key.isReadable()){
                    readableHandle(key);
                }
                //处理完后移除
                iterator.remove();
            }
        }


    }

    /**
     * 从Channel 到 Buffer
     */
    private static void readableHandle(SelectionKey key) throws IOException, InterruptedException {
        SocketChannel sc = (SocketChannel) key.channel();
        int len = -1;
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while((len = sc.read(buffer))!=-1){
            Thread.sleep(1000);
            System.out.println(new String(buffer.array()));
            buffer.clear();
        }
        //关闭通道
        sc.close();
    }

    private static void accessbleHandle(Selector selector,SelectionKey key, ServerSocketChannel serverSocketChannel) throws IOException {
        SocketChannel channel = serverSocketChannel.accept();
        channel.configureBlocking(false);
        channel.register(selector,SelectionKey.OP_READ);
    }
}