基于 CentOS 搭建微信小程序服务教程-云服务器玩法在线实验

云计算分享家 · 发表于 2020-4-7 15:13:21

实验内容小程序无疑是今年互联网的重大热点。本实验带您从零开始，基于 NodeJS 搭建起一个可以支撑小程序运行的服务，包括 HTTPS 部署、会话服务、WebSocket 服务，最后利用这些服务实现一个实时的剪刀石头布小游戏。

首次可免费使用云主机 3 小时，到期后云主机将被重置并退库，若想保留成果请及时留用。

免费在线实验地址：点击进入
实验资源：云服务器，没有云服务器的朋友推荐1折抢购：69元/年的阿里云服务器、或者99元/年的腾讯云服务器

软件环境CentOS 7.2 64 位

一、准备域名和证书
小程序后台服务需要通过 HTTPS 访问，在实验开始之前，我们要准备域名和 SSL 证书。推荐：万网域名、阿里云SSL证书、腾讯云SSL证书
域名购买完成后, 需要将域名解析到实验云主机上，实验云主机的 IP 为：

<您的 CVM IP 地址>

复制代码

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

ping www.yourmpdomain.com

复制代码

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

注意替换下面命令中的 www.yourmpdomain.com 为您自己的注册的域名

复制代码

二、搭建小程序开发环境在开始搭建我们的小程序服务器之前，需要先完成客户端小程序开发环境的搭建。
注册开发者账号
如果你还不是小程序开发者，请先在微信公众平台并注册：

https://mp.weixin.qq.com

复制代码

配置小程序服务器信息
登录微信公众平台后，依次进入设置 - 开发设置 - 服务器域名 - 修改。
扫码完成身份校验后，request 合法域名和 socket 合法域名均填写在上一步准备好的域名地址。
配置完成后，点击保存并提交。

运行配套小程序代码

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

