/** * Returns a {@link Marshaller} for {@link Optional} objects. * * @param valueMarshaller used to marshall values held by {@link Optional} instances. * @param <T> the value type * @return a {@link Marshaller} for {@link Optional} objects. */ public static <T> Marshaller<Optional<T>> optionalMarshaller(Marshaller<T> valueMarshaller) { return new OptionalMarshaller<>(valueMarshaller); }
/** * Returns a {@link Marshaller} for {@link Serializable} objects. When de-serializing, the default implementation of * {@link java.io.ObjectInputStream#resolveClass(ObjectStreamClass)} is used to resolve {@link Class} objects. * * @param clazz the {@link Class} of the instances being marshalled * @param <T> the value type * @return a {@link Marshaller} for {@link Serializable} objects. */ public static <T extends Serializable> Marshaller<T> serializableMarshaller(Class<T> clazz) { return new JavaSerializationMarshaller<>(clazz); }
/** * Returns a {@link Marshaller} for {@link String} objects. * * @return a {@link Marshaller} for {@link String} objects. */ public static Marshaller<String> stringMarshaller() { return new StringMarshaller(); }
private StableReadExternalCache<String> getCache(String cacheName) { return cacheFactory.getStableReadExternalCache( cacheName, serializableMarshaller(String.class), new ExternalCacheSettingsBuilder().build() ); }
@Test public void stableReadExternalCache_normal_marshaller() { final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder() .defaultTtl(Duration.ofSeconds(60)) .entryGrowthRateHint(ChangeRate.LOW_CHANGE) .dataChangeRateHint(ChangeRate.LOW_CHANGE) .entryCountHint(100) .build(); @SuppressWarnings("deprecation") final StableReadExternalCache<String> cache = vCacheFactory().getStableReadExternalCache( "my-stable-read-cache", MarshallerFactory.stringMarshaller(), settings); assertThat(cache, notNullValue()); assertThat(cache.getName(), is("my-stable-read-cache")); final CompletionStage<Void> rmall = cache.removeAll(); assertThat(rmall, successful()); final CompletionStage<Boolean> put1 = cache.put("three", "drei", PUT_ALWAYS); assertThat(put1, successfulWith(is(true))); final CompletionStage<Optional<String>> get1 = cache.get("three"); assertThat(get1, successfulWith(is(Optional.of("drei")))); assertThat(invocationsOfBegunTxns, is(0)); }
private ObjectInputStream createObjectInputStream(InputStream istr) throws IOException { return loader.isPresent() ? new ObjectInputStreamWithLoader(istr, loader.get()) : new ObjectInputStream(istr); }
@Override public T unmarshall(byte[] raw) throws MarshallerException { final ByteArrayInputStream bais = new ByteArrayInputStream(raw); try (ObjectInputStream ois = createObjectInputStream(bais)) { return clazz.cast(ois.readObject()); } catch (ClassCastException | ClassNotFoundException | IOException ex) { throw new MarshallerException("Unable to unmarshall", ex); } }
@SuppressWarnings("unchecked") private StableReadExternalCache<ImmutableMap<String, ImmutableList<ImmutableMap<String, PageProperty>>>> createCache(VCacheFactory cacheFactory) { return cacheFactory.getStableReadExternalCache( CACHE_NAME, (Marshaller) serializableMarshaller(ImmutableMap.class), new ExternalCacheSettingsBuilder().build() ); }
@Test public void directExternalCache_normal_marshaller() { final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder() .defaultTtl(Duration.ofSeconds(60)) .entryGrowthRateHint(ChangeRate.LOW_CHANGE) .dataChangeRateHint(ChangeRate.LOW_CHANGE) .entryCountHint(100) .build(); @SuppressWarnings("deprecation") final DirectExternalCache<String> cache = vCacheFactory().getDirectExternalCache( "my-direct-cache", MarshallerFactory.stringMarshaller(), settings); assertThat(cache, notNullValue()); assertThat(cache.getName(), is("my-direct-cache")); final CompletionStage<Void> rmall = cache.removeAll(); assertThat(rmall, successful()); final CompletionStage<Boolean> put1 = cache.put("one1", "eine", PUT_ALWAYS); assertThat(put1, successfulWith(is(true))); final CompletionStage<Optional<String>> get1 = cache.get("one1"); assertThat(get1, successfulWith(is(Optional.of("eine")))); assertThat(vCacheManagement().allJvmCacheDetails().size(), is(0)); assertThat(vCacheManagement().allRequestCacheDetails().size(), is(0)); }
/** * Returns a {@link Marshaller} for {@link Serializable} objects. When de-serializing, the supplied * {@link ClassLoader} is used to resolve {@link Class} objects. * * @param clazz the {@link Class} of the instances being marshalled * @param loader the {@link ClassLoader} is used to resolve {@link Class} objects * @param <T> the value type * @return a {@link Marshaller} for {@link Serializable} objects. */ public static <T extends Serializable> Marshaller<T> serializableMarshaller(Class<T> clazz, ClassLoader loader) { return new JavaSerializationMarshaller<>(clazz, loader); } }
public TwitterRenderer(I18NBeanFactory i18NBeanFactory, LocaleManager localeManager, VCacheFactory cacheFactory, PageBuilderService pageBuilderService, VelocityRenderService velocityRenderService, HttpRetrievalService httpRetrievalService) { this.i18NBeanFactory = i18NBeanFactory; this.localeManager = localeManager; this.pageBuilderService = pageBuilderService; this.velocityRenderService = velocityRenderService; this.httpRetrievalService = httpRetrievalService; this.cacheRef = Lazy.supplier(() -> cacheFactory.getStableReadExternalCache( CACHE_NAME, serializableMarshaller(TweetRetrievalResult.class), new ExternalCacheSettingsBuilder().build() )); }
@Test public void transactionalExternalCache_normal_marshaller() { final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder() .defaultTtl(Duration.ofSeconds(60)) .entryGrowthRateHint(ChangeRate.LOW_CHANGE) .dataChangeRateHint(ChangeRate.LOW_CHANGE) .entryCountHint(100) .build(); @SuppressWarnings("deprecation") final TransactionalExternalCache<String> cache = vCacheFactory().getTransactionalExternalCache( "my-txn-cache", MarshallerFactory.stringMarshaller(), settings); assertThat(cache, notNullValue()); assertThat(cache.getName(), is("my-txn-cache")); assertThat(invocationsOfBegunTxns, is(0)); cache.removeAll(); assertThat(invocationsOfBegunTxns, is(1)); cache.put("three", "drei", PUT_ALWAYS); final CompletionStage<Optional<String>> get1 = cache.get("three"); assertThat(get1, successfulWith(is(Optional.of("drei")))); vCacheLifecycleManager().transactionSync(currentRequestContext()); assertThat(invocationsOfBegunTxns, is(1)); forceNewRequestContext(); final CompletionStage<Optional<String>> get2 = cache.get("three"); assertThat(invocationsOfBegunTxns, is(2)); unsafeJoin(get2.toCompletableFuture()).get(); assertThat(get2, successfulWith(is(Optional.of("drei")))); assertThat(invocationsOfBegunTxns, is(2)); }