Java TCP通信简易实现#

客户端#

一，建立与服务端的连接#

现在我们假设服务端已经在它的主机上的6666端口启动了服务，我们为了建立与它的连接，需要new一个socket对象，向服务端发起TCP连接请求

1
// 假设服务端在本地6666端口启动，
2
//              new Socket(IPAddress  ,port);
3
Socket socket = new Socket("127.0.0.1",6666);

好的，现在请求成功了，已经与服务端建立好了连接，接下来我们需要发送我们打算发送的数据

于是我们需要一个输出流（OutputStream）

1
OutputStream os = socket.getOutputStream();

你可能会问，

Q：为什么不是自己new一个os呢？

A：因为socket对象内部已经与服务器建立了底层的连接通道，它封装了网路的输入输出流，只有通过socket.getOutputStream() 获得的流对象，才真正连接到对方的接收端口。

Q：那我不能把自己new的os对象手动建立连接吗？

A：不能，os对象本身是一个抽象的数据流接口/抽象类，它只负责数据的“写出”功能，但它不具备“建立网络连接”这个能力。

接下来我们又遇到一个问题，OutputStream对象只能写入原始字节，不能直接写 int、float、String 等数据类型，也就是byte类型，所以我们要进行包装，方便数据的写入

1
DataOutputStream dos = new DataOutputStream(os);

太好了，这下我们可以进行数据的写入了！

1
Scanner sc = new Scanner(System.in);
2
String msg = sc.nextLine();
3
dos.writeUTF(msg);

整合代码：

1
import java.io.DataOutputStream;
2
import java.io.IOException;
3
import java.io.OutputStream;
4
import java.net.Socket;
5
import java.util.Scanner;
6

7
public class TCPClientNote {
8
    public static void main(String[] args) throws IOException {
9
        Socket socket = new Socket("127.0.0.1",6666);
10
        OutputStream os = socket.getOutputStream();
11
        DataOutputStream dos = new DataOutputStream(os);
12

13
        Scanner sc = new Scanner(System.in);
14
        String msg = sc.nextLine();
15
        dos.writeUTF(msg);
16
    }
17
}

但是现在有一个问题，我们发完一次数据好像我的客户端就结束了，所以为了可以不断地发送信息，我们可以加一个循环嵌套：

1
while(true){
2
  Scanner sc = new Scanner(System.in);
3
    String msg = sc.nextLine();
4
}

再加一个退出条件：

1
while(true){
2
  Scanner sc = new Scanner(System.in);
3
    String msg = sc.nextLine();
4
   if(msg == "exit"){
5
        // 先关闭 dos流，再关闭 socket连接
6
        dos.close();
7
         socket.close();
8
        break;
9
    }
10
    dos.writeUTF(msg);
11
    // 强制把缓冲区中的消息发送出去，避免数据停留在内存里
12
  // DataOutputStream 内部有缓冲机制，调用 writeUTF() 后，数据可能暂时存放在内存缓冲区，还没真正
13
    // 通过网络发送出去。
14
    dos.flush();
15
}

完整版：

1
import java.io.DataOutputStream;
2
import java.io.IOException;
3
import java.io.OutputStream;
4
import java.net.Socket;
5
import java.util.Scanner;
6

7
public class TCPClientNote {
8
    public static void main(String[] args) throws IOException {
9
        Socket socket = new Socket("127.0.0.1",6666);
10
        OutputStream os = socket.getOutputStream();
11
        DataOutputStream dos = new DataOutputStream(os);
12

13
    while(true){
14
      Scanner sc = new Scanner(System.in);
15
         String msg = sc.nextLine();
16
       if(msg == "exit"){
17
            dos.close();
18
             socket.close();
19
                break;
20
        }
21
        dos.writeUTF(msg);
22
        dos.flush();
23
        }
24
    }
25
}

服务端：#

一，连接客户端#

new 一个Serversocket对象，用于与客户端进行连接，需要指定端口，用于监听。

1
int port = 6666;
2
Serversocket ss = new Serversocket(port);
3
// Serversocket ss = new Serversocket(6666);

为了与来进行连接的客户端进行连接，有以下代码：

1
Socket socket = ss.accept();

这行代码会在此处阻塞等待，直到有客户端连接。

