TCP套接字，发送文件，客户端服务器，服务器不保存整个文件，C语言

分类：编程问答

如何解决TCP套接字，发送文件，客户端服务器，服务器不保存整个文件，C语言

我写了一个简单的协议，其中Im可以在客户端和服务器之间交换文件/文本消息。如果客户端向服务器发送文本，服务器应简单地将其回显。另一方面，当客户端发送特殊命令（例如SEND_TXT_FILE）时，服务器应收到客户端上传到服务器的文件。

我几乎可以工作了。但是，发送文件仍然存在问题。服务器不会保存整个文件，只会创建它并断开连接。

以下是协议：

CLIENT ---------- text1 ----------> SERVER
CLIENT <---------- text1 ---------- SERVER
CLIENT ---------- text2 ----------> SERVER
CLIENT <---------- text3 ---------- SERVER
CLIENT ---------- SENDTXTFILE ----------> SERVER
CLIENT <---------- OK ---------- SERVER
CLIENT ---------- FILENAME ----------> SERVER
CLIENT <---------- OK ---------- SERVER
CLIENT ---------- file content ----------> SERVER
CLIENT <--------- FILE_UPLOADED --------- SERVER
CLIENT ---------- text3 ----------> SERVER
CLIENT <---------- text3 ---------- SERVER

我该如何解决？

server.c 

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <string.h>

#define BUFFER_SIZE 1024

int send_all(int sockfd,const char *buf,int len)
{
    ssize_t n;

    while (len > 0)
    {
        n = send(sockfd,buf,len,0);
        if (n < 0)
            return -1;
        buf += n;
        len -= n;
    }

    return 0;
}

int recv_all(int sockfd,char *buf,int len)
{
    ssize_t n;

    while (len > 0)
    {
        n = recv(sockfd,0);
        if (n <= 0)
            return n;
        buf += n;
        len -= n;
    }

    return 1;
}

int recv_txt_file(int sockfd,int len,const char *filename)
{
    FILE *fp = fopen(filename,"wb");
    int total = 0,b = 0;
    char buffer[BUFFER_SIZE];
    memset(buffer,'\0',BUFFER_SIZE);

    if (fp != NULL)
    {
        while (recv_all(sockfd,buffer,len) != 1)
        {
            total += b;
            fwrite(buffer,1,b,fp);
        }

        printf("Received byte: %d\n",total);
        if (b < 0)
            perror("Receiving");

        fclose(fp);
    }
    else
    {
        perror("File");
    }
    close(sockfd);
}

int main()
{
    int port = 6666;
    int server_fd,client_fd,read;
    struct sockaddr_in server,client;
    char buffer[BUFFER_SIZE],filename[BUFFER_SIZE];
    char remote_ip[16];
    int remote_port,res = 0;

    server_fd = socket(AF_INET,SOCK_STREAM,0);
    if (server_fd < 0)
    {
        perror("Could not create socket");
        return 1;
    }

    int optval = 1;
    setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,(const void *)&optval,sizeof(int));

    memset(&server,sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    server.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(server_fd,(struct sockaddr *)&server,sizeof(server)) < 0)
    {
        perror("Could not bind socket");
        close(server_fd);
        return 1;
    }

    if (listen(server_fd,1) < 0)
    {
        perror("Could not listen on socket");
        close(server_fd);
        return 1;
    }

    printf("Server TCP is listening on port %d ... \n",port);

    socklen_t client_len = sizeof(client);
    client_fd = accept(server_fd,(struct sockaddr *)&client,&client_len);

    if (client_fd < 0)
    {
        perror("Could not establish new connection");
        close(server_fd);
        return 1;
    }

    remote_port = ntohs(client.sin_port);
    inet_ntop(AF_INET,&client.sin_addr,remote_ip,sizeof(remote_ip));

    printf("Client IP address: %s,port %d\n",remote_port);

    while (1)
    {
        read = recv_all(client_fd,BUFFER_SIZE);
        if (read <= 0)
        {
            if (read < 0)
                perror("Client read failed");
            else
                printf("Client disconnected\n");
            break;
        }

        if ((res = strcmp(buffer,"SENDFILE_TXT\n") == 0))
        {

            printf("-------FROM CLIENT: %s-------\n",buffer);
            memset(buffer,BUFFER_SIZE,'\0');
            strcpy(buffer,"OK");
            if (send_all(client_fd,BUFFER_SIZE) < 0)
            {
                perror("Client write failed");
                break;
            }
            read = recv_all(client_fd,BUFFER_SIZE);
            if (read <= 0)
            {
                if (read < 0)
                    perror("Client read failed");
                else
                    printf("Client disconnected\n");
                break;
            }
            printf("-------FROM CLIENT: %s-------\n",buffer);
            memset(filename,BUFFER_SIZE);
            strcpy(filename,BUFFER_SIZE) < 0)
            {
                perror("Client write failed");
                break;
            }
            recv_txt_file(client_fd,filename);
        }
        else
        {
            printf("FROM CLIENT: %.*s\n",buffer);

            if (send_all(client_fd,BUFFER_SIZE) < 0)
            {
                perror("Client write failed");
                break;
            }
        }
    }

    close(client_fd);
    close(server_fd);

    return 0;
}

