最近研究Android与后台进行Socket通讯，在后台获取到客户端的socket对象时，给客户端发送一条数据对象，这时候会用到输入流与输出流，来传输数据，而数据是要经过序列化之后才能传输的。到客户端的数据在经过反序列化，获取数据对象，但是在运行过程中总是报ClassNotFoundException。

1.ClassNotFoundException解决方法：

将服务端与客户端的包名修改成一样的，如下图所示：

Android端：



服务器端：

这个时候如果服务器与客户端的jdk版本一样应该就灭有问题了， 可偏偏楼主的两个jdk版本不一样，在反序列化的时候报了java.io.InvalidClassException，产生这个问题的原因是：序列化之后的对象都会唯一对应一个serialVersionUID的长整形数据来唯一标识该序列化对象。这个是由jdk自己计算出来的，当然应该也可以自己定义。当客户端与服务器端计算的serialVersionUID值不一样就能会报java.io.InvalidClassException这个错，解决的方法是将客户端与服务器端的serialVersionUID保持一致，这样就可以解决问题了。

Eclips/MyEclispe生成方法：

序列化的类如果没有serialVersionUID，该类下会有警告的黄线，将鼠标移动到黄线上，会出现解决Tips，点击第一个或者第二个都行，图示如下：



 ok，解决！

另贴上传输序列化对象的方法：

服务器向客户端发送序列化后的数据

//获取输出流对象
OutputStream os = mSocket.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
//将信息对象写入输出流
oos.writeObject(msg);//msg序列化的对象
oos.flush();

客户端反序列化，获取数据对象

ChatMessage chatMessage;
try {
      ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
      Object object = ois.readObject();
      if (object != null){
          chatMessage =(ChatMessage)object;
          sendObjMsgToHandler(SOCKETMSG,chatMessage); //发送包含ChatMessage对象的信息到Handler，在Ui线程更新数据
 }catch (Exception e) {
      e.printStackTrace();
 }

简介

在学习了深入理解操作系统第11章的内容后，更加深刻的理解的Socket，IO流，fork，Cgi 以及Http等知识。并且学习了HTTP服务器的代码实现。并不复杂，大概300行，就可以实现发送图片，和执行CGI程序将结果返回给客户端。



具体实现过程



服务器代码：

代码量比较少，而且添加了一些注释，简明易懂。 

csapp.h是该书的通用头文件，定义了一些常量，以及进一步封装了一些系统调用（检查返回值等）。对应的函数实现代码为csapp.c 

（全书的代码网上有资源）



#include "csapp.h"

void doit(int fd);
void read_requesthdrs(rio_t *rp);
int parse_uri(char *uri, char *filename, char *cgiargs);
void serve_static(int fd, char *filename, int filesize);
void get_filetype(char *filename, char *filetype);
void serve_dynamic(int fd, char *filename, char *cgiargs);
void clienterror(int fd, char *cause, char *errnum, 
         char *shortmsg, char *longmsg);

int main(int argc, char **argv) 
{
    int listenfd, connfd, port, clientlen;
    struct sockaddr_in clientaddr;

    /* 检查命令行输入 */
    if (argc != 2) {
    fprintf(stderr, "usage: %s <port>\n", argv[0]);
    exit(1);
    }
    port = atoi(argv[1]); //获取服务器端口号

    //循环监听客户端请求
    listenfd = Open_listenfd(port);
    while (1) {
    clientlen = sizeof(clientaddr);
    connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen); //接收客户端的请求
    doit(connfd);                                             //执行服务
    Close(connfd);                                            //关闭与客户端的连接
    }
}
/* $end tinymain */

/*
 * doit - 处理一个Http请求
 */
