Dubbo源码分析之四：服务的调用
在调用服务之前，先得获得服务的引用。
ReferenceBean 就是服务的引用。它实现了一个FactoryBean接口，在我们需要一个服务时，FactoryBean接口的getObject() 方法会被调用。
public Object getObject() throws Exception {
return get(); //返回服务的代理。
}
。。。
// get() ->init()->createProxy(map)
// 过程主要是一些参数的检查，初始化等准备工作
// 我们重点看看createProxy 方法，参数为服务需要的所有配置信息
private T createProxy(Map map) {
URL tmpUrl = new URL("temp", "localhost", 0, map);
final boolean isJvmRefer;
if (isInjvm() == null) {
if (url != null && url.length() > 0) { //指定URL的情况下，不做本地引用
isJvmRefer = false;
} else if (InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl)) {
//默认情况下如果本地有服务暴露，则引用本地服务.
isJvmRefer = true;
} else {
isJvmRefer = false;
}
} else {
isJvmRefer = isInjvm().booleanValue();
}
if (isJvmRefer) {
URL url = new URL(Constants.LOCAL_PROTOCOL, NetUtils.LOCALHOST, 0, interfaceClass.getName()).addParameters(map);
invoker = refprotocol.refer(interfaceClass, url);
if (logger.isInfoEnabled()) {
logger.info("Using injvm service " + interfaceClass.getName());
}
} else {
if (url != null && url.length() > 0) { // 用户指定URL，指定的URL可能是对点对直连地址，也可能是注册中心URL
String[] us = Constants.SEMICOLON_SPLIT_PATTERN.split(url);
if (us != null && us.length > 0) {
for (String u : us) {
URL url = URL.valueOf(u);
if (url.getPath() == null || url.getPath().length() == 0) {
url = url.setPath(interfaceName);
}
if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
urls.add(url.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
} else {
urls.add(ClusterUtils.mergeUrl(url, map));
}
}
}
} else { // 通过注册中心配置拼装URL
List us = loadRegistries(false);
if (us != null && us.size() > 0) {
for (URL u : us) {
URL monitorUrl = loadMonitor(u);
if (monitorUrl != null) {
map.put(Constants.MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
}
urls.add(u.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
}
}
if (urls == null || urls.size() == 0) {
throw new IllegalStateException("No such any registry to reference " + interfaceName + " on the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", please config > invokers = new ArrayList>();
URL registryURL = null;
for (URL url : urls) {
// 我们重点看下这里，invokers 存放所有可用的服务调用者
// 然后集群策略会根据这些调用者做一些负载均衡处理。
// 见下一段
invokers.add(refprotocol.refer(interfaceClass, url));
if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
registryURL = url; // 用了最后一个registry url
}
}
if (registryURL != null) { // 有 注册中心协议的URL
// 对有注册中心的Cluster 只用 AvailableCluster
URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME);
// 加入集群，返回一个集群调用者。它内部会做一些负载均衡的处理。
// 默认的集群策略为自动恢复,默认的负载均衡为随机，如果调用者只有2个，则为轮询。
invoker = cluster.join(new StaticDirectory(u, invokers));
} else { // 不是 注册中心的URL
invoker = cluster.join(new StaticDirectory(invokers));
}
}
}
。。。// 省略
// 创建服务代理
return (T) proxyFactory.getProxy(invoker);
} 接下来 我们看看 refprotocol.refer(interfaceClass, url)
refprotocol 其实是一个代理，代理谁不知道，只有在调用时才能确定。
这个代理类是动态生成，动态编译的。后面有机会我们再讲。
通过这个动态代理的使用，最终会调用到 RegistryProtocol.refer 方法。
public Invoker refer(Class type, URL url) throws RpcException {
url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
//根据URL获得对应的注册器。
// 如果是ZK，则 registry 为ZookeeperRegistry
Registry registry = registryFactory.getRegistry(url);
if (RegistryService.class.equals(type)) {
return proxyFactory.getInvoker((T) registry, type, url);
}
// group="a,b" or group="*"
// 如果消费者使用了分组
Map qs = StringUtils.parseQueryString(url.getParameterAndDecoded(Constants.REFER_KEY));
String group = qs.get(Constants.GROUP_KEY);
if (group != null && group.length() > 0 ) {
if ( ( Constants.COMMA_SPLIT_PATTERN.split( group ) ).length > 1
|| "*".equals( group ) ) {
return doRefer( getMergeableCluster(), registry, type, url );
}
}
// 返回调用器
return doRefer(cluster, registry, type, url);
}
private Invoker doRefer(Cluster cluster, Registry registry, Class type, URL url) {
// RegistryDirectory 可以把它理解成注册资源，其中包含了消费者，服务，路由等相关信息。
// 调用者需要这些信息来进行调用
RegistryDirectory directory = new RegistryDirectory(type, url);
directory.setRegistry(registry); // 注册器
directory.setProtocol(protocol); // 协议
URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, NetUtils.getLocalHost(), 0, type.getName(), directory.getUrl().getParameters());
if (! Constants.ANY_VALUE.equals(url.getServiceInterface())
&& url.getParameter(Constants.REGISTER_KEY, true)) {
// 注册消费者
registry.register(subscribeUrl.addParameters(Constants.CATEGORY_KEY, Constants.CONSUMERS_CATEGORY,
Constants.CHECK_KEY, String.valueOf(false)));
}
// 订阅，
// 会从注册中心获得对应的服务提供者的信息
directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
Constants.PROVIDERS_CATEGORY
+ "," + Constants.CONFIGURATORS_CATEGORY
+ "," + Constants.ROUTERS_CATEGORY));
// 默认的cluster 为FailFastCluster
// 返回 FailfastClusterInvoker
return cluster.join(directory);
} 接下来，我们看看 FailfastClusterInvoker 。FailfastClusterInvoker 继承 AbstractClusterInvoker 实现了Invoker 接口。
我们看看AbstractClusterInvoker.invoke
public Result invoke(final Invocation invocation) throws RpcException {
checkWheatherDestoried();// 检查此调用者是否被销毁
LoadBalance loadbalance; // 负载均衡算法
// 获得对应的Invoker。主要从RegistryDirectory 中获取。
List> invokers = list(invocation);
if (invokers != null && invokers.size() > 0) {
// 确定负载均衡算法，默认为随机
loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(invokers.get(0).getUrl()
.getMethodParameter(invocation.getMethodName(),Constants.LOADBALANCE_KEY, Constants.DEFAULT_LOADBALANCE));
} else {
loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(Constants.DEFAULT_LOADBALANCE);
}
//如果是异步操作默认添加invocation id
RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
// 调用FailfastClusterInvoker.doInvoke
return doInvoke(invocation, invokers, loadbalance);
} 我们看看 list(invocation) 是怎么获取的。
调用关系为
list(invocation) -> AbstractDirectory.list(invocation) ->RegistryDirectory.doList(invocation)
// RegistryDirectory.doList
public List> doList(Invocation invocation) {
if (forbidden) { // 如果被禁止消费
throw new RpcException(RpcException.FORBIDDEN_EXCEPTION, "Forbid consumer " + NetUtils.getLocalHost() + " access service " + getInterface().getName() + " from registry " + getUrl().getAddress() + " use dubbo version " + Version.getVersion() + ", Please check registry access list (whitelist/blacklist).");
}
List> invokers = null;
// methodInvokerMap 为方法到调用器的映射
Map>> localMethodInvokerMap = this.methodInvokerMap; // local reference
if (localMethodInvokerMap != null && localMethodInvokerMap.size() > 0) {
String methodName = RpcUtils.getMethodName(invocation);
Object[] args = RpcUtils.getArguments(invocation);
if(args != null && args.length > 0 && args[0] != null
&& (args[0] instanceof String || args[0].getClass().isEnum())) {
invokers = localMethodInvokerMap.get(methodName + "." + args[0]); // 可根据第一个参数枚举路由
}
if(invokers == null) {
invokers = localMethodInvokerMap.get(methodName);
}
if(invokers == null) {
invokers = localMethodInvokerMap.get(Constants.ANY_VALUE);
}
if(invokers == null) {
Iterator>> iterator = localMethodInvokerMap.values().iterator();
if (iterator.hasNext()) {
invokers = iterator.next();
}
}
}
return invokers == null ? new ArrayList>(0) : invokers;
} 重点在 methodInvokerMap 中。那么其中的数据是这么来的呢？答案在
RegistryProtocol.doRefer 中的 directory.subscribe 。上面也提到过。
// RegistryDirectory
public void subscribe(URL url) {
setConsumerUrl(url);
registry.subscribe(url, this); //订阅，回调notify方法
}
// notify() -> refreshInvoker() -> toInvokers()
// methodInvokerMap 的赋值就在 refreshInvoker 中而 invoker 也会被初始化为 InvokerDelegete。InvokerDelegete的创建在toInvokers方法中。
InvokerDelegete 是 RegistryDirectory 中内部类。也就是一个代理。
最终会根据 protocol 调用最终的 Invoker。
例如：dubbo
protocol=>DubboProtocol
invoker=> DubboInvoker
// DubboProtocol
public Invoker refer(Class serviceType, URL url) throws RpcException {
// modified by lishen
// 序列优化。主要是SerializationOptimizer
// 将需要序列化的类放入SerializationOptimizer
optimizeSerialization(url);
// create rpc invoker.
// 创建RPC 调用者
// 底层通信主要看选择了那种client
DubboInvoker invoker = new DubboInvoker(serviceType, url, getClients(url), invokers);
invokers.add(invoker);
return invoker;
}
// 获得client,连接
private ExchangeClient[] getClients(URL url){
//是否共享连接
boolean service_share_connect = false;
int connections = url.getParameter(Constants.CONNECTIONS_KEY, 0);
//如果connections不配置，则共享连接，否则每服务每连接
if (connections == 0){
service_share_connect = true;
connections = 1;
}
ExchangeClient[] clients = new ExchangeClient[connections];
for (int i = 0; i < clients.length; i++) {
if (service_share_connect){
// 获得共享连接，没有则创建(调initClient(url))
// 能不能共享主要看 url.address
clients[i] = getSharedClient(url);
} else {
clients[i] = initClient(url); // 创建client
}
}
return clients;
}
/**
* 创建新连接.
*/
private ExchangeClient initClient(URL url) {
// client type setting.
String str = url.getParameter(Constants.CLIENT_KEY, url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_CLIENT));
String version = url.getParameter(Constants.DUBBO_VERSION_KEY);
boolean compatible = (version != null && version.startsWith("1.0."));
// 设置DubboCodec 编码器 （序列化的操作就在里面）
url = url.addParameter(Constants.CODEC_KEY, Version.isCompatibleVersion() && compatible ? COMPATIBLE_CODEC_NAME : DubboCodec.NAME);
//默认开启heartbeat
url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
// BIO存在严重性能问题，暂时不允许使用
if (str != null && str.length() > 0 && ! ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str)) {
throw new RpcException("Unsupported client type: " + str + "," +
" supported client type is " + StringUtils.join(ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions(), " "));
}
ExchangeClient client ;
try {
//设置连接应该是lazy的
if (url.getParameter(Constants.LAZY_CONNECT_KEY, false)){
client = new LazyConnectExchangeClient(url ,requestHandler);
} else {
// 重点看这里，获得一个连接
client = Exchangers.connect(url ,requestHandler);
}
} catch (RemotingException e) {
throw new RpcException("Fail to create remoting client for service(" + url
+ "): " + e.getMessage(), e);
}
return client;
} 创建一个连接，最终定为到了Exchangers.connect(url ,requestHandler);
// Exchangers
public static ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
if (url == null) {
throw new IllegalArgumentException("url == null");
}
if (handler == null) {
throw new IllegalArgumentException("handler == null");
}
// 如果没有编码器，则设置一个ExchangeCodec编码器
// 但前面已经设置过了
// 后面会讲
url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
// 获得一个连接
return getExchanger(url).connect(url, handler);
}
public static Exchanger getExchanger(URL url) {
String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER); // 默认为header
return getExchanger(type);
}
public static Exchanger getExchanger(String type) {
// 最终获得 HeaderExchanger
// 怎么获得前面也讲过，主要通过类路径扫描定义文件
// header -> HeaderExchanger
return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
}我们在看看HeaderExchanger
// HeaderExchanger
public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
// 根据底层client 封装一个HeaderExchangeClient
// 重点看Transporters.connect。
return new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
}Transporters.connect 最终会调用
ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension()
如果没有特别指定，将最终使用NettyTransporter。
netty为默认的通信方式。（见Transporter.class 的注解）
在NettyTransporter中会直接new NettyClient
// NettyClient
// 此方法将由父类的构造方法调用，然后再调用connect()
@Override
protected void doOpen() throws Throwable {
NettyHelper.setNettyLoggerFactory();
bootstrap = new ClientBootstrap(channelFactory);
// config
// @see org.jboss.netty.channel.socket.SocketChannelConfig
bootstrap.setOption("keepAlive", true); //长连接
bootstrap.setOption("tcpNoDelay", true);
bootstrap.setOption("connectTimeoutMillis", getTimeout());
final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() {
// getcodec()获取到的是DubboCodes编码器。序列化的操作就在对应的Codes类中
NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyClient.this);
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("decoder", adapter.getDecoder()); //解码
pipeline.addLast("encoder", adapter.getEncoder());// 编码
pipeline.addLast("handler", nettyHandler); //处理器
return pipeline;
}
});
}doOpen() 调用完回调用doConnect，来完成通道的建立。
并保存在 NettyClient.this.channel = newChannel;
数据的发送在父类的send方法。
发送方法的调用来源于DubboInvoker.doInvoke 方法。