client.c 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#define BUFFER_SIZE 1024

socklen_t hostname_to_ip_port(char *hostname,int port,struct sockaddr_storage *addr)
{
    int sockfd;
    struct addrinfo hints,*servinfo;
    int rv;

    char service[20];
    sprintf(service,"%d",port);

    memset(&hints,sizeof hints);
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    if ((rv = getaddrinfo(hostname,service,&hints,&servinfo)) != 0)
    {
        fprintf(stderr,"getaddrinfo: %s\n",gai_strerror(rv));
        return 0;
    }

    socklen_t addrlen = servinfo->ai_addrlen;
    memcpy(addr,servinfo->ai_addr,addrlen);

    freeaddrinfo(servinfo);

    return addrlen;
}

int send_all(int sockfd,size_t len)
{
    ssize_t n;

    while (len > 0)
    {
        n = send(sockfd,0);
        if (n <= 0)
            return n;
        buf += n;
        len -= n;
    }

    return 1;
}

long int get_file_size(char filename[])
{
    // opening the file in read mode
    FILE *fp = fopen(filename,"r");

    // checking if the file exist or not
    if (fp == NULL) {
        printf("File Not Found!\n");
        return -1;
    }

    fseek(fp,0L,SEEK_END);

    // calculating the size of the file
    long int res = ftell(fp);

    // closing the file
    fclose(fp);

    return res;
}

int send_txt_file(int sockfd,"r");
    int b;
    char buffer[BUFFER_SIZE];
    memset(buffer,BUFFER_SIZE);

    if (fp == NULL)
    {
        perror("Error while openning file");
        return 0;
    }

    while ((b = fread(buffer,fp)) > 0){
        send_all(sockfd,BUFFER_SIZE);
        memset(buffer,BUFFER_SIZE);
    }

    fclose(fp);
    return 1;
}

