`
cfyme
  • 浏览: 273681 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

(转载)java本地缓存实现

 
阅读更多

在java web 项目中对频繁读取且相对稳定的数据一般都是用了缓存,这样可以极大地减少数据库的压力且提高的响应的速度。 一般都是,通过key 从缓存中读取value 如果value 为空则读取DB,将DB读取的数据再放入缓存这样的一个过程。

一个简易的本地缓存实现。

      首先数据一般都是有时效性的,不是放入缓存就一直存在,如果超过一定时间没有被使用则应当被清空,使其系统中不会使用到过期数据。

      下面是对本地缓存的一种简单实现

           首先定义一个缓存实体,包含三个属性 放入缓存的时间戳,值以及过期时间;其次需要个线程去监控缓存实体是否过期。

 

Java代码  收藏代码
  1. /** 
  2. * 
  3. * @author zhangwei_david 
  4. * @version $Id: CacheEntity.java, v 0.1 2014年9月6日 下午2:07:00 Lenovo Exp $ 
  5. */  
  6. /** 
  7. *本地缓存保存的实体 
  8. * 
  9. * @author Lenovo 
  10. * @version $Id: LocalCache.java, v 0.1 2014年9月6日 下午1:13:43 Lenovo Exp $ 
  11. */  
  12. public class CacheEntity implements Serializable {  
  13.   
  14. /** */  
  15. private static final long serialVersionUID = 7172649826282703560L;  
  16.   
  17. /** 
  18. * 值 
  19. */  
  20. private Object value;  
  21.   
  22. /** 
  23. * 保存的时间戳 
  24. */  
  25. private long gmtModify;  
  26.   
  27. /** 
  28. * 过期时间 
  29. */  
  30. private int expire;  
  31.   
  32. public Object getValue() {  
  33. return value;  
  34. }  
  35.   
  36. public void setValue(Object value) {  
  37. this.value = value;  
  38. }  
  39.   
  40. public long getGmtModify() {  
  41. return gmtModify;  
  42. }  
  43.   
  44. public void setGmtModify(long gmtModify) {  
  45. this.gmtModify = gmtModify;  
  46. }  
  47.   
  48. public int getExpire() {  
  49. return expire;  
  50. }  
  51.   
  52. public void setExpire(int expire) {  
  53. this.expire = expire;  
  54. }  
  55.   
  56. public CacheEntity(Object value, long gmtModify, int expire) {  
  57. super();  
  58. this.value = value;  
  59. this.gmtModify = gmtModify;  
  60. this.expire = expire;  
  61. }  
  62.   
  63. }  

 

Java代码  收藏代码
  1. /** 
  2. * 简易本地缓存的实现类 
  3. * @author zhangwei_david 
  4. * @version $Id: LocalCache.java, v 0.1 2014年9月6日 下午1:04:53 zhangwei_david Exp $ 
  5. */  
  6. public class LocalCache {  
  7. //默认的缓存容量  
  8. private static int DEFAULT_CAPACITY = 512;  
  9. //最大容量  
  10. private static int MAX_CAPACITY = 100000;  
  11. //刷新缓存的频率  
  12. private static int MONITOR_DURATION = 2;  
  13. // 启动监控线程  
  14. static {  
  15. new Thread(new TimeoutTimerThread()).start();  
  16. }  
  17. //使用默认容量创建一个Map  
  18. private static ConcurrentHashMap<String, CacheEntity> cache = new ConcurrentHashMap<String, CacheEntity>(  
  19. DEFAULT_CAPACITY);  
  20.   
  21. /** 
  22. * 将key-value 保存到本地缓存并制定该缓存的过期时间 
  23. * 
  24. * @param key 
  25. * @param value 
  26. * @param expireTime 过期时间,如果是-1 则表示永不过期 
  27. * @return 
  28. */  
  29. public boolean putValue(String key, Object value, int expireTime) {  
  30. return putCloneValue(key, value, expireTime);  
  31. }  
  32.   
  33. /** 
  34. * 将值通过序列化clone 处理后保存到缓存中,可以解决值引用的问题 
  35. * 
  36. * @param key 
  37. * @param value 
  38. * @param expireTime 
  39. * @return 
  40. */  
  41. private boolean putCloneValue(String key, Object value, int expireTime) {  
  42. try {  
  43. if (cache.size() >= MAX_CAPACITY) {  
  44. return false;  
  45. }  
  46. // 序列化赋值  
  47. CacheEntity entityClone = clone(new CacheEntity(value, System.nanoTime(), expireTime));  
  48. cache.put(key, entityClone);  
  49. return true;  
  50. catch (Exception e) {  
  51. e.printStackTrace();  
  52. }  
  53. return false;  
  54. }  
  55.   
  56. /** 
  57. * 
  58. * 序列化 克隆处理 
  59. * @param object 
  60. * @return 
  61. */  
  62. private <T extends Serializable> T clone(T object) {  
  63. T cloneObject = null;  
  64. try {  
  65. ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  66. ObjectOutputStream oos = new ObjectOutputStream(baos);  
  67. oos.writeObject(object);  
  68. oos.close();  
  69. ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());  
  70. ObjectInputStream ois = new ObjectInputStream(bais);  
  71. cloneObject = (T) ois.readObject();  
  72. ois.close();  
  73. catch (Exception e) {  
  74. e.printStackTrace();  
  75. }  
  76. return cloneObject;  
  77. }  
  78.   
  79. /** 
  80. *从本地缓存中获取key对应的值,如果该值不存则则返回null 
  81. * 
  82. * @param key 
  83. * @return 
  84. */  
  85. public Object getValue(String key) {  
  86. return cache.get(key).getValue();  
  87.   
  88. }  
  89.   
  90. /** 
  91. * 清空所有 
  92. */  
  93. public void clear() {  
  94. cache.clear();  
  95. }  
  96.   
  97. /** 
  98. * 过期处理线程 
  99. * 
  100. * @author Lenovo 
  101. * @version $Id: LocalCache.java, v 0.1 2014年9月6日 下午1:34:23 Lenovo Exp $ 
  102. */  
  103. static class TimeoutTimerThread implements Runnable {  
  104. public void run() {  
  105. while (true) {  
  106. try {  
  107. System.out.println("Cache monitor");  
  108. TimeUnit.SECONDS.sleep(MONITOR_DURATION);  
  109. checkTime();  
  110. catch (Exception e) {  
  111. e.printStackTrace();  
  112. }  
  113. }  
  114. }  
  115.   
  116. /** 
  117. * 过期缓存的具体处理方法 
  118. * @throws Exception 
  119. */  
  120. private void checkTime() throws Exception {  
  121. //"开始处理过期 ";  
  122.   
  123. for (String key : cache.keySet()) {  
  124. CacheEntity tce = cache.get(key);  
  125. long timoutTime = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime()  
  126. - tce.getGmtModify());  
  127. //" 过期时间 : "+timoutTime);  
  128. if (tce.getExpire() > timoutTime) {  
  129. continue;  
  130. }  
  131. System.out.println(" 清除过期缓存 : " + key);  
  132. //清除过期缓存和删除对应的缓存队列  
  133. cache.remove(key);  
  134. }  
  135. }  
  136. }  
  137.   
  138. }  

 

转载地址:http://zhangwei-david.iteye.com/blog/2179087

分享到:
评论

相关推荐

    Java利用ConcurrentHashMap实现本地缓存demo

    Java利用ConcurrentHashMap实现本地缓存demo; 基本功能有缓存有效期、缓存最大数、缓存存入记录、清理线程、过期算法删除缓存、LRU算法删除、获取缓存值等功能。 复制到本地项目的时候,记得改包路径哦~

    java本地缓存ConcurrentHashMap

    java本地缓存ConcurrentHashMap

    如何基于LoadingCache实现Java本地缓存

    Java 本地缓存基于 LoadingCache 实现详解 在 Java 中,缓存是一种提高应用程序性能的重要手段。 LoadingCache 是 Guava 库提供的一种缓存实现方式,本文将详细介绍如何基于 LoadingCache 实现 Java 本地缓存。 一...

    Java本地缓存的实现代码

    ConcurrentHashMap是Java中的一个线程安全的哈希表,可以用来实现本地缓存。其线程安全的特性使得基于ConcurrentHashMap的LocalCache在多线程并发环境下的操作是安全的。在JDK1.8中,ConcurrentHashMap还支持完全...

    java手写本地缓存示例

    基于java的map和timer实现本地缓存及定时清理失效缓存的功能 本项目仅用于初学者学习使用 初学者可基于此项目初步了解缓存实现的基本原理 后期在项目中使用建议使用现成的缓存框架:redis、ehcache等

    实现 Java 本地缓存的方法解析

    在实现本地缓存时,我们可以采用 ConcurrentHashMap 作为存储集合,使用定时删除策略来处理过期缓存,并采用最少使用策略来淘汰缓存。 Cache 对象类是实现本地缓存的核心部分, Cache 对象类实现了 Comparable ...

    java 通过文件实现缓存

    java实现缓存可以通过读取本地文件的方式实现,改代码就是通过读取本地文件实现缓存的简单例子

    java map 实现缓存技术

    本文将深入探讨如何使用Java Map实现缓存技术,以及其中的关键知识点。 首先,让我们理解什么是缓存。缓存是一种存储技术,用于暂时保存经常访问的数据,以便于快速检索。在Java中,我们通常使用HashMap、...

    redis本地缓存与redis缓存

    本地缓存指的是将数据存储在应用程序的内存中,通常是Java的HashMap、Guava Cache或C#的MemoryCache等。这种方式的优点在于数据读取速度极快,因为避免了网络通信的延迟。但是,本地缓存的缺点也很明显,如数据一致...

    spring简单的缓存

    本示例将聚焦于“Spring简单的缓存”实现,帮助开发者了解如何在Spring框架中集成和使用缓存功能。 Spring框架提供了强大的缓存抽象,支持多种缓存机制,如 EhCache、Redis、Hazelcast 和 Infinispan 等。在Spring...

    本地缓存与分布式缓存优缺点,使用

    1. 不能进行大量数据存储:本地缓存占用了应用进程的内存空间,比如 Java 进程的 JVM 内存空间,故不能进行大数据量存储。 2. 集群部署,数据可能存在不一致:需要应用服务保证数据一致性。 3. 应用重启,缓存数据...

    清楚Java Applet缓存

    当用户访问包含Applet的网页时,这些Applets会被下载到本地并运行,同时,Java运行环境(Java Virtual Machine, JVM)会将它们存储在本地缓存中,以优化后续的加载速度,避免每次访问都重新下载。 然而,这种缓存...

    java Map实现的cache manager,定时清除缓存里面的值

    java Map实现的cache manager,定时清除缓存里面的值,使数据一致保持最新

    仿redis缓存Java版轻量级缓存组件LocalCache

    仿redis缓存Java版轻量级缓存组件LocalCache,基于JVM内存实现数据缓存及过期机制

    Java缓存技术的使用实例

    在这个“Java缓存技术的使用实例”中,我们将深入探讨Java缓存的实现、工作原理以及如何部署和运行示例代码。 首先,让我们理解什么是缓存。缓存是一种存储机制,用于临时存储常用或最近使用的数据,以便快速访问。...

    Java本地缓存

    实现Java本地缓存的方法多种多样,常见的有以下几种: 1. **Guava Cache**:Google提供的Guava库包含了强大的缓存功能,支持自动过期、大小限制等特性。开发者可以通过简单的API设置缓存策略,并在需要时将缓存的...

    带有本地缓存机制的http连接框架

    3. 内置缓存:内置了本地缓存机制,无需额外编写代码即可实现数据的本地存储和读取。 4. 支持多种请求方法:GET、POST、PUT、DELETE等HTTP方法都可轻松使用。 5. 请求参数与Header管理:方便地添加请求参数和自定义...

    java简单的缓存池实现

    java缓存原理,简单的缓存池实现,java缓存原理,简单的缓存池实现,java缓存原理,简单的缓存池实现,java缓存原理,简单的缓存池实现。

    springboot笔记-集成Java本地缓存之王Caffeine Cache

    springboot笔记-集成Java本地缓存之王Caffeine Cache

Global site tag (gtag.js) - Google Analytics