#361 - Add support for resolving values in request mappings

Original pull-request: #391

Author: Josh Ghiloni

src/main/java/org/springframework/hateoas/core/AnnotationMappingDiscoverer.java

@@ -75,7 +75,7 @@ public String getMapping(Class<?> type) {
 		return mapping.length == 0 ? null : mapping[0];
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.hateoas.core.MappingDiscoverer#getMapping(java.lang.reflect.Method)
 	 */
@@ -86,7 +86,7 @@ public String getMapping(Method method) {
 		return getMapping(method.getDeclaringClass(), method);
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.hateoas.core.MappingDiscoverer#getMapping(java.lang.Class, java.lang.reflect.Method)
 	 */

src/main/java/org/springframework/hateoas/core/MappingDiscoverer.java

@@ -21,6 +21,8 @@
  * Strategy interface to discover a URI mapping for either a given type or method.
  * 
  * @author Oliver Gierke
+ * @author Josh Ghiloni
+ * @author Greg Turnquist
  */
 public interface MappingDiscoverer {
 
@@ -36,7 +38,7 @@ public interface MappingDiscoverer {
 	 * Returns the mapping associated with the given {@link Method}. This will include the type-level mapping.
 	 * 
 	 * @param method must not be {@literal null}.
-	 * @return the method mapping including the type-level one or {@literal null} if neither of them present.
+	 * @return the method mapping including the type-level one or {@literal null} if neither are present.
 	 */
 	String getMapping(Method method);
 
@@ -49,4 +51,5 @@ public interface MappingDiscoverer {
 	 * @return the method mapping including the type-level one or {@literal null} if neither of them present.
 	 */
 	String getMapping(Class<?> type, Method method);
+
 }

src/main/java/org/springframework/hateoas/core/PropertyResolvingDiscoverer.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2017 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.hateoas.core;
+
+import java.lang.reflect.Method;
+
+import org.springframework.core.env.PropertyResolver;
+import org.springframework.util.Assert;
+
+/**
+ * Take any other {@link MappingDiscoverer} and wrap it with an attempt to resolve properties via {@link PropertyResolver}.
+ *
+ * @author Greg Turnquist
+ */
+public class PropertyResolvingDiscoverer implements MappingDiscoverer {
+
+	private final MappingDiscoverer discoverer;
+	private final PropertyResolver resolver;
+
+	public PropertyResolvingDiscoverer(MappingDiscoverer discoverer, PropertyResolver resolver) {
+
+		Assert.notNull(discoverer, "MappingDiscoverer must not be null!");
+		Assert.notNull(resolver, "PropertyResolver must not be null!");
+		this.discoverer = discoverer;
+		this.resolver = resolver;
+	}
+
+	/**
+	 * Returns the mapping associated with the given type.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @return the type-level mapping or {@literal null} in case none is present.
+	 */
+	@Override
+	public String getMapping(Class<?> type) {
+		return attemptToResolve(resolver, this.discoverer.getMapping(type));
+	}
+
+	/**
+	 * Returns the mapping associated with the given {@link Method}. This will include the type-level mapping.
+	 *
+	 * @param method must not be {@literal null}.
+	 * @return the method mapping including the type-level one or {@literal null} if neither of them present.
+	 */
+	@Override
+	public String getMapping(Method method) {
+		return attemptToResolve(resolver, this.discoverer.getMapping(method));
+	}
+
+	/**
+	 * Returns the mapping for the given {@link Method} invoked on the given type. This can be used to calculate the
+	 * mapping for a super type method being invoked on a sub-type with a type mapping.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @param method must not be {@literal null}.
+	 * @return the method mapping including the type-level one or {@literal null} if neither of them present.
+	 */
+	@Override
+	public String getMapping(Class<?> type, Method method) {
+		return attemptToResolve(resolver, this.discoverer.getMapping(type, method));
+	}
+
+	/**
+	 * Use the {@link PropertyResolver} to substitute values into the link.
+	 *
+	 * @param resolver
+	 * @param value
+	 * @return
+	 */
+	private String attemptToResolve(PropertyResolver resolver, String value) {
+		return resolver.resolvePlaceholders(value);
+	}
+}

src/main/java/org/springframework/hateoas/mvc/ControllerLinkBuilder.java

@@ -18,7 +18,6 @@
 import static org.springframework.util.StringUtils.*;
 
 import lombok.RequiredArgsConstructor;
-import lombok.experimental.Delegate;
 
 import java.lang.reflect.Method;
 import java.net.URI;
@@ -53,16 +52,19 @@
  * @author Kevin Conaway
  * @author Andrew Naydyonock
  * @author Oliver Trosien
+ * @author Josh Ghiloni
  * @author Greg Turnquist
  */
 public class ControllerLinkBuilder extends LinkBuilderSupport<ControllerLinkBuilder> {
 
 	private static final String REQUEST_ATTRIBUTES_MISSING = "Could not find current request via RequestContextHolder. Is this being called from a Spring MVC handler?";
 	private static final CachingAnnotationMappingDiscoverer DISCOVERER = new CachingAnnotationMappingDiscoverer(
-			new AnnotationMappingDiscoverer(RequestMapping.class));
+		new AnnotationMappingDiscoverer(RequestMapping.class));
 	private static final ControllerLinkBuilderFactory FACTORY = new ControllerLinkBuilderFactory();
 	private static final CustomUriTemplateHandler HANDLER = new CustomUriTemplateHandler();
 
+	private static MappingDiscoverer delegateDiscovererOverride = null;
+
 	private final TemplateVariables variables;
 
 	/**
@@ -78,19 +80,25 @@ public class ControllerLinkBuilder extends LinkBuilderSupport<ControllerLinkBuil
 	}
 
 	/**
-	 * Creates a new {@link ControllerLinkBuilder} using the given {@link UriComponents}.
+	 * Creates a new {@link ControllerLinkBuilder} using the given {@link UriComponents}, {@link TemplateVariables}, and
+	 * {@link MappingDiscoverer}.
 	 *
 	 * @param uriComponents must not be {@literal null}.
 	 */
-	ControllerLinkBuilder(UriComponents uriComponents) {
-		this(uriComponents, TemplateVariables.NONE);
-	}
-
-	ControllerLinkBuilder(UriComponents uriComponents, TemplateVariables variables) {
+	ControllerLinkBuilder(UriComponents uriComponents, TemplateVariables variables, MappingDiscoverer discoverer) {
 
 		super(uriComponents);
 
 		this.variables = variables;
+		this.delegateDiscovererOverride = discoverer;
+	}
+
+	public static void setDelegateDiscoverer(MappingDiscoverer discoverer) {
+		delegateDiscovererOverride = discoverer;
+	}
+
+	public static void clearDelegateDiscoverer() {
+		delegateDiscovererOverride = null;
 	}
 
 	/**
@@ -304,12 +312,20 @@ private static HttpServletRequest getCurrentRequest() {
 	@RequiredArgsConstructor
 	private static class CachingAnnotationMappingDiscoverer implements MappingDiscoverer {
 
-		private final @Delegate AnnotationMappingDiscoverer delegate;
+		private final AnnotationMappingDiscoverer delegate;
 		private final Map<String, UriTemplate> templates = new ConcurrentReferenceHashMap<String, UriTemplate>();
 
+		/**
+		 * If {@link ControllerLinkBuilder} has a static {@link MappingDiscoverer}, use it instead of the delegate.
+		 * @return
+		 */
+		private MappingDiscoverer getDelegate() {
+			return (delegateDiscovererOverride != null) ? delegateDiscovererOverride : this.delegate;
+		}
+
 		public UriTemplate getMappingAsUriTemplate(Class<?> type, Method method) {
 
-			String mapping = delegate.getMapping(type, method);
+			String mapping = getDelegate().getMapping(type, method);
 
 			UriTemplate template = templates.get(mapping);
 
@@ -320,6 +336,41 @@ public UriTemplate getMappingAsUriTemplate(Class<?> type, Method method) {
 
 			return template;
 		}
+
+		/**
+		 * Returns the mapping associated with the given type.
+		 *
+		 * @param type must not be {@literal null}.
+		 * @return the type-level mapping or {@literal null} in case none is present.
+		 */
+		@Override
+		public String getMapping(Class<?> type) {
+			return getDelegate().getMapping(type);
+		}
+
+		/**
+		 * Returns the mapping associated with the given {@link Method}. This will include the type-level mapping.
+		 *
+		 * @param method must not be {@literal null}.
+		 * @return the method mapping including the type-level one or {@literal null} if neither of them present.
+		 */
+		@Override
+		public String getMapping(Method method) {
+			return getDelegate().getMapping(method);
+		}
+
+		/**
+		 * Returns the mapping for the given {@link Method} invoked on the given type. This can be used to calculate the
+		 * mapping for a super type method being invoked on a sub-type with a type mapping.
+		 *
+		 * @param type must not be {@literal null}.
+		 * @param method must not be {@literal null}.
+		 * @return the method mapping including the type-level one or {@literal null} if neither of them present.
+		 */
+		@Override
+		public String getMapping(Class<?> type, Method method) {
+			return getDelegate().getMapping(type, method);
+		}
 	}
 
 	private static class CustomUriTemplateHandler extends DefaultUriTemplateHandler {

src/main/java/org/springframework/hateoas/mvc/ControllerLinkBuilderFactory.java

@@ -64,16 +64,26 @@
  * @author Oemer Yildiz
  * @author Kevin Conaway
  * @author Andrew Naydyonock
+ * @author Josh Ghiloni
+ * @author Greg Turnquist
  */
 public class ControllerLinkBuilderFactory implements MethodLinkBuilderFactory<ControllerLinkBuilder> {
 
-	private static final MappingDiscoverer DISCOVERER = new AnnotationMappingDiscoverer(RequestMapping.class);
 	private static final AnnotatedParametersParameterAccessor PATH_VARIABLE_ACCESSOR = new AnnotatedParametersParameterAccessor(
 			new AnnotationAttribute(PathVariable.class));
 	private static final AnnotatedParametersParameterAccessor REQUEST_PARAM_ACCESSOR = new RequestParamParameterAccessor();
 
+	private MappingDiscoverer discoverer;
 	private List<UriComponentsContributor> uriComponentsContributors = new ArrayList<UriComponentsContributor>();
 
+	public ControllerLinkBuilderFactory() {
+		this.discoverer = new AnnotationMappingDiscoverer(RequestMapping.class);
+	}
+
+	public ControllerLinkBuilderFactory(MappingDiscoverer discoverer) {
+		this.discoverer = discoverer;
+	}
+
 	/**
 	 * Configures the {@link UriComponentsContributor} to be used when building {@link Link} instances from method
 	 * invocations.
@@ -135,7 +145,7 @@ public ControllerLinkBuilder linkTo(Object invocationValue) {
 		Iterator<Object> classMappingParameters = invocations.getObjectParameters();
 		Method method = invocation.getMethod();
 
-		String mapping = DISCOVERER.getMapping(invocation.getTargetType(), method);
+		String mapping = this.discoverer.getMapping(invocation.getTargetType(), method);
 		UriComponentsBuilder builder = ControllerLinkBuilder.getBuilder().path(mapping);
 
 		UriTemplate template = new UriTemplate(mapping);
@@ -183,7 +193,7 @@ public ControllerLinkBuilder linkTo(Object invocationValue) {
 			variables = variables.concat(variable);
 		}
 
-		return new ControllerLinkBuilder(components, variables);
+		return new ControllerLinkBuilder(components, variables, discoverer);
 	}
 
 	/* 

src/test/java/org/springframework/hateoas/core/AnnotationMappingDiscovererUnitTest.java

@@ -19,8 +19,12 @@
 import static org.junit.Assert.*;
 
 import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.junit.Test;
+import org.springframework.core.env.MapPropertySource;
+import org.springframework.core.env.StandardEnvironment;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 
@@ -30,10 +34,12 @@
  * @author Oliver Gierke
  * @author Kevin Conaway
  * @author Mark Paluch
+ * @author Josh Ghiloni
+ * @author Greg Turnquist
  */
 public class AnnotationMappingDiscovererUnitTest {
 
-	MappingDiscoverer discoverer = new AnnotationMappingDiscoverer(RequestMapping.class);
+	AnnotationMappingDiscoverer discoverer = new AnnotationMappingDiscoverer(RequestMapping.class);
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNullAnnotation() {
@@ -151,6 +157,35 @@ public void discoversMethodLevelMappingUsingComposedAnnotation() throws Exceptio
 		assertThat(discoverer.getMapping(method), is("/type/otherMethod"));
 	}
 
+	/**
+	 * @see #361
+	 */
+	@Test
+	public void resolvesVariablesInMappings() throws NoSuchMethodException {
+
+		Map<String, Object> source = new HashMap<String, Object>();
+		source.put("test.variable", "dynamicparent");
+		source.put("test.child", "dynamicchild");
+
+		StandardEnvironment env = new StandardEnvironment();
+		env.getPropertySources().addLast(new MapPropertySource("mapping-env", source));
+
+		Method method = DynamicEndpointControllerWithMethod.class.getMethod("method");
+
+		// Test regression first
+		assertThat(discoverer.getMapping(DynamicEndpointController.class), is("/${test.variable}"));
+		assertThat(discoverer.getMapping(DynamicEndpointControllerWithMethod.class, method),
+			is("/${test.variable}/${test.child}"));
+
+		// Test property substitution
+		PropertyResolvingDiscoverer propertyResolvingDiscoverer = new PropertyResolvingDiscoverer(discoverer, env);
+
+		assertThat(propertyResolvingDiscoverer.getMapping(DynamicEndpointController.class), is("/dynamicparent"));
+		assertThat(propertyResolvingDiscoverer.getMapping(method), is("/dynamicparent/dynamicchild"));
+		assertThat(propertyResolvingDiscoverer.getMapping(DynamicEndpointControllerWithMethod.class, method),
+			is("/dynamicparent/dynamicchild"));
+	}
+
 	@RequestMapping("/type")
 	interface MyController {
 
@@ -230,4 +265,14 @@ interface MultipleMappingsController {
 		@RequestMapping({ "/method", "/methodAlias" })
 		void method();
 	}
+
+	@RequestMapping("/${test.variable}")
+	interface DynamicEndpointController {}
+
+	@RequestMapping("/${test.variable}")
+	interface DynamicEndpointControllerWithMethod {
+
+		@RequestMapping("/${test.child}")
+		void method();
+	}
 }