From 0006a38c54850c0bfc9a4afc73bc895e8523188a Mon Sep 17 00:00:00 2001 From: kuangthree Date: Sat, 3 Feb 2024 12:48:20 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- noname/library/cache/cacheContext.js | 67 +++++++++++++++++++++------- 1 file changed, 50 insertions(+), 17 deletions(-) diff --git a/noname/library/cache/cacheContext.js b/noname/library/cache/cacheContext.js index 5bb071023..18d6b3e81 100644 --- a/noname/library/cache/cacheContext.js +++ b/noname/library/cache/cacheContext.js @@ -9,29 +9,49 @@ import { hex_md5 } from "../crypt/md5.js"; export class CacheContext{ constructor(){ - this.lib = this.createCacheProxy(Library); - this.game = this.createCacheProxy(Game); - this.get = this.createCacheProxy(Get); + this.lib = this._createCacheProxy(Library); + this.game = this._createCacheProxy(Game); + this.get = this._createCacheProxy(Get); this.sourceMap = new Map(); this.storageMap = new Map(); } + /** + * 设置当前是否处于缓存环境。当使用inject对类进行注入时，只在缓存环境下会返回缓存值。 + * @param {boolean} cache + */ static setInCacheEnvironment(cache){ _status.cacheEnvironment = cache; } + /** + * 设置一个公有的缓存上下文。缓存上下文持有期间，假设所缓存的函数在参数相同时，绝对不会（注意是绝对不会）返回不同的返回值。 + * 使用inject对类进行注入时，将应用公有的缓存上下文。 + * @param {CacheContext} context + */ static setCacheContext(context){ _status.cacheContext = context; } + /** + * 返回当前公有的缓存上下文。 + * @returns {CacheContext} 缓存上下文 + */ static getCacheContext(){ return _status.cacheContext; } + /** + * 移除当前公有的缓存上下文。 + */ static removeCacheContext(){ delete _status.cacheContext; } + /** + * 返回公有的缓存上下文，没有就创建一个新的返回（不会设置为新的公有缓存上下文）。 + * @returns {CacheContext} 缓存上下文 + */ static requireCacheContext(){ let cache = CacheContext.getCacheContext(); if(!cache){ @@ -40,6 +60,13 @@ export class CacheContext{ return cache; } + /** + * 对一个对象进行代理，对象的所有函数都将按条件返回缓存结果。 + * 注意：以cache开头的方法依然保持原来的调用。 + * 如果所代理的对象拥有cacheSupportFunction方法（返回一个方法名数组），只有允许的方法才会返回缓存结果，剩余方法依然保持原来的调用。 + * @param {any} source 需要代理的对象 + * @returns + */ delegate(source){ if(source === null || source === undefined)return source; if(source._cacheDelegateSource)return source; @@ -47,11 +74,17 @@ export class CacheContext{ if(proxy){ return proxy; } - proxy = this.createCacheProxy(source); + proxy = this._createCacheProxy(source); this.sourceMap.set(source,proxy); return proxy; } + /** + * 对一个类进行注入。methods为可以返回缓存的所有方法。注入后，此类的相关方法会在公有缓存上下文下返回缓存值。 + * @param {any} source + * @param {Array} methods + * @returns + */ static inject(source,methods){ if(source == null || source === undefined)return null; for(let method of methods){ @@ -63,7 +96,7 @@ export class CacheContext{ return func.call(this,...arguments); } return CacheContext - .getCacheValueFromObject(CacheContext.requireCacheContext().requireStorage(this),method,arguments,this,func); + ._getCacheValueFromObject(CacheContext.requireCacheContext()._requireStorage(this),method,arguments,this,func); }catch(e){ return func.call(this,...arguments); } @@ -71,7 +104,7 @@ export class CacheContext{ } } - requireStorage(obj){ + _requireStorage(obj){ let storage = this.storageMap.get(obj); if(!storage){ storage = {}; @@ -85,7 +118,7 @@ export class CacheContext{ * @param {T} delegateObject * @returns {T} */ - createCacheProxy(delegateObject){ + _createCacheProxy(delegateObject){ const cacheFuncObj = {}; const cacheStorage = {}; return new Proxy(delegateObject,{ @@ -106,7 +139,7 @@ export class CacheContext{ wrapFunc = function(){ try{ return CacheContext - .getCacheValueFromObject(cacheStorage,key,arguments,target); + ._getCacheValueFromObject(cacheStorage,key,arguments,target); }catch(e){ return value.call(target,...arguments); } @@ -120,10 +153,10 @@ export class CacheContext{ }); } - static getCacheValueFromObject(storage,key,params,source,func){ + static _getCacheValueFromObject(storage,key,params,source,func){ let cache = storage; - let funcCache = CacheContext.ensureMember(cache,key); - let cacheKey = CacheContext.wrapParametersToCacheKey(params); + let funcCache = CacheContext._ensureMember(cache,key); + let cacheKey = CacheContext._wrapParametersToCacheKey(params); let ret = funcCache[cacheKey]; if(ret === undefined){ ret = ((typeof func == 'function')?func:source[key]).call(source,...params); @@ -135,7 +168,7 @@ export class CacheContext{ return ret; } - static ensureMember(obj,key){ + static _ensureMember(obj,key){ let mem = obj[key]; if(!mem){ mem = {}; @@ -144,14 +177,14 @@ export class CacheContext{ return mem; } - static wrapParametersToCacheKey(params){ + static _wrapParametersToCacheKey(params){ return Array.from(params) .filter(p=>!(p instanceof CacheContext)) - .map(param=>CacheContext.wrapParameterToCacheKey(param)) + .map(param=>CacheContext._wrapParameterToCacheKey(param)) .join('-'); } - static wrapParameterToCacheKey(param){ + static _wrapParameterToCacheKey(param){ if(param === null)return 'null'; if(param === undefined)return 'undefined'; if(typeof param === 'string')return `[str:${param}]`; @@ -159,11 +192,11 @@ export class CacheContext{ if(typeof param === 'boolean')return `[bl:${param}]`; if(typeof param.getCacheKey == 'function')return param.getCacheKey(); if(Array.isArray(param)){ - return `[arr:[${param.filter(p=>!(p instanceof CacheContext)).map(p=>CacheContext.wrapParameterToCacheKey(p)).join('-')}]]`; + return `[arr:[${param.filter(p=>!(p instanceof CacheContext)).map(p=>CacheContext._wrapParameterToCacheKey(p)).join('-')}]]`; } if(typeof param === 'function')return `[f:${hex_md5(param.toString())}]`; let entries = Object.entries(param); entries.sort((a,b)=>a[0]e[0]+":"+CacheContext.wrapParameterToCacheKey(e[1])).join(',')}}]`; + return `[obj:{${entries.map(e=>e[0]+":"+CacheContext._wrapParameterToCacheKey(e[1])).join(',')}}]`; } } \ No newline at end of file