com.ifengxue.http.proxy.RequestInvoker Maven / Gradle / Ivy

/*
 * Copyright 2019 https://www.ifengxue.com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


package com.ifengxue.http.proxy;

import com.ifengxue.http.HttpClientException;
import com.ifengxue.http.annotation.BodyType;
import com.ifengxue.http.annotation.Delete;
import com.ifengxue.http.annotation.Get;
import com.ifengxue.http.annotation.Head;
import com.ifengxue.http.annotation.HttpMethod;
import com.ifengxue.http.annotation.Patch;
import com.ifengxue.http.annotation.Post;
import com.ifengxue.http.annotation.Put;
import com.ifengxue.http.annotation.ResponseType;
import com.ifengxue.http.annotation.Rest;
import com.ifengxue.http.collection.MultiMap;
import com.ifengxue.http.collection.MultiValueMap;
import com.ifengxue.http.contract.Callback;
import com.ifengxue.http.contract.HttpOperations;
import com.ifengxue.http.contract.HttpResponse;
import com.ifengxue.http.executor.HttpExecutor;
import com.ifengxue.http.executor.HttpExecutorFactory;
import com.ifengxue.http.executor.Request;
import com.ifengxue.http.executor.Request.Builder;
import com.ifengxue.http.parser.HttpParser;
import com.ifengxue.http.parser.HttpParserFactory;
import com.ifengxue.http.parser.StreamHttpParser;
import com.ifengxue.http.util.TypeUtil;
import com.ifengxue.http.util.Version;
import io.mikael.urlbuilder.UrlBuilder;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpHost;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.impl.client.CloseableHttpClient;

/**
 * 请求调用代理
 */
public class RequestInvoker implements InvocationHandler, HttpClientConfig, HttpOperations {

  private static final Timeout NOT_SET_TIMEOUT = new Timeout();
  private final Class proxyInterface;
  private final HttpExecutorFactory executorFactory = new HttpExecutorFactory();
  private final HttpParserFactory parserFactory = new HttpParserFactory();
  private final LinkedList interceptors = new LinkedList<>();
  private final Map headers = new HashMap<>();
  private final MultiMap parameters = new MultiValueMap<>();
  private final Map httpOperationsDelegateMethod = new ConcurrentHashMap<>();
  private final Rest rest;
  private volatile URL prefixUrl;
  private Charset charset = UTF_8;
  private HttpHost proxy;
  private Timeout timeout = NOT_SET_TIMEOUT;
  private volatile UsernamePasswordCredentials basicAuthCredentials;
  private AtomicBoolean basicAuthInterceptorHasSet = new AtomicBoolean(false);
  /**
   * 自定义的http client
   */
  private CloseableHttpClient customHttpClient;
  private ExecutorService threadPool;

  private RequestInvoker(Class proxyInterface) {
    this.proxyInterface = proxyInterface;
    rest = proxyInterface.getAnnotation(Rest.class);
    setUserAgent("Http-client-proxy/" + Version.getVersion() + " Java/" + SystemUtils.JAVA_VERSION);
  }

  /**
   * 使用Thread.currentThread().getContextClassLoader()作为类加载器创建请求代理
   *
   * @param proxyInterface 被代理的接口
   */
  public static  T create(Class proxyInterface) {
    return create(proxyInterface, Thread.currentThread().getContextClassLoader());
  }

  /**
   * 创建请求代理
   *
   * @param proxyInterface 被代理的接口
   * @param classLoader 类加载器
   */
  @SuppressWarnings("unchecked")
  public static  T create(Class proxyInterface, ClassLoader classLoader) {
    Objects.requireNonNull(proxyInterface, "proxyInterface cannot be null");
    if (!proxyInterface.isInterface()) {
      throw new IllegalArgumentException(proxyInterface.getName() + " not an interface");
    }
    classLoader = classLoader == null ? Thread.currentThread().getContextClassLoader() : classLoader;
    // 当Thread.currentThread.getContextClassLoader()为null时重新赋值
    classLoader = classLoader == null ? RequestInvoker.class.getClassLoader() : classLoader;
    return (T) Proxy.newProxyInstance(classLoader,
        new Class[]{proxyInterface, HttpClientConfig.class, HttpOperations.class},
        new RequestInvoker(proxyInterface));
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (method.getName().equals("toString") && args == null) {
      return proxyInterface.getSimpleName() + " is proxy by " + getClass().getSimpleName() + "!";
    }
    if (method.getName().equals("hashCode") && args == null) {
      return Objects.hashCode(this);
    }
    if (method.getName().equals("equals") && args != null && args.length == 1) {
      return Objects.equals(this, args[0]);
    }
    if (method.getDeclaringClass() == HttpClientConfig.class) {
      return method.invoke(this, args);
    }
    if (method.isDefault()) {
      Constructor constructor = Lookup.class.getDeclaredConstructor(Class.class);
      constructor.setAccessible(true);
      return constructor.newInstance(method.getDeclaringClass())
          .in(method.getDeclaringClass())
          .unreflectSpecial(method, method.getDeclaringClass())
          .bindTo(proxy)
          .invokeWithArguments(args);
    }
    doInit();
    // invoke after init config
    if (method.getDeclaringClass() == HttpOperations.class) {
      return findHttpOperationsDelegateMethod(method).invoke(this, createNewArgs(method, args));
    }

    RequestMethodHolder requestMethodHolder = createHolder(method);
    MultiMap parameterMap = Resolver.resolveParameters(method, args, requestMethodHolder.getBodyType());

    // 解析request
    Request request = Request.Builder.newBuilder(requestMethodHolder.getMethod())
        .setPrefixUrl(prefixUrl)
        .setSuffixUrl(requestMethodHolder.getSuffixUrl())
        .addHeaders(headers)
        .addHeaders(Resolver.resolveHeaders(method))
        .addHeaders(Resolver.resolveParamHeaders(method, args))
        .addParameters(parameters)
        .addParameters(parameterMap)
        .setBody(Resolver.resolveBody(method, args))
        .addQueryParameterNames(Resolver.resolveQueryParameterNames(method, args))
        .setCallbackHandler(Resolver.findCallbackHandler(method, args))
        .build();
    if (request.getCallbackHandler() == null) {
      Supplier