【JavaWeb】网络编程概念 + Socket套接字 + UDP/TCP编程

最新推荐文章于 2024-07-29 22:57:36 发布

p_fly

最新推荐文章于 2024-07-29 22:57:36 发布

阅读量897

点赞数 1

分类专栏： JavaWeb 文章标签： tcp/ip udp 网络 tcp java

本文链接：https://blog.csdn.net/p_fly/article/details/128899833

版权

JavaWeb 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

网络编程基础概念

网络编程，指网络上的主机，通过 不同的进程 ，以编程的方式实现 网络通信（网络数据传输） 。只需要满足进程不同，同一个主机的不同进程相互之间进行网络通信也是网络编程。

下面介绍一些网络编程的常用的基础概念。

发送端与接受端

发送端：发送数据的进程。发送端主机：该进程所在的主机(源主机)。

接收端：接受数据的进程。接受端主机：该进程所在的主机(目的主机)。

发送端和接收端只是相对的。

请求与响应

请求：发送端到接受端所发出的要求。

响应：接收端到发送端所回复的动作。

一般来说，一次完整的网络通信既要有请求也要有响应。

客户端与服务器

客户端：发送请求并获取服务的一端。

服务器：接受请求并提供服务的一段。

常见的客户端服务器模型

如下图

Socket套接字

Socket套接字是操作系统提供用于网络编程的技术，是基于TCP/IP协议的网络通信的基本单元。

简单的理解为，在下图中的分层里，是传输层协议和应用层协议之间的API。

传输层中最核心的两个协议就是TCP和UDP。因此Socket也提供了两种风格的API。还有一种unix，现在基本不使用了。

在Java中，JVM把这个Socket又封装了一下，以供我们使用，名字还是Socket。

回显(echo)程序

回显服务器：客户端发过来什么，原封不动的在发回去。

UDP版的回显程序

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

连接：客户端和服务器之间进行通信之前先要相互联系上。

可靠传输：下篇文章详细讲UDP协议是会提到。

面向数据报：所传输的数据都是以“数据报”为单位的。

全双工：一个通信通道，同一时间内，既可以发送也可以接收数据。(因为通信通道里有8条网线)

半双工：一个通信通道，同一时间内，只能发送或接收数据。

在写程序之前，先画出一个图有更全面的认识。

服务器代码

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

// UDP版本的回响服务器
class UdpEchoServe {

    // 通过DatagramSocket实例化的对象serverSocket来操作网卡
    // 操作系统把这个对象抽象成文件来管理的
    private DatagramSocket serverSocket = null;

    // 传输信息的单位不是简单的字节，而是包装成了DatagramPacket这个类来使用
    // 这里第一个参数是一个返回型参数，客户端传过来的信息可以存到这里面
    // 第二个参数是最多可以放多少空间来存信息
    DatagramPacket serverPacket = new DatagramPacket(new byte[8192], 8000);

    // 构造方法
    // 建议服务器手动绑定端口号(1024~65535之间任意选择一个整数)
    // 如果系统自动分配的话，客户端就不知道服务器是哪个端口了，就无法通信了
    // 服务器的端口我们还是可以控制查询的，主动权在我们手中，客户端则是未知的
    // 端口号可以定位进程本质上就是serverSocket对象绑定了端口号
    public UdpEchoServe(int port) throws SocketException {
        this.serverSocket = new DatagramSocket(port);
    }

    // 通过这个方法让服务器启动
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // 如果没有收到请求，就会阻塞等待
            // 请求填充到reservePacket中的数组里了
            serverSocket.receive(serverPacket);

            // 使用work方法代表处理请求
            // 先把请求变成字符串，后续更加方便操作它
            String workBeforeString = new String(serverPacket.getData(), 0, serverPacket.getLength());
            String workAfterString = work(workBeforeString);

            // 请求已经处理完毕，需要返回给客户端
            // 把处理结果打包成DatagramPacket类型来传输            这里不能直接用字符串的长度，而是要转成字节后的长度
            DatagramPacket retPacket = new DatagramPacket(workAfterString.getBytes(), workAfterString.getBytes().length,
                    // 同时还要从serverPacket中拿到客户端的地址(端口号和IP)
                    serverPacket.getSocketAddress());

