月度归档:2019年08月

Linux Socket 编程简介和实现

这篇文章主要介绍了Linux Socket 编程简介和实现,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

在 TCP/IP 协议中,"IP地址 + TCP或UDP端口号" 可以唯一标识网络通讯中的一个进程,"IP地址+端口号" 就称为 socket。本文以一个简单的 TCP 协议为例,介绍如何创建基于 TCP 协议的网络程序。

TCP 协议通讯流程

下图描述了 TCP 协议的通讯流程(此图来自互联网):

1

下图则描述 TCP 建立连接的过程(此图来自互联网):

服务器调用 socket()、bind()、listen() 函数完成初始化后,调用 accept() 阻塞等待,处于监听端口的状态,客户端调用 socket() 初始化后,调用 connect() 发出 SYN 段并阻塞等待服务器应答,服务器应答一个SYN-ACK 段,客户端收到后从 connect() 返回,同时应答一个 ACK 段,服务器收到后从 accept() 返回。

TCP 连接建立后数据传输的过程:

建立连接后,TCP 协议提供全双工的通信服务,但是一般的客户端/服务器程序的流程是由客户端主动发起请求,服务器被动处理请求,一问一答的方式。因此,服务器从 accept() 返回后立刻调用 read(),读 socket 就像读管道一样,如果没有数据到达就阻塞等待,这时客户端调用 write() 发送请求给服务器,服务器收到后从 read() 返回,对客户端的请求进行处理,在此期间客户端调用 read() 阻塞等待服务器的应答,服务器调用 write() 将处理结果发回给客户端,再次调用 read() 阻塞等待下一条请求,客户端收到后从 read() 返回,发送下一条请求,如此循环下去。

下图描述了关闭 TCP 连接的过程:

如果客户端没有更多的请求了,就调用 close() 关闭连接,就像写端关闭的管道一样,服务器的 read() 返回 0,这样服务器就知道客户端关闭了连接,也调用 close() 关闭连接。注意,任何一方调用 close() 后,连接的两个传输方向都关闭,不能再发送数据了。如果一方调用 shutdown() 则连接处于半关闭状态,仍可接收对方发来的数据。

在学习 socket 编程时要注意应用程序和 TCP 协议层是如何交互的:

  1. 应用程序调用某个 socket 函数时 TCP 协议层完成什么动作,比如调用 connect() 会发出 SYN 段
  2. 应用程序如何知道 TCP 协议层的状态变化,比如从某个阻塞的 socket 函数返回就表明 TCP 协议收到了某些段,再比如 read() 返回 0 就表明收到了 FIN 段

下面通过一个简单的 TCP 网络程序来理解相关概念。程序分为服务器端和客户端两部分,它们之间通过 socket 进行通信。

服务器端程序

下面是一个非常简单的服务器端程序,它从客户端读字符,然后将每个字符转换为大写并回送给客户端:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#define MAXLINE 80
#define SERV_PORT 8000
int main(void)
{
  struct sockaddr_in servaddr, cliaddr;
  socklen_t cliaddr_len;
  int listenfd, connfd;
  char buf[MAXLINE];
  char str[INET_ADDRSTRLEN];
  int i, n;
  // socket() 打开一个网络通讯端口,如果成功的话,
  // 就像 open() 一样返回一个文件描述符,
  // 应用程序可以像读写文件一样用 read/write 在网络上收发数据。
  listenfd = socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(SERV_PORT);
  
  // bind() 的作用是将参数 listenfd 和 servaddr 绑定在一起,
  // 使 listenfd 这个用于网络通讯的文件描述符监听 servaddr 所描述的地址和端口号。
  bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
  // listen() 声明 listenfd 处于监听状态,
  // 并且最多允许有 20 个客户端处于连接待状态,如果接收到更多的连接请求就忽略。
  listen(listenfd, 20);
  printf("Accepting connections ...\n");
  while (1)
  {
    cliaddr_len = sizeof(cliaddr);
    // 典型的服务器程序可以同时服务于多个客户端,
    // 当有客户端发起连接时,服务器调用的 accept() 返回并接受这个连接,
    // 如果有大量的客户端发起连接而服务器来不及处理,尚未 accept 的客户端就处于连接等待状态。
    connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
   
    n = read(connfd, buf, MAXLINE);
    printf("received from %s at PORT %d\n",
        inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
        ntohs(cliaddr.sin_port));
  
    for (i = 0; i < n; i++)
    {
      buf[i] = toupper(buf[i]);
    }
      
    write(connfd, buf, n);
    close(connfd);
  }
}

把上面的代码保存到文件 server.c 文件中,并执行下面的命令编译:

?
1
$ gcc server.c -o server

然后运行编译出来的 server 程序:

?
1
$ ./server

此时我们可以通过 ss 命令来查看主机上的端口监听情况:

如上图所示,server 程序已经开始监听主机的 8000 端口了。

下面让我们介绍一下这段程序中用到的 socket 相关的 API。

?
1
int socket(int family, int type, int protocol);

socket() 打开一个网络通讯端口,如果成功的话,就像 open() 一样返回一个文件描述符,应用程序可以像读写文件一样用 read/write 在网络上收发数据。对于IPv4,family 参数指定为 AF_INET。对于 TCP 协议,type 参数指定为 SOCK_STREAM,表示面向流的传输协议。如果是 UDP 协议,则 type 参数指定为 SOCK_DGRAM,表示面向数据报的传输协议。protocol 指定为 0 即可。

?
1
int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

服务器需要调用 bind 函数绑定一个固定的网络地址和端口号。bind() 的作用是将参数 sockfd 和 myaddr 绑定在一起,使 sockfd 这个用于网络通讯的文件描述符监听 myaddr 所描述的地址和端口号。struct sockaddr *是一个通用指针类型,myaddr 参数实际上可以接受多种协议的 sockaddr 结构体,而它们的长度各不相同,所以需要第三个参数 addrlen 指定结构体的长度。

程序中对 myaddr 参数的初始化为:

?
1
2
3
4
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);

首先将整个结构体清零,然后设置地址类型为 AF_INET,网络地址为 INADDR_ANY,这个宏表示本地的任意 IP 地址,因为服务器可能有多个网卡,每个网卡也可能绑定多个 IP 地址,这样设置可以在所有的 IP 地址上监听,直到与某个客户端建立了连接时才确定下来到底用哪个 IP 地址,端口号为 SERV_PORT,我们定义为 8000。

?
1
int listen(int sockfd, int backlog);

listen() 声明 sockfd 处于监听状态,并且最多允许有 backlog 个客户端处于连接待状态,如果接收到更多的连接请求就忽略。

?
1
int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

三方握手完成后,服务器调用 accept() 接受连接,如果服务器调用 accept() 时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来。cliaddr 是一个传出参数,accept() 返回时传出客户端的地址和端口号。addrlen 参数是一个传入传出参数(value-result argument),传入的是调用者提供的缓冲区 cliaddr 的长度以避免缓冲区溢出问题,传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区)。如果给 cliaddr 参数传 NULL,表示不关心客户端的地址。

服务器程序的主要结构如下:

?
1
2
3
4
5
6
7
8
9
while (1)
{
  cliaddr_len = sizeof(cliaddr);
  connfd = accept(listenfd,
      (struct sockaddr *)&cliaddr, &cliaddr_len);
  n = read(connfd, buf, MAXLINE);
  ......
  close(connfd);
}

整个是一个 while 死循环,每次循环处理一个客户端连接。由于 cliaddr_len 是传入传出参数,每次调用 accept( ) 之前应该重新赋初值。accept() 的参数 listenfd 是先前的监听文件描述符,而 accept() 的返回值是另外一个文件描述符 connfd,之后与客户端之间就通过这个 connfd 通讯,最后关闭 connfd 断开连接,而不关闭 listenfd,再次回到循环开头 listenfd 仍然用作 accept 的参数。

客户端程序

下面是客户端程序,它从命令行参数中获得一个字符串发给服务器,然后接收服务器返回的字符串并打印:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MAXLINE 80
#define SERV_PORT 8000
int main(int argc, char *argv[])
{
  struct sockaddr_in servaddr;
  char buf[MAXLINE];
  int sockfd, n;
  char *str;
  
  if (argc != 2)
  {
    fputs("usage: ./client message\n", stderr);
    exit(1);
  }
  str = argv[1];
  
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
  servaddr.sin_port = htons(SERV_PORT);
  
  // 由于客户端不需要固定的端口号,因此不必调用 bind(),客户端的端口号由内核自动分配。
  // 注意,客户端不是不允许调用 bind(),只是没有必要调用 bind() 固定一个端口号,
  // 服务器也不是必须调用 bind(),但如果服务器不调用 bind(),内核会自动给服务器分配监听端口,
  // 每次启动服务器时端口号都不一样,客户端要连接服务器就会遇到麻烦。
  connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
  write(sockfd, str, strlen(str));
  n = read(sockfd, buf, MAXLINE);
  printf("Response from server:\n");
  write(STDOUT_FILENO, buf, n);
  printf("\n");
  close(sockfd);
  return 0;
}

把上面的代码保存到文件 client.c 文件中,并执行下面的命令编译:

?
1
$ gcc client.c -o client

然后运行编译出来的 client 程序:

?
1
$ ./client hello

此时服务器端会收到请求并返回转换为大写的字符串,并输出相应的信息:

而客户端在发送请求后会收到转换过的字符串:

在客户端的代码中有两点需要注意:

1. 由于客户端不需要固定的端口号,因此不必调用 bind(),客户端的端口号由内核自动分配。
2. 客户端需要调用 connect() 连接服务器,connect 和 bind 的参数形式一致,区别在于 bind 的参数是自己的地址,而 connect 的参数是对方的地址。

至此我们已经使用 socket 技术完成了一个最简单的客户端服务器程序,虽然离实际应用还非常遥远,但就学习而言已经足够了。

提升服务器端的响应能力

虽然我们的服务器程序可以响应客户端的请求,但是这样的效率太低了。一般情况下服务器程序需要能够同时处理多个客户端的请求。可以通过 fork 系统调用创建子进程来处理每个请求,下面是大体的实现思路:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
listenfd = socket(...);
bind(listenfd, ...);
listen(listenfd, ...);
while (1)
{
  connfd = accept(listenfd, ...);
  n = fork();
  if (n == -1)
  {
    perror("call to fork");
    exit(1);
  }
  else if (n == 0)
  {
    // 在子进程中处理客户端的请求。
    close(listenfd);
    while (1)
    {
      read(connfd, ...);
      ...
      write(connfd, ...);
    }
    close(connfd);
    exit(0);
  }
  else
  {
    close(connfd);
  
}

此时父进程的任务就是不断的创建子进程,而由子进程去响应客户端的具体请求。通过这种方式,可以极大的提升服务器端的响应能力。

总结

本文通过一个简单的建基于 TCP 协议的网络程序介绍了 linux socket 编程中的基本概念。通过它我们可以了解到 socket 程序工作的基本原理,以及一些解决性能问题的思路。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

来源: https://www.jb51.net/article/135558.htm

 

-----

详解Linux Socket编程(不限Linux)

本篇文章主要介绍了Linux Socket编程,网络之间的通信全靠Socket,详细的介绍了Socket,有兴趣的同学可以了解一下。

我们深谙信息交流的价值,那网络中进程之间如何通信,如我们每天打开浏览器浏览网页时,浏览器的进程怎么与web服务器通信的?当你用QQ聊天时,QQ进程怎么与服务器或你好友所在的QQ进程通信?这些都得靠socket?那什么是socket?socket的类型有哪些?还有socket的基本函数,这些都是本文想介绍的。本文的主要内容如下:

1、网络中进程之间如何通信?

本地的进程间通信(IPC)有很多种方式,但可以总结为下面4类:

  • 消息传递(管道、FIFO、消息队列)
  • 同步(互斥量、条件变量、读写锁、文件和写记录锁、信号量)
  • 共享内存(匿名的和具名的)
  • 远程过程调用(Solaris门和Sun RPC)

但这些都不是本文的主题!我们要讨论的是网络中进程之间如何通信?首要解决的问题是如何唯一标识一个进程,否则通信无从谈起!在本地可以通过进程PID来唯一标识一个进程,但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题,网络层的“ip地址”可以唯一标识网络中的主机,而传输层的“协议+端口”可以唯一标识主机中的应用程序(进程)。这样利用三元组(ip地址,协议,端口)就可以标识网络的进程了,网络中的进程通信就可以利用这个标志与其它进程进行交互。

使用TCP/IP协议的应用程序通常采用应用编程接口:UNIX  BSD的套接字(socket)和UNIX System V的TLI(已经被淘汰),来实现网络进程之间的通信。就目前而言,几乎所有的应用程序都是采用socket,而现在又是网络时代,网络中进程通信是无处不在,这就是我为什么说“一切皆socket”。

2、什么是Socket?

上面我们已经知道网络中的进程是通过socket来通信的,那什么是socket呢?socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。我的理解就是Socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/写IO、打开、关闭),这些函数我们在后面进行介绍。

socket一词的起源

在组网领域的首次使用是在1970年2月12日发布的文献IETF RFC33中发现的,撰写者为Stephen Carr、Steve Crocker和Vint Cerf。根据美国计算机历史博物馆的记载,Croker写道:“命名空间的元素都可称为套接字接口。一个套接字接口构成一个连接的一端,而一个连接可完全由一对套接字接口规定。”计算机历史博物馆补充道:“这比BSD的套接字接口定义早了大约12年。”

3、socket的基本操作

既然socket是“open—write/read—close”模式的一种实现,那么socket就提供了这些操作对应的函数接口。下面以TCP为例,介绍几个基本的socket接口函数。

3.1、socket()函数

?
1
int socket(int domain, int type, int protocol);

socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字,而socket()用于创建一个socket描述符(socket descriptor),它唯一标识一个socket。这个socket描述字跟文件描述字一样,后续的操作都有用到它,把它作为参数,通过它来进行一些读写操作。

正如可以给fopen的传入不同参数值,以打开不同的文件。创建socket的时候,也可以指定不同的参数创建不同的socket描述符,socket函数的三个参数分别为:

  • domain:即协议域,又称为协议族(family)。常用的协议族有,AF_INET、AF_INET6、AF_LOCAL(或称AF_UNIX,Unix域socket)、AF_ROUTE等等。协议族决定了socket的地址类型,在通信中必须采用对应的地址,如AF_INET决定了要用ipv4地址(32位的)与端口号(16位的)的组合、AF_UNIX决定了要用一个绝对路径名作为地址。
  • type:指定socket类型。常用的socket类型有,SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等(socket的类型有哪些?)。
  • protocol:故名思意,就是指定协议。常用的协议有,IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等,它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议(这个协议我将会单独开篇讨论!)。

