// 這里可以獲取到處理程序方法參數(shù)解析器的一個列表
        List<HandlerMethodArgumentResolver> argumentResolvers =
                requestMappingHandlerAdapter.getArgumentResolvers()

        //這里可以獲取到處理程序方法返回值的處理器
        List<HandlerMethodReturnValueHandler> originalHandlers = 
                 requestMappingHandlerAdapter.getReturnValueHandlers();

/**
 * @BelongsProject: 
 * @BelongsPackage: 
 * @Author: hef
 * @CreateTime: 2020-06-20 18:49
 * @Description: 描述
 */
public class MyHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {


    /**
     * 這個是處理@RequestParam注解的原本策略類
     */
    private RequestParamMethodArgumentResolver requestParamMethodArgumentResolver;

    /**
     * 全參構(gòu)造
     */
    public MyHandlerMethodArgumentResolver(RequestParamMethodArgumentResolver requestParamMethodArgumentResolver) {
        this.requestParamMethodArgumentResolver = requestParamMethodArgumentResolver;
    }

    /**
     * 當(dāng)參數(shù)前有@RequestParam注解時，會使用此 解析器
     * <p>
     * 注:此方法的返回值將決定:是否使用此解析器解析該參數(shù)
     */
    @Override
    public boolean supportsParameter(MethodParameter methodParameter) {
    	//很明顯,就是判斷是否有這個注解
        return methodParameter.hasParameterAnnotation(RequestParam.class);
    }


