一、创建Employee员工类
package cn.codeduck.guavatest.pojo;
import com.google.common.base.MoreObjects;
public class Employee {
private String name;
private String dept;
private String empID;
public Employee() {
}
public Employee(String name, String dept, String empID) {
this.name = name;
this.dept = dept;
this.empID = empID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDept() {
return dept;
}
public void setDept(String dept) {
this.dept = dept;
}
public String getEmpID() {
return empID;
}
public void setEmpID(String empID) {
this.empID = empID;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(Employee.class)
.add("name",name)
.add("dept",dept)
.add("empID", empID).toString();
}
}
二、Guava Cache使用示例：
package cn.codeduck.guavatest.basic;
import cn.codeduck.guavatest.pojo.Employee;
import com.google.common.cache.*;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.ListenableFuture;
import org.junit.Test;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
public class LoadingCacheTest {
@Test
public void test(){
//创建一个员工LoadingCache对象
LoadingCache<String, Employee> employeeLoadingCache = CacheBuilder.newBuilder()
.maximumSize(100) //基于容量回收：总数量100个
// .maximumWeight(1000) //基于容量回收：总权重1000
// .weigher(new Weigher<String, Employee>() { //配置权重
// @Override
// public int weigh(String key, Employee employee) {
// return key.length();
// }
// })
.expireAfterAccess(30, TimeUnit.MINUTES) //定时回收：没有读写访问30分钟后失效清理
.expireAfterWrite(30, TimeUnit.MINUTES) //定时回收：没有写访问30分钟后失效清理
.refreshAfterWrite(3, TimeUnit.SECONDS) //定时刷新缓存，和expireAfterWrite使用，只有检索时刷新缓存。
.weakKeys() //基于引用回收：弱引用key
.weakValues() //基于引用回收：弱引用value
// .softValues() //基于引用回收：软引用value
.removalListener(RemovalListeners.asynchronous(new RemovalListener<String, Employee>() { //异步移除监听器
@Override
public void onRemoval(RemovalNotification<String, Employee> removalNotification) {
System.out.println("removalNotification = " + removalNotification);
}
}, new Executor() {
@Override
public void execute(Runnable command) {
command.run();
}
}))
.recordStats() //开启Guava Cache 统计功能
.build(CacheLoader.asyncReloading(new CacheLoader<String, Employee>() { //异步缓存加载器
// get 缓存获取不到值时候加载
@Override
public Employee load(String key) throws Exception {
//数据库中加载
return getFromDatabase(key);
}
// refresh 扩展刷新时的行为
@Override
public ListenableFuture<Employee> reload(String key, Employee oldValue) throws Exception {
return super.reload(key, oldValue);
}
// getAll 缓存批量获取不到值时候加载
@Override
public Map<String, Employee> loadAll(Iterable<? extends String> keys) throws Exception {
return super.loadAll(keys);
}
}, new Executor() {
@Override
public void execute(Runnable command) {
command.run();
}
}));
// 1.单个查询
System.out.println("1.单个查询");
try {
System.out.println("#第一次调用:");
// 在第一次调用时，缓存将从数据库中填充相应的员工记录
System.out.println(employeeLoadingCache.get("100"));
System.out.println(employeeLoadingCache.get("103"));
System.out.println(employeeLoadingCache.get("110"));
System.out.println("#第二次调用:");
// 在第二次调用时，会直接从缓存中读取
System.out.println(employeeLoadingCache.get("100"));
System.out.println(employeeLoadingCache.get("103"));
System.out.println(employeeLoadingCache.get("110"));
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("#第三次调用:");
// 第三次调用时 getUnchecked 不执行检查
System.out.println(employeeLoadingCache.getUnchecked("100"));
System.out.println(employeeLoadingCache.getUnchecked("103"));
System.out.println(employeeLoadingCache.getUnchecked("110"));
//1.单个查询
//#第一次调用:
//数据库命中100
//Employee{name=Mahesh, dept=Finance, empID=100}
//数据库命中103
//Employee{name=Rohan, dept=IT, empID=103}
//数据库命中110
//Employee{name=Sohan, dept=Admin, empID=110}
//#第二次调用:
//Employee{name=Mahesh, dept=Finance, empID=100}
//Employee{name=Rohan, dept=IT, empID=103}
//Employee{name=Sohan, dept=Admin, empID=110}
//#第三次调用:
//Employee{name=Mahesh, dept=Finance, empID=100}
//Employee{name=Rohan, dept=IT, empID=103}
//Employee{name=Sohan, dept=Admin, empID=110}
// 2.批量查询
System.out.println("\n2.批量查询");
try {
List<String> list = Lists.newArrayList("100", "103", "110");
ImmutableMap<String, Employee> cacheAll = employeeLoadingCache.getAll(list);
cacheAll.forEach((k,v)->{
System.out.println("key: "+k+", value: "+v);
});
} catch (ExecutionException e) {
e.printStackTrace();
}
//2.批量查询
//key: 100, value: Employee{name=Mahesh, dept=Finance, empID=100}
//key: 103, value: Employee{name=Rohan, dept=IT, empID=103}
//key: 110, value: Employee{name=Sohan, dept=Admin, empID=110}
// 3.回调查询
System.out.println("\n3.回调查询");
try {
Object employee = employeeLoadingCache.get("001", new Callable<Employee>() {
@Override
public Employee call() throws Exception {
return getFromDatabase("001");
}
});
System.out.println(employee);
} catch (ExecutionException e) {
e.printStackTrace();
}
//3.回调查询
//数据库命中001
//Employee{name=Tingfeng, dept=Admin, empID=001}
// 4.显示插入
System.out.println("\n4.显示插入");
employeeLoadingCache.put("001", new Employee("若风","总裁部","001"));
System.out.println(employeeLoadingCache.getUnchecked("001"));
//4.显示插入
//removalNotification = 001=Employee{name=Tingfeng, dept=Admin, empID=001}
//Employee{name=若风, dept=总裁部, empID=001}
// 5.更改视图
System.out.println("\n5.更改视图");
try {
ConcurrentMap<String, Employee> asMap = employeeLoadingCache.asMap();
asMap.put("100",new Employee("codeduck","CTO","100"));
ImmutableMap<String, Employee> cacheAll = employeeLoadingCache.getAll(Lists.newArrayList("100", "103", "110"));
cacheAll.forEach((k,v)->{
System.out.println("key: "+k+", value:"+v);
});
} catch (ExecutionException e) {
e.printStackTrace();
}
//5.更改视图
//removalNotification = 100=Employee{name=Mahesh, dept=Finance, empID=100}
//key: 100, value:Employee{name=codeduck, dept=CTO, empID=100}
//key: 103, value:Employee{name=Rohan, dept=IT, empID=103}
//key: 110, value:Employee{name=Sohan, dept=Admin, empID=110}
// 6.清除缓存
System.out.println("\n6.清除所有缓存,调用移除监听器");
employeeLoadingCache.invalidateAll();
//6.清除所有缓存,调用移除监听器
//removalNotification = 100=Employee{name=codeduck, dept=CTO, empID=100}
//removalNotification = 001=Employee{name=若风, dept=总裁部, empID=001}
//removalNotification = 110=Employee{name=Sohan, dept=Admin, empID=110}
//removalNotification = 103=Employee{name=Rohan, dept=IT, empID=103}
}
// 模拟数据库中数据
private static Employee getFromDatabase(String empId) {
Map<String, Employee> database = Maps.newHashMap();
database.put("100", new Employee("Mahesh", "Finance", "100"));
database.put("103", new Employee("Rohan", "IT", "103"));
database.put("110", new Employee("Sohan", "Admin", "110"));
database.put("001", new Employee("Tingfeng", "Admin", "001"));
System.out.println("数据库命中" + empId);
return database.get(empId);
}
}