注意:并不是上面的type和protocol可以随意组合的,如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时,会自动选择type类型对应的默认协议。

当我们调用socket创建一个socket时,返回的socket描述字它存在于协议族(address family,AF_XXX)空间中,但没有一个具体的地址。如果想要给它赋值一个地址,就必须调用bind()函数,否则就当调用connect()、listen()时系统会自动随机分配一个端口。

3.2、bind()函数

正如上面所说bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。

?
1
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

函数的三个参数分别为:

•sockfd:即socket描述字,它是通过socket()函数创建了,唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。

•addr:一个const struct sockaddr *指针,指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同,如ipv4对应的是:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct sockaddr_in {
  sa_family_t  sin_family; /* address family: AF_INET */
  in_port_t   sin_port;  /* port in network byte order */
  struct in_addr sin_addr;  /* internet address */
};
/* Internet address. */
struct in_addr {
  uint32_t    s_addr;   /* address in network byte order */
};
ipv6对应的是:
struct sockaddr_in6 {
  sa_family_t   sin6_family;  /* AF_INET6 */
  in_port_t    sin6_port;   /* port number */
  uint32_t    sin6_flowinfo; /* IPv6 flow information */
  struct in6_addr sin6_addr;   /* IPv6 address */
  uint32_t    sin6_scope_id; /* Scope ID (new in 2.4) */
};
struct in6_addr {
  unsigned char  s6_addr[16];  /* IPv6 address */
};

Unix域对应的是:

?
1
2
3
4
5
6
#define UNIX_PATH_MAX  108
struct sockaddr_un {
  sa_family_t sun_family;        /* AF_UNIX */
  char    sun_path[UNIX_PATH_MAX]; /* pathname */
};

•addrlen:对应的是地址的长度。

通常服务器在启动的时候都会绑定一个众所周知的地址(如ip地址+端口号),用于提供服务,客户就可以通过它来接连服务器;而客户端就不用指定,有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind(),而客户端就不会调用,而是在connect()时由系统随机生成一个。

网络字节序与主机字节序

主机字节序就是我们平常说的大端和小端模式:不同的CPU有不同的字节序类型,这些字节序是指整数在内存中保存的顺序,这个叫做主机序。引用标准的Big-Endian和Little-Endian的定义如下:

a) Little-Endian就是低位字节排放在内存的低地址端,高位字节排放在内存的高地址端。

b) Big-Endian就是高位字节排放在内存的低地址端,低位字节排放在内存的高地址端。

网络字节序:4个字节的32 bit值以下面的次序传输:首先是0~7bit,其次8~15bit,然后16~23bit,最后是24~31bit。这种传输次序称作大端字节序。由于TCP/IP首部中所有的二进制整数在网络中传输时都要求以这种次序,因此它又称作网络字节序。字节序,顾名思义字节的顺序,就是大于一个字节类型的数据在内存中的存放顺序,一个字节的数据没有顺序的问题了。

所以:在将一个地址绑定到socket的时候,请先将主机字节序转换成为网络字节序,而不要假定主机字节序跟网络字节序一样使用的是Big-Endian。由于这个问题曾引发过血案!公司项目代码中由于存在这个问题,导致了很多莫名其妙的问题,所以请谨记对主机字节序不要做任何假定,务必将其转化为网络字节序再赋给socket。

3.3、listen()、connect()函数

如果作为一个服务器,在调用socket()、bind()之后就会调用listen()来监听这个socket,如果客户端这时调用connect()发出连接请求,服务器端就会接收到这个请求。

?
1
2
int listen(int sockfd, int backlog);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

listen函数的第一个参数即为要监听的socket描述字,第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的,listen函数将socket变为被动类型的,等待客户的连接请求。

connect函数的第一个参数即为客户端的socket描述字,第二参数为服务器的socket地址,第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

3.4、accept()函数

TCP服务器端依次调用socket()、bind()、listen()之后,就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后,就会调用accept()函数取接收请求,这样连接就建立好了。之后就可以开始网络I/O操作了,即类同于普通文件的读写I/O操作。

?
1
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

accept函数的第一个参数为服务器的socket描述字,第二个参数为指向struct sockaddr *的指针,用于返回客户端的协议地址,第三个参数为协议地址的长度。如果accpet成功,那么其返回值是由内核自动生成的一个全新的描述字,代表与返回客户的TCP连接。

注意:accept的第一个参数为服务器的socket描述字,是服务器开始调用socket()函数生成的,称为监听socket描述字;而accept函数返回的是已连接的socket描述字。一个服务器通常通常仅仅只创建一个监听socket描述字,它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字,当服务器完成了对某个客户的服务,相应的已连接socket描述字就被关闭。

3.5、read()、write()等函数

万事具备只欠东风,至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了,即实现了网咯中不同进程之间的通信!网络I/O操作有下面几组:

  • read()/write()
  • recv()/send()
  • readv()/writev()
  • recvmsg()/sendmsg()
  • recvfrom()/sendto()

我推荐使用recvmsg()/sendmsg()函数,这两个函数是最通用的I/O函数,实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <unistd.h>
 ssize_t read(int fd, void *buf, size_t count);
 ssize_t write(int fd, const void *buf, size_t count);
 #include <sys/types.h>
 #include <sys/socket.h>
 ssize_t send(int sockfd, const void *buf, size_t len, int flags);
 ssize_t recv(int sockfd, void *buf, size_t len, int flags);
 ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
        const struct sockaddr *dest_addr, socklen_t addrlen);
 ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
         struct sockaddr *src_addr, socklen_t *addrlen);
 ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
 ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

read函数是负责从fd中读取内容.当读成功时,read返回实际所读的字节数,如果返回的值是0表示已经读到文件的结束了,小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的,如果是ECONNREST表示网络连接出了问题。

write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数。失败时返回-1,并设置errno变量。 在网络程序中,当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于0,表示写了部分或者是全部的数据。2)返回的值小于0,此时出现了错误。我们要根据错误类型来处理。如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接)。

其它的我就不一一介绍这几对I/O函数了,具体参见man文档或者baidu、Google,下面的例子中将使用到send/recv。

3.6、close()函数

在服务器与客户端建立连接之后,会进行一些读写操作,完成了读写操作就要关闭相应的socket描述字,好比操作完打开的文件要调用fclose关闭打开的文件。

?
1
2
#include <unistd.h>
int close(int fd);

close一个TCP socket的缺省行为时把该socket标记为以关闭,然后立即返回到调用进程。该描述字不能再由调用进程使用,也就是说不能再作为read或write的第一个参数。

注意:close操作只是使相应socket描述字的引用计数-1,只有当引用计数为0的时候,才会触发TCP客户端向服务器发送终止连接请求。

4、socket中TCP的三次握手建立连接详解

我们知道tcp建立连接要进行“三次握手”,即交换三个分组。大致流程如下:

  • 客户端向服务器发送一个SYN J
  • 服务器向客户端响应一个SYN K,并对SYN J进行确认ACK J+1
  • 客户端再想服务器发一个确认ACK K+1

只有就完了三次握手,但是这个三次握手发生在socket的那几个函数中呢?请看下图:

图1、socket中发送的TCP三次握手

从图中可以看出,当客户端调用connect时,触发了连接请求,向服务器发送了SYN J包,这时connect进入阻塞状态;服务器监听到连接请求,即收到SYN J包,调用accept函数接收请求向客户端发送SYN K ,ACK J+1,这时accept进入阻塞状态;客户端收到服务器的SYN K ,ACK J+1之后,这时connect返回,并对SYN K进行确认;服务器收到ACK K+1时,accept返回,至此三次握手完毕,连接建立。

总结:客户端的connect在三次握手的第二个次返回,而服务器端的accept在三次握手的第三次返回。

5、socket中TCP的四次握手释放连接详解

上面介绍了socket中TCP的三次握手建立过程,及其涉及的socket函数。现在我们介绍socket中的四次握手释放连接的过程,请看下图:

图2、socket中发送的TCP四次握手

图示过程如下:

  • 某个应用进程首先调用close主动关闭连接,这时TCP发送一个FIN M;
  • 另一端接收到FIN M之后,执行被动关闭,对这个FIN进行确认。它的接收也作为文件结束符传递给应用进程,因为FIN的接收意味着应用进程在相应的连接上再也接收不到额外数据;
  • 一段时间之后,接收到文件结束符的应用进程调用close关闭它的socket。这导致它的TCP也发送一个FIN N;
  • 接收到这个FIN的源发送端TCP对它进行确认。

这样每个方向上都有一个FIN和ACK。

6、一个例子(实践一下)

说了这么多了,动手实践一下。下面编写一个简单的服务器、客户端(使用TCP)——服务器端一直监听本机的6666号端口,如果收到连接请求,将接收请求并接收客户端发来的消息;客户端与服务器端建立连接并发送一条消息。

服务器端代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#define MAXLINE 4096
int main(int argc, char** argv)
{
  int  listenfd, connfd;
  struct sockaddr_in   servaddr;
  char  buff[4096];
  int   n;
  if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){
  printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
  exit(0);
  }
  memset(&servaddr, 0, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(6666);
  if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){
  printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
  exit(0);
  }
  if( listen(listenfd, 10) == -1){
  printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
  exit(0);
  }
  printf("======waiting for client's request======\n");
  while(1){
  if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1){
    printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
    continue;
  }
  n = recv(connfd, buff, MAXLINE, 0);
  buff[n] = '\0';
  printf("recv msg from client: %s\n", buff);
  close(connfd);
  }
  close(listenfd);
}

客户端代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#define MAXLINE 4096
int main(int argc, char** argv)
{
  int  sockfd, n;
  char  recvline[4096], sendline[4096];
  struct sockaddr_in  servaddr;
  if( argc != 2){
  printf("usage: ./client <ipaddress>\n");
  exit(0);
  }
  if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
  printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);
  exit(0);
  }
  memset(&servaddr, 0, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_port = htons(6666);
  if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
  printf("inet_pton error for %s\n",argv[1]);
  exit(0);
  }
  if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){
  printf("connect error: %s(errno: %d)\n",strerror(errno),errno);
  exit(0);
  }
  printf("send msg to server: \n");
  fgets(sendline, 4096, stdin);
  if( send(sockfd, sendline, strlen(sendline), 0) < 0)
  {
  printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
  exit(0);
  }
  close(sockfd);
  exit(0);
}

当然上面的代码很简单,也有很多缺点,这就只是简单的演示socket的基本函数使用。其实不管有多复杂的网络程序,都使用的这些基本函数。上面的服务器使用的是迭代模式的,即只有处理完一个客户端请求才会去处理下一个客户端的请求,这样的服务器处理能力是很弱的,现实中的服务器都需要有并发处理能力!为了需要并发处理,服务器需要fork()一个新的进程或者线程去处理请求等。

7、动动手

留下一个问题,欢迎大家回帖回答!!!是否熟悉Linux下网络编程?如熟悉,编写如下程序完成如下功能:

服务器端:

接收地址192.168.100.2的客户端信息,如信息为“Client Query”,则打印“Receive Query”

客户端:

向地址192.168.100.168的服务器端顺序发送信息“Client Query test”,“Cleint Query”,“Client Query Quit”,然后退出。

题目中出现的ip地址可以根据实际情况定。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

 

来源:https://www.jb51.net/article/99377.htm

浅谈 Linux C语言 socket 网络编程

Linux C语言socket网络编程


注意:本文是按照 TCP、UDP的工作过程进行总结的

  1. TCP套 socket 接口编程:基于TCP的 客户/服务器(C/S)模式的工作过程如下:

服务器进程中的一些函数:


  1. socket():
    /*  函数所需头文件及其原型 */
    #include <sys/socket.h>
    int socket( int family, int type, int protocol);
    socketfd = soket(AF_INET, SOCK_STREAM, 0);
    /*  socketfd 作为返回值,可以记作描述符。
     若 socketfd 非负则表示成功,为负则表示失败。
     参数:
         family   -> 指明协议族
         type     -> 字节流类型
         protocol -> 一般置0.
     参数 family 的取值范围是:  
         AF_LOCAL    UNIX 协议族 
         AF_ROUTE    路由套接口  
            AF_INET      IPv4 协议  
            AF_INET6    IPv6 协议  
            AF_KEY       密钥套接口
        参数 type 的取值范围:   
            SOCK_STREAM   TCP 套接口  
            SOCK_DGRAM    UDP 套接口  
            SOCK_PACKET   支持数据链路访问  
            SOCK_RAM      原始套接口 
    */
    

    生成套接口描述字(套接字)后,要为套接口的地址数据结构进行赋初值。

    通用套接口地址的数据结构中,struct sockaddr_in 需要掌握:

    struct in_addr  {    
        in_addr_t s_addr;       
        /*32 位 IP 地址,网络字节序*/  
    }; 
    
    struct sockaddr_in  {    
        uint8 sin_len;    
        sa_family_t sin_family;    
        in_port_t sin_port;              
        /*16 位端口号,网络字节序*/    
        struct in_addr sin_addr;             
        char sin_zero[8];                
        /*备用的域,未使用*/  
    };
    

    PS:需要注意的是,一般在 socket() 之后,我们会填写 sockaddr 的相关内容。

     /* Fill the local socket address struct */
     memset (&servaddr,0,sizeof(servaddr));
     servaddr.sin_family = AF_INET;                      // Protocol Family
     servaddr.sin_port = htons (PORT);                   // Port number
     servaddr.sin_addr.s_addr  = htonl (INADDR_ANY);     // AutoFill local address
     
    
  2. bind():
 // 函数原型:
 #include <sys/socket.h>  
 int bind(int sockfd,const struct sockaddr *myaddr,socklen_t addrlen);
 /*
     参数 sockfd :套接字描述符。 
     参数 my_addr:指向 sockaddr 结构体的指针(该结构体中保存有端口和 IP 地址 信息)。 
     参数 addlen:结构体 sockaddr 的长度。
        
        返回:0──成功, -1──失败 
 */
 ret = bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr)); 

 /*  功能:当调用 socket 函数创建套接字后,该套接字并没有与 本机地址和端口等 信息相连,
     bind 函数将完成这些工作。
 */
  1. listen():
 //  函数原型:
 #include <sys/socket.h>  
 #include<sys/types.h>
 //  #define BACKLOG 10
 int listen(int sockfd,int backlog);

 /*
     参数 sockfd :套接字描述符。
     参数 backlog :规定内核为此套接口排队的最大选择个数。 
 */
 ret = listen(sockfd,BACKLOG);
 
 // 通常采用一下的异常处理:
 if(listen(listenfd,BACKLOG) == -1){  
     printf("ERROR: Failed to listen Port %d.\n", PORT);
     return (0);
 }
 else{
     printf("OK: Listening the Port %d sucessfully.\n", PORT);
 }

