基于CentOS搭建微信小程序服务

1. 准备域名、证书和服务器

小程序后台服务需要通过 HTTPS 访问，在实验开始之前，我们要准备域名和 SSL 证书。

• 购买云服务器（腾讯云）

• 域名解析

  域名购买完成后, 需要将域名解析到云主机

  域名设置解析后需要过一段时间才会生效，通过 ping 命令检查域名是否生效 ，如：ping www.yourdomain.com。

  如果 ping 命令返回的信息中含有你设置的解析的 IP 地址，说明解析成功。

• 申请 SSL 证书

2. 搭建小程序开发环境

在开始搭建我们的小程序服务器之前，需要先完成客户端小程序开发环境的搭建。

• 注册开发者账号

  如果你还不是小程序开发者，请先在微信公众平台并注册：https://mp.weixin.qq.com

• 配置小程序服务器信息

  登录微信公众平台后，依次进入 设置 - 开发设置 - 服务器域名 - 修改。

  扫码完成身份校验后，request 合法域名和 socket 合法域名均填写在上一步准备好的域名地址。

  配置完成后，点击 保存并提交。

• 运行配套小程序代码

  要运行本实验配套的小程序代码，请下载下列资源：

  • 实验配套源码
  • 微信小程序开发工具

  源码下载后，请解压到本地工作目录。

  开发工具下载后，请安装并启动，然后用微信扫码登录。

  登录后，选择 本地小程序项目 - 添加项目，使用以下配置：

  • AppID：填写小程序的 AppID，请登录公众平台后在 设置 - 开发设置 - 开发者 ID 中查看

  • 项目名称：填写任意您喜欢的名称

  • 项目目录：选择刚才解压的配套源码目录（目录包含 app.js）

  填写完成后，点击 添加项目。

• 设置实验域名

  在开发工具的 编辑 面板中，选中 app.js 进行编辑，需要修改小程序通信域名，请参考下面的配置：

  App({
      config: {
          host: '' // 这个地方填写你的域名
      },
      onLaunch () {
          console.log('App.onLaunch()');
      }
  });

3. 搭建 HTTP 服务

下面的步骤，将带大家在服务器上使用 Node 和 Express 搭建一个 HTTP 服务器

• 安装 NodeJS 和 NPM

  使用下面的命令安装 NodeJS 和 NPM

  curl --silent --location https://rpm.nodesource.com/setup_8.x | sudo bash -
  yum install nodejs -y

  安装完成后，使用下面的命令测试安装结果

  node -v

• 编写 HTTP Server 源码

  创建工作目录

  使用下面的命令在服务器创建一个工作目录：

  mkdir -p /data/release/weapp

  进入此工作目录

  cd /data/release/weapp

  创建 package.json

  在刚才创建的工作目录创建 package.json，添加我们服务器包的名称和版本号，可参考下面的示例。

  {
      "name": "weapp",
      "version": "1.0.0"
  }

  添加 Server 源码

  在工作目录创建 app.js，使用 Express.js 来监听 8765 端口
  ，可参考下面的示例代码。

  // 引用 express 来支持 HTTP Server 的实现
  const express = require('express');
  
  // 创建一个 express 实例
  const app = express();
  
  // 实现唯一的一个中间件，对于所有请求，都输出 "Response from express"
  app.use((request, response, next) => {
      response.write('Response from express');
      response.end();
  });
  
  // 监听端口，等待连接
  const port = 8765;
  app.listen(port);
  
  // 输出服务器启动日志
  console.log(`Server listening at http://127.0.0.1:${port}`);

