在绑定 Spring MVC 命令对象时如何自定义参数名称？

我有一个命令对象:

public class Job {
private String jobType;
private String location;
}

它受 spring-mvc 的约束:

@RequestMapping("/foo")
public String doSomethingWithJob(Job job) {
...
}

这对于 http://example.com/foo?jobType=permanent&location=Stockholm来说很好用，但是现在我需要让它适用于下面的网址:

http://example.com/foo?jt=permanent&loc=Stockholm

显然，我不想改变我的命令对象，因为字段名必须保持长(正如它们在代码中使用的那样)。我该怎么定制呢？有没有这样的选择:

public class Job {
@RequestParam("jt")
private String jobType;
@RequestParam("loc")
private String location;
}

这不起作用(@RequestParam不能应用于字段)。

我考虑的是类似于 FormHttpMessageConverter的自定义消息转换器，并读取目标对象上的自定义注释

68257 次浏览
小开

I would like to point you to another direction. But I do not know if it works.

I would try to manipulate the binding itself.

It is done by WebDataBinder and will be invoked from HandlerMethodInvoker method Object[] resolveHandlerArguments(Method handlerMethod, Object handler, NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception

I have no deep look in Spring 3.1, but what I have seen, is that this part of Spring has been changed a lot. So it is may possible to exchange the WebDataBinder. In Spring 3.0 it seams not possible without overriding the HandlerMethodInvoker.

小开

Try intercepting request using InterceptorAdaptor, and then using simple checking mechanism decide whether to foward the request to the controller handler. Also wrap HttpServletRequestWrapper around the request, to enable you override the requests getParameter().

This way you can repass the actual parameter name and its value back to the request to be seen by the controller.

Example option:

public class JobInterceptor extends HandlerInterceptorAdapter {
private static final String requestLocations[]={"rt", "jobType"};


private boolean isEmpty(String arg)
{
return (arg !=null && arg.length() > 0);
}


public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {


//Maybe something like this
if(!isEmpty(request.getParameter(requestLocations[0]))|| !isEmpty(request.getParameter(requestLocations[1]))
{
final String value =
!isEmpty(request.getParameter(requestLocations[0])) ? request.getParameter(requestLocations[0]) : !isEmpty(request
.getParameter(requestLocations[1])) ? request.getParameter(requestLocations[1]) : null;


HttpServletRequest wrapper = new HttpServletRequestWrapper(request)
{
public String getParameter(String name)
{
super.getParameterMap().put("JobType", value);
return super.getParameter(name);
}
};


//Accepted request - Handler should carry on.
return super.preHandle(request, response, handler);
}


//Ignore request if above condition was false
return false;
}
}

Finally wrap the HandlerInterceptorAdaptor around your controller handler as shown below. The SelectedAnnotationHandlerMapping allows you to specify which handler will be interecepted.

<bean id="jobInterceptor" class="mypackage.JobInterceptor"/>
<bean id="publicMapper" class="org.springplugins.web.SelectedAnnotationHandlerMapping">
<property name="urls">
<list>
<value>/foo</value>
</list>
</property>
<property name="interceptors">
<list>
<ref bean="jobInterceptor"/>
</list>
</property>
</bean>

EDITED.

小开

there is no nice built in way to do it, you can only choose which workaround you apply. The difference between handling

@RequestMapping("/foo")
public String doSomethingWithJob(Job job)

and

@RequestMapping("/foo")
public String doSomethingWithJob(String stringjob)

is that job is a bean and stringjob isn't (no surprise so far). The real difference is that beans are resolved with the standard Spring bean resolver mechanism, while string params are resolved by spring MVC that knows the concept of the @RequestParam annotation. To make the long story short there is no way in the standard spring bean resolution (that is using classes like PropertyValues, PropertyValue, GenericTypeAwarePropertyDescriptor) to resolve "jt" to a property called "jobType" or at least I dont know about it.

The workarounds coud be as others suggested to add a custom PropertyEditor or a filter, but I think it just messes up the code. In my opinion the cleanest solution would be to declare a class like this :

public class JobParam extends Job {
public String getJt() {
return super.job;
}


public void setJt(String jt) {
super.job = jt;
}


}

then use that in your controller

@RequestMapping("/foo")
public String doSomethingWithJob(JobParam job) {
...
}

UPDATE :

A slightly simpler option is to not to extend, just add the extra getters, setters to the original class

public class Job {


private String jobType;
private String location;


public String getJt() {
return jobType;
}


public void setJt(String jt) {
jobType = jt;
}


}
小开
最佳答案

Here's what I got working:

First, a parameter resolver:

/**
* This resolver handles command objects annotated with @SupportsAnnotationParameterResolution
* that are passed as parameters to controller methods.
*
* It parses @CommandPerameter annotations on command objects to
* populate the Binder with the appropriate values (that is, the filed names
* corresponding to the GET parameters)
*
* In order to achieve this, small pieces of code are copied from spring-mvc
* classes (indicated in-place). The alternative to the copied lines would be to
* have a decorator around the Binder, but that would be more tedious, and still
* some methods would need to be copied.
*
* @author bozho
*
*/
public class AnnotationServletModelAttributeResolver extends ServletModelAttributeMethodProcessor {


/**
* A map caching annotation definitions of command objects (@CommandParameter-to-fieldname mappings)
*/
private ConcurrentMap<Class<?>, Map<String, String>> definitionsCache = Maps.newConcurrentMap();


public AnnotationServletModelAttributeResolver(boolean annotationNotRequired) {
super(annotationNotRequired);
}


@Override
public boolean supportsParameter(MethodParameter parameter) {
if (parameter.getParameterType().isAnnotationPresent(SupportsAnnotationParameterResolution.class)) {
return true;
}
return false;
}


@Override
protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request) {
ServletRequest servletRequest = request.getNativeRequest(ServletRequest.class);
ServletRequestDataBinder servletBinder = (ServletRequestDataBinder) binder;
bind(servletRequest, servletBinder);
}


@SuppressWarnings("unchecked")
public void bind(ServletRequest request, ServletRequestDataBinder binder) {
Map<String, ?> propertyValues = parsePropertyValues(request, binder);
MutablePropertyValues mpvs = new MutablePropertyValues(propertyValues);
MultipartRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartRequest.class);
if (multipartRequest != null) {
bindMultipart(multipartRequest.getMultiFileMap(), mpvs);
}


// two lines copied from ExtendedServletRequestDataBinder
String attr = HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE;
mpvs.addPropertyValues((Map<String, String>) request.getAttribute(attr));
binder.bind(mpvs);
}


private Map<String, ?> parsePropertyValues(ServletRequest request, ServletRequestDataBinder binder) {


// similar to WebUtils.getParametersStartingWith(..) (prefixes not supported)
Map<String, Object> params = Maps.newTreeMap();
Assert.notNull(request, "Request must not be null");
Enumeration<?> paramNames = request.getParameterNames();
Map<String, String> parameterMappings = getParameterMappings(binder);
while (paramNames != null && paramNames.hasMoreElements()) {
String paramName = (String) paramNames.nextElement();
String[] values = request.getParameterValues(paramName);


String fieldName = parameterMappings.get(paramName);
// no annotation exists, use the default - the param name=field name
if (fieldName == null) {
fieldName = paramName;
}


if (values == null || values.length == 0) {
// Do nothing, no values found at all.
} else if (values.length > 1) {
params.put(fieldName, values);
} else {
params.put(fieldName, values[0]);
}
}


return params;
}


/**
* Gets a mapping between request parameter names and field names.
* If no annotation is specified, no entry is added
* @return
*/
private Map<String, String> getParameterMappings(ServletRequestDataBinder binder) {
Class<?> targetClass = binder.getTarget().getClass();
Map<String, String> map = definitionsCache.get(targetClass);
if (map == null) {
Field[] fields = targetClass.getDeclaredFields();
map = Maps.newHashMapWithExpectedSize(fields.length);
for (Field field : fields) {
CommandParameter annotation = field.getAnnotation(CommandParameter.class);
if (annotation != null && !annotation.value().isEmpty()) {
map.put(annotation.value(), field.getName());
}
}
definitionsCache.putIfAbsent(targetClass, map);
return map;
} else {
return map;
}
}


/**
* Copied from WebDataBinder.
*
* @param multipartFiles
* @param mpvs
*/
protected void bindMultipart(Map<String, List<MultipartFile>> multipartFiles, MutablePropertyValues mpvs) {
for (Map.Entry<String, List<MultipartFile>> entry : multipartFiles.entrySet()) {
String key = entry.getKey();
List<MultipartFile> values = entry.getValue();
if (values.size() == 1) {
MultipartFile value = values.get(0);
if (!value.isEmpty()) {
mpvs.add(key, value);
}
} else {
mpvs.add(key, values);
}
}
}
}

