Java 类net.sf.ehcache.Ehcache 实例源码

项目：lams 文件：EhCacheFactoryBean.java

/**
 * Predict the particular {@code Ehcache} implementation that will be returned from
 * {@link #getObject()} based on logic in {@link #createCache()} and
 * {@link #decorateCache(Ehcache)} as orchestrated by {@link #afterPropertiesSet()}.
 */
@Override
public Class<? extends Ehcache> getObjectType() {
    if (this.cache != null) {
        return this.cache.getClass();
    }
    if (this.cacheEntryFactory != null) {
        if (this.cacheEntryFactory instanceof UpdatingCacheEntryFactory) {
            return UpdatingSelfPopulatingCache.class;
        }
        else {
            return SelfPopulatingCache.class;
        }
    }
    if (this.blocking) {
        return BlockingCache.class;
    }
    return Cache.class;
}

项目：webside 文件：EhCacheShiroSessionRepository.java

@SuppressWarnings("unchecked")
@Override
   public Collection<Session> getAllSessions() {
    Collection<Session> sessions = new ArrayList<Session>(0);
    try {
        Object object = cacheManager.getCache(this.activeSessionsCacheName).getNativeCache();
        if(object instanceof Ehcache)
        {
            Ehcache ehcache = (Ehcache)object;
            List<Serializable> keys = ehcache.getKeysWithExpiryCheck();
            if (!CollectionUtils.isEmpty(keys)) {
                for (Serializable key : keys) {
                    sessions.add(getSession(key));
                }
            }
        }
    } catch (Exception e) {
        logger.error("获取全部session异常", e);
    }

       return sessions;
   }

项目：xsharing-services-router 文件：EhCacheWrapper.java

/**
 * Use the Ehcache provided search API to perform criteria queries on defined search attributes.
 * NOTE: Requires search attributes to be previously defined in Ehcache config!
 * DEPRECATED because at observed large cache quantities the search noticeably slows down the system
 * @param params the search parameters as key/value pairs
 * @return the first found cache hit
 */
@Deprecated
@SuppressWarnings("unchecked")
public VALUE lookup(Map<String, String> params) {
    Query q = cache.createQuery();

    for (Map.Entry<String, String> param : params.entrySet()) {
        Attribute<String> theAttribute = ((Ehcache) cache).getSearchAttribute(param.getKey());
        q.addCriteria(theAttribute.eq(param.getValue()));
    }

    q.includeKeys().includeValues();
    Results results = q.execute();

    if (results == null || results.size() == 0) {
        return null;
    }

    if (results.size() > 1) {
        log.warn("There are multiple entries registered for params: {}", params.toString());
    }

    return (VALUE) results.all().get(0).getValue();
}

项目：spring4-understanding 文件：EhCacheFactoryBean.java

/**
 * Predict the particular {@code Ehcache} implementation that will be returned from
 * {@link #getObject()} based on logic in {@link #createCache()} and
 * {@link #decorateCache(Ehcache)} as orchestrated by {@link #afterPropertiesSet()}.
 */
@Override
public Class<? extends Ehcache> getObjectType() {
    if (this.cache != null) {
        return this.cache.getClass();
    }
    if (this.cacheEntryFactory != null) {
        if (this.cacheEntryFactory instanceof UpdatingCacheEntryFactory) {
            return UpdatingSelfPopulatingCache.class;
        }
        else {
            return SelfPopulatingCache.class;
        }
    }
    if (this.blocking) {
        return BlockingCache.class;
    }
    return Cache.class;
}

项目：spring4-understanding 文件：EhCacheSupportTests.java

@Test
public void testEhCacheFactoryBeanWithBlockingCache() throws Exception {
    EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean();
    cacheManagerFb.afterPropertiesSet();
    try {
        CacheManager cm = cacheManagerFb.getObject();
        EhCacheFactoryBean cacheFb = new EhCacheFactoryBean();
        cacheFb.setCacheManager(cm);
        cacheFb.setCacheName("myCache1");
        cacheFb.setBlocking(true);
        assertEquals(cacheFb.getObjectType(), BlockingCache.class);
        cacheFb.afterPropertiesSet();
        Ehcache myCache1 = cm.getEhcache("myCache1");
        assertTrue(myCache1 instanceof BlockingCache);
    }
    finally {
        cacheManagerFb.destroy();
    }
}

