import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;

public class BIOClient {
    public static void main(String[] args) {
        new BIOClient().start("localhost", 6666);
    }

    public void start(String host, int port) {
        // 初始化 socket
        Socket socket = new Socket();

        try {
            // 設(shè)置 socket 連接
            SocketAddress remote = new InetSocketAddress(host, port);
            socket.setSoTimeout(5000);
            socket.connect(remote);

            // 發(fā)送數(shù)據(jù)
            PrintWriter writer = getWriter(socket);
            writer.write("hello server");
            writer.flush();

//            // 發(fā)起請(qǐng)求
//            PrintWriter writer = getWriter(socket);
//            writer.write(compositeRequest(host));
//            writer.flush();
//
//            // 讀取響應(yīng)
//            String msg;
//            BufferedReader reader = getReader(socket);
//            while ((msg = reader.readLine()) != null) {
//                System.out.println(msg);
//            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(in));
    }

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream out = socket.getOutputStream();
        return new PrintWriter(new OutputStreamWriter(out));
    }

    private String compositeRequest(String host) {
        return "GET / HTTP/1.1\r\n" +
                "Host: " + host + "\r\n" +
                "User-Agent: curl/7.43.0\r\n" +
                "Accept: */*\r\n\r\n";
    }
}

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

public class BIOServer {
    public static void main(String[] args) throws Exception {
        // 創(chuàng)建一個(gè)線程池
        ExecutorService pool = Executors.newCachedThreadPool();
        // 創(chuàng)建 ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        while (true) {
            // 等待客戶端連接
            final Socket socket = serverSocket.accept();
            // 接收到一個(gè)客戶端連接 放入線程池進(jìn)行處理
            pool.execute(() -> process(socket));
        }
    }

    static void process(Socket socket) {
        try {
            byte[] bytes = new byte[1024];
            // 通過(guò) socket 獲取輸入流
            InputStream inputStream = socket.getInputStream();
            // 循環(huán)讀取客戶端發(fā)送的數(shù)據(jù)
            while (true) {
                // 沒(méi)有數(shù)據(jù)的時(shí)候這里會(huì)阻塞等待
                int read = inputStream.read(bytes);
                if (read == -1) break;
                // 輸出客戶端發(fā)送的數(shù)據(jù)
                System.out.println(new String(bytes, 0, read));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 說(shuō)明 1.MappedByteBuffer 可讓文件直接在內(nèi)存（堆外內(nèi)存）修改,操作系統(tǒng)不需要拷貝一次
 */
public class MappedByteBufferTest {

    public static void main(String[] args) throws Exception {

        RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");
        //獲取對(duì)應(yīng)的通道
        FileChannel channel = randomAccessFile.getChannel();

        /**
         * 參數(shù) 1:FileChannel.MapMode.READ_WRITE 使用的讀寫(xiě)模式
         * 參數(shù) 2：0：可以直接修改的起始位置
         * 參數(shù) 3:5: 是映射到內(nèi)存的大小（不是索引位置），即將 1.txt 的多少個(gè)字節(jié)映射到內(nèi)存
         * 可以直接修改的范圍就是 0-5
         * 實(shí)際類(lèi)型 DirectByteBuffer
         */
        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);

        mappedByteBuffer.put(0, (byte) 'H');
        mappedByteBuffer.put(3, (byte) '9');
        mappedByteBuffer.put(5, (byte) 'Y');//IndexOutOfBoundsException

        randomAccessFile.close();
        System.out.println("修改成功~~");
    }
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class GroupChatServer {

    // 定義屬性
    private Selector selector;
    private ServerSocketChannel listenChannel;

    private static final int PORT = 6667;

    // 構(gòu)造器執(zhí)行初始化工作
    public GroupChatServer() {
        try {
            // 得到選擇器
            selector = Selector.open();
            // 監(jiān)聽(tīng)端口的主線程
            listenChannel = ServerSocketChannel.open();
            // 綁定端口
            listenChannel.socket().bind(new InetSocketAddress(PORT));
            // 設(shè)置非阻塞模式
            listenChannel.configureBlocking(false);
            // 將該 listenChannel 注冊(cè)到 selector
            listenChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void listen() {
        try {
            // 循環(huán)處理
            while (true) {
                int count = selector.select();
                // 有事件處理
                if (count > 0) {
                    // 遍歷得到 selectionKey 集合
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        // 取出 selectionKey
                        SelectionKey key = iterator.next();
                        // 監(jiān)聽(tīng)到 accept
                        if (key.isAcceptable()) {
                            SocketChannel sc = listenChannel.accept();
                            sc.configureBlocking(false);
                            // 將該 sc 注冊(cè)到 selector
                            sc.register(selector, SelectionKey.OP_READ);
                            // 提示
                            System.out.println(sc.getRemoteAddress() + " 上線 ");
                        }
                        if (key.isReadable()) {// 通道發(fā)送read事件，即通道是可讀的狀態(tài)
                            // 處理讀(專(zhuān)門(mén)寫(xiě)方法..)
                            readData(key);
                        }
                        // 當(dāng)前的 key 刪除，防止重復(fù)處理
                        iterator.remove();
                    }
                } else {
                    System.out.println("等待....");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 發(fā)生異常處理....
        }
    }

    // 讀取客戶端消息
    public void readData(SelectionKey key) {
        SocketChannel channel = null;
        try {
            // 得到 channel
            channel = (SocketChannel) key.channel();
            // 創(chuàng)建 buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int count = channel.read(buffer);// NIO這里不會(huì)阻塞 因?yàn)槭录|發(fā)時(shí)必然已經(jīng)有數(shù)據(jù)了 所以叫非阻塞IO
            // 根據(jù) count 的值做處理
            if (count > 0) {
                // 把緩存區(qū)的數(shù)據(jù)轉(zhuǎn)成字符串
                String msg = new String(buffer.array());
                // 輸出該消息
                System.out.println("form客戶端:" + msg);
                // 向其它的客戶端轉(zhuǎn)發(fā)消息(去掉自己),專(zhuān)門(mén)寫(xiě)一個(gè)方法來(lái)處理
                sendInfoToOtherClients(msg, channel);
            }
        } catch (IOException e) {
            try {
                System.out.println(channel.getRemoteAddress() + "離線了..");
                // 取消注冊(cè)
                key.cancel();
                // 關(guān)閉通道
                channel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }
    }

    // 轉(zhuǎn)發(fā)消息給其它客戶(通道)
    private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {
        System.out.println("服務(wù)器轉(zhuǎn)發(fā)消息中...");
        // 遍歷所有注冊(cè)到 selector 上的 SocketChannel,并排除 self
        for (SelectionKey key : selector.keys()) {
            // 通過(guò) key 取出對(duì)應(yīng)的 SocketChannel
            Channel targetChannel = key.channel();
            // 排除自己
            if (targetChannel instanceof SocketChannel && targetChannel != self) {
                // 轉(zhuǎn)型
                SocketChannel dest = (SocketChannel) targetChannel;
                // 將 msg 存儲(chǔ)到 buffer
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                // 將 buffer 的數(shù)據(jù)寫(xiě)入通道
                dest.write(buffer);
            }
        }
    }

    public static void main(String[] args) {
        // 創(chuàng)建服務(wù)器對(duì)象
        GroupChatServer groupChatServer = new GroupChatServer();
        groupChatServer.listen();
    }
}