/**
  * See {@link #testCacheEntryFactoryReturningElementMake} this test ensures the Refresh
  * functionality works
  */
 @Test
 public void testCacheEntryFactoryReturningElementRefresh() throws Exception {
   final long specialVersionNumber = 54321L;
   final CacheEntryFactory elementReturningFactory =
       new CacheEntryFactory() {
         public Object createEntry(final Object key) throws Exception {
           Element e = new Element(key, "V_" + key);
           e.setVersion(specialVersionNumber);
           return e;
         }
       };
   selfPopulatingCache = new SelfPopulatingCache(cache, elementReturningFactory);
   Element e = null;
   e = selfPopulatingCache.get("key1");
   assertEquals("V_key1", e.getValue());
   assertEquals(specialVersionNumber, e.getVersion());
   e = selfPopulatingCache.get("key2");
   assertEquals("V_key2", e.getValue());
   assertEquals(specialVersionNumber, e.getVersion());
   assertEquals(2, selfPopulatingCache.getSize());
   selfPopulatingCache.refresh();
   e = selfPopulatingCache.get("key1");
   assertEquals("V_key1", e.getValue());
   assertEquals(specialVersionNumber, e.getVersion());
   e = selfPopulatingCache.get("key2");
   assertEquals("V_key2", e.getValue());
   assertEquals(specialVersionNumber, e.getVersion());
   assertEquals(2, selfPopulatingCache.getSize());
 }
