JavaEE-网络编程

已于 2023-01-29 10:58:09 修改
阅读量414 收藏
点赞数
分类专栏： JavaEE 文章标签： 网络 java-ee udp
于 2023-01-29 09:56:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61341342/article/details/128784037
版权

目录

一、网络编程套接字

网络编程套接字就是操作系统给应用程序提供的一组API(叫做socket API)。

socket 可以视为是应用层和传输层之间的通信桥梁。

传输层的核心协议有两种：TCP和UDP。

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

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

  1. 有连接和无连接
    有连接：像打电话，得先接通，才能交互数据
    无连接：像发微信，不需要接通，直接就能发数据

  2. 可靠传输与不可靠传输
    可靠：传输过程中，发送方知道接收方有没有收到数据
    不可靠：参考无连接，微信直接可以发消息，不知道对方有没有看见这个消息。

  3. 面向字流/数据报
    面向字节流：以字节为单位进行传输，类似于文件操作中的字节流。
    面向数据报：以数据报为单位进行传输，一个数据报会明确大小，一次发送/接收一个完整的数据报，不能是半个数据报。

  4. 全双工/半双工
    全双工：一条链路，双向通信。
    半双工：一条链路，单向通信。

二、UDP Socket

UDP Socket 中主要涉及两个类：DatagramSocket 和 DatagramPacket.

DatagramSocket 的一个对象就对应操作系统中的一个socket文件。

DatagramPacket代表了一个UDP数据报，使用UDP传输数据的基本单位。
在这里插入图片描述

2.1 客户端服务器程序-回显服务(EchoServer)

回显：请求内容是啥，得到的响应就是啥。
在这里插入图片描述
这里在我们的idea下先建立一个包network，在这个包下建立两个类分别是服务器UdpEchoServer和客户端UdpEchoClient。

2.1.1 UdpEchoServer

  1. 进行网络编程，第一步就需要先准备好 socket实例，这是进行网络编程的大前提
private DatagramSocket socket = null;
  1. 此处在构造服务器这边的socket对象的时候，就需要显式的绑定一个端口号
    端口号是用来区分一个应用程序的，主机收到网卡上的数据的时候，这个数据该给哪个程序？
    抛出异常的原因：1.端口号可能已经被占用了。2.每个进程能够打开的文件个数是有限的。
public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
  1. 启动服务器，服务器是被动接收请求的一方，主动发送请求的是客户端，DatagramPacket刚才说过是表示一个UDP数据报，发送一次数据就是发送DatagramPacket，接收一次数据也就是在收一个DatagramPacket。
// 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);

        }
    }

    // 由于是回显服务，响应就和请求一样了
    // 实际上对于一个真实的服务器来说，这个过程是复杂的，为了实现这个过程，可能需要几行甚至几万行
    private String process(String request) {
        return request;
    }
  • 这里requestPacket.getLength（）这个长度不一定是1024，可能此处的UDP数据报最长是1024，实际的数据可能不够1024。
  • 注意这里send方法的参数，也是DatagramPacket，需要把响应数据先构造成一个DatagramPacket再进行发送。
  • response.getByte（）这里的参数也不再是一个空的数组，response是刚才根据请求计算得到的响应。DatagramPacket里面的数据就是String response的数据。
  • requestPacket.getSocketAddress();这个参数的作用就是表示要把数据发给哪个地址+端口。

  • 完整代码：

    package network;

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

@SuppressWarnings({"all"})
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("启动服务器");
        // UDP 不需要建立连接，直接接收从客户端来的数据即可~
        while (true) {
            // 1. 读取客户端发来的请求
            DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
            socket.receive(requestPacket);// 为了接收数据，需要先准备一个空的DatagramPacket对象，由receive来进行填充数据
            // 把 DatagramPacket 解析成一格String
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "utf-8");
            // 2. 根据请求计算响应( 由于是一个回显服务器，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);

        }
    }

    // 由于是回显服务，响应就和请求一样了
    // 实际上对于一个真实的服务器来说，这个过程是复杂的，为了实现这个过程，可能需要几行甚至几万行
    private String process(String request) {
        return request;
    }

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

    在这里插入图片描述

    2.1.2 UdpEchoClient

    在客户端构造 socket 对象的时候，就不再手动指定端口号，使用无参版本的构造方法。
    不指定端口号，是让操作系统自己分配一个空闲的端口号。
    在这里插入图片描述

    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;

