一. 网络编程套接字

网络编程套接字, 就是指操作系统提供的网络编程的api, 称为"socket api"

操作系统, 提供的socket api, 有三套:

1. 流式 套接字 => 给TCP使用的
2. 数据报 套接字 => 给UDP使用的
3. Unix域套接字 =>不能夸主机通信, 只能本地主机上的进程和进程之间的通信(现在很少使用)

TCP和UDP都是传输层协议, 都是给应用程序提供服务的
但是这两个协议特点差异非常大, 因此我们就需要搞两套api, 来分别表示

TCP和UDP的特点

TCP的特点:
有连接, 可靠传输, 面相字节流, 全双工
UDP的特点:
无连接, 不可靠传输, 面向数据报, 全双工

有连接 vs 无连接

计算机中的连接, 指的是建立联系的双方, 各自保存对方的信息
那么TCP协议要求:
通信双方保存对方的信息
UDP要求:
通信双方不需要保存对方的信息

可靠传输 vs 不可靠传输

可靠 != 安全
可靠, 指的是要传输的数据, 尽可能的传输给对方, 尽力不是确保
那么, TCP协议, 内部提供了一系列的机制, 来实现可靠传输
UDP协议, 只关心发送, 并不关心后续

面向字节流 vs 面向数据报

文件操作, 也是字节流的, 读写非常灵活, 读写的基本单位就是字节
TCP也是字节流的

数据报Datagram, 数据段Segment, 数据包Packet, 数据帧Frame, 这些都是网络传输数据的基本单位, 但是有不同的使用场景
那么, UDP, 是面向数据报, 传输数据的基本单位, 是一个个的UDP数据报

全双工 vs 半双工

全双工: 一条链路, 能够进行双向通信
半双工: 一条链路, 只能进行单向通信
TCP, UDP都是全双工

后续会对TCP和UDP进行进一步详细介绍

二. java用UDP实现网络编程

socket api 都是系统提供的, java中对于系统的这些api进行进一步封装了
UDP的socket api 重点的两个类:
1. DatagramSocket
系统中的socket, 可以理解成是一种"文件", socket文件, 可以视为是"网卡"这种硬件设备的抽象表现形式
DatagramSocket, 就是对socket进行封装, 可以视为是"操作网卡"的遥控器
针对这个对象进行读写操作, 就是在针对网卡进行读写操作

具有"遥控器属性"这样的概念, 计算机中起了个专门的名字"句柄"(handle)

构造方法:

读写方法:

2. DatagramPacket
是针对UDP数据报的一个抽象表示

构造方法:

成员方法:

代码实现:

网络程序, 既有服务器, 也有客户端
我们现在只是进行一个简单的实现, 服务器收到客户端请求后, 无需做什么, 客户端请求啥, 直接响应啥, 这种程序, 就叫做"回显"(Echo)
服务器:
第一步:创建对象

1. 服务器运行, 要把端口号确定下来, 以便让客户端找到, 客户端才能主动发送请求
   实际运行的时候, 端口只能为多少是程序猿自己决定的
   但是要确保: 1)端口号是合法的 1-65535 2) 自己写的端口号, 不能和别的进程使用的端口号冲突
2. 为什么把new对象放在构造方法里? 方便抛异常

第二步:创建start方法

服务器需要不停的处理请求, 不停地响应, 所以需要写成死循环

第三步:读取请求并解析

这个对象是一个UDP数据报, 包含两个部分:
1)报头(通过类的属性来表示的)
2)载荷(通过构造方法传递的字节数组, 作为持有载荷的空间, 这个存储载荷的空间, 人家没有自己new, 而是让你new好)

如果receive没有收到请求, 那么就会阻塞等待, 直到有客户端发送请求
为了方便后续再java代码中的处理(打印), 可以把上述数据报中的二进制数据拿出来, 构造成String

第四步:根据请求计算响应

将响应的结果通过process方法返回:

第五步: 把响应写回到客户端

构造一个DatagramPacket作为发送的数据报
第一个参数是byte[] 类型, String中的getBytes()方法可以获取字节
最后一个参数是用来获取客户端的ip和端口信息