项目：spring4-understanding 文件：EhCacheSupportTests.java

@Test
public void testEhCacheFactoryBeanWithSelfPopulatingCache() throws Exception {
    EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean();
    cacheManagerFb.afterPropertiesSet();
    try {
        CacheManager cm = cacheManagerFb.getObject();
        EhCacheFactoryBean cacheFb = new EhCacheFactoryBean();
        cacheFb.setCacheManager(cm);
        cacheFb.setCacheName("myCache1");
        cacheFb.setCacheEntryFactory(new CacheEntryFactory() {
            @Override
            public Object createEntry(Object key) throws Exception {
                return key;
            }
        });
        assertEquals(cacheFb.getObjectType(), SelfPopulatingCache.class);
        cacheFb.afterPropertiesSet();
        Ehcache myCache1 = cm.getEhcache("myCache1");
        assertTrue(myCache1 instanceof SelfPopulatingCache);
        assertEquals("myKey1", myCache1.get("myKey1").getValue());
    }
    finally {
        cacheManagerFb.destroy();
    }
}

项目：my-paper 文件：ArticleServiceImpl.java

public long viewHits(Long id) {
    Ehcache cache = cacheManager.getEhcache(Article.HITS_CACHE_NAME);
    Element element = cache.get(id);
    Long hits;
    if (element != null) {
        hits = (Long) element.getObjectValue();
    } else {
        Article article = articleDao.find(id);
        if (article == null) {
            return 0L;
        }
        hits = article.getHits();
    }
    hits++;
    cache.put(new Element(id, hits));
    long time = System.currentTimeMillis();
    if (time > viewHitsTime + Article.HITS_CACHE_INTERVAL) {
        viewHitsTime = time;
        updateHits();
        cache.removeAll();
    }
    return hits;
}

项目：my-paper 文件：ProductServiceImpl.java

public long viewHits(Long id) {
    Ehcache cache = cacheManager.getEhcache(Product.HITS_CACHE_NAME);
    Element element = cache.get(id);
    Long hits;
    if (element != null) {
        hits = (Long) element.getObjectValue();
    } else {
        Product product = productDao.find(id);
        if (product == null) {
            return 0L;
        }
        hits = product.getHits();
    }
    hits++;
    cache.put(new Element(id, hits));
    long time = System.currentTimeMillis();
    if (time > viewHitsTime + Product.HITS_CACHE_INTERVAL) {
        viewHitsTime = time;
        updateHits();
        cache.removeAll();
    }
    return hits;
}

项目：Camel 文件：CacheValidate.java

public boolean isValid(CacheManager cacheManager, String cacheName, String key) {
    LOG.trace("Cache Name: {}", cacheName);

    if (!cacheManager.cacheExists(cacheName)) {
        LOG.debug("No existing Cache found with name: {}"
                + ". Please ensure a cache is first instantiated using a Cache Consumer or Cache Producer."
                + " Replacement will not be performed since the cache {} does not presently exist", cacheName, cacheName);
        return false;
    }

    LOG.debug("Found an existing cache: {}", cacheName);

    if (LOG.isTraceEnabled()) {
        LOG.trace("Cache {} currently contains {} elements", cacheName, cacheManager.getCache(cacheName).getSize());
    }
    Ehcache cache = cacheManager.getCache(cacheName);

    if (!cache.isKeyInCache(key)) {
        LOG.debug("No Key with name: {} presently exists in the cache. It is also possible that the key may have expired in the cache."
                + " Replacement will not be performed until an appropriate key/value pair is added to (or) found in the cache.", key);
        return false;
    }

    return true;
}

项目：Camel 文件：CacheEventListener.java

private void dispatchExchange(Ehcache cache, Element element, String operation) {
    Exchange exchange;
    LOG.debug("Consumer Dispatching the Exchange containing the Element {} in cache {}", element, cache.getName());

    if (element == null) {
        exchange = cacheConsumer.getEndpoint().createCacheExchange(operation, "", "");
    } else {
        exchange = cacheConsumer.getEndpoint().createCacheExchange(operation, (String) element.getObjectKey(), element.getObjectValue());
    }
    try {
        cacheConsumer.getProcessor().process(exchange);
    } catch (Exception e) {
        throw new CacheException("Error in consumer while dispatching exchange containing key "
            + (element != null ? element.getObjectKey() : null) + " for further processing", e);
    }
}