ss.accept() 在与客户端连接之后会返回一个socket对象，通过创建socket变量并接收这个连接的对象，用于与客户端通信，读取客户端发送的数据。

二，读取客户端发来的消息#

现在我们已经获取了客户端的socket，现在我们可以进行读取操作了

首先将socket中的输入流取出来，也就是客户端发过来的数据流：

1
InputStream is = socket.getInputStream();

但是这样获取过来的都是原始的字节信息，即 byte数组，如果读取这样的信息，我们还要进行各种各样的转换操作才能将他变成可读的信息，为了更方便的读取数据，我们可以再次将输入流进行包装：

1
// 传入字节流对象
2
DataInputStream dis = new DataInputStream(is);

这下我们就可以方便的读取数据了：

1
String msg = dis.readUTF();
2
System.out.println(msg);

到这里，一个简易的服务端的代码编写基本就完成了

整合代码：

1
import java.io.DataInputStream;
2
import java.io.IOException;
3
import java.io.InputStream;
4
import java.net.ServerSocket;
5
import java.net.Socket;
6

7
public class TCPServerNote{
8
    public static void main(String[] args) throws IOException {
9
        ServerSocket ss = new ServerSocket(6666);
10
        Socket socket = ss.accept();
11

12
        InputStream is = socket.getInputStream();
13
        DataInputStream dis = new DataInputStream(is);
14

15
        String msg = dis.readUTF();
16
        System.out.println(msg);
17
    }
18
}

但是这段代码有个非常明显的问题，就是只接收了一次消息，然后程序就结束了

同理，那我们加一层循环嵌套，可以一直接收消息：

1
while(true){
2
    String msg = dis.readUTF();
3
    System.out.println(msg);
4
}

完整版：

1
import java.io.DataInputStream;
2
import java.io.IOException;
3
import java.io.InputStream;
4
import java.net.ServerSocket;
5
import java.net.Socket;
6

7
public class TCPServerNote{
8
    public static void main(String[] args) throws IOException {
9
        ServerSocket ss = new ServerSocket(6666);
10
        Socket socket = ss.accept();
11

12
        InputStream is = socket.getInputStream();
13
        DataInputStream dis = new DataInputStream(is);
14

15
        while(true){
16
        String msg = dis.readUTF();
17
        System.out.println(msg);
18
    }
19
    }
20
}

这下，客户端可以与服务端通信了

多用户连接与群发消息：#

一、多线程与实现#

前面我们所实现的仅仅是一对一的连接，即一个服务端连接一个客户端，接下来我们来实现多个客户端连接一个服务端。

有人会说，那我直接while true 不断让他接收新的客户端连接不就行了嘛

1
while(true){
2
    Socket socket = serverSocket.accept();
3
    // ...
4
}

事实是：不行

每次接收到新socket连接时，serversocket会将之前的客户端连接所遗弃，只处理本次连接的客户端

换句话说，现在的服务端只有一个main线程在运行，这样简单的循环实现没有告诉他我要并行处理多个客户端连接

所以我们需要使用多线程：

1
while(true){
2
    Socket socket = serverSocket.accept();
3
    // ...
4
    new ServerReaderThread(socket).start();
5
}

我们先不看线程类如何实现，我们先来关注如何存储我们的用户池

其实非常简单，直接new一个ArrayLsit即可：

1
// static设置为类级别，只有一个线程池
2
public static List<Socket> ClientSockets = new ArrayList<>();

完整代码：

1
import java.io.IOException;
2
import java.net.ServerSocket;
3
import java.net.Socket;
4
import java.util.ArrayList;
5
import java.util.List;
6

7
public class TCPServer2 {
8
    public static List<Socket> onLineSockets = new ArrayList<>();
9
    public static void main(String[] args) throws IOException {
10
        ServerSocket serverSocket = new ServerSocket(6666);
11

12
        while (true) {
13
            Socket socket = serverSocket.accept();
14
            onLineSockets.add(socket);
15
            // 启动线程
16
            // new ServerReaderThread(socket).start();
17
        }
18
    }
19
}

接下来我们来实现线程类

二、线程类#

现在我们的主文件不再需要实现接收消息的功能，只需要在线程类中实现即可：

