javax.cache.annotation.CacheResult Java Examples

protected CacheResultOperation createCacheResultOperation(Method method, @Nullable CacheDefaults defaults, CacheResult ann) {
	String cacheName = determineCacheName(method, defaults, ann.cacheName());
	CacheResolverFactory cacheResolverFactory =
			determineCacheResolverFactory(defaults, ann.cacheResolverFactory());
	KeyGenerator keyGenerator = determineKeyGenerator(defaults, ann.cacheKeyGenerator());

	CacheMethodDetails<CacheResult> methodDetails = createMethodDetails(method, ann, cacheName);

	CacheResolver cacheResolver = getCacheResolver(cacheResolverFactory, methodDetails);
	CacheResolver exceptionCacheResolver = null;
	final String exceptionCacheName = ann.exceptionCacheName();
	if (StringUtils.hasText(exceptionCacheName)) {
		exceptionCacheResolver = getExceptionCacheResolver(cacheResolverFactory, methodDetails);
	}

	return new CacheResultOperation(methodDetails, cacheResolver, keyGenerator, exceptionCacheResolver);
}
 

protected CacheResultOperation createCacheResultOperation(Method method, CacheDefaults defaults, CacheResult ann) {
	String cacheName = determineCacheName(method, defaults, ann.cacheName());
	CacheResolverFactory cacheResolverFactory =
			determineCacheResolverFactory(defaults, ann.cacheResolverFactory());
	KeyGenerator keyGenerator = determineKeyGenerator(defaults, ann.cacheKeyGenerator());

	CacheMethodDetails<CacheResult> methodDetails = createMethodDetails(method, ann, cacheName);

	CacheResolver cacheResolver = getCacheResolver(cacheResolverFactory, methodDetails);
	CacheResolver exceptionCacheResolver = null;
	final String exceptionCacheName = ann.exceptionCacheName();
	if (StringUtils.hasText(exceptionCacheName)) {
		exceptionCacheResolver = getExceptionCacheResolver(cacheResolverFactory, methodDetails);
	}

	return new CacheResultOperation(methodDetails, cacheResolver, keyGenerator, exceptionCacheResolver);
}
 

protected CacheResolver getExceptionCacheResolver(
		@Nullable CacheResolverFactory factory, CacheMethodDetails<CacheResult> details) {

	if (factory != null) {
		javax.cache.annotation.CacheResolver cacheResolver = factory.getExceptionCacheResolver(details);
		return new CacheResolverAdapter(cacheResolver);
	}
	else {
		return getDefaultExceptionCacheResolver();
	}
}
 

protected DefaultCacheInvocationContext<?> createDummyContext() throws Exception {
	Method method = Sample.class.getMethod("get", String.class);
	CacheResult cacheAnnotation = method.getAnnotation(CacheResult.class);
	CacheMethodDetails<CacheResult> methodDetails =
			new DefaultCacheMethodDetails<>(method, cacheAnnotation, "test");
	CacheResultOperation operation = new CacheResultOperation(methodDetails,
			defaultCacheResolver, defaultKeyGenerator, defaultExceptionCacheResolver);
	return new DefaultCacheInvocationContext<>(operation, new Sample(), new Object[] {"id"});
}
 

@GET
@Path("icon/{id}")
@Produces({ APPLICATION_JSON, APPLICATION_OCTET_STREAM, "image/svg+xml" })
@CacheResult
public CompletionStage<Response> icon() {
    return handler.forward();
}
 

@CacheResult
CompletionStage<ActionList> getActions() {
    return client
            .path("action/index")
            .queryParam("language", "en")
            .request(APPLICATION_JSON_TYPE)
            .rx()
            .get(ActionList.class);
}
 

@Override
@CacheResult(cacheName = "conference")
public Conference findBySlug(String slug) {
	List<Conference> all = entityManager
			.createQuery("from Conference where slug=:slug",
					Conference.class).setParameter("slug", slug)
			.getResultList();
	if (!all.isEmpty()) {
		return all.get(0); 
	}

	return null;
}
 

@GET
@Path("icon/family/{id}")
@CacheResult
@Produces({ APPLICATION_JSON, APPLICATION_OCTET_STREAM, "image/svg+xml" })
public CompletionStage<Response> familyIcon() {
    return handler.forward();
}
 

@Override
public CacheResolver getExceptionCacheResolver(final CacheMethodDetails<CacheResult> cacheMethodDetails)
{
    final String exceptionCacheName = cacheMethodDetails.getCacheAnnotation().exceptionCacheName();
    if (exceptionCacheName == null || exceptionCacheName.isEmpty())
    {
        throw new IllegalArgumentException("CacheResult.exceptionCacheName() not specified");
    }
    return findCacheResolver(exceptionCacheName);
}
 

@Test
public void tooManyKeyValues() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "anotherSimpleGet", String.class, Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);

	// missing one argument
	assertThatIllegalStateException().isThrownBy(() ->
			operation.getKeyParameters("bar"));
}
 

