IO-BIO聊天室升级版

最新推荐文章于 2022-07-21 21:52:17 发布
最新推荐文章于 2022-07-21 21:52:17 发布
阅读量237 收藏 1
点赞数
分类专栏： io 文章标签： bio架构 bio-socket聊天室 bio学习实战 socket全双工 bio实现客户端管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22271479/article/details/86426075
版权

IO-BIO聊天室升级版

存在的问题

在这里插入图片描述
当处理线程池达到最大线程的时候，那么后面的客户端将无法发送消息，这个是致命的。

新思路

在这里插入图片描述

该架构的优点

  1. 解决了之前版本在线程池达到最大线程数的时候，服务端将不能在处理新加入的客户端，除非客户端掉线，线程才有机会去处理。
  2. 该版本支持大规模的客户端在线服务。
  3. 通过接管了客户端input监听，能更好控制线程数，维持机器的良好新能，可控。

项目架构

Server

  • AbstractBioServer
    • BioServer
    • BioServerSupper
AbstractBioServer

是Server的抽象类，实现了基础的一些操作，规定了需要子类实现的一些方法。

package com.yzz.chartroom.server;

import com.yzz.chartroom.protocol.Message;

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * describe:
 * E-mail:yzzstyle@163.com  date:2019/1/13
 *
 * @Since 0.0.1
 */
public abstract class AbstractBioServer {
    //默认端口
    public static final int DEFAULT_PORT = 8080;

    //默认地址
    public static final String DEFAULT_LOCATION = "127.0.0.1";

    //客户端连接(socket连接)的队列最大长度
    public static final int DEFAULT_BACKLOG = 50;

    //服务端口
    protected final int port;

    //连接队列的最大长度
    protected final int backlog;

    //地址
    protected final String location;

    //Socket监听服务对象
    protected ServerSocket serverSocket;

    //Socket服务监听地址包装类
    protected InetAddress inetAddress;

    //这是一个线程安全的非阻塞的队列
    protected volatile  ConcurrentLinkedQueue<Socket> clientSockets = new ConcurrentLinkedQueue<>();

    //日志
    protected Logger logger = Logger.getLogger(this.getClass().getName());

    protected AbstractBioServer(int port, int backlog, String location) throws IOException {
        this.port = port;
        this.backlog = backlog;
        this.location = location;
        inetAddress = InetAddress.getByName(location);
        //创建一个端口监听对象，监听客户端连接，此刻服务端已经就绪
        serverSocket = new ServerSocket(port, backlog, inetAddress);
        logger.log(Level.INFO, "BIO server has started in " + location + " listening port " + port);
    }

    /**
     * 清除资源 从队列中去移除
     *
     * @param client
     */
    public void remove(Socket client) {
        try {
            boolean result = clientSockets.remove(client);
            if (result && client != null && !client.isClosed()) {
                //关闭连接
                client.close();
                logger.log(Level.WARNING, "移除client" + client.getInetAddress().getHostAddress() + ":" + client.getPort());
            }
        } catch (IOException e) {
            e.printStackTrace();
            logger.log(Level.WARNING, e.getMessage());
        }
    }

    /**
     * 监听客户端连接
     *
     * @throws IOException
     */
    protected abstract void listen() throws IOException;

    /**
     * 提供客户端消息服务
     *
     * @param client
     */
    protected abstract void provideService(Socket client);

    /**
     * 获取客户端消息
     *
     * @param client
     * @return
     * @throws IOException
     */
    protected abstract Message readRequest(Socket client) throws IOException;

    /**
     * 转发客户端消息
     *
     * @param message
     */
    protected abstract void dispatch(Message message);
}
BioServer

是上一个版本的实现类,通过为每个客户端分配线程实现客户端监听

package com.yzz.chartroom.server;

import com.yzz.chartroom.protocol.BioChartRoomProtocol;
import com.yzz.chartroom.protocol.Message;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.util.Iterator;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * describe: 聊天室服务端
 * E-mail:yzzstyle@163.com  date:2019/1/12
 * 你可以简单的这样去启动一个服务端
 *
 * @Since 0.0.1
 * <p>
 * public class Server {
 * public static void main(String[] args) {
 * try {
 * BioServer bioServer = BioServer.newServerByPort(9090);
 * bioServer.listen();
 * } catch (Exception e) {
 * e.printStackTrace();
 * }
 * }
 * }
 */
public class BioServer extends AbstractBioServer {

