多个客户端--多人聊天+私聊

在多人聊天室的基础上增加了私聊功能。 实现方法：在Send类中添加name区别客户端，用于客户端；在MyChannel中添加name区别客户端连接，用于服务端。 1.服务端

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;


/**
 * 创建服务器
 * 发送数据：输出流
 * 接收数据：输入流
 */
public class MyServer {
    //存放服务端与客户端的连接
    private List<MyChannel> all = new ArrayList<>();
    public static void main(String[] args) throws IOException {
        new MyServer().start();
    }
    public void start() throws IOException {
        ServerSocket server = new ServerSocket(8888);
        while(true) {
            Socket socket = server.accept();
            MyChannel myChannel = new MyChannel(socket);
            all.add(myChannel);
            new Thread(myChannel).start();
        }
    }
    /**
     * 一个客户端一条道路，
     * 一个客户端一个线程。
     * 1.输入流
     * 2.输出流
     * 3.接收数据
     * 4.发送数据
     * 成员内部类，静态方法不能访问。
     */
    class MyChannel implements Runnable{
        //输入流
        private DataInputStream dis;
        //输出流
        private DataOutputStream dos;
        //控制线程的标识符
        private boolean isRunning = true;
        //名称  给每个连接命名，区别客户端  不考虑重名
        private String name;
        //初始化建立管道
        public MyChannel(Socket socket) {
            try {
                dis = new DataInputStream(socket.getInputStream());
                dos = new DataOutputStream(socket.getOutputStream());

                
                name = dis.readUTF();

                
                send("欢迎您进入聊天室！");//发送给自己客户端
                sendOthers(name + "进入了聊天室！", true); //发给其他的客户端
            } catch (IOException e) {
                e.printStackTrace();
                CloseUtil.closeAll(dis, dos);
                all.remove(this);
                isRunning = false;
            }
        }
        //读取数据
        private String receive() {
            String msg = "";
            try {
                msg = dis.readUTF();
            } catch (IOException e) {
                e.printStackTrace();
                CloseUtil.closeAll(dis, dos);
                all.remove(this);
                isRunning = false;
            }
            return msg;
        }
        //发送给this数据
        private void send(String msg) {
            if(msg == null || msg.equals("")) {
                return;
            }
            try {
                dos.writeUTF(msg);
                dos.flush();
            } catch (IOException e) {
                e.printStackTrace();
                CloseUtil.closeAll(dis, dos);
                all.remove(this);
                isRunning = false;
            }
        }
        //发送给其他客户端
        private void sendOthers(String msg, boolean isSysMsg) {
            //是否为私聊
            if(msg.startsWith("@") && msg.indexOf(":") != -1) {//向一个特定的人发消息，格式为@xxx:message
                //获取name
                String name = msg.substring(1, msg.indexOf(":"));
                //获取内容
                String content = msg.substring(msg.indexOf(":") + 1);
                for(MyChannel other:all) {
                    if(other.name.equals(name)) {
                        other.send(this.name + "对您悄悄地说：" + content);
                    }
                }
            } else {//向全体发消息
                //遍历容器
                for(MyChannel other : all) {
                    if(other == this) {
                        continue;
                    }
                    if(isSysMsg) {//是系统消息
                        //发送给其他客户端
                        other.send("系统信息：" + msg);
                    } else {//不是系统消息
                        //发送给其他客户端
                        other.send(name + "对所有人说：" + msg);
                    }

                    
                }
            }
        }
        @Override
        public void run() {
            while(isRunning) {
                sendOthers(receive(), false);
            }
        }
    }
}

2.客户端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
/**
 * 创建客户端：发送数据+接收数据
 * 发送数据：输出流
 * 接收数据：输入流
 * 输出流和输入流应该彼此独立，使用线程处理。
 * 加入名称。
 */
public class MyClient {
    public static void main(String[] args) throws IOException {
        //通过名称判断不同的客户 端，存放在Send类中。
        System.out.println("请输入名称：");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String name = br.readLine();
        if(name.equals("")) {
            return;
        }

        
        Socket client = new Socket("localhost", 8888);
        //发送  控制台输入并发送到服务端
        new Thread(new Send(client, name)).start();//一条路径
        //接收  接收服务端数据并打印
        new Thread(new Receive(client)).start();//一条路径
    }
}

发送数据线程

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;


/**
 * 发送数据  线程
 */
public class Send implements Runnable{
    //控制台输入流
    private BufferedReader console;
    //管道输出流
    private DataOutputStream dos;
    //控制线程的标识符
    private boolean isRunning = true;
    //名称  不考虑重名
    private String name;
    //初始化建立管道
    public Send(Socket socket, String name) {
        try {
            console = new BufferedReader(new InputStreamReader(System.in));
            dos = new DataOutputStream(socket.getOutputStream());
            this.name = name;
            send(name);
        } catch (IOException e) {
            e.printStackTrace();
            isRunning = false;
            CloseUtil.closeAll(dos, console);
        }
    }

    
    /**
     * 1.从控制台接收数据
     * 2.向服务端发送数据
     */
    //1.从控制台接收数据
    private String getMsgFromConsole() {
        String msg = "";
        try {
            msg = console.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            isRunning = false;
            CloseUtil.closeAll(dos, console);
        }
        return msg;
    }
    //2.向服务端发送数据
    private void send(String msg) {
        try {
            if(msg != null && !msg.equals("")) {
                dos.writeUTF(msg);
                dos.flush();//强制刷新
            }
        } catch (IOException e) {
            e.printStackTrace();
            isRunning = false;
            CloseUtil.closeAll(dos, console);
        }
    }
    @Override
    public void run() {
        //线程体
        while(isRunning) {
            send(getMsgFromConsole());
        }
    }
}

接收数据线程

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;


public class Receive implements Runnable{
    //输入流
    private DataInputStream dis;
    //线程标识符
    private boolean isRunning = true;
    //初始化建立管道
    public Receive(Socket socket) {
        try {
            dis = new DataInputStream(socket.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
            isRunning = false;
            CloseUtil.closeAll(dis);
        }
    }
    /**
     * 接收数据
     */
    private String receive() {
        String msg = "";
        try {
            msg = dis.readUTF();
        } catch (IOException e) {
            e.printStackTrace();
            isRunning = false;
            CloseUtil.closeAll(dis);
        }
        return msg;
    }

    
    @Override
    public void run() {
        //线程体
        while(isRunning) {
            System.out.println(receive());
        }
    }
}

3.关闭流工具类

import java.io.Closeable;
import java.io.IOException;


/**
 * 关闭io流的工具
 */
public class CloseUtil {
    public static void closeAll(Closeable... io) {
        for(Closeable temp : io) {
            try {
                if(temp != null) {
                    temp.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}