精华内容
下载资源
问答
  • 缓存方案
    千次阅读
    2020-07-08 17:23:22
        /**
         * 从缓存查询access_token
         */
        @Override
        public String getAccessToken() throws Exception {
            // 从缓存取
            String accessToken = getAccessTokenCache();
            if (StringUtils.isNotBlank(accessToken)) {
                return accessToken;
            }
    
            // 缓存没有,从微信取
            AccessTokenVO accessTokenVO = WeChatUtils.getAccessToken(wxAppId, wxAppSecret);
            if (accessTokenVO == null || StringUtils.isBlank(accessTokenVO.getAccess_token())) {
                throw new RuntimeException("从微信取access_token失败");
            }
    
            // 放入缓存,设置失效时间
            writeAccessTokenCache(accessTokenVO);
    
            return accessTokenVO.getAccess_token();
        }
        
        /**
         * 从缓存取access_token
         */
        private String getAccessTokenCache() {
            return redisTemplate.opsForValue().get(ACCESS_TOKEN_KEY);
        }
    
        /**
         * access_token放入缓存
         */
        private void writeAccessTokenCache(AccessTokenVO accessTokenVO) {
            redisTemplate.opsForValue().set(ACCESS_TOKEN_KEY,
                    accessTokenVO.getAccess_token(), accessTokenVO.getExpires_in(), TimeUnit.SECONDS);
        }
    
        /**
         * WeChatUtils.getAccessToken
         */
        public static AccessTokenVO getAccessToken(String appId, String userAppSecret) throws Exception {
            String url = String.format(ACCESS_TOKEN_URL, appId, userAppSecret);
    
            String result = HttpClientUtils.doGet(url);
            if (StringUtils.isNotBlank(result)) {
                return JSONObject.parseObject(result, AccessTokenVO.class);
            }
            return null;
        }
    
    

     

    更多相关内容
  • 移动端静态资源缓存方案 - CandyWebCache.pdf
  • 为了保证网络存储的负载平衡并避免在节点或磁盘故障的情况下造成不可恢复的损失,提出一种基于均衡数据放置策略的分布式网络存储编码缓存方案,针对大型高速缓存和小型缓存分别给出了不同的解决办法。首先,将Maddah...
  • 结合对象存储系统的数据访问模式,综合设计客户端和元数据服务的缓存,构造存储系统的合作缓存方案.该方案将客户端和元数据服务器的缓存作为整体进行设计,以达到提高缓存利用率的目的;通过缓存准入策略合理选择...
  • dubbo+zookeeper缓存方案

    2018-06-03 12:09:00
    dubbo+zookeeper缓存方案 dubbo+zookeeper缓存方案dubbo+zookeeper缓存方案dubbo+zookeeper缓存方案
  • 针对基于代理的分布式VOD系统,提出一种使网络带宽消耗最小的最优代理缓存方案,开发了一种全局试探寻优法,使各种流行度节目得到最优的缓存配置;通过把缓存方案与典型的节目调度策略相结合,定量地分析了缓存配置...
  • uniapp手机端图片缓存方案

    千次阅读 2021-09-28 17:19:58
    uniapp手机端图片缓存方案 思路:定义缓存图片key值规则,每次加载网络图片时,首先根据key获取本地存储的数据,查询是否有对应文件路径,如果有缓存内容,直接返回本地图片路径去渲染显示,若没有缓存数据,就用...

    uniapp手机端图片缓存方案

    思路:定义缓存图片key值规则,每次加载网络图片时,首先根据key获取本地存储的数据,查询是否有对应文件路径,如果有缓存内容,直接返回本地图片路径去渲染显示,若没有缓存数据,就用图片网络路径去下载并保存到本地

    1. 定义获取缓存图片的全局js函数
    /*
     * @description 获取文件的缓存路径,如果文件未缓存,则直接返回网络路径,并下载缓存
     * @method getImageCache
     * @param {String} filePath 完整的图片下载路径,如果没有从缓存中获取到,则用这个路径去下载
     * @param {String} fileMd5 文件md5,必须唯一
     * @return {Object} promise对象
    */
    
    const getImageCache = function(filePath, fileMd5) {
    	// 图片缓存key值
    	let storageKey = 'IMAGE_CACHE_INFO_' + fileMd5
    	// 首先获取本地存储的数据,查询是否有对应文件路径,如果有缓存内容,直接返回
    	const cacheFileInfo = uni.getStorageSync(storageKey)
    	if (cacheFileInfo) {
    		console.log("已缓存为:" + cacheFileInfo)
    		return cacheFileInfo
    	} else {
    		console.log("未缓存,进行下载保存")
    		// 如果没有,执行下载,并存储起来后
    		uni.downloadFile({
    		    url: filePath,
    		    success: (res) => {
    		        if (res.statusCode === 200) {
    		            console.log('下载成功');
    					// 再进行本地保存
    					uni.saveFile({
    					      tempFilePath: res.tempFilePath,
    					      success: function (res2) {
    							  console.log(res2.savedFilePath)
    							  uni.setStorageSync(storageKey, res2.savedFilePath)
    							  return res2.savedFilePath
    					      },
    						  fail: function (res2) {
    						  	return filePath
    						  }
    					    })
    		        } else {
    					console.log('下载临时文件失败')
    					return filePath
    				}
    		    },
    			fail: (res) => {
    				console.log(res)
    				return filePath
    			}
    		})
    	}
    }
    

    2.封装一个加载缓存图片的组件

    <template>
    	<view class="wrap">
    		<image :src="src" :style="{width: width,height:height,borderRadius:radius}"></image>
        </view> 
    </template>
    
    <script>
    	export default {
    		props: {
    			url: {
    				type: String,
    				default(){
    					return ''
    				}
    			},
    			fileMd5: {
    				type: String,
    				default(){
    					return ''
    				}
    			},
    			width: {
    				type: String,
    				default(){
    					return '';
    				}
    			},
    			height: {
    				type: String,
    				default(){
    					return '';
    				}
    			},
    			radius: {
    				type: String,
    				default(){
    					return '';
    				}
    			}
    		},
    		data() {
    			return {
    					src: '' // 图片地址
    			}
    		},
    		watch: {
    			// 监听头像md5值的变化
    			fileMd5(val) { 
    				// 查找获取图片缓存
    				this.getImageCache()
    			}
    		},
    		created() {
    			// 查找获取图片缓存
    			this.getImageCache()
    		},
    		methods: {
    			// 查找获取图片缓存
    			async getImageCache() { 
    				// #ifdef APP-PLUS
    				var result = await this.$util.getImageCache(this.url, this.fileMd5)
    				if (result) {
    					this.src = result
    				} else {
    					this.src = this.url
    				}
    				// #endif
    				// #ifndef APP-PLUS
    				this.src = this.url
    				// #endif
    			}
    		}
    	}
    </script>
    
    <style scoped lang="scss">
    	.wrap {
    	}
    </style>
    
    

    3.调用
    正确引入组件后

    <cache-image v-if="avatarMd5" :url="avatar" :fileMd5="avatarMd5" width="140rpx" height="140rpx" radius="100%"></cache-image>
    

    便能实现手机端缓存网络图片功能,每次加载图片根据设定的key去查缓存数据,没有便下载并保存到本地,下次加载就会是直接拿的本地缓存图片的地址

    展开全文
  • 前端 api 请求缓存方案

    千次阅读 2019-04-27 10:45:56
    在开发 web 应用程序时,性能都是必不可少的话题。对于webpack打包的单页面应用程序而言,我们可以采用很多方式来对性能进行优化,比方说 tree-shaking...而事实上,缓存一定是提升web应用程序有效方法之一,尤其是...

    在开发 web 应用程序时,性能都是必不可少的话题。对于webpack打包的单页面应用程序而言,我们可以采用很多方式来对性能进行优化,比方说 tree-shaking、模块懒加载、利用 extrens 网络cdn 加速这些常规的优化。甚至在vue-cli 项目中我们可以使用 --modern 指令生成新旧两份浏览器代码来对程序进行优化。

    而事实上,缓存一定是提升web应用程序有效方法之一,尤其是用户受限于网速的情况下。提升系统的响应能力,降低网络的消耗。当然,内容越接近于用户,则缓存的速度就会越快,缓存的有效性则会越高。

    以客户端而言,我们有很多缓存数据与资源的方法,例如 标准的浏览器缓存 以及 目前火热的 Service worker。但是,他们更适合静态内容的缓存。例如 html,js,css以及图片等文件。而缓存系统数据,我采用另外的方案。

    那我现在就对我应用到项目中的各种 api 请求缓存方案,从简单到复杂依次介绍一下。

    方案一 数据缓存

    简单的 数据 缓存,第一次请求时候获取数据,之后便使用数据,不再请求后端api。
    代码如下:

    const dataCache = new Map()
    
    async getWares() {
        let key = 'wares'
        // 从data 缓存中获取 数据
        let data = dataCache.get(key)
        if (!data) {
            // 没有数据请求服务器
            const res = await request.get('/getWares')
            
            // 其他操作
            ...
            data = ...
    
            // 设置数据缓存
            dataCache.set(key, data)
    
        }
        return data
    } 
    

    第一行代码 使用了 es6以上的 Map,如果对map不是很理解的情况下,你可以参考 ECMAScript 6 入门 Set 和 Map或者 Exploring ES6 关于 map 和 set的介绍,此处可以理解为一个键值对存储结构。

    之后 代码 使用 了 async 函数,可以将异步操作变得更为方便。 你可以参考ECMAScript 6 入门 async函数来进行学习或者巩固知识。

    代码本身很容易理解,是利用 Map 对象对数据进行缓存,之后调用从 Map 对象来取数据。对于及其简单的业务场景,直接利用此代码即可。

    调用方式:

    getWares().then( ... )
    // 第二次调用 取得先前的data
    getWares().then( ... )
    

    方案二 promise缓存

    方案一本身是不足的。因为如果考虑同时两个以上的调用此 api,会因为请求未返回而进行第二次请求api。当然,如果你在系统中添加类似于 vuex、redux这样的单一数据源框架,这样的问题不太会遇到,但是有时候我们想在各个复杂组件分别调用api,而不想对组件进行组件通信数据时候,便会遇到此场景。

    const promiseCache = new Map()
    
    getWares() {
        const key = 'wares'
        let promise = promiseCache.get(key);
        // 当前promise缓存中没有 该promise
        if (!promise) {
            promise = request.get('/getWares').then(res => {
                // 对res 进行操作
                ...
            }).catch(error => {
                // 在请求回来后,如果出现问题,把promise从cache中删除 以避免第二次请求继续出错S
                promiseCache.delete(key)
                return Promise.reject(error)
            })
        }
        // 返回promise
        return promise
    }
    

    该代码避免了方案一的同一时间多次请求的问题。同时也在后端出错的情况下对promise进行了删除,不会出现缓存了错误的promise就一直出错的问题。

    调用方式:

    getWares().then( ... )
    // 第二次调用 取得先前的promise
    getWares().then( ... )
    

    方案三 多promise 缓存

    该方案是同时需要 一个以上 的api请求的情况下,对数据同时返回,如果某一个api发生错误的情况下。均不返回正确数据。

    const querys ={
        wares: 'getWares',
        skus: 'getSku'
    }
    const promiseCache = new Map()
    
    async queryAll(queryApiName) {
        // 判断传入的数据是否是数组
        const queryIsArray = Array.isArray(queryApiName)
        // 统一化处理数据,无论是字符串还是数组均视为数组
        const apis = queryIsArray ? queryApiName : [queryApiName]
        
        // 获取所有的 请求服务
        const promiseApi = []
    
        apis.forEach(api => {
            // 利用promise 
            let promise = promiseCache.get(api)
    
            if (promise) {
                // 如果 缓存中有,直接push
                promise.push(promise)
            } else {
                 promise = request.get(querys[api]).then(res => {
                    // 对res 进行操作
                    ...
                    }).catch(error => {
                    // 在请求回来后,如果出现问题,把promise从cache中删除
                    promiseCache.delete(api)
                    return Promise.reject(error)
                })
                promiseCache.set(api, promise)
                promiseCache.push(promise)
            }
        })
        return Promise.all(promiseApi).then(res => {
            // 根据传入的 是字符串还是数组来返回数据,因为本身都是数组操作
            // 如果传入的是字符串,则需要取出操作
            return queryIsArray ? res : res[0]
        })
    }
    
    

    该方案是同时获取多个服务器数据的方式。可以同时获得多个数据进行操作,不会因为单个数据出现问题而发生错误。

    调用方式

    queryAll('wares').then( ... )
    // 第二次调用 不会去取 wares,只会去skus
    queryAll(['wares', 'skus']).then( ... )
    

    方案四 添加时间有关的缓存

    往往缓存是有危害的,如果我们在知道修改了数据的情况下,直接把 cache 删除即可,此时我们调用方法就可以向服务器进行请求。这样我们规避了前端显示旧的的数据。但是我们可能一段时间没有对数据进行操作,那么此时旧的数据就一直存在,那么我们最好规定个时间来去除数据。
    该方案是采用了 类 持久化数据来做数据缓存,同时添加了过期时长数据以及参数化。
    代码如下: 首先定义持久化类,该类可以存储 promise 或者 data

    class ItemCache() {
        construct(data, timeout) {
            this.data = data
            // 设定超时时间,设定为多少秒
            this.timeout = timeout
            // 创建对象时候的时间,大约设定为数据获得的时间
            this.cacheTime = (new Date()).getTime
        }
    }
    

    然后我们定义该数据缓存。我们采用Map 基本相同的api

    class ExpriesCache {
        // 定义静态数据map来作为缓存池
        static cacheMap =  new Map()
    
        // 数据是否超时
        static isOverTime(name) {
            const data = ExpriesCache.cacheMap.get(name)
            
            // 没有数据 一定超时
            if (!data) return true
    
            // 获取系统当前时间戳
            const currentTime = (new Date()).getTime()        
            
            // 获取当前时间与存储时间的过去的秒数
            const overTime = (currentTime - data.cacheTime) / 1000
            
            // 如果过去的秒数大于当前的超时时间,也返回null让其去服务端取数据
            if (Math.abs(overTime) > data.timeout) {
                // 此代码可以没有,不会出现问题,但是如果有此代码,再次进入该方法就可以减少判断。
                ExpriesCache.cacheMap.delete(name)
                return true
            }
    
            // 不超时
            return false
        }
    
        // 当前data在 cache 中是否超时
        static has(name) {
            return !ExpriesCache.isOverTime(name)
        }
    
        // 删除 cache 中的 data
        static delete(name) {
            return ExpriesCache.cacheMap.delete(name) 
        }
    
        // 获取
        static get(name) {
            const isDataOverTiem = ExpriesCache.isOverTime(name)
            //如果 数据超时,返回null,但是没有超时,返回数据,而不是 ItemCache 对象
            return isDataOverTiem ? null : ExpriesCache.cacheMap.get(name).data
        }
    
        // 默认存储20分钟
        static set(name, data, timeout = 1200) {
            // 设置 itemCache
            const itemCache = mew ItemCache(data, timeout)
            //缓存
            ExpriesCache.cacheMap.set(name, itemCache)
        }
    }
    

    此时数据类以及操作类 都已经定义好,我们可以在api层这样定义

    // 生成key值错误
    const generateKeyError = new Error("Can't generate key from name and argument")
    
    // 生成key值
    function generateKey(name, argument) {
        // 从arguments 中取得数据然后变为数组
        const params = Array.from(argument).join(',')
        
        try{
            // 返回 字符串,函数名 + 函数参数
            return `${name}:${params}`
        }catch(_) {
            // 返回生成key错误
            return generateKeyError
        }
    }
    
    async getWare(params1, params2) {
        // 生成key
        const key = generateKey('getWare', [params1, params2]) 
        // 获得数据
        let data = ExpriesCache.get(key)
        if (!data) {
            const res = await request('/getWares', {params1, params2})
            // 使用 10s 缓存,10s之后再次get就会 获取null 而从服务端继续请求
            ExpriesCache.set(key, res, 10)
        }
        return data
    }
    

    该方案使用了 过期时间 和 api 参数不同而进行 缓存的方式。已经可以满足绝大部分的业务场景。

    调用方式

    getWares(1,2).then( ... )
    // 第二次调用 取得先前的promise
    getWares(1,2).then( ... )
    // 不同的参数,不取先前promise
    getWares(1,3).then( ... )
    

    方案五 基于修饰器的方案四

    和方案四是的解法一致的,但是是基于修饰器来做。 代码如下:

    // 生成key值错误
    const generateKeyError = new Error("Can't generate key from name and argument")
    
    // 生成key值
    function generateKey(name, argument) {
        // 从arguments 中取得数据然后变为数组
        const params = Array.from(argument).join(',')
        try{
            // 返回 字符串
            return `${name}:${params}`
        }catch(_) {
            return generateKeyError
        }
    }
    
    function decorate(handleDescription, entryArgs) {
        // 判断 当前 最后数据是否是descriptor,如果是descriptor,直接 使用
        // 例如 log 这样的修饰器
        if (isDescriptor(entryArgs[entryArgs.length - 1])) {
            return handleDescription(...entryArgs, [])
        } else {
            // 如果不是
            // 例如 add(1) plus(20) 这样的修饰器
            return function() {
                return handleDescription(...Array.protptype.slice.call(arguments), entryArgs)
            }
        }
    }
    
    function handleApiCache(target, name, descriptor, ...config) {
        // 拿到函数体并保存
        const fn = descriptor.value
        // 修改函数体
        descriptor.value = function () { 
            const key =  generateKey(name, arguments)
            // key无法生成,直接请求 服务端数据
            if (key === generateKeyError)  {
                // 利用刚才保存的函数体进行请求
                return fn.apply(null, arguments)
            }
            let promise = ExpriesCache.get(key)
            if (!promise) {
                // 设定promise
                promise = fn.apply(null, arguments).catch(error => {
                     // 在请求回来后,如果出现问题,把promise从cache中删除
                    ExpriesCache.delete(key)
                    // 返回错误
                    return Promise.reject(error)
                })
                // 使用 10s 缓存,10s之后再次get就会 获取null 而从服务端继续请求
                ExpriesCache.set(key, promise, config[0])
            }
            return promise 
        }
        return descriptor;
    }
    
    // 制定 修饰器
    function ApiCache(...args) {
        return decorate(handleApiCache, args)
    }
    

    此时 我们就会使用 类来对api进行缓存

    class Api {
        // 缓存10s
        @ApiCache(10)
        // 此时不要使用默认值,因为当前 修饰器 取不到
        getWare(params1, params2) {
            return request.get('/getWares')
        }
    }
    

    因为函数存在函数提升,所以没有办法利用函数来做 修饰器
    例如:

    var counter = 0;
    
    var add = function () {
      counter++;
    };
    
    @add
    function foo() {
    }
    

    该代码意图是执行后counter等于 1,但是实际上结果是counter等于 0。因为函数提升,使得实际执行的代码是下面这样

    @add
    function foo() {
    }
    
    var counter;
    var add;
    
    counter = 0;
    
    add = function () {
      counter++;
    };
    

    所以没有 办法在函数上用修饰器。具体参考ECMAScript 6 入门 Decorator
    此方式写法简单且对业务层没有太多影响。但是不可以动态修改 缓存时间

    调用方式

    getWares(1,2).then( ... )
    // 第二次调用 取得先前的promise
    getWares(1,2).then( ... )
    // 不同的参数,不取先前promise
    getWares(1,3).then( ... )
    

    总结

    api的缓存机制与场景在这里也基本上介绍了,基本上能够完成绝大多数的数据业务缓存,在这里我也想请教教大家,有没有什么更好的解决方案,或者这篇博客中有什么不对的地方,欢迎指正,在这里感谢各位了。
    同时这里也有很多没有做完的工作,可能会在后面的博客中继续完善。

    作者: jump--jump 

    原文地址:https://my.oschina.net/wsafight/blog/3040140

    展开全文
  • App 数据缓存方案

    千次阅读 2020-07-02 17:24:12
    策略1:规则缓存(单纯App本地缓存) App根据接口数据特性,本地规定缓存以及更新数据策略(例如:登录后更新数据)。即特定场景下指定特定数据源(local,remote)。有些数据不会经常变更,例如用户权限,可以规定...

    策略1:规则缓存(单纯App本地缓存)

    App根据接口数据特性,本地规定缓存以及更新数据策略(例如:登录后更新数据)。即特定场景下指定特定数据源(local,remote)。有些数据不会经常变更,例如用户权限,可以规定在特殊场景下触发Request获取remote数据,其余场景下从本地缓存获取。

    减少网络访问次数,数据实时性达不到。

    策略2:时效缓存(单纯App本地缓存)

    App(或者服务端)根据接口数据特性,规定特定接口缓存时效。即根据不同接口,设置Cache-Control的不同时长。同时根据网络情况,定义断网和联网场景下的缓存时效。

    接口1:.header("Cache-Control", "max-age=" + 1000)

    接口2:.header("Cache-Control", "max-age=" + 2000)

    接口2:.header("Cache-Control", "max-age=" + 3000)

    缓存方式:Cache

    减少网络访问次数,数据实时性达不到。

    策略3:时间戳缓存(参数形式,完全自定义)

    App本地缓存接口数据,同时缓存最新接口访问时间戳

    (1)每次访问,上次request时间戳传参给后台(协议定义第一次访问参数形式,例如:“-1”)

    (2)由后台判断该时间戳开始,到当前时间点截止,该接口数据有无变更,有:返回data,同时返回本次请求响应的时间戳;无:返回data = null(或协议其他形式)。

    (3)App判断响应data是否为空数据(或者定义其他形式的协议),是,获取本地缓存;否,获取响应data,同时更新本地缓存以及本次接口访问时间戳

    说明:

    (1)App负责缓存接口数据,最新的接口访问时间戳。

    (2)后台负责记录接口数据最新的变更时间戳updateTime,负责对比终端请求参数中,上一次请求时间戳oldRequestTime 和 updateTime:

    if(oldRequestTime > updateTime) {

        return null;
    }
    else {
       
    return data;
    }

    (3)本策略,App需自定义并管理Cache。

    策略4:Last-Modified-Date(Headers形式,OkHttp缓存策略)

    App本地缓存接口数据,同时缓存remote接口数据最后一次变更时间戳。

    (1)App第一次请求时,服务器返回接口数据最后一次变更时间点(Headers):

    Last-Modified: Tue, 12 Jan 2016 09:31:27 GMT

    (2)App二次请求时,头部加上如下header:

    If-Modified-Since: Tue, 12 Jan 2016 09:31:27 GMT

    (3)服务器判断在If-Modified-Since ~ 当前,资源是否被二次修改,否:服务器返回code = 304告知客户端直接复用本地缓存(OkHttp内置缓存拦截器已实现相关策略);是:服务器正常返回data,同时返回Last-Modified

    说明:

    App可完全采用OkHttp内置缓存拦截器机制,并自定义CommonHeaderInterceptor拦截器,在每次请求前,把If-Modified-Since添加到Request的Headers中。

    策略5:全服务端策略

    由服务端记录每个用户(每台设备)对每个数据接口的最后一次访问时间戳lastRequestTime,以及该数据最新update的时间戳lastUpdateTime。当每个用户再次访问数据接口时,服务端对比lastRequestTime和lastUpdateTime的先后顺序,判断是否返回data。

    if(lastRequestTime> lastUpdateTime) {

        return null;
    }
    else {
       
    return data;
    }

    App判断响应data是否为空数据(或者定义其他形式的协议),是,获取本地缓存;否,获取响应data。

    特殊情况:用户强制使用remote data,服务端不做时间戳对比,直接返回相应数据。

    说明:

    该策略对端无感知,适合多个团队合作,一个服务器,多个端的情况。但同时服务端需要对每个用户n,每个接口m做最后一次访问时间戳的记录,复杂度n*m。

    总结:

    策略3,4性能无差,策略4对App而言更容易管理,但要充分考虑Cache大小设置;策略3App需要自己封装一套缓存代码,相应滴,也可以达到自定义缓存方式(sql,cache,文件,等等)的效果。

    不同场景下,其实可以考虑把策略1,2,(3,4,5)综合运用,根据业务场景不同,定义相应的接口调用规则(策略1);再由后台根据接口数据的update实际情况,指定App对不同数据的缓存时效(Cache-Control控制)(策略2),从而减少网络访问次数;同时记录data update time,配合App实现缓存与数据实时性并存(策略3,4)的效果。

    说白了,策略1,2缓存的目的是减少网络访问次数,节约网络资源。策略3,4缓存的目的是最大限度节约数据流量,减少带宽压力,同时保证数据实时性。

    扩展

    对于策略5,服务端可以对接口数据变更时间戳,和用户所有接口访问时间戳同时保存(扩展),为后续用户行为分析,数据安全性等方面提供支持。

    展开全文
  • 前端页面利用localStorage设置缓存方案 localStorage的存储空间大致在5M左右,各大浏览器略有差别。我再chrome 54中测试能放下 5233962 字节,该值并不精确,通过每次往localStorage中插入一个大字符串,到达上线...
  • nginx 发布前端资源的缓存方案

    千次阅读 2021-12-18 17:49:35
    nginx 发布前端资源的缓存方案 前言 对于前端开发者来说,最头疼的事情莫过于。当你兴冲冲的给项目打包以后,上传到 nginx 等静态资源服务器发布以后,自己本地验证没问题,以为万事大吉,结果测试人员、用户反馈...
  • 分布式缓存解决方案

    千次阅读 2021-08-29 10:59:45
    缓存的概念 Redis缓存的用法 SpringCache的用法 缓存穿透解决方案 缓存雪崩解决方案 缓存的数据一致性解决策略
  • Webpack5 内置缓存方案探索

    千次阅读 2021-01-04 09:52:31
    通过把loader的处理结果缓存到本地磁盘,来加速二次编译 通过预编译dll让webpack跳过一些模块的编译,来加速编译 这些方案在一定程度上解决了编译速度慢的问题,但随之而来的是成堆的配置,严重影响了Webpack的使用...
  • 本文由以下三个部分组成1、讲解缓存更新策略2、对每种策略进行缺点分析3、针对缺点给出改进方案先做一个说明,从理论上来说,给缓存设置过期时间,是保证最终一致性的解决方案。这种方案下,我们可以对存入缓存的...
  • 多级优化缓存概览1、缓存设计原则2、多级缓存方案一、Redis集中式缓存1.1 Redis sentinal哨兵模式1.2 Redis cluster模式1.3 Redis集中式缓存商品详情页接入1.4 Redis集中式缓存压测效果验证二、本地热点缓存2.1 ...
  • 缓存方案之Redis

    万次阅读 多人点赞 2015-04-03 15:49:13
    在很多地方,Redis也被业内人士称为数据结构服务器,因为它允许缓存的值(value)可以是字符串(string)、哈希(hash)、列表(list)、集合(set)和有序集合(sorted set)等类型。此外,Redis还支持master-slave方式的数据...
  • 分布式缓存平台方案

    万次阅读 2019-01-03 11:09:08
    2、多协议支持方案 3、高可用(HA)方案 3.1、基础设施 3.2、故障检测 3.3、故障切换 4、分布式方案 4.1、垂直扩展 4.2、水平扩展 5、容量管理 6、安全 6.1、配置安全 6.2、访问安全 6.3、内置安全机制 ...
  • 下面会介绍缓存使用技巧和设计方案,包含如下内容:缓存的收益和成本分析、缓存更新策略的选择和使用场景、缓存粒度控制方法、穿透问题优化、无底洞问题优化、雪崩问题优化、热点key重建优化。...
  • Redis分页查询缓存方案

    千次阅读 2021-03-16 22:12:39
    常规分页查询缓存方案我们都知道,通过缓存查询的结果,可以极大的提升系统的服务能力,以及降低底层服务或者是数据库的压力。对于有分页条件的缓存,我们也可以按照不同的分页条件来缓存多个key,比如分页查询产品...
  • SSD作缓存方案之LVM cache

    千次阅读 2019-09-28 23:41:52
    SSD作缓存方案之LVM cache 1. 前言 最近因为工作的需要,接触了一些SSD作缓存相关的知识。所谓SSD作缓存就是使用fast device(例如SSD),给slow device(例如机械硬盘)做缓存,以提高计算机整体的I/O存储性能。 ...
  • 抱歉,其实这篇应该几天前就出的,不过在这个项目中的lucene加载出bug了(虽然还没解决,但缓存的先记录下来,发出给大家)。今天是两个缓存方案的介绍,排行榜缓存以及整表缓存!!!
  • vue项目实现缓存方案

    千次阅读 2019-10-28 17:11:39
    vue项目实现缓存方案 需求: 商品列表页 跳转到 商品详情页,在从 商品详情页 返回 列表页,要求列表页添加缓存,使用keep-alive的include(添加缓存的列表) 、ecclude(不添加缓存的列表)和路由的钩子函数,灵活实现...
  • 8种方案,保证缓存和数据库的最终一致性

    千次阅读 多人点赞 2021-11-23 21:48:47
    由于对数据库以及缓存的整体操作,并不是原子性的,再加上读写并发,究竟什么样的方案可以保证数据库与缓存的一致性呢? 下面介绍8种方案,配合读写时序图,希望你能从其中了解到保证一致性的设计要点。
  • WEB前端缓存解决方案

    千次阅读 2018-11-09 16:38:49
    WEB前端缓存解决方案问题描述页面缓存js/css缓存 问题描述 使用angularjs(1.5.0)+gulp(3.9.0)做SPA开发时,修改js后,使用gulp-rev(6.0.1)对文件名进行了修改,但是刷新界面后修改的文件并没有加载,必须使用CRLT+F5...
  • 友情提示:文章最后附有项目源码现在,Android有很多优秀的图片加载框架。例如:Picasso,Glide,Fresco。...今天就从头开始设计一套图片异步加载缓存方案。本方案用到以下技术,想了解更细致的内...
  • vue项目实现缓存的最佳方案

    万次阅读 2019-07-11 13:13:14
    展示视频名称和是否收藏,点击进去某一项观看,可以收藏或者取消收藏,返回的时候需要记住列表页面的页码等状态,同时这条视频的收藏状态也需要更新, 但是从其他页面进来视频列表页面的时候不缓存这个页面,也就是...
  • iOS开发之音视频边下边播缓存方案

    千次阅读 2017-04-10 10:53:00
    不过,我还真没看到目前有哪个公开的实现方案有做的更好的,可能是我孤陋寡闻,如果你知道更好的方案,一定要留言告诉我,鞠躬.. 进入正题,这次的主要内容  理解 AVAssetResourceLoaderDelegate 的使用  ...
  • 如何设计缓存系统:缓存穿透,缓存击穿,缓存雪崩解决方案分析.docx
  • Nginx默认会对上传的文件先在本地进行缓存,再转发到应用服务器。请问怎么禁止掉这个缓存,让Nginx只转发而不缓存文件?本文给大家详细介绍Nginx上传文件全部缓存解决方案,有需要的朋友来参考下
  • 配置缓存方案

    千次阅读 2012-01-11 22:50:20
    5.7.1 配置缓存方案 虽然Spring Modules会提供一个代理来拦截方法并把结果保存到缓存,它并没有提供一个实际的缓存解决方案,而是要依赖于第三方的缓存方案。可以使用的方案有多个,包括: EHCache GigaSpaces ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 570,818
精华内容 228,327
关键字:

缓存方案