一、网络编程基础

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 转成一个 StringString 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 之前，需要构造一个空的 DatagramPacketDatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);socket.receive(requestPacket);// 2. 对请求进行解析，把 DatagramPacket 转成一个 StringString 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 就会返回 falseSystem.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 就会返回 falseSystem.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();}
}

JavaEE：网络编程套接字相关推荐

1. 【javaEE】网络编程套接字

   To u&me: 努力经营当下,直至未来明朗 文章目录 前言 一.网络编程(没时间可以跳过) 一)网络编程了解 二)相关基本概念 二.Socket套接字 三.数据报套接字通信(UDP) 写一个 ...

2. 网络编程套接字（四）

   网络编程套接字(四) 文章目录 网络编程套接字(四) 一.实现tcp服务器多用户版本(多进程.多线程.线程池版本) 一.实现tcp服务器多用户版本(多进程.多线程.线程池版本) tcp_process ...

3. 网络编程套接字（三）

   网络编程套接字(三) 文章目录 网络编程套接字(三) 一.实现简单的Tcp服务器(单用户) 一.实现简单的Tcp服务器(单用户) tcp_socket.hpp #pragma once #includ ...

4. 网络编程套接字（二）

   网络编程套接字(二) 文章目录 网络编程套接字(二) 一.简单的UDP网络程序 一.简单的UDP网络程序 封装udp_socket #pragma once #include <cstdio&g ...

5. 网络编程套接字（一）

   网络编程套接字(一) 文章目录 网络编程套接字(一) 一.基础知识 二.sock编程接口 一.基础知识 1. 理解源IP地址和目的IP地址 在IP数据包头部中,有两个IP地址,分别叫源IP地址和目的I ...

6. 详细讲解 —— 网络编程套接字（Java EE初阶）

   网络编程套接字 1 认识网络编程套接字 2 UDP 数据报套接字编程 2.1 UPD服务端 2.1 UDP客户端 2.3 结果测试 3 TCP流套接字编程 3.1 TCP服务端 3.2 TCP客户端 ...

7. Java网络编程套接字

   文章目录 1.网络编程基础 2.什么是网络编程 3.网络编程中的基本概念 3.1.发送端和接收端 3.2 请求和响应 3.3 客户端和服务端 3.4 常见的客户端服务端模型 4.Socket套接字 4 ...

8. UNIX网络编程---套接字编程简介（三）

   UNIX网络编程---套接字编程简介 一.概述 从这里开始正式开始网络编程之旅,所有的函数都是基本的库函数.这些都是网络编程的基础.Come on!!!! 二.套接字地址结构 大多数套接字函数都需要一 ...

9. 【网络编程套接字（一）】

   网络编程套接字(一) 理解源IP地址和目的IP地址 理解源MAC地址和目的MAC地址 理解源端口号和目的端口号 PORT VS PID 认识TCP协议和UDP协议 网络字节序 socket编程接口 s ...

10. Linux·网络编程套接字（三）

    目录 简单的TCP英译汉服务器 简单回顾 更改handler方法 地址转换函数 字符串IP转整数IP 整数IP转字符串IP 绑定失败问题 TCP协议通讯流程 通讯流程总览 三次握手的过程 数据传输的过 ...

最新文章

1. 【java】java自带的java.util.logging.Logger日志功能
2. 会计期间13-16怎么用
3. 文本文件的读写（字符流）
4. TCPIP / MTU 和 MSS 的区别和联系
5. Win10开发UWP使用.Net Native编译时遇到的一些问题。
6. 您与此网站建立的连接不安全_dede网站密码忘记找回服务为先
7. oracle精度说明符1~38_Oracle 错误代码总结及解决方案
8. 【PyTorch】中view()==＞相当于numpy中resize()、reshape()的功能
9. Servlet如何上传文件? 戳这里
10. Android开发笔记（一百四十四）高仿支付宝的头部伸缩动画
11. MySQL快速上手[学习笔记]（二）
12. 【中级篇】Linux下搭建MySQL数据库系统
13. Multisim单结晶体管触发电路仿真
14. 小程序用php还是java_微信小程序用php开发的可以吗
15. 华为模拟器eNSP - HCIP - OSPF的Totally STUB 、Totally NSSA综合实验
16. 图像修复-基本问题和经典方法
17. samba服务器的位置文件是,从windows通过samba服务器访问文件问题
18. 微信小程序 - 小技巧
19. 织梦手机站 html 插件,织梦DEDECMS手机端生成静态页面插件完整版
20. NLP前提假设之在一个系统里面最为灵活的人，最能掌控大局的人

热门文章

1. -- 6、查询“李“姓老师的数量
2. 看守所里的信息化故事：刘所家的新地毯
3. H.264官方软件JM源代码简单分析-解码器ldecod（转载）
4. 7.1 RAID（独立冗余磁盘阵列）
5. cos(a+b)=cosa*cosb-sina*sinb的推导过程
6. c#十二星座速配系统_不同的调是否具有独立色彩？作曲时如何选择用什么调？...
7. 超硬核之傅里叶公式推导(上)
8. 经常使用的网页开发工具有哪些
9. 互融云贷款中介平台搭建，助力企业实现数字化智能办公
10. 浏览器主页被搜狗劫持如何处理