javax.cache.annotation.CacheRemove Java Examples

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

@Override
@CacheRemove(afterInvocation = false)
public void earlyRemove(String id) {
	Object key = SimpleKeyGenerator.generateKey(id);
	Cache.ValueWrapper valueWrapper = defaultCache.get(key);
	if (valueWrapper != null) {
		throw new AssertionError("Value with key " + key + " expected to be already remove from cache");
	}
}
 

@Override
@CacheRemove(afterInvocation = false)
public void earlyRemove(String id) {
	Object key = SimpleKeyGenerator.generateKey(id);
	Cache.ValueWrapper valueWrapper = defaultCache.get(key);
	if (valueWrapper != null) {
		throw new AssertionError("Value with key " + key + " expected to be already remove from cache");
	}
}
 

@Override
protected CacheRemoveOperation createSimpleOperation() {
	CacheMethodDetails<CacheRemove> methodDetails = create(CacheRemove.class,
			SampleObject.class, "simpleRemove", Long.class);

	return new CacheRemoveOperation(methodDetails, defaultCacheResolver, defaultKeyGenerator);
}
 

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

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

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

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

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

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

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

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

@Override
@CacheRemove(afterInvocation = false)
public void earlyRemove(String id) {
	Object key = SimpleKeyGenerator.generateKey(id);
	Cache.ValueWrapper valueWrapper = defaultCache.get(key);
	if (valueWrapper != null) {
		throw new AssertionError("Value with key " + key + " expected to be already remove from cache");
	}
}
 

@Override
@CacheRemove(afterInvocation = false)
public void earlyRemove(String id) {
	Object key = SimpleKeyGenerator.generateKey(id);
	Cache.ValueWrapper valueWrapper = defaultCache.get(key);
	if (valueWrapper != null) {
		throw new AssertionError("Value with key " + key + " expected to be already remove from cache");
	}
}
 

@Override
protected CacheRemoveOperation createSimpleOperation() {
	CacheMethodDetails<CacheRemove> methodDetails = create(CacheRemove.class,
			SampleObject.class, "simpleRemove", Long.class);

	return new CacheRemoveOperation(methodDetails, defaultCacheResolver, defaultKeyGenerator);
}
 

protected CacheRemoveOperation createCacheRemoveOperation(Method method, @Nullable 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);
}
 

@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 CacheRemoveOperation(
		CacheMethodDetails<CacheRemove> methodDetails, CacheResolver cacheResolver, KeyGenerator keyGenerator) {

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

@Override
protected CacheRemoveOperation createSimpleOperation() {
	CacheMethodDetails<CacheRemove> methodDetails = create(CacheRemove.class,
			SampleObject.class, "simpleRemove", Long.class);

	return new CacheRemoveOperation(methodDetails, defaultCacheResolver, defaultKeyGenerator);
}
 

@Override
@CacheRemove(afterInvocation = false)
public void earlyRemove(String id) {
	Object key = SimpleKeyGenerator.generateKey(id);
	Cache.ValueWrapper valueWrapper = defaultCache.get(key);
	if (valueWrapper != null) {
		throw new AssertionError("Value with key " + key + " expected to be already remove from cache");
	}
}
 

protected CacheRemoveOperation createCacheRemoveOperation(Method method, @Nullable 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);
}
 

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

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

@Override
@CacheRemove(afterInvocation = false)
public void earlyRemove(String id) {
	Object key = SimpleKeyGenerator.generateKey(id);
	Cache.ValueWrapper valueWrapper = defaultCache.get(key);
	if (valueWrapper != null) {
		throw new AssertionError("Value with key " + key + " expected to be already remove from cache");
	}
}
 

