JavaEE-网络编程套接字（UDP/TCP）

news/2024/5/18 15:29:38 标签: 网络, java-ee, udp

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

下面写一个简单的UDP客户端服务器流程
思路：
对于服务器端：读取请求，并解析–> 根据解析出的请求，做出响应(这里是一个回显，)–>把响应写回客户端
对于客户端：从控制台读取用户输入的内容–>从控制台读取用户输入的内容–>从控制台读取用户输入的内容–>将其显示在屏幕上
全部代码如下：
服务器端：

package network;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
//UDP的回显服务器   客户端发出的请求是啥，服务器返回的响应就是啥
public class UdpEchoServer {
    private DatagramSocket socket=null;

    //  指定服务器的port
    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. 把响应写回客户端  此时需要告诉网卡，要发的内容是啥，发给谁
            //构造一个发送数据包
            DatagramPacket responsePacket=new DatagramPacket(response.getBytes(),response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //记录日志
            System.out.printf("[%s:%d]  req: %s, resp: %s\n",requestPacket.getAddress().toString(),requestPacket.getPort(),
                    request,response);
        }
    }
    //这里是一个回显，只需要返回这个字符串
    public String process(String request){
        return request;
    }

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

客户端：

package network;

import java.io.IOException;
import java.net.*;
import java.util.Scanner;
public class UdpEchoClient {
    //由于客户端的port是自动分配的，所以这里不会像服务器那样配置port
    //但是，客户端需要向服务器发送请求，所以，这里我们需要知道服务器的ip和port
    private DatagramSocket socket=null;
    private String serverIp;
    private int serverPort;

    //外部指定服务器的ip和port
    public UdpEchoClient(String ip,int port) throws SocketException {
        this.serverIp=ip;
        this.serverPort=port;
        //客户端的port是自动分配的
        socket=new DatagramSocket();

    }
    // 让这个客户端反复的从控制台读取用户输入的内容. 把这个内容构造成 UDP 请求, 发给服务器. 再读取服务器返回的 UDP 响应
    // 最终再显示在客户端的屏幕上.
    public void  start() throws IOException {
        Scanner scanner=new Scanner(System.in);
        System.out.println("客户端开始启动");
        while(true){
            //1. 从控制台读取用户输入的内容
            System.out.println("->");
            String requset=scanner.next();
            //2.构造请求对象，发送给服务器
            DatagramPacket requsetPacket=new DatagramPacket(requset.getBytes(),requset.getBytes().length,
                    InetAddress.getByName(serverIp),serverPort);
            socket.send(requsetPacket);
            //3.读取服务器的响应，并解析出其内容
            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 udpEchoClient=new UdpEchoClient("127.0.0.1",9090);//127.0.0.1 本机ip
        udpEchoClient.start();

    }
}

运行结果如下
在这里插入图片描述
对上述过程中的一些谈论和分析：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

多个客户端向一个服务器发送请求
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

下面写一个简单的翻译服务器
在这里插入图片描述

重写的服务器端的代码如下：

package network;

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

public class UdpDictServer extends UdpEchoServer{
    //使用HashMap保存中英文翻译的键值对
    private Map<String,String> dict =new HashMap<>();
    //实现父类的构造方法
    public UdpDictServer(int port) throws SocketException {
        super(port);

        //一些原始的键值对
        dict.put("cat","猫");
        dict.put("dog","狗");
        dict.put("people","人");
    }
    //与原始的UdpEachServer相比，这里对于请求的处理过程是不一样的
    //重写process方法

    @Override
    public String process(String request) {
        //找到对应的翻译，并返回
        //getOrDefault方法，找到key所对应的value值，如果没有找到，则返回defaultValue（即第二个参数）
        return dict.getOrDefault(request,"该词没有查询到");
    }

    public static void main(String[] args) throws IOException {
        UdpDictServer server=new UdpDictServer(9090);
        // start 不需要重新再写一遍了. 直接就复用了之前的 start
        server.start();
    }
}

执行结果如下：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

下面写一个基于TCP 的回显流程

思路：
服务器端：先从队列中拿到一个“连接”–> 读取请求并解析–>根据请求计算响应–>把响应写回给客户端
客户端：从控制台输入字符串–>把请求发送给服务器–>从服务器读取响应.–>把响应打印出来

全部代码如下：
服务器端代码：

package network;

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;

//基于TCP的回显服务器
public class TcpEachServer {
    private ServerSocket serverSocket=null;

