基于腾讯云的微信小程序搭建

准备域名和证书

  • 域名注册0
    如果您还没有域名,可以在腾讯云上选购,过程可以参考下面的视频。
     
    域名解析0
    域名购买完成后, 需要将域名解析到实验云主机上,实验云主机的 IP 为:
    139.199.199.225
    在腾讯云购买的域名,可以到控制台添加解析记录,过程可参考下面的视频:
    域名设置解析后需要过一段时间才会生效,通过 ping 命令检查域名是否生效 
     
    ,如:
    ping www.yourmpdomain.com
    如果 ping 命令返回的信息中含有你设置的解析的 IP 地址,说明解析成功。
     
    申请 SSL 证书0
    腾讯云提供了 SSL 证书的免费申请,申请方式可参考下面视频:
    申请提交后,审批结果会以短信的形式通知。审批通过后,可以到 SSL 控制台下载您的证书文件,可参考下面的视频:

     

    搭建小程序开发环境

    • 注册开发者账号0
      如果你还不是小程序开发者,请先在微信公众平台并注册:
      https://mp.weixin.qq.com
      具体注册流程可参考如下视频:
      若您已注册,请点击下一步。
    • 配置小程序服务器信息0
      登录微信公众平台后,依次进入 设置 - 开发设置 - 服务器域名 - 修改
      扫码完成身份校验后,request 合法域名和 socket 合法域名均填写在上一步准备好的域名地址。
      配置完成后,点击 保存并提交。您可以点击如下视频查看如何进行配置:
    • 运行配套小程序代码0
      要运行本实验配套的小程序代码,请下载下列资源:
      源码下载后,请解压到本地工作目录。
      开发工具下载后,请安装并启动,然后用微信扫码登录。
      登录后,选择 本地小程序项目 - 添加项目,使用以下配置:
      • AppID:填写小程序的 AppID,请登录公众平台后在 设置开发设置 - 开发者 ID 中查看
      • 项目名称:填写任意您喜欢的名称
      • 项目目录:选择刚才解压的配套源码目录(目录包含 app.js
      填写完成后,点击 添加项目。具体操作可查看如下视频:
    • 设置实验域名0
      在开发工具的 编辑 面板中,选中 app.js 进行编辑,需要修改小程序通信域名
       
      ,请参考下面的配置:
      App({
          config: {
              host: ‘‘ // 这个地方填写你的域名
          },
          onLaunch () {
              console.log(‘App.onLaunch()‘);
          }
      });
      当然,这步操作也录制了对应的视频:

       

       

      搭建 HTTP 服务

      • 安装 NodeJS 和 NPM0
        使用下面的命令安装 NodeJS 和 NPM
        curl --silent --location https://rpm.nodesource.com/setup_8.x | sudo bash -
        yum install nodejs -y
        安装完成后,使用下面的命令测试安装结果
        node -v
      • 编写 HTTP Server 源码0

        创建工作目录

        使用下面的命令在服务器创建一个工作目录:
        mkdir -p /data/release/weapp
        进入此工作目录
        cd /data/release/weapp

        创建 package.json

        在刚才创建的工作目录创建 package.json,添加我们服务器包的名称和版本号,可参考下面的示例。
        完成后,使用 Ctrl + S 保存文件

        添加 Server 源码

        在工作目录创建 app.js,使用 Express.js 来监听 8765 端口
         
        ,可参考下面的示例代码。
      • 运行 HTTP 服务0

        安装 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://139.199.199.225:8765运行
        要查看服务输出的日志,可以使用下面的命令:
        pm2 logs
        如果要重启服务,可以使用下面的命令:
        pm2 restart app


        搭建 HTTPS 服务

        • 安装 Nginx0
          在 CentOS 上,可直接使用 yum 来安装 Nginx
          yum install nginx -y
          安装完成后,使用 nginx 命令启动 Nginx:
          nginx
          此时,访问 http://139.199.199.225 可以看到 Nginx 的测试页面 
           
        • 配置 HTTPS 反向代理0
          外网用户访问服务器的 Web 服务由 Nginx 提供,Nginx 需要配置反向代理才能使得 Web 服务转发到本地的 Node 服务。
          先将之前下载的 SSL 证书(解压后 Nginx 目录分别以 crt 和 key 作为后缀的文件)通过拖动到左侧文件
          浏览器/etc/nginx目录的方式来上传文件到服务器上
          Nginx 配置目录在 /etc/nginx/conf.d,我们在该目录创建 ssl.conf
          按 Ctrl + S 保存配置文件,让 Nginx 重新加载配置使其生效:
          nginx -s reload
          在浏览器通过 https 的方式访问你解析的域名来测试 HTTPS 是否成功启动
        • 在小程序中测试 HTTPS 访问0
          打开配套的小程序,点击 实验一:HTTPS,点击 发送请求 来测试访问结果。
          如果服务器响应成功,请点击下一步。
           
           
           

          小程序会话

          • 安装 MongoDB0
            使用 Yum 在机器上安装 
            MongoDB
             
             及其客户端命令行工具:
            yum install mongodb-server mongodb -y
            安装结束后,可以使用下面的命令查看安装的版本:
            mongod --version
            mongo --version
          • 启动 MongoDB0
            创建目录,用于 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 用户0
            登录本地 MongoDB 服务:
            mongo
            登录后,创建一个用户 weapp 
             
            use weapp;
            db.createUser({ user: ‘weapp‘, pwd: ‘weapp-dev‘, roles: [‘dbAdmin‘, ‘readWrite‘]});
            创建完成后,使用 exit 退出命令行工具。
          • 安装 Node 模块0
            实现小程序的会话功能,我们需要安装 
            connect-mongo
             
             和 
            wafer-node-session
             
            cd /data/release/weapp
            npm install connect-mongo wafer-node-session --save
          • 实现小程序会话0
            在工作目录创建配置文件 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
            重启后,使用配套的小程序完成会话测试:打开配套小程序 - 点击 实验二:会话 - 获取会话
            如果您能看到您的微信头像,那就表示会话已经成功获取了。
             

            WebSocket 服务

            • 安装 Node 模块0
              本实验使用 ws 模块来在服务器上支持 WebSocket 协议,下面使用 NPM 来安装:
              cd /data/release/weapp
              npm install ws --save
            • 实现 WebSocket 服务器0
              创建 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}`);

               

               
              修改完成后,按 Ctrl + S 保存文件,并重启服务:
              pm2 restart app
            • 更新 Nginx 代理0
              编辑 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;
              }
              }

               

               
              配置完成后,按 Ctrl + S 保存,并且通知 Nginx 进程重新加载配置:
              nginx -s reload
            • 测试 WebSocket0
              打开配套的小程序,点击 实验三:WebSocket。进入测试页面后,点击 连接 按钮,
              如果出现连接成功的提示,表示 WebSocket 服务已经正常运行,可以收发消息。
               
               

              剪刀石头布小游戏

              • 实现游戏房间逻辑0
                创建 /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 });
                }
                }
                }

                 

                 
              • 实现玩家逻辑0
                添加 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);
                }
                }

                 
              • 实现电脑玩家0
                在实现人类玩家之前,我们先来创建 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);
                }
                }

                 
              • 实现人类玩家0
                人类玩家通过 WebSocket 信道来实现玩家的输入输出
                 
                ,我们需要添加 game/Tunnel.js 和 game/HumanPlayer.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 }));
                }
                }

                 

                 

                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);
                }
                }

                 
              • 添加游戏服务入口0
                游戏的实现已经完成了,接下来,编辑 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 模块0
                我们的源码中使用到了 co 进行协程管理,启动游戏服务前,需要先安装:
                cd /data/release/weapp
                npm install co --save
              • 测试游戏服务0
                重启 Node 服务:
                pm2 restart app
                打开配套的小程序,点击 实验四 - 剪刀石头布小游戏,点击 开始 按钮进行游戏。
              • 完成实验0
                恭喜!您已经完成了小程序服务的全部实验内容!你可以选择保留已经运行的服务,继续进行小程序的学习研究,建议留用机器。
             
             


       

     
     
     
     


基于腾讯云的微信小程序搭建

上一篇:用linux文件处理三剑客将微信群成员导出的方法


下一篇:Java程序员如何正确地学习新的知识,拓展自己的技术栈