javax.cache.annotation.CacheMethodDetails Java Examples

public CachePutOperation(
		CacheMethodDetails<CachePut> methodDetails, CacheResolver cacheResolver, KeyGenerator keyGenerator) {

	super(methodDetails, cacheResolver, keyGenerator);

	CachePut ann = methodDetails.getCacheAnnotation();
	this.exceptionTypeFilter = createExceptionTypeFilter(ann.cacheFor(), ann.noCacheFor());

	CacheParameterDetail valueParameterDetail =
			initializeValueParameterDetail(methodDetails.getMethod(), this.allParameterDetails);
	if (valueParameterDetail == null) {
		throw new IllegalArgumentException("No parameter annotated with @CacheValue was found for " +
				methodDetails.getMethod());
	}
	this.valueParameterDetail = valueParameterDetail;
}
 

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);
}
 

public CachePutOperation(
		CacheMethodDetails<CachePut> methodDetails, CacheResolver cacheResolver, KeyGenerator keyGenerator) {

	super(methodDetails, cacheResolver, keyGenerator);

	CachePut ann = methodDetails.getCacheAnnotation();
	this.exceptionTypeFilter = createExceptionTypeFilter(ann.cacheFor(), ann.noCacheFor());

	CacheParameterDetail valueParameterDetail =
			initializeValueParameterDetail(methodDetails.getMethod(), this.allParameterDetails);
	if (valueParameterDetail == null) {
		throw new IllegalArgumentException("No parameter annotated with @CacheValue was found for " +
				methodDetails.getMethod());
	}
	this.valueParameterDetail = valueParameterDetail;
}
 

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(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 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));
}
 

public CacheRemoveOperation(
		CacheMethodDetails<CacheRemove> methodDetails, CacheResolver cacheResolver, KeyGenerator keyGenerator) {

	super(methodDetails, cacheResolver, keyGenerator);
	CacheRemove ann = methodDetails.getCacheAnnotation();
	this.exceptionTypeFilter = createExceptionTypeFilter(ann.evictFor(), ann.noEvictFor());
}
 

@Test
public void noCacheValue() {
	CacheMethodDetails<CachePut> methodDetails = create(CachePut.class,
			SampleObject.class, "noCacheValue", Long.class);

	thrown.expect(IllegalArgumentException.class);
	createDefaultOperation(methodDetails);
}
 

/**
 * Create a new instance.
 * @param methodDetails the {@link CacheMethodDetails} related to the cached method
 * @param cacheResolver the cache resolver to resolve regular caches
 * @param keyGenerator the key generator to compute cache keys
 */
protected AbstractJCacheKeyOperation(CacheMethodDetails<A> methodDetails,
		CacheResolver cacheResolver, KeyGenerator keyGenerator) {

	super(methodDetails, cacheResolver);
	this.keyGenerator = keyGenerator;
	this.keyParameterDetails = initializeKeyParameterDetails(this.allParameterDetails);
}
 

@Test
public void multiCacheValues() {
	CacheMethodDetails<CachePut> methodDetails = create(CachePut.class,
			SampleObject.class, "multiCacheValues", Long.class, SampleObject.class, SampleObject.class);

	thrown.expect(IllegalArgumentException.class);
	createDefaultOperation(methodDetails);
}
 

public CacheResultOperation(CacheMethodDetails<CacheResult> methodDetails, CacheResolver cacheResolver,
		KeyGenerator keyGenerator, CacheResolver exceptionCacheResolver) {

	super(methodDetails, cacheResolver, keyGenerator);
	CacheResult ann = methodDetails.getCacheAnnotation();
	this.exceptionTypeFilter = createExceptionTypeFilter(ann.cachedExceptions(), ann.nonCachedExceptions());
	this.exceptionCacheResolver = exceptionCacheResolver;
	this.exceptionCacheName = (StringUtils.hasText(ann.exceptionCacheName()) ? ann.exceptionCacheName() : null);
}
 

/**
 * Create a new instance.
 * @param methodDetails the {@link CacheMethodDetails} related to the cached method
 * @param cacheResolver the cache resolver to resolve regular caches
 */
protected AbstractJCacheOperation(CacheMethodDetails<A> methodDetails, CacheResolver cacheResolver) {
	Assert.notNull(methodDetails, "method details must not be null.");
	Assert.notNull(cacheResolver, "cache resolver must not be null.");
	this.methodDetails = methodDetails;
	this.cacheResolver = cacheResolver;
	this.allParameterDetails = initializeAllParameterDetails(methodDetails.getMethod());
}
 

/**
 * Create a new instance.
 * @param methodDetails the {@link CacheMethodDetails} related to the cached method
 * @param cacheResolver the cache resolver to resolve regular caches
 */
protected AbstractJCacheOperation(CacheMethodDetails<A> methodDetails, CacheResolver cacheResolver) {
	Assert.notNull(methodDetails, "method details must not be null.");
	Assert.notNull(cacheResolver, "cache resolver must not be null.");
	this.methodDetails = methodDetails;
	this.cacheResolver = cacheResolver;
	this.allParameterDetails = initializeAllParameterDetails(methodDetails.getMethod());
}
 

protected CacheResolver getCacheResolver(CacheResolverFactory factory, CacheMethodDetails<?> details) {
	if (factory != null) {
		javax.cache.annotation.CacheResolver cacheResolver = factory.getCacheResolver(details);
		return new CacheResolverAdapter(cacheResolver);
	}
	else {
		return getDefaultCacheResolver();
	}
}
 

