当前位置： 首页 > news >正文

JavaEE初阶：网络编程套接字

news 来源：原创 2024/5/3 14:01:02

文章目录

  • 一、网络编程基础
    • 1、为什么需要网络编程
    • 2、什么是网络编程
    • 3、网络编程中的基本概念
      • ① 发送端和接收端
      • ② 请求和相应
      • ③ 客户端和服务端
      • ④ 常见的客户端服务端模型
  • 二、Socket套接字
    • 1、概念
    • 2、分类
      • ① 流套接字（TCP）
      • ② 数据报套接字（UDP）
      • ③ 原始套接字
  • 三、UDP数据报套接字编程
    • 1、DatagramSocket API
    • 2、DatagramPacket API
    • 3、InetSocketAddress API
    • 4、示例一：一发一收（无响应）
      • ① UDP服务端
      • ② UDP客户端
    • 5、示例二：请求响应
      • ① UDP服务端
      • ② UDP客户端
  • 四、TCP流套接字编程
    • 1、ServerSocket API
    • 2、Socket API
    • 3、TCP中的长短连接
    • 4、示例一：一发一收（长连接）
      • ① TCP服务端
      • ② TCP客户端
    • 5、示例二：请求响应（长连接）
      • ① TCP服务端
      • ② TCP客户端

一、网络编程基础

1、为什么需要网络编程

与本地打开视频文件类似，只是视频文件这个资源的来源是网络。
相比本地资源来说，网络提供了更为丰富的网络资源：
所谓的网络资源，其实就是在网络中可以获取的各种数据资源。
而所有的网络资源，都是通过网络编程来进行数据传输的。

2、什么是网络编程

网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。

进程具有隔离性（每个进程都有自己独立的虚拟地址空间）.
进程间通信，借助一个每个进程都能访问到的公共区域，完成数据交换.

网络编程，也就是一种进程 间通信的方式，借助的公共区域就是 网卡.（当下最主流的方式）

3、网络编程中的基本概念

① 发送端和接收端

发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。

注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。

② 请求和相应

请求：客户端给服务器发送的数据.
响应：服务器给客户端返回的数据.

③ 客户端和服务端

客户端：主动发送网络数据的一方.
服务器：被动接受网络数据的一方.

④ 常见的客户端服务端模型

  1. 一问一答（最常见的方式，比如：浏览网页）
    客户端给服务器发一个请求
    服务器给客户端返回一个响应
  2. 多问一答（更少见一些，比如：上传文件）
    客户端给服务器发多个请求
    服务器给客户端返回一个响应
  3. 一问多答（不多不少，比如：下载文件）
    客户端给服务器发一个请求
    服务器给客户端返回多个响应
  4. 多问多答（比如：远程控制，有些串流）
    客户端给服务器发多个请求
    服务器给客户端返回多个响应

二、Socket套接字

在这里插入图片描述

1、概念

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

2、分类

Socket套接字主要针对传输层协议划分为如下三类：
流套接字（TCP）、数据报套接字（UDP）、原始套接字.

① 流套接字（TCP）

TCP，即Transmission Control Protocol（传输控制协议），传输层协议。

TCP 特点：

  • 有连接（打电话：先建立连接，然后再通信）
  • 可靠传输（数据对方是否收到，发送方能够感知）
  • 面向字节流
  • 全双工（双向通信，一个管道，能 A->B，B->A 同时进行）

对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。

② 数据报套接字（UDP）

UDP，即User Datagram Protocol（用户数据报协议），传输层协议。

UDP 特点：

  • 无连接（发微信：不必建立连接，直接通信即可）
  • 不可靠传输（数据对方是否收到，发送方无法感知）
  • 面向数据报
  • 全双工（单向通信，一个管道，同一时刻，要么 A->B，要么 B->A，不能同时进行）

对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。

③ 原始套接字

原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。
我们不学习原始套接字，简单了解即可。

三、UDP数据报套接字编程

