Dubbo源码解析-Dubbo服务消费者_Injvm协议（一）

本文主要是介绍Dubbo源码解析-Dubbo服务消费者_Injvm协议（一），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

前言：

前两篇我们分析了Dubbo服务提供者，在创建时的基本配置属性，如ServiceConfig、ApplicationConfig、RegistryConfig等。基本了解了基于API方式来创建Dubbo服务提供者的套路。

同时第二篇我们分析了在injvm（本地）模式下，dubbo服务如何向外注册（本质上还是注册在本地的map中，就是InjvmProtocol.exporterMap中），等待同进程中的服务消费者来调用（这个很重要，笔者基于Dubbo-demo源码中测试代码进行测试时候，无论怎样，消费者都会报错，找不到服务提供者，就是因为消费者和提供者不在同一个进程内）。

下面我们就来看下基于Injvm模式下的服务消费者创建方式及源码分析。

1.Injvm模式下的服务消费者和创建者

代码来自dubbo-2.7.7中dubbo-demo-api项目下的Application，笔者有所精简（最主要的是将服务的发布和消费放到同一个main方法中了）

public class Application {
	// 服务提供者代码有所精简，本质上还是与之前的示例一样
	public static void main(String[] args) throws Exception {
        startWithExport();
        runWithRefer();
    }

    // 服务提供者
    private static void startWithExport() throws InterruptedException {
        ServiceConfig<DemoServiceImpl> service = new ServiceConfig<>();
        service.setInterface(DemoService.class);
        service.setRef(new DemoServiceImpl());
        service.setApplication(new ApplicationConfig("dubbo-demo-api-provider"));
        service.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181"));

        // 只暴露在本地，当前进程内
        service.setScope("local");
        service.export();

        System.out.println("dubbo service started");
//        new CountDownLatch(1).await();
    }

	// 服务消费者
    private static void runWithRefer() {
        ReferenceConfig<DemoService> reference = new ReferenceConfig<>();
        reference.setApplication(new ApplicationConfig("dubbo-demo-api-consumer"));
        reference.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181"));
        reference.setInterface(DemoService.class);
        // 寻找本地模式的服务提供者
        reference.setScope("local");
        DemoService service = reference.get();
        String message = service.sayHello("dubbo");
        System.out.println(message);
    }
}

有关于ApplicationConfig、RegistryConfig等之前都已经有过介绍，不再赘述。我们主要来看下ReferenceConfig

1.1 ReferenceConfig

public class ReferenceConfig<T> extends ReferenceConfigBase<T> {
 	// 在 Dubbo服务提供（Injvm）中我们有过分析，这里返回的就是Protocol$Adaptive，
    // 调用链是Protocol$Adaptive --> ProtocolFilterWrapper  --> ProtocolListenerWrapper --> InjvmProtocol
    private static final Protocol REF_PROTOCOL = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
	// 这个暂时用不上，可以先忽略
    private static final Cluster CLUSTER = ExtensionLoader.getExtensionLoader(Cluster.class).getAdaptiveExtension();
	// 同理，这里返回的是ProxyFactory$Adaptive，调用链是StubProxyFactoryWrapper --> JavassistProxyFactory
    private static final ProxyFactory PROXY_FACTORY = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();

    // 注册的接口类
    private transient volatile T ref;
    // ReferenceConfig主要属性就是以上
    ...
}

// ReferenceConfigBase
public abstract class ReferenceConfigBase<T> extends AbstractReferenceConfig {
 
    // 接口名
    protected String interfaceName;

    //接口类信息
    protected Class<?> interfaceClass;

    /**
     * client type TODO
     */
    protected String client;

    // 用于点对点模式下指定调用的url
    protected String url;

    // 消费者配置信息（指定线程数等信息）
    protected ConsumerConfig consumer;

    // 指定协议
    protected String protocol;

    protected ServiceMetadata serviceMetadata;
}