int main(int argc,char **argv)
{
    char *hostname = "127.0.0.1";
    int port = 6666;
    char buffer[BUFFER_SIZE],fname[BUFFER_SIZE];

    int sockfd,err,res;
    struct sockaddr_storage server_addr;
    socklen_t server_addr_len;

    server_addr_len = hostname_to_ip_port(hostname,port,&server_addr);
    if (server_addr_len == 0)
        return 1;

    sockfd = socket(server_addr.ss_family,IPPROTO_TCP);
    if (sockfd < 0)
    {
        perror("Could not create socket");
        return 1;
    }

    if (connect(sockfd,(struct sockaddr *)&server_addr,server_addr_len) < 0)
    {
        perror("Could not connect socket");
        return 1;
    }

    while (1)
    {
        memset(buffer,'\0');
        memset(fname,'\0');

        printf("> ");
        if (!fgets(buffer,stdin))
            break;

        if (strstr(buffer,"SENDFILE_TXT") != NULL)
        {
            if (send_all(sockfd,BUFFER_SIZE) < 0)
            {
                perror("Could not send message");
                close(sockfd);
                return 1;
            }

            memset(buffer,'\0');
            err = recv_all(sockfd,BUFFER_SIZE);
            if (err <= 0)
            {
                if (err < 0)
                    perror("Could not read message");
                else
                    printf("Server disconnected\n");
                break;
            }
            if ((res = strcmp(buffer,"OK") == 0))
            {
                printf("-------FROM SERVER: %s-------\n",buffer);

                printf("Give filename> ");
                memset(fname,'\0');
                if (!fgets(fname,stdin))
                    break;
                if (send_all(sockfd,fname,BUFFER_SIZE) < 0)
                {
                    perror("Could not send message");
                    close(sockfd);
                    return 1;
                }
            }

            err = recv_all(sockfd,BUFFER_SIZE);
            if (err <= 0)
            {
                if (err < 0)
                    perror("Could not read message");
                else
                    printf("Server disconnected\n");
                break;
            }

            fname[strlen(fname)-1] = 0;
            printf("----%s----\n",fname);
            send_txt_file(sockfd,fname);

            printf("FROM SERVER: %.*s\n",buffer);
        }
        else
        {
            if (send_all(sockfd,BUFFER_SIZE) < 0)
            {
                perror("Could not send message");
                close(sockfd);
                return 1;
            }

            err = recv_all(sockfd,BUFFER_SIZE);
            if (err <= 0)
            {
                if (err < 0)
                    perror("Could not read message");
                else
                    printf("Server disconnected\n");
                break;
            }
            printf("FROM SERVER: %.*s\n",buffer);
        }
    }

    close(sockfd);

    return 0;
}

解决方法

您使用send_txt_file()和recv_txt_file()传输文件的方式不正确。

在服务器端：

当客户端连接时，服务器等待客户端为每个命令精确发送 BUFFER_SIZE（1024）字节，不多也不少（这浪费了带宽）简短命令）。收到SENDFILE_TXT命令时，服务器从客户端读取文件名（如果文件名的长度完全 BUFFER_SIZE个字节，则会导致缓冲区溢出），然后呼叫recv_txt_file()。

recv_txt_file() 尝试循环读取客户端，精确读取 BUFFER_SIZE块。但是，正在使用的while循环编码不正确。它正在检查失败而不是成功的recv_all()的返回值。 !=支票需要改为==。而且，用于递增b并告诉total要写入多少字节的fwrite()变量永远不会设置为除0以外的任何值 >。应该将其设置为BUFFER_SIZE，因为如果recv_all()返回1，则实际上已读取了多少字节。

但是，即使while循环的编码正确，传输仍然无法正常运行，因为它需要以偶数倍发送 >个BUFFER_SIZE。如果文件的大小不是偶数，则recv_all()最终将等待客户端不发送的数据，直到套接字上发生错误为止。

此外，recv_txt_file()在传输完成后正在关闭连接。不应这样做，因为这将阻止客户端在发送文件后发送其他命令。客户端在发送文件后不会关闭其连接的末端，因此服务器在接收到文件后不应关闭其连接的末端。

在客户端：

当客户端发送SENDFILE_TXT命令并收到确认消息时，它将调用send_txt_file()，后者以循环方式读取文件，并以BUFFER_SIZE大小的块将其发送到服务器。如果文件大小不是BUFFER_SIZE的偶数倍，则最后发送的块只会浪费带宽并将随机垃圾发送到服务器。另外，如果套接字上发生错误，您将忽略send_all()的返回值来中断循环。

客户端应在发送文件数据之前将实际文件大小发送到服务器。然后，服务器可以先读取该大小值，以便知道何时停止读取。

话虽如此，请尝试类似以下的内容：

