文章目录

1. Socket 套接字
- 1.1 有连接与无连接
- 1.2 可靠与不可靠传输
- 1.3 面向字节流与面向数据报
- 1.4 全双工与半双工
2. UDP数据报套接字编程
- 2.1 DatagramSocket API
- 2.2 DatagramPacket API
- 2.3 InetSocketAddress API
3. UDP 版本的客户端服务器程序
- 3.1 服务器实现
- 3.2 客户端实现
- 3.3 程序的执行结果
4. 跨主机通信

1. Socket 套接字

Socket（套接字）是这里的核心，这是操作系统提供给应用程序的网络编程 API

Socket API 是和传输层密切相关的。

传输层里提供了两个最核心的协议：UDP 和 TCP。
因此 Socket API 也提供了两种风格（UDP 和 TCP）

UDP 的特点：无连接、不可靠传输、面向数据报、全双工

TCP 的特点：有连接、可靠传输、面向字节流、全双工

1.1 有连接与无连接

需要建立连接关系了才能通信，连接建立需要对方来接受。

比如说打电话就是有链接的，而发短信和微信就是无连接的。
如果是打电话就需要对方接听才可以通信，如果是发微信，就不需要对方 “接受”，直接发就ok。

如果是打电话这种有连接的方式，在通信的过程中，可以及时获取到对方的状态。
（也就是对方有没有听到我说的话）

如果是发微信这种无连接的方式，在通信的过程中，就不可以及时获取到对方的状态。
（也就是对方到底看没看到信息是不找到的）

1.2 可靠与不可靠传输

网络环境天然是复杂的，不可能保证传输的数据可以 100% 就能到达。

发送方能知道消息是发送过去了还是丢了，打电话是属于可靠传输，发微信是不可靠传输。

如果是具有已读功能的就相当于是可靠传输了，可靠还是不可靠与有无连接没关系。

1.3 面向字节流与面向数据报

面向字节流：数据传输就和文件读写一样类似于 “流式” 的，获取使用比较灵活。

面向数据报：数据传输以一个一个 “数据报” 为基本单位。
（一个数据报可能是若干个字节，是带有一定格式的）

1.4 全双工与半双工

全双工 就是 一个通信通道可以双向传输（既可以发送又可以接受）。

半双工 就是不能双向传输。

比如一个水管，只能是从一头进水一头出水，不能都是进水或者都是出水。（单向传输）

水管就是一个 半双工。

如果是两头都是进水，那就不可以了。

为什么 UDP 和 TCP 都是全双工？

因为一根网线实际上是有 8 根线组成的。

2. UDP数据报套接字编程

2.1 DatagramSocket API

DatagramSocket 是 UDP Socket，用于发送和 接收UDP数据报。

可以使用 DatagramSocket 这个类表示一个 socket对象。

在操作系统中，把这个 socket 对象也是当成一个文件来处理，相当于是文件描述符表上的一项。

普通的文件对应的硬件设备是硬盘。
socket 文件对应的硬件设备是网卡

创建了一个 socket 对象后就可以和另外一台主机进行通信了。
如果要和多个不同的主机通信，那就需要多创建几个 socket 对象。

1、 DatagramSocket 类的构造方法

DatagramSocket() ：没有指定端口号，但是系统会自动分配一个空闲的端口。
DatagramSocket(int port)：需要传入一个端口号。

此时就是让当前的 socket 对象和这个指定的端口（简单的整数），关联起来。

本质上说，不是进程和端口建立联系，而是进程中的 socket 对象和端口建立了联系。

2、DatagramSocket 类的方法

void receive(DatagramPacket p)：从此套接字接收数据报。
（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacket p)：从此套接字发送数据报包（不会阻塞等待，直接发送）
void close()：关闭此数据报套接字，使用完了要关闭，释放资源。

DatagramPacket p 此处传入的相当于是一个空的对象，receive 方法内部会对参数的这个空对象进行内容填充。
从而构造出结果了，参数也是一个 “输出型参数”

2.2 DatagramPacket API

