本文介绍了Socket套接字的概念，分别讲解了UDP和TCP的特点。通过示例代码展示了如何基于UDP和TCP实现回显服务器，包括服务器端和客户端的实现。同时，提到了端口冲突问题以及TCP的连接、可靠传输和面向字节流的特点。
目录
Socket
Socket套接字，是由系统提供用于网络通讯的技术，是基于TCP/IP协议的网络通信的基本操作单元，基于Socket套接字的网络程序开发就是网络编程。Socket套接字根据不同的传输层协议可以分为流套接字（使用TCP），数据报套接字（使用UDP）。在操作系统中，把这个socket对象当成一个文件来处理（普通文件对应硬盘，socket文件对于网卡），通过构造socket对象，就可以和另外的主机通信。
一.UDP
特点
UDP是无连接，不可靠传输，面向数据报，全双工，大小受限（一次最多传输64k个二进制）。
①无连接是指传输方与接受方之间是建立连接后，才进行通讯的，如：打电话。
②不可靠传输是指发送方并不知道自己的消息是否到达接收方。
③面向数据包是指数据传输是以“数据报”为基本单位进行传输。（一个数据报是带有一定格式的若干个字节）
④全双工是指一个通讯通道，是可以双向传输，既可以发送，也可以接受。
基于UDP实现回显服务器
服务器
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UDPServer {
//操作系统内核，使用了socket 抽象表示网卡。
//进行网络通讯，必须要有一个socket对象
//一个端口一般不能被多个进程使用，但一个进程可使用多个端口
//socket和端口号1对1，进程和socket1对多。
private DatagramSocket socket = null;
//对于服务器来说，创建socket对象的同时，要让他绑定一个具体的端口号。
//服务器一定要关联上一个具体的端口。
//服务器是网络传输中，被动的一方，如果是操作系统随机分配的端口，客户端就不知道端口是哪个，就无法通信。
public UDPServer(int port) throws SocketException {
socket = new DatagramSocket(port);
}
public void start() throws IOException {
while(true){
System.out.println("服务器start");
//服务器一直运行，并等待客户端请求。
//1.读取客户端发送的请求
//receive方法的参数是输出型参数，需要先构造好一个空白的DatagramPacket对象，交给receive进行填充
DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
socket.receive(requestPacket);//如果有请求就顺利读出来，没有请求就阻塞
//此时datagrampacket是一个特殊的对象，不方便直接处理，需要把这里包含的数据拿出来，构造成一个字符串。
String request = new String(requestPacket.getData(),0,requestPacket.getLength());
//2.根据请求计算响应，（业务代码）
String response = process(request);
//3.把响应写回到客户端，send的参数也是DatagramPackt，需要把这个packet对象构造好。
//此处构造的响应对象，不能是空的字节数组构造，而是要使用响应数据来构造。
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
requestPacket.getSocketAddress());//获取客户端的ip和端口号
socket.send(responsePacket);
//4.打印一下，当前这次请求响应的处理中间结果。
System.out.printf("[%s:%d] req:%s;resp:%s\n",requestPacket.getAddress().toString(),
requestPacket.getPort(),request,response);
}
}
private String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
UDPServer udpServer = new UDPServer(9090);
udpServer.start();
}
}服务器的端口是要固定指定的：目的是方便客户端找到服务器程序。
客户端的端口是系统自动分配的：如果手动指定，可能会和客户端上的其他程序的端口冲突,因为服务器上的代码可控，而客户端不可控。
客户端
import java.io.IOException;
import java.net.*;
import java.util.Scanner;
public class UDPClient {
private DatagramSocket socket = null;
private String severIp = null;
private int severPort = 0;
//一次通讯，要有两个ip与端口。
//客户端ip是本机，即127.0.0.1
//客户端port由系统自动分配
//服务器的ip与端口需要传给客户端
public UDPClient (String severIp,int port) throws SocketException {
socket = new DatagramSocket();
this.severIp = severIp;
this.severPort = port;
}
public void start() throws IOException {
System.out.println("Client start");
Scanner scanner = new Scanner(System.in);
while(true){
//1.从控制台读取要发送数据
System.out.println(">");
String request = scanner.next();
if(request.equals("exit")){
System.out.println("bye");
break;
}
//2.构造UDP请求，并发送
// 构造packet时，需要把服务器的ip与port都要传入，单是此处的ip地址需要填写的是32位整数形式。
// 上述的ip是一个字符串，使用InetAddress.getbyname转换。
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
InetAddress.getByName(severIp),severPort);
socket.send(requestPacket);
//3.读取服务器的UDP响应，并解析
DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
socket.receive(responsePacket);
String response = new String(responsePacket.getData(),0,responsePacket.getLength());
//4.把解析好的结果显示
System.out.println(response);
}
}
public static void main(String[] args) throws IOException {
UDPClient udpClient = new UDPClient("127.0.0.1",9090);
udpClient.start();
}
}总结：在UDP中，由于面向数据报来进行传输，所以需要把请求和响应构造成packet对象，再通过socket对象的receive和send方法来进行收发packet，即完成了数据的传输。
端口冲突
端口只能被一个端口使用，当一个端口被两个线程都设定时，即会发生端口冲突。
当我在IDEA上运行同一个服务器两次后，将有以下报错：
Address aleady in use:Cannot bind--即为端口冲突错误。
图解
二.TCP
特点
TCP有连接，可靠传输，面向字节流，全双工，且大小不受限。
基于TCP实现回显服务器
服务器
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* Created with IntelliJ IDEA.
* Description:
* User: asus
* Date: 2023-02-13
* Time: 16:58
*/
public class TCPSever {
private ServerSocket socket = null;
public TCPSever(int port) throws IOException {
socket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("启动");
ExecutorService executorService = Executors.newCachedThreadPool();
while(true){
//接受一个连接
Socket client = socket.accept();
//处理连接 使用多线程实现多个客户端请求
// processClient(client);
//但是由于如果客户端请求过多，就要创建、销毁线程
// Thread t = new Thread(()->{
// processClient(client);
// });
// t.start();
//使用线程池 实现任务
//使用Fixed不合适，此处不应该是固定的
executorService.submit(new Runnable() {
@Override
public void run() {
processClient(client);
}
});
}
}
private void processClient(Socket client) {
System.out.printf("[%s : %d] 客户端请求\n",client.getInetAddress().toString(),client.getPort());
//基于Socket通信
try(InputStream inputStream = client.getInputStream(); OutputStream outputStream = client.getOutputStream()) {
while(true){
//1.接受请求
Scanner scanner = new Scanner(inputStream);
if(!scanner.hasNext()){
System.out.printf("[%s : %d] 客户端下线\n",client.getInetAddress().toString(),client.getPort());
break;
}
String request = scanner.next();//读取到空格，换行符，其他空白符结束,返回结果不包含空格，换行符，其他空白符。
//2.读取请求
String response = process(request);
//3.返回响应结果
//由于outputStream没有 write String 的功能，可以将String里的字符数组传入。
//也可以通过字符流转化
// PrintWriter printWriter = new PrintWriter(outputStream);
// //println带有一个\n，便于接受解析
// printWriter.println(response);
// //flush用于刷新缓冲区，保证写入的数据，发送出去了
// printWriter.flush();
outputStream.write(response.getBytes());
outputStream.write('\n');
System.out.printf("[%s : %d]:req: %s;resp: %s\n",client.getInetAddress().toString(),client.getPort(),
request,response);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//客户端请求结束，释放socket资源
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//解决客户端特别多，C10M问题，使用IO多路复用方法（IO多路转接）。
private String process(String request) {
return request+1;
}
public static void main(String[] args) throws IOException {
TCPSever tcpSever = new TCPSever(4090);
tcpSever.start();
}
}客户端
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
/**
* Created with IntelliJ IDEA.
* Description:
* User: asus
* Date: 2023-02-13
* Time: 18:31
*/
//TCP实现回显服务器
public class TCPClient {
private Socket socket = null;
public TCPClient(String severIp, int port) throws IOException {
//socket 可以识别十进制格式的IP地址，不像datagramPacket。
//new对象的同时，就会进行TCP连接，等待服务器accept接收
socket = new Socket(severIp,port);
}
public void start(){
System.out.println("客户端启动");
Scanner scanner = new Scanner(System.in);
try(InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
while(true){
//1.从键盘上输入
String request = scanner.next();
if(request.equals("exit")){
System.out.println("再见");
break;
}
//2.客户端读取内容，构成请求，发送给服务器
//字符流转换
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(request);
printWriter.flush();
//3.读取服务器的响应
Scanner scanResponse = new Scanner(inputStream);
String response = scanResponse.next();
//4.打印
System.out.println(response);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
TCPClient tcpClient = new TCPClient("127.0.0.1",4090);
tcpClient.start();
}
}图解
总结：TCP协议通信，要先通过socket对象建立连接，在客户端new Socket对象时，即会向服务器请求建立连接，而服务器通过socket.accpet接受连接。成功建立连接后，通过两个流对象，进行数据的传输。
扫一扫
9010
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