And then registering the parameter resolver using a post-processor. It should be registered as a <bean>:

/**
* Post-processor to be used if any modifications to the handler adapter need to be made
*
* @author bozho
*
*/
public class AnnotationHandlerMappingPostProcessor implements BeanPostProcessor {


@Override
public Object postProcessAfterInitialization(Object bean, String arg1)
throws BeansException {
return bean;
}


@Override
public Object postProcessBeforeInitialization(Object bean, String arg1)
throws BeansException {
if (bean instanceof RequestMappingHandlerAdapter) {
RequestMappingHandlerAdapter adapter = (RequestMappingHandlerAdapter) bean;
List<HandlerMethodArgumentResolver> resolvers = adapter.getCustomArgumentResolvers();
if (resolvers == null) {
resolvers = Lists.newArrayList();
}
resolvers.add(new AnnotationServletModelAttributeResolver(false));
adapter.setCustomArgumentResolvers(resolvers);
}


return bean;
}


}
小开

In Spring 3.1, ServletRequestDataBinder provides a hook for additional bind values:

protected void addBindValues(MutablePropertyValues mpvs, ServletRequest request) {
}

The ExtendedServletRequestDataBinder subclass uses it to add URI template variables as binding values. You could extend it further to make it possible to add command-specific field aliases.

