如果微信小程序要获取微信登录的用户信息，需要拿到code去后台换取用户信息，具体步骤又如下：
首先服务端先安装两个包
npm i koa-weixin-auth --save
npm i koa-body --save
小程序端
<button bindgetuserinfo="login" open-type="getUserInfo" type="primary">登陆</button>
login(e) {
console.log(e);
let {userInfo,
encryptedData,
iv} = e.detail
wx.login({
success(res0) {
if (res0.code) {
//发起网络请求
wx.request({
url: 'http://localhost:3000/user/wexin-login',
method: 'POST',
header: {
'content-type': 'application/json'
},
data: {
code: res0.code,
userInfo,
encryptedData,
iv
},
success(res) {
console.log('请求成功', res.data)
getApp().globalData.token = res.data.data.authorizationToken
console.log('authorization', getApp().globalData.token)
},
fail(err) {
console.log('请求异常', err)
}
})
} else {
console.log('登录失败！' + res.errMsg)
}
}
})
},
服务端
const WeixinAuth = require("../lib/koa2-weixin-auth")
const WXBizDataCrypt = require('../lib/WXBizDataCrypt')
// 小程序的机要信息
const miniProgramAppId = '自己的appId'
const miniProgramAppSecret = '自己的appSecret'
const weixinAuth = new WeixinAuth(config.miniProgram.appId, config.miniProgram.appSecret);
// 这是第一次小程序登陆法
router.post("/wexin-login", async (ctx) => {
let { code } = ctx.request.body
const token = await weixinAuth.getAccessToken(code);
// const accessToken = token.data.access_token;
const openid = token.data.openid;
// const userinfo = await weixinAuth.getUser(openid)
// 这个地方有一个错误，invalid credential, access_token is invalid or not latest
// 拉取不到userInfo
ctx.status = 200
ctx.body = {
code: 200,
msg: 'ok',
data: openid
}
})
小程序端
<button bindgetuserinfo="login" open-type="getUserInfo" type="primary">登陆</button>
login(e) {
console.log(e);
let {
userInfo,
encryptedData,
iv
} = e.detail
console.log('userInfo', userInfo);
const requestLoginApi = (code)=>{
//发起网络请求
wx.request({
url: 'http://localhost:3000/user/wexin-login2',
method: 'POST',
header: {
'content-type': 'application/json'
},
data: {
code: code,
userInfo,
encryptedData,
iv
},
success(res) {
console.log('请求成功', res.data)
let token = res.data.data.authorizationToken
wx.setStorageSync('token', token)
onUserLogin(token)
console.log('authorization', token)
},
fail(err) {
console.log('请求异常', err)
}
})
}
const onUserLogin = (token)=>{
getApp().globalData.token = token
wx.showToast({
title: '登陆成功了',
})
}
wx.checkSession({
success () {
//session_key 未过期，并且在本生命周期一直有效
console.log('在登陆中');
let token = wx.getStorageSync('token')
if (token) onUserLogin(token)
},
fail () {
// session_key 已经失效，需要重新执行登录流程
wx.login({
success(res0) {
if (res0.code) {
requestLoginApi(res0.code)
} else {
console.log('登录失败！' + res.errMsg)
}
}
})
}
})
},
const WeixinAuth = require("../lib/koa2-weixin-auth")
const WXBizDataCrypt = require('../lib/WXBizDataCrypt')
// 小程序的机要信息
const miniProgramAppId = '自己的appId'
const miniProgramAppSecret = '自己的appSecret'
router.post("/wexin-login2", async (ctx) => {
console.log('request.body', ctx.request.body);
let { code,
userInfo,
encryptedData,
iv,
sessionKeyIsValid } = ctx.request.body
console.log("sessionKeyIsValid", sessionKeyIsValid);
let sessionKey
// 如果客户端有token，则传来，解析
if (sessionKeyIsValid) {
let token = ctx.request.header.authorization;
token = token.split(' ')[1]
// token有可能是空的
if (token) {
let payload = await util.promisify(jsonwebtoken.verify)(token, config.jwtSecret).catch(err => {
console.log('err', err);
})
console.log('payload', payload);
if (payload) sessionKey = payload.sessionKey
}
}
// 除了尝试从token中获取sessionKey，还可以从数据库中或服务器redis缓存中获取
// 如果在db或redis中存储，可以与cookie结合起来使用，
// 目前没有这样做，sessionKey仍然存在丢失的时候，又缺少一个wx.clearSession方法
//
console.log("ctx.session.sessionKeyRecordId", ctx.session.sessionKeyRecordId);
if (sessionKeyIsValid && !sessionKey && ctx.session.sessionKeyRecordId) {
let sessionKeyRecordId = ctx.session.sessionKeyRecordId
console.log("sessionKeyRecordId", sessionKeyRecordId);
// 如果还不有找到历史上有效的sessionKey，从db中取一下
let sesskonKeyRecordOld = await SessionKey.findOne({
where: {
id: ctx.session.sessionKeyRecordId
}
})
if (sesskonKeyRecordOld) sessionKey = sesskonKeyRecordOld.sessionKey
console.log("从db中查找sessionKey3", sessionKey);
}
// 如果从token中没有取到，则从服务器上取一次
if (!sessionKey) {
const token = await weixinAuth.getAccessToken(code)
// 目前微信的 session_key, 有效期3天
sessionKey = token.data.session_key;
console.log('sessionKey2', sessionKey);
}
let decryptedUserInfo
var pc = new WXBizDataCrypt(config.miniProgram.appId, sessionKey)
// 有可能因为sessionKey不与code匹配，而出错
// 通过错误，通知前端再重新拉取code
decryptedUserInfo = pc.decryptData(encryptedData, iv)
console.log('解密后 decryptedUserInfo.openId: ', decryptedUserInfo.openId)
let user = await User.findOne({ where: { openId: decryptedUserInfo.openId } })
if (!user) {//如果用户没有查到，则创建
let createRes = await User.create(decryptedUserInfo)
console.log("createRes", createRes);
if (createRes) user = createRes.dataValues
}
let sessionKeyRecord = await SessionKey.findOne({ where: { uid: user.id } })
if (sessionKeyRecord) {
await sessionKeyRecord.update({
sessionKey: sessionKey
})
} else {
let sessionKeyRecordCreateRes = await SessionKey.create({
uid: user.id,
sessionKey: sessionKey
})
sessionKeyRecord = sessionKeyRecordCreateRes.dataValues
console.log("created record", sessionKeyRecord);
}
// ctx.cookies.set("sessionKeyRecordId", sessionKeyRecord.id)
ctx.session.sessionKeyRecordId = sessionKeyRecord.id
console.log("sessionKeyRecordId", sessionKeyRecord.id);
// 添加上openId与sessionKey
let authorizationToken = jsonwebtoken.sign({
uid: user.id,
nickName: decryptedUserInfo.nickName,
avatarUrl: decryptedUserInfo.avatarUrl,
openId: decryptedUserInfo.openId,
sessionKey: sessionKey
},
config.jwtSecret,
{ expiresIn: '3d' }//修改为3天，这是sessionKey的有效时间
)
Object.assign(decryptedUserInfo, { authorizationToken })
ctx.status = 200
ctx.body = {
code: 200,
msg: 'ok',
data: decryptedUserInfo
}
})
koa2-weixin-auth.js
const querystring = require("querystring");
const request = require("request");
const AccessToken = function(data){
if(!(this instanceof AccessToken)){
return new AccessToken(data);
}
this.data = data;
}
/*!
* 检查AccessToken是否有效，检查规则为当前时间和过期时间进行对比
*
* Examples:
* ```
* token.isValid();
* ```
*/
AccessToken.prototype.isValid = function() {
return !!this.data.session_key && (new Date().getTime()) < (this.data.create_at + this.data.expires_in * 1000);
}
/**
* 根据appid和appsecret创建OAuth接口的构造函数
* 如需跨进程跨机器进行操作，access token需要进行全局维护
* 使用使用token的优先级是：
*
* 1. 使用当前缓存的token对象
* 2. 调用开发传入的获取token的异步方法，获得token之后使用（并缓存它）。
* Examples:
* ```
* var OAuth = require('oauth');
* var api = new OAuth('appid', 'secret');
* ```
* @param {String} appid 在公众平台上申请得到的appid
* @param {String} appsecret 在公众平台上申请得到的app secret
*/
const Auth = function (appid, appsecret) {
this.appid = appid;
this.appsecret = appsecret;
this.store = {};
this.getToken = function (openid) {
return this.store[openid];
};
this.saveToken = function (openid, token) {
this.store[openid] = token;
};
}
/**
* 获取授权页面的URL地址
* @param {String} redirect 授权后要跳转的地址
* @param {String} state 开发者可提供的数据
* @param {String} scope 作用范围，值为snsapi_userinfo和snsapi_base，前者用于弹出，后者用于跳转
*/
Auth.prototype.getAuthorizeURL = function(redirect_uri, scope, state) {
return new Promise((resolve, reject) => {
const url = "https://open.weixin.qq.com/connect/oauth2/authorize";
let info = {
appid: this.appid,
redirect_uri: redirect_uri,
scope: scope || 'snsapi_base',
state: state || '',
response_type: 'code'
}
resolve(url + '?' + querystring.stringify(info) + '#wechat_redirect')
})
}
/*!
* 处理token，更新过期时间
*/
Auth.prototype.processToken = function(data){
data.create_at = new Date().getTime();
// 存储token
this.saveToken(data.openid, data);
return AccessToken(data);
}
/**
* 根据授权获取到的code，换取access token和openid
* 获取openid之后，可以调用`wechat.API`来获取更多信息
* Examples:
* ```
* api.getAccessToken(code);
* ```
* Exception:
*
* - `err`, 获取access token出现异常时的异常对象
*
* 返回值:
* ```
* {
* data: {
* "access_token": "ACCESS_TOKEN",
* "expires_in": 7200,
* "refresh_token": "REFRESH_TOKEN",
* "openid": "OPENID",
* "scope": "SCOPE"
* }
* }
* ```
* @param {String} code 授权获取到的code
*/
Auth.prototype.getAccessToken = function(code){
return new Promise((resolve, reject) => {
const url = "https://api.weixin.qq.com/sns/jscode2session";
// const url = "https://api.weixin.qq.com/sns/oauth2/access_token";
const info = {
appid: this.appid,
secret: this.appsecret,
js_code: code,
grant_type: 'authorization_code'
}
request.post(url,{form:info},(err, res, body) => {
if(err){
reject(err)
}else{
const data = JSON.parse(body);
resolve(this.processToken(data))
}
})
})
}
/**
* 根据refresh token，刷新access token，调用getAccessToken后才有效
* Examples:
* ```
* api.refreshAccessToken(refreshToken);
* ```
* Exception:
*
* - `err`, 刷新access token出现异常时的异常对象
*
* Return:
* ```
* {
* data: {
* "access_token": "ACCESS_TOKEN",
* "expires_in": 7200,
* "refresh_token": "REFRESH_TOKEN",
* "openid": "OPENID",
* "scope": "SCOPE"
* }
* }
* ```
* @param {String} refreshToken refreshToken
*/
Auth.prototype.refreshAccessToken = function(refreshToken){
return new Promise((resolve, reject) => {
const url = 'https://api.weixin.qq.com/sns/oauth2/refresh_token';
var info = {
appid: this.appid,
grant_type: 'refresh_token',
refresh_token: refreshToken
};
request.post(url,{form:info},(err, res, body) => {
if(err){
reject(err)
}else{
const data = JSON.parse(body);
resolve(this.processToken(data))
}
})
})
}
/**
* 根据openid，获取用户信息。
* 当access token无效时，自动通过refresh token获取新的access token。然后再获取用户信息
* Examples:
* ```
* api.getUser(options);
* ```
*
* Options:
* ```
* openId
* // 或
* {
* "openId": "the open Id", // 必须
* "lang": "the lang code" // zh_CN 简体，zh_TW 繁体，en 英语
* }
* ```
* Callback:
*
* - `err`, 获取用户信息出现异常时的异常对象
*
* Result:
* ```
* {
* "openid": "OPENID",
* "nickname": "NICKNAME",
* "sex": "1",
* "province": "PROVINCE"
* "city": "CITY",
* "country": "COUNTRY",
* "headimgurl": "http://wx.qlogo.cn/mmopen/g3MonUZtNHkdmzicIlibx6iaFqAc56vxLSUfpb6n5WKSYVY0ChQKkiaJSgQ1dZuTOgvLLrhJbERQQ4eMsv84eavHiaiceqxibJxCfHe/46",
* "privilege": [
* "PRIVILEGE1"
* "PRIVILEGE2"
* ]
* }
* ```
* @param {Object|String} options 传入openid或者参见Options
*/
Auth.prototype.getUser = async function(openid){
const data = this.getToken(openid);
console.log("getUser",data);
if(!data){
var error = new Error('No token for ' + options.openid + ', please authorize first.');
error.name = 'NoOAuthTokenError';
throw error;
}
const token = AccessToken(data);
var accessToken;
if(token.isValid()){
accessToken = token.data.session_key;
}else{
var newToken = await this.refreshAccessToken(token.data.refresh_token);
accessToken = newToken.data.session_key
}
console.log('accessToken',accessToken)
return await this._getUser(openid,accessToken);
}
Auth.prototype._getUser = function(openid, accessToken,lang){
return new Promise((resolve, reject) => {
const url = "https://api.weixin.qq.com/sns/userinfo";
const info = {
access_token:accessToken,
openid:openid,
lang:lang||'zh_CN'
}
request.post(url,{form:info},(err, res, body) => {
if(err){
reject(err)
}else{
resolve(JSON.parse(body));
}
})
})
}
/**
* 根据code，获取用户信息。
* Examples:
* ```
* var user = yield api.getUserByCode(code);
* ```
* Exception:
*
* - `err`, 获取用户信息出现异常时的异常对象
*
* Result:
* ```
* {
* "openid": "OPENID",
* "nickname": "NICKNAME",
* "sex": "1",
* "province": "PROVINCE"
* "city": "CITY",
* "country": "COUNTRY",
* "headimgurl": "http://wx.qlogo.cn/mmopen/g3MonUZtNHkdmzicIlibx6iaFqAc56vxLSUfpb6n5WKSYVY0ChQKkiaJSgQ1dZuTOgvLLrhJbERQQ4eMsv84eavHiaiceqxibJxCfHe/46",
* "privilege": [
* "PRIVILEGE1"
* "PRIVILEGE2"
* ]
* }
* ```
* @param {String} code 授权获取到的code
*/
Auth.prototype.getUserByCode = async function(code){
const token = await this.getAccessToken(code);
return await this.getUser(token.data.openid);
}
module.exports = Auth;
WXBizDataCrypt .js
var crypto = require('crypto')
function WXBizDataCrypt(appId, sessionKey) {
this.appId = appId
this.sessionKey = sessionKey
}
WXBizDataCrypt.prototype.decryptData = function (encryptedData, iv) {
// base64 decode
var sessionKey = new Buffer.from(this.sessionKey, 'base64')
encryptedData = new Buffer.from(encryptedData, 'base64')
iv = new Buffer.from(iv, 'base64')
try {
// 解密
var decipher = crypto.createDecipheriv('aes-128-cbc', sessionKey, iv)
// 设置自动 padding 为 true，删除填充补位
decipher.setAutoPadding(true)
// 问题是cipher.update(data, 'binary')输出一个缓冲区，该缓冲区自动字符串化为十六进制编码的字符串
var decoded = decipher.update(encryptedData,'binary',"utf8")
// 这里有一个错误发生：
// error:06065064:digital envelope routines:EVP_DecryptFinal_ex:bad decrypt
// 本质是由于sessionKey与code不匹配造成的
decoded += decipher.final('utf8')
decoded = JSON.parse(decoded)
} catch (err) {
console.log('err',err);
throw new Error('Illegal Buffer')
}
if (decoded.watermark.appid !== this.appId) {
throw new Error('Illegal Buffer')
}
return decoded
}
module.exports = WXBizDataCrypt