Dubbo之ExtensionLoader源码解析

Dear 丶 2022-05-24 11:42 233阅读 0赞

ExtensionLoader，从字面理解，拓展组件加载器，是Dubbo里用来加载器内部SPI（Service Provider Interface）的加载器。

理解ExtensionLoader的内部机制，能够更得心应手的使用Dubbo的拓展组件，比如Filter，Listener，Protocol，RegistryService，Invoker等等，如何自定义拓展组件，他们的加载逻辑。

@SPI("dubbo")
    public interface Protocol { 
    
        int getDefaultPort();
    
        @Adaptive
        <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
    
        @Adaptive
        <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    
        void destroy();
    
    }

挑一个典型，我们以Protocol接口为例，按流程逐步讲解。

Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

以上这行代码就是获取Protocol的自适应拓展组件，我们就从行代码为切入点，深入看起源码：

public class ExtensionLoader<T> { 
    
        /** * 根据拓展点的接口，获得拓展加载器 * * @param type 接口 * @param <T> 泛型 * @return 加载器 */
        @SuppressWarnings("unchecked")
        public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
            if (type == null) { throw new IllegalArgumentException("Extension type == null"); }
            // 必须是接口
            if (!type.isInterface()) {
                throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
            }
            // 必须包含 @SPI 注解
            if (!withExtensionAnnotation(type)) {
                throw new IllegalArgumentException("Extension type(" + type +
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
            }
    
            // 获得接口对应的拓展点加载器
            ExtensionLoader<T> loader = (ExtensionLoader<T>)EXTENSION_LOADERS.get(type);
            if (loader == null) {
                EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
                loader = (ExtensionLoader<T>)EXTENSION_LOADERS.get(type);
            }
            return loader;
        }
    
    
        /** * 获得自适应拓展对象,也就是 type$Adaptive 对象,比如 Protocol$Adaptive * 这个对象是由javassist动态代理生成 * * @return 拓展对象 */
        @SuppressWarnings("unchecked")
        public T getAdaptiveExtension() {
            // 从缓存中，获得自适应拓展对象
            Object instance = cachedAdaptiveInstance.get();
            if (instance == null) {
                // 若之前未创建报错，
                if (createAdaptiveInstanceError == null) {
                    synchronized (cachedAdaptiveInstance) {
                        instance = cachedAdaptiveInstance.get();
                        if (instance == null) {
                            try {
                                // 创建自适应拓展对象, 如 Protocol$Adaptive
                                instance = createAdaptiveExtension();               
                                // 设置到缓存
                                cachedAdaptiveInstance.set(instance);
                            } catch (Throwable t) {
                                // 记录异常
                                createAdaptiveInstanceError = t;
                                throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
                            }
                        }
                    }
                    // 若之前创建报错，则抛出异常 IllegalStateException
                } else {
                    throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
                }
            }
            return (T)instance;
        }
    
    }

以上代码的关键就是createAdaptiveExtension( ) 方法了，此方法生成拓展类对象，然后设置到缓存，这样下次再获取的时候就不需要再次生成了，我们从这个方法接着看：

public class ExtensionLoader<T> { 
    
        /** * 创建自适应拓展对象,获取到拓展类后，调用默认的构造函数获得实例 * * @return 拓展对象 */
        @SuppressWarnings("unchecked")
        private T createAdaptiveExtension() {
            try {
                return injectExtension((T)getAdaptiveExtensionClass().newInstance());
            } catch (Exception e) {
                throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
            }
        }
    
    
        /** * @return 自适应拓展类 */
        @SuppressWarnings("deprecation")
        private Class<?> getAdaptiveExtensionClass() {
            // 关键方法, 加载此接口的所有拓展类
            getExtensionClasses();                           
            if (cachedAdaptiveClass != null) {
                return cachedAdaptiveClass;
            }
            return cachedAdaptiveClass = createAdaptiveExtensionClass();
        }
    
    }

以上代码最重要的就是**getExtensionClasses()** 和 **createAdaptiveExtensionClass()**了。

我们先深入 getExtensionClasses() ：

public class ExtensionLoader<T> { 
    
    
        private static final String SERVICES_DIRECTORY = "META-INF/services/";
    
        private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
    