You can override RequestMappingHandlerAdapter.createDataBinderFactory(..) to provide a custom WebDataBinder instance. From a controller's perspective it could look like this:

@InitBinder
public void initBinder(MyWebDataBinder binder) {
binder.addFieldAlias("jobType", "jt");
// ...
}
小开

This solution more concise but requires using RequestMappingHandlerAdapter, which Spring use when <mvc:annotation-driven /> enabled. Hope it will help somebody. The idea is to extend ServletRequestDataBinder like this:

 /**
* ServletRequestDataBinder which supports fields renaming using {@link ParamName}
*
* @author jkee
*/
public class ParamNameDataBinder extends ExtendedServletRequestDataBinder {


private final Map<String, String> renameMapping;


public ParamNameDataBinder(Object target, String objectName, Map<String, String> renameMapping) {
super(target, objectName);
this.renameMapping = renameMapping;
}


@Override
protected void addBindValues(MutablePropertyValues mpvs, ServletRequest request) {
super.addBindValues(mpvs, request);
for (Map.Entry<String, String> entry : renameMapping.entrySet()) {
String from = entry.getKey();
String to = entry.getValue();
if (mpvs.contains(from)) {
mpvs.add(to, mpvs.getPropertyValue(from).getValue());
}
}
}
}

Appropriate processor:

/**
* Method processor supports {@link ParamName} parameters renaming
*
* @author jkee
*/


public class RenamingProcessor extends ServletModelAttributeMethodProcessor {


@Autowired
private RequestMappingHandlerAdapter requestMappingHandlerAdapter;


//Rename cache
private final Map<Class<?>, Map<String, String>> replaceMap = new ConcurrentHashMap<Class<?>, Map<String, String>>();


public RenamingProcessor(boolean annotationNotRequired) {
super(annotationNotRequired);
}


@Override
protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest nativeWebRequest) {
Object target = binder.getTarget();
Class<?> targetClass = target.getClass();
if (!replaceMap.containsKey(targetClass)) {
Map<String, String> mapping = analyzeClass(targetClass);
replaceMap.put(targetClass, mapping);
}
Map<String, String> mapping = replaceMap.get(targetClass);
ParamNameDataBinder paramNameDataBinder = new ParamNameDataBinder(target, binder.getObjectName(), mapping);
requestMappingHandlerAdapter.getWebBindingInitializer().initBinder(paramNameDataBinder, nativeWebRequest);
super.bindRequestParameters(paramNameDataBinder, nativeWebRequest);
}


