基于腾讯云的微信小程序搭建
准备域名和证书
域名注册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）
填写完成后，点击
添加项目。具体操作可查看如下视频：- AppID：填写小程序的 AppID，请登录公众平台后在
设置实验域名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来安装 Nginxyum 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
登录后，创建一个用户
：weappuse 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
恭喜！您已经完成了小程序服务的全部实验内容！你可以选择保留已经运行的服务，继续进行小程序的学习研究，建议留用机器。
