spring mvc 给参数起别名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package com.davidwang456.web.model;
 
import com.davidwang456.web.annotation.ParamName;
 
public class Job {

    @ParamName("jt")

    private String jobType;

    @ParamName("loc")

    private String location;

    public String getJobType() {

        return jobType;

    }

    public void setJobType(String jobType) {

        this.jobType = jobType;

    }

    public String getLocation() {

        return location;

    }

    public void setLocation(String location) {

        this.location = location;

    }
 
    @Override

    public String toString(){

        return "jobType="+jobType+",location="+location;

    }
 
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package com.davidwang456.web.annotation;
 
import java.lang.annotation.Documented;

import java.lang.annotation.Retention;

import java.lang.annotation.Target;

import java.lang.annotation.ElementType;

import java.lang.annotation.RetentionPolicy;

/**

 * Overrides parameter name

 */
 
@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface ParamName {
 
    /**

     * The name of the request parameter to bind to.

     */

    String value();
 
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

package com.davidwang456.web.processor;
 
import java.lang.reflect.Field;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;
 
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.WebDataBinder;

import org.springframework.web.context.request.NativeWebRequest;

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;

import org.springframework.web.servlet.mvc.method.annotation.ServletModelAttributeMethodProcessor;
 
import com.davidwang456.web.annotation.ParamName;
 
/**

 * Method processor supports {@link ParamName} parameters renaming

 *

 */
 
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;

    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

package com.davidwang456.web.processor;
 
import java.util.Map;
 
import javax.servlet.ServletRequest;
 
import org.springframework.beans.MutablePropertyValues;

import org.springframework.web.servlet.mvc.method.annotation.ExtendedServletRequestDataBinder;
 
/**

* ServletRequestDataBinder which supports fields renaming using {@link ParamName}

*

*/

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());

           }

       }

   }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

<mvc:annotation-driven>

        <mvc:argument-resolvers>

            <bean>

                <constructor-arg />

            </bean>

        </mvc:argument-resolvers>

    </mvc:annotation-driven>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package com.davidwang456.web.configurer;
 
import java.util.List;
 
import org.springframework.context.annotation.Configuration;

import org.springframework.web.method.support.HandlerMethodArgumentResolver;

import org.springframework.web.servlet.config.annotation.EnableWebMvc;

import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 
import com.davidwang456.web.processor.RenamingProcessor;
 
@Configuration

@EnableWebMvc

public class WebConfig extends WebMvcConfigurerAdapter{

      @Override

      public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {

          RenamingProcessor renameResolver = new RenamingProcessor(true);

          argumentResolvers.add(renameResolver);

      }

}