Socket（套接字）网络编程是在网络中实现两个进程间通信的一种方式，其中由 ip 和端口组成 Socket 的作用就是唯一标识网络中端点，以实现端与端之间的通信。其中最常用的传输层通信协议包括 TCP 和 UDP，与具体语言无关。很多语言都提供了基于 TCP 和 UDP 的 Socket API，本文使用 Java 实现基于 Socket 的 C/S 通信模型。
TCP
- 通过建立连接实现端到端的通信，一对基于 TCP 通信的 Socket 由客户端 ip、客户端端口、服务端 ip、服务端端口描述；
- Java 的 io 包和 net 包分别提供了输入输出流和套接字相关的 API，基于这些 API 可以轻易构建 TCP 服务端和客户端。
Server.java
package tcp;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* TCP 服务端类
*
* @author ywh
* @since 3/4/2019
*/
public class Server {
/** 服务端端口 */
private final static int SERVER_PORT = 5_000;
/** 客户端请求处理类 */
private static class RequestHandler extends Thread {
/** 每个客户端请求处理线程对应一个 socket */
private Socket socket;
/** 请求处理标记，默认为 true，false 表示结束处理 */
private boolean flag = true;
/** 结束标记 */
private static final String END_TAG = "bye";
RequestHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
super.run();
// 打印客户端的 ip 和端口
System.out.println(String.format("新的客户端接入：%s:%d", socket.getInetAddress(), socket.getPort()));
try {
// 发送到客户端：打印流
PrintStream output = new PrintStream(socket.getOutputStream());
// 从客户端接收：输入流缓冲
BufferedReader input = new BufferedReader(
new InputStreamReader(socket.getInputStream())
);
// 循环处理客户端消息，直到接收到结束标记
while (flag) {
// 阻塞，等待客户端消息
String msg = input.readLine();
if (END_TAG.equalsIgnoreCase(msg)) {
flag = false;
}
System.out.println(String.format("接收到客户端 [%s:%d] 消息：%s", socket.getInetAddress(), socket.getPort(), msg));
output.println("返回消息长度：" + msg.length());
}
// 资源释放
input.close();
output.close();
} catch (IOException ex) {
ex.printStackTrace();
} finally {
try {
socket.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
System.out.println(String.format("客户端 [%s:%d] 已经断开连接", socket.getInetAddress(), socket.getPort()));
}
}
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(SERVER_PORT);
System.out.println(String.format("服务端 [%s:%d] 启动...", server.getInetAddress(), server.getLocalPort()));
while (true) {
// 阻塞，等待客户端接入
Socket client = server.accept();
// 创建线程处理接入的客户端 Socket（不建议手动创建线程执行，而应使用线程池）
RequestHandler requestHandler = new RequestHandler(client);
requestHandler.start();
}
}
}
Client.java
package tcp;
import java.io.*;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.Socket;
/**
* TCP 客户端
*
* @author ywh
* @since 3/4/2019
*/
public class Client {
/** 服务端端口 */
private final static int SERVER_PORT = 5_000;
/** 连接超时时间 */
private final static int TIMEOUT = 3_000;
/** 结束标记 */
private static final String END_TAG = "bye";
/**
* 连接服务端后发送数据
*
* @param client
* @throws IOException
*/
private static void process(Socket client) throws IOException {
// 从标准输入流接收数据
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// 发送到服务端：发送从 reader 接收的数据
PrintStream output = new PrintStream(client.getOutputStream());
// 从服务端接收
BufferedReader input = new BufferedReader(
new InputStreamReader(client.getInputStream())
);
boolean flag = true;
while (flag) {
// 从标准输入流读入一行，发送到服务端
System.out.print("发送到服务端：");
String msg = reader.readLine();
output.println(msg);
// 从服务端接收（阻塞）
String response = input.readLine();
if (END_TAG.equalsIgnoreCase(msg)) {
flag = false;
}
System.out.println(response);
}
// 资源释放
input.close();
output.close();
}
public static void main(String[] args) throws IOException {
// 创建客户端 Socket，设置超时时间、连接的服务端 ip 和端口
Socket client = new Socket();
client.setSoTimeout(3000);
client.connect(
new InetSocketAddress(Inet4Address.getLocalHost(), SERVER_PORT), 3000
);
System.out.println(
String.format("客户端 [%s:%d] 连接到服务端 [%s:%d] ",
client.getLocalAddress(), client.getLocalPort(),
client.getInetAddress(), client.getPort()
)
);
try {
process(client);
} catch (IOException ex) {
ex.printStackTrace();
}
client.close();
System.out.println(String.format("客户端 [%s:%d] 已断开连接", client.getLocalAddress(), client.getLocalPort()));
}
}
- 服务端进程需要指定一个端口创建
ServerSocket用于监听来自客户端的接入请求（此时在循环中阻塞），每有新的客户端接入即创建一个处理请求的线程（每个线程对应一个客户端Socket）； - 请求处理线程启动后，创建输入和输出流，在循环中阻塞等待客户端消息和返回消息给客户端，直到接收到结束标记才退出循环、释放资源；
- 客户端进程创建
Socket的同时需要指定接入服务端的 ip 和端口（InetSocketAddress）、连接超时时间（而自身的端口则随机分配）； - 成功接入服务端后，消息交互与服务端类似（阻塞等待接收消息并打印、发送结束标记后断开连接和释放资源）；
- 分别执行 Server.java 和 Client.java，输出结果：
Client
Server
UDP
- 区别于 TCP，UDP 没有建立连接的过程，而且任何一端都可以作为消息的发送者和接收者，Socket 由源端口和目的端口描述；根据接收者的数量，通信方式还可以分为单播、广播和组播；
- UDP 通信不区分服务端与客户端，但在示例中为了方便标识通信的两端，还是定义为 Server（接收消息、返回特定格式的响应报文）和 Client（搜索并发送消息给网络中的 Server）。
Server.java
package udp;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.UUID;
/**
* UDP 消息服务端类
* 根据接收的消息提供服务（提供的服务为返回消息长度）
*
* @author ywh
* @since 3/4/2019
*/
public class Server {
/** 服务端端端口 */
private final static int SERVER_PORT = 5_000;
private static final String EXIT_CMD = "exit";
private static class Worker extends Thread {
/** 消息提供者唯一标识 */
private final String id;
/** 每个消息提供者对应一个 Socket */
private DatagramSocket datagramSocket = null;
/** 请求处理标记，默认为 true，false 表示结束处理 */
private boolean flag = true;
public Worker() {
super();
this.id = UUID.randomUUID().toString();
}
/**
* 处理接收到的消息，返回消息长度到指定的 ip 和端口
*/
@Override
public void run() {
super.run();
System.out.println("消息接收端启动...");
try {
datagramSocket = new DatagramSocket(SERVER_PORT);
while(flag) {
// 构建 DatagramPacket 缓冲，用于存放从 Searcher 接收的消息
final byte[] buffer = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
datagramSocket.receive(receivePacket);
String[] data = new String(receivePacket.getData()).split("&");
// 从接收消息解析出响应的目标端口，默认格式为：port&id&msg
int responsePort = Integer.parseInt(data[0]);
String clientId = data[1];
String msg = data[2].trim();
System.out.println(
String.format(
"从 (%s)[%s:%d] 接收到消息：%s",
clientId,
receivePacket.getAddress().getHostAddress(),
receivePacket.getPort(),
msg
)
);
byte[] responseData = String.format(
"%d&%s&消息长度：%d", datagramSocket.getPort(), this.id, msg.length()
).getBytes();
DatagramPacket responsePacket = new DatagramPacket(
responseData, responseData.length, receivePacket.getAddress(), responsePort
);
datagramSocket.send(responsePacket);
}
} catch (IOException ex) {
ex.printStackTrace();
} finally {
if (datagramSocket != null) {
datagramSocket.close();
datagramSocket = null;
}
}
}
public void exit() {
flag = false;
}
}
public static void main(String[] args) throws IOException {
Worker worker = new Worker();
worker.start();
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
while(!EXIT_CMD.equalsIgnoreCase(reader.readLine())) {}
worker.exit();
}
}
Client.java
package udp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* UDP 消息客户类，
* 模拟服务请求方，自动搜索消息接收者
*
* @author ywh
* @since 3/4/2019
*/
public class Client {
/** 服务端端端口 */
private final static int SERVER_PORT = 5_000;
/** 监听端口 */
private static final int LISTEN_PORT = 30_000;
/**
* 服务端类
*/
private static class Server {
final int port;
final String ip;
final String id;
private Server(String ip, int port, String id) {
this.port = port;
this.ip = ip;
this.id = id;
}
@Override
public String toString() {
return "Server{" +
"port=" + port +
", ip='" + ip + '\'' +
", id='" + id + '\'' +
'}';
}
}
private static class Worker extends Thread {
private final int listenPort = LISTEN_PORT;
private final List<Server> serverList = new ArrayList<>();
private boolean flag = true;
private DatagramSocket datagramSocket = null;
public Worker() {
super();
}
@Override
public void run() {
super.run();
try {
// 监听消息回复端口
datagramSocket = new DatagramSocket(listenPort);
while (flag) {
final byte[] buffer = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
datagramSocket.receive(receivePacket);
String[] data = new String(receivePacket.getData()).split("&");
// 从接收消息解析出响应的目标端口，默认格式为：port&id&msg
int responsePort = Integer.parseInt(data[0]);
String serverId = data[1];
String msg = data[2];
String serverIp = receivePacket.getAddress().getHostAddress();
int serverPort = receivePacket.getPort();
System.out.println(
String.format(
"从 (%s)[%s:%d] 接收到处理结果：%s", serverId, serverIp, serverPort, msg
)
);
// 添加到设备列表
serverList.add(new Server(serverIp, serverPort, serverId));
}
} catch (IOException ex) {
ex.printStackTrace();
} finally {
if (datagramSocket != null) {
datagramSocket.close();
datagramSocket = null;
}
}
}
List<Server> exit() {
flag = false;
return serverList;
}
}
/**
* 监听广播消息
*
* @return
* @throws InterruptedException
*/
private static Worker listen() throws InterruptedException {
Worker worker = new Worker();
worker.start();
return worker;
}
/**
* 发送广播消息
*
* @throws IOException
*/
private static void send() throws IOException {
System.out.println("客户端发送广播消息...");
DatagramSocket datagramSocket = new DatagramSocket();
byte[] requestData = String.format("%d&%s&%s", LISTEN_PORT, UUID.randomUUID().toString(), "求本消息的长度").getBytes();
DatagramPacket requestPacket = new DatagramPacket(requestData, requestData.length);
requestPacket.setAddress(InetAddress.getByName("255.255.255.255"));
requestPacket.setPort(SERVER_PORT);
datagramSocket.send(requestPacket);
datagramSocket.close();
System.out.println("客户端发送广播消息结束...");
}
public static void main(String[] args) throws IOException, InterruptedException{
System.out.println("客户端启动...");
Worker worker = listen();
// 发送消息请求服务
send();
// 输入任意内容即退出
System.in.read();
List<Server> serverList = worker.exit();
for(Server server: serverList) {
System.out.println("Server: " + server.toString());
}
}
}
- 虽然前面已经提到 UDP 通信不区分客户端和服务端，但在本场景中 Server 在网络中可建立多个，其作用都是接收来自来自 Client 的广播消息、返回该消息的长度；
- 区别于 TCP 直接通过 Socket 的输入输出流收发消息，UDP 的消息都是以
byte数组的形式封装在DatagramPacket中，其中DatagramPacket携带着 ip 和端口等信息； - Client 发送广播报文到网络中所有主机的指定端口，并在接收到响应的同时记录可为其提供服务的主机以供最终输出：
requestPacket.setAddress(InetAddress.getByName("255.255.255.255"));
requestPacket.setPort(SERVER_PORT);
- 客户端在向服务端发送消息的同时监听一个回传端口，并在消息携带上该端口（格式为
port&id&msg），使得服务端可以把响应消息发送到客户端的指定端口； - 分别执行 Server.java 和 Client.java，输出结果：
Server
Client
