接口函数,解决重复请求和并发请求问题
分为前端版本和服务器版本
/*
缓存并发接口函数,解决重复请求和并发请求问题
id：唯一值
cacheSecond:缓存时间,单位秒
syncFunc：加载函数
*/
const _map = {}
const _startTimeMap = {}
const _idArr=[]
const _resArr=[]
const _timeArr=[]
let len=0
let lenMax=100
async function CacheRequest (syncFunc,id,cacheSecond=0) {
const now = Date.now()
const idx=_idArr.indexOf(id)
if (idx>-1) {
if(now<_timeArr[idx]){
return _resArr[idx];
}else{
_idArr.splice(idx,1)
_resArr.splice(idx,1)
_timeArr.splice(idx,1)
if(len>0){
len--
}else{
len=lenMax
}
}
}
// 兼容并发加载的情况
if (!_map[id]) {
_map[id] = []
_startTimeMap[id] = now
const res = await syncFunc()
//缓存时间
if(cacheSecond>0){
_idArr[len]=id
_resArr[len]=res
_timeArr[len]=cacheSecond*1000+Date.now()
len++
if(len>lenMax){
len=0
}
}
setTimeout(function () {
if (_map[id].length > 0) {
_map[id].forEach(function (callback) {
callback(res)
})
}
delete _map[id]
delete _startTimeMap[id]
}, 0)
return res
} else {
// 10秒超时后，并发不做优化
if (now - _startTimeMap[id] < 10000) {
return new Promise(function (resolve) {
_map[id].push(resolve)
})
} else {
return syncFunc()
}
}
}
module.exports=CacheRequest
// function getUser () {
// console.log('只会请求一次')
// return new Promise(function (resolve){
// setTimeout(function (){
// resolve({name:'name'})
// },2000)
// })
//
// }
// //解决重复请求问题
// async function test1(){
// const user1=await CacheRequest(getUser,'xx123',3000)
// const user2=await CacheRequest(getUser,'xx123',3000)
// const user3=await CacheRequest(getUser,'xx123',3000)
// console.log('test1',user1,user2,user3)
// }
// test1()
// //解决并发请求问题
// async function test2(){
// CacheRequest(getUser,'xx123',).then(function (user){
// console.log('test2',user)
// })
// CacheRequest(getUser,'xx123',).then(function (user){
// console.log('test2',user)
// })
// CacheRequest(getUser,'xx123',).then(function (user){
// console.log('test2',user)
// })
// }
// test2()
服务器版本redis
/*
缓存并发接口函数,解决重复请求和并发请求问题
id：唯一值
cacheSecond:缓存时间,单位秒
syncFunc：加载函数
*/
const redis = require('redis')
const crypto = require("crypto");
const _map = {}
const _startTimeMap = {}
let lenMax=1000
const version='v1'
const _idCache={
idArr:[],
len:0,
}
let client;
function md5key(key) {
const content=version+key
if (content.length <= 32) return content
let md5 = crypto.createHash('md5')
md5.update(content)
return md5.digest('hex')
}
const serverCache={
interNum:0,
init:async function (){
if (client) return client
let clientOptions = {
url: `redis://127.0.0.1:6379`,
database: 9,
}
let _client = redis.createClient(clientOptions)
_client.on("error", function (error) {
console.error('redis:', error)
})
await _client.connect()
client=_client
const {value,time}=await this.get('_idCache')
if(value.idArr.length>lenMax){
const dArr=value.idArr.splice(lenMax)
dArr.forEach(async (key)=>{
await this.del(key)
})
}
Object.assign(_idCache,value)
return client
},
set:async function (key,value){
await client.set(md5key(key),JSON.stringify({ value, time:Date.now() }))
},
get:async function (key){
const data={}
try {
Object.assign(data,JSON.parse(await client.get(md5key(key))))
}catch (e){
console.error(e)
}
return data
},
del:async function (key){
await client.del(md5key(key))
},
setCache_idCache:async function(){
this.interNum++
await new Promise(cb => setTimeout(cb, 5000))
this.interNum--
if(this.interNum===0){
await this.set('_idCache',_idCache)
}
}
}
async function _CacheRequestRedis (syncFunc,id,cacheSecond=0) {
const now = Date.now()
const idx=_idCache.idArr.indexOf(id)
if (idx>-1) {
const md5Key=_idCache.idArr[idx]
const {value,time}=await serverCache.get(md5Key,cacheSecond)
//在有效时间
if(now<cacheSecond*1000+time){
return value
}else{
_idCache.idArr.splice(idx,1)
await serverCache.del(md5Key)
if(_idCache.len>0){
_idCache.len--
}else{
_idCache.len=lenMax-1
}
serverCache.setCache_idCache()
}
}
// 兼容并发加载的情况
if (!_map[id]) {
_map[id] = []
_startTimeMap[id] = now
const res = await syncFunc()
//缓存时间
if(cacheSecond>0){
if(_idCache.idArr[_idCache.len]){
await serverCache.del(_idCache.idArr[_idCache.len])
}
_idCache.idArr[_idCache.len]=id
const md5Key=id
await serverCache.set(md5Key,res)
_idCache.len++
if(_idCache.len>=lenMax){
_idCache.len=0
}
serverCache.setCache_idCache()
}
setTimeout(function () {
if (_map[id].length > 0) {
_map[id].forEach(function (callback) {
callback(res)
})
}
delete _map[id]
delete _startTimeMap[id]
}, 0)
return res
} else {
// 10秒超时后，并发不做优化
if (now - _startTimeMap[id] < 10000) {
return new Promise(function (resolve) {
_map[id].push(resolve)
})
} else {
return syncFunc()
}
}
}
let initCacheRequestRedis=false
async function CacheRequestRedis(syncFunc,id,cacheSecond=0){
if(!initCacheRequestRedis){
await _CacheRequestRedis(function (){
return serverCache.init()
},'initCacheRequestRedis')
initCacheRequestRedis=true
}
return _CacheRequestRedis(syncFunc,id,cacheSecond)
}
module.exports=CacheRequestRedis
// function getUser () {
// console.log('只会请求一次')
// return new Promise(function (resolve){
// setTimeout(function (){
// resolve({name:'name'})
// },2000)
// })
//
// }
// //解决重复请求问题
// async function test1(){
// const user1=await CacheRequestRedis(getUser,'xx123',3000)
// const user2=await CacheRequestRedis(getUser,'xx123',3000)
// const user3=await CacheRequestRedis(getUser,'xx123',3000)
// console.log('test1',user1,user2,user3)
// }
// test1()
// //解决并发请求问题
// async function test2(){
// CacheRequestRedis(getUser,'xx123',).then(function (user){
// console.log('test2',user)
// })
// CacheRequestRedis(getUser,'xx123',).then(function (user){
// console.log('test2',user)
// })
// CacheRequestRedis(getUser,'xx123',).then(function (user){
// console.log('test2',user)
// })
// }
// test2()
