1. 全栈程序员必看首页

Java 网络编程

全栈程序员-用户IM • • 未分类

Java 网络编程

概述

计算机网络

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络编程

网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。

JavaWeb：网页编程 B/S

网络编程：TCP/IP C/S

网路通信的要素

如何实现网络的通信？

通信双方地址：

  • IP
  • 端口号
  • 192.168.123.1:8080

规则：网络通信的协议

OSI 七层模型和TCP/IP参考模型：

Java 网络编程

Java 网络编程

小结

  1. 网络编程中有两个主要的问题

    • 如何准确的定位到网络上的一台或者多台主机
    • 找到主机之后如何进行通信

  2. 网络编程中的要素

    • IP和端口号
    • 网络通信写协议 udp tcp

  3. 万物皆对象

IP

IP地址：InetAddress

  • 唯一定位一台网络上计算机

  • 127.0.0.1：本机localhost

  • IP地址的分类

    • ipv4/ipv6

      • IPV4 127.0.0.1，4个字节组成。0~255，42亿。
      • IPV6 2001:0DB8:0000:0023:0008:0800:200C:417A，128位。8个无符号整数。

    • 公网（互联网）- 私网（局域网）

      • 192.168.xxx.xxx 局域网

      • IP地址分类

        Java 网络编程

        Java 网络编程

  • 域名：记忆IP问题

例子：

public class TestInetAddress {
   
    public static void main(String[] args) throws UnknownHostException {
   
        //查询网站IP地址
        InetAddress inetAddress1 = InetAddress.getByName("www.baidu.com");
        System.out.println(inetAddress1);
        //查询本地地址
        InetAddress inetAddress2 = InetAddress.getLocalHost();
        System.out.println(inetAddress2);
        //常用方法
        System.out.println(inetAddress1.getAddress());
        System.out.println(inetAddress1.getCanonicalHostName());//规范的名字
        System.out.println(inetAddress1.getHostAddress());//ip
        System.out.println(inetAddress1.getHostName());//域名，或者自己电脑的名字
    }
}

运行结果：

