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.isEmpty()) {            for (int i = filters.size() - 1; i >= 0; i--) {                final Filter filter = filters.get(i);                final Invoker<T> next = last;                last = new Invoker<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 {                        Result asyncResult;                        try {                            asyncResult = filter.invoke(next, invocation);                        } catch (Exception e) {                            // onError callback                            if (filter instanceof ListenableFilter) {                                Filter.Listener listener = ((ListenableFilter) filter).listener();                                if (listener != null) {                                    listener.onError(e, invoker, invocation);                                }                            }                            throw e;                        }                        return asyncResult;                    }
                    @Override                    public void destroy() {                        invoker.destroy();                    }
                    @Override                    public String toString() {                        return invoker.toString();                    }                };            }        }
        return new CallbackRegistrationInvoker<>(last, filters);    }

@Activate(group = CommonConstants.PROVIDER, order = -110000)public class EchoFilter implements Filter {
    @Override    public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException {        if (inv.getMethodName().equals($ECHO) && inv.getArguments() != null && inv.getArguments().length == 1) {            return AsyncRpcResult.newDefaultAsyncResult(inv.getArguments()[0], inv);        }        return invoker.invoke(inv);    }}

@Adaptivepublic class AdaptiveCompiler implements Compiler {
    private static volatile String DEFAULT_COMPILER;
    public static void setDefaultCompiler(String compiler) {        DEFAULT_COMPILER = compiler;    }
    @Override    public Class<?> compile(String code, ClassLoader classLoader) {        Compiler compiler;        ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);        String name = DEFAULT_COMPILER; // copy reference        if (name != null && name.length() > 0) {            compiler = loader.getExtension(name);        } else {            compiler = loader.getDefaultExtension();        }        return compiler.compile(code, classLoader);    }
}

/** * Protocol. (API/SPI, Singleton, ThreadSafe) */@SPI("dubbo")public interface Protocol {
    /**     * Get default port when user doesn't config the port.     *     * @return default port     */    int getDefaultPort();
    /**     * Export service for remote invocation: <br>     * 1. Protocol should record request source address after receive a request:     * RpcContext.getContext().setRemoteAddress();<br>     * 2. export() must be idempotent, that is, there's no difference between invoking once and invoking twice when     * export the same URL<br>     * 3. Invoker instance is passed in by the framework, protocol needs not to care <br>     *     * @param <T>     Service type     * @param invoker Service invoker     * @return exporter reference for exported service, useful for unexport the service later     * @throws RpcException thrown when error occurs during export the service, for example: port is occupied     */    @Adaptive    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
    /**     * Refer a remote service: <br>     * 1. When user calls `invoke()` method of `Invoker` object which's returned from `refer()` call, the protocol     * needs to correspondingly execute `invoke()` method of `Invoker` object <br>     * 2. It's protocol's responsibility to implement `Invoker` which's returned from `refer()`. Generally speaking,     * protocol sends remote request in the `Invoker` implementation. <br>     * 3. When there's check=false set in URL, the implementation must not throw exception but try to recover when     * connection fails.     *     * @param <T>  Service type     * @param type Service class     * @param url  URL address for the remote service     * @return invoker service's local proxy     * @throws RpcException when there's any error while connecting to the service provider     */    @Adaptive    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    /**     * Destroy protocol: <br>     * 1. Cancel all services this protocol exports and refers <br>     * 2. Release all occupied resources, for example: connection, port, etc. <br>     * 3. Protocol can continue to export and refer new service even after it's destroyed.     */    void destroy();
}