Dubbo服务引用（一）本地引用

哈哈哈和服务暴露一样，也有两种：

1. 本地引用，jvm本地调用：

// 推荐
<dubbo:service scope="local" />
// 不推荐使用，准备废弃
<dubbo:service injvm="true" />

2. 远程暴露，网络远程通信：

<dubbo:service scope="remote" />

这篇看看本地引用。

在ReferenceConfig中的init() 方法里，会在配置初始化完成后，调用顺序图的起点 createProxy(map) 方法，开始引用服务：

/**
 * 自适应 Protocol 实现对象
 */
private static final Protocol refprotocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
/**
 * 自适应 ProxyFactory 实现对象
 */
private static final ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();
    
/**
 * 直连服务提供者地址
 */
// url for peer-to-peer invocation
private String url;

  private T createProxy(Map<String, String> map) {
      URL tmpUrl = new URL("temp", "localhost", 0, map);
      // 是否本地引用
      final boolean isJvmRefer;
      // injvm 属性为空，不通过该属性判断
      if (isInjvm() == null) {
          // 直连服务提供者，参见文档《直连提供者》http://dubbo.apache.org/zh-cn/docs/user/demos/explicit-target.html
          if (url != null && url.length() > 0) { // if a url is specified, don't do local reference
              isJvmRefer = false;
          // 通过 `tmpUrl` 判断，是否需要本地引用
          } else if (InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl)) {
             // by default, reference local service if there is
              isJvmRefer = true;
          // 默认不是
          } else {
              isJvmRefer = false;
          }
      // 通过 injvm 属性。
      } else {
          isJvmRefer = isInjvm();
      }
  
      // 本地引用
      if (isJvmRefer) {
          // 创建服务引用 URL 对象
          URL url = new URL(Constants.LOCAL_PROTOCOL, NetUtils.LOCALHOST, 0, interfaceClass.getName()).addParameters(map);
          // 引用服务，返回 Invoker 对象
          invoker = refprotocol.refer(interfaceClass, url);
          if (logger.isInfoEnabled()) {
              logger.info("Using injvm service " + interfaceClass.getName());
          }
      // 正常流程，一般为远程引用
      } else {
          // ... 省略本文暂时不分享的服务远程引用 
          }
      }
  
      // 启动时检查
      Boolean c = check;
      if (c == null && consumer != null) {
          c = consumer.isCheck();
      }
      if (c == null) {
          c = true; // default true
      }
      if (c && !invoker.isAvailable()) {
          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());
      }
      if (logger.isInfoEnabled()) {
          logger.info("Refer dubbo service " + interfaceClass.getName() + " from url " + invoker.getUrl());
      }
  
      // 创建 Service 代理对象
      // create service proxy
      return (T) proxyFactory.getProxy(invoker);
  }

上面调用InjvmProtocol的isInjvmRefer(url) 方法，通过 tmpUrl 判断，是否需要本地引用。使用 tmpUrl ，相当于使用服务引用配置对象的配置项：

 /**
  * 是否本地引用
  *
  * @param url URL
  * @return 是否
  */
 public boolean isInjvmRefer(URL url) {
     final boolean isJvmRefer;
     String scope = url.getParameter(Constants.SCOPE_KEY);
     // Since injvm protocol is configured explicitly, we don't need to set any extra flag, use normal refer process.
     // 当 `protocol = injvm` 时，本身已经是 jvm 协议了，走正常流程就是了。
    if (Constants.LOCAL_PROTOCOL.toString().equals(url.getProtocol())) {
         isJvmRefer = false;
     // 当 `scope = local` 或者 `injvm = true` 时，本地引用
     } else if (Constants.SCOPE_LOCAL.equals(scope) || (url.getParameter("injvm", false))) {
         // if it's declared as local reference
         // 'scope=local' is equivalent to 'injvm=true', injvm will be deprecated in the future release
         isJvmRefer = true;
     // 当 `scope = remote` 时，远程引用
     } else if (Constants.SCOPE_REMOTE.equals(scope)) {
         // it's declared as remote reference
         isJvmRefer = false;
     // 当 `generic = true` 时，即使用泛化调用，远程引用。
     } else if (url.getParameter(Constants.GENERIC_KEY, false)) {
         // generic invocation is not local reference
         isJvmRefer = false;
     // 当本地已经有该 Exporter 时，直接本地引用
     } else if (getExporter(exporterMap, url) != null) {
         // by default, go through local reference if there's the service exposed locally
         isJvmRefer = true;
     // 默认，远程引用
     } else {
         isJvmRefer = false;
     }
     return isJvmRefer;
 }

refer(type, url) 方法：

 public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
     // 注册中心
     if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
         return protocol.refer(type, url);
     }
     // 引用服务，返回 Invoker 对象
     // 给改 Invoker 对象，包装成带有 Filter 过滤链的 Invoker 对象
     return buildInvokerChain(protocol.refer(type, url), Constants.REFERENCE_FILTER_KEY, Constants.CONSUMER);
 }

ProtocolListenerWrapper：refer(type, url) 方法：

 public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
     // 注册中心协议
     if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
         return protocol.refer(type, url);
     }
     // 引用服务
     Invoker<T> invoker = protocol.refer(type, url);
     // 获得 InvokerListener 数组
     List<InvokerListener> listeners = Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(InvokerListener.class).getActivateExtension(url, Constants.INVOKER_LISTENER_KEY));
     // 创建 ListenerInvokerWrapper 对象
     return new ListenerInvokerWrapper<T>(invoker, listeners);
 }

InjvmProtocol : refer(type, url) 方法 : 创建 InjvmInvoker 对象。注意，传入的 exporterMap 参数，包含所有的 InjvmExporter 对象。

