BlogJava-聂永的博客-随笔分类-socket.io

c_socket.io_server笔记之定义私有接口

nieyong — Fri, 29 Mar 2013 09:18:00 GMT

有些话说

头文件可以作为接口定义，再加上static修饰符，就很容易定义私有的接口，每一个具体的实现，即所有包含所有私有接口的头文件，都必须要完整实现所有已声明但未实现的函数，否则gcc编译不过去。废话不多说，进入步骤吧。

开始实施

以毫无用处的blog为例，简单两个方法就行了，需要每一个实现暴露一个可以外部调用函数。

定义一个结构，公用

blog.h:

    #ifndef _BLOG_H
    #define _BLOG_H

    typedef struct {
        char *name;
        void (*init)(void);
        void (*welcome)(void);
    } blog_t;

    #endif

这个头文件定义了一个对象。可以自由的被包含，包含之后自由使用blog_t结构。

定义一个完全私有函数头文件

blog_impl.h:

#ifndef _BLOG_IMPL_H
#define _BLOG_IMPL_H

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "blog.h" //继承blog.h文件

static void welcome(void);
static void init(void);

static blog_t *gen_default(char *name) {
    blog_t *blog = (blog_t *)malloc(sizeof(blog_t));
    blog->name = strdup(name);
    blog->init = init;
    blog->welcome = welcome;

    return blog;
}

#endif

这个文件声明定义了若干static属性的函数，因此，只要包含此头文件的C源文件，必须实现welcome与init函数，否则gcc编译不通过。需要注意此头文件私有。

编写实现

blog1.c，仅仅一个实现:

#include "blog_impl.h"

static blog_t *this;

static void init(void){
    printf("the blog owner is %s\n", this->name);
}

static void welcome(void){
    printf("here is the %s haha !\n", this->name);
}

blog_t *gen_blog1_ptr(){
    blog_t *blog = gen_default("blog1");
    this = blog;

    return blog;
}

仅有一个对外入口：gen_blog1_ptr，也就是此实现对外唯一的交互方式。

blog2.c，默认的实现:

#include "blog_impl.h"

static void init(void){
    printf("Here is the default blog init action !\n");
}

static void welcome(void){
    printf("The system's welcome action !\n");
}

blog_t *gen_blog2_ptr(){
    blog_t *blog = gen_default("default");

    return blog;
}

此文件对外唯一入口为：gen_blog2_ptr。

其实两个实现已经可以了，但多一个说明接口单一，实现多样性，再说锦上添花也是人们喜欢做的事情。 blog3.c，添花版:

#include "blog_impl.h"

static blog_t *this;

static void init(void){
    printf("Hi, %s\n", this->name);
}

static void welcome(void){
    printf("you are welcome %s!\n", this->name);
}

blog_t *gen_blog3_ptr(){
    blog_t *blog = gen_default("blog3");
    this = blog;

    return blog;
}

一样可以看到类似约定好的对外函数名称gen_blog3_ptr

应用端实现

我们以app.c作为应用入口：

#include <stdio.h>
#include <stdlib.h>

#include "blog.h"

int main(int argc, char const *argv[]) {
    blog_t *blog1 = gen_blog1_ptr();
    blog_t *blog2 = gen_blog2_ptr();
    blog_t *blog3 = gen_blog3_ptr();

    printf("the blog1's actions \n");
    blog1->init();
    blog1->welcome();
    printf("\n");

    printf("the blog2's actions \n");
    blog2->init();
    blog2->welcome();
    printf("\n");

    printf("the blog3's actions \n");
    blog3->init();
    blog3->welcome();
    printf("\n");

    return 0;
}

这里分别调用blog1.c, blog2.c, blog3.c，唯一入口，执行简单的逻辑。

编译运行

编译命令行代码很简单：

gcc -o app app.c blog1.c blog2.c blog3.c

运行：

./app

运行效果:

the blog1's actions ...
the blog owner is blog1
here is the blog1 haha !
the blog2's actions ... Here is the default blog init action !
The system's welcome action !
the blog3's actions ...
Hi, blog3
you are welcome blog3!

小结

