前面的服务提供者和消费者暴漏和引用过程中首先都是用的Protocol,
而且使用ExtensionLoader加载的adaptive的Protocol,最终得到的是
ProtocolListenerWrapper->ProtocolFilterWrapper->{RegistryProtocol,DubboProtocol}
1、ProtocolListenerWrapper如何使用Listener的
也就是export,refer方法
使用了ExtensionLoader得到了当前配置激活的ExporterListener,或者InvokerListener,
然后new出ListenerExporterWrapper或者ListenerInvokerWrapper
ListenerExporterWrapper构造方法中遍历了listeners执行了listener.exported方法,同样unexport
2、ProtocolFilterWrapper的export
关键就在于buildInvokerChain,它把最后的invoker和激活的filter整合到了一起
可以这样表示一下
这样就形成了一个过滤链,所以使用filter时候一般是
而且使用ExtensionLoader加载的adaptive的Protocol,最终得到的是
ProtocolListenerWrapper->ProtocolFilterWrapper->{RegistryProtocol,DubboProtocol}
1、ProtocolListenerWrapper如何使用Listener的
也就是export,refer方法
使用了ExtensionLoader得到了当前配置激活的ExporterListener,或者InvokerListener,
然后new出ListenerExporterWrapper或者ListenerInvokerWrapper
ListenerExporterWrapper构造方法中遍历了listeners执行了listener.exported方法,同样unexport
方法也是遍历执行,再看看ListenerInvokerWrapper也是类似
public ListenerExporterWrapper(Exporter<T> exporter, List<ExporterListener> listeners){
if (exporter == null) {
throw new IllegalArgumentException("exporter == null");
}
this.exporter = exporter;
this.listeners = listeners;
if (listeners != null && listeners.size() > 0) {
RuntimeException exception = null;
for (ExporterListener listener : listeners) {
if (listener != null) {
try {
listener.exported(this);
} catch (RuntimeException t) {
logger.error(t.getMessage(), t);
exception = t;
}
}
}
if (exception != null) {
throw exception;
}
}
}
2、ProtocolFilterWrapper的export
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
return protocol.export(invoker);
}
return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
}
关键就在于buildInvokerChain,它把最后的invoker和激活的filter整合到了一起
private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
Invoker<T> last = invoker;
List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
if (filters.size() > 0) {
for (int i = filters.size() - 1; i >= 0; i --) {
final Filter filter = filters.get(i);
final Invoker<T> next = last;
last = new Invoker<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 filter.invoke(next, invocation);
}
public void destroy() {
invoker.destroy();
}
@Override
public String toString() {
return invoker.toString();
}
};
}
}
return last;
}
可以这样表示一下
filterN ... filter2 filter1 invoker0(就是具体接口实现类)
new出对应的
invokerN invoker2 invoker1
//invokerN的invoke方法为
public Result invoke(Invocation invocation) throws RpcException {
return filterN.invoke(invoker(N-1), invocation);
}
这样就形成了一个过滤链,所以使用filter时候一般是
@Activate(group = Constants.PROVIDER)
public class XxxFilter implements Filter {
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
//调用前拦截处理
Result result = invoker.invoke(invocation);
//对结果拦截处理
return result;
}
}