处在监听模式下后,程序就需要一个循环来实现挂起等待客户机请求。所以接下来的一步就是 接受客户机的请求。

  1. accept():

先来了解一下 accept() 这个函数:

//   函数原型:
#include <sys/socket.h>  
#include<sys/types.h> 
int accept(int sockfd,struct sockaddr *cliaddr,socklen_t *addrlen);

/*
 sockfd  参数:监听的  套接字描述符。 
 cliaddr 参数:指向结构体 sockaddr 的指针。  
 addrlen 参数:cliaddr 参数指向的内存空间的长度。 
*/

sin_size = sizeof(struct sockaddr_in);  
connect_fd = accept(sockfd,( struct sockaddr *)&their_addr,&sin_size); 

accept() 函数用于面向连接类型的套接字类型。
accept() 函数将从连接请求队列中获得连接信息,创建新的套 接字,并返回该套接字的文件描述符。
新创建的套接字用于服务器与客户机的通信,而原来的套接字仍然处于监听状态。
它们的区别在于:监听套接口描述字 只有一个,而且一直存在,
每一个连接都有一个已连接套接口描述字,当连接断开 时就关闭该描述字。

注意:bind 函数和 accept 函数的第三个参数是不一样的。

  1. close():
//   函数原型:
#include <unistd.h>  
int close(int sockfd); 
//   成功则返回 0,否则返回-1。 
//   功能:关闭套接口 其中参数 sockfd 是关闭的套接口描述字。 
//   当对一个套接口调用 close()时, 关闭该套接口描述字,并停止连接。

    以后这个套接口不能再使用,也不能再执行 任何读写操作,但关闭时已经排队准备发送的数据仍会被发出 使用完一个套接口后,一定要记得将它关掉,任何一个文件读写操作完毕之后, 都要关闭它的描述字。 

客户机进程中的一些函数:


  1. socket():这个函数前面提过,这里不必多说。

    创建套接字后,同理,也需要对套接口进行设置: (这是在客户端填充的服务器 端的资料)......

    bzero(&server_addr,sizeof(server_addr)); // 初始化,置 0 
    server_addr.sin_family=AF_INET;          // IPV4 
    server_addr.sin_port=htons(portnumber);  
    // (将本机器上的 short 数据转化为网络上的 short 数据)端口号,与服务器端 的端口号相同 
    server_addr.sin_addr=*((struct in_addr *)host->h_addr_list);  // IP 地址
    
  2. connect():
 connect(sockfd,(struct sockaddr *)(&server_addr), sizeof(structsockaddr)); 
    函数原型:
    #include <sys/types.h>  
    #include <sys/socket.h>  
    int connect(int sockfd,const struct sockaddr *serv_addr,int addrlen); 

 /*
     返回值:成功:返回 0 错误:返回-1,并将全局变量 errno 设置为相应的错误号。 
     参数 sockfd :数据发送的套接字,解决从哪里发送的问题,ockfd 是先前 socket 返回的值 
     参数 serv_addr:据发送的目的地,也就是服务器端的地址 
     参数 addrlen:指定 server_addr 结构体的长度 
 */

 函数功能:
 创建了一个套接口之后,使客户端和服务器连接。其实就是完成一个 有连接协议 的连接过程,
 对于 TCP 来说就是那个三段握手过程。

关于三段握手:( 《计算机网络》谢希仁编著 第七版中 将其定名为:" 三报文握手"):

​ 客户端先用 connect() 向服务器发出一个要求连接的信号 SYN1;

​ 服务器 进程接收到这个信号后,发回应答信号 ack1,同时这也是一个要求回答的信号 SYN2;

​ 客户端收到信号 ack1 和 SYN2 后,再次应答 ack2; 服务器收到应答信号 ack2,一次连接才算建立完成。

​ 从上面过程可以看出,服务器会收到两次信 号 SYN1 和 ack2,因此服务器进程需要两个队列保存不同状态的连接。刚接收 到 SYN1 信号时,连接还未完成,这时的连接放在一个名为“未完成连接”的队列中。接收到 ack2 信号后,三段握手完成,这时的连接放在名为“已完成连接” 的队列中,等待 accept() 调用。

关于 recv() 、send() 和 recvfrom() 、sendto() :


  1. 先说前两个:recv() 和 send() 都是基于 TCP 协议。

    不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。

    客户程序一般用send函数向服务器发送请求,而服务器则通常用send函数来向客户程序发送应答。

    同样,不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。

    //   函数原型:
    int send( SOCKET s, const char *buf, int len, int flags );
    int recv( SOCKET s, char *buf, int len, int flags );
    

    (1)recv 先等待 s 的发送缓冲中的数据被协议传送完毕,如果协议在传送 s 的发送缓冲中的数据时出现网络错误,那么recv函数返回 SOCKET_ERROR ;

    (2)如果 s 的发送缓冲中没有数据或者数据被协议成功发送完毕后,recv 先检查套接字 s 的接收缓冲区,如果 s 接收缓冲区中没有数据或者协议正在接收数据,那么 recv 就一直等待,直到协议把数据接收完毕。

    ​ 当协议把数据接收完毕,recv 函数就把 s 的接收缓冲中的数据 copy 到 buf 中(注意协议接收到的数据可能大于 buf 的长度,所以在这种情况下要调用几次 recv 函数才能把s的接收缓冲中的数据 copy 完。recv 函数仅仅是 copy 数据,真正的接收数据是协议来完成的);

    ​ 其中,recv 函数返回其实际 copy 的字节数。如果 recv 在 copy 时出错,那么它返回 SOCKET_ERROR;如果recv函数在等待协议接收数据时网络中断了,那么它返回 0。

  1. 然后是后两个:recvfrom() 和 sendto() 都是基于 UDP 协议。

    ​ 不同于 TCP 协议,UDP 提供的是一种无连接的、不可靠的数据包协议。它不对数据进行确认、出错重传、排序等可靠性处理,但是它却具有代码小、速度快和系统开销小等优点。对于某些应用程序,使用 UDP 来实现,将带来更大效率。

    ​ 与基于 TCP 协议的客户机/服务器模式的工作流程图相比较,它们的主要区别 在于:

    ​ 使用 TCP 套接口必须先建立连接(例如客户进程的 connect() ,服务器进程 的 **listen() **和 accept() ) 。

    ​ 而 UDP 套接口不需预先连接,它在调用 socket()生成一个套接口后,

    ​ -> 在服务器端调用 bind() 绑定众所周知的端口后, 服务器阻塞于 recvfrom() 调用,

    ​ -> 客户端调用 sendto() 发送数据请求,阻塞于 recvfrom() 调用,

    ​ -> 服务器端调用 recvfrom() 接收数据,服务器端也调用 sendto() 向客户发送数据作为应答,然后阻塞于 recvfrom() 调用,

    ​ -> 客户端 调用 recvfrom() 接收数据......

    ​ 当数据传输完成以后,UDP 套接口中的客户端调用 close() 断开连接,而 TCP 套接口中的客户端不必再发出“断开连接信号”来通知服务器端关闭连接。

    ​ 一些重要的应用程序,如域名服务系统 DNS、网络文件 系统 NFS 都使用 UDP 套接口。

    //   函数原型:
    #include <sys/socket.h>   
    int recvfrom(int sockfd, void *buff, int len,int flags, struct sockaddr *fromaddr, int *addrlen);
    /*
     参数 sockfd 为套接口描述字;  
     参数 buff 为指向读缓冲的指针;  
     参数 len 为读的字节数;  
     参数 flags 一般设置为 0;  
     参数 fromaddr 为指向数据接收的套接口地址结构的指针;  
     参数 addrlen 为套接口结构长度。
     
     函数返回实际读的字节数,可以为 0,如果出错,则返回-1。
    */
    
    
    int sendto(int sockfd, void *mes,int len, int flags, struct sockaddr *toaddr, int *addrlen); 
    /*
     参数 mes 为指向写缓冲的指针;  
     参数 toaddr 为指向数据发送的套接口地址结构的指针; 
     
     函数返回实际写的字节数,可以为 0,如果出错,则返回-1。 
    */

来源:https://www.jianshu.com/p/f19578165383

 

socket网络编程 - socket()
名称:
socket - 创建一个通信端点

概要:
#include          /* See NOTES */
#include

int socket(int domain, int type, int protocol);

描述:
socket()创建一个用于通信的端点,并返回引用该端点的文件描述符。

domain参数指定通信域; 这个参数选定用于通信的协议族。
这些协议域在中定义。目前理解的格式包括:

名称              目的           操作说明
AF_UNIX, AF_LOCAL      本地通信          unix(7)
AF_INET             IPv4因特网协议           ip(7)
AF_INET6             IPv6因特网协议           ipv6(7)
AF_IPX               IPX - Novell协议
AF_NETLINK           内核用户接口驱动        netlink(7)
AF_X25              ITU-T X.25/ISO-8208协议     x25(7)
AF_AX25             Amateur radio AX.25 协议
AF_ATMPVC           Access to raw ATM PVCs
AF_APPLETALK        Mac机所用的网络协议之一       ddp(7)
AF_PACKET            低层数据包接口         packet(7)
AF_ALG               内核加密API接口

socket具有指定的type,用以指定通信语义。目前定义的类型有:

SOCK_STREAM      提供顺序的,可靠的双向的基于连接的字节流。
可能支持带外数据传输机制。

SOCK_DGRAM       支持数据报(无连接,最大长度固定的不可靠消息)。

SOCK_SEQPACKET     为固定最大长度的数据报提供顺序可靠的双向的基于连接的
数据传输路径; 每个输入系统调用需要消费者读取整个数据包。

SOCK_RAW         提供原始网络协议访问。

SOCK_RDM         提供不保证顺序的可靠数据报层。

SOCK_PACKET       过时的且不应该在新程序中使用; 见packet(7)。

所有协议族可能都不实现某些套接字类型。

自从2.6.27版本以来,type参数用于第二个目的:除了指定套接字类型之外,
它还可能包含以下任何值的按位OR,以修改socket()的行为:

SOCK_NONBLOCK    在新打开的文件描述中设置O_NONBLOCK文件状态标志。
使用此标志可以节省对fcntl(2)的额外调用,以获得相同的结果。

SOCK_CLOEXEC      在新的文件描述符上设置close-on-exec (FD_CLOEXEC)标志。
有关这可能有用的原因,请参阅open(2)中的O_CLOEXEC标志的说明。

参数protocol指定了与socket一起使用的特定协议。通常对给定protocol
family中的特定socket type,只存在一个protocol可以支持,在这种情况下
protocol可以指定为0。然而,可能存在很多protocol,在这种情况下,
必须以这种方式指定特定的协议。protocol number用于指定进行通信的
"communication domain";见protocols(5)。关于如何将协议名称字符串映射到协议号,
请参阅getprotoent(3)。

SOCK_STREAM类型的套接字是全双工字节流。它们不保留记录边界。流套接字必须处于
连接状态,才能发送或接收任何数据。使用connect(2)调用创建与另一个套接字的连接。
一旦连接,可以使用read(2)和write(2)调用或send(2)和recv(2)调用的某些变体来
传输数据。会话完成后,可以执行close(2)。带外数据也可以如send(2)中所述发送,
如recv(2)所述接收。

通信协议SOCK_STREAM的实现确保了数据不丢失或重复。如果对等协议具有缓冲区空间
的一条数据不能在合理的时间长度内成功发送,那么连接被认为是死机。当在套接字上
启用SO_KEEPALIVE时,如果另一端仍然存在,协议将以协议指定的方式进行检查。如果
程序在broken stream中发送或接收,则会产生SIGPIP信号; 这导致naive processes,
该程序不处理信号,直接退出。SOCK_SEQPACKET套接字采用与SOCK_STREAM套接字相同
的系统调用。唯一的区别是read(2)调用将仅返回所请求的数据量,并且到达的数据包
中剩余的任何数据将被丢弃。传入数据报中的所有消息边界也被保留。

SOCK_DGRAM和SOCK_RAW sockets允许将数据报发送到在sendto(2)调用中命名的通讯员。
数据报通常用recvfrom(2)接收,它返回下一个数据报及其发送者的地址。

SOCK_PACKET是一种过时的套接字类型,可直接从设备驱动程序接收原始数据包。使用
packet(7)代替。

fcntl(2)F_SETOWN操作可用于指定进程或进程组,以接收外带数据到达时的信号SIGURG,
或接收连接意外断开时的信号SOCK_STREAM。此操作也可以通过使用SIGIO设置进程或进程组
接收I/O和I/O事件的异步通知。使用F_SETOWN等效于使用FIOSETOWN或SIOCSPGRP参数的
ioctl(2)调用。

当网络向协议模块发送错误状况(例如,使用IPMP消息的IP)时,为套接字设置挂起的错误
标志。此套接字上的下一个操作将返回挂起错误的错误代码。对于某些协议,可以启用每个
套接字错误队列来检索关于错误的详细信息; 请参阅ip(7)中的IP_RECVERR。

套接字的操作由套接字级别选项控制。这些选项在中定义。
函数setsockopt(2)和getsockopt(2)分别用于设置和获取选项。

返回值:
成功时,将返回新套接字的文件描述符,
出错时,将返回-1,相应的错误信息记录在errno中。

错误:
EACCES 创建指定类型和/或协议的套接字的权限被拒绝。

EAFNOSUPPORT 该实现不支持指定的地址族。

EINVAL 未知协议或协议族不可用

EINVAL type参数无效

EMFILE 已达到每个进程的打开文件描述符数的限制。

ENFILE 已经达到了系统的打开文件总数的限制。

ENOBUFS 或 ENOMEM 内存不足。在释放足够的资源之前,无法创建套接字。

EPROTONOSUPPORT 该域(domain)中不支持协议类型或指定的协议。

底层协议模块可能会生成其他错误。

遵循:
POSIX.1-2001, POSIX.1-2008, 4.4BSD.

SOCK_NONBLOCK和SOCK_CLOEXEC标志是Linux特有的。

socket()出现在4.2BSD中。通常对支持BSD套接层(包括系统V变体)克隆的
非BSD系统是可移植的。