这里借助两个头文件，模拟了私有接口，公有结构体对象，三个具体子类实现。
在c_socket.io_server项目中，作用于具体的实现，以及定义了传输通道模型和实现，互相不干扰。
当然和JAVA相比，模拟对象程度稍低了一些，但够用了。这个世界不仅仅只有面向对象，还有面向并发的函数式Erlang，还有面向软件工程的大型语言Go。嗯，面向对象不过是这个世界其中一角，天生存在缺陷，也不是被所有人喜欢。组件公用、库的概念，倒是大部分语言都很自然的欣然接受。面向过程，面向对象，不过是大部分人给与的标签，怎么用才重要。

nieyong 2013-03-29 17:18 发表评论

c_socket.io_server笔记之htmlfile块传输

nieyong — Thu, 28 Mar 2013 00:41:00 GMT

关于htmlfile chunked传输

Google天才工程师们使用一个称为“htmlfile”的 ActiveX 解决了在 IE 中的加载显示问题，具体是封装了一个基于 iframe 和 htmlfile 的 JavaScript comet 对象，支持 IE、Mozilla Firefox 浏览器，但需要服务器端配合使用。
稍微熟悉一下有关Transfer-Encoding: chunked的同学，会感觉一点技术含量都没有。但那是他们的事情，笨鸟先飞，记录下来，以作备忘。
我们做一个时间显示，每隔一秒自动显示在页面上。那么做这件事情的顺序，就很简单。

输出头部

chunked块传输，需要浏览器支持，服务器需要提前告诉浏览器端：

#define HTMLFILE_RESPONSE_HEADER \
"HTTP/1.1 200 OK\r\n" \
"Connection: keep-alive\r\n" \
"Content-Type: text/html; charset=utf-8\r\n" \
"Transfer-Encoding: chunked\r\n" \
"\r\n"......
write_ori(client, HTMLFILE_RESPONSE_HEADER);

在socket.io服务器中，数据量不大，传输内容无须gzip压缩，毕竟压缩算法要耗费一些CPU时间。

传输部分HTML预备内容

这部分不是必须的，为了调用客户端javascript方便，可以提前定义好调用函数。

#define HTMLFILE_RESPONSE_FIRST \
    "htmlfile chunked example"......
char target_message[strlen(HTMLFILE_RESPONSE_FIRST) + 20];
sprintf(target_message, "%X\r\n%s\r\n", (int)strlen(HTMLFILE_RESPONSE_FIRST), HTMLFILE_RESPONSE_FIRST);
write_ori(client, target_message);

除了http header头部输出，剩下内容的输出，需要注意输出的简单格式：

具体输出内容长度16进制数字表示\r\n具体输出内容\r\n

如

2D

掌握了格式要求之后，其它的，就没有什么难点。

设置定时器，周期性循环

client->timeout.data = client;
ev_timer_init(&client->timeout, timeout_cb, 1.0, 1.0);
ev_timer_start(loop, &client->timeout);

时间触发函数timeout_cb每一秒会定时触发：

static void timeout_cb(EV_P_ struct ev_timer *timer, int revents) {
if (EV_ERROR & revents) {
    fprintf(stderr, "error event in timer_beat\n");
    return ;
}
if (timer == NULL) {
    fprintf(stderr, "the timer is NULL now !\n");
}
client_t *client = timer->data;
if (client == NULL) {
     fprintf(stderr, "Timeout the client is NULL !\n");
    return;
}
char target_msg[50];
snprintf(target_msg, 50, "now time is %d", (int)ev_time());
write_body(client, target_msg);
}

OK，基本功能完毕。

编译运行

编译一下：

gcc htmlfile.c -o htmlfile ../include/libev.a -lm

运行它：

./htmlfile

打开浏览器，输入地址 http://192.168.190.150:8080/htmlfile，可以看到时间一点点的流逝，诸如：

now time is 1364043695

完整代码

nieyong 2013-03-28 08:41 发表评论

c_socket.io_server笔记之长轮询超时(timeout)处理

nieyong — Wed, 27 Mar 2013 00:57:00 GMT

不吐不快