server.c 

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <string.h>
#include <stdint.h>

#define BUFFER_SIZE 1024

int send_all(int sockfd,const void *buf,int len)
{
    ssize_t n;
    const char *pbuf = (const char*) buf;

    while (len > 0)
    {
        n = send(sockfd,pbuf,len,0);
        if (n < 0)
        {
            perror("Client write failed");
            return n;
        }
        pbuf += n;
        len -= n;
    }

    return 0;
}

int send_uint32(int sockfd,uint32_t value)
{
    value = htonl(value);
    if (send_all(sockfd,&value,sizeof(value)) < 0)
        return -1;
    return 0;
}

int send_str(int sockfd,const char *s)
{
    uint32_t len = strlen(s);
    int res = send_uint32(sockfd,len);
    if (res == 0)
        res = send_all(sockfd,s,len);
    return res;
}

int recv_all(int sockfd,void * buf,int len)
{
    ssize_t n;
    char *pbuf = (char*) buf;

    while (len > 0)
    {
        n = recv(sockfd,0);
        if (n <= 0)
        {
            if (n < 0)
                perror("Client read failed");
            else
                printf("Client disconnected\n");
            return n;
        }
        pbuf += n;
        len -= n;
    }

    return 1;
}

int recv_uint32(int sockfd,uint32_t *value)
{
    int res = recv_all(sockfd,value,sizeof(*value));
    if (res > 0)
        *value = ntohl(*value);
    return res;
}

int recv_uint64(int sockfd,uint64_t *value)
{
    int res = recv_all(sockfd,sizeof(*value));
    if (res > 0)
        *value = ntohll(*value); // <-- use any implementation of your choosing...
    return res;
}

int recv_str(int sockfd,char **str)
{
    uint32_t len;

    int res = recv_uint32(sockfd,&len);
    if (res <= 0)
        return res;

    *str = (char*) malloc(len + 1);
    if (*str == NULL)
    {
        perror("Could not allocate memory");
        return -1;
    }

    res = recv_all(sockfd,*str,len);
    if (res <= 0)
        free(*str);
    else
        (*str)[len] = '\0';

    return res;
}

int recv_txt_file(int sockfd)
{
    char *filename;
    uint64_t filesize;

    if (recv_str(sockfd,&filename) <= 0)
        return -1;

    int res = recv_uint64(sockfd,&filesize);
    if (res <= 0)
    {
        free(filename);
        return -1;
    }

    printf("-------FROM CLIENT: %s-------\n",filename);

    FILE* fp = fopen(filename,"wb");
    if (fp == NULL)
    {
        perror("Could not create file");
        free(filename);
        send_str(sockfd,"NO");
        return 0;
    }

    free(filename);

    // optional: pre-size the new file to the specified filesize...

    if (send_str(sockfd,"OK") < 0)
        return -1;

    char buffer[BUFFER_SIZE];
    int b;
    uint64_t total = 0;

    while (filesize > 0)
    {
        b = (filesize > BUFFER_SIZE) ? BUFFER_SIZE : (int) filesize;

        res = recv_all(sockfd,buffer,b);
        if (res <= 0)
        {
            fclose(fp);
            return -1;
        }

        if (fwrite(buffer,b,1,fp) < 1)
        {
            perror("Could not write to file");
            fclose(fp);
            send_str(sockfd,"ERROR");
            return -1;
        }

        total += b;
        filesize -= b;
    }

    fclose(fp);
    printf("Received bytes: %lu\n",total);

    if (send_str(sockfd,"OK") < 0)
        return -1;

    return 1;
}