Exemple #2
0
 @Test
 public void testSupportsCopyOnRead() {
   Element element = new Element(KEY, "Some String", 1);
   xaStore.put(element);
   Element copy = xaStore.get(KEY);
   assertNotNull(copy);
   assertNotSame(copy, xaStore.get(KEY));
   assertEquals("Some String", copy.getValue());
   assertEquals(copy.getValue(), xaStore.get(KEY).getValue());
   assertNotSame(copy.getValue(), xaStore.get(KEY).getValue());
 }
  @Override
  public synchronized void updateEntry(final String key, final HttpCacheUpdateCallback callback)
      throws IOException, HttpCacheUpdateException {
    int numRetries = 0;
    do {
      final Element oldElement = cache.get(key);

      HttpCacheEntry existingEntry = null;
      if (oldElement != null) {
        final byte[] data = (byte[]) oldElement.getValue();
        existingEntry = serializer.readFrom(new ByteArrayInputStream(data));
      }

      final HttpCacheEntry updatedEntry = callback.update(existingEntry);

      if (existingEntry == null) {
        putEntry(key, updatedEntry);
        return;
      } else {
        // Attempt to do a CAS replace, if we fail then retry
        // While this operation should work fine within this instance, multiple instances
        //  could trample each others' data
        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
        serializer.writeTo(updatedEntry, bos);
        final Element newElement = new Element(key, bos.toByteArray());
        if (cache.replace(oldElement, newElement)) {
          return;
        } else {
          numRetries++;
        }
      }
    } while (numRetries <= maxUpdateRetries);
    throw new HttpCacheUpdateException("Failed to update");
  }
  /** Tests the expiry notifier. Check a reported scenario */
  @Test
  public void testExpiryNotifications() throws InterruptedException {
    Serializable key = "1";
    Element element = new Element(key, new Date());

    TestCacheEventListener cacheEventListener = new TestCacheEventListener();
    cache.getCacheEventNotificationService().registerListener(cacheEventListener);

    // Put
    cache.put(element);

    // expire
    Thread.sleep(15000);
    for (int i = 0; i < cache.getCacheConfiguration().getMaxEntriesLocalHeap(); i++) {
      cache.put(new Element(i, i));
      cache.get(i); // makes sure the entry is flushed
    }
    assertThat(cacheEventListener.counter.get(), equalTo(1));

    // the TestCacheEventListener does a put of a new Element with the same key on expiry
    assertNotNull(cache.get(key));
    Element newElement = cache.get(key);
    assertNotNull(newElement);
    assertEquals("set on notify", newElement.getValue());

    // Check counting listener
    CountingCacheEventListener listener = getCountingCacheEventListener(cache);
    List<CacheEvent> notifications = listener.getCacheElementsExpired();
    assertThat(notifications, hasSize(1));
    assertEquals(element, notifications.get(0).getElement());

    // check for NPE
    cache.remove(null);
  }
  /** 主方法 如果某方法可被缓存就缓存其结果 方法结果必须是可序列化的(serializable) */
  public Object invoke(MethodInvocation invocation) throws Throwable {

    String targetName = invocation.getThis().getClass().getName();

    String methodName = invocation.getMethod().getName();

    Object[] arguments = invocation.getArguments();

    Object result;

    logger.info("在缓存中查找方法返回的对象!");

    String cacheKey = getCacheKey(targetName, methodName, arguments);

    Element element = cache.get(cacheKey);

    if (element == null) {

      logger.info("正在拦截方法!");

      result = invocation.proceed();

      logger.info("正在缓存对象!");

      element = new Element(cacheKey, (Serializable) result);

      cache.put(element);
    }

    return element.getValue();
  }
 /**
  * Retrieve the missed cache item from the specified cache.
  *
  * @param key the unique key for the cache item
  * @param cacheName the name of the cache - this is the cache region name from ehcache config
  * @param <T> the type of the cache item
  * @return the cache item instance
  */
 protected <T> T getObjectFromCache(String key, String cacheName) {
   Element cacheElement = getCache(cacheName).get(key);
   if (cacheElement != null) {
     return (T) cacheElement.getValue();
   }
   return null;
 }
 @Override
 public <T extends GeneralMessage> boolean isNewMessage(String userId, T message, Class<T> T) {
   Cache cache = cm.getCache("Messages");
   String key = message.getUniqueFieldValue() + userId;
   Element element = cache.get(key);
   if (element != null) {
     return (Boolean) element.getValue();
   }
   Query<UnreaddenMessage> isUnread =
       ds.createQuery(UnreaddenMessage.class)
           .field("userId")
           .equal(userId)
           .field("message")
           .equal(new Key<T>(T, message.getId()));
   Query<ReaddenMessage> isRead =
       ds.createQuery(ReaddenMessage.class)
           .field("userId")
           .equal(userId)
           .field("messageUniqueId")
           .equal(message.getUniqueFieldValue().toString());
   Boolean newMessage = isUnread.countAll() <= 0 && isRead.countAll() <= 0;
   element = new Element(key, new Boolean(false));
   cache.put(element);
   return newMessage;
 }
 public V get(final K key) {
   Element element = this.cache.get(key);
   if (element != null) {
     return (V) element.getValue();
   }
   return null;
 }
 @Override
 public void doResponse() {
   // TODO Auto-generated method stub
   try {
     String platform = request.getParameter("p");
     platform = platform == null ? "android" : platform;
     String cacheIndex = REQUEST_TYPE + ",p:" + platform;
     UtilFunctions.serverLog("cacheIndex:" + cacheIndex);
     String responseData = null;
     Element element = null;
     if ((element = cache.get(cacheIndex)) != null /*cache.isKeyInCache(cacheIndex)*/) {
       responseData = (String) element.getValue();
       // System.out.println(REQUEST_TYPE+":缓存数据");
       UtilFunctions.serverLog(REQUEST_TYPE + CACHE_DATA);
     } else {
       VersionService versionService = (VersionService) context.getBean("versionService");
       Version version =
           versionService.getLatestVersion(
               platform == null ? VersionService.PLATFORM_ANDROID : platform);
       if (version == null) {
         UtilFunctions.serverLog(REQUEST_TYPE + "version is null");
         return;
       }
       responseData = version.getJSONObject().toString();
       cache.put(new Element(cacheIndex, responseData));
       // System.out.println(REQUEST_TYPE+":非缓存数据");
       UtilFunctions.serverLog(REQUEST_TYPE + NOT_CACHE_DATA);
     }
     PrintWriter pw = response.getWriter();
     pw.write(responseData);
     pw.close();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
 public <T extends ISocioObject> void saveObject(T object) throws DuplicateMySocioObjectException {
   if (object instanceof IUniqueObject) {
     IUniqueObject uniqueObject = (IUniqueObject) object;
     Cache cache = cm.getCache("Objects");
     String key = uniqueObject.getUniqueFieldName() + uniqueObject.getUniqueFieldValue();
     Element element = cache.get(key);
     if (element != null) {
       ((SocioObject) object).setId((ObjectId) element.getValue());
       return;
     }
     @SuppressWarnings("unchecked")
     Query<T> q =
         (Query<T>)
             ds.createQuery(object.getClass())
                 .field(uniqueObject.getUniqueFieldName())
                 .equal(uniqueObject.getUniqueFieldValue());
     T objectT = (T) q.get();
     if (objectT != null) {
       ((SocioObject) object).setId(objectT.getId());
       element = new Element(key, objectT.getId());
       cache.put(element);
       logger.info(
           "Duplicate object of type: " + object.getClass() + " for query: " + q.toString());
       throw new DuplicateMySocioObjectException(
           "Duplicate object of type: " + object.getClass() + " for query: " + q.toString());
     }
   }
   ds.save(object);
 }
  @Around("findTurmaEfetiva()")
  public Object findTurmaEfetivaMethodInterceptor(ProceedingJoinPoint joinPoint) throws Throwable {
    Object result = null;
    CacheManager cacheManager =
        CacheManager.create(new ClassPathResource("echache.xml").getInputStream());
    Cache cache = cacheManager.getCache("turmas-efetivas-cache");

    Object[] args = joinPoint.getArgs();

    Long turmaId = (Long) args[0];

    Element element = cache.get(turmaId);

    if (element == null) {
      result = joinPoint.proceed();
      cache.put(new Element(turmaId, result));

    } else {
      Logger.getLogger(this.getClass().getName())
          .log(
              Level.INFO,
              "Dados presentes no cache de turmas, não foi necessário acesso ao banco de dados");
      result = element.getValue();
    }
    return result;
  }
  @Around("findAllComPendendias()")
  public Object findAllTurmasComPendenciasMethodInterceptor(ProceedingJoinPoint joinPoint)
      throws Throwable {
    Object result = null;
    CacheManager cacheManager =
        CacheManager.create(new ClassPathResource("echache.xml").getInputStream());
    Cache cache = cacheManager.getCache("turmas-pendencias-cache");

    Object[] args = joinPoint.getArgs();

    if (args[0] == null || args[1] == null) {
      result = joinPoint.proceed();
      return result;
    }
    SimpleDateFormat df = new SimpleDateFormat("yyyy");
    String exercicio = df.format((Date) args[0]);
    String organizacao = ((Long) args[1]).toString();

    String key = exercicio + "-" + organizacao;
    Element element = cache.get(key);

    if (element == null) {
      result = joinPoint.proceed();
      cache.put(new Element(key, result));
    } else {
      Logger.getLogger(this.getClass().getName())
          .log(Level.INFO, "Dados presentes no cache, não foi necessário acesso ao banco de dados");
      result = element.getValue();
    }
    return result;
  }
 /** {@inheritDoc} */
 @Override
 public Integer getNewPmCountFor(String username) {
   Element cacheElementForUser = userDataCache.get(username);
   if (cacheElementForUser == null) {
     return null;
   }
   return (Integer) cacheElementForUser.getValue();
 }
  /** Tests fetching an entry. */
  @Test
  public void testFetch() throws Exception {
    LOG.error(".");

    // Lookup
    final Element element = selfPopulatingCache.get("key");
    assertEquals("value", element.getValue());
  }
 @Override
 @SuppressWarnings("unchecked")
 public Map<String, Product> getCachedProductList() {
   Element cachedCodeList = this.codeCache.get("productList");
   if (cachedCodeList == null) {
     cacheCodeList();
   }
   return (Map<String, Product>) cachedCodeList.getValue();
 }
 /** {@inheritDoc} */
 @Override
 public void decrementNewMessageCountFor(String username) {
   Element cacheElementForUser = userDataCache.get(username);
   if (cacheElementForUser != null) {
     int count = (Integer) cacheElementForUser.getValue();
     count--;
     userDataCache.put(new Element(username, count));
   }
 }
 public void notifyElementExpired(Ehcache cache, Element element) {
   JRadiusSession session = (JRadiusSession) element.getValue();
   RadiusLog.debug("Expired session: " + session.getSessionKey());
   if (JRadiusServer.getEventDispatcher() != null) {
     SessionExpiredEvent evt = new SessionExpiredEvent(session);
     evt.setApplicationContext(applicationContext);
     JRadiusServer.getEventDispatcher().post(evt);
   }
 }
Exemple #18
0
  protected Dashboard getDashboardFromCache(DashboardCacheKey key) {
    Dashboard dashboard;

    RepositoryAccess repository = RepositoryAccess.getRepository();

    try {
      Cache cache = getCache();
      Element cacheElement = cache.get(key);
      if (cacheElement == null) {
        return null;
      } else {
        dashboard = (Dashboard) cacheElement.getValue();
      }
      logger.info("Got dashboard from cache");
      ISolutionFile dash =
          repository.getSolutionFile(key.getCdfde(), FileAccess.READ); // was NO_PERM=0;
      if (dash == null) {
        logger.error(key.getCdfde() + " not found.");
        return null;
      }

      ISolutionFile templ;
      if (key.getTemplate() == null) {
        templ = null;
      } else {
        templ = repository.getSolutionFile(key.getTemplate(), FileAccess.READ);
      }

      /* Cache is invalidated if the dashboard or template have changed since
       * the cache was loaded, or at midnight every day, because of dynamic
       * generation of date parameters.
       */
      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.HOUR_OF_DAY, 00);
      cal.set(Calendar.MINUTE, 00);
      cal.set(Calendar.SECOND, 1);
      boolean
          cacheInvalid =
              dash.getLastModified() > dashboard.getLoaded().getTime()
                  || (templ != null && templ.getLastModified() > dashboard.getLoaded().getTime()),
          cacheExpired = cal.getTime().after(dashboard.getLoaded());

      if (cacheExpired) {
        logger.info("Dashboard expired, re-rendering");
        return null;
      } else if (cacheInvalid) {
        logger.info("Dashboard cache invalidated, re-rendering");
        return null;
      } else {
        return dashboard;
      }
    } catch (CacheException ce) {
      logger.info("Dashboard cache invalidated, re-rendering");
      return null;
    }
  }
  @Override
  public synchronized HttpCacheEntry getEntry(final String key) throws IOException {
    final Element e = cache.get(key);
    if (e == null) {
      return null;
    }

    final byte[] data = (byte[]) e.getValue();
    return serializer.readFrom(new ByteArrayInputStream(data));
  }
 public synchronized long incr(String key, int by) {
   Element e = cache.get(key);
   if (e == null) {
     return -1;
   }
   long newValue = ((Number) e.getValue()).longValue() + by;
   Element newE = new Element(key, newValue);
   newE.setTimeToLive(e.getTimeToLive());
   cache.put(newE);
   return newValue;
 }
Exemple #21
0
  @Around("simplePointcut()")
  public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
    String targetName = joinPoint.getTarget().getClass().toString();
    String methodName = joinPoint.getSignature().getName();
    Object[] arguments = joinPoint.getArgs();

    // 试图得到标注的Ehcache类
    @SuppressWarnings("unused")
    Method[] methods = joinPoint.getTarget().getClass().getMethods();
    Ehcache flag = null;
    for (Method m : methods) {
      if (m.getName().equals(methodName)) {
        Class[] tmpCs = m.getParameterTypes();
        if (tmpCs.length == arguments.length) {
          flag = m.getAnnotation(Ehcache.class);
          break;
        }
      }
    }
    if (flag == null) {
      return null;
    }
    // Ehcache flag
    // =joinPoint.getTarget().getClass().getMethod(methodName).getAnnotation(Ehcache.class);
    Object result;
    String cacheKey = getCacheKey(targetName, methodName, arguments);

    Element element = null;
    if (flag.eternal()) {
      // 永久缓存
      element = dictCache.get(cacheKey);
    } else {
      // 临时缓存
      element = eternalCache.get(cacheKey);
    }

    if (element == null) {
      if ((arguments != null) && (arguments.length != 0)) {
        result = joinPoint.proceed(arguments);
      } else {
        result = joinPoint.proceed();
      }

      element = new Element(cacheKey, (Serializable) result);
      if (flag.eternal()) {
        // 永久缓存
        dictCache.put(element);
      } else {
        // 临时缓存
        eternalCache.put(element);
      }
    }
    return element.getValue();
  }
  @Override
  public ManageableSecurity loadSecurityDetail(ManageableSecurity base) {
    ManageableSecurity cached;

    Element e = _detailsCache.get(base.getUniqueId());
    if (e != null) {
      cached = (ManageableSecurity) e.getValue();
    } else {
      cached = _underlying.loadSecurityDetail(base);
      e = new Element(base.getUniqueId(), cached);
      _detailsCache.put(e);
    }
    return JodaBeanUtils.clone(cached);
  }
  @Override
  public SellingContext getByGuid(final String sellingContextGuid) {
    Element element = getCache().get(sellingContextGuid);
    if (element != null && !element.isExpired()) {
      LOG.debug("get objecct from cache... guid: " + sellingContextGuid);
      return (SellingContext) element.getValue();
    }

    LOG.debug("get objecct from database... guid: " + sellingContextGuid);
    SellingContext sellingContext = sellingContextService.getByGuid(sellingContextGuid);
    cache.put(new Element(sellingContextGuid, sellingContext));

    return sellingContext;
  }
 public Serializable get(Serializable key) {
   if (getEhcache().getStatus() == Status.STATUS_ALIVE) {
     try {
       Element element = getEhcache().get(key);
       if (element == null) {
         return null;
       } else {
         return element.getValue();
       }
     } catch (Error ignore) {
       return null;
     }
   }
   return null;
 }
  /** {@inheritDoc} */
  @SuppressWarnings("unchecked")
  @Override
  public void removeCache(String cacheName, LookupCode lookupCode) {

    Cache cache = cacheManager.getCache("codeCache");
    Element element = cache.get("codeList");
    Map<String, List<LookupCode>> map = (Map<String, List<LookupCode>>) element.getValue();
    List<LookupCode> lookupCodes = codeService.getCodeList(lookupCode);
    if (lookupCodes.size() == 0) {
      map.remove(lookupCode.getCodeGroup());
    } else {
      map.put(lookupCode.getCodeGroup(), lookupCodes);
    }

    this.codeCache.put(new Element("codeList", map));
  }
  /** {@inheritDoc} */
  @SuppressWarnings("unchecked")
  @Override
  public List<LookupCode> appendCache(String cacheName, LookupCode lookupCode) {
    String lang = lookupCode.getLanguage();
    lookupCode.setLanguage("ALL");

    Cache cache = cacheManager.getCache("codeCache");
    Element element = cache.get(cacheName);
    Map<String, List<LookupCode>> map = (Map<String, List<LookupCode>>) element.getValue();
    List<LookupCode> lookupCodes = codeService.getCodeList(lookupCode);
    map.put(lookupCode.getCodeGroup(), lookupCodes);

    this.codeCache.put(new Element("codeList", map));
    lookupCode.setLanguage(lang);
    return lookupCodes;
  }
