root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Rename @[Path/Destination]Variable in spring-messaging 

Issue: SPR-11208
This commit is contained in:
Rossen Stoyanchev 2013-12-11 14:44:57 -05:00
parent a9605a11e9
commit 92dad1849f
6 changed files with 70 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/PathVariable.java → spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/DestinationVariable.java
View File

@ -23,26 +23,26 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotation that indicates a method parameter should be bound to a path template
* variable. Supported on message handling methods such as
* {@link MessageMapping @MessageMapping} for messages with path-like destination
* semantics.
*
* <p>A {@code @PathVariable} template variable is always required and does not have a
* default value to fall back on.
* Annotation that indicates a method parameter should be bound to a template variable
* in a destination template string. Supported on message handling methods such as
* {@link MessageMapping @MessageMapping}.
* <p>
* A {@code @DestinationVariable} template variable is always required.
*
* @author Brian Clozel
* @author Rossen Stoyanchev
* @since 4.0
*
* @see org.springframework.messaging.handler.annotation.MessageMapping
* @see org.springframework.messaging.simp.annotation.support.SimpAnnotationMethodMessageHandler
*/
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PathVariable {
public @interface DestinationVariable {
/**
* The path template variable to bind to.
* The name of the destination template variable to bind to.
*/
String value() default "";

4
spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/MessageMapping.java
View File

@ -53,8 +53,8 @@ import org.springframework.messaging.Message;
* with STOMP over WebSocket support also sub-classes such as
* {@link org.springframework.messaging.simp.SimpMessageHeaderAccessor}
* for convenient access to all method arguments.</li>
* <li>{@link PathVariable}-annotated arguments for access to URI variable
* values extracted from the message destination (i.e. /hotels/{hotel}).
* <li>{@link DestinationVariable}-annotated arguments for access to template
* variable values extracted from the message destination (e.g. /hotels/{hotel}).
* Variable values will be converted to the declared method argument type.</li>
* <li>{@link java.security.Principal} method arguments are supported with
* STOMP over WebSocket messages. It reflects the user logged in to the

37
spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/PathVariableMethodArgumentResolver.java → spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/DestinationVariableMethodArgumentResolver.java
View File

@ -22,46 +22,45 @@ import org.springframework.core.MethodParameter;
import org.springframework.core.convert.ConversionService;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHandlingException;
import org.springframework.messaging.handler.annotation.PathVariable;
import org.springframework.messaging.handler.annotation.DestinationVariable;
import org.springframework.messaging.handler.annotation.ValueConstants;
/**
* Resolves method parameters annotated with {@link PathVariable @PathVariable}.
*
* <p>A @{@link PathVariable} is a named value that gets resolved from a path
* template variable that matches the Message destination header.
* It is always required and does not have a default value to fall back on.
* Resolves method parameters annotated with
* {@link org.springframework.messaging.handler.annotation.DestinationVariable @DestinationVariable}.
*
* @author Brian Clozel
* @see org.springframework.messaging.handler.annotation.PathVariable
* @see org.springframework.messaging.MessageHeaders
* @since 4.0
*/
public class PathVariableMethodArgumentResolver extends AbstractNamedValueMethodArgumentResolver {
public class DestinationVariableMethodArgumentResolver extends AbstractNamedValueMethodArgumentResolver {
public static final String PATH_TEMPLATE_VARIABLES_HEADER =
PathVariableMethodArgumentResolver.class.getSimpleName() + ".templateVariables";
public static final String DESTINATION_TEMPLATE_VARIABLES_HEADER =
DestinationVariableMethodArgumentResolver.class.getSimpleName() + ".templateVariables";
public PathVariableMethodArgumentResolver(ConversionService cs) {
public DestinationVariableMethodArgumentResolver(ConversionService cs) {
super(cs, null);
}
@Override
public boolean supportsParameter(MethodParameter parameter) {
return parameter.hasParameterAnnotation(PathVariable.class);
return parameter.hasParameterAnnotation(DestinationVariable.class);
}
@Override
protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
PathVariable annotation = parameter.getParameterAnnotation(PathVariable.class);
return new PathVariableNamedValueInfo(annotation);
DestinationVariable annotation = parameter.getParameterAnnotation(DestinationVariable.class);
return new DestinationVariableNamedValueInfo(annotation);
}
@Override
protected Object resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name) throws Exception {
protected Object resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)
throws Exception {
@SuppressWarnings("unchecked")
Map<String, String> vars = (Map<String, String>) message.getHeaders().get(PATH_TEMPLATE_VARIABLES_HEADER);
Map<String, String> vars = (Map<String, String>) message.getHeaders().get(
DESTINATION_TEMPLATE_VARIABLES_HEADER);
return (vars != null) ? vars.get(name) : null;
}
@ -72,9 +71,9 @@ public class PathVariableMethodArgumentResolver extends AbstractNamedValueMethod
}
private static class PathVariableNamedValueInfo extends NamedValueInfo {
private static class DestinationVariableNamedValueInfo extends NamedValueInfo {
private PathVariableNamedValueInfo(PathVariable annotation) {
private DestinationVariableNamedValueInfo(DestinationVariable annotation) {
super(annotation.value(), true, ValueConstants.DEFAULT_NONE);
}
}

17
spring-messaging/src/main/java/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandler.java
View File

@ -41,12 +41,8 @@ import org.springframework.messaging.converter.StringMessageConverter;
import org.springframework.messaging.core.AbstractMessageSendingTemplate;
import org.springframework.messaging.handler.HandlerMethod;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.support.AnnotationExceptionHandlerMethodResolver;
import org.springframework.messaging.handler.annotation.support.HeaderMethodArgumentResolver;
import org.springframework.messaging.handler.annotation.support.HeadersMethodArgumentResolver;
import org.springframework.messaging.handler.annotation.support.MessageMethodArgumentResolver;
import org.springframework.messaging.handler.annotation.support.PathVariableMethodArgumentResolver;
import org.springframework.messaging.handler.annotation.support.PayloadArgumentResolver;
import org.springframework.messaging.handler.annotation.support.*;
import org.springframework.messaging.handler.annotation.support.DestinationVariableMethodArgumentResolver;
import org.springframework.messaging.handler.invocation.AbstractExceptionHandlerMethodResolver;
import org.springframework.messaging.handler.invocation.AbstractMethodMessageHandler;
import org.springframework.messaging.handler.DestinationPatternsMessageCondition;
@ -66,10 +62,11 @@ import org.springframework.util.ClassUtils;
import org.springframework.util.PathMatcher;
/**
* A handler for messages delegating to {@link org.springframework.messaging.simp.annotation.SubscribeMapping @SubscribeMapping} and
* A handler for messages delegating to
* {@link org.springframework.messaging.simp.annotation.SubscribeMapping @SubscribeMapping} and
* {@link MessageMapping @MessageMapping} annotated methods.
* <p>
* Supports Ant-style path patterns as well as URI template variables in destinations.
* Supports Ant-style path patterns with template variables.
*
* @author Rossen Stoyanchev
* @author Brian Clozel
@ -226,7 +223,7 @@ public class SimpAnnotationMethodMessageHandler extends AbstractMethodMessageHan
// Annotation-based argument resolution
resolvers.add(new HeaderMethodArgumentResolver(this.conversionService, beanFactory));
resolvers.add(new HeadersMethodArgumentResolver());
resolvers.add(new PathVariableMethodArgumentResolver(this.conversionService));
resolvers.add(new DestinationVariableMethodArgumentResolver(this.conversionService));
// Type-based argument resolution
resolvers.add(new PrincipalMethodArgumentResolver());
@ -339,7 +336,7 @@ public class SimpAnnotationMethodMessageHandler extends AbstractMethodMessageHan
Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchedPattern, lookupDestination);
headers.setDestination(lookupDestination);
headers.setHeader(PathVariableMethodArgumentResolver.PATH_TEMPLATE_VARIABLES_HEADER, vars);
headers.setHeader(DestinationVariableMethodArgumentResolver.DESTINATION_TEMPLATE_VARIABLES_HEADER, vars);
message = MessageBuilder.withPayload(message.getPayload()).setHeaders(headers).build();
super.handleMatch(mapping, handlerMethod, lookupDestination, message);

33
spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/PathVariableMethodArgumentResolverTests.java → spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/DestinationVariableMethodArgumentResolverTests.java
View File

@ -29,18 +29,19 @@ import org.springframework.core.MethodParameter;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHandlingException;
import org.springframework.messaging.handler.annotation.PathVariable;
import org.springframework.messaging.handler.annotation.DestinationVariable;
import org.springframework.messaging.support.MessageBuilder;
import static org.junit.Assert.*;
/**
* Test fixture for {@link PathVariableMethodArgumentResolver} tests.
* Test fixture for {@link DestinationVariableMethodArgumentResolver} tests.
*
* @author Brian Clozel
*/
public class PathVariableMethodArgumentResolverTests {
public class DestinationVariableMethodArgumentResolverTests {
private PathVariableMethodArgumentResolver resolver;
private DestinationVariableMethodArgumentResolver resolver;
private MethodParameter paramAnnotated;
private MethodParameter paramAnnotatedValue;
@ -49,7 +50,7 @@ public class PathVariableMethodArgumentResolverTests {
@Before
public void setup() throws Exception {
this.resolver = new PathVariableMethodArgumentResolver(new DefaultConversionService());
this.resolver = new DestinationVariableMethodArgumentResolver(new DefaultConversionService());
Method method = getClass().getDeclaredMethod("handleMessage", String.class, String.class, String.class);
this.paramAnnotated = new MethodParameter(method, 0);
@ -57,9 +58,9 @@ public class PathVariableMethodArgumentResolverTests {
this.paramNotAnnotated = new MethodParameter(method, 2);
this.paramAnnotated.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
GenericTypeResolver.resolveParameterType(this.paramAnnotated, PathVariableMethodArgumentResolver.class);
GenericTypeResolver.resolveParameterType(this.paramAnnotated, DestinationVariableMethodArgumentResolver.class);
this.paramAnnotatedValue.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
GenericTypeResolver.resolveParameterType(this.paramAnnotatedValue, PathVariableMethodArgumentResolver.class);
GenericTypeResolver.resolveParameterType(this.paramAnnotatedValue, DestinationVariableMethodArgumentResolver.class);
}
@Test
@ -71,13 +72,17 @@ public class PathVariableMethodArgumentResolverTests {
@Test
public void resolveArgument() throws Exception {
Map<String, Object> pathParams = new HashMap<String, Object>();
pathParams.put("foo", "bar");
pathParams.put("name", "value");
Map<String, Object> vars = new HashMap<String, Object>();
vars.put("foo", "bar");
vars.put("name", "value");
Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeader(
PathVariableMethodArgumentResolver.PATH_TEMPLATE_VARIABLES_HEADER, pathParams).build();
DestinationVariableMethodArgumentResolver.DESTINATION_TEMPLATE_VARIABLES_HEADER, vars).build();
Object result = this.resolver.resolveArgument(this.paramAnnotated, message);
assertEquals("bar", result);
result = this.resolver.resolveArgument(this.paramAnnotatedValue, message);
assertEquals("value", result);
}
@ -89,6 +94,10 @@ public class PathVariableMethodArgumentResolverTests {
}
@SuppressWarnings("unused")
private void handleMessage(@PathVariable String foo, @PathVariable(value = "name") String param1, String param3) {
private void handleMessage(
@DestinationVariable String foo,
@DestinationVariable(value = "name") String param1,
String param3) {
}
}

27
spring-messaging/src/test/java/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandlerTests.java
View File

@ -26,17 +26,16 @@ import org.springframework.context.support.StaticApplicationContext;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.SubscribableChannel;
import org.springframework.messaging.handler.annotation.DestinationVariable;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.PathVariable;
import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
import org.springframework.messaging.simp.SimpMessageSendingOperations;
import org.springframework.messaging.simp.SimpMessageType;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.annotation.SubscribeMapping;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.simp.annotation.support.SimpAnnotationMethodMessageHandler;
import org.springframework.stereotype.Controller;
import static org.junit.Assert.*;
@ -86,26 +85,26 @@ public class SimpAnnotationMethodMessageHandlerTests {
}
@Test
public void messageMappingPathVariableResolution() {
public void messageMappingDestinationVariableResolution() {
SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create();
headers.setDestination("/pre/message/bar/value");
Message<?> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build();
this.messageHandler.handleMessage(message);
assertEquals("messageMappingPathVariable", this.testController.method);
assertEquals("messageMappingDestinationVariable", this.testController.method);
assertEquals("bar", this.testController.arguments.get("foo"));
assertEquals("value", this.testController.arguments.get("name"));
}
@Test
public void subscribeEventPathVariableResolution() {
public void subscribeEventDestinationVariableResolution() {
SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(SimpMessageType.SUBSCRIBE);
headers.setDestination("/pre/sub/bar/value");
Message<?> message = MessageBuilder.withPayload(new byte[0])
.copyHeaders(headers.toMap()).build();
this.messageHandler.handleMessage(message);
assertEquals("subscribeEventPathVariable", this.testController.method);
assertEquals("subscribeEventDestinationVariable", this.testController.method);
assertEquals("bar", this.testController.arguments.get("foo"));
assertEquals("value", this.testController.arguments.get("name"));
}
@ -175,17 +174,17 @@ public class SimpAnnotationMethodMessageHandlerTests {
}
@MessageMapping("/message/{foo}/{name}")
public void messageMappingPathVariable(@PathVariable("foo") String param1,
@PathVariable("name") String param2) {
this.method = "messageMappingPathVariable";
public void messageMappingDestinationVariable(@DestinationVariable("foo") String param1,
@DestinationVariable("name") String param2) {
this.method = "messageMappingDestinationVariable";
this.arguments.put("foo", param1);
this.arguments.put("name", param2);
}
@SubscribeMapping("/sub/{foo}/{name}")
public void subscribeEventPathVariable(@PathVariable("foo") String param1,
@PathVariable("name") String param2) {
this.method = "subscribeEventPathVariable";
public void subscribeEventDestinationVariable(@DestinationVariable("foo") String param1,
@DestinationVariable("name") String param2) {
this.method = "subscribeEventDestinationVariable";
this.arguments.put("foo", param1);
this.arguments.put("name", param2);
}
@ -196,7 +195,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
}
@MessageMapping("/bestmatch/{foo}/path")
public void bestMatch(@PathVariable("foo") String param1) {
public void bestMatch(@DestinationVariable("foo") String param1) {
this.method = "bestMatch";
this.arguments.put("foo", param1);
}
@ -207,7 +206,7 @@ public class SimpAnnotationMethodMessageHandlerTests {
}
@MessageMapping("/binding/id/{id}")
public void simpleBinding(@PathVariable("id") Long id) {
public void simpleBinding(@DestinationVariable("id") Long id) {
this.method = "simpleBinding";
this.arguments.put("id", id);
}