主要属性就是上述这些，没有什么特别的东西。

有关于Protocol$Adaptive、ProxyFactory$Adaptive的内容可参考 Dubbo源码解析-Dubbo服务提供者_Injvm协议（二）_恐龙弟旺仔的博客-CSDN博客

2.Injvm消费者源码分析

2.1 ReferenceConfig.get()

public class ReferenceConfig<T> extends ReferenceConfigBase<T> {
	public synchronized T get() {
        if (destroyed) {
            throw new IllegalStateException("The invoker of ReferenceConfig(" + url + ") has already destroyed!");
        }
        // 交由init()方法处理
        if (ref == null) {
            init();
        }
        return ref;
    }
    
    public synchronized void init() {
        // 初始化过的则不再初始化
        if (initialized) {
            return;
        }
		...
		// 这里主要用于设置属性 serviceMetadata
        checkAndUpdateSubConfigs();

		...
        Map<String, String> map = new HashMap<String, String>();
        map.put(SIDE_KEY, CONSUMER_SIDE);

        ReferenceConfigBase.appendRuntimeParameters(map);
        ...
        // 一系列的配置参数，不是重点，直接忽略
        map.put(INTERFACE_KEY, interfaceName);
        AbstractConfig.appendParameters(map, getMetrics());
        ...
        serviceMetadata.getAttachments().putAll(map);

        // 这里是重点
        ref = createProxy(map);

        serviceMetadata.setTarget(ref);
        serviceMetadata.addAttribute(PROXY_CLASS_REF, ref);
        ...
    }
}

这里主要是解析ApplicationConfig等配置的参数到map中，最终添加到ServiceConfig中

// 在笔者当前的示例中，map的内容如下：
	"side" -> "consumer"
    "application" -> "dubbo-demo-api-consumer"
    "register.ip" -> "xxx.xxx"
    "release" -> ""
    "methods" -> "sayHello,sayHelloAsync"
    "scope" -> "local"
    "sticky" -> "false"
    "dubbo" -> "2.0.2"
    "pid" -> "9612"
    "interface" -> "org.apache.dubbo.demo.DemoService"
    "timestamp" -> "1628079039393"

2.2 ReferenceConfig.createProxy()

public class ReferenceConfig<T> extends ReferenceConfigBase<T> {
	private T createProxy(Map<String, String> map) {
        // 这里判断是否injvm模式，本例中时 是
        if (shouldJvmRefer(map)) {
            // 本例中生成的url 内容为：injvm://127.0.0.1/org.apache.dubbo.demo.DemoService?application=dubbo-demo-api-consumer&dubbo=2.0.2&interface=org.apache.dubbo.demo.DemoService&methods=sayHello,sayHelloAsync&pid=9612&register.ip=172.20.89.171&release=&scope=local&side=consumer&sticky=false&timestamp=1628079039393
            URL url = new URL(LOCAL_PROTOCOL, LOCALHOST_VALUE, 0, interfaceClass.getName()).addParameters(map);
            
            // 这里通过代理对象生成invoker，通过之前的分析我们知道，最终会调用InjvmProtocol.refer()方法，具体分析见2.2.1
            invoker = REF_PROTOCOL.refer(interfaceClass, url);
            if (logger.isInfoEnabled()) {
                logger.info("Using injvm service " + interfaceClass.getName());
            }
        } else {
            // 非本地模式的不是本文重点，先忽略
        }

        // 如果当前没有设置check=false，并且Invoker没有找到合适的服务提供者（怎么找呢，见2.2.2）
        if (shouldCheck() && !invoker.isAvailable()) {
            invoker.destroy();
            throw new IllegalStateException("Failed to check the status of the service "
                    + interfaceName
                    + ". No provider available for the service "
                    + (group == null ? "" : group + "/")
                    + interfaceName +
                    (version == null ? "" : ":" + version)
                    + " from the url "
                    + invoker.getUrl()
                    + " to the consumer "
                    + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion());
        }
        ...
        String metadata = map.get(METADATA_KEY);
        WritableMetadataService metadataService = WritableMetadataService.getExtension(metadata == null ? DEFAULT_METADATA_STORAGE_TYPE : metadata);
        if (metadataService != null) {
            URL consumerURL = new URL(CONSUMER_PROTOCOL, map.remove(REGISTER_IP_KEY), 0, map.get(INTERFACE_KEY), map);
            metadataService.publishServiceDefinition(consumerURL);
        }
        // 重要的又来了，我们接着看
        return (T) PROXY_FACTORY.getProxy(invoker, ProtocolUtils.isGeneric(generic));
    }
}

