【Linux开发实战指南】基于TCP、进程数据结构与SQL数据库：构建在线云词典系统（含注册、登录、查询、历史记录管理功能及源码分享）-阿里云开发者社区

@author: bbxwg

@system_version: Ubuntu 22.04

@Time : 2024-07-05

dic.txt文件因为过于庞大，所以放到公众号中，大家需要自取。

项目演示：

1. 主界面

编辑

2. 注册

编辑

3. 登录

编辑

4. 查询单词

编辑

5. 查询历史记录

编辑

6. 删除历史记录

编辑

7. 退出

编辑

技术讲解：

编辑

TCP连接

TCP（Transmission Control Protocol）连接是互联网上最常用的一种面向连接、可靠的、基于字节流的传输层通信协议。建立TCP连接需要经过著名的“三次握手”过程：

SYN（同步序列编号）：客户端发送一个SYN包给服务器，并进入SYN_SEND状态，等待服务器确认。
SYN-ACK：服务器收到SYN包后，回应一个SYN-ACK（SYN+ACKnowledgment）包，告诉客户端其接收到了请求，并同意建立连接，此时服务器进入SYN_RECV状态。
ACK（确认字符）：客户端收到服务器的SYN-ACK包后，发送一个ACK包给服务器，确认收到了服务器的确认信息。此时，TCP连接正式建立，双方进入ESTABLISHED状态。

进程的并发

进程并发是指多个进程在同一时间段内交替执行的现象，操作系统通过时间片轮转、优先级调度等策略来管理进程的执行，给予每个进程一定的CPU时间来执行任务，从而实现“同时”处理多个任务的效果。并发可以提高系统资源利用率和整体处理能力，但也会带来资源竞争、死锁等问题，需要通过同步机制（如互斥锁、信号量等）来协调。

链表

链表是一种重要的数据结构，用于存储线性集合的元素，每个元素（节点）包含数据和指向下一个节点的指针。链表分为单链表、双链表、循环链表等类型。与数组相比，链表的优点在于插入和删除操作更快，因为它不需要移动其他元素，只需修改相邻节点的指针。缺点是访问元素不如数组直接，需要从头节点开始逐个遍历。

SQLite3

SQLite3是一个轻量级、无服务器、零配置的嵌入式数据库引擎，它允许程序将整个数据库（包括定义、表、索引和数据）存储在单一的文件中。SQLite支持SQL语言，可以用于各种应用开发，特别是在那些需要本地存储、对数据库服务器要求不高或不想管理数据库服务器的场景下，如手机应用、桌面应用等。SQLite的特点是易于集成、跨平台、占用资源少。

IO对文件的读写

在编程中，对文件的读写是基础的IO操作，主要通过系统调用或库函数实现。以C语言为例：

读文件：通常使用fopen函数打开文件，然后通过fread或fgets等函数读取内容。例如：
C

1FILE *file = fopen("example.txt", "r");
2if (file != NULL) {
3    char buffer[255];
4    fgets(buffer, sizeof(buffer), file);
5    fclose(file);
6}

写文件：同样使用fopen函数以写模式打开文件，然后通过fwrite或fprintf等函数写入数据。例如：
C

1FILE *file = fopen("output.txt", "w");
2if (file != NULL) {
3    fprintf(file, "Hello, World!\n");
4    fclose(file);
5}

这些操作涉及文件句柄、缓冲区管理及错误处理，是进行文件操作的基本步骤。

功能实现

Linux系统编程：利用Linux环境下的高级编程技巧。
用户的注册和登录：实现安全的用户认证机制。
查询单词：高效检索词典数据库中的词汇信息。
查询或删除历史记录：提供用户对过往查询记录的操作功能。

实现逻辑

本节将详细介绍开发过程的关键步骤，帮助你从零开始构建这一系统。

创建SQLite3数据库：用于存储用户账户信息及查询历史记录，确保数据的持久化和安全性。

设计数据库模式，包括用户表和历史记录表。
实现增删查改的基本操作。

