缓存可分为二大类:
一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式；
二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查.
下面为一个简单的缓存代码
Java代码
1.package lhm.hcy.guge.frameset.cache;
2.
3.import java.util.*;
4.
5./**
6. * <p>Title: </p>
7. *
8. * <p>Description: 管理缓存</p>
9. * Deep blue 2008-11-28 think
10. * 可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间
11. * <p>Copyright: Copyright (c) 2008</p>
12. *
13. * <p>Company: </p>
14. *
15. * @author Deepblue 2008-11-11
16. * @version 1.0
17. */
18.public class CacheManager {
19. private static HashMap cacheMap = new HashMap();
20.
21. //单实例构造方法
22. private CacheManager() {
23. super();
24. }
25. //获取布尔值的缓存
26. public static boolean getSimpleFlag(String key){
27. try{
28. return (Boolean) cacheMap.get(key);
29. }catch(NullPointerException e){
30. return false;
31. }
32. }
33. public static long getServerStartdt(String key){
34. try {
35. return (Long)cacheMap.get(key);
36. } catch (Exception ex) {
37. return 0;
38. }
39. }
40. //设置布尔值的缓存
41. public synchronized static boolean setSimpleFlag(String key,boolean flag){
42. if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖
43. return false;
44. }else{
45. cacheMap.put(key, flag);
46. return true;
47. }
48. }
49. public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){
50. if (cacheMap.get(key) == null) {
51. cacheMap.put(key,serverbegrundt);
52. return true;
53. }else{
54. return false;
55. }
56. }
57.
58.
59. //得到缓存。同步静态方法
60. private synchronized static Cache getCache(String key) {
61. return (Cache) cacheMap.get(key);
62. }
63.
64. //判断是否存在一个缓存
65. private synchronized static boolean hasCache(String key) {
66. return cacheMap.containsKey(key);
67. }
68.
69. //清除所有缓存
70. public synchronized static void clearAll() {
71. cacheMap.clear();
72. }
73.
74. //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配
75. public synchronized static void clearAll(String type) {
76. Iterator i = cacheMap.entrySet().iterator();
77. String key;
78. ArrayList<String> arr = new ArrayList<String>();
79. try {
80. while (i.hasNext()) {
81. java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
82. key = (String) entry.getKey();
83. if (key.startsWith(type)) { //如果匹配则删除掉
84. arr.add(key);
85. }
86. }
87. for (int k = 0; k < arr.size(); k++) {
88. clearOnly(arr.get(k));
89. }
90. } catch (Exception ex) {
91. ex.printStackTrace();
92. }
93. }
94.
95. //清除指定的缓存
96. public synchronized static void clearOnly(String key) {
97. cacheMap.remove(key);
98. }
99.
100. //载入缓存
101. public synchronized static void putCache(String key, Cache obj) {
102. cacheMap.put(key, obj);
103. }
104.
105. //获取缓存信息
106. public static Cache getCacheInfo(String key) {
107.
108. if (hasCache(key)) {
109. Cache cache = getCache(key);
110. if (cacheExpired(cache)) { //调用判断是否终止方法
111. cache.setExpired(true);
112. }
113. return cache;
114. }else
115. return null;
116. }
117.
118. //载入缓存信息
119. public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) {
120. Cache cache = new Cache();
121. cache.setKey(key);
122. cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存
123. cache.setValue(obj);
124. cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE
125. cacheMap.put(key, cache);
126. }
127. //重写载入缓存信息方法
128. public static void putCacheInfo(String key,Cache obj,long dt){
129. Cache cache = new Cache();
130. cache.setKey(key);
131. cache.setTimeOut(dt+System.currentTimeMillis());
132. cache.setValue(obj);
133. cache.setExpired(false);
134. cacheMap.put(key,cache);
135. }
136.
137. //判断缓存是否终止
138. public static boolean cacheExpired(Cache cache) {
139. if (null == cache) { //传入的缓存不存在
140. return false;
141. }
142. long nowDt = System.currentTimeMillis(); //系统当前的毫秒数
143. long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数
144. if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE
145. return false;
146. } else { //大于过期时间 即过期
147. return true;
148. }
149. }
150.
151. //获取缓存中的大小
152. public static int getCacheSize() {
153. return cacheMap.size();
154. }
155.
156. //获取指定的类型的大小
157. public static int getCacheSize(String type) {
158. int k = 0;
159. Iterator i = cacheMap.entrySet().iterator();
160. String key;
161. try {
162. while (i.hasNext()) {
163. java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
164. key = (String) entry.getKey();
165. if (key.indexOf(type) != -1) { //如果匹配则删除掉
166. k++;
167. }
168. }
169. } catch (Exception ex) {
170. ex.printStackTrace();
171. }
172.
173. return k;
174. }
175.
176. //获取缓存对象中的所有键值名称
177. public static ArrayList<String> getCacheAllkey() {
178. ArrayList a = new ArrayList();
179. try {
180. Iterator i = cacheMap.entrySet().iterator();
181. while (i.hasNext()) {
182. java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
183. a.add((String) entry.getKey());
184. }
185. } catch (Exception ex) {} finally {
186. return a;
187. }
188. }
189.
190. //获取缓存对象中指定类型 的键值名称
191. public static ArrayList<String> getCacheListkey(String type) {
192. ArrayList a = new ArrayList();
193. String key;
194. try {
195. Iterator i = cacheMap.entrySet().iterator();
196. while (i.hasNext()) {
197. java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
198. key = (String) entry.getKey();
199. if (key.indexOf(type) != -1) {
200. a.add(key);
201. }
202. }
203. } catch (Exception ex) {} finally {
204. return a;
205. }
206. }
207.
208.}
209.
210.
211.package lhm.hcy.guge.frameset.cache;
212.
213./**
214. * <p>Title: </p>
215. *
216. * <p>Description: 缓存DTO</p>
217. *
218. * <p>Copyright: Copyright (c) 2008</p>
219. *
220. * <p>Company: </p>
221. *
222. * @author Deepblue 2008-11-11
223. * @version 1.0
224. */
225.public class Cache {
226. private String key;//缓存ID
227. private Object value;//缓存数据
228. private long timeOut;//更新时间
229. private boolean expired; //是否终止
230. public Cache() {
231. super();
232. }
233.
234. public Cache(String key, Object value, long timeOut, boolean expired) {
235. this.key = key;
236. this.value = value;
237. this.timeOut = timeOut;
238. this.expired = expired;
239. }
240.
241. public String getKey() {
242. return key;
243. }
244.
245. public long getTimeOut() {
246. return timeOut;
247. }
248.
249. public Object getValue() {
250. return value;
251. }
252.
253. public void setKey(String string) {
254. key = string;
255. }
256.
257. public void setTimeOut(long l) {
258. timeOut = l;
259. }
260.
261. public void setValue(Object object) {
262. value = object;
263. }
264.
265. public boolean isExpired() {
266. return expired;
267. }
268.
269. public void setExpired(boolean b) {
270. expired = b;
271. }
272.}
273.
274.//测试类，
275.class Test {
276. public static void main(String[] args) {
277. System.out.println(CacheManager.getSimpleFlag("alksd"));
278.// CacheManager.putCache("abc", new Cache());
279.// CacheManager.putCache("def", new Cache());
280.// CacheManager.putCache("ccc", new Cache());
281.// CacheManager.clearOnly("");
282.// Cache c = new Cache();
283.// for (int i = 0; i < 10; i++) {
284.// CacheManager.putCache("" + i, c);
285.// }
286.// CacheManager.putCache("aaaaaaaa", c);
287.// CacheManager.putCache("abchcy;alskd", c);
288.// CacheManager.putCache("cccccccc", c);
289.// CacheManager.putCache("abcoqiwhcy", c);
290.// System.out.println("删除前的大小："+CacheManager.getCacheSize());
291.// CacheManager.getCacheAllkey();
292.// CacheManager.clearAll("aaaa");
293.// System.out.println("删除后的大小："+CacheManager.getCacheSize());
294.// CacheManager.getCacheAllkey();
295.
296.
297. }
298.}
分享到：
相关推荐
仿redis缓存Java版轻量级缓存组件LocalCache，基于JVM内存实现数据缓存及过期机制
标题中的“websphere缓存java调用以及jar包”指的是在IBM WebSphere Application Server (WAS) 中使用Java编程方式来管理和操作缓存系统。WebSphere应用服务器提供了一种高效的方式来存储和检索频繁访问的数据，以...
《DiskLruCache：Java实现的磁盘缓存解析》 在移动开发，尤其是Android应用开发中，数据缓存是优化用户体验的关键技术之一。DiskLruCache是一款基于磁盘的缓存库，由Jake Wharton编写，用于存储关键数据到本地文件...
T21.11_Hibernate的缓存 java 经典教程 经典教材
下面将详细介绍如何在Java中使用Redis缓存，特别是针对Map、List和Set的使用实例。 首先，你需要在项目中引入Jedis的依赖，如果你使用的是Maven，可以在pom.xml文件中添加以下依赖： ```xml <groupId>redis....
Hibernate 是一个非常流行的开源对象关系映射（ORM）框架，它允许 Java 开发人员将数据库操作转换为面向对象的方式，从而简化了数据访问。在 Hibernate 中，缓存机制是提高性能的重要工具，尤其是在处理大量数据时。...
在Java开发中，缓存是一种优化性能的重要技术，它能够减少对数据库的访问频率，提高应用的响应速度。Ehcache是一款广泛使用的开源Java缓存框架，尤其在处理大量数据时，它可以显著提升应用程序的效率。本文将深入...
Java高速文件缓存是一种优化应用程序性能的技术，它通过将经常访问的数据存储在内存中，以减少对硬盘或网络I/O的依赖，从而显著提高数据读取速度。在Java中实现高效的文件缓存策略，可以利用Java集合框架、内存管理...
JCACHE，即JSR 107，是Java临时内存缓存的标准规范，旨在规定如何在内存中缓存Java对象，包括创建、共享、失效等管理方式。它可以优化如JSP页面中频繁读取的数据，显著提升查询响应速度。 Ehcache最初是为Hibernate...
本文将深入探讨如何使用Java Map实现缓存技术，以及其中的关键知识点。 首先，让我们理解什么是缓存。缓存是一种存储技术，用于暂时保存经常访问的数据，以便于快速检索。在Java中，我们通常使用HashMap、...
java本地缓存ConcurrentHashMap
Java中间件，缓存JAVA核心知识点整理--》从Java基础-->Java数据结构-->框架-->Java中间件，缓存JAVA核心知识点整理--》从Java基础-->Java数据结构-->框架-->Java中间件，缓存JAVA核心知识点整理--...
Java利用ConcurrentHashMap实现本地缓存demo； 基本功能有缓存有效期、缓存最大数、缓存存入记录、清理线程、过期算法删除缓存、LRU算法删除、获取缓存值等功能。 复制到本地项目的时候，记得改包路径哦~
本篇文章将深入探讨如何使用Java来实现分页缓存，并介绍在读取过程中如何优先从缓存获取数据。 首先，理解分页的基本概念是必要的。在Web应用中，当用户浏览大量数据时，通常会采用分页的方式来显示，而不是一次性...
java实现缓存可以通过读取本地文件的方式实现，改代码就是通过读取本地文件实现缓存的简单例子
分布式缓存是现代大型Java系统中的重要组成部分，它主要用于存储经常访问的数据，以减少数据库的负担，提高系统的响应速度和整体性能。这份“Java系统分布式缓存PPT”涵盖了从基础理论到实战技巧，再到综合案例，...
Java 微服务实践 - Spring Boot 缓存 Java 微服务实践中，缓存是一种久经考验并且显著地提升应用性能以及伸缩性的技术。缓存用作临时存储信息复本，该复本未来可能被再次使用，减少再次加载或创建的成本。 Java ...
本篇将深入探讨如何利用Java虚拟机（JVM）进行高效的缓存处理，以提升项目的典型数据应用性能。我们将从源码解析、工具使用等角度出发，全面理解并实践JVM缓存技术。 一、JVM内存模型与缓存 Java虚拟机的内存模型...
本文将探讨如何利用缓存策略来优化Java中的反射操作，并通过源码分析来阐述这一过程。 反射优化的一个关键策略是使用缓存。当频繁地使用相同的反射操作时，如获取Class对象、构造函数或方法，预加载这些信息并存储...