public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
    return new InjvmInvoker<T>(serviceType, url, url.getServiceKey(), exporterMap);
}

AbstractInvoker ，实现 Invoker 接口，抽象 Invoker 类，主要提供了 Invoker 的通用属性和 invoke(Invocation) 方法的通用实现。属性：

/**
 * 接口类型
 */
private final Class<T> type;
/**
 * 服务 URL
 */
private final URL url;
/**
 * 公用的隐式传参。在 {@link #invoke(Invocation)} 方法中使用。
 */
private final Map<String, String> attachment;
/**
 * 是否可用
 */
private volatile boolean available = true;
/**
 * 是否销毁
 */
private AtomicBoolean destroyed = new AtomicBoolean(false);

InjvmInvoker ，实现 AbstractInvoker 抽象类，Injvm Invoker 实现类, 属性：

/**
 * 服务键
 */
private final String key;
/**
 * Exporter 集合
 *
 * key: 服务键
 *
 * 该值实际就是 {@link com.alibaba.dubbo.rpc.protocol.AbstractProtocol#exporterMap}
 */
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;
}

isAvailable() 方法，是否可用：
开启启动时检查时，调用该方法，判断该 Invoker 对象，是否有对应的 Exporter 。若不存在，说明依赖服务不存在，检查不通过。

@Override
public boolean isAvailable() {
    // 判断是否有 Exporter 对象
    InjvmExporter<?> exporter = (InjvmExporter<?>) exporterMap.get(key);
    if (exporter == null) {
        return false;
    } else {
        return super.isAvailable();
    }
}

ListenerInvokerWrapper ，实现 Invoker 接口，具有监听器功能的 Invoker 包装器：

public class ListenerInvokerWrapper<T> implements Invoker<T> {

    private static final Logger logger = LoggerFactory.getLogger(ListenerInvokerWrapper.class);

    /**
     * 真实的 Invoker 对象
     */
    private final Invoker<T> invoker;
    /**
     * Invoker 监听器数组
     */
    private final List<InvokerListener> listeners;

    public ListenerInvokerWrapper(Invoker<T> invoker, List<InvokerListener> listeners) {
        if (invoker == null) {
            throw new IllegalArgumentException("invoker == null");
        }
        this.invoker = invoker;
        this.listeners = listeners;
        // 执行监听器
        if (listeners != null && !listeners.isEmpty()) {
            for (InvokerListener listener : listeners) {
                if (listener != null) {
                    try {
                        listener.referred(invoker);
                    } catch (Throwable t) {
                        logger.error(t.getMessage(), t);
                    }
                }
            }
        }
    }

    public Class<T> getInterface() {
        return invoker.getInterface();
    }

    public URL getUrl() {
        return invoker.getUrl();
    }

    public boolean isAvailable() {
        return invoker.isAvailable();
    }

    public Result invoke(Invocation invocation) throws RpcException {
        return invoker.invoke(invocation);
    }

    @Override
    public String toString() {
        return getInterface() + " -> " + (getUrl() == null ? " " : getUrl().toString());
    }

    public void destroy() {
        try {
            invoker.destroy();
        } finally {
            // 执行监听器
            if (listeners != null && !listeners.isEmpty()) {
                for (InvokerListener listener : listeners) {
                    if (listener != null) {
                        try {
                            listener.destroyed(invoker);
                        } catch (Throwable t) {
                            logger.error(t.getMessage(), t);
                        }
                    }
                }
            }
        }
    }

}

InvokerListener ，Invoker 监听器:

@SPI
public interface InvokerListener {

    /**
     * The invoker referred
     *
     * 当服务引用完成
     *
     * @param invoker
     * @throws RpcException
     * @see com.alibaba.dubbo.rpc.Protocol#refer(Class, URL)
     */
    void referred(Invoker<?> invoker) throws RpcException;

    /**
     * The invoker destroyed.
     *
     * 当服务销毁引用完成
     *
     * @param invoker
     * @see com.alibaba.dubbo.rpc.Invoker#destroy()
     */
    void destroyed(Invoker<?> invoker);

}

InvokerListenerAdapter ，实现 InvokerListener 接口，InvokerListener 适配器抽象类：

public abstract class InvokerListenerAdapter implements InvokerListener {

    public void referred(Invoker<?> invoker) throws RpcException { }

    public void destroyed(Invoker<?> invoker) { }

}

DeprecatedInvokerListener ，实现 InvokerListenerAdapter 抽象类 ，引用废弃的服务时，打印错误日志提醒：

@Activate(Constants.DEPRECATED_KEY)
public class DeprecatedInvokerListener extends InvokerListenerAdapter {

    private static final Logger LOGGER = LoggerFactory.getLogger(DeprecatedInvokerListener.class);

    public void referred(Invoker<?> invoker) throws RpcException {
        if (invoker.getUrl().getParameter(Constants.DEPRECATED_KEY, false)) {
            LOGGER.error("The service " + invoker.getInterface().getName() + " is DEPRECATED! Declare from " + invoker.getUrl());
        }
    }

}

@Activate(Constants.DEPRECATED_KEY) 注解，基于 Dubbo SPI Activate 机制加载。配置方式如下:

    <dubbo:service interface="com.alibaba.dubbo.demo.DemoService" ref="demoService" deprecated="true" />
  

本地引用服务的配置方式如下 (本地引用服务时，不是使用服务提供者的 URL ，而是服务消费者的 URL ):

<dubbo:reference id="demoService" interface="com.alibaba.dubbo.demo.DemoService" protocol="injvm">
    <dubbo:parameter key="deprecated" value="true" />
</dubbo:reference>