express redis socket 消息提醒方案:本地emit 轮循服务器获取redis 再推送

在做项目时，需要实现消息提醒，因为现在有多个项目，都需要实现。

为了实现多项目公用，和以后项目也可以使用。

单独开了个项目，起了个node 服务来实现消息提醒。

用express redis socket.io来实现的。

session 都存在redis里，所有的服务都一样。这样实现了，sessio共享

只要其他项目登录了，消息服务也就登录了。

因为要多个项目共用，所以会在项目中引用socket.io js 然后创建

var socket=io('http://localhost:8007');

链接到8007也就是消息服务器。

消息服务io connection 链接上后，通过socket.request.headers.sookie 来获取请求的cookie 找到connect.sid 得到sid。

再从redis上查找对应的用户信息。保存到链接socket上。然后发送emit open ，表示链接成功。

本地接收到后轮循向服务器发请message 请求来获取消息。

服务器查询redis获取消息，并emit 返回。

以下是服务端代码：

/*star 2016-8-20
socket 从请求中获取cookie 也就是token 再从redis里取到token对应的user 信息。
这后向socket页面emit(open) 表示当前登录用户链接socket成功。
本地轮循发起emit message 事件，获取用户的提示条数。
服务器根据 userid 从redis里读取提示条数并返回。
----此为node socket 消息服务器第一种解决方案
*/
var express = require('express');
var path = require('path');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var session = require('express-session');
var RedisStore = require('connect-redis')(session);
var http = require('http');

var redis_api=require('./redis_api.js')

var port=8007;
var app = express();

// view engine setup
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

// 设置 Session
app.use(session({
store: new RedisStore({
host: "127.0.0.1",
port: 6379,
db: 0
//pass: 'yu'
}),
resave:false,
saveUninitialized:false,
secret: 'keyboard cat'
}))

app.use(function(req,res,next){
console.log(req.url);
next();
})

app.get('/socket',function(req,res){
res.header("Access-Control-Allow-Origin", "*");
//console.log(req.session.username)
res.send(req.session)
})

var server = http.createServer(app);

server.listen(port);
server.on('error', onError);
server.on('listening', onListening);

var io=require('socket.io')(server);
var users=[]
io.on('connection',function(socket){
console.log('open')
//获取请求cookie
var cookie_string=decodeURIComponent(socket.request.headers.cookie)
//正则匹配 获取sid
var s=/connect.sid=([^\.]+)/g.exec(cookie_string);
var sid='';
if(s && s.length>1){
sid=s[1].split(':')[1];
//console.log(sid);
var user;
redis_api.getsid(sid,function(err,res){
if(!err){
user=res;
socket.emit('open',{sid:sid,user:user.user})
socket.sid=sid;
socket.user=user.user;
//链接数测试
/*var n=9000000;
while(n--){
users.push(socket);
}*/
}
})
}
socket.on('message',function(res){
console.log(res);
switch(res.action){
case "read":
read();
break;
}
})
function read(){
redis_api.getmessage(socket.user.id,function(err,reply){
if(!err){
socket.emit('message',{type:1,action:'message',data:reply,number:users.length})
}
})
}
socket.on('disconnect',function(){
console.log('close')
})

})

function onError(error) {
if (error.syscall !== 'listen') {
throw error;
}

var bind = typeof port === 'string'
? 'Pipe ' + port
: 'Port ' + port;

// handle specific listen errors with friendly messages
switch (error.code) {
case 'EACCES':
console.error(bind + ' requires elevated privileges');

break;
case 'EADDRINUSE':
console.error(bind + ' is already in use');

break;
default:
throw error;
}
}

/**
* Event listener for HTTP server "listening" event.
*/

function onListening() {

console.log('localhost:'+port)
}以下是redis_api代码
var redis = require('redis');
var client = redis.createClient('6379', '127.0.0.1');

exports.getsid=function(sid,call){
//client.select('0',function(err){
//if(!err){
//console.log('select 0',err)
client.get('sess:'+sid ,function(err,reply){
console.log('------sess:'+sid)
console.log('sess:',sid,err,reply)
console.log('end ------sess:'+sid)
if(err){
call(err)
}else{
//console.log('sess:'+sid+'=',reply)
call(0,JSON.parse(reply))
}
})
//}
//})

}
//根据userid 获取消息数
exports.getmessage=function(userid,call){
client.select('0',function(err){
if(!err){
client.get('message:'+userid,function(err,reply){
if(!err){
console.log('message:'+userid+'='+reply)
call(0,JSON.parse(reply))
}
// 关闭链接
//client.quit();
})
}
})
}



以下是页面代码：

var socket=io('http://localhost:8007');
socket.on('open',function(res){
console.log('开了',res)
time();
//socket.emit('message',{id:1,type:1,action:'read'})
})
socket.on('message',function(res){
console.log(res,new Date());
})

//以下为轮循发请emit 获取消息数
function time(){
setInterval(function(){
socket.emit('message',{type:1,action:'read'})
//socket.emit('message',{type:1,action:'read'})
},3000)
}

当然这种实现是有问题 的，并不是时时消息提醒。
而且当链接数大时不断轮循会给服务器和带宽带来很大压力。