            // 打包完成，返回数据
            serverSocket.send(retPacket);

            // 在服务器这里打印一下请求响应的中间结果
            System.out.printf("[请求方的IP：%s | 请求方的端口号： %d] = 请求：%s | 处理结果：%s\n",
                    serverPacket.getAddress().toString(), serverPacket.getPort(), workBeforeString, workAfterString);
        }
    }

    protected String work(String str) {
        // 由于是回显服务器，处理的结果就直接返回原字符串即可
        return str;
    }

}

public class UdpServer {

    public static void main(String[] args) throws IOException {
        // 指定端口号
        UdpEchoServe udpEchoServe = new UdpEchoServe(9999);
        udpEchoServe.start();

    }

}

客户端代码

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

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

    // 和客户端的一样，也是要通过这个类实例出来的对象来操作网卡
    private DatagramSocket clientSocket = null;
    // 同时还需要设定服务器的IP和端口，这样才能把消息发给客户端
    // 服务器则不用设定，因为服务器作为被动的接受数据的一方，这数据中就包含了客户端的IP和端口
    private String serverIp = null;
    private int serverPort = -1;

    // 构造方法
    // 在构造方法中设定客户端端口、服务器IP和服务器端口
    public UdpEchoClient(String serverIp, int serverPort) throws SocketException {
        // 建议随机分配客户端的端口
        // 因为随机分配的端口是空闲的端口，如果自己指定，则不一定是
        this.clientSocket = new DatagramSocket();
        this.serverIp = serverIp;
        this.serverPort = serverPort;
    }

    // 通过start方法启动客户端
    public void start() throws IOException {
        System.out.println("客户端启动！");
        while (true) {
            System.out.println("请输入：");
            Scanner scanner = new Scanner(System.in);

            // 输入数据
            String data = scanner.next();
            if (data.equals("exit")) {
                clientSocket.close();
                break;
            }

            // 收到数据后打包数据  同样是以DatagramPacket为单位
            // 这里把字符串转成字节，还有字节的实际个数也要传过去
            // InetAddress这个类中的getByName方法可以把"127.0.0.1"这个字符串转成32位二进制数
            DatagramPacket clientPacket = new DatagramPacket(data.getBytes(), data.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);

            // 发送数据
            clientSocket.send(clientPacket);

            // ... ... 等待服务器处理，然后接收处理后的数据

            // 接收数据
            DatagramPacket backedData = new DatagramPacket(new byte[8192], 8000);
            // 把收到的数据填到数组当中
            clientSocket.receive(backedData);

            // 解析数据 然后使用数据
            work(backedData);
        }

    }

    // 处理返回数据的方法
    private void work(DatagramPacket backedData) {
        String useData = new String(backedData.getData(), 0, backedData.getLength());
        // 解析好之后使用数据
        System.out.println(useData);
    }
}

public class UdpClient {

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

}

结果

如果像多创造一些客户端，在IDEA中可以勾选允许创建多个实例。

TCP版的回显程序

TCP的特点：有链接，可靠传输，面向字节流，全双工。

字节流：和之前的文件读写一样(通过字节流)，所传输的数据都是转换成了字节流。

工作流程如下图

服务器代码

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;

// TCP版本的回显服务器
class TcpEchoServer {

    // 同UDP，这里的类变成了ServerSocket来管理TCP版的服务器
    private ServerSocket serverSocket = null;