2.2.1 Protocol$Adaptive.refer()

调用链依旧是 Protocol$Adaptive --> ProtocolFilterWrapper --> ProtocolListenerWrapper --> InjvmProtocol

我们直接看InjvmProtocol.refer()方法

public abstract class AbstractProtocol implements Protocol {
 
    public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        // 最终由InjvmProtocol.protocolBindingRefer实现
        return new AsyncToSyncInvoker<>(protocolBindingRefer(type, url));
    }
}

// InjvmProtocol.protocolBindingRefer
public class InjvmProtocol extends AbstractProtocol implements Protocol {
    public <T> Invoker<T> protocolBindingRefer(Class<T> serviceType, URL url) throws RpcException {
        // 这个exporterMap很重要，就是之前我们injvm模式下，服务提供者将当前服务注册的地方，在当前Invoker中，直接把这个map当做构造参数传入
        return new InjvmInvoker<T>(serviceType, url, url.getServiceKey(), exporterMap);
    }
}

class InjvmInvoker<T> extends AbstractInvoker<T> {
    private final Map<String, Exporter<?>> exporterMap;
    
    InjvmInvoker(Class<T> type, URL url, String key, Map<String, Exporter<?>> exporterMap) {
        super(type, url);
        this.key = key;
        this.exporterMap = exporterMap;
    }
}

重要：我们要正确的理解exporterMap，服务提供者（Injvm模式）会将当前服务添加到这个map中，key就是我们当前的接口全限定名。

现在我们在创建服务消费者（Injvm模式），会将InjvmProtocol中的这个exporterMap当做构造参数直接传入InjvmInvoker中，正好作为后续的使用。

2.2.2 invoker.isAvailable()

本质上还是InjvmInvoker.isAvailable()方法的调用

class InjvmInvoker<T> extends AbstractInvoker<T> {
    public boolean isAvailable() {
        // 接着上面的看，就是看exporterMap是否有当前接口的服务提供者
        InjvmExporter<?> exporter = (InjvmExporter<?>) exporterMap.get(key);
        if (exporter == null) {
            return false;
        } else {
            return super.isAvailable();
        }
    }
}

2.3 PROXY_FACTORY.getProxy()

正确的调用链就是 ProxyFactory$Adaptive --> StubProxyFactoryWrapper --> JavassistProxyFactory

我们直接看JavassistProxyFactory.getProxy()

public class JavassistProxyFactory extends AbstractProxyFactory {
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        // 之前的文章中有分析过Proxy.getProxy，就是使用javassist动态创建代理类，最终还是调用InjvmInvoker来实现
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }
}

