Add JSR-107 cache annotations support

This commit adds support for the JSR-107 cache annotations alongside
the Spring's cache annotations, that is @CacheResult, @CachePut,
@CacheRemove and @CacheRemoveAll as well as related annotations
@CacheDefaults, @CacheKey and @CacheValue.

Spring's caching configuration infrastructure detects the presence of
the JSR-107 API and Spring's JCache implementation. Both
@EnableCaching and the cache namespace are able to configure the
required JCache infrastructure when necessary. Both proxy mode
and AspectJ mode are supported.

As JSR-107 permits the customization of the CacheResolver to use for
both regular and exception caches, JCacheConfigurer has been
introduced as an extension of CachingConfigurer and permits to define
those.

If an exception is cached and should be rethrown, it is cloned and
the call stack is rewritten so that it matches the calling thread each
time. If the exception cannot be cloned, the original exception is
returned.

Internally, the interceptors uses Spring's caching abstraction by default
with an adapter layer when a JSR-107 component needs to be called.
This is the case for CacheResolver and CacheKeyGenerator.

The implementation uses Spring's CacheManager abstraction behind the
scene. The standard annotations can therefore be used against any
CacheManager implementation.

Issue: SPR-9616

spring-core/src/test/java/org/springframework/util/filter/ExceptionTypeFilterTests.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.util.filter;
+
+import static java.util.Arrays.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+/**
+ * @author Stephane Nicoll
+ */
+public class ExceptionTypeFilterTests {
+
+	@Test
+	public void subClassMatch() {
+		ExceptionTypeFilter filter = new ExceptionTypeFilter(
+				asList(RuntimeException.class), null, true);
+		assertTrue(filter.match(RuntimeException.class));
+		assertTrue(filter.match(IllegalStateException.class));
+	}
+
+}

spring-core/src/test/java/org/springframework/util/filter/InstanceFilterTests.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2002-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.util.filter;
+
+import static java.util.Arrays.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+/**
+ * @author Stephane Nicoll
+ */
+public class InstanceFilterTests {
+
+	@Test
+	public void emptyFilterApplyMatchIfEmpty() {
+		InstanceFilter<String> filter = new InstanceFilter<String>(null, null, true);
+		match(filter, "foo");
+		match(filter, "bar");
+	}
+
+	@Test
+	public void includesFilter() {
+		InstanceFilter<String> filter = new InstanceFilter<String>(
+				asList("First", "Second"), null, true);
+		match(filter, "Second");
+		doNotMatch(filter, "foo");
+	}
+
+	@Test
+	public void excludesFilter() {
+		InstanceFilter<String> filter = new InstanceFilter<String>(
+				null, asList("First", "Second"), true);
+		doNotMatch(filter, "Second");
+		match(filter, "foo");
+	}
+
+	@Test
+	public void includesAndExcludesFilters() {
+		InstanceFilter<String> filter = new InstanceFilter<String>(
+				asList("foo", "Bar"), asList("First", "Second"), true);
+		doNotMatch(filter, "Second");
+		match(filter, "foo");
+	}
+
+	@Test
+	public void includesAndExcludesFiltersConflict() {
+		InstanceFilter<String> filter = new InstanceFilter<String>(
+				asList("First"), asList("First"), true);
+		doNotMatch(filter, "First");
+	}
+
+	private <T> void match(InstanceFilter<T> filter, T candidate) {
+		assertTrue("filter '" + filter + "' should match " + candidate, filter.match(candidate));
+	}
+
+	private <T> void doNotMatch(InstanceFilter<T> filter, T candidate) {
+		assertFalse("filter '" + filter + "' should not match " + candidate, filter.match(candidate));
+	}
+
+}