javax.cache.integration.CacheWriter Java Examples

@Override
public void deleteAll(final Collection<?> keys) throws CacheWriterException
{
    CacheWriterException e = null;
    for (final CacheWriter<K, V> writer : writers)
    {
        try
        {
            writer.deleteAll(keys);
        }
        catch (final CacheWriterException ex)
        {
            if (e == null)
            {
                e = ex;
            }
        }
    }
    if (e != null)
    {
        throw e;
    }
}
 

@Override
public void delete(final Object key) throws CacheWriterException
{
    CacheWriterException e = null;
    for (final CacheWriter<K, V> writer : writers)
    {
        try
        {
            writer.delete(key);
        }
        catch (final CacheWriterException ex)
        {
            if (e == null)
            {
                e = ex;
            }
        }
    }
    if (e != null)
    {
        throw e;
    }
}
 

@Override
public void writeAll(final Collection<Cache.Entry<? extends K, ? extends V>> entries) throws CacheWriterException
{
    CacheWriterException e = null;
    for (final CacheWriter<K, V> writer : writers)
    {
        try
        {
            writer.writeAll(entries);
        }
        catch (final CacheWriterException ex)
        {
            if (e == null)
            {
                e = ex;
            }
        }
    }
    if (e != null)
    {
        throw e;
    }
}
 

@Override
public void write(final Cache.Entry<? extends K, ? extends V> entry) throws CacheWriterException
{
    CacheWriterException e = null;
    for (final CacheWriter<K, V> writer : writers)
    {
        try
        {
            writer.write(entry);
        }
        catch (final CacheWriterException ex)
        {
            if (e == null)
            {
                e = ex;
            }
        }
    }
    if (e != null)
    {
        throw e;
    }
}
 

private <K, V> Jsr107CacheLoaderWriter<K, V> initCacheLoaderWriter(CompleteConfiguration<K, V> config) {
  Factory<CacheLoader<K, V>> cacheLoaderFactory = config.getCacheLoaderFactory();
  @SuppressWarnings("unchecked")
  Factory<CacheWriter<K, V>> cacheWriterFactory = (Factory<CacheWriter<K, V>>) (Object) config.getCacheWriterFactory();

  if (config.isReadThrough() && cacheLoaderFactory == null) {
    throw new IllegalArgumentException("read-through enabled without a CacheLoader factory provided");
  }
  if (config.isWriteThrough() && cacheWriterFactory == null) {
    throw new IllegalArgumentException("write-through enabled without a CacheWriter factory provided");
  }

  CacheLoader<K, V> cacheLoader = cacheLoaderFactory == null ? null : cacheLoaderFactory.create();
  CacheWriter<K, V> cacheWriter;
  try {
    cacheWriter = cacheWriterFactory == null ? null : cacheWriterFactory.create();
  } catch (Throwable t) {
    throw closeAllAfter(new CacheException(t), cacheLoader);
  }

  if (cacheLoader == null && cacheWriter == null) {
    return null;
  } else {
    return new Eh107CacheLoaderWriter<>(cacheLoader, config.isReadThrough(), cacheWriter, config.isWriteThrough());
  }
}
 

private <T> MutableConfiguration<String, T> configure(final MutableConfiguration<String, T> configuration, final OAuth2Options opts) {
    ofNullable(opts.getJcacheLoader())
            .map(n -> lookup(CacheLoader.class, n))
            .ifPresent(l -> configuration.setCacheLoaderFactory(new FactoryBuilder.SingletonFactory<CacheLoader<String, T>>(l)));
    ofNullable(opts.getJcacheWriter())
            .map(n -> lookup(CacheWriter.class, n))
            .ifPresent(w -> configuration.setCacheWriterFactory(new FactoryBuilder.SingletonFactory<CacheWriter<String, T>>(w)));
    return configuration
            .setStoreByValue(opts.isJcacheStoreValue())
            .setStatisticsEnabled(opts.isJcacheStatistics())
            .setManagementEnabled(opts.isJcacheJmx());
}
 

/**
 * Constructs an CacheWriterServer.
 *
 * @param port        the port on which to accept {@link CacheWriterClient} requests
 * @param cacheWriter (optional) the {@link CacheWriter} that will be used to handle
 *                    client requests
 */
public CacheWriterServer(int port, CacheWriter<K, V> cacheWriter) {
    super(port);

    // establish the client-server operation handlers
    addOperationHandler(new WriteOperationHandler());
    addOperationHandler(new WriteAllOperationHandler());
    addOperationHandler(new DeleteOperationHandler());
    addOperationHandler(new DeleteAllOperationHandler());

    this.cacheWriter = cacheWriter;
}
 

