Java 网络编程基础 - TCP 与 UDP

作者: 千反田爱瑠爱好者 | 来源:发表于2019-03-04 21:05 被阅读0次

IO
Java基础09网络编程
Java 网络编程基础 - TCP 与 UDP
IO
socket通讯编程
TCP
2018-09-12网络基础
第78节:Java中的网络编程(上)
iOS之网络编程(二：Scoket)
JAVA编程学习笔记，网络编程基础TCP与UDP

Socket（套接字）网络编程是在网络中实现两个进程间通信的一种方式，其中由 ip 和端口组成 Socket 的作用就是唯一标识网络中端点，以实现端与端之间的通信。其中最常用的传输层通信协议包括 TCP 和 UDP，与具体语言无关。很多语言都提供了基于 TCP 和 UDP 的 Socket API，本文使用 Java 实现基于 Socket 的 C/S 通信模型。

TCP

通过建立连接实现端到端的通信，一对基于 TCP 通信的 Socket 由客户端 ip、客户端端口、服务端 ip、服务端端口描述；
Java 的 io 包和 net 包分别提供了输入输出流和套接字相关的 API，基于这些 API 可以轻易构建 TCP 服务端和客户端。

Server.java

package tcp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * TCP 服务端类
 *
 * @author ywh
 * @since 3/4/2019
 */
public class Server {

    /** 服务端端口 */
    private final static int SERVER_PORT = 5_000;

    /** 客户端请求处理类 */
    private static class RequestHandler extends Thread {

        /** 每个客户端请求处理线程对应一个 socket */
        private Socket socket;

        /** 请求处理标记，默认为 true，false 表示结束处理 */
        private boolean flag = true;

        /** 结束标记 */
        private static final String END_TAG = "bye";

        RequestHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            super.run();

            // 打印客户端的 ip 和端口
            System.out.println(String.format("新的客户端接入：%s:%d", socket.getInetAddress(), socket.getPort()));

            try {

                // 发送到客户端：打印流
                PrintStream output = new PrintStream(socket.getOutputStream());

                // 从客户端接收：输入流缓冲
                BufferedReader input = new BufferedReader(
                    new InputStreamReader(socket.getInputStream())
                );

                // 循环处理客户端消息，直到接收到结束标记
                while (flag) {
                    // 阻塞，等待客户端消息
                    String msg = input.readLine();
                    if (END_TAG.equalsIgnoreCase(msg)) {
                        flag = false;
                    }
                    System.out.println(String.format("接收到客户端 [%s:%d] 消息：%s", socket.getInetAddress(), socket.getPort(), msg));
                    output.println("返回消息长度：" + msg.length());
                }

                // 资源释放
                input.close();
                output.close();

            } catch (IOException ex) {
                ex.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }

            System.out.println(String.format("客户端 [%s:%d] 已经断开连接", socket.getInetAddress(), socket.getPort()));
        }
    }

    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(SERVER_PORT);
        System.out.println(String.format("服务端 [%s:%d] 启动...", server.getInetAddress(), server.getLocalPort()));

        while (true) {
            // 阻塞，等待客户端接入
            Socket client = server.accept();

            // 创建线程处理接入的客户端 Socket（不建议手动创建线程执行，而应使用线程池）
            RequestHandler requestHandler = new RequestHandler(client);
            requestHandler.start();
        }
    }
}

Client.java

package tcp;

import java.io.*;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
 * TCP 客户端
 *
 * @author ywh
 * @since 3/4/2019
 */
public class Client {

    /** 服务端端口 */
    private final static int SERVER_PORT = 5_000;

    /** 连接超时时间 */
    private final static int TIMEOUT = 3_000;

    /** 结束标记 */
    private static final String END_TAG = "bye";

    /**
     * 连接服务端后发送数据
     *
     * @param client
     * @throws IOException
     */
    private static void process(Socket client) throws IOException {

        // 从标准输入流接收数据
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // 发送到服务端：发送从 reader 接收的数据
        PrintStream output = new PrintStream(client.getOutputStream());

        // 从服务端接收
        BufferedReader input = new BufferedReader(
            new InputStreamReader(client.getInputStream())
        );

        boolean flag = true;
        while (flag) {

            // 从标准输入流读入一行，发送到服务端
            System.out.print("发送到服务端：");
            String msg = reader.readLine();
            output.println(msg);

            // 从服务端接收（阻塞）
            String response = input.readLine();

            if (END_TAG.equalsIgnoreCase(msg)) {
                flag = false;
            }
            System.out.println(response);
        }

        // 资源释放
        input.close();
        output.close();
    }

