Java CacheEntryEvent类代码示例

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
@Override
public boolean evaluate(CacheEntryEvent<? extends String, ? extends Integer> event)
    throws CacheEntryListenerException
{
    switch (event.getEventType())
    {
        case EXPIRED:
            return true;

        case REMOVED:
            return true;

        case UPDATED:
            return true;
    }

    return false;
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
@Override
protected JndiRegistry createRegistry() throws Exception {
    JndiRegistry registry = super.createRegistry();
    registry.bind("myFilter", new CacheEntryEventFilter<Object, Object>() {
        @Override
        public boolean evaluate(CacheEntryEvent<?, ?> event) throws CacheEntryListenerException {
            if (event.getEventType() == EventType.REMOVED) {
                return false;
            }

            return !event.getValue().toString().startsWith("to-filter-");
        }
    });

    return registry;
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
@Override
public void onCreated(Iterable<CacheEntryEvent<? extends K, ? extends V>> cacheEntryEvents) throws CacheEntryListenerException {
    cacheEntryEvents.forEach(cacheEntryEvent -> {
                if (cacheEntryEvent.getValue().getClass().isAnnotationPresent(NeverCached.class)) {
                    log.error("Cached a @NeverCached annotated model: '{}'", cacheEntryEvent.getValue().getClass());
                    try {
                        String webAppRoot = new ClassPathResource(".").getFile().getAbsolutePath();
                        PrintWriter writer = new PrintWriter(webAppRoot + "../../../NeverCachedException.jsp", "UTF-8");
                        writer.println("This file is generated because a @NeverCached annotated model was found in cache. Check site logs for more information.");
                        writer.close();
                    } catch (IOException e) {
                        throw new RuntimeException("Unable to create a NeverCachedException.jsp file.");
                    }
                    throw new CacheEntryListenerException("Cached a @NeverCached annotated model!");
                } else {
                    log.debug("Cached view model is: '{}'", cacheEntryEvent.getValue().getClass());
                }
            }
    );
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
/**
 * @param cache Ignite cache.
 * @throws Exception If fail.
 */
private void executeContiniouseQuery(IgniteCache cache) throws Exception {
    ContinuousQuery<Integer, String> qry = new ContinuousQuery<>();

    qry.setLocalListener(
        new CacheEntryUpdatedListener<Integer, String>() {
            @Override public void onUpdated(Iterable<CacheEntryEvent<? extends Integer, ? extends String>> events)
                throws CacheEntryListenerException {
                for (CacheEntryEvent<? extends Integer, ? extends String> event : events)
                    System.out.println("Key = " + event.getKey() + ", Value = " + event.getValue());
            }
        }
    );

    final Class<CacheEntryEventSerializableFilter> remoteFilterClass = (Class<CacheEntryEventSerializableFilter>)
        ldr.loadClass("org.apache.ignite.tests.p2p.CacheDeploymentCacheEntryEventSerializableFilter");

    qry.setRemoteFilterFactory(new ClassFilterFactory(remoteFilterClass));

    cache.query(qry);

    for (int i = 0; i < 100; i++)
        cache.put(i, "Message " + i);
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
@Override
public void onExpired(Iterable<CacheEntryEvent<? extends Integer, ? extends String>> events)
		throws CacheEntryListenerException
{
	String msg = name + ":EXPIRED!";
	int eventCount = countEvents(events, msg);
	expiredListenerFiredCount.addAndGet(eventCount);
	if (printAllEvents)
	{
		Iterator<CacheEntryEvent<? extends Integer, ? extends String>> iterator = events.iterator();
		while (iterator.hasNext() )
		{
			
			CacheEntryEvent<? extends Integer,? extends String> event = iterator.next();
			System.out.println(msg + " Event: " + event.getValue());
			
		}
		
	}
		
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public boolean evaluate(CacheEntryEvent<? extends QueryTestKey, ? extends QueryTestValue> e)
    throws CacheEntryListenerException {
    if (e.getKey().compareTo(new QueryTestKey(KEYS)) < 0) {
        IgniteCache<QueryTestKey, QueryTestValue> cache = ignite.cache(cacheName);

        if (ThreadLocalRandom.current().nextBoolean()) {
            Set<QueryTestKey> keys = new LinkedHashSet<>();

            for (int key = KEYS; key < KEYS + KEYS_FROM_CALLBACK; key++)
                keys.add(new QueryTestKey(key));

            cache.invokeAll(keys, new IncrementTestEntryProcessor());
        }
        else {
            for (int key = KEYS; key < KEYS + KEYS_FROM_CALLBACK; key++)
                cache.invoke(new QueryTestKey(key), new IncrementTestEntryProcessor());
        }

        filterCbCntr.incrementAndGet();
    }

    return true;
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
/**
 * Evaluate the filter.
 *
 * @param ctx Context.
 * @param filterPtr Native filter pointer.
 * @param evt Event.
 * @return Result.
 * @throws CacheEntryListenerException In case of failure.
 */
public static boolean evaluateContinuousQueryEvent(PlatformContext ctx, long filterPtr, CacheEntryEvent evt)
    throws CacheEntryListenerException {
    assert filterPtr != 0;

    try (PlatformMemory mem = ctx.memory().allocate()) {
        PlatformOutputStream out = mem.output();

        out.writeLong(filterPtr);

        writeCacheEntryEvent(ctx.writer(out), evt);

        out.synchronize();

        return ctx.gateway().continuousQueryFilterApply(mem.pointer()) == 1;
    }
    catch (Exception e) {
        throw toCacheEntryListenerException(e);
    }
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override public boolean evaluate(CacheEntryEvent evt) throws CacheEntryListenerException {
    if (javaFilter != null)
        return javaFilter.evaluate(evt);

    lock.readLock().lock();

    try {
        if (ptr == 0)
            throw new CacheEntryListenerException("Failed to evaluate the filter because it has been closed.");

        return !hasFilter || PlatformUtils.evaluateContinuousQueryEvent(platformCtx, ptr, evt);
    }
    finally {
        lock.readLock().unlock();
    }
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
/** {@inheritDoc} */
@Override public void onUpdated(final Iterable<CacheEntryEvent<?, ?>> deps) {
    GridSpinBusyLock busyLock = GridServiceProcessor.this.busyLock;

    if (busyLock == null || !busyLock.enterBusy())
        return;

    try {
        depExe.execute(new DepRunnable() {
            @Override public void run0() {
                onSystemCacheUpdated(deps);
            }
        });
    }
    finally {
        busyLock.leaveBusy();
    }
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
/**
 * @param cache Cache.
 * @return Event counter.
 */
private T2<AtomicInteger, QueryCursor> startListener(IgniteCache<Object, Object> cache) {
    final AtomicInteger evtCnt = new AtomicInteger();

    ContinuousQuery<Object, Object> qry = new ContinuousQuery<>();

    qry.setLocalListener(new CacheEntryUpdatedListener<Object, Object>() {
        @Override public void onUpdated(Iterable<CacheEntryEvent<?, ?>> evts) {
            for (CacheEntryEvent evt : evts) {
                assertNotNull(evt.getKey());
                assertNotNull(evt.getValue());

                if ((Integer)evt.getValue() >= 0)
                    evtCnt.incrementAndGet();
            }
        }
    });

    QueryCursor cur = cache.query(qry);

    return new T2<>(evtCnt, cur);
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
@Override
public void onExpired(Iterable<CacheEntryEvent<? extends String, ? extends String>> events)
        throws CacheEntryListenerException {
    CacheEntryEvent<? extends String, ? extends String> entry = events.iterator().next();
    
    assertThat(entry.getKey()).isEqualTo(key);
    assertThat(entry.getValue()).isEqualTo(value);
    latch.countDown();
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
/**
 *
 * @param event The entry just added.
 * @throws CacheEntryListenerException
 */
@Override
public void entryCreated(CacheEntryEvent<? extends IdentityCacheKey, ? extends PolicyStatus> event) throws CacheEntryListenerException {
    if(log.isDebugEnabled()){
        log.debug("ConfigCacheCreatedListener triggered for tenant: " + event.getKey().getTenantId() + " and " +
                "key : " + event.getKey()
                .getKey());
    }
    PolicyCache.updateLocalPolicyCacheMap(event.getKey(),event.getValue());
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
/**
 *
 * @param event The event just updated.
 * @throws CacheEntryListenerException
 */
@Override
public void entryUpdated(CacheEntryEvent<? extends IdentityCacheKey, ? extends PolicyStatus> event) throws CacheEntryListenerException {
    if(event!=null) {
        PolicyCache.updateLocalPolicyCacheMap(event.getKey(), event.getValue());
    }
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
@Override
public boolean evaluate(CacheEntryEvent<?, ?> event) throws CacheEntryListenerException {
    if (filteredEvents == null) {
        return true;
    }

    return !filteredEvents.contains(event.getEventType());
}
 

import javax.cache.event.CacheEntryEvent; //导入依赖的package包/类
private CacheEntryListenerConfiguration<Object, Object> createEntryListenerConfiguration() {
    return new MutableCacheEntryListenerConfiguration<>(
        new Factory<CacheEntryListener<Object, Object>>() {
            @Override
            public CacheEntryListener<Object, Object> create() {
                return new JCacheEntryEventListener() {
                    @Override
                    protected void onEvents(Iterable<CacheEntryEvent<?, ?>> events) {
                        for (CacheEntryEvent<?, ?> event : events) {
                            Exchange exchange = getEndpoint().createExchange();
                            Message message = exchange.getIn();
                            message.setHeader(JCacheConstants.EVENT_TYPE, event.getEventType().name());
                            message.setHeader(JCacheConstants.KEY, event.getKey());
                            message.setBody(event.getValue());

                            if (event.isOldValueAvailable()) {
                                message.setHeader(JCacheConstants.OLD_VALUE, event.getOldValue());
                            }

                            try {
                                getProcessor().process(exchange);
                            } catch (Exception e) {
                                LOGGER.error("Error processing event ", e);
                            }
                        }
                    }
                };
            }
        },
        new Factory<CacheEntryEventFilter<Object, Object>>() {
            @Override
            public CacheEntryEventFilter<Object, Object> create() {
                return getJCacheEndpoint().getManager().getEventFilter();
            }
        },
        getJCacheEndpoint().getManager().getConfiguration().isOldValueRequired(),
        getJCacheEndpoint().getManager().getConfiguration().isSynchronous()
    );
}