import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
/**
 * Delete a {@link SystemConfiguration}
 * 
 * @param name
 *            The configuration name to delete.
 */
@DELETE
@Path("{name}")
@CacheRemove(cacheName = "configuration")
public void delete(@CacheKey @PathParam("name") final String name) {
	repository.deleteAllBy("name", name);
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
public CacheRemoveOperation(
		CacheMethodDetails<CacheRemove> methodDetails, CacheResolver cacheResolver, KeyGenerator keyGenerator) {

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

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@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);
	}
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
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);
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@Override
protected CacheRemoveOperation createSimpleOperation() {
	CacheMethodDetails<CacheRemove> methodDetails = create(CacheRemove.class,
			SampleObject.class, "simpleRemove", Long.class);

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

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@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");
	}
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove(cacheName = "simpleCache")
public void simpleRemove(Long id) {
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove
@CacheRemoveAll
public void multiAnnotations() {
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove
public void evict(long id) {
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@Override
@CacheRemove
public void remove(String id) {
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@Override
@CacheRemove(noEvictFor = NullPointerException.class)
public void removeWithException(@CacheKey String id, boolean matchFilter) {
	throwException(matchFilter);
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@Override
@CacheRemove(afterInvocation = false, evictFor = UnsupportedOperationException.class)
public void earlyRemoveWithException(@CacheKey String id, boolean matchFilter) {
	throwException(matchFilter);
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove
public void clear(@CacheKey String key) {
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove(cacheName = "heavyComputation")
public void updateDataset(){
    LOG.info("updateDataset");
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove(cacheName = "users")
public void removeUser(@CacheKey String name) {
    //...
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove
@Override
public void delete(@CacheKey Object parentKey, @CacheKey java.lang.String id) throws IOException {
  super.delete(parentKey, id);
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove
@Override
public void delete(@CacheKey Object parentKey, @CacheKey java.lang.Long id) throws IOException {
  super.delete(parentKey, id);
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@Override
@CacheRemove
public boolean removeBook(Long id) {
	return delegate.removeBook(id);
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@CacheRemove
public void deletePerson(@CacheKey int id) {
	System.out.println("Removing");
	database.removeIf(p -> p.getId() == id);
}
 

import javax.cache.annotation.CacheRemove; //导入依赖的package包/类
@Override
@CacheRemove(cacheName = "conference" )
public void delete(final Long id) {
	entityManager.remove(entityManager.find(Conference.class, id));
	entityManager.flush();
}