private static Map<String, String> analyzeClass(Class<?> targetClass) {
Field[] fields = targetClass.getDeclaredFields();
Map<String, String> renameMap = new HashMap<String, String>();
for (Field field : fields) {
ParamName paramNameAnnotation = field.getAnnotation(ParamName.class);
if (paramNameAnnotation != null && !paramNameAnnotation.value().isEmpty()) {
renameMap.put(paramNameAnnotation.value(), field.getName());
}
}
if (renameMap.isEmpty()) return Collections.emptyMap();
return renameMap;
}
}

Annotation: 

/**
* Overrides parameter name
* @author jkee
*/


@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ParamName {


/**
* The name of the request parameter to bind to.
*/
String value();


}

Spring config:

<mvc:annotation-driven>
<mvc:argument-resolvers>
<bean class="ru.yandex.metrika.util.params.RenamingProcessor">
<constructor-arg name="annotationNotRequired" value="true"/>
</bean>
</mvc:argument-resolvers>
</mvc:annotation-driven>

And finally, usage (like Bozho solution):

public class Job {
@ParamName("job-type")
private String jobType;
@ParamName("loc")
private String location;
}
小开

You can use Jackson com.fasterxml.jackson.databind.ObjectMapper to convert any map to your DTO/POJO class with nested props. You need annotate your POJOs with @JsonUnwrapped on nested object. Like this:

public class MyRequest {


@JsonUnwrapped
private NestedObject nested;


public NestedObject getNested() {
return nested;
}
}

And than use it like this:

@RequestMapping(method = RequestMethod.GET, value = "/myMethod")
@ResponseBody
public Object myMethod(@RequestParam Map<String, Object> allRequestParams) {


MyRequest request = new ObjectMapper().convertValue(allRequestParams, MyRequest.class);
...
}

That's all. A little coding. Also, you can give any names to your props usign @JsonProperty.

小开

There is a simple way, you can just add one more setter method, like "setLoc,setJt".

小开

Thanks the answer of @jkee .
Here is my solution.
First, a custom annotation:

@Inherited
@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParamName {


/**
* The name of the request parameter to bind to.
*/
String value();


}

A customer DataBinder:

public class ParamNameDataBinder extends ExtendedServletRequestDataBinder {


private final Map<String, String> paramMappings;


public ParamNameDataBinder(Object target, String objectName, Map<String, String> paramMappings) {
super(target, objectName);
this.paramMappings = paramMappings;
}


@Override
protected void addBindValues(MutablePropertyValues mutablePropertyValues, ServletRequest request) {
super.addBindValues(mutablePropertyValues, request);
for (Map.Entry<String, String> entry : paramMappings.entrySet()) {
String paramName = entry.getKey();
String fieldName = entry.getValue();
if (mutablePropertyValues.contains(paramName)) {
mutablePropertyValues.add(fieldName, mutablePropertyValues.getPropertyValue(paramName).getValue());
}
}
}


}

A parameter resolver:

public class ParamNameProcessor extends ServletModelAttributeMethodProcessor {


@Autowired
private RequestMappingHandlerAdapter requestMappingHandlerAdapter;


private static final Map<Class<?>, Map<String, String>> PARAM_MAPPINGS_CACHE = new ConcurrentHashMap<>(256);


public ParamNameProcessor() {
super(false);
}


@Override
public boolean supportsParameter(MethodParameter parameter) {
return parameter.hasParameterAnnotation(RequestParam.class)
&& !BeanUtils.isSimpleProperty(parameter.getParameterType())
&& Arrays.stream(parameter.getParameterType().getDeclaredFields())
.anyMatch(field -> field.getAnnotation(ParamName.class) != null);
}


@Override
protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest nativeWebRequest) {
Object target = binder.getTarget();
Map<String, String> paramMappings = this.getParamMappings(target.getClass());
ParamNameDataBinder paramNameDataBinder = new ParamNameDataBinder(target, binder.getObjectName(), paramMappings);
requestMappingHandlerAdapter.getWebBindingInitializer().initBinder(paramNameDataBinder, nativeWebRequest);
super.bindRequestParameters(paramNameDataBinder, nativeWebRequest);
}


