套接字
什么是socket：
所谓的套接字也就是socket，这个socket和我们编写网络程序又有什么关系呢：
socket是传输层给应用层提供的API的集合，socket就相当于是程序使用网络的接口，而网卡是把数据发出去的硬件，socket就相当于是网卡的一个遥控器
我们网络编程主要涉及的就是传输层以及应用层的交互，我们先决定传输层的哪一个协议，是UDP还是TCP，也就是上文所介绍的两种：
后续的各种层是操作系统根据我们代码中的任务来选择的
发送数据的过程：
Java 程序
↓
Java Socket 对象
↓
文件描述符 fd
↓
进程的文件描述符表
↓
操作系统内核中的 Socket 对象
↓
TCP / IP 协议栈
↓
网卡
↓
网络
为什么会有文件描述符表：明明我们是讲socket，为什么会有一个文件描述符表呢，原因就是在Linux中很多东西都被抽象成了“可以像文件一样读写的资源”，所以他们统一通过文件描述符表（fd）来管理，但是我们学习的并不是linux操作系统啊，为什么会有什么个说法，因为在基本上所有的操作系统中，都有这么一个概念，都会让程序拿到一个编号，然后通过这个编号来找到底层系统中的操作以及方法，只不过在linux里面叫做文件描述符表，所以我们可以统一叫做这个来理解，还有就是为什么我们不能直接通过Java代码来操作一切，因为网络、文件、进程这些资源都属于操作系统的重要资源，不能让普通程序随便直接改，所以需要通过一个像文件描述符表的东西进行调度，调度到底层的操作系统的socket
socket的组成：
Socket（网络通信接口，大概念）
│
├── TCP
│ ├── Socket
│ └── ServerSocket
│
└── UDP
├── DatagramSocket
└── DatagramPacket
UDP
DatagramSocket = 通信工具
DatagramPacket = 要传输的数据包
DatagramSocket
| 构造方法 | 作用 | 常见场景 |
|---|---|---|
DatagramSocket() | 创建一个 UDP Socket，端口由系统自动分配 | 客户端常用 |
DatagramSocket(int port) | 创建 UDP Socket，并绑定指定端口 | 服务器常用 |
DatagramSocket(int port, InetAddress laddr) | 绑定指定端口和本机 IP | 一台机器有多个网卡/IP 时使用 |
| 方法 | 作用 |
|---|---|
send(DatagramPacket p) | 发送 UDP 数据包 |
receive(DatagramPacket p) | 接收 UDP 数据，并保存到 p 中 |
close() | 关闭 Socket，释放网络资源 |
getLocalPort() | 获取当前 Socket 绑定的本地端口 |
getLocalAddress() | 获取当前 Socket 绑定的本地 IP |
isClosed() | 判断 Socket 是否已经关闭 |
DatagramPacket
1，接收数据：
new DatagramPacket(byte[] buf, int length)
| 参数 | 作用 |
|---|---|
buf | 用来存放收到的数据 |
length | 最多允许接收多少字节 |
2，发送数据：
new DatagramPacket(
byte[] buf,
int length,
InetAddress address,
int port
)
| 参数 | 作用 |
|---|---|
buf | 要发送的数据 |
length | 要发送多少字节 |
address | 对方的 IP 地址 |
port | 对方的端口号 |
回显服务器例子
注意一
为什么服务器要指定端口，而客户端不需要，因为一台服务器是用来服务很多的客户端的，指定端口是让客户端知道并且只传入到那一个端口里面去，但是客户端有很多，就得系统随机，并且有些同学很容易将一个概念混淆，就是觉得客户端的端口和服务器的端口得一致才能对接上，实际是不是的：这里也会涉及前文讲到的五原组
我们只要明确了这五个就行，不需要一致
不是说需要五元组吗，那为什么服务器里面好像少了一个自己的ip：因为系统会根据客户端的数据进行匹配
比如客户端发送：
目标 IP = 192.168.1.10
目标端口 = 9090
协议 = UDP
到我们电脑之后，系统看到的信息就是
目的 IP：192.168.1.10
目的端口：9090
协议：UDP
假设你服务器中写到：
new DatagramSocket(9090);
也就相当于是：
监听：所有本机 IP 的 UDP 9090
然后进行匹配，最终就可以得出服务器自己的ip
所以说五元组往往是客户端和服务器两边的信息共同组成的！！！！！！！！
注意二
局域网 ≈ 一个小区
IP ≈ 楼号 / 房屋地址
端口 ≈ 房间号
所以为什么会出现端口号冲突，也就是我们现在写的程序是在自己的电脑上面，所以ip都是127.0.0.1，所以如果服务器和客户端的端口号也一致的情况下，就会产生端口号冲突，也就是走到了一个小区的一个楼层中的一个房间，那我们电脑上有那么多的应用程序，为什么不会造成冲突呢，因为系统会给客户端的端口自动分配，所以我们程序里面的客户端的代码也没有指定端口号，简单介绍一下电脑里的ip
不同 IP 的来源不一样：
127.0.0.1：操作系统按照网络协议标准预留的，本机固定使用。
192.168.x.x 这种局域网 IP：一般是你家路由器通过 DHCP 自动分配给电脑。
公网 IP：通常由运营商分配给你的路由器/网络出口。
VPN 的 IP：由 VPN 软件或 VPN 服务器分配。
所以我们的应用程序的ip都是通过操作系统自己分配的，比如你点开来一个网站，系统会识别这个请求是从WiFi网卡发出去的，所以会分配192开头的那个
具体代码
package network;
//服务器
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
public class UdpEchoServer {
//首先创建一个socket对象
DatagramSocket serverSocket=null;
//通过构造方法来完整
//创建一个服务器对象，需要指定端口
public UdpEchoServer(int port) throws Exception{
serverSocket=new DatagramSocket(port);
}
//开始方法
public void start() throws IOException {
System.out.println("服务器启动了");
while (true) {
//先得创建一个datagrampacket对象，这个对象是传输数据的基本单位，就相当于你赶海一人拿一个桶是一样的
DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
//接收请求
serverSocket.receive(requestPacket);
//将请求转为字符串
String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
//根据请求计算响应
String response = process(request);
//将响应封装到datagrampacket对象中,并且返回
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
requestPacket.getSocketAddress());
//requestPacket.getSocketAddress()不仅拿到了ip也拿到了端口号
serverSocket.send(responsePacket);
//打印日志
System.out.printf("客户端:%s 请求:%s 响应:%s\n", requestPacket.getSocketAddress(), request, response);
}
}
private String process(String request) {
//因为回显，所以就原路返回就行
return request;
}
public static void main(String[] args) throws Exception {
UdpEchoServer udpEchoServer=new UdpEchoServer(9090);
udpEchoServer.start();
}
}
package network;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
//客户端
public class UdpEchoClient {
//也是先创建一个socket对象
DatagramSocket clientSocket=null;
//需要给定服务器的ip以及端口
private String serverIp;
private int serverPort;
public UdpEchoClient(String serverIp,int serverPort) throws SocketException {
clientSocket=new DatagramSocket();
this.serverIp=serverIp;
this.serverPort=serverPort;
}
public void start() throws Exception{
while(true){
Scanner scanner=new Scanner(System.in);
System.out.println("请输入要发送的内容：");
String request=scanner.nextLine();
if (request.equals("exit")){
break;
}
DatagramPacket requestPacket=new DatagramPacket(request.getBytes(),request.getBytes().length,
InetAddress.getByName(serverIp),serverPort);
clientSocket.send(requestPacket);
DatagramPacket responsePacket=new DatagramPacket(new byte[1024],1024);
clientSocket.receive(responsePacket);
//将服务器返回的数据打印出来
String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
// 4. 显示响应.
System.out.println(response);
}
}
public static void main(String[] args) throws Exception {
UdpEchoClient udpEchoClient=new UdpEchoClient("127.0.0.1",9090);
udpEchoClient.start();
}
}
注意三
别人要访问我的服务器：
本机测试用 127.0.0.1，想让互联网中的别人访问，通常需要“公网 IP + 开放端口”，云服务器就是最常见的实现方式。
127.0.0.1表示当前这台电脑自己。
查字典案例
我们刚刚通过一个回显的案例来初步了解了一下UDP的构造以及相关socket的api，那我们现在再用一个查字典的案例来进一步了解一下
注意一
服务器以及客户端的主要流程
服务器大体
在while循环里面
第一步：读取请求并解析
（因为我们这里是需要返回一个字符串，所以转为字符串格式）
第二步：根据请求计算相应
（这里以回显为例子，所以只需要原路返回就行）
第三步：把相应返回给客户端
客户端大体
第一步：在控制台读取输入
第二步：构造请求发送给服务器
第三步：接收服务器发来的响应
第四步：根据返回来的响应进行显示结果
所以我们可以总结一下：我们写服务器以及客户端，只需要跟着上面的步骤，在发送和接收的时候，来书写对的DatagramPacket对象，使用正确的构造方法
注意二
为什么可以这么写：因为其实现在市面的大部分背单词软件都是这么写的，我们也可以上网复制中英文对应关系来使我们的回答更加全面
具体代码
package network;
import java.io.IOException;
import java.net.DatagramSocket;
import java.util.HashMap;
import java.util.Map;
public class UdpDictServer extends UdpEchoServer{
//因为我们是一个查字典，所以我们用到map来根据key来查找values
Map<String,String> map=new HashMap<String, String>();
//重写方法
public UdpDictServer(int port) throws Exception {
super(port);
//在这里传入对应的中英文关系
map.put("apple","苹果");
map.put("banana","香蕉");
map.put("cat","猫");
map.put("dog","狗");
}
@Override
public String process(String request) {
//request 是客户端传来的查询内容，是 key；getOrDefault() 返回的是这个 key 对应的 value。
return map.getOrDefault(request,"查无此词");
}
public static void main(String[] args) throws Exception {
UdpDictServer server = new UdpDictServer(9090);
server.start();
}
}
（因为这里的客户端和前面的回显服务器一样，都是发送，包装成String，然后发送回去，所以我们还是用的之前的客户端）
TCP
ServerSocket和Socket
客户端 服务器
Socket
│
│ 请求连接
├──────────────────────────→ ServerSocket
│ │
│ accept()
│ │
│ ↓
│ Socket
│ │
└──────────── TCP连接 ────────────┘
整体的关系差不多就是这样，serversocket负责将将请求引进家门（处理客户端的连接，所以只会在服务器中写到），而socket像是专门负责业务的专员（在客户端以及服务器里都会用到）
回显服务器例子
TCP的短长连接
短连接：就是连接一次，通信完就断，需要多次进行连接和断开，会影响效率，但是不会一直占着服务器资源
长连接：连接一次，可以通信很多次之后关闭，就像我们程序中写到的while循环，不用老是创建和关闭，所以效率会高，但是会长时间占着资源，可能一直占着一个线程
注意一
accept建立连接：
因为在我们没有写多线程的时候，就只有一个socket服务员，也就是只能一个线程在进行服务，后面的就得等着，所以我们通过多线程的形式，可以实现多客户端
注意二
flush：
在我们用printwriter（这个内置了缓冲区）进行写入的时候，会先将数据写进缓冲区里，数据满了之后才会将数据传输出去，所以我们得写flush，写入一些数据就将他们传输过去
TCP和UDP的有无连接
TCP的Socket socket = serverSocket.accept()这个方法，会进行连接，也就是会拿到这个socket的信息并且记录下来，所以后续就会根据这个信息给特定的socket进行交互，但是udp不会记录对方socket信息
注意三
具体代码
package network;
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 {
Socket socket=null;
TcpEchoClient(String serverName,int serverPort) throws IOException {
socket=new Socket(serverName,serverPort);
}
public void start() throws IOException {
System.out.println("client start!");
//依旧是先创建字节流的输入输出来处理数据
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
Scanner scanner = new Scanner(System.in);
Scanner scannerNetwork = new Scanner(inputStream);
PrintWriter printWriter = new PrintWriter(outputStream);
while (true) {
//先读取数据
System.out.println("client:请输入数据");
String request = scanner.next();
//再将读取的数据传给服务器
printWriter.println(request);
printWriter.flush();
//最后读取服务器的相应
if (!scannerNetwork.hasNext()) {
break;
}
String response = scannerNetwork.next();
//最后打印出来
System.out.println("server: " + response);
}
}catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);
client.start();
}
}
package network;
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 {
//先创建一个ServerSocket对象
ServerSocket serverSocket = null;
public TcpEchoServer(int port) throws Exception {
serverSocket = new ServerSocket(port);
}
//开始方法
public void start() throws IOException {
//先建立连接，然后由Socket进行处理
//注意一
ExecutorService executorService = Executors.newCachedThreadPool();
while (true) {
Socket socket = serverSocket.accept();
executorService.submit(() -> {
try {
processConnection(socket);
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
}
private void processConnection(Socket socket) throws IOException {
System.out.printf("[%s:%d] 客户端上线!\n", socket.getInetAddress(), socket.getPort());
//tcp是面向字节流的
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
//因为tcp是面向字节流的，所以我们定义了InputStream和OutputStream，但是我们输入是一个字符串，所以我们会
//继续用到scanner来读和PrintWriter来写，并且PrintWriter可以将我们输入的字符串转为字节传输出去
Scanner scanner = new Scanner(inputStream);
PrintWriter printWriter = new PrintWriter(outputStream);
while (true) {
if (!scanner.hasNext()) {
// 客户端关闭了连接
System.out.printf("[%s:%d] 客户端下线!\n", socket.getInetAddress(), socket.getPort());
// 假设这里有一系列的逻辑呢??
break;
}
//先接收数据
String request = scanner.next();
//再根据请求计算相应
String response = process(request);
//最后发送相应给客户端
printWriter.println(response);
//注意二
printWriter.flush();
System.out.printf("[%s:%d] 客户端请求: %s\n", socket.getInetAddress(), socket.getPort(), request);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
socket.close();
}
}
public String process(String request) {
return request;
}
public static void main(String[] args) throws Exception {
TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
tcpEchoServer.start();
}
}
查字典案例
package network;
import java.util.HashMap;
import java.util.Map;
public class TcpDictServer extends TcpEchoServer{
Map<String,String> map=new HashMap<String, String>();
public TcpDictServer(int port) throws Exception {
super(port);
map.put("apple","苹果");
map.put("banana","香蕉");
map.put("cat","猫");
map.put("dog","狗");
}
@Override
public String process(String request) {
//request 是客户端传来的查询内容，是 key；getOrDefault() 返回的是这个 key 对应的 value。
return map.getOrDefault(request,"查无此词");
}
public static void main(String[] args) throws Exception {
TcpDictServer server = new TcpDictServer(9090);
server.start();
}
}
3510
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