• 运行 HTTP 服务

  安装 PM2

  在开始之前，我们先来安装 PM2

  npm install pm2 --global

  PM2 安装时间可能稍长，请耐心等候

  安装 Express

  我们的服务器源码里使用到了 Express 模块，下面的命令使用 NPM 来安装 Express

  cd /data/release/weapp
  npm install express --save

  启动服务

  安装完成后，使用 PM2 来启动 HTTP 服务

  cd /data/release/weapp
  pm2 start app.js

  现在，您的 HTTP 服务已经在 http://yourdomain.com:8765 运行

  要查看服务输出的日志，可以使用下面的命令：

  pm2 logs

  如果要重启服务，可以使用下面的命令：

  pm2 restart app

4. 搭建 HTTPS 服务

微信小程序要求和服务器的通信都通过 HTTPS 进行

• 安装 Nginx

  在 CentOS 上，可直接使用 yum 来安装 Nginx

  yum install nginx -y

  安装完成后，使用 nginx 命令启动 Nginx：

  nginx

  此时，访问 http://yourdomain.com 可以看到 Nginx 的测试页面

• 配置 HTTPS 反向代理

  外网用户访问服务器的 Web 服务由 Nginx 提供，Nginx 需要配置反向代理才能使得 Web 服务转发到本地的 Node 服务。

  先将之前下载的 SSL 证书(解压后 Nginx 目录分别以 crt 和 key 作为后缀的文件)通过 PuTTy（Windows） 或者 sftp（MacOS 或 Linux） 上传到服务器的 /etc/nginx 目录。

  参考：putty教程、sftp教程

  Nginx 配置目录在 /etc/nginx/conf.d，我们在该目录创建 ssl.conf，内容如下：

  server {
      listen 443;
      server_name www.example.com; # 改为绑定证书的域名
      # ssl 配置
      ssl on;
      ssl_certificate 1_www.example.com_bundle.crt; # 改为自己申请得到的 crt 文件的名称
      ssl_certificate_key 2_www.example.com.key; # 改为自己申请得到的 key 文件的名称
      ssl_session_timeout 5m;
      ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
      ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
      ssl_prefer_server_ciphers on;
  
      location / {
          proxy_pass http://127.0.0.1:8765;
      }
  }

  让 Nginx 重新加载配置使其生效

  nginx -s reload

  在浏览器通过 https 的方式访问你解析的域名来测试 HTTPS 是否成功启动

• 在小程序中测试 HTTPS 访问

  打开配套的小程序，点击 实验一：HTTPS，点击 发送请求 来测试访问结果。

5. 小程序会话

小程序不支持 Cookie 存储和跟踪，服务器需要自行实现会话层

• 安装 MongoDB

  使用 Yum 在机器上安装 MongoDB及其客户端命令行工具：

  yum install mongodb-server mongodb -y

  安装结束后，可以使用下面的命令查看安装的版本：

  mongod --version
  mongo --version

• 启动 MongoDB

  创建目录，用于 MongoDB 数据和日志存储：

  mkdir -p /data/mongodb
  mkdir -p /data/logs/mongodb

  创建后，使用下面的命令来启动 MongoDB：

  mongod --fork --dbpath /data/mongodb --logpath /data/logs/mongodb/weapp.log

  可以使用下面的命令来检查是否启动成功

  netstat -ltp | grep 27017

• 添加 MongoDB 用户

  登录本地 MongoDB 服务：

  mongo

  登录后，创建一个用户 weapp ：

  use weapp;
  db.createUser({ user: 'weapp', pwd: 'weapp-dev', roles: ['dbAdmin', 'readWrite']});

  创建完成后，使用 exit 退出命令行工具。

• 安装 Node 模块

  实现小程序的会话功能，我们需要安装 connect-mongo
  和 wafer-node-session

  cd /data/release/weapp
  npm install connect-mongo wafer-node-session --save

