javax.cache.annotation.CacheInvocationParameter Java Examples

@SuppressWarnings("unchecked")
private static Object doGenerate(KeyGenerator keyGenerator, CacheKeyInvocationContext<?> context) {
	List<Object> parameters = new ArrayList<Object>();
	for (CacheInvocationParameter param : context.getKeyParameters()) {
		Object value = param.getValue();
		if (param.getParameterPosition() == context.getAllParameters().length - 1 &&
				context.getMethod().isVarArgs()) {
			parameters.addAll((List<Object>) CollectionUtils.arrayToList(value));
		}
		else {
			parameters.add(value);
		}
	}
	return keyGenerator.generate(context.getTarget(), context.getMethod(),
			parameters.toArray(new Object[parameters.size()]));

}
 

@SuppressWarnings("unchecked")
private static Object doGenerate(KeyGenerator keyGenerator, CacheKeyInvocationContext<?> context) {
	List<Object> parameters = new ArrayList<Object>();
	for (CacheInvocationParameter param : context.getKeyParameters()) {
		Object value = param.getValue();
		if (param.getParameterPosition() == context.getAllParameters().length - 1 &&
				context.getMethod().isVarArgs()) {
			parameters.addAll((List<Object>) CollectionUtils.arrayToList(value));
		}
		else {
			parameters.add(value);
		}
	}
	return keyGenerator.generate(context.getTarget(), context.getMethod(),
			parameters.toArray(new Object[parameters.size()]));

}
 

@Test
public void simpleGet() {
	CacheResultOperation operation = createSimpleOperation();

	assertNotNull(operation.getKeyGenerator());
	assertNotNull(operation.getExceptionCacheResolver());

	assertNull(operation.getExceptionCacheName());
	assertEquals(defaultExceptionCacheResolver, operation.getExceptionCacheResolver());

	CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
	assertEquals(1, allParameters.length);
	assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);

	CacheInvocationParameter[] keyParameters = operation.getKeyParameters(2L);
	assertEquals(1, keyParameters.length);
	assertCacheInvocationParameter(keyParameters[0], Long.class, 2L, 0);
}
 

@Test
public void simpleGet() {
	CacheResultOperation operation = createSimpleOperation();

	assertNotNull(operation.getKeyGenerator());
	assertNotNull(operation.getExceptionCacheResolver());

	assertNull(operation.getExceptionCacheName());
	assertEquals(defaultExceptionCacheResolver, operation.getExceptionCacheResolver());

	CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
	assertEquals(1, allParameters.length);
	assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);

	CacheInvocationParameter[] keyParameters = operation.getKeyParameters(2L);
	assertEquals(1, keyParameters.length);
	assertCacheInvocationParameter(keyParameters[0], Long.class, 2L, 0);
}
 

@Test
public void simpleGet() {
	CacheResultOperation operation = createSimpleOperation();

	assertNotNull(operation.getKeyGenerator());
	assertNotNull(operation.getExceptionCacheResolver());

	assertNull(operation.getExceptionCacheName());
	assertEquals(defaultExceptionCacheResolver, operation.getExceptionCacheResolver());

	CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
	assertEquals(1, allParameters.length);
	assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);

	CacheInvocationParameter[] keyParameters = operation.getKeyParameters(2L);
	assertEquals(1, keyParameters.length);
	assertCacheInvocationParameter(keyParameters[0], Long.class, 2L, 0);
}
 

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

@Override
public CacheInvocationParameter[] getAllParameters(Object... values) {
	if (this.allParameterDetails.size() != values.length) {
		throw new IllegalStateException("Values mismatch, operation has " +
				this.allParameterDetails.size() + " parameter(s) but got " + values.length + " value(s)");
	}
	List<CacheInvocationParameter> result = new ArrayList<CacheInvocationParameter>();
	for (int i = 0; i < this.allParameterDetails.size(); i++) {
		result.add(this.allParameterDetails.get(i).toCacheInvocationParameter(values[i]));
	}
	return result.toArray(new CacheInvocationParameter[result.size()]);
}
 

/**
 * Return the {@link CacheInvocationParameter} for the parameters that are to be
 * used to compute the key.
 * <p>Per the spec, if some method parameters are annotated with
 * {@link javax.cache.annotation.CacheKey}, only those parameters should be part
 * of the key. If none are annotated, all parameters except the parameter annotated
 * with {@link javax.cache.annotation.CacheValue} should be part of the key.
 * <p>The method arguments must match the signature of the related method invocation
 * @param values the parameters value for a particular invocation
 * @return the {@link CacheInvocationParameter} instances for the parameters to be
 * used to compute the key
 */
