javax.cache.annotation.CacheRemoveAll Java Examples

@Override
@CacheRemoveAll(afterInvocation = false)
public void earlyRemoveAll() {
	ConcurrentHashMap<?, ?> nativeCache = (ConcurrentHashMap<?, ?>) defaultCache.getNativeCache();
	if (!nativeCache.isEmpty()) {
		throw new AssertionError("Cache was expected to be empty");
	}
}
 

/**
 * This just illustrates how easily we could discover a runtime annotation.
 */
@Test
public void testAnnotations() {
  Object value = new CacheNameOnEachMethodBlogManagerImpl();
  boolean foundRemoveAllAnnotation = false;
  for (Method m : value.getClass().getMethods()) {
    if (m.isAnnotationPresent(CacheRemoveAll.class)) {
      System.out.println(m.getName());
      foundRemoveAllAnnotation = true;
    }
  }
  assertTrue(foundRemoveAllAnnotation);
}
 

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
@CacheRemoveAll(cacheName = "conference")
public void deleteAll() {
	List<Conference> all = entityManager.createQuery("from Conference",
			Conference.class).getResultList();
	for (Conference c : all) {
		delete(c);
	}
	entityManager.flush();
}
 

@Override
@CacheRemoveAll(afterInvocation = false)
public void earlyRemoveAll() {
	ConcurrentHashMap<?, ?> nativeCache = (ConcurrentHashMap<?, ?>) defaultCache.getNativeCache();
	if (!nativeCache.isEmpty()) {
		throw new AssertionError("Cache was expected to be empty");
	}
}
 

@Override
@CacheRemoveAll(afterInvocation = false)
public void earlyRemoveAll() {
	ConcurrentHashMap<?, ?> nativeCache = (ConcurrentHashMap<?, ?>) defaultCache.getNativeCache();
	if (!nativeCache.isEmpty()) {
		throw new AssertionError("Cache was expected to be empty");
	}
}
 

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

	return new CacheRemoveAllOperation(methodDetails, defaultCacheResolver);
}
 

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

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

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

@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
@CacheRemoveAll(afterInvocation = false)
public void earlyRemoveAll() {
	ConcurrentHashMap<?, ?> nativeCache = (ConcurrentHashMap<?, ?>) defaultCache.getNativeCache();
	if (!nativeCache.isEmpty()) {
		throw new AssertionError("Cache was expected to be empty");
	}
}
 

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

	return new CacheRemoveAllOperation(methodDetails, defaultCacheResolver);
}
 

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

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

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

@Override
@CacheRemoveAll(afterInvocation = false)
public void earlyRemoveAll() {
	ConcurrentHashMap<?, ?> nativeCache = (ConcurrentHashMap<?, ?>) defaultCache.getNativeCache();
	if (!nativeCache.isEmpty()) {
		throw new AssertionError("Cache was expected to be empty");
	}
}
 

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

@Override
@CacheRemoveAll(afterInvocation = false)
public void earlyRemoveAll() {
	ConcurrentHashMap<?, ?> nativeCache = (ConcurrentHashMap<?, ?>) defaultCache.getNativeCache();
	if (!nativeCache.isEmpty()) {
		throw new AssertionError("Cache was expected to be empty");
	}
}
 

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

	return new CacheRemoveAllOperation(methodDetails, defaultCacheResolver);
}
 

@CacheRemoveAll(cacheName = "simpleCache")
public void simpleRemoveAll() {
}
 

@Override
@CacheRemoveAll
public void removeAll() {
}
 

@CacheRemove
@CacheRemoveAll
public void multiAnnotations() {
}
 

@CacheRemoveAll
public void clear() {
}
 

@Override
@CacheRemoveAll
public void removeAll() {
}
 

@Override
@CacheRemoveAll(noEvictFor = NullPointerException.class)
public void removeAllWithException(boolean matchFilter) {
	throwException(matchFilter);
}
 

@CacheRemoveAll
public void clear() {
}
 

@Override
@CacheRemoveAll(afterInvocation = false, evictFor = UnsupportedOperationException.class)
public void earlyRemoveAllWithException(boolean matchFilter) {
	throwException(matchFilter);
}
 

@Override
@CacheRemoveAll
public void removeAll() {
}
 

@Override
@CacheRemoveAll(noEvictFor = NullPointerException.class)
public void removeAllWithException(boolean matchFilter) {
	throwException(matchFilter);
}