精华内容
下载资源
问答
  • 分页缓存

    2019-06-14 13:37:00
    //生成分页 function createLi(pagetotal){ console.log(pagetotal); var str = ""; for(var i=0;i;i++){ str += `${i+1}</li>` } oUL.innerHTML = str; var oLi = oUL....
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>留言板</title>
    <meta name="description" content="">
    <meta name="keywords" content="">
    <link href="" rel="stylesheet">
    <script src="js/jquery.min.js" type="text/javascript"></script>
    <style>
    	div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,form,fieldset,input,textarea,blockquote,p,body{
    	padding:0;margin:0;}
    	ul,li{list-style:none;}
    	img{border:0 none;}
    	a{ text-decoration:none; color:#666666; font-family:"微软雅黑";}
    	h1, h2, h3, h4, h5, h6 {font-size: 100%;font-weight: normal;}
    	body{ font-family:"微软雅黑"; font-size:14px; color:#595959; line-height:24px; background:#fff;}
    	.w1100{ width:1100px; margin:0 auto;}
    	.clearfix:after { visibility:hidden; display:block; font-size:0; content:" "; clear:both; height:0;} 
    	.clearfix { zoom:1;}
    
    	/*样式*/
    	.msg-dl dd{
    		float: left;
    		width: 120px;
    		margin-top: 10px;
    		border-top: 1px solid #666666;
    		border-left: 1px solid #666666;
    		border-bottom: 1px solid #666666;
    		text-align: center;
    	}
    	.msg-dl dd:last-child{
    		border-right: 1px solid #666666;
    		width:300px;
    	}
    	#msgbox{
    		width: 1200px;
    		margin:30px 0 0 30px;
    		position: relative;
    	}
    	#msgbox h2{
    		font-size: 16px;
    		text-align: left;
    	}
    	.msg-ul li{
    		display:flex;
    	}
    	.msg-ul{
    		height: 280px;
    	}
    	.msg-ul li span{
    		width: 120px;
    		border-left: 1px solid #666666;
    		border-bottom: 1px solid #666666;
    		text-align: center;
    		line-height: 25px;
    		height: 25px;
    	}
    	.msg-ul li span:nth-of-type(5){
    		width:200px;
    	}
    	.msg-dl dd:nth-of-type(5){
    		width:200px;
    	}
    	.msg-ul li span:nth-of-type(6){
    		width:200px;
    	}
    	.msg-dl dd:nth-of-type(6){
    		width:200px;
    	}
    	.msg-ul li span:last-child{
    		border-right: 1px solid #666666;
    		width:300px;
    	}
    	#msgbox h3{
    		background: red;
    		color: #FFF;
    		position: absolute;
    		width: 25px;
    		font-size: 12px;
    		padding:0 5px;
    		top: 100px;
    		left: 0;
    	}	
    	ul.pagination {
    		display: inline-block;
    		padding: 0;
    		margin: 0;
    	}
    	
    	ul.pagination li {display: inline;}
    	
    	ul.pagination li a {
    		color: black;
    		float: left;
    		padding: 8px 16px;
    		text-decoration: none;
    		border: 1px solid blue;
    		border-radius:3px;
    	}
    	.active{
    		background-color: #7FFFAA;
    	}
    	.pagination li{
    		width:20px;
    		height:20px;
    		border:1px solid #000;
    		padding:3px 8px;
    		cursor:pointer;
    		margin: 0 3px;
    	}
    	.pager{
    		margin-top:20px;
    	}
    	.pager .page-active{
    		background:red;
    		color:#fff;
    	}
    </style>
    </head>
    <body>
    	<div id="msgbox">
    		<h2>网站留言</h2>
    		<dl class="msg-dl clearfix">
    			<dd>序号</dd>
    			<dd>姓名</dd>
    			<dd>电话</dd>
    			<dd>项目名称</dd>
    			<dd>邮箱</dd>
    			<dd>留言内容</dd>
    			<dd>时间</dd>
    		</dl>
    		<ul class="msg-ul clearfix">
    		 </ul>
    		 <div class="pager">
    			<ul class="pagination">
    				
    			</ul>
    		 </div>
    	</div>
        <script>
    
    
    
    
    
    		$(function(){
    			$.ajax({
    				type: "GET",
    				url: "./fetch.php",
    				success: function (res) {
    					var data = JSON.parse(res);
    					createLi(data.pagecount);
    				}
    			});
    
    
    
    			//获取数据
    			getData();
    			function getData(page){
    				var page = page || 1;
    				$.ajax({
    					type: "GET",
    					url: "./fetch.php",
    					data: {"pagenow":page},
    					success: function (res) {
    						var data = JSON.parse(res);
    						//console.log(data.pagecount);
    						cache.set(page,data.newarr);
    						renderData(data.newarr);
    					}
    				});
    			};
    
    			//闭包
    			var cache = cacheData();
    			function cacheData(){
    				var cache = {}; //声明一个缓存池变量
    				return{
    					set:function(page,doc){
    						cache[page] = doc; // 缓存
    					},//存储新数据
    					get:function(page){
    						if(page in cache){
    							renderData(cache[page])
    							//console.log("第"+page +"页面已经缓存,无需再次请求");
    						}else{
    							getData(page);
    						}
    					}//读取数据
    				}
    			};
    			//渲染页面
    			function renderData(data){
    				var msgUl = document.querySelector(".msg-ul");
    				var str = "";
    				data.forEach((item) => {
    					str +=`<li>
    						<span>${item.id}</span>
    						<span>${item.name}</span>
    						<span>${item.phone}</span>
    						<span>${item.pro}</span>
    						<span>${item.email}</span>
    						<span>${item.text}</span>
    						<span>${item.time}</span>
    					</li>`
    				})
    				msgUl.innerHTML= str;
    			}
    			//点击事件
    			var oUL = document.querySelector(".pagination");
    			oUL.addEventListener("click",function(e){
    				var e = e || window.event;
    				var oLi = oUL.querySelectorAll("li");
    				console.log(oLi)
    				if(e.target.tagName.toLowerCase() == "li"){
    					var page = e.target.innerText;
    					cache.get(page);
    					for(var i=0;i<oLi.length;i++){
    						oLi[i].className ="";
    					};
    					e.target.className = "page-active";
    				}
    			});
    			//生成分页
    			function createLi(pagetotal){
    				console.log(pagetotal);
    				var str = "";
    				for(var i=0;i<pagetotal;i++){
    					str += `<li>${i+1}</li>`
    				}
    				oUL.innerHTML = str;
    				var oLi = oUL.querySelectorAll("li");
    				oLi[0].className="page-active";
    			}
    		});
    		
    		
    	</script>
    </body>
    </html>
    

     

    转载于:https://www.cnblogs.com/wangshengli520/p/11022866.html

    展开全文
  • 长列表分页缓存策略

    万次阅读 2017-01-13 20:40:25
    下面总结对两种常见的分页缓存的策略, 适用场景以及各自的优缺点。 策略一: 直接对分页结果缓存 顾名思义,就是直接缓存每次分页查询的结果。 适用场景 列表长度无法提前预知 数据和排序不...

    通常,对于长列表加载的场景,都需要进行分页, 如最近的世界杯体育垂站项目中的赛程页,评论流,直播流。而为了提高分页加载的性能,往往需要对分页进行缓存。 下面总结对两种常见的分页缓存的策略, 适用场景以及各自的优缺点。

     

     

    策略一: 直接对分页结果缓存

    顾名思义,就是直接缓存每次分页查询的结果。

     

    1531379878187-e71c1767-b892-4b26-9751-c7

     

    适用场景

    • 列表长度无法提前预知

    • 数据和排序不经常变更

     

    优点:

    • 实现简单

    • 通常能获得不错的性能。由于直接缓存分页的结果,因此只需一次IO就能把数据查出来

     

    缺点

    • 无法及时更新

    随着列表增长,一个对象可能从第1页转移到第2页。因此当某个对象发生变更(或排序权重发生变化)后,无法判断该更新哪几页的缓存;除非同步维护一张倒排表,记录每个对象ID到所有缓存键值的映射关系, 但对于一般web应用实现成本有点高

     

    • 数据不一致

    由于无法做到实时主动更新,因此失效时间不宜设置过长,这就需要根据实际业务场景(比如允许一定的更新延迟) 选取一个能接受的值, 而在缓存失效之前,需要忍受数据不一致。

     

    • 缓存键值(cacheKey)设计或使用不当, 可能会产生大量无效的缓存垃圾

    假设分页查询的条件是 _prev_pos 和 size,_prev_pos为上一页最后一个对象的_pos值, 即从某个对象开始向前(或向后)检索size个对象, 则cacheKey = (_prev_pos+size), 选择不同的_prev_pos 和 size 会生成 不同的cacheKey。

    类似的还有cacheKey= md5(url) , cacheKey = (startTime + endTime), 使用不当时也会产生大量垃圾cacheKey.

    产生大量垃圾cacheKey的直接后果是,缓存空间会很快被耗尽,频繁触发LRU,最终影响应用的性能

     

     

     

    策略二:缓存整个对象ID列表,再分别对每个对象建立缓存

     

    1531381115475-5956c61a-bf56-4c0d-a62e-fa

    预先把整个对象ID列表缓存起来,由程序实现分页逻辑,分页查询的结果是一个ID数组, 然后再根据每个ID从缓存中查找对象,最后组装成一个对象数组返回

     

    适用场景

    • 列表长度有限

    • 对象数据或排序权重需要频繁更新

     

    优点

    • 数据一致

    在这种存储结构下, 当对象数据和排序权重发生变更时,能及时更新对应的缓存块,避免出现缓存的数据和数据库不一致的情况。又由于每次分页查询都是一次动态计算的结果,因此只要缓存更新了,就一定能拿到最新的结果

     

    • 缓存空间的大小是恒定且能提前预估

     

    • 缓存块能设置比较长的过期时间,不用担心缓存失效

     

    缺点

    • IO次数 = n + 1 ( n 为每页的条数),为了保证性能, n 通常不能选得过大

    • 列表长度和 分页逻辑的算法 直接影响查询性能

    • 实现成本略高

     

     

    策略3:缓存分页结果,并定时更新前几页缓存

    在策略1的基础上,增加一个定时任务,定时刷新前几页的缓存, 从而尽量保证前几页的缓存是最新的。

     

    由于在某些业务场景下,用户只会浏览前几页的内容,比如用户一般只会关注未来 1 ~ 2周的体育赛事, 因此只要保证前几页的内容是最新的即可。

     

     

    总结

    在项目实践中,我发现没有一种缓存策略能完美解决所有问题,往往需要在 性能 和 数据一致性之间寻找一个平衡点。 比如对于体育赛程列表,由于更新频率不高的特点,适合采用策略1 对赛程列表进行分页缓存,但是对于比赛直播流, 则采用策略2或策略3比较合适,特别对直播流有较强的人工运营需求(比如往流中插入一些竞猜题目或用户的评论).

    展开全文
  • 怎么用redis实现分页缓存,比如有1000页数据,只缓存当前页的后两页,点击到其他页时再缓存当前页的后两页。
  • redis 分页缓存

    2019-09-19 00:54:11
    package com.meitun.operation.cache; import java.util.List; /** * 分页缓存回调 * * @author: xiongyan * @date: 2018年6月15日 下午5:24:19 * @param <T&...

    package com.meitun.operation.cache;

    import java.util.List;

    /**
     * 分页缓存回调
     * 
     * @author: xiongyan
     * @date: 2018年6月15日 下午5:24:19
     * @param <T>
     */
    public interface OprPageCacheCallback<T> {
        
        /**
         * 查询结果
         * 
         * @return
         */
        List<T> list();
        
    }
     

     

    package com.meitun.operation.cache;

    import java.util.Collections;
    import java.util.Date;
    import java.util.List;

    import org.apache.commons.collections4.CollectionUtils;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

    import com.meitun.operation.common.constant.OprConstant;
    import com.meitun.operation.common.util.OprDateUtils;
    import com.meitun.operation.common.util.OprSpringBeanUtils;
    import com.meitun.operation.common.util.OprThreadPoolUtils;
    import com.meitun.operation.common.util.OprThreadPoolUtils.ThreadPoolCallback;
    import com.meitun.operation.redis.OprRedisClient;

    /**
     * 分页缓存
     * 
     * @author: xiongyan
     * @date: 2018年6月15日 下午5:24:19
     * @param <T>
     */
    public abstract class OprAbstractPageCache<T> implements OprPageCacheCallback<T> {
        
        /**
         * ThreadPoolTaskExecutor
         */
        protected static ThreadPoolTaskExecutor executor = OprSpringBeanUtils.getBean("commonThreadPoolTaskExecutor");
        
        /**
         * 是否整点缓存
         * 
         * @return
         */
        public boolean isWholePoint() {
            return false;
        }
        
        /**
         * 是否异步更新
         * 
         * @return
         */
        public boolean isAsyncUpdate() {
            return false;
        }
        
        /**
         * 缓存剩余时间,默认60秒,1分钟
         * 
         * @return
         */
        public int ttlTime() {
            return OprConstant.ONE_MINUTE_CACHE_TIME;
        }
        
        /**
         * 是否异步放缓存
         * 
         * @return
         */
        public boolean isAsyncSet() {
            return false;
        }
        
        /**
         * 异步查询结果
         * 
         * @return
         */
        public List<T> asyncList() {
            return Collections.emptyList();
        }
        
        /**
         * 获取整点缓存key
         * 
         * @param key
         * @return
         */
        public String getKey(String key) {
            // 当前整点时间
            String currentTime = OprDateUtils.format(new Date(), OprConstant.HOUR_DATE_FORMAT);
            // 整点时间缓存key
            return key + "_currentTime_" + currentTime;
        }
        
        /**
         * 查询list总记录数
         * 
         * @param key
         * @return
         */
        public int getTotalSize(String key) {
            // 从redis缓存中获取list数据结构的len
            return OprRedisClient.listLen(key);
        }
        
        /**
         * 分页查询list
         * 
         * @param key
         * @param start
         * @param end
         * @return
         */
        public List<T> getCache(String key, int start, int end) {
            // 分页获取缓存数据
            return OprRedisClient.getList(key, start, end);
        }
        
        /**
         * 同步放缓存
         * 
         * @param key
         * @param list
         * @param second
         */
        public void setCache(String key, List<T> list, int second) {
            // 同步放缓存
            OprRedisClient.setList(key, list, second);
        }
        
        /**
         * 异步放缓存(重写此方法,isAsyncSet必须是true,否则不起作用)
         * 
         * @param key
         * @param second
         */
        public void asyncSetCache(final String key, final int second) {
            // 加锁
            if (!OprRedisClient.tryLock(key, 0, OprConstant.ASYNC_UPDATE_LOCK_TIME)) {
                return;
            }
            OprThreadPoolUtils.execute(executor, new ThreadPoolCallback<Void>() {

                @Override
                public Void call() {
                    try {
                        List<T> list = asyncList();
                        if (CollectionUtils.isEmpty(list)) {
                            return null;
                        }

                        // 放入缓存
                        OprRedisClient.setList(key, list, second);
                    } finally {
                        // 释放锁
                        OprRedisClient.unlock(key);
                    }
                    return null;
                }
            });
        }
        
        /**
         * 异步更新缓存
         * 
         * @param key
         * @param second
         */
        public void asyncUpdateCache(final String key, final int second) {
            // 加锁
            if (!OprRedisClient.tryLock(key, 0, OprConstant.ASYNC_UPDATE_LOCK_TIME)) {
                return;
            }
            OprThreadPoolUtils.execute(executor, new ThreadPoolCallback<Void>() {

                @Override
                public Void call() {
                    try {
                        // 根据是否异步放缓存,调用不同的方法
                        List<T> list = isAsyncSet() ? asyncList() : list();
                        if (CollectionUtils.isEmpty(list)) {
                            return null;
                        }

                        // 放入缓存
                        OprRedisClient.setList(key, list, second);
                    } finally {
                        // 释放锁
                        OprRedisClient.unlock(key);
                    }
                    return null;
                }
            });
        }
        
    }
     

     

    package com.meitun.operation.cache;

    import java.text.MessageFormat;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;

    import org.apache.commons.collections4.CollectionUtils;

    import com.meitun.operation.common.dto.OprPage;
    import com.meitun.operation.common.util.OprCollectionUtils;
    import com.meitun.operation.redis.OprRedisClient;

    /**
     * 缓存工具类,单利模式
     * 批量缓存
     * 分页缓存
     * 
     * @author: xiongyan
     * @date: 2018年6月7日 上午9:20:06
     */
    public class OprCacheUtils extends OprAbstractCache {

        /**
         * 内部类
         */
        private static class SingletonHolder {

            private SingletonHolder() {
            }

            /**
             * 初始化对象
             */
            private static final OprCacheUtils INSTANCE = new OprCacheUtils();
        }

        /**
         * 获取实例
         * 
         * @return
         */
        public static OprCacheUtils getInstance() {
            return SingletonHolder.INSTANCE;
        }

        /**
         * 批量缓存
         * 
         * @param e 业务枚举类
         * @param params 参数
         * @param refreshTime -1:不刷新,0:剩余1分钟内刷新,>0:存放时间刷新(单位秒)
         * @param callback 回调函数
         * @return
         */
        public <T> List<T> batchCache(Enum<?> e, List<Object> params, long refreshTime, OprAsyncCacheCallback<T> callback) {
            if (null == e || CollectionUtils.isEmpty(params)) {
                return Collections.emptyList();
            }

            OprCache cache = getCache(e);
            if (null == cache) {
                return Collections.emptyList();
            }

            Map<String, Object> keyMap = new HashMap<>(params.size());
            for (Object param : params) {
                keyMap.put(MessageFormat.format(cache.getKey(), param), param);
            }

            return batchCacheValues(cache, keyMap, refreshTime, callback);
        }
        
        /**
         * 分页缓存
         * 功能:分页缓存,整点缓存,异步放缓存,异步更新缓存
         * 
         * @param pageCache 参数
         * @param callback 回调
         * @return
         */
        public <T> OprPage<T> pageCache(OprPageCache pageCache, OprAbstractPageCache<T> callback) {
            if ( null == pageCache || null == callback) {
                return null;
            }
            
            // 页码
            int pageNo = pageCache.getPageNo();
            // 每页显示数量
            int pageSize = pageCache.getPageSize();
            // 缓存key
            String key = pageCache.getKey();
            if (callback.isWholePoint()) {
                key = callback.getKey(key);
            }
            // 缓存时间
            int second = pageCache.getSecond();
            // 默认分页对象
            OprPage<T> result = new OprPage<>();
            result.setPageNo(pageNo);
            result.setPageSize(pageSize);
            result.setTotalCount(0);
            
            // 从redis缓存中获取list数据结构的len
            int totalSize = callback.getTotalSize(key);
            if (totalSize > 0) {
                // 计算总页数
                int totalPage = OprCollectionUtils.getTotalPages(totalSize, pageSize);
                if (pageNo > totalPage) {
                    // 如果页码大于总页数,返回空page
                    result.setTotalCount(totalSize);
                    return result;
                }
                
                // 分页获取缓存数据
                List<T> list = callback.getCache(key, result.getStart(), result.getEnd());
                if (CollectionUtils.isNotEmpty(list)) {
                    // 是否需要异步更新
                    if (callback.isAsyncUpdate() && OprRedisClient.ttl(key) <= callback.ttlTime()) {
                        callback.asyncUpdateCache(key, second);
                    }
                    result.setList(list);
                    result.setTotalCount(totalSize);
                    return result;
                }
            }
            
            // 调用业务方法,返回list数据
            List<T> list = callback.list();
            if (CollectionUtils.isEmpty(list)) {
                return result;
            }
            
            // 放入缓存
            if (callback.isAsyncSet()) {
                // 异步放缓存
                callback.asyncSetCache(key, second);
            } else {
                // 同步放缓存
                callback.setCache(key, list, second);
            }
            
            // 获取指定页的数据
            result.setList((List<T>) OprCollectionUtils.pageCollection(list, pageNo, pageSize));
            result.setTotalCount(list.size());
            return result;
        }
        
    }
     

    转载于:https://my.oschina.net/xiongyanokok/blog/1834705

    展开全文
  • 分页缓存预加载算法

    2019-10-03 05:24:34
    分页缓存预加载算法: 将数据分页(块)存储在缓存,这个页(块),一般大于应用实际请求的页面大小,分页(块)缓存的加载采取预加载方式,即在应用分页请求还没读到分页(块)的最后一页数据时,即预先加载...

     

    分页缓存预加载算法:
         将数据分页(块)存储在缓存,这个页(块),一般大于应用实际请求的页面大小,分页(块)缓存的加载采取预加载方式,即在应用分页请求还没读到分页(块)的最后一页数据时,即预先加载下一页的缓存。这样做有点如下:(1)减少DB读取次数。(2)减少缓存传输数据大小。(3)预加载分页缓存则避免应用请求超时。
    令:
    total : 记录总数
    cm :缓存大小,每一次缓存的记录条数
    cp :当前缓存页数
    n :一次请求多少条数
    p :当前请求第几页
    x :提前几页开始预加载缓存
    bucket:缓存第几页(块)
    begin : 从缓存的第几条开始取
    threshold : 触发读取DB条件。
    令:cm >= n+ n*x  保证缓存数据可供至少请求一次才触发预加载
    则:
    bucket = (p * n) / cm + 1
    begin = (p - 1) * n  + 1
    threshold :((p * n) % cm + n * x) >= cm
    算法描述:
    1. 初始化加载缓存,从DB中取cm条记录存入缓存。
    2. 应用分页请求时,如果:
      1. (p * n) % cm >= n,在第(p * n) / cm + 1页缓存从((p - 1) * n ) % cm + 1 条开始取n条记录返回
      2. (p * n) % cm < n , 请求跨了两个(页)缓存,需要在两个缓存中各取一部分数据拼接返回。在缓存从 (p * n) / cm 页缓存中从  ((p - 1)*n - 1) % cm + 1条开始取 n - (p * n) % cm 条加上,在缓存从(p * n) / cm + 1页缓存中从第1条开始取(p * n) % cm条合并返回。
      3. 如果 (p * n) % cm + n * x  >= cm ,触发预加载,即从DB中加载cm条记录至缓存。
    3. 结束。

    算法demo:

    package com.xx.lt;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Created by Jenkin.K on 17/6/1.
     */
    public class PageCache {
        Map<Integer,Cache> cacheMemory = new HashMap<Integer, Cache>();
        Map<Integer, Record> dbData;
        int cm = 50;        //缓存大小
        int bucket ;        //当前缓存页
        int begin ;         //从缓存的第几条开始取
        int n ;             //一次请求多少条
        int p ;             //当前请求第几页
        int x = 2;          //提前
    
        public static void main(String args[]){
            PageCache pageCache = new PageCache();
            pageCache.dbData = pageCache.initData();
            pageCache.cacheMemory.put(1, pageCache.loadCache(pageCache.cm, 1));
            int total = 1000;
            int pageSize = 6;
            for(int i = 0; i < total/pageSize - 1; i++) {
                System.out.println("get "+ (i+1) +" page :" );
                pageCache.getPage(i + 1, pageSize);
            }
            System.out.println(pageCache.cacheMemory);
        }
    
        private Map<Integer, Record> initData(){
            Map<Integer, Record> data = new HashMap<Integer, Record>();
            for(int i = 0; i < 1000; i++){
                data.put(i+1, new Record(i+1));
            }
            return data;
        }
    
        public void getPage(int p, int n){
            Map<Integer, Record> page = new HashMap<Integer, Record>();
            bucket = (p * n) / cm + 1; //求当前取哪页缓存
            begin = ((p -1) * n)  + 1;
            if((p * n) % cm > n || (p * n) % cm == n){  //没跨缓存
                page = getFromCache(bucket, begin, n, page);
            }else {  //跨缓存
                page = getFromCache(bucket - 1, begin, n - (p * n) % cm, page);
                page = getFromCache(bucket, (bucket-1) * cm + 1, (p * n) % cm, page);
            }
            if((p * n) % cm > cm - n * x || (p * n) % cm == cm - n * x){
                System.out.println("load cache");
                cacheMemory.put(bucket + 1, loadCache(cm, bucket + 1));
            }
            System.out.println("page data : " + page);
        }
    
        /**
         *
         * @param bucket 第几页缓存
         * @param begin 从哪个开始取
         * @return
         */
        private Map<Integer, Record> getFromCache(int bucket, int begin, int n, Map<Integer, Record> page){
            Cache cache = cacheMemory.get(bucket);
            for(int i = 0; i < n; i++){
                Record r = cache.cache.get(begin + i);
                page.put(begin + i, r);
            }
            return page;
        }
    
        /**
         *
         * @param cm 缓存大小
         * @param bucket 第几页缓存
         * @return
         */
        private Cache loadCache(int cm, int bucket){
            Cache cache = new Cache();
            int deta = cm * (bucket-1) + 1;
            for(int i = 0; i < cm; i++){
                cache.cache.put(deta + i, dbData.get(deta + i));
            }
            return cache;
        }
    
        class Cache{
            Map<Integer, Record> cache = new HashMap<Integer, Record>();
            public String toString(){
                StringBuffer sb = new StringBuffer();
                for(Map.Entry entry : cache.entrySet()){
                    sb.append(entry.getKey() + ":" + entry.getValue() + ",");
                }
                return String.valueOf(sb);
            }
        }
    
        class Record{
            Object value;
            Record(Object o){
                value = o;
            }
            public String toString(){
                return String.valueOf(value);
            }
        }
    
    }
    

      

     

    转载于:https://www.cnblogs.com/kisf/p/6930105.html

    展开全文
  • 移动端的分页缓存

    2016-08-30 18:57:47
    主要讨论移动端数据分页缓存问题,以便更好的实现速度和流量方面均衡。
  • 初学redis分页缓存方法实现

    千次阅读 2019-03-06 14:06:10
    初学redis分页缓存方法实现 使用缓存技术一般是在不经常增删改查的数据,我们可以使用缓存技术将第一次请求访问的数据缓存到redis中保存起来,后来的请求的时候首先查询redis数据库是否查询到这些数据,如果存在,...
  • 分页缓存<用java实现分页,并读取过程先读取缓存数据>
  • # 分页缓存 + 搜索条件 + 缓存版本号 header( 'content-type:text/html;charset=utf-8' ); $mysql_obj = new mysqli( '127.0.0.1', 'root', '', 'yii_shop' ); $redis_obj = new Redis(); $redis_obj...
  • 利用Ajax实现分页缓存

    千次阅读 2017-11-05 21:11:45
    用原生JavaScript写数据分页缓存,看教学视频写的,下面是详细代码。 index --> body{ margin:0; padding:0; } .wrap{ margin:30px auto; border:1px solid; width:500px; } .flex_row{ padding:0; display:...
  • Lua在Redis中的应用-分页缓存 普通分页 一般分页缓存为直接查出,按页来缓存,这样的缺点是,如果一般有数据增加,所有按页缓存的数据都会失效,对于新增比较多的数据,数据比较大的分页不太适合,所以都是采取...
  • 用memcached做分页缓存,可能很多人会觉得麻烦而不用。因为在增加、修改、删除的过程中,你不知道会影响到哪些数据,而如果把所有分页相关的数据缓存都删除并重新生成一遍,实现又很麻烦,甚至不可行,所以干脆就用...
  • vue + element 前端分页缓存实现

    千次阅读 2018-06-29 10:46:24
    vue + element 分页缓存实现 需求起源: &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;今天在做工作流审批,但是明细数据是分页的,如下: 我填了第一页的审批数量,如果翻页的话就...
  • 通常,对于长列表加载的场景,... 下面总结对两种常见的分页缓存的策略, 适用场景以及各自的优缺点。 策略一: 直接对分页结果缓存 顾名思义,就是直接缓存每次分页查询的结果。 适用场景 列表...
  • 序列化分页缓存 本章提供了大量的二进制数据的离堆缓存信息。 本章包含以下各节:  了解序列化分页缓存  分页缓存配置序列化  优化分区的高速缓存服务  配置高可用性  配置负载平衡和故障转移  ...
  • 假设我们有个文章页要以分页形式显示,分页类型...其实,需要解决的核心问题就一个:增加、删除、修改数据时能够让分页缓存都失效,实现这一点只需要引入版本号就可以了,在所有受影响的memcached的key中都加入版本...
  • 分页缓存设置

    千次阅读 2015-01-13 11:42:34
    1,对于分页来说,效率是关键,本例是在分页的时候,缓存5页记录,默认每页20条,缓存大小100,这可以修改的; 2,基本思路是:第一次查的时候,先判断缓存中存不存在当前页的数据,如果存在,查找缓存中的数据,...
  • spring分页缓存

    千次阅读 2018-10-18 16:01:43
    ... @Cacheable(key = "'myPage_'+#pagePlus.current+'_'+#pagePlus.limit") public void cachePage(Page pagePlus) { } ...
  • 前言工作过程中,经常会遇到基于内存数据进行分页处理的情况,例如批量更新数据库时,集合过大需要分批更新的情况,还有例如对缓存中的集合数据进行分页获取这种情况。本文提供了通用的内存分页工具,参考了网络上的...
  • } } } 2)StudentMapper.java接口: 1 //逻辑分页 RowBounds里面有分页信息 2 public ListfindStudent(RowBounds rowBound);3 4 //物理分页 5 public List findStudent2(Map map); 3)StudentMapper.xml映射文件: /p...
  • 缓存类,支持数据分页缓存

    千次阅读 2007-12-12 11:19:00
    (缓存类,支持数据分页缓存).用来缓存数据,也可以一次性查询数据库之后缓存,下次查询数据时读取按照分页读取缓存.本人的第一主题.希望大家多多支持,这个是我参考FleaPHP的缓存写出来的.复制PHP内容到剪贴板PHP代码://...
  • APP网络查询数据,多客户端分页缓存 转载于:https://www.cnblogs.com/trsing/p/4779466.html
  • controller层 ...//评论分页 @RequestMapping("queryPingLun") @ResponseBody public JSONObject queryPingLun(String goodId, Integer page, Integer rows, CommentsBean commentsBean) { JSONObject...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,060
精华内容 1,224
关键字:

分页缓存