// Proxy.getProxy()
public abstract class Proxy {
	public static Proxy getProxy(ClassLoader cl, Class<?>... ics) {
        ...

            // create ProxyInstance class.
            String pcn = pkg + ".proxy" + id;
            ccp.setClassName(pcn);
            ccp.addField("public static java.lang.reflect.Method[] methods;");
            ccp.addField("private " + InvocationHandler.class.getName() + " handler;");
            ccp.addConstructor(Modifier.PUBLIC, new Class<?>[]{InvocationHandler.class}, new Class<?>[0], "handler=$1;");
            ccp.addDefaultConstructor();
            Class<?> clazz = ccp.toClass();
            clazz.getField("methods").set(null, methods.toArray(new Method[0]));

            // create Proxy class.
            String fcn = Proxy.class.getName() + id;
            ccm = ClassGenerator.newInstance(cl);
            ccm.setClassName(fcn);
            ccm.addDefaultConstructor();
            ccm.setSuperClass(Proxy.class);
            ccm.addMethod("public Object newInstance(" + InvocationHandler.class.getName() + " h){ return new " + pcn + "($1); }");
            Class<?> pc = ccm.toClass();
        // 还是动态生成代理那一套，我们直接看下动态生成的代理类的内容，见2.3.1
            proxy = (Proxy) pc.newInstance();
        } catch (RuntimeException e) {
            ...
        }
        return proxy;
    }
}

2.3.1 org.apache.dubbo.common.bytecode.Proxy0

如何查看动态生成的类呢？可以参考这篇文章：https://blog.csdn.net/yfxhao123/article/details/109472166

package org.apache.dubbo.common.bytecode;
import java.lang.reflect.InvocationHandler;

// 其继承的这个Proxy就是org.apache.dubbo.common.bytecode.Proxy抽象类，并实现了其抽象方法newInstance()
public class Proxy0
  extends Proxy
  implements ClassGenerator.DC
{
  public Object newInstance(InvocationHandler paramInvocationHandler)
  {
    return new proxy0(paramInvocationHandler);
  }
}

总结：我们上面示例代码中reference.get()最终返回的就是一个调用代理类Proxy（针对InjvmInvoker的代理类InvokerInvocationHandler对象）

最终，我们还是要通过InvokerInvocationHandler来真正实现调用。

2.4 InvokerInvocationHandler.invoke()

public class InvokerInvocationHandler implements InvocationHandler {
 
    // 这里传入的proxy就是 上面的InjvmInvoker对象
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(invoker, args);
        }
        String methodName = method.getName();
        Class<?>[] parameterTypes = method.getParameterTypes();
        ...
        // 创建RpcInvocation
        RpcInvocation rpcInvocation = new RpcInvocation(method, invoker.getInterface().getName(), args);
        String serviceKey = invoker.getUrl().getServiceKey();
        rpcInvocation.setTargetServiceUniqueName(serviceKey);
      
        if (consumerModel != null) {
            rpcInvocation.put(Constants.CONSUMER_MODEL, consumerModel);
            rpcInvocation.put(Constants.METHOD_MODEL, consumerModel.getMethodModel(method));
        }

        // 还是交由invoker执行，后续的还是熟悉的配方，调用链依次执行ProtocolFilterWrapper --> ListenerInvokerWrapper --> InjvmInvoker
        return invoker.invoke(rpcInvocation).recreate();
    }
}

中间的ProtocolFilterWrapper、ListenerInvokerWrapper，我们先不分析，后续讲到Filter时会仔细说明。

直接来看最终的调用InjvmInvoker

2.4 InjvmInvoker.doInvoker()

class InjvmInvoker<T> extends AbstractInvoker<T> {
	public Result doInvoke(Invocation invocation) throws Throwable {
        // 获取之前存放在exporterMap中的InjvmExporter
        Exporter<?> exporter = InjvmProtocol.getExporter(exporterMap, getUrl());
        if (exporter == null) {
            throw new RpcException("Service [" + key + "] not found.");
        }
        RpcContext.getContext().setRemoteAddress(LOCALHOST_VALUE, 0);
        
        // InjvmExport.invoker就是我们之前分析的，忘记的可以再翻翻看下 Dubbo服务提供（Injvm）
        return exporter.getInvoker().invoke(invocation);
    }
}

貌似又回来了，我们拿到服务提供者的InjvmExporter之后，其Invoker属性就是之前文章中说的 JavassistProxyFactory.getInvoker()方法所返回的那个AbstractProxyInvoker