    //线程池，用于执行接收客户端消息并转发消息至所有在线的客户端，这里最大可以接收10 + Integer.MAX_VALUE 个客户端
    private final Executor pool = Executors.newFixedThreadPool(1);

    /**
     * 创建一个默认的聊天室服务端
     *
     * @return
     * @throws IOException
     */
    public static BioServer createServerByDefault() throws IOException {
        return new BioServer(DEFAULT_PORT, DEFAULT_BACKLOG, DEFAULT_LOCATION);
    }

    /**
     * 创建一个自定义端口的服务端
     *
     * @param port
     * @return
     * @throws IOException
     */
    public static BioServer newServerByPort(int port) throws IOException {
        return new BioServer(port, DEFAULT_BACKLOG, DEFAULT_LOCATION);
    }

    /**
     * 创建一个自定义端口和连接队列深度的服务
     *
     * @param port    端口
     * @param logback 连接队列最大num
     * @return
     * @throws IOException
     */
    public static BioServer newServerWithDefaultLocation(int port, int logback) throws IOException {
        return new BioServer(port, logback, DEFAULT_LOCATION);
    }

    /**
     * 自定义端口、连接大小、地址的服务端对象
     *
     * @param port
     * @param logback
     * @param location
     * @return
     * @throws IOException
     */
    public static BioServer newServerDynamic(int port, int logback, String location) throws IOException {
        return new BioServer(port, logback, location);
    }

    /**
     * @param port     监听的端口号
     * @param backlog  客户端连接的队列最大长度
     * @param location 地址
     * @throws IOException
     */
    protected BioServer(int port, int backlog, String location) throws IOException {
        super(port, backlog, location);
    }

    /**
     * accept 监听客户端的连接
     * 1. accept()获取客户端Socket
     * 2. provideService（）提供处理客户端消息的服务
     *
     * @throws IOException
     */
    @Override
    public void listen() throws IOException {
        while (true) {
            Socket client = serverSocket.accept();
            clientSockets.add(client);
            logger.log(Level.INFO, client.getInetAddress().getHostAddress() + "加入了聊天室");
            logger.log(Level.INFO, "当前在线人数：" + clientSockets.size());
            pool.execute(() -> provideService(client));
        }
    }

    /**
     * 提供服务 轮询去客户端处理消息
     *
     * @param client
     */
    @Override
    protected void provideService(Socket client) {
        while (true) {
            //自定义协议 消息对象
            Message message = null;
            try {
                //1. 获取客户端发送至服务端的消息
                message = readRequest(client);
                //1.如果客户端队列的size为0，就说明所有客户端都已经下线，直接结束轮询
                if (clientSockets.size() == 0) {
                    break;
                } else {
                    //转发消息至所有客户端
                    dispatch(message);
                }
            } catch (IOException e) {
                //这里的异常表示客户端已经下线，此时需要去清除客户端连接资源
                logger.log(Level.WARNING, e.getMessage());
                remove(client);
                break;
            }
        }
    }

    /**
     * 读取客户端发送来的消息
     *
     * @param client 客户端Socket
     * @return
     * @throws IOException
     */
    @Override
    protected Message readRequest(Socket client) throws IOException {
        InputStream in = client.getInputStream();
        //自定义协议负责去解析消息
        return BioChartRoomProtocol.getInstance().parse(in);
    }

    /**
     * 转发请求至所有客户端
     *
     * @param message
     */
    @Override
    protected void dispatch(Message message) {
        Iterator<Socket> clients = clientSockets.iterator();
        Socket client = null;
        //遍历发送至客户端，该方法是同步方法，so，客户端收到的消息是先后顺序和其进入聊天室的顺序是一致的
        while (clients.hasNext()) {
            try {
                client = clients.next();
                logger.log(Level.INFO, "转发消息至" + message.getHeader().toString());
                //协议去写入消息至客户端
                BioChartRoomProtocol.getInstance().write(client.getOutputStream(), message);
            } catch (IOException e) {
                //这里的异常表示客户端已经下线，此时需要去清除客户端连接资源
                e.printStackTrace();
                logger.log(Level.INFO, e.getMessage());
                remove(client);
            }
        }
    }

}
BioServerSupper

该类是第二版，通过一条工作线程去轮询监听客户端输入状态，通过线程池并发去转发消息。

package com.yzz.chartroom.server;

import com.yzz.chartroom.protocol.BioChartRoomProtocolSupper;
import com.yzz.chartroom.protocol.Message;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.util.Iterator;
import java.util.concurrent.*;
import java.util.logging.Level;