private MethodMeta createMeta(final InvocationContext ic)
{
    final CacheDefaults defaults = findDefaults(ic.getTarget() == null ? null : ic.getTarget()
                                                  .getClass(), ic.getMethod());

    final Class<?>[] parameterTypes = ic.getMethod().getParameterTypes();
    final Annotation[][] parameterAnnotations = ic.getMethod().getParameterAnnotations();
    final List<Set<Annotation>> annotations = new ArrayList<>();
    for (final Annotation[] parameterAnnotation : parameterAnnotations)
    {
        final Set<Annotation> set = new HashSet<>(parameterAnnotation.length);
        set.addAll(Arrays.asList(parameterAnnotation));
        annotations.add(set);
    }

    final Set<Annotation> mtdAnnotations = new HashSet<>();
    mtdAnnotations.addAll(Arrays.asList(ic.getMethod().getAnnotations()));

    final CacheResult cacheResult = ic.getMethod().getAnnotation(CacheResult.class);
    final String cacheResultCacheResultName = cacheResult == null ? null : defaultName(ic.getMethod(), defaults, cacheResult.cacheName());
    final CacheResolverFactory cacheResultCacheResolverFactory = cacheResult == null ?
            null : cacheResolverFactoryFor(defaults, cacheResult.cacheResolverFactory());
    final CacheKeyGenerator cacheResultCacheKeyGenerator = cacheResult == null ?
            null : cacheKeyGeneratorFor(defaults, cacheResult.cacheKeyGenerator());

    final CachePut cachePut = ic.getMethod().getAnnotation(CachePut.class);
    final String cachePutCachePutName = cachePut == null ? null : defaultName(ic.getMethod(), defaults, cachePut.cacheName());
    final CacheResolverFactory cachePutCacheResolverFactory = cachePut == null ?
            null : cacheResolverFactoryFor(defaults, cachePut.cacheResolverFactory());
    final CacheKeyGenerator cachePutCacheKeyGenerator = cachePut == null ?
            null : cacheKeyGeneratorFor(defaults, cachePut.cacheKeyGenerator());

    final CacheRemove cacheRemove = ic.getMethod().getAnnotation(CacheRemove.class);
    final String cacheRemoveCacheRemoveName = cacheRemove == null ? null : defaultName(ic.getMethod(), defaults, cacheRemove.cacheName());
    final CacheResolverFactory cacheRemoveCacheResolverFactory = cacheRemove == null ?
            null : cacheResolverFactoryFor(defaults, cacheRemove.cacheResolverFactory());
    final CacheKeyGenerator cacheRemoveCacheKeyGenerator = cacheRemove == null ?
            null : cacheKeyGeneratorFor(defaults, cacheRemove.cacheKeyGenerator());

    final CacheRemoveAll cacheRemoveAll = ic.getMethod().getAnnotation(CacheRemoveAll.class);
    final String cacheRemoveAllCacheRemoveAllName = cacheRemoveAll == null ? null : defaultName(ic.getMethod(), defaults, cacheRemoveAll.cacheName());
    final CacheResolverFactory cacheRemoveAllCacheResolverFactory = cacheRemoveAll == null ?
            null : cacheResolverFactoryFor(defaults, cacheRemoveAll.cacheResolverFactory());

    return new MethodMeta(
            parameterTypes,
            annotations,
            mtdAnnotations,
            keyParameterIndexes(ic.getMethod()),
            getValueParameter(annotations),
            getKeyParameters(annotations),
            cacheResultCacheResultName,
            cacheResultCacheResolverFactory,
            cacheResultCacheKeyGenerator,
            cacheResult,
            cachePutCachePutName,
            cachePutCacheResolverFactory,
            cachePutCacheKeyGenerator,
            cachePut != null && cachePut.afterInvocation(),
            cachePut,
            cacheRemoveCacheRemoveName,
            cacheRemoveCacheResolverFactory,
            cacheRemoveCacheKeyGenerator,
            cacheRemove != null && cacheRemove.afterInvocation(),
            cacheRemove,
            cacheRemoveAllCacheRemoveAllName,
            cacheRemoveAllCacheResolverFactory,
            cacheRemoveAll != null && cacheRemoveAll.afterInvocation(),
            cacheRemoveAll);
}
 

@Override
@CacheRemove(cacheName = "conference" )
public void delete(final Conference conf) {
	entityManager.remove(entityManager.merge(conf));
	entityManager.flush();
}
 

@Override
@CacheRemove(cacheName = "conference" )
public void delete(final Long id) {
	entityManager.remove(entityManager.find(Conference.class, id));
	entityManager.flush();
}
 

@Override
@CacheRemove(afterInvocation = false, evictFor = UnsupportedOperationException.class)
public void earlyRemoveWithException(@CacheKey String id, boolean matchFilter) {
	throwException(matchFilter);
}
 

public CacheRemove getCacheRemove()
{
    return cacheRemove;
}
 

@Override
@CacheRemove(noEvictFor = NullPointerException.class)
public void removeWithException(@CacheKey String id, boolean matchFilter) {
	throwException(matchFilter);
}
 

@Override
@CacheRemove
public void remove(String id) {
}
 

@Override
@CacheRemove(afterInvocation = false, evictFor = UnsupportedOperationException.class)
public void earlyRemoveWithException(@CacheKey String id, boolean matchFilter) {
	throwException(matchFilter);
}