#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

@@ -81,7 +81,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)
 	 */
@@ -92,7 +92,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

@@ -25,6 +25,7 @@
  * given type or method.
  * 
  * @author Oliver Gierke
+ * @author Josh Ghiloni
  * @author Greg Turnquist
  */
 public interface MappingDiscoverer {
@@ -41,7 +42,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);
 

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

@@ -0,0 +1,94 @@
+/*
+ * 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 java.util.Collection;
+
+import org.springframework.core.env.PropertyResolver;
+import org.springframework.http.HttpMethod;
+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(this.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(this.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));
+	}
+
+	@Override
+	public Collection<HttpMethod> getRequestMethod(Class<?> type, Method method) {
+		return this.discoverer.getRequestMethod(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.hateoas.mvc.ForwardedHeader.*;
 
 import lombok.RequiredArgsConstructor;
-import lombok.experimental.Delegate;
 
 import java.lang.reflect.Method;
 import java.net.URI;
@@ -39,6 +38,7 @@
 import org.springframework.hateoas.core.DummyInvocationUtils.MethodInvocation;
 import org.springframework.hateoas.core.LinkBuilderSupport;
 import org.springframework.hateoas.core.MappingDiscoverer;
+import org.springframework.http.HttpMethod;
 import org.springframework.http.MediaType;
 import org.springframework.plugin.core.OrderAwarePluginRegistry;
 import org.springframework.plugin.core.PluginRegistry;
@@ -63,6 +63,7 @@
  * @author Kevin Conaway
  * @author Andrew Naydyonock
  * @author Oliver Trosien
+ * @author Josh Ghiloni
  * @author Greg Turnquist
  */
 public class ControllerLinkBuilder extends LinkBuilderSupport<ControllerLinkBuilder> {
@@ -82,6 +83,8 @@ public class ControllerLinkBuilder extends LinkBuilderSupport<ControllerLinkBuil
 				.create(factories);
 	}
 
+	private static MappingDiscoverer delegateDiscovererOverride = null;
+
 	private final TemplateVariables variables;
 
 	/**
@@ -102,17 +105,26 @@ public class ControllerLinkBuilder extends LinkBuilderSupport<ControllerLinkBuil
 	 * @param uriComponents must not be {@literal null}.
 	 */
 	ControllerLinkBuilder(UriComponents uriComponents) {
-		this(uriComponents, TemplateVariables.NONE, null);
+		this(uriComponents, TemplateVariables.NONE, null, null);
 	}
 
-	ControllerLinkBuilder(UriComponents uriComponents, TemplateVariables variables, MethodInvocation invocation) {
+	ControllerLinkBuilder(UriComponents uriComponents, TemplateVariables variables, MethodInvocation invocation, MappingDiscoverer discoverer) {
 
 		super(uriComponents);
 
 		this.variables = variables;
+		ControllerLinkBuilder.delegateDiscovererOverride = discoverer;
 		this.addAffordances(findAffordances(invocation, uriComponents));
 	}
 
+	public static void setDelegateDiscoverer(MappingDiscoverer delegateDiscovererOverride) {
+		ControllerLinkBuilder.delegateDiscovererOverride = delegateDiscovererOverride;
+	}
+
+	public static void clearDelegateDiscoverer() {
+		ControllerLinkBuilder.delegateDiscovererOverride = null;
+	}
+	
 	/**
 	 * Creates a new {@link ControllerLinkBuilder} with a base of the mapping annotated to the given controller class.
 	 * 
@@ -249,7 +261,7 @@ public static <T> T methodOn(Class<T> controller, Object... parameters) {
 		return DummyInvocationUtils.methodOn(controller, parameters);
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.hateoas.UriComponentsLinkBuilder#getThis()
 	 */
@@ -368,14 +380,65 @@ private static Collection<Affordance> findAffordances(MethodInvocation invocatio
 	@RequiredArgsConstructor
 	private static class CachingAnnotationMappingDiscoverer implements MappingDiscoverer {
 
-		private final @Delegate AnnotationMappingDiscoverer delegate;
+		private final AnnotationMappingDiscoverer delegate;
 		private final Map<String, UriTemplate> templates = new ConcurrentReferenceHashMap<>();
 
+		/**
+		 * 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);
 			return templates.computeIfAbsent(mapping, UriTemplate::new);
 		}
+
+		/**
+		 * 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);
+		}
+
+		/**
+		 * Returns the {@link HttpMethod} invoked on the given type and {@link Method}.
+		 */
+		@Override
+		public Collection<HttpMethod> getRequestMethod(Class<?> type, Method method) {
+			return getDelegate().getRequestMethod(type, method);
+		}
 	}
 
 	private static class CustomUriTemplateHandler extends DefaultUriTemplateHandler {
@@ -402,4 +465,4 @@ public UriComponents expandAndEncode(UriComponentsBuilder builder, Object[] uriV
 			return super.expandAndEncode(builder, uriVariables);
 		}
 	}
-}
+}

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

@@ -65,16 +65,25 @@
  * @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 List<UriComponentsContributor> uriComponentsContributors = new ArrayList<>();
+	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
@@ -137,8 +146,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);
@@ -186,7 +194,7 @@ public ControllerLinkBuilder linkTo(Object invocationValue) {
 			variables = variables.concat(variable);
 		}
 
-		return new ControllerLinkBuilder(components, variables, invocation);
+		return new ControllerLinkBuilder(components, variables, invocation, discoverer);
 	}
 
 	/*