Java多用户即时通讯系统

已于 2023-07-28 12:59:16 修改
阅读量236 收藏
点赞数 1
分类专栏： Java网络编程 文章标签： java 学习
于 2022-11-10 19:02:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bingbingyihao/article/details/127750099
版权

Java多用户即时通讯系统

项目学习说明

项目学习自哔哩哔哩的韩顺平老师的课程，Java网络多线程专题 - TCP UDP Socket编程 多线程 并发处理 文件传输 新闻推送 Java

该项目主要对Java网络编程和多线程进行一个熟悉与锻炼；项目仅供学习使用

系统涉及知识说明

系统涉及的知识：多线程、网络通讯、数据库、集合

这里的交流格式采用对象流

采用Scanner输入对空格问题的解决

采用 scanner.useDelimiter(“\n”); 设置为换行即可
工具类如下

package chat.base;

import java.util.Scanner;

/**
 * @author bbyh
 * @date 2022/11/9 0009 23:41
 * @description
 */
public class ScannerUtil {
    private static final Scanner SCANNER = new Scanner(System.in);

    public static String read(int size) {
        SCANNER.useDelimiter("\n");
        String next = SCANNER.next();
        if (next.length() <= size) {
            return next;
        }
        return next.substring(0, size);
    }
}

遇到的对象字节流问题

正常写入读出对象，但是报错 java.io.StreamCorruptedException: invalid type code: AC
查看一些文章表示是 Socket 采用对象字节流进行写入的时候会写入头部，然后读出的时候读出头部，但是不是每一次都写，就很奇怪
参考文章：java.io.StreamCorruptedException: invalid type code: AC错误解决

解决方式就是自己重写Object输入输出的两个方法，具体原因还没有查明

目前的实现了私聊的简单版本

项目链接：https://pan.baidu.com/s/12UygVcYiXreJ4Qy7mPImGQ
提取码：0925

关于对象字节流报错问题解决

报错的文件及复现项目：StreamCorruptedException异常的产生和应注意的点
项目地址：https://pan.baidu.com/s/1pEyWgLlu-gU3tMMSjLg96Q
提取码：0925

给出的建议：如果你使用socket，并通过对象输入/输出流来处理的话，并且已经对某个socket调用了一次getInputStream时，但又需要把这个socket的相关信息作为参数传递给别的对象时，应注意：不用直接把socket传过去，应该把对应的ObjectInputStream或ObjectOutputStream对象传递过去

对于文件及一般的Socket调用对象字节流的测试

经测试发现文件流，写入读出多个同一类型的对象是没问题的，多个不同对象也是没问题的，不管顺序是否打乱

package chat.test;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:17
 * @description
 */
public class Test {
    public static void main(String[] args) throws Exception {
        String filePath = "D:/test1.txt";
        Path path = Paths.get(filePath);

        ObjectOutputStream oos = new ObjectOutputStream(Files.newOutputStream(path));
        oos.writeObject(new Person("Hello1", 20));
        oos.writeObject(new Person("Hello2", 22));

        ObjectInputStream ois = new ObjectInputStream(Files.newInputStream(path));
        Object o1 = ois.readObject();
        Object o2 = ois.readObject();

        System.out.println(o1);
        System.out.println(o2);
    }
}

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

经测试发现，Socket在连续发送对象且只有单向通信时也并不会出现无法解析的情况

package chat.test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

import static chat.test.Client.PORT;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:32
 * @description
 */
public class Server {
    public static void main(String[] args) throws Exception {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            Socket accept = serverSocket.accept();
            ObjectInputStream ois = new ObjectInputStream(accept.getInputStream());
            Object o1 = ois.readObject();
            Object o2 = ois.readObject();

            System.out.println(o1);
            System.out.println(o2);
        }
    }
}


package chat.test;

import java.io.*;
import java.net.Socket;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:17
 * @description
 */
public class Client {
    public static final String IP = "127.0.0.1";
    public static final int PORT = 9090;

    public static void main(String[] args) throws Exception {
        try (Socket socket = new Socket(IP, PORT)) {
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(new Person("Hello1", 20));
            oos.writeObject(new Man("Hello2", 21));
        }
    }
}


package chat.test;

import java.io.*;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:17
 * @description
 */
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


package chat.test;

import java.io.*;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:17
 * @description
 */
public class Man implements Serializable {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final int age;

