这篇实例中有四个类,分别为
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
4
3
希望本篇文章内容对您有所帮助
原文链接:http://blog.csdn.net/magi1201/article/details/60964107