Cache<Object, Object> getOrCreateCache(final String prefix, final String entity)
{
    final String internalName = prefix + entity;
    Cache<Object, Object> cache = cacheManager.getCache(internalName);
    if (cache == null)
    {
        final Properties properties = cacheManager.getProperties();
        final MutableConfiguration<Object, Object> configuration = new MutableConfiguration<Object, Object>()
                .setStoreByValue("true".equalsIgnoreCase(properties.getProperty("jcache.store-by-value", "false")));

        configuration.setReadThrough("true".equals(properties.getProperty("jcache.read-through", "false")));
        configuration.setWriteThrough("true".equals(properties.getProperty("jcache.write-through", "false")));
        if (configuration.isReadThrough())
        {
            configuration.setCacheLoaderFactory(new FactoryBuilder.ClassFactory<CacheLoader<Object, Object>>(properties.getProperty("jcache.cache-loader-factory")));
        }
        if (configuration.isWriteThrough())
        {
            configuration.setCacheWriterFactory(new FactoryBuilder.ClassFactory<CacheWriter<Object, Object>>(properties.getProperty("jcache.cache-writer-factory")));
        }
        final String expirtyPolicy = properties.getProperty("jcache.expiry-policy-factory");
        if (expirtyPolicy != null)
        {
            configuration.setExpiryPolicyFactory(new FactoryBuilder.ClassFactory<ExpiryPolicy>(expirtyPolicy));
        }
        else
        {
            configuration.setExpiryPolicyFactory(new FactoryBuilder.SingletonFactory<ExpiryPolicy>(new CreatedExpiryPolicy(Duration.FIVE_MINUTES)));
        }
        configuration.setManagementEnabled("true".equals(properties.getProperty("jcache.management-enabled", "false")));
        configuration.setStatisticsEnabled("true".equals(properties.getProperty("jcache.statistics-enabled", "false")));

        cache = cacheManager.createCache(internalName, configuration);
    }
    return cache;
}
 

/** @return a writer created by the configured factory or null if not set. */
public @Nullable CacheWriter<K , V> getCacheWriter() {
  if (hasCacheWriter()) {
    @SuppressWarnings("unchecked")
    CacheWriter<K , V> writer = (CacheWriter<K, V>) getCacheWriterFactory().create();
    return writer;
  }
  return null;
}
 

private MutableConfiguration<Long, String> getConfiguration(final boolean readThrough, final CacheLoader<Long, String> cacheLoader,
                                                            final boolean writeThrough, final CacheWriter<Long, String> cacheWriter) {
  MutableConfiguration<Long, String> config = new MutableConfiguration<>();
  config.setTypes(Long.class, String.class);
  config.setReadThrough(readThrough);
  config.setCacheLoaderFactory(() -> cacheLoader);
  config.setWriteThrough(writeThrough);
  config.setCacheWriterFactory(() -> cacheWriter);
  return config;
}
 

@Test
public void jsr107WriterGetsRegistered() {
  MutableConfiguration<Object, Object> configuration = new MutableConfiguration<>();
  CacheWriter<Object, Object> mock = mock(CacheWriter.class);
  RecordingFactory<CacheWriter<Object, Object>> factory = factoryOf(mock);
  configuration.setWriteThrough(true).setCacheWriterFactory(factory);

  merger.mergeConfigurations("cache", configuration);

  assertThat(factory.called, is(true));
  verify(cacheLoaderWriterFactory).registerJsr107Loader(eq("cache"), ArgumentMatchers.<CacheLoaderWriter<Object, Object>>isNotNull());
}
 

Eh107CacheLoaderWriter(CacheLoader<K, V> cacheLoader, boolean readThrough, CacheWriter<K, V> cacheWriter, boolean writeThrough) {
  this.cacheLoader = cacheLoader;
  this.readThrough = cacheLoader != null && readThrough;
  if (writeThrough) {
    this.cacheWriter = cacheWriter;
  } else {
    this.cacheWriter = null;
  }
}
 

/** {@inheritDoc} */
@Override public CacheConfiguration<K, V> setCacheWriterFactory(
    Factory<? extends CacheWriter<? super K, ? super V>> factory) {
    super.setCacheWriterFactory(factory);

    return this;
}
 

/**
 * @param ldr Loader.
 * @param writer Writer.
 */
GridCacheLoaderWriterStore(@Nullable CacheLoader<K, V> ldr, @Nullable CacheWriter<K, V> writer) {
    assert ldr != null || writer != null;

    this.ldr = ldr;
    this.writer = writer;
}
 