定义请求类型：通过结构体区分注册、登录、查询单词和管理历史记录等不同操作。

结构体设计应包含所有必要的字段，如用户名、密码、操作类型等。
利用链表存储结构体实例，便于动态管理。

搭建代码框架：先构建整体框架，再逐步填充细节。

定义服务器和客户端的主循环。
规划函数调用流程，预留函数体以便后续填充。

确保TCP通信稳定：实现可靠的双向数据传输。

初始化TCP套接字，监听端口。
处理连接请求，接收和发送数据包。
验证数据格式，防止解析错误。

准备单词文档：作为词典数据源。

选择合适的单词列表文件。
使用标准I/O库读取和解析文档。

实现核心逻辑：编写关键算法和业务处理代码。

注册和登录验证：检查用户信息的正确性。
单词查询：采用高效的数据结构加速检索。

注意：使用回调函数时，确保条件判断准确无误，避免查询失败或结果不匹配。

历史记录管理：记录和展示用户的查询历史，提供删除选项。

我遇到的问题：

编辑

大概思路图：

编辑

服务器端代码思路解析

必要条件

并发能力：采用进程并发模型，确保服务器能同时处理来自多个客户端的请求。
通信方式：基于TCP协议，实现可靠的数据传输。

步骤详解

创建数据库表

设计两个SQLite3表：一个用于存储用户账号信息（用户名、密码），另一个用于记录历史查询数据。
实现基本的CRUD（创建、读取、更新、删除）操作，确保数据的准确性和完整性。

初始化网络服务

创建TCP套接字，设置相关属性。
绑定IP地址和端口号，启动监听，准备接受客户端连接。
接收客户端连接请求，为每个连接创建新进程以处理并发请求。

处理客户端请求

读取客户端发送的完整结构体数据包。
使用switch语句分析请求类型，调用相应的处理函数。

注册/登录：验证用户信息，更新数据库状态。
查询单词：搜索词典数据库，返回查询结果。
历史记录：记录或检索用户的历史查询记录。

客户端代码思路解析

步骤详解

初始化网络连接

创建TCP套接字，指定服务器地址和端口。
连接到服务器，建立通信通道。
准备发送和接收数据。

交互逻辑

打印帮助菜单，指导用户输入命令。
根据用户输入，调用相应函数处理请求。

注册/登录：向服务器发送用户信息，等待认证结果。
查询单词：提交单词查询请求，接收查询结果。
历史记录：请求历史记录，显示或删除记录。