1、DatagramSocket API

DatagramSocket：socke类，本质上相当于是一个 “文件”，在系统中，还有一种特殊的 socket 文件，对应到网卡设备.
构造一个 DatagramSocket 对象，就相当于是打开了一个 内核中的 socket 文件.

DatagramSocket 构造方法：

方法签名方法说明
DatagramSocket()创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端）
DatagramSocket(int port)创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）

DatagramSocket 方法：

方法签名方法说明
void receive(DatagramPacket p)从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacket p)从此套接字发送数据报包（不会阻塞等待，直接发送）
void close()关闭此数据报套接字

2、DatagramPacket API

DatagramPacket：表示一个 UDP 数据报，UDP 是面向数据报的协议，传输数据，就是以 DatagramPacket 为基本单位.

DatagramPacket 构造方法：

方法签名方法说明
DatagramPacket(byte[] buf, int length)构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数 length）
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号

DatagramPacket 方法：

方法签名方法说明
InetAddress getAddress()从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort()从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData()获取数据报中的数据

3、InetSocketAddress API

InetSocketAddress：IP 地址 + 端口号.

InetSocketAddress （ SocketAddress 的子类 ）构造方法：

方法签名方法说明
InetSocketAddress(InetAddress addr, int port)创建一个Socket地址，包含IP地址和端口号

4、示例一：一发一收（无响应）

① UDP服务端

package network;

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

public class UDP_demo1_Server {
    private DatagramSocket socket = null;

    public UDP_demo1_Server(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);

            System.out.println("---------------------------------------------------");
            System.out.println("等待接收UDP数据报...");

            socket.receive(requestPacket);

            // 2. 对请求进行解析，把 DatagramPacket 转成一个 String
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());

            System.out.printf("IP: %s\n",requestPacket.getAddress().getHostAddress());
            System.out.printf("端口号: %s\n",requestPacket.getPort());
            System.out.printf("req: %s\n",request);
        }
    }

    public static void main(String[] args) throws IOException {
        // 真正启动服务器
        UDP_demo1_Server server = new UDP_demo1_Server(8000);
        server.start();
    }
}

② UDP客户端

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;

public class UDP_demo1_Client {
    private DatagramSocket socket = null;

    public UDP_demo1_Client() throws SocketException {
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 让客户端从控制台读取一个请求数据.
            System.out.print("> ");
            String request = scanner.next();

            // 2. 把这个字符串请求发送给服务器，构造 DatagramPacket
            //    构造的 Packet 既要包含 要传输的数据，又要包含把数据发到哪里
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName("127.0.0.1"), 8000);

            // 3. 把数据报发给服务器.
            socket.send(requestPacket);
        }
    }

    public static void main(String[] args) throws IOException {
        UDP_demo1_Client client = new UDP_demo1_Client();
        client.start();
    }
}

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

5、示例二：请求响应

在这里插入图片描述

① UDP服务端

package network;

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

public class UDPEchoServer {
    // 要想创建 UDP 服务器，首先要先打开一个 socket 文件.
    private DatagramSocket socket = null;

    public UDPEchoServer(int port) throws SocketException {
        // 绑定一个端口：把这个进程和一个端口号，关联起来
        // 一个操作系统上，有很多端口号：0~65535
        // 端口号相当于用来在网络上区分进程的身份标识符

        // 分配端口号的过程：
        // 1. 程序员手动绑定
        // socket = new DatagramSocket(port);
        // 2. 系统自动分配（系统自动分配一个闲置的端口）
        // socket = new DatagramSocket();

        // 一个端口，在通常情况下，是不能被同一个主机上的多个进程同时绑定的
        // 如果同时绑定，就会抛出 SocketException 异常.
        socket = new DatagramSocket(port);
    }