当你习惯了现有WEB服务器，诸如nginx、apache，JAVA应用服务器Tomcat等，你就不能不注意HTTP请求的响应超时时间，需要小心，尤其是反向代理时。当你可以自由控制请求timeout超时时，那是怎样一个快意。
在libev中使用timeout，没有像java那样封装的完善，一切都很原始，但确实锋利多了。

长轮询

一般长轮询需要定义超时时间，一旦超时，服务器端会主动断开连接。无论是xhr形式的长轮询，还是jsonp长轮询，在服务器端处理没有多大差别，输出数据有异。

输出头部

一般优先输出头部，告诉浏览器，需要保持长连接，当然，这需要浏览器支持http 1.1协议，并且明确的注明当前连接为一直保持着：keep-alive：

char heaer_str[200] = "";
strcat(heaer_str, "HTTP/1.1 200 OK\r\n");
strcat(heaer_str, "Content-Type: text/plain; charset=UTF-8\r\n");
strcat(heaer_str, "Connection: keep-alive\r\n");
strcat(heaer_str, "\r\n");
write_msg(client, heaer_str);

定时器启动，等待

连接什么时候关闭，需要在代码中手动控制，除非浏览器端在发出请求等待响应期间出现异常，无故断开了连接。设服务器端设定好连接持续时间为30秒，那么就应该启动一个定时器，除非所使用的语言层面提供了内置支持。

client->timeout.data = client;
ev_timer_init(&client->timeout, timeout_cb, 30.0, 0); //30s
ev_timer_start(loop, &client->timeout);

定时器start之后，触发的函数timeout_cb：

1     static void timeout_cb(EV_P_ struct ev_timer *timer, int revents) {
2         if (EV_ERROR & revents) {
3             fprintf(stderr, "error event in timer_beat\n");
4             return ;
5         }
6
7         if (timer == NULL) {
8             fprintf(stderr, "the timer is NULL now !\n");
9             return;
10         }
11
12         client_t *client = timer->data;
13
14         if (client == NULL) {
15             fprintf(stderr, "Timeout the client is NULL !\n");
16             return;
17         }
18
19         write_msg(client, HTML_RESPONSE_ECHO);
20         free_res(loop, client);
21     }

可以看到，定时器触发之后，本例中将输出一串预先定义好的文字，然后关闭连接。
如何关闭触发器，则很简单：

    ev_timer *timer = &client->timeout;
    if (timer != NULL && (timer->data != NULL)) {
        ev_timer_stop(loop, timer);
    }

编译运行

编译一下：

gcc longpolling.c -o longpolling ../include/libev.a ../include/http-parser/http_parser.o -lm

运行它：

./long_polling

然后测试：

curl -i http://192.168.190.150:9000/long_polling

可以先看到头部：

HTTP/1.1 200 OK Content-Type: text/plain; charset=UTF-8 Connection: keep-alive

等到30秒后输出具体的文字内容：

The timeout(30s) had passed, you are welcome ~!

小结

所演示的长轮询，没有什么难度，HTTP 1.1头部输出，定时器启动，然后等待输出。
libev内含的timer组件简单易用，控制方便，但不算是最佳实践，官方文档给出了若干种最佳实践方式。具体可参阅:
http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#codeevtimercoderelativeandopti

完整代码

nieyong 2013-03-27 08:57 发表评论

c_socket.io_server笔记之处理静态文件

nieyong — Mon, 25 Mar 2013 08:46:00 GMT

缘由

在编写纯C语言版socket.io服务器时，选择了libev作为网络基础层代码，可以离epoll模型远一些，再说还可以避免单独使用Epoll，写出不易维护的多层嵌套代码，听说，有时Epoll出现一些“伪信号”小问题，没有那么空闲精力，绕过之，选择成熟度非常高的libev好了。
有关libev的文章，中文资料不多，英文资料也不多。这里推荐三篇：
- libev 设计分析
- libev ev_io源码分析
- 官方文档http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod，更为全面一些，阅读时可以获得较总体认知。

这里把在编写c_socket.io_server程中使用libev的一些地方做些笔记，记录下来，也方便以后查阅。

预备知识

