Web端即时通讯、消息推送的实现

admin

在浏览某些网页的时候，例如 WebQQ、京东在线客服服务、CSDN私信消息等类似的情况下，我们可以在网页上进行在线聊天，或者即时消息的收取与回复，可见，这种功能的需求由来已久，并且应用广泛。

网上关于这方面的文章也能搜到一大堆，不过基本上都是理论，真正能够运行的代码很少，原理性的东西我就不当搬运工了，本文主要是贴示例代码，最多在代码中穿插一点便于理解，本文主要的示例代码基于 javascript，服务端基于 nodejs 的 koa(1/2)框架实现。

---

模拟推送

Web端 常见的消息推送实际上大多数都是模拟推送，之所以是模拟推送，是因为这种实现并不是服务器主动推送，本质依旧是客户端发起请求，服务端返回数据，起主动作用的是客户端。

---

; b3 [; v) J2 i7 b* z8 G) O短轮询

实现上最简单的一种模拟推送方法，原理就是客户端不断地向服务端发请求，如果服务端数据有更新，服务端就把数据发送回来，客户端就能接收到新数据了。

一种实现的示例如下：

1. const loadXMLDoc = (url, callback) => {
   9 R% P6 A  B& X6 E2 q
2.   let xmlhttp
   % j" H( n3 _# a
3.   if(window.XMLHttpRequest) {
   
4.     //  IE7+ Firefox Chrome Safari 等现代浏览器执行的代码
   
5.     xmlhttp = new XMLHttpRequest()
   
6.   } else {
   
7.     // IE5 IE6浏览器等老旧浏览器执行的代码
   
8.     xmlhttp = new ActiveXObject('Microsoft.XMLHTTP')
   7 |& n+ J7 G! {- V0 \
9.   }
   ) D# }* L1 x; H/ J
10. 
    
11.   xmlhttp.onreadystatechange = () => {
    : H8 A3 n6 T9 {% z/ ?* z4 |
12.     if(xmlhttp.readyState === 4 && xmlhttp.status === 200) {
    ' W  e: E8 n! C& O# ?; l2 }
13.       document.getElementById('box1').innerHTML = xmlhttp.responseText
    
14.       callback && callback()
      g: f! u' d* P4 A
15.     }
    
16.   }
    
17.   // 打开链接发送请求
    ; u  K% G6 N. o5 N
18.   xmlhttp.open('GET', 'http://127.0.0.1:3000/' + url, true)
    3 W4 ^' P1 ]" ^6 E
19.   xmlhttp.send()
    
20. }
    
21. 
    1 |- p5 W9 D3 X& T
22. // 轮询
    
23. setInterval(function() {
    
24.   loadXMLDoc('fetchMsg')
    
25. }, 2000)

复制代码

上述代码，设置定时任务，每隔 2s使用 ajax发起一次请求，客户端根据服务端返回的数据来进行决定执行对应的操作，除了发送 ajax，你还可以使用 fetch：

1. fetch('localhost:3000/fetchMsg', {
   ) B; l; O+ b3 k, Y( q" f$ f
2.     headers: {
   
3.         'Accept': 'application/json, text/plain, */*'
   $ x3 @! f) Y% S6 X
4.     }
   
5. }

复制代码

1. 引申：fetch目前的浏览器支持度还很低，所以在实际生产环境中使用的时候，最好添加一些 polyfill，一种垫片使用顺序示例如下：
   
2. - es5 的 polyfill — es5-shim
   
3. - Promise 的 polyfill — es6-promise - IE8+
   
4. - fetch 的 polyfill — fetch - IE10+

复制代码

如果你在使用某种框架，例如 vue 或者 angular，那么你同样可以使用这些框架自带的请求方法，总之基于页面的友好访问性，在发送请求的同时不要刷新页面就行了。

另外，如果不想在主程序的线程中做这种机械的轮询，可以尝试使用 Web Worker，下面是一个使用 Web Worker轮询的例子：

1. // 在主程序中创建 Web Worker
   
2. function createWorker(fn) {
   
3.   const blob = new Blob([fn.toString()])
   
4.   const url = window.URL.createObjectURL(blob)
   $ y9 C9 K6 H! t
5.   const worker = new Worker(url)
   2 f  Y5 N* K$ o( J
6.   return worker
   
7. }
   
8. 
   ; s5 T; X7 g' a+ j* U7 ?2 r
9. // 轮询函数
   
10. const pollingWorker = createWorker(() => {
    # @# D( e( \7 a1 t
11.   let cache = null
    $ t7 }/ l, o' P  q, }
12.   // 如果这一个 worker只干这一件事，setInterval是不会受到干扰的
    
13.   setInterval(function() {
    " v  T7 L$ ?5 ~( V
14.     fetch('/my-api').then(res => {
    
15.       const data = res.json()
    
16.       if (data !== cache) {
    7 i6 l: b" F1 y1 }2 d. e" a
17.         // 轮询的数据发生变化
    
18.         cache = data
    
19.         // worker向主程序发送通知
    1 I5 m3 u0 v2 C3 \
20.         self.postMessage(data)
    - ~& X& c/ h2 Z+ G0 L) d' x$ F
21.       }
    
22.     })
    1 U& `8 N$ b2 |
23.   }, 1000)
    ! G; w! l. a" W5 k7 `, M
24. })
    
25. 
    
26. pollingWorker.onmessage = function() {
    
27.   // 主程序接收到 worker发来的通知
    3 t# ~& P3 P8 V! f* w
28.   // do something
    $ _" |$ @) I; q& T. z4 n9 m
29. }

复制代码

优点：

1. 前后端程序都很容易编写，没什么技术难度

复制代码

缺点：

1. 这种方法因为需要对服务器进行持续不断的请求，就算你设置的请求间隔时间很长，但在用户访问量比较大的情况下，也很容易给服务器带来很大的压力，而且绝大部分情况下都是无效请求，浪费带宽和服务器资源，一般不会用于实际生产环境的，自己知道一下就行了。

复制代码

---

长轮询

相比于上一种实现，长轮询同样是客户端发起请求，服务端返回数据，只不过不同的是，在长轮询的情况下，服务器端在接到客户端请求之后，如果发现数据库中的数据并没有更新或者不符合要求，那么就不会立即响应客户端，而是 hold住这次请求，直到符合要求的数据到达或者因为超时等原因才会关闭连接，客户端在接收到新数据或者连接被关闭后，再次发起新的请求。

为了节约资源，一次长轮询的周期时间最好在 10s ~ 25s左右，长连接也是实际生产环境中，被广泛运用于实时通信的技术。

客户端代码如下：

1. function getData() {
   ( g7 h$ Z/ s/ z* t
2.   loadXMLDoc('holdFetchMsg', ()=>{
   0 w. }3 F! A8 x% J! b$ e4 C
3.     getData()
   * J7 U- S4 G2 }3 |
4.   })
   
5. }
   
6. getData()

复制代码

想要在连接断开或发生错误的时候，再次发起请求连接，实现也很简单，以下问使用 fetch 实现示例：

1. function getData() {
   + |: e$ L8 u" {$ }4 o4 n8 K" }1 ^
2.   let result = fetch('http://127.0.0.1:3000/holdFetchMsg', {
   
3.     headers: {
   
4.         'Accept': 'application/json, text/plain, */*'
   
5.     }
   & J2 Y  o( t3 w
6.   })
   
7.   result.then(res => {
   
8.     return res.text()
   
9.   }).then(data => {
   + R+ p% V. o9 w+ c( B
10.     document.getElementById('box1').innerHTML = data
    * @; ]8 }4 L3 a' h4 A% p' r
11.   }).catch(e => {
    
12.     console.log('Catch Error:', e)
    
13.   }).then(() => {
    
14.     getData()
    
15.   })
    
16. }
    