实验配套源码
微信小程序开发工具
源码下载后，请解压到本地工作目录。开发工具下载后，请安装并启动，然后用微信扫码登录。登录后，选择本地小程序项目 - 添加项目，使用以下配置：AppID：填写小程序的 AppID，请登录公众平台后在设置 - 开发设置 - 开发者 ID 中查看项目名称：填写任意您喜欢的名称项目目录：选择刚才解压的配套源码目录（目录包含 app.js）填写完成后，点击添加项目。
设置实验域名在开发工具的编辑面板中，选中 app.js 进行编辑，需要修改小程序通信域名，请参考下面的配置：
1. App({
2. config: {
3. host: '' // 这个地方填写你的域名
4. },
5. onLaunch () {
6. console.log('App.onLaunch()');
7. }
8. });
复制代码
三、搭建 HTTP 服务下面的步骤，将带大家在服务器上使用 Node 和 Express 搭建一个 HTTP 服务器安装 NodeJS 和 NPM使用下面的命令安装 NodeJS 和 NPM
1. curl --silent --location [url]https://rpm.nodesource.com/setup_8.x[/url] | sudo bash -
2. yum install nodejs -y
复制代码
安装完成后，使用下面的命令测试安装结果
1. node -v
复制代码
编写 HTTP Server 源码创建工作目录使用下面的命令在服务器创建一个工作目录：
1. mkdir -p /data/release/weapp
复制代码
进入此工作目录
1. cd /data/release/weapp
复制代码
创建 package.json在刚才创建的工作目录创建 package.json，添加我们服务器包的名称和版本号，可参考下面的示例。
示例代码：/data/release/weapp/package.json
1. {
2. "name": "weapp",
3. "version": "1.0.0"
4. }
复制代码
完成后，使用 Ctrl + S 保存文件
添加 Server 源码在工作目录创建 app.js，使用 Express.js 来监听 8765 端口，可参考下面的示例代码。
示例代码：/data/release/weapp/app.js
1. // 引用 express 来支持 HTTP Server 的实现
2. const express = require('express');
4. // 创建一个 express 实例
5. const app = express();
7. // 实现唯一的一个中间件，对于所有请求，都输出 "Response from express"
8. app.use((request, response, next) => {
9. response.write('Response from express');
10. response.end();
11. });
13. // 监听端口，等待连接
14. const port = 8765;
15. app.listen(port);
17. // 输出服务器启动日志
18. console.log(`Server listening at [url]http://127.0.0.1:[/url]${port}`);
复制代码
1. 本实验会以 8765 端口的打开作为实验步骤完成的依据，为了后面的实验步骤顺利进行，请不要使用其它端口号
复制代码
运行 HTTP 服务安装 PM2在开始之前，我们先来安装
1. npm install pm2 --global
复制代码
PM2 安装时间可能稍长，请耐心等候安装 Express我们的服务器源码里使用到了 Express 模块，下面的命令使用 NPM 来安装 Express
1. cd /data/release/weapp
2. npm install express --save
复制代码
启动服务安装完成后，使用 PM2 来启动 HTTP 服务
1. cd /data/release/weapp
2. pm2 start app.js
复制代码
现在，您的 HTTP 服务已经在 http://<您的 CVM IP 地址>:8765 运行
要查看服务输出的日志，可以使用下面的命令：
1. pm2 logs
复制代码
如果要重启服务，可以使用下面的命令：
1. pm2 restart app
复制代码
我们使用 PM2 来进行 Node 进程的运行、监控和管理
NPM 仓库在国内访问速度可能不太理想，如果实在太慢可以尝试使用 CNPM 的 Registry 进行安装：
1. npm install pm2 -g --registry=https://r.cnpmjs.org/
复制代码
四、搭建 HTTPS 服务微信小程序要求和服务器的通信都通过 HTTPS 进行
安装 Nginx在 CentOS 上，可直接使用 yum 来安装 Nginx
1. yum install nginx -y
复制代码
安装完成后，使用 nginx 命令启动 Nginx：
1. nginx
复制代码
此时，访问 http://<您的域名> 可以看到 Nginx 的测试页面如果无法访问，请重试用 nginx -s reload 命令重启 Nginx
配置 HTTPS 反向代理外网用户访问服务器的 Web 服务由 Nginx 提供，Nginx 需要配置反向代理才能使得 Web 服务转发到本地的 Node 服务。先将之前下载的 SSL 证书(解压后 Nginx 目录分别以 crt 和 key 作为后缀的文件)通过拖动到左侧文件浏览器/etc/nginx目录的方式来上传文件到服务器上如何上传 SSL 证书到 /etc/nginx 目录Nginx 配置目录在 /etc/nginx/conf.d，我们在该目录创建 ssl.conf示例代码：/etc/nginx/conf.d/ssl.conf
1. server {
2. listen 443;
3. server_name www.example.com; # 改为绑定证书的域名
4. # ssl 配置
5. ssl on;
6. ssl_certificate 1_www.example.com_bundle.crt; # 改为自己申请得到的 crt 文件的名称
7. ssl_certificate_key 2_www.example.com.key; # 改为自己申请得到的 key 文件的名称
8. ssl_session_timeout 5m;
9. ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
10. ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
11. ssl_prefer_server_ciphers on;
13. location / {
14. proxy_pass http://127.0.0.1:8765;
15. }
16. }
复制代码
按 Ctrl + S 保存配置文件，让 Nginx 重新加载配置使其生效：
1. nginx -s reload
复制代码
在浏览器通过 https 的方式访问你解析的域名来测试 HTTPS 是否成功启动在小程序中测试 HTTPS 访问打开配套的小程序，点击实验一：HTTPS，点击发送请求来测试访问结果。如果服务器响应成功，请点击下一步。
五、小程序会话小程序不支持 Cookie 存储和跟踪，服务器需要自行实现会话层
安装 MongoDB使用 Yum 在机器上安装 [MongoDB] 及其客户端命令行工具：
1. yum install mongodb-server mongodb -y
复制代码
安装结束后，可以使用下面的命令查看安装的版本：
1. mongod --version
2. mongo --version
复制代码
MongoDB 是一款 NoSQL 数据库，支持 JSON 格式的结构化文档存储和查询，对 JavaScript 有着友好的支持
启动 MongoDB创建目录，用于 MongoDB 数据和日志存储：
1. mkdir -p /data/mongodb
2. mkdir -p /data/logs/mongodb
复制代码
创建后，使用下面的命令来启动 MongoDB：
1. mongod --fork --dbpath /data/mongodb --logpath /data/logs/mongodb/weapp.log
复制代码
可以使用下面的命令来检查是否启动成功
1. netstat -ltp | grep 27017
复制代码
MongoDB 首次启动可能会花费大概 1min 时间，请耐心等待MongoDB 默认监听 27017 端口等待连接，下面的命令查看当前 27017 端口被哪个进程占用，如果是 MongoDB 的进程，则表示启动成功。
添加 MongoDB 用户登录本地 MongoDB 服务：
1. mongo
复制代码
登录后，创建一个用户 weapp
1. use weapp;
2. db.createUser({ user: 'weapp', pwd: 'weapp-dev', roles: ['dbAdmin', 'readWrite']});
复制代码
创建完成后，使用 exit 退出命令行工具。创建的用户和密码将用于下一步中连接数据库时使用，如果使用不同的用户或密码，注意要保存好
安装 Node 模块实现小程序的会话功能，我们需要安装 [connect-mongo] 和 [wafer-node-session]
1. cd /data/release/weapp
2. npm install connect-mongo wafer-node-session --save
复制代码
connect-mongo 模块通过连接到 MongoDB 为会话提供存储wafer-node-session 是由腾讯云提供的独立小程序会话管理中间件
实现小程序会话在工作目录创建配置文件 config.js，用于保存我们服务所用的配置，可参考下面的实现(注：请将参考配置文件中的 YORU_APP_ID 和 YOUR_APP_SECRET 替换为你申请的小程序对应的 AppID 和 AppSecret)：
示例代码：/data/release/weapp/config.js
1. module.exports = {
2. serverPort: '8765',
4. // 小程序 appId 和 appSecret
5. // 请到 https://mp.weixin.qq.com 获取 AppID 和 AppSecret
6. appId: 'YORU_APP_ID',
7. appSecret: 'YOUR_APP_SECRET',
9. // mongodb 连接配置，生产环境请使用更复杂的用户名密码
10. mongoHost: '127.0.0.1',
11. mongoPort: '27017',
12. mongoUser: 'weapp',
13. mongoPass: 'weapp-dev',
14. mongoDb: 'weapp'
15. };
复制代码
编辑 app.js，添加会话实现逻辑，可参考下面的代码：
示例代码：/data/release/weapp/app.js
1. // 引用 express 来支持 HTTP Server 的实现
2. const express = require('express');
3. // 引用 wafer-session 支持小程序会话
4. const waferSession = require('wafer-node-session');
5. // 使用 MongoDB 作为会话的存储
6. const MongoStore = require('connect-mongo')(waferSession);
7. // 引入配置文件
8. const config = require('./config');
10. // 创建一个 express 实例
11. const app = express();
13. // 添加会话中间件，登录地址是 /login
14. app.use(waferSession({
15. appId: config.appId,
16. appSecret: config.appSecret,
17. loginPath: '/login',
18. store: new MongoStore({
19. url: `mongodb://${config.mongoUser}:${config.mongoPass}@${config.mongoHost}:${config.mongoPort}/${config.mongoDb}`
20. })
21. }));
23. // 在路由 /me 下，输出会话里包含的用户信息
24. app.use('/me', (request, response, next) => {
25. response.json(request.session ? request.session.userInfo : { noBody: true });
26. if (request.session) {
27. console.log(`Wafer session success with openId=${request.session.userInfo.openId}`);
28. }
29. });
31. // 实现一个中间件，对于未处理的请求，都输出 "Response from express"
32. app.use((request, response, next) => {
33. response.write('Response from express');
34. response.end();
35. });
37. // 监听端口，等待连接
38. app.listen(config.serverPort);
40. // 输出服务器启动日志
41. console.log(`Server listening at http://127.0.0.1:${config.serverPort}`);
复制代码
源码编写完成后，重启服务：
1. pm2 restart app
复制代码
重启后，使用配套的小程序完成会话测试：打开配套小程序 - 点击实验二：会话 - 获取会话，如果您能看到您的微信头像，那就表示会话已经成功获取了。随着服务变得复杂，我们可以把配置集中起来方便管理，比如目前我们需要保存：服务器运行端口、小程序配置、MongoDB 连接配置
六、WebSocket 服务安装 Node 模块本实验使用 ws 模块来在服务器上支持 WebSocket 协议，下面使用 NPM 来安装：
1. cd /data/release/weapp
2. npm install ws --save
复制代码
实现 WebSocket 服务器创建 websocket.js，实现 WebSocket 服务，可参考下面的代码：
示例代码：/data/release/weapp/websocket.js
1. // 引入 ws 支持 WebSocket 的实现
2. const ws = require('ws');
4. // 导出处理方法
5. exports.listen = listen;
7. /**
8. * 在 HTTP Server 上处理 WebSocket 请求
9. * @param {http.Server} server
10. * @param {wafer.SessionMiddleware} sessionMiddleware
11. */
12. function listen(server, sessionMiddleware) {
13. // 使用 HTTP Server 创建 WebSocket 服务，使用 path 参数指定需要升级为 WebSocket 的路径
14. const wss = new ws.Server({ server, path: '/ws' });
16. // 监听 WebSocket 连接建立
17. wss.on('connection', (ws,request) => {// 要升级到 WebSocket 协议的 HTTP 连接
19. // 被升级到 WebSocket 的请求不会被 express 处理，
20. // 需要使用会话中间节获取会话
21. sessionMiddleware(request, null, () => {
22. const session = request.session;
23. if (!session) {
24. // 没有获取到会话，强制断开 WebSocket 连接
25. ws.send(JSON.stringify(request.sessionError) || "No session avaliable");
26. ws.close();
27. return;
28. }
29. // 保留这个日志的输出可让实验室能检查到当前步骤是否完成
30. console.log(`WebSocket client connected with openId=${session.userInfo.openId}`);
31. serveMessage(ws, session.userInfo);
32. });
33. });
35. // 监听 WebSocket 服务的错误
36. wss.on('error', (err) => {
37. console.log(err);
38. });
39. }
41. /**
42. * 进行简单的 WebSocket 服务，对于客户端发来的所有消息都回复回去
43. */
44. function serveMessage(ws, userInfo) {
45. // 监听客户端发来的消息
46. ws.on('message', (message) => {
47. console.log(`WebSocket received: ${message}`);
48. ws.send(`Server: Received(${message})`);
49. });
51. // 监听关闭事件
52. ws.on('close', (code, message) => {
53. console.log(`WebSocket client closed (code: ${code}, message: ${message || 'none'})`);
54. });
56. // 连接后马上发送 hello 消息给会话对应的用户
57. ws.send(`Server: 恭喜，${userInfo.nickName}`);
58. }
复制代码
编辑 app.js，调用 WebSocket 服务，可参考下面代码：
示例代码：/data/release/weapp/app.js
1. // HTTP 模块同时支持 Express 和 WebSocket
2. const http = require('http');
3. // 引用 express 来支持 HTTP Server 的实现
4. const express = require('express');
5. // 引用 wafer-session 支持小程序会话
6. const waferSession = require('wafer-node-session');
7. // 使用 MongoDB 作为会话的存储
8. const MongoStore = require('connect-mongo')(waferSession);
9. // 引入配置文件
10. const config = require('./config');
11. // 引入 WebSocket 服务实现
12. const websocket = require('./websocket');
14. // 创建一个 express 实例
15. const app = express();
17. // 独立出会话中间件给 express 和 ws 使用
18. const sessionMiddleware = waferSession({
19. appId: config.appId,
20. appSecret: config.appSecret,
21. loginPath: '/login',
22. store: new MongoStore({
23. url: `mongodb://${config.mongoUser}:${config.mongoPass}@${config.mongoHost}:${config.mongoPort}/${config.mongoDb}`
24. })
25. });
26. app.use(sessionMiddleware);
28. // 在路由 /me 下，输出会话里包含的用户信息
29. app.use('/me', (request, response, next) => {
30. response.json(request.session ? request.session.userInfo : { noBody: true });
31. if (request.session) {
32. console.log(`Wafer session success with openId=${request.session.userInfo.openId}`);
33. }
34. });
36. // 实现一个中间件，对于未处理的请求，都输出 "Response from express"
37. app.use((request, response, next) => {
38. response.write('Response from express');
39. response.end();
40. });
42. // 创建 HTTP Server 而不是直接使用 express 监听
43. const server = http.createServer(app);
45. // 让 WebSocket 服务在创建的 HTTP 服务器上监听
46. websocket.listen(server, sessionMiddleware);
48. // 启动 HTTP 服务
49. server.listen(config.serverPort);
51. // 输出服务器启动日志
52. console.log(`Server listening at http://127.0.0.1:${config.serverPort}`);
复制代码
修改完成后，按 Ctrl + S 保存文件，并重启服务：
1. pm2 restart app
复制代码
更新 Nginx 代理
1. 编辑 Nginx 配置 ssl.conf，添加 WebSocket 支持，可参考下面的配置(注：请将参考配置文件中的 www.example.com 替换为前面步骤申请的域名，将 1_www.example.com.crt 和 2_www.example.com.key 替换为前面步骤申请并上传的 SSL 证书的名称)：
复制代码
示例代码：/etc/nginx/conf.d/ssl.conf
1. # WebSocket 配置
2. map $http_upgrade $connection_upgrade {
3. default upgrade;
4. '' close;
5. }
7. server {
8. listen 443;
9. server_name www.example.com; # 改为绑定证书的域名
10. # ssl 配置
11. ssl on;
12. ssl_certificate 1_www.example.com.crt; # 改为自己申请得到的 crt 文件的名称
13. ssl_certificate_key 2_www.example.com.key; # 改为自己申请得到的 key 文件的名称
14. ssl_session_timeout 5m;
15. ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
16. ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
17. ssl_prefer_server_ciphers on;
19. # WebSocket 配置
20. proxy_set_header Upgrade $http_upgrade;
21. proxy_set_header Connection $connection_upgrade;
23. location / {
24. proxy_pass http://127.0.0.1:8765;
25. }
26. }
复制代码
配置完成后，按 Ctrl + S 保存，并且通知 Nginx 进程重新加载配置：
1. nginx -s reload
复制代码
测试 WebSocket打开配套的小程序，点击实验三：WebSocket。进入测试页面后，点击连接按钮，如果出现连接成功的提示，表示 WebSocket 服务已经正常运行，可以收发消息。
七、剪刀石头布小游戏实现游戏房间逻辑创建 /data/release/weapp/game 目录用于存放剪刀石头布小游戏的代码
1. mkdir -p /data/release/weapp/game
复制代码
添加 game/Room.js 实现游戏房间逻辑，可参考下面的代码：
示例代码：/data/release/weapp/game/Room.js
1. /**
2. enum GameChoice {
3. // 剪刀
4. Scissors = 1,
5. // 石头
6. Rock = 2,
7. // 布
8. Paper = 3
9. }
10. */
11. function judge(choice1, choice2) {
12. // 和局
13. if (choice1 == choice2) return 0;
14. // Player 1 没出，Player 2 胜出
15. if (!choice1) return 1;
16. // Player 2 没出，Player 1 胜出
17. if (!choice2) return -1;
18. // 都出了就这么算
19. return (choice1 - choice2 + 3) % 3 == 1 ? -1 : 1;
20. }
22. /** @type {Room[]} */
23. const globalRoomList = [];
25. // 每个房间最多两人
26. const MAX_ROOT_MEMBER = 2;
28. // 游戏时间，单位秒
29. const GAME_TIME = 3;
31. let nextRoomId = 0;
33. /** 表示一个房间 */
34. module.exports = class Room {
36. /** 获取所有房间 */
37. static all() {
38. return globalRoomList.slice();
39. }
41. /** 获取有座位的房间 */
42. static findRoomWithSeat() {
43. return globalRoomList.find(x => !x.isFull());
44. }
46. /** 创建新房间 */
47. static create() {
48. const room = new Room();
49. globalRoomList.unshift(room);
50. return room;
51. }
53. constructor() {
54. this.id = `room${nextRoomId++}`;
55. this.players = [];
56. }
58. /** 添加玩家 */
59. addPlayer(player) {
60. const { uid, uname } = player.user;
61. console.log(`Player ${uid}(${uname}) enter ${this.id}`);
62. this.players.push(player);
63. if (this.isFull()) {
64. this.startGame();
65. }
66. }
68. /** 删除玩家 */
69. removePlayer(player) {
70. const { uid, uname } = player.user;
71. console.log(`Player ${uid}(${uname}) leave ${this.id}`);
72. const playerIndex = this.players.indexOf(player);
73. if (playerIndex != -1) {
74. this.players.splice(playerIndex, 1);
75. }
76. if (this.players.length === 0) {
77. console.log(`Room ${this.id} is empty now`);
78. const roomIndex = globalRoomList.indexOf(this);
79. if (roomIndex > -1) {
80. globalRoomList.splice(roomIndex, 1);
81. }
82. }
83. }
85. /** 玩家已满 */
86. isFull() {
87. return this.players.length == MAX_ROOT_MEMBER;
88. }
90. /** 开始游戏 */
91. startGame() {
92. // 保留这行日志输出可以让实验室检查到实验的完成情况
93. console.log('game started!');
95. // 当局积分清零
96. this.players.forEach(player => player.gameData.roundScore = 0);
98. // 集合玩家用户和游戏数据
99. const players = this.players.map(player => Object.assign({}, player.user, player.gameData));
101. // 通知所有玩家开始
102. for (let player of this.players) {
103. player.send('start', {
104. gameTime: GAME_TIME,
105. players
106. });
107. }
109. // 计时结束
110. setTimeout(() => this.finishGame(), GAME_TIME * 1000);
111. }
113. /** 结束游戏 */
114. finishGame() {
115. const players = this.players;
117. // 两两对比算分
118. for (let i = 0; i < MAX_ROOT_MEMBER; i++) {
119. let p1 = players[i];
120. if (!p1) break;
121. for (let j = i + 1; j < MAX_ROOT_MEMBER; j++) {
122. let p2 = players[j];
123. const result = judge(p1.gameData.choice, p2.gameData.choice);
124. p1.gameData.roundScore -= result;
125. p2.gameData.roundScore += result;
126. }
127. }
128. // 计算连胜奖励
129. for (let player of players) {
130. const gameData = player.gameData;
131. // 胜局积分
132. if (gameData.roundScore > 0) {
133. gameData.winStreak++;
134. gameData.roundScore *= gameData.winStreak;
135. }
136. // 败局清零
137. else if (gameData.roundScore < 0) {
138. gameData.roundScore = 0;
139. gameData.winStreak = 0;
140. }
141. // 累积总分
142. gameData.totalScore += gameData.roundScore;
143. }
144. // 计算结果
145. const result = players.map(player => {
146. const { uid } = player.user;
147. const { roundScore, totalScore, winStreak, choice } = player.gameData;
148. return { uid, roundScore, totalScore, winStreak, choice };
149. });
150. // 通知所有玩家游戏结果
151. for (let player of players) {
152. player.send('result', { result });
153. }
154. }
155. }
复制代码
处理游戏开始、计算结果、积分等逻辑
实现玩家逻辑添加 game/Player.js 实现玩家逻辑，可参考下面的代码：
示例代码：/data/release/weapp/game/Player.js
1. const Room = require("./Room");
3. /**
4. * 表示一个玩家，处理玩家的公共游戏逻辑，消息处理部分需要具体的玩家实现（请参考 ComputerPlayer 和 HumanPlayer）
5. */
6. module.exports = class Player {
7. constructor(user) {
8. this.id = user.uid;
9. this.user = user;
10. this.room = null;
11. this.gameData = {
12. // 当前的选择（剪刀/石头/布）
13. choice: null,
14. // 局积分
15. roundScore: 0,
16. // 总积分
17. totalScore: 0,
18. // 连胜次数
19. winStreak: 0
20. };
21. }
23. /**
24. * 上线当前玩家，并且异步返回给玩家分配的房间
25. */
26. online(room) {
27. // 处理玩家 'join' 消息
28. // 为玩家寻找一个可用的房间，并且异步返回
29. this.receive('join', () => {
30. if (this.room) {
31. this.room.removePlayer(this);
32. }
33. room = this.room = room || Room.findRoomWithSeat() || Room.create();
34. room.addPlayer(this);
35. });
37. // 处理玩家 'choise' 消息
38. // 需要记录玩家当前的选择，并且通知到房间里的其它玩家
39. this.receive('choice', ({ choice }) => {
40. this.gameData.choice = choice;
41. this.broadcast('movement', {
42. uid: this.user.uid,
43. movement: "choice"
44. });
45. });
47. // 处理玩家 'leave' 消息
48. // 让玩家下线
49. this.receive('leave', () => this.offline);
50. }
52. /**
53. * 下线当前玩家，从房间离开
54. */
55. offline() {
56. if (this.room) {
57. this.room.removePlayer(this);
58. this.room = null;
59. }
60. this.user = null;
61. this.gameData = null;
62. }
64. /**
65. * 发送指定消息给当前玩家，需要具体子类实现
66. * @abstract
67. * @param {string} message 消息类型
68. * @param {*} data 消息数据
69. */
70. send(message, data) {
71. throw new Error('Not implement: AbstractPlayer.send()');
72. }
74. /**
75. * 处理玩家发送的消息，需要具体子类实现
76. * @abstract
77. * @param {string} message 消息类型
78. * @param {Function} handler
79. */
80. receive(message, handler) {
81. throw new Error('Not implement: AbstractPlayer.receive()');
82. }
84. /**
85. * 给玩家所在房间里的其它玩家发送消息
86. * @param {string} message 消息类型
87. * @param {any} data 消息数据
88. */
89. broadcast(message, data) {
90. if (!this.room) return;
91. this.others().forEach(neighbor => neighbor.send(message, data));
92. }
94. /**
95. * 获得玩家所在房间里的其他玩家
96. */
97. others() {
98. return this.room.players.filter(player => player != this);
99. }
100. }
复制代码
处理玩家加入游戏、选择出拳、通知其他玩家等逻辑
实现电脑玩家在实现人类玩家之前，我们先来创建 ComputerPlayer.js 来实现电脑玩家
示例代码：/data/release/weapp/game/ComputerPlayer.js
1. const EventEmitter = require('events');
2. const Player = require('./Player');
4. let nextComputerId = 0;
6. /**
7. * 机器人玩家实现，使用 EventEmitter 接收和发送消息
8. */
9. module.exports = class ComputerPlayer extends Player {
10. constructor() {
11. const computerId = `robot-${++nextComputerId}`;
12. super({
13. uid: computerId,
14. uname: computerId,
15. uavatar: 'http://www.scoutiegirl.com/wp-content/uploads/2015/06/Blue-Robot.png'
16. });
17. this.emitter = new EventEmitter();
18. }
20. /**
21. * 模拟玩家行为
22. */
23. simulate() {
24. this.receive('start', () => this.play());
25. this.receive('result', () => this.stop());
26. this.send('join');
27. }
29. /**
30. * 游戏开始后，随机时间后随机选择
31. */
32. play() {
33. this.playing = true;
34. const randomTime = () => Math.floor(100 + Math.random() * 2000);
35. const randomChoice = () => {
36. if (!this.playing) return;
37. this.send("choice", {
38. choice: Math.floor(Math.random() * 10000) % 3 + 1
39. });
40. setTimeout(randomChoice, randomTime());
41. }
42. setTimeout(randomChoice, 10);
43. }
45. /**
46. * 游戏结束后，标记起来，阻止继续随机选择
47. */
48. stop() {
49. this.playing = false;
50. }
52. /**
53. * 发送消息给当前玩家，直接转发到 emitter
54. */
55. send(message, data) {
56. this.emitter.emit(message, data);
57. }
59. /**
60. * 从当前的 emitter 处理消息
61. */
62. receive(message, handle) {
63. this.emitter.on(message, handle);
64. }
65. }
复制代码
测试游戏逻辑的时候，可能没有其它人可以一起参与，实现一个电脑玩家是不错的选择
实现人类玩家人类玩家通过 WebSocket 信道来实现玩家的输入输出，我们需要添加 game/Tunnel.js 和 game/HumanPlayer.js 来实现人类玩家逻辑，可参考下面的代码：
示例代码：/data/release/weapp/game/Tunnel.js
1. const EventEmitter = require('events');
3. /**
4. * 封装 WebSocket 信道
5. */
6. module.exports = class Tunnel {
7. constructor(ws) {
8. this.emitter = new EventEmitter();
9. this.ws = ws;
10. ws.on('message', packet => {
11. try {
12. // 约定每个数据包格式：{ message: 'type', data: any }
13. const { message, data } = JSON.parse(packet);
14. this.emitter.emit(message, data);
15. } catch (err) {
16. console.log('unknown packet: ' + packet);
17. }
18. });
19. }
21. on(message, handle) {
22. this.emitter.on(message, handle);
23. }
25. emit(message, data) {
26. this.ws.send(JSON.stringify({ message, data }));
27. }
28. }
复制代码
示例代码：/data/release/weapp/game/HumanPlayer.js
1. const co = require('co');
2. const Player = require('./Player');
3. const ComputerPlayer = require('./ComputerPlayer');
4. const Tunnel = require('./Tunnel');
6. /**
7. * 人类玩家实现，通过 WebSocket 信道接收和发送消息
8. */
9. module.exports = class HumanPlayer extends Player {
10. constructor(user, ws) {
11. super(user);
12. this.ws = ws;
13. this.tunnel = new Tunnel(ws);
14. this.send('id', user);
15. }
17. /**
18. * 人类玩家上线后，还需要监听信道关闭，让玩家下线
19. */
20. online(room) {
21. super.online(room);
22. this.ws.on('close', () => this.offline());
24. // 人类玩家请求电脑玩家
25. this.receive('requestComputer', () => {
26. const room = this.room;
27. while(room && !room.isFull()) {
28. const computer = new ComputerPlayer();
29. computer.online(room);
30. computer.simulate();
31. }
32. });
33. }
35. /**
36. * 下线后关闭信道
37. */
38. offline() {
39. super.offline();
40. if (this.ws && this.ws.readyState == this.ws.OPEN) {
41. this.ws.close();
42. }
43. this.ws = null;
44. this.tunnel = null;
45. if (this.room) {
46. // 清理房间里面的电脑玩家
47. for (let player of this.room.players) {
48. if (player instanceof ComputerPlayer) {
49. this.room.removePlayer(player);
50. }
51. }
52. this.room = null;
53. }
54. }
56. /**
57. * 通过 WebSocket 信道发送消息给玩家
58. */
59. send(message, data) {
60. this.tunnel.emit(message, data);
61. }
63. /**
64. * 从 WebSocket 信道接收玩家的消息
65. */
66. receive(message, callback) {
67. this.tunnel.on(message, callback);
68. }
69. }
复制代码
人类玩家和电脑玩家的逻辑是一致的，但是 IO 不同，人类玩家使用之前实现的 WebSocket 服务进行输入输出，而电脑玩家直接使用 EventEmiter 处理
添加游戏服务入口游戏的实现已经完成了，接下来，编辑 websocket.js 添加服务入口，可参考下面的代码：
示例代码：/data/release/weapp/websocket.js
1. // 引入 url 模块用于解析 URL
2. const url = require('url');
3. // 引入 ws 支持 WebSocket 的实现
4. const ws = require('ws');
5. // 引入人类玩家
6. const HumanPlayer = require('./game/HumanPlayer');
8. // 导出处理方法
9. exports.listen = listen;
11. /**
12. * 在 HTTP Server 上处理 WebSocket 请求
13. * @param {http.Server} server
14. * @param {wafer.SessionMiddleware} sessionMiddleware
15. */
16. function listen(server, sessionMiddleware) {
17. // 使用 HTTP Server 创建 WebSocket 服务，使用 path 参数指定需要升级为 WebSocket 的路径
18. const wss = new ws.Server({ server });
20. // 同时支持 /ws 和 /game 的 WebSocket 连接请求
21. wss.shouldHandle = (request) => {
22. const path = url.parse(request.url).pathname;
23. request.path = path;
24. return ['/ws', '/game'].indexOf(path) > -1;
25. };
27. // 监听 WebSocket 连接建立
28. wss.on('connection', (ws, request) => {
29. // request: 要升级到 WebSocket 协议的 HTTP 连接
31. // 被升级到 WebSocket 的请求不会被 express 处理，
32. // 需要使用会话中间节获取会话
33. sessionMiddleware(request, null, () => {
34. const session = request.session;
35. if (!session) {
36. // 没有获取到会话，强制断开 WebSocket 连接
37. ws.send(JSON.stringify(request.sessionError) || "No session avaliable");
38. ws.close();
39. return;
40. }
41. console.log(`WebSocket client connected with openId=${session.userInfo.openId}`);
43. // 根据请求的地址进行不同处理
44. switch (request.path) {
45. case '/ws': return serveMessage(ws, session.userInfo);
46. case '/game': return serveGame(ws, session.userInfo);
47. default: return ws.close();
48. }
49. });
50. });
52. // 监听 WebSocket 服务的错误
53. wss.on('error', (err) => {
54. console.log(err);
55. });
56. }
58. /**
59. * 进行简单的 WebSocket 服务，对于客户端发来的所有消息都回复回去
60. */
61. function serveMessage(ws, userInfo) {
62. // 监听客户端发来的消息
63. ws.on('message', (message) => {
64. console.log(`WebSocket received: ${message}`);
65. ws.send(`Server: Received(${message})`);
66. });
68. // 监听关闭事件
69. ws.on('close', (code, message) => {
70. console.log(`WebSocket client closed (code: ${code}, message: ${message || 'none'})`);
71. });
73. // 连接后马上发送 hello 消息给会话对应的用户
74. ws.send(`Server: 恭喜，${userInfo.nickName}`);
75. }
77. /**
78. * 使用 WebSocket 进行游戏服务
79. */
80. function serveGame(ws, userInfo) {
81. const user = {
82. uid: userInfo.openId,
83. uname: userInfo.nickName,
84. uavatar: userInfo.avatarUrl
85. };
86. // 创建玩家
87. const player = new HumanPlayer(user, ws);
88. // 玩家上线
89. player.online();
90. }
复制代码
安装 co 模块我们的源码中使用到了 co 进行协程管理，启动游戏服务前，需要先安装：
1. cd /data/release/weapp
2. npm install co --save
复制代码
测试游戏服务重启 Node 服务：
1. pm2 restart app
复制代码
打开配套的小程序，点击实验四 - 剪刀石头布小游戏，点击开始按钮进行游戏。
完成实验恭喜！您已经完成了小程序服务的全部实验内容

基于 CentOS 搭建微信小程序服务教程-云服务器玩法在线实验

相关帖子

关于我们

文章导航

精品资源

内容导航