Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.github.bingoohuang.springrediscache;
  
  import org.slf4j.Logger;
 
 
 import static net.jodah.expiringmap.ExpiringMap.ExpirationPolicy.CREATED;
 
     private final MethodInvocation invocation;
     private final RedisCacheEnabled redisCacheAnn;
     private final String valueKey;
     private final String lockKey;
     private final Redis redis;
     private final ExpiringMap<StringCachedValueWrapperlocalCache;
     private final ApplicationContext appContext;
     private final ScheduledExecutorService executorService;
     final Logger logger;
     private final ValueSerializable valueSerializer;
     private Object value;
 
                       ApplicationContext appContextScheduledExecutorService executorService) {
         this. = LoggerFactory.getLogger(invocation.getMethod().getDeclaringClass());
         this. = invocation;
         this. = invocation.getMethod().getAnnotation(RedisCacheEnabled.class);
         this. = RedisCacheUtils.tryGetBean(appContextRedis.class);
         this. = localCache;
         this. = appContext;
         this. = executorService;
 
         this. = RedisCacheUtils.generateValueKey(invocationappContext);
         this. = RedisCacheUtils.createValueSerializer(appContextinvocation.getMethod(), );
         this. =  + ":lock";
     }
 
     long expirationSeconds() {
         return .expirationSeconds();
     }
 
     Object invokeMethod() {
         this. = RedisCacheUtils.invokeMethod();
         return this.;
     }
 
     boolean tryRedisLock() {
         boolean locked = .tryLock();
         if (locked.debug("got redis lock {}");
         return locked;
     }
 
     void unlockRedis(boolean locked) {
         if (locked) {
             .del();
             .debug("free redis lock {}");
         }
     }
 
     void setex(long expirationSeconds) {
         .debug("put redis {} = {} with expiration {} seconds"expirationSeconds);
 
         String value = .serialize(this.);
         .setex(valueexpirationSeconds.);
     }
 
     Object getLocalCache() {
         CachedValueWrapper cachedValue = .get();
         if (cachedValue != null) {
             long expectedExpiration = getExpectedExpirationSeconds();
             .debug("got local {} = {} with expiration {} seconds"cachedValue.getValue(), expectedExpiration);
             if (expectedExpiration >= 0) this. = cachedValue.getValue();
             else .remove();
         } else {
             .debug("got local {} = null");
         }
 
         return this.;
     }
 
     private long getExpectedExpirationSeconds() {
         try {
             return .getExpectedExpiration() / 1000;
         } catch (NoSuchElementException e) {
             return -1;
         }
     }
 
     long redisTtlSeconds() {
         return .ttl();
     }
 
    void putLocalCache(long ttlSeconds) {
        .debug("put local {} = {} with expiration {} seconds"this.ttlSeconds);
        CachedValueWrapper valueWrapper = new CachedValueWrapper(this.);
        .put(valueWrapperttlSeconds.);
    }
        waitRedisLock();
        loadRedisValueToCache(-1);
    }
    Object getValue() {
        return ;
    }
    void loadRedisValueToCache(long ttlSeconds) {
        String redisValue = .get();
        .debug("got redis {} = {}"redisValue);
        if (StringUtils.isEmpty(redisValue))  = null;
        else {
             = .deserialize(redisValue.getMethod());
            if ( != nullputLocalCache(ttlSeconds > 0 ? ttlSeconds : redisTtlSeconds());
        }
    }
    boolean isBeforeAheadSeconds() {
    }
    boolean isAheadRefreshEnabled() {
        return .aheadRefresh() &&
                .expirationSeconds() > .;
    }
    Object process() {
        checkRedisRequired();
        CacheProcessor cacheProcessor = getCacheProcessor();
        return cacheProcessor.process();
    }
    private CacheProcessor getCacheProcessor() {
        switch (.redisFor()) {
            case :
                return new StoreValueProcessor(this);
            case :
            case :
            default:
                return new RefreshSecondsProcessor(this);
        }
    }
    private void checkRedisRequired() {
        switch (.redisFor()) {
            case :
            case :
                if ( != nullreturn;
                throw new RuntimeException("Redis bean should defined in spring context");
        }
    }
    private void tryInvalidCacheIfConnectingCache() {
        Object threadLocalValue = ..get();
        if (threadLocalValue == nullreturn;
        .remove();
    }
    void submit(Runnable runnable) {
        .submit(runnable);
    }
    boolean tryLockLocalCache() {
        return prev == null;
    }
    void unlockLocalCache() {
        .remove();
        .debug("free local lock {}");
    }
        invokeMethod();
        if ( != null) {
            long expiration = RedisCacheUtils.redisExpirationSeconds();
            putLocalCache(expiration);
        }
        return ;
    }
    void waitCacheLock() {
        .debug("wait cache lock {}");
        while (!tryLockLocalCache()) {
            RedisCacheUtils.sleep(100);
        }
        .debug("got cache lock {}");
    }
    private void waitRedisLock() {
        .debug("wait redis lock {}");
        do {
            RedisCacheUtils.sleep(100);
        } while (.isLocked());
        .debug("got redis lock {}");
    }
New to GrepCode? Check out our FAQ X