目录
TCP流套接字编程
1.ServerSocket API
2.Socket API
3.TCP中的长短连接
4.回显程序(短连接)
5.服务器和客户端它们的交互过程
6.运行结果及修改代码
TCP流套接字编程
❗❗两个核心：ServerSocket Socket
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(String host, int port) 创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接Socket 方法：
InetAddress getInetAddress() 返回套接字所连接的地址
InputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流3.TCP中的长短连接
🔎TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
4.回显程序(短连接)
1️⃣TCP 客户端
package io;
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 port) throws IOException {
// 这个操作相当于让客户端和服务器建立 tcp 连接.
// 这里的连接连上了, 服务器的 accept 就会返回.
socket = new Socket(serverIp, port);
}
//启动客户端程序
public void start() {
Scanner scanner = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
PrintWriter printWriter = new PrintWriter(outputStream);
Scanner scannerFromSocket = new Scanner(inputStream);
while (true) {
// 1. 从键盘上读取用户输入的内容.
System.out.print("-> ");
String request = scanner.next();
// 2. 把读取的内容构造成请求, 发送给服务器.
// 注意, 这里的发送, 是带有换行的!!
printWriter.println(request);//这里只是把数据写入内存的缓冲区中，等待缓冲区满了，才会真正写网卡
// 3. 从服务器读取响应内容
String response = scannerFromSocket.next();
// 4. 把响应结果显示到控制台上.
System.out.printf("req: %s; resp: %s\n", request, 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();
}
}2️⃣TCP 服务端
package io;
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;
public class TcpEchoServer {
// serverSocket 就是外场拉客的小哥
// clientSocket 就是内场服务的小姐姐.
// serverSocket 只有一个. clientSocket 会给每个客户端都分配一个~
private ServerSocket serverSocket = null;
//端口号绑定
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动!");
while (true) {
Socket clientSocket = serverSocket.accept();
processConnection(clientSocket);
}
}
// 通过这个方法来处理一个连接.
// 读取请求
// 根据请求计算响应
// 把响应返回给客户端
private void processConnection(Socket clientSocket) throws IOException {
System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort());
// try () 这种写法, ( ) 中允许写多个流对象. 使用 ; 来分割
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
// 没有这个 scanner 和 printWriter, 完全可以!! 但是代价就是得一个字节一个字节扣, 找到哪个是请求的结束标记 \n
// 不是不能做, 而是代码比较麻烦.为了简单, 把字节流包装秤了更方便的字符流~~
Scanner scanner = new Scanner(inputStream);
//Scanner 相当于 字符流，上述约定了请求是字符串，所以就可以使用字符流来处理
PrintWriter printWriter = new PrintWriter(outputStream);
while (true) {
// 1. 读取请求：
//hasNext 判定接下来还有没有数据了，如果对端关闭连接(客户端关闭连接)，此时 hasNext 就会返回 false，循环就让它结束
//如果对端有数据，hasNxet 返回 true，进一步就可以使用 next 方法来读出这一段字符串的内容了
if (!scanner.hasNext()) {
// 读取的流到了结尾了 (对端关闭了)
System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort());
break;
}
// 直接使用 scanner 读取一段字符串.
String request = scanner.next();
//next：一直往后读，读到空白符结束——空格，换行，制表符，翻页符..都算空白符
//nextLine 只是读到换行符结束
//这里不要用nextLine
// 2. 根据请求计算响应
String response = process(request);
// 3. 把响应写回给客户端. 不要忘了, 响应里也是要带上换行的.
printWriter.println(response);
System.out.printf("[%s:%d] req: %s; resp: %s\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
clientSocket.close();//clientSocket 只是给一个连接提供服务的，还是要能够进行关闭
}
}
private String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
tcpEchoServer.start();
}
}5.服务器和客户端它们的交互过程
1️⃣启动服务器
2️⃣客户端启动
当客户端和服务器连接建立好之后，服务器这边的 accept 就返回了
3️⃣服务器就进入 processConnection 了，尝试从客户端读取请(由于此时客户端还没有发送请求，此时读取操作也会阻塞)
与此同时：
用户端往下执行到，从控制台读取用户输入——也会阻塞
4️⃣当用户真的输入内容，客户端真正发送了请求出去；同时往下执行到，读取服务器响应，再次阻塞
5️⃣服务器收到客户端的请求之后，从 next 这里返回，执行 process 执行 println ，把响应写回到客户端
6️⃣服务器重新回到上述开头位置，继续尝试读取请求，并阻塞
客户端收到服务器的响应就可以把结果显示出来了；同时进入下次循环，再次等待用户的输入了
6.运行结果及修改代码
❗❗❗当我们输入 hello 之后，发现客户端没有任何响应——因为数据还在缓冲区内
// 2. 把读取的内容构造成请求, 发送给服务器.
// 注意, 这里的发送, 是带有换行的!!
printWriter.println(request);这里只是把数据写入内存的缓冲区中，等待缓冲区满了，才会真正写网卡
1️⃣此时我们需要冲刷
此时就可以响应了；当前程序已经跑起来了，已经可以正常通信了
❗❗但是还存在一个严重的 bug！！服务器需要同时能够给多个客户端提供服务的
2️⃣在 idea 中启动多个客户端，需要配置，默认一个程序只能启动一个
🔎此时就可以启动多个程序
3️⃣但是我们看到的是在第一个客户端输入 hello，运行是正常的；但是我们在第二个客户端输入 hello2的时候没有任何反应
这就是当前服务器无法同时服务多个客户端；为什么会造成这种原因呢？
6️⃣解决方法：希望同时能够给客户端1提供服务，又能够循环的调用 accept——多线程
如果直接调用，该方法回影响这个循环的二次执行，导致 accept 不及时了 ；这个时候就需要 创建新的线程，用新线程来调用 processConnection；每次来一个新的客户端都搞一个新的线程即可！！!
public void start() throws IOException {
System.out.println("服务器启动!");
while (true) {
Socket clientSocket = serverSocket.accept();
//如果直接调用，该方法回影响这个循环的二次执行，导致 accept 不及时了
//这个时候就需要 创建新的线程，用新线程来调用 processConnection；每次来一个新的客户端都搞一个新的线程即可！！!
Thread t = new Thread(() -> {
try {
processConnection(clientSocket);
} catch (IOException e) {
e.printStackTrace();
}
});
t.start();
}
}
此时运行结果：
7️⃣解决方案2：使用 线程池 修改上述代码
✨一个连接的所有请求处理完，这个程序不会销毁，而且还到池子里，下次直接使用
