美文网首页
使用Koa开发微信公众号

使用Koa开发微信公众号

作者: 眸晓 | 来源:发表于2020-10-16 15:33 被阅读0次

    一、使用koa2-generator搭建koa项目

    1.全局安装Koa脚手架

    npm install koa-generator -g

    2.创建模板

    koa2 my-project-name -e // -e代表使用ejs模板引擎

    二、配置微信公众号后台

    进入后台 -> 开发 -> 基本配置

    1.配置ip白名单

    调用获取access_token的ip地址,需要放进白名单,比如你本地测试的ip和你之后部署的服务器ip(只需要填写ip,不需要加上http://之类的)

    2.获取AppSecret

    这是获取access_token需要用的密码,一定在保存好,微信生成后不会存储,只会重置。

    三、使用koa获取access_token

    1.开发前先仔细阅读下微信的开发文档

    微信开放文档

    看完之后,你会了解到,调取几乎所有微信的接口都需要这个access_token,所以获取这个access_token是第一步,获取access_token需要3个参数,分别是:appidsecret(即上面所说的appsecret)和grant_type(值为:client_credential),这三个值你可以放到项目的配置文件中,因为他们的值几乎不会变(除非某一天你弄丢了appsecret,需要重置)。

    2.接口调用

    使用 https请求方式 GET请求

    请求地址:https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET

    其中APPID和APPSECRET是变量,从你的配置文件中读取。

    3.在koa中如何调用第三方的接口

    我使用的是koa2-request

    使用npm i koa2-request -S并加载const koaReq = require('koa2-request')

    以下是我的调用方法,从配置文件中读取appid,secret,grant_type,qs中就是GET请求参数

    const koaReq = require('koa2-request')
    getAccessTokenApi(){
        const {appid,secret,grant_type} = wechat
        return new Promise((resolve,reject)=>{
            koaReq({
                method: 'get',
                url: `https://api.weixin.qq.com/cgi-bin/token`,
                qs: { appid, secret, grant_type },
                json: true//设置返回的数据为json
            },(error, response, body)=> {
                if(error){
                    reject(error)
                }else{
                    resolve(body)
                }
            })
        })
    }
    

    正常情况下,微信会返回下述JSON数据包给公众号:
    {"access_token":"ACCESS_TOKEN","expires_in":7200}

    由于access_token的过期时间是2小时(7200秒),所以需要我们定时去重新获取,才能保证调用其他微信方法时access_token不会失效

    我将access_token和过期时间expires_time保存在文件中,设置过期时间expires_time为当前时间+(7200-1800)秒,也就是当前时间的1个半小时后是我的过期时间。我使用了一个定时任务插件(node-schedule),每10分钟去判断一下当前时间和过期时间,如果当前时间大于过期时间,则需要重新获取access_token

    // schedule.js
    // 先书写一个每10分钟执行一次的定时任务
    const schedule = require('node-schedule');
    const fs = require('fs')
    const path = require('path')
    const os = require("os");
    module.exports = {
        refreshTokenSchedule(callback){
            console.log('启动定时任务');
            const loggerPath = path.resolve(__dirname,'../file/scheuleLogger.txt')
            var rule = new schedule.RecurrenceRule();
            rule.minute = [0,10,20,30,40,50];
            const j = schedule.scheduleJob(rule, function(){
                let now = new Date().format('yyyy年M月d日 hh:mm:ss');
                fs.appendFile(loggerPath,now+=os.EOL,(err)=>{
                    if(err) throw err
                })
              callback && callback()
            });
        }
    }
    
    const koaReq = require('koa2-request')
    const path = require('path')
    const { wechat } = require('../config')
    const { refreshTokenSchedule } = require('../config/schedule')
    const { readFile, writeFile, isFile } = require('../config/file')
    const FILEPATH = path.resolve(__dirname, '../file/accessToken.txt')
    
    class Token {
        constructor() {
            // 执行定时器,定时去判断是否过期,如果过期就重新获取
            refreshTokenSchedule(async () => {
                try {
                    let isFileExist;
                    try {
                        isFileExist = await isFile(FILEPATH);
                    } catch (e) {
                        // 说明文件还不存在
                        this.writeTokenToFile()
                    }
                    if (isFileExist) {
                        const oldAccessTokenObj = await readFile(FILEPATH)
                        const { expires_time } = JSON.parse(oldAccessTokenObj)
                        if (new Date().getTime() > expires_time) {
                            // 即将过期-重新获取
                            this.writeTokenToFile()
                        }
                    }
                } catch (err) {
                    console.error(err);
                }
            })
        }
        // 将token写入文件
        async writeTokenToFile() {
            try {
                const { access_token, expires_in } = await this.getAccessTokenApi();
                let expires_time = new Date().getTime() + (expires_in - 1800) * 1000; //提前半小时
                writeFile(FILEPATH, JSON.stringify({ access_token, expires_time }))
            } catch (err) {
                console.error(err.errmsg || 'ERROR')
            }
        }
        // 调用获取access_token的接口
        getAccessTokenApi() {
            const { appid, secret, grant_type } = wechat
            return new Promise((resolve, reject) => {
                koaReq({
                    method: 'get',
                    url: `https://api.weixin.qq.com/cgi-bin/token`,
                    qs: { appid, secret, grant_type },
                    json: true//设置返回的数据为json
                }, (error, response, body) => {
                    if (error) {
                        reject(error)
                    } else {
                        if (body.errcode) {
                            reject(body)
                        } else {
                            resolve(body)
                        }
                    }
                })
            })
        }
    }
    
    
    
    module.exports = Token
    
    
    // file.js
    const fs = require('fs')
    const os = require("os");
    
    module.exports = {
        // 读取文件
        readFile(fileName){
            return new Promise((resolve,reject)=>{
                fs.readFile(fileName, (err, data) => {
                    if (err) {
                        reject(err);
                    }else{
                        resolve(data) 
                    }
                });
            })
        },
        // 写入文件
        writeFile(fileName,data){
            return new Promise((resolve,reject)=>{
                fs.writeFile(fileName,data,'utf8',(err) => {
                    if (err) {
                        reject(err);
                    }else{
                        resolve(data)
                    }
              });
            })
        },
    
        appendFile(fileName,data){
            return new Promise((resolve,reject)=>{
                fs.appendFile(fileName,data+=os.EOL,(err) => {
                    if (err) {
                        reject(err);
                    }else{
                        resolve(data)
                    }
                });
            })
        },
        // 是否是file
        isFile(fileName){
            return new Promise((resolve,reject)=>{
                fs.stat(fileName, (err,stats) => {
                    if(err){
                        // 文件不存在
                        reject(err);
                    }else{
                        resolve(stats.isFile())
                    }
                });
            })
        }
    }
    

    四、配置服务器地址

    这个时候我们已经可以拿到access_token可以调用其他的微信方法了,现在我们进行服务器配置,可以先查看微信开发文档了解如何配置。

    其中要了解的是需要填写的Token,相当于是微信方和你之间的秘密,这个值是你任意填写的,但是之后会用到。当你配置服务器地址URL时,微信会发送一个GET请求到你填写的服务器地址URL上,其中GET请求的请求参数是signature、timestamp、nonce、echostr,当你接收到之后,你需要将timestamp、nonce以及你之前填写在微信后台的Token,进行一个字典序排序,并进行sha1(npm i sha1 -S)加密,如果加密后的字符串,与微信的请求中的signature的值一模一样,说明这个请求来自微信,你需要返回之前微信给你的echostr,这样你和微信之间才做好了服务器的验证。如果上面的功能你都完成了,你可以填写配置服务器地址URL,如果成功了,则说明验证成功,如果失败了,微信会给出提示。

    // router/wechat.js
    const router = require('koa-router')()
    const sha1 = require('sha1')
    const {wechat:{token}} = require('../config')
    
    router.prefix('/wechat');
    
    router.get('/', async (ctx, next) => {
        const {signature,nonce,timestamp,echostr} = ctx.query
        const passStr = [token, timestamp, nonce].sort().join('');
        const shaStr = sha1(passStr);
        if(shaStr === signature){
            // 说明该请求来自微信
            ctx.body = echostr;
        }else{
            ctx.body = 'error'
        }
    })
    

    Tips:因为微信公众号开发需要域名,如何在本地实时开发呢?我用的是ngrok,进行内网映射,免费的,教程在此。免去每次都要重新部署到服务器的烦恼。

    五、如何回复后台消息

    之前我们配置服务器地址的时候,写了一个GET接口,现在我们在此接口基础上,写一个POST请求,就可以处理消息了。但是要注意,微信接收到用户的消息,给你时是一个xml数据包,所以你需要对xml进行解析,并且再回复时,也需要将json串转为xml,再返回给微信。接收消息文档

    // router/wechat.js
    const router = require('koa-router')()
    const {wechat:{token}} = require('../config')
    const xml = require('../utils/xmlParse')
    const {message} = require('../utils/wx')
    
    router.post('/', async (ctx, next) => {
        const promise = new Promise((resolve, reject) => {
            let buf = ''
            ctx.req.setEncoding('utf8')
            ctx.req.on('data', (chunk) => {
                buf += chunk
            })
            ctx.req.on('end', () => {
                xml.xmlToJson(buf)
                .then(resolve)
                .catch(reject)
            })
        })
        
        await promise.then((xmlResult = {}) => {
            try{
                const {xml:msg} = xmlResult;
                let replyResult = ''; //回复信息
                switch(msg.MsgType[0]){
                case 'text':
                    replyResult = message.text(msg,'你的文采太好啦~')
                    break;
                case 'voice':
                    replyResult = message.text(msg,'你的声音太好听啦!')
                    break;
                default:
                    replyResult = message.text(msg,'成功了哦!')
                    break;
                }
                    ctx.body = replyResult;
                }catch(e){
                    console.error(e)
                }
            })
        .catch((e) => {
              e.status = 400
        })
        
        await next()
    })
    

    回复微信消息,json转xml

    // utils/wx
    const xml = require('../utils/xmlParse')
    exports.message = {
        text (msg, content) {
            return xml.jsonToXml({
                xml: {
                    ToUserName: msg.FromUserName,
                    FromUserName: msg.ToUserName,
                    CreateTime: Date.now(),
                    //   MsgType: msg.MsgType,
                    MsgType: 'text',
                    Content: content
                }
            })
        },
    }
    

    解析xml使用了xml2js插件 npm i xml2js -S

    // utils/xmlParse
    const xml2js = require('xml2js')
    
    exports.xmlToJson = (str) => {
        return new Promise((resolve, reject) => {
            const parseString = xml2js.parseString
            parseString(str, (err, result) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(result)
                }
            })
        })
    }
    
    exports.jsonToXml = (obj) => {
        const builder = new xml2js.Builder()
        return builder.buildObject(obj)
    }
    

    这样你就可以试着给你的公众号发消息啦!他已经会回复你了哦

    相关文章

      网友评论

          本文标题:使用Koa开发微信公众号

          本文链接:https://www.haomeiwen.com/subject/xewzpktx.html