/**
 * describe: 聊天室服务端
 * E-mail:yzzstyle@163.com  date:2019/1/12
 * 你可以简单的这样去启动一个服务端
 *
 * @Since 0.0.1
 * <p>
 * public class Server {
 * public static void main(String[] args) {
 * try {
 * BioServer bioServer = BioServer.newServerByPort(9090);
 * bioServer.listen();
 * } catch (Exception e) {
 * e.printStackTrace();
 * }
 * }
 * }
 */
public class BioServerSupper extends AbstractBioServer {

    private final int core = Runtime.getRuntime().availableProcessors();

    //循环监听线程
    private final ThreadPoolExecutor providerPool = new ThreadPoolExecutor(core, core, 2, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

    //等待队列
    private volatile ConcurrentLinkedQueue<Socket> waitQueue = new ConcurrentLinkedQueue();


    //处理消息线程池
    private ExecutorService handelMessagePool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    /**
     * 创建一个默认的聊天室服务端
     *
     * @return
     * @throws IOException
     */
    public static BioServer createServerByDefault() throws IOException {
        return new BioServer(DEFAULT_PORT, DEFAULT_BACKLOG, DEFAULT_LOCATION);
    }

    /**
     * 创建一个自定义端口的服务端
     *
     * @param port
     * @return
     * @throws IOException
     */
    public static BioServerSupper newServerByPort(int port) throws IOException {
        return new BioServerSupper(port, DEFAULT_BACKLOG, DEFAULT_LOCATION);
    }

    /**
     * 创建一个自定义端口和连接队列深度的服务
     *
     * @param port    端口
     * @param logback 连接队列最大num
     * @return
     * @throws IOException
     */
    public static BioServerSupper newServerWithDefaultLocation(int port, int logback) throws IOException {
        return new BioServerSupper(port, logback, DEFAULT_LOCATION);
    }

    /**
     * 自定义端口、连接大小、地址的服务端对象
     *
     * @param port
     * @param logback
     * @param location
     * @return
     * @throws IOException
     */
    public static BioServerSupper newServerDynamic(int port, int logback, String location) throws IOException {
        return new BioServerSupper(port, logback, location);
    }

    protected BioServerSupper(int port, int backlog, String location) throws IOException {
        super(port, backlog, location);
    }

    /**
     * 轮询监听客户端输入
     */
    public void loopClientForProviderServer() {
        providerPool.execute(
                () -> {
                    while (true) {
                        Socket[] clients = new Socket[clientSockets.size()];
                        //监听
                        listenClientInputStatus(clientSockets.toArray(clients));
                    }
                }
        );
    }

    /**
     * 监听客户端输入状态
     *
     * @param clients
     */
    public void listenClientInputStatus(Socket[] clients) {
        for (Socket client : clients) {
            if (!clientIsOk(client)) {
                remove(client);
                continue;
            }
            if (waitQueue.contains(client)) {
                continue;
            }
            try {
                InputStream inputStream = client.getInputStream();
                if (inputStream.available() > 0) {
                    //如果有消息，则加入等待处理的队列，一旦加入不可重复消费
                    waitQueue.add(client);
                    //提供转发服务
                    provideService(client);
                }
            } catch (IOException e) {
                logger.log(Level.WARNING, e.getMessage());
                remove(client);
            }
        }
    }

    /**
     * 判断客户端是否有效
     *
     * @param client
     * @return
     */
    public boolean clientIsOk(Socket client) {
        if (client == null || client.isClosed() || client.isInputShutdown() || client.isOutputShutdown()) {
            return false;
        }
        return true;
    }

    /**
     * 监听，服务的入口
     *
     * @throws IOException
     */
    @Override
    public void listen() throws IOException {
        //开启监听客户端的消息流状态
        loopClientForProviderServer();
        //轮询监听
        while (true) {
            Socket client = serverSocket.accept();
            clientSockets.add(client);
            logger.log(Level.INFO, client.getInetAddress().getHostAddress() + "加入了supper聊天室");
            logger.log(Level.INFO, "当前在线人数：" + clientSockets.size());
        }
    }


    /**
     * 提供妆发服务
     *
     * @param client
     */
    @Override
    protected void provideService(Socket client) {
        handelMessagePool.execute(() -> {
            //检查
            if (!clientIsOk(client)) {
                return;
            }
            try {
                //获取客户端的消息
                Message message = readRequest(client);
                if (message == null) {
                    return;
                }
                if (client != null) {
                    //出队，任务消息转发完毕，可再次提供服务
                    waitQueue.remove(client);
                }
                //转发客户端的消息
                dispatch(message);
            } catch (IOException e) {
                e.printStackTrace();
                logger.log(Level.WARNING, e.getMessage());
                remove(client);
            }
        });
    }

    @Override
    protected Message readRequest(Socket client) throws IOException {
        InputStream in = client.getInputStream();
        //自定义协议负责去解析消息
        return BioChartRoomProtocolSupper.getInstance().parse(in);
    }

    @Override
    protected void dispatch(Message message) {
        Iterator<Socket> clients = clientSockets.iterator();
        Socket client = null;
        //遍历发送至客户端，该方法是同步方法，so，客户端收到的消息是先后顺序和其进入聊天室的顺序是一致的
        while (clients.hasNext()) {
            try {
                client = clients.next();
                logger.log(Level.INFO, Thread.currentThread().getName() + "->转发消息至" + client.getInetAddress().getHostAddress() + ":" + client.getPort());
                //协议去写入消息至客户端
                if (clientIsOk(client)) {
                    BioChartRoomProtocolSupper.getInstance().write(client.getOutputStream(), message);
                }
            } catch (IOException e) {
                //这里的异常表示客户端已经下线，此时需要去清除客户端连接资源
                e.printStackTrace();
                logger.log(Level.INFO, e.getMessage());
                remove(client);
            }
        }
    }
}

client

客户端和上篇一样，客户端不必做更改,详情可见上一篇

项目地址

https://github.com/yinzhongzheng/bio-chatroom

git clone https://github.com/yinzhongzheng/bio-chatroom.git
尹忠政
关注
专栏目录
基于BIO的的多人聊天室，
06-16
基于BIO的多人聊天室，使用了多线程技术，比如 CountDownLatch 和线程池等技术， 以udp为辅，tcp为主, 对于tcp服务器端：客户端的消息读写是双通道的，互不影响
Java网络编程-Socket编程初涉二（基于BIO模型的简易多人聊天室）
kaven
02-03 1113
Java网络编程-Socket编程初涉二（基于BIO模型的简易多人聊天室） 要求 我们要实现一个基于BIO模型的简易多人聊天室，不能像上一个版本一样（Java网络编程-Socket编程初涉一（简易客户端-服务器）），当服务器与某个客户端连接成功后，它们在进行数据交互过程中，其他客户端的连接请求，服务器是不会响应的，我们这里要使用BIO模式来改善这一点。 所谓多人聊天室，就是某个用户发送的消息，其他...
从BIO到实现简单多人聊天室功能--IO模型
m0_52410356的博客
07-21 490
从BIO到实现简单多人聊天室功能
tio-chat -- 一个长得像微信的IM
小屁孩大帅-保密的博客
11-26 1859
https://www.t-io.org/1187879625909477376?pageNumber=1 tio-chat简介 使命：让所有公司都做得出高性能IM 普及版如包含如下功能：好友聊天，群组聊天，消息撤回、已读、未读，消息格式支持图片、视频、表情… … tio-chat同类产品的研发成本在100万以上（架构师1 × 4W、主程1 × 2.5W、前端1 × 1W、测试1 × 1W...
IO-BIO实现聊天室
尹忠政的博客
01-12 904
IO-BIO实现聊天室(Socket全双工) 概述 本次实现的是一个聊天室，使用的是TCP/IP协议，使用自定义传输协议。多个客户端连接上服务端，客户端发送消息到服务端，服务端将客户端加入到客户端队列，通过loop队列，向所有的客户端转发消息。此处转发为同步转发，意味着先加入的客户端将优先收到消息。当客户端离线的时候，服务端将从队列中移除，并且终止针对该客户端的轮询。 流程图 服务端 获取客...
commons-io-2.2-API文档-中文版.zip
04-08
包含翻译后的API文档：commons-io-2.2-javadoc-API文档-中文(简体)版.zip 对应Maven信息：groupId：commons-io，artifactId：commons-io，version：2.2 使用方法：解压翻译后的API文档，用浏览器打开“index.html”...
IO-LINK V1.1.2 和V1.1.3相关标准-中文和英文
最新发布
09-26
IO-LINK V1.1.3是后续的升级版，主要在V1.1.2的基础上进行了增强和优化。此版本可能包括了以下改进： 1. **增强的性能**：可能提升了数据传输的速度和效率，适应了更高速度的工业应用需求。 2. **更多设备类型支持*...
commons-io-1.3.2-API文档-中文版.zip
07-12
包含翻译后的API文档：commons-io-1.3.2-javadoc-API文档-中文(简体)版.zip； Maven坐标：commons-io:commons-io:1.3.2； 标签：commons、io、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开...
commons-io-2.11.0-API文档-中文版.zip
05-31
包含翻译后的API文档：commons-io-2.11.0-javadoc-API文档-中文(简体)版.zip； Maven坐标：commons-io:commons-io:2.11.0； 标签：commons、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开...
commons-io-2.7-API文档-中英对照版.zip
03-30
包含翻译后的API文档：commons-io-2.7-javadoc-API文档-中文(简体)-英语-对照版.zip 对应Maven信息：groupId：commons-io，artifactId：commons-io，version：2.7 使用方法：解压翻译后的API文档，用浏览器打开...
BIO实现简易的聊天室
sjtu_big_pig的博客
12-14 232
代码主要分为4个部分： 1 服务器端 ChartServer 2 客户端 ChartClient 3 当客户端给服务器端发送请求时，服务器端要给每一个提出请求的客户端分配一个线程ChartHandle 3 客户端需要有两个线程，主线程负责读取键盘输入，第二个线程负责读取其他客户端发过来的信息UserInputHandle，就像微信聊天时，一个线程是接受你的输入，同时别人说的话你也可以收到，互不影响...
java-chat-room 聊天室基于Bio
weiyang的博客
10-25 357
Client import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.Socket; public class ClientBio { //相当于自定义协议格式，与客户端协商好 private static Strin...
t-io 入门篇（三）即时消息发送demo学习
chusaiou2655的博客
05-11 1515
前言 t-io作者在开源其框架的同时还附带了几个demo，如：简单的hello world、im等。接下来这篇博客将会围绕tio-examples-im-simple-client、tio-examples-im-simple-server展开分析和学习。 demo项目结构 ...
C++在线多人聊天室
saxiy的博客
06-13 7352
基于SOCKET套接字的聊天程序 当初没有考虑要和别人一起开发什么,所以没有注释, 我还是很相信自己码风的,你肯定看得懂 虽然努力了但还是BUG多多,仅供参考,下次更新就是在暑假了 窝还是一个可怜的高中OIer就不要在意那么多细节嘛 服务端(cmd界面) #include <winsock2.h> #include <windows.h> #include <thr...
BIO聊天室(群聊+私聊)
mazouri的博客
05-10 347
功能:群聊+私发+上线提醒+下线提醒+查询在线用户 文件UtilsFinalValueMessageServerClientReceiveSend Utils FinalValue Message Server Client Receive Send package moremorechat_bio; import java.io.Closeable; public class Utils { /** * 关闭流 * @param targets */ pu
java网络socket编程（八）之java中BIO实现聊天系统的群聊功能
zzjstudent的专栏
08-23 2113
代码分为了三部分：客户端代码、服务器端代码、通用类代码 客户端代码 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.Socket; import java.net.UnknownHostException; /** * 创
BIO实现一个聊天室
一年半
01-29 330
BIO实现一个聊天室 需要实现一个客户端的消息可以发送给所有客户端去接受。(群聊的实现）（B站黑马程序员里的代码） 客户端代码 package BIO_instantmassging.client; import BIO_instantmassging.util.Constants; import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;
BIO聊天室【仅做笔记参考】
L12131415L的博客
02-17 192
Client: package socket; import java.io.*; import java.net.Socket; import java.nio.charset.StandardCharsets; import java.util.Scanner; /** * 聊天室客户端 */ public class Client { /** * java.net.Socket 套接字 * Socket封装了TCP协议的通讯细节，我们使用他可以与远端计算机建立TCP
Java实现聊天室的原理（使用BIO哦）
CrazyMan1997
03-19 2013
PS: 这是参考某课网的视频的 1、使用了UDP和TCP，UDP客户端发送广播，并携带数据头部信息；然后服务器进行监听，收到广播后，首先进行解析头部信息是否符合预期，如果符合则进行回送数据，回送服务器端的将要进行的TCP连接（服务器已经绑定了基本的信息）的信息（服务器端TCP绑定的端口）以及客户端要验证的信息。 2、验证通过后，客户端发起连接 3、服...
commons-io-2.4 API文档双语对照版
资源摘要信息:"commons-io-2.4-API文档-中英对照版.zip" Apache Commons IO是一个用于处理文件和I/O流的实用工具类库。它不属于Java标准库的一部分，但提供了许多用于Java I/O操作的便捷方法，使得文件操作更加简洁...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值