/** {@inheritDoc} */
@Override public CacheStore<K, V> create() {
    CacheLoader<K, V> ldr = ldrFactory == null ? null : ldrFactory.create();

    CacheWriter<K, V> writer = writerFactory == null ? null : writerFactory.create();

    return new GridCacheLoaderWriterStore<>(ldr, writer);
}
 

public CacheWriterWrapper(CacheWriter<? super K, ? super V> cw, boolean isAsync)
	{
		@SuppressWarnings("unchecked")
		CacheWriter<K, V> cw2 = (CacheWriter<K, V>) cw;
		this.cacheWriter = cw2;
//		this.isAsync = isAsync;
	}
 

ActionRunner(ActionContext<K,V> actionContext)
{
	// actionContext. It is currently taken directly from the Cache
        CacheWriter<K, V> writer = actionContext.cacheWriter();
        if (writer instanceof NopCacheWriter)
        {
            this.cacheWriter = null;
        }
        else
        {               
            this.cacheWriter = actionContext.cacheWriter();
        }
	this.listeners = actionContext.listeners();
	this.stats = actionContext.statisticsCalculator();		
}
 

/**
 * @param ldrFactory Loader factory.
 * @param writerFactory Writer factory.
 */
GridCacheLoaderWriterStoreFactory(@Nullable Factory<CacheLoader<K, V>> ldrFactory,
    @Nullable Factory<CacheWriter<K, V>> writerFactory) {
    this.ldrFactory = ldrFactory;
    this.writerFactory = writerFactory;

    assert ldrFactory != null || writerFactory != null;
}
 

@Override
public Factory<CacheWriter<? super K, ? super V>> getCacheWriterFactory() {
    return delegate.getCacheWriterFactory();
}
 

@Test
public void loader()
{
    final CachingProvider cachingProvider = Caching.getCachingProvider();
    final CacheManager cacheManager = cachingProvider.getCacheManager();
    cacheManager.createCache("default", new CompleteConfiguration<Object, Object>()
    {
        /**
         * 
         */
        private static final long serialVersionUID = -4598329777808827966L;

        @Override
        public boolean isReadThrough()
        {
            return true;
        }

        @Override
        public boolean isWriteThrough()
        {
            return false;
        }

        @Override
        public boolean isStatisticsEnabled()
        {
            return false;
        }

        @Override
        public boolean isManagementEnabled()
        {
            return false;
        }

        @Override
        public Iterable<CacheEntryListenerConfiguration<Object, Object>> getCacheEntryListenerConfigurations()
        {
            return null;
        }

        @Override
        public Factory<CacheLoader<Object, Object>> getCacheLoaderFactory()
        {
            return () -> new CacheLoader<Object, Object>()
            {
                @Override
                public Object load(Object key) throws CacheLoaderException
                {
                    return "super";
                }

                @Override
                public Map<Object, Object> loadAll(Iterable<?> keys) throws CacheLoaderException
                {
                    return null;
                }
            };
        }

        @Override
        public Factory<CacheWriter<? super Object, ? super Object>> getCacheWriterFactory()
        {
            return null;
        }

        @Override
        public Factory<ExpiryPolicy> getExpiryPolicyFactory()
        {
            return null;
        }

        @Override
        public Class<Object> getKeyType()
        {
            return Object.class;
        }

        @Override
        public Class<Object> getValueType()
        {
            return Object.class;
        }

        @Override
        public boolean isStoreByValue()
        {
            return false;
        }
    });
    final Cache<String, String> cache = cacheManager.getCache("default");
    assertEquals("super", cache.get("lazilyLoaded"));
    cachingProvider.close();
}
 

@Override
public Factory<CacheWriter<? super K, ? super V>> getCacheWriterFactory()
{
    return cacheWristerFactory;
}
 

@Override
public CacheWriter<K, V> create()
{
    return this;
}
 