public CacheInvocationParameter[] getKeyParameters(Object... values) {
	List<CacheInvocationParameter> result = new ArrayList<CacheInvocationParameter>();
	for (CacheParameterDetail keyParameterDetail : this.keyParameterDetails) {
		int parameterPosition = keyParameterDetail.getParameterPosition();
		if (parameterPosition >= values.length) {
			throw new IllegalStateException("Values mismatch, key parameter at position "
					+ parameterPosition + " cannot be matched against " + values.length + " value(s)");
		}
		result.add(keyParameterDetail.toCacheInvocationParameter(values[parameterPosition]));
	}
	return result.toArray(new CacheInvocationParameter[result.size()]);
}
 

/**
 * Return the {@link CacheInvocationParameter} for the parameter holding the value
 * to cache.
 * <p>The method arguments must match the signature of the related method invocation
 * @param values the parameters value for a particular invocation
 * @return the {@link CacheInvocationParameter} instance for the value parameter
 */
public CacheInvocationParameter getValueParameter(Object... values) {
	int parameterPosition = this.valueParameterDetail.getParameterPosition();
	if (parameterPosition >= values.length) {
		throw new IllegalStateException("Values mismatch, value parameter at position " +
				parameterPosition + " cannot be matched against " + values.length + " value(s)");
	}
	return this.valueParameterDetail.toCacheInvocationParameter(values[parameterPosition]);
}
 

@Test
public void simpleRemove() {
	CacheRemoveOperation operation = createSimpleOperation();

	CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
	assertEquals(1, allParameters.length);
	assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
}
 

@Test
public void simplePut() {
	CachePutOperation operation = createSimpleOperation();

	CacheInvocationParameter[] allParameters = operation.getAllParameters(2L, sampleInstance);
	assertEquals(2, allParameters.length);
	assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
	assertCacheInvocationParameter(allParameters[1], SampleObject.class, sampleInstance, 1);

	CacheInvocationParameter valueParameter = operation.getValueParameter(2L, sampleInstance);
	assertNotNull(valueParameter);
	assertCacheInvocationParameter(valueParameter, SampleObject.class, sampleInstance, 1);
}
 

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

@Test
public void simplePut() {
	CachePutOperation operation = createSimpleOperation();

	CacheInvocationParameter[] allParameters = operation.getAllParameters(2L, sampleInstance);
	assertEquals(2, allParameters.length);
	assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
	assertCacheInvocationParameter(allParameters[1], SampleObject.class, sampleInstance, 1);

	CacheInvocationParameter valueParameter = operation.getValueParameter(2L, sampleInstance);
	assertNotNull(valueParameter);
	assertCacheInvocationParameter(valueParameter, SampleObject.class, sampleInstance, 1);
}
 

@Test
public void simpleRemoveAll() {
	CacheRemoveAllOperation operation = createSimpleOperation();

	CacheInvocationParameter[] allParameters = operation.getAllParameters();
	assertEquals(0, allParameters.length);
}
 

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

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

@Test
public void simpleRemoveAll() {
	CacheRemoveAllOperation operation = createSimpleOperation();

	CacheInvocationParameter[] allParameters = operation.getAllParameters();
	assertEquals(0, allParameters.length);
}
 

@Override
public GeneratedCacheKey
        generateCacheKey(final CacheKeyInvocationContext<? extends Annotation> cacheKeyInvocationContext) {
    return new GeneratedCacheKeyImpl(Stream
            .concat(Stream.of(cacheKeyInvocationContext.getKeyParameters()).map(CacheInvocationParameter::getValue),
                    getContextualKeys())
            .toArray(Object[]::new));
}
 

/**
 * Return the {@link CacheInvocationParameter} for the parameter holding the value
 * to cache.
 * <p>The method arguments must match the signature of the related method invocation
 * @param values the parameters value for a particular invocation
 * @return the {@link CacheInvocationParameter} instance for the value parameter
 */
public CacheInvocationParameter getValueParameter(Object... values) {
	int parameterPosition = this.valueParameterDetail.getParameterPosition();
	if (parameterPosition >= values.length) {
		throw new IllegalStateException("Values mismatch, value parameter at position " +
				parameterPosition + " cannot be matched against " + values.length + " value(s)");
	}
	return this.valueParameterDetail.toCacheInvocationParameter(values[parameterPosition]);
}
 