服务器源码如下：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/select.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "dictionary.h"
#include <sqlite3.h>
#include <signal.h>
#include <sys/wait.h>
#include <time.h>
int acceptfd;
int search_word(int acceptfd);
int num = 10;
time_t t;
struct tm *tm;
// 注册函数
void register_sev(int acceptfd, char *p, sqlite3 *db)
{
    char sql[128] = " "; //定义数组来装insert语句
    sprintf(sql, "insert into user values('%s','%s');", dic.name, dic.password);
    //如果插入不成功则给dic.text赋值失败反之OK
    if (sqlite3_exec(db, sql, NULL, NULL, &p) != SQLITE_OK)
    {
        strcpy(dic.text, "already exits!");
    }
    else
    {
        strcpy(dic.text, "OK");
    }
    send(acceptfd, &dic, sizeof(dic), 0); //发送
}
// 登录函数
void login_sev(int acceptfd, char *p, char **result, int row, int line, sqlite3 *db)
{
    // 定义一个输入去接收这个查询用户名和密码的语句
    char buf[128];
    sprintf(buf, "select * from user where name = '%s' and password = '%s';", dic.name, dic.password);
    // 先把输入的数据查询一下在表里，如果表里有数据则代表数据库有密码
    if (sqlite3_get_table(db, buf, &result, &row, &line, &p) != SQLITE_OK)
    {
        perror("sev sqlite3_table error\n");
        return;
    }
    // 如果行大于零则代表有数据成功
    if (row > 0)
    {
        strcpy(dic.text, "login successs");
    }
    else
    {
        strcpy(dic.text, "login loose,please check your name or password!");
    }
    send(acceptfd, &dic, sizeof(dic), 0);
}
// 查询单词
void query_sev(int acceptfd, sqlite3 *db, char *p)
{
    time_t t;
    struct tm *tm;
    int a = 0;
    //定义一个语句去接受查询的语句
    char sql2[128] = "";
    int found = search_word(acceptfd); //去接受查询单词这个函数的返回值 不为1则代表失败 返回1则代表成功
    if (found != 1)
    {
        strcpy(dic.text, "can't find \n");
        send(acceptfd, &dic, sizeof(dic), 0);
    }
    else
    {
        time(&t);
        tm = localtime(&t);
        sprintf(dic.time_sev, "%d-%d-%d %d:%d:%d", tm->tm_year + 1900,
                tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
        sprintf(sql2, "insert into record values('%s','%s');", dic.password, dic.time_sev); // 成功后就把查询成功的单词插入到record这个表里
        if (sqlite3_exec(db, sql2, NULL, NULL, &p) != SQLITE_OK)
        {
            perror("record insert error\n");
            return;
        }
    }
}
// 查询单词函数
int search_word(int acceptfd)
{
    //定义每次接受来的密码的长度
    int len = strlen(dic.password);
    //打开文件用标准IO
    FILE *sp = fopen("dic.txt", "r");
    if (NULL == sp)
    {
        perror("sp error\n");
        return -1;
    }
    //如果dic.txt文件不为空时继续执行
    while (fgets(dic.text, sizeof(dic.text), sp) != NULL)
    {
        //拿密码去比较文件中的前几位 如果成功发送dic 并且返回1
        if (!strncmp(dic.text, dic.password, len))
        {
            send(acceptfd, &dic, sizeof(dic), 0);
            return 1;
        }
    }
}
//回调函数
int history_callback(void *arg, int colunms, char **text, char **name)
{
    if (text != NULL)
    {
        sprintf(dic.text, "%s %s", text[0], text[1]);
        send(acceptfd, &dic, sizeof(dic), 0);
    }
    return 0;
}
//历史函数
int history_sev(char *p, sqlite3 *db)
{
    if (sqlite3_exec(db, "select * from record;", history_callback, NULL, &p) != SQLITE_OK) // 此处用的是回调函数
    {
        fprintf(stderr, "select is error: %s\n", p); //如果不等于OK责代表没成功，报错
        return -1;
    }
    else
        printf("请求成功\n");
    dic.history_id = 1;
    send(acceptfd, &dic, sizeof(dic), 0);
    return 0;
}
void delete_history(char *p, sqlite3 *db)
{
    if (sqlite3_exec(db, "delete from record;", NULL, NULL, &p) != SQLITE_OK)
    {
        fprintf(stderr, "delete is error: %s\n", p); //如果不等于OK责代表没成功，报错
    }
    else
    {
        strcpy(dic.text, "删除成功!");
        send(acceptfd, &dic, sizeof(dic), 0);
    }
}
//处理僵尸进程
void hanlder(int arg)
{
    waitpid(-1, NULL, WNOHANG);
}
int main(int argc, char const *argv[])
{
    //1. 创建sql表
    sqlite3 *db = NULL;
    if (sqlite3_open("./dictionary.db", &db) != 0)
    {
        fprintf(stderr, "sqlite3 is error%s\n", sqlite3_errmsg(db));
        return -1;
    }
    // 创建两个表
    char *p = NULL;
    if (sqlite3_exec(db, "create table user(name char primary key, password char);", NULL, NULL, &p) != SQLITE_OK)
    {
        fprintf(stderr, "create stu1 is error %s\n", p);
        return -1;
    }
    if (sqlite3_exec(db, "create table record(password char,time char);", NULL, NULL, &p) != SQLITE_OK)
    {
        fprintf(stderr, "create record is error %s\n", p);
        return -1;
    }
    // 创建指针以及行和列的变量
    char **result = NULL;
    int row = 0;
    int line = 0;
    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("sev sockfd error\n");
        return -1;
    }
    //填充结构体
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int len = sizeof(caddr);
    // 绑定 和 监听
    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind error\n");
        return -1;
    }
    if (listen(sockfd, 5) < 0)
    {
        perror("sev listen error\n");
        return -1;
    }
    // 处理僵尸进程
    signal(SIGCHLD, hanlder);
    // 循环去接受
    while (1)
    {
        acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);
        if (acceptfd < 0)
        {
            perror("sev acceptfd is error\n");
            return -1;
        }
        // 创建进程
        pid_t pid = fork();
        if (pid < 0)
        {
            perror("sev pid error\n");
            return -1;
        }
        else if (pid == 0) // 子进程
        {
            while (recv(acceptfd, &dic, sizeof(dic), 0))
            {
                switch (dic.type)
                {
                case 'r':
                    register_sev(acceptfd, p, db); // 注册函数
                    break;
                case 'l':
                    login_sev(acceptfd, p, result, row, line, db); // 登录函数
                    break;
                case 'q':
                    query_sev(acceptfd, db, p); //查询函数
                    break;
                case 'h':
                    history_sev(p, db); //历史查询函数
                    break;
                case 'd':
                    delete_history(p, db);// 历史记录删除函数
                    break;
                default:
                    break;
                }
            }
        }
        else // 父进程
        {
            close(acceptfd);
        }
    }
    return 0;
}

