fx java 聊天室 聊天室java 代码

聊天室

实现简单聊天室
能够实现简单功能
1 查看在线人名单 2 私聊 3 群发 4 退出
客户端代码

public class Client {

    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 5000);
        System.out.println("已连接服务器");
        //建立连接
        System.out.println("请输入一个昵称");
        Scanner input = new Scanner(System.in);
        String s = input.next();
        OutputStream out = socket.getOutputStream();
        InputStream in = socket.getInputStream();
        out.write(s.getBytes());
        //发送请求
        new Thread(()->{
            while (true){
                try {
                    byte[] bt = new byte[1024*8];
                    int l= 0;
                    while(true){
                        l =in.read(bt);
                        if(l==-1) break;
                        System.out.println(new String(bt, 0, l));
                    }

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


            }
        }).start();

        //输出接收的消息
        new Thread(()->{
            String s1;
            System.out.println("请选择功能：");
            System.out.println("1.查看在线人名单");
            System.out.println("2.私聊(2 人名 信息)");
            System.out.println("3.群发(3 群发信息)");
            System.out.println("4.退出");
            while(true){

                try {
                    s1= input.next();
                    out.write(s1.getBytes());
                switch (s1) {
                    case "2":
                        s1=input.next();
                        out.write(s1.getBytes());
                        s1=input.next();
                        out.write(s1.getBytes());
                       break;
                    case "3":
                        s1=input.next();
                        out.write(s1.getBytes());break;
                    case "4":System.exit(0);
               }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

客户端需要两个线程同时工作，一个线程从控制台读取数据，一个线程将从服务器返回的数据显示在控制台上。

服务器代码

public class task implements Runnable {

    private Socket socket;
    final static ConcurrentHashMap<Socket, String> map = new ConcurrentHashMap<>();
    public task(Socket socket) {
        this.socket=socket;
    }
    @Override
    public void run() {
        try {
            Login(socket);
            handle(socket);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static void handle(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        byte[] bt = new byte[1024*8];
        int l= 0;
        Set<Socket> sockets=  map.keySet();
        Socket sockett = null;
        String s1,s2;
        //读取请求

        while (true){
            l = in.read(bt);
            String s =new String(bt,0,l);
            switch (s){
                case "1":
                    //响应名单
                    Collection<String> list = map.values();
                    out.write(list.toString().getBytes());break;
                case "2"://读取目的用户
                    l = in.read(bt);
                    s1 =new String(bt,0,l);
                    //寻找目的用户的socket
                    for (Socket socket1 : sockets) {
                        if(map.get(socket1).equals(s1)){
                            sockett=socket1;
                            break;
                        }
                    }
                    //读取内容
                    l = in.read(bt);
                    s2 =new String(bt,0,l);
                    //响应输出
                    OutputStream out1 = sockett.getOutputStream();
                    out1.write((map.get(socket)+":"+s2).getBytes());break;

                case "3": l = in.read(bt);
                    s2 =new String(bt,0,l);
                    for (Socket socket1 : sockets) {
                        OutputStream out2 = socket1.getOutputStream();
                        out2.write((map.get(socket)+":"+s2).getBytes());
                    }break;
                case "4":
                    String s3=map.get(socket);
                            map.remove(socket);
                    System.out.println(s3+"离开了");
                    Thread thread =Thread.currentThread();
                    thread.stop();
            }

        }

    }

    //建立连接
    private static void Login(Socket socket) throws IOException {

        try {
            InputStream in = socket.getInputStream();
            OutputStream out = socket.getOutputStream();
            byte[] bt = new byte[1024*8];
            int l=in.read(bt);
            String s =new String(bt,0,l);
            System.out.println(s+"已连接");
            map.put(socket,s);
            s="欢迎您"+s;
            out.write(s.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class Server {

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(5000);
        System.out.println("服务已启动，等待连接");
        ExecutorService service = new ThreadPoolExecutor(10, 10, 0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        while(true) {
            // 2. 调用accept 等待客户端连接
            Socket socket = serverSocket.accept();
            service.submit(new task(socket));
        }
    }
}

在实现过程中，每次先给服务器发送请求代号。如果是1则服务器之间返回Map信息，如果是2则服务器再接受两条信息，分别是发送对象和信息内容，如果是3则服务器再接受信息内容。

一般客户端-服务器编程应该使用同一的协议，而且客户端与服务器的接受和发送内容很相似，可以抽象为一个父类，只是接受信息后的处理不同。而子类只需要完成接受后的处理操作就好。
协议：
先发送一个字节的请求代号，然后发送两个字节的消息长度，最后发送消息。

抽象父类

public abstract class AbstractCS {
		//接受消息
    protected void receive(Socket socket, InputStream in, OutputStream out) throws IOException {
        while (true) {
            int cmd = in.read();
            if (cmd == -1) {
                break;
            }
            int hi = in.read();
            int lo = in.read();
            int length = (hi << 8) + lo;
            byte[] content = new byte[length];
            in.read(content);
            String str = new String(content, "utf-8");
            handle(socket, out, cmd, str);
        }
    }
		//发送消息
    protected void send(OutputStream out, int cmd, String content) throws IOException {
        out.write(cmd);
        byte[] bytes = content.getBytes("utf-8");
        int length = bytes.length;
        out.write(0xFF & length >> 8);
        out.write(0xFF & length);
        out.write(bytes);
    }
		//自定义接受消息后的处理
    protected abstract void handle(Socket socket, OutputStream out, int cmd, String str) throws IOException;
}

客户端

public class Client extends AbstractCS {

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

    }

    public void start() throws IOException {
        Socket socket = new Socket("localhost", 5000);

        // 第一个线程负责从控制台获取输入
        new Thread(() -> {
            try (
                    Scanner scanner = new Scanner(System.in);
                    OutputStream out = socket.getOutputStream();
            ) {
                System.out.println("请输入昵称:");
                Scanner s = new Scanner(System.in);
                String name = s.nextLine();
                send(socket.getOutputStream(),1,name);
                input(scanner, out);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

        // 第二个线程负责接收服务器端的输入
        new Thread(() -> {
            try (
                    InputStream in = socket.getInputStream();
                    OutputStream out = socket.getOutputStream();
            ) {
                receive(socket, in, out);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }

    @Override
    protected void handle(Socket socket, OutputStream out, int cmd, String content) throws IOException {
        switch (cmd){
            case 5:
                System.out.println(content);break;
            case 6:
                System.out.println(content);break;
            case 7:
                System.out.println(content);break;
            case 8:
                System.out.println(content);break;

        }
    }


    protected void input(Scanner scanner, OutputStream out) {
        try {
            while (scanner.hasNextLine()) {
                String str = scanner.nextLine();
                char cmd = str.charAt(0);
                // 发送消息
                // 2 获取用户
                // 3 内容 群聊
                // 4 内容 对方名字 私聊
                // 对命令进行分析
                switch (cmd) {
                    case '2':
                        send(out, 2, "");
                        break;
                    case '3':
                        String content = str.substring(2);
                        send(out, 3, content);
                        break;
                    case '4':
                        String content1 = str.substring(2);
                        send(out, 4, content1);
                        break;
                    default:
                        System.out.println("不支持的命令");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务器

public class Server extends AbstractCS {
    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }

    public void start() {
        System.out.println("==== 【畅聊】聊天室，版本 v2");
        ExecutorService service = Executors.newFixedThreadPool(10);
        try (ServerSocket serverSocket = new ServerSocket(5000)) {
            while (true) {
                // 来一个连接，开一个空闲线程处理请求，但上限是10
                Socket socket = serverSocket.accept();
                service.submit(() -> {
                    try (
                            InputStream in = socket.getInputStream();
                            OutputStream out = socket.getOutputStream();
                    ) {
                        this.receive(socket, in, out);
                    }
                    catch (SocketException ex){
                        map.remove(socket);
                    }
                    catch (IOException e) {
                        e.printStackTrace();
                    }
                });
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private Map<Socket, String> map = new ConcurrentHashMap<>();
    @Override
    protected void handle(Socket socket, OutputStream out, int cmd, String content) throws IOException {
        switch (cmd) {
            case 1:
                map.put(socket, content);
                send(out,5, "欢迎[" + content + "]来到聊天室");
                break;
            case 2:
                send(out,6, map.values().toString());
                break;
            case 3:
                String nick = map.get(socket);
                String c = nick+": "+content;
                map.forEach((s, value)->{
                    try {
                        send(s.getOutputStream(),7,c);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                });
                break;
            case 4:
                String[] array = content.split(" ");
                String n = array[0]; // 对方的名字
                String c2 = array[1]; // 内容
                boolean found = false;
                for (Map.Entry<Socket, String> entry :map.entrySet()) {
                    // 找到了
                    if(entry.getValue().equals(n)) {
                        send(entry.getKey().getOutputStream(),8, map.get(socket)+"："+c2);
                        found = true;
                        break;
                    }
                }
                if(!found) {
                    send(out,8, "聊天室没有这个人");
                }
                break;

        }
    }
}