注意:
POSIX.1不要求包含,且Linux也不要求包含这个头文件。然而,
然而,一些历史的(BSD)实现需要这个头文件,并且对可移植程序来说,
包含它是可能是明智的选择。

在4.x BSD下用于协议族的清单常数是PF_UNIX,PF_INET等,AF_UNIX,AF_INET等
用于地址族。然而,BSD手册页已经承诺:“协议族通常与地址族相同”,随后的
标准使用AF_*。

在Linux 2.6.38中添加了AF_ALG协议类型。有关此接口的更多信息,请参阅内核HTML文档:

https://www.kernel.org/doc/htmldocs/crypto-API/User.html。

示例:
getaddrinfo(3)中展示了使用socket()的示例。

另请参考:
accept(2), bind(2), close(2), connect(2), fcntl(2), getpeername(2),
getsockname(2), getsockopt(2), ioctl(2), listen(2), read(2), recv(2),
select(2), send(2), shutdown(2), socketpair(2), write(2),
getprotoent(3), ip(7), socket(7), tcp(7), udp(7), unix(7)

“一个4.3BSD进程间通信教程介绍”和“BSD进程间通信教程”,
转载于UNIX Programmer's Supplementary Documents Volume 1。

版本记录:
本页面是Linux man-pages项目的4.10版本的一部分。
有关项目的描述,相关错误报告信息以及本页面的最新版本,
请参见https://www.kernel.org/doc/man-pages/。

Linux            2015-12-28            SOCKET(2)

 

mybatis中关于example类

这几天刚接触example,很多内容都是破碎的,写一篇文章加深理解。

一、什么是example类

mybatis-generator会为每个字段产生Criterion,为底层的mapper.xml创建动态sql。如果表的字段比较多,产生的example类会十分庞大。理论上通过example类可以构造你想到的任何筛选条件。在mybatis-generator中加以配置,配置数据表的生成操作就可以自动生成example了。具体配置可以参考 Mybatis-Generator的具体使用方法 - zorro的菜鸟笔记 - 博客园。

参考资料:http://www.mybatis.org/mybatis-dynamic-sql/docs/introduction.html

下面是mybatis自动生成example的使用。

二、了解example成员变量

 //作用:升序还是降序
 //参数格式:字段+空格+asc(desc)
 protected String orderByClause;  
 //作用:去除重复
 //true是选择不重复记录,false,反之
 protected boolean distinct;
 //自定义查询条件
 //Criteria的集合,集合中对象是由or连接
 protected List<Criteria> oredCriteria;
 //内部类Criteria包含一个Cretiron的集合,
 //每一个Criteria对象内包含的Cretiron之间是由  AND连接的
 public static class Criteria extends GeneratedCriteria {
  protected Criteria() {super();}
 }
 //是mybatis中逆向工程中的代码模型
 protected abstract static class GeneratedCriteria {......}
 //是最基本,最底层的Where条件,用于字段级的筛选
 public static class Criterion {......}

三、example使用前的准备

比如我的example是根据user表生成的,UserMapper属于dao层,UserMapper.xml是对应的映射文件。

UserMapper接口
long countByExample(CompetingStoreExample example);
List<CompetingStore> selectByExample(CompetingStoreExample example);

在我们的测试类里
UserExample example = new UserExample();
UserExample.Criteria criteria = example.createCriteria();

四、查询用户数量

 long count = UserMapper.countByExample(example);

类似于:select count(*) from user