    public Man(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Man{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

就算是双向通信一次也并没有出现解析出错的情况

package chat.test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

import static chat.test.Client.PORT;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:32
 * @description
 */
public class Server {
    public static void main(String[] args) throws Exception {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            Socket accept = serverSocket.accept();
            ObjectInputStream ois = new ObjectInputStream(accept.getInputStream());
            Object o1 = ois.readObject();
            Object o2 = ois.readObject();

            System.out.println(o1);
            System.out.println(o2);

            ObjectOutputStream oos = new ObjectOutputStream(accept.getOutputStream());
            oos.writeObject(new Person("Hello3", 22));
            oos.writeObject(new Man("Hello4", 23));
            accept.shutdownOutput();
        }
    }
}


package chat.test;

import java.io.*;
import java.net.Socket;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:17
 * @description
 */
public class Client {
    public static final String IP = "127.0.0.1";
    public static final int PORT = 9090;

    public static void main(String[] args) throws Exception {
        try (Socket socket = new Socket(IP, PORT)) {
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(new Person("Hello1", 20));
            oos.writeObject(new Man("Hello2", 21));
            socket.shutdownOutput();

            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Object o1 = ois.readObject();
            Object o2 = ois.readObject();

            System.out.println(o1);
            System.out.println(o2);
        }
    }
}

对Socket调用了getInputStream或getOutputStream，并再次作为参数传递的测试

复现了，确实是由于调用了两次 getInputStream 导致的不匹配问题
对于直接写入文件的对象字节流 ，是可以发现写入的时候并没有都加 开头的 AC ED 00 05
于是再次进行获取 getInputStream，则报出错误，这实际上是反序列化漏洞，反序列化漏洞整理

package chat.test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

import static chat.test.Client.PORT;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:32
 * @description
 */
public class Server {
    public static void main(String[] args) throws Exception {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            while (true) {
                Socket accept = serverSocket.accept();
                ObjectInputStream ois = new ObjectInputStream(accept.getInputStream());
                Object o1 = ois.readObject();
                Object o2 = ois.readObject();

                System.out.println(o1);
                System.out.println(o2);

                ObjectOutputStream oos = new ObjectOutputStream(accept.getOutputStream());
                oos.writeObject(new Person("Hello3", 22));
                oos.writeObject(new Man("Hello4", 23));
                accept.shutdownOutput();
                accept.close();
            }
        }
    }
}


package chat.test;

import java.io.*;
import java.net.Socket;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:17
 * @description
 */
public class Client {
    public static final String IP = "127.0.0.1";
    public static final int PORT = 9090;

    public static void main(String[] args) throws Exception {
        try (Socket socket = new Socket(IP, PORT)) {
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(new Person("Hello1", 20));
            oos.writeObject(new Man("Hello2", 21));
            socket.shutdownOutput();

            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Object o1 = ois.readObject();
            System.out.println(o1);

            test(socket);
        }
    }

    public static void test(Socket socket) throws Exception {
        try (ObjectInputStream ois = new ObjectInputStream(socket.getInputStream())) {
            Object o1 = ois.readObject();
            System.out.println(o1);
        }
    }
}

同样的，两次调用 getOutputStream，也会导致解析出错

package chat.test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

import static chat.test.Client.PORT;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:32
 * @description
 */
public class Server {
    public static void main(String[] args) throws Exception {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            while (true) {
                Socket accept = serverSocket.accept();
                ObjectInputStream ois = new ObjectInputStream(accept.getInputStream());
                Object o1 = ois.readObject();
                System.out.println(o1);

                Object o2 = ois.readObject();
                System.out.println(o2);

                ObjectOutputStream oos = new ObjectOutputStream(accept.getOutputStream());
                oos.writeObject(new Person("Hello3", 22));
                accept.shutdownOutput();
                accept.close();
            }
        }
    }
}


package chat.test;

import java.io.*;
import java.net.Socket;

/**
 * @author bbyh
 * @date 2022/11/9 0009 19:17
 * @description
 */
public class Client {
    public static final String IP = "127.0.0.1";
    public static final int PORT = 9090;

    public static void main(String[] args) throws Exception {
        try (Socket socket = new Socket(IP, PORT)) {
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(new Person("Hello1", 20));

            test(socket);

            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Object o1 = ois.readObject();
            System.out.println(o1);
        }
    }

    public static void test(Socket socket) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream())) {
            oos.writeObject(new Man("Hello2", 21));
            socket.shutdownOutput();
        }
    }
}

解决聊天软件中出现的对象读出问题

采用上面的重写字节流那两个类的两个方法也可以；或者采取传递转化好后的字节流，而不是传递socket到方法；或者防止对socket进行两次获取 getInputStream、getOutputStream

对比之下，我个人感觉，直接传递 转化好的字节流是最好的方式，简洁安全高效

项目链接：https://pan.baidu.com/s/15g9L6uDuYCFD_s7DbMuQ9w
提取码：0925

byte与String转化问题

对文件传输过程中，采用字符串存储字节数组，再转回来的字节数发生变化问题解决

需要采用 StandardCharsets.ISO_8859_1 这种单字节编码才不会让字符串转化回来的字节数组变长

package chat.test;

import java.io.BufferedInputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

import static chat.base.Config.FILE_MAX_SIZE;

/**
 * @author bbyh
 * @date 2022/11/10 0010 0:37
 * @description
 */