/**
 * Return the {@link CacheInvocationParameter} for the parameters that are to be
 * used to compute the key.
 * <p>Per the spec, if some method parameters are annotated with
 * {@link javax.cache.annotation.CacheKey}, only those parameters should be part
 * of the key. If none are annotated, all parameters except the parameter annotated
 * with {@link javax.cache.annotation.CacheValue} should be part of the key.
 * <p>The method arguments must match the signature of the related method invocation
 * @param values the parameters value for a particular invocation
 * @return the {@link CacheInvocationParameter} instances for the parameters to be
 * used to compute the key
 */
public CacheInvocationParameter[] getKeyParameters(Object... values) {
	List<CacheInvocationParameter> result = new ArrayList<CacheInvocationParameter>();
	for (CacheParameterDetail keyParameterDetail : this.keyParameterDetails) {
		int parameterPosition = keyParameterDetail.getParameterPosition();
		if (parameterPosition >= values.length) {
			throw new IllegalStateException("Values mismatch, key parameter at position "
					+ parameterPosition + " cannot be matched against " + values.length + " value(s)");
		}
		result.add(keyParameterDetail.toCacheInvocationParameter(values[parameterPosition]));
	}
	return result.toArray(new CacheInvocationParameter[result.size()]);
}
 

@Override
public CacheInvocationParameter[] getAllParameters(Object... values) {
	if (this.allParameterDetails.size() != values.length) {
		throw new IllegalStateException("Values mismatch, operation has " +
				this.allParameterDetails.size() + " parameter(s) but got " + values.length + " value(s)");
	}
	List<CacheInvocationParameter> result = new ArrayList<CacheInvocationParameter>();
	for (int i = 0; i < this.allParameterDetails.size(); i++) {
		result.add(this.allParameterDetails.get(i).toCacheInvocationParameter(values[i]));
	}
	return result.toArray(new CacheInvocationParameter[result.size()]);
}
 

@Test
public void simplePut() {
	CachePutOperation operation = createSimpleOperation();

	CacheInvocationParameter[] allParameters = operation.getAllParameters(2L, sampleInstance);
	assertEquals(2, allParameters.length);
	assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
	assertCacheInvocationParameter(allParameters[1], SampleObject.class, sampleInstance, 1);

	CacheInvocationParameter valueParameter = operation.getValueParameter(2L, sampleInstance);
	assertNotNull(valueParameter);
	assertCacheInvocationParameter(valueParameter, SampleObject.class, sampleInstance, 1);
}
 

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

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

@Test
public void simpleRemove() {
	CacheRemoveOperation operation = createSimpleOperation();

	CacheInvocationParameter[] allParameters = operation.getAllParameters(2L);
	assertEquals(1, allParameters.length);
	assertCacheInvocationParameter(allParameters[0], Long.class, 2L, 0);
}
 

@Test
public void simpleRemoveAll() {
	CacheRemoveAllOperation operation = createSimpleOperation();

	CacheInvocationParameter[] allParameters = operation.getAllParameters();
	assertEquals(0, allParameters.length);
}
 

@Override
public CacheInvocationParameter[] getAllParameters()
{
    if (parameters == null)
    {
        parameters = doGetAllParameters(null);
    }
    return parameters;
}
 

@Override
public GeneratedCacheKey generateCacheKey(final CacheKeyInvocationContext<? extends Annotation> cacheKeyInvocationContext)
{
    final CacheInvocationParameter[] keyParameters = cacheKeyInvocationContext.getKeyParameters();
    final Object[] parameters = new Object[keyParameters.length];
    for (int index = 0; index < keyParameters.length; index++)
    {
        parameters[index] = keyParameters[index].getValue();
    }
    return new GeneratedCacheKeyImpl(parameters);
}
 

@Override
public CacheInvocationParameter[] getKeyParameters()
{
    if (keyParams == null)
    {
        keyParams = doGetAllParameters(meta.getKeysIndices());
    }
    return keyParams;
}
 

@Override
public CacheInvocationParameter getValueParameter()
{
    if (valueParam == null)
    {
        valueParam = meta.getValueIndex() >= 0 ? doGetAllParameters(new Integer[]{meta.getValueIndex()})[0] : null;
    }
    return valueParam;
}