/* $begin doit */
void doit(int fd) 
{
    int is_static;  //是否为静态请求
    struct stat sbuf;

    char buf[MAXLINE], 
    method[MAXLINE], //请求方法 
    uri[MAXLINE],    //uri路径
    version[MAXLINE]; //MAXLINE:8192

    char filename[MAXLINE],  //文件名
    cgiargs[MAXLINE]; //cgi程序的参数
    rio_t rio;


    //读取客户的请求 以及HTTP头文件 
    //Rio_readinitb是封装过的IO读取函数
    Rio_readinitb(&rio, fd);
    Rio_readlineb(&rio, buf, MAXLINE);    //读取请求              
    sscanf(buf, "%s %s %s", method, uri, version);   //解析请求 
    if (strcasecmp(method, "GET")) {             //只能提供GET   
       clienterror(fd, method, "501", "Not Implemented",
                "Tiny does not implement this method");
        return;
    }                                
    read_requesthdrs(&rio);            //读取请求头 


    //从浏览器的输入栏中解析GET请求
    is_static = parse_uri(uri, filename, cgiargs);       //静态图片 / 动态加法请求检查
    if (stat(filename, &sbuf) < 0) {                  //没有用户所请求的文件   
    clienterror(fd, filename, "404", "Not found",
            "Tiny couldn't find this file");
    return;
    }                                                    //line:netp:doit:endnotfound

    if (is_static) { /* 静态请求，返回图片*/          
    if (!(S_ISREG(sbuf.st_mode)) || !(S_IRUSR & sbuf.st_mode)) { //line:netp:doit:readable
        clienterror(fd, filename, "403", "Forbidden",
            "Tiny couldn't read the file");
        return;
    }
    serve_static(fd, filename, sbuf.st_size);        //将图片发送给客户端
    }
    else { /* 调用CGI程序执行加法运算*/
    if (!(S_ISREG(sbuf.st_mode)) || !(S_IXUSR & sbuf.st_mode)) { 
        clienterror(fd, filename, "403", "Forbidden",
            "Tiny couldn't run the CGI program");
        return;
    }
    serve_dynamic(fd, filename, cgiargs);            //动态服务，传入参数给cgi程序
    }
}
/* $end doit */

/*
 * read_requesthdrs - read and parse HTTP request headers
 */
/* $begin read_requesthdrs */
void read_requesthdrs(rio_t *rp) 
{
    char buf[MAXLINE];

    Rio_readlineb(rp, buf, MAXLINE);
    while(strcmp(buf, "\r\n")) {          //HTTP Header 规定以\r\n结尾
    Rio_readlineb(rp, buf, MAXLINE);
    printf("%s", buf);
    }
    return;
}
/* $end read_requesthdrs */

/*
*
 *  解析浏览器发来的URI中的文件名 或者 是 CGI参数（加法的两个数）
 *  返回值：0为动态CGI，1为静态图片
 */
/* $begin parse_uri */
int parse_uri(char *uri, char *filename, char *cgiargs) 
{
    char *ptr;

    if (!strstr(uri, "cgi-bin")) {  /* Static content */ //line:netp:parseuri:isstatic
    strcpy(cgiargs, "");                             //line:netp:parseuri:clearcgi
    strcpy(filename, ".");                           //line:netp:parseuri:beginconvert1
    strcat(filename, uri);                           //line:netp:parseuri:endconvert1
    if (uri[strlen(uri)-1] == '/')                   //line:netp:parseuri:slashcheck
        strcat(filename, "home.html");               //line:netp:parseuri:appenddefault
    return 1;
    }
    else {  /* Dynamic content */                        //line:netp:parseuri:isdynamic
    ptr = index(uri, '?');                           //line:netp:parseuri:beginextract
    if (ptr) {
        strcpy(cgiargs, ptr+1);
        *ptr = '\0';
    }
    else 
        strcpy(cgiargs, "");                         //line:netp:parseuri:endextract
    strcpy(filename, ".");                           //line:netp:parseuri:beginconvert2
    strcat(filename, uri);                           //line:netp:parseuri:endconvert2
    return 0;
    }
}
/* $end parse_uri */

/*
 * 
 * 静态服务 : 拷贝图片返回给客户
 */
/* $begin serve_static */
void serve_static(int fd, char *filename, int filesize) 
{
    int srcfd;
    char *srcp, filetype[MAXLINE], buf[MAXBUF];

    /* 发送服务器响应Header给客户端 */
    get_filetype(filename, filetype);       //line:netp:servestatic:getfiletype
    sprintf(buf, "HTTP/1.0 200 OK\r\n");    //line:netp:servestatic:beginserve
    sprintf(buf, "%sServer: Tiny Web Server\r\n", buf);
    sprintf(buf, "%sContent-length: %d\r\n", buf, filesize);
    sprintf(buf, "%sContent-type: %s\r\n\r\n", buf, filetype);
    Rio_writen(fd, buf, strlen(buf));       //line:netp:servestatic:endserve

    /* 通过内存映射，发送文件 */
    srcfd = Open(filename, O_RDONLY, 0);    //line:netp:servestatic:open
    srcp = Mmap(0, filesize, PROT_READ, MAP_PRIVATE, srcfd, 0);//line:netp:servestatic:mmap
    Close(srcfd);                           //line:netp:servestatic:close
    Rio_writen(fd, srcp, filesize);         //line:netp:servestatic:write
    Munmap(srcp, filesize);                 //line:netp:servestatic:munmap
}