www.baidu.com/163.177.151.110
DESKTOP-QOS6ALD/192.168.123.7
[B@2f7a2457
163.177.151.110
163.177.151.110
www.baidu.com

端口

端口表示计算机上的一个程序的进程。

  • 不同的进程有不同的端口号！用来区分软件！

  • 被规定0~65535

  • TCP/UDP：65535*2 tcp：80，udp：80，单个协议下，端口号不能冲突！

  • 端口分类

    • 公有端口0~1023

      • HTTP：80
      • HTTPS：443
      • FTP：21
      • Telnet：23

    • 程序注册端口：2014~49151，分配用户或者程序

      • Tomcat：8080
      • MySQL：3306
      • Oracle：1521

    • 动态、私有：49152~65535

      netstat -ano#查看所有端口
netstat -ano|findstr "5900"#查看指定端口
tasklist|findstr "8696" #查看指定端口的进程

    • public class TestInetSocketAddress {
       
    public static void main(String[] args){
       
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(inetSocketAddress);
        System.out.println(inetSocketAddress2);
        System.out.println(inetSocketAddress.getAddress());
        System.out.println(inetSocketAddress.getHostName());
        System.out.println(inetSocketAddress.getPort());
        System.out.println(inetSocketAddress.getHostString());
    }
}

通信协议

网络通信协议： 速率、传输码率、代码结构、传输控制…

TCP/IP协议簇

重要：

  • TCP：用户传输协议
  • UDP：用户数据报协议

TCP 和 UDP 对比

TCP：打电话

  • 连接，稳定

  • 三次握手，四次挥手

    三次握手过程理解

    img

    第一次握手：建立连接时，客户端发送syn包（syn=j）到服务器，并进入SYN_SENT状态，等待服务器确认；SYN：同步序列编号（Synchronize Sequence Numbers）。

    第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；

    第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1），此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。

    四次挥手过程理解

    img
    1）客户端进程发出连接释放报文，并且停止发送数据。释放数据报文首部，FIN=1，其序列号为seq=u（等于前面已经传送过来的数据的最后一个字节的序号加1），此时，客户端进入FIN-WAIT-1（终止等待1）状态。 TCP规定，FIN报文段即使不携带数据，也要消耗一个序号。
    2）服务器收到连接释放报文，发出确认报文，ACK=1，ack=u+1，并且带上自己的序列号seq=v，此时，服务端就进入了CLOSE-WAIT（关闭等待）状态。TCP服务器通知高层的应用进程，客户端向服务器的方向就释放了，这时候处于半关闭状态，即客户端已经没有数据要发送了，但是服务器若发送数据，客户端依然要接受。这个状态还要持续一段时间，也就是整个CLOSE-WAIT状态持续的时间。
    3）客户端收到服务器的确认请求后，此时，客户端就进入FIN-WAIT-2（终止等待2）状态，等待服务器发送连接释放报文（在这之前还需要接受服务器发送的最后的数据）。
    4）服务器将最后的数据发送完毕后，就向客户端发送连接释放报文，FIN=1，ack=u+1，由于在半关闭状态，服务器很可能又发送了一些数据，假定此时的序列号为seq=w，此时，服务器就进入了LAST-ACK（最后确认）状态，等待客户端的确认。
    5）客户端收到服务器的连接释放报文后，必须发出确认，ACK=1，ack=w+1，而自己的序列号是seq=u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。
    6）服务器只要收到了客户端发出的确认，立即进入CLOSED状态。同样，撤销TCB后，就结束了这次的TCP连接。可以看到，服务器结束TCP连接的时间要比客户端早一些。

  • 客户端、服务端

  • 传输完成，释放连接，效率低

UDP：发短信

  • 不连接，不稳定
  • 客户端、服务端：没有明确的界限
  • 不管有没有准备好，都可以发给你

TCP

客户端

  1. 连接服务器Socket

  2. 发送信息

    import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;

/** * ClassName:TcpClientDemo1 * Package:com.company.network * Description: * 客户端 * * @date:2021/3/18 22:44 * @author:yt */

public class TcpClientDemo1 {
     
    public static void main(String[] args) {
     
        Socket socket = null;
        OutputStream os = null;
        try {
     
            //1.要知道服务器地址
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建Socket连接
            socket = new Socket(inetAddress, port);
            //3.发送消息IO流
            os = socket.getOutputStream();
            os.write("你好！".getBytes(StandardCharsets.UTF_8));
        } catch (UnknownHostException e) {
     
            e.printStackTrace();
        } catch (IOException e) {
     
            e.printStackTrace();
        } finally {
     
            if (os != null) {
     
                try {
     
                    os.close();
                } catch (IOException e) {
     
                    e.printStackTrace();
                }
            }
            if (socket != null) {
     
                try {
     
                    socket.close();
                } catch (IOException e) {
     
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器

  1. 建立服务端口ServerSocket

  2. 等待用户连接 accept

  3. 接受用户的消息

    import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/** * ClassName:TcpServerDemo1 * Package:com.company.network * Description: * 服务器 * * @date:2021/3/18 22:45 * @author:yt */

public class TcpServerDemo1 {
     
    public static void main(String[] args) {
     
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
     
            //1.我得有一个地址
            serverSocket = new ServerSocket(9999);
            while (true) {
     
                //2.等待客户端连接过来
                socket = serverSocket.accept();
                //3.读取客户端的信息
                is = socket.getInputStream();
                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = is.read(buffer)) != -1) {
     
                    baos.write(buffer, 0, len);
                }
                System.out.println(baos.toString());
            }
        } catch (IOException e) {
     
            e.printStackTrace();
        } finally {
     
            //关闭资源
            if (baos != null) {
     
                try {
     
                    baos.close();
                } catch (IOException e) {
     
                    e.printStackTrace();
                }
            }
            if (is != null) {
     
                try {
     
                    is.close();
                } catch (IOException e) {
     
                    e.printStackTrace();
                }
            }
            if (socket != null) {
     
                try {
     
                    socket.close();
                } catch (IOException e) {
     
                    e.printStackTrace();
                }
            }
            if (serverSocket != null) {
     
                try {
     
                    serverSocket.close();
                } catch (IOException e) {
     
                    e.printStackTrace();
                }
            }


        }
    }
}

文件上传

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

/** * ClassName:TcpClientDemo2 * Package:com.company.network * Description: * 客户端 * @date:2021/3/18 23:48 * @author:yt */

public class TcpClientDemo2 {
   
    public static void main(String[] args) throws IOException {
   
        //1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2.创建一个·输出流
        OutputStream os = socket.getOutputStream();
        //3.读取文件
        FileInputStream fis = new FileInputStream(new File("Thread1.jpg"));
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
   
            os.write(buffer, 0, len);
        }
        //通知服务器，我已经结束了
        socket.shutdownOutput();
        //确定服务器接收完毕，才能断开连接
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        while ((len = is.read(buffer)) != -1) {
   
            baos.write(buffer, 0, len);
        }
        System.out.println(baos.toString());
        //5.关闭资源
        baos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}


import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

/** * ClassName:TcpServerDemo2 * Package:com.company.network * Description: * 服务器 * @date:2021/3/18 23:57 * @author:yt */

public class TcpServerDemo2 {
   
    public static void main(String[] args) throws IOException {
   
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        //阻塞式监听，会一直等到客户端连接
        Socket socket = serverSocket.accept();
        //3.获取输入流
        InputStream is = socket.getInputStream();
        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1) {
   
            fos.write(buffer, 0, len);
        }
        //通知客户端我接收完毕
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕了，你可以断开了".getBytes(StandardCharsets.UTF_8));
        //关闭资源
        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

UDP

发送数据，不用连接，需要对方的地址！

发送消息

客户端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;

/** * ClassName:UdpClientDemo1 * Package:com.company.network * Description: * 客户端，不需要连接服务器 * @date:2021/3/19 10:58 * @author:yt */

public class UdpClientDemo1 {
   
    public static void main(String[] args) throws Exception {
   
        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();

        //2.建个包
        String msg="你好，服务器！";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port=9090;
        DatagramPacket packet = new DatagramPacket(msg.getBytes(StandardCharsets.UTF_8),0,msg.getBytes(StandardCharsets.UTF_8).length,localhost,port);

        //3.发送包
        socket.send(packet);
        //4.关闭资源
        socket.close();
    }


}

接收端

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/** * ClassName:UdpServerDemo1 * Package:com.company.network * Description: * 服务器，还是要等待客户端连接 * @date:2021/3/19 10:59 * @author:yt */

public class UdpServerDemo1 {
   
    public static void main(String[] args) throws Exception {
   
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        //阻塞接收
        socket.receive(packet);
        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(), 0, packet.getLength()));
        //关闭连接
        socket.close();
    }
}

循环发送消息

发送端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Scanner;

/** * ClassName:UdpSenderDemo1 * Package:com.company.network.chat * Description: * 发送端 * * @date:2021/3/19 23:58 * @author:yt */

public class UdpSenderDemo1 {
   
    public static void main(String[] args) throws Exception {
   
        DatagramSocket socket = new DatagramSocket(8888);
        //准备数据：控制台读取 System.in
        Scanner sc = new Scanner(System.in);
        while (true) {
   
            String data = sc.nextLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
            socket.send(packet);
            if (data.equals("bye"))
            {
   
                break;
            }
        }
        socket.close();
        sc.close();
    }
}

接收端

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/** * ClassName:UdpReceiveDemo1 * Package:com.company.network.chat * Description: * 接收端 * @date:2021/3/19 23:59 * @author:yt */

public class UdpReceiveDemo1 {
   
    public static void main(String[] args) throws Exception {
   
        DatagramSocket socket = new DatagramSocket(6666);

        while (true) {
   
            //准备接收数据
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            //阻塞式接收数据包
            socket.receive(packet);
            //断开连接 bye
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, packet.getLength());
            System.out.println(receiveData);
            if(receiveData.equals("bye")){
   
                break;
            }


        }
        socket.close();
    }
}

咨询

在线咨询：两个人都可以是发送方，也都可以是接收方！

发送端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Scanner;

/** * ClassName:TalkSend * Package:com.company.network.chat * Description: * * @date:2021/3/20 0:43 * @author:yt */

public class TalkSend implements Runnable {
   
    DatagramSocket socket = null;
    Scanner sc = null;
    private int formPort;
    private String toIP;
    private int toPort;

    public TalkSend(int formPort, String toIP, int toPort) {
   
        this.formPort = formPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
   
            socket = new DatagramSocket(formPort);
            sc = new Scanner(System.in);
        } catch (Exception e) {
   
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
   

        //准备数据：控制台读取 System.in

        while (true) {
   
            String data = sc.nextLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIP, this.toPort));
            try {
   
                socket.send(packet);
            } catch (IOException e) {
   
                e.printStackTrace();
            }
            if (data.equals("bye")) {
   
                break;
            }
        }
        socket.close();
        sc.close();
    }
}