五、where条件查询或多条件查询

 example.setOrderByClause(age asc"); //升序
 example.setDistinct(false); //不去重
 if(!StringUtils.isNotBlank(user.getName())){
 Criteria.andNameEqualTo(user.getName());
 }
 if(!StringUtils.isNotBlank(user.getSex())){
 Criteria.andSexEqualTo(user.getSex());
 }
 List<User> userList=userMapper.selectByExample(example);

类似于:select * from user where name={#user.name} and sex={#user.sex} order by age asc;

 UserExample.Criteria criteria1 = example.createCriteria();
 UserExample.Criteria criteria2 = example.createCriteria();
 if(!StringUtils.isNotBlank(user.getName())){
 Criteria1.andNameEqualTo(user.getName());
 }
 if(!StringUtils.isNotBlank(user.getSex())){
 Criteria2.andSexEqualTo(user.getSex());
 }
 Example.or(criteria2);
 List<User> userList=userMapper.selectByExample(example);

类似于:select * from user where name={#user.name} or sex={#user.sex} ;

六、模糊查询

 if(!StringUtils.isNotBlank(user.getName())){
 criteria.andNameLIke(%+name+%);
 }
 List<User> userList=userMapper.selectByExample(example);

类似于:select * from user where name like %{#user.name}%

七、分页查询

 int start = (currentPage - 1) * rows;
 //分页查询中的一页数量
 example.setPageSize(rows); 
 //开始查询的位置
 example.setStartRow(start);  
 List<User> userList=userMapper.selectByExample(example);

类似于:select * from user limit start to rows

如果喜欢我的文章欢迎关注我的专栏~

-----------

要使用example类,先要在项目中导入mybatis.mapper的jar包。

Mapper接口中包含了单表的增删改查以及分页功能。

给出实例:

CountryMappermapper = sqlSession.getMapper(Country.class);

//Country.class是实体类

//查询操作

List<Country>cList = mapper.select(new Country());

现在使用Example查询

Example example =new Example(Country.class);

example.createCriteria().andEqualTo(“id”,100);

//这里给出查询为id=100

cList = mapper.selectByExample(example);

 

example.setOrderByClause(“字段名ASC”); 以某字段升序排序

example.setDistinct(false)//去除重复,boolean型,true为选择不重复的记录

selectByExample()返回的是一个集合

mybatis中mapper的实例函数:
int countByExample(UserExample example) thorws SQLException:按条件计数。
int deleteByPrimaryKey(Integer id) thorws SQLException:按主键删除。
int deleteByExample(UserExample example) thorws SQLException:按条件删除。
String/Integer insert(User record) thorws SQLException:插入(返回值为id值)
User selectByPrimaryKey(Integer id) thorws SQLException:按主键查询。
List<?>selectByExample(UserExample example) thorws SQLException:按条件查询
List<?>selectByExampleWithBLOGs(UserExample example) thorws SQLException:按

条件查询(包括BLOB字段)。只有当数据表中的字段类型有为二进制的才会产生。
int updateByPrimaryKey(User record) thorws SQLException:按主键更新
int updateByPrimaryKeySelective(User record) thorws SQLException:按主键更新值不为null的字段

int updateByExample(User record, UserExample example) thorws SQLException: 按条件更新

int updateByExampleSelective(User record, UserExample example)thorws

SQLException:按条件更新值不为null的字段

mybatis中mapper的实例函数详解:
selectByPrimaryKey()

Country country = ##Mapper.selectByPrimaryKey(100);

相当于select * from user where id = 100

还有一些方法不在这里赘述,可以参考mybatis中的example

Example类是什么?

Example类指定如何构建一个动态的where子句. 表中的每个non-BLOB列可以被包括在where子句中. 例子是展示此类用法的最好方式.

Example类可以用来生成一个几乎无限的where子句.

Example类包含一个内部静态类 Criteria 包含一个用 anded 组合在where子句中的条件列表. Example类包含一个 List 属性,所有内部类Criteria中的子句会用 ored组合在一起. 使用不同属性的 Criteria 类允许您生成无限类型的where子句.

创建 Criteria 对象 可以使用Example类中的 createCriteria() 或者 or() . 如果 Criteria 对象是用 createCriteria() 创建的,它会自动为 List 属性添加一个 Criteria 对象 - 这使得它更容易写一个简单的where子句, 如果您不需要 or 或者其他几个子句组合的话. 用 or(Criteria criteria) 方法创建 Criteria 对象, 方法里的 criteria 对象会被添加进 Criteria 对象的列表中.

重要 我们推荐您只使用 or() 方法创建 Criteria 对象. 我们相信这种方法使代码更有可读性.

如何生成Example类?

mybatis的的配置文件可以使用mybatis-generator工具生成,它就可以帮我们生成example类。
根据 Mybatis 代码生成工具文档,需要一个配置文件,这里命名为:mbgConfiguration.xml放在 src 目录下. 配置文件内容如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE generatorConfiguration
      PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
      "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

    <generatorConfiguration>

      <!-- 配置mysql 驱动jar包路径.用了绝对路径 -->
      <classPathEntry location="D:\Work\Java\eclipse\workspace\myBatisGenerator\WebContent\WEB-INF\lib\mysql-connector-java-5.1.22-bin.jar" />

      <context id="yihaomen_mysql_tables" targetRuntime="MyBatis3">

        <!-- 为了防止生成的代码中有很多注释,比较难看,加入下面的配置控制 -->
        <commentGenerator>
          <property name="suppressAllComments" value="true" />
          <property name="suppressDate" value="true" />
        </commentGenerator>
        <!-- 注释控制完毕 -->

        <!-- 数据库连接 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"
            userId="root"
            password="password">
        </jdbcConnection>

        <javaTypeResolver >
          <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- 数据表对应的model 层  -->
        <javaModelGenerator targetPackage="com.yihaomen.model" targetProject="src">
          <property name="enableSubPackages" value="true" />
          <property name="trimStrings" value="true" />
        </javaModelGenerator>

        <!-- sql mapper 隐射配置文件 -->
        <sqlMapGenerator targetPackage="com.yihaomen.mapper"  targetProject="src">
          <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>

        <!-- 在ibatis2 中是dao层,但在mybatis3中,其实就是mapper接口 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.yihaomen.inter"  targetProject="src">
          <property name="enableSubPackages" value="true" />
        </javaClientGenerator>

        <!-- 要对那些数据表进行生成操作,必须要有一个. -->
        <table schema="mybatis" tableName="category" domainObjectName="Category" 
            enableCountByExample="false" enableUpdateByExample="false"
            enableDeleteByExample="false" enableSelectByExample="false"
            selectByExampleQueryId="false">     
        </table>

      </context>
    </generatorConfiguration>

 

当我们需要生成example类的时候,需要table里面去掉

enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
selectByExampleQueryId="false"

 

 

example如何使用?

简单查询

这个例子展示了如何用生成后的Example类去生成一个简单的where子句:

TestTableExample example = new TestTableExample();

example.createCriteria().andField1EqualTo(5);
作为另一种选择, 下面的方式也是可以的:

TestTableExample example = new TestTableExample();

example.or().andField1EqualTo(5);
在上面的例子中, 动态生成的where子句是:

where field1 = 5

下面的例子展示了如何用生成后的Example类去生成一个复杂的where子句 (用到了 JSE 5.0 的泛型):

TestTableExample example = new TestTableExample();

example.or()
.andField1EqualTo(5)
.andField2IsNull();

example.or()
.andField3NotEqualTo(9)
.andField4IsNotNull();

List field5Values = new ArrayList();
field5Values.add(8);
field5Values.add(11);
field5Values.add(14);
field5Values.add(22);

example.or()
.andField5In(field5Values);

example.or()
.andField6Between(3, 7);

在上面的例子中, 动态生成的where子句是:

where (field1 = 5 and field2 is null)
or (field3 <> 9 and field4 is not null)
or (field5 in (8, 11, 14, 22))
or (field6 between 3 and 7)
将会返回满足这些条件的记录结果.

去重复查询
您可以在所有的Example类中调用 setDistinct(true) 方法进行强制去重复查询.

Criteria类
Criteria 内部类的每个属性都包含 andXXX 方法,以及如下的标准的SQL查询方法:

IS NULL - 指相关的列必须为NULL
IS NOT NULL - 指相关的列必须不为NULL
= (equal) - 指相关的列必须等于方法参数中的值
<> (not equal) - 指相关的列必须不等于方法参数中的值

(greater than) - 指相关的列必须大于方法参数中的值
= (greater than or equal) - 指相关的列必须大于等于方法参数中的值
< (less than) - 指相关的列必须小于于方法参数中的值
<= (less than or equal) - 指相关的列必须小于等于方法参数中的值
LIKE - 指相关的列必须 “like” 方法参数中的值. 这个方法不用必须加入 ‘%’, 您必须设置方法参数中的值.
NOT LIKE - 指相关的列必须 “not like” 方法参数中的值. 这个方法不用必须加入 ‘%’, 您必须设置方法参数中的值.
BETWEEN - 指相关的列必须在 “between” 方法参数中的两个值之间.
NOT BETWEEN - 指相关的列必须不在 “not between” 方法参数中的两个值之间.
IN - 指相关的列必须在传入的方法参数的list中.
NOT IN - 指相关的列必须不在传入的方法参数的list中.

        之前用Mybatis框架反向的实体,还有实体里面的Example,之前只是知道Example里面放的是条件查询的方法,可以一直不知道怎么用,到今天才开始知道怎么简单的用。

在我们前台查询的时候会有许多的条件传过来:先看个例子:

  1. public List<Contact> searchByExample(Contact contact) {
  2. System.out.println("searchByExampleContact");
  3. ContactExample example = new ContactExample();
  4. ContactExample.Criteria cri = example.createCriteria();
  5. // //////////////////////////////////////////////////////////
  6. if (this.objectAttrNullCheck(contact, "username"))
  7. cri.andUsernameEqualTo(contact.getUsername());
  8. if (this.objectAttrNullCheck(contact, "password"))
  9. cri.andPasswordEqualTo(contact.getPassword());
  10. ContactMapper vcontactMapper = sqlSession
  11. .getMapper(ContactMapper.class);
  12. List<Contact> returnList = vcontactMapper.selectByExample(example);
  13. return returnList;
  14. }

这是简单的用户登录的后台代码,example中有一个Criterria的方法,里面

andUsernameEqualTo  
andPasswordEqualTo

都是在生成example的时候生成的。这两个方法是判断单值的。简单介绍下,都是百度的:

  • Criteria

Criteria包含一个Cretiron的集合,每一个Criteria对象内包含的Cretiron之间是由AND连接的,是逻辑与的关系。

oredCriteria

Example内有一个成员叫oredCriteria,是Criteria的集合,就想其名字所预示的一样,这个集合中的Criteria是由OR连接的,是逻辑或关系。oredCriteria就是ORed Criteria。

其他

Example类的distinct字段用于指定DISTINCT查询。

orderByClause字段用于指定ORDER BY条件,这个条件没有构造方法,直接通过传递字符串值指定。

  1. import java.io.IOException;
  2. import java.io.Reader;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  9. import org.apache.log4j.pattern.ClassNamePatternConverter;
  10. import org.springframework.context.ApplicationContext;
  11. import org.springframework.context.support.ClassPathXmlApplicationContext;
  12. import cn.itcast.ssm.mapper.ItemsMapper;
  13. import cn.itcast.ssm.po.ItemsExample;
  14. public class Student {
  15. public static void main(String[] args) throws IOException {
  16. /*方式一 */
  17. ItemsExample itemsExample1 = new ItemsExample();
  18. itemsExample1.or().andIdEqualTo(5).andNameIsNotNull();
  19. itemsExample1.or().andPicEqualTo("xxx").andPicIsNull();
  20. List<Integer> fieldValues = new ArrayList<Integer>();
  21. fieldValues.add(8);
  22. fieldValues.add(11);
  23. fieldValues.add(14);
  24. fieldValues.add(22);
  25. itemsExample1.or().andIdIn(fieldValues);
  26. itemsExample1.or().andIdBetween(5, 9);
  27. /* 方式二 criteria1与criteria2是or的关系 */
  28. ItemsExample itemsExample2 = new ItemsExample();
  29. ItemsExample.Criteria criteria1 = itemsExample2.createCriteria();
  30. criteria1.andIdIsNull();
  31. criteria1.andPriceEqualTo((float) 3);
  32. ItemsExample.Criteria criteria2 = itemsExample2.createCriteria();
  33. criteria2.andNameIsNull();
  34. criteria2.andIdGreaterThanOrEqualTo(5);
  35. itemsExample2.or(criteria2);
  36. //方式一和方式二是等价的
  37. // spring获取mapper代理对象
  38. ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
  39. ItemsMapper itemsMapper = (ItemsMapper) applicationContext.getBean("itemsMapper");
  40. itemsMapper.countByExample(itemsExample2);
  41. // 获取SqlSessionFactory
  42. String resource = "SqlMapConfig.xml";
  43. Reader reader = Resources.getResourceAsReader(resource);
  44. SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
  45. // 获取SqlSession
  46. SqlSession sqlSession = sqlMapper.openSession();
  47. }
  48. }

avaBeans类的成员变量一般称为属性(property)。对每个属性访问权限一般定义为private或protected,而不是定义为public的。注意:属性名必须以小写字母开头。对每个属性,一般定义两个public方法,它们分别称为访问方法(getter)和修改方法(setter),允许容器访问和修改bean的属性。

public String getColor();

public void setColor(String);

一个例外是当属性是boolean类型时,访问器方法应该定义为isXxx()形式。

对象类型

虽然可以明确的引用对象的属性名了,但如果要在if元素中测试传入的user参数,仍然要使用_parameter来引用传递进来的实际参数,因为传递进来的User对象的名字是不可考的。如果测试对象的属性,则直接引用属性名字就可以了。

测试user对象:

<if test="_parameter != null">

传入对象属性

<if test="name != null">

 

map类型

传入map类型,直接通过#{keyname}就可以引用到键对应的值。使用@param注释的多个参数值也会组装成一个map数据结构,和直接传递map进来没有区别。

mapper接口:

int updateByExample(@Param("user") User user, @Param("example") UserExample example);

sql映射:

  1. <update id="updateByExample" parameterType="map" >
  2. update tb_user
  3. set id = #{user.id,jdbcType=INTEGER},
  4. ...
  5. <if test="_parameter != null" >
  6. <include refid="Update_By_Example_Where_Clause" />
  7. </if>

注意这里测试传递进来的map是否为空,仍然使用_parameter以上参考:http://blog.51cto.com/tianxingzhe/1741268

再来看看我的项目中的,我写的是项目的接口开发,前端要穿写条件进来查询,前端的传参格式:

  1. 传参格式:
  2. * {
  3. "currPage": 0,
  4. "startRow": 0,
  5. "pageSize": 20,
  6. "map":{
  7. "andStealtollTypeEqualTo":1
  8. }
  9. }

注意map里面的传的参数格式:全部是example里面的参数格式,如果还要传入什么参数直接在里面加(相当于前端传过来的条件),这些条件全部放进map里面,

  1. HisVehReviewHandleExample example = new HisVehReviewHandleExample();
  2. example.setPage(page);//将前面传过来的page数据放进example中
  3. popQeuryExample(example.getPage().getMap(), example.createCriteria());
  4. vehReviewService.queryPage(example);
  5. Map<String, Object> map = new HashMap<String, Object>();
  6. map.put("page", page);
  7. //map.put("typeCount", value);
  8. result.setData(map);
  9. writeJson(response, JSON.toJSON(result));

service层:

  1. public Page<HisVehReviewHandle> queryPage(HisVehReviewHandleExample example) {
  2. Page<HisVehReviewHandle> page = example.getPage();
  3. List<HisVehReviewHandle> list = HisVehReviewHandleMapper.selectByExample(example);
  4. System.out.println("查询list成功"+list.get(0).getStealtollType()+" "+list.get(0).getStealtollTypeName());
  5. int count = HisVehReviewHandleMapper.countByExample(example);
  6. page.setRows(list);
  7. page.setTotalCount(count);
  8. return page;
  9. }

sql语句查询exaple的:

  1. <select id="selectByExample" parameterType="com.vrview.ssm.model.example.HisVehReviewHandleExample" resultMap="BaseResultMap">
  2. <!--
  3. WARNING - @mbggenerated
  4. This element is automatically generated by MyBatis Generator, do not modify.
  5. This element was generated on Wed Jan 17 10:03:58 CST 2018.
  6. -->
  7. <include refid="OracleDialectPrefix" />
  8. select
  9. <if test="distinct">
  10. distinct
  11. </if>
  12. <include refid="Base_Column_List" />
  13. from HIS_VEH_REVIEW_HANDLE
  14. <if test="_parameter != null">
  15. <include refid="Example_Where_Clause" />
  16. </if>
  17. <if test="orderByClause != null">
  18. order by ${orderByClause}
  19. </if>
  20. <include refid="OracleDialectSuffix" />
  21. </select>

sql语句,用来查询数量的:

  1. <select id="countByExample" parameterType="com.vrview.ssm.model.example.HisVehReviewHandleExample" resultType="java.lang.Integer">
  2. <!--
  3. WARNING - @mbggenerated
  4. This element is automatically generated by MyBatis Generator, do not modify.
  5. This element was generated on Wed Jan 17 10:03:58 CST 2018.
  6. -->
  7. select count(*) from HIS_VEH_REVIEW_HANDLE
  8. <if test="_parameter != null">
  9. <include refid="Example_Where_Clause" />
  10. </if>
  11. </select>

关于参数_paramerter:参考:http://blog.csdn.net/u014476019/article/details/45878771
这部分就是对criteria里面的参数进行判断,进而根据条件查询。

  1. <sql id="Example_Where_Clause">
  2. <where>
  3. <foreach collection="oredCriteria" item="criteria" separator="or">
  4. <if test="criteria.valid">
  5. <trim prefix="(" prefixOverrides="and" suffix=")">
  6. <foreach collection="criteria.criteria" item="criterion">
  7. <choose>
  8. <when test="criterion.noValue">//没有值
  9. and ${criterion.condition}
  10. </when>
  11. <when test="criterion.singleValue">//单个值
  12. and ${criterion.condition} #{criterion.value}
  13. </when>
  14. <when test="criterion.betweenValue">//区间值,范围查询
  15. and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
  16. </when>
  17. <when test="criterion.listValue">//一组值
  18. and ${criterion.condition}
  19. <foreach close=")" collection="criterion.value" item="listItem" open="(" separator=",">
  20. #{listItem}
  21. </foreach>
  22. </when>
  23. </choose>
  24. </foreach>
  25. </trim>
  26. </if>
  27. </foreach>
  28. </where>
  29. </sql>

Mybatis动态sql语句

1、MyBatis中#{ }和${ }的区别

在 mapper 中定义的参数传到 xml 中之后,在查询之前 mybatis 会对其进行动态解析。mybatis 为我们提供了两种支持动态 sql 的语法:#{} 以及 ${},他们都可以用来动态传递参数,补全SQL语句。

#{"参数名"}在SQL中相当于一个参数占位符“?”,用来补全预编译语句。它补全预编译语句时,可以理解为在此参数值两端加了单引号。举例如下,当需要动态的按id查询用户信息时。

select * from my_user where id = #{id};
如果我们为id赋值为1,这条SQL执行效果相当于下面的SQL。

select * from my_user where id = '1';
由于预编译SQL使用PreparedStatement对象抽象预编译语句,之后使用也无需再次编译,而且能够防止注入式攻击。所以,虽然这时候两种方式得到相同的结果,但是只要能够使用#{ }解决,我们都应该使用#{ }。

${"参数名"}就是单纯的字符串拼接,拼接完成后才会对SQL进行编译、执行,所以性能较低,也无法复用。但是在有些#{ }无法胜任的地方,还是会需要${ }来完成。比如当SQL中数据库表名为参数时,如果使用#{ },如下所示。

select * from #{tableName};
当我们为tableName赋值为"my_user"时,相当于执行以下SQL。

select * from 'my_user';
由于表名不能加单引号,所以语法错误。这时候就需要使用${ }来进行字符串拼接。

select * from ${tableName};

为tableName赋值为"my_user"后,相当于执行以下SQL。

select * from my_user;

2、动态sql语句书写

(1)、使用 if 标签

例:根据性别和名字查询用户

<!--如果不用if标签,做条件判断,如果查询条件为null或"",就会报 异常-->
<select id="queryUserByWhere" parameterType="user" resultType="user">
    SELECT id, username, birthday, sex, address FROM `user`
    WHERE 1=1
    <if test="sex != null and sex != ''">
        AND sex = #{sex}
    </if>
    <if test="username != null and username != ''">
        AND username LIKE
        '%${username}%'
    </if>
</select>

(2)、使用Where标签

为什么要使用Where标签?

想想下面的例子,如果我要根据两个字段性别和用户名进行查询,但是放在前面的查询条件没有给值,这时候我们就必须在where 后面写1=1,很麻烦,可以使用where标签进行改造。

例:根据性别和名字查询用户

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
    SELECT id, username, birthday, sex, address FROM `user`
<!-- where标签可以自动添加where,同时处理sql语句中第一个and关键字 -->
    <where>
        <if test="sex != null">
            AND sex = #{sex}
        </if>
        <if test="username != null and username != ''">
            AND username LIKE
            '%${username}%'
        </if>
    </where>
</select>

(3)、使用sql片段

Sql中可将重复的sql提取出来,使用时用include引用即可,最终达到sql重用的目的。

<!-- 声明sql片段 -->
<sql id="userFields">
    id, username, birthday, sex, address
</sql>

<!-- 根据条件查询用户 -->
<select id="queryUserByWhere" parameterType="user" resultType="user">
    <!-- SELECT id, username, birthday, sex, address FROM `user` -->
    <!-- 使用include标签加载sql片段;refid是sql片段id -->
    SELECT <include refid="userFields" /> FROM `user`
    <!-- where标签可以自动添加where关键字,同时处理sql语句中第一个and关键字 -->
    <where>
        <if test="sex != null">
            AND sex = #{sex}
        </if>
        <if test="username != null and username != ''">
            AND username LIKE
            '%${username}%'
        </if>
    </where>
</select>

(4)、使用foreach标签

想一想:如果我们要查询的是一个List,那么我们就要传不是一个id(或者username……)了,或者一次要穿n个id(其他字段同id),这样就要用到foreach标签。

  foreach 元素的功能非常强大,它允许你指定一个集合,声明可以在元素体内使用的集合项(item)和索引(index)变量。它也允许你指定开头与结尾的字符串以及在迭代结果之间放置分隔符。这个元素是很智能的,因此它不会偶然地附加多余的分隔符。

  注意: 你可以将任何可迭代对象(如 List、Set 等)、Map 对象或者数组对象传递给 foreach 作为集合参数。当使用可迭代对象或者数组时,index 是当前迭代的次数,item 的值是本次迭代获取的元素。当使用 Map 对象(或者 Map.Entry 对象的集合)时,index 是键,item 是值。

向sql传递数组或List,mybatis使用foreach解析

<!-- 根据ids查询用户 -->
<select id="queryUserByIds" parameterType="queryVo" resultType="user">
    SELECT * FROM `user`
    <where>
        <!-- foreach标签,进行遍历 -->
        <!-- collection:遍历的集合,这里是QueryVo的ids属性 -->
        <!-- item:遍历的项目,可以随便写,,但是和后面的#{}里面要一致 -->
        <!-- open:在前面添加的sql片段 -->
        <!-- close:在结尾处添加的sql片段 -->
        <!-- separator:指定遍历的元素之间使用的分隔符 -->
        <foreach collection="ids" item="item" open="id IN (" close=")"
            separator=",">
            #{item}
        </foreach>
    </where>
</select>

mybatis中动态sql常用的标签

//mapper中我们要为这个方法传递的是一个容器,将容器中的元素一个一个的
//拼接到xml的方法中就要使用这个forEach这个标签了
public List<Entity> queryById(List<String> userids);

//对应的xml中如下
  <select id="queryById" resultMap="BaseReslutMap" >
      select * FROM entity
      where id in 
      <foreach collection="userids" item="userid" index="index" open="(" separator="," close=")">
              #{userid}
      </foreach>
  </select>

concat模糊查询

//比如说我们想要进行条件查询,但是几个条件不是每次都要使用,那么我们就可以
//通过判断是否拼接到sql中
  <select id="queryById" resultMap="BascResultMap" parameterType="entity">
    SELECT *  from entity
    <where>
        <if test="name!=null">
            name like concat('%',concat(#{name},'%'))
        </if>
    </where>
  </select>

choose (when, otherwise)标签

choose标签是按顺序判断其内部when标签中的test条件出否成立,如果有一个成立,则 choose 结束。当 choose 中所有 when 的条件都不满则时,则执行 otherwise 中的sql。类似于Java 的 switch 语句,choose 为 switch,when 为 case,otherwise 则为 default。

例如下面例子,同样把所有可以限制的条件都写上,方面使用。choose会从上到下选择一个when标签的test为true的sql执行。安全考虑,我们使用where将choose包起来,放置关键字多于错误。

<!--  choose(判断参数) - 按顺序将实体类 User 第一个不为空的属性作为:where条件 -->  
<select id="getUserList_choose" resultMap="resultMap_user" parameterType="com.yiibai.pojo.User">  
    SELECT *  
      FROM User u   
    <where>  
        <choose>  
            <when test="username !=null ">  
                u.username LIKE CONCAT(CONCAT('%', #{username, jdbcType=VARCHAR}),'%')  
            </when >  
            <when test="sex != null and sex != '' ">  
                AND u.sex = #{sex, jdbcType=INTEGER}  
            </when >  
            <when test="birthday != null ">  
                AND u.birthday = #{birthday, jdbcType=DATE}  
            </when >  
            <otherwise>  
            </otherwise>  
        </choose>  
    </where>    
</select>  

selectKey 标签

   在insert语句中,在Oracle经常使用序列、在MySQL中使用函数来自动生成插入表的主键,而且需要方法能返回这个生成主键。使用myBatis的selectKey标签可以实现这个效果。
   下面例子,使用mysql数据库自定义函数nextval('student'),用来生成一个key,并把他设置到传入的实体类中的studentId属性上。所以在执行完此方法后,边可以通过这个实体类获取生成的key。
<!-- 插入学生 自动主键-->  
<insert id="createStudentAutoKey" parameterType="liming.student.manager.data.model.StudentEntity" keyProperty="studentId">  
    <selectKey keyProperty="studentId" resultType="String" order="BEFORE">  
        select nextval('student')  
    </selectKey>  
    INSERT INTO STUDENT_TBL(STUDENT_ID,  
                            STUDENT_NAME,  
                            STUDENT_SEX,  
                            STUDENT_BIRTHDAY,  
                            STUDENT_PHOTO,  
                            CLASS_ID,  
                            PLACE_ID)  
    VALUES (#{studentId},  
            #{studentName},  
            #{studentSex},  
            #{studentBirthday},  
            #{studentPhoto, javaType=byte[], jdbcType=BLOB, typeHandler=org.apache.ibatis.type.BlobTypeHandler},  
            #{classId},  
            #{placeId})  
</insert>  

调用接口方法,和获取自动生成key

StudentEntity entity = new StudentEntity();  
entity.setStudentName("黎明你好");  
entity.setStudentSex(1);  
entity.setStudentBirthday(DateUtil.parse("1985-05-28"));  
entity.setClassId("20000001");  
entity.setPlaceId("70000001");  
this.dynamicSqlMapper.createStudentAutoKey(entity);  
System.out.println("新增学生ID: " + entity.getStudentId());  

if标签

if标签可用在许多类型的sql语句中,我们以查询为例。首先看一个很普通的查询:

<!-- 查询学生list,like姓名 -->  
<select id="getStudentListLikeName" parameterType="StudentEntity" resultMap="studentResultMap">  
    SELECT * from STUDENT_TBL ST   
WHERE ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName}),'%')  
</select>  

但是此时如果studentName为null,此语句很可能报错或查询结果为空。此时我们使用if动态sql语句先进行判断,如果值为null或等于空字符串,我们就不进行此条件的判断,增加灵活性。

参数为实体类StudentEntity。将实体类中所有的属性均进行判断,如果不为空则执行判断条件。

<!-- 2 if(判断参数) - 将实体类不为空的属性作为where条件 -->  
<select id="getStudentList_if" resultMap="resultMap_studentEntity" parameterType="liming.student.manager.data.model.StudentEntity">  
    SELECT ST.STUDENT_ID,  
           ST.STUDENT_NAME,  
           ST.STUDENT_SEX,  
           ST.STUDENT_BIRTHDAY,  
           ST.STUDENT_PHOTO,  
           ST.CLASS_ID,  
           ST.PLACE_ID  
      FROM STUDENT_TBL ST   
     WHERE  
    <if test="studentName !=null ">  
        ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName, jdbcType=VARCHAR}),'%')  
    </if>  
    <if test="studentSex != null and studentSex != '' ">  
        AND ST.STUDENT_SEX = #{studentSex, jdbcType=INTEGER}  
    </if>  
    <if test="studentBirthday != null ">  
        AND ST.STUDENT_BIRTHDAY = #{studentBirthday, jdbcType=DATE}  
    </if>  
    <if test="classId != null and classId!= '' ">  
        AND ST.CLASS_ID = #{classId, jdbcType=VARCHAR}  
    </if>  
    <if test="classEntity != null and classEntity.classId !=null and classEntity.classId !=' ' ">  
        AND ST.CLASS_ID = #{classEntity.classId, jdbcType=VARCHAR}  
    </if>  
    <if test="placeId != null and placeId != '' ">  
        AND ST.PLACE_ID = #{placeId, jdbcType=VARCHAR}  
    </if>  
    <if test="placeEntity != null and placeEntity.placeId != null and placeEntity.placeId != '' ">  
        AND ST.PLACE_ID = #{placeEntity.placeId, jdbcType=VARCHAR}  
    </if>  
    <if test="studentId != null and studentId != '' ">  
        AND ST.STUDENT_ID = #{studentId, jdbcType=VARCHAR}  
    </if>   
</select>  

使用时比较灵活, new一个这样的实体类,我们需要限制那个条件,只需要附上相应的值就会where这个条件,相反不去赋值就可以不在where中判断。

public void select_test_2_1() {  
    StudentEntity entity = new StudentEntity();  
    entity.setStudentName("");  
    entity.setStudentSex(1);  
    entity.setStudentBirthday(DateUtil.parse("1985-05-28"));  
    entity.setClassId("20000001");  
    //entity.setPlaceId("70000001");  
    List<StudentEntity> list = this.dynamicSqlMapper.getStudentList_if(entity);  
    for (StudentEntity e : list) {  
        System.out.println(e.toString());  
    }  
}  

if + where 的条件判断

当where中的条件使用的if标签较多时,这样的组合可能会导致错误。我们以在3.1中的查询语句为例子,当java代码按如下方法调用时:

@Test  
public void select_test_2_1() {  
    StudentEntity entity = new StudentEntity();  
    entity.setStudentName(null);  
    entity.setStudentSex(1);  
    List<StudentEntity> list = this.dynamicSqlMapper.getStudentList_if(entity);  
    for (StudentEntity e : list) {  
        System.out.println(e.toString());  
    }  
}  

如果上面例子,参数studentName为null,将不会进行STUDENT_NAME列的判断,则会直接导“WHERE AND”关键字多余的错误SQL。
这时我们可以使用where动态语句来解决。这个“where”标签会知道如果它包含的标签中有返回值的话,它就插入一个‘where’。此外,如果标签返回的内容是以AND 或OR 开头的,则它会剔除掉。
上面例子修改为:

<!-- 3 select - where/if(判断参数) - 将实体类不为空的属性作为where条件 -->  
<select id="getStudentList_whereIf" resultMap="resultMap_studentEntity" parameterType="liming.student.manager.data.model.StudentEntity">  
    SELECT ST.STUDENT_ID,  
           ST.STUDENT_NAME,  
           ST.STUDENT_SEX,  
           ST.STUDENT_BIRTHDAY,  
           ST.STUDENT_PHOTO,  
           ST.CLASS_ID,  
           ST.PLACE_ID  
      FROM STUDENT_TBL ST   
    <where>  
        <if test="studentName !=null ">  
            ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName, jdbcType=VARCHAR}),'%')  
        </if>  
        <if test="studentSex != null and studentSex != '' ">  
            AND ST.STUDENT_SEX = #{studentSex, jdbcType=INTEGER}  
        </if>  
        <if test="studentBirthday != null ">  
            AND ST.STUDENT_BIRTHDAY = #{studentBirthday, jdbcType=DATE}  
        </if>  
        <if test="classId != null and classId!= '' ">  
            AND ST.CLASS_ID = #{classId, jdbcType=VARCHAR}  
        </if>  
        <if test="classEntity != null and classEntity.classId !=null and classEntity.classId !=' ' ">  
            AND ST.CLASS_ID = #{classEntity.classId, jdbcType=VARCHAR}  
        </if>  
        <if test="placeId != null and placeId != '' ">  
            AND ST.PLACE_ID = #{placeId, jdbcType=VARCHAR}  
        </if>  
        <if test="placeEntity != null and placeEntity.placeId != null and placeEntity.placeId != '' ">  
            AND ST.PLACE_ID = #{placeEntity.placeId, jdbcType=VARCHAR}  
        </if>  
        <if test="studentId != null and studentId != '' ">  
            AND ST.STUDENT_ID = #{studentId, jdbcType=VARCHAR}  
        </if>  
    </where>    