• 实现小程序会话

  在工作目录创建配置文件 config.js，用于保存我们服务所用的配置，可参考下面的实现(注：请将参考配置文件中的 YORU_APP_ID 和 YOUR_APP_SECRET 替换为你申请的小程序对应的 AppID 和 AppSecret)：

  module.exports = { 
      serverPort: '8765', 
  
      // 小程序 appId 和 appSecret 
      // 请到 https://mp.weixin.qq.com 获取 AppID 和 AppSecret
      appId: 'YORU_APP_ID', 
      appSecret: 'YOUR_APP_SECRET', 
  
      // mongodb 连接配置，生产环境请使用更复杂的用户名密码
      mongoHost: '127.0.0.1', 
      mongoPort: '27017', 
      mongoUser: 'weapp', 
      mongoPass: 'weapp-dev', 
      mongoDb: 'weapp'
  };

  编辑 app.js，添加会话实现逻辑，可参考下面的代码：

  // 引用 express 来支持 HTTP Server 的实现
  const express = require('express');
  // 引用 wafer-session 支持小程序会话
  const waferSession = require('wafer-node-session'); 
  // 使用 MongoDB 作为会话的存储
  const MongoStore = require('connect-mongo')(waferSession); 
  // 引入配置文件
  const config = require('./config'); 
  
  // 创建一个 express 实例
  const app = express();
  
  // 添加会话中间件，登录地址是 /login
  app.use(waferSession({ 
      appId: config.appId, 
      appSecret: config.appSecret, 
      loginPath: '/login',
      store: new MongoStore({ 
      url: `mongodb://${config.mongoUser}:${config.mongoPass}@${config.mongoHost}:${config.mongoPort}/${config.mongoDb}` 
      }) 
  })); 
  
  // 在路由 /me 下，输出会话里包含的用户信息
  app.use('/me', (request, response, next) => { 
          response.json(request.session ? request.session.userInfo : { noBody: true }); 
      if (request.session) {
          console.log(`Wafer session success with openId=${request.session.userInfo.openId}`);
      }
  }); 
  
  // 实现一个中间件，对于未处理的请求，都输出 "Response from express"
  app.use((request, response, next) => {
      response.write('Response from express');
      response.end();
  });
  
  // 监听端口，等待连接
  app.listen(config.serverPort);
  
  // 输出服务器启动日志
  console.log(`Server listening at http://127.0.0.1:${config.serverPort}`);

  源码编写完成后，重启服务：

  pm2 restart app

  重启后，使用配套的小程序完成会话测试：打开配套小程序 - 点击 实验二：会话 - 获取会话，如果您能看到您的微信头像，那就表示会话已经成功获取了。

6. WebSocket 服务

• 安装 Node 模块

  本实验使用 ws 模块来在服务器上支持 WebSocket 协议，下面使用 NPM 来安装：

  cd /data/release/weapp
  npm install ws --save

