TCP创建多人聊天室
2024-04-20 15:50:32
群聊-聊天室
群聊：任何时候，任何一个客户端都可以向其它客户端发送和接受数据，服务器只起到转发的作用。
1、首先创建一个聊天室的简易版(版本1)。
需求：可以多个用户同时访问服务端，并且可以不断各自请求服务端获取响应的数据。
可以多个用户同时访问服务端：这个需要在服务端创建多线程，使服务端的监听套接字，可以被多个客户端使用。
可以不断各自请求服务端获取响应的数据：这个只需要在客户端的数据发送和接受处加上一层死循环，在服务端的外层套上一层死循环即可。
需要改进的不足之处：
1、客户端只能自己对自己说话，还没有实现群聊的效果。
2、代码比较多，不易于维护。
3、客户端的接收和发送数据没有分离，必须等到指定者发送数据，才能接收指定者的消息。
服务端
代码：
1 package 在线聊天室;
2
3 import java.io.DataInputStream;
4 import java.io.DataOutputStream;
5 import java.io.IOException;
6 import java.net.ServerSocket;
7 import java.net.Socket;
8
9 /**
10 * 模拟单人聊天室
11 * @author liuzeyu12a
12 *
13 */
14 public class Chat {
15 public static void main(String[] args) throws Exception {
16 //建立服务器端套接字，绑定本地端口
17 ServerSocket server = new ServerSocket(9999);
18 while(true){
19 new Thread(()->{
20 Socket client = null;
21 try {
22 //监听客户端
23 client = server.accept();
24 } catch (IOException e) {
25 e.printStackTrace();
26 }
27 System.out.println("一个客户端建立了连接...");
28
29 //接受客户端的消息
30 DataInputStream dis = null;
31 DataOutputStream dos = null;
32 try {
33 dis = new DataInputStream(client.getInputStream());
34 dos = new DataOutputStream(client.getOutputStream());
35 } catch (IOException e) {
36 e.printStackTrace();
37 }
38
39 boolean isRunning = true;
40 while(isRunning) {
41 String msg = null;
42 try {
43 msg = dis.readUTF();
44 } catch (IOException e) {
45 e.printStackTrace();
46 }
47 //返回回去给客户端
48 try {
49 dos.writeUTF(msg);
50 dos.flush();
51 } catch (IOException e) {
52 isRunning = false; //客户端断开即停止读写数据
53 }
54 }
55
56 //释放资源
57 try {
58 if(null!=dos)
59 dos.close();
60 } catch (IOException e) {
61 e.printStackTrace();
62 }
63 try {
64 if(null!=dis)
65 dis.close();
66 } catch (IOException e) {
67 e.printStackTrace();
68 }
69 try {
70 if(null!=client)
71 client.close();
72 } catch (IOException e) {
73 e.printStackTrace();
74 }
75 }).start();
76
77 }
78 }
79 }View Code
客户端
代码：
1 package 在线聊天室;
2
3 import java.io.BufferedReader;
4 import java.io.DataInputStream;
5 import java.io.DataOutputStream;
6 import java.io.IOException;
7 import java.io.InputStreamReader;
8 import java.net.Socket;
9
10 /**
11 * TCP模拟单人聊天室
12 * @author liuzeyu12a
13 *
14 */
15 public class Client {
16 public static void main(String[] args) throws IOException, IOException {
17 //建立客户端套接字
18 Socket client = new Socket("localhost",9999);
19
20 //发送数据
21 BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
22 DataInputStream dis = new DataInputStream(client.getInputStream());
23 DataOutputStream dos = new DataOutputStream(client.getOutputStream());
24 boolean isRunning = true;
25 while(isRunning) {
26 String msg = reader.readLine();
27 dos.writeUTF(msg);
28 //客户端接收服务器的响应
29
30 String respond = dis.readUTF();
31 System.out.println(respond);
32 }
33 //关闭
34 client.close();
35 }
36 }View Code
2、我们将版本1的2，3问题进行改善一下(版本2)。
封装：
1）将服务器的接受和发送数据用一个Channel 类进行封装，这样子一个client 就对应了一个Channel对象了
2）将客户端的接收和发送分离开，使用两个线程进行分割，这样子接收数据和发送数据就可以不用同时进行了(为群聊做准备)。
将关闭资源的系列用一个ChatUtils工具类包装起来,使用Closeable接口。
1 package 在线聊天室;
2
3 import java.io.Closeable;
4 import java.io.IOException;
5 /**
6 * 用于聊天室一些流释放资源
7 * @author liuzeyu12a
8 *
9 */
10 public class ChatUtils {
11
12 static public void close(Closeable...closeables) {
13 for(Closeable target :closeables) {
14 if(null!=target) {
15 try {
16 target.close();
17 } catch (IOException e) {
18 e.printStackTrace();
19 }
20 }
21 }
22 }
23 }利用面向对象思想对服务端进行封装
1 package 在线聊天室;
2
3 import java.io.DataInputStream;
4 import java.io.DataOutputStream;
5 import java.io.IOException;
6 import java.net.ServerSocket;
7 import java.net.Socket;
8
9 /**
10 * 1）将服务器的接受和发送数据用一个Channel 类进行封装，
11 * 这样子一个client 就对应了一个Channel对象了
12
13 2）将客户端的接收和发送分离开，
14 使用两个线程进行分割，这样子接收数据和发送数据就可以不用同时进行了
15 (为群聊做准备)。
16 * @author liuzeyu12a
17 *
18 */
19 public class Chat2 {
20 public static void main(String[] args) throws Exception {
21 System.out.println("-----Server-----");
22 //建立服务器端地址，并绑定本地端口
23 ServerSocket server = new ServerSocket(8989);
24
25 //这边加上死循环是为了接受多个客户的请求
26 while(true) {
27 //监听
28 Socket client = server.accept();
29 System.out.println("一个客户端建立了连接");
30 new Thread(new Channel(client)).start();
31 }
32
33 }
34 //静态内部类，封装处理客户端的数据
35 static class Channel implements Runnable{
36 private DataInputStream dis;
37 private DataOutputStream dos;
38 private Socket client;
39 private boolean isRunning;
40 //构造器
41 public Channel(Socket client) {
42 this.client = client;
43 this.isRunning = true;
44 try {
45 dis = new DataInputStream(
46 client.getInputStream());
47 dos = new DataOutputStream(
48 client.getOutputStream());
49 } catch (IOException e) {
50 release();
51 }
52 }
53 @Override
54 public void run() {
55 while(isRunning) {
56 String msg = receive();
57 if(!msg.equals(""))
58 send(msg);
59 }
60 }
61
62 //发送数据
63 public void send(String msg) {
64 try {
65 dos.writeUTF(msg);
66 dos.flush();
67 } catch (IOException e) {
68 System.out.println("发送数据失败");
69 release();
70 }
71 }
72
73 //接受数据
74 public String receive() {
75 try {
76 String msg = "";
77 msg = dis.readUTF();
78 return msg;
79 } catch (IOException e) {
80 isRunning = false;
81 System.out.println("接受数据失败");
82 release();
83 }
84 return "";
85 }
86
87 //释放资源
88 public void release() {
89 ChatUtils.close(client,dos,dis);
90 }
91 }
92 }View Code
客户端的发送：
1 package 在线聊天室;
2
3 import java.io.BufferedReader;
4 import java.io.DataOutputStream;
5 import java.io.IOException;
6 import java.io.InputStreamReader;
7 import java.net.Socket;
8
9 /**
10 * 为聊天室Client2 的发送功能服务
11 * @author liuzeyu12a
12 *
13 */
14 public class Send implements Runnable{
15 //准备数据
16 private BufferedReader reader;
17 //发送数据
18 private DataOutputStream dos;
19 private Socket client;
20 private boolean isRunning;
21 //构造器
22 public Send(Socket client) {
23 this.client = client ;
24 this.isRunning = true;
25 reader= new BufferedReader(
26 new InputStreamReader(System.in));
27 try {
28 dos= new DataOutputStream(client.getOutputStream());
29 } catch (IOException e) {
30 System.out.println("DataOutputStream对象创建失败");
31 release();
32 }
33 }
34 @Override
35 public void run() {
36 while(isRunning) {
37 send("");
38 }
39 }
40
41 //发送数据
42 public void send(String msg) {
43 try {
44 msg = getMsgFromConsole();
45 dos.writeUTF(msg);
46 dos.flush();
47 } catch (IOException e) {
48 System.out.println("数据发送失败");
49 release();
50 }
51 }
52
53 public String getMsgFromConsole(){
54 try {
55 return reader.readLine();
56 } catch (IOException e) {
57 e.printStackTrace();
58 }
59 return null;
60 }
61 //释放资源
62 public void release() {
63 isRunning = false;
64 ChatUtils.close(dos,client,reader);
65 }
66 }View Code
客户端的接收：
1 package 在线聊天室;
2
3 import java.io.DataInputStream;
4 import java.io.IOException;
5 import java.net.Socket;
6
7 /**
8 * 为聊天室Client2 的接收功能服务
9 * @author liuzeyu12a
10 *
11 */
12 public class Receive implements Runnable{
13
14 private boolean isRunning;
15 private DataInputStream dis;
16 private Socket client;
17 //构造器
18 public Receive(Socket client) {
19 this.client = client;
20 this.isRunning = true;
21 try {
22 dis = new DataInputStream(client.getInputStream());
23 } catch (IOException e) {
24 System.out.println("DataInputStream对象创建失败失败");
25 release();
26 }
27 }
28 @Override
29 public void run() {
30 while(isRunning) {
31 String msg = "";
32 msg = recevie();
33 if(!msg.equals(""))
34 System.out.println(msg);
35 }
36 }
37
38 public String recevie() {
39 String respone = null;
40 try {
41 respone = dis.readUTF();
42 return respone;
43 } catch (IOException e) {
44 release();
45 System.out.println("数据接收失败");
46 }
47 return null;
48 }
49
50
51 //释放资源
52 public void release() {
53 isRunning = false;
54 ChatUtils.close(dis,client);
55 }
56 }View Code
客户端的封装：
1 package 在线聊天室;
2
3 import java.io.IOException;
4 import java.net.Socket;
5
6 /**
7 * 1）将服务器的接受和发送数据用一个Channel 类进行封装，
8 * 这样子一个client 就对应了一个Channel对象了
9
10 2）将客户端的接收和发送分离开，
11 使用两个线程进行分割，这样子接收数据和发送数据就可以不用同时进行了
12 (为群聊做准备)。
13 * @author liuzeyu12a
14 *
15 */
16 public class Client2 {
17 public static void main(String[] args) throws IOException, IOException {
18 System.out.println("-----Server-----");
19 //创建Socket套接字，绑定服务器端口
20 Socket client =new Socket("localhost",8989);
21
22 //发送数据
23 new Thread(new Send(client)).start();
24 //接收数据
25 new Thread(new Receive(client)).start();
26 }
27 }View Code
3、实现简单的群聊功能。
服务器可以实现数据的转发功能，客户端不再局限于自己对话自己，是一个典型的群聊案例，重点理解如何将name进行传递。
客户端接受：
1 package 在线聊天室过渡版;
2
3 import java.io.DataInputStream;
4 import java.io.IOException;
5 import java.net.Socket;
6
7 /**
8 * 为聊天室Client2 的接收功能服务
9 * @author liuzeyu12a
10 *
11 */
12 public class Receive implements Runnable{
13
14 private boolean isRunning;
15 private DataInputStream dis;
16 private Socket client;
17 //构造器
18 public Receive(Socket client) {
19 this.client = client;
20 this.isRunning = true;
21 try {
22 dis = new DataInputStream(client.getInputStream());
23 } catch (IOException e) {
24 System.out.println("DataInputStream对象创建失败失败");
25 release();
26 }
27 }
28 @Override
29 public void run() {
30 while(isRunning) {
31 String msg = "";
32 msg = receive();
33 if(!msg.equals("")) {
34 System.out.println(msg);
35 }
36
37 }
38 }
39 public String receive() {
40 String respone = null;
41 try {
42 respone = dis.readUTF();
43 return respone;
44 } catch (IOException e) {
45 release();
46 System.out.println("数据接收失败");
47 }
48 return "";
49 }
50
51 //释放资源
52 public void release() {
53 isRunning = false;
54 ChatUtils.close(dis,client);
55 }
56 }View Code
客户端发送：
1 package 在线聊天室过渡版;
2
3 import java.io.BufferedReader;
4 import java.io.DataOutputStream;
5 import java.io.IOException;
6 import java.io.InputStreamReader;
7 import java.net.Socket;
8
9 /**
10 * 为聊天室Client2 的发送功能服务
11 * @author liuzeyu12a
12 *
13 */
14 public class Send implements Runnable{
15 //准备数据
16 private BufferedReader reader;
17 //发送数据
18 private DataOutputStream dos;
19 private Socket client;
20 private boolean isRunning;
21 private String name;
22 //构造器
23 public Send(Socket client,String name) {
24 this.client = client ;
25 this.isRunning = true;
26 //获取名称
27 this.name = name;
28 reader= new BufferedReader(
29 new InputStreamReader(System.in));
30 try {
31 dos= new DataOutputStream(client.getOutputStream());
32 send(name); //发送名称
33 } catch (IOException e) {
34 System.out.println("DataOutputStream对象创建失败");
35 release();
36 }
37 }
38 @Override
39 public void run() {
40 while(isRunning) {
41 String msg = null;
42 try {
43 msg = reader.readLine();
44 } catch (IOException e) {
45 System.out.println("数据写入失败");
46 release();
47 }
48 send(msg);
49
50 }
51 }
52 public void send(String msg) {
53 try {
54 dos.writeUTF(msg);
55 dos.flush();
56 } catch (IOException e) {
57 System.out.println("数据发送失败");
58 release();
59 }
60 }
61 //释放资源
62 public void release() {
63 ChatUtils.close(dos,client,reader);
64 }
65 }View Code
客户端封装：
1 package 在线聊天室过渡版;
2
3 import java.io.BufferedReader;
4 import java.io.IOException;
5 import java.io.InputStreamReader;
6 import java.net.Socket;
7
8 /**
9 * 可以实现简单的群聊了。
10 * @author liuzeyu12a
11 *
12 */
13 public class Client2 {
14 public static void main(String[] args) throws IOException, IOException {
15 System.out.println("-----Client-----");
16 System.out.println("请输入用户名：");
17 BufferedReader reader = new BufferedReader(
18 new InputStreamReader(System.in));
19 String name = reader.readLine();
20
21 //创建Socket套接字，绑定服务器端口
22 Socket client =new Socket("localhost",8989);
23
24 //发送数据
25 new Thread(new Send(client,name)).start();
26 //接收数据
27 new Thread(new Receive(client)).start();
28 }
29 }View Code
服务端：
1 package 在线聊天室过渡版;
2
3 import java.io.DataInputStream;
4 import java.io.DataOutputStream;
5 import java.io.IOException;
6 import java.net.ServerSocket;
7 import java.net.Socket;
8 import java.util.concurrent.CopyOnWriteArrayList;
9
10 /**
11 * 可以实现简单的群聊了。
12 * @author liuzeyu12a
13 *
14 */
15 public class Chat2 {
16 //用于存储客户端的容器，涉及到多线程的并发操作，
17 //使用CopyOnWriteArrayList保证线程的安全
18 private static CopyOnWriteArrayList<Channel> all =
19 new CopyOnWriteArrayList<Channel>();
20 public static void main(String[] args) throws Exception {
21 System.out.println("-----Server-----");
22 //建立服务器端地址，并绑定本地端口
23 ServerSocket server = new ServerSocket(8989);
24
25 //这边加上死循环是为了接受多个客户的请求
26 while(true) {
27 //监听
28 Socket client = server.accept();
29 Channel c = new Channel(client);
30 all.add(c); //添加一个客户端
31 System.out.println("一个客户端建立了连接");
32 new Thread(c).start();
33 }
34 }
35 //静态内部类，封装处理客户端的数据
36 static class Channel implements Runnable{
37 private DataInputStream dis;
38 private DataOutputStream dos;
39 private Socket client;
40 private boolean isRunning;
41 private String name;
42 //构造器
43 public Channel(Socket client) {
44
45 this.client = client;
46 this.isRunning = true;
47 try {
48 dis = new DataInputStream(
49 client.getInputStream());
50 dos = new DataOutputStream(
51 client.getOutputStream());
52 this.name = receive(); //接收客户端的名称
53 this.send("欢迎光临聊天室..");
54 this.sendOther(this.name+"来到了聊天室...", true);
55 } catch (IOException e) {
56 release();
57 }
58 }
59 @Override
60 public void run() {
61 while(isRunning) {
62 String msg = receive();
63 if(!msg.equals("")) {
64 //send(msg);
65 sendOther(msg,false);
66 }
67
68 }
69 }
70
71 //发送数据
72 public void send(String msg) {
73 try {
74 dos.writeUTF(msg);
75 dos.flush();
76 } catch (IOException e) {
77 System.out.println("发送数据失败");
78 release();
79 }
80 }
81 /**
82 * 获取自己的消息，然后发送给其它人
83 * boolean isSys表示是否为系统消息
84 * @return
85 */
86 public void sendOther(String msg,boolean isSys) {
87 for(Channel other:all) {
88 if(other == this) { //不再自己发给自己了
89 continue;
90 }
91 if(!isSys) {
92 other.send(this.name+"对大家说："+msg); //发送给自己
93 }else {
94 other.send(msg);
95 }
96 }
97 }
98
99 //接受数据
100 public String receive() {
101 try {
102 String msg = "";
103 msg = dis.readUTF();
104 return msg;
105 } catch (IOException e) {
106 isRunning = false;
107 System.out.println("接受数据失败");
108 release();
109 }
110 return "";
111 }
112
113 //释放资源
114 public void release() {
115 this.isRunning = false;
116 ChatUtils.close(client,dos,dis);
117 all.remove(this);
118 this.sendOther(this.name+"离开了聊天室...", true);
119 }
120 }
121 }View Code
4、群聊功能升级(可以实现私聊某一个人@)。
只需要在发送消息的地方动手脚，其它的代码不变即可。
约定私聊的格式：@xxx:消息内容
1 /**
2 * 获取自己的消息，然后发送给其它人
3 * boolean isSys表示是否为系统消息
4 * 添加私聊的功能：可以向某一特定的用户发送数据
5 * 约定格式：@xxx：数据
6 * @return
7 */
8 public void sendOther(String msg,boolean isSys) {
9 //判断数据是否以@开头
10 boolean isPrivate = msg.startsWith("@");
11 if(isPrivate) {
12 //寻找：
13 int index = msg.indexOf(":");
14 //截取名字
15 String targetName = msg.substring(1, index);
16 //截取消息内容
17 String datas = msg.substring(index+1);
18 for(Channel other :all) {
19 if(other.name.equals(targetName)) {
20 other.send(this.name+"悄悄对你说："+datas);
21 }
22 }
23
24 }else {
25 for(Channel other:all) {
26 if(other == this) { //不再自己发给自己了
27 continue;
28 }
29 if(!isSys) {
30 other.send(this.name+"对大家说："+msg); //发送给自己
31 }else {
32 other.send(msg);
33 }
34 }
35 }
36
37 }服务端：
1 package 在线聊天室终极版;
2
3 import java.io.DataInputStream;
4 import java.io.DataOutputStream;
5 import java.io.IOException;
6 import java.net.ServerSocket;
7 import java.net.Socket;
8 import java.util.concurrent.CopyOnWriteArrayList;
9
10 /**
11 * 可以实现简单的群聊了。
12 * @author liuzeyu12a
13 *
14 */
15 public class Chat2 {
16 //用于存储客户端的容器，涉及到多线程的并发操作，
17 //使用CopyOnWriteArrayList保证线程的安全
18 private static CopyOnWriteArrayList<Channel> all =
19 new CopyOnWriteArrayList<Channel>();
20 public static void main(String[] args) throws Exception {
21 System.out.println("-----Server-----");
22 //建立服务器端地址，并绑定本地端口
23 ServerSocket server = new ServerSocket(8989);
24
25 //这边加上死循环是为了接受多个客户的请求
26 while(true) {
27 //监听
28 Socket client = server.accept();
29 Channel c = new Channel(client);
30 all.add(c); //添加一个客户端
31 System.out.println("一个客户端建立了连接");
32 new Thread(c).start();
33 }
34 }
35 //静态内部类，封装处理客户端的数据
36 static class Channel implements Runnable{
37 private DataInputStream dis;
38 private DataOutputStream dos;
39 private Socket client;
40 private boolean isRunning;
41 private String name;
42 //构造器
43 public Channel(Socket client) {
44
45 this.client = client;
46 this.isRunning = true;
47 try {
48 dis = new DataInputStream(
49 client.getInputStream());
50 dos = new DataOutputStream(
51 client.getOutputStream());
52 this.name = receive(); //接收客户端的名称
53 this.send("欢迎光临聊天室..");
54 this.sendOther(this.name+"来到了聊天室...", true);
55 } catch (IOException e) {
56 release();
57 }
58 }
59 @Override
60 public void run() {
61 while(isRunning) {
62 String msg = receive();
63 if(!msg.equals("")) {
64 //send(msg);
65 sendOther(msg,false);
66 }
67
68 }
69 }
70
71 //发送数据
72 public void send(String msg) {
73 try {
74 dos.writeUTF(msg);
75 dos.flush();
76 } catch (IOException e) {
77 System.out.println("发送数据失败");
78 release();
79 }
80 }
81 /**
82 * 获取自己的消息，然后发送给其它人
83 * boolean isSys表示是否为系统消息
84 * 添加私聊的功能：可以向某一特地呢的用户发送数据
85 * 约定格式：@xxx：数据
86 * @return
87 */
88 public void sendOther(String msg,boolean isSys) {
89 //判断数据是否以@开头
90 boolean isPrivate = msg.startsWith("@");
91 if(isPrivate) {
92 //寻找：
93 int index = msg.indexOf(":");
94 //截取名字
95 String targetName = msg.substring(1, index);
96 //截取消息内容
97 String datas = msg.substring(index+1);
98 for(Channel other :all) {
99 if(other.name.equals(targetName)) {
100 other.send(this.name+"悄悄对你说："+datas);
101 }
102 }
103
104 }else {
105 for(Channel other:all) {
106 if(other == this) { //不再自己发给自己了
107 continue;
108 }
109 if(!isSys) {
110 other.send(this.name+"对大家说："+msg); //发送给自己
111 }else {
112 other.send(msg);
113 }
114 }
115 }
116
117 }
118
119 //接受数据
120 public String receive() {
121 try {
122 String msg = "";
123 msg = dis.readUTF();
124 return msg;
125 } catch (IOException e) {
126 isRunning = false;
127 System.out.println("接受数据失败");
128 release();
129 }
130 return "";
131 }
132
133 //释放资源
134 public void release() {
135 this.isRunning = false;
136 ChatUtils.close(client,dos,dis);
137 all.remove(this);
138 this.sendOther(this.name+"离开了聊天室...", true);
139 }
140 }
141 }View Code
截图：
小结：
1、模拟多人聊天室，代码比较多，重点在于多线程，TCP数据的传递，面向对象的封装。
2、利用面向对象的思想可以对代码进行封装，简化代码，提高代码的可维护性。
3、多个客户端可以在服务端使用容器进行装载。
3、在使用容器中，多线程如果涉及到多个同步的操作，如聊天室中可能在聊天中忽然有人退出，有人加入，
容易造成数据的错误发送和接收，可以使用JUC并发容器CopyOnWriteArrayList(再操作容器前copy一个副本存起来，一旦数据有错，就启用副本数据
来保证数据的安全性)。
转载于:https://www.cnblogs.com/liuzeyu12a/p/10406715.html
TCP创建多人聊天室相关推荐
- linux多人聊天室 qt,Qt编程详解--网络通信之基于TCP的多人聊天室
一.了解TCP的通信过程 Qt中封装了TCP协议 QTcpServer类负责服务端: 1.创建QTcpServer对象 2.监听listen需要的参数是地址和端口号 3.当有新的客户端连接成功时会发射 ...
- Java TCP简易多人聊天室
一.说明: 本例是一个简易的Java TCP多人聊天室,先启动服务器端,再启动客户端,客户端敲入用户名,然后可以开始聊天,敲入信息,每一个在线的用户都会收到相应信息. 演示如下图: 二.服务器端代 ...
- python多人聊天室 跨主机_python+tcp实现多人聊天室
tcp介绍 引用百度百科的介绍 传输控制协议(TCP,Transmission Control Protocol)是一种面向连接的.可靠的.基于字节流的传输层通信协议,由IETF的RFC 793 [1 ...
- java tcp多人聊天室
TCP的多人聊天室 上次写了一个只能两个人通信的TCP,这次写了个可以多人聊天的,利用多线程实现. 设计模式: 服务端:首先运行服务器,然后启动一个专门处理客户端消息的线程,然后监听是否有客户端连接, ...
- 基于Python Tkiner、thread与socket实现的简单多人聊天室，在Python中创建TCP服务器与客户端进行通信
基于Python Tkiner.thread与socket实现的简单多人聊天室,在Python中创建TCP服务器与客户端进行通信 完整代码下载地址:基于Python Tkiner.thread与soc ...
- c语言tcp多线程聊天,基于tcp和多线程的多人聊天室-C语言
之前在学习关于网络tcp和多线程的编程,学了知识以后不用一下总绝对心虚,于是就编写了一个基于tcp和多线程的多人聊天室. 具体的实现过程: 服务器端:绑定socket对象->设置监听数-> ...
- 【Java课程设计】仿QQ多人聊天室（基于TCP协议与JavaSwing）附下载
仿QQ多人聊天室 下载地址:链接:https://pan.baidu.com/s/1dLFjSxwTA4gL5lI0B4UGuQ 提取码:2qs0 有两个项目,分别是服务器chatterServer ...
- 基于TCP协议的mfc多人聊天室
基于TCP协议的MFC多人聊天室 简易的mfc聊天室思路实现 前言 一.socket通信 二.效果展示 三.代码实现 1.ClientSocket.cpp 客户端套接字 2.ServerSocket. ...
- linux网络编程TCP多人聊天室
用socket实现一个多人聊天室的思路很简单,即在服务器端定义一个fd的int型数组,用来存储已经连接的客户端的socket连接套接字fd(因为发送和接收数据都只需要借助连接套接字fd),当服务器接收 ...
最新文章
- centos7 升级openssh7.4之后 报错
- js改变img标签的src属性在IE下没反应的解决方法
- dotnet安装包时找不到依赖关系_无法加载文件或程序集'Microsoft.AspNet.TelemetryCorrelation'或其依赖项之一 . 该系统找不到指定的文件...
- Spark-sql:以编程方式执行Spark SQL查询（通过反射的方式推断出Schema，通过StrutType直接指定Schema）
- php中的var_dump()方法的详细说明
- FileSystemWatcher监听文件是否有被修改
- gsea结果分析图怎么看_微信公众平台数据分析怎么看
- Creating a Google Suggest Style Filter with the AutoComplete Control
- 机器视觉齿轮质量快速检测
- 印象笔记html预览,超级笔记使用指南 | 印象笔记
- Mysql压缩包版的安装教程
- Laravel文档阅读笔记-mews/captcha的使用（验证码功能）
- 【程序员2公务员】一、基本认知
- 特斯拉DTC运营解读
- 文件是存储在计算机外存上的,计算机存储器——内存和外存.doc
- windows10 自带的office突然无缘故被卸载了
- 经常困倦、乏力、失眠，其实是慢性疲劳综合征
- “我才是腾讯的第一任董事长”
- DX11小知识1-Direct 3D
- 英语话题 Zodiac