广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Java实现在线聊天室(层层递进）
  • 436

0
分享到

Java实现在线聊天室(层层递进）

2024-04-02 19:04:59 436人浏览 独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

本文实例为大家分享了Java实现在线聊天室的具体代码，供大家参考，具体内容如下 - 本文讲述了从实现单个多个客户的收发信息（基础简易版），到各种实现代码的封装（oop版），实现群聊（

本文实例为大家分享了Java实现在线聊天室的具体代码，供大家参考，具体内容如下

- 本文讲述了从实现单个多个客户的收发信息（基础简易版），到各种实现代码的封装（oop版），实现群聊（群聊过渡版），到最后实现私聊（终极版）的过程
- 本文内容是在初步学习网络编程时，练习强化记忆时的学习总结
- 主要利用了tcp网络编程和多线程
- 如有问题，欢迎指出

综合案例：在线聊天室

需求：使用TCP的Socket实现一个聊天室

  • 服务器端：一个线程专门发送消息，一个线程专门接收消息
  • 客户端：一个线程专门发送消息，一个线程专门接收消息

1. 基础简易版

1.1 一个客户收发多条消息

目标：实现一个客户可以正常收发多条信息

服务器


public class MutiChat {
    public static void main(String[] args) throws ioException {
        System.out.println("-----Server-----");
        // 1、指定端口  使用ServerSocket创建服务器
        ServerSocket server = new ServerSocket(8888);
        // 2、利用Socket的accept方法，监听客户端的请求。阻塞，等待连接的建立
        Socket client = server.accept();
        System.out.println("一个客户端建立了连接");
        DataInputStream dis = new DataInputStream(client.getInputStream());
        DataOutputStream dos = new DataOutputStream(client.getOutputStream());

        boolean isRunning = true;
        while (isRunning) {
            // 3、接收消息
            String msg = dis.readUTF();
            // 4、返回消息
            dos.writeUTF(msg);
            dos.flush();
        }
        // 5、释放资源
        dos.close();
        dis.close();
        client.close();
    }
}

客户端


public class MutiClient {
    public static void main(String[] args) throws IOException {
        System.out.println("-----Client-----");
        // 1、建立连接：使用Socket创建客户端 + 服务的地址和端口
        Socket client = new Socket("localhost", 8888);
        // 2、客户端发送消息
        BufferedReader console = new BufferedReader(new InputStreamReader(System.in));  // 对接控制台
        DataOutputStream dos = new DataOutputStream(client.getOutputStream());
        DataInputStream dis = new DataInputStream(client.getInputStream());

        boolean isRunning = true;
        while (isRunning) {
            String msg = console.readLine();
            dos.writeUTF(msg);
            dos.flush();
            // 3、获取消息
            msg = dis.readUTF();
            System.out.println(msg);
        }

        // 4、释放资源
        dos.close();
        dis.close();
        client.close();
    }
}

1.2 多个客户收发多条消息(不使用多线程)

  • 目标：实现多个客户可以正常收发多条信息
  • 出现排队问题：其他客户必须等待之前的客户退出，才能收发消息

服务器

public class MutiChat {
    public static void main(String[] args) throws IOException {
        System.out.println("-----Server-----");
        // 1、指定端口  使用ServerSocket创建服务器
        ServerSocket server = new ServerSocket(8888);
        // 2、利用Socket的accept方法，监听客户端的请求。阻塞，等待连接的建立
        while (true) {
            Socket client = server.accept();
            System.out.println("一个客户端建立了连接");
            DataInputStream dis = new DataInputStream(client.getInputStream());
            DataOutputStream dos = new DataOutputStream(client.getOutputStream());

            boolean isRunning = true;
            while (isRunning) {
                // 3、接收消息
                String msg = dis.readUTF();
                // 4、返回消息
                dos.writeUTF(msg);
                dos.flush();
            }
            // 5、释放资源
            dos.close();
            dis.close();
            client.close();
        }
    }
}

1.3 多个客户收发多条消息(多线程)

  • 目标：实现多个客户可以正常收发多条信息
  • 出现的问题：利用Lambda太复杂，代码过多不好维护；客户端读写没有分开，必须先写后读

服务器代码

public class ThreadMutiChat {
    public static void main(String[] args) throws IOException {
        System.out.println("-----Server-----");
        // 1、指定端口  使用ServerSocket创建服务器
        ServerSocket server = new ServerSocket(8888);
        // 2、利用Socket的accept方法，监听客户端的请求。阻塞，等待连接的建立
        while (true) {
            Socket client = server.accept();
            System.out.println("一个客户端建立了连接");

            // 加入多线程
            new Thread(()->{
                DataInputStream dis = null;
                DataOutputStream dos = null;
                try {
                    dis = new DataInputStream(client.getInputStream());
                    dos = new DataOutputStream(client.getOutputStream());
                } catch (IOException e) {
                    e.printStackTrace();
                }
                boolean isRunning = true;
                while (isRunning) {
                    // 3、接收消息
                    String msg = null;
                    try {
                        msg = dis.readUTF();
                        // 4、返回消息
                        dos.writeUTF(msg);
                        dos.flush();
                    } catch (IOException e) {
//                        e.printStackTrace();
                        isRunning = false;  // 停止线程
                    }
                }
                // 5、释放资源
                try {
                    if (null == dos) {
                        dos.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if (null == dis) {
                        dis.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if (null == client) {
                        client.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

2. oop封装版

目标：封装使用多线程实现多个客户可以正常收发多条消息

  • 1、线程代理 Channel，一个客户代表一个 Channel
  • 2、实现方法：接收消息 - receive; 发送消息 - send; 释放资源 - release;
  • 3、其中释放资源 release方法中利用工具类 Utils：实现Closeable接口、可变参数
  • 好处：利用封装，是代码简洁，便于维护

服务器端

示例代码：

public class ThreadMutiChat {
    public static void main(String[] args) throws IOException {
        System.out.println("---服务器开始工作---");
        // 1、指定端口  使用ServerSocket创建服务器
        ServerSocket server = new ServerSocket(8888);
        // 2、利用Socket的accept方法，监听客户端的请求。阻塞，等待连接的建立
        while (true) {
            Socket client = server.accept();
            System.out.println("一个客户端建立了连接");

            new Thread(new Channel(client)).start();
        }
    }

    // 一个客户代表一个Channel
    static class Channel implements Runnable {
        private DataInputStream dis = null;
        private DataOutputStream dos = null;
        private Socket client;
        private boolean isRunning;

        public Channel(Socket client) {
            this.client = client;
            try {
                dis = new DataInputStream(client.getInputStream());
                dos = new DataOutputStream(client.getOutputStream());
                isRunning = true;
            } catch (IOException e) {
                System.out.println("---构造时出现异常---");
                release();
            }
        }

        // 接收消息
        private String receive() {
            String msg = "";        // 避免空指针
            try {
                msg = dis.readUTF();
            } catch (IOException e) {
                System.out.println("---接受消息出现异常---");
                release();
            }
            return msg;
        }

        // 发送消息
        private void send(String msg) {
            try {
                dos.writeUTF(msg);
                dos.flush();
            } catch (IOException e) {
                System.out.println("---发送消息出现异常---");
                release();
            }
        }

        // 释放资源
        private void release() {
            this.isRunning = false;
            // 封装
            Utils.close(dis, dos, client);
        }

        // 线程体
        @Override
        public void run() {
            while (isRunning) {
                String msg = receive();
                if (!msg.equals("")) {
                    send(msg);
                }
            }
        }
    }
}

工具类Utils：实现Closeable接口，利用可变参数，达到释放资源的作用

示例代码

public class Utils {
    public static void close(Closeable... targets) {        
    // Closeable是IO流中接口，"..."可变参数
    // IO流和Socket都实现了Closeable接口，可以直接用
        for (Closeable target: targets) {
            try {
                // 只要是释放资源就要加入空判断
                if (null != target) {
                    target.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

客户端：启用两个线程Send和Receive实现收发信息的分离

示例代码

public class ThreadMutiClient {
    public static void main(String[] args) throws IOException {
        System.out.println("-----客户端开始工作-----");
        Socket client = new Socket("localhost", 8888);

        new Thread(new Send(client)).start();
        new Thread(new Receive(client)).start();
    }
}

使用多线程封装客户的发送端 – Send类

实现方法：

1、发送消息 - send()
2、从控制台获取消息 - getStrFromConsole()
3、释放资源 - release()
4、线程体 - run()

示例代码

public class Send implements Runnable {
    private BufferedReader console;
    private DataOutputStream dos;
    private Socket client;
    private boolean isRunning;

    public Send(Socket client) {
        this.client = client;
        console = new BufferedReader(new InputStreamReader(System.in));  // 对接控制台
        try {
            dos = new DataOutputStream(client.getOutputStream());
            isRunning = true;
        } catch (IOException e) {
            System.out.println("---客户发送端构造时异常---");
            release();
        }
    }

    // 从控制台获取消息
    private String getStrFromConsole() {
        try {
            return console.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    // 发送消息
    private void send(String msg) {
        try {
            dos.writeUTF(msg);
            dos.flush();
        } catch (IOException e) {
            System.out.println("---客户发送端发送消息异常---");
            release();
        }
    }

    @Override
    public void run() {
        while (isRunning) {
            String msg = getStrFromConsole();
            if (!msg.equals("")) {
                send(msg);
            }
        }
    }

    // 释放资源
    private void release() {
        this.isRunning = false;
        Utils.close(dos,client);
    }
}

使用多线程封装客户的接收端 – Receive类

实现方法：

1、接收消息 - send
2、释放资源 - release()
3、线程体 - run()

示例代码

public class Receive implements Runnable {
    private DataInputStream dis;
    private Socket client;
    private boolean isRunning;

    public Receive(Socket client) {
        this.client = client;
        try {
            dis = new DataInputStream(client.getInputStream());
            isRunning = true;
        } catch (IOException e) {
            System.out.println("---客户接收端构造时异常---");
            release();
        }
    }

    // 接收消息
    private String receive() {
        String msg = "";
        try {
            msg = dis.readUTF();
        } catch (IOException e) {
            System.out.println("---客户接收端接收消息异常---");
            release();
        }
        return msg;
    }

    // 释放资源
    private void release() {
        isRunning = false;
        Utils.close(dis, client);
    }

    @Override
    public void run() {
        while (isRunning) {
            String msg = receive();
            if (!msg.equals("")) {
                System.out.println(msg);
            }
        }
    }
}

3. 群聊过渡版

目标：加入容器，实现群聊

服务器端

1、建立 CopyOnWriteArrayList<Channel> 容器，容器中的元素是Channel客户端代理。要对元素进行修改同时遍历时，推荐使用此容器，避免出问题。
2、实现方法void sendOthers(String msg)将信息发送给除自己外的其他人。

服务器端实现代码

public class Chat {
    // 建立 CopyOnWriteArrayList<Channel> 容器
    private static CopyOnWriteArrayList<Channel> all = new CopyOnWriteArrayList<>();

    public static void main(String[] args) throws IOException {
        System.out.println("---服务器开始工作---");

        ServerSocket server = new ServerSocket(8888);

        while (true) {
            Socket client = server.accept();
            System.out.println("一个客户端建立了连接");
            Channel c = new Channel(client);
            all.add(c);     // 管理所有的成员
            new Thread(c).start();
        }
    }

    // 一个客户代表一个Channel
    static class Channel implements Runnable {
        private DataInputStream dis;
        private DataOutputStream dos;
        private Socket client;
        private boolean isRunning;
        private String name;

        public Channel(Socket client) {
            this.client = client;

            try {
                dis = new DataInputStream(client.getInputStream());
                dos = new DataOutputStream(client.getOutputStream());
                isRunning = true;
                // 获取名称
                this.name = receive();
                // 欢迎
                this.send("欢迎你的到来");
                sendOthers(this.name + "加入群聊", true);
            } catch (IOException e) {
                System.out.println("---构造时出现问题---");
                release();
            }
        }

        // 接收消息
        private String receive() {
            String msg = "";        // 避免空指针
            try {
                msg = dis.readUTF();
            } catch (IOException e) {
                System.out.println("---接受消息出现问题---");
                release();
            }
            return msg;
        }

        // 发送消息
        private void send(String msg) {
            try {
                dos.writeUTF(msg);
                dos.flush();
            } catch (IOException e) {
                System.out.println("---发送消息出现问题---");
                release();
            }
        }

        // 群聊：把自己的消息发送给其他人
        private void sendOthers(String msg, boolean isSys) {
            for (Channel other : all) {
                if (other == this) {
                    continue;
                }
                if (!isSys) {
                    other.send(this.name + ": " + msg);  // 群聊消息
                } else {
                    other.send("系统消息：" + msg);    // 系统消息
                }
            }
        }

        // 线程体
        @Override
        public void run() {
            while (isRunning) {
                String msg = receive();
                if (!msg.equals("")) {
                    sendOthers(msg, false);
                }
            }

        }

        // 释放资源
        private void release() {
            this.isRunning = false;
            // 封装
            Utils.close(dis, dos, client);
            // 退出
            all.remove(this);
            sendOthers(this.name + "离开聊天室", true);
        }
    }
}

客户端实现代码

public class Client {
    public static void main(String[] args) throws IOException {
        System.out.println("-----客户端开始工作-----");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Socket client = new Socket("localhost", 8888);
        System.out.println("请输入用户名：");      // 不考虑重名
        String name = br.readLine();


        new Thread(new Send(client, name)).start();
        new Thread(new Receive(client)).start();
    }
}

客户端Send类实现代码

public class Send implements Runnable {
    private BufferedReader console;
    private DataOutputStream dos;
    private Socket client;
    private boolean isRunning;
    private String name;

    public Send(Socket client, String name) {
        this.client = client;
        console = new BufferedReader(new InputStreamReader(System.in));
        this.isRunning = true;
        this.name = name;
        try {
            dos = new DataOutputStream(client.getOutputStream());
            // 发送名称
            send(name);
        } catch (IOException e) {
            System.out.println("Send类构造时异常");
            release();
        }
    }

    // 从控制台获取消息
    private String getStrFromConsole() {
        try {
            return console.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    // 发送消息
    private void send(String msg) {
        try {
            dos.writeUTF(msg);
            dos.flush();
        } catch (IOException e) {
            System.out.println("---客户发送端发送消息异常---");
            release();
        }
    }

    @Override
    public void run() {
        while (isRunning) {
            String msg = getStrFromConsole();
            if (!msg.equals("")) {
                send(msg);
            }
        }
    }

    // 释放资源
    private void release() {
        this.isRunning = false;
        Utils.close(dos,client);
    }
}

客户端Receive类实现代码

public class Receive implements Runnable {
    private DataInputStream dis;
    private Socket client;
    private boolean isRunning;

    public Receive(Socket client) {
        this.client = client;
        try {
            dis = new DataInputStream(client.getInputStream());
            isRunning = true;
        } catch (IOException e) {
            System.out.println("---客户接收端构造时异常---");
            release();
        }
    }

    // 接收消息
    private String receive() {
        String msg = "";
        try {
            msg = dis.readUTF();
        } catch (IOException e) {
            System.out.println("---客户接收端接收消息异常---");
            release();
        }
        return msg;
    }

    // 释放资源
    private void release() {
        isRunning = false;
        Utils.close(dis, client);
    }

    @Override
    public void run() {
        while (isRunning) {
            String msg = receive();
            if (!msg.equals("")) {
                System.out.println(msg);
            }
        }
    }
}

运行结果

4. 终极版：实现私聊

私聊形式：@XXX:

实现方法

1、boolean isPrivate = msg.startsWith("@")用于判断是否为私聊

  • 利用String类中方法
  • boolean startsWith(String prefix):测试此字符串是否以指定的前缀开头

2、String targetName = msg.substring(1, index)用于判断用户名；msg = msg.substring(index+1)用于判断发送的信息

  • 利用String类中方法
  • substring(int beginIndex):返回一个字符串，该字符串是此字符串的子字符串
  • substring(int beginIndex, int endIndex):返回一个字符串，该字符串是此字符串的子字符串

服务器端实现代码

public class Chat {
    private static CopyOnWriteArrayList<Channel> all = new CopyOnWriteArrayList<>();

    public static void main(String[] args) throws IOException {
        System.out.println("---服务器开始工作---");

        ServerSocket server = new ServerSocket(8888);

        while (true) {
            Socket client = server.accept();
            System.out.println("一个客户端建立了连接");
            Channel c = new Channel(client);
            all.add(c);     // 管理所有的成员
            new Thread(c).start();
        }
    }
    static class Channel implements Runnable {
        private DataInputStream dis;
        private DataOutputStream dos;
        private Socket client;
        private boolean isRunning;
        private String name;

        public Channel(Socket client) {
            this.client = client;
            try {
                dis = new DataInputStream(client.getInputStream());
                dos = new DataOutputStream(client.getOutputStream());
                isRunning = true;
                // 获取名称
                this.name = receive();
                // 欢迎
                this.send("欢迎你的到来");
                sendOthers(this.name + "加入群聊", true);
            } catch (IOException e) {
                System.out.println("---构造时出现问题---");
                release();
            }
        }
        private String receive() {
            String msg = "";        // 避免空指针
            try {
                msg = dis.readUTF();
            } catch (IOException e) {
                System.out.println("---接受消息出现问题---");
                release();
            }
            return msg;
        }
        private void send(String msg) {
            try {
                dos.writeUTF(msg);
                dos.flush();
            } catch (IOException e) {
                System.out.println("---发送消息出现问题---");
                release();
            }
        }
        
        private void sendOthers(String msg, boolean isSys) {
            boolean isPrivate = msg.startsWith("@");
            if (isPrivate) { // 私聊
                int index = msg.indexOf(":");       // 第一次冒号出现的位置
                // 获取目标和数据
                String targetName = msg.substring(1, index);
                msg = msg.substring(index+1);
                for (Channel other: all) {
                    if (other.name.equals(targetName)) { // 目标
                        other.send(this.name + "对您说悄悄话: " + msg);  // 群聊消息
                    }
                }
            } else {
                for (Channel other : all) {
                    if (other == this) {
                        continue;
                    }
                    if (!isSys) {
                        other.send(this.name + ": " + msg);  // 群聊消息
                    } else {
                        other.send("系统消息：" + msg);    // 系统消息
                    }
                }
            }
        }
        @Override
        public void run() {
            while (isRunning) {
                String msg = receive();
                if (!msg.equals("")) {
                    sendOthers(msg, false);
                }
            }

        }
        private void release() {
            this.isRunning = false;
            Utils.close(dis, dos, client);
            all.remove(this);
            sendOthers(this.name + "离开聊天室", true);
        }
    }
}

客户端实现代码

public class Client {
    public static void main(String[] args) throws IOException {
        System.out.println("-----客户端开始工作-----");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Socket client = new Socket("localhost", 8888);
        System.out.println("请输入用户名：");      // 不考虑重名
        String name = br.readLine();


        new Thread(new Send(client, name)).start();
        new Thread(new Receive(client)).start();
    }
}

客户端Send类实现代码

public class Send implements Runnable {
    private BufferedReader console;
    private DataOutputStream dos;
    private Socket client;
    private boolean isRunning;
    private String name;

    public Send(Socket client, String name) {
        this.client = client;
        console = new BufferedReader(new InputStreamReader(System.in));
        this.isRunning = true;
        this.name = name;
        try {
            dos = new DataOutputStream(client.getOutputStream());
            // 发送名称
            send(name);
        } catch (IOException e) {
            System.out.println("Send类构造时异常");
            release();
        }
    }
    private String getStrFromConsole() {
        try {
            return console.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
    private void send(String msg) {
        try {
            dos.writeUTF(msg);
            dos.flush();
        } catch (IOException e) {
            System.out.println("---客户发送端发送消息异常---");
            release();
        }
    }
    @Override
    public void run() {
        while (isRunning) {
            String msg = getStrFromConsole();
            if (!msg.equals("")) {
                send(msg);
            }
        }
    }
    private void release() {
        this.isRunning = false;
        Utils.close(dos,client);
    }
}

客户端Receive类实现代码

public class Receive implements Runnable {
    private DataInputStream dis;
    private Socket client;
    private boolean isRunning;

    public Receive(Socket client) {
        this.client = client;
        try {
            dis = new DataInputStream(client.getInputStream());
            isRunning = true;
        } catch (IOException e) {
            System.out.println("---客户接收端构造时异常---");
            release();
        }
    }
    
    private String receive() {
        String msg = "";
        try {
            msg = dis.readUTF();
        } catch (IOException e) {
            System.out.println("---客户接收端接收消息异常---");
            release();
        }
        return msg;
    }
    
    private void release() {
        isRunning = false;
        Utils.close(dis, client);
    }
    
    @Override
    public void run() {
        while (isRunning) {
            String msg = receive();
            if (!msg.equals("")) {
                System.out.println(msg);
            }
        }
    }
}

Utils类实现代码

public class Utils {
    public static void close(Closeable... targets) {
        for (Closeable target: targets) {
            try {
                if (null != target) {
                    target.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

输出结果

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程网。

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java实现在线聊天室(层层递进）

本文链接: https://www.lsjlt.com/news/167612.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • Java实现在线聊天室(层层递进）
    本文实例为大家分享了Java实现在线聊天室的具体代码，供大家参考，具体内容如下 - 本文讲述了从实现单个多个客户的收发信息（基础简易版），到各种实现代码的封装（oop版），实现群聊（...
    99+
    2022-11-13
  • Java实现单线程聊天室
    本文实例为大家分享了Java实现单线程聊天室的具体代码，供大家参考，具体内容如下 一. Socket API简介 1. Socket编程 Java.net.Socket类代表一个套接...
    99+
    2022-11-13
  • Java实现多线程聊天室
    本文实例为大家分享了Java实现多线程聊天室的具体代码，供大家参考，具体内容如下 之前呢已经用单线程的方式来实现了聊天室,但其实它的功能并不齐全,下面用多线程来实现,功能会比单线程聊...
    99+
    2022-11-12
  • AngularJS+Node.js实现在线聊天室
    不得不说，上手AngularJS比我想象得难多了，把官网提供的PhoneCat例子看完，又跑到慕课网把大漠穷秋的AngularJS实战系列看了一遍，对于基本的使用依然有很多说不清道不明的疑惑，于是决定通过做...
    99+
    2022-06-04
    在线 聊天室 AngularJS
  • Python怎么实现在线聊天室私聊
    本篇内容主要讲解“Python怎么实现在线聊天室私聊”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Python怎么实现在线聊天室私聊”吧!实现思路对于私聊，我觉得应该有如下两点需要实现私聊列表更...
    99+
    2023-06-02
  • 在线聊天室的Java实现(功能比较弱)
    自己用Java写的一个在线聊天室...功能不是很完善...供参考[@more@]ChatServer.java这里是主调用部分package com.darkblue;import java.net.*;import java.io.*;p...
    99+
    2023-06-03
  • Java聊天室之实现使用Socket传递音频
    目录一、题目描述二、解题思路三、代码详解多学一个知识点一、题目描述 题目实现：使用网络编程时，需要通过Socket传递音频文件。 二、解题思路 创建一个服务器类：ServerSock...
    99+
    2022-11-13
    Java实现聊天室 Java聊天室 Java Socket传递音频
  • Java聊天室之使用Socket实现传递对象
    目录一、题目描述二、解题思路三、代码详解一、题目描述 题目实现：使用网络编程时，需要通过Socket传递对象。 二、解题思路 创建一个类：Student,实现序列化 ​ Studen...
    99+
    2022-11-13
    Java实现聊天室 Java聊天室 Java Socket传递对象
  • Java聊天室之使用Socket实现传递图片
    目录一、题目描述二、解题思路三、代码详解一、题目描述 题目实现：使用网络编程时，需要通过Socket传递图片。 二、解题思路 创建一个服务器类：ServerSocketFrame，继...
    99+
    2022-11-13
    Java实现聊天室 Java聊天室 Java Socket传递图片
  • Java多线程局域网聊天室的实现
    目录1.TCP2.套接字3.C/S架构4.多线程5.服务器客户端局域网聊天室 在学习了一个学期的java以后，觉得java真是博大精深，彻底放弃了因为c++而轻视java的心态，搞了...
    99+
    2022-11-12
  • Java多线程实现多人聊天室功能
    本文为大家分享了Java多线程实现多人聊天室功能的具体代码，供大家参考，具体内容如下 1.实验目的： 编写一个 Java 应用程序，实现图形界面多人聊天室（多线程实现），要求聊天室窗...
    99+
    2022-11-12
  • Django实现WebSocket在线聊天室功能(channels库)
    1.Django实现WebSocket在线聊天室 1.1 安装 pip install channels==2.3 (saas) F:\Desktop\Python_Study\...
    99+
    2022-11-12
  • Node.js+express+socket实现在线实时多人聊天室
    本文实例为大家分享了Node.js+express+socket实现在线实时多人聊天室的具体代码，供大家参考，具体内容如下 文件结构如下： 前端部分： 登录页面Login部分： l...
    99+
    2022-11-12
  • Node.js怎么实现在线实时多人聊天室
    本篇内容介绍了“Node.js怎么实现在线实时多人聊天室”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！文件结构如下：前端部分：登录页面Log...
    99+
    2023-07-04
  • Java Socket+多线程实现多人聊天室功能
    本文实例为大家分享了Java Socket+多线程实现多人聊天室的具体代码，供大家参考，具体内容如下 思路简介 分为客户端和服务器两个类，所有的客户端将聊的内容发送给服务器，服务器接...
    99+
    2022-11-12
  • Java实现在线聊天功能
    本文实例为大家分享了Java实现在线聊天功能的具体代码，供大家参考，具体内容如下 效果 关键代码 创建Client.java import java.io.IOException;...
    99+
    2022-11-13
  • java实现在线聊天系统
    本文实例为大家分享了java实现在线聊天系统的具体代码，供大家参考，具体内容如下 本博客是博主在观看相关视频后写下的代码，希望能够帮助大家掌握java socket的相关知识。 原理...
    99+
    2022-11-13
  • Node.js+express+socket怎么实现在线实时多人聊天室
    本文小编为大家详细介绍“Node.js+express+socket怎么实现在线实时多人聊天室”，内容详细，步骤清晰，细节处理妥当，希望这篇“Node.js+express+socket怎么实现在线实时多人聊天室”文章能帮助大家解决疑惑，下...
    99+
    2023-06-17
  • 如何使用Go语言和Redis实现在线聊天室
    如何使用Go语言和Redis实现在线聊天室引言：随着互联网的迅速发展，社交网络已经成为人们日常生活中不可或缺的一部分。在线聊天室作为社交网络中的一个重要组成部分，具有便捷、实时、交互性强等特点受到人们的欢迎。本文以Go语言和Redis为基础...
    99+
    2023-10-27
    Go语言 redis 在线聊天室
  • 怎么用Java Socket+多线程实现多人聊天室功能
    这篇文章主要讲解了“怎么用Java Socket+多线程实现多人聊天室功能”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“怎么用Java Socket+多线程实现多人聊天室功能”吧！思路简介分...
    99+
    2023-06-20
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作