客户端源码如下：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/select.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "dictionary.h"
#include <sqlite3.h>
// 声明函数
void query(int sockfd);
void History(int sockfd);
void delete_history(int sockfd);
//注册
void register_sev(int sockfd)
{
    printf("*******注册页面*******\n");
    dic.type = 'r'; // 令他的类型等于r 也就是我设置的注册类型
    printf("请输入你的用户名: ");
    scanf("%s", dic.name);
    printf("请输入你的密码: ");
    scanf("%s", dic.password);
    send(sockfd, &dic, sizeof(dic), 0);
    int recvfd = recv(sockfd, &dic, sizeof(dic), 0);
    if (recvfd < 0)// 接受失败
    {
        perror("recv error\n");
        return;
    }
    else if (recvfd == 0)// 服务器退出
    {
        printf("Sever already quit\n");
        return;
    }
    else // 接受成功
    {
        printf("%s\n", dic.text);
    }
}
//登录
int login_sev(int sockfd)
{
    printf("*******登录页面*******\n");
    dic.type = 'l';
    printf("请输入你的用户名: ");
    scanf("%s", dic.name);
    getchar();
    printf("请输入你的密码: ");
    scanf("%s", dic.password);
    getchar();
    send(sockfd, &dic, sizeof(dic), 0);
    //将整个结构体发送过去
    //接受整个结构体 如果接受错误的话就返回-1如果 登录成功就返回1
    int recvfd = recv(sockfd, &dic, sizeof(dic), 0);
    if (recvfd < 0)
    {
        perror("recv error\n");
        return -1;
    }
    else if (recvfd == 0)
    {
        printf("Sever already quit\n");
        return -1;
    }
    else
    {
        if (!strcmp(dic.text, "login successs")) // 如果接收到客户端发过来的成功语句就打印成功
        {
            printf("登录成功！\n");
            return 1;
        }
        else
        {
            printf("%s\n", dic.text);
        }
    }
}
// 进入登录后的页面
void next(int sockfd)
{
    int next;
    while (1)
    {
printf("*****************************查询页面***********************************\n");
printf("1.: query_password     2.: History_password   3:delete:History  4.:quit\n");      printf("***********************************************************************\n");
        printf("\n");
        printf("Please choose：");
        scanf("%d", &next);
        switch (next)
        {
        case 1:
            query(sockfd); //查询函数
            break;
        case 2:
            History(sockfd); //历史函数
            break;
        case 3:
            delete_history(sockfd); // 删除历史记录
            break;
        case 4:
            close(sockfd); //返回上一级
            exit(0);
        default:
            break;
        }
    }
}
// 查询单词
void query(int sockfd)
{
    dic.type = 'q';
    while (1)
    {
        printf("Please input words that you want to search: ");
        scanf("%s", dic.password);
        putchar(10);                    //防止垃圾字符
        if (!strcmp(dic.password, "#")) //如果在查找单词中输入#就会退出
        {
            break;
        }
        send(sockfd, &dic, sizeof(dic), 0); // 将结构体发过去
        int recvfd = recv(sockfd, &dic, sizeof(dic), 0);
        if (recvfd < 0)
        {
            perror("recv error\n");
            return;
        }
        else if (recvfd == 0)
        {
            printf("Sever already quit\n");
            return;
        }
        else
        {
            printf("%s this word is expain: %s", dic.password, dic.text);
            printf("\n");
        }
    }
}
// 历史记录
void History(int sockfd)
{
    dic.type = 'h';
    send(sockfd, &dic, sizeof(dic), 0); // 目的是为了将结构体类型发过去
    while (1)
    {
        int recvfd = recv(sockfd, &dic, sizeof(dic), 0);
        if (recvfd < 0)
        {
            perror("recv error\n");
            return;
        }
        if(dic.history_id == 1)
            break;
        printf("%s\n",dic.text);
        printf("\n");
    }
}
// 删除历史记录
void delete_history(int sockfd)
{
    dic.type = 'd';
    send(sockfd, &dic, sizeof(dic), 0); // 目的是为了将结构体类型发过去
    while (1)
    {
        int recvfd = recv(sockfd, &dic, sizeof(dic), 0);
        if (recvfd < 0)
        {
            perror("recv error\n");
            return;
        }
        else if (recvfd == 0)
        {
            exit(0);
        }
        else
        {
            printf("%s \n", dic.text);
            printf("\n");
            break;
        }
    }
}
int main(int argc, char const *argv[])
{
    //1. 创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("cli sockfd error\n");
        return -1;
    }
    //2.填充结构体
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[2]));
    saddr.sin_addr.s_addr = inet_addr(argv[1]);
    //链接
    if (connect(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("cli connect erroen\n");
        return -1;
    }
    int cli_type1;
    while (1)
    {
        printf("**************************************\n");
        printf("1: register     2: login     3:quit\n");
        printf("**************************************\n");
        printf("Please choose (must number!!!)：");
        scanf("%d", &cli_type1);
        if (cli_type1 != 1 && cli_type1 != 2 && cli_type1 != 3)
        {
            printf("请重新输入正确的数字！\n");
            return -1;
        }
        switch (cli_type1)
        {
        //2.注册
        case 1:
            register_sev(sockfd);
            break;
        //3.登录
        case 2:
            if (login_sev(sockfd) == 1) //接受上面返回成功的1进行到下一个函数
                next(sockfd);
            break;
        //4.退出
        case 3:
            close(sockfd);
            exit(0);
        default:
            break;
        }
    }
    return 0;
}

dictionary.h源码如下：

struct dictionary
{
    char type; // r代表注册 l 代表登录 q代表查询 h代表历史
    char name[128];// 用户名
    char password[128];// 密码
    char text[128];// 通知内容或者查找内容
    char time_sev[32];// 时间
    int history_id;
} dic;

dic.txt文件因为过于庞大，所以放到公众号中，大家需要自取。

微信关注嵌入式工程之家发送 dic源码即可获得文件哟。

【Linux开发实战指南】基于TCP、进程数据结构与SQL数据库：构建在线云词典系统（含注册、登录、查询、历史记录管理功能及源码分享）

项目演示：

1. 主界面

技术讲解：

TCP连接

进程的并发

链表

SQLite3

IO对文件的读写

功能实现

实现逻辑

我遇到的问题：

服务器端代码思路解析

必要条件

步骤详解

客户端代码思路解析

步骤详解

服务器源码如下：

客户端源码如下：

dictionary.h源码如下：

dic.txt文件因为过于庞大，所以放到公众号中，大家需要自取。

物联网

热门文章

最新文章

相关课程

相关电子书

推荐镜像