一、什么是UDP与TCP

二、什么是Socket

三、UDP网络编程简单实现

1、DatagramSocket API

2、DatagramPacket API

3、基本使用方法：

我们以一个简易的翻译器的案例，来实现简单的UDP编程：

服务器端代码：

部分代码的说明：

客户端代码：

部分代码说明：

测试结果：

四、TCP网络编程简单实现

ServerSocket API

Socket API

接下来以一个简单的回显服务器来说明TCP编程。

1、建立服务器端

部分代码说明：

2.建立客户端

测试结果：

一、什么是UDP与TCP

TCP与UDP是计算机网络中五层模型的运输层协议。

UDP协议：(User Datagram Protocol)是一种数据报文协议，它是无连接协议，不保证可靠传输。因为UDP协议在通信前不需要建立连接，因此它的传输效率比TCP高

TCP 协议：是传输控制协议，它是面向连接的协议，支持可靠传输和双向通信。它在传输数据之前需要先建立连接，建立连接后才能传输数据，传输完后还需要断开连接。TCP协议之所以能保证数据的可靠传输，是通过接收确认、超时重传这些机制实现的。并且，TCP协议允许双向通信，即通信双方可以同时发送和接收数据。

对比来看两个协议的特点：

TCP：有连接；可靠传输；面向字节流；全双工

UDP：无连接；不可靠传输；面向数据报；全双工

有连接：比如打电话，得先接通，才能相互交互数据

无连接：想发微信，不需要接通，直接就能发数据

可靠传输：传输过程中，发送方知道接受方有没有收到数据

不可靠传输：传输过程中，发送方不知道接收方有没有收到数据

面向字节流：依字节为单位进行传输（非常类似于文件操作中的字节流）

面向数据报：以数据报为单位进行传输（一个数据报都会明确大小）一次发送/接受必须是一个完整的数据报，不能是半个或者一个半

全双工：一条链路，双向通信（双行道）

半双工：一条链路，单向通信（单行道）

二、什么是Socket

在我们进行网络编程时，都会接触到一个名叫Scoket的概念，应用程序通过Scoket来建立远程连接，Socket通过内部封装好的协议把数据传输到网络。网络编程套接字，是操作系统给应用程序提供的一组API(叫做socket API）

为什么需要Socket 进行网络通信?因为仅仅通过IP地址进行通信是不够的，同一台计算机同一时间会运行多个网络应用程序，例如浏览器、QQ、邮件客户端等。当操作系统接收到一个数据包的时候，如果只有IP地址，它没法判断应该发给哪个应用程序，所以，操作系统抽象出Socket 接口，每个应用程序需要各自对应到不同的Socket,数据包才能根据 Socket正确地发到对应的应用程序。socket可以视为应用层和传输层之间的通信桥梁。

使用Socket进行网络编程时，本质上就是两个进程之间的网络通信。其中一个进程必须充当服务器端，它会主动监听某个指定的端口，另一个进程必须充当客户端，它必须主动连接服务器的IP地址和指定端口，如果连接成功，服务器端和客户端就成功地建立了一个TCP连接，双方后续就可以随时发送和接收，因此，当Socket 连接成功地在服务器端和客户端之间建立后:对服务器端来说，它的Socket是指定的IP地址和指定的端口号。

三、UDP网络编程简单实现

UDP和TCP相比，就简单的一点，因为UDP不需要建立连接，也就没有区分哪一个是客户端哪一个是服务器端，是依靠数据包来进行实现的，数据包也是收一个发一个，不存在使用流的概念。

UDP也是需要使用Socket来监听端口的的，不过它使用的是java提供的DatagramSocket。

1、DatagramSocket API

DatagramSocket API是UDP Socket，用于发送和接受UDP数据报

2、DatagramPacket API

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

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

3、基本使用方法：

服务端：

1.创建一个DatagramSocket对象，创建的同时关联一个端口号
2.读取请求，并解析
3.根据请求计算响应
4.把响应写回到客户端
5.打印日志

客户端：

1.创建一个DatagramSocket对象，创建的同时指定服务器的ip和端口号
2.读取输入的数据
3.构造请求并发送给服务器
4.从服务器读取响应
5.把数据显示给用户

我们以一个简易的翻译器的案例，来实现简单的UDP编程：

服务器端代码：

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


public class UdpEchoServer {
    //创一个DatagramSocket对象中
    private DatagramSocket socket = null;

    //翻译就是从key——>value的过程
    private Map<String,String> dict = new HashMap<>();

    //构造方法：
    //参数的端口表示我们的服务器要绑定的端口
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);

        //这里利用HashMap存放大量的key,value值
        dict.put("玫瑰","rose");
        dict.put("许愿","Wishing");
        dict.put("不期而遇",
                "unexpected encounters ");
    }

    //启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动！");
        //UDP不需要建立连接，直接接收从客户端传来的数据
        //死循环：不断接收客户端的连接
        while(true) {
            //每循环一次，处理一次请求

            //1、读取请求并解析
            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、把响应写回到客户端
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length
            ,requestPacket.getSocketAddress());
            //写回
            socket.send(responsePacket);

            //4、打印一个日志，记录当前的情况
            System.out.printf("[%s:%d] req:%s;resp:%s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(),request,response);
        }
    }
    public String process(String Data) {
        return dict.getOrDefault(Data,"词典中未找到");
    }

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

部分代码的说明：

在构造方法中，port参数的是什么意思：

port参数，就是表示该服务器要绑定的端口，目的在于能够让客户端明确是访问主机上的哪个进程，通过端口确定一个进程，就需要在这个进程启动的时候绑定一个端口，并且一个端口只能被一个进程绑定（一般）

为什么使用死循环：

服务器是不知道客户端啥时候发送请求，所以需要时刻准备着，接收