17. getData()

复制代码

一种较为直观的服务器 hold住连接的实现如下：
0 {, }* h. v) T' [4 g

1. router.get('/holdFetchMsg', (ctx, next)=> {
   2 d0 U$ @, v& f! R2 G# c% [: L, V
2.   let i = 0
   + S* b6 [- }  ]' \4 o. T' q& ]
3.   while(true) {
   
4.     // 这里的条件在实际环境中可以换成是到数据库查询数据的操作
   + }6 t7 e& s" ^* n/ \
5.     // 如果查询到了符合要求的数据，再 break
   " `4 u" b4 I2 S1 K4 S6 R
6.     // 不过这种可能会导致服务器进行例如疯狂查询数据库的操作，非常不友好
   
7.     if(++i > 2222222222) {
   
8.       ctx.body = '做我的狗吧'
   
9.       break
   & F( @+ @1 G7 ^- Y( @( P, {) k
10.     }
    1 d+ ^9 D; f# ]' @
11.   }
    
12. })

复制代码

还有一种方法，不过这种纯粹是为了 hold住而 hold住，可以作为上一种方法的辅助，解决诸如服务端进行疯狂查询数据库的操作，类似于 Java中的 Thread.sleep()操作
7 Y( B  {' M2 f8 R* \, G' H6 Q0 O+ u

1. let delay = 2000, i = 0
   1 a- G& f2 ~& _
2. while(true) {
   
3.    let startTime = new Date().getTime()
   ; o# p4 @7 |+ o& ~/ l/ Q  c0 ]
4.    // 这里的条件在实际环境中可以换成是到数据库查询数据的操作
   
5.    if(++i > 3) {
   8 x) _' w5 u4 }; u0 u) {# a
6.      ctx.body = '做我的狗吧'
   
7.      break
   4 a  [4 T$ K# R$ g* ?
8.    } else {
   
9.      // 休息会，别那么频繁地进行诸如查询数据库的操作
   
10.      // delay 为每次查询后 sleep的时间
    2 F# B  k- a: F0 s! y/ A
11.      while(new Date().getTime() < startTime + delay);
    1 m, ~4 R6 @' m% q8 ]
12.    }
    ( t6 \# x5 T/ g+ D6 f9 R( h
13. }

复制代码

如果你现在的 Nodejs版本支持 ES6中的 Generator的话，那么还可以这样(koa1环境， Generator写法)：

1. app.use(function* (next){
   
2.   let i = 0
   
3.   const sleep = ms => {
   . E7 b% Q7 \* Q0 J1 G5 k) h
4.     return new Promise(function timer(resolve){
   
5.       setTimeout(()=>{
   
6.         if(++i > 3) {
   3 k/ P: b1 i: C. f+ e# w8 w
7.           resolve()
   
8.         } else {
   ! M" m  A% B9 C- h8 s- \
9.           timer(resolve)
   
10.         }
    3 K' j; o8 G3 T/ h. M2 R
11.       }, ms)
    
12.     })
    
13.   }
    
14.   yield sleep(2000)
    
15.   this.body = '做我的狗吧'
    " N1 k! r) |! L
16. })

复制代码

如果你现在的 Nodejs版本支持 ES7中的 async/await的话，，那么还有一种 hold住连接的方法可供选择(koa2环境)：

1. router.get('/holdFestchMsg', async(ctx, next) => {
   
2.     let i = 0
   1 ]* D$ x4 g- w
3.     const sleep = ms => {
   8 @1 _7 s0 p  u% p. [! U/ ~$ B9 O
4.        return new Promise(function timer(resolve) {
   
5.          setTimeout(async()=>{
     t  e, `8 K; k1 {! T3 W1 F
6.            // 这里的条件在实际环境中可以换成是到数据库查询数据的操作
   
7.            if(++i > 3) {
   0 J; K/ @% w1 i  r& G. y' b
8.              resolve()
   * L, }) P% C1 W
9.            } else {
   , d6 _- t4 ^1 j# R- B9 ^$ T
10.              timer(resolve)
    
11.            }
    
12.          }, ms)
    
13.        })
    
14.      }
    
15.      await sleep(2000)
    
16.      ctx.body = '做我的狗吧'
    
17. })

复制代码

优点：

1. 尽管长轮询不可能做到每一次的响应都是有用的数据，因为服务器超时或者客户端网络环境的变化，以及服务端为了更好的分配资源而自动在一个心跳周期的末尾断掉连接等原因，而导致长轮询不可能一直存在，必须要不断地进行断开和连接操作，但无论如何，相比于短轮询来说，长轮询耗费资源明显小了很多

复制代码

缺点：

1. 服务器 hold连接依旧会消耗不少的资源，特别是当连接数很大的时候，返回数据顺序无保证，难于管理维护。

复制代码

---

长连接

这种是基于 iframe 或者 script实现的，主要原理大概就是在主页面中插入一个隐藏的 iframe(script)，然后这个 iframe(script)的 src属性指向服务端获取数据的接口，因为是iframe(script)是隐藏的，而且 iframe(script)的 刷新也不会导致 主页面刷新，所以可以为这个 iframe(script)设置一个定时器，让其每隔一段时间就朝服务器发送一次请求，这样就能获得服务端的最新数据了。

先说一下 利用 script的长连接：

前端实现：

1. <script>
   
2.   function callback(msg) {
   0 L9 e2 C; S, ~" U+ V( W) N
3.     // 得到后端返回的数据
   
4.     console.log(msg);
   
5.   }
   
6.   function createScript() {
   ( Y$ m, @) A$ _: |: S. n2 ~0 g
7.     let script = document.createElement('script')
   
8.     script.src = 'http://127.0.0.1:3000/fetchMsg'
   5 S0 e1 a# v7 G2 X! T
9.     document.body.appendChild(script)
   
10.     document.body.removeChild(script)
    
11.   }
    5 F  Y# `8 m1 \0 k# U6 p1 t- {
12. </script>
    
13. <script>
    7 }4 ]! H( `- l0 O# J
14.   window.onload = function() {
    
15.     setInterval(()=>{
    
16.       createScript()
    # }0 m0 X9 G, T2 E
17.     }, 3000)
    ' c1 I: i; P1 W
18.   }
    
19. </script>

复制代码

后端实现：

1. router.get('/fetchMsg', (ctx, next)=> {
   
2.   ctx.body = 'callback("做我的狗吧")'
   
3. })

复制代码

主要是在前端，一共两条 script脚本，大致左右就是在一定的时间间隔内（示例为 3s）就动态地在页面中增删一个链接为用于请求后端数据的 script脚本。

后端则返回一段字符串，这段字符串在返回前端时，有一个 callback字段调用前端的代码，类似于 jsonp的请求。

1. 注意：修改一个已经执行过的 script脚本的 src属性是没什么卵用的，修改之后，最多在页面的 DOM上发生一些变化，而浏览器既不会发请求，也不会执行脚本，所以这里采用动态增删整个 script标签的做法。

复制代码

可以看到，这种方法其实与短轮询没什么区别，唯一的区别在于短轮询保证每次请求都能收到响应，但上述示例的长连接不一定每次都能得到响应，如果下一次长连接开始请求，上一次连接还没得到响应，则上一次连接将被终止。

当然，如果你想长连接每次也都能保证得到响应也是可以的，大致做法就是在页面中插入不止一条 script标签，每条标签对应一个请求，等到当前请求到达再决定是否移除当前 script标签。

如果想要得到有序的数据响应，则还可以将 setInterval换成递归调用，例如：

1. function createScript() {
   
2.   let script = document.createElement('script')
   
3.   script.src = 'http://127.0.0.1:3000/fetchMsg'
   : |: N9 w* v& y, O& ^4 G
4.   document.body.appendChild(script)
   , V7 `0 F4 f3 S5 r
5.   script.onload = ()=> {
   3 ?' O7 b) \/ t3 N5 O; ^/ o
6.     document.body.removeChild(script)
   ' d2 d& d. n9 H' H8 w
7.     // 约束轮询的频率
   
8.     setTimeout(()=>{
   " E: `- Z' w6 ?- n" b+ Q: ?6 Q! o
9.       createScript()
   9 O: y$ T0 o: @! ^) Y$ y! |1 s
10.     }, 2000)
    
11.   }
    3 w7 d* ?3 {4 y! w$ m2 z
12. }
    
13. 
    8 D/ X7 }$ o: p1 U
14. window.onload = function() {
    
15. createScript()
    
16. }

复制代码

使用 iframe的方式与此类似，就不赘述了，不过需要注意的是， iframe可能存在跨域的情况，可能会比 script方式麻烦一些。

---

4 j7 J: s) m6 C3 l8 [0 CWebSocket

WebSoket是 HTML5新增的 API，具体介绍如下（来源w3c菜鸟教程）

1. WebSocket是HTML5开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。
   
2. 
   
3. 在WebSocket API中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。
   ) o" Y) _! U7 r' l
4. 
   
5. 浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求，连接建立以后，客户端和服务器端就可以通过 TCP 连接直接交换数据。
   
6. 
   7 S! ~7 R6 _! c( a" U; q) q/ R2 d
7. 当你获取 Web Socket 连接后，你可以通过 send() 方法来向服务器发送数据，并通过 onmessage 事件来接收服务器返回的数据。

复制代码

上面所提到的短轮询、长轮询、长连接，本质都是单向通信，客户端主动发起请求，服务端被动响应请求，但 WebSocket则已经是全双工通讯了，也就是说无论是客户端还是服务端都能主动向对方发起响应，服务器具备了真正的 推送能力。

一段简单的 客户端 WebSocket代码示例如下：

1. function myWebSocket() {
   
2.   let ws = new WebSocket('ws://localhost:3000')
   9 h( |! o9 Y& I7 J
3.   ws.onopen = ()=> {
   
4.     console.log('send data')
   
5.     ws.send('client send data')
   
6.   }
   9 |* J9 T/ i9 e* Z0 P, f9 Z' G0 H8 z
7. 
   
8.   ws.onmessage = (e)=> {
   
9.     let receiveMsg = e.data
     R% p9 K3 W) F+ m9 x! {3 n; v( U; R& m
10.     console.log('client get data')
    ' G1 Q) m* z* p1 Q7 a) @
11.   }
    
12. 
    
13.   ws.onerror = (e)=>{
    
14.     console.log('Catch Error:', e)
    - d1 t  a- |. q) w
15.   }
    & @7 D& `* A; E6 R' ?, k
16. 
    
17.   ws.onclose = ()=> {
      m% m, T. c% ?! a9 s! k. d/ L4 [
18.     console.log('ws close')
    ; n- i5 A- ^+ \9 \# m0 h
19.   }
    + L/ J6 [4 O% z/ x, \
20. }

复制代码

想要让客户端的 WebSocket能够连接上服务器，服务端必须要具备能够响应 WebSocket类型的请求才行，一般的服务器是没有自带这种能力的，所以必须要对服务器端程序代码做出些改变。

自己封装服务器端响应 WebSocket的代码可能会涉及到很底层的东西，所以一般都是使用第三方封装好的库，基于nodejs的 WebSocket库有很多，ws 功能简单， API形式更贴近于原生，大名鼎鼎的 socket.io 是与 Nodejs联手开发，功能齐全，被广泛运用于游戏、实时通讯等应用。

以下给出一种基于 socket.io 实现 简单客户端和服务端通信的示例：

客户端：

1. // HTML
   
2. <body>
   2 d' j# |! _* a; @& S6 p/ d7 g
3.   <ul id="messages"></ul>
   ; V% G0 K  q* t/ N- K- y9 n) R0 S
4.   <form action="" id="msgForm">
   - a! S5 o/ n, ~# \) K$ O* W1 O
5.     <input id="m" autocomplete="off" /><input type="submit" class="submit" value="submit">
   
6.   </form>
   
7. </body>
   
8. 
   
9. // 引入 socket.io
   
10. <script src='/socket.io/socket.io.js'></script>
    " D5 K; Z$ T. K* D
11. <script>
    
12.   function appendEle(parent, childValue, position = 'appendChild') {
    ( f) d  n- U* q; r* G; U8 g
13.     let child = document.createElement('li')
    8 S. X. \4 q. ~6 L3 t
14.     child.innerHTML = childValue
    6 p* W: c4 J; b4 L% I% W9 [6 F( \
15.     parent[position](child)
    
16.   }
    
17. 
    , @7 i; l0 S; q; i& z
18.   function socketIO(msgForm, msgBox, msgList) {
    
19.     const socket = io()
    
20.     msgForm.addEventListener('submit', (e)=>{
    5 O& N, Q" C2 U! H
21.       e.preventDefault()
    4 N, r( P- Z" q( b
22.       socket.emit('chat message', msgBox.value)
    + l9 J( y+ [3 F  J9 C
23.       appendEle(msgList, '<b>Client: </b>' + msgBox.value)
    
24.       msgBox.value = ''
    & D# ~* W3 ~/ z1 M
25.     })
    
26. 
    ( |- z) `4 i' E0 p8 I. Q6 d
27.     socket.on('chat message', (msg)=>{
    
28.       appendEle(msgList, msg)
    
29.     })
    ; ~. r! Q9 y* n& }) y$ L
30.   }
    
31. 
    
32.   window.onload = ()=>{
    
33.     let msgForm = document.querySelector('#msgForm')
    
34.     let msgBox = document.querySelector('#m')
      @0 }- F' J" ^7 E) j( }
35.     let msgList = document.querySelector('#messages')
    % v4 O0 |* P8 c5 b8 e& I
36.     socketIO(msgForm, msgBox, msgList)
    
37.   }
    
38. </script>

复制代码

服务端实现：

1. const app = require('express')()
   6 Z; V9 F2 J% H: {3 Z
2. const http = require('http').Server(app)
   
3. const io = require('socket.io')(http)
   
4. 
   
5. app.get('/', (req, res)=> {
   6 P, \& U9 W8 R3 z
6.   res.sendFile(__dirname + '/index.html')
   
7. })
   . j. x/ h1 a9 M2 P) ]
8. 
   
9. io.on('connection', socket=>{
   
10.   console.log('a user connected')
    
11.   socket.on('disconnect', ()=>{
    2 D: S: Y& @$ G7 |
12.     console.log('user disconnect')
    ( l: Y1 e% c: t/ }. {
13.   })
    
14.   socket.on('chat message', (msg)=>{
    
15.     console.log('clien get message: ', msg)
    
16.     setTimeout(()=>{
    , Y1 N$ e$ W- W. d8 r
17.       io.emit('chat message', '<b>Server:</b>' + ' Are you Sure? -- Come from your father')
    9 E1 g; t6 g: T! Q
18.     }, 1500)
    3 X6 `( _2 \- a, s/ Q' s
19.   })
    
20. })
    $ e( d3 a) z$ x
21. 
    
22. http.listen(3000, ()=> {
    
23.   console.log('Server running at 3000.')
    - E$ p0 Q# p( L  J" \
24. })

复制代码

WebSocket 的浏览器支持程序为 IE10+， Android 4.4+，所以，如果不是 淘宝那样量级超大的产品，应该都可以使用 这项应该不算是新技术的技术了。