</select>  

if + set实现修改语句

当update语句中没有使用if标签时,如果有一个参数为null,都会导致错误。
当在update语句中使用if标签时,如果前面的if没有执行,则或导致逗号多余错误。使用set标签可以将动态的配置SET 关键字,和剔除追加到条件末尾的任何不相关的逗号。使用if+set标签修改后,如果某项为null则不进行更新,而是保持数据库原值。如下示例:

<!-- 4 if/set(判断参数) - 将实体类不为空的属性更新 -->  
<update id="updateStudent_if_set" parameterType="liming.student.manager.data.model.StudentEntity">  
    UPDATE STUDENT_TBL  
    <set>  
        <if test="studentName != null and studentName != '' ">  
            STUDENT_TBL.STUDENT_NAME = #{studentName},  
        </if>  
        <if test="studentSex != null and studentSex != '' ">  
            STUDENT_TBL.STUDENT_SEX = #{studentSex},  
        </if>  
        <if test="studentBirthday != null ">  
            STUDENT_TBL.STUDENT_BIRTHDAY = #{studentBirthday},  
        </if>  
        <if test="studentPhoto != null ">  
            STUDENT_TBL.STUDENT_PHOTO = #{studentPhoto, javaType=byte[], jdbcType=BLOB, typeHandler=org.apache.ibatis.type.BlobTypeHandler},  
        </if>  
        <if test="classId != '' ">  
            STUDENT_TBL.CLASS_ID = #{classId}  
        </if>  
        <if test="placeId != '' ">  
            STUDENT_TBL.PLACE_ID = #{placeId}  
        </if>  
    </set>  
    WHERE STUDENT_TBL.STUDENT_ID = #{studentId};      
</update>  

if + trim代替where/set标签

trim是更灵活的去处多余关键字的标签,他可以实践where和set的效果。

trim代替where

<!-- 5.1if/trim代替where(判断参数) -将实体类不为空的属性作为where条件-->  
<select id="getStudentList_if_trim" resultMap="resultMap_studentEntity">  
    SELECT ST.STUDENT_ID,  
           ST.STUDENT_NAME,  
           ST.STUDENT_SEX,  
           ST.STUDENT_BIRTHDAY,  
           ST.STUDENT_PHOTO,  
           ST.CLASS_ID,  
           ST.PLACE_ID  
      FROM STUDENT_TBL ST   
    <trim prefix="WHERE" prefixOverrides="AND|OR">  
        <if test="studentName !=null ">  
            ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName, jdbcType=VARCHAR}),'%')  
        </if>  
        <if test="studentSex != null and studentSex != '' ">  
            AND ST.STUDENT_SEX = #{studentSex, jdbcType=INTEGER}  
        </if>  
        <if test="studentBirthday != null ">  
            AND ST.STUDENT_BIRTHDAY = #{studentBirthday, jdbcType=DATE}  
        </if>  
        <if test="classId != null and classId!= '' ">  
            AND ST.CLASS_ID = #{classId, jdbcType=VARCHAR}  
        </if>  
        <if test="classEntity != null and classEntity.classId !=null and classEntity.classId !=' ' ">  
            AND ST.CLASS_ID = #{classEntity.classId, jdbcType=VARCHAR}  
        </if>  
        <if test="placeId != null and placeId != '' ">  
            AND ST.PLACE_ID = #{placeId, jdbcType=VARCHAR}  
        </if>  
        <if test="placeEntity != null and placeEntity.placeId != null and placeEntity.placeId != '' ">  
            AND ST.PLACE_ID = #{placeEntity.placeId, jdbcType=VARCHAR}  
        </if>  
        <if test="studentId != null and studentId != '' ">  
            AND ST.STUDENT_ID = #{studentId, jdbcType=VARCHAR}  
        </if>  
    </trim>     
</select> 

trim代替set

<!-- 5.2 if/trim代替set(判断参数) - 将实体类不为空的属性更新 -->  
<update id="updateStudent_if_trim" parameterType="liming.student.manager.data.model.StudentEntity">  
    UPDATE STUDENT_TBL  
    <trim prefix="SET" suffixOverrides=",">  
        <if test="studentName != null and studentName != '' ">  
            STUDENT_TBL.STUDENT_NAME = #{studentName},  
        </if>  
        <if test="studentSex != null and studentSex != '' ">  
            STUDENT_TBL.STUDENT_SEX = #{studentSex},  
        </if>  
        <if test="studentBirthday != null ">  
            STUDENT_TBL.STUDENT_BIRTHDAY = #{studentBirthday},  
        </if>  
        <if test="studentPhoto != null ">  
            STUDENT_TBL.STUDENT_PHOTO = #{studentPhoto, javaType=byte[], jdbcType=BLOB, typeHandler=org.apache.ibatis.type.BlobTypeHandler},  
        </if>  
        <if test="classId != '' ">  
            STUDENT_TBL.CLASS_ID = #{classId},  
        </if>  
        <if test="placeId != '' ">  
            STUDENT_TBL.PLACE_ID = #{placeId}  
        </if>  
    </trim>  
    WHERE STUDENT_TBL.STUDENT_ID = #{studentId}  
</update> 

foreach

对于动态SQL 非常必须的,主是要迭代一个集合,通常是用于IN 条件。List 实例将使用“list”做为键,数组实例以“array” 做为键。

foreach元素是非常强大的,它允许你指定一个集合,声明集合项和索引变量,它们可以用在元素体内。它也允许你指定开放和关闭的字符串,在迭代之间放置分隔符。这个元素是很智能的,它不会偶然地附加多余的分隔符。

注意:你可以传递一个List实例或者数组作为参数对象传给MyBatis。当你这么做的时候,MyBatis会自动将它包装在一个Map中,用名称在作为键。List实例将会以“list”作为键,而数组实例将会以“array”作为键。

这个部分是对关于XML配置文件和XML映射文件的而讨论的。下一部分将详细讨论Java API,所以你可以得到你已经创建的最有效的映射。

1参数为array示例的写法

接口的方法声明:

public List<StudentEntity> getStudentListByClassIds_foreach_array(String[] classIds);  

动态SQL语句:

<!— 7.1 foreach(循环array参数) - 作为where中in的条件 -->  
<select id="getStudentListByClassIds_foreach_array" resultMap="resultMap_studentEntity">  
    SELECT ST.STUDENT_ID,  
           ST.STUDENT_NAME,  
           ST.STUDENT_SEX,  
           ST.STUDENT_BIRTHDAY,  
           ST.STUDENT_PHOTO,  
           ST.CLASS_ID,  
           ST.PLACE_ID  
      FROM STUDENT_TBL ST  
      WHERE ST.CLASS_ID IN   
     <foreach collection="array" item="classIds"  open="(" separator="," close=")">  
        #{classIds}  
     </foreach>  