    // 启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // 1. 读取客户端发来的请求.
            // receive 是尝试读取，不是说调用了就一定能读取到！
            // 如果客户端没有发来请求，receive 就会阻塞等待.
            // receive 的参数属于输出型参数
            // 调用 receive 之前，需要构造一个空的 DatagramPacket
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestPacket);

            // 2. 对请求进行解析，把 DatagramPacket 转成一个 String
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());

            // 3. 根据请求，处理相应
            String response = process(request);

            // 4. 把响应构造成 DatagramPacket 对象.
            //    构造响应对象，要搞清楚，对象要发给谁，谁发的请求，就把响应发给谁
            //    response.getBytes().length 表示字节数
            //    response..length           表示字符数
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                    requestPacket.getSocketAddress());

            // 5. 把这个 DatagramPacket 对象 返回给客户端.
            socket.send(responsePacket);
            System.out.printf("[%s:%d] req=%s; resp=%s\n", requestPacket.getAddress().toString(), requestPacket.getPort(),
                    request, response);
        }
    }

    // 通过这个方法，实现根据请求计算响应 这个过程
    // 由于是回显服务器，所以不涉及其他逻辑
    // 但是如果是其他服务器，就可以在 process 里，加上其他逻辑处理
    public String process(String req) {
        return req;
    }

    public static void main(String[] args) throws IOException {
        // 真正启动服务器
        // 端口号 0~65535 随便写，但是一般来说 1024 一下的端口，都是系统保留.
        UDPEchoServer server = new UDPEchoServer(8000);
        server.start();
    }
}

② UDP客户端

package network;

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class UDPEchoClient {
    private DatagramSocket socket = null;

    public UDPEchoClient() throws SocketException {
        // 客户端的端口号，一般都是由操作系统自动分配的
        // 虽然手动指定也许，习惯上还是自动分配比较好

        // ①服务器，端口一般是手动指定的
        //   如果自动分配，客户端就不知道服务器的端口是什么了！
        // ②客户端，端口一般是自动分配的
        //   客户端程序是安装在用户的电脑上的，用户电脑当前运行哪些程序，是不可控的
        //   如果手动指定端口号，说不定这个端口就和其他程序冲突了，代码就无法运行了
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 让客户端从控制台读取一个请求数据.
            System.out.print("> ");
            String request = scanner.next();

            // 2. 把这个字符串请求发送给服务器，构造 DatagramPacket
            //    构造的 Packet 既要包含 要传输的数据，又要包含把数据发到哪里
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName("127.0.0.1"), 8000);

            // 3. 把数据报发给服务器.
            socket.send(requestPacket);

            // 4. 从服务器读取响应数据
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);

            // 5. 把响应的数据获取出来，转成字符串
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());

            System.out.printf("req: %s; resp: %s\n", request, response);
        }
    }

    public static void main(String[] args) throws IOException {
        UDPEchoClient client = new UDPEchoClient();
        client.start();
    }
}

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

四、TCP流套接字编程

1、ServerSocket API

ServerSocket 是创建 TCP 服务端 Socket 的 API.
accept 没有参数，返回值是一个 Socket 对象， 功能是等待有客户端和服务器建立上连接.
accept 则会把这个连接获取到进程中，进一步的通过返回值的 Socket 对象来和客户端进行交互

ServerSocket 构造方法：

方法签名方法说明
ServerSocket(int port)创建一个服务端流套接字Socket，并绑定到指定端口

ServerSocket 方法：

方法签名方法说明
Socket accept()开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket 对象，并基于该Socket建立与客户端的连接，否则阻塞等待
void close()关闭此套接字

2、Socket API

Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端 Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
这里的传输数据，不是直接通过 Socket 对象，而是 Socket 内部包含了输入流 对象（接收）输出流 对象（发送）。

Socket 构造方法：

方法签名方法说明
Socket(String host, int port)创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接

Socket 方法：

方法签名方法说明
InetAddress getInetAddress()返回套接字所连接的地址
InputStream getInputStream()返回此套接字的输入流
OutputStream getOutputStream()返回此套接字的输出流