@SuppressWarnings({"all"})
public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;

    public UdpEchoClient(String ip, int port) throws SocketException {
        socket = new DatagramSocket();
        serverIp = ip;
        serverPort = port;
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 先从控制台读取一个用户输入的字符串
            System.out.println("-> ");
            String request = scanner.next();
            // 2. 把这个用户输入的内容构造成一格UDP请求，并发送
            //    构造的请求里包含两部分信息：
            //    1) 数据的内容，request 字符串
            //    2） 数据要发送给谁  服务器的IP + 端口
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIp),serverPort);
            socket.send(requestPacket);
            // 3. 从服务器读取响应数据，并解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[1024],1024);
            socket.receive(responsePacket);
            // 4. 把响应结果显示到控制台上。
            String response = new String(responsePacket.getData(),0,responsePacket.getLength(),"UTF-8");
            System.out.printf("req: %s, resp: %s\n",request,response);

        }
    }

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

    在这里插入图片描述

    在这里插入图片描述

    2.1.3 一个简单程序

    写一个翻译程序(英译汉)

    package network;

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

@SuppressWarnings({"all"})
public class UdpDictServer extends UdpEchoServer{

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

    public UdpDictServer(int port) throws SocketException {
        super(port);

        // 简单构造几个词
        dict.put("cat","小猫");
        dict.put("dog","小狗");
        dict.put("hello","你好");
        dict.put("pig","小猪");
    }

    @Override
    public String process(String request) {
        return dict.getOrDefault(request, "该词无法被翻译");
    }

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

    在这里插入图片描述

    在这里插入图片描述

    三、TCP 客户端服务器程序

    3.1 TCP API

    在TCP API 中，也是涉及到两个核心的类，
    ServerSocket(专门给TCP服务器用)
    Socket(既需要给服务器用，又需要给客户端用)

    前面基本都和UDP的差不多，区别就是这里的start方法，由于tcp是有连接的，不是一上来就能读数据，需要先建立连接(打电话)；accept返回了一个socket对象，accept可以理解为接电话，那么接电话的前提就是有人给你打电话，如果无，那么这里accept就会阻塞。

    TcpEchoServer

