实验：通过 Java 模拟 ServerSocket 来调用 OS 底层的 Socket，实现网络通信
目的：了解什么是 natvie 方法和 JNI 调用步骤

Linux 下的 Socket 函数

  1. man 2 socket
  3. NAME
  4.        socket - create an endpoint for communication
  6. SYNOPSIS
  7.        #include <sys/types.h>          /* See NOTES */
  8.        #include <sys/socket.h>
  10.        int socket(int domain, int type, int protocol);
  12. DESCRIPTION
  13.        socket()  creates  an  endpoint  for communication and returns a file descriptor that refers to that endpoint.
  14.        The file descriptor returned by a successful call will be the lowest-numbered file  descriptor  not  currently
  15.        open for the process.
  17.        The  domain argument specifies a communication domain; this selects the protocol family which will be used for
  18.        communication.  These families are defined in <sys/socket.h>.  The currently understood formats include:
  20.        Name                Purpose                          Man page
  21.        AF_UNIX, AF_LOCAL   Local communication              unix(7)
  22.        AF_INET             IPv4 Internet protocols          ip(7)
  23.        AF_INET6            IPv6 Internet protocols          ipv6(7)
  24.        ... // 省略其他协议
  26.        The socket has the indicated type, which specifies the communication semantics.  Currently defined types are:
  28.        SOCK_STREAM     Provides sequenced, reliable, two-way, connection-based byte  streams.   An  out-of-band  data
  29.                        transmission mechanism may be supported.
  31.        SOCK_DGRAM      Supports datagrams (connectionless, unreliable messages of a fixed maximum length).
  32.        ... // 省略其他类型
  34.        The protocol specifies a particular protocol to be used with the socket.   Normally  only  a  single  protocol
  35.        exists to support a particular socket type within a given protocol family, in which case protocol can be spec‐
  36.        ified as 0.  However, it is possible that many protocols may exist, in which case a particular  protocol  must
  37.        be  specified  in  this manner.  The protocol number to use is specific to the “communication domain” in which
  38.        communication is to take place; see protocols(5).  See getprotoent(3) on how to map protocol name  strings  to
  39.        protocol numbers.
  41. RETURN VALUE
  42.        On success, a file descriptor for the new socket is returned.  On error, -1 is  returned,  and  errno  is  set
  43.        appropriately.

Linux 下的 bind 函数

我们可以看出来，如果想要 bind 某一个 socket，需要一个 socket 的文件描述，一个结构体 socketaddr 和地址程度，那么 struct sockaddr 又是在哪里呢？

  1. man 2 bind
  3. NAME
  4.        bind - bind a name to a socket
  6. SYNOPSIS
  7.        #include <sys/types.h>          /* See NOTES */
  8.        #include <sys/socket.h>
  10.        int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
  12. DESCRIPTION
  13.        When  a  socket  is  created  with  socket(2),  it  exists in a name space (address family) but has no address
  14.        assigned to it.  bind() assigns the address specified by addr to the socket referred to by the file descriptor
  15.        sockfd.   addrlen  specifies  the size, in bytes, of the address structure pointed to by addr.  Traditionally,
  16.        this operation is called “assigning a name to a socket”.
  18.        It is normally necessary to assign a local address using bind() before a SOCK_STREAM socket may  receive  con‐
  19.        nections (see accept(2)).
  21.        The  rules  used  in  name binding vary between address families.  Consult the manual entries in Section 7 for
  22.        detailed information.  For AF_INET, see ip(7); for AF_INET6,  see  ipv6(7);  for  AF_UNIX,  see  unix(7);  for
  23.        AF_APPLETALK,  see  ddp(7);  for  AF_PACKET,  see  packet(7);  for AF_X25, see x25(7); and for AF_NETLINK, see
  24.        netlink(7).
  26.        The actual structure passed for the addr argument will depend on the address family.  The  sockaddr  structure
  27.        is defined as something like:
  29.            struct sockaddr {
  30.                sa_family_t sa_family;
  31.                char        sa_data[14];
  32.            }
  34.        The  only purpose of this structure is to cast the structure pointer passed in addr in order to avoid compiler
  35.        warnings.  See EXAMPLE below.
  37. RETURN VALUE
  38.        On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.


Linux 下的 ip 函数

