GET方式参数解析器

一、配置类

package com.caohua.launcher.config;

import com.caohua.api.ptom.annotation.handle.JsonArgumentResolver;
import com.caohua.api.ptom.annotation.handle.ParamArgumentResolver;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;

import java.util.ArrayList;
import java.util.List;

@Component
public class ArgumentResolverConfig implements BeanPostProcessor {

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

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
//        System.out.println("-------------------------------" + beanName);
        if(beanName.contains("RequestMappingHandlerAdapter")) {
            //对RequestMappingHandlerAdapter进行修改
            RequestMappingHandlerAdapter adapter = (RequestMappingHandlerAdapter) bean;
            List<HandlerMethodArgumentResolver> argumentResolvers = adapter.getArgumentResolvers();
            //添加自定义参数处理器
            argumentResolvers = addArgumentResolvers(argumentResolvers);
            adapter.setArgumentResolvers(argumentResolvers);
        }
        return bean;
    }

    private List<HandlerMethodArgumentResolver> addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();
        //将自定义的添加到最前面
        resolvers.add(new JsonArgumentResolver());// 添加参数解析器Post-(application/json)
        resolvers.add(new ParamArgumentResolver());// 添加参数解析器key-value键值对方式数组参数解析
        //将原本的添加后面
        resolvers.addAll(argumentResolvers);
        return resolvers;
    }
}

二、注解

package com.caohua.api.ptom.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * key-value键值对方式数组参数解析（目前仅支持[’String‘，’int‘]）
 * 默认解析字符串类型数组，type传递”int“则解析整型数组
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface ParamArg {

    public String value() default "";

    public String type() default "";

}

三、解析类

package com.caohua.api.ptom.annotation.handle;

import java.util.*;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import com.alibaba.fastjson.JSONArray;
import com.caohua.api.ptom.annotation.ParamArg;
import net.sf.ehcache.search.expression.NotNull;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

public class ParamArgumentResolver implements HandlerMethodArgumentResolver {

    final static Logger log = LoggerFactory.getLogger(ParamArgumentResolver.class);

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(ParamArg.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        Map<String, List<String>> requestParams = getRequestParams(webRequest);
        String arg = parameter.getParameterAnnotation(ParamArg.class).value();
        String type = parameter.getParameterAnnotation(ParamArg.class).type();
        if (StringUtils.isEmpty(arg)) {
            arg = parameter.getParameterName();
        }
        Object val = null;
        try {
            List<String> list = requestParams.get(arg);
            if (list == null || list.size() == 0) {
                return null;
            }
            if (type.equals("int")) {
                val = list.stream().map(Integer::new).collect(Collectors.toList());
            } else {
                val = list;
            }
        } catch (Exception e) {
            log.error("ParamArgumentResolver,参数解析错误,msg:{},body:{}", e.getMessage(), requestParams.get(arg + "[]"));
        }
        return val;
    }

    private Map<String, List<String>> getRequestParams(NativeWebRequest webRequest){
        HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
        Map<String, String[]> parameterMap = servletRequest.getParameterMap();
        if (parameterMap == null) {
            return new HashMap<>();
        }
        Map<String, List<String>> paramsMap = new HashMap<>();
        for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
            String mapKey = entry.getKey();
            String[] mapValue = entry.getValue();
            List<String> params;
            if (mapValue[0].indexOf("[") > -1 && mapValue[0].indexOf("]") > -1) { // list=[?,?]
                try {
                    JSONArray arr = JSONArray.parseArray(mapValue[0]);
                    params = arr.stream()
                            .filter(Objects::nonNull)
                            .map(String::valueOf)
                            .distinct()
                            .collect(Collectors.toList());
                } catch (Exception e) {
                    List<String> incompleteList = Arrays.asList(mapValue);
                    params = new ArrayList<>(incompleteList);
                }
            } else if (mapKey.indexOf("[") > -1 && mapKey.indexOf("]") > -1) {
                String key = mapKey.split("\\[")[0];
                if (mapKey.indexOf("[]") > -1) { // list[]=?
                    List<String> incompleteList = Arrays.asList(mapValue);
                    params = new ArrayList<>(incompleteList);
                    mapKey = key; // 修改键名
                } else { // Post-formData：list[0]=?,list[1]=?,...
                    params = paramsMap.get(key);
                    if (params == null || params.size() == 0) {
                        params = new ArrayList<>();
                    }
                    params.add(mapValue[0]);
                    mapKey = key; // 修改键名
                }
            } else {
                List<String> incompleteList = Arrays.asList(mapValue);
                params = new ArrayList<>(incompleteList); // Arrays.asList()转换后的List调用方法会直接抛出异常
            }
            paramsMap.put(mapKey, params);
        }
        return paramsMap;
    }

}