receive() 方法说明：

这个方法的参数，是个输出型参数，调用receive的时候，就需要构造一个空的 DatagramPacket对象，然后把对象交给receive，在receive里面负责把从网卡读到的数据，给填充到这个对象里面

注：构造对象时，里面的new byte[4096]，这个是自己调整大小，不要太小就好了

两次构造对象的区别：

requestPacket.getSocketAddress()的作用：

记录客户端的IP和端口号

例如：

我买了一个快递，现在想要退货，就需要把这个包裹发回给商家，商家的收货地址和收件人都是在我收到的包裹上写着的。

日志打印：

客户端代码：

import java.io.IOException;
import java.net.*;
import java.util.Scanner;


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 {
        Scanner sc = new Scanner(System.in);
        while(true) {
            //1、从控制台读取用户输入的内容
            System.out.println("->");
            String request = sc.next();

            //2、构造一个UDP请求，发送给服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(this.serverIP),this.serverPort);
            //发送
            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 {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

部分代码说明：

构造方法的参数：

public UdpEchoClient(String serverIP,int serverPort) {}

前者是服务器IP，后者是服务器端口

疑问？为什么服务器那边，只是端口号，因为服务器一般情况下，IP就是本机IP

为什么让系统自动指定窗口？

socket = new DatagramSocket();

一般情况下，都是系统自动指定的，如果是手动指定，刚好所指定的窗口正在被别人使用，就会引来不必要的麻烦

举例：

我们去餐厅吃饭，每次去我们都喜欢坐在一个拐角处（指定窗口），突然有一天，这里被别人坐了，我们总不能去赶走人家吧，最好还是做个空位做下就好啦，所以通常都是有系统自动指定一个空闲的窗口

关于DatagramPacket构造：

整体的运行流程：

测试结果：

四、TCP网络编程简单实现

TCP的编程实现客户端与服务器端交互，是通过建立连接，从而利用“流”来进行数据交换的，即使用字节输入/输出流，把要发送的数据，存储到字节数组，通过“流”来实现发送与接收。

ServerSocket API

Socket API

接下来以一个简单的回显服务器来说明TCP编程。

1、建立服务器端

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 {
    //代码中会涉及到多个socket对象，使用不同的名字来区分
    private ServerSocket listenSocket = null;

    public TcpEchoServer(int port) throws IOException {
        listenSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动！");
        ExecutorService service = Executors.newCachedThreadPool();
        while(true) {
            //1、先调用accept来接受客户端的连接
            //如果当前没有客户端来建立连接，accept就会阻塞
            Socket clientSocket = listenSocket.accept();
            //2、再处理这个连接，这里应该要使用多线程，每个客户端上来都分配一个新的线程负责处理


            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
        }
    }

    private  void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d 客户端上线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort() );
        //接下来处理客户端的请求
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            while(true) {
                //1、读取请求并解析
                Scanner sc = new Scanner(inputStream);
                if(!sc.hasNext()) {
                    //读完了，连接断开了
                    System.out.printf("[%s:%d] 客户端下线！\n",clientSocket.getInetAddress().toString());
                    break;
                }
                String request = sc.next();
                //2、根据请求计算响应
                String response = process(request);
                //3、把响应写回给客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                //刷新缓冲区确保数据确实是通过网卡发送出去了
                printWriter.flush();

                System.out.printf("%s:%d req:%s;resp:%s\n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);

            }
        }catch(IOException e) {
            e.printStackTrace();
        } finally {
            //这个关闭socket
            clientSocket.close();

        }
    }

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

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

部分代码说明：

为什么使用线程池？

        为了实现一个服务器能够并发响应多个客户端的请求，这里引入多线程的方法：

        1，因为listen()监听函数过后，服务器的ip与端口就会暴露在网络中，网络中连接的各个客户端就可以连接该服务器，而所有的连接请求都会存储在监听文件描述符对应的读缓冲区中，每执行一次accept，就会从该监听文件描述符对应的读缓冲区中读取一个连接，因此，如果是多线程服务器，应该在主线程中将accept函数包含在一个while(true)循环中，让主线程不断从该缓冲区中接收连接。
        2，当accept函数执行完以后，就要有对应的子线程处理accept函数返回的客户端，因此，在while循环内部，每当执行完accept成功以后，就创建一个子线程，让该线程去处理该客户端。子线程内部的流程就是与客户端互相交流的一些代码。

为什么关闭socket

socket也是一个文件，一个进程能够同时打开的文件个数有上限（PCB文件描述符表是有限的），listenSocket对象在TCP服务器程序中，只有一个唯一的对象，一般不会把文件描述符表占满（随着进程的结束，自动释放）。而clientSocket是在死循环里面的，每次来一个客户端，建立连接，都要分配一个，这个对象就会被反复创建按销毁实例，每创建一个，都要销毁一个文件描述符，因此需要把不再使用的clientSocket及时释放掉

2.建立客户端

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对象来建立连接
    private Socket socket = null;

    public TcpEchoClient(String serverIP,int serverPort) throws IOException {
        //和服务器建立连接，就需要知道服务器在哪儿了
        //这里和UDP客户端差别比较大
        socket = new Socket(serverIP,serverPort);
    }
    public void start() {
        Scanner sc = new Scanner(System.in);
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()) {
            while (true) {
                //1、从控制台读取数据，构成一个请求
                System.out.println("->");
                String request = sc.next();
                //2、发送请求给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                //这个flush不要忘记,否则可能导致请求没有真发出去
                printWriter.flush();
                //3、从服务器读取响应
                Scanner respScanner = new Scanner(inputStream);
                String response = respScanner.next();
                //4、把响应显示到界面上
                System.out.println(response);

            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

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