@Override
public void init(final FilterConfig filterConfig) throws ServletException
{
    final ClassLoader classLoader = filterConfig.getServletContext().getClassLoader();
    provider = Caching.getCachingProvider(classLoader);

    String uri = filterConfig.getInitParameter("configuration");
    if (uri == null)
    {
        uri = provider.getDefaultURI().toString();
    }
    final Properties properties = new Properties();
    for (final String key : list(filterConfig.getInitParameterNames()))
    {
        final String value = filterConfig.getInitParameter(key);
        if (value != null)
        {
            properties.put(key, value);
        }
    }
    manager = provider.getCacheManager(URI.create(uri), classLoader, properties);

    String cacheName = filterConfig.getInitParameter("cache-name");
    if (cacheName == null)
    {
        cacheName = JCacheFilter.class.getName();
    }
    cache = manager.getCache(cacheName);
    if (cache == null)
    {
        final MutableConfiguration<PageKey, Page> configuration = new MutableConfiguration<PageKey, Page>()
                .setStoreByValue(false);
        configuration.setReadThrough("true".equals(properties.getProperty("read-through", "false")));
        configuration.setWriteThrough("true".equals(properties.getProperty("write-through", "false")));
        if (configuration.isReadThrough())
        {
            configuration.setCacheLoaderFactory(new FactoryBuilder.ClassFactory<CacheLoader<PageKey, Page>>(properties.getProperty("cache-loader-factory")));
        }
        if (configuration.isWriteThrough())
        {
            configuration.setCacheWriterFactory(new FactoryBuilder.ClassFactory<CacheWriter<? super PageKey, ? super Page>>(properties.getProperty("cache-writer-factory")));
        }
        final String expirtyPolicy = properties.getProperty("expiry-policy-factory");
        if (expirtyPolicy != null)
        {
            configuration.setExpiryPolicyFactory(new FactoryBuilder.ClassFactory<ExpiryPolicy>(expirtyPolicy));
        }
        configuration.setManagementEnabled("true".equals(properties.getProperty("management-enabled", "false")));
        configuration.setStatisticsEnabled("true".equals(properties.getProperty("statistics-enabled", "false")));
        cache = manager.createCache(cacheName, configuration);
    }
}
 

@Override
public CacheWriter<K, V> cacheWriter()
{
	return cacheWriter;
}
 

public CacheWriter<K, V> getCacheWriter() {
    return cacheWriter;
}
 

@SuppressWarnings("unchecked")
public Builder<K, V> setCacheWriterFactory(Factory<? extends CacheWriter<? super K, ? super V>> factory)
{
	this.writerFactory = (Factory<CacheWriter<? super K, ? super V>>) factory;
	return this;
}
 

public CompositeCacheWriter(final CacheWriter<K, V>... writers)
{
    this.writers = writers;
}
 

@Override
public CacheWriter<K, V> create()
{
    return this;
}
 

public AsyncCacheWriter(final CacheWriter<K, V> delegate, final int poolSize)
{
    writer = delegate;
    pool = Executors.newFixedThreadPool(
            poolSize, new DaemonThreadFactory(delegate.getClass().getName() + "-" + delegate.hashCode() + "-"));
}
 

/**
 * Delegates to the wrapped cache. Wrap configuration and return true on store by value
 */
@SuppressWarnings("unchecked")
@Override
public <C extends Configuration<K, T>> C getConfiguration(Class<C> clazz) {
  final C c = cache.getConfiguration(clazz);
  if (c instanceof CompleteConfiguration) {
    final CompleteConfiguration<K, T> cc = (CompleteConfiguration<K,T>) c;
    return (C) new CompleteConfiguration<K, T>() {
      @Override
      public Iterable<CacheEntryListenerConfiguration<K, T>> getCacheEntryListenerConfigurations() {
        return cc.getCacheEntryListenerConfigurations();
      }

      @Override
      public boolean isReadThrough() {
        return cc.isReadThrough();
      }

      @Override
      public boolean isWriteThrough() {
        return cc.isWriteThrough();
      }

      @Override
      public boolean isStatisticsEnabled() {
        return cc.isStatisticsEnabled();
      }

      @Override
      public boolean isManagementEnabled() {
        return cc.isManagementEnabled();
      }

      @Override
      public Factory<CacheLoader<K, T>> getCacheLoaderFactory() {
        return cc.getCacheLoaderFactory();
      }

      @Override
      public Factory<CacheWriter<? super K, ? super T>> getCacheWriterFactory() {
        return cc.getCacheWriterFactory();
      }

      @Override
      public Factory<ExpiryPolicy> getExpiryPolicyFactory() {
        return cc.getExpiryPolicyFactory();
      }

      @Override
      public Class<K> getKeyType() {
        return cc.getKeyType();
      }

      @Override
      public Class<T> getValueType() {
        return cc.getValueType();
      }

      @Override
      public boolean isStoreByValue() {
        return true;
      }
    };
  } else if (c instanceof Configuration) {
    return (C) new Configuration<K, T>() {
      @Override
      public Class<K> getKeyType() {
        return c.getKeyType();
      }

      @Override
      public Class<T> getValueType() {
        return c.getValueType();
      }

      @Override
      public boolean isStoreByValue() {
        return true;
      }
    };
  }
  return c;
}