        private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
    
        /** * 获得拓展实现类数组,缓存到{ @link #cachedClasses}中 * * @return 拓展实现类数组 */
        private Map<String, Class<?>> getExtensionClasses() {
            // 从缓存中，获得拓展实现类数组
            Map<String, Class<?>> classes = cachedClasses.get();
            if (classes == null) {
                synchronized (cachedClasses) {
                    classes = cachedClasses.get();
                    if (classes == null) {
                        // 从配置文件中，加载拓展实现类数组
                        classes = loadExtensionClasses();
                        // 设置到缓存中，之后就能通过简称来获取对应的Class
                        cachedClasses.set(classes);
                    }
                }
            }
            return classes;
        }
    
    
        /** * 加载拓展实现类数组 * * 无需声明 synchronized ，因为唯一调用该方法的 { @link #getExtensionClasses()} 已经声明。 * // synchronized in getExtensionClasses * * @return 拓展实现类数组 */
        private Map<String, Class<?>> loadExtensionClasses() {
            // 通过 @SPI 注解，获得默认的拓展实现类名
            final SPI defaultAnnotation = type.getAnnotation(SPI.class);
            if (defaultAnnotation != null) {
                String value = defaultAnnotation.value();
                if ((value = value.trim()).length() > 0) {
                    String[] names = NAME_SEPARATOR.split(value);
                    if (names.length > 1) {
                        throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()
                            + ": " + Arrays.toString(names));
                    }
                    if (names.length == 1) {
                        cachedDefaultName = names[0];
                    }
                }
            }
    
            // 从配置文件中，加载拓展实现类数组
            Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
            loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
            loadFile(extensionClasses, DUBBO_DIRECTORY);
            loadFile(extensionClasses, SERVICES_DIRECTORY);
            return extensionClasses;
        }
    
    
    }

Dubbo的jar包下，**/META-INF/dobbo/internal**路径下有很多配置文件，形式如下：

![Dubbo拓展组件配置文件][Dubbo]

loadFile(extensionClasses, DUBBO\_INTERNAL\_DIRECTORY); DUBBO\_INTERNAL\_DIRECTORY的路径就是 **/META-INF/dobbo/internal**，也就是加载此路径下的文件。

我们深入loadFile(…) 方法：

public class ExtensionLoader<T> { 
    