1
// 继承自线程类
2
public class ServerReaderThread extends Thread{
3
    private Socket socket;
4
    // 构造方法注入socket对象
5
    public ServerReaderThread(Socket socket){
6
        this.socket = socket;
7
    }
8
  @Override
9
    public void run(){
10
        // ...
11
    }
12
}

接下来我们来看看启动线程后的代码如何写

与之前服务类相同，先获取输入流，之后进行包装：

1
InputStream is = socket.getInputStream();
2
DataInputStream dis = new DataInputStream(is);

循环接收发来的信息：

1
while(true){
2
    String msg = dis.readUTF();
3
    System.out.println(msg);
4
}

当客户端断开连接时，会抛出异常，所以我们还要进行异常的捕获：

1
while (true){
2
       try {
3
            String msg = dis.readUTF();
4
            System.out.println(msg);
5
            SendMsgAll(msg);
6
       }catch (Exception e) {
7
           //从线程池中移除断开连接的用户
8
           TCPServer2.onLineSockets.remove(socket);
9
           dis.close();
10
           socket.close();
11
           break;
12
       }
13
}

完整代码：

1
public class ServerReaderThread extends Thread {
2
    private Socket socket;
3
    public ServerReaderThread(Socket socket){
4
        this.socket = socket;
5
    }
6
    @Override
7
    public void run() {
8
        // 在 run() 方法中，获取输入流的过程可能抛出受检异常，如 IOException，但 run() 方法无法在
9
        // 签名中使用 throws 抛出，因此必须用最外层 try-catch 捕获并处理。常见做法是将其转化为
10
        // RuntimeException，以便后续调试和统一异常管理。
11
        try {
12
            InputStream inputStream = socket.getInputStream();
13
            DataInputStream dis = new DataInputStream(inputStream);
14
            while (true){
15
                try {
16
                    String msg = dis.readUTF();
17
                    System.out.println(msg);
18
                } catch(Exception e) {
19
                    TCPServer2.onLineSockets.remove(socket);
20
                    dis.close();
21
                    socket.close();
22
                    break;
23
                }
24
            }
25
        } catch (Exception e) {
26
            throw new RuntimeException(e);
27
        }
28
    }
29
}

三、群发消息#

下面我们来实现如何将用户的消息转发给别的用户

实际上在我们的模型中，必须有一个人做服务端接收消息，而用户端都是发送消息的一方，如何实现也能接收消息呢？其实就是服务端进行转发

为此，我们还要实现一个ClientReaderThread，用于客户端接收消息，这是因为如果我们直接在Client.java里实现接收的话，由于只有一个主线程，在接收消息时如果没人给他发送消息，主线程就会被阻塞，无法执行其他任务，以下是代码实现，与ServerReaderthread几乎一样：

1
import java.io.DataInputStream;
2
import java.io.InputStream;
3
import java.net.Socket;
4

5
public class ClienReaderThread extends Thread{
6
    public Socket socket;
7
    public ClienReaderThread(Socket socket){
8
        this.socket = socket;
9
    }
10
    @Override
11
    public void run() {
12
        try {
13
            InputStream inputStream = socket.getInputStream();
14
            DataInputStream dis = new DataInputStream(inputStream);
15
            while (true){
16
                try {
17
                    String msg = dis.readUTF();
18
                    System.out.println(msg);
19
                } catch(Exception e) {
20
                    dis.close();
21
                    socket.close();
22
                    break;
23
                }
24
            }
25
        } catch (Exception e) {
26
            throw new RuntimeException(e);
27
        }
28
    }
29
}

之后将这个线程在客户端代码中启动即可：

1
    // ...其他代码...
2
    Socket socket = new Socket("127.0.0.1",6666);
3
        new ClienReaderThread(socket).start();
4
        OutputStream os = socket.getOutputStream();
5
    // ...其他代码...

群发消息也很简单，就是遍历用户池中的用户，进行发消息即可，以下是方法实现：

1
private void SendMsgAll(String msg) throws IOException {
2
        for (Socket onLineSocket : TCPServer2.onLineSockets) {
3
         if(onLineSocket.getRemoteSocketAddress().equals(socket.getRemoteSocketAddress())){
4
                continue;
5
            }
6
            OutputStream os = onLineSocket.getOutputStream();
7
            DataOutputStream dos = new DataOutputStream(os);
8
            dos.writeUTF(msg);
9
            dos.flush();
10
        }
11
    }

