NIO聊天室

服务端

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.nio.charset.StandardCharsets;
import java.util.Set;

/**
 * 使用NIO完成聊天室服务端
 */
public class NIOServer {
    public void start(){
        try{
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();   //创建阻塞通道
            serverSocketChannel.configureBlocking(false);       //设置为非阻塞
            serverSocketChannel.bind(new InetSocketAddress(8088));  //绑定端口

            Selector selector = Selector.open();    //创建多路选择器
            serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);  //将此通道注册到多路选择器上
            //让主线程一直关注选择器是否有事件需要处理了
            while (true){
                selector.select();      //开始处理事件        //当选择器发现注册在它上面的某些通道有事件时，该方法会立即返回，否则会阻塞
                Set<SelectionKey> keySet = selector.selectedKeys(); //获取目前所有有事件的通道
                for (SelectionKey key: keySet){      //遍历并处理每一个事件
                    if (key.isAcceptable()){    //判断该事件是否为可接受客户端链接的(ServerSocketChannel注册的OP_ACCEPT所响应的事件)
                        ServerSocketChannel ssc = (ServerSocketChannel) key.channel();    //获取该事件对应通道
                        SocketChannel socketChannel = ssc.accept();     //“接电话”。
                        if (socketChannel==null){       //accept方法可能返回null
                            continue;       //null就忽略操作
                        }
                        socketChannel.configureBlocking(false);     //将SocketChannel设置为非阻塞式
                        socketChannel.register(selector,SelectionKey.OP_READ);  //将SocketChannel注册到多路选择器上
                        System.out.println("一个客户端链接了");

                    //如果该事件是表示有消息可读(该事件一定是SocketChannel响应的)
                    }else if (key.isReadable()){
                        SocketChannel sc = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        sc.read(buffer);      //读取客户端发送过来的所有数据存入buffer
                        buffer.flip();
                        if (buffer.limit()==0){   //如果本次一个字节都没有读取到就忽略
                            buffer.clear();
                            continue;
                        }

                        //获取缓冲区冲本次读取到的所有字节:0--limit
                        //创建一个与buffer中目前可用字节一样长的一个字节数组
                        byte[] data = new byte[buffer.limit()];
                        buffer.get(data);       //要求buffer将所有可用字节存入我们传入的字节数组data中
                        String message = new String(data, StandardCharsets.UTF_8);
                        System.out.println("客户端说："+message);
                    }
                }
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        NIOServer server = new NIOServer();
        server.start();
    }
}

客户端

import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

/**
 * 聊天室客户端
 */
public class Client {
    /*
        java.net.Socket 套接字
        封装了TCP协议的通讯细节，使用它可以和远端计算机建立TCP链接，并基于两条流的读写操作
        完成与远端计算机的数据交换。
    */
    private Socket socket;

    /**
     * 构造方法，用于初始化客户端
     */
    public Client(){
        try {
            System.out.println("正在连接服务端...");
            socket = new Socket("localhost",8088);
            System.out.println("与服务端建立链接！");
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    /**
     * 客户端开始工作的方法
     */
    public void start(){
        //启动一条线程来处理读取服务端发送过来消息的操作
        ServerHandler handler = new ServerHandler();
        Thread t = new Thread(handler);
        t.setDaemon(true);     //如果不再发消息了也就不用再读客户端消息了,所以可以设置为守护线程
        t.start();
        try{
            OutputStream out = socket.getOutputStream();        //获取一个字节输出流
            //转换输出流(高级流)，1:负责衔接字符与字节流  2:将写出的字符转换为字节
            OutputStreamWriter  osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);
            //缓冲字符输出流(高级流)，负责块写文本数据提高写出效率
            BufferedWriter bw = new BufferedWriter(osw);
            //PrintWriter(高级流)，1:按行写出字符串  2:自动行刷新
            PrintWriter pw = new PrintWriter(bw,true);

            Scanner scanner = new Scanner(System.in);
            System.out.println("请开始输入内容，单独输入exit退出。");
            while (true){
                String line = scanner.nextLine();
                if ("exit".equals(line)){
                    break;
                }
                pw.println(line);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                socket.close();   //调用socket的close可以与远端计算机断开链接，并且自动关闭通过它获取的流
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 该线程任务负责读取服务端发送过来的消息
     */
    private class ServerHandler implements Runnable{
        public void run(){
            try {
                //通过socket获取输入流,用于读取服务端发送过来的消息
                InputStream in = socket.getInputStream();
                InputStreamReader  isr = new InputStreamReader(in,StandardCharsets.UTF_8);
                BufferedReader br = new BufferedReader(isr);

                String line;
                //循环读取服务端发送过来的每一条消息并输出
                while ((line = br.readLine())!=null){
                    System.out.println(line);
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.start();
    }
}