        /** * 从一个配置文件中，加载拓展实现类数组。 * * @param extensionClasses 拓展类名数组 * @param dir 文件名 */
        private void loadFile(Map<String, Class<?>> extensionClasses, String dir) {
            // 完整的文件名 ,如： "META-INF/dubbo/internal/com.alibaba.dubbo.rpc.Protocol
            String fileName = dir + type.getName();
            try {
                Enumeration<java.net.URL> urls;
                // 获得文件名对应的所有文件数组
                ClassLoader classLoader = findClassLoader();
                if (classLoader != null) {
                    urls = classLoader.getResources(fileName);
                } else {
                    urls = ClassLoader.getSystemResources(fileName);
                }
                // 遍历文件数组
                if (urls != null) {
                    while (urls.hasMoreElements()) {
                        java.net.URL url = urls.nextElement();
                        try {
                            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
                            try {
                                String line;
                                while ((line = reader.readLine()) != null) {
                                    // 跳过当前被注释掉的情况，例如 #spring=xxxxxxxxx
                                    final int ci = line.indexOf('#');
                                    if (ci >= 0) { line = line.substring(0, ci); }
                                    line = line.trim();
                                    if (line.length() > 0) {
                                        try {
                                            // 拆分，key=value 的配置格式
                                            String name = null;
                                            int i = line.indexOf('=');
                                            if (i > 0) {
                                                name = line.substring(0, i).trim();
                                                line = line.substring(i + 1).trim();
                                            }
                                            if (line.length() > 0) {
                                                // 判断拓展实现，是否实现拓展接口
                                                Class<?> clazz = Class.forName(line, true, classLoader);
                                                if (!type.isAssignableFrom(clazz)) {
                                                    throw new IllegalStateException("Error when load extension class(interface: " +
                                                        type + ", class line: " + clazz.getName() + "), class "
                                                        + clazz.getName() + "is not subtype of interface.");
                                                }
    
                                                // 缓存自适应拓展对象的类到 `cachedAdaptiveClass`
                                                if (clazz.isAnnotationPresent(Adaptive.class)) {
                                                    if (cachedAdaptiveClass == null) {
                                                        cachedAdaptiveClass = clazz;
                                                    } else if (!cachedAdaptiveClass.equals(clazz)) {
                                                        throw new IllegalStateException("More than 1 adaptive class found: "
                                                            + cachedAdaptiveClass.getClass().getName()
                                                            + ", " + clazz.getClass().getName());
                                                    }
                                                } else {
                                                    // 缓存拓展 Wrapper 实现类到 `cachedWrapperClasses`,包装类统一有一个含原始类型的构造函数
                                                    try {
                                                        clazz.getConstructor(type);
                                                        Set<Class<?>> wrappers = cachedWrapperClasses;
                                                        if (wrappers == null) {
                                                            cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                                                            wrappers = cachedWrapperClasses;
                                                        }
                                                        wrappers.add(clazz);
                                                        // 缓存拓展实现类到 `extensionClasses`
                                                    } catch (NoSuchMethodException e) {
                                                        clazz.getConstructor();
                                                        // 未配置拓展名，自动生成。例如，protocol配置文件里的com.alibaba.dubbo.rpc.protocol.http.HttpProtocol，没有指定key
                                                        if (name == null || name.length() == 0) {
                                                            // 从类的 @Extension 注解获取name, 如果未标识此注解，那么用类的 HttpProtocol - Protocol = http
                                                            name = findAnnotationName(clazz);
                                                            // 如果类的名称不是以接口名称结尾
                                                            if (name == null || name.length() == 0) {
                                                                if (clazz.getSimpleName().length() > type.getSimpleName().length()
                                                                    && clazz.getSimpleName().endsWith(type.getSimpleName())) {
                                                                    name = clazz.getSimpleName().substring(0,
                                                                        clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
                                                                } else {
                                                                    throw new IllegalStateException(
                                                                        "No such extension name for the class " + clazz.getName() + " in the config " + url);
                                                                }
                                                            }
                                                        }
                                                        // 获得拓展名，可以是数组，有多个拓展名。
                                                        String[] names = NAME_SEPARATOR.split(name);
                                                        if (names != null && names.length > 0) {
                                                            // 缓存 @Activate 到 `cachedActivates` 。
                                                            Activate activate = clazz.getAnnotation(Activate.class);
                                                            if (activate != null) {
                                                                cachedActivates.put(names[0], activate);
                                                            }
                                                            for (String n : names) {
                                                                // 缓存到 `cachedNames`
                                                                if (!cachedNames.containsKey(clazz)) {
                                                                    cachedNames.put(clazz, n);
                                                                }
                                                                // 缓存拓展实现类到 `extensionClasses`
                                                                Class<?> c = extensionClasses.get(n);
                                                                if (c == null) {
                                                                    extensionClasses.put(n, clazz);
                                                                } else if (c != clazz) {
                                                                    throw new IllegalStateException(
                                                                        "Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and "
                                                                            + clazz.getName());
                                                                }
                                                            }
                                                        }
                                                    }
    
                                            }
                                        } catch (Throwable t) {
                                            // 发生异常，记录到异常集合
                                            IllegalStateException e = new IllegalStateException(
                                                "Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t
                                                    .getMessage(), t);
                                            exceptions.put(line, e);
                                        }
                                    }
                                } // end of while read lines
                            } finally {
                                reader.close();
                            }
                        } catch (Throwable t) {
                            logger.error("Exception when load extension class(interface: " +
                                type + ", class file: " + url + ") in " + url, t);
                        }
                    } // end of while urls
                }
            } catch (Throwable t) {
                logger.error("Exception when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
            }
        }
    
    
    }

总结loadFile（） 方法的内容：

1.  加载/META-INF/dobbo/internal下文件名称为接口名称的文件，解析其内部的键值对配置信息
2.  缓存拓展类的**Class > simpleName** 的映射，以及缓存**WrapperClasses** ，也就是拓展类的包装器，比如将Filter，Listener封装进Protocol，  
    比如这个类**com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper**。

在讲完了加载拓展类后，我们接着讲创建自适应拓展类对象的方法 ：**createAdaptiveExtensionClass()**

public class ExtensionLoader<T> { 
    
        /** * @return 自适应拓展类 */
        @SuppressWarnings("deprecation")
        private Class<?> getAdaptiveExtensionClass() {
            // 关键方法, 加载此接口的所有拓展类
            getExtensionClasses();
            // 如果在加载拓展类的过程中，拓展类标识了 @Adaptive，那么这个类就会被缓存入cachedAdaptiveClass中
            if (cachedAdaptiveClass != null) {
                return cachedAdaptiveClass;
            }
            return cachedAdaptiveClass = createAdaptiveExtensionClass();
        }
    
        /** * 自动生成自适应拓展的代码实现，并编译后返回该类。 * * @return 类 */
        private Class<?> createAdaptiveExtensionClass() {
            // 自动生成自适应拓展的代码实现的字符串
            String code = createAdaptiveExtensionClassCode();
            // 编译代码，并返回该类
            ClassLoader classLoader = findClassLoader();
            com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class)
                .getAdaptiveExtension();
            return compiler.compile(code, classLoader);
        }
    
    }

**createAdaptiveExtensionClassCode()**，此方法动态地为拓展接口做一个默认实现，使用拼接字符串的形式，拼出一个实现类的字符串，然后使用编译器将字符串编译成一个类。  
编译器的默认实现时 **Javassist**,也就是用javassist动态的为接口生成代理类

Dubbo会为其内部的很多SPI组件生成动态自适应代理对象：

![自适应拓展类][70]

我们以Protocol接口为例，看起生成的默认字符串的形式：

package com.alibaba.dubbo.rpc;
    
    import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.Adaptive;
    import com.alibaba.dubbo.common.extension.SPI;
    
    @SPI("dubbo")
    public interface Protocol { 
    
        int getDefaultPort();
    
        @Adaptive
        <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
    
        @Adaptive
        <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    
        void destroy();
    
    }
    
    
    package com.alibaba.dubbo.rpc;
    
    import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.ExtensionLoader;
    
    /** * 由Javasistent字节码编辑器生成的Protocol代理类 * * @author Administrator * @create 2018-04-25 22:26 */
    public class Protocol$Adaptive implements Protocol { 
    
        @Override
        public int getDefaultPort() {
            throw new UnsupportedOperationException(
                "method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
        }
    
        public Exporter export(Invoker arg0) {
            if (arg0 == null) {
                throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
            }
            if (arg0.getUrl() == null) {
                throw new IllegalArgumentException(
                    "com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
            }
            URL url = arg0.getUrl();
            String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
            if (extName == null) {
                throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
            }
            Protocol extension = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName);
            return extension.export(arg0);
        }
    
        @Override
        public Invoker refer(Class arg0, URL arg1) {
            if (arg1 == null) { throw new IllegalArgumentException("url == null"); }
            URL url = arg1;
            String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
            if (extName == null) {
                throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
            }
            Protocol extension = ExtensionLoader.getExtensionLoader(Protocol.class)
                .getExtension(extName);                // 获取指定名称对应的拓展对象
            return extension.refer(arg0, arg1);
        }
    
        @Override
        public void destroy() {
            throw new UnsupportedOperationException(
                "method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
        }
    }

通过查看Protocol$Adaptive类的代码，做生成的格式总结：

1.  忽略无参数的方法
2.  有参数的方法，优先从URL上获取接口名称的小写的parameter，如果不存在，那么使用接口上@SPI指定的value，比如”dubbo”
3.  然后再到ExtensionLoader里获取此名称对应的拓展类对象

我们接下来深入**getExtension(extName)**的源码：

public class ExtensionLoader<T> { 
    
    
        /** * 返回指定名字的扩展对象。如果指定名字的扩展不存在，则抛异常 { @link IllegalStateException}. * 这个方法是关键,通过url上的组件名称来获取相应的组件 * * @param name 拓展名 * @return 拓展对象 */
        @SuppressWarnings("unchecked")
        public T getExtension(String name) {
            if (name == null || name.length() == 0) { throw new IllegalArgumentException("Extension name == null"); }
            // 查找 默认的 拓展对象
            if ("true".equals(name)) {
                return getDefaultExtension();
            }
            // 从 缓存中 获得对应的拓展对象
            Holder<Object> holder = cachedInstances.get(name);
            if (holder == null) {
                cachedInstances.putIfAbsent(name, new Holder<Object>());
                holder = cachedInstances.get(name);
            }
            Object instance = holder.get();
            if (instance == null) {
                synchronized (holder) {
                    instance = holder.get();
                    // 从 缓存中 未获取到，进行创建缓存对象。
                    if (instance == null) {
                        instance = createExtension(name);
                        // 设置创建对象到缓存中
                        holder.set(instance);
                    }
                }
            }
            return (T)instance;
        }
    
        /** * 创建拓展名的拓展对象，并缓存。 * * @param name 拓展名 * @return 拓展对象 */
        @SuppressWarnings("unchecked")
        private T createExtension(String name) {
            // 获得拓展名对应的拓展实现类，在加载配置文件时，已经换成了name >> class 的映射关系
            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);
                // 创建 Wrapper 拓展对象
                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 new IllegalStateException("Extension instance(name: " + name + ", class: " +
                    type + ") could not be instantiated: " + t.getMessage(), t);
            }
        }
    
    
    }

在**createExtension(String name)**这段代码中，有wrapperClass 出现，这个包装类是对拓展组件的一种装饰，我们以Protocol为例：

public class ProtocolListenerWrapper implements Protocol { 
    
        private final Protocol protocol;
    
        public ProtocolListenerWrapper(Protocol protocol) {
            if (protocol == null) {
                throw new IllegalArgumentException("protocol == null");
            }
            this.protocol = protocol;
        }
    
        public int getDefaultPort() {
            return protocol.getDefaultPort();
        }
    
        public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
            // 注册中心协议
            if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
                return protocol.export(invoker);
            }
            // 暴露服务，创建 Exporter 对象
            Exporter<T> exporter = protocol.export(invoker);
            // 获得 ExporterListener 数组
            List<ExporterListener> listeners = Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(ExporterListener.class).getActivateExtension(invoker.getUrl(), Constants.EXPORTER_LISTENER_KEY));
            // 创建带 ExporterListener 的 Exporter 对象
            return new ListenerExporterWrapper<T>(exporter, listeners);
        }
    
        public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
            // 如果是向Zookeeper注册自身
            if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                return protocol.refer(type, url);
            }
            // 引用服务
            Invoker<T> invoker = protocol.refer(type, url);
            // 获得 InvokerListener 数组
            List<InvokerListener> listeners = Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(InvokerListener.class).getActivateExtension(url, Constants.INVOKER_LISTENER_KEY));
            // 创建 ListenerInvokerWrapper 对象
            return new ListenerInvokerWrapper<T>(invoker, listeners);
        }
    
        public void destroy() {
            protocol.destroy();
        }

