基于CentOS搭建GIT服务器

1. 下载安装 git

Git 是一款免费、开源的分布式版本控制系统，用于敏捷高效地处理任何或小或大的项目。

此教程以 CentOS 7.2 x64 的系统为环境，搭建 git 服务器。

  • 安装依赖库和编译工具

    为了后续安装能正常进行，我们先来安装一些相关依赖库和编译工具

    1
    yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel

    安装编译工具

    1
    yum install gcc perl-ExtUtils-MakeMaker

  • 下载 git

    选一个目录，用来放下载下来的安装包，这里将安装包放在 /usr/local/src 目录里

    1
    cd /usr/local/src

    到官网找一个新版稳定的源码包下载到 /usr/local/src 文件夹里

    1
    wget https://www.kernel.org/pub/software/scm/git/git-2.10.0.tar.gz

  • 解压和编译

    解压下载的源码包

    1
    tar -zvxf git-2.10.0.tar.gz

    解压后进入 git-2.10.0 文件夹

    1
    cd git-2.10.0

    执行编译

    1
    make all prefix=/usr/local/git

    编译完成后, 安装到 /usr/local/git 目录下

    1
    make install prefix=/usr/local/git

2. 配置环境变量

将 git 目录加入 PATH

将原来的 PATH 指向目录修改为现在的目录

1
echo 'export PATH=$PATH:/usr/local/git/bin' >> /etc/bashrc

生效环境变量

1
source /etc/bashrc

此时我们能查看 git 版本号，说明我们已经安装成功了。

1
git --version

3. 创建 git 账号密码

创建 git 账号

为我们刚刚搭建好的 git 创建一个账号

1
useradd -m gituser

然后为这个账号设置密码

1
passwd gituser

4. 初始化 git 仓库并配置用户权限

  • 创建 git 仓库并初始化

    我们创建 /data/repositories 目录用于存放 git 仓库

    1
    mkdir -p /data/repositories

    创建好后，初始化这个仓库

    1
    cd /data/repositories/ && git init --bare test.git

  • 配置用户权限

    给 git 仓库目录设置用户和用户组并设置权限

    1
    2
    chown -R gituser:gituser /data/repositories
    chmod 755 /data/repositories

    查找 git-shell 所在目录 , 编辑 /etc/passwd 文件，将最后一行关于 gituser 的登录 shell 配置改为 git-shell 的目录，如下

    1
    gituser:x:500:500::/home/gituser:/usr/local/git/bin/git-shell

  • 使用搭建好的 Git 服务

    克隆 test repo 到本地

    1
    cd ~ && git clone gituser@yourip:/data/repositories/test.git #yourip可以你服务器的ip地址或域名

展开全文 >>

基于CentOS搭建个人Leanote云笔记本

Leanote 依赖 MongoDB 作为数据存储，下面开始安装MongoDB：
1. 下载启动 MongoDB

  • 下载 MongoDB

    进入 /home 目录，并下载 MongoDB：

    1
    cd /home

    下载源码：

    1
    wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.0.1.tgz

    解压缩源码包：

    1
    tar -xzvf mongodb-linux-x86_64-3.0.1.tgz

  • 创建用于存储的文件夹目录

    1
    mkdir -p /data/db

    配置 MongoDB 的环境变量：

    编辑 /etc/profile，在文件末尾追加以下配置：

    1
    export PATH=$PATH:/home/mongodb-linux-x86_64-3.0.1/bin

    并执行以下命令，使环境变量生效。

    1
    source /etc/profile
  • 启动 MongoDB（启动需要 3 ~ 5 分钟，耐心等待）： 
    1
    mongod --bind_ip localhost --port 27017 --dbpath /data/db/ --logpath=/var/log/mongod.log --fork

2. 安装 Leanote

  • 下载 Leanote

    先进入 /home 目录

    1
    cd /home

    下载 Leanote 源码

    1
    wget https://iweb.dl.sourceforge.net/project/leanote-bin/2.4/leanote-linux-amd64-v2.4.bin.tar.gz

  • 解开压缩包：

    1
    tar -zxvf leanote-linux-amd64-v2.4.bin.tar.gz

  • 编辑 Leanote 配置文件

    编辑文件 app.conf，在文件中找到 app.secret= 项，并修改为如下内容：

    1
    app.secret=qcloud666

  • 初始化数据库

    导入初始化数据：

    1
    mongorestore -h localhost -d leanote --dir /home/leanote/mongodb_backup/leanote_install_data/

  • 启动 Leanote 服务

    1
    nohup /bin/bash /home/leanote/bin/run.sh >> /var/log/leanote.log 2>&1 &

3. 访问 Leanote 云笔记本

通过访问 http://yourip:9000 或 http://yourdomain.com:9000就可以了使用自己的笔记本。

  • 初始化账户： admin

  • 初始化密码： abc123

请务必修改密码已确保使用安全！