    /**
     * 解析參數(shù)
     */
    @Override
    public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer,
                                  NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory)
            throws Exception {
        final String applicationJson = "application/json";
        HttpServletRequest request = nativeWebRequest.getNativeRequest(HttpServletRequest.class);
        if (request == null) {
            throw new RuntimeException(" request must not be null!");
        }
        //獲取到內(nèi)容類型
        String contentType = request.getContentType();
        //如果類型是屬于json 那么則跑自己解析的方法
        if (null != contentType && contentType.contains(applicationJson )) {
        	//獲取參數(shù)名稱
            String parameterName = methodParameter.getParameterName();
            //獲取參數(shù)類型
            Class<?> parameterType = methodParameter.getParameterType();
			//因為json數(shù)據(jù)是放在流里面,所以要去讀取流,
			//但是ServletRequest的getReader()和getInputStream()兩個方法只能被調(diào)用一次，而且不能兩個都調(diào)用。
			//所以這里是需要寫個自定義的HttpServletRequestWrapper,主要功能就是需要重復(fù)讀取流數(shù)據(jù)
            String read = getRead(request.getReader());
            //轉(zhuǎn)換json
            JSONObject jsonObject = JSON.parseObject(read);
            Object o1;
            if (jsonObject == null) {
            	//這里有一個可能性就是比如get請求,參數(shù)是拼接在URL后面,但是如果我們還是去讀流里面的數(shù)據(jù)就會讀取不到
                Map<String, String[]> parameterMap = request.getParameterMap();
                o1 = parameterMap.get(parameterName);
            }else {
                o1 = jsonObject.get(parameterName);
            }
            Object arg = null;
            //如果已經(jīng)獲取到了值的話那么再做類型轉(zhuǎn)換
            if (o1 != null) {
                WebDataBinder binder = webDataBinderFactory.createBinder(nativeWebRequest, null, parameterName);
                arg = binder.convertIfNecessary(o1, parameterType, methodParameter);
            }
            return arg;
        }
		//否則跑原本的策略類.
        Object o = requestParamMethodArgumentResolver.resolveArgument(methodParameter,
                modelAndViewContainer, nativeWebRequest, webDataBinderFactory);
        return o;
    }

    /**
     * 流轉(zhuǎn)字符串
     *
     * @param bf
     * @return
     */
    private static String getRead(BufferedReader bf) {
        StringBuilder sb = new StringBuilder();
        try {
            char[] buff = new char[1024];
            int len;
            while ((len = bf.read(buff)) != -1) {
                sb.append(buff, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }
}

/**
 * @BelongsProject: 
 * @BelongsPackage: 
 * @Author: hef
 * @CreateTime: 2020-06-20 18:49
 * @Description: 描述
 */
@Configuration
public class ConfigArgumentResolvers {
    private final RequestMappingHandlerAdapter requestMappingHandlerAdapter;

    public ConfigArgumentResolvers(RequestMappingHandlerAdapter requestMappingHandlerAdapter) {
        this.requestMappingHandlerAdapter = requestMappingHandlerAdapter;
    }

	//springBoot啟動的時候執(zhí)行
    @PostConstruct
    private void addArgumentResolvers() {
        // 獲取到框架定義好的參數(shù)解析集合
        List<HandlerMethodArgumentResolver> argumentResolvers =
                requestMappingHandlerAdapter.getArgumentResolvers();
        MyHandlerMethodArgumentResolver myHandlerMethodArgumentResolver = getMyHandlerMethodArgumentResolver(argumentResolvers);
        // ha.getArgumentResolvers()獲取到的是不可變的集合,所以我們需要新建一個集合來放置參數(shù)解析器
        List<HandlerMethodArgumentResolver> myArgumentResolvers =
                new ArrayList<>(argumentResolvers.size() + 1);
        //這里有一個注意點就是自定義的處理器需要放在RequestParamMethodArgumentResolver前面
        //為什么呢?因為如果放在它后面的話,那么它已經(jīng)處理掉了,就到不了我們自己定義的策略里面去了
        //所以直接把自定義的策略放在第一個,穩(wěn)妥!
        // 將自定義的解析器，放置在第一個； 并保留原來的解析器
        myArgumentResolvers.add(myHandlerMethodArgumentResolver);
        myArgumentResolvers.addAll(argumentResolvers);
        //再把新的集合設(shè)置進去
        requestMappingHandlerAdapter.setArgumentResolvers(myArgumentResolvers);
    }

    /**
     * 獲取MyHandlerMethodArgumentResolver實例
     */
    private MyHandlerMethodArgumentResolver getMyHandlerMethodArgumentResolver(
            List<HandlerMethodArgumentResolver> argumentResolversList) {
        // 原本處理RequestParam的類
        RequestParamMethodArgumentResolver requestParamMethodArgumentResolver = null;

        if (argumentResolversList == null) {
            throw new RuntimeException("argumentResolverList must not be null!");
        }
        for (HandlerMethodArgumentResolver argumentResolver : argumentResolversList) {
            if (requestParamMethodArgumentResolver != null) {
                break;
            }
            if (argumentResolver instanceof RequestParamMethodArgumentResolver) {
            // 因為在我們自己策略里面是還需要用到這個原本的類的,所以需要得到這個對象實例
                requestParamMethodArgumentResolver = (RequestParamMethodArgumentResolver) argumentResolver;
            }
        }
        if (requestParamMethodArgumentResolver == null) {
            throw new RuntimeException("RequestParamMethodArgumentResolver not be null!");
        }
        //實例化自定義參數(shù)解析器
        return new MyHandlerMethodArgumentResolver(requestParamMethodArgumentResolver);
    }
}

/**
 * @BelongsProject: 
 * @BelongsPackage: 
 * @Author: hef
 * @CreateTime: 2020-06-22 16:29
 * @Description: 描述
 */
public class MyHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private final byte[] body;

    public MyHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        //在讀取流之前獲取一次這個parameterMap,否則讀取流后無法再解析出數(shù)據(jù),
        // 原因是org.apache.catalina.connector.Request里面有usingInputStream 和 usingReader兩個全局變量記錄流是否被讀取過
        //org.apache.catalina.connector.Request里面的parseParameters方法就是用來解析請求參數(shù)(Parse request parameters.)
        //在解析參數(shù)之前會有一個判斷,如果流被讀取過 則不再解析請求參數(shù) //
        // if (usingInputStream || usingReader) { 這是源碼里面的判斷
        //                success = true;
        //                return;
        //            }
        //如果先請求過一次后,那么org.apache.catalina.util.ParameterMap里面會有一個locked狀態(tài),如果讀過一次之后 會變成鎖定狀態(tài) 那么后面再讀都是讀取解析過后的map
        //    /**
        //     * The current lock state of this parameter map.
        //     */
        //    private boolean locked = false;
        request.getParameterMap();
        body = ReadAsChars(request).getBytes(Charset.forName("UTF-8"));
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {

        final ByteArrayInputStream bais = new ByteArrayInputStream(body);

        return new ServletInputStream() {

            @Override
            public int read() throws IOException {
                return bais.read();
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }
        };
    }

	/**
     * 解析流
     * @param request
     * @return
     */
	public static String ReadAsChars(ServletRequest request)
        {
            InputStream is = null;
            StringBuilder sb = new StringBuilder();
            try
            {
                is = request.getInputStream();

                byte[] b = new byte[4096];
                for (int n; (n = is.read(b)) != -1;)
                {
                    sb.append(new String(b, 0, n));
                }
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            finally
            {
                if (null != is)
                {
                    try
                    {
                        is.close();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
            return sb.toString();
        }
}

/**
 * @BelongsProject: 
 * @BelongsPackage: 
 * @Author: hef
 * @CreateTime: 2020-06-22 16:47
 * @Description: 描述
 */
@Component
public class HttpServletRequestReplacedFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;
        if(request instanceof HttpServletRequest) {
            requestWrapper = new MyHttpServletRequestWrapper((HttpServletRequest) request);
        }
        if(null == requestWrapper) {
            chain.doFilter(request, response);
        } else {
            chain.doFilter(requestWrapper, response);
        }
    }
}

    /**
     * 解析Content-Type為application/json的默認解析器是RequestResponseBodyMethodProcessor
     */
    private RequestResponseBodyMethodProcessor requestResponseBodyMethodProcessor;

    /**
     * 解析Content-Type為application/x-www-form-urlencoded的默認解析器是ServletModelAttributeMethodProcessor
     */
    private ServletModelAttributeMethodProcessor servletModelAttributeMethodProcessor;