在加载Protocol的配文件时，其内部含有ProtocolListenerWrapper ，在获取Protocol的自适应实例时，可能会返回ProtocolListenerWrapper 对象，通过InvokerListener的自适应对象从url上获取指定的Listener参数对应的InvokerListener拓展类对象，参与其export和refer方法的调用过程，也就是执行这些方法时会调用InvokerListener的相应方法，起到一个监听的作用。

以上就是ExtensionLoader加载拓展组件的主要过程源码，总结关键一点：

**通过url上的名称来获取对应的拓展类，如果url上没有相应参数，那么使用此接口上@SPI的value( ) 的值对应的拓展类，实例化这个类的对象，如果拓展组件上有包装类wrapperClass，那么有几个包装类就包装几次，最后返回一个包装对象。**

也就是说如果我们要自定义拓展组件，那么在使用前，先将去注入到ExtensionLoader对象中，以Protocol为例：

ExtensionLoader.getExtensionLoader(Protocol.class).addExtension(String name, Class<?> clazz);

name值为自定义组件的key，class为自定义组件的类型。 然后在url上加上参数protocol=name或者在注解@Service，@Reference指定相应的组件名称，这样就能使用我们自定义的组件了。

[Dubbo]: /images/20220524/558e7cf8bd3b484abb38fa71cf0265ee.png
[70]: /images/20220524/62ff07454be34447b5d50ea2be0cb589.png