接收端

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

/** * ClassName:TalkReceive * Package:com.company.network.chat * Description: * * @date:2021/3/20 0:51 * @author:yt */

public class TalkReceive implements Runnable {
   
    DatagramSocket socket = null;
    private int port;
    private String msgForm;

    public TalkReceive(int port, String msgForm) {
   
        this.port = port;
        this.msgForm = msgForm;
        try {
   
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
   
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
   

        while (true) {
   
            try {
   
                //准备接收数据
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                //阻塞式接收数据包
                socket.receive(packet);
                //断开连接 bye
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, packet.getLength());
                System.out.println(msgForm+"： "+receiveData);
                if (receiveData.equals("bye")) {
   
                    break;
                }
            } catch (IOException e) {
   
                e.printStackTrace();
            }


        }
        socket.close();
    }
}

例子：

学生

public class TalkStudent {
   
    public static void main(String[] args){
   
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

老师

public class TalkTeacher {
   
    public static void main(String[] args){
   
        //开启两个线程
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

URL

https://www.baidu.com/

统一资源定位符：定位资源的，定位互联网上的某一个资源。

DNS域名解析：www.baidu.com xxx.xxx.xxx.xxx

协议：//ip地址:端口/项目名/资源

例子：

public class URLDemo1 {
   
    public static void main(String[] args) throws MalformedURLException {
   
        URL url = new URL("http://localhost:9090/ROOT/index.jsp");
        //协议
        System.out.println(url.getProtocol());
        //主机ip
        System.out.println(url.getHost());
        //端口
        System.out.println(url.getPort());
        //路径
        System.out.println(url.getPath());
        //文件
        System.out.println(url.getFile());
        //参数
        System.out.println(url.getQuery());

    }
}

下载网络资源

例子：

public class URLDown {
   
    public static void main(String[] args) throws Exception {
   
        //1.下载地址
        URL url = new URL("http://localhost:9090/yt/yt.txt");
        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        InputStream is = urlConnection.getInputStream();
        FileOutputStream fos = new FileOutputStream("yt.txt");
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
   
            fos.write(buffer,0,len);
        }
        fos.close();
        is.close();
        urlConnection.disconnect();
    }
}
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/114426.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • AutoFac文档5（转载）

    AutoFac文档5（转载）

    AutoFac文档5（转载）

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年8月25日
  • 阿里云服务器定时在线运行python爬虫代码「建议收藏」

    阿里云服务器定时在线运行python爬虫代码「建议收藏」

    阿里云服务器定时在线运行python爬虫代码「建议收藏」服务器：centos任务管理：cron服务对于cron服务不了解的可以看我这篇文章

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月18日
  • win10开机“正在准备自动修复”，且无法修复你的电脑「建议收藏」

    win10开机“正在准备自动修复”，且无法修复你的电脑「建议收藏」

    win10开机“正在准备自动修复”，且无法修复你的电脑「建议收藏」昨天一顿操作，先是快速启动，后来又觉得快速启动没用又关掉了，第二天过来，发现电脑开不起来了，进到里面怎么自动修复不得行，网上大多数的答案是重装，经过半天努力摸索，终于修好了，原理就不想深究了。准备:一个U盘,并且制作PE系统。1、电脑的系统启动设置在U盘启动，进入PE系统2、打开分区工具DiskGenius点硬盘点重建主引导记录MBR（一般在开始菜单都有）3、再返…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月20日
  • servlet到底是什么？[通俗易懂]

    servlet到底是什么？[通俗易懂]

    servlet到底是什么？[通俗易懂]servlet到底是什么？对于这个问题一直云里雾里的，今天打算刨根问底。一、Servlet简介　　Servlet是sun公司提供的一门用于开发动态web资源的技术。　　Sun公司在其API中提供了一个servlet接口，用户若想用发一个动态web资源(即开发一个Java程序向浏览器输出数据)，需要完成以下2个步骤：　　1、编写一个Java类，实现servlet接口。

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年6月25日
  • 哈希表基本概念介绍及哈希冲突的处理方法(附源码)

    哈希表基本概念介绍及哈希冲突的处理方法(附源码)

    哈希表基本概念介绍及哈希冲突的处理方法(附源码)工科生一枚，热衷于底层技术开发，有强烈的好奇心，感兴趣内容包括单片机，嵌入式Linux，Uboot等，欢迎学习交流！爱好跑步，打篮球，睡觉。欢迎加我QQ1500836631（备注CSDN），一起学习交流问题，分享各种学习资料，电子书籍，学习视频等。文章目录哈希表和哈希函数的概念哈希函数的构造直接定址法数字分析法平方取中法折叠法除留余数法（常用）随机数法哈希函数的选择处理冲突的方法开放定址法再哈希法链地址法建立一个公共溢出区代码实现哈希表和哈希函数的概念  哈希表（散列表），是根据关键码值(Ke.

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年6月29日
  • 学计算机我后悔了(计算机专业初级书籍)

    学计算机我后悔了(计算机专业初级书籍)

    大家好，我是小林哥。平日里，大家都喊程序员加班多很辛苦，动不动就掉头发，但干的还是很香的，毕竟大多数公司钱还是给的很到位的，今年毕业应届生的我见到好多动不动就月薪20K~30K的，真让人两眼泪酸酸，当然这离不开他们大学期间的努力。讲真，没什么家庭背景的人，选择当程序员确实是比较好的选择了，原因有二：首先，当今互联网、AI人工智能、大数据等都是高速发展的行业，自然人才需求很多，薪资也相对其他传统行业高；第二，纯粹看你技术能力，只要自己愿意付出努力，技术能力肯定会慢慢提高上来，而且现在比起几十年

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月18日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号