    public static void main(String[] args) throws IOException {

        // 创建客户端 Socket，设置超时时间、连接的服务端 ip 和端口
        Socket client = new Socket();
        client.setSoTimeout(3000);
        client.connect(
            new InetSocketAddress(Inet4Address.getLocalHost(), SERVER_PORT), 3000
        );
        System.out.println(
            String.format("客户端 [%s:%d] 连接到服务端 [%s:%d] ",
                client.getLocalAddress(), client.getLocalPort(),
                client.getInetAddress(), client.getPort()
            )
        );

        try {
            process(client);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        client.close();
        System.out.println(String.format("客户端 [%s:%d] 已断开连接", client.getLocalAddress(), client.getLocalPort()));
    }
}

服务端进程需要指定一个端口创建 ServerSocket 用于监听来自客户端的接入请求（此时在循环中阻塞），每有新的客户端接入即创建一个处理请求的线程（每个线程对应一个客户端 Socket）；
请求处理线程启动后，创建输入和输出流，在循环中阻塞等待客户端消息和返回消息给客户端，直到接收到结束标记才退出循环、释放资源；
客户端进程创建 Socket 的同时需要指定接入服务端的 ip 和端口（InetSocketAddress）、连接超时时间（而自身的端口则随机分配）；
成功接入服务端后，消息交互与服务端类似（阻塞等待接收消息并打印、发送结束标记后断开连接和释放资源）；
分别执行 Server.java 和 Client.java，输出结果：

Client

Server

UDP

区别于 TCP，UDP 没有建立连接的过程，而且任何一端都可以作为消息的发送者和接收者，Socket 由源端口和目的端口描述；根据接收者的数量，通信方式还可以分为单播、广播和组播；
UDP 通信不区分服务端与客户端，但在示例中为了方便标识通信的两端，还是定义为 Server（接收消息、返回特定格式的响应报文）和 Client（搜索并发送消息给网络中的 Server）。

Server.java

package udp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.UUID;

/**
 * UDP 消息服务端类
 * 根据接收的消息提供服务（提供的服务为返回消息长度）
 *
 * @author ywh
 * @since 3/4/2019
 */
public class Server {

    /** 服务端端端口 */
    private final static int SERVER_PORT = 5_000;

    private static final String EXIT_CMD = "exit";

    private static class Worker extends Thread {

        /** 消息提供者唯一标识 */
        private final String id;

        /** 每个消息提供者对应一个 Socket */
        private DatagramSocket datagramSocket = null;

        /** 请求处理标记，默认为 true，false 表示结束处理 */
        private boolean flag = true;

        public Worker() {
            super();
            this.id = UUID.randomUUID().toString();
        }

        /**
         * 处理接收到的消息，返回消息长度到指定的 ip 和端口
         */
        @Override
        public void run() {

            super.run();
            System.out.println("消息接收端启动...");

            try {
                datagramSocket = new DatagramSocket(SERVER_PORT);
                while(flag) {

                    // 构建 DatagramPacket 缓冲，用于存放从 Searcher 接收的消息
                    final  byte[] buffer = new byte[1024];
                    DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
                    datagramSocket.receive(receivePacket);
                    String[] data = new String(receivePacket.getData()).split("&");

                    // 从接收消息解析出响应的目标端口，默认格式为：port&id&msg
                    int responsePort = Integer.parseInt(data[0]);
                    String clientId = data[1];
                    String msg = data[2].trim();

                    System.out.println(
                        String.format(
                            "从 (%s)[%s:%d] 接收到消息：%s",
                            clientId,
                            receivePacket.getAddress().getHostAddress(),
                            receivePacket.getPort(),
                            msg
                        )
                    );

                    byte[] responseData = String.format(
                        "%d&%s&消息长度：%d", datagramSocket.getPort(), this.id, msg.length()
                    ).getBytes();

                    DatagramPacket responsePacket = new DatagramPacket(
                        responseData, responseData.length, receivePacket.getAddress(), responsePort
                    );

                    datagramSocket.send(responsePacket);
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            } finally {
                if (datagramSocket != null) {
                    datagramSocket.close();
                    datagramSocket = null;
                }
            }
        }

        public void exit() {
            flag = false;
        }
    }

    public static void main(String[] args) throws IOException {
        Worker worker = new Worker();
        worker.start();
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while(!EXIT_CMD.equalsIgnoreCase(reader.readLine())) {}
        worker.exit();
    }
}

Client.java

package udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * UDP 消息客户类，
 * 模拟服务请求方，自动搜索消息接收者
 *
 * @author ywh
 * @since 3/4/2019
 */
public class Client {

    /** 服务端端端口 */
    private final static int SERVER_PORT = 5_000;

    /** 监听端口 */
    private static final int LISTEN_PORT = 30_000;

    /**
     * 服务端类
     */
    private static class Server {
        final int port;

        final String ip;

        final String id;

        private Server(String ip, int port, String id) {
            this.port = port;
            this.ip = ip;
            this.id = id;
        }

        @Override
        public String toString() {
            return "Server{" +
                "port=" + port +
                ", ip='" + ip + '\'' +
                ", id='" + id + '\'' +
                '}';
        }
    }

    private static class Worker extends Thread {

        private final int listenPort = LISTEN_PORT;

        private final List<Server> serverList = new ArrayList<>();

        private boolean flag = true;

        private DatagramSocket datagramSocket = null;