前面我们知道, UDP是无连接的, 所以本身并没有存储对方的ip和端口信息, 但是上述我们用来接收数据的DatagramPacket中, 存放了客户端的ip和接口, 所以我们可以通过getSocketAddress()方法来获取到

第六步: 打印请求记录

这样我们就完成了UDP协议下的服务器实现!

完整代码:

public class UDPEchoServer {
    private DatagramSocket socket = null;

    public UDPEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while(true){
            //1)读取请求并解析
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestPacket);
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
            //2)根据请求计算响应
            String response = this.process(request);
            //3)把响应写回到客户端
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), 0, response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);

            System.out.printf("[%s:%d] req=%s, resp=%s\n", requestPacket.getAddress(), requestPacket.getPort(),
                    request, response);
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        UDPEchoServer server = new UDPEchoServer(9090);//随便假设的端口号, 如果不能运行就换一个
        server.start();
    }

}

客户端:
第一步:创建对象
因为客户端是先发送请求的一端, 所以当我们创建类的时候, 需要知道服务器的ip地址和端口

注意: 客户端这边, 创建DatagramSocket对象时, 不需要传端口参数
不是客户端不需要端口, 是因为操作系统, 自动分配了一个空闲的(不和别人冲突)的端口号, 不需要自己指定
这个自动分配的端口号, 每次重新启动程序都可能不一样

第二步: 创建start方法

客户端可以不停地给服务器发送请求, 所以使用死循环

第三步: 从控制台读取用户输入

第四步: 构造请求并发送

因为客户端和服务器之间是没有连接的, 所以我们怎么才能知道将数据传给谁呢
数据报帮我们完成了这个工作, 在构造数据报时, 我们需要传5个参数,
前三个和写服务器是一样, 将字符串转化成字节数组, 并规定长度
后两个是传服务器的IP地址和端口号
传服务器的IP地址时, 我们所获取到的是点分十进制的字符串, 我们需要转化成java能够识别的对象
需要借助InetAddress.getByName方法

第五步: 读取响应的数据

需要自己new空间存放数据

第六步:显示响应到控制台

将接收到的数据报转成字符串, 打印到控制台上

第七步: 实现main方法

当前服务器和客户端在一个主机上, 固定使用"127.0.0.1" 这个ip即可, 称为环回ip

完整代码:

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;

    public UdpEchoClient(String serverIp, int serverPort) throws SocketException {
        socket = new DatagramSocket();
        this.serverIp = serverIp;
        this.serverPort = serverPort;
    }

    public void start() throws IOException {
        System.out.println("客户端启动!");
        Scanner scanner = new Scanner(System.in);
        while(true){
            System.out.println("请输入要发送的请求");
            //1. 从控制台读取用户输入
            String request = scanner.next();
            //2. 构造请求并发送
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),0,request.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            //3. 读取响应的数据
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            //4. 显示响应到数据台
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
        client.start();
    }
}

运行代码:

要先运行服务器, 再运行客户端


这样, 客户端和服务器就能够正常运行啦

启动多个客户端

默认情况下, idea里面只能启动一个客户端, 要想启动多个:


这样就可以运行多个客户端啦

别人能否使用?

我们这个客户端和服务器都在同一个主机上, 那么不同如果是不同主机, 是不能成功的
因为:
我们的电脑的IP只是一个局域网内部使用的私有IP, 而不是在广域网上直接使用的"公有IP"
虽然我们没有公有IP, 但是我们可以买云服务器

实现翻译功能

我们上述逻辑, 属于回显, 并没有实际完成什么逻辑
接下来我们来实现一个简单的翻译功能的服务器
由于逻辑大致相同, 只有process内部的功能不同, 所以我们可以使用继承来完成

 public class UdpDictServer extends UDPEchoServer{
    private Map<String, String> dict = null;

    public UdpDictServer(int port) throws SocketException {
        super(port);
        dict = new HashMap<>();
        dict.put("hello", "你好");
        dict.put("cat", "小猫");
        dict.put("dog", "小狗");
    }

    @Override
    public String process(String request) {
        return dict.getOrDefault(request, "没查询到该词汇");
    }

    public static void main(String[] args) throws IOException {
        UDPEchoServer server = new UdpDictServer(9090);
        server.start();
    }
}