Dubbo Wrapper 解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@SPI("ali")
// 默认的值支付宝支付
public interface Pay {
// 接口的方法需要添加这个注解，在测试代码中，参数至少要有一个URL类型的参数
@Adaptive({"paytype"})
// 付款方式
void pay(URL url);
}
public class AliPay implements Pay {
@Override
public void pay(URL url) {
System.out.println("使用支付宝支付");
}
}
public class WechatPay implements Pay {
@Override
public void pay(URL url) {
System.out.println("使用微信支付");
}
}
在/dubbo-common/src/main/resources/META-INF/services/com.test.Pay文件下添加内容如下：
wechat = com.test.WechatPay
ali = com.test.AliPay

1
2
3
4
5
6
7
8
public static void main(String[] args) {
ExtensionLoader<Pay> loader = ExtensionLoader.getExtensionLoader(Pay.class);
Pay pay = loader.getAdaptiveExtension();
pay.pay(URL.valueOf("http://localhost:9999/xxx"));
// 使用支付宝支付
pay.pay(URL.valueOf("http://localhost:9999/xxx?paytype=wechat"));
// 使用微信支付
}

1
2
3
4
5
6
7
8
9
10
11
12
public class PayWrapper1 implements Pay {
Pay pay;
public PayWrapper1(Pay pay) {
this.pay = pay;
}
@Override
public void pay(URL url) {
System.out.println("pay before...");
pay.pay(url);
System.out.println("pay after...");
}
}

1
2
3
4
5
6
7
8
9
10
11
12
public class PayWrapper2 implements Pay {
Pay pay;
public PayWrapper2(Pay pay) {
this.pay = pay;
}
@Override
public void pay(URL url) {
System.out.println("-----pay before...");
pay.pay(url);
System.out.println("-----pay after...");
}
}

1
2
3
4
5
----pay before...
pay before...
使用支付宝支付
pay after...
-----pay after...

1
2
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
复制代码

1
2
3
4
5
6
7

com.alibaba.dubbo.common.URL url = arg0.getUrl();
String extName = ((url.getProtocol() == null) ? "dubbo"
: url.getProtocol());
com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class)
.getExtension(extName);
复制代码

1
2
3
4
5
6
7
8
9
private boolean isWrapperClass(Class<?> clazz) {
try {
clazz.getConstructor(type);
return true;
} catch (NoSuchMethodException e) {
return false;
}
}
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper
mock=com.alibaba.dubbo.rpc.support.MockProtocol
dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
injvm=com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol
rmi=com.alibaba.dubbo.rpc.protocol.rmi.RmiProtocol
hessian=com.alibaba.dubbo.rpc.protocol.hessian.HessianProtocol
com.alibaba.dubbo.rpc.protocol.http.HttpProtocol
com.alibaba.dubbo.rpc.protocol.webservice.WebServiceProtocol
thrift=com.alibaba.dubbo.rpc.protocol.thrift.ThriftProtocol
memcached=com.alibaba.dubbo.rpc.protocol.memcached.MemcachedProtocol
redis=com.alibaba.dubbo.rpc.protocol.redis.RedisProtocol
rest=com.alibaba.dubbo.rpc.protocol.rest.RestProtocol
registry=com.alibaba.dubbo.registry.integration.RegistryProtocol
qos=com.alibaba.dubbo.qos.protocol.QosProtocolWrapper
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
private T createExtension(String name) {
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) {
throw findException(name);
}
try {
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
injectExtension(instance);
//从成员属性获取对应的 cachedWrapperClasses
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
//循环
for (Class<?> wrapperClass : wrapperClasses) {
//实例化，同时进行注入
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
return instance;
} catch (Throwable t) {
// throw Exception...
}
}
复制代码

1
2
3
4
5
6
7
8
9
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
//通过 url 的协议查看是不是 Registry
if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
return protocol.export(invoker);
}
//建立 invoker 调用链，然后传递给下一个
return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
}
复制代码

1
2
3
4
5
6
7
8
9
10
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
//通过 url 的协议查看是不是 Registry
if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
startQosServer(invoker.getUrl());
return protocol.export(invoker);
}
//直接调用持有对象
return protocol.export(invoker);
}
复制代码

1
2
3
4
5
6
7
8
9
10
11
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
通过 url 的协议查看是不是 Registry
if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
return protocol.export(invoker);
}
//两步进行
return new ListenerExporterWrapper<T>(protocol.export(invoker),
Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(ExporterListener.class)
.getActivateExtension(invoker.getUrl(), Constants.EXPORTER_LISTENER_KEY)));
}
复制代码