Java缓存池代码实例详解

时间:2022-09-29 09:35:52

这篇实例中有四个类,分别为

CacheItem  缓存实体类

CachePool  缓存池

Student  学生实体类

MainTest  主测试类

其中,缓存实体类CacheItem  中存放管理学生实体对象Student  ,缓存实体类CacheItem  存放在缓存池CachePool  中,MainTest  主要负责整体的测试工作。

缓存实体类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com.paic.zhangqi.cache; 
import java.util.Date;
 
/**
 * 缓存实体
 * @author ZHANGQI947
 */
public class CacheItem { 
 // 创建缓存时间
 private Date createTime = new Date();  
 // 缓存期满时间
 private long expireTime = 1;  
 // 缓存实体
 private Object entity;   
 public CacheItem(Object obj, long expires) {
  this.entity = obj;
  this.expireTime = expires;
 }  
 // 判断缓存是否超时
 public boolean isExpired() {
  return (expireTime != -1 && new Date().getTime() - createTime.getTime() > expireTime);
 
 public Date getCreateTime() {
  return createTime;
 
 public void setCreateTime(Date createTime) {
  this.createTime = createTime;
 
 public Object getEntity() {
  return entity;
 
 public void setEntity(Object entity) {
  this.entity = entity;
 
 public long getExpireTime() {
  return expireTime;
 
 public void setExpireTime(long expireTime) {
  this.expireTime = expireTime;
 }
}

缓存池CachePool

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package com.paic.zhangqi.cache; 
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
 * 缓存池
 * @author Administrator
 */
public class CachePool {
 // 缓存池唯一实例
 private static CachePool instance;
 // 缓存Map
 private static Map<String, Object> cacheItems;  
 private CachePool() {
  cacheItems = new HashMap<String, Object>();
 }  
 /**
  * 获取唯一的实例
  * @return instance
  */
 public synchronized static CachePool getInstance() {
  if (instance == null) {
   instance = new CachePool();
  }
  return instance;
 }  
 /**
  * 清除所有的Item缓存
  */
 public synchronized void clearAllItems() {
  cacheItems.clear();
 }  
 /**
  * 获取缓存实例
  * @param name 缓存名称
  * @return 缓存实例
  */
 public synchronized Object getCacheItem(String name) {
  if (!cacheItems.containsKey(name)) {
   return null;
  }
  CacheItem cacheItem = (CacheItem) cacheItems.get(name);
  if (cacheItem.isExpired()) {
   return null;
  }
  return cacheItem.getEntity();
 }
 /**
  * 存放缓存信息
  * @param name 名称
  * @param obj 实例对象
  * @param expires 超时时长
  */
 public synchronized void putCacheItem(String name, Object obj, long expires) {
  // 判断该对象是否在在缓存池,不在直接put
  if (!cacheItems.containsKey(name)) {
   cacheItems.put(name, new CacheItem(obj, expires));
  }
  // 获取缓存池中对象,更新对象信息
  CacheItem cacheItem = (CacheItem) cacheItems.get(name);
  cacheItem.setCreateTime(new Date());
  cacheItem.setEntity(obj);
  cacheItem.setExpireTime(expires);
 }
 /**
  * 移除缓存数据
  * @param name
  */
 public synchronized void removeCacheItem(String name) {
  if (!cacheItems.containsKey(name)) {
   return ;
  }
  cacheItems.remove(name);
 }  
 /**
  * 获取缓存数据的数量
  * @return
  */
 public int getSize() {
  return cacheItems.size();
 
}

学生类Student

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.paic.zhangqi.cache;
/**
 * 学生类
 * @author Administrator
 */
public class Student { 
 private String name;
 private String id;
 private int age;
 private int sal;
 public Student() {
   
 }  
 public Student(String name, String id, int age, int sal) {
  this.name = name;
  this.id = id;
  this.age = age;
  this.sal = sal;
 
 public String getName() {
  return name;
 
 public void setName(String name) {
  this.name = name;
 
 public String getId() {
  return id;
 
 public void setId(String id) {
  this.id = id;
 
 public int getAge() {
  return age;
 
 public void setAge(int age) {
  this.age = age;
 
 public int getSal() {
  return sal;
 }
 public void setSal(int sal) {
  this.sal = sal;
 }
}

主测试类MainTest

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.paic.zhangqi.cache;
/**
 * 主测试类
 * @author ZHANGQI947
 */
public class MainTest {
 
 /**
  * @param args
  * @throws InterruptedException
  */
 public static void main(String[] args) throws InterruptedException {
  // 获取缓存池
  CachePool cachePool = CachePool.getInstance();   
  Student stu1 = new Student("l1", "stu001", 25, 40);
  Student stu2 = new Student("l2", "stu002", 25, 40);
  Student stu3 = new Student("l3", "stu003", 25, 40);
  Student stu4 = new Student("l4", "stu004", 25, 40);   
  cachePool.putCacheItem("001", stu1, 122222);
  cachePool.putCacheItem("002", stu2, 10);
  cachePool.putCacheItem("003", stu3, 360002);
  cachePool.putCacheItem("004", stu4, 1222222);   
  // 设置线程休眠,其中002对象会超时
  Thread.sleep(200);   
  Student stu001 = (Student) cachePool.getCacheItem("001");
  if (null != stu001) {
   System.out.println(stu001.getName());
  }   
  // 由于超时,这里取出的002对象为null
  Student stu002 = (Student) cachePool.getCacheItem("002");
  if (null != stu002) {
   System.out.println(stu002.getName());
  }   
  // 获取打印缓存池中对象数量
  int cacheSize = cachePool.getSize();
  System.out.println(cacheSize);   
  // 删除对象002
  cachePool.removeCacheItem("002");  
  // 打印缓存池数量
  cacheSize = cachePool.getSize();
  System.out.println(cacheSize);
 }
}

测试结果

l1 

3

希望本篇文章内容对您有所帮助

原文链接:http://blog.csdn.net/magi1201/article/details/60964107