目录
TCP流套接字编程
1.ServerSocket API
2.Socket API
3.TCP中的长短连接
4.回显程序(短连接)
5.服务器和客户端它们的交互过程
6.运行结果及修改代码
❗❗两个核心:ServerSocket Socket
✨ServerSocket 是创建 TCP服务端Socket的API
ServerSocket 构造方法:
ServerSocket(int port) 创建一个服务端流套接字Socket,并绑定到指定端口
ServerSocket 方法:
Socket accept() 开始监听指定端口(创建时绑定的端口)有客户端连接后,返回一个服务端Socket对象,并基于该Socket建立与客户端的连接,否则阻塞等待
void close() 关闭此套接字
✨Socket 是 客户端Socket,或服务端中接收到客户端建立连接(accept方法)的请求后,返回的服务端 Socket。
Socket 构造方法:
Socket(String host, int port) 创建一个客户端流套接字Socket,并与对应IP的主机上,对应端口的进程建立连接
Socket 方法:
InetAddress getInetAddress() 返回套接字所连接的地址
InputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流
TCP发送数据时,需要先建立连接,什么时候关闭连接就决定是短连接还是长连接:
短连接:每次接收到数据并返回响应后,都关闭连接,即是短连接。也就是说,短连接只能一次收发数据。
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();
}
}
1️⃣启动服务器
2️⃣客户端启动
当客户端和服务器连接建立好之后,服务器这边的 accept 就返回了
3️⃣服务器就进入 processConnection 了,尝试从客户端读取请(由于此时客户端还没有发送请求,此时读取操作也会阻塞)
与此同时:
用户端往下执行到,从控制台读取用户输入——也会阻塞
4️⃣当用户真的输入内容,客户端真正发送了请求出去;同时往下执行到,读取服务器响应,再次阻塞
5️⃣服务器收到客户端的请求之后,从 next 这里返回,执行 process 执行 println ,把响应写回到客户端
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:使用 线程池 修改上述代码
✨一个连接的所有请求处理完,这个程序不会销毁,而且还到池子里,下次直接使用