这里我们可以看到 struct sockaddr_in 与 struct in_addr 结构体的描述

  1. man 7 ip
  3. NAME
  4.        ip - Linux IPv4 protocol implementation
  6. SYNOPSIS
  7.        #include <sys/socket.h>
  8.        #include <netinet/in.h>
  9.        #include <netinet/ip.h> /* superset of previous */
  11.        tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
  12.        udp_socket = socket(AF_INET, SOCK_DGRAM, 0);
  13.        raw_socket = socket(AF_INET, SOCK_RAW, protocol);
  15. DESCRIPTION
  16.        Linux  implements  the Internet Protocol, version 4, described in RFC 791 and RFC 1122.  ip contains a level 2
  17.        multicasting implementation conforming to RFC 1112.  It also contains an IP router including a packet filter.
  19.        The programming interface is BSD-sockets compatible.  For more information on sockets, see socket(7).
  21.        An IP socket is created using socket(2):
  23.            socket(AF_INET, socket_type, protocol);
  25.        Valid socket types are SOCK_STREAM to open a tcp(7) socket, SOCK_DGRAM to open a udp(7) socket, or SOCK_RAW to
  26.        open  a  raw(7) socket to access the IP protocol directly.  protocol is the IP protocol in the IP header to be
  27.        received or sent.  The only valid values for protocol are 0  and  IPPROTO_TCP  for  TCP  sockets,  and  0  and
  28.        IPPROTO_UDP  for  UDP  sockets.   For  SOCK_RAW  you  may specify a valid IANA IP protocol defined in RFC 1700
  29.        assigned numbers.
  31.        When a process wants to receive new incoming packets or connections, it should bind a socket to a local inter‐
  32.        face  address using bind(2).  In this case, only one IP socket may be bound to any given local (address, port)
  33.        pair.  When INADDR_ANY is specified in the bind call, the socket will be bound to all local interfaces.   When
  34.        listen(2)  is  called  on  an unbound socket, the socket is automatically bound to a random free port with the
  35.        local address set to INADDR_ANY.  When connect(2) is called on an unbound socket, the socket is  automatically
  36.        bound to a random free port or to a usable shared port with the local address set to INADDR_ANY.
  38.        A  TCP  local  socket  address  that  has  been  bound  is unavailable for some time after closing, unless the
  39.        SO_REUSEADDR flag has been set.  Care should be taken when using this flag as it makes TCP less reliable.
  41.    Address format
  42.        An IP socket address is defined as a combination of an IP interface address and a  16-bit  port  number.   The
  43.        basic IP protocol does not supply port numbers, they are implemented by higher level protocols like udp(7) and
  44.        tcp(7).  On raw sockets sin_port is set to the IP protocol.
  46.            struct sockaddr_in {
  47.                sa_family_t    sin_family; /* address family: AF_INET */
  48.                in_port_t      sin_port;   /* port in network byte order */
  49.                struct in_addr sin_addr;   /* internet address */
  50.            };
  52.            /* Internet address. */
  53.            struct in_addr {
  54.                uint32_t       s_addr;     /* address in network byte order */
  55.            };
  56.         sin_family is always set to AF_INET.  This is required; in Linux 2.2 most networking functions  return  EINVAL
  57.        when  this setting is missing.  sin_port contains the port in network byte order.  The port numbers below 1024
  58.        are called privileged ports (or sometimes: reserved ports).  Only a privileged process (on  Linux:  a  process
  59.        that  has  the  CAP_NET_BIND_SERVICE  capability  in  the  user namespace governing its network namespace) may
  60.            };
  62.            /* Internet address. */
  63.            struct in_addr {
  64.                uint32_t       s_addr;     /* address in network byte order */
  65.            };
  67.        sin_family is always set to AF_INET.  This is required; in Linux 2.2 most networking functions  return  EINVAL
  68.        when  this setting is missing.  sin_port contains the port in network byte order.  The port numbers below 1024
  69.        are called privileged ports (or sometimes: reserved ports).  Only a privileged process (on  Linux:  a  process
  70.        that  has  the  CAP_NET_BIND_SERVICE  capability  in  the  user namespace governing its network namespace) may
  71.        bind(2) to these sockets.  Note that the raw IPv4 protocol as such has no concept of a port, they  are  imple‐
  72.        mented only by higher protocols like tcp(7) and udp(7).
  74.        sin_addr  is  the IP host address.  The s_addr member of struct in_addr contains the host interface address in
  75.        network byte order.  in_addr should be assigned one of  the  INADDR_*  values  (e.g.,  INADDR_LOOPBACK)  using
  76.        htonl(3)  or set using the inet_aton(3), inet_addr(3), inet_makeaddr(3) library functions or directly with the
  77.        name resolver (see gethostbyname(3)).
  79.        IPv4 addresses are divided into unicast, broadcast, and multicast addresses.  Unicast addresses specify a sin‐
  80.        gle  interface  of a host, broadcast addresses specify all hosts on a network, and multicast addresses address
  81.        all hosts in a multicast group.  Datagrams to broadcast addresses can  be  sent  or  received  only  when  the
  82.        SO_BROADCAST  socket  flag  is set.  In the current implementation, connection-oriented sockets are allowed to
  83.        use only unicast addresses.
  85.        Note that the address and the port are always stored in network byte order.  In particular,  this  means  that
  86.        you  need  to call htons(3) on the number that is assigned to a port.  All address/port manipulation functions
  87.        in the standard library work in network byte order.
  89.        There are several special addresses: INADDR_LOOPBACK (127.0.0.1) always refers to the local host via the loop‐
  90.        back  device; INADDR_ANY (0.0.0.0) means any address for binding; INADDR_BROADCAST (255.255.255.255) means any
  91.        host and has the same effect on bind as INADDR_ANY for historical reasons.


