1、ServerSocket API
ServerSocket是创建TCP服务端Socket的API。
ServerSocket构造方法是：
| 方法签名 | 方法说明 |
| ServerSocket(int port) | 创建一个服务端流套接字Socket，并绑定到指定端口 |
ServerSocket的一般方法有：
| 方法签名 | 方法说明 |
| Socket accept() | 开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立与客户端的连接，否则阻塞等待 |
| void close() | 关闭此套接字 |
2、Socket API
Socket是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
Socket的构造方法有：
| 方法签名 | 方法说明 |
| Socket(String host, int port) | 创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接 |
Socket的一般方法有：
| 方法签名 | 方法说明 |
| InetAddress getInetAddress() | 返回套接字所连接的地址 |
| InputStream getInputStream() | 返回此套接字的输入流 |
| OutputStream getOutputStream() | 返回此套接字的输出流 |
3、TCP中的长短连接
TCP发送数据时，需要先建立连接，什么时候关闭连接就决定它是短连接还是长连接：
- 短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
- 长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
对比以上长短连接，两者区别如下：
- 建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
- 主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
- 两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。
4、示例一
我们模仿UDP示例一来写一下TCP服务端与客户端：
- TCP服务端
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TcpEchoServer {
private ServerSocket serverSocket = null;
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动!");
ExecutorService service = Executors.newCachedThreadPool();
while (true) {
// 通过 accept 方法, 把内核中已经建立好的连接拿到应用程序中.
// 建立连接的细节流程都是内核自动完成的. 应用程序只需要 "捡现成" 的.
Socket clientSocket = serverSocket.accept();
// 此处不应该直接调用 processConnection, 会导致服务器不能处理多个客户端.
// 创建新的线程来调用更合理的做法.
// 这种做法可行, 不够好
// Thread t = new Thread(() -> {
// processConnection(clientSocket);
// });
// t.start();
// 更好一点的办法, 是使用线程池.
service.submit(new Runnable() {
@Override
public void run() {
processConnection(clientSocket);
}
});
}
}
// 通过这个方法, 来处理当前的连接.
public void processConnection(Socket clientSocket) {
// 进入方法, 先打印一个日志, 表示当前有客户端连上了.
System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress(), clientSocket.getPort());
// 接下来进行数据的交互.
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
// 使用 try ( ) 方式, 避免后续用完了流对象, 忘记关闭.
// 由于客户端发来的数据, 可能是 "多条数据", 针对多条数据, 就循环的处理.
while (true) {
Scanner scanner = new Scanner(inputStream);
if (!scanner.hasNext()) {
// 连接断开了. 此时循环就应该结束
System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress(), clientSocket.getPort());
break;
}
// 1. 读取请求并解析. 此处就以 next 来作为读取请求的方式. next 的规则是, 读到 "空白符" 就返回.
String request = scanner.next();
// 2. 根据请求, 计算响应.
String response = process(request);
// 3. 把响应写回到客户端.
// 可以把 String 转成字节数组, 写入到 OutputStream
// 也可以使用 PrintWriter 把 OutputStream 包裹一下, 来写入字符串.
PrintWriter printWriter = new PrintWriter(outputStream);
// 此处的 println 不是打印到控制台了, 而是写入到 outputStream 对应的流对象中, 也就是写入到 clientSocket 里面.
// 自然这个数据也就通过网络发送出去了. (发给当前这个连接的另外一端)
// 此处使用 println 带有 \n 也是为了后续 客户端这边 可以使用 scanner.next 来读取数据.
printWriter.println(response);
// 此处还要记得有个操作, 刷新缓冲区. 如果没有刷新操作, 可能数据仍然是在内存中, 没有被写入网卡.
printWriter.flush();
// 4. 打印一下这次请求交互过程的内容
System.out.printf("[%s:%d] req=%s, resp=%s\n", clientSocket.getInetAddress(), clientSocket.getPort(),
request, response);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 在这个地方, 进行 clientSocket 的关闭.
// processConnection 就是在处理一个连接. 这个方法执行完毕, 这个连接也就处理完了.
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public String process(String request) {
// 此处也是写的回显服务器. 响应和请求是一样的.
return request;
}
public static void main(String[] args) throws IOException {
TcpEchoServer server = new TcpEchoServer(9090);
server.start();
}
}
- TCP客户端
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoClient {
private Socket socket = null;
public TcpEchoClient(String serverIp, int serverPort) throws IOException {
// 需要在创建 Socket 的同时, 和服务器 "建立连接", 此时就得告诉 Socket 服务器在哪里~~
// 具体建立连接的细节, 不需要咱们代码手动干预. 是内核自动负责的.
// 当我们 new 这个对象的时候, 操作系统内核, 就开始进行 三次握手 具体细节, 完成建立连接的过程了.
socket = new Socket(serverIp, serverPort);
}
public void start() {
// tcp 的客户端行为和 udp 的客户端差不多.
// 都是:
// 3. 从服务器读取响应.
// 4. 把响应显示到界面上.
Scanner scanner = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
PrintWriter writer = new PrintWriter(outputStream);
Scanner scannerNetwork = new Scanner(inputStream);
while (true) {
// 1. 从控制台读取用户输入的内容
System.out.print("-> ");
String request = scanner.next();
// 2. 把字符串作为请求, 发送给服务器
// 这里使用 println, 是为了让请求后面带上换行.
// 也就是和服务器读取请求, scanner.next 呼应
writer.println(request);
writer.flush();
// 3. 读取服务器返回的响应.
String response = scannerNetwork.next();
// 4. 在界面上显示内容了.
System.out.println(response);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);
client.start();
}
}
5、示例二
构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务：
- 客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）
- 发送请求：使用客户端Socket的输出流发送TCP报文。即输入的相对路径。
- 服务端接收并处理请求：使用服务端Socket的输入流来接收请求报文，根据请求的路径，列出下一级子文件及子文件夹。
- 服务端返回响应：使用服务端Socket的输出流来发送响应报文。即遍历子文件和子文件夹，每个文件名一行，返回给客户端。
- 客户端接收响应：使用客户端Socket的输入流来接收响应报文。简单的打印输出所有的响应内容，即文件列表。
以下为服务端和客户端代码：
- TCP服务端
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPsockServer {
//服务器socket要绑定固定的端口
private static final int PORT = 8888;
//本地文件目录要展示的根路径
private static final String BASE_PATH = "E:/TMP";
public static void main(String[] args) throws IOException {
// 1.创建一个服务端ServerSocket，用于收发TCP报文
ServerSocket server = new ServerSocket(PORT);
// 不停的等待客户端连接
while(true) {
System.out.println("---------------------------------------------------");
System.out.println("等待客户端建立TCP连接...");
// 2.等待客户端连接，注意该方法为阻塞方法
Socket socket = server.accept();
System.out.printf("客户端IP：%s%n", socket.getInetAddress().getHostAddress());
System.out.printf("客户端端口号：%s%n", socket.getPort());
// 5.接收客户端的数据，需要从客户端Socket中的输入流获取
InputStream is = socket.getInputStream();
// 为了方便获取字符串内容，可以将以上字节流包装为字符流
BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
// 客户端请求只发送一行数据，我们也只需要读取一行
String request = br.readLine();
// 6.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列出下一级子文件
//请求的文件列表目录
System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH + request);
File dir = new File(BASE_PATH + request);
//获取下一级子文件，子文件夹
File[] children = dir.listFiles();
// 7.返回响应给客户端：通过客户端socket中的输出流发送响应数据
OutputStream os = socket.getOutputStream();
// 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
// 7-1.返回的响应内容：每个文件及目录名称为一行
if(children != null){
for (File child : children) {
pw.println(child.getName());
}
}
// 7-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
pw.flush();
// 7-3.双方关闭连接：服务端是关闭客户端socket连接
socket.close();
}
}
}- TCP客户端
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class TCPsockClient {
//服务端IP或域名
private static final String SERVER_HOST = "localhost";
//服务端Socket进程的端口号
private static final int SERVER_PORT = 8888;
public static void main(String[] args) throws IOException {
// 准备要发送的数据：这里调整为键盘输入作为发送的内容
Scanner scanner = new Scanner(System.in);
while(true) {
System.out.println("---------------------------------------------------");
System.out.println("请输入要展示的目录：");
// 每输入新行（回车），就作为发送的TCP请求报文
String request = scanner.nextLine();
// 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
// 发送TCP数据，是通过socket中的输出流进行发送
OutputStream os = socket.getOutputStream();
// 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
// 发送数据：
pw.println(request);
// 有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
pw.flush();
// 接收返回的响应数据：通过socket中的输入流获取
System.out.println("接收到服务端响应：");
InputStream is = socket.getInputStream();
// 为了方便获取字符串内容，可以将以上字节流包装为字符流
BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
String line;
// 一直读取到流结束：TCP是基于流的数据传输，一定要服务端关闭Socket输出流才表示客户端接收的IO输入流结束
while ((line = br.readLine()) != null) {
System.out.println(line);
}
// 双方关闭连接：客户端关闭socket连接
socket.close();
}
}
}