int main()
{
    int port = 6666;
    int server_fd,client_fd,read;
    struct sockaddr_in server,client;
    char filename[BUFFER_SIZE],*cmd;
    char remote_ip[16];
    int remote_port,res = 0;

    server_fd = socket(AF_INET,SOCK_STREAM,0);
    if (server_fd < 0)
    {
        perror("Could not create socket");
        return 1;
    }

    int optval = 1;
    setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,&optval,sizeof(int));

    memset(&server,'\0',sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    server.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(server_fd,(struct sockaddr *) &server,sizeof(server)) < 0)
    {
        perror("Could not bind socket");
        close(server_fd);
        return 1;
    }

    if (listen(server_fd,1) < 0)
    {
        perror("Could not listen on socket");
        close(server_fd);
        return 1;
    }

    printf("Server TCP is listening on port %d ... \n",port);

    socklen_t client_len = sizeof(client);
    client_fd = accept(server_fd,(struct sockaddr *) &client,&client_len);

    if (client_fd < 0)
    {
        perror("Could not establish new connection");
        close(server_fd);
        return 1;
    }

    remote_port = ntohs(client.sin_port);
    inet_ntop(AF_INET,&client.sin_addr,remote_ip,sizeof(remote_ip));

    printf("Client IP address: %s,port %d\n",remote_port);

    while (recv_str(client_fd,&cmd) > 0)
    {
        printf("-------FROM CLIENT: %s-------\n",cmd);

        if (strcmp(cmd,"SENDFILE_TXT") == 0)
        {
            if (recv_txt_file(client_fd) < 0)
                break;
        }
        else
        {
            if (send_str(client_fd,cmd) < 0)
            {
                free(cmd);
                break;
            }
        }

        free(cmd);
    }

    close(client_fd);
    close(server_fd);

    return 0;
}

client.c 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <stdint.h>

#define BUFFER_SIZE 1024

socklen_t hostname_to_ip_port(char *hostname,int port,struct sockaddr_storage *addr)
{
    int sockfd;
    struct addrinfo hints,*servinfo;
    int rv;

    char service[20];
    sprintf(service,"%d",port);

    memset(&hints,sizeof hints);
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    if ((rv = getaddrinfo(hostname,service,&hints,&servinfo)) != 0)
    {
        fprintf(stderr,"getaddrinfo: %s\n",gai_strerror(rv));
        return 0;
    }

    socklen_t addrlen = servinfo->ai_addrlen;
    memcpy(addr,servinfo->ai_addr,addrlen);

    freeaddrinfo(servinfo);

    return addrlen;
}

int send_all(int sockfd,size_t len)
{
    ssize_t n;
    const char *pbuf = (const char *) buf;

    while (len > 0)
    {
        n = send(sockfd,0);
        if (n < 0)
        {
            perror("Server write failed");
            return n;
        }
        pbuf += n;
        len -= n;
    }

    return 0;
}

int send_uint32(int sockfd,uint32_t value)
{
    value = htonl(value);
    return send_all(sockfd,sizeof(value));
}

int send_uint64(int sockfd,uint64_t value)
{
    value = htonll(value); // <-- use any implementation of your choosing...
    return send_all(sockfd,sizeof(value));
}

int send_str(int sockfd,void *buf,0);
        if (n <= 0)
        {
            if (n < 0)
                perror("Server read failed");
            else
                printf("Server disconnected\n");
            return n;
        }
        pbuf += n;
        len -= n;
    }

    return 1;
}

int recv_uint32(int sockfd,sizeof(*value));
    if (res > 0)
        *value = ntohl(*value);
    return res;
}

int recv_str(int sockfd,len);
    if (res <= 0)
        free(*str);
    else
        (*str)[len] = '\0';

    return res;
}

