Java MutableCacheEntryListenerConfiguration类代码示例

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
/**
 * @param cache Cache.
 * @param lsnrFactory Listener factory.
 * @param key Key.
 * @param create {@code True} if listens for create events.
 * @param update {@code True} if listens for update events.
 * @param rmv {@code True} if listens for remove events.
 * @param expire {@code True} if listens for expire events.
 * @throws Exception If failed.
 */
private void checkEvents(
    final IgniteCache<Object, Object> cache,
    final Factory<CacheEntryListener<Object, Object>> lsnrFactory,
    Integer key,
    boolean create,
    boolean update,
    boolean rmv,
    boolean expire) throws Exception {
    CacheEntryListenerConfiguration<Object, Object> lsnrCfg = new MutableCacheEntryListenerConfiguration<>(
        lsnrFactory,
        null,
        true,
        false
    );

    cache.registerCacheEntryListener(lsnrCfg);

    try {
        checkEvents(cache, lsnrCfg, key, create, update, rmv, expire, true);
    }
    finally {
        cache.deregisterCacheEntryListener(lsnrCfg);
    }
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
@Test
public void testTemplateAddsListeners() throws Exception {
  CacheManager cacheManager = cachingProvider.getCacheManager(getClass().getResource("/ehcache-107-listeners.xml")
      .toURI(), getClass().getClassLoader());

  MutableConfiguration<String, String> configuration = new MutableConfiguration<>();
  configuration.setTypes(String.class, String.class);
  MutableCacheEntryListenerConfiguration<String, String> listenerConfiguration = new MutableCacheEntryListenerConfiguration<>(Test107CacheEntryListener::new, null, false, true);
  configuration.addCacheEntryListenerConfiguration(listenerConfiguration);

  Cache<String, String> cache = cacheManager.createCache("foos", configuration);
  cache.put("Hello", "Bonjour");

  assertThat(Test107CacheEntryListener.seen.size(), Matchers.is(1));
  assertThat(TestCacheEventListener.seen.size(), Matchers.is(1));
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
@Produces
@CustomCache
public Cache<Integer, Person> produces() {
	CacheManager manager = Caching.getCachingProvider().getCacheManager();
	
	Cache<Integer, Person> cache = manager.getCache(CACHE_NAME, Integer.class, Person.class);
	if(cache == null) {
		MutableConfiguration<Integer, Person> configuration = new MutableConfiguration<>();
		configuration.setTypes(Integer.class, Person.class);
		configuration.setStatisticsEnabled(true);
			
		cache = manager.createCache(CACHE_NAME, configuration);
		
		CacheEntryListenerConfiguration<Integer, Person> listenersConfiguration
			= new MutableCacheEntryListenerConfiguration<>(FactoryBuilder.factoryOf(CacheModificationListener.class), null, false, true);
		cache.registerCacheEntryListener(listenersConfiguration);
	}
	
	return cache;
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
@Produces
@LimitedCache
public Cache<Integer, Person> produce() {
	CacheManager manager = Caching.getCachingProvider().getCacheManager();

	Cache<Integer, Person> cache = manager.getCache(CACHE_NAME, Integer.class, Person.class);
	if(cache == null) {
		MutableConfiguration<Integer, Person> configuration = new MutableConfiguration<>();
		configuration.setTypes(Integer.class, Person.class);
		configuration.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ONE_MINUTE));

		cache = manager.createCache(CACHE_NAME, configuration);

		CacheEntryListenerConfiguration<Integer, Person> listenersConfiguration = new MutableCacheEntryListenerConfiguration<>(
				FactoryBuilder.factoryOf(CacheModificationListener.class), null, false, true);
		cache.registerCacheEntryListener(listenersConfiguration);
	}

	return cache;
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
@Setup
public void setup() {
    results = targetInstance.getList(name);
    listeners = targetInstance.getList(name + "listeners");

    cache = CacheUtils.getCache(targetInstance, name);
    listener = new ICacheEntryListener<Integer, Long>();
    filter = new ICacheEntryEventFilter<Integer, Long>();

    threadsRemaining.set(threadCount);

    CacheEntryListenerConfiguration<Integer, Long> config = new MutableCacheEntryListenerConfiguration<Integer, Long>(
            FactoryBuilder.factoryOf(listener),
            FactoryBuilder.factoryOf(filter),
            false, syncEvents);
    cache.registerCacheEntryListener(config);
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
@Override
protected MutableConfiguration<Integer, String> extraSetup(MutableConfiguration<Integer, String> cfg) {
  // cfg.setExpiryPolicyFactory(ModifiedExpiryPolicy.factoryOf(new Duration(TimeUnit.MILLISECONDS, 5)));
  cacheEntryListenerServer = new CacheEntryListenerServer<>(10011, Integer.class, String.class);
  try {
    cacheEntryListenerServer.open();
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
  listener = new RecordingListener<>();
  cacheEntryListenerServer.addCacheEventListener(listener);
  CacheEntryListenerClient<Integer, String> clientListener =
    new CacheEntryListenerClient<>(cacheEntryListenerServer.getInetAddress(), cacheEntryListenerServer.getPort());
  boolean _isSynchronous = false;
  listenerConfiguration = new MutableCacheEntryListenerConfiguration<>(
    FactoryBuilder.factoryOf(clientListener), null, true, _isSynchronous);
  return cfg.addCacheEntryListenerConfiguration(listenerConfiguration);
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
@Override
protected MutableConfiguration<Long, String> extraSetup(MutableConfiguration<Long, String> configuration) {
  cacheEntryListenerServer = new CacheEntryListenerServer<Long, String>(10011, Long.class, String.class);
  try {
    cacheEntryListenerServer.open();
  } catch (IOException e) {
    e.printStackTrace();
  }

  //establish and open a CacheEntryListenerServer to handle cache
  //cache entry events from a CacheEntryListenerClient
  listener = new MyCacheEntryListener<Long, String>();
  cacheEntryListenerServer.addCacheEventListener(listener);

  //establish a CacheEntryListenerClient that a Cache can use for CacheEntryListening
  //(via the CacheEntryListenerServer)
  CacheEntryListenerClient<Long, String> clientListener =
    new CacheEntryListenerClient<>(cacheEntryListenerServer.getInetAddress(), cacheEntryListenerServer.getPort());
  listenerConfiguration = new MutableCacheEntryListenerConfiguration<Long, String>(FactoryBuilder.factoryOf(clientListener), null, true, true);
  return configuration.addCacheEntryListenerConfiguration(listenerConfiguration);
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
@Test
public void  testDeregistration() {

  assertEquals(1, getConfigurationCacheEntryListenerConfigurationSize(cache));

  MyCacheEntryListener secondListener = new MyCacheEntryListener<Long, String>();
  MutableCacheEntryListenerConfiguration<Long,
      String> secondListenerConfiguration = new
      MutableCacheEntryListenerConfiguration(FactoryBuilder.factoryOf(secondListener), null, false, true);
  cache.registerCacheEntryListener(secondListenerConfiguration);

  assertEquals(2, getConfigurationCacheEntryListenerConfigurationSize(cache));
  cache.deregisterCacheEntryListener(secondListenerConfiguration);

  assertEquals(1, getConfigurationCacheEntryListenerConfigurationSize(cache));

  //no effect if called after it has been removed
  cache.deregisterCacheEntryListener(secondListenerConfiguration);
  assertEquals(1, getConfigurationCacheEntryListenerConfigurationSize(cache));

  //Deregister the listener registered at configuration time
  cache.deregisterCacheEntryListener(listenerConfiguration);
  assertEquals(0, getConfigurationCacheEntryListenerConfigurationSize(cache));
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
@Test
public void testExpiration() throws InterruptedException, IllegalArgumentException, URISyntaxException, FailedToStartRedisException, IOException {
    RedisProcess runner = new RedisRunner()
            .nosave()
            .randomDir()
            .port(6311)
            .run();

    MutableConfiguration<String, String> config = new MutableConfiguration<>();
    config.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 1)));
    config.setStoreByValue(true);
    
    URI configUri = getClass().getResource("redisson-jcache.json").toURI();
    Cache<String, String> cache = Caching.getCachingProvider().getCacheManager(configUri, null)
            .createCache("test", config);

    CountDownLatch latch = new CountDownLatch(1);
    
    String key = "123";
    ExpiredListener clientListener = new ExpiredListener(latch, key, "90");
    MutableCacheEntryListenerConfiguration<String, String> listenerConfiguration = 
            new MutableCacheEntryListenerConfiguration<String, String>(FactoryBuilder.factoryOf(clientListener), null, true, true);
    cache.registerCacheEntryListener(listenerConfiguration);

    cache.put(key, "90");
    Assert.assertNotNull(cache.get(key));
    
    latch.await();
    
    Assert.assertNull(cache.get(key));
    
    cache.close();
    runner.stop();
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的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()
    );
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
public static void registerListeners() throws ClassNotFoundException {
    if (isDone) {
        return;
    }

    ApplicationContext context = ApplicationContextHolder.getContext();
    NamedCacheProvider cacheProvider = context.getBean(NamedCacheProvider.class);
    if (cacheProvider.isCacheEnabled()) {

        // first let's ensure that we process at least well-known DXA caches
        ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
        scanner.addIncludeFilter(new AssignableTypeFilter(SimpleCacheWrapper.class));
        for (BeanDefinition beanDefinition : scanner.findCandidateComponents("com.sdl")) {
            Class<?> aClass = forName(beanDefinition.getBeanClassName(), getDefaultClassLoader());
            SimpleCacheWrapper cacheWrapper = (SimpleCacheWrapper) context.getBean(aClass);
            cacheWrapper.getCache();
        }

        // now let's add out listeners
        MutableCacheEntryListenerConfiguration<Object, Object> listenerConfiguration =
                new MutableCacheEntryListenerConfiguration<>(
                        FactoryBuilder.factoryOf(new NeverCacheListener<>()),
                        FactoryBuilder.factoryOf(new OnlyCreatedFilter<>()),
                        false, true);
        //noinspection unchecked
        cacheProvider.getOwnCaches().forEach(cache -> cache.registerCacheEntryListener(listenerConfiguration));
        isDone = true;
    }
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
public final void Register() throws Exception {

        _listenerConfig = new MutableCacheEntryListenerConfiguration(
                FactoryBuilder.factoryOf(this),
                FactoryBuilder.factoryOf(new EventFilter(_eventType)),
                _isOldValueRequired,
                _isSynchronous
        );

        _cache.registerCacheEntryListener(_listenerConfig);
    }
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
/**
 * @param cache Cache.
 * @return Event listener.
 */
private AllEventListener<Integer, String> registerCacheListener(IgniteCache<Integer, String> cache) {
    AllEventListener<Integer, String> lsnr = new AllEventListener<>();

    cache.registerCacheEntryListener(
        new MutableCacheEntryListenerConfiguration<>(factoryOf(lsnr), null, true, false));

    return lsnr;
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
/**
 * @param key Key.
 * @param res Result.
 * @param id Listener ID.
 * @return Listener
 */
private CacheEntryListenerConfiguration<Integer, String> createCacheListener(
    Integer key,
    IgniteFuture<String> res,
    int id) {
    return new MutableCacheEntryListenerConfiguration<>(
        factoryOf(new CacheListener(res, id)),
        new SingletonFactory<>(new KeyEventFilter(key, id)), false, true);
}
 

import javax.cache.configuration.MutableCacheEntryListenerConfiguration; //导入依赖的package包/类
/**
 * @param ccfg Cache configuration.
 * @throws Exception If failed.
 */
private void checkExpiredEvents(CacheConfiguration<Object, Object> ccfg) throws Exception {
    IgniteCache<Object, Object> cache = ignite(0).createCache(ccfg);

    try {
        evtCntr = new AtomicInteger();

        CacheEntryListenerConfiguration<Object, Object> lsnrCfg = new MutableCacheEntryListenerConfiguration<>(
            new ExpiredListenerFactory(),
            null,
            true,
            false
        );

        cache.registerCacheEntryListener(lsnrCfg);

        IgniteCache<Object, Object> expiryCache =
            cache.withExpiryPolicy(new ModifiedExpiryPolicy(new Duration(MILLISECONDS, 500)));

        expiryCache.put(1, 1);

        for (int i = 0; i < 10; i++)
            cache.get(i);

        boolean wait = GridTestUtils.waitForCondition(new GridAbsPredicate() {
            @Override public boolean apply() {
                return evtCntr.get() > 0;
            }
        }, 5000);

        assertTrue(wait);

        U.sleep(100);

        assertEquals(1, evtCntr.get());
    }
    finally {
        ignite(0).destroyCache(cache.getName());
    }
}