3、TCP中的长短连接

短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

4、示例一：一发一收（长连接）

① 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;

public class Tcp_demo1_Server {
    private ServerSocket serverSocket = null;

    public Tcp_demo1_Server(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            Socket clientSocket = serverSocket.accept();
            processConnect(clientSocket);
        }
    }

    private void processConnect(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 建立连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            Scanner scanner = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);

            while (true) {
                if (!scanner.hasNext()) {
                    // 连接断开，当客户端断开连接的时候，此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1. 读取请求并解析
                String request = scanner.next();

                // 2. 返回字符串
                String response = process(request);

                System.out.printf("[%s:%d] req: %s！\n",
                        clientSocket.getInetAddress().toString(), clientSocket.getPort(),
                        request);
            }
        }finally {
            clientSocket.close();
        }
    }

    public String process(String req) {
        return req;
    }

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

② TCP客户端

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

    public Tcp_demo1_Client() throws IOException {
        socket = new Socket("127.0.0.1", 8000);
    }

    public void start() throws IOException {
        // 由于实现的是长连接，一个连接会处理 N 个请求和响应
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 1. 从控制台读取用户的输入.
                System.out.print("> ");
                String request = scanner.next();

                // 2. 把请求发送到服务器
                printWriter.println(request);
                printWriter.flush();

                // 3. 把结果显示到界面上
                System.out.printf("req: %s\n", request);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Tcp_demo1_Client client = new Tcp_demo1_Client();
        client.start();
    }
}

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

5、示例二：请求响应（长连接）

在这里插入图片描述

① 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;

public class TcpEchoServer {
    private ServerSocket serverSocket = null;

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

    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // accept 进行的工作，是拉客
            // 对于操作系统来说，建立 TCP 连接，是内核的工作.
            // accept 是等连接建立好了，把这个连接拿到 应用程序 中.
            // 如果当前连接还没有建立，accept 就会阻塞
            Socket clientSocket = serverSocket.accept();

            // 不再直接调用了，而是创建一个新的线程，让新线程来调用
            // processConnect(clientSocket);
            Thread t=new Thread(()->{
                try {
                    processConnect(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }
    }

    // 通过这个方法，给当前连上的客户端，提供服务！
    // 一个连接过来了，服务方式可能有两种
    // 1. 一个连接只进行一次数据交互（一个请求+一个响应） 短连接
    // 2. 一个连接进行多次数据交互（N个请求+N个响应）    长连接
    // 此处我们来写长连接的版本
    private void processConnect(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 建立连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            Scanner scanner = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);

            // 这里是长连接的写法，需要通过 循环 来获取到多次交互的情况
            while (true) {
                if (!scanner.hasNext()) {
                    // 连接断开，当客户端断开连接的时候，此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1. 读取请求并解析
                String request = scanner.next();

                // 2. 根据请求计算响应
                String response = process(request);

                // 3. 把响应写回给客户端
                printWriter.println(response);
                //    刷新一下缓冲区，避免数据没有真的发出去
                printWriter.flush();

                System.out.printf("[%s:%d] req: %s; resp: %s！\n",
                        clientSocket.getInetAddress().toString(), clientSocket.getPort(),
                        request, response);
            }
        }finally {
            // 加在这里是更稳妥的做法
            // clientSocket 用完之后，要关闭，clientSocket 和 ServerSocket 不同
            // ServerSocket 的生命周期，是跟随整个程序的！
            // clientSocket 的生命周期，只是当前连接！
            // 如果不关闭，就会造成资源泄漏
            // ServerSocket 只有一个; clientSocket 会有无数个：每个客户端的连接都是一个！
            clientSocket.close();
        }
    }

    public String process(String req) {
        return req;
    }

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

② TCP客户端

package network;

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

public class TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient() throws IOException {
        // new 这个对象，需要和服务器建立连接
        // 要想建立连接，就得知道服务器在哪里！！
        socket = new Socket("127.0.0.1", 8000);
    }

    public void start() throws IOException {
        // 由于实现的是长连接，一个连接会处理 N 个请求和响应
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 1. 从控制台读取用户的输入.
                System.out.print("> ");
                String request = scanner.next();

                // 2. 把请求发送到服务器
                printWriter.println(request);
                printWriter.flush();

                // 3. 从服务器读取响应
                String response = scannerNet.next();

                // 4. 把结果显示到界面上
                System.out.printf("req: %s; resp: %s\n", request, response);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient();
        client.start();
    }
}

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

相关文章：