</select>  

测试代码,查询学生中,在20000001、20000002这两个班级的学生:

@Test  
public void test7_foreach() {  
    String[] classIds = { "20000001", "20000002" };  
    List<StudentEntity> list = this.dynamicSqlMapper.getStudentListByClassIds_foreach_array(classIds);  
    for (StudentEntity e : list) {  
        System.out.println(e.toString());  
    }  
}

2参数为list示例的写法
接口的方法声明:

public List<StudentEntity> getStudentListByClassIds_foreach_list(List<String> classIdList);  
  • 1

动态SQL语句:

<!-- 7.2 foreach(循环List<String>参数) - 作为where中in的条件 -->  
<select id="getStudentListByClassIds_foreach_list" resultMap="resultMap_studentEntity">  
    SELECT ST.STUDENT_ID,  
           ST.STUDENT_NAME,  
           ST.STUDENT_SEX,  
           ST.STUDENT_BIRTHDAY,  
           ST.STUDENT_PHOTO,  
           ST.CLASS_ID,  
           ST.PLACE_ID  
      FROM STUDENT_TBL ST  
      WHERE ST.CLASS_ID IN   
     <foreach collection="list" item="classIdList"  open="(" separator="," close=")">  
        #{classIdList}  
     </foreach>  
</select>  

测试代码,查询学生中,在20000001、20000002这两个班级的学生:

@Test  
public void test7_2_foreach() {  
    ArrayList<String> classIdList = new ArrayList<String>();  
    classIdList.add("20000001");  
    classIdList.add("20000002");  
    List<StudentEntity> list = this.dynamicSqlMapper.getStudentListByClassIds_foreach_list(classIdList);  
    for (StudentEntity e : list) {  
        System.out.println(e.toString());  
    }  
}  

Wireshark使用教程

抓取报文:

  下载和安装好Wireshark之后,启动Wireshark并且在接口列表中选择接口名,然后开始在此接口上抓包。例如,如果想要在无线网络上抓取流量,点击无线接口。点击Capture Options可以配置高级属性,但现在无此必要。

点击接口名称之后,就可以看到实时接收的报文。Wireshark会捕捉系统发送和接收的每一个报文。如果抓取的接口是无线并且选项选取的是混合模式,那么也会看到网络上其他报文。

上端面板每一行对应一个网络报文,默认显示报文接收时间(相对开始抓取的时间点),源和目标IP地址,使用协议和报文相关信息。点击某一行可以在下面两个窗口看到更多信息。“+”图标显示报文里面每一层的详细信息。底端窗口同时以十六进制和ASCII码的方式列出报文内容。

需要停止抓取报文的时候,点击左上角的停止按键。

色彩标识:

进行到这里已经看到报文以绿色,蓝色,黑色显示出来。Wireshark通过颜色让各种流量的报文一目了然。比如默认绿色是TCP报文,深蓝色是DNS,浅蓝是UDP,黑色标识出有问题的TCP报文——比如乱序报文。

报文样本:

比如说你在家安装了Wireshark,但家用LAN环境下没有感兴趣的报文可供观察,那么可以去Wireshark wiki下载报文样本文件。

打开一个抓取文件相当简单,在主界面上点击Open并浏览文件即可。也可以在Wireshark里保存自己的抓包文件并稍后打开。

过滤报文:

如果正在尝试分析问题,比如打电话的时候某一程序发送的报文,可以关闭所有其他使用网络的应用来减少流量。但还是可能有大批报文需要筛选,这时要用到Wireshark过滤器。

最基本的方式就是在窗口顶端过滤栏输入并点击Apply(或按下回车)。例如,输入“dns”就会只看到DNS报文。输入的时候,Wireshark会帮助自动完成过滤条件。

也可以点击Analyze菜单并选择Display Filters来创建新的过滤条件。

另一件很有趣的事情是你可以右键报文并选择Follow TCP Stream。

你会看到在服务器和目标端之间的全部会话。

关闭窗口之后,你会发现过滤条件自动被引用了——Wireshark显示构成会话的报文。

检查报文:

选中一个报文之后,就可以深入挖掘它的内容了。

也可以在这里创建过滤条件——只需右键细节并使用Apply as Filter子菜单,就可以根据此细节创建过滤条件。

Wireshark是一个非常之强大的工具,第一节只介绍它的最基本用法。网络专家用它来debug网络协议实现细节,检查安全问题,网络协议内部构件等等。

一站式学习Wireshark(二):应用Wireshark观察基本网络协议

TCP:

TCP/IP通过三次握手建立一个连接。这一过程中的三种报文是:SYN,SYN/ACK,ACK。

第一步是找到PC发送到网络服务器的第一个SYN报文,这标识了TCP三次握手的开始。

如果你找不到第一个SYN报文,选择Edit -> Find Packet菜单选项。选择Display Filter,输入过滤条件:tcp.flags,这时会看到一个flag列表用于选择。选择合适的flag,tcp.flags.syn并且加上==1。点击Find,之后trace中的第一个SYN报文就会高亮出来了。

注意:Find Packet也可以用于搜索十六进制字符,比如恶意软件信号,或搜索字符串,比如抓包文件中的协议命令。

一个快速过滤TCP报文流的方式是在Packet List Panel中右键报文,并且选择Follow TCP Stream。这就创建了一个只显示TCP会话报文的自动过滤条件。

这一步骤会弹出一个会话显示窗口,默认情况下包含TCP会话的ASCII代码,客户端报文用红色表示服务器报文则为蓝色。

窗口类似下图所示,对于读取协议有效载荷非常有帮助,比如HTTP,SMTP,FTP。

更改为十六进制Dump模式查看载荷的十六进制代码,如下图所示:

关闭弹出窗口,Wireshark就只显示所选TCP报文流。现在可以轻松分辨出3次握手信号。

注意:这里Wireshark自动为此TCP会话创建了一个显示过滤。本例中:(ip.addr eq 192.168.1.2 and ip.addr eq 209.85.227.19) and (tcp.port eq 80 and tcp.port eq 52336)

SYN报文:

图中显示的5号报文是从客户端发送至服务器端的SYN报文,此报文用于与服务器建立同步,确保客户端和服务器端的通信按次序传输。SYN报文的头部有一个32 bit序列号。底端对话框显示了报文一些有用信息如报文类型,序列号。

SYN/ACK报文:

7号报文是服务器的响应。一旦服务器接收到客户端的SYN报文,就读取报文的序列号并且使用此编号作为响应,也就是说它告知客户机,服务器接收到了SYN报文,通过对原SYN报文序列号加一并且作为响应编号来实现,之后客户端就知道服务器能够接收通信。

ACK报文:

8号报文是客户端对服务器发送的确认报文,告诉服务器客户端接收到了SYN/ACK报文,并且与前一步一样客户端也将序列号加一,此包发送完毕,客户端和服务器进入ESTABLISHED状态,完成三次握手。

ARP & ICMP:

开启Wireshark抓包。打开Windows控制台窗口,使用ping命令行工具查看与相邻机器的连接状况。

停止抓包之后,Wireshark如下图所示。ARP和ICMP报文相对较难辨认,创建只显示ARP或ICMP的过滤条件。

ARP报文:

地址解析协议,即ARP(Address Resolution Protocol),是根据IP地址获取物理地址的一个TCP/IP协议。其功能是:主机将ARP请求广播到网络上的所有主机,并接收返回消息,确定目标IP地址的物理地址,同时将IP地址和硬件地址存入本机ARP缓存中,下次请求时直接查询ARP缓存。

最初从PC发出的ARP请求确定IP地址192.168.1.1的MAC地址,并从相邻系统收到ARP回复。ARP请求之后,会看到ICMP报文。

ICMP报文:

网络控制消息协定(Internet Control Message Protocol,ICMP)用于TCP/IP网络中发送控制消息,提供可能发生在通信环境中的各种问题反馈,通过这些信息,令管理者可以对所发生的问题作出诊断,然后采取适当的措施解决。

PC发送echo请求,收到echo回复如上图所示。ping报文被mark成Type 8,回复报文mark成Type 0。

如果多次ping同一系统,在PC上删除ARP cache,使用如下ARP命令之后,会产生一个新的ARP请求。

C:\> ping 192.168.1.1

… ping output …

C:\> arp –d *

HTTP:

HTTP协议是目前使用最广泛的一种基础协议,这得益于目前很多应用都基于WEB方式,实现容易,软件开发部署也简单,无需额外的客户端,使用浏览器即可使用。这一过程开始于请求服务器传送网络文件。

从上图可见报文中包括一个GET命令,当HTTP发送初始GET命令之后,TCP继续数据传输过程,接下来的链接过程中HTTP会从服务器请求数据并使用TCP将数据传回客户端。传送数据之前,服务器通过发送HTTP OK消息告知客户端请求有效。如果服务器没有将目标发送给客户端的许可,将会返回403 Forbidden。如果服务器找不到客户端所请求的目标,会返回404。

如果没有更多数据,连接可被终止,类似于TCP三次握手信号的SYN和ACK报文,这里发送的是FIN和ACK报文。当服务器结束传送数据,就发送FIN/ACK给客户端,此报文表示结束连接。接下来客户端返回ACK报文并且对FIN/ACK中的序列号加1。这就从服务器端终止了通信。要结束这一过程客户端必须重新对服务器端发起这一过程。必须在客户端和服务器端都发起并确认FIN/ACK过程。

应用Wireshark IO图形工具分析数据流

基本IO Graphs:

IO graphs是一个非常好用的工具。基本的Wireshark IO graph会显示抓包文件中的整体流量情况,通常是以每秒为单位(报文数或字节数)。默认X轴时间间隔是1秒,Y轴是每一时间间隔的报文数。如果想要查看每秒bit数或byte数,点击“Unit”,在“Y Axis”下拉列表中选择想要查看的内容。这是一种基本的应用,对于查看流量中的波峰/波谷很有帮助。要进一步查看,点击图形中的任意点就会看到报文的细节。

为了讲解方便,点击示例报文包,或用自己的wireshark点击Statistics – IO Graphs。这个抓包是HTTP下载遇到报文丢失的情况。

注意:过滤条件为空,此图形显示所有流量。

这个默认条件下的显示在大多数troubleshooting中并不是非常有用。将Y轴改为bits/tick这样就可以看到每秒的流量。从这张图可以看到峰值速率是300kbps左右。如果你看到有些地方流量下降为零,那可能是一个出问题的点。这个问题在图上很好发现,但在看报文列表时可能不那么明显。

过滤:

每一个图形都可以应用一个过滤条件。这里创建两个不同的graph,一个HTTP一个ICMP。可以看到过滤条件中Graph 1使用“http”Graph 2使用“icmp”。图中可以看到红色ICMP流量中有些间隙,进一步分析。

创建两个图形,一个显示ICMP Echo(Type=8)一个显示ICMP Reply(Type=0)。正常情况下对于每一个echo请求会有一个连续的reply。这里的情况是:

可以看到红色脉冲线(icmp type==0 – ICMP Reply)中间有间隙,而整张图中ICMP请求保持连续。这意味着有些reply没有接收到。这是由于报文丢失导致的reply drop。CLI中看到的ping信息如下:

常用排错过滤条件:

对于排查网络延时/应用问题有一些过滤条件是非常有用的:

tcp.analysis.lost_segment:表明已经在抓包中看到不连续的序列号。报文丢失会造成重复的ACK,这会导致重传。

tcp.analysis.duplicate_ack:显示被确认过不止一次的报文。大凉的重复ACK是TCP端点之间高延时的迹象。

tcp.analysis.retransmission:显示抓包中的所有重传。如果重传次数不多的话还是正常的,过多重传可能有问题。这通常意味着应用性能缓慢和/或用户报文丢失。

tcp.analysis.window_update:将传输过程中的TCP window大小图形化。如果看到窗口大小下降为零,这意味着发送方已经退出了,并等待接收方确认所有已传送数据。这可能表明接收端已经不堪重负了。

tcp.analysis.bytes_in_flight:某一时间点网络上未确认字节数。未确认字节数不能超过你的TCP窗口大小(定义于最初3此TCP握手),为了最大化吞吐量你想要获得尽可能接近TCP窗口大小。如果看到连续低于TCP窗口大小,可能意味着报文丢失或路径上其他影响吞吐量的问题。

tcp.analysis.ack_rtt:衡量抓取的TCP报文与相应的ACK。如果这一时间间隔比较长那可能表示某种类型的网络延时(报文丢失,拥塞,等等)。

在抓包中应用以上一些过滤条件:

注意:Graph 1是HTTP总体流量,显示形式为packets/tick,时间间隔1秒。Graph 2是TCP丢失报文片段。Graph 3是TCP 重复ACK。Graph 4是TCP重传。

从这张图可以看到:相比于整体HTTP流量,有很多数量的重传以及重复ACK。从这张图中,可以看到这些事件发生的时间点,以及在整体流量中所占的比例。

函数:

IO Graphs有六个可用函数:SUM, MIN, AVG, MAX, COUNT, LOAD。

MIN( ), AVG( ), MAX( )

首先看一下帧之间的最小,平均和最大时间,这对于查看帧/报文之间的延时非常有用。我们可以将这些函数结合“frame.time_delta”过滤条件看清楚帧延时,并使得往返延时更为明显。如果抓包文件中包含不同主机之间的多个会话,而只想知道其中一个pair,可将“frame.time_delta”结合源和目标主机条件如“ip.addr==x.x.x.x &&ip.addr==y.y.y.y”。如下图所示:

我们做了以下步骤:

将Y轴设置为“Advanced”,让Caculation域可见。不做这一步就看不到计算选项。

X轴时间间隔1秒,所以每个柱状图代表1秒间隔的计算结果。

过滤出两个特定IP地址的HTTP会话,使用条件:“(ip.addr==192.168.1.4&& ip.addr==128.173.87.169) && http”。

使用3个不同的graph,分别计算Min(), Avg(), Max()。

对每一个计算结果应用条件“frame.time_delta”,将style设置成“FBar”,显示效果最佳。

从上图可见,在第106秒时数据流的MAX frame.delta_time达到0.7秒,这是一个严重延时并且导致了报文丢失。如果想要深入研究,只需要点击图中这一点,就会跳转至相应帧。对应于本例抓包文件中第1003个报文。如果你看见帧之间平均延时相对较低但突然某一点延时很长,可点击这一帧,看看这一时间点究竟发生了什么。