Linux 下的 accept 函数

  1. man 2 accept
  2. NAME
  3.        accept, accept4 - accept a connection on a socket
  5. SYNOPSIS
  6.        #include <sys/types.h>          /* See NOTES */
  7.        #include <sys/socket.h>
  9.        int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
  11.        #define _GNU_SOURCE             /* See feature_test_macros(7) */
  12.        #include <sys/socket.h>
  14.        int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
  16. DESCRIPTION
  17.        The  accept()  system  call  is  used  with  connection-based  socket types (SOCK_STREAM, SOCK_SEQPACKET).  It
  18.        extracts the first connection request on the queue of pending connections for the  listening  socket,  sockfd,
  19.        creates a new connected socket, and returns a new file descriptor referring to that socket.  The newly created
  20.        socket is not in the listening state.  The original socket sockfd is unaffected by this call.
  22.        The argument sockfd is a socket that has been created with socket(2), bound to a local address  with  bind(2),
  23.        and is listening for connections after a listen(2).
  25.        The  argument  addr is a pointer to a sockaddr structure.  This structure is filled in with the address of the
  26.        peer socket, as known to the communications layer.  The exact format of the address returned  addr  is  deter‐
  27.        mined  by  the  socket's  address  family (see socket(2) and the respective protocol man pages).  When addr is
  28.        NULL, nothing is filled in; in this case, addrlen is not used, and should also be NULL.
  30.        The addrlen argument is a value-result argument: the caller must initialize it to contain the size (in  bytes)
  31.        of the structure pointed to by addr; on return it will contain the actual size of the peer address.
  33.        The  returned  address  is  truncated if the buffer provided is too small; in this case, addrlen will return a
  34.        value greater than was supplied to the call.
  36.        If no pending connections are present on the queue, and the socket is  not  marked  as  nonblocking,  accept()
  37.        blocks  the  caller until a connection is present.  If the socket is marked nonblocking and no pending connec‐
  38.        tions are present on the queue, accept() fails with the error EAGAIN or EWOULDBLOCK.
  40.        In order to be notified of incoming connections on a socket, you can use select(2), poll(2), or  epoll(7).   A
  41.        readable  event  will  be delivered when a new connection is attempted and you may then call accept() to get a
  42.        socket for that connection.  Alternatively, you can set the socket to deliver SIGIO when activity occurs on  a
  43.        socket; see socket(7) for details.
  45.        If  flags  is 0, then accept4() is the same as accept().  The following values can be bitwise ORed in flags to
  46.        obtain different behavior:
  48.        SOCK_NONBLOCK   Set the O_NONBLOCK file status flag on the new open file description.  Using this  flag  saves
  49.                        extra calls to fcntl(2) to achieve the same result.
  51.        SOCK_CLOEXEC    Set  the  close-on-exec  (FD_CLOEXEC) flag on the new file descriptor.  See the description of
  52.                        the O_CLOEXEC flag in open(2) for reasons why this may be useful.
  54. RETURN VALUE
  55.        On success, these system calls return a nonnegative integer that is a file descriptor for the accepted socket.
  56.        On error, -1 is returned, and errno is set appropriately.