@Test
public void annotatedGet() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "annotatedGet", Long.class, String.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);
	CacheInvocationParameter[] parameters = operation.getAllParameters(2L, "foo");

	Set<Annotation> firstParameterAnnotations = parameters[0].getAnnotations();
	assertEquals(1, firstParameterAnnotations.size());
	assertEquals(CacheKey.class, firstParameterAnnotations.iterator().next().annotationType());

	Set<Annotation> secondParameterAnnotations = parameters[1].getAnnotations();
	assertEquals(1, secondParameterAnnotations.size());
	assertEquals(Value.class, secondParameterAnnotations.iterator().next().annotationType());
}
 

@Test
public void fullGetConfig() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "fullGetConfig", Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);
	assertTrue(operation.isAlwaysInvoked());
	assertNotNull(operation.getExceptionTypeFilter());
	assertTrue(operation.getExceptionTypeFilter().match(IOException.class));
	assertFalse(operation.getExceptionTypeFilter().match(NullPointerException.class));
}
 

@Test
public void fullGetConfig() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "fullGetConfig", Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);
	assertTrue(operation.isAlwaysInvoked());
	assertNotNull(operation.getExceptionTypeFilter());
	assertTrue(operation.getExceptionTypeFilter().match(IOException.class));
	assertFalse(operation.getExceptionTypeFilter().match(NullPointerException.class));
}
 

@Test
public void annotatedGet() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "annotatedGet", Long.class, String.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);
	CacheInvocationParameter[] parameters = operation.getAllParameters(2L, "foo");

	Set<Annotation> firstParameterAnnotations = parameters[0].getAnnotations();
	assertEquals(1, firstParameterAnnotations.size());
	assertEquals(CacheKey.class, firstParameterAnnotations.iterator().next().annotationType());

	Set<Annotation> secondParameterAnnotations = parameters[1].getAnnotations();
	assertEquals(1, secondParameterAnnotations.size());
	assertEquals(Value.class, secondParameterAnnotations.iterator().next().annotationType());
}
 

@Test
public void invokeWithWrongParameters() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "anotherSimpleGet", String.class, Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);

	thrown.expect(IllegalStateException.class);
	operation.getAllParameters("bar"); // missing one argument
}
 

@Override
protected CacheResultOperation createSimpleOperation() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "simpleGet", Long.class);

	return new CacheResultOperation(methodDetails, defaultCacheResolver, defaultKeyGenerator,
			defaultExceptionCacheResolver);
}
 

protected CacheResolver getExceptionCacheResolver(CacheResolverFactory factory,
		CacheMethodDetails<CacheResult> details) {

	if (factory != null) {
		javax.cache.annotation.CacheResolver cacheResolver = factory.getExceptionCacheResolver(details);
		return new CacheResolverAdapter(cacheResolver);
	}
	else {
		return getDefaultExceptionCacheResolver();
	}
}
 

@Test
public void tooManyKeyValues() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "anotherSimpleGet", String.class, Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);

	thrown.expect(IllegalStateException.class);
	operation.getKeyParameters("bar"); // missing one argument
}
 

@Test
public void multiParameterKey() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "multiKeysGet", Long.class, Boolean.class, String.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);

	CacheInvocationParameter[] keyParameters = operation.getKeyParameters(3L, Boolean.TRUE, "Foo");
	assertEquals(2, keyParameters.length);
	assertCacheInvocationParameter(keyParameters[0], Long.class, 3L, 0);
	assertCacheInvocationParameter(keyParameters[1], String.class, "Foo", 2);
}
 

protected DefaultCacheInvocationContext<?> createDummyContext() {
	Method method = ReflectionUtils.findMethod(Sample.class, "get", String.class);
	Assert.notNull(method);
	CacheResult cacheAnnotation = method.getAnnotation(CacheResult.class);
	CacheMethodDetails<CacheResult> methodDetails =
			new DefaultCacheMethodDetails<>(method, cacheAnnotation, "test");
	CacheResultOperation operation = new CacheResultOperation(methodDetails,
			defaultCacheResolver, defaultKeyGenerator, defaultExceptionCacheResolver);
	return new DefaultCacheInvocationContext<CacheResult>(operation, new Sample(), new Object[] {"id"});
}
 

@Test
public void invokeWithWrongParameters() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "anotherSimpleGet", String.class, Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);

	thrown.expect(IllegalStateException.class);
	operation.getAllParameters("bar"); // missing one argument
}
 

protected CacheResolver getExceptionCacheResolver(CacheResolverFactory factory,
		CacheMethodDetails<CacheResult> details) {

	if (factory != null) {
		javax.cache.annotation.CacheResolver cacheResolver = factory.getExceptionCacheResolver(details);
		return new CacheResolverAdapter(cacheResolver);
	}
	else {
		return getDefaultExceptionCacheResolver();
	}
}
 