    // listen -> 监听
    // 但是在 Java socket 中是体现不出来"监听"的含义的
    // 之所以这么叫，是操作系统原生的API 中有一个操作叫做listen
    private ServerSocket listenSocket = null;

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

    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // 由于 Tcp是有连接的，不能一上来就读取数据，而要先建立连接(接电话)
            // accept 就是在"接电话"，前提是有人给你打电话
            // accept 返回了一个socket 对象，称为clientSocket，后续和客户端的沟通都是通过clientSocket来完成的
            // 进一步讲，listenSocket就干了一件事，就是接电话
            Socket clientSocket =  listenSocket.accept();
            processConnection(clientSocket);
        }
    }

    接下来我们来写processConnection()方法的代码。

    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客户端建立连接！", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        // 接下来处理请求和响应
        // 这里的针对 TCP socket 的读写就和文件读写是一模一样的
        try (InputStream inputStream = clientSocket.getInputStream()) {
            try (OutputStream outputStream = clientSocket.getOutputStream()) {
                // 循环的处理每个请求，分别返回响应
                Scanner scanner = new Scanner(System.in);
                while (true) {
                    // 1. 读取请求
                    if (!scanner.hasNext()) {
                        System.out.printf("[%s:%d] 客户端断开连接！", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                        break;
                    }
                    // 此处用 Scanner 更方便，如果不用Scanner 就用原生的InputStream的read
                    String request = scanner.next();
                    // 2. 根据请求，计算响应
                    String response = process(request);
                    // 3. 把这个响应返回客户端
                    // 为了方便响应，可以使用PrintWriter 把OutputStream包裹一下
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    // 刷新缓冲区，如果没有这个刷新，可能客户端就不能第一时间看到响应
                    printWriter.flush();

                    System.out.printf("[%s:%d] req: %s, resp: %s\n", clientSocket.getInetAddress().toString(), clientSocket.getPort(), request, response);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            clientSocket.close();
        }
    }

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

    完整代码：

    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;

@SuppressWarnings({"all"})
public class TcpEchoServer {
    // listen -> 监听
    // 但是在 Java socket 中是体现不出来"监听"的含义的
    // 之所以这么叫，是操作系统原生的API 中有一个操作叫做listen
    private ServerSocket listenSocket = null;

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

    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // 由于 Tcp是有连接的，不能一上来就读取数据，而要先建立连接(接电话)
            // accept 就是在"接电话"，前提是有人给你打电话
            // accept 返回了一个socket 对象，称为clientSocket，后续和客户端的沟通都是通过clientSocket来完成的
            // 进一步讲，listenSocket就干了一件事，就是接电话
            Socket clientSocket = listenSocket.accept();
            processConnection(clientSocket);
        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客户端建立连接！", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        // 接下来处理请求和响应
        // 这里的针对 TCP socket 的读写就和文件读写是一模一样的
        try (InputStream inputStream = clientSocket.getInputStream()) {
            try (OutputStream outputStream = clientSocket.getOutputStream()) {
                // 循环的处理每个请求，分别返回响应
                Scanner scanner = new Scanner(System.in);
                while (true) {
                    // 1. 读取请求
                    if (!scanner.hasNext()) {
                        System.out.printf("[%s:%d] 客户端断开连接！", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                        break;
                    }
                    // 此处用 Scanner 更方便，如果不用Scanner 就用原生的InputStream的read
                    String request = scanner.next();
                    // 2. 根据请求，计算响应
                    String response = process(request);
                    // 3. 把这个响应返回客户端
                    // 为了方便响应，可以使用PrintWriter 把OutputStream包裹一下
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    // 刷新缓冲区，如果没有这个刷新，可能客户端就不能第一时间看到响应
                    printWriter.flush();

                    System.out.printf("[%s:%d] req: %s, resp: %s\n", clientSocket.getInetAddress().toString(), clientSocket.getPort(), request, response);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            clientSocket.close();
        }
    }

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

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

    TcpEchoClient

    package network;

import jdk.internal.util.xml.impl.Input;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;

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

@SuppressWarnings({"all"})
public class TcpEchoClient {
    // 用普通的 socket 即可，不用 ServerSocket了
    // 此处也不用手动给客户端指定端口号，让系统自由分配
    private Socket socket = null;

    public TcpEchoClient(String sreverIP, int sreverPort) throws IOException {
        // 其实这里是可以给的，但是这里给了之后，含义是不同的
        // 这里传入的ip和端口号的含义表示的不是自己绑定，而是表示和这个ip端口建立连接口
        socket = new Socket(sreverIP, sreverPort);
    }

    public void start() {
        System.out.println("和服务器连接成功！");
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream()) {
            try (OutputStream outputStream = socket.getOutputStream()) {
                while (true) {
                    // 要做的事情，仍然是四个步骤
                    // 1. 从控制台读取字符串
                    System.out.println("-> ");
                    String request = scanner.next();
                    // 2. 根据读取的字符串， 构造请求，把请求发给服务器
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(request);
                    printWriter.flush();// 如果不刷新，服务器可能不能及时看到数据
                    // 3. 从服务器读取响应，并解析
                    Scanner respScanner = new Scanner(System.in);
                    String response = respScanner.next();
                    // 4. 把结果显示到控制台上
                    System.out.printf("req: %s, resp: %s\n",request, 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();
    }
}

    先启动服务器，再启动客户端
    在这里插入图片描述
    服务器启动成功，我们启动客户端，可以发现和服务器连接成功！在这里插入图片描述
    然后我们点到服务器这边观察一下，可以发现服务器已经和客户端建立连接，系统已经分配了端口号。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    那么我们结束客户端，看服务器这边的响应。
    在这里插入图片描述
    在这里插入图片描述
    我们可以发现这里的代码第一次accept结束之后，就会进入processConnection，在processConnection中又有一个循环，若processConnection里面的循环不停，processConnection就无法完成，就会导致外层循环无法进入下一轮，也就无法第二次调用accept了。

    我们可以通过多线程的方式来解决这个问题，让主线程循环调用accept，当有客户端连接上来的时候就让主线程创建一个新线程，由新线程负责客户端的若干个请求，这个时候多个线程看上去是同时执行的。

    这里我们新写一个类TcpThreadEchoServer，在原有的TcpEchoServer基础上修改以下部分代码即可。

         Thread t = new Thread(()->{
         processConnection(clinetSocket);
     });
     t.start();

    TcpThreadEchoServer

    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;
 
public class TcpThreadEchoServer {
    //    private ServerSocket listenSocket = null;
    private   ServerSocket serverSocket = null;
 
    public  TcpThreadEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
 
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true){
            Socket clinetSocket = serverSocket.accept();
            Thread t = new Thread(()->{
                processConnection(clinetSocket);
            });
            t.start();
        }
    }
 
    private void processConnection(Socket clinetSocket) {
        System.out.printf("[%s:%d客户端建立连接！\n",clinetSocket.getInetAddress().toString(),clinetSocket.getPort());
        try(InputStream inputStream = clinetSocket.getInputStream()){
            try(OutputStream outputStream = clinetSocket.getOutputStream()){
                Scanner scanner = new Scanner(inputStream);//读取请求
                while (true){
                    if(!scanner.hasNext()){
                        System.out.printf("[%s:%d]客户端断开连接！\n",clinetSocket.getInetAddress().toString(),clinetSocket.getPort());
                        break;
                    }
                    String request = scanner.next();
                    String response = process(request);
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    //刷新缓冲区，如果没有这个刷新，可能客户端就不能第一时间看到响应结果。
                    printWriter.flush();
                    System.out.printf("[%s:%d] rep:%s,resp:%s\n",
                            clinetSocket.getInetAddress().toString(),clinetSocket.getPort(),request,response);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //记得关闭操作
            try {
                clinetSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    private String process(String request) {
        return request;
    }
 
    public static void main(String[] args) throws IOException {
        TcpThreadEchoServer server = new TcpThreadEchoServer(9090);
        server.start();
    }
}

    那么之前为什么UDP版本的程序就不需要多线程就可以处理多个请求呢？

    因为UDP不需要连接，只需要一个循环就可以处理所有客户端的请求，但是TCP即需要处理连接，又需要处理一个连接中的多个请求。

摸鱼王胖嘟嘟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于javaEE学生选课系统（计算机毕业设计完整项目代码）
01-21 2178
基于javaEE学生选课系统（计算机毕业设计完整项目代码）
javaee-api-8.0-javadoc.zip
10-12
4. **JSR 362: Java Message Service (JMS) 2.0**：JMS 2.0简化了消息传递API，提供了更好的编程模型，并允许开发者更灵活地控制消息的发布和订阅。 5. **JSR 373: Java API for JSON Processing (JSON-P) 1.1** 和...
网络编程——JavaEE
sjp151的博客
07-06 503
网络编程套接字：是操作系统给应用程序提供的一组 API （socket API）。socket API 可以视为是 应用层 和 传输层 之间的通信桥梁。传输层的核心协议有两种，TCP UDP，socket API 也有对应的两组。由于 TCP 和 UDP 协议，差别很大，所以这两组 API 差别也挺大UDP socket 比 TCP 更简单，主要涉及到两个类：回想服务就是请求内容是啥，响应就是啥。我们把整个回显服务分为两部分： 绑定端口号，可以在运行程序的时候来指定。 多个进程不能绑定同一个端口。一
[附源码]java毕业设计基于JavaEE的在线学习平台
卓杰计算机程序设计
11-15 849
项目运行环境配置：Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM + mybatis + Maven + Vue 等等组成，B/S模式 + Maven管理等等。环境需要1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。2.IDE环境：IDEA，Eclipse,Myeclipse都可以。
【JavaEE】第一个servlet程序
冲击大厂之路!!!
02-04 2807
如何写出第一个servlet程序的保姆教程！！
JavaEE初阶学习:网络编程
m0_66030479的博客
05-10 135
udp tcp 初步学习
JavaEE---翟明明6500.doc
09-09
【JavaEE技术体系】 JavaEE，全称Java Platform, Enterprise Edition，是Java平台的企业版，主要用于构建企业级的分布式...他的技能集涵盖了从系统设计、数据库管理到网络编程的多个方面，符合JavaEE开发的全面要求。
javaee-web相关api
09-02
JDK 6.0 API文档是Java开发者的重要参考资料，其中包含了所有核心类库的详细描述，如集合框架、I/O流、网络编程、多线程和异常处理等。对于Web开发，`javax.servlet`和`javax.servlet.http`包提供了Servlet和JSP的...
javaee-api
07-15
"javaee-api"是一个关键的组成部分，它是Java EE平台的标准API文档，包含了各种Java EE技术的接口和类的规范。 Java EE API主要包括以下几个核心模块： 1. **Servlet**：Servlet是Java EE中的基石，它定义了服务器...
javase与javaee-api
10-24
在JavaSE 1.6版本中，包括了I/O流、网络编程、多线程、集合框架、Swing GUI组件、国际化、反射、数据库连接（JDBC）等关键模块。开发者可以使用这些API来创建独立运行的桌面应用，或者作为服务器端应用程序的基础。 ...
JavaEE程序设计与应用开发源代码
02-26
<<JavaEE程序设计与应用开发>>源代码
JavaEE架构与程序设计
05-14
《JavaEE架构与程序设计》书本上的原代码，但自己用的时候需要根据实际情况修改。可能还会有点小错误，望体谅了哈（由于上传限制，只能先上传一小部分）
java EE编程
12-29
java EE编程
JavaEE编程技术
09-26
Java EE编程技术——源代码和课件下载
最全的javaee编程
02-19
最全的javaee编程
JavaEE(SpringMVC+SpringBoot+mybatis)期末复习
最新发布
China_ZJ的博客
12-22 1853
id`
JavaEE简单示例——Spring的数据库编程
hssjsh的博客
03-23 329
JavaEE简单示例——Spring的数据库编程
Java 网络编程，javaee大学教程
m0_64867047的博客
12-19 96
ServerSocket 类的方法 服务器应用程序通过使用 java.net.ServerSocket 类以获取一个端口,并且侦听客户端请求。 ServerSocket 类有四个构造方法： public ServerSocket(int port) throws IOException 创建绑定到特定端口的服务器套接字。 public ServerSocket(int port, int backlog) throws IOException 利用指定的 backlog 创建服务器套接字并将其绑定到
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

摸鱼王胖嘟嘟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值