/*
 * 
 * 获取文件类型
 */
void get_filetype(char *filename, char *filetype) 
{
    if (strstr(filename, ".html"))
    strcpy(filetype, "text/html");
    else if (strstr(filename, ".gif"))
    strcpy(filetype, "image/gif");
    else if (strstr(filename, ".jpg"))
    strcpy(filetype, "image/jpeg");
    else
    strcpy(filetype, "text/plain");
}  
/* $end serve_static */

/*
 * 
 * 动态服务：执行CGI程序，将结果返回给客户端（浏览器显示加法结果）
 */
/* $begin serve_dynamic */
void serve_dynamic(int fd, char *filename, char *cgiargs) 
{
    char buf[MAXLINE], *emptylist[] = { NULL };

    /* Return first part of HTTP response */
    sprintf(buf, "HTTP/1.0 200 OK\r\n"); 
    Rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Server: Tiny Web Server\r\n");
    Rio_writen(fd, buf, strlen(buf));

    //创建子进程
    if (Fork() == 0) { /* child */ //line:netp:servedynamic:fork
    /* Real server would set all CGI vars here */
    //发送环境变量
    setenv("QUERY_STRING", cgiargs, 1); 
    //重定向stdout
    Dup2(fd, STDOUT_FILENO);         
    //执行服务器上的CGI程序
    Execve(filename, emptylist, environ); 
    }
    Wait(NULL); // 父进程等待子进程结束并回收
}
/* $end serve_dynamic */

/*
 * 
 * 返回请求错误消息给客户端
 */
/* $begin clienterror */
void clienterror(int fd, char *cause, char *errnum, 
         char *shortmsg, char *longmsg) 
{
    char buf[MAXLINE], body[MAXBUF];

    /* Build the HTTP response body */
    sprintf(body, "<html><title>Tiny Error</title>");
    sprintf(body, "%s<body bgcolor=""ffffff"">\r\n", body);
    sprintf(body, "%s%s: %s\r\n", body, errnum, shortmsg);
    sprintf(body, "%s<p>%s: %s\r\n", body, longmsg, cause);
    sprintf(body, "%s<hr><em>The Tiny Web server</em>\r\n", body);

    /* Print the HTTP response */
    sprintf(buf, "HTTP/1.0 %s %s\r\n", errnum, shortmsg);
    Rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Content-type: text/html\r\n");
    Rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Content-length: %d\r\n\r\n", (int)strlen(body));
    Rio_writen(fd, buf, strlen(buf));
    Rio_writen(fd, body, strlen(body));
}
/* $end clienterror */



Cgi程序-加法器adder.c ：



#include "csapp.h"

int main(void) {
    char *buf, *p;
    char arg1[MAXLINE], arg2[MAXLINE], content[MAXLINE];
    int n1=0, n2=0;

    /* Extract the two arguments */
    if ((buf = getenv("QUERY_STRING")) != NULL) {
    p = strchr(buf, '&');
    *p = '\0';
    strcpy(arg1, buf);
    strcpy(arg2, p+1);
    n1 = atoi(arg1);
    n2 = atoi(arg2);
    }

    /* Make the response body */
    sprintf(content, "Welcome to add.com: ");
    sprintf(content, "%sTHE Internet addition portal.\r\n<p>", content);
    sprintf(content, "%sThe answer is: %d + %d = %d\r\n<p>", 
        content, n1, n2, n1 + n2);
    sprintf(content, "%sThanks for visiting!\r\n", content);

    /* Generate the HTTP response */
    printf("Content-length: %d\r\n", (int)strlen(content));
    printf("Content-type: text/html\r\n\r\n");
    printf("%s", content);
    fflush(stdout);
    exit(0);
}
/* $end adder */

HTTP服务器目录结构

cgi-bin中存放编译好的adder.c的二进制adder.o文件： 




运行HTTP服务器





linux环境下浏览器请求服务



1）静态服务，返回图片





2）CGI动态服务，返回加法结果：





服务器输出日志