项目：kettle_support_kettle8.0 文件：SpringCacheManager.java

@Override
public int size() {
    if (springCache.getNativeCache() instanceof Ehcache) {
        Ehcache ehcache = (Ehcache) springCache.getNativeCache();
        return ehcache.getSize();
    }
    throw new UnsupportedOperationException(
            "invoke spring cache abstract size method not supported");
}

项目：kettle_support_kettle8.0 文件：SpringCacheManager.java

@Override
public Set keys() {
    if (springCache.getNativeCache() instanceof Ehcache) {
        Ehcache ehcache = (Ehcache) springCache.getNativeCache();
        return new HashSet(ehcache.getKeys());
    }
    throw new UnsupportedOperationException(
            "invoke spring cache abstract keys method not supported");
}

项目：kettle_support_kettle8.0 文件：SpringCacheManager.java

@Override
public int size() {
    if (springCache.getNativeCache() instanceof Ehcache) {
        Ehcache ehcache = (Ehcache) springCache.getNativeCache();
        return ehcache.getSize();
    }
    throw new UnsupportedOperationException(
            "invoke spring cache abstract size method not supported");
}

项目：kettle_support_kettle8.0 文件：SpringCacheManager.java

@Override
public Set keys() {
    if (springCache.getNativeCache() instanceof Ehcache) {
        Ehcache ehcache = (Ehcache) springCache.getNativeCache();
        return new HashSet(ehcache.getKeys());
    }
    throw new UnsupportedOperationException(
            "invoke spring cache abstract keys method not supported");
}

项目：smart-cache 文件：CacheTemplate.java

/**
 * 创建本地缓存
 */
private Ehcache getEhcache(final String name) {
    Future<Ehcache> future = this.ehcaches.get(name);
    if (future == null) {
        Callable<Ehcache> callable = new Callable<Ehcache>() {
            @Override
            public Ehcache call() throws Exception {
                Ehcache cache = cacheManager.getEhcache(name);
                if (cache == null) {
                    cacheManager.addCache(name);
                    cache = cacheManager.getEhcache(name);
                }
                return cache;
            }
        };
        FutureTask<Ehcache> task = new FutureTask<>(callable);
        future = this.ehcaches.putIfAbsent(name, task);
        if (future == null) {
            future = task;
            task.run();
        }
    }
    try {
        return future.get();
    } catch (Exception e) {
        this.ehcaches.remove(name);
        throw new CacheException(e);
    }
}

项目：zkAdmin 文件：SpringCacheManagerWrapper.java

@Override
public int size() {
    if(springCache.getNativeCache() instanceof Ehcache) {
        Ehcache ehcache = (Ehcache) springCache.getNativeCache();
        return ehcache.getSize();
    }
    throw new UnsupportedOperationException("invoke spring cache abstract size method not supported");
}

项目：zkAdmin 文件：SpringCacheManagerWrapper.java

@Override
public Set keys() {
    if(springCache.getNativeCache() instanceof Ehcache) {
        Ehcache ehcache = (Ehcache) springCache.getNativeCache();
        return new HashSet(ehcache.getKeys());
    }
    throw new UnsupportedOperationException("invoke spring cache abstract keys method not supported");
}

项目：kaltura-ce-sakai-extension 文件：KalturaTestWebservices.java

protected void onSetUpInTransaction() {

        // make a cache
        CacheManager cacheManager = CacheManager.create();
        if (! cacheManager.cacheExists("ehcache.sakai.kaltura.entries")) {
            cacheManager.addCache("ehcache.sakai.kaltura.entries");
        }
        Ehcache entriesCache = cacheManager.getCache("ehcache.sakai.kaltura.entries");

        // create and setup the object to be tested
        external = new ExternalLogicStub();
        service = new KalturaAPIService();
        service.setExternal(external);
        service.setEntriesCache(entriesCache);
        service.setOffline(true); // for testing we do not try to fetch real data

        // run the init
        external.currentUserId = FakeDataPreload.ADMIN_USER_ID; // DEFAULT ADMIN
        // UNICON settings for testing
        external.config.put("kaltura.partnerid", 166762);
        external.config.put("kaltura.adminsecret", "26d08a0ba54c911492bbc7599028295f");
        external.config.put("kaltura.secret", "6e4755b613a38b19e4cfb5d7405ed170");

        service.testWSInit(); // SPECIAL INIT

        service.getKalturaClient();
    }