所有代码的编写、编译、测试和运行等，都在Ubuntu下进行，另外实例严重依赖libev和http-parser HTTP解析库。
其它依赖，可以从https://github.com/yongboy/csocket.ioserver处下载。

处理静态文件

这里设计一个静态文件WEB服务器，非常简单，仅仅满足socket.io服务器最基本的需求，因此别苛求太多。但比网上很多大把类似文章多了一点写入管道时缓冲区已满问题的处理。
这里简单说一下处理静态文件的思路。

计算静态文件路径以及扩展名和内容类型

char file_path[200]; 
sprintf(file_path, "%s%s", static_folder, url_str);

获取文件内容和以及优先输出响应头部

     char file_path[200];
     sprintf(file_path, "%s%s", static_folder, url_str);
 
     int file = open(file_path, O_RDONLY);
     struct stat info;
     if (fstat(file, &info) == -1) {
         fprintf(stderr, "the file %s is NULL\n", file_path);
         write(client->fd, RESPONSE_404, strlen(RESPONSE_404));
 
         close(file);
         free_res(loop, client);
 
         return 0;
     }
 
     char file_ext[50];
     get_extension(file_path, file_ext);
     char content_type[50];
     get_content_type(file_ext, content_type);
 
     int file_len = info.st_size;
     char head_msg[200] = "";
     sprintf(head_msg, RESPONSE_TEMPLATE, content_type, file_len);
     write(client->fd, head_msg, strlen(head_msg));

很显然，这里引入fcntl.h头部文件，调用fstat初始化stat结构，可判断文件是否存在，以及文件大小等。

读取文件内容到缓冲区，循环写入

    int read_count;
    int buf_size = 8 * 1024;//8096;
    char buffer[buf_size + 1];
    while ((read_count = read(file, buffer, buf_size)) > 0) {
        int bytes_left = read_count;
        char *ptr = buffer;
        int need_break = 0;
        while (bytes_left > 0) {
            ssize_t write_len = write(client->fd, ptr, bytes_left);

            if (write_len == -1) {
                fprintf(stderr, "write failed(errno = %d): %s\n", errno, strerror(errno));
                switch (errno) {
                case EAGAIN:
                case EINTR:
                case EINPROGRESS:
                    fprintf(stderr, "now sleep 0.2s\n");
                    ev_sleep(0.2);
                    break;
                default:
                    need_break = 1;
                    break;
                }
            } else if (write_len == 0) {
                need_break = 1;
                fprintf(stderr, "write_len is zero, and break now\n");
                break;
            } else if (write_len < bytes_left) {
                bytes_left -= write_len;
                ptr += write_len;
                fprintf(stderr, "write client with something wrong wtih bytes_left = %d & write_len = %d and write the left data !\n", (int)bytes_left, (int)write_len);
            } else {
                break;
            }
        }

        if (need_break) {
            break;
        }
    }

    close(file);

需要注意，构造的一个大约8K+1的缓冲区buffer，不是每次都可以正常完整输出到socket对端，write输出不完整，会返回-1，系统返回errno值，在errno = EAGAIN，EINTR，EINPROGRESS时，需要再次将缓冲区中尚未写入的剩下数据再次写入到请求端。这样可以避免常见的半包、包不完整问题。

关闭socket描述符,当前请求结束

free_res(loop, client);

请求完成，一定要记得关闭socket描述符，释放相应资源等。这样一个较为完整的HTTP请求，静态文件就处理完毕了。

编译运行

先编译：

gcc staticserver.c -o staticserver ../include/libev.a ../include/http-parser/http_parser.o -lm

运行之：

./static_server ../static

命令输入错误，如输入静态路径为空，会报错的，哈哈：

Error: invald path parmeter

Usage: ./static_server

Example:
./staticserver ../static
./staticserver /home/yongboy/yourstaticfolder

Enjoy it~

测试一下吧

curl -i http://192.168.190.150:8000/index.html

在浏览器内，测试一下，支持图片样式等，完好显示。

需要注意，要传入静态文件目录路径，相对的路径，或绝对的路径，都是可以接受的。最后，附上完整代码：

nieyong 2013-03-25 16:46 发表评论

