精华内容
下载资源
问答
  • 易游缓存工具

    2014-06-24 09:27:52
    CacheX缓存器-易游缓存工具 CacheX缓存器-易游缓存工具
  • 重建图标缓存工具重建图标缓存工具重建图标缓重建图标缓存工具存工具重建图标缓存工具
  • 删除IE缓存工具 删除IE缓存的工具 删除IE缓存 工具
  • CacheMap缓存工具

    2017-11-06 16:12:36
    工具类提供了存入缓存、查找缓存、删除缓存、获取缓存大小SIZE,代码下载下来就可用
  • 缓存工具

    2018-06-15 16:49:35
    获取缓存,从缓存中移除, 写入缓存,获得一个Cache,没有则创建一个
  • hutools提供了TimedCache时间缓存工具,可以实现该场景。下面使用到该组件,并为了适配工作场景,对该工具类做优化升级。 Maven依赖 <dependency> <groupId>cn.hutool</groupId> <...

    目录

    简述

    Maven依赖

    简单使用

    工具优化-监听过期、增加回调

    总结


    简述

    我们在工作中会碰到需要使用带过期时间的缓存场景。但是使用redis有太重了,毕竟缓存的数据很小,放在内存够够的。hutools提供了TimedCache时间缓存工具,可以实现该场景。下面使用到该组件,并为了适配工作场景,对该工具类做优化升级。

    Maven依赖

            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.4.6</version>
            </dependency>
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>30.1.1-jre</version>
            </dependency>

    简单使用

    不多说了,上代码。

    import cn.hutool.cache.CacheUtil;
    import cn.hutool.cache.impl.TimedCache;
    import cn.hutool.core.thread.ThreadUtil;
    
    /** @Author huyi @Date 2021/10/12 17:00 @Description: */
    public class TimedCacheUtils {
      private static final TimedCache<String, String> TIMED_CACHE = CacheUtil.newTimedCache(5000);
    
      static {
        /** 每5ms检查一次过期 */
        TIMED_CACHE.schedulePrune(5);
      }
    
      /**
       * 存入键值对,提供消逝时间
       *
       * @param key
       * @param value
       * @param timeout
       */
      public static void put(String key, String value, Long timeout) {
        /** 设置消逝时间 */
        TIMED_CACHE.put(key, value, timeout);
      }
    
      /**
       * 每次重新get一次缓存,均会重新刷新消逝时间
       * @param key
       * @return
       */
      public static String get(String key) {
        return TIMED_CACHE.get(key);
      }
    
      public static void main(String[] args) {
        put("haha", "1", 3000L);
        ThreadUtil.sleep(2000);
        //    if (TIMED_CACHE.containsKey("haha")) {
        //      System.out.println("aa");
        //    }
        System.out.println("第1次结果:" + get("haha"));
        ThreadUtil.sleep(2000);
        System.out.println("第2次结果:" + get("haha"));
        ThreadUtil.sleep(5000);
        System.out.println("第3次结果:" + get("haha"));
        // 取消定时清理
        TIMED_CACHE.cancelPruneSchedule();
      }
    }

    首先我们看一下执行的效果

     说明:

    1、设置的超时时间为3000毫秒,所以第一次打印在2秒钟,所以可以获取到值。

    2、因为第一次打印调用了get方法,刷新了过期时间,所以依然可以获取到值。

    3、第三次打印在5秒后,所以已经过期,无法获取到值,打印null。

    那么,需要知道是否缓存还在可以使用containsKey方法。如下:

        put("haha", "1", 3000L);
        ThreadUtil.sleep(2000);
        if (TIMED_CACHE.containsKey("haha")) {
          System.out.println("第1次结果:缓存存在");
        }
    //    System.out.println("第1次结果:" + get("haha"));
        ThreadUtil.sleep(2000);
        System.out.println("第2次结果:" + get("haha"));
        ThreadUtil.sleep(5000);
        System.out.println("第3次结果:" + get("haha"));
        // 取消定时清理
        TIMED_CACHE.cancelPruneSchedule();

     执行结果如下:

    工具优化-监听过期、增加回调

    我们在使用TimedCache会发现,一旦缓存过期我们并不能立马知道,很多工作场景中需要对缓存做监听回调。所以我升级了一下该工具类。

    import cn.hutool.cache.CacheUtil;
    import cn.hutool.cache.impl.TimedCache;
    import cn.hutool.core.thread.ThreadUtil;
    import com.google.common.util.concurrent.*;
    import org.checkerframework.checker.nullness.qual.Nullable;
    
    import java.text.MessageFormat;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.function.Consumer;
    
    /** @Author huyi @Date 2021/10/12 10:57 @Description: 时间缓存工具 */
    public class TimedCacheUtils {
      private static final TimedCache<String, String> TIMED_CACHE = CacheUtil.newTimedCache(5000);
      /** 线程池 */
      private static final ExecutorService executorService = Executors.newCachedThreadPool();
    
      private static final ListeningExecutorService listeningExecutorService =
          MoreExecutors.listeningDecorator(executorService);
      /** 回调方法映射 */
      private static ConcurrentHashMap<String, Consumer<String>> callbackMap;
    
      /**
       * 存入键值对,添加过期时间,和消费回调
       *
       * @param key
       * @param timeout
       * @param consumer
       */
      public static void put(String key, String value, Long timeout, Consumer<String> consumer) {
        TIMED_CACHE.put(key, value, timeout);
        addListen(key, consumer);
      }
    
      /**
       * 获取缓存值
       *
       * @param key
       * @return
       */
      public static String get(String key) {
        return TIMED_CACHE.get(key);
      }
    
      /**
       * 删除缓存和回调映射
       *
       * @param key
       */
      public static void remove(String key) {
        callbackMap.remove(key);
        TIMED_CACHE.remove(key);
      }
    
      /**
       * 添加监听器
       *
       * @param key
       * @param consumer
       */
      public static void addListen(String key, Consumer<String> consumer) {
        ListenableFuture<String> listenableFuture =
            listeningExecutorService.submit(
                () -> {
                  while (TIMED_CACHE.containsKey(key)) {
                    ThreadUtil.sleep(500);
                  }
                  return key;
                });
        Futures.addCallback(
            listenableFuture,
            new FutureCallback<String>() {
              @Override
              public void onSuccess(@Nullable String s) {
                consumer.accept(s);
              }
    
              @Override
              public void onFailure(Throwable throwable) {
                throwable.printStackTrace();
              }
            },
            listeningExecutorService);
      }
    
      public static void main(String[] args) {
        put("haha", "1", 3000L, x -> System.out.println(MessageFormat.format("[{0}] - 缓存消逝", x)));
        ThreadUtil.sleep(2000);
        System.out.println(get("haha"));
        ThreadUtil.sleep(2000);
        System.out.println(get("haha"));
        ThreadUtil.sleep(5000);
        System.out.println(get("haha"));
        // 关闭监听线程池
        listeningExecutorService.shutdown();
      }
    }

     执行结果:

     说明:

    1、可以看到监听到缓存过期,并进行了回调。

    总结

    具体的工具类使用场景,因项目而异,大家看着来。

    如果本文对你有帮助,请点个赞支持一下吧。

    展开全文
  • 缓存查看工具

    2013-01-16 10:34:45
    缓存查看工具 ie、chrome 便于从缓存中检索信息
  • AS3 缓存工具

    2012-12-20 12:03:24
    很好的管理AS3缓存工具类,将数据存入缓存,判断缓存是否数据等
  • 清除缓存工具 很棒的清楚缓存工具。。。。 推荐使用。。
  • 三分钟学会缓存工具DiskLruCache

    千次阅读 2015-08-04 19:02:02
    DiskLruCache是一个十分好用的android缓存工具,所有的数据都存储在/storage/emulated/0/Android/data/应用包名/cache/XXX文件夹中,这个是android系统默认的应用缓存位置,如果应用被删除,这个文件也会一起被删除...

    DiskLruCache是一个十分好用的android缓存工具,我们可以从GitHub上下载其源码:https://github.com/JakeWharton/DiskLruCache

    DiskLruCache所有的数据都存储在/storage/emulated/0/Android/data/应用包名/cache/XXX文件夹中(你也可以修改,但不建议这样做,原因请继续往下看),这个是android系统默认的应用缓存位置,如果应用被删除,这个文件也会一起被删除,避免应用删除后有残留数据的问题。同时,由于数据没有存储在硬盘里,所以不会影响系统性能,在sd卡里,你可以存储任意多数据。
    由于DiskLruCache是被final修饰的,因此不可以直接通过new获得它的实例,我们使用它的open方法获得它的一个实例:
    public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
    open方法需要四个参数,第一个是缓存文件文件的位置,通过下面的方法可得到:

        private File getDiskCacheDir(Context context, String uniqueName) {
            String cachePath;
            //如果sd卡存在并且没有被移除
            if (Environment.MEDIA_MOUNTED.equals(Environment
                    .getExternalStorageState())
                    || !Environment.isExternalStorageRemovable()) {
                cachePath = context.getExternalCacheDir().getPath();
            } else {
                cachePath = context.getCacheDir().getPath();
            }
            return new File(cachePath + File.separator + uniqueName);
        }

    第二个参数是应用程序的版本号,要传入版本号是因为如果应用升级缓存会被清除掉。通过下面的方法可以获得程序的版本号:

        private int getAppVersion(Context context) {
            try {
                PackageInfo info = context.getPackageManager().getPackageInfo(
                        context.getPackageName(), 0);
                return info.versionCode;
            } catch (NameNotFoundException e) {
                e.printStackTrace();
            }
            return 1;
        }

    第三个参数表示同一个key可以对应多少个缓存文件,一般情况下我们都是传1,这样key和缓存文件一一对应,查找和移除都会比较方便。
    第四个参数表示最大可以缓存多少字节的数据。
    打开了DiskLruCache之后,我们可以看看怎么向DiskLruCache中缓存数据:
    先来看看从网上down一张图片:

        private boolean downloadImg(final String urlStr,
                final OutputStream outputStream) {
            HttpURLConnection conn = null;
            BufferedOutputStream out = null;
            BufferedInputStream in = null;
            try {
                URL url = new URL(urlStr);
                conn = (HttpURLConnection) url.openConnection();
                in = new BufferedInputStream(conn.getInputStream(), 8 * 1024);
                out = new BufferedOutputStream(outputStream, 8 * 1024);
                int len = 0;
                while ((len = in.read()) != -1) {
                    out.write(len);
                }
                return true;
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (conn != null)
                    conn.disconnect();
                try {
                    if (out != null)
                        out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if (in != null)
                        in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return false;
        }

    这是一个简单的联网down图片代码,拿到图片后就可以缓存到本地了,但是对于每一个存储资源都需要有一个key,这个key要是唯一的,而且这个key最长120个字符,且只能包括a-z,0-9,下划线以及减号,一次我们可以采用Java中的UUID来得到key,也可以使用MD5加密网址得到一个key,我这里采用md5,方法如下:

    public class MD5Util {
    
        public final static String md5(String pwd) {
            //用于加密的字符
            char md5String[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                    'A', 'B', 'C', 'D', 'E', 'F' };
            try {
                //使用平台的默认字符集将此 String 编码为 byte序列,并将结果存储到一个新的 byte数组中
                byte[] btInput = pwd.getBytes();
    
                // 获得指定摘要算法的 MessageDigest对象,此处为MD5
                //MessageDigest类为应用程序提供信息摘要算法的功能,如 MD5 或 SHA 算法。
                //信息摘要是安全的单向哈希函数,它接收任意大小的数据,并输出固定长度的哈希值。 
                MessageDigest mdInst = MessageDigest.getInstance("MD5");
                //System.out.println(mdInst);  
                //MD5 Message Digest from SUN, <initialized>
    
                //MessageDigest对象通过使用 update方法处理数据, 使用指定的byte数组更新摘要
                mdInst.update(btInput);
                //System.out.println(mdInst);  
                //MD5 Message Digest from SUN, <in progress>
    
                // 摘要更新之后,通过调用digest()执行哈希计算,获得密文
                byte[] md = mdInst.digest();
                //System.out.println(md);
    
                // 把密文转换成十六进制的字符串形式
                int j = md.length;
                //System.out.println(j);
                char str[] = new char[j * 2];
                int k = 0;
                for (int i = 0; i < j; i++) {   //  i = 0
                    byte byte0 = md[i];  //95
                    str[k++] = md5String[byte0 >>> 4 & 0xf];    //    5  
                    str[k++] = md5String[byte0 & 0xf];   //   F
                }
    
                //返回经过加密后的字符串
                return new String(str);
    
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    }

    各位看官在使用的时候记得把md5String[]中大写的字母改为小写,因为key中如果有大写字母验证会不通过。当然,你也可以修改DiskLruCache的源码从而让它支持大写字母,修改的地方:
    这里写图片描述
    现在万事俱备,我们来把图片缓存起来,由于联网是好事操作,所以要在新线程中完成,完整的方法如下:

        private void cacheImg() {
            new Thread(new Runnable() {
    
                @Override
                public void run() {
                    String key = MD5Util.md5(IMGIP);
                    try {
                        DiskLruCache.Editor editor = mDiskLruCache.edit(key);
                        if (editor != null) {
                            OutputStream out = editor.newOutputStream(0);
                            if (downloadImg(IMGIP, out)) {
                                //提交
                                editor.commit();
                            } else {
                                //撤销操作
                                editor.abort();
                            }
                        }
                        /**
                         * 这个方法用于将内存中的操作记录同步到日志文件(也就是journal文件)当中。
                         * 这个方法非常重要,因为DiskLruCache能够正常工作的前提就是要依赖于journal文件中的内容。
                         * 并不是每次写入缓存都要调用一次flush()方法的,频繁地调用并不会带来任何好处,
                         * 只会额外增加同步journal文件的时间。
                         * 比较标准的做法就是在Activity的onPause()方法中去调用一次flush()方法就可以了
                         */
                        mDiskLruCache.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

    editor.newOutputStream(0);方法有一个参数,查看源码我们知道这个参数必须大于0并且小于valueCount,前文中valueCount我们已经设置为1了,所以这里只能取值0。这个时候打开你的缓存文件夹,/storage/emulated/0/Android/data/应用包名/cache/XXX,里边已经有了我们缓存的数据了:
    这里写图片描述

    好了,数据存下来了,接下来就是读取,每一个缓存文件都对应一个key,读取就是根据这个key来读取:

        private void showImg() {
            String key = MD5Util.md5(IMGIP);  
            try {
                DiskLruCache.Snapshot snapShot = mDiskLruCache.get(key);
                if(snapShot!=null){
                    InputStream is = snapShot.getInputStream(0);
                    Bitmap bitmap = BitmapFactory.decodeStream(is);
                    im.setImageBitmap(bitmap);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } 
        }

    读取的时候我们最先拿到的是一个Snapshot 对象,再根据我们之前传入的参数0拿到缓存文件的流,最后把流转换为图片。

    到这里大家可能就明白了,之前的editor.newOutputStream(0);方法为什么会有一个0的参数了,相当于一个标识,读取时也传入参数0才能读到我们想要的数据。(加入我们的key与缓存文件不是一一对应,也就是我们一开始的open方法中传入的不是valueCount的值不是1,那么一个key对应多个缓存文件我们要怎么区分?就是通过这种方式,有兴趣的同学查看源码就一目了然了)。

    下来就是清除缓存了,看方法:

        private void clearCache() {
            String key = MD5Util.md5(IMGIP);
            try {
                mDiskLruCache.remove(key);
            } catch (IOException e) {
                e.printStackTrace();
            }  
        }

    根据缓存文件的key,调用remove方法,将该缓存文件移除。

    下来是查看缓存大小:
    这里写图片描述
    像凤凰新闻客户端中显示缓存大小,这个数值我们可以通过size()方法直接拿到:

        private void getCacheSize() {
            tv.setText(mDiskLruCache.size()+"");
        }

    大家应该看到了凤凰新闻还有一个功能就是清除缓存,这个功能直接调用delete方法就能实现:

        private void deleteAll() {
            /**
             * 这个方法用于将所有的缓存数据全部删除
             * 其实只需要调用一下DiskLruCache的delete()方法就可以实现了。
             * 会删除包括日志文件在内的所有文件
             */
            try {
                mDiskLruCache.delete();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    所有功能都完成之后,我们要记得在onDestory方法中关闭DiskLruCache。

        @Override
        protected void onDestroy() {
            super.onDestroy();
            /**
             * 这个方法用于将DiskLruCache关闭掉,是和open()方法对应的一个方法。
             * 关闭掉了之后就不能再调用DiskLruCache中任何操作缓存数据的方法,
             * 通常只应该在Activity的onDestroy()方法中去调用close()方法。
             */
            try {
                mDiskLruCache.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    到此,我想大家已经基本会用这个东东了吧。

    最后奉上本文源码下载地址http://pan.baidu.com/s/1kTzSHtd

    展开全文
  • 清除DNS缓存工具

    2015-01-09 20:24:16
    一键快速清除本机所有的DNS缓存,很实用的小工具,纯绿色,解压即可使用。
  • EhCacheUtil缓存工具

    千次阅读 2019-05-10 14:36:38
    import net.sf.ehcache.Cache; import ... ... /** 使用API来动态的添加缓存(将缓存的配置信息通过java代码来实现而非写在配置文件) @author Administrator */ public class EhCacheUtil { st...

    import net.sf.ehcache.Cache;
    import net.sf.ehcache.CacheManager;
    import net.sf.ehcache.Element;
    /**

    • 使用API来动态的添加缓存(将缓存的配置信息通过java代码来实现而非写在配置文件)
    • @author Administrator

    */
    public class EhCacheUtil {
    static CacheManager singletonManager;
    static String proName = “maoyoujc”;
    static {
    singletonManager = CacheManager.create();
    }

    /**
     * 创建缓存区间
     */
    public static void createCache() {
    	Cache memoryOnlyCache = singletonManager.getCache(proName);
        //建立一个缓存实例
    	if (memoryOnlyCache == null) {
    		//项目名称   缓存最大数量 是否缓存成文件 设定缓存是否过期  对象存活时间   无访问多长时间缓存失效 
    		memoryOnlyCache = new Cache(proName, 5000, false, false, 7200, 3600);
    		//在内存管理器中添加缓存实例
    		singletonManager.addCache(memoryOnlyCache);
    	}
    }
    /**
     * 查询缓存中的数据
     * @param key
     * @return
     */
    @SuppressWarnings("deprecation")
    public static Object getValue(String key) {
    	 //在缓存管理器中获取一个缓存实例
    	
        Cache cache = singletonManager.getCache(proName);
     
        Element element = cache.get(key);
        
        if (element == null) {
    		return null;
    	}
        System.out.println("从缓存EhCache中取出:" + key+"对应的值"+element.getValue());
        return element.getValue();
    }
    /**
     * 添加缓存
     * @param key
     * @param value
     */
    public static void setValue(String key,Object value) {
    	System.out.println("增加缓存"+key+"及对应的value值:"+value);
    	Cache cache = singletonManager.getCache(proName);
        //使用获取到的缓存实例
        Element element = new Element(key, value);
        cache.put(element);//添加缓存值
    }
    /**
     * 删除缓存
     * @param key
     */
    public static void remove(String key) {
    	Cache cache = singletonManager.getCache(proName);
    	Element element = cache.get(key);
    	if (element != null) {		
    		cache.remove(key);
    	}
    	System.out.println("删除"+key+"对应的值");
    }
    

    }

    展开全文
  • 服务器缓存设置 工具

    2010-01-20 16:46:55
    服务器缓存设置 工具 服务器缓存设置 工具 服务器缓存设置 工具
  • Guava——Cache缓存工具

    千次阅读 2019-02-04 01:03:07
    Cache缓存工具的特点2. 构建Cache2.1 数据对象2.2 数据获取层Dao2.3 构建Cache对象2.4 基于weight构建Cache3. 使用Cache3.1 从Cache中获取数据3.2 从Cache中获取数据(指定特定获取方式)3.3 删除某个key的缓存3.4 ...

    1. Cache缓存工具的特点

    • 自动加载对象至缓存
    • 达到最大size上限后,会根据LRU算法移除对象
    • 可通过最近读取或写对象的时长来移除对象
    • key自动使用弱引用包装
    • value自动使用弱引用or软引用包装
    • 对象移除后,会进行提示
    • 提供缓存访问的统计信息

    2. 构建Cache

    2.1 数据对象

    public class MyData {
    
        private String name;
    
        private String info;
    
        public MyData(String name, String info) {
            this.name = name;
            this.info = info;
        }
    
    }
    

    2.2 数据获取层Dao

    public class MyDao {
    
        /**
         * 获取数据需要花费一定时间
         *
         * @return 数据对象
         * @param key
         */
        public MyData getData(String key) {
            try {
                // 模拟获取的时间
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            return new MyData(key, "Hello World!" + key.hashCode());
        }
    
    }
    

    2.3 构建Cache对象(基于size)

    // 数据获取层对象
    MyDao myDao = new MyDao();
    
     // 移除数据的监听接口 lambda
    RemovalListener<String, MyData> removalListener = notification -> System.out.println("remove -> " + notification);
    
     // 缓存加载器,当不存在对应缓存时,调用load()
    CacheLoader<String, MyData> cacheLoader = new CacheLoader<String, MyData>() {
         public MyData load(String key) throws Exception {
             return myDao.getData();
         }
     };
    
     // 构建Cache
    LoadingCache<String, MyData> cache = CacheBuilder.newBuilder()
             .maximumSize(100) // 设置缓存size上限,当达到最大size后,将删除最近最少使用的对象(即LRU算法)
             .expireAfterWrite(10, TimeUnit.MINUTES) // 设置缓存过期时间
             .removalListener(removalListener)
             .build(cacheLoader);
    

    2.4 构建Cache对象(基于weight)

    LoadingCache<String, MyData> cache = CacheBuilder.newBuilder()
            .maximumWeight(10000L) // 当所有对象的weight的和超过此值,就开始使用LRU策略移除对象
            .weigher(new Weigher<String, MyData>() {
                @Override
                public int weigh(String key, MyData value) {
                	// 设置对象占总weight的多少
                	// 例如你可以使用对象的内存大小,从而限制Cache最多占用的内存
                    return key.length() + value.hashCode() % 100;
                }
            })
            .build(cacheLoader);
    

    3. 使用Cache

    3.1 从Cache中获取数据

    MyData myData = cache.get("key");
    System.out.println("myData = " + myData);
    

    3.2 从Cache中获取数据(指定特定获取方式)

    MyData myData = cache.get("key", new Callable<MyData>() {
    	@Override
        public MyData call() throws Exception {
            Thread.sleep(5000); // 模拟获取花费的时间
            return new MyData("key", "Other Method");
        }
    });
    System.out.println("myData = " + myData);
    

    3.3 删除某个key的缓存

    cache.invalidate("key");
    

    3.4 向Cache存入数据

    cache.put("key", new MyData("key", "google"));
    

    4. Cache的特性

    4.1 缓存性能效果

    for (int i = 0; i < 100; i++) {
    try {
          // 前5个值获取比较慢,因为key都是新的,需要重新生成对象
          // 后续的数据,因为Cache中已有,所以很快
          String key = String.valueOf(i % 5);
          MyData myData = cache.get(key);
          System.out.println("myData = " + myData);
      } catch (ExecutionException e) {
          e.printStackTrace();
      }
    }
    

    4.2 缓存上限size

    达到上限size后,会根据LRU策略移除缓存对象,并调用监听接口

    Random random = new Random();
    for (int i = 0; i < 100; i++) {
        try {
            String key = String.valueOf(random.nextInt(15));
            MyData myData = cache.get(key);
            System.out.println("myData = " + myData);
            System.out.println("cache.size() = " + cache.size());
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    

    4.3 缓存统计信息

    // 构建Cache时,需要添加recordStats()
    LoadingCache<String, MyData> cache = CacheBuilder.newBuilder()
            .maximumSize(10)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .removalListener(removalListener)
            .recordStats() // 启动统计
            .build(cacheLoader);
     
     Random random = new Random();
     for (int i = 0; i < 100; i++) {
        try {
             String key = String.valueOf(random.nextInt(15));
             MyData myData = cache.get(key);
             System.out.println("myData = " + myData);
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
    // 打印统计信息
     System.out.println("stats = " + cache.stats());
    
    展开全文
  • ehcache 缓存工具

    千次阅读 2012-12-28 18:30:59
    package com.test.util; import net.sf.ehcache.Cache; import net.sf.ehcache.CacheManager; import net.sf.ehcache.Element;... * ehcache 缓存工具类 * * cacheName在ehcache.xml中配置 */ public clas
  • ppstream缓存提取工具

    2010-07-09 10:26:05
    pps缓存提取工具 在pps中的缓存文件ppsds.pgf中提取最近缓存的文件,看过的基本可以另存为保存下来方便以后观看 非常好用的工具
  • redis缓存管理工具

    2018-06-30 12:50:05
    轻松管理redis缓存,让你更能清晰的了解缓存数据,对于不需要的缓存可以删除掉
  • flash 缓存清理工具 用于 flash flex开发 经典工具
  • SimpleCache 是一个简单易用的java缓存工具,用来简化缓存代码的编写,让你摆脱单调乏味的重复工作! 1. 完全透明的缓存支持,对业务代码零侵入 2. 支持使用Redis和Memcached作为后端缓存。 3. 支持缓存数据分区规则...
  • dns缓存清理工具

    2018-07-16 16:14:55
    dns清理工具、一键清理缓存。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • Android清理缓存工具

    千次阅读 2016-09-21 13:31:52
    安卓APP中清理缓存功能,不单单是系统优化工具之类的软件才的。。。普通的APP也很常见要显示缓存大小、清理缓存的功能。这种需求也相对比较简单,只是操作本应用的缓存目录罢了。安卓应用的缓存目录一般两个,...
  • 用友NC缓存清除工具

    2009-10-07 23:47:21
    NC缓存清除工具NC缓存清除工具NC缓存清除工具
  • Android DiskLruCache缓存工具封装

    千次阅读 2017-12-09 11:07:59
    介绍Android 应用缓存很常见,大多数应用都在使用DiskLruCache缓存技术,也很多人介绍过DiskLruCache,因此我在这里就不介绍了。DiskLruCache用起来不难,但是如果不加以封装的话,你会遇到各种open呀各种方法的...
  • chrome缓存资源导出工具,可以批量导出缓存中的图片,音频资源。
  • Java 实现本地缓存工具

    千次阅读 2016-12-01 12:11:40
    3、缓存工具使用单例模式 4、重写put 与 get 方法 5、重载一个 put 方法,增加一个缓存时间参数 经测试:存储100万以内普通数据的频繁读写性能还可以,能满足中小型系统缓存需求,如果要多机器共享缓存,建议单独...
  • Java 内存缓存工具

    千次阅读 2019-08-27 18:25:48
    /** * */ package cn.xdl.utils.common; import java.util.HashMap; import java.util.Iterator; import java.util.Map; /** * @author liurui * @date 2019年8月27日 */ public class ... // 缓存...
  • php程序在抵抗大流量访问的时候动态网站往往都是难以招架,所以要引入缓存机制,一般情况下两种类型缓存 一、文件缓存 二、数据查询结果缓存,使用内存来实现高速缓存 本例主要使用文件缓存。 主要原理使用缓存...
  • 图标缓存刷新工具....

    2010-11-21 12:53:13
    图标缓存刷新工具图标缓存刷新工具图标缓存刷新工具图标缓存刷新工具
  • DiskDataCacher磁盘缓存工具用法以及原理原创文档,转载请注明出处 by WindyDiskDataCacher是一个轻量级的Android磁盘缓存工具,基于LRU算法实现,同时可以设置缓存有效期,使用起来十分方便。 源码:...
  • 服务器管理>缓存>清除:清除已从工作区中移除的模型 服务器管理>缓存>缓存工具>清除缓存:​除已在本地修改/新建且尚未上传的模型外,其他模型一律清除

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 618,059
精华内容 247,223
关键字:

缓存工具有哪些