• 实现 WebSocket 服务器

  创建 websocket.js，实现 WebSocket 服务，可参考下面的代码：

  // 引入 ws 支持 WebSocket 的实现
  const ws = require('ws');
  
  // 导出处理方法
  exports.listen = listen;
  
  /**
   * 在 HTTP Server 上处理 WebSocket 请求
   * @param {http.Server} server
   * @param {wafer.SessionMiddleware} sessionMiddleware
   */
  function listen(server, sessionMiddleware) {
      // 使用 HTTP Server 创建 WebSocket 服务，使用 path 参数指定需要升级为 WebSocket 的路径
      const wss = new ws.Server({ server, path: '/ws' });
  
      // 监听 WebSocket 连接建立
      wss.on('connection', (ws,request) => {// 要升级到 WebSocket 协议的 HTTP 连接
  
          // 被升级到 WebSocket 的请求不会被 express 处理，
          // 需要使用会话中间节获取会话
          sessionMiddleware(request, null, () => {
              const session = request.session;
              if (!session) {
                  // 没有获取到会话，强制断开 WebSocket 连接
                  ws.send(JSON.stringify(request.sessionError) || "No session avaliable");
                  ws.close();
                  return;
              }
              // 保留这个日志的输出可让实验室能检查到当前步骤是否完成
              console.log(`WebSocket client connected with openId=${session.userInfo.openId}`);
              serveMessage(ws, session.userInfo);
          });
      });
  
      // 监听 WebSocket 服务的错误
      wss.on('error', (err) => {
              console.log(err);
          });
      }
  
  /**
   * 进行简单的 WebSocket 服务，对于客户端发来的所有消息都回复回去
   */
  function serveMessage(ws, userInfo) {
      // 监听客户端发来的消息
      ws.on('message', (message) => {
          console.log(`WebSocket received: ${message}`);
          ws.send(`Server: Received(${message})`);
      });
  
      // 监听关闭事件
      ws.on('close', (code, message) => {
          console.log(`WebSocket client closed (code: ${code}, message: ${message || 'none'})`);
      });
  
      // 连接后马上发送 hello 消息给会话对应的用户
      ws.send(`Server: 恭喜，${userInfo.nickName}`);
  }

  编辑 app.js，调用 WebSocket 服务，可参考下面代码：

  // HTTP 模块同时支持 Express 和 WebSocket
  const http = require('http'); 
  // 引用 express 来支持 HTTP Server 的实现
  const express = require('express');
  // 引用 wafer-session 支持小程序会话
  const waferSession = require('wafer-node-session'); 
  // 使用 MongoDB 作为会话的存储
  const MongoStore = require('connect-mongo')(waferSession); 
  // 引入配置文件
  const config = require('./config'); 
  // 引入 WebSocket 服务实现
  const websocket = require('./websocket');
  
  // 创建一个 express 实例
  const app = express();
  
  // 独立出会话中间件给 express 和 ws 使用
  const sessionMiddleware = waferSession({
      appId: config.appId,
      appSecret: config.appSecret,
      loginPath: '/login',
      store: new MongoStore({
          url: `mongodb://${config.mongoUser}:${config.mongoPass}@${config.mongoHost}:${config.mongoPort}/${config.mongoDb}`
      })
  });
  app.use(sessionMiddleware);
  
  // 在路由 /me 下，输出会话里包含的用户信息
  app.use('/me', (request, response, next) => { 
      response.json(request.session ? request.session.userInfo : { noBody: true }); 
      if (request.session) {
          console.log(`Wafer session success with openId=${request.session.userInfo.openId}`);
      }
  }); 
  
  // 实现一个中间件，对于未处理的请求，都输出 "Response from express"
  app.use((request, response, next) => {
      response.write('Response from express');
      response.end();
  });
  
  // 创建 HTTP Server 而不是直接使用 express 监听
  const server = http.createServer(app);
  
  // 让 WebSocket 服务在创建的 HTTP 服务器上监听
  websocket.listen(server, sessionMiddleware);
  
  // 启动 HTTP 服务
  server.listen(config.serverPort);
  
  // 输出服务器启动日志
  console.log(`Server listening at http://127.0.0.1:${config.serverPort}`);

  重启服务

  pm2 restart app

• 更新 Nginx 代理

  编辑 Nginx 配置 ssl.conf，添加 WebSocket 支持，可参考下面的配置(注：请将参考配置文件中的 www.example.com 替换为前面步骤申请的域名，将 1_www.example.com.crt 和 2_www.example.com.key 替换为前面步骤申请并上传的 SSL 证书的名称)：

  
  # WebSocket 配置
  
  map $http_upgrade $connection_upgrade {
      default upgrade;
      ''      close;
  }
  
  server {
      listen 443;
      server_name www.example.com; # 改为绑定证书的域名
      # ssl 配置
      ssl on;
      ssl_certificate 1_www.example.com.crt; # 改为自己申请得到的 crt 文件的名称
      ssl_certificate_key 2_www.example.com.key; # 改为自己申请得到的 key 文件的名称
      ssl_session_timeout 5m;
      ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
      ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
      ssl_prefer_server_ciphers on;
  
      # WebSocket 配置
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection $connection_upgrade;
  
      location / {
          proxy_pass http://127.0.0.1:8765;
      }
  }

  通知 Nginx 进程重新加载配置：

  nginx -s reload

