top.jfunc.http.interfacing.HttpRequestFactory Maven / Gradle / Ivy

Go to download
package top.jfunc.http.interfacing;

import top.jfunc.http.annotation.*;
import top.jfunc.http.base.*;
import top.jfunc.http.config.Config;
import top.jfunc.http.holderrequest.DefaultBodyRequest;
import top.jfunc.http.holderrequest.DefaultRequest;
import top.jfunc.http.holderrequest.DefaultFormBodyRequest;
import top.jfunc.http.holderrequest.DefaultUploadRequest;
import top.jfunc.http.request.HttpRequest;
import top.jfunc.common.utils.ArrayListMultiValueMap;
import top.jfunc.common.utils.ArrayUtil;
import top.jfunc.common.utils.MultiValueMap;

import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.net.URI;
import java.net.URL;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static top.jfunc.http.interfacing.TypeUtils.methodError;
import static top.jfunc.http.interfacing.TypeUtils.parameterError;

/**
 * @author xiongshiyan at 2019/5/24 , contact me with email [email protected] or phone 15208384257
 */
class HttpRequestFactory implements RequestFactory {
    private static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
    /**
     * 形如{id}这样的路径参数
     */
    private static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{(" + PARAM + ")\\}");
    private static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
    /**
     * 传入的方法
     */
    private java.lang.reflect.Method method;

    /**
     * 通过method计算获取请求方法
     */
    private Method httpMethod;

    /**
     * 全局配置
     */
    private Config config;

    /**
     * 参数对应的处理器
     */
    private final AbstractParameterHandler[] parameterHandlers;

    /**
     * 是否有Body
     * @see POST
     * @see GET
     */
    private boolean hasBody = false;
    /**
     * 是否是文件上传
     * @see Multipart
     */
    private boolean multiPart = false;
    /**
     * 是否是FormUrlEncoded
     * @see FormUrlEncoded
     */
    private boolean formEncoded = false;
    /**
     * Content-Type
     */
    private MediaType contentType;
    /**
     * @Headers 注解添加的header
     */
    private MultiValueMap headers;
    /**
     * 请求的相对URL
     */
    private String relativeUrl;
    /**
     * 路径参数名称集合
     */
    private Set relativeUrlParamNames;

    private boolean gotField;
    private boolean gotPart;
    private boolean gotBody;
    private boolean gotPath;
    private boolean gotQuery;
    private boolean gotQueryMap;
    private boolean gotUrl;

    public HttpRequestFactory(java.lang.reflect.Method method, Config config) {
        this.method = method;
        this.config = config;

        //处理方法上的注解
        for (Annotation annotation : method.getAnnotations()) {
            parseMethodAnnotation(annotation);
        }

        if (httpMethod == null) {
            throw methodError(method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).");
        }

        if (!hasBody) {
            if (multiPart) {
                throw methodError(method,
                        "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
            }
            if (formEncoded) {
                throw methodError(method, "FormUrlEncoded can only be specified on HTTP methods with "
                        + "request body (e.g., @POST).");
            }
        }

        //方法泛型参数类型
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        //方法的实际类型
        Class[] parameterTypes = method.getParameterTypes();
        //方法参数的注解
        Annotation[][] parameterAnnotationsArray = method.getParameterAnnotations();

        int parameterCount = parameterAnnotationsArray.length;
        parameterHandlers = new AbstractParameterHandler[parameterCount];
        for (int p = 0; p < parameterCount; p++) {

            if(HttpRequest.class.isAssignableFrom(parameterTypes[p])){
                //HttpRequest已经有URL了
                gotUrl = true;
                parameterHandlers[p] = AbstractParameterHandler.DoNothing.INSTANCE;
            }else {
                parameterHandlers[p] = parseParameter(p, genericParameterTypes[p], parameterAnnotationsArray[p]);
            }

        }

        if (relativeUrl == null && !gotUrl) {
            throw methodError(method, "Missing either @%s URL or @Url parameter.", httpMethod);
        }
        if (!formEncoded && !multiPart && !hasBody && gotBody) {
            throw methodError(method, "Non-body HTTP method cannot contain @Body.");
        }
        if (formEncoded && !gotField) {
            throw methodError(method, "Form-encoded method must contain at least one @Field.");
        }
        if (multiPart && !gotPart) {
            throw methodError(method, "Multipart method must contain at least one @Part.");
        }
    }

    @Override
    public Method getHttpMethod() {
        return httpMethod;
    }

    @Override
    public HttpRequest httpRequest(Object[] args){

        int argumentCount = args.length;
        if (argumentCount != parameterHandlers.length) {
            throw new IllegalArgumentException("Argument count (" + argumentCount
                    + ") doesn't match expected count (" + parameterHandlers.length + ")");
        }


        HttpRequest httpRequest = initHttpRequest();

        //如果直接传递的是HttpRequest，就忽略其他的注解，因为他已经包含了请求所需的所有信息
        if(ArrayUtil.isNotEmpty(args)){
            if(args[0] instanceof HttpRequest){
                httpRequest = (HttpRequest) (args[0]);
            }
        }



        AbstractParameterHandler