package cn.annotation; 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; 
/**
 * Title:      RequestJson
 * @date       2018年9月10日
 * @version    V1.0
 * Description: 自定義請(qǐng)求json數(shù)據(jù)解析注解（主要解決單參數(shù)傳遞）
 */
@Target(ElementType.PARAMETER)//使用在參數(shù)上
@Retention(RetentionPolicy.RUNTIME)//運(yùn)行時(shí)注解
public @interface RequestJson {
    /**
     * 是否必須出現(xiàn)的參數(shù)
     */
    boolean required() default true;
 
    /**
     * 當(dāng)value的值或者參數(shù)名不匹配時(shí)，是否允許解析最外層屬性到該對(duì)象
     */
    boolean parseAllFields() default true;
 
    /**
     * 解析時(shí)用到的JSON的key
     */
    String value() default "";
}

package cn.config; 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject; 
import cn.annotation.RequestJson; 
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
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; 
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Set;
 
/**
 * Title:      RequestJsonHandlerMethodArgumentResolver
 * @date       2018年9月10日
 * @version    V1.0
 * Description: 自定義解析json數(shù)據(jù)
 */
public class RequestJsonHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {
 private static final String JSONBODY_ATTRIBUTE = "JSON_REQUEST_BODY";
  
    /**
     * 設(shè)置支持的方法參數(shù)類型
     * @param parameter 方法參數(shù)
     * @return 支持的類型
     */
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        // 支持帶@RequestJson注解的參數(shù)
        return parameter.hasParameterAnnotation(RequestJson.class);
    }
 
    /**
     * 參數(shù)解析，利用fastjson
     * 注意：非基本類型返回null會(huì)報(bào)空指針異常，要通過(guò)反射或者JSON工具類創(chuàng)建一個(gè)空對(duì)象
     */
    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
 
        String jsonBody = getRequestBody(webRequest);
 
        JSONObject jsonObject = JSON.parseObject(jsonBody);
        // 根據(jù)@RequestJson注解value作為json解析的key
        RequestJson parameterAnnotation = parameter.getParameterAnnotation(RequestJson.class);
        //注解的value是JSON的key
        String key = parameterAnnotation.value();
        Object value = null;
        // 如果@RequestJson注解沒(méi)有設(shè)置value，則取參數(shù)名FrameworkServlet作為json解析的key
        if (StringUtils.isNotEmpty(key)) {
            value = jsonObject.get(key);
            // 如果設(shè)置了value但是解析不到，報(bào)錯(cuò)
            if (value == null && parameterAnnotation.required()) {
                throw new IllegalArgumentException(String.format("required param %s is not present", key));
            }
        } else {
            // 注解為設(shè)置value則用參數(shù)名當(dāng)做json的key
            key = parameter.getParameterName();
            value = jsonObject.get(key);
        }
 
 
        Class<?> parameterType = parameter.getParameterType();
        // 通過(guò)注解的value或者參數(shù)名解析，能拿到value進(jìn)行解析
        if (value != null) {
            if (isBasicDataTypes(parameterType)) {
                return value;
            }
            return JSON.parseObject(value.toString(), parameterType);
        }
 
        // 解析不到則將整個(gè)json串解析為當(dāng)前參數(shù)類型
        if (isBasicDataTypes(parameterType)) {
            if (parameterAnnotation.required()) {
                throw new IllegalArgumentException(String.format("required param %s is not present", key));
            } else {
                return null;
            }
        }
 
        Object result = parameterType.newInstance();
        // 非基本類型，不允許解析所有字段，返回null
        if (!parameterAnnotation.parseAllFields()) {
            // 如果是必傳參數(shù)拋異常
            if (parameterAnnotation.required()) {
                throw new IllegalArgumentException(String.format("required param %s is not present", key));
            }
            // 否則返回空對(duì)象
            return result;
        }
       // 非基本類型，允許解析，將外層屬性解析
        result = JSON.parseObject(jsonObject.toString(), parameterType);
        // 如果非必要參數(shù)直接返回，否則如果沒(méi)有一個(gè)屬性有值則報(bào)錯(cuò)
        if (!parameterAnnotation.required()) {
                return result;
        }else{
            boolean haveValue = false;
            Field[] declaredFields = parameterType.getDeclaredFields();
            for(Field field : declaredFields){
                field.setAccessible(true);
                if(field.get(result) != null){
                    haveValue = true;
                    break;
                }
            }
            if(!haveValue){
                throw new IllegalArgumentException(String.format("required param %s is not present", key));
            }
            return result;
        }
    }
 
    /**
     * 基本數(shù)據(jù)類型直接返回
     */
    @SuppressWarnings("rawtypes")
    private boolean isBasicDataTypes(Class clazz) {
  Set<Class> classSet = new HashSet<>();
        classSet.add(String.class);
        classSet.add(Integer.class);
        classSet.add(Long.class);
        classSet.add(Short.class);
        classSet.add(Float.class);
        classSet.add(Double.class);
        classSet.add(Boolean.class);
        classSet.add(Character.class);
        return classSet.contains(clazz);
    }
 
    /**
     * 獲取請(qǐng)求體JSON字符串
     */
    private String getRequestBody(NativeWebRequest webRequest) {
        HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
 
        // 有就直接獲取
        String jsonBody = (String) webRequest.getAttribute(JSONBODY_ATTRIBUTE, NativeWebRequest.SCOPE_REQUEST);
        // 沒(méi)有就從請(qǐng)求中讀取
        if (jsonBody == null) {
            try {
                jsonBody = IOUtils.toString(servletRequest.getReader());
                webRequest.setAttribute(JSONBODY_ATTRIBUTE, jsonBody, NativeWebRequest.SCOPE_REQUEST);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return jsonBody;
 }
}

package cn.config; 
import java.nio.charset.Charset;
import java.util.List; 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 
/**
 * Title:      WebConfig
 * @date       2018年9月10日
 * @version    V1.0
 * Description: 將自定義注解配置到spring
 */
 
@Configuration
@SuppressWarnings("deprecation")
public class WebConfig extends WebMvcConfigurerAdapter{
 @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(new RequestJsonHandlerMethodArgumentResolver());
    }
 
    @Bean
    public HttpMessageConverter<String> responseBodyConverter() {
        return new StringHttpMessageConverter(Charset.forName("UTF-8"));
    }
 
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        super.configureMessageConverters(converters);
        converters.add(responseBodyConverter());
    }
}