/**
* Get param mappings.
* Cache param mappings in memory.
*
* @param targetClass
* @return {@link Map<String, String>}
*/
private Map<String, String> getParamMappings(Class<?> targetClass) {
if (PARAM_MAPPINGS_CACHE.containsKey(targetClass)) {
return PARAM_MAPPINGS_CACHE.get(targetClass);
}
Field[] fields = targetClass.getDeclaredFields();
Map<String, String> paramMappings = new HashMap<>(32);
for (Field field : fields) {
ParamName paramName = field.getAnnotation(ParamName.class);
if (paramName != null && !paramName.value().isEmpty()) {
paramMappings.put(paramName.value(), field.getName());
}
}
PARAM_MAPPINGS_CACHE.put(targetClass, paramMappings);
return paramMappings;
}


}

Finally, a bean configuration for adding ParamNameProcessor into the first of argument resolvers:

@Configuration
public class WebConfig {


/**
* Processor for annotation {@link ParamName}.
*
* @return ParamNameProcessor
*/
@Bean
protected ParamNameProcessor paramNameProcessor() {
return new ParamNameProcessor();
}


/**
* Custom {@link BeanPostProcessor} for adding {@link ParamNameProcessor} into the first of
* {@link RequestMappingHandlerAdapter#argumentResolvers}.
*
* @return BeanPostProcessor
*/
@Bean
public BeanPostProcessor beanPostProcessor() {
return new BeanPostProcessor() {


@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}


@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof RequestMappingHandlerAdapter) {
RequestMappingHandlerAdapter adapter = (RequestMappingHandlerAdapter) bean;
List<HandlerMethodArgumentResolver> argumentResolvers = new ArrayList<>(adapter.getArgumentResolvers());
argumentResolvers.add(0, paramNameProcessor());
adapter.setArgumentResolvers(argumentResolvers);
}
return bean;
}
};
}


}

Param pojo:

@Data
public class Foo {


private Integer id;


@ParamName("first_name")
private String firstName;


@ParamName("last_name")
private String lastName;


@ParamName("created_at")
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date createdAt;


}

Controller method:

@GetMapping("/foos")
public ResponseEntity<List<Foo>> listFoos(@RequestParam Foo foo, @PageableDefault(sort = "id") Pageable pageable) {
List<Foo> foos = fooService.listFoos(foo, pageable);
return ResponseEntity.ok(foos);
}

That's all.

小开

There's a little improvement to jkee's answer.

In order to support inheritance you should also analyze parent classes.

/**
* ServletRequestDataBinder which supports fields renaming using {@link ParamName}
*
* @author jkee
* @author Yauhen Parmon
*/
public class ParamRenamingProcessor extends ServletModelAttributeMethodProcessor {


@Autowired
private RequestMappingHandlerAdapter requestMappingHandlerAdapter;


//Rename cache
private final Map<Class<?>, Map<String, String>> replaceMap = new ConcurrentHashMap<>();


public ParamRenamingProcessor(boolean annotationNotRequired) {
super(annotationNotRequired);
}


@Override
protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest nativeWebRequest) {
Object target = binder.getTarget();
Class<?> targetClass = Objects.requireNonNull(target).getClass();
if (!replaceMap.containsKey(targetClass)) {
replaceMap.put(targetClass, analyzeClass(targetClass));
}
Map<String, String> mapping = replaceMap.get(targetClass);
ParamNameDataBinder paramNameDataBinder = new ParamNameDataBinder(target, binder.getObjectName(), mapping);
Objects.requireNonNull(requestMappingHandlerAdapter.getWebBindingInitializer())
.initBinder(paramNameDataBinder);
super.bindRequestParameters(paramNameDataBinder, nativeWebRequest);
}


private Map<String, String> analyzeClass(Class<?> targetClass) {
Map<String, String> renameMap = new HashMap<>();
for (Field field : targetClass.getDeclaredFields()) {
ParamName paramNameAnnotation = field.getAnnotation(ParamName.class);
if (paramNameAnnotation != null && !paramNameAnnotation.value().isEmpty()) {
renameMap.put(paramNameAnnotation.value(), field.getName());
}
}
if (targetClass.getSuperclass() != Object.class) {
renameMap.putAll(analyzeClass(targetClass.getSuperclass()));
}
return renameMap;
}
}

This processor will analyze fields of superclasses annotated with @ParamName. It also doesn't use initBinder method with 2 parameters which is deprecated as of Spring 5.0. All the rest in jkee's answer is OK.


提交答案