• 测试 WebSocket

  打开配套的小程序，点击 实验三：WebSocket。进入测试页面后，点击 连接 按钮，如果出现连接成功的提示，表示 WebSocket 服务已经正常运行，可以收发消息。

7. 剪刀石头布小游戏

• 实现游戏房间逻辑

  创建 /data/release/weapp/game 目录用于存放剪刀石头布小游戏的代码

  mkdir -p /data/release/weapp/game

  添加 game/Room.js 实现游戏房间逻辑，可参考下面的代码：

  /**
  enum GameChoice {
      // 剪刀
      Scissors = 1,
      // 石头
      Rock = 2,
      // 布
      Paper = 3
  }
  */
  function judge(choice1, choice2) {
      // 和局
      if (choice1 == choice2) return 0;
      // Player 1 没出，Player 2 胜出
      if (!choice1) return 1;
      // Player 2 没出，Player 1 胜出
      if (!choice2) return -1;
      // 都出了就这么算
      return (choice1 - choice2 + 3) % 3 == 1 ? -1 : 1;
  }
  
  /** @type {Room[]} */
  const globalRoomList = [];
  
  // 每个房间最多两人
  const MAX_ROOT_MEMBER = 2;
  
  // 游戏时间，单位秒
  const GAME_TIME = 3;
  
  let nextRoomId = 0;
  
  /** 表示一个房间 */
  module.exports = class Room {
  
      /** 获取所有房间 */
      static all() {
          return globalRoomList.slice();
      }
  
      /** 获取有座位的房间 */
      static findRoomWithSeat() {
          return globalRoomList.find(x => !x.isFull());
      }
  
      /** 创建新房间 */
      static create() {
          const room = new Room();
          globalRoomList.unshift(room);
          return room;
      }
  
      constructor() {
          this.id = `room${nextRoomId++}`;
          this.players = [];
      }
  
      /** 添加玩家 */
      addPlayer(player) {
          const { uid, uname } = player.user;
          console.log(`Player ${uid}(${uname}) enter ${this.id}`);
          this.players.push(player);
          if (this.isFull()) {
              this.startGame();
          }
      }
  
      /** 删除玩家 */
      removePlayer(player) {
          const { uid, uname } = player.user;
          console.log(`Player ${uid}(${uname}) leave ${this.id}`);
          const playerIndex = this.players.indexOf(player);
          if (playerIndex != -1) {
              this.players.splice(playerIndex, 1);
          }
          if (this.players.length === 0) {
              console.log(`Room ${this.id} is empty now`);
              const roomIndex = globalRoomList.indexOf(this);
              if (roomIndex > -1) {
                  globalRoomList.splice(roomIndex, 1);
              }
          }
      }
  
      /** 玩家已满 */
      isFull() {
          return this.players.length == MAX_ROOT_MEMBER;
      }
  
      /** 开始游戏 */
      startGame() {
          // 保留这行日志输出可以让实验室检查到实验的完成情况
          console.log('game started!');
  
          // 当局积分清零
          this.players.forEach(player => player.gameData.roundScore = 0);
  
          // 集合玩家用户和游戏数据
          const players = this.players.map(player => Object.assign({}, player.user, player.gameData));
  
          // 通知所有玩家开始
          for (let player of this.players) {
              player.send('start', {
                  gameTime: GAME_TIME,
                  players
              });
          }
  
          // 计时结束
          setTimeout(() => this.finishGame(), GAME_TIME * 1000);
      }
  
      /** 结束游戏 */
      finishGame() {
          const players = this.players;
  
          // 两两对比算分
          for (let i = 0; i < MAX_ROOT_MEMBER; i++) {
              let p1 = players[i];
              if (!p1) break;
              for (let j = i + 1; j < MAX_ROOT_MEMBER; j++) {
                  let p2 = players[j];
                  const result = judge(p1.gameData.choice, p2.gameData.choice);
                  p1.gameData.roundScore -= result;
                  p2.gameData.roundScore += result;
              }
          }
          // 计算连胜奖励
          for (let player of players) {
              const gameData = player.gameData;
              // 胜局积分
              if (gameData.roundScore > 0) {
                  gameData.winStreak++;
                  gameData.roundScore *= gameData.winStreak;
              }
              // 败局清零
              else if (gameData.roundScore < 0) {
                  gameData.roundScore = 0;
                  gameData.winStreak = 0;
              }
              // 累积总分
              gameData.totalScore += gameData.roundScore;
          }
          // 计算结果
          const result = players.map(player => {
              const { uid } = player.user;
              const { roundScore, totalScore, winStreak, choice } = player.gameData;
              return { uid, roundScore, totalScore, winStreak, choice };
          });
          // 通知所有玩家游戏结果
          for (let player of players) {
              player.send('result', { result });
          }
      }
  }