项目：kaltura-ce-sakai-extension 文件：KalturaAPIServiceStub.java

public KalturaAPIServiceStub(ExternalLogicStub external, Ehcache entriesCache, Ehcache categoriesCache) {
    this.external = external;
    setExternal(external);
    setEntriesCache(entriesCache);
    setCategoriesCache(categoriesCache);
    init();
}

项目：kaltura-ce-sakai-extension 文件：MediaServiceTest.java

@Override
protected void setUp() throws Exception {
    // THIS IS EXECUTED BEFORE EACH TEST

    // make the caches
    CacheManager cacheManager = CacheManager.create();
    if (! cacheManager.cacheExists("ehcache.sakai.kaltura.entries")) {
        cacheManager.addCache("ehcache.sakai.kaltura.entries");
    }
    Ehcache entriesCache = cacheManager.getCache("ehcache.sakai.kaltura.entries");

    if (! cacheManager.cacheExists("ehcache.sakai.kaltura.cats")) {
        cacheManager.addCache("ehcache.sakai.kaltura.cats");
    }
    Ehcache categoriesCache = cacheManager.getCache("ehcache.sakai.kaltura.cats");

    // create and setup the object to be tested
    external = new ExternalLogicStub();

    kalturaAPIService = new KalturaAPIServiceStub(external, entriesCache, categoriesCache);
    kalturaAPIService.setKalturaClippingEnabled(true); // for testing

    service = new MediaService();
    service.setExternal(external);
    service.setKalturaAPIService(kalturaAPIService);
    service.setEntriesCache(entriesCache);
    service.setForceMediaNameOrdering(false);

    // run the init
    service.init();
}

项目：lams 文件：EhCacheFactoryBean.java

/**
 * Decorate the given Cache, if necessary.
 * @param cache the raw Cache object, based on the configuration of this FactoryBean
 * @return the (potentially decorated) cache object to be registered with the CacheManager
 */
protected Ehcache decorateCache(Ehcache cache) {
    if (this.cacheEntryFactory != null) {
        if (this.cacheEntryFactory instanceof UpdatingCacheEntryFactory) {
            return new UpdatingSelfPopulatingCache(cache, (UpdatingCacheEntryFactory) this.cacheEntryFactory);
        }
        else {
            return new SelfPopulatingCache(cache, this.cacheEntryFactory);
        }
    }
    if (this.blocking) {
        return new BlockingCache(cache);
    }
    return cache;
}

项目：lams 文件：EhCacheCacheManager.java

@Override
public Cache getCache(String name) {
    Cache cache = super.getCache(name);
    if (cache == null) {
        // Check the EhCache cache again (in case the cache was added at runtime)
        Ehcache ehcache = getCacheManager().getEhcache(name);
        if (ehcache != null) {
            addCache(new EhCacheCache(ehcache));
            cache = super.getCache(name);  // potentially decorated
        }
    }
    return cache;
}

项目：lams 文件：EhCacheCache.java

/**
 * Create an {@link EhCacheCache} instance.
 * @param ehcache backing Ehcache instance
 */
public EhCacheCache(Ehcache ehcache) {
    Assert.notNull(ehcache, "Ehcache must not be null");
    Status status = ehcache.getStatus();
    Assert.isTrue(Status.STATUS_ALIVE.equals(status),
            "An 'alive' Ehcache is required - current cache is " + status.toString());
    this.cache = ehcache;
}

项目：webside 文件：EhcacheShiroCache.java

public int size() {
    if(cache.getNativeCache() instanceof Ehcache) {
        Ehcache ehcache = (Ehcache) cache.getNativeCache();
        return ehcache.getSize();
    }
    throw new UnsupportedOperationException("invoke spring cache abstract size method not supported");
}

项目：webside 文件：EhcacheShiroCache.java

@SuppressWarnings("unchecked")
public Set<K> keys() {
       if(cache.getNativeCache() instanceof Ehcache) {
           Ehcache ehcache = (Ehcache) cache.getNativeCache();
           return new HashSet<K>(ehcache.getKeys());
       }
       throw new UnsupportedOperationException("invoke spring cache abstract keys method not supported");
   }