        public Worker() {
            super();
        }

        @Override
        public void run() {
            super.run();

            try {

                // 监听消息回复端口
                datagramSocket = new DatagramSocket(listenPort);

                while (flag) {
                    final byte[] buffer = new byte[1024];
                    DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
                    datagramSocket.receive(receivePacket);
                    String[] data = new String(receivePacket.getData()).split("&");

                    // 从接收消息解析出响应的目标端口，默认格式为：port&id&msg
                    int responsePort = Integer.parseInt(data[0]);
                    String serverId = data[1];
                    String msg = data[2];
                    String serverIp = receivePacket.getAddress().getHostAddress();
                    int serverPort = receivePacket.getPort();

                    System.out.println(
                        String.format(
                            "从 (%s)[%s:%d] 接收到处理结果：%s", serverId, serverIp, serverPort, msg
                        )
                    );

                    // 添加到设备列表
                    serverList.add(new Server(serverIp, serverPort, serverId));
                }

            } catch (IOException ex) {
                ex.printStackTrace();
            } finally {
                if (datagramSocket != null) {
                    datagramSocket.close();
                    datagramSocket = null;
                }
            }
        }

        List<Server> exit() {
            flag = false;
            return serverList;
        }
    }

    /**
     * 监听广播消息
     *
     * @return
     * @throws InterruptedException
     */
    private static Worker listen() throws InterruptedException {
        Worker worker = new Worker();
        worker.start();
        return worker;
    }

    /**
     * 发送广播消息
     *
     * @throws IOException
     */
    private static void send() throws IOException {
        System.out.println("客户端发送广播消息...");

        DatagramSocket datagramSocket = new DatagramSocket();

        byte[] requestData = String.format("%d&%s&%s", LISTEN_PORT, UUID.randomUUID().toString(), "求本消息的长度").getBytes();
        DatagramPacket requestPacket = new DatagramPacket(requestData, requestData.length);

        requestPacket.setAddress(InetAddress.getByName("255.255.255.255"));
        requestPacket.setPort(SERVER_PORT);

        datagramSocket.send(requestPacket);
        datagramSocket.close();

        System.out.println("客户端发送广播消息结束...");
    }


    public static void main(String[] args) throws IOException, InterruptedException{
        System.out.println("客户端启动...");
        Worker worker = listen();

        // 发送消息请求服务
        send();

        // 输入任意内容即退出
        System.in.read();

        List<Server> serverList = worker.exit();
        for(Server server: serverList) {
            System.out.println("Server: " + server.toString());
        }
    }
}

虽然前面已经提到 UDP 通信不区分客户端和服务端，但在本场景中 Server 在网络中可建立多个，其作用都是接收来自来自 Client 的广播消息、返回该消息的长度；
区别于 TCP 直接通过 Socket 的输入输出流收发消息，UDP 的消息都是以 byte 数组的形式封装在 DatagramPacket 中，其中 DatagramPacket 携带着 ip 和端口等信息；
Client 发送广播报文到网络中所有主机的指定端口，并在接收到响应的同时记录可为其提供服务的主机以供最终输出：

requestPacket.setAddress(InetAddress.getByName("255.255.255.255"));
requestPacket.setPort(SERVER_PORT);

客户端在向服务端发送消息的同时监听一个回传端口，并在消息携带上该端口（格式为 port&id&msg），使得服务端可以把响应消息发送到客户端的指定端口；
分别执行 Server.java 和 Client.java，输出结果：

Server

Client

IO
java网络编程阻塞IO NIO 1. java网络编程基础知识1.ip地址和端口号2.tcp/udp协议3....
Java基础09网络编程
Java 基础08GUI 熟练掌握什么是网络编程，网络编程的三要素，Socket原理机制、UDP传输、TCP传输等...
Java 网络编程基础 - TCP 与 UDP
Socket（套接字）网络编程是在网络中实现两个进程间通信的一种方式，其中由 ip 和端口组成 Socket 的作...
IO
一.java网络编程 1.基础知识 1)ip地址和端口号 2）tcp/udp协议 3）URL 4）InetAddr...
socket通讯编程
这一块属于网络编程，主要是学习TCP/IP四层的网络体系结构，学习TCP编程和UDP编程。 java.net中一...
TCP
聊聊iOS中网络编程长连接的那些事网络编程基础知识：简述传输层协议TCP和UDP的区别总结：TCP协议在传送数...
2018-09-12网络基础
网络基础 OSI模型协议数据解封数据封装 TCP与UDP协议 URL资源定位符 01-socket编程 im...
第78节:Java中的网络编程(上)
第78节:Java中的网络编程(上) 前言网络编程涉及ip,端口,协议,tcp和udp的了解,和对socket通...
iOS之网络编程(二：Scoket)
上一篇写了iOS之网络编程（一：基础HTTP/HTTPS与TCP/UDP），这篇就重点说说Socket。注：网上关...
JAVA编程学习笔记，网络编程基础TCP与UDP
Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和...