• 实现玩家逻辑

  添加 game/Player.js 实现玩家逻辑，可参考下面的代码：
  const Room = require(“./Room”);

  /**
   * 表示一个玩家，处理玩家的公共游戏逻辑，消息处理部分需要具体的玩家实现（请参考 ComputerPlayer 和 HumanPlayer）
   */
  module.exports = class Player {
      constructor(user) {
          this.id = user.uid;
          this.user = user;
          this.room = null;
          this.gameData = {
              // 当前的选择（剪刀/石头/布）
              choice: null,
              // 局积分
              roundScore: 0,
              // 总积分
              totalScore: 0,
              // 连胜次数
              winStreak: 0
          };
      }
  
      /**
       * 上线当前玩家，并且异步返回给玩家分配的房间
       */
      online(room) {
          // 处理玩家 'join' 消息
          // 为玩家寻找一个可用的房间，并且异步返回
          this.receive('join', () => {
              if (this.room) {
                  this.room.removePlayer(this);
              }
              room = this.room = room || Room.findRoomWithSeat() || Room.create();
              room.addPlayer(this);
          });
  
          // 处理玩家 'choise' 消息
          // 需要记录玩家当前的选择，并且通知到房间里的其它玩家
          this.receive('choice', ({ choice }) => {
              this.gameData.choice = choice;
              this.broadcast('movement', {
                  uid: this.user.uid,
                  movement: "choice"
              });
          });
  
          // 处理玩家 'leave' 消息
          // 让玩家下线
          this.receive('leave', () => this.offline);
      }
  
      /**
       * 下线当前玩家，从房间离开
       */
      offline() {
          if (this.room) {
              this.room.removePlayer(this);
              this.room = null;
          }
          this.user = null;
          this.gameData = null;
      }
  
      /**
       * 发送指定消息给当前玩家，需要具体子类实现
       * @abstract
       * @param {string} message 消息类型
       * @param {*} data 消息数据
       */
      send(message, data) {
          throw new Error('Not implement: AbstractPlayer.send()');
      }
  
      /**
       * 处理玩家发送的消息，需要具体子类实现
       * @abstract
       * @param {string} message 消息类型
       * @param {Function} handler
       */
      receive(message, handler) {
          throw new Error('Not implement: AbstractPlayer.receive()');
      }
  
      /**
       * 给玩家所在房间里的其它玩家发送消息
       * @param {string} message 消息类型
       * @param {any} data 消息数据
       */
      broadcast(message, data) {
          if (!this.room) return;
          this.others().forEach(neighbor => neighbor.send(message, data));
      }
  
      /**
       * 获得玩家所在房间里的其他玩家
       */
      others() {
          return this.room.players.filter(player => player != this);
      }
  }

