org.apache.dubbo.rpc.protocol.ProtocolListenerWrapper
public class ProtocolListenerWrapper implements Protocol {
private final Protocol protocol;
public ProtocolListenerWrapper(Protocol protocol) {
if (protocol == null) {
throw new IllegalArgumentException("protocol == null");
}
this.protocol = protocol;
}
@Override
public int getDefaultPort() {
return protocol.getDefaultPort();
}
@Override
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
if (REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) { // 不处理 registry协议
return protocol.export(invoker);
}
// 为服务端,安装监听器
return new ListenerExporterWrapper<T>(protocol.export(invoker),
Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(ExporterListener.class)
.getActivateExtension(invoker.getUrl(), EXPORTER_LISTENER_KEY)));
}
@Override
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
if (REGISTRY_PROTOCOL.equals(url.getProtocol())) { // 不处理 registry协议
return protocol.refer(type, url);
}
// 为客户端,安装监听器
return new ListenerInvokerWrapper<T>(protocol.refer(type, url),
Collections.unmodifiableList(
ExtensionLoader.getExtensionLoader(InvokerListener.class)
.getActivateExtension(url, INVOKER_LISTENER_KEY)));
}
@Override
public void destroy() {
protocol.destroy();
}
}
refer监听(作为客户端)
org.apache.dubbo.rpc.listener.ListenerInvokerWrapper
public class ListenerInvokerWrapper<T> implements Invoker<T> {
private static final Logger logger = LoggerFactory.getLogger(ListenerInvokerWrapper.class);
private final Invoker<T> 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 (CollectionUtils.isNotEmpty(listeners)) {
for (InvokerListener listener : listeners) { // 遍历监听器列表
if (listener != null) {
try {
listener.referred(invoker); // 调用监听器的 referred 方法
} catch (Throwable t) {
logger.error(t.getMessage(), t);
}
}
}
}
}
@Override
public Class<T> getInterface() {
return invoker.getInterface();
}
@Override
public URL getUrl() {
return invoker.getUrl();
}
@Override
public boolean isAvailable() {
return invoker.isAvailable();
}
@Override
public Result invoke(Invocation invocation) throws RpcException {
return invoker.invoke(invocation);
}
@Override
public String toString() {
return getInterface() + " -> " + (getUrl() == null ? " " : getUrl().toString());
}
@Override
public void destroy() {
try {
invoker.destroy();
} finally {
if (CollectionUtils.isNotEmpty(listeners)) {
for (InvokerListener listener : listeners) { // 遍历监听器列表
if (listener != null) {
try {
listener.destroyed(invoker); // 调用监听器的 destroyed 方法
} catch (Throwable t) {
logger.error(t.getMessage(), t);
}
}
}
}
}
}
}
export 监听(作为服务端)
public class ListenerExporterWrapper<T> implements Exporter<T> {
private static final Logger logger = LoggerFactory.getLogger(ListenerExporterWrapper.class);
private final Exporter<T> exporter;
private final List<ExporterListener> listeners;
public ListenerExporterWrapper(Exporter<T> exporter, List<ExporterListener> listeners) {
if (exporter == null) {
throw new IllegalArgumentException("exporter == null");
}
this.exporter = exporter;
this.listeners = listeners;
if (CollectionUtils.isNotEmpty(listeners)) {
RuntimeException exception = null;
for (ExporterListener listener : listeners) { // 遍历监听器列表
if (listener != null) {
try {
listener.exported(this); // 调用监听器的 exported 方法
} catch (RuntimeException t) {
logger.error(t.getMessage(), t);
exception = t;
}
}
}
if (exception != null) {
throw exception;
}
}
}
@Override
public Invoker<T> getInvoker() {
return exporter.getInvoker();
}
@Override
public void unexport() {
try {
exporter.unexport();
} finally {
if (CollectionUtils.isNotEmpty(listeners)) {
RuntimeException exception = null;
for (ExporterListener listener : listeners) { // 遍历监听器列表
if (listener != null) {
try {
listener.unexported(this); // 调用监听器的 unexported 方法
} catch (RuntimeException t) {
logger.error(t.getMessage(), t);
exception = t;
}
}
}
if (exception != null) {
throw exception;
}
}
}
}
}