Linux 下的 read 函数

  1. NAME
  2.        read - read from a file descriptor
  4. SYNOPSIS
  5.        #include <unistd.h>
  7.        ssize_t read(int fd, void *buf, size_t count);
  9. DESCRIPTION
  10.        read() attempts to read up to count bytes from file descriptor fd into the buffer starting at buf.
  12.        On  files that support seeking, the read operation commences at the file offset, and the file offset is incre‐
  13.        mented by the number of bytes read.  If the file offset is at or past the end of file, no bytes are read,  and
  14.        read() returns zero.
  16.        If  count  is  zero, read() may detect the errors described below.  In the absence of any errors, or if read()
  17.        does not check for errors, a read() with a count of 0 returns zero and has no other effects.
  19.        According to POSIX.1, if count is greater than SSIZE_MAX, the result is implementation-defined; see NOTES  for
  20.        the upper limit on Linux.
  22. RETURN VALUE
  23.        On  success,  the  number  of  bytes  read  is returned (zero indicates end of file), and the file position is
  24.        advanced by this number.  It is not an error if this number is smaller than the  number  of  bytes  requested;
  25.        this  may happen for example because fewer bytes are actually available right now (maybe because we were close
  26.        to end-of-file, or because we are reading from a pipe, or from a terminal), or because read() was  interrupted
  27.        by a signal.  See also NOTES.
  29.        On  error,  -1  is returned, and errno is set appropriately.  In this case, it is left unspecified whether the
  30.        file position (if any) changes.


C 语言启动 socket 主要步骤

此时我们就可以用 C 语言来调用 Linux 下的 Socket 函数了

C 语言调用 socket 函数

  1. // AF_INET: IPV4
  2. // SOCK_STREAM: TCP/IP
  3. // 0: 默认为 0
  4. // 返回值 lfd: 返回一个文件描述符
  5. int lfd = socket(AF_INET, SOCK_STREAM, 0);


C 语言调用 bind 函数

  1. struct sockaddr_in my_addr; // 定义一个结构体
  2. my_addr.sin_family = AF_INET; // IPV4 协议
  3. my_addr.sin_port = htons(8080); // 整型变量从主机字节顺序转变成网络字节顺序
  4. my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // htonl：将主机数转换成无符号长整型的网络字节顺序
  5. bind(lfd, (struct sockaddr*)&my_addr, sizeof(my_addr));
  6. listen(lfd, 128); // 监听此 socket 在同一时刻的连接数（并发数）

调用完 bind 函数，理论上我们就可以进行 accept 等待线程接入了

C 语言调用 accept 函数

  1. struct sockaddr_in client_addr;
  2. char client_ip[INET_ADDRSTRLEN] = "";
  3. socklen_t client_addr_len = sizeof(client_addr);
  4. int connfd = accept(lfd, (struct sockaddr*)&client_addr, &client_addr_len);

当调用完 accept 函数后，就可以获取到客户端的文件描述符，然后调用 read 函数就可以获取客户端发送的数据

C 语言调用 read 函数

  1. char recv_buf[512] = "";
  2. while(1) {
  3.     // ssize_t read(int fd, void *buf, size_t count);
  4.     int length = read(connfd, recv_buf, sizeof(recv_buf)); // 读取流中的内容到缓冲区
  5.     printf("recv data=%d\n", length);
  6.     printf("%s\n", recv_buf);
  7. }