展开全文 >>

基于CentOS搭建个人网盘

1. 安装 Seafile

  • 安装依赖环境

    使用 yum 安装 Python 及 MySQL：

    1
    yum install python python-setuptools python-imaging python-ldap python-memcached MySQL-python mariadb mariadb-server

    启动 MariaDB 服务：

    1
    2
    sudo systemctl start mariadb.service
    sudo systemctl enable mariadb.service

    配置 MySQL：

    1
    /usr/bin/mysql_secure_installation

    配置过程输入参数如截图所示，其中 New password 和 Re-enter new password 字段都设置为 QcE7gi1g（最好自己定义一个密码），其他字段一路回车使用默认值：

    图片

  • 安装 Seafile

    下载 Seafile 安装包：

    1
    wget https://mc.qcloudimg.com/static/archive/3d8addbe52be88df4f6139ec7e35b453/seafile-server_5.1.4_x86-64.tar.gz

    解压 Seafile 安装包：

    1
    tar -zxvf seafile-server_5.1.4_x86-64.tar.gz

    安装 Seafile 安装包：

    1
    2
    3
    4
    5
    sudo mkdir -p /opt/seafile/installed
    sudo mv seafile-server_5.1.4_x86-64.tar.gz /opt/seafile/installed
    sudo mv seafile-server-5.1.4/ /opt/seafile
    cd /opt/seafile/seafile-server-5.1.4
    sudo ./setup-seafile-mysql.sh

    执行过程输入参数如截图所示，[server name] 字段输入 Seafile，[ This server's ip or domain ] 字段输入你的域名或服务器IP，[ 1 or 2 ] 字段选择 1，mysql 的 [ root password ] 字段输入 QcE7gi1g（这个是上面步骤你设置的密码），其他字段一路回车使用默认值：

    这里写图片描述

2. 启动 Seafile 及修改防火墙规则

  • 启动 Seafile

    1
    2
    sudo ./seafile.sh start
    sudo ./seahub.sh start

    执行过程输入参数如截图所示，其中 [ admin email ] 设置为您登录网盘的帐号，如 admin@qcloudlab.wang，[ admin password ] 和 [ admin password again ] 设置为登录网盘的密码，如 admin_QcE7gi1g（最好自己定义一个密码）：

    这里写图片描述

  • 修改防火墙规则

    1
    2
    3
    sudo firewall-cmd --zone=public --permanent --add-port=8082/tcp
    sudo firewall-cmd --zone=public --permanent --add-port=8000/tcp
    sudo firewall-cmd --reload

展开全文 >>

基于CentOS搭建WordPress个人博客

1. 准备 LNMP 环境

LNMP 是 Linux、Nginx、MySQL 和 PHP 的缩写，是 WordPress 博客系统依赖的基础运行环境。我们先来准备 LNMP 环境

  • 安装 Nginx

    使用 yum 安装 Nginx：

    1
    yum install nginx -y

    修改 /etc/nginx/conf.d/default.conf，去除对 IPv6 地址的监听，可参考下面的示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    server {
        listen       80 default_server;
        # listen       [::]:80 default_server;
        server_name  _;
        root         /usr/share/nginx/html;
        # Load configuration files for the default server block.
        include /etc/nginx/default.d/*.conf;
        location / {
        }
        error_page 404 /404.html;
            location = /40x.html {
        }
        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }

    修改完成后，启动 Nginx：

    1
    nginx

    此时，可访问云服务器外网 HTTP 服务（http://yourdomain.com）来确认是否已经安装成功。

    将 Nginx 设置为开机自动启动：

    1
    chkconfig nginx on

  • 安装 MySQL

    使用 yum 安装 MySQL：

    1
    yum install mysql-server -y

    安装完成后，启动 MySQL 服务：

    1
    service mysqld restart

    设置 MySQL 账户 root 密码：

    1
    /usr/bin/mysqladmin -u root password 'MyPas$word4Word_Press'

    将 MySQL 设置为开机自动启动：

    1
    chkconfig mysqld on

  • 安装 PHP

    使用 yum 安装 PHP：

    1
    yum install php-fpm php-mysql -y

    安装之后，启动 PHP-FPM 进程：

    1
    service php-fpm start

    启动之后，可以使用下面的命令查看 PHP-FPM 进程监听哪个端口 

    1
    netstat -nlpt | grep php-fpm

    把 PHP-FPM 也设置成开机自动启动：

    1
    chkconfig php-fpm on

2. 安装并配置 WordPress

  • 安装 WordPress

    配置好 LNMP 环境后，继续使用 yum 来安装 WordPress：

    1
    yum install wordpress -y

    安装完成后，就可以在 /usr/share/wordpress 看到 WordPress 的源代码了。

    由于上面的安装方法默认安装的是英文版，所以我们还要下载中文语言包，如果不需要中文安装可跳过此步骤

    1
    2
    3
    4
    wget https://cn.wordpress.org/wordpress-4.8.1-zh_CN.tar.gz
    tar -zxvf wordpress*
    mv -r wordpress/wp-content/languages /usr/share/wordpress/wp-content
    rm -rf wordpress*

  • 配置数据库

    进入 MySQL：

    1
    mysql -uroot --password='MyPas$word4Word_Press'

    为 WordPress 创建一个数据库：

    1
    CREATE DATABASE wordpress;

MySQL 部分设置完了，我们退出 MySQL 环境：

1
exit

把上述的 DB 配置同步到 WordPress 的配置文件 `wp-config.php` 中，可参考下面的配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
<?php
/**
 * The base configuration for WordPress
 *
 * The wp-config.php creation script uses this file during the
 * installation. You don't have to use the web site, you can
 * copy this file to "wp-config.php" and fill in the values.
 *
 * This file contains the following configurations:
 *
 * * MySQL settings
 * * Secret keys
 * * Database table prefix
 * * ABSPATH
 *
 * @link https://codex.wordpress.org/Editing_wp-config.php
 *
 * @package WordPress
 */
// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define('DB_NAME', 'wordpress');
/** MySQL database username */
define('DB_USER', 'root');
/** MySQL database password */
define('DB_PASSWORD', 'MyPas$word4Word_Press');
/** MySQL hostname */
define('DB_HOST', 'localhost');
/** Database Charset to use in creating database tables. */
define('DB_CHARSET', 'utf8');
/** The Database Collate type. Don't change this if in doubt. */
define('DB_COLLATE', '');
define('WPLANG', 'zh_CN');
/**#@+
 * Authentication Unique Keys and Salts.
 *
 * Change these to different unique phrases!
 * You can generate these using the {@link https://api.wordpress.org/secret-key/1.1/salt/ WordPress.org secret-key service}
 * You can change these at any point in time to invalidate all existing cookies. This will force all users to have to log in again.
 *
 * @since 2.6.0
 */
define('AUTH_KEY',         'put your unique phrase here');
define('SECURE_AUTH_KEY',  'put your unique phrase here');
define('LOGGED_IN_KEY',    'put your unique phrase here');
define('NONCE_KEY',        'put your unique phrase here');
define('AUTH_SALT',        'put your unique phrase here');
define('SECURE_AUTH_SALT', 'put your unique phrase here');
define('LOGGED_IN_SALT',   'put your unique phrase here');
define('NONCE_SALT',       'put your unique phrase here');
/**#@-*/
/**
 * WordPress Database Table prefix.
 *
 * You can have multiple installations in one database if you give each
 * a unique prefix. Only numbers, letters, and underscores please!
 */
$table_prefix  = 'wp_';
/**
 * See http://make.wordpress.org/core/2013/10/25/the-definitive-guide-to-disabling-auto-updates-in-wordpress-3-7
 */
/* Disable all file change, as RPM base installation are read-only */
define('DISALLOW_FILE_MODS', true);
/* Disable automatic updater, in case you want to allow
   above FILE_MODS for plugins, themes, ... */
define('AUTOMATIC_UPDATER_DISABLED', true);
/* Core update is always disabled, WP_AUTO_UPDATE_CORE value is ignore */
/**
 * For developers: WordPress debugging mode.
 *
 * Change this to true to enable the display of notices during development.
 * It is strongly recommended that plugin and theme developers use WP_DEBUG
 * in their development environments.
 *
 * For information on other constants that can be used for debugging,
 * visit the Codex.
 *
 * @link https://codex.wordpress.org/Debugging_in_WordPress
 */
define('WP_DEBUG', false);
/* That's all, stop editing! Happy blogging. */
/** Absolute path to the WordPress directory. */
if ( !defined('ABSPATH') )
    define('ABSPATH', '/usr/share/wordpress');
/** Sets up WordPress vars and included files. */
require_once(ABSPATH . 'wp-settings.php');

  • 配置 Nginx

    WordPress 已经安装完毕，我们配置 Nginx 把请求转发给 PHP-FPM 来处理

    首先，重命名默认的配置文件：

    1
    2
    cd /etc/nginx/conf.d/
    mv default.conf defaut.conf.bak

    在 /etc/nginx/conf.d 创建 wordpress.conf 配置，参考下面的内容：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    server {
        listen 80;
        root /usr/share/wordpress;
        location / {
            index index.php index.html index.htm;
            try_files $uri $uri/ /index.php index.php;
        }
        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        location ~ .php$ {
            fastcgi_pass   127.0.0.1:9000;
            fastcgi_index  index.php;
            fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
            include        fastcgi_params;
        }
    }

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

    1
    nginx -s reload

  • 大功告成

    恭喜，您的 WordPress 博客已经部署完成，您可以通过浏览器访问博客查看效果。博客访问地址：http://yourdomain.com/wp-admin/install.php

展开全文 >>

基于CentOS搭建搭建FTP文件服务

1. 安装并启动 FTP 服务

  • 安装 VSFTPD

    使用 yum 安装 vsftpd：

    1
    yum install vsftpd -y

  • 启动 VSFTPD

    安装完成后，启动 FTP 服务：

    1
    service vsftpd start

    启动后，可以看到系统已经监听了 21 端口：

    1
    netstat -nltp | grep 21

    此时，访问 ftp://yourdomain.com 可浏览机器上的 /var/ftp 目录了。

2. 配置 FTP 权限

目前 FTP 服务登陆允许匿名登陆，也无法区分用户访问，我们需要配置 FTP 访问权限

  • 了解 VSFTP 配置

    vsftpd 的配置目录为 /etc/vsftpd，包含下列的配置文件：

    • vsftpd.conf 为主要配置文件
    • ftpusers 配置禁止访问 FTP 服务器的用户列表
    • user_list 配置用户访问控制

  • 阻止匿名访问和切换根目录

    匿名访问和切换根目录都会给服务器带来安全风险，我们把这两个功能关闭。

    编辑 /etc/vsftpd/vsftpd.conf，找到下面两处配置并修改：

    1
    2
    3
    4
    5
    # 禁用匿名用户
    anonymous_enable=NO
    # 禁止切换根目录
    chroot_local_user=YES

    重新启动 FTP 服务

    1
    service vsftpd restart

  • 创建 FTP 用户

    创建一个用户 ftpuser ：

    1
    useradd ftpuser

    为用户 ftpuser 设置密码 ：

    1
    echo "3oEiU5s7" | passwd ftpuser --stdin

  • 限制该用户仅能通过 FTP 访问

    限制用户 ftpuser 只能通过 FTP 访问服务器，而不能直接登录服务器：

    1
    usermod -s /sbin/nologin ftpuser

  • 为用户分配主目录

    为用户 ftpuser 创建主目录并约定：

    /data/ftp 为主目录, 该目录不可上传文件

    /data/ftp/pub 文件只能上传到该目录下

    1
    mkdir -p /data/ftp/pub

    创建登录欢迎文件 ：

    1
    echo "Welcome to use FTP service." > /data/ftp/welcome.txt

    设置访问权限：

    1
    chmod a-w /data/ftp && chmod 777 -R /data/ftp/pub

    设置为用户的主目录：

    1
    usermod -d /data/ftp ftpuser

  • 完成

展开全文 >>

基于CentOS搭建Discuz

1. 购买服务器和域名

2. 准备 LAMP 环境

LAMP 是 Linux、Apache、MySQL 和 PHP 的缩写，是 Discuz 论坛系统依赖的基础运行环境。我们先来准备 LAMP 环境

  • 安装 MySQL

    使用 yum 安装 MySQL：

    1
    yum install mysql-server -y

    安装完成后，启动 MySQL 服务：

    1
    service mysqld restart

    此教程使用 mysql 默认账户名和密码，您也可以设置自己的 MySQL 账户名和密码，参考下面的内容：

    1
    /usr/bin/mysqladmin -u root password 'NGky9EKq'

    将 MySQL 设置为开机自动启动：

    1
    chkconfig mysqld on

  • 安装 Apache 组件

    使用 yum 安装 Apache 组件：

    1
    yum install httpd -y

    安装之后，启动 httpd 进程：

    1
    service httpd start

    把 httpd 也设置成开机自动启动：

    1
    chkconfig httpd on

  • 安装 PHP

    使用 yum 安装 PHP：

    1
    yum install php php-fpm php-mysql -y

    安装之后，启动 PHP-FPM 进程：

    1
    service php-fpm start

    启动之后，可以使用下面的命令查看 PHP-FPM 进程监听哪个端口 

    1
    netstat -nlpt | grep php-fpm

    把 PHP-FPM 也设置成开机自动启动：

    1
    chkconfig php-fpm on

3. 安装并配置 Discuz

  • 安装 Discuz

    CentOS 6 没有Discuz 的 yum 源，所以我们需要下载一个Discuz 压缩包：

    1
    wget http://download.comsenz.com/DiscuzX/3.2/Discuz_X3.2_SC_UTF8.zip

    下载完成后，解压这个压缩包

    1
    unzip Discuz_X3.2_SC_UTF8.zip

  • 配置 Discuz

    由于PHP默认访问 /var/www/html/ 文件夹，所以我们需要把upload文件夹里的文件都复制到 /var/www/html/ 文件夹

    1
    2
    cd Discuz*
    cp -r upload/* /var/www/html/

    给 /var/www/html 目录及其子目录赋予权限

    1
    chmod -R 777 /var/www/html

    重启 Apache

    1
    service httpd restart

  • 完成

展开全文 >>

搭建微信订阅号后台服务

1. 准备域名和服务器

微信公众平台需要配置服务器地址 URL 访问，在实验开始之前，我们要准备域名。

  • 购买服务器（腾讯云）

  • 域名注册

  • 域名解析

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

    1
    ping www.yourdomain.com

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

2. 申请微信个人订阅号

在开始搭建我们的订阅号服务器之前，需要先拿到订阅号相关信息。

  • 注册开发者账号

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

  • 获取微信订阅号公众平台认证字段信息

    我们需要获取3个字段：AppID Token EncodingAESKey。

    登录微信公众平台，依次进入 开发 - 基本配置 可以拿到 AppID。

    在基本配置 - 服务器配置 - 修改配置 表单中：
    URL 填第一步申请的域名;

    Token 用户根据提示填写，用于后面校验服务端合法性;

    EncodingAESKey 点击 随机生成 按钮来生成。

    当点击表单 提交 按钮时，微信会通过 Token 来校验 URL 的合法性，这个我们在后面步骤实现，此界面暂时保留不关闭。

3. 搭建 HTTP 服务

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

  • 安装 NodeJS 和 NPM

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

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

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

    1
    node -v

  • 编写 HTTP Server 源码

    创建工作目录

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

    1
    mkdir -p /data/release/weapp

    进入此工作目录

    1
    cd /data/release/weapp

    创建 package.json

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

    1
    2
    3
    4
    {
        "name": "weapp",
        "version": "1.0.0"
    }

    添加 Server 源码

    在工作目录创建 app.js，使用 Express.js 来监听 5050 端口，可参考下面的示例代码(注：请将 app.js 文件中的token/appid/encodingAESKey等配置项替换为您的订阅号对应的取值)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    // 引用 express 来支持 HTTP Server 的实现
    const express = require('express');
    // 引用微信公共平台自动回复消息接口服务中间件
    var wechat = require('wechat');
    // 创建一个 express 实例
    const app = express();
    // 配置微信公众平台参数，在教程第二步中获取
    var config = {
        token: 'your token', // 填第二步中获取的 `token`
        appid: 'your appid', // 填第二步中获取的 `appid`
        encodingAESKey: 'your encodingAESKey', // 填第二步中获取的 `encodingAESKey`
        checkSignature: true // 可选，默认为true。由于微信公众平台接口调试工具在明文模式下不发送签名，所以如要使用该测试工具，请将其设置为false 
    };
    app.use(express.query());
    app.use('/', wechat(config, function (req, res, next) {
        res.reply({
            content: '你好，Hello World!',
            type: 'text'
        });
    }));
    // 监听端口，等待连接
    const port = 5050;
    app.listen(port);
    // 输出服务器启动日志
    console.log(`Server listening at http://127.0.0.1:${port}`);

  • 运行 HTTP 服务

    安装 PM2

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

    1
    npm install pm2 --global

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

    安装 Express

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

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

    安装 Wechat

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

    1
    2
    cd /data/release/weapp
    npm install wechat --save

    启动服务

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

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

    现在，您的 HTTP 服务已经在 http://yourdomain.com:5050 运行要查看服务输出的日志，可以使用下面的命令：

    1
    pm2 logs

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

    1
    pm2 restart app

4. 搭建 nginx 对外服务

NodeJs只是侦听的机器上的 5050 端口，我们使用 nginx 侦听 80 端口提供对外域名服务

  • 安装 Nginx

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

    1
    yum install nginx -y

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

    1
    nginx

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

  • 配置 HTTP 反向代理

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

    Nginx 配置目录在 /etc/nginx/conf.d，我们在该目录创建 wechat.conf，参考示例代码如下：

    1
    2
    3
    4
    5
    6
    7
    8
    server {
           listen 80;
           server_name www.example.com; # 改为第一步申请的域名
           
           location / {
               proxy_pass http://127.0.0.1:5050;
           }
       }

    重新加载配置

    1
    nginx -s reload

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

5. 使用Server端回复微信消息

  • 提交服务端配置

    我们将第二步微信公众平台中保留的表单提交，同时将 基本配置 - 服务器配置 启用

  • 关注、发送与消息回复

    首先通过二维码关注微信订阅号

    在聊天界面向微信公众号发送一条消息

    最终我们会回到一条 你好，Hello World! 的回复

  • 大功搞成

展开全文 >>

基于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 进行编辑，需要修改小程序通信域名，请参考下面的配置：

    1
    2
    3
    4
    5
    6
    7
    8
    App({
        config: {
            host: '' // 这个地方填写你的域名
        },
        onLaunch () {
            console.log('App.onLaunch()');
        }
    });

3. 搭建 HTTP 服务

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

  • 安装 NodeJS 和 NPM

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

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

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

    1
    node -v

  • 编写 HTTP Server 源码

    创建工作目录

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

    1
    mkdir -p /data/release/weapp

    进入此工作目录

    1
    cd /data/release/weapp

    创建 package.json

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

    1
    2
    3
    4
    {
        "name": "weapp",
        "version": "1.0.0"
    }

    添加 Server 源码

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    // 引用 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

    1
    npm install pm2 --global

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

    安装 Express

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

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

    启动服务

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

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

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

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

    1
    pm2 logs

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

    1
    pm2 restart app

4. 搭建 HTTPS 服务

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

  • 安装 Nginx

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

    1
    yum install nginx -y

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

    1
    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，内容如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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 重新加载配置使其生效

    1
    nginx -s reload

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

  • 在小程序中测试 HTTPS 访问

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

5. 小程序会话

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

  • 安装 MongoDB

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

    1
    yum install mongodb-server mongodb -y

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

    1
    2
    mongod --version
    mongo --version

  • 启动 MongoDB

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

    1
    2
    mkdir -p /data/mongodb
    mkdir -p /data/logs/mongodb

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

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

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

    1
    netstat -ltp | grep 27017

  • 添加 MongoDB 用户

    登录本地 MongoDB 服务：

    1
    mongo

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

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

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

  • 安装 Node 模块

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

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

  • 实现小程序会话

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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，添加会话实现逻辑，可参考下面的代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    // 引用 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}`);

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

    1
    pm2 restart app

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

6. WebSocket 服务

  • 安装 Node 模块

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

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

  • 实现 WebSocket 服务器

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    // 引入 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 服务，可参考下面代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    // 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}`);

    重启服务

    1
    pm2 restart app

  • 更新 Nginx 代理

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    # 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 进程重新加载配置：

    1
    nginx -s reload

  • 测试 WebSocket

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

7. 剪刀石头布小游戏

  • 实现游戏房间逻辑

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

    1
    mkdir -p /data/release/weapp/game

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    /**
    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”);

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    /**
     * 表示一个玩家，处理玩家的公共游戏逻辑，消息处理部分需要具体的玩家实现（请参考 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 来实现电脑玩家

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    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 添加服务入口，可参考下面的代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    // 引入 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 进行协程管理，启动游戏服务前，需要先安装：

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

  • 测试游戏服务

    重启 Node 服务：

    1
    pm2 restart app

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

  • 测试完成

展开全文 >>

七牛云——对象存储管理工具介绍

由于我是一个七牛的重度使用者（主要是对象存储），每次上传文件、复制链接、下载文件都必须用浏览器打开网页，而且还要登录，感觉好麻烦啊，干脆就自己开发了一个这样的工具（使用JavaFX编写），打包成可执行的jar包。

主要功能就是文件的上传下载，获取存储空间中的文件列表，搜索文件（支持正则表达式），复制文件外链，删除文件，移动（或复制）文件，重命名文件名，设置文件的生存时间等。

功能截图：

1. 主窗口界面：

程序主界面

  • 设置文件前缀

    路径前缀可以用来分类文件，例如： image/jpg/your-file-name.jpg

  • 添加存储空间

    添加存储空间，需要同时指定空间名称，空间域名以及所在区域

    添加存储空间

  • 重置密钥

    如果你修改了Key，可以在此处修改密钥

    重置密钥

    说明：出于安全考虑，建议您周期性地更换密钥。查看我的密钥 密钥安全使用须知

  • 配置文件

    Windows使用路径：C:/ProgramData/QiniuTool

    MacOS 或 Linux 使用路径：$user.home/tool

    其中 config.json 为配置文件

  • 文件上传

    除了可（支持断点和覆盖）上传本地文件外，还可抓取网络文件到空间中，如：

    上传网络文件

    然后点击 开始上传 即可

2. 资源管理界面：

资源管理界面

  • 刷新列表

    刷新当前存储空间的资源列表

  • 复制链接

    复制你选中文件的外链

  • 删除文件

    从存储空间中删除你选中的所有文件

  • 移动文件

    移动（或复制）选中的所有文件到指定的存储空间中（目前好像七牛还不支持跨区域移动文件）

    移动文件界面

    说明：勾选“保存文件副本”时表示当前操作为复制，不勾选时表示移动（会删除本存储空间的文件），默认勾选。

  • 生存时间

    设置选中文件的生存时间，到期后七牛会自动删除这些文件

  • 更新镜像

    此功能首先需要你配置了镜像存储

    官方解释：对于配置了镜像存储的空间，如果镜像源站更新了文件内容，则默认情况下，七牛不会再主动从客户镜像源站同步新的副本，这个时候就需要利用这个prefetch接口来主动地将空间中的文件和更新后的源站副本进行同步。

  • 公有下载

    直接下载选中的文件（私有的存储空间不可用）

  • 私有下载

    下载选中的私有存储空间的文件

  • 打开文件

    用浏览器打开你选中的文件

  • 链接下载

    由于这两天迅雷抽风了，下载出现BUG，所以提供了这样一个临时的下载方案，打开后直接输入链接即可下载

  • 文件刷新

    从七牛云镜像源刷新你选中的文件，保证用户下载的是最新上传的文件，而不是之前的旧版本（个人感觉和 更新镜像 是一样的）

  • 日志下载

    从七牛下载指定日期的操作日志

说明：操作文件时，需要选中文件才能操作（支持多选）。由于下载私有空间的文件需要临时授权，所以文件的下载分为私有下载（生成临时授权然后下载文件）和公有下载（直接下载文件）。

3. 数据统计界面

数据统计界面

说明：时间范围不超过31天，否则无法获取数据，这是七牛官方规定的。

4. 其他

展开全文 >>

JavaFX Dialog对话框

1. 标准对话框

  • 消息对话框
    1
    2
    3
    4
    5
    6
    Alert alert = new Alert(AlertType.INFORMATION);
    alert.setTitle("Information Dialog");
    alert.setHeaderText("Look, an Information Dialog");
    alert.setContentText("I have a great message for you!");
    alert.showAndWait();

information dialog

  • 没有标题的消息对话框
    1
    2
    3
    4
    5
    6
    Alert alert = new Alert(AlertType.INFORMATION);
    alert.setTitle("Information Dialog");
    alert.setHeaderText(null);
    alert.setContentText("I have a great message for you!");
    alert.showAndWait();

information dialog no header

2. 警告对话框

1
2
3
4
5
6
Alert alert = new Alert(AlertType.WARNING);
alert.setTitle("Warning Dialog");
alert.setHeaderText("Look, a Warning Dialog");
alert.setContentText("Careful with the next step!");
alert.showAndWait();

warning dialog

3. 错误对话框

1
2
3
4
5
6
Alert alert = new Alert(AlertType.ERROR);
alert.setTitle("Error Dialog");
alert.setHeaderText("Look, an Error Dialog");
alert.setContentText("Ooops, there was an error!");
alert.showAndWait();

error dialog

4. 异常对话框

这不是一个完整的异常对话框。但我们可以很容易地将 TextArea 作为可扩展的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Alert alert = new Alert(AlertType.ERROR);
alert.setTitle("Exception Dialog");
alert.setHeaderText("Look, an Exception Dialog");
alert.setContentText("Could not find file blabla.txt!");
Exception ex = new FileNotFoundException("Could not find file blabla.txt");
// Create expandable Exception.
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
ex.printStackTrace(pw);
String exceptionText = sw.toString();
Label label = new Label("The exception stacktrace was:");
TextArea textArea = new TextArea(exceptionText);
textArea.setEditable(false);
textArea.setWrapText(true);
textArea.setMaxWidth(Double.MAX_VALUE);
textArea.setMaxHeight(Double.MAX_VALUE);
GridPane.setVgrow(textArea, Priority.ALWAYS);
GridPane.setHgrow(textArea, Priority.ALWAYS);
GridPane expContent = new GridPane();
expContent.setMaxWidth(Double.MAX_VALUE);
expContent.add(label, 0, 0);
expContent.add(textArea, 0, 1);
// Set expandable Exception into the dialog pane.
alert.getDialogPane().setExpandableContent(expContent);
alert.showAndWait();

exception dialog

5. 确认对话框

1
2
3
4
5
6
7
8
9
10
11
Alert alert = new Alert(AlertType.CONFIRMATION);
alert.setTitle("Confirmation Dialog");
alert.setHeaderText("Look, a Confirmation Dialog");
alert.setContentText("Are you ok with this?");
Optional<ButtonType> result = alert.showAndWait();
if (result.get() == ButtonType.OK){
    // ... user chose OK
} else {
    // ... user chose CANCEL or closed the dialog
}

confirmation dialog

6. 自定义确认对话框

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Alert alert = new Alert(AlertType.CONFIRMATION);
alert.setTitle("Confirmation Dialog with Custom Actions");
alert.setHeaderText("Look, a Confirmation Dialog with Custom Actions");
alert.setContentText("Choose your option.");
ButtonType buttonTypeOne = new ButtonType("One");
ButtonType buttonTypeTwo = new ButtonType("Two");
ButtonType buttonTypeThree = new ButtonType("Three");
ButtonType buttonTypeCancel = new ButtonType("Cancel", ButtonData.CANCEL_CLOSE);
alert.getButtonTypes().setAll(buttonTypeOne, buttonTypeTwo, buttonTypeThree, buttonTypeCancel);
Optional<ButtonType> result = alert.showAndWait();
if (result.get() == buttonTypeOne){
    // ... user chose "One"
} else if (result.get() == buttonTypeTwo) {
    // ... user chose "Two"
} else if (result.get() == buttonTypeThree) {
    // ... user chose "Three"
} else {
    // ... user chose CANCEL or closed the dialog
}

custom action confirmation dialog

7. 可输入的对话框

1
2
3
4
5
6
7
8
9
10
11
12
13
TextInputDialog dialog = new TextInputDialog("walter");
dialog.setTitle("Text Input Dialog");
dialog.setHeaderText("Look, a Text Input Dialog");
dialog.setContentText("Please enter your name:");
// Traditional way to get the response value.
Optional<String> result = dialog.showAndWait();
if (result.isPresent()){
    System.out.println("Your name: " + result.get());
}
// The Java 8 way to get the response value (with lambda expression).
result.ifPresent(name -> System.out.println("Your name: " + name));

text input dialog

说明：如果用户点击了取消按钮result.isPresent()将会返回false

8. 可选择的对话框

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
List<String> choices = new ArrayList<>();
choices.add("a");
choices.add("b");
choices.add("c");
ChoiceDialog<String> dialog = new ChoiceDialog<>("b", choices);
dialog.setTitle("Choice Dialog");
dialog.setHeaderText("Look, a Choice Dialog");
dialog.setContentText("Choose your letter:");
// Traditional way to get the response value.
Optional<String> result = dialog.showAndWait();
if (result.isPresent()){
    System.out.println("Your choice: " + result.get());
}
// The Java 8 way to get the response value (with lambda expression).
result.ifPresent(letter -> System.out.println("Your choice: " + letter));

choice dialog

说明：如果用户没有选择或点击了取消，result.isPresent()将会返回false

9. 自定义登录框

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// Create the custom dialog.
Dialog<Pair<String, String>> dialog = new Dialog<>();
dialog.setTitle("Login Dialog");
dialog.setHeaderText("Look, a Custom Login Dialog");
// Set the icon (must be included in the project).
dialog.setGraphic(new ImageView(this.getClass().getResource("login.png").toString()));
// Set the button types.
ButtonType loginButtonType = new ButtonType("Login", ButtonData.OK_DONE);
dialog.getDialogPane().getButtonTypes().addAll(loginButtonType, ButtonType.CANCEL);
// Create the username and password labels and fields.
GridPane grid = new GridPane();
grid.setHgap(10);
grid.setVgap(10);
grid.setPadding(new Insets(20, 150, 10, 10));
TextField username = new TextField();
username.setPromptText("Username");
PasswordField password = new PasswordField();
password.setPromptText("Password");
grid.add(new Label("Username:"), 0, 0);
grid.add(username, 1, 0);
grid.add(new Label("Password:"), 0, 1);
grid.add(password, 1, 1);
// Enable/Disable login button depending on whether a username was entered.
Node loginButton = dialog.getDialogPane().lookupButton(loginButtonType);
loginButton.setDisable(true);
// Do some validation (using the Java 8 lambda syntax).
username.textProperty().addListener((observable, oldValue, newValue) -> {
    loginButton.setDisable(newValue.trim().isEmpty());
});
dialog.getDialogPane().setContent(grid);
// Request focus on the username field by default.
Platform.runLater(() -> username.requestFocus());
// Convert the result to a username-password-pair when the login button is clicked.
dialog.setResultConverter(dialogButton -> {
    if (dialogButton == loginButtonType) {
        return new Pair<>(username.getText(), password.getText());
    }
    return null;
});
Optional<Pair<String, String>> result = dialog.showAndWait();
result.ifPresent(usernamePassword -> {
    System.out.println("Username=" + usernamePassword.getKey() + ", Password=" + usernamePassword.getValue());
});

login dialog

10. 修改对话框样式

  • 自定义图标
    1
    2
    3
    4
    5
    // Get the Stage.
    Stage stage = (Stage) dialog.getDialogPane().getScene().getWindow();
    // Add a custom icon.
    stage.getIcons().add(new Image(this.getClass().getResource("login.png").toString()));

custom icon

说明：根据JavaFX 8u40最终版本的BUG报告，应该使用与它正在运行的应用程序相同的图标。在这种情况下，你还需要设置它的所有者，对话框会得到所有者的图标:

1
dialog.initOwner(otherStage);

  • 不使用图标
    1
    dialog.initStyle(StageStyle.UTILITY);

minimal

11. 其他操作

  • 设置拥有者
    你可以为每一个对话框指定所有者。如果指定所有者或拥有者为null，那么它是一个顶级的、未拥有的对话框。
    1
    2
    3
    4
    5
    6
    dialog.initOwner(parentWindow);
    ``` 
    - 设置模式
    你可以指定对话框的模式，包括`Modality.NONE`、`WINDOW_MODAL`或`Modality.APPLICATION_MODAL`。
    ``` java
    dialog.initModality(Modality.NONE);

12. API 文档

关于对话框的更多信息，请看JavaFX API官方文档:

阅读原文点击这里

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

热爱编程，<br/>崇尚开源，<br/>喜欢折腾，<br/>Linux爱好者，<br/>追求编写极致优雅的代码。