二、openfeign生成并调用客户端动态代理对象

所有文章

https://www.cnblogs.com/lay2017/p/11908715.html

正文

上一篇文章中，我们了解到了@FeignClient注解的接口被扫描到以后，会生成一个FeignClientFactoryBean的BeanDefinition。然后，spring将会通过调用FeignClientFactoryBean的getObject方法来获取@FeignClient注解的接口对应的代理对象。

生成proxy对象

本文，从FeignClientFactoryBean的getObject方法开始，看看代理对象的生成。跟进getObject方法

public Object getObject() throws Exception {

    return getTarget();

}

继续跟进getTarget，该方法做了一些预处理。获取了一个上下文以及Feign的构造器，没有URL的情况下拼接了一个

FeignContext是在FeignAutoConfiguration被解析的时候成为Bean的

<T> T getTarget() {

    // 获取一个上下文

    FeignContext context = this.applicationContext.getBean(FeignContext.class);

    // feign用于构造代理对象，builder将会构建feign

    Feign.Builder builder = feign(context);

    if (!StringUtils.hasText(this.url)) {

        // 拼接URL地址，如：http://service-provider/

        if (!this.name.startsWith("http")) {

            this.url = "http://" + this.name;

        } else {

            this.url = this.name;

        }

        this.url += cleanPath();

        return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type, this.name, this.url));

    }

    // ... 省略

}

预处理之后，进入loadBalance方法

protected <T> T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget<T> target) {

    // 获取执行http请求的客户端

    Client client = getOptional(context, Client.class);

    if (client != null) {

        builder.client(client);

        // 选择获取代理对象的实现类，默认是HystrixTargeter

        Targeter targeter = get(context, Targeter.class);

        return targeter.target(this, builder, context, target);

    }

    throw new IllegalStateException("No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");

}

获取代理对象的实现由Targeter的实现类处理，默认是HystrixTargeter

跟进HystrixTargeter的target方法

public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context, Target.HardCodedTarget<T> target) {

    if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {

        return feign.target(target);

    }

    // ...

    return feign.target(target);

}

前面说过，Feign实现了构造代理对象的过程，所以这里将会回调feign的构造过程方法

跟进feign的target方法，build将会构造出Feign对象，而newInstance会返回代理对象

public <T> T target(Target<T> target) {

  return build().newInstance(target);

}

public Feign build() {

  // ...

  return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);

}

跟进newInstance方法，看看代理对象是如何被构建的

public <T> T newInstance(Target<T> target) {

    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);

    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();

    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();

    for (Method method : target.type().getMethods()) {

      if (method.getDeclaringClass() == Object.class) {

        continue;

      } else if (Util.isDefault(method)) {

        DefaultMethodHandler handler = new DefaultMethodHandler(method);

        defaultMethodHandlers.add(handler);

        methodToHandler.put(method, handler);

      } else {

        methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));

      }

    }

    InvocationHandler handler = factory.create(target, methodToHandler);

    // jdk的动态代理获取的代理对象

    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[] {target.type()}, handler);

    for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {

      defaultMethodHandler.bindTo(proxy);

    }

    return proxy;

}

代理对象的构建主要由三块内容

1、构建Method到MethodHandler的映射关系，后面调用代理的对象的时候将会根据Method找到MethodHandler然后调用MethodHandler的invoke方法，而MethodHandler将包含发起http请求的实现。

2、jdk动态代理需要提供InvocationHandler，这个大家比较熟悉了。而InvocationHandler将由InvocationHandlerFactory的create方法实现

3、通过Proxy.newProxyInstance方法，生成proxy对象。

这里我们看看factory.create方法生成InvocationHandler的实现吧

static final class Default implements InvocationHandlerFactory {

    @Override

    public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {

      // 这是一个内部类的实现

      return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);

    }

  }

调用proxy对象发起http请求

我们知道，jdk的动态代理将会调用FeignInvocationHandler的invoke方法。所以，我们看看FeignInvocationHandler是怎么调用Method的

private final Map<Method, MethodHandler> dispatch;

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

  // ...

  return dispatch.get(method).invoke(args);

}

前面我们说到，构建proxy对象的时候会构建Method和MethodHandler的映射关系。而这里invoke代理对象的时候又会根据method来获取到MethodHandler，再调用其invoke方法。

MethodHandler的默认实现类是SynchronousMethodHandler，我们跟进它的invoke方法

public Object invoke(Object[] argv) throws Throwable {

    RequestTemplate template = buildTemplateFromArgs.create(argv);

    Options options = findOptions(argv);

    Retryer retryer = this.retryer.clone();

    while (true) {

      try {

        return executeAndDecode(template, options);

      } catch (RetryableException e) {

        // ...

      }

    }

  }

熟悉的代码来了，executeAndDecode将会负责发起http请求

Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {

    Request request = targetRequest(template);

    Response response;

    try {

         // 执行http请求

      response = client.execute(request, options);

    } catch (IOException e) {

    }

    try {

      //...

      // http请求成功

      if (response.status() >= 200 && response.status() < 300) {

          // 无需返回值

        if (void.class == metadata.returnType()) {

          return null;

        } else {

          // 解码结果

          Object result = decode(response);

          return result;

        }

      } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {

        // ...

      } else {

        // ...

      }

    } catch (IOException e) {

      // ...

    } finally {

      // ...

    }

  }

总结

openFeign生成@FeignClient注解的接口的代理对象是从FeignClientFactoryBean的getObject方法开始的，生成proxy对象主要由ReflectiveFeign对象来实现。动态代理方法由jdk原生的动态代理支持。

调用proxy对象，其实就是发起http请求，请求结果将被解码并返回。

所以，正如Feign本身的意义一样，http远程调用被伪装成了本地调用一样简单的代理对象，对于使用者来说就是调用本地接口一样简单。

巴特西

二、openfeign生成并调用客户端动态代理对象

所有文章

正文

生成proxy对象

调用proxy对象发起http请求

总结

最新文章

热门文章