@Override
protected JCacheOperation<?> findCacheOperation(Method method, Class<?> targetType) {
	CacheResult cacheResult = method.getAnnotation(CacheResult.class);
	CachePut cachePut = method.getAnnotation(CachePut.class);
	CacheRemove cacheRemove = method.getAnnotation(CacheRemove.class);
	CacheRemoveAll cacheRemoveAll = method.getAnnotation(CacheRemoveAll.class);

	int found = countNonNull(cacheResult, cachePut, cacheRemove, cacheRemoveAll);
	if (found == 0) {
		return null;
	}
	if (found > 1) {
		throw new IllegalStateException("More than one cache annotation found on '" + method + "'");
	}

	CacheDefaults defaults = getCacheDefaults(method, targetType);
	if (cacheResult != null) {
		return createCacheResultOperation(method, defaults, cacheResult);
	}
	else if (cachePut != null) {
		return createCachePutOperation(method, defaults, cachePut);
	}
	else if (cacheRemove != null) {
		return createCacheRemoveOperation(method, defaults, cacheRemove);
	}
	else {
		return createCacheRemoveAllOperation(method, defaults, cacheRemoveAll);
	}
}
 

@Override
protected JCacheOperation<?> findCacheOperation(Method method, @Nullable Class<?> targetType) {
	CacheResult cacheResult = method.getAnnotation(CacheResult.class);
	CachePut cachePut = method.getAnnotation(CachePut.class);
	CacheRemove cacheRemove = method.getAnnotation(CacheRemove.class);
	CacheRemoveAll cacheRemoveAll = method.getAnnotation(CacheRemoveAll.class);

	int found = countNonNull(cacheResult, cachePut, cacheRemove, cacheRemoveAll);
	if (found == 0) {
		return null;
	}
	if (found > 1) {
		throw new IllegalStateException("More than one cache annotation found on '" + method + "'");
	}

	CacheDefaults defaults = getCacheDefaults(method, targetType);
	if (cacheResult != null) {
		return createCacheResultOperation(method, defaults, cacheResult);
	}
	else if (cachePut != null) {
		return createCachePutOperation(method, defaults, cachePut);
	}
	else if (cacheRemove != null) {
		return createCacheRemoveOperation(method, defaults, cacheRemove);
	}
	else {
		return createCacheRemoveAllOperation(method, defaults, cacheRemoveAll);
	}
}
 

public MethodMeta(Class<?>[] parameterTypes, List<Set<Annotation>> parameterAnnotations, Set<Annotation>
        annotations, Integer[] keysIndices, Integer valueIndex, Integer[] parameterIndices, String
        cacheResultCacheName, CacheResolverFactory cacheResultResolverFactory, CacheKeyGenerator
        cacheResultKeyGenerator, CacheResult cacheResult, String cachePutCacheName, CacheResolverFactory
        cachePutResolverFactory, CacheKeyGenerator cachePutKeyGenerator, boolean cachePutAfter, CachePut cachePut, String
        cacheRemoveCacheName, CacheResolverFactory cacheRemoveResolverFactory, CacheKeyGenerator
        cacheRemoveKeyGenerator, boolean cacheRemoveAfter, CacheRemove cacheRemove, String cacheRemoveAllCacheName,
                  CacheResolverFactory cacheRemoveAllResolverFactory, boolean
                          cacheRemoveAllAfter, CacheRemoveAll cacheRemoveAll)
{
    this.parameterTypes = parameterTypes;
    this.parameterAnnotations = parameterAnnotations;
    this.annotations = annotations;
    this.keysIndices = keysIndices;
    this.valueIndex = valueIndex;
    this.parameterIndices = parameterIndices;
    this.cacheResultCacheName = cacheResultCacheName;
    this.cacheResultResolverFactory = cacheResultResolverFactory;
    this.cacheResultKeyGenerator = cacheResultKeyGenerator;
    this.cacheResult = cacheResult;
    this.cachePutCacheName = cachePutCacheName;
    this.cachePutResolverFactory = cachePutResolverFactory;
    this.cachePutKeyGenerator = cachePutKeyGenerator;
    this.cachePutAfter = cachePutAfter;
    this.cachePut = cachePut;
    this.cacheRemoveCacheName = cacheRemoveCacheName;
    this.cacheRemoveResolverFactory = cacheRemoveResolverFactory;
    this.cacheRemoveKeyGenerator = cacheRemoveKeyGenerator;
    this.cacheRemoveAfter = cacheRemoveAfter;
    this.cacheRemove = cacheRemove;
    this.cacheRemoveAllCacheName = cacheRemoveAllCacheName;
    this.cacheRemoveAllResolverFactory = cacheRemoveAllResolverFactory;
    this.cacheRemoveAllAfter = cacheRemoveAllAfter;
    this.cacheRemoveAll = cacheRemoveAll;
}
 

@CacheResult(cacheName = "testSimple")
public SampleObject anotherSimpleGet(String foo, Long bar) {
	return null;
}
 

@Override
@CacheResult(skipGet = true)
public Long cacheAlwaysInvoke(String id) {
	return counter.getAndIncrement();
}
 

@Override
@CacheResult
public Long cacheWithPartialKey(@CacheKey String id, boolean notUsed) {
	return counter.getAndIncrement();
}
 

@Override
@CacheResult(cacheResolverFactory = TestableCacheResolverFactory.class)
public Long cacheWithCustomCacheResolver(String id) {
	return counter.getAndIncrement();
}
 

@GET
@Path("details")
@CacheResult
public CompletionStage<Response> getDetail() {
    return handler.forward();
}