• 实现电脑玩家

  在实现人类玩家之前，我们先来创建 ComputerPlayer.js 来实现电脑玩家

  const EventEmitter = require('events');
  const Player = require('./Player');
  
  let nextComputerId = 0;
  
  /**
   * 机器人玩家实现，使用 EventEmitter 接收和发送消息
   */
  module.exports = class ComputerPlayer extends Player {
      constructor() {
          const computerId = `robot-${++nextComputerId}`;
          super({
              uid: computerId,
              uname: computerId,
              uavatar: 'http://www.scoutiegirl.com/wp-content/uploads/2015/06/Blue-Robot.png'
          });
          this.emitter = new EventEmitter();
      }
  
      /**
       * 模拟玩家行为
       */
      simulate() {
          this.receive('start', () => this.play());
          this.receive('result', () => this.stop());
          this.send('join');
      }
  
      /**
       * 游戏开始后，随机时间后随机选择
       */
      play() {
          this.playing = true;
          const randomTime = () => Math.floor(100 + Math.random() * 2000);
          const randomChoice = () => {
              if (!this.playing) return;
              this.send("choice", {
                  choice: Math.floor(Math.random() * 10000) % 3 + 1
              });
              setTimeout(randomChoice, randomTime());
          }
          setTimeout(randomChoice, 10);
      }
  
      /**
       * 游戏结束后，标记起来，阻止继续随机选择
       */
      stop() {
          this.playing = false;
      }
  
      /**
       * 发送消息给当前玩家，直接转发到 emitter
       */
      send(message, data) {
          this.emitter.emit(message, data);
      }
  
      /**
       * 从当前的 emitter 处理消息
       */
      receive(message, handle) {
          this.emitter.on(message, handle);
      }
  }

• 实现人类玩家

  人类玩家通过 WebSocket 信道来实现玩家的输入输出
  ，我们需要添加 game/Tunnel.js 和 game/HumanPlayer.js 来实现人类玩家逻辑，可参考下面的代码：

  Tunnel.js

  const EventEmitter = require('events');
  
  /**
   * 封装 WebSocket 信道
   */
  module.exports = class Tunnel {
      constructor(ws) {
          this.emitter = new EventEmitter();
          this.ws = ws;
          ws.on('message', packet => {
              try {
                  // 约定每个数据包格式：{ message: 'type', data: any }
                  const { message, data } = JSON.parse(packet);
                  this.emitter.emit(message, data);
              } catch (err) {
                  console.log('unknown packet: ' + packet);
              }
          });
      }
  
      on(message, handle) {
          this.emitter.on(message, handle);
      }
  
      emit(message, data) {
          this.ws.send(JSON.stringify({ message, data }));
      }
  }

  HumanPlayer.js

  const co = require('co');
  const Player = require('./Player');
  const ComputerPlayer = require('./ComputerPlayer');
  const Tunnel = require('./Tunnel');
  
  /**
   * 人类玩家实现，通过 WebSocket 信道接收和发送消息
   */
  module.exports = class HumanPlayer extends Player {
      constructor(user, ws) {
          super(user);
          this.ws = ws;
          this.tunnel = new Tunnel(ws);
          this.send('id', user);
      }
  
      /**
       * 人类玩家上线后，还需要监听信道关闭，让玩家下线
       */
      online(room) {
          super.online(room);
          this.ws.on('close', () => this.offline());
  
          // 人类玩家请求电脑玩家
          this.receive('requestComputer', () => {
              const room = this.room;
              while(room && !room.isFull()) {
                  const computer = new ComputerPlayer();
                  computer.online(room);
                  computer.simulate();
              }
          });
      }
  
      /**
       * 下线后关闭信道
       */
      offline() {
          super.offline();
          if (this.ws && this.ws.readyState == this.ws.OPEN) {
              this.ws.close();
          }
          this.ws = null;
          this.tunnel = null;
          if (this.room) {
              // 清理房间里面的电脑玩家
              for (let player of this.room.players) {
                  if (player instanceof ComputerPlayer) {
                      this.room.removePlayer(player);
                  }
              }
              this.room = null;
          }
      }
  
      /**
       * 通过 WebSocket 信道发送消息给玩家
       */
      send(message, data) {
          this.tunnel.emit(message, data);
      }
  
      /**
       * 从 WebSocket 信道接收玩家的消息
       */
      receive(message, callback) {
          this.tunnel.on(message, callback);
      }
  }