    public TcpEchoServer(int port) throws IOException {
        // 手动绑定服务器端口号
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        // 启动服务器
        System.out.println("服务器启动！");

        // 要先和客户端建立连接
        // 通过Socket这个类与客户端建立连接
        // 如果客户端没有连接，accept就会进行阻塞

        // Ⅰ 这里只能处理一个客户端
        // Socket connectionSocket = serverSocket.accept();
        // 具体的连接和收发数据给connectionWork这个方法
        // connectionWork(connectionSocket);

        // Ⅱ 通过多线程可以处理多个客户端——多搞几个连接
//        while (true) {
//            Thread threadConnection = new Thread(() -> {
//                try {
//                    Socket connectionSocket = serverSocket.accept();
//                    connectionWork(connectionSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            threadConnection.start();
//        }

        // Ⅲ 使用线程池
        while (true) {
            ExecutorService threadPoolExecutor = Executors.newCachedThreadPool();
            threadPoolExecutor.submit(()-> {
                try {
                    Socket connectionSocket = serverSocket.accept();
                    connectionWork(connectionSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    // 这里处理一个客户端连接和收发数据
    private void connectionWork(Socket connectionSocket) throws IOException {
        // 能到这里说明客户端已经建立连接了·
        System.out.printf("[IP: %s | 端口号: %d] 客户端上线！\n",
                connectionSocket.getInetAddress().toString(), connectionSocket.getPort());

        try (InputStream inputStream = connectionSocket.getInputStream();
             OutputStream outputStream = connectionSocket.getOutputStream()) {
            // 可能会有很多次的请求，通过循环来一直保持连接(长连接)
            while (true) {
                // 把读进来的请求用scanner装起来，更方便操作
                Scanner scanner = new Scanner(inputStream);

                // 如果请求没了，说明读完了就退出
                if (!scanner.hasNext()) {
                    System.out.printf("[IP: %s | 端口号: %d] 客户端下线！\n",
                            connectionSocket.getInetAddress().toString(), connectionSocket.getPort());
                    break;
                }

                // 把请求从scanner中读出来, 不包括空格 会车符等空白字符串
                String workBeforeString = scanner.next();
                // 放到 work方法中加工
                String workAfterString = work(workBeforeString);

                // 通过OutPutStream返回结果结果
                // 由于OutPutStream中没有可以直接把字符串写进去的方法
                // 这里通过PrintWriter来代替写
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 把处理后的字符串+回车符写进去
                printWriter.println(workAfterString);
                // 在把数据冲刷一下, 确认写进去了
                printWriter.flush();

                System.out.printf("[请求方的IP：%s | 请求方的端口号： %d] = 请求：%s | 处理结果：%s\n",
                        connectionSocket.getInetAddress().toString(), connectionSocket.getPort(), workBeforeString, workAfterString);
            }
        }
        finally {
            // 每一个客户端请求完成后就要关闭请求连接的这个资源, 否则会越来越多
            // 在finally中确保一定会关闭的
            connectionSocket.close();
        }
    }


    private String work(String workBeforeString) {
        return workBeforeString;
    }
}

public class TcpServer {
    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer = new TcpEchoServer(5050);
        tcpEchoServer.start();
    }
}

客户端代码


// TCP版本的回显客户端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

class TcpEchoClient {
    // 通过Socket这个类来连接服务器
    private Socket connectionSocket = null;

    public TcpEchoClient (String serverIP, int serverPort) throws IOException {
        // 这里实例化的时候就与服务器建立连接了
        // 同时Socket的构造方法可以识别"127.0.0.1"这样字符串类型的点分十进制
        connectionSocket = new Socket(serverIP, serverPort);
    }

    public void start() throws IOException {
        System.out.println("客户端启动! ");
        try(InputStream inputStream = connectionSocket.getInputStream();
            OutputStream outputStream = connectionSocket.getOutputStream()) {
            while (true) {
                // 先输入数据
                Scanner scanner = new Scanner(System.in);
                System.out.println("请输入：");
                String data = scanner.next();
                if (data.equals("exit")) {
                    break;
                }
                // 打包数据发给服务器
                // 通过PrintWriter类来包装数据
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 这里还把 \n 写进去了，为了分割数据
                printWriter.println(data);
                // 确保数据发送出去了
                printWriter.flush();

                // ... ...等到客户端处理完成后接收结果
                // 读取客户端的响应
                Scanner result = new Scanner(inputStream);
                String resultString = result.next();

                // 最后打印结果
                System.out.println(resultString);
            }
        }
    }
}

public class TcpClient {

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

        TcpEchoClient tcpEchoClient = new TcpEchoClient("127.0.0.1", 5050);
        tcpEchoClient.start();

    }

}