package com.hh;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class LocalUtil {
private static Cache<String,Integer> demoCache= CacheBuilder.newBuilder().
expireAfterWrite(10, TimeUnit.SECONDS).recordStats().build();
public static Integer getKey(String key, Callable<Integer> callable) throws ExecutionException {
Integer integer = demoCache.get(key, callable);
return integer;
}
}
package com.hh;
import com.google.common.cache.CacheBuilder;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
public class Test05 {
public static void main(String[] args) throws ExecutionException {
Callable<Integer> callable= new Callable<Integer>() {
public Integer call() throws Exception {
System.out.println("hello");
return 10;
}
};
System.out.println(LocalUtil.getKey("1",callable));
System.out.println(LocalUtil.getKey("1",callable));
}
}
package com.sankuai.grocerywms.logistics.gray.grocery.service.utils;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.sankuai.grocerywms.logistics.gray.grocerygraycenterclient.response.GrayBatchDTO;
import com.sankuai.grocerywms.logistics.gray.grocerygraycenterclient.response.GrayPlanApiDTO;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class LocalCacheUtils {
public static void test() throws Exception {
LoadingCache<String, Integer> cache = CacheBuilder.newBuilder()
.expireAfterWrite(60, TimeUnit.SECONDS)//缓存10秒,10秒之后进行回收
.recordStats()//开启,记录状态数据功能
.build(new CacheLoader<String, Integer>() {
//数据加载,默认返回-1,也可以是查询操作,如从DB查询
@Override
public Integer load(String key) throws Exception {
// TODO Auto-generated method stub
return -1;
}
});
cache.put("key1", 1);
System.out.println(cache.get("key1"));
Thread.sleep(5000);
System.out.println(cache.get("key1"));
Thread.sleep(5000);
System.out.println(cache.get("key1"));
}
/**
* 从缓存中获取灰度信息列表
*
* @param listGrayPlanIds
* @param listResponse
* @return
* @throws Exception
*/
public static List<GrayPlanApiDTO> getGranPlanList(List<Long> listGrayPlanIds, List<GrayPlanApiDTO> listResponse) throws Exception {
List<GrayPlanApiDTO> grayPlanApiDTOList = Collections.emptyList();
if (listGrayPlanIds.size() > 0) {
String key = StringNewUtils.listToString(listGrayPlanIds, ',');
// 从缓存里取,如果取不到从库里取,然后放入缓存中
LoadingCache<String, List<GrayPlanApiDTO>> cache = CacheBuilder.newBuilder()
.expireAfterWrite(60, TimeUnit.SECONDS)//缓存10秒,10秒之后进行回收
.recordStats()//开启,记录状态数据功能
.build(new CacheLoader<String, List<GrayPlanApiDTO>>() {
//数据加载,默认返回-1,也可以是查询操作,如从DB查询
@Override
public List<GrayPlanApiDTO> load(String key) throws Exception {
// 从数据库里取,根据list读取plan,batch,config前端,后端,终端
return listResponse;
}
});
grayPlanApiDTOList = cache.get(key);
} else {
// todo 缓存所有有效的灰度信息
}
return grayPlanApiDTOList;
}
/**
* 缓存操作对象-根据需求获取灰度信息
*/
private static LoadingCache<String, List<GrayPlanApiDTO>> GLOBAL_CACHE = null;
/**
* 配置
*/
private static LoadingCache<String, List<GrayBatchDTO>> GRAYBATCH_CACHE = null;
/**
* 配置-中的featureId
*/
private static LoadingCache<String, List<String>> GRAYFEATUREID_CACHE = null;
/**
* 配置-中的featureId
*/
private static LoadingCache<String, Long> GRAYDIMID_CACHE = null;
static {
List<GrayPlanApiDTO> grayPlanApiDTOList = Collections.emptyList();
String key = "default";
// 从缓存里取,如果取不到从库里取,然后放入缓存中
GLOBAL_CACHE = CacheBuilder.newBuilder()
.expireAfterWrite(60, TimeUnit.SECONDS)//缓存10秒,10秒之后进行回收
.recordStats()//开启,记录状态数据功能
.build(new CacheLoader<String, List<GrayPlanApiDTO>>() {
//数据加载,默认返回-1,也可以是查询操作,如从DB查询
@Override
public List<GrayPlanApiDTO> load(String key) throws Exception {
// 从数据库里取,根据list读取plan,batch,config前端,后端,终端
return Collections.emptyList();
}
});
// 灰度配置
// 从缓存里取,如果取不到从库里取,然后放入缓存中
GRAYBATCH_CACHE = CacheBuilder.newBuilder()
.expireAfterWrite(60, TimeUnit.SECONDS)//缓存10秒,10秒之后进行回收
.recordStats()//开启,记录状态数据功能
.build(new CacheLoader<String, List<GrayBatchDTO>>() {
//数据加载,默认返回-1,也可以是查询操作,如从DB查询
@Override
public List<GrayBatchDTO> load(String key) throws Exception {
// 从数据库里取,根据list读取plan,batch,config前端,后端,终端
return Collections.emptyList();
}
});
GRAYFEATUREID_CACHE = CacheBuilder.newBuilder()
.expireAfterWrite(60, TimeUnit.SECONDS)//缓存10秒,10秒之后进行回收
.recordStats()//开启,记录状态数据功能
.build(new CacheLoader<String, List<String>>() {
//数据加载,默认返回-1,也可以是查询操作,如从DB查询
@Override
public List<String> load(String key) throws Exception {
// 从数据库里取,根据list读取plan,batch,config前端,后端,终端
return Collections.emptyList();
}
});
GRAYDIMID_CACHE = CacheBuilder.newBuilder()
.expireAfterWrite(60, TimeUnit.SECONDS)//缓存10秒,10秒之后进行回收
.recordStats()//开启,记录状态数据功能
.build(new CacheLoader<String, Long>() {
//数据加载,默认返回-1,也可以是查询操作,如从DB查询
@Override
public Long load(String key) throws Exception {
// 从数据库里取,根据list读取plan,batch,config前端,后端,终端
return -1L;
}
});
}
/**
* 获取缓存
*
* @param key
* @return
* @throws Exception
*/
public static List<GrayPlanApiDTO> getKeyValue(String key) throws Exception {
return GLOBAL_CACHE.get(key);
}
/**
* 更新缓存
*
* @param key
* @param listResponse
* @return
* @throws Exception
*/
public static void pushKeyValue(String key, List<GrayPlanApiDTO> listResponse) throws Exception {
GLOBAL_CACHE.put(key,listResponse);
}
/**
* 获取缓存
*
* @param key
* @return
* @throws Exception
*/
public static List<GrayBatchDTO> getKeyBatchValue(String key) throws Exception {
return GRAYBATCH_CACHE.get(key);
}
/**
* 更新缓存
*
* @param key
* @param listResponse
* @return
* @throws Exception
*/
public static void pushKeyBatchValue(String key, List<GrayBatchDTO> listResponse) throws Exception {
GRAYBATCH_CACHE.put(key,listResponse);
}
/**
* 获取缓存
*
* @param key
* @return
* @throws Exception
*/
public static List<String> getKeyFeatureValue(String key) throws Exception {
return GRAYFEATUREID_CACHE.get(key);
}
/**
* 更新缓存
*
* @param key
* @param listResponse
* @return
* @throws Exception
*/
public static void pushKeyFeatureValue(String key, List<String> listResponse) throws Exception {
GRAYFEATUREID_CACHE.put(key,listResponse);
}
/**
* 获取缓存
*
* @param key
* @return
* @throws Exception
*/
public static Long getKeyDimValue(String key) throws Exception {
return GRAYDIMID_CACHE.get(key);
}
/**
* 更新缓存
*
* @param key
* @param listResponse
* @return
* @throws Exception
*/
public static void pushKeyDimValue(String key, Long listResponse) throws Exception {
GRAYDIMID_CACHE.put(key,listResponse);
}
}
package com.sankuai.grocerywms.logistics.gray.grocery.service.utils;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.sankuai.grocerywms.logistics.gray.grocerygraycenterclient.response.GrayBatchDTO;
import com.sankuai.grocerywms.logistics.gray.grocerygraycenterclient.response.GrayPlanApiDTO;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class LocalCacheNewUtils {
/**
* 缓存操作对象-根据需求获取灰度信息
*/
private static LoadingCache<String, Object> GLOBAL_CACHE = null;
static {
String key = "default";
// 从缓存里取,如果取不到从库里取,然后放入缓存中
GLOBAL_CACHE = CacheBuilder.newBuilder()
.expireAfterWrite(60, TimeUnit.SECONDS)//缓存10秒,10秒之后进行回收
.recordStats()//开启,记录状态数据功能
.build(new CacheLoader<String, Object>() {
//数据加载,默认返回-1,也可以是查询操作,如从DB查询
@Override
public Object load(String key) throws Exception {
// 从数据库里取,根据list读取plan,batch,config前端,后端,终端
return "";
}
});
}
/**
* 获取缓存
*
* @param key
* @return
* @throws Exception
*/
public static Object getKeyValue(String key) throws Exception {
return GLOBAL_CACHE.get(key);
}
/**
* 更新缓存
*
* @param key
* @param listResponse
* @return
* @throws Exception
*/
public static void pushKeyValue(String key, Object listResponse) throws Exception {
GLOBAL_CACHE.put(key,listResponse);
}
}