网络编程技术 实验3

实验目标：通过套接字和WSL，实现局域网内的通信。



### 1 修改后的客户端代码


``` c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    printf("start sending message to server on 127.0.0.1:1324\n");

    // 创建客户端套接字
    int socketfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (socketfd == -1) {
        perror("create socket failed: \n");
        return -1;
    }

    // 创建服务器端地址
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(1324);
    server_addr.sin_addr.s_addr = inet_addr("172.20.201.19");

    // 开始发送数据
    char* message = "Hello from client! \0";
    ssize_t bytes_sent = sendto(socketfd, message, strlen(message), 0, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if (bytes_sent == -1) {
        perror("sending message failed: \n");
        close(socketfd);
        return -1;
    }

    // 开始接收数据
    char buffer[1024];
    ssize_t bytes_recv = recvfrom(socketfd, buffer, sizeof(buffer), 0, NULL, NULL);
    if (bytes_recv == -1) {
        perror("receiving data failed: \n");
        close(socketfd);
        return -1;
    }
    printf("received from server:\n");
    printCharArrayToHex(buffer, 1024);

    // 关闭套接字
    close(socketfd);
    return 0;
}

// 将char数组中的内容按十六进制进行打印
void printCharArrayToHex(char *buf, int bytes) {
    int i;
    for (i = 0; i < bytes; i++)
    {
        printf("%x ", (unsigned char)buf[i]);
    }
    
}

```

### 2 修改后的服务端代码

``` c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

// 创建一个简单UDP服务器 监听1324端口

int main(int argc, char const *argv[])
{

    printf("start monitor on 192.168.189.17:1324 \n");

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0); // SOCK_DGRAM是UDP套接字
    // sockfd这个名字中的fd 是文件描述符的缩写 在unix/linux中 fd是进程独有的文件描述符表的索引 它的意思是 socket可以被视作一个文件
    if (sockfd == -1) {
        perror("create socket failed: \n");
        return -1;
    }

    // 设置服务器地址
    struct sockaddr_in addr;
    addr.sin_family = AF_INET; // 地址族
    addr.sin_port = htons(1324); // 端口
    addr.sin_addr.s_addr = inet_addr("192.168.189.17"); // IP 另外 INADDR_ANY可表示0.0.0.0

    // 将套接字绑定到服务器地址上
    int ret = bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)); // addr这里 可以视作做了一个转型
    if (0 > ret) {
        // 绑定失败
        perror("bind failed: \n");
        close(sockfd);
        return -1;
    }

    // 设置客户端地址
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[1024];

    while (1)
    {
        ssize_t bytes_recv = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&client_addr, &client_len);
        if (bytes_recv == -1) {
            perror("receive message error: \n");
            continue;
        }

        char client_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &(client_addr.sin_addr), client_ip, INET_ADDRSTRLEN);
        int clinet_port = ntohs(client_addr.sin_port);
        printf("client ip: %s, port: %d\n", client_ip, clinet_port);

        printf("received from client: %s\n", buffer);
        memset(buffer, 0, sizeof(buffer));

        // 按老师要求 编写自定义回复内容
        const char* response = "Hello from server! \0";

        // 定义char数组
        char buf[1024];
        // 声明一个指针 并且指向buf数组的第一个元素
        u_int8_t *p;
        p = buf;
        // 填充24进去
        buf[0] = 24;
        // 指针转型 使得编辑的内容从一位变成了两位 另外多字节内容必须转换字节序
        *((u_int16_t*)(buf + 1)) = htons(2024);
        // 同上的指针转型
        *((u_int32_t*)(buf + 3)) = htonl(20240304);
        // 获取主机名 如果无法获取则填充"Unknown Host"
        if (gethostname(buf + 7, 1017) == -1) {
            strcpy(buf + 7, "Unknown Host");
        }

        ssize_t bytes_send = sendto(sockfd, buf, 1017, 0, (struct sockaddr*)&client_addr, client_len);
        if (bytes_send == -1) {
            perror("sending message error: \n");
        }
    }
    
    close(sockfd);
    return 0;
}

```

### 3 运行效果