DatagramPacket 是 UDP Socket 发送和接收的数据报。

表示 UDP 中传输的一个报文，构造这个对象可以指定一些具体的数据进去。

1、构造方法

DatagramPacket(byte[] buf, int length)：把 buf 这个缓冲区给设置进去了。
DatagramPacket(byte[] buf, int offset, int length,SocketAddress address)（构造缓冲区加地址。）

使用这个类表示 IP （地址）+ port（端口号）。

2、方法

构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建。

2.3 InetSocketAddress API

InetSocketAddress （ SocketAddress 的子类）构造方法：

3. UDP 版本的客户端服务器程序

3.1 服务器实现

下面编写一个最简单的 UDP 版本的客户端服务器程序，称之为回显服务器。

一个普通的服务器：收到请求后，要根据请求计算响应，然后返回响应。

回显服务器：省略了其中 “根据请求计算响应” ，请求是什么就返回什么。
（回显服务器只是为了展示 socket api 的基本用法，并没有实际的业务）

作为一个真正的服务器，一定要有 “根据请求计算响应” ，因为这个环节是最重要的。

网络编程本质上是要操作网卡。
但是网卡不方便直接操作在操作系统内核中，使用一种特殊的叫做 ”socket“ 这样的文件抽象表示网卡。
因此进行网络通信势必先要有一个 “socket” 对象。

java"> private DatagramSocket socket = null; //创建 socket 对象

对于服务器来说，创建 “socket” 对象的同时要让他绑定上一个具体的端口号。
服务器一定要关联上一个具体的端口号！！！
服务器是网络传输中被动的一方，如果是操作系统随机分配端口，此时客户就不知道这个端口是什么了。

举个例子，比如说张三是卖煎饼的，在集市上租了一个10号摊位。

如果有人要来吃煎饼就需要到集市上的10号摊位购买，集市相当于是搭建的服务器，10号摊位相当于是端口号。

如果有人下次还要购买的的话，就还需要到集市上的10号摊位购买。
如果下一次来买的时候就不是10号摊位了，就找不到了。
换成服务器也是同理，如果没有或者是一个随机的端口，每次启动都是一个不同的端口。

有了具体的摊位才能让客户找到，有了具体的端口号才能方便客户端找到。

java">public UdpEchoServer(int port) throws SocketException {
    socket = new DatagramSocket(port);
}

1、读取客户端发来的请求是什么

对于 UDP 来说，传输数据的基本单位是 DatagramPacket

java">DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(requestPacket);

相当于是刚开始给 DatagramPacket 一个空白的纸条，客户在这张纸条上写出需求之后再把纸条还回来。

比如说买煎饼的时候需要告诉店家需要什么料儿，加什么酱料等待。
店家拿到客户制作煎饼的需求后才能开始制作。

receive 内部会针对参数对象进行填充，填充的数据来自网卡。

此时的这个 DatagramPacket 是一个特殊的对象，并不方便直接进行处理，可以将包含的数据拿出来，构造成一个字符串。

java">String request = new String(requestPacket.getData(), 0, requestPacket.getLength());

此处给 requestPacket 的最大长度是 4096，但是实际上这里的空间不一定满了，可能只使用了一小部分。

因此，getLength 获取到实际的数据包的长度，只需要把这个实际的有效部分给构造成字符串即可。

2、根据请求响应，由于此处是回显服务器，响应和请求相同

写一个方法来根据请求来计算响应。

java">public String process(String request) {
    return request;
}

3、把响应写回到客户端。send 的参数也是 DatagramPacket 需要把这个 Packet 构造好

此处构造的响应对象，不能是用空的字节数组构造了而是要使用响应数据来构造

java">DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
        response.getBytes().length, requestPacket.getSocketAddress());

DatagramPacket 不认识字符只认识字节，response.getBytes 是传响应对象的字节数组。
response.getBytes().length 指定长度，requestPacket.getSocketAddress() 获取到客户端的IP和端口号

4、打印一下当前这次请求响应的中间处理结果