至此，我们实现了所有功能

全部完整代码：

1
import java.io.IOException;
2
import java.net.ServerSocket;
3
import java.net.Socket;
4
import java.util.ArrayList;
5
import java.util.List;
6

7
public class TCPServer2 {
8
    public static List<Socket> onLineSockets = new ArrayList<>();
9
    public static void main(String[] args) throws IOException {
10
        ServerSocket serverSocket = new ServerSocket(6666);
11

12
        while (true) {
13
            Socket socket = serverSocket.accept();
14
            onLineSockets.add(socket);
15
            System.out.println( socket.getRemoteSocketAddress() + "上线了");
16
            new ServerReaderThread(socket).start();
17
        }
18
    }
19
}

1
import java.io.DataOutputStream;
2
import java.io.IOException;
3
import java.io.OutputStream;
4
import java.net.Socket;
5
import java.util.Scanner;
6

7
public class TCPClient {
8
    public static void main(String[] args) throws IOException {
9
        //服务器主机ip和端口
10
        Socket socket = new Socket("127.0.0.1",6666);
11

12
        new ClienReaderThread(socket).start();
13

14
        OutputStream os = socket.getOutputStream();
15

16
        DataOutputStream dos = new DataOutputStream(os);
17

18
        Scanner sc = new Scanner(System.in);
19
        System.out.println("已连接");
20
        while (true) {
21
            String msg = sc.nextLine();
22
            if (msg.equals("exit")){
23
                System.out.println("end");
24
                dos.close();
25
                socket.close();
26
                break;
27
            }
28
            dos.writeUTF(msg);
29
            dos.flush();
30
        }
31
    }
32
}

1
import java.io.*;
2
import java.net.Socket;
3

4
public class ServerReaderThread extends Thread {
5
    private Socket socket;
6
    public ServerReaderThread(Socket socket){
7
        this.socket = socket;
8
    }
9
    @Override
10
    public void run() {
11
        try {
12
            InputStream inputStream = socket.getInputStream();
13
            DataInputStream dis = new DataInputStream(inputStream);
14
            while (true){
15
                try {
16
                    String msg = dis.readUTF();
17
                    System.out.println(msg);
18
                    SendMsgAll(msg);
19
                } catch(Exception e) {
20
                    System.out.println("有人下线了" + socket.getRemoteSocketAddress());
21
                    TCPServer2.onLineSockets.remove(socket);
22
                    dis.close();
23
                    socket.close();
24
                    break;
25
                }
26
            }
27
        } catch (Exception e) {
28
            throw new RuntimeException(e);
29
        }
30
    }
31

32
    private void SendMsgAll(String msg) throws IOException {
33
        for (Socket onLineSocket : TCPServer2.onLineSockets) {
34
            if (onLineSocket.getRemoteSocketAddress().equals(socket.getRemoteSocketAddress())){
35
                continue;
36
            }
37
            OutputStream os = onLineSocket.getOutputStream();
38
            DataOutputStream dos = new DataOutputStream(os);
39
            dos.writeUTF(msg);
40
            dos.flush();
41
        }
42
    }
43
}

1
import java.io.DataInputStream;
2
import java.io.InputStream;
3
import java.net.Socket;
4

5
public class ClienReaderThread extends Thread{
6
    public Socket socket;
7
    public ClienReaderThread(Socket socket){
8
        this.socket = socket;
9
    }
10
    @Override
11
    public void run() {
12
        try {
13
            InputStream inputStream = socket.getInputStream();
14
            DataInputStream dis = new DataInputStream(inputStream);
15
            while (true){
16
                try {
17
                    String msg = dis.readUTF();
18
                    System.out.println(msg);
19
                } catch(Exception e) {
20
                    System.out.println("自己下线了");
21
                    dis.close();
22
                    socket.close();
23
                    break;
24
                }
25
            }
26
        } catch (Exception e) {
27
            throw new RuntimeException(e);
28
        }
29
    }
30
}

完成于2025.6.5 16:50