Java基础缓存
、缓存
将程序或系统中常用的数据对象存储在像内存这样特定的介质中，以避免在每次程序调用时，重新创建或组织数据所带来的性能损耗，从而提高了系统的整体运行速度
以目前的系统架构来说，用户的请求一般会先经过缓存系统，如果缓存中没有相关的数据，就会在其他系统中查询到相应的数据并保存在缓存中，最后返回给调用方
2、本地式缓存
本地缓存是指程序级别的缓存组件，它的特点是本地缓存和应用程序会运行在同一个进程中，所以本地缓存的操作会非常快，因为在同一个进程内也意味着不会有网络上的延迟和开销
本地缓存适用于单节点非集群的应用场景，它的优点是快，缺点是多程序无法共享缓存
无法共享缓存可能会造成系统资源的浪费，这是因为每个系统都单独维护了一份属于自己的缓存，而同一份缓存有可能被多个系统单独进行存储，从而浪费了系统资源
本地缓存可以使用 EhCache 和 Google 的 Guava 来实现
EhCache ：
目前比较流行的开源缓存框架，是用纯 Java 语言实现的简单、快速的 Cache 组件
支持内存缓存和磁盘缓存
支持 LRU（Least Recently Used，最近很少使用）、LFU（Least Frequently Used，最近不常被使用）和 FIFO（First In First Out，先进先出）等多种淘汰算法
支持分布式的缓存系统
LRU 和 LFU 的区别：
LRU 算法有一个缺点，比如说很久没有使用的一个键值，如果最近被访问了一次，那么即使它是使用次数最少的缓存，它也不会被淘汰
LFU 算法解决了偶尔被访问一次之后，数据就不会被淘汰的问题，它是根据总访问次数来淘汰数据的，其核心思想是“如果数据过去被访问多次，那么将来它被访问次数也会比较多”
1
2
3
4
5
6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 创建缓存管理器，可以通过单例或者多例的方式创建，也是 Ehcache 的入口类
// 每个 CacheManager 可以管理多个 Cache，每个 Cache 可以采用 hash 的方式存储多个元素
CacheManager cacheManager= CacheManagerBuilder.newCacheManagerBuilder().build();
// 初始化 EhCache
cacheManager.init();
// 创建缓存（存储器）
Cache
CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class,
ResourcePoolsBuilder.heap(10)));// 设置缓存的最大容量
// 设置缓存的最大容量
// 设置缓存
myCache.put("key","Hello");
// 读取缓存
String value = myCache.get("key");
// 输出缓存
System.out.println(value);
// 关闭缓存
cacheManager.close();
Guava ：
Guava Cache 是 Google 开源的 Guava 里的一个子功能
是一个内存型的本地缓存实现方案，提供了线程安全的缓存操作机制
Guava Cache 的架构设计灵感来源于 ConcurrentHashMap，它使用了多个 segments 方式的细粒度锁，在保证线程安全的同时，支持了高并发的使用场景
Guava Cache 类似于 Map 集合的方式对键值对进行操作，只不过多了过期淘汰等处理逻辑
Guava Cache 的创建有两种方式，一种是 LoadingCache，另一种是 Callable
1
2
3
4
5
6
7
//添加依赖
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
import com.google.common.cache.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class GuavaExample {
public static void main(String[] args) throws ExecutionException {
// 创建方式一：LoadingCache
LoadingCache
// 并发级别设置为 5，是指可以同时写缓存的线程数
.concurrencyLevel(5)
// 设置 8 秒钟过期
.expireAfterWrite(8, TimeUnit.SECONDS)
//设置缓存容器的初始容量为 10
.initialCapacity(10)
// 设置缓存最大容量为 100，超过之后就会按照 LRU 算法移除缓存项
.maximumSize(100)
// 设置要统计缓存的命中率
.recordStats()
// 设置缓存的移除通知
.removalListener(new RemovalListener
public void onRemoval(RemovalNotification
System.out.println(notification.getKey() + " was removed, cause is " + notification.getCause());
}
})
// 指定 CacheLoader，缓存不存在时，可自动加载缓存
.build(
new CacheLoader
@Override
public String load(String key) throws Exception {
// 自动加载缓存的业务
return "cache-value:" + key;
}
}
);
// 设置缓存
loadCache.put("c1", "Hello, c1.");
// 查询缓存
String val = loadCache.get("c1");
System.out.println(val);
// 查询不存在的缓存
String noval = loadCache.get("noval");
System.out.println(noval);
// 创建方式二：Callable
Cache
.maximumSize(2) // 设置缓存最大长度
.build();
// 设置缓存
cache.put("k1", "Hello, k1.");
// 查询缓存
String value = cache.get("k1", new Callable
@Override
public String call() {
// 缓存不存在时，执行
return "nil";
}
});
// 输出缓存值
System.out.println(value);
// 查询缓存
String nokey = cache.get("nokey", new Callable
@Override
public String call() {
// 缓存不存在时，执行
return "nil";
}
});
// 输出缓存值
System.out.println(nokey);
}
}
3、分布式缓存
指将应用系统和缓存组件进行分离的缓存机制，这样多个应用系统就可以共享一套缓存数据了，它的特点是共享缓存服务和可集群部署，为缓存系统提供了高可用的运行环境，以及缓存共享的程序运行机制
分布式缓存可以使用 Redis 或 Memcached 来实现