java">System.out.printf("[%s:%d] req:%s; reap:%ds\n", requestPacket.getAddress().toString(),
        requestPacket.getPort(), request, response);

requestPacket.getPort() 是获取到里面的端口，requestPacket.getAddress().toString() 是获取到 packet 里面的 IP。

完整代码

java">package network;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

// UDP 版本的回显服务器
public class UdpEchoServer {
    //先要有一个 “socket” 对象
    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 = process(request);
            //3.把响应写回到客户端。send 的参数也是 DatagramPacket 需要把这个 Packet 构造好
            //此处构造的响应对象，不能是用空的字节数组构造了而是要使用响应数据来构造
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), 
            response.getBytes().length, requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //4.打印一下当前这次请求响应的中间处理结果
            System.out.printf("[%s:%d] req:%s; reap:%s\n", requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }
    }

    //这个方法根据请求来计算响应
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException{
        //端口的指定在 1024~65535 就可以
        UdpEchoServer udpEchoServer = new UdpEchoServer(9090);
        udpEchoServer.start(); //启动服务器
    }
}

socket.receive(requestPacket) 如果客户端发送请求了，receive 就能顺利地读出来，如果没有发送请求，receive 就阻塞等待。

3.2 客户端实现

和服务器的代码一样，客户端这里也是要先有个 socket 对象。

java"> private DatagramSocket socket = null;

与服务器不同的是在构造这个 socket 对象的时候，不需要显示的绑定一个端口。
操作系统会为之自动分配一个没有别的进程在使用的空闲端口。

java">public UdpEchoClient () throws SocketException {
    socket = new DatagramSocket();

在一次通信中涉及到的 ip 和端口有两组：源ip 和 源端口、目的ip 和 目的端口。

如果让客户端给服务器发送一个数据，此时的 源ip 就是 客户端的 ip 地址，目的 ip 就是 服务器的 ip 地址。
源端口就是 客户端的端口，目的端口就是 服务器的端口。

端口号用来表示/区分一个进程，因此不允许一个端口同时被多个进程使用（前提是同一个主机上）

一个端口在通常情况下不能被多个进程使用。（我租个店面开个小吃店，只能我用，别人不行）
但是一个进程可以绑定多个端口。（我不但可以租一个店面，我也可以开几个分店）

进程只要多创建几个 socket 对象，就可以分别关联不同的端口。（socket 和端口是一对一的，进程和 socket 是一对一多的）

对于服务器来说，端口必须是确定好的；而对于客户端来说，端口可以是系统分配的。

如果有客户来到我的小吃店吃东西，点完餐以后我给他了一个手牌，这个手牌上面取餐码就相当于是客户的端口。
（这个取餐码是多少，是随机的）

如果客户点餐的时候想要指定一个取餐码（比如说客户就喜欢 6 ），也不是不可以，但是不推荐。
因为这个 6 号有可能已经被别的顾客使用了。

客户端如果显示的指定一个 6666 这个端口，很有可能就和客户端电脑上其他程序正在使用 6666 这个端口，
此时这就可能导致程序无法正确通信，运行就会抛出异常，提示端口绑定失败。

为什么服务器指定端口不怕重复？

因为服务器是程序猿手里的机器，上面运行什么都是程序猿可以控制的，程序猿可以安排程序使用哪两个端口。
而客户端的机器是处于用户这里的，不受小猿的控制。
毕竟有一千个读者就有一千个哈姆雷特，每个客户运行的程序都不相同。

如果是服务器发给客户端的操作，服务器的端口就是源端口，客户端的端口就是目的端口。

如果是客户端发给服务器的操作，服务器的端口就是目的端口，客户端的端口就是源端口。

任何的通信，都得是源端口和目的端口两个端口

1、== 从控制台读取要发送的数据==

java"> Scanner scanner = new Scanner(System.in);
 System.out.println("<");
 String request = scanner.next();
 if (request.equals("exit")) {
     System.out.println("goodbye");
     return;
 }

2、构造成 UDP 请求并发送

java">DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                      InetAddress.getByName(serverIp), serverPort);
socket.send(requestPacket);