  • JAVA猎才学员成长心得分享
  • 2022年0903我的SpringBoot框架入门的第一个程序
  • 【高阶数据结构】并查集的实现(含压缩路径)及其应用-C++版本
  • Java——线程不安全的原因（图解）
  • [数据结构]~双向+循环链表从(0~1）
  • 【开学季】再见大一，你好大二 | 完成自己的未完成
  • java毕业设计网站SSM版学生选课系统[包运行成功]
  • 【计算机网络】第六章：应用层
  • FS03MR12A6MA1LBBPSA1 1200V 400A 紧凑型 六单元模块
  • 系统篇： ubuntu 18.04 ROS1 和 ROS2 环境搭建
  • 贪心算法 - 买卖股票的最佳时机|| + 分割平衡字符串
  • ActiveReports.NET 16.2RPX 部分报告的完全支持
  • 专业英语第八章Communications and Networks测试题
  • 【Linux操作系统】-- 多线程（三）-- 线程池+单例模式+读写者模型
  • Pinia实操配置，Vuex的替代品
  • 分享一款快速APP功能测试工具
  • CentOS7简单部署NFS
  • eclipse的离线汉化
  • Java 9 被无情抛弃，Java 8 直接升级到 Java 10！！
  • Meteor的表单提交:Form
  • swift基础之_对象 实例方法 对象方法。
  • win10下安装mysql5.7
  • 测试如何在敏捷团队中工作？
  • 关于Flux,Vuex,Redux的思考
  • 开源地图数据可视化库——mapnik
  • 码农张的Bug人生 - 见面之礼
  • 容器服务kubernetes弹性伸缩高级用法
  • 使用Tinker来调试Laravel应用程序的数据以及使用Tinker一些总结
  • 微信小程序设置上一页数据
  • 我有几个粽子，和一个故事
  • ionic异常记录
  • 关于Android全面屏虚拟导航栏的适配总结
  • 整理一些计算机基础知识！
  • ​​​​​​​sokit v1.3抓手机应用socket数据包： Socket是传输控制层协议，WebSocket是应用层协议。
  • ​LeetCode解法汇总2670. 找出不同元素数目差数组
  • !! 2.对十份论文和报告中的关于OpenCV和Android NDK开发的总结
  • #{} 和 ${}区别
  • #ifdef 的技巧用法
  • #我与Java虚拟机的故事#连载07：我放弃了对JVM的进一步学习
  • $redis-setphp_redis Set命令，php操作Redis Set函数介绍
  • $分析了六十多年间100万字的政府工作报告，我看到了这样的变迁
  • ( 10 )MySQL中的外键
  • （C语言）二分查找 超详细
  • (附源码)springboot课程在线考试系统 毕业设计 655127
  • （十）T检验-第一部分
  • （五）c52学习之旅-静态数码管
  • （一）Java算法：二分查找
  • (原)记一次CentOS7 磁盘空间大小异常的解决过程
  • (转)ABI是什么
  • .\OBJ\test1.axf: Error: L6230W: Ignoring --entry command. Cannot find argumen 'Reset_Handler'
  • .Net 6.0 处理跨域的方式
  • .NET Core中的去虚
  • .NET 反射 Reflect
  • @Autowired注解的实现原理
  • @ConfigurationProperties注解对数据的自动封装