int send_txt_file(int sockfd,const char *filename)
{
    char *resp;
    int res;
    long int filesize;
    char buffer[BUFFER_SIZE];
    int b;

    FILE* fp = fopen(filename,"rb");
    if (fp == NULL)
    {
        printf("Could not open file!\n");
        return 0;
    }

    fseek(fp,0L,SEEK_END);
    filesize = ftell(fp);
    fseek(fp,SEEK_SET);

    if (filesize < 0)
    {
        fclose(fp);
        return 0;
    }

    if (send_str(sockfd,"SENDFILE_TXT") < 0)
    {
        fclose(fp);
        return -1;
    }

    if (send_str(sockfd,filename) < 0)
    {
        fclose(fp);
        return -1;
    }

    if (send_uint64(sockfd,filesize) < 0)
    {
        fclose(fp);
        return -1;
    }

    res = recv_str(sockfd,&resp);
    if (res <= 0)
        return -1;

    printf("-------FROM SERVER: %s-------\n",resp);

    if (strcmp(resp,"OK") != 0)
    {
        free(resp);
        fclose(fp);
        return 0;
    }

    free(resp);

    while (filesize > 0)
    {
        b = (filesize > BUFFER_SIZE) ? BUFFER_SIZE : (int) filesize;

        b = fread(buffer,fp);
        if (b < 1)
        {
            fclose(fp);
            return -1;
        }

        if (send_all(sockfd,b) < 0)
        {
            fclose(fp);
            return -1;
        }

        filesize -= b;
    }

    fclose(fp);

    res = recv_str(sockfd,resp);

    free(resp);

    return 0;
}

int prompt(const char *text,char **input)
{
    *input = NULL;
    size_t size = 0;

    printf("%s> ",text);

    ssize_t len = getline(input,&size,stdin);
    if (len < 0)
        return len;

    if ((*input)[len-1] == '\n')
    {
        --len;
        (*input)[len] = '\0';
    }

    return len;
}

int main()
{
    char *hostname = "127.0.0.1";
    int port = 6666;
    char *cmd,*resp,*fname;
    size_t size;
    ssize_t len;

    int sockfd,res;
    struct sockaddr_storage server_addr;
    socklen_t server_addr_len;

    server_addr_len = hostname_to_ip_port(hostname,port,&server_addr);
    if (server_addr_len == 0)
        return 1;

    sockfd = socket(server_addr.ss_family,IPPROTO_TCP);
    if (sockfd < 0)
    {
        perror("Could not create socket");
        return 1;
    }

    if (connect(sockfd,(struct sockaddr *) &server_addr,server_addr_len) < 0)
    {
        perror("Could not connect socket");
        return 1;
    }

    while (prompt("",&cmd) >= 0)
    {
        if (strcmp(cmd,"SENDFILE_TXT") == 0)
        {
            if (prompt("Give filename",&fname) < 0)
                break;

            if (send_txt_file(sockfd,fname) < 0)
                break;

            free(fname);
        }
        else
        {
            if (send_str(sockfd,cmd) < 0)
            {
                free(cmd);
                close(sockfd);
                return 1;
            }

            if (recv_str(sockfd,&resp) <= 0)
                break;

            printf("FROM SERVER: %s\n",resp);
            free(resp);
        }

        free(cmd);
    }

    close(sockfd);

    return 0;
}
,

关于：

int total = 0,b = 0;

和

