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” 对象。

 private DatagramSocket socket = null; //创建 socket 对象

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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

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

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

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


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

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

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

完整代码

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 对象。

 private DatagramSocket socket = null;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 Scanner scanner = new Scanner(System.in);
 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);

5、完整代码

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 相比，大部分的东西是一样的，主要是 “根据请求计算响应” 的步骤不太一样。

public class extends UdpEchoServer {

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

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

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

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

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

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

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

完整代码

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(); //启动
    }
}

执行结果