如何利用协议编写一个简单的聊天室

最新推荐文章于 2024-07-05 17:27:57 发布
最新推荐文章于 2024-07-05 17:27:57 发布
阅读量1.3k 收藏 5
点赞数 3
分类专栏： # Java 文章标签： 聊天 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YouBeHui/article/details/53138695
版权

1.先建立两个项目，一个是客户端，一个是服务器端。
   项目搭建如下所示：
   其中YcChart 为客户端，YcChatServer为服务器端。
项目搭建如下所示

2.编写协议类（两边的协议要一样，即自定义的YCCP协议）

package com.yc.entity;

public class YCCP {
    public static final int LOGIN = 1;      //登录处理
    public static final int SEND_MSG = 2;   //消息处理
    public static final int USER_LIST = 3;  //登录用户处理
    private int code;           // 区分不同的消息
    private String content;     // 发送的内容

    public YCCP() {
    }

    public YCCP(int code, String content) {
        this.code = code;
        this.content = content;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

3.Java是面向对象编程，所以我们把一个用户定义为一个User类（两边的User类相同）

package com.yc.entity;

public class User {
    private String name;   //用户名称
    private String ip;     //用户IP地址

    public User() {
    }

    public User(String name, String ip) {
        this.name = name;
        this.ip = ip;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }
}

4.编写服务器（Server）

package com.yc.server;

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

public class Server {

    private ServerSocket server;

    public static void main(String[] args) {
        new Server().startServer();
    }

    private void startServer() {
        try {
            server = new ServerSocket(9090);
            System.out.println("服务器启动，,端口9090成功...");
            while(true){    //接收多个请求客户端
                Socket client = server.accept();    //接受客户请求，没有请求就等待
                System.out.println("接收请求： " + client);
                new Thread( new ClientStack(client)).start();   //每一个客户请求，都一个线程，这样就不会相互影响了
            }
        } catch (IOException e) {
            System.err.println("服务器启动失败");
        }
    }
}

5.编写客户端接收处理类（ClientStack）

package com.yc.server;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Scanner;

import com.google.gson.Gson;
import com.yc.entity.User;
import com.yc.entity.YCCP;

public class ClientStack implements Runnable {
    private static List<ClientStack> clients = new ArrayList<ClientStack>();
    private static List<User> users = new ArrayList<User>();
    private Socket client;
    private Scanner in;
    private PrintWriter out;
    private User user;
    public ClientStack(Socket client) {
        try {
            this.client = client;
            in = new Scanner(client.getInputStream());  //接收客户端发送过来的数据输入流
            out = new PrintWriter( client.getOutputStream());   //向客户端发送响应数据输出流
            clients.add(this);  //加入当前请求的客户端到集合
        } catch (IOException e) {
            System.err.println( client.getInetAddress() + ":" + client.getPort() + "断开与服务器连接！！！");  //拼接客户端发送过来的数据
        }
    }

    @Override
    public void run() {
        boolean isExit= true;
        while(isExit){
            String line=null;
            YCCP yccp=null;
            try {
                line = in.nextLine(); //拼接客户端发送过来的数据
                yccp =new Gson().fromJson(line, YCCP.class);
                switch(yccp.getCode()){
                    case YCCP.LOGIN:
                        line = doLogin(yccp);
                        break;

                    case YCCP.SEND_MSG:
                        line = acceptMsg(yccp);
                        break;
                }
            } catch (Exception e) {
                line = user.getName() + "退出了聊天室...\r\n";
                clients.remove(this);
                users.remove(user);
                isExit = false;
            }   

            boardcast(YCCP.SEND_MSG,line);

            if(yccp != null && yccp.getCode() == YCCP.LOGIN || !isExit){
                boardcast(YCCP.USER_LIST, new Gson().toJson(users));
            }
        }


    }

    private void boardcast(int code,String line){
        Gson gson = new Gson();
        line = gson.toJson(new YCCP(code, line));  //转换成json格式输出
        for (ClientStack clientStack:clients) {
            clientStack.out.println(line); //给客户端写入的内容
            clientStack.out.flush();
        }
    }


    //接收发送消息处理
    private String acceptMsg(YCCP yccp) {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        String msg = String.format("%s  %s : \r\n %s \r\n", user.getName(),sdf.format(new Date()),yccp.getContent());
        return msg;
    }

    //登录处理
    private String doLogin(YCCP yccp) {
        String uname = yccp.getContent();
        String ip = client.getInetAddress() +":" +client.getPort();
        user=new User(uname, ip); 
        users.add(user);
        return uname + "加入聊天室... \r\n";
    }

}

6.编写客户端ui界面（TalkView）

package com.yc.ui;

import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Type;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.List;
import java.util.Scanner;

import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.wb.swt.SWTResourceManager;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.yc.entity.User;
import com.yc.entity.YCCP;

import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;


public class TalkView {
    protected Shell shell;
    private Text uname;
    private Text text_1;
    private Text text_2;
    private Text chatMessage;
    private Table table;
    private Text message;



    private Button connetBtn; // 联接
    private Button breakBtn; // 断开
    private Button sendBtn; // 发送

    private boolean flag = false;   //标识变量，控制接收消息处理

    private Socket client;
    private Scanner in;
    private PrintWriter out;
    public static void main(String[] args) {
        try {
            TalkView window = new TalkView();
            window.open();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void open() {
        Display display = Display.getDefault();
        createContents();
        shell.open();
        shell.layout();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
    }

    protected void createContents() {
        shell = new Shell();
        shell.setSize(856, 619);
        shell.setText("源辰聊天室");
        shell.setImage(SWTResourceManager.getImage(TalkView.class, "/images/yc.ico"));
        shell.setLayout(new FillLayout(SWT.HORIZONTAL));
        SashForm sashForm = new SashForm(shell, SWT.NONE);
        sashForm.setOrientation(SWT.VERTICAL);

        Group group = new Group(sashForm, SWT.NONE);
        group.setText("连接配置");

        Label label = new Label(group, SWT.NONE);
        label.setBounds(10, 38, 54, 18);
        label.setText("昵称:");

        uname = new Text(group, SWT.BORDER);
        uname.setText("random");
        uname.setBounds(78, 38, 70, 18);

        Label lblip = new Label(group, SWT.NONE);
        lblip.setBounds(177, 38, 54, 18);
        lblip.setText("服务器IP:");

        text_1 = new Text(group, SWT.BORDER);
        text_1.setText("127.0.0.1");
        text_1.setBounds(260, 38, 167, 18);

        Label label_2 = new Label(group, SWT.NONE);
        label_2.setBounds(446, 38, 54, 18);
        label_2.setText("端口");

        text_2 = new Text(group, SWT.BORDER);
        text_2.setText("9090");
        text_2.setBounds(521, 38, 70, 18);

        connetBtn = new Button(group, SWT.NONE);
        connetBtn.setBounds(614, 38, 72, 22);
        connetBtn.setText("联接");

        breakBtn = new Button(group, SWT.NONE);
        breakBtn.setEnabled(false);
        breakBtn.setBounds(719, 38, 72, 22);
        breakBtn.setText("断开");

        Group group_1 = new Group(sashForm, SWT.NONE);
        group_1.setText("聊天记录");
        group_1.setLayout(new FillLayout(SWT.HORIZONTAL));

        SashForm sashForm_1 = new SashForm(group_1, SWT.NONE);

        Composite composite = new Composite(sashForm_1, SWT.NONE);
        composite.setLayout(new FillLayout(SWT.HORIZONTAL));

        chatMessage = new Text(composite, SWT.BORDER | SWT.READ_ONLY | SWT.WRAP
                | SWT.H_SCROLL | SWT.V_SCROLL | SWT.CANCEL | SWT.MULTI);
        chatMessage.setBackground(SWTResourceManager.getColor(SWT.COLOR_WIDGET_HIGHLIGHT_SHADOW));


        Group group_3 = new Group(sashForm_1, SWT.NONE);
        group_3.setText("在线用户列表");
        group_3.setLayout(new FillLayout(SWT.HORIZONTAL));

        table = new Table(group_3, SWT.BORDER | SWT.FULL_SELECTION);
        table.setHeaderVisible(true);
        table.setLinesVisible(true);

        TableColumn tableColumn = new TableColumn(table, SWT.NONE);
        tableColumn.setWidth(150);
        tableColumn.setText("昵称");

        TableColumn tblclmnIp = new TableColumn(table, SWT.NONE);
        tblclmnIp.setWidth(200);
        tblclmnIp.setText("IP");
        sashForm_1.setWeights(new int[] { 470, 369 });

        Group group_2 = new Group(sashForm, SWT.NONE);
        group_2.setText("聊天信息");

        Label label_1 = new Label(group_2, SWT.NONE);
        label_1.setBounds(36, 29, 54, 18);
        label_1.setText("内容");

        message = new Text(group_2, SWT.BORDER);
        message.setBounds(111, 23, 519, 70);

        sendBtn = new Button(group_2, SWT.NONE);
        sendBtn.setBounds(700, 51, 72, 22);
        sendBtn.setText("发送");
        sendBtn.setEnabled(false);
        sashForm.setWeights(new int[] { 82, 384, 113 });
        doEvent();

    }

     //事件的集中地
     public void doEvent(){

         //联接
         connetBtn.addSelectionListener(new SelectionAdapter() {
                @Override
                public void widgetSelected(SelectionEvent e) {
                    String ipStr=text_1.getText();
                    String portStr=text_2.getText();
                    InetAddress address;
                    try {
                        address = InetAddress.getByName(ipStr);
                    } catch (UnknownHostException e1) {
                        MessageBox mb = new MessageBox(shell);
                        mb.setText("连接服务器信息");
                        mb.setMessage("服务连接地址有问题！！！");
                        mb.open();
                        return;
                    }
                    try {
                        client = new Socket(address, Integer.parseInt(portStr));    //建立与服务器的连接通道
                        flag = true;
                        in = new Scanner(client.getInputStream());  //通道的输入流
                        out = new PrintWriter(client.getOutputStream());    //通道的输出流
                        doLogin();

                        acceptMessage();
                        breakBtn.setEnabled(true);
                        connetBtn.setEnabled(false);
                    } catch (NumberFormatException | IOException e1) {
                        MessageBox mb = new MessageBox(shell);
                        mb.setText("连接服务器信息");
                        mb.setMessage("连接服务器失败，请检查服务器信息");
                        mb.open();
                        return;
                    }
                }
            });

         //断开连接
         breakBtn.addSelectionListener(new SelectionAdapter() {
                @Override
                public void widgetSelected(SelectionEvent e) {
                    MessageBox mb = new MessageBox(shell,SWT.YES| SWT.NO | SWT.ICON_WARNING);
                    mb.setText("连接服务器信息");
                    mb.setMessage("是否断开与服务器的连接？");
                    if(mb.open()==SWT.YES){
                            try {
                                flag = false;
                                client.close();
                                chatMessage.setText("");
                                breakBtn.setEnabled(false);
                                connetBtn.setEnabled(true);
                                table.removeAll();
                            } catch (IOException e1) {
                                // TODO Auto-generated catch block
                                e1.printStackTrace();
                            }
                    }
                }
            });

         //发送消息
         sendBtn.addSelectionListener(new SelectionAdapter() {
                @Override
                public void widgetSelected(SelectionEvent e) {
                    SendMessage();

                }
            });

         //发送信息框处理
         message.addModifyListener(new ModifyListener() {
                public void modifyText(ModifyEvent arg0) {
                    sendBtn.setEnabled("".intern() != message.getText().trim());
                }
            });

         //按Enter键发送
         message.addKeyListener(new KeyAdapter() {
                @Override
                public void keyReleased(KeyEvent e) {
                    if(e.keyCode==13){
                        SendMessage();
                    }
                }
            });

     }

    //接收服务器发送过来的消息
    public void acceptMessage() {
        new Thread(){
            public void run() {
                while(flag){
                    if(in.hasNextLine()){
                        String line = in.nextLine();
                        YCCP yccp =new Gson().fromJson(line, YCCP.class);
                        switch(yccp.getCode()){
                            case YCCP.USER_LIST:
                                doUserList(yccp);
                                break;

                            case YCCP.SEND_MSG:
                                doMsg(yccp);
                                break;
                        }

                    }
                }
            };
        }.start();
    }

    public void doMsg(YCCP yccp) {
        final String line = yccp.getContent();
        Display.getDefault().asyncExec(new Runnable(){
            @Override
            public void run() {
                chatMessage.setText(chatMessage.getText() + "\r\n" + line);
            }
        });
    }

    public void doUserList(YCCP yccp) {
        Gson gson = new Gson();
        Type t=new TypeToken<List<User>>(){}.getType(); //json复杂类型的转换
        final List<User> users = gson.fromJson(yccp.getContent(), t);
        Display.getDefault().asyncExec(new Runnable(){
            @Override
            public void run() {
                table.removeAll();
                for(User user : users){
                    TableItem ti = new TableItem(table,SWT.NONE);
                    ti.setText(new String[]{user.getName(),user.getIp()});
                }
            }
        });

    }



    //向服务器发送消息
    public void SendMessage() {
        YCCP yccp = new YCCP(YCCP.SEND_MSG,message.getText());
        String msg = new Gson().toJson(yccp);
        out.println(msg);
        out.flush();
        message.setText("");
    }

    public void SendMessage(String msg) {
        out.println(msg);
        out.flush();
    }

    //第一次连接做登录
    public void doLogin(){
        String user = uname.getText();
        YCCP yccp = new YCCP(YCCP.LOGIN,user);
        SendMessage(new Gson().toJson(yccp));
    }
}
codeRandom
关注
专栏目录
基于TCP协议的网络聊天室
爱科比的博客
07-27 1065
1.客户端 package 网络编程; import java.io.*; import java.net.Socket; import java.util.Scanner; public class Client1 { public static void main (String[] args) throws Exception { Socket s= new...
实现一个简单的语音聊天室（源码）
weixin_34199335的博客
10-30 1964
　　语音聊天室，或多人语音聊天，是即时通信应用中常见的功能之一，比如，QQ的语音讨论组就是我们用得比较多的。        这篇文章将实现一个简单的语音聊天室，让多个人可以进入同一个房间进行语音沟通。先看运行效果截图： 　　         　　 从左到右的三张图分别是：登录界面、语音聊天室的主界面、标注了各个控件的主界面。 　　（如果觉得界面太丑，没关系，后面下载源码后，你可以自己美化~...
BASH Shell中的NetCat(nc)搭建聊天室
2403_83125679的博客
07-05 119
首先访问https://ipecho.net/ 查看你的IP地址,然后把你的IP地址复制下来(在Your IP is 后面)因为有时候他的字可能输入的时候输入不全,而且这个命令行好像是旧一点儿的,所以他文字有的会在这个端上显示却没有在那个端上显示。创建了一个nc套接字,然后回车,就可以输入消息了。nc -l 你的IP地址 想要占用的端口。能正常收发消息,但是不能显示姓名的。nc 你的IP地址 占用的端口。回车,就可以输入消息了。在termux中输入。在termux中输入。
网络编程TCP协议-聊天室
weixin_30648587的博客
09-23 122
网络编程TCP协议-聊天室（客户端与服务端的交互）;<span style="font-size:18px;">1、客户端发数据到服务端。</span><span style="font-size:18px;">2、</span><span style="font-size: 18px; font-family: Arial, Helv...
webSocket协议（聊天室）
刺心的博客
06-24 420
1)HTTP无法轻松实现实时应用： 1、 HTTP协议是无状态的，服务器只会响应来自客户端的请求，但是它与客户端之间不具备持续连接。 2、我们可以非常轻松的捕获浏览器上发生的事件（比如用户点击了盒子），这个事件可以轻松产生与服务器的数据交互（比如Ajax）。但是，反过来却是不可能的：服务器端发生了一个事件，服务器无法将这个事件的信息实时主动通知它的客户端。只有在客户端查询服务器的当前状态的时...
eclipse实现的聊天室
05-30
一个不错的聊天室示例，共同学习
Java基于UDP协议实现简单的聊天室程序
09-02
这个简单的Java UDP聊天室程序实现了基本的聊天功能，包括用户登录聊天室和在聊天室内发送消息。服务器端负责接收所有客户端发送的数据包，解析其中的聊天信息，并将消息分发到对应的聊天室。客户端则负责登录聊天室...
WebSocket编写的简单聊天室
02-18
6. **UI界面**：尽管描述中提到该项目的UI可能不完美，但一个简单的聊天室至少会有一个输入框供用户输入消息，一个展示聊天记录的区域，以及一个发送按钮。这部分可能使用HTML、CSS和JavaScript实现，与WebSocket...
python基于twisted框架编写简单聊天室
09-20
在本案例中，我们将使用Twisted来创建一个简单的聊天室应用，让多个客户端可以通过TCP连接进行实时通信。 首先，我们需要导入所需的模块： ```python from twisted.internet.protocol import Factory from twisted...
JAVA语言写的一个简单的聊天室
12-16
Java语言是一种广泛应用于各种领域的编程语言，因其跨平台的特性，常被用来开发网络应用程序，如本例中的一个简单的聊天室。聊天室是多用户实时交流的平台，通过网络连接将用户的输入广播给所有在线用户。在Java中，...
简单聊天室的编写
11-09
【标题】"简单聊天室的编写"所涉及的知识点主要集中在构建一个基本的在线聊天平台，包括用户登录、注册和群聊功能。这样的项目对于初学者来说，是学习网络编程和交互式应用开发的一个良好实践。 【描述】中的关键...
eclipse java聊天室
03-02
java聊天室，带有可执行文件，源代码和效果图
java聊天室（Eclipse开发）
10-26
带有注册功能，可多人聊天，用到了数据库。里面有怎样使源代码的视频，是一本书的随书光盘里的。
Android Stdio+Eclipse开发的聊天室
04-04
Android Stdio开发的客户端，eclipse开发的服务器，采用多线程模式，利用Socket通信实现数据传输。
java实现简易聊天室（eclipse源码）.zip
11-14
使用JAVA完成了类似QQ的简易聊天室功能。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行编程。
基于QT的TCP聊天室（包含TCP服务器和客户端）
03-28
自己写的一个TCP聊天室软件。实现了客户端与客户端通过外网通信，这里的外网通信是用花生壳的内网穿透功能实现的。也就是通过花生壳使内网TCP服务器的 IP地址和端口 映射到公网的ip地址和端口。然后让TCP客户端都去链接这个TCP服务器，这个服务器主要负责客户端信息的转发。也就是“客户端<--->客户端”.客户端的信息用数据库保存，写了两个版本的数据库。sqlite3和mysql。实际上改动不大，也就是开始链接数据库和表的创建有所不同。
基于UDP/IP协议的聊天室
weixin_44846862的博客
07-25 284
基于TCP/IP通信协议的聊天室 概述： 基于TCP/IP通信协议的聊天室是通过服务端/客户端的模式进行的，必须是服务端开启之后，客户端通过获取服务端的ip和端口号并连接之后才能进行信息的共享，具体的实现过程代码如下： package cs聊天室; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.ArrayList; import java.util.C
TCP协议简述（聊天室实现）
weixin_34005042的博客
10-09 1092
前言TCP 为传输层协议，在 NodeJS 中，基于 TCP 的核心模块为 net，http 和 https 模块都是基于 net 实现的，我们先简单介绍 net 的用法，再根据 net 实现一个简易的聊天室。net 模块的基本用法1、使用 net 创建一个网络服务方式 1：const net = require("net"); // 创建 TCP 服务 const server = net.c...
C/S架构即时聊天程序程序设计——通信协议设计
lwylhh的博客
03-23 1487
此次讨论的协议是数据传输时遵照的一定格式。 文章目录协议要求通信种类分析协议设计代码实现 协议要求 一个好的通信协议，首先要囊括所有需要发送的信息，能适应各种发送情况，不管你需要向服务端发送一条消息，还是需要验证登录，都可以通过固定的协议格式发送。在这个基础上应该尽量精简，减少打包发送和解包读取的工作量，减轻双方的负担。所以在设计协议之前我们需要讨论都有可能发送何种消息，根据具体的需求确定具体的协...
利用C语言编写基于TCP协议的聊天室程序
最新发布
09-11
利用C语言编写基于TCP协议的聊天室程序，大致可以分为以下几个步骤： 1. 网络编程基础：首先需要了解TCP协议的工作原理，以及C语言中网络编程的相关API。TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议，它提供全双工服务，并且是面向字节流的。 2. 套接字（Socket）编程：在C语言中，可以使用套接字来实现网络通信。创建套接字，需要指定地址族（Address Family）、套接字类型和协议类型。对于TCP协议，地址族通常是AF_INET（IPv4地址），套接字类型是SOCK_STREAM，协议类型是IPPROTO_TCP。 3. 服务器端实现： - 创建套接字，绑定IP地址和端口号。 - 监听连接请求。 - 接受客户端连接请求。 - 读取和发送数据。 - 关闭套接字。 4. 客户端实现： - 创建套接字。 - 连接到服务器的IP地址和端口号。 - 发送和接收数据。 - 关闭套接字。 5. 多线程或多进程：为了能够同时处理多个客户端连接，服务器端通常会使用多线程或多进程技术。每个客户端连接可以由一个线程或进程来处理，这样可以实现并发通信。 6. 完善功能：为了构建一个完整的聊天室程序，还需要考虑数据的封装、协议设计（比如聊天消息的格式）、用户管理、会话管理等。 以下是一个简化的示例代码框架，展示了基于TCP的简单聊天室服务器端的核心步骤： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <pthread.h> #define PORT 8080 #define BUFFER_SIZE 1024 void* handle_client(void* arg); int main(int argc, char *argv[]) { int sockfd, new_sockfd; socklen_t clilen; char buffer[BUFFER_SIZE]; struct sockaddr_in serv_addr, cli_addr; pthread_t thread_id; sockfd = socket(AF_INET, SOCK_STREAM, 0); memset(&serv_addr, 0, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(PORT); bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); listen(sockfd, 10); clilen = sizeof(cli_addr); while(1) { new_sockfd = accept(sockfd, (struct sockaddr*)&cli_addr, &clilen); if(new_sockfd < 0) { perror("ERROR on accept"); continue; } if(pthread_create(&thread_id, NULL, handle_client, (void*)&new_sockfd) < 0) { perror("ERROR creating thread"); close(new_sockfd); continue; } } return 0; } void* handle_client(void* arg) { int sockfd = *((int*)arg); char buffer[BUFFER_SIZE]; int read_size; // 读取数据并发送给客户端 while(1) { memset(buffer, '\0', BUFFER_SIZE); read_size = read(sockfd, buffer, BUFFER_SIZE - 1); if(read_size == 0) { printf("Client closed the connection\n"); break; } else if(read_size > 0) { printf("From client: %s", buffer); // 发送数据给客户端，这里假设只是简单地回显 write(sockfd, buffer, strlen(buffer)); } } close(sockfd); return NULL; } ``` 注意：上述代码仅为示例，没有包含错误处理、用户交互、多线程同步等完整聊天室所需的全部功能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值