哈，又来一个纯C语言版本的socket.io服务器端实现~

nieyong — Fri, 15 Mar 2013 08:02:00 GMT

前言

哈，这又是一个socket.io服务端实现，本意是，拿C练练手，加强对C和linux系统的理解，写着写着，就写成了一个socket.io服务器端实现了。以为半成品，那就正式托管在github站点上吧，以便记录一下，可让大家批评与指正，加强内功的修炼等。
项目地址为
yongboy/c_socket.io_server

以下部分文字，偷懒，摘录自项目的README.md文件

说明

这是一个纯C语言版本的socket.io服务器端实现，目前仅支持linux系统，严重依赖libev and glib等基础库。
在运行socket.io_server之前，需要安装以下依赖：

sudo apt-get install uuid-dev
sudo apt-get install libglib2.0-dev

如何运行

编写实现代码（eg:chatroom.c），需要包含头文件 endpoint_impl.h
把实现代码(eg:chatroom.c)放入examples目录
编写对应的html文件，放入static目录
编辑Makefile文件
终端下运行make命令
然后敲入 ./socket.io_server 接口运行
打开浏览器即可访问 (eg:http://localhost:8000/chatroom.html)

API说明

对外的API，可以在头文件 endpoint_impl.h 看到其定义，其继承了另外一个公用的头文件 endpoint.h, 其完整定义为：

完整定义.
在example目录中，你可以看到聊天室演示 chatroom 和在线白板示范 whiteboard . 因为C语言中没有散列表，只好借助于成熟的glib库实现。

其它

项目不太成熟，期待大家的参与，您的建议、批评和指正，都是一种激励，再次表示感谢。

nieyong 2013-03-15 16:02 发表评论

刚出炉的，socket.io erlang server版本，有点小清新

nieyong — Mon, 15 Oct 2012 06:57:00 GMT

絮言

最近在学习Erlang，顺便写了一个socket.io server作为练练手，感受函数式/面向并发编程的好处。

毫无疑问，同样兼容最新的socket.io spec 1.0。

无论哪一种语言，从头开始构建HTTP协议支持，都是很痛苦的，站在巨人肩上，总是可以让你更专注于业务。Java社区可选择netty，Erlang社区可以选择非常轻量级的mochiweb和cowboy等，这里要感谢一下尤日华同学（http://www.cnblogs.com/yourihua/），特别热心，一一给我们分析了以上两个http框架的源码，我等新手获益良多。就是在其文章的帮助下，开始构建一个socket.io erlang server。

mochiweb，有些历史，已趋于稳定，但目前不支持websocket协议。

cowboy，模块/协议自由替换，使用二进制传输基本保证了低内存占用和快速传输，内置非常赞的dispatch URL分发器，内置对长连接的支持，目前使用的是0.6.1版本。推荐使用！

闲话少说，目前已经释出0.1版本，项目地址为：

https://code.google.com/p/erlang-scoketio/

项目介绍

Erlang 版本的socket.io服务器实现

1. 基于cowboy构建

检出地址： https://erlang-scoketio.googlecode.com/svn/socket.io_cowboy
兼容 socket.io-spec(https://github.com/LearnBoost/socket.io-spec) 1.0
支持xhr-polling/jsonp-polling/htmlfile/websocket/flashsocket等通讯协议
支持CJK语言，UTF-8编码下很少出现乱码
现在可以作为0.1版本释出，具有一个chat示范

2. 基于mochiweb构建

检出地址: https://erlang-scoketio.googlecode.com/svn/socket.io_mochiweb
兼容 socket.io-spec(https://github.com/LearnBoost/socket.io-spec) 1.0
仅支持xhr-polling/jsonp-polling/htmlfile等通讯协议
暂时精力有限，停止更新，假若有需要，可以进一步有偿商谈

3. 运行一个示范

下载示范文件http://code.google.com/p/erlang-scoketio/downloads/detail?name=socket.io.zip
在Linux下解压
#unzip socket*.zip
#cd socket.io
#make
#sh start.sh
打开浏览器，访问http://yourip:8080/index.html

一个实现

这里介绍一个聊天示范，看代码，很简单，也很短，才80行。

与Java相比，Erlang代码显得少多了。

其它

刚入门，项目代码写的有些草；您若慷慨，希望给些指点，谢谢：))

nieyong 2012-10-15 14:57 发表评论

Javascript EventBus(事件总线)模拟socket.io中事件处理

nieyong — Fri, 24 Aug 2012 15:04:00 GMT

socket.io客户端对事件处理相当优雅，和weboscket的有限的javascript接口差不多一致好看，但可以支持更多的自定义事件：

使用了EventBus(事件总线)方式可以很好的处理事件订阅者/事件的发布者解耦，发布者不知道订阅者，订阅者只需要自身注册，等待通知便可。EventBus是一种简单，高效，优雅，良好的客户端架构方式。嗯，还好，javascritp本身支持函数作为参数进行传递，要不还是很麻烦的。

构建一个最简单的EventBus javascript库，也不难：

简单不到40行代码，提供了事件订阅，事件取消，事件广播/发布等，虽简单，但已经满足最简单的页面端EventBus模型，可以一窥全貌了。

客户端使用事件总线代码：

看着和socket.io的客户端使用方式有所类似，但socket.io的处理方式复杂多了，并且多了一些内置的事件，这里不过是简化了很多。

嗯，有空谈一谈JAVA是如何做到事件总线(EventBus)的。

nieyong 2012-08-24 23:04 发表评论

Real-Time Web实时信息流推送培训文档

nieyong — Thu, 23 Aug 2012 01:57:00 GMT

摘要: Real-Time Web实时信息流推送
培训演示文档，文档大纲：
推送实现技术/历程
客户端如何选择
Java支持现状
socket.io
Realtime Web概念和现状
阅读全文

nieyong 2012-08-23 09:57 发表评论

构建实时Web的JAVA选择组合：socket.io client + socketio-netty server

nieyong — Thu, 24 May 2012 01:10:00 GMT

摘要: 很显然，实时Web，是一种技术趋势，将成为一种人们的默认技术选择，用以拉近和桌面应用的距离。
socket.io是一种数据实时推送、事件驱动模型的框架，支持事件订阅，简单易用。其价值目前看来，还未被完整的挖掘出来。

socket.io即提供了node.js服务器端（地址）又提供了客户端（地址）的整体解决方案，而socketio-netty则是基于JAVA服务器端，支持最新socket.io client最新版规范。对JAVA编程人员来讲，可以不用学习node.js，从而多了一个选择。阅读全文

nieyong 2012-05-24 09:10 发表评论

socketio-netty(socket.io 服务器端JAVA实现) 近期升级手记

nieyong — Mon, 21 May 2012 09:31:00 GMT

前言

针对JAVA开发者，socketio-netty是一个socket.io的服务器端选择，又是目前兼容最新0.9+ – 1.0的JAVA服务器端实现。

从http://socket.io官网来看，最近版本升级趋于缓和，几乎是没修正一个Bug，小版本就增加一次。已经是非常稳定的版本了，可以真正使用了。

貌似国内使用socket.io少之又少，可惜了，这么优秀的全功能型实时推送实现，小众范围内被知晓。

嗯，就最近当前项目修改做一些简单记载。

升级手记

netty升级到3.4.5
3.4.5的QueueFactory类，增加对了JAVA SE 7引入的JUC并发类LinkedTransferQueue，若是本地使用JAVA SE 6，还想要保持高性能的阻塞队列，那就需要引入Doug Lea’s jsr166y.jar并发包(下载地址)，然后修改一下QueueFactory实现。我已经重新打包成jar包（这里是netty-3.4.5.Final-modify.jar）。
QueueFactory原始代码：
QueueFactory修改后代码：
socket.io client 升级到 0.9.6
支持将HTML/CSS/JS等文件
socketio.properties 增加配置项static，指定静态资源的相对路径，默认是static
若浏览器请求：http://localhost:9000/style/chat.css，则此文件相对路径为 static/style/chat.css，其它文件与此类似。
此属性便于打包，以及不再单独依赖Web容器
项目中，直接把网页文件拷贝到/source/static目录中，运行相应的JAVA文件（ChatServer.java）
在Google Code 增加demo
下载聊天示范，下载后解压，双击 start.bat或者start.sh，浏览　http://localhost:9000/　即可。

有时间，会聊聊更具体的实时Web一些心得，以及更为具体的示范等。

nieyong 2012-05-21 17:31 发表评论

为Phonegap Android平台增加websocket支持，使默认成为socket.io首选通道选择

nieyong — Thu, 10 May 2012 06:10:00 GMT

摘要: 构建一个在市面上常见浏览器上都可以正常运行的聊天应用，保证在IE6+，Firefox，Chrome，Safari，Opear，IOS，Android等可以正常运转，根据具体环境自动选择最佳的通信通道。
嗯，既然是跨浏览器平台，那自然选择socket.io了。它也是本文的重心，最终目的也是让socket.io 客户端版本在Phonegap包装的Android Apk程序中可以使用Websocket协议。
同时也保证我们的示范应用尽可能的做到编写一次，到处运行。
还好，有了socket.io(客户端js) + socketio-netty（socket.io服务器端JAVA实现） + Phonegap, 构建各种交互的HTML应用，是个不错的选择。
另，本文项目为仅仅为演示其功能，不保证样式。阅读全文

nieyong 2012-05-10 14:10 发表评论

socketio-netty : 又一款socket.io服务器端实现，兼容0.9-1.0版本~

nieyong — Sat, 07 Apr 2012 14:08:00 GMT

缘起

socket.io是一个跨浏览器的全平台反响AJAX实现，官网（http://socket.io）定义为：the cross-browser WebSocket for realtime apps.

个人认为这是一个跨浏览器的集大成者，支持桌面端和移动端浏览器（http://socket.io/#browser-support）：

Desktop

Internet Explorer 5.5+
Safari 3+
Google Chrome 4+
Firefox 3+
Opera 10.61+

Mobile

iPhone Safari
iPad Safari
Android WebKit
WebOs WebKit

为了支持众多浏览器，必然内置对若干协议的支持：

WebSocket
Adobe® Flash® Socket
AJAX long polling
AJAX multipart streaming
Forever Iframe
JSONP Polling

socket.io跨浏览器，根据浏览器自动适配最适合方案进行实时推送。

官方提供了各种语言的实现，见 https://github.com/learnboost/socket.io/wiki/，有java语言实现服务器端，但不支持最新的0.9版本，于是萌发了重写一个的想法。

概述

这是一个Socket.IO服务器端实现，基于netty框架，适配socket.io 0.9-1.0版本（虽然socket.io 目前还处于 0.9版本，会支持到1.0）

项目地址： http://code.google.com/p/socketio-netty/

采用流行的Apache License 2.0协议，svn作为源代码管理。

邮件讨论组为 http://groups.google.com/group/socketio-netty
或者
https://groups.google.com/group/socketio-netty
期待您的加入。

至于为什么没有采用tomcat/jetty支持的servlet3规范、sebsocket实现，个人认为，构建在其基础上较为容易，tomcat7最新版刚刚支持websocket，传说支持websocket的servlet 3.1还未出世，等等看吧。而Netty这个异步IO框架，我们可以在它的基础上一站式搞定如此多的传输通道/协议。

socketio-netty支持：

WebSocket
Flash Socket
AJAX long polling
Forever Iframe
JSONP Polling

等传输通道协议。

示范

本示范，参考 socket.io node.js 版本的聊天实现(chat)，客户端完全一致，服务器端完全换成了socketio-netty实现。其它的没有任何变化。嗯，可能看一个示范，可以让人更放心的使用。客户端入口 chat.html (存放在tomcat/jetty/nginx/apache/iis相应位置，可以直接访问即可)：看一下，我们的服务器端如何实现，来一个启动入口：然后需要一个DemoChatHandler处理器，这个是一个单列多线程模式：

以上就是整个的聊天室实现，虽然不算优雅，但很简单。

所有你所需要做的就是，检出代码，运行com.yongboy.socketio.test.ChatServer即可。

nieyong 2012-04-07 22:08 发表评论