Java聊天室

通过 TCP 与 Socket 实现一对多聊天室

具体代码如下所示：

客户端：

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.SocketException;
import java.util.Scanner;

public class SocketClient {
    public static final int port = SocketServer.port;
    public static final String address = SocketServer.address;
    //为了方便使用直接定义为静态属性，，调用很方便。
    private static Socket client = null;

    private static String clientName ;

    public static void main(String[] args) throws IOException, InterruptedException {
        client = new Socket(address, port);
        new SendThread().start();
        new ReceiveThread().start();
        System.out.println("请先设置用户名,直接输入您要起的名字就行！");
        Scanner in = new Scanner(System.in);//接收输入
        clientName = in.next();
        if(clientName != ""){
            System.out.println("用户名设置成功，你的用户名为"+clientName);
        }
        while (!client.isClosed()) {
            Thread.sleep(1000);
        }
    }

    /**
     * 发送Socket的socket
     *
     * @param outStr 待发送信息
     * @param client 客户端Socket
     */
    private static void sendSocketServer(String outStr, Socket client) {
        try {
            ObjectOutputStream o = new ObjectOutputStream(client.getOutputStream());
            o.writeObject(outStr);
            o.flush();//刷新，将流发出去
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 发送信息线程
     */
    static class SendThread extends Thread {
        @Override
        public void run() {
            super.run();
            while (!client.isClosed()) {//插入停止条件
                Scanner in = new Scanner(System.in);//接收输入
                String inputStr = in.next();
                if (inputStr != null) {
                    sendSocketServer(clientName+":"+inputStr, client);//发送消息
                }
            }
        }
    }

    /**
     * 接受信息线程，，运行在后台，，等待输入信息
     */
    static class ReceiveThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                InputStream serverInputStream = client.getInputStream();
                while (!client.isClosed() && serverInputStream != null) {//插入停止条件
                    ObjectInputStream ois = new ObjectInputStream(serverInputStream);
                    String inputStr = (String) ois.readObject();
                    //获取输出流，经过测试发现，输入流貌似是阻塞，，也就是没有输入时他就停在这里了，一直等着输入，所以无需加入Thread.sleep().
                    System.out.println(inputStr);
                }
            } catch (SocketException e) {
                try {
                    client.close();//服务器断开连接此时需要关闭客户端连接
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

}

服务器：

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class SocketServer {
    //用于保存客户端Socket
    public static List<Socket> clientSocketList = new ArrayList<Socket>();
    //服务器端口
    public static final int port = 8080;
    //服务器主机名
    public static final String address = "localhost";
    //服务器接收消息，以日志形式记录，动态
    private static Logger log = Logger.getLogger("server");

    public static void main(String[] args) throws IOException {
        //创建ServerSocket监听
        ServerSocket serverSocket = new ServerSocket(port);
        log.log(Level.INFO, "服务器开启监听，端口：" + port);
        while (true) {
            Socket client = serverSocket.accept();//阻塞监听
            new SocketDoWith(client).start();//创建线程对其进行操作
            clientSocketList.add(client);//将链接添加到，集合中，用以群发
        }
    }

    //服务器处理客户端Socket消息线程
    static class SocketDoWith extends Thread {
        Logger log = Logger.getLogger("server");
        private Socket socket = null;

        public SocketDoWith(Socket socket) {
            this.socket = socket;
        }

        public void run() {
            if (socket == null) return;
            try {
                String s = null;
                while (!socket.isClosed()) {
                    //将输入封装成对象流（处理起来更方便）
                    ObjectInputStream oi = new ObjectInputStream(socket.getInputStream());
                    s = (String) oi.readObject();
                    //将输入作为日志打印
                    log.log(Level.INFO, "服务器接收内容：" + s);

                    //把信息输出到，当前连接的所有客户端。
                    for (Socket client : clientSocketList) {
                        if (!client.isClosed()) {//防止发现送消息给，，断连客户端。
                            ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());
                            oos.writeObject(s);
                            oos.flush();
                            log.log(Level.INFO, "服务器发送内容：" + s);//+ client.toString() + "  "
                        } else {//断开的Socket就移除
                            clientSocketList.remove(client);//移除
                        }
                    }
                }
            } catch (SocketException e) {
                log.log(Level.INFO, "客户端断开连接！！！");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}