Exemple #27
0
 private CnATreeElement getFromCache(CnATreeElement element) {
   final Element cachedElement = getCache().get(element.getUuid());
   if (cachedElement != null) {
     element = (CnATreeElement) cachedElement.getValue();
     if (getLog().isDebugEnabled()) {
       getLog()
           .debug("Element from cache: " + element.getTitle() + ", UUID: " + element.getUuid());
     }
   } else {
     element = getDao().retrieve(element.getDbId(), RetrieveInfo.getPropertyInstance());
     if (element != null) {
       getCache().put(new Element(element.getUuid(), element));
     }
   }
   return element;
 }
Exemple #28
0
 private void oturumSayisiArtir() {
   GregorianCalendar gcal = new GregorianCalendar();
   int minute = gcal.get(GregorianCalendar.MINUTE);
   int hour = gcal.get(GregorianCalendar.HOUR_OF_DAY);
   String statisticKey = "" + ((hour * 6) + (minute / 10));
   Element element = getStatisticCache().get(statisticUUID + statisticKey);
   OturumStatistic oturumSayisi = null;
   if (element == null) {
     oturumSayisi = new OturumStatistic(statisticKey);
   } else {
     oturumSayisi = (OturumStatistic) element.getValue();
   }
   oturumSayisi.oturumSayisiArtir();
   Element element2 = new Element(statisticUUID + statisticKey, oturumSayisi);
   getStatisticCache().put(element2);
 }
  public CasAuthentication get(String serviceTicket) {
    Element element = null;
    try {
      element = cache.get(serviceTicket);
    } catch (CacheException cacheException) {
      throw new CacheException("Cache failure: " + cacheException.getMessage());
    }

    if (logger.isDebugEnabled()) {
      logger.debug("Cache hit: " + (element != null) + "; service ticket: " + serviceTicket);
    }

    if (element == null) {
      return null;
    } else {
      return (CasAuthentication) element.getValue();
    }
  }
  /** {@inheritDoc} */
  @SuppressWarnings("unchecked")
  @Override
  public Product appendProductCache(String cacheName, String prodCd) {

    Cache cache = cacheManager.getCache("codeCache");
    Element element = cache.get(cacheName);
    Map<String, Product> map = (Map<String, Product>) element.getValue();
    Product pdhProduct = new Product();
    pdhProduct.setProdCd(prodCd);
    List<Product> products = pdhService.getAllProductList(pdhProduct);
    if (products != null && products.size() > 0) {
      map.put(prodCd, products.get(0));
      return products.get(0);
    } else {
      // 할인상품이 있는 지 한번더 조회 한다.
      return pdhService.getDiscountProduct(pdhProduct);
    }
  }