public void testMultiCache(CacheableService<?> service) {
Object o1 = new Object();
Object o2 = new Object();
Cache primary = cm.getCache("primary");
Cache secondary = cm.getCache("secondary");
assertNull(primary.get(o1));
assertNull(secondary.get(o1));
Object r1 = service.multiCache(o1);
assertSame(r1, primary.get(o1).get());
assertSame(r1, secondary.get(o1).get());
Object r2 = service.multiCache(o1);
Object r3 = service.multiCache(o1);
assertSame(r1, r2);
assertSame(r1, r3);
assertNull(primary.get(o2));
assertNull(secondary.get(o2));
Object r4 = service.multiCache(o2);
assertSame(r4, primary.get(o2).get());
assertSame(r4, secondary.get(o2).get());
}
public static boolean unLocketTicket(
CacheManager cacheManager, String witRewardid, String witOrderId) {
Cache ticketCache = cacheManager.getCache(CacheConfig.CACHE_NAME_WIT_TICKET_LOCKED);
ticketCache.evict(witOrderId);
getLockedTicketNum(cacheManager, witRewardid);
return true;
}
private void validateGuavaCacheWithStats() {
GuavaCacheManager cacheManager = validateCacheManager(GuavaCacheManager.class);
assertThat(cacheManager.getCacheNames(), containsInAnyOrder("foo", "bar"));
assertThat(cacheManager.getCacheNames(), hasSize(2));
Cache foo = cacheManager.getCache("foo");
foo.get("1");
assertThat(((GuavaCache) foo).getNativeCache().stats().missCount(), equalTo(1L));
}
public void testMethodName(CacheableService<?> service, String keyName) throws Exception {
Object key = new Object();
Object r1 = service.name(key);
assertSame(r1, service.name(key));
Cache cache = cm.getCache("default");
// assert the method name is used
assertNotNull(cache.get(keyName));
}
/**
* @param key
* @throws Exception
*/
public void deleteFromCache(String key) throws CacheOperationException {
logger.info("delete obj from cache with key: " + key);
Cache cache = getCache();
if (!StringUtils.hasText(key)) {
throw new CacheOperationException("No such key in cache. ");
}
cache.evict(key);
}
@Test
public void guavaCacheExplicitWithCaches() {
load(DefaultCacheConfiguration.class, "spring.cache.type=guava", "spring.cache.cacheNames=foo");
GuavaCacheManager cacheManager = validateCacheManager(GuavaCacheManager.class);
Cache foo = cacheManager.getCache("foo");
foo.get("1");
// See next tests: no spec given so stats should be disabled
assertThat(((GuavaCache) foo).getNativeCache().stats().missCount(), equalTo(0L));
}
protected PageInfo buildNewPageInfo(
HttpServletRequest request,
HttpServletResponse response,
FilterChain chain,
CacheStatus cacheStatus,
Map<String, Collection<CacheOperationContext>> operationsByType)
throws Exception {
Timer timer = new Timer(getCachedUri(request));
timer.start();
String key = calculateKey(request);
PageInfo pageInfo;
try {
// Page is not cached - build the response, cache it, and send to client
pageInfo = buildPage(request, response, chain);
if (pageInfo.isOk()) {
Object noCache = pageInfo.getCacheDirectives().get("no-cache");
if (noCache instanceof Boolean && ((Boolean) noCache)) {
log.debug("Response ok but Cache-Control: no-cache is present, not caching");
releaseCacheLocks(operationsByType, key);
} else {
Collection<Cache> caches = new ArrayList<Cache>();
for (CacheOperationContext operationContext : operationsByType.get(UPDATE)) {
for (Cache cache : operationContext.getCaches()) {
caches.add(cache);
}
}
update(caches, pageInfo, cacheStatus, key);
}
} else {
for (CacheOperationContext operationContext : operationsByType.get(UPDATE)) {
for (Cache cache : operationContext.getCaches()) {
log.debug(
"Response not ok ({}). Putting null into cache {} with key {}",
pageInfo.getStatusCode(),
cache.getName(),
key);
}
}
releaseCacheLocks(operationsByType, key);
}
} catch (Exception e) {
if ("net.sf.ehcache.constructs.blocking.LockTimeoutException"
.equals(e.getClass().getName())) {
// do not release the lock, because you never acquired it
throw e;
}
// Must unlock the cache if the above fails. Will be logged at Filter
releaseCacheLocks(operationsByType, key);
throw e;
}
timer.stop(false);
response.addHeader(X_CACHED, String.valueOf(false));
return pageInfo;
}
/**
* @param key
* @throws Exception
*/
public void setToCache(String key, Object value) throws CacheOperationException {
logger.info("set obj to cache with key: " + key);
Cache cache = getCache();
if (!StringUtils.hasText(key)) {
logger.error("Key is empty when setToCache Operation. ");
throw new CacheOperationException("Key is empty when setToCache Operation. ");
}
cache.put(key, value);
}
public boolean destroyCache(String name) {
Cache cache = caches.remove(name);
if (cache != null) {
// TODO remove Redis backing store
cache.clear();
}
return true;
}
@Test
public void testDynamicMode() {
CacheManager cm = new ConcurrentMapCacheManager();
Cache cache1 = cm.getCache("c1");
assertTrue(cache1 instanceof ConcurrentMapCache);
Cache cache1again = cm.getCache("c1");
assertSame(cache1again, cache1);
Cache cache2 = cm.getCache("c2");
assertTrue(cache2 instanceof ConcurrentMapCache);
Cache cache2again = cm.getCache("c2");
assertSame(cache2again, cache2);
Cache cache3 = cm.getCache("c3");
assertTrue(cache3 instanceof ConcurrentMapCache);
Cache cache3again = cm.getCache("c3");
assertSame(cache3again, cache3);
cache1.put("key1", "value1");
assertEquals("value1", cache1.get("key1").get());
cache1.put("key2", 2);
assertEquals(2, cache1.get("key2").get());
cache1.put("key3", null);
assertNull(cache1.get("key3").get());
cache1.evict("key3");
assertNull(cache1.get("key3"));
}
public void testConditionalCacheUpdate(CacheableService<?> service) {
Integer one = Integer.valueOf(1);
Integer three = Integer.valueOf(3);
Cache cache = cm.getCache("default");
assertEquals(one, Integer.valueOf(service.conditionalUpdate(one).toString()));
assertNull(cache.get(one));
assertEquals(three, Integer.valueOf(service.conditionalUpdate(three).toString()));
assertEquals(three, Integer.valueOf(cache.get(three).get().toString()));
}
private Script compileIfNotCompiled(String scriptString, Context ctx) {
ValueWrapper vw = scriptCache.get(scriptString);
Script script = null;
if (vw == null) {
script = ctx.compileString(scriptString, UUID.randomUUID().toString(), 0, null);
scriptCache.put(scriptString, script);
} else {
script = (Script) vw.get();
}
return script;
}
private Function compileIfNotCompiled(Context ctx, String funcStr) {
ValueWrapper vw = funtionCache.get(funcStr);
Function func = null;
if (vw == null) {
func = ctx.compileFunction(global, funcStr, null, 1, null);
funtionCache.put(funcStr, func);
} else {
func = (Function) vw.get();
}
return func;
}
/** Collect agent system data every second. */
@Scheduled(fixedDelay = 1000)
public void collectAgentSystemData() {
Ehcache nativeCache = (Ehcache) agentMonioringTargetsCache.getNativeCache();
List<String> keysWithExpiryCheck = convert(nativeCache.getKeysWithExpiryCheck());
for (String each : keysWithExpiryCheck) {
ValueWrapper value = agentMonioringTargetsCache.get(each);
if (value != null && value.get() != null) {
writeObjectToFile(
getAgentPath(each), getAgentManager().getSystemDataModel((AgentIdentity) value.get()));
}
}
}
public void testCacheUpdate(CacheableService<?> service) {
Object o = new Object();
Cache cache = cm.getCache("default");
assertNull(cache.get(o));
Object r1 = service.update(o);
assertSame(r1, cache.get(o).get());
o = new Object();
assertNull(cache.get(o));
Object r2 = service.update(o);
assertSame(r2, cache.get(o).get());
}
protected void update(
Collection<Cache> caches, PageInfo pageInfo, CacheStatus cacheStatus, String key) {
ValueWrapper element = cacheStatus == null ? null : cacheStatus.valueWrapper;
Object maxAge = pageInfo.getCacheDirectives().get("max-age");
int timeToLive =
(maxAge instanceof Integer) ? ((Integer) maxAge) : (int) pageInfo.getTimeToLiveSeconds();
for (Cache cache : caches) {
log.debug(
"Response ok. Adding to cache {} with key {} and ttl {}",
cache.getName(),
key,
getTimeToLive(element));
put(cache, key, pageInfo, timeToLive);
}
}
public static boolean locketTicket(
CacheManager cacheManager, String witRewardid, String witOrderId) {
Cache ticketindex = cacheManager.getCache(CacheConfig.CACHE_NAME_WIT_TICKET_LOCKED_INDEX);
Cache ticketCache = cacheManager.getCache(CacheConfig.CACHE_NAME_WIT_TICKET_LOCKED);
ticketCache.put(witOrderId, witOrderId);
String json = ticketindex.get(witRewardid, String.class);
List<String> tickets;
if (json != null && !json.isEmpty()) {
tickets = Json.fromJson(json, ArrayList.class);
} else {
tickets = new ArrayList<>();
}
tickets.add(witOrderId);
ticketindex.put(witRewardid, Json.toJson(tickets));
return true;
}
/**
* 获得当前锁定的票数
*
* @param cacheManager
* @param witRewardid
* @return
*/
public static int getLockedTicketNum(CacheManager cacheManager, String witRewardid) {
Cache ticketindex = cacheManager.getCache(CacheConfig.CACHE_NAME_WIT_TICKET_LOCKED_INDEX);
Cache ticketCache = cacheManager.getCache(CacheConfig.CACHE_NAME_WIT_TICKET_LOCKED);
List<String> newTickets = new ArrayList<>();
String json = ticketindex.get(witRewardid, String.class);
if (json != null && !json.isEmpty()) {
List<String> tickets = Json.fromJson(json, ArrayList.class);
for (String t : tickets) {
if (ticketCache.get(t) != null) {
newTickets.add(t);
}
}
ticketindex.put(witRewardid, Json.toJson(newTickets));
}
return newTickets.size();
}
protected boolean inspectCacheEvicts(
Collection<CacheOperationContext> evictions, boolean beforeInvocation) {
if (evictions.isEmpty()) {
return false;
}
boolean trace = log.isTraceEnabled();
boolean atLeastOne = false;
for (CacheOperationContext operationContext : evictions) {
CacheEvictOperation evict = (CacheEvictOperation) operationContext.operation;
if (beforeInvocation == evict.isBeforeInvocation()) {
if (operationContext.isConditionPassing()) {
atLeastOne = true;
// for each cache
// lazy key initialization
Object key = null;
for (Cache cache : operationContext.getCaches()) {
// cache-wide flush
if (evict.isCacheWide()) {
cache.clear();
logRequestDetails(operationContext.request, getContext(), "Flushing request");
} else {
// check key
if (key == null) {
key = operationContext.generateKey();
}
if (trace) {
log.trace(
"Invalidating cache key {} for operation {} on method {}",
key,
evict,
operationContext.method);
}
cache.evict(key);
}
}
} else {
logRequestDetails(operationContext.request, getContext(), "Not flushing request");
}
}
}
return atLeastOne;
}
public void put(String key, Object value, int expire) {
if (!canCache() || value == null) return;
CacheElement ce = CacheElement.create(key, value, expire);
cache.put(key, ce);
if (logger.isInfoEnabled()) {
logger.info("put into cache: " + ce);
}
}
@Override
public CsrfToken loadToken(HttpServletRequest request) {
String token = Strings.clean(request.getParameter(parameterName));
if (token == null) {
token = Strings.clean(request.getHeader(headerName));
}
if (token == null) {
return null;
}
try {
Jws<Claims> jws = Jwts.parser().setSigningKey(signingKey).parseClaimsJws(token);
// signature is valid, now let's ensure it hasn't been submitted before:
String id = jws.getBody().getId();
String usedNonce = null;
Cache.ValueWrapper wrapper = nonceCache.get(id);
if (wrapper != null) {
Object val = wrapper.get();
if (val != null) {
usedNonce = val.toString();
}
}
if (usedNonce == null) {
// CSRF token hasn't been used yet, mark it as used:
nonceCache.put(id, token);
return new DefaultCsrfToken(headerName, parameterName, token);
}
} catch (Exception e) {
log.debug(
"CSRF token is invalid (this is likely to happen and not necessarily an error condition).",
e);
}
return null;
}
public void testMultiPut(CacheableService<?> service) {
Object o = Integer.valueOf(1);
Cache primary = cm.getCache("primary");
Cache secondary = cm.getCache("secondary");
assertNull(primary.get(o));
assertNull(secondary.get(o));
Object r1 = service.multiUpdate(o);
assertSame(r1, primary.get(o).get());
assertSame(r1, secondary.get(o).get());
o = Integer.valueOf(2);
assertNull(primary.get(o));
assertNull(secondary.get(o));
Object r2 = service.multiUpdate(o);
assertSame(r2, primary.get(o).get());
assertSame(r2, secondary.get(o).get());
}
/**
* Add the agent system data model share request on cache.
*
* @param id agent id in db.
*/
@Override
public void requestShareAgentSystemDataModel(Long id) {
AgentInfo agent = getAgent(id, false);
if (agent == null) {
return;
}
agentRequestCache.put(
extractRegionFromAgentRegion(agent.getRegion()) + "|" + createAgentKey(agent),
new ClustedAgentRequest(agent.getIp(), agent.getName(), SHARE_AGENT_SYSTEM_DATA_MODEL));
}
/**
* Stop agent. In cluster mode, it queues the agent stop request to agentRequestCache.
*
* @param id agent id in db
*/
@Override
public void stopAgent(Long id) {
AgentInfo agent = getAgent(id, false);
if (agent == null) {
return;
}
agentRequestCache.put(
extractRegionFromAgentRegion(agent.getRegion()) + "|" + createAgentKey(agent),
new ClustedAgentRequest(agent.getIp(), agent.getName(), STOP_AGENT));
}
/**
* Handles the GET request for downloading an artifact.
*
* @param downloadId the generated download id
* @param response of the servlet
* @return {@link ResponseEntity} with status {@link HttpStatus#OK} if successful
*/
@RequestMapping(method = RequestMethod.GET, value = RestConstants.DOWNLOAD_ID_V1_REQUEST_MAPPING)
@ResponseBody
public ResponseEntity<Void> downloadArtifactByDownloadId(
@PathVariable final String downloadId, final HttpServletResponse response) {
try {
final ValueWrapper cacheWrapper = cache.get(downloadId);
if (cacheWrapper == null) {
LOGGER.warn("Download Id {} could not be found", downloadId);
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
final DownloadArtifactCache artifactCache = (DownloadArtifactCache) cacheWrapper.get();
DbArtifact artifact = null;
switch (artifactCache.getDownloadType()) {
case BY_SHA1:
artifact = artifactRepository.getArtifactBySha1(artifactCache.getId());
break;
default:
LOGGER.warn("Download Type {} not supported", artifactCache.getDownloadType());
break;
}
if (artifact == null) {
LOGGER.warn(
"Artifact with cached id {} and download type {} could not be found.",
artifactCache.getId(),
artifactCache.getDownloadType());
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
try {
IOUtils.copy(artifact.getFileInputStream(), response.getOutputStream());
} catch (final IOException e) {
LOGGER.error("Cannot copy streams", e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
} finally {
cache.evict(downloadId);
}
return ResponseEntity.ok().build();
}
private <T, E extends Throwable> T getValue(Callback<T, E> callback, Cache cache, Object key)
throws E {
@Nullable final Cache.ValueWrapper valueWrapper = cache.get(key);
if (valueWrapper != null) {
return cast(valueWrapper.get());
}
final T loadedValue = callback.call();
putValue(cache, key, loadedValue);
return loadedValue;
}
public static void main(String... args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
ClassroomService classroomService = context.getBean(ClassroomService.class);
Teacher teacher = new Teacher(1, "Mert");
Student student1 = new Student(2, "Tugce");
Person personFetch1 = classroomService.getPerson(teacher);
System.out.println(personFetch1);
Person personFetch2 = classroomService.getPerson(student1);
System.out.println(personFetch2);
CacheManager cacheManager = context.getBean(CacheManager.class);
Cache students = cacheManager.getCache("students");
System.out.println(
"students cache storage: " + ((ConcurrentHashMap) students.getNativeCache()).values());
Cache teachers = cacheManager.getCache("teachers");
System.out.println(
"teachers cache storage: " + ((ConcurrentHashMap) teachers.getNativeCache()).values());
}
public void testEvictAll(CacheableService<?> service) throws Exception {
Object o1 = new Object();
Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
Object o2 = new Object();
Object r10 = service.cache(o2);
assertSame(r1, r2);
assertNotSame(r1, r10);
service.evictAll(new Object());
Cache cache = cm.getCache("default");
assertNull(cache.get(o1));
assertNull(cache.get(o2));
Object r3 = service.cache(o1);
Object r4 = service.cache(o1);
assertNotSame(r1, r3);
assertSame(r3, r4);
}
public UserDetails getUserFromCache(String username) {
Cache.ValueWrapper element = username != null ? cache.get(username) : null;
if (logger.isDebugEnabled()) {
logger.debug("Cache hit: " + (element != null) + "; username: " + username);
}
if (element == null) {
return null;
} else {
return (UserDetails) element.get();
}
}
@Test
public void getAndPut() {
cache.clear();
long key = 1;
Long value = service.getAndPut(key);
assertEquals("Wrong value for @Cacheable key", value, cache.get(key).get());
assertEquals(
"Wrong value for @CachePut key", value, cache.get(value + 100).get()); // See @CachePut
// CachePut forced a method call
Long anotherValue = service.getAndPut(key);
assertNotSame(value, anotherValue);
// NOTE: while you might expect the main key to have been updated, it hasn't. @Cacheable
// operations
// are only processed in case of a cache miss. This is why combining @Cacheable with @CachePut
// is a very bad idea. We could refine the condition now that we can figure out if we are going
// to invoke the method anyway but that brings a whole new set of potential regressions.
// assertEquals("Wrong value for @Cacheable key", anotherValue, cache.get(key).get());
assertEquals(
"Wrong value for @CachePut key", anotherValue, cache.get(anotherValue + 100).get());
}