完整的 C 文件内容

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <unistd.h>
  5. #include <sys/socket.h>
  6. #include <netinet/in.h>
  7. #include <arpa/inet.h>
  8. #include <sys/types.h>
  9. #include "WeServerSocket.h"
  12. JNIEXPORT void JNICALL Java_WeServerSocket_conn(JNIEnv *env, jobject cl, int jint) {
  13.     // int socket(int domain, int type, int protocol);
  14.     int lfd = socket(AF_INET, SOCK_STREAM, 0);
  16.     // int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
  17.     struct sockaddr_in my_addr; // 定义一个结构体
  18.     my_addr.sin_family = AF_INET; // IPV4 协议
  19.     my_addr.sin_port = htons(jint); // 整型变量从主机字节顺序转变成网络字节顺序
  20.     my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // htonl：将主机数转换成无符号长整型的网络字节顺序
  21.     bind(lfd, (struct sockaddr*)&my_addr, sizeof(my_addr));
  23.     // int listen(int sockfd, int backlog);
  24.     listen(lfd, 128); // 监听此 socket 在同一时刻的连接数（并发数）
  25.     printf("-listen client @port=%d...\n", jint);
  27.     // int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
  28.     struct sockaddr_in client_addr;
  29.     char client_ip[INET_ADDRSTRLEN] = ""; // 定义一个 client_ip 数组，INET_ADDRSTRLEN = 16
  30.     socklen_t client_addr_len = sizeof(client_addr);
  31.     int connfd = accept(lfd, (struct sockaddr*)&client_addr, &client_addr_len); // 返回客户端 socket 的文件描述符
  33.     // const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
  34.     inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, INET_ADDRSTRLEN); // 将客户端地址（网络字节）转化为数值，放到 client_ip 数组中
  35.     printf("------------------------------------------\n");
  36.     printf("client ip=%s, port=%d\n", client_ip, ntohs(client_addr.sin_port)); // ntohs：将一个16位数由网络字节顺序转换为主机字节顺序
  38.     char recv_buf[512] = "";
  39.     while(1) {
  40.         // ssize_t read(int fd, void *buf, size_t count);
  41.         int length = read(connfd, recv_buf, sizeof(recv_buf)); // 读取流中的内容到缓冲区
  42.         printf("recv data=%d\n", length);
  43.         printf("%s\n", recv_buf);
  44.     }
  46.     close(connfd);
  47.     printf("client closed\n");
  48.     close(lfd);
  49. }

JNI 调用步骤

  1. Java 调用 native 方法

    1. public class WeServerSocket {
    2.  static {
    3.      System.loadLibrary("WeNativeNet");
    4.  }
    6.  public static void main(String[] args) throws IOException {
    7.      WeServerSocket serverSocket = new WeServerSocket();
    8.      serverSocket.conn(8080);
    9.  }
    11.  public native void conn(int port);
    12. }

  2. 装载库，保证 JVM 在启动的时候就会装载所需要的库（so 文件），故而一般都是 static 方法

    1. static {
    2.  System.loadLibrary("WeNativeNet");
    3. }

  3. 编译成 class 文件

    1. javac WeServerSocket.java

  4. 生成 .h 的头文件

    1. javah 包名.类名
    2. javah WeServerSocket

  5. 将 .h 头文件包含到 c 文件中，并查看 .h 头文件中的方法签名信息，复制到 c 文件中 ```bash

    include “WeServerSocket.h”

JNIEXPORT void JNICALL Java_WeServerSocket_conn(JNIEnv *env, jobject cl, int jint)

  2. 6. 将 C 文件编译动态连接库 .so 文件
  3. - /usr/lib/jdk/jdk1.8.0_231/include 目录下包括 jni.h 文件
  4. - /usr/lib/jdk/jdk1.8.0_231/include/linux 目录下包括 md_jni.h 文件
  5. - 动态库前面必须是 lib 开头
  6. ```bash
  7. gcc -fPIC -I /usr/lib/jdk/jdk1.8.0_231/include -I /usr/lib/jdk/jdk1.8.0_231/include/linux -shared -o lib动态库名.so C文件名.c -pthread

  1. 把这个动态连接库加入到 path 环境变量下（临时），如果需要的话可以加到 /etc/profile 下

    1. export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/

  2. 运行 class 文件 ```bash java WeServerSocket

-listen client @port=8080…

  2. 9. 用 nc 测试
  3. ```bash
  4. nc 127.0.0.1 8080
  5. hello server

至此完成了模拟 ServerSocket 启动 socket 服务端的所有流程，同时你也清楚了 natvie 方法和 JNI 调用方式