![image.png](https://www.misaka19327.cc/static/img/27686d32346285f55db4996e3ebbae9e.image.png)


![image.png](https://www.misaka19327.cc/static/img/4756d3257201d52b6b6ff30ddf88a8da.image.png)

可见局域网内的两个IP成功地进行通信，并且通信内容中包含主机名。

### 4 注意事项

1. 局域网内的两个主机通过这种方式通信，必须关闭双方主机的防火墙：

    ![image.png](https://www.misaka19327.cc/static/img/2ffeffe708451624b9b4387f148066bb.image.png)
    
2. 如果WSL想要被外界以一个固定IP访问，那么必须修改用户文件夹下的`.wslconfig`文件，并且修改`hostAddressLoopback`参数为`true`。

    ![image.png](https://www.misaka19327.cc/static/img/4ff7ecbeeabfa0cf0b7a5909708f6b05.image.png)
    
    在这里附上微软官方的说明：
    
    ![image.png](https://www.misaka19327.cc/static/img/447d844920f1f7fc8f28b9677076b174.image.png)
    
    （请注意，该说明为2024年3月5日截取，实际微软可能修改，请以最新说明为准[WSL中的高级设置配置 | Microsoft Learn](https://learn.microsoft.com/zh-cn/windows/wsl/wsl-config)）
    
    实际效果：
    
    ![image.png](https://www.misaka19327.cc/static/img/51ff0ba23408a0e790b0165121ae11db.image.png)

网络编程技术 实验2

实验目标：通过套接字，创建客户端和服务端，并且实现基础的互相通信。



环境: Ubuntu 22.04 LTS(WSL)，gcc 11.04，GNU gdb (Ubuntu 12.1-0ubuntu1~22.04) 12.1

### 1 WSL + VS Code + C/C++配置

先安装WSL（必须是WSL2），并且在WSL中安装C/C++编译器，在VS Code中安装WSL扩展，C/C++所需扩展（后续记得在WSL中安装）：
![image.png](https://www.misaka19327.cc/static/img/1944894b85a75e20edc997a46552a50e.image.png)
> 安装C/C++编译器命令：
> 1. `sudo apt install gcc-11`
> 2. `sudo apt install g++-11`
> 3. `sudo apt install gdb`

![image.png](https://www.misaka19327.cc/static/img/913ad3de5a9f6a23154159042d3f8fd8.image.png)


之后在文件管理器里找到WSL的位置，随便创建一个.c文件，然后使用VS Code打开，并且在左侧的资源管理器里打开文件夹：

![image.png](https://www.misaka19327.cc/static/img/d7860b2d15bbe608d58df5744859d0e4.image.png)

打开之后，左下角会提示：We are working on folders in \\wsl...，点击“Reopen Folder in WSL”：

![image.png](https://www.misaka19327.cc/static/img/17bb84443b6337c5b2abd6a8709a3ad1.image.png)

在这个项目文件夹下新建.vscode文件夹，并且新建三个文件（settings.json不必要）：

![image.png](https://www.misaka19327.cc/static/img/7a858b235afd16aca824d4f5dbe4259a.image.png)

c_cpp_properties.json（C语言版）：
``` json
{
    "configurations": [
        {
            "name": "Linux",
            // includePath中的内容除了第一条 剩下的在WSL中运行"gcc-11 -v -E -x c -"(c配置)或"gcc-11 -v -E -x c++ -"(c++配置)后 见下图寻找内容
            "includePath": [
                "${workspaceFolder}/**",
                "/usr/lib/gcc/x86_64-linux-gnu/11/include",
                "/usr/local/include",
                "/usr/include/x86_64-linux-gnu",
                "/usr/include"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc", // 编译器路径
            "intelliSenseMode": "linux-gcc-x64",
            "cStandard": "c11" // c语言标准
        }
    ],
    "version": 4
}
```

![image.png](https://www.misaka19327.cc/static/img/8237c0019f24d5bc56e205acfb6efb22.image.png)

c_cpp_properties.json（C++语言版）：
``` json
{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/usr/include/c++/11",
                "/usr/include/x86_64-linux-gnu/c++/11",
                "/usr/include/c++/11/backward",
                "/usr/lib/gcc/x86_64-linux-gnu/11/include",
                "/usr/local/include",
                "/usr/include/x86_64-linux-gnu",
                "/usr/include"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/g++",
            "intelliSenseMode": "linux-gcc-x64",
            "cStandard": "c11"
        }
    ],
    "version": 4
}
```

launch.json：
``` json
{
    // 使用 IntelliSense 了解相关属性。 
    // 悬停以查看现有属性的描述。
    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "gcc-11 - 生成和调试活动文件",
            "type": "cppdbg",
            "request": "launch",
            "program": "${fileDirname}/${fileBasenameNoExtension}",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "gdb",
            "setupCommands": [
                {
                    "description": "为 gdb 启用整齐打印",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "Launch: build active file"
        }
    ]
}
```

tasks.json（C语言版）：
``` json
{
    "tasks": [
        {
            "type": "cppbuild",
            "label": "Launch: build active file",
            "command": "/usr/bin/gcc", // 编译器路径
            "args": [
                "-fdiagnostics-color=always",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "use /usr/bin/gcc-11"
        }
    ],
    "version": "2.0.0"
}
```

task.json（C++语言版）：
``` json
{
    "tasks": [
        {
            "type": "cppbuild",
            "label": "Launch: build active file",
            "command": "/usr/bin/g++",
            "args": [
                "-fdiagnostics-color=always",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "use /usr/bin/gcc-11"
        }
    ],
    "version": "2.0.0"
    }
```

之后，就可以编译并且运行C/C++代码了：

![image.png](https://www.misaka19327.cc/static/img/4d1233e0cc2692294eb2f90b87244542.image.png)

### 2 服务端代码

``` c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

// 创建一个简单UDP服务器 监听1324端口

int main(int argc, char const *argv[])
{

    printf("start monitor on 127.0.0.1:1324 \n");

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0); // SOCK_DGRAM是UDP套接字
    // sockfd这个名字中的fd 是文件描述符的缩写 在unix/linux中 fd是进程独有的文件描述符表的索引 它的意思是 socket可以被视作一个文件
    if (sockfd == -1) {
        // 创建socket失败
        perror("create socket failed: \n"); // 该函数会查找全局变量errno 并且将其保存的错误码转换为可读的报错信息
        // 全局变量errno 是大部分标准库函数出错时保存报错码的位置
        return -1;
    }

    // 设置服务器地址
    struct sockaddr_in addr;
    addr.sin_family = AF_INET; // 地址族
    addr.sin_port = htons(1324); // 端口
    addr.sin_addr.s_addr = inet_addr("127.0.0.1"); // IP 另外 INADDR_ANY可表示0.0.0.0

    // 将套接字绑定到服务器地址上
    int ret = bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)); // addr这里 可以视作做了一个转型
    if (0 > ret) {
        // 绑定失败
        perror("bind failed: \n");
        close(sockfd); // 关闭套接字
        return -1;
    }

    // 设置客户端地址 这个结构体的作用是在下面的recvfrom函数中保存发送者的地址信息
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[1024]; //缓冲区

    while (1)
    {
        ssize_t bytes_recv = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&client_addr, &client_len);
        if (bytes_recv == -1) {
            // 接收信息错误
            perror("receive message error: \n");
            continue;
        }

        char client_ip[INET_ADDRSTRLEN]; // INET_ADDRSTRLEN表示 32 位 IPv4 地址 的字符串表示形式所需的最大长度 为16
        inet_ntop(AF_INET, &(client_addr.sin_addr), client_ip, INET_ADDRSTRLEN); // 该函数用于将二进制格式的IPv4或IPv6地址 转换为文本格式
        int clinet_port = ntohs(client_addr.sin_port); // 转换字节的网络序和主机序 这里的ntohs是Network to Host Short的缩写 网络序转主机16位无符号短整数(u_short)
        // 类似的还有htonl: Host to Network u_long
        // htons: Host to Network u_short
        // ntohl: Network to Host u_long
        printf("client ip: %s, port: %d\n", client_ip, clinet_port);

        printf("received from client: %s\n", buffer);
        memset(buffer, 0, sizeof(buffer)); // 清除缓冲区

        const char* response = "Hello from server! \0";
        ssize_t bytes_send = sendto(sockfd, response, strlen(response), 0, (struct sockaddr*)&client_addr, client_len); // 发回去
        if (bytes_send == -1) {
            // 没发成功
            perror("sending message error: \n");
        }
    }
    
    close(sockfd);
    return 0;
}

```

### 3 客户端代码

``` c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    printf("start sending message to server on 127.0.0.1:1324\n");

    // 创建客户端套接字
    int socketfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (socketfd == -1) {
        perror("create socket failed: \n");
        return -1;
    }

    // 创建服务器端地址
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(1324);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    // 开始发送数据
    char* message = "Hello from client! \0";
    ssize_t bytes_sent = sendto(socketfd, message, strlen(message), 0, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if (bytes_sent == -1) {
        perror("sending message failed: \n");
        close(socketfd);
        return -1;
    }

    // 开始接收数据
    char buffer[1024];
    ssize_t bytes_recv = recvfrom(socketfd, buffer, sizeof(buffer), 0, NULL, NULL);
    if (bytes_recv == -1) {
        perror("receiving data failed: \n");
        close(socketfd);
        return -1;
    }
    printf("received from server: %s\n", buffer);

    // 关闭套接字
    close(socketfd);
    return 0;
}

```

### 4 运行结果

客户端：

![image.png](https://www.misaka19327.cc/static/img/c6b13ab82edcd4fea58175392414f9b4.image.png)

服务端：

![image.png](https://www.misaka19327.cc/static/img/1fff9c7c7fe679e04a928e7d2bd34721.image.png)

### 5 WSL其他问题

1. 修改WSL用户密码

在PowerShell中，运行`wsl.exe --user root`进入WSL，之后再运行`passwd root`（root替换要修改密码的用户名）来修改用户名：

![image.png](https://www.misaka19327.cc/static/img/7dd44c71602bfe269af335856b344d4b.image.png)

2. WSL在默认情况下是英文，没有中文，所以中文显示会是乱码。对于Ubuntu来说，安装以下解决问题：

``` bash
sudo apt install fonts-noto-cjk
```

3. WSL文件管理器，Chrome安装，

``` bash
sudo apt install nautilus -y
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt install --fix-missing ./google-chrome-stable_current_amd64.deb
```

4. Linux运行程序报错：error while loading shared libraries: libQt5Widgets.so.5: cannot open shared object file: No such file or directory

运行`sudo apt-get install libqt5widgets5`解决。

5. Linux运行二进制文件报错

![image.png](https://www.misaka19327.cc/static/img/1d15be68fc1e62b4879dc9cf9ccaf6fe.image.png)

该文件没有执行权限，`chmod 777 mNetAssist`即可解决。

6. 其他问题见官方说明[ 在适用于 Linux 的 Windows 子系统上运行 Linux GUI 应用 ](https://learn.microsoft.com/zh-cn/windows/wsl/tutorials/gui-apps)。

网络编程技术 实验1

Room框架是谷歌官方开发框架Jetpack的其中一部分，主要目的是简化开发者访问应用自身的SQLite数据库的步骤。



官方对[Room库](https://developer.android.google.cn/training/data-storage/room?hl=zh-cn)的说明说明：

> Room 持久性库在 SQLite 上提供了一个抽象层，以便在充分利用 SQLite 的强大功能的同时，能够流畅地访问数据库。具体来说，Room 具有以下优势：
> 
> 1. 提供针对 SQL 查询的编译时验证。
> 2. 提供方便注解，可最大限度减少重复和容易出错的样板代码。
> 3. 简化了数据库迁移路径。
> 
> 出于这些方面的考虑，我们强烈建议您使用 Room，而不是直接使用 SQLite API。

Room库的架构示意图：

![image.png](https://www.misaka19327.cc/static/img/182ae86439ecb9ccbeb136f4291f8c11.image.png)

### 1 依赖

``` groovy
dependencies {
    def room_version = "2.6.1" // room版本

    implementation "androidx.room:room-runtime:$room_version"
    annotationProcessor "androidx.room:room-compiler:$room_version"

    // To use Kotlin annotation processing tool (kapt)
    kapt "androidx.room:room-compiler:$room_version"
    // To use Kotlin Symbol Processing (KSP)
    ksp "androidx.room:room-compiler:$room_version"

    // optional - RxJava2 support for Room
    implementation "androidx.room:room-rxjava2:$room_version"

    // optional - RxJava3 support for Room
    implementation "androidx.room:room-rxjava3:$room_version"

    // optional - Guava support for Room, including Optional and ListenableFuture
    implementation "androidx.room:room-guava:$room_version"

    // optional - Test helpers
    testImplementation "androidx.room:room-testing:$room_version"

    // optional - Paging 3 Integration
    implementation "androidx.room:room-paging:$room_version"
}
```

### 2 定义实体类

在Room中，一个实体即为一个数据类，对应一个表中的一条记录。因此一个实体类能够对应一个表的结构。

写法示例如下：

``` kotlin

/**
 * 单个文件版本信息
 *
 * @property rowid 主键Id
 * @property fileId 文件Id
 * @property filePath 文件具体路径
 * @property dateTime 文件更新时间
 * @property version 文件版本
 */
// @Fts4 该注解使一个实体能够支持全文搜索 但该注解不支持外键
@Entity(
    tableName = "FileVersionInfo",  // 实体注解 声明表名
    foreignKeys = [ForeignKey( // 实体注解 声明外键 外键可以有多个
        entity = FileEntity::class, // 主表对应实体
        childColumns = ["fileId"], // 从表的字段
        parentColumns = ["rowid"], // 主表中要依赖的具体字段
        onUpdate = ForeignKey.CASCADE, // 更新策略
        onDelete = ForeignKey.CASCADE // 删除策略
    )]
)
data class FileVersionEntity (
    @PrimaryKey(autoGenerate = true) // 声明主键
    val rowid: Int = 0,

    // 文件Id
    @ColumnInfo(name = "fileId") // 声明字段
    val fileId: Int,

    // 文件路径
    @ColumnInfo(name = "filePath")
    val filePath: String,

    // 文件存储日期
    @ColumnInfo(name = "dateTime", defaultValue = "DATETIME")
    val dateTime: String,

    // 文件版本
    @ColumnInfo(name = "version")
    val version: Long
)

/**
 * 单个文件信息
 *
 * @property rowid 主键Id
 * @property fileName 文件名
 * @property fileIncidentId 文件关联事件Id
 * @property fileTag 文件Tag列表
 * @property fileUpdateDateTime 文件最新更新日期
 * @property fileLatestVersion 文件最新版本
 * @property fileComment 文件说明
 * @property fileHash 文件最新版本Hash值
 */
//@Fts4
@Entity(
    tableName = "FileInfo",
    foreignKeys = [ForeignKey(
        entity = IncidentEntity::class,
        childColumns = ["fileIncidentId"],
        parentColumns = ["rowid"],
        onDelete = ForeignKey.CASCADE,
        onUpdate = ForeignKey.CASCADE
    )]
)
data class FileEntity(
    @PrimaryKey(autoGenerate = true)
    val rowid: Int = 0,

    @ColumnInfo(name = "fileName")
    val fileName: String,

    @ColumnInfo(name = "fileIncidentId")
    val fileIncidentId: Int,

    @ColumnInfo(name = "fileTag")
    val fileTag: String,

    @ColumnInfo(name = "fileUpdateDateTime", defaultValue = "DATETIME")
    val fileUpdateDateTime: String,

    @ColumnInfo(name = "fileLatestVersion")
    val fileLatestVersion: Int,

    @ColumnInfo(name = "fileComment")
    val fileComment: String,

    @ColumnInfo(name = "fileHash")
    val fileHash: String,

) {
    @Ignore // Ignore注解可以使得room根据实体建表时忽略该字段
    val fileVersionInfo: List<FileVersionEntity>? = null

    // Entity所需要的DataClass的构造方法只能和表的字段互相匹配 因此需要Ignore的字段不能放在构造方法中
}

/**
 * 单个事件信息
 *
 * @property rowid 主键Id
 * @property incidentName 事件名
 * @property incidentComment 事件说明
 */
@Entity(tableName = "IncidentInfo")
data class IncidentEntity(
    @PrimaryKey(autoGenerate = true)
    val rowid: Int = 0,

    @ColumnInfo(name = "incidentName")
    val incidentName: String,

    @ColumnInfo(name = "incidentComment")
    val incidentComment: String,
) {
    @Ignore
    val incidentFileInfo: List<FileEntity>? = null
}
```

### 3 定义数据访问对象（DAO）

在这里只需要定义DAO接口即可，在接口中的抽象方法声明方法要执行的SQL增删改查操作，其余的代码Room会自动生成。

写法示例如下：

``` kotlin

```

### 4 定义数据库类

数据库类定义了数据库的配置，并且作为应用对SQLite数据库的主要访问点。该数据库类必须是抽象类，必须带有`@Database`注解，并且对于与该数据库关联的每个DAO类，该类必须定义一个空参数的抽象方法，并返回DAO类的实例。

写法示例如下：

``` kotlin

/**
 * 数据库类 通过getInstance()获取实例
 *
 */
@Database(
    entities = [FileVersionEntity::class, FileEntity::class, IncidentEntity::class], 
    version = 1
) // Database注解 声明数据库
abstract class FileDatabase: RoomDatabase() {

    // 这些获取DAO实例的方法必须有
    abstract fun fileEntityDAO(): FileEntityDAO // DAO 这一个数据库里可以有多个DAO
    abstract fun incidentEntityDAO(): IncidentEntityDAO
    abstract fun fileVersionInfoDAO(): FileVersionInfoDAO

    // 伴生对象 kotlin的静态方法的写法
    companion object {
        private var INSTANCE: FileDatabase? = null

        /**
         * 获取数据库实例 (单例模式)
         *
         * @param context 上下文
         * @return 数据库实例
         */
        fun getInstance(context: Context): FileDatabase {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(
                    context.applicationContext,
                    FileDatabase::class.java,
                    "FileReceiveActivity"
                ).build()
            }
            return INSTANCE as FileDatabase // 转型
        }
    }
}
```

### 5 在应用中通过Room访问数据

首先必须在应用中获取数据库类和DAO类的实例，之后通过实例在协程中获取数据，再在主线程上更新UI。

### * 通过App Inspection调试应用中的数据库