2.5 调回到AbstractProxyInvoker.doInvoke()

public class JavassistProxyFactory extends AbstractProxyFactory {
	...
    @Override
    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
        // TODO Wrapper cannot handle this scenario correctly: the classname contains '$'
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
        return new AbstractProxyInvoker<T>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class<?>[] parameterTypes,
                                      Object[] arguments) throws Throwable {
                // 最终执行到这个方法，而wrapper.invokeMethod()的调用见2.5.1
                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }
}

2.5.1 Wrapper1.invokeMethod()

public class Wrapper0
  extends Wrapper
  implements ClassGenerator.DC
{
public Object invokeMethod(Object paramObject, String paramString, Class[] paramArrayOfClass, Object[] paramArrayOfObject)
    throws InvocationTargetException
  {
    DemoServiceImpl localDemoServiceImpl;
    try
    {
      localDemoServiceImpl = (DemoServiceImpl)paramObject;
    }
    catch (Throwable localThrowable1)
    {
      throw new IllegalArgumentException(localThrowable1);
    }
    try
    {
    // 在这里实现了对localDemoServiceImpl的调用，就是我们在创建ServiceConfig时setRef()方法所引用的类，本例中即为 new DemoServiceImpl()
      if ((!"sayHello".equals(paramString)) || (paramArrayOfClass.length == 1)) {
        return localDemoServiceImpl.sayHello((String)paramArrayOfObject[0]);
      }
      if ((!"sayHelloAsync".equals(paramString)) || (paramArrayOfClass.length == 1)) {
        return localDemoServiceImpl.sayHelloAsync((String)paramArrayOfObject[0]);
      }
    }
    catch (Throwable localThrowable2)
    {
      throw new InvocationTargetException(localThrowable2);
    }
    throw new NoSuchMethodException("Not found method \"" + paramString + "\" in class org.apache.dubbo.demo.provider.DemoServiceImpl.");
  }
}

总结：

1.通过创建ReferenceConfig，在调用其get()方法时，会返回InjvmInvoker对象，该对象的exporterMap即当前InjvmProtocol下的所有服务提供者信息；

2.通过ProxyFactory$Adaptive创建对InjvmInvoker的代理，最终调用到JavassistProxyFactory.getProxy()来实现，动态创建了对InjvmInvoker的代理类Proxy0；

3.在调用业务方法Proxy0.sayHello()时，实际调用的是InjvmInvoker.doInvoker()方法，这里会从之前保存的exporterMap中获取对应的Exporter实现类，并获取Exporter.getInvoker()对象，调用其invoke()方法，此时我们又回到了服务端的逻辑

4.Exporter.getInvoker()本质上就是JavassistProxyFactory.getInvoker()方法返回值，即AbstractProxyInvoker，其doInvoke()调用交由wrapper实现

5.根据我们对Wrapper1（动态生成的对象）进行解析，可以发现，其最终调用的还是我们在ServiceConfig.setRef()中设置的实现类。

最重要的两个方法：

public class ReferenceConfig<T> extends ReferenceConfigBase<T> {
	private T createProxy(Map<String, String> map) {
        if (shouldJvmRefer(map)) {
            URL url = new URL(LOCAL_PROTOCOL, LOCALHOST_VALUE, 0, interfaceClass.getName()).addParameters(map);
            // 1.生成Invoker
            invoker = REF_PROTOCOL.refer(interfaceClass, url);
        } else {
            // 非本地模式的不是本文重点，先忽略
        }

        ...
        // 2.生成Proxy
        return (T) PROXY_FACTORY.getProxy(invoker, ProtocolUtils.isGeneric(generic));
    }
}

所以，服务消费者的主要过程也就是：将消费转变为Invoker（本例中为InjvmInvoker）；将Invoker转变为Proxy

最后，用一张时序图来展示下消费者（Injvm模式）全过程

这篇关于Dubbo源码解析-Dubbo服务消费者_Injvm协议（一）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程