    //绑定端口号
    public  TcpEachServer(int port) throws IOException {
        serverSocket=new ServerSocket(port);
    }

    //启动服务器
    public  void  start() throws IOException {
        System.out.println("服务器开始启动");
        while(true){
            //从管理连接的队列中拿出一个“连接”出来
            Socket clientSocket=serverSocket.accept();
            //处理这个连接内的请求
            processConnection(clientSocket);
        }
    }
    //这个方法用来处理连接中的逻辑
    private void processConnection(Socket clientSocket) throws IOException {
        //日志
        System.out.printf("[%s:%d] 客户端上线\n",clientSocket.getInetAddress().toString(),
                clientSocket.getPort());
        //下面开始读取请求，计算响应，返回响应  三步曲
        //Socket对象内部包含两种字节流对象InputStream和OutputStream，可以先把这两个对象流获
        // 取到，方便后续处理过程种的读写工作
        try(InputStream inputStream=clientSocket.getInputStream();
            OutputStream outputStream=clientSocket.getOutputStream()){
            //不同于UDP协议中的无连接，在客户端的一次连接过程中，可能涉及多次请求/响应过程
            //因此。这里使用一个while循环，直到该连接中的所有请求处理完毕
            while(true){
                //1，读取请求并解析
                Scanner scanner=new Scanner(inputStream);
                //hasNext的作用是，检测输入流中是否有结束输入的控制符，比如0x1A(EOF,Ctrl-Z)
                //用于检测一个连接是否结束
                if(!scanner.hasNext()){
                    //一个连接处理完毕
                    System.out.printf("[%s:%d] 客户端本次连接处理完毕，下线！\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                // 这个代码暗含一个约定, 客户端发过来的请求, 得是文本数据, 同时, 还得带有空白符作为分割. (比如换行这种)
                //next()：当输入到空白符结束
                String request=scanner.next();
                //2.根据请求计算响应
               String response=process(request);
               //3. 把响应写回客户端，把OutputStream用PrintWriter(此处的PrintWriter相当于Scanner)包裹一下，便于发送数据
                //将outputStream和PrintWriter关联起来
                PrintWriter writer=new PrintWriter(outputStream);
                //使用 PrintWriter 的 println 方法,打印到输出流中 把响应返回给客户端.
                //此处用 println, 而不是 print 就是为了在结尾加上 \n . 方便客户端读取响应, 使用 scanner.next 读取.
                writer.println(response);
                //这里还需要加一个 "刷新缓冲区" 操作.将缓冲区的数据强制输出，用于清空缓冲区
                writer.flush();

                //日志 记录当前的请求和响应
                System.out.printf("[%s:%d]  req: %s,resp: %s\n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
            }
        }
    }

    //回显，只需要再返回这个字符串
    public String process(String requset){
        return requset;
    }
    public static void main(String[] args) throws IOException {
        TcpEachServer tcpEachServer=new TcpEachServer(9090);
        tcpEachServer.start();
    }
}

客户端代码：

package network;

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 {
    private Socket socket=null;

    //服务器端的ip和port
    public  TcpEchoClient(String serverIp,int serverPort) throws IOException {
        //这个new的动作完成后，完成了tcp的建立
        socket=new Socket(serverIp,serverPort);
    }

    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner scannerConsole=new Scanner(System.in);
        //Socket对象内部包含两种字节流对象InputStream和OutputStream，可以先把这两个对象流获
        //   取到，方便后续处理过程种的读写工作
        try(InputStream inputStream=socket.getInputStream();
            OutputStream outputStream=socket.getOutputStream()){
            while(true){
                //1.从控制台输入字符串
                System.out.println("-->");
                String request=scannerConsole.next();
                //2.把请求发送给服务器  需要对request进行包装，使用PrintWriter
                PrintWriter printWriter=new PrintWriter(outputStream);
                //使用 println 带上换行. 后续服务器读取请求, 就可以使用 scanner.next 来获取了
                printWriter.println(request);//发送请求
                printWriter.flush();
                //3.从服务器中接收响应
                Scanner scannerNetwork=new Scanner(inputStream);
                String response=scannerNetwork.next();
                //4.把响应打印出来
                System.out.println(response);
            }
        }
    }
    public static void main(String[] args) throws IOException {
        TcpEchoClient tcpEchoClient=new TcpEchoClient("127.0.0.1",9090);
        tcpEchoClient.start();
    }
}

当开多个线程时，发现只有一个线程在被处理，其它线程都在等待，
在这里插入图片描述
当被处理的线程下线后，其他线程的逻辑才开始被处理
在这里插入图片描述

在这里插入图片描述
原因在于 Socket clientSocket = serverSocket.accept();和processConnection(clientSocket);都是主线程进行处理的且在同一次循环体中，只有一个clinetSocket连接被处理完后，才会去队列中accept下一个连接，为此，这里我们可以采用多线程进行处理。
在这里插入图片描述

修改为多线程后，可以看到 有多个客户端可以访问服务器
在这里插入图片描述

在这里插入图片描述
考虑到一个现实的情况，许多客户端需要频繁的访问服务器，那就是需要频繁的断开/连接，我们这里可以使用线程池
在这里插入图片描述
在这里插入图片描述
同样也可以实现多个客户端同时访问服务器。

最终的服务器的代码如下：

package network;

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的回显服务器
public class TcpEachServer {
    private ServerSocket serverSocket=null;
    //创建一个非固定数目的线程池
    private ExecutorService service= Executors.newCachedThreadPool();

    //绑定端口号
    public  TcpEachServer(int port) throws IOException {
        serverSocket=new ServerSocket(port);
    }

    //启动服务器
    public  void  start() throws IOException {
        System.out.println("服务器开始启动");
        while(true){
            //从管理连接的队列中拿出一个“连接”出来
            Socket clientSocket=serverSocket.accept();
            //处理这个连接内的请求
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
/*            Thread t=new Thread(() ->{
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            t.start();*/
        }
    }
    //这个方法用来处理连接中的逻辑
    private void processConnection(Socket clientSocket) throws IOException {
        //日志
        System.out.printf("[%s:%d] 客户端上线\n",clientSocket.getInetAddress().toString(),
                clientSocket.getPort());
        //下面开始读取请求，计算响应，返回响应  三步曲
        //Socket对象内部包含两种字节流对象InputStream和OutputStream，可以先把这两个对象流获
        // 取到，方便后续处理过程种的读写工作
        try(InputStream inputStream=clientSocket.getInputStream();
            OutputStream outputStream=clientSocket.getOutputStream()){
            //不同于UDP协议中的无连接，在客户端的一次连接过程中，可能涉及多次请求/响应过程
            //因此。这里使用一个while循环，直到该连接中的所有请求处理完毕
            while(true){
                //1，读取请求并解析
                Scanner scanner=new Scanner(inputStream);
                //hasNext的作用是，检测输入流中是否有结束输入的控制符，比如0x1A(EOF,Ctrl-Z)
                //用于检测一个连接是否结束
                if(!scanner.hasNext()){
                    //一个连接处理完毕
                    System.out.printf("[%s:%d] 客户端本次连接处理完毕，下线！\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                // 这个代码暗含一个约定, 客户端发过来的请求, 得是文本数据, 同时, 还得带有空白符作为分割. (比如换行这种)
                //next()：当输入到空白符结束
                String request=scanner.next();
                //2.根据请求计算响应
               String response=process(request);
               //3. 把响应写回客户端，把OutputStream用PrintWriter(此处的PrintWriter相当于Scanner)包裹一下，便于发送数据
                //将outputStream和PrintWriter关联起来
                PrintWriter writer=new PrintWriter(outputStream);
                //使用 PrintWriter 的 println 方法,打印到输出流中 把响应返回给客户端.
                //此处用 println, 而不是 print 就是为了在结尾加上 \n . 方便客户端读取响应, 使用 scanner.next 读取.
                writer.println(response);
                //这里还需要加一个 "刷新缓冲区" 操作.将缓冲区的数据强制输出，用于清空缓冲区
                writer.flush();

                //日志 记录当前的请求和响应
                System.out.printf("[%s:%d]  req: %s,resp: %s\n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
            }
        } finally {
            clientSocket.close();
        }
    }

    //回显，只需要再返回这个字符串
    public String process(String requset){
        return requset;
    }
    public static void main(String[] args) throws IOException {
        TcpEachServer tcpEachServer=new TcpEachServer(9090);
        tcpEachServer.start();
    }
}

上述过程中的一些思路

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述


http://www.niftyadmin.cn/n/5069013.html

相关文章

配置文件生成器-秒杀SSM的xml整合

配置文件生成器-秒杀SSM的xml整合

配置文件生成器-秒杀SSM的xml整合 思路&#xff1a; 通过简单的配置&#xff0c;直接生成对应配置文件。 maven坐标 <dependencies><!-- 配置文件生成 --><dependency><groupId>org.freemarker</groupId><artifactId>freemarker<…
阅读更多...
golang gin——controller 模型绑定与参数校验

golang gin——controller 模型绑定与参数校验

controller 模型绑定与参数校验 gin框架提供了多种方法可以将请求体的内容绑定到对应struct上&#xff0c;并且提供了一些预置的参数校验 绑定方法 根据数据源和类型的不同&#xff0c;gin提供了不同的绑定方法 Bind, shouldBind: 从form表单中去绑定对象BindJSON, shouldB…
阅读更多...
Python数据攻略-数据连续变量常用10种处理方法

Python数据攻略-数据连续变量常用10种处理方法

今天将探讨一个非常重要的主题：如何处理连续变量。在数据分析、机器学习和科学研究中，连续变量是一种常见的数据类型。但连续变量通常需要经过一定的处理，才能更好地用于模型训练或分析。 文章的目的是展示如何使用Python进行这些处理，使数据更适合分析或机器学习模型。这…
阅读更多...
动态内存函数笔试题

动态内存函数笔试题

题目四&#xff1a; 修改后 #include<string.h> void test() {char* str (char*)malloc(100);strcpy(str, "hello");if (str ! NULL){strcpy(str, "world");printf(str);}free(str);str NULL; } int main() {test();return 0; } 源代码 #inclu…
阅读更多...
对深度学习的批评

对深度学习的批评

对深度学习的主要批评是许多方法缺乏理论支撑。 大多数深度结构仅仅是梯度下降的某些变式。 尽管梯度下降法已经被充分地研究&#xff0c;但理论涉及的其他算法&#xff0c;例如对比分歧算法&#xff0c;并没有获得充分的研究&#xff0c;其收敛性等问题仍不明确。 深度学习…
阅读更多...
洛谷题解 | P9712 「QFOI R1」贴贴

洛谷题解 | P9712 「QFOI R1」贴贴

目录 题目描述输入格式输出格式样例 #1样例输入 #1样例输出 #1 样例 #2样例输入 #2样例输出 #2 样例 #3样例输入 #3样例输出 #3 提示题目思路AC代码 题目描述 小 R 是一个可爱的女孩子&#xff0c;她希望通过给洛谷题目写题解的方式跟出题人贴贴。 她发现&#xff0c;如果从题…
阅读更多...
第八章 排序 五、快速排序

第八章 排序 五、快速排序

目录 一、算法思想 二、例子 三、代码实现 四、验证 五、算法效率分析 1、时间复杂度 ​编辑 2、空间复杂度 3、小结 4、优化思路 5、稳定性 六、总结 一、算法思想 首先&#xff0c;选取一个数作为序列的基准数&#xff0c;分别定义序列的第一个数和最后一个数为l…
阅读更多...
php实战案例记录(16)php://input输入流

php实战案例记录(16)php://input输入流

php://input是PHP中的一个特殊的输入流&#xff0c;它允许访问请求的原始数据。它主要用于处理非表单的POST请求&#xff0c;例如当请求的内容类型为application/json或application/xml时。使用php://input可以获取到POST请求中的原始数据&#xff0c;无论数据是什么格式。使用…
阅读更多...
最新文章

Copyright @ 2022~2023