import javax.cache.annotation.CachePut; //导入依赖的package包/类
/**
 * Save or update a setting and return the corresponding identifier.
 * 
 * @param name
 *            the configuration name.
 * @param value
 *            the new value.
 */
@POST
@PUT
@Path("{name}/{value}")
@CachePut(cacheName = "configuration")
public void saveOrUpdate(@CacheKey @PathParam("name") final String name, @CacheValue @PathParam("value") final String value) {
	final SystemConfiguration setting = repository.findByName(name);
	if (setting == null) {
		final SystemConfiguration entity = new SystemConfiguration();
		entity.setName(name);
		entity.setValue(cryptoHelper.encrypt(value));
		repository.saveAndFlush(entity);
	} else {
		setting.setValue(cryptoHelper.encrypt(value));
	}
}
 

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

	super(methodDetails, cacheResolver, keyGenerator);
	CachePut ann = methodDetails.getCacheAnnotation();
	this.exceptionTypeFilter = createExceptionTypeFilter(ann.cacheFor(), ann.noCacheFor());
	this.valueParameterDetail = initializeValueParameterDetail(methodDetails.getMethod(), this.allParameterDetails);
	if (this.valueParameterDetail == null) {
		throw new IllegalArgumentException("No parameter annotated with @CacheValue was found for " +
				"" + methodDetails.getMethod());
	}
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@Override
protected Object invoke(CacheOperationInvocationContext<CachePutOperation> context,
		CacheOperationInvoker invoker) {

	CacheKeyInvocationContext<CachePut> invocationContext = createCacheKeyInvocationContext(context);
	CachePutOperation operation = context.getOperation();

	boolean earlyPut = operation.isEarlyPut();
	Object value = invocationContext.getValueParameter().getValue();

	if (earlyPut) {
		cacheValue(context, value);
	}

	try {
		Object result = invoker.invoke();
		if (!earlyPut) {
			cacheValue(context, value);
		}
		return result;
	}
	catch (CacheOperationInvoker.ThrowableWrapper ex) {
		Throwable original = ex.getOriginal();
		if (!earlyPut && operation.getExceptionTypeFilter().match(original.getClass())) {
			cacheValue(context, value);
		}
		throw ex;
	}
}
 

import javax.cache.annotation.CachePut; //导入依赖的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.CachePut; //导入依赖的package包/类
protected CachePutOperation createCachePutOperation(Method method, CacheDefaults defaults, CachePut ann) {
	String cacheName = determineCacheName(method, defaults, ann.cacheName());
	CacheResolverFactory cacheResolverFactory =
			determineCacheResolverFactory(defaults, ann.cacheResolverFactory());
	KeyGenerator keyGenerator = determineKeyGenerator(defaults, ann.cacheKeyGenerator());

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

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@Test
public void noCacheValue() {
	CacheMethodDetails<CachePut> methodDetails = create(CachePut.class,
			SampleObject.class, "noCacheValue", Long.class);

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

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

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

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@Override
@CachePut(afterInvocation = false)
public void earlyPut(String id, @CacheValue Object value) {
	Object key = SimpleKeyGenerator.generateKey(id);
	Cache.ValueWrapper valueWrapper = defaultCache.get(key);
	if (valueWrapper == null) {
		throw new AssertionError("Excepted value to be put in cache with key " + key);
	}
	Object actual = valueWrapper.get();
	if (value != actual) { // instance check on purpose
		throw new AssertionError("Wrong value set in cache with key " + key + ". " +
				"Expected=" + value + ", but got=" + actual);
	}
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {

  final Method method = methodInvocation.getMethod();
  final CachePut annotation = method.getAnnotation(CachePut.class);
  checkNotNull(annotation);
  final CacheKeyInvocationContext<CachePut> context = new GuiceCacheKeyInvocationContext<>(methodInvocation, annotation, annotation.cacheName());

  LOGGER.trace("Cache PUT {}", context.getMethod().getName());

  // get cache
  final Cache<GeneratedCacheKey, Optional<?>> cache = getCache(context, methodInvocation);

  // get key
  final CacheKeyGenerator keyGenerator = getCacheKeyGenerator(methodInvocation, annotation.cacheKeyGenerator());
  final GeneratedCacheKey key = keyGenerator.generateCacheKey(context);

  // get value to cache
  final Object value = context.getValueParameter().getValue();

  if (!annotation.afterInvocation()) {
    cacheValue(key, value, cache);
  }

  final Object result = methodInvocation.proceed();

  if (annotation.afterInvocation()) {
    cacheValue(key, value, cache);
  }

  return result;
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@Override
@CachePut(cacheName = "conference" )
public Conference save(final Conference conference) {
	if (conference.isNew()) {
		entityManager.persist(conference);
		entityManager.flush();
		return conference;
	} else {
		Conference conf = entityManager.merge(conference);
		entityManager.flush();
		return conf;
	}
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@CachePut(cacheName = "simpleCache")
public void simplePut(Long id, @CacheValue SampleObject instance) {
}
 

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

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@CachePut(cacheName = "simpleCache")
public void multiCacheValues(Long id, @CacheValue SampleObject instance,
		@CacheValue SampleObject anotherInstance) {
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@CachePut(cacheName = "simpleCache", afterInvocation = false,
		cacheFor = Exception.class, noCacheFor = RuntimeException.class)
public void fullPutConfig(@CacheKey Long id, @CacheValue SampleObject instance) {
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@Override
protected CachePutOperation createSimpleOperation() {
	CacheMethodDetails<CachePut> methodDetails = create(CachePut.class,
			SampleObject.class, "simplePut", Long.class, SampleObject.class);
	return createDefaultOperation(methodDetails);
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
private CachePutOperation createDefaultOperation(CacheMethodDetails<CachePut> methodDetails) {
	return new CachePutOperation(methodDetails, defaultCacheResolver, defaultKeyGenerator);
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@CachePut
public void put(long id, @CacheValue Object object) {
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@Override
@CachePut
public void put(String id, @CacheValue Object value) {
}
 

import javax.cache.annotation.CachePut; //导入依赖的package包/类
@Override
@CachePut(cacheFor = UnsupportedOperationException.class)
public void putWithException(@CacheKey String id, @CacheValue Object value, boolean matchFilter) {
	throwException(matchFilter);
}