io-0-socket

socket

服务端
    1.创建一个特定端口的ServerSocket
    2.监听端口的入站连接（阻塞），直到客户端尝试连接
    3.服务端和客户端根据已协商的协议交互
    4.服务器或客户端关闭连接
客户端
    1.创建socket连接指定端口和地址
    2.服务端和客户端根据已协商的协议交互
    3.客户端关闭连接

单线程服务端

//服务器端
  // 监听8888端口
        ServerSocket serverSocket=new ServerSocket(8888) ;
        while (true) {
            //接受连接（此方法是阻塞的）
            Socket conection=serverSocket.accept();
            //获取输出流
            OutputStream out = conection.getOutputStream();
            //转化为writer 写文本
            Writer writer=new OutputStreamWriter(out,"utf-8");
            Date date=new Date();
            writer.write(date.toLocaleString());
            writer.flush();
            //关闭连接
            conection.close();
        }

客户端

//客户端
 try (Socket socket=new Socket("127.0.0.1", 8888)) {
            InputStream in=socket.getInputStream();
            BufferedReader reader=new BufferedReader(new InputStreamReader(in, "utf-8"));
            StringBuilder stringBuilder=new StringBuilder();
            String line  = null ;
            //读取数据
            while ((line=reader.readLine()) != null) {
                stringBuilder.append(line);
            }
         System.out.println(stringBuilder.toString());
        } catch (IOException e) {
            System.out.println( e);
        }
        //输出
2017-7-11 22:55:57

多线程服务端

 ServerSocket server=new ServerSocket(8888);
        while (true) {
            Socket socket=server.accept();
           new Thread(
                    () ->{
                        try {
                            //获取输出流
                            OutputStream out = socket.getOutputStream();
                            //转化为writer 写文本
                            Writer writer=new OutputStreamWriter(out,"utf-8");
                            Date date=new Date();
                            writer.write(date.toLocaleString());
                            writer.flush();
                        } catch (IOException e) {
                            System.out.println(e);
                        }finally {
                            //关闭连接
                            if (socket != null) {
                                try {
                                    socket.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }

                        }
                    }
            ).start();
        }

服务端socket选项

    1.SO_TIMEOUT:等待入站连接时间（毫秒）
        public void setSotimeout（int timeout）；
    2.SO_RCVBUF：设置接受客户端缓冲区大小（需要在服务端绑定端口前设置）
        public void setReceiveBufferSize（int size）；

  try (ServerSocket serverSocket=new ServerSocket(8888)) {
            serverSocket.setSoTimeout(3000); // 3秒未连接报错
            try {
                Socket accept=serverSocket.accept();
                accept.close();
            } catch (SocketTimeoutException e) {
                System.out.println(" accept is error  " + e);
            }
        } catch (Exception e) {
            System.out.println(e);
        }
        //输出
        accept is error  java.net.SocketTimeoutException: Accept timed out

channel

基于通道的客户端

SocketAddress socketAddress=new InetSocketAddress("127.0.0.1", 8888);
        //开启通道
        SocketChannel client=SocketChannel.open(socketAddress);  
        ByteBuffer byteBuffer=ByteBuffer.allocate(100);
        WritableByteChannel out=Channels.newChannel(System.out);
        while (true) {
            int read=client.read(byteBuffer);
            //获取数据 可能read为0 没有任何数据
            if (read > 0) {
                byteBuffer.flip();
                out.write(byteBuffer);
                byteBuffer.clear();
            }
            if (read == -1) 
                break;    //连接异常
        }
        client.close();

基于通道的服务端

  //通道数据
        byte[] send=new byte[95 * 2];
        for (byte i=' '; i <= '~'; i++) {
            send[i - ' ']=i;  //填充数据
            send[i + 95 - ' ']=i; //填充相同的数据
        }

        //打开服务端通道
        ServerSocketChannel serverChannel;
        Selector selector;
        try {
            serverChannel=ServerSocketChannel.open();
            ServerSocket server=serverChannel.socket();
            //绑定监听端口
            server.bind(new InetSocketAddress(8888));
            //设置服务端处于非阻塞模式，如果没有连接，将accept获取为null。
            serverChannel.configureBlocking(false);

            //打开选择器
            selector=Selector.open();
            //注册选择器
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        } catch (Exception e) {
            System.out.println(e);
            return;
        }

        while (true) {
            try {
                selector.select();
            } catch (IOException e) {
                e.printStackTrace();
                break;
            }

            Set<SelectionKey> selectionKeys=selector.selectedKeys();
            Iterator<SelectionKey> iterator=selectionKeys.iterator();

            while (iterator.hasNext()) {
                SelectionKey key=iterator.next();
                iterator.remove();
                try {
                    if (key.isAcceptable()) {
                        ServerSocketChannel server=(ServerSocketChannel) key.channel();

                        //打开客户端通道
                        SocketChannel clientChannel=server.accept();
                        //设置客户端处于非阻塞模式，允许服务器处理多并发连接
                        clientChannel.configureBlocking(false);
                        //客户端注册
                        SelectionKey clientKey=clientChannel.register(selector, SelectionKey.OP_WRITE);
                        ByteBuffer buffer=ByteBuffer.allocate(74);
                        buffer.put(send, 0, 72);
                        buffer.put((byte) '\r');
                        buffer.put((byte) '\n');
                        buffer.flip();
                        clientKey.attach(buffer);
                    } else if (key.isWritable()) {
                        SocketChannel client=(SocketChannel) key.channel();
                        ByteBuffer buffer=(ByteBuffer) key.attachment();
                        if (!buffer.hasRemaining()) {
                            //用下一行重更新填充缓冲区
                            buffer.rewind();
                            //得到上一次的首字符
                            int first=buffer.get();
                            buffer.rewind();
                            int postion=first - ' ' + 1;
                            buffer.put(send, postion, 72);
                            buffer.put((byte) '\r');
                            buffer.put((byte) '\n');
                            buffer.flip();
                        }
                        client.write(buffer);
                    }
                } catch (IOException e) {
                    key.cancel();
                    try {
                        key.channel().close();
                    } catch (Exception ex) {
                        System.out.println(ex);
                    }
                    e.printStackTrace();
                }
            }
        }
    }