public class Test {
    public static void main(String[] args) throws Exception {
        String filePath = "src/image/1.jpg";
        byte[] buf = new byte[FILE_MAX_SIZE];

        BufferedInputStream bis = new BufferedInputStream(Files.newInputStream(Paths.get(filePath)));
        int read = bis.read(buf);
        System.out.println(read);

        String str = new String(buf, 0, read, StandardCharsets.ISO_8859_1);
        System.out.println(str.getBytes(StandardCharsets.ISO_8859_1).length);
    }
}

最终版（强制下线、群聊、发送文件、服务端推送、离线发送）

项目链接：https://pan.baidu.com/s/1J7f343QblcZxznRxfdXoVQ
提取码：0925

遇到的一些问题就是多线程代码过长时不易维护，考虑到后期可以改为采用设计模式进行改进；以及多线程下对线程的属性认识不全，最后是字节流对象传输的对象设计的并不是十分完善，可以考虑设计的完善一些

bingbingyihao
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用JAVA实现的即时通讯系统
04-01
9. **用户界面**：JAVA Swing或JavaFX可以用于构建即时通讯系统的用户界面，提供友好的交互体验，包括聊天窗口、联系人列表、文件传输等功能。 10. **异常处理与日志记录**：良好的异常处理和日志记录机制能帮助...
即时通讯全套JAVA源码
09-25
用JAVA语言,基于t-io开发的轻量、高性能、单机支持几十万至百万在线用户IM，主要目标降低即时通讯门槛，快速打造低成本接入在线IM系统，通过极简洁的消息格式就可以实现多端不同协议间的消息发送如内置(Http、...
Java笔记（二十八）：多用户即时通信系统【下】（功能实现--私聊/群聊发文件/服务端推送消息/离线信息存储接收、虚拟机作为服务端代码修改）
欢迎~
08-01 218
QQview类：新增对象属性，调用新增类的新方法MessageClientService类：新增类ClientConnectServerThread类：新增类型判断。
java实现多用户即时通信系统（一）
dujiu777的博客
10-16 99
需要取代码请到本文末~~简化了图形界面（GUI）方面，基于控制台的网络编程核心功能：查看在线用户列表，私聊，群发消息，发送文件，服务端推送新闻/消息扩展功能：单点登录 等一些bug……后续增加，离线留言，离线发送文件功能的实现，可以前往我的下一篇文章，java实现多用户即时通信系统（二）——离线留言和离线发送文件
多用户即时通信系统
要学就学灰太狼的博客
01-06 333
1 为什么选择这个项目 （1）有趣 （2）设计到Java各个方面的技术 项目框架设计 Java面向对象编程 网络编程 多线程 IO流 MySQL （3）巩固旧知识，学习新知识 1.1 项目开发流程
java 多用户即时通信系统的实现 万字详解
Cyan_RA9的博客
05-01 4405
java 多用户即时通讯系统 提升功力推荐（难度较大）。
多用户即时通讯系统
jerker___的博客
04-22 1516
多用户即时通讯系统 项目放置于GitHub ,连接： 多用户即时通讯系统 提前说明 没有UI界面，即在控制台显示 功能不够完善，存在诸多bug 需先运行服务端在运行客户端 服务端运行 客户端运行 用户的用户名和密码 使用技术：java基础 线程 IO流 网络编程 Socket 面向对象等 实现功能 客户端 显示在线用户列表 群发消息(发送给所有用户) 私聊 发送文件 退出登录 服务端 推送消息(推送给所有用户) 关闭服务器 ...
java-开源即时通讯(IM)系统Android端
07-12
在即时通讯系统中，Java 的并发处理能力对于实现多用户同时在线聊天至关重要。 2. **Android SDK**：Android SDK 提供了用于构建 Android 应用的各种工具和框架，包括用于网络通信的 API，如 HttpURLConnection 和 ...
基于Java的OIM即时通讯聊天系统设计源码
04-15
基于Java的OIM即时通讯聊天系统设计源码，该项目包含6809个文件，主要文件类型有4937个png图像文件...该项目是一个基于Java的OIM即时通讯聊天系统设计源码，可能涉及用户界面设计、应用逻辑实现、数据存储等多个方面。
java适用于开发者的分布式即时通讯系统
07-12
1. **Java NIO (非阻塞I/O)**: 在构建分布式即时通讯系统时，Java NIO提供了异步I/O操作的能力，允许服务器处理更多的并发连接，提高了系统的吞吐量。NIO的通道和缓冲区机制降低了CPU的上下文切换，提高了系统效率。...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1132
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 406
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 771
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 786
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 133
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 323
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 973
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 820
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
Java局域网即时通讯系统设计与实现
然而，值得注意的是，尽管Java即时通讯系统具备一定的优点，如易用性和可扩展性，但在实际应用中可能需要考虑更多因素，如安全性、性能优化、用户体验以及与其他系统的集成。例如，为了防止未经授权的访问，系统可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值