Count( )       

此函数计算时间间隔内事件发生的次数,在查看TCP分析标识符时很有用,例如重传。例图如下:

Sum( )         

该函数统计事件的累加值。有两种常见的用例是看在捕获TCP数据量,以及检查TCP序列号。让我们看看第一个TCP长度的例子。创建两个图,一个使用客户端IP 192.168.1.4为源,另一个使用客户端IP作为一个目的地址。每个图我们将sum()功能结合tcp.len过滤条件。拆分成两个不同的图我们就可以看到在一个单一的方向移动的数据量。

从图表中我们可以看到,发送到客户端的数据量(IP.DST = = 192.168.1.4过滤条件)比来自客户端的数据量要高。在图中红色表示。黑条显示从客户端到服务器的数据,相对数据量很小。这是有道理的,因为客户只是请求文件和收到之后发送确认数据,而服务器发送大文件。很重要的一点是,如果你交换了图的顺序,把客户端的IP作为图1的目标地址,并且客户端IP作为图2的源地址,采用了FBAR的时候可能看不到正确的数据显示。因为图编号越低表示在前台显示,可能会覆盖较高图号。

现在让我们看一下同一个数据包丢失和延迟的TCP序列号。

可以在图中看到若干峰值和下降,表示TCP传输有问题。与正常TCP报文比较:

这张图可以看到TCP序列号相当稳定地增加,表示传输平稳,没有过多重传或丢包。

来源:https://www.jianshu.com/p/55ec409c739e

Wireshark使用教程 - 简书

-------------------

wireshark抓包工具详细说明及操作使用

为了安全考虑,wireshark只能查看封包,而不能修改封包的内容,或者发送封包。

wireshark能获取HTTP,也能获取HTTPS,但是不能解密HTTPS,所以wireshark看不懂HTTPS中的内容,总结,如果是处理HTTP,HTTPS 还是用Fiddler, 其他协议比如TCP,UDP 就用wireshark.

wireshark 开始抓包

开始界面

wireshark是捕获机器上的某一块网卡的网络包,当你的机器上有多块网卡的时候,你需要选择一个网卡。

点击Caputre->Interfaces.. 出现下面对话框,选择正确的网卡。然后点击"Start"按钮, 开始抓包

Wireshark 窗口介绍

WireShark 主要分为这几个界面

1. Display Filter(显示过滤器),  用于过滤

2. Packet List Pane(封包列表), 显示捕获到的封包, 有源地址和目标地址,端口号。 颜色不同,代表

3. Packet Details Pane(封包详细信息), 显示封包中的字段

4. Dissector Pane(16进制数据)

5. Miscellanous(地址栏,杂项)

使用过滤是非常重要的, 初学者使用wireshark时,将会得到大量的冗余信息,在几千甚至几万条记录中,以至于很难找到自己需要的部分。搞得晕头转向。

过滤器会帮助我们在大量的数据中迅速找到我们需要的信息。

过滤器有两种,

一种是显示过滤器,就是主界面上那个,用来在捕获的记录中找到所需要的记录

一种是捕获过滤器,用来过滤捕获的封包,以免捕获太多的记录。 在Capture -> Capture Filters 中设置

保存过滤

在Filter栏上,填好Filter的表达式后,点击Save按钮, 取个名字。比如"Filter 102",

Filter栏上就多了个"Filter 102" 的按钮。

过滤表达式的规则

表达式规则

1. 协议过滤

比如TCP,只显示TCP协议。

2. IP 过滤

比如 ip.src ==192.168.1.102 显示源地址为192.168.1.102,

ip.dst==192.168.1.102, 目标地址为192.168.1.102

3. 端口过滤

tcp.port ==80,  端口为80的

tcp.srcport == 80,  只显示TCP协议的愿端口为80的。

4. Http模式过滤

http.request.method=="GET",   只显示HTTP GET方法的。

5. 逻辑运算符为 AND/ OR

常用的过滤表达式

过滤表达式用途
http只查看HTTP协议的记录
ip.src ==192.168.1.102 or ip.dst==192.168.1.102 源地址或者目标地址是192.168.1.102

封包列表(Packet List Pane)

封包列表的面板中显示,编号,时间戳,源地址,目标地址,协议,长度,以及封包信息。 你可以看到不同的协议用了不同的颜色显示。

你也可以修改这些显示颜色的规则,  View ->Coloring Rules.

封包详细信息 (Packet Details Pane)

这个面板是我们最重要的,用来查看协议中的每一个字段。

各行信息分别为

Frame:   物理层的数据帧概况

Ethernet II: 数据链路层以太网帧头部信息

Internet Protocol Version 4: 互联网层IP包头部信息

Transmission Control Protocol:  传输层T的数据段头部信息,此处是TCP

Hypertext Transfer Protocol:  应用层的信息,此处是HTTP协议

TCP包的具体内容

从下图可以看到wireshark捕获到的TCP包中的每个字段。

看到这, 基本上对wireshak有了初步了解, 现在我们看一个TCP三次握手的实例

三次握手过程为

这图我都看过很多遍了, 这次我们用wireshark实际分析下三次握手的过程。

打开wireshark, 打开浏览器输入 http://www.cr173.com

在wireshark中输入http过滤, 然后选中GET /tankxiao HTTP/1.1的那条记录,右键然后点击"Follow TCP Stream",

这样做的目的是为了得到与浏览器打开网站相关的数据包,将得到如下图

图中可以看到wireshark截获到了三次握手的三个数据包。第四个包才是HTTP的, 这说明HTTP的确是使用TCP建立连接的。

第一次握手数据包

客户端发送一个TCP,标志位为SYN,序列号为0, 代表客户端请求建立连接。 如下图

第二次握手的数据包

服务器发回确认包, 标志位为 SYN,ACK. 将确认序号(Acknowledgement Number)设置为客户的I S N加1以.即0+1=1, 如下图

第三次握手的数据包

客户端再次发送确认包(ACK) SYN标志位为0,ACK标志位为1.并且把服务器发来ACK的序号字段+1,放在确定字段中发送给对方.并且在数据段放写ISN的+1, 如下图:

 就这样通过了TCP三次握手,建立了连接

Wireshark是世界上最重要的网络协议分析仪,是许多行业的标准。这个软件,在1998年开始延续。

协议的特点包括数百深度检测,被添加更多的时间,实时捕获和离线分析,标准的三窗格包浏览器,可以通过一个GUI浏览捕捉网络数据,或通过TTY模式的tshark的效用,并丰富的VoIP分析。

来源: https://blog.csdn.net/qq78069460/article/details/79153895

wireshark抓包工具详细说明及操作使用 - 海绵的博客 - CSDN博客

 

-----------------

Wireshark使用教程(界面说明、捕获过滤器表达式、显示过滤器表达式)

一、说明

1.1 背景说明

对于大多数刚开始接触wireshark的使用者而言,经常是开始的时候时候看到wireshark能把所有数据包都拦截下来觉得强无敌,但是面对一大堆的数据包要问有什么用或者说想要找到我想要的那些数据包怎么找(比如telnet登录过程的那些数据包)则完全是一脸茫然。

一是界面一堆窗口,什么作用什么区别看不懂;二是捕获、显示过滤器表达示看不出有什么规律,每次过滤都要百度找半天。其实wireshark界面还是比较清晰的,过滤器表过示也不困难,我们今天就来破解这wireshark使用的两大难题。

官网地址:https://www.wireshark.org/

官网下载地址:https://www.wireshark.org/#download

安装就不多说了和一般windows一样下一步下一下装就可以了。另外ethereal为什么在2006年更名wireshark参见:https://www.linux.com/news/ethereal-changes-name-wireshark

 

1.2 拦截本地回环数据

另外注意本机访问本机的回环数据是不经过网卡的,比如我们在本机访问搭建在本机上的web服务,但我们经常有服务搭建在本机的操作也经常有拦截本地回环数据包加以分析的需求,所以我们环要拦载回环数据包。操作如下。

首先,以管理员身份运行cmd(普通用户没有路由表操作权限,会提示“请求的操作需要提升”)

然后,使用ipconfig查看本机ip和网关:

ipconfig

再然后,使用以下命令添加路由,指定回环数据也要先转发到网关(使用上一步获取本的本机ip和网关替换其中的<your_IP>和<gateway_IP>):

route add <your_IP> mask 255.255.255.255 <gateway_IP> metric 1

最后,查看路由表中路由是否已添加成功:

route print

回环数据经网关再回来会增加网卡的压力,可使用以下命令删除路由(使用前边获取本的本机ip替换其中的<your_IP>):

route delete <your_IP>

 

二、Wireshark界面说明

过滤器表达式书写是wireshark使用的核心,但在此之前,很多初学者还会碰到一个难题,就是感觉wireshark界面上很多东西不懂怎么看。其实还是挺明了的我们下面简单说一下,如下图。

1号窗口展示的是wireshark捕获到的所有数据包的列表。注意最后一列Info列是wireshark组织的说明列并不一定是该数据包中的原始内容。

2号窗口是1号窗口中选定的数据包的分协议层展示。底色为红色的是因为wireshark开启校验和验证而该层协议校验和又不正确所致。

3号窗口是1号窗口中选定的数据包的源数据,其中左侧是十六进制表示右侧是ASCII码表示。另外在2号窗口中选中某层或某字段,3号窗口对应位置也会被高亮。

被认为最难的其实还是2号窗口展开后的内容不懂怎么看,其实也很明了,以IP层为例:

每一行就对应该层协议的一个字段;中括号行是前一字段的说明。

冒号前的英文是协议字段的名称;冒号后是该数据包中该协议字段的值。

 

三、捕获过滤器表达式

捕获过滤器表达式作用在wireshark开始捕获数据包之前,只捕获符合条件的数据包,不记录不符合条件的数据包。

捕获过滤器表达式没有像显示过滤器表达式那样明显的规律,但写法不多所以也不难;而且除非全部捕获要占用的磁盘空间实现太大,且你非常明确过滤掉的数据包是你不需要的,不然一般都不用捕获过滤器表达式而用显示过滤器表达式。

在wireshark2.x版本,启动后欢迎界面即有捕获过滤器,在其中输入过滤表达式开始捕获数据包时即会生效:

点击图中“书签”标志,再点管理“捕获筛选器”,即可看到常用捕获过滤表达示的书写形式

 

四、显示过滤器表达示及其书写规律

显示过滤器表达式作用在在wireshark捕获数据包之后,从已捕获的所有数据包中显示出符合条件的数据包,隐藏不符合条件的数据包。

显示过滤表达示在工具栏下方的“显示过滤器”输入框输入即可生效

4.1 基本过滤表达式

一条基本的表达式由过滤项、过滤关系、过滤值三项组成。

比如ip.addr == 192.168.1.1,这条表达式中ip.addr是过滤项、==是过滤关系,192.168.1.1是过滤值(整条表达示的意思是找出所有ip协议中源或目标ip、等于、192.168.1.1的数据包)

4.1.1 过滤项

初学者感觉的“过滤表达式复杂”,最主要就是在这个过滤项上:一是不知道有哪些过滤项,二是不知道过滤项该怎么写。

这两个问题有一个共同的答案-----wireshark的过滤项是“协议“+”.“+”协议字段”的模式。以端口为例,端口出现于tcp协议中所以有端口这个过滤项且其写法就是tcp.port。

推广到其他协议,如eth、ip、udp、http、telnet、ftp、icmp、snmp等等其他协议都是这么个书写思路。当然wireshark出于缩减长度的原因有些字段没有使用协议规定的名称而是使用简写(比如Destination Port在wireshark中写为dstport)又出于简使用增加了一些协议中没有的字段(比如tcp协议只有源端口和目标端口字段,为了简便使用wireshark增加了tcp.port字段来同时代表这两个),但思路总的算是不变的。而且在实际使用时我们输入“协议”+“.”wireshark就会有支持的字段提示(特别是过滤表达式字段的首字母和wireshark在上边2窗口显示的字段名称首字母通常是一样的),看下名称就大概知道要用哪个字段了。wireshark支持的全部协议及协议字段可查看官方说明

4.1.2 过滤关系

过滤关系就是大于、小于、等于等几种等式关系,我们可以直接看官方给出的表。注意其中有“English”和“C-like”两个字段,这个意思是说“English”和“C-like”这两种写法在wireshark中是等价的、都是可用的。

4.1.3 过滤值

过滤值就是设定的过滤项应该满足过滤关系的标准,比如500、5000、50000等等。过滤值的写法一般已经被过滤项和过滤关系设定好了,只是填下自己的期望值就可以了。

 

4.2 复合过滤表达示

所谓复合过滤表达示,就是指由多条基本过滤表达式组合而成的表达示。基本过滤表达式的写法还是不变的,复合过滤表达示多出来的东西就只是基本过滤表达示的“连接词”

我们依然直接参照官方给出的表,同样“English”和“C-like”这两个字段还是说明这两种写法在wireshark中是等价的、都是可用的。

 

4.3 常见用显示过滤需求及其对应表达式

数据链路层:

筛选mac地址为04:f9:38:ad:13:26的数据包----eth.src == 04:f9:38:ad:13:26

筛选源mac地址为04:f9:38:ad:13:26的数据包----eth.src == 04:f9:38:ad:13:26

网络层:

筛选ip地址为192.168.1.1的数据包----ip.addr == 192.168.1.1

筛选192.168.1.0网段的数据---- ip contains "192.168.1"

筛选192.168.1.1和192.168.1.2之间的数据包----ip.addr == 192.168.1.1 && ip.addr == 192.168.1.2

筛选从192.168.1.1到192.168.1.2的数据包----ip.src == 192.168.1.1 && ip.dst == 192.168.1.2

传输层:

筛选tcp协议的数据包----tcp

筛选除tcp协议以外的数据包----!tcp

筛选端口为80的数据包----tcp.port == 80

筛选12345端口和80端口之间的数据包----tcp.port == 12345 && tcp.port == 80

筛选从12345端口到80端口的数据包----tcp.srcport == 12345 && tcp.dstport == 80

应用层:

特别说明----http中http.request表示请求头中的第一行(如GET index.jsp HTTP/1.1),http.response表示响应头中的第一行(如HTTP/1.1 200 OK),其他头部都用http.header_name形式。

筛选url中包含.php的http数据包----http.request.uri contains ".php"

筛选内容包含username的http数据包----http contains "username"

 

参考:

官方文档:https://www.wireshark.org/docs/wsug_html_chunked/ChapterWork.html

https://blog.csdn.net/readiay/article/details/53063932