• 添加游戏服务入口

  游戏的实现已经完成了，接下来，编辑 websocket.js 添加服务入口，可参考下面的代码：

  // 引入 url 模块用于解析 URL
  const url = require('url');
  // 引入 ws 支持 WebSocket 的实现
  const ws = require('ws');
  // 引入人类玩家
  const HumanPlayer = require('./game/HumanPlayer');
  
  // 导出处理方法
  exports.listen = listen;
  
  /**
   * 在 HTTP Server 上处理 WebSocket 请求
   * @param {http.Server} server
   * @param {wafer.SessionMiddleware} sessionMiddleware
   */
  function listen(server, sessionMiddleware) {
      // 使用 HTTP Server 创建 WebSocket 服务，使用 path 参数指定需要升级为 WebSocket 的路径
      const wss = new ws.Server({ server });
  
      // 同时支持 /ws 和 /game 的 WebSocket 连接请求 
      wss.shouldHandle = (request) => { 
          const path = url.parse(request.url).pathname; 
          request.path = path; 
          return ['/ws', '/game'].indexOf(path) > -1; 
      }; 
  
      // 监听 WebSocket 连接建立
      wss.on('connection', (ws, request) => {
          // request: 要升级到 WebSocket 协议的 HTTP 连接
  
          // 被升级到 WebSocket 的请求不会被 express 处理，
          // 需要使用会话中间节获取会话
          sessionMiddleware(request, null, () => {
              const session = request.session;
              if (!session) {
                  // 没有获取到会话，强制断开 WebSocket 连接
                  ws.send(JSON.stringify(request.sessionError) || "No session avaliable");
                  ws.close();
                  return;
              }
              console.log(`WebSocket client connected with openId=${session.userInfo.openId}`);
  
              // 根据请求的地址进行不同处理 
              switch (request.path) { 
                  case '/ws': return serveMessage(ws, session.userInfo); 
                  case '/game': return serveGame(ws, session.userInfo); 
                  default: return ws.close();
              }
          });
      });
  
      // 监听 WebSocket 服务的错误
      wss.on('error', (err) => {
          console.log(err);
      });
  }
  
  /**
   * 进行简单的 WebSocket 服务，对于客户端发来的所有消息都回复回去
   */
  function serveMessage(ws, userInfo) {
      // 监听客户端发来的消息
      ws.on('message', (message) => {
          console.log(`WebSocket received: ${message}`);
          ws.send(`Server: Received(${message})`);
      });
  
      // 监听关闭事件
      ws.on('close', (code, message) => {
          console.log(`WebSocket client closed (code: ${code}, message: ${message || 'none'})`);
      });
  
      // 连接后马上发送 hello 消息给会话对应的用户
      ws.send(`Server: 恭喜，${userInfo.nickName}`);
  }
  
  /**
   * 使用 WebSocket 进行游戏服务
   */
  function serveGame(ws, userInfo) {
      const user = { 
          uid: userInfo.openId, 
          uname: userInfo.nickName, 
          uavatar: userInfo.avatarUrl 
      }; 
      // 创建玩家 
      const player = new HumanPlayer(user, ws); 
      // 玩家上线
      player.online();
  }

• 安装 co 模块

  我们的源码中使用到了 co 进行协程管理，启动游戏服务前，需要先安装：

  cd /data/release/weapp
  npm install co --save

• 测试游戏服务

  重启 Node 服务：

  pm2 restart app

  打开配套的小程序，点击 实验四 - 剪刀石头布小游戏，点击 开始 按钮进行游戏。

• 测试完成