3、读取服务器的 UDP 响应并解析

java">DatagramPacket reponsePacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(reponsePacket);
String response = new String(reponsePacket.getData(), 0, reponsePacket.getLength());

4、把解析好的结果显示出来

java">System.out.println(response);

5、完整代码

java">package network;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

// UDP 版本的回显客户端
public class UdpEchoClient {

    //要先有一个 socket 对象
    private DatagramSocket socket = null;
    private String serverIp = null;
    private int serverPort = 0;

    // 一次通信需要有两个IP，两个端口
    // 客户端的 ip 是 127.0.0.1 已知
    // 客户端的 port 是系统自动分配的
    // 服务器的 ip 和 port 也需要告诉客户端，才能顺利的把消息发给服务器
    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) {
            // 1.从控制台读取要发送的数据
            System.out.println("<");
            String request = scanner.next();
            if (request.equals("exit")) {
                System.out.println("goodbye");
                return;
            }
            // 2.构造成 UDP 请求并发送
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            // 3.读取服务器的 UDP 响应并解析
            DatagramPacket reponsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(reponsePacket);
            String response = new String(reponsePacket.getData(), 0, reponsePacket.getLength());
            // 4.把解析好的结果显示出来
            System.out.println(response);
        }
    }

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

通信的过程

对于客户端服务器程序来说，一个服务器要给很多的客户端提供服务，我们也就需要构造很多的客户端来进行测试。
IDEA 默认只能启动一个客户端，需要调整一下让idea 能启动多个客户端。

1、找到 idea 右上角如图位置

2、点击圈中的的位置

3、在出现窗口中选中如同圈出的位置

4、选中以后别忘了点击 OK

3.3 程序的执行结果

先来看两个客户端的

接着是服务器

这里的 127.0.0.1:49675 指的是 IP 和 端口号，此处的 IP 是环回 IP ，这里的端口是系统随机分配。

端口冲突

下面来看看端口冲突是什么样的效果。

一个端口只能被一个进程使用，如果有多个进程使用就不行。

下面先启动回显服务器，在启动查词典的服务器，注意看效果。

4. 跨主机通信

回显服务器缺少业务逻辑，现在就在上面的代码的基础上稍微调整，实现一个查词典的服务器（英文单词翻译成中文）

对于 DisServer 来说，和 EchoServer 相比，大部分的东西是一样的，主要是 “根据请求计算响应” 的步骤不太一样。

java">public class extends UdpEchoServer {

    public UdpDisServer(int port) throws SocketException {
        super(port);
}

直接继承之前所写的回显服务器，然后构造 UdpDisServer。

设置一个 Map 并在 dict 里面添内容。

java"> private Map<String, String> dict = new HashMap<String, String>();

java"> // 给这个 dict 设置内容 
 dict.put("sing","唱");
 dict.put("jump","跳");
 dict.put("rap","说唱");
 dict.put("basketball","篮球");
 // 这里可以无线多

重写 UdpEchoServer 服务器的 process 方法实现根据响应计算请求的。

java"> @Override
 public String process(String request) {
     //查词典的过程
     return dict.getOrDefault(request, "当前单词不存在！！！");
 }

完整代码

java">package network;

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;

// 对于 DisServer 来说，和 EchoServer 相比，大部分的东西是一样的
// 主要是 “根据请求计算响应” 的步骤不太一样
public class UdpDisServer extends UdpEchoServer{

    private Map<String, String> dict = new HashMap<String, String>();

    public UdpDisServer(int port) throws SocketException {
        super(port);

        // 给这个 dict 设置内容
        dict.put("sing","唱");
        dict.put("jump","跳");
        dict.put("rap","说唱");
        dict.put("basketball","篮球");
        // 这里可以无线多
    }

    @Override
    public String process(String request) {
        //查词典的过程
        return dict.getOrDefault(request, "当前单词不存在！！！");
    }

    public static void main(String[] args) throws IOException {
        UdpDisServer server = new UdpDisServer(9090);
        server.start(); //启动
    }
}