protected CacheRemoveOperation createCacheRemoveOperation(Method method, CacheDefaults defaults, CacheRemove ann) {
	String cacheName = determineCacheName(method, defaults, ann.cacheName());
	CacheResolverFactory cacheResolverFactory =
			determineCacheResolverFactory(defaults, ann.cacheResolverFactory());
	KeyGenerator keyGenerator = determineKeyGenerator(defaults, ann.cacheKeyGenerator());

	CacheMethodDetails<CacheRemove> methodDetails = createMethodDetails(method, ann, cacheName);
	CacheResolver cacheResolver = getCacheResolver(cacheResolverFactory, methodDetails);
	return new CacheRemoveOperation(methodDetails, cacheResolver, keyGenerator);
}
 

protected CacheRemoveAllOperation createCacheRemoveAllOperation(Method method, CacheDefaults defaults, CacheRemoveAll ann) {
	String cacheName = determineCacheName(method, defaults, ann.cacheName());
	CacheResolverFactory cacheResolverFactory =
			determineCacheResolverFactory(defaults, ann.cacheResolverFactory());

	CacheMethodDetails<CacheRemoveAll> methodDetails = createMethodDetails(method, ann, cacheName);
	CacheResolver cacheResolver = getCacheResolver(cacheResolverFactory, methodDetails);
	return new CacheRemoveAllOperation(methodDetails, cacheResolver);
}
 

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"});
}
 

@Test
public void fullPutConfig() {
	CacheMethodDetails<CachePut> methodDetails = create(CachePut.class,
			SampleObject.class, "fullPutConfig", Long.class, SampleObject.class);
	CachePutOperation operation = createDefaultOperation(methodDetails);
	assertTrue(operation.isEarlyPut());
	assertNotNull(operation.getExceptionTypeFilter());
	assertTrue(operation.getExceptionTypeFilter().match(IOException.class));
	assertFalse(operation.getExceptionTypeFilter().match(NullPointerException.class));
}
 

@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
}
 

@Override
protected CacheRemoveAllOperation createSimpleOperation() {
	CacheMethodDetails<CacheRemoveAll> methodDetails = create(CacheRemoveAll.class,
			SampleObject.class, "simpleRemoveAll");

	return new CacheRemoveAllOperation(methodDetails, defaultCacheResolver);
}
 

@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);
}
 

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

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

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

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

@Test
public void multiCacheValues() {
	CacheMethodDetails<CachePut> methodDetails = create(CachePut.class,
			SampleObject.class, "multiCacheValues", Long.class, SampleObject.class, SampleObject.class);

	thrown.expect(IllegalArgumentException.class);
	createDefaultOperation(methodDetails);
}
 

@Test
public void noCacheValue() {
	CacheMethodDetails<CachePut> methodDetails = create(CachePut.class,
			SampleObject.class, "noCacheValue", Long.class);

	thrown.expect(IllegalArgumentException.class);
	createDefaultOperation(methodDetails);
}
 

protected <A extends Annotation> CacheMethodDetails<A> create(Class<A> annotationType,
		Class<?> targetType, String methodName,
		Class<?>... parameterTypes) {
	Method method = ReflectionUtils.findMethod(targetType, methodName, parameterTypes);
	Assert.notNull(method, "requested method '" + methodName + "'does not exist");
	A cacheAnnotation = method.getAnnotation(annotationType);
	return new DefaultCacheMethodDetails<>(method, cacheAnnotation, getCacheName(cacheAnnotation));
}
 

public CacheResultOperation(CacheMethodDetails<CacheResult> methodDetails, CacheResolver cacheResolver,
		KeyGenerator keyGenerator, @Nullable CacheResolver exceptionCacheResolver) {

	super(methodDetails, cacheResolver, keyGenerator);

	CacheResult ann = methodDetails.getCacheAnnotation();
	this.exceptionTypeFilter = createExceptionTypeFilter(ann.cachedExceptions(), ann.nonCachedExceptions());
	this.exceptionCacheResolver = exceptionCacheResolver;
	this.exceptionCacheName = (StringUtils.hasText(ann.exceptionCacheName()) ? ann.exceptionCacheName() : null);
}
 

/**
 * Construct a new {@code AbstractJCacheOperation}.
 * @param methodDetails the {@link CacheMethodDetails} related to the cached method
 * @param cacheResolver the cache resolver to resolve regular caches
 */
protected AbstractJCacheOperation(CacheMethodDetails<A> methodDetails, CacheResolver cacheResolver) {
	Assert.notNull(methodDetails, "CacheMethodDetails must not be null");
	Assert.notNull(cacheResolver, "CacheResolver must not be null");
	this.methodDetails = methodDetails;
	this.cacheResolver = cacheResolver;
	this.allParameterDetails = initializeAllParameterDetails(methodDetails.getMethod());
}
 

@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());
}
 

protected CacheRemoveAllOperation createCacheRemoveAllOperation(Method method, @Nullable CacheDefaults defaults, CacheRemoveAll ann) {
	String cacheName = determineCacheName(method, defaults, ann.cacheName());
	CacheResolverFactory cacheResolverFactory =
			determineCacheResolverFactory(defaults, ann.cacheResolverFactory());

	CacheMethodDetails<CacheRemoveAll> methodDetails = createMethodDetails(method, ann, cacheName);
	CacheResolver cacheResolver = getCacheResolver(cacheResolverFactory, methodDetails);
	return new CacheRemoveAllOperation(methodDetails, cacheResolver);
}