while(recv_all(sockfd,len) != 1)
{
    total += b;
    fwrite(buffer,fp);

total和b永远不会偏离其初始值0。因此0字节被写入输出文件。

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

导入项目后报错问题
依赖报错 idea导入项目后依赖报错，解决方案：https://blog.csdn.net/weixin_42420249/article/details/81191861 依赖版本报错：更换其他版本 无法下载依赖可参考：https://blog.csdn.net/weixin_42628809/a
idea不能识别yaml文件
使用mybatis plus常见错误
错误1：代码生成器依赖和mybatis依赖冲突 启动项目时报错如下 2021-12-03 13:33:33.927 ERROR 7228 [ main] o.s.b.d.LoggingFailureAnalysisReporter : *************************** APPL
gradle常见问题与错误
错误1：gradle项目控制台输出为乱码 # 解决方案：https://blog.csdn.net/weixin_43501566/article/details/112482302 # 在gradle-wrapper.properties 添加以下内容 org.gradle.jvmargs=-Df
Mybatis Plus传入参数0不起作用
错误还原：在查询的过程中，传入的workType为0时，该条件不起作用 &lt;select id=&quot;xxx&quot;&gt; SELECT di.id, di.name, di.work_type, di.updated... &lt;where&gt; &lt;if test=&qu
linux中make编译源码包失败
报错如下，gcc版本太低 ^ server.c:5346:31: 错误：‘struct redisServer’没有名为‘server_cpulist’的成员 redisSetCpuAffinity(server.server_cpulist); ^ server.c: 在函数‘hasActiveC
微服务启动错误：Command line is too long. Shorten command line for
解决方案1 1、改项目中.idea/workspace.xml配置文件，增加dynamic.classpath参数 2、搜索PropertiesComponent，添加如下 &lt;property name=&quot;dynamic.classpath&quot; value=&quot;tru
vue常见错误
删除根组件app.vue中的默认代码后报错：Module Error (from ./node_modules/eslint-loader/index.js): 解决方案：关闭ESlint代码检测，在项目根目录创建vue.config.js，在文件中添加 module.exports = { lin
spark常见错误
查看spark默认的python版本 [root@master day27]# pyspark /home/software/spark-2.3.4-bin-hadoop2.7/conf/spark-env.sh: line 2: /usr/local/hadoop/bin/hadoop: No s
matplotlib报错：AttributeError: module 'backend_interagg' has no attribute 'FigureCanvas'. Did you mean: 'FigureCanvasAgg'?
使用本地python环境可以成功执行 import pandas as pd import matplotlib.pyplot as plt # 设置字体 plt.rcParams[&#39;font.sans-serif&#39;] = [&#39;SimHei&#39;] # 能正确显示负号 p
gitlab登录失败，报错：This challenge page was accidentally cached by an intermediary and is no longer available.
设置时间 控制面板
后端开发常见错误
错误1：Request method ‘DELETE‘ not supported 错误还原：controller层有一个接口，访问该接口时报错：Request method ‘DELETE‘ not supported 错误原因：没有接收到前端传入的参数，修改为如下 参考 错误2：cannot r
docker常见错误
错误1：启动docker镜像时报错：Error response from daemon: driver failed programming external connectivity on endpoint quirky_allen 解决方法：重启docker -&gt; systemctl r
idea常见错误
错误1：private field ‘xxx‘ is never assigned 按Altʾnter快捷键，选择第2项 参考：https://blog.csdn.net/shi_hong_fei_hei/article/details/88814070 错误2：启动时报错，不能找到主启动类 #
pip安装依赖失败
报错如下，通过源不能下载，最后警告pip需升级版本 Requirement already satisfied: pip in c:\users\ychen\appdata\local\programs\python\python310\lib\site-packages (22.0.4) Coll
maven常见错误
错误1：maven打包报错 错误还原：使用maven打包项目时报错如下 [ERROR] Failed to execute goal org.apache.maven.plugins:maven-resources-plugin:3.2.0:resources (default-resources)
cloud项目中常见错误
错误1：服务调用时报错 服务消费者模块assess通过openFeign调用服务提供者模块hires 如下为服务提供者模块hires的控制层接口 @RestController @RequestMapping(&quot;/hires&quot;) public class FeignControl
springboot常见错误
错误1：运行项目后报如下错误 解决方案 报错2：Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.8.1:compile (default-compile) on project sb 解决方案：在pom.
springmvc拦截器中使用redisTemplate报空指针异常
参考 错误原因 过滤器或拦截器在生效时，redisTemplate还没有注入 解决方案：在注入容器时就生效 @Component //项目运行时就注入Spring容器 public class RedisBean { @Resource private RedisTemplate&lt;String
vite报错：npm ERR! command C:WINDOWSsystem32cmd.exe /d /s /c C:UsersychenAppDataLocalTempnpx-dde1c848.cmd
使用vite构建项目报错 C:\Users\ychen\work&gt;npm init @vitejs/app @vitejs/create-app is deprecated, use npm init vite instead C:\Users\ychen\AppData\Local\npm-
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot