dubbo SPI @Adaptive源码解读

àì夳堔傛蜴生んèń 2022-11-20 07:00 156阅读 0赞

> 接上文[dubbo SPI @Adaptive注解使用方法与原理解析][dubbo SPI _Adaptive]

### 目录 ###

*  概览
 *  `getAdaptiveExtension`——入口
 *   *  `createAdaptiveExtension`
     *   *  1`getAdaptiveExtensionClass`
         *   *  1.1`getExtensionClasses`
             *   *  1.1.1`loadExtensionClasses`
             *  1.2 `createAdaptiveExtensionClass`
         *  2`injectExtension`

# 概览 #

**自适应类的用法示例**

SimpleExt simpleExt= ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();

**接口代码示例**

@SPI("impl1")
    public interface SimpleExt { 
    
    	String echo(URL url,String s);
    
        @Adaptive({ "key4"})
        void printA(URL url);
    
        @Adaptive
        void printB(URL url);
    
        @Adaptive({ "key3","key2","key1"})
        void printC(URL url);
    }

`getAdaptiveExtension`**方法的大致流程如下图**（从左到右）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTYwNDI1_size_16_color_FFFFFF_t_70_pic_center]

接下来对每个方法进行解读。

# `getAdaptiveExtension`——入口 #

此方法是获取自适应类的入口

public T getAdaptiveExtension() { 
            //获得自适应扩展类实例的缓存
            Object instance = cachedAdaptiveInstance.get();
            //这里是使用了双重校验锁的单例模式
            if (instance == null) { 
                if (createAdaptiveInstanceError != null) { 
                    throw new IllegalStateException("Failed to create adaptive instance: " +
                            createAdaptiveInstanceError.toString(),
                            createAdaptiveInstanceError);
                }
    
                synchronized (cachedAdaptiveInstance) { 
                    instance = cachedAdaptiveInstance.get();
                    if (instance == null) { 
                        try { 
                            //无缓存则创建实例并缓存
                            instance = createAdaptiveExtension();
                            cachedAdaptiveInstance.set(instance);
                        } catch (Throwable t) { 
                            createAdaptiveInstanceError = t;
                            throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
                        }
                    }
                }
            }
            return (T) instance;
        }

## `createAdaptiveExtension` ##

当前面的方法没有获取带自适应类实例的缓存时，会进入此方法。这个方法里一共做了三件事。

1.  `getAdaptiveExtensionClass` **先获取自适应类**
2.  `newInstance` **再生成对应的实例**
3.  `injectExtension` **然后为实例注入扩展类属性**

private T createAdaptiveExtension() { 
            try { 
                return injectExtension((T) getAdaptiveExtensionClass().newInstance());
            } catch (Exception e) { 
                throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
            }
        }

### 1`getAdaptiveExtensionClass` ###

这里将分为两步骤

1.  `getExtensionClasses`**加载扩展点文件**。若实现类上有`@Adaptive`注解，会被缓存起来，只能存在一个自适应类的缓存，默认是不可覆盖的，并且后续的执行方法都是用的此实现类。
2.  `createAdaptiveExtensionClass`**创建自适应类**（仅在自适应类缓存为空时进入此方法）

private Class<?>  getAdaptiveExtensionClass() { 
            //加载配置文件
            getExtensionClasses();
            //若自适应类有缓存则返回
            if (cachedAdaptiveClass != null) { 
                return cachedAdaptiveClass;
            }
            //自适应类的缓存为空则创建
            return cachedAdaptiveClass = createAdaptiveExtensionClass();
        }

#### 1.1`getExtensionClasses` ####

此方法是dubbo SPI的核心方法，获取扩展类都需要经过这步（包括`getDefalultExtension`,`getAdaptiveExtension`,`getActivateExtension`）。同样还是先希望从缓存取，不存在就去加载文件填充缓存。

private Map<String, Class<?>> getExtensionClasses() { 
            //取缓存
            Map<String, Class<?>> classes = cachedClasses.get();
            if (classes == null) { 
                synchronized (cachedClasses) { 
                    classes = cachedClasses.get();
                    if (classes == null) { 
                        //缓存无，则从文件加载扩展点
                        classes = loadExtensionClasses();
                        cachedClasses.set(classes);
                    }
                }
            }
            return classes;
        }

##### 1.1.1`loadExtensionClasses` #####

这里也分为两步骤

1.  `cacheDefaultExtensionName`**获取扩展点名称并缓存**。例如`@SPI("impl1")`则是将"impl1"缓存下来
2.  `loadDirectory`**解析扩展点文件并缓存实现类**。例如配置文件内容为`impl1=com.example.demo.impl.SimpleExtImpl1`,则会以**key=“impl1” value= SimpleExtImpl1类**的键值对 存在`Map<String, Class<?>>`中。除了进行**普通扩展类**的缓存，此方法还会额外做三种缓存（**自适应类，包装扩展类，自动激活类**）以加快后续方法的执行效率。

private Map<String, Class<?>> loadExtensionClasses() { 
            //获取扩展点名称并缓存
            cacheDefaultExtensionName();
    
            Map<String, Class<?>> extensionClasses = new HashMap<>();
    
            for (LoadingStrategy strategy : strategies) { 
                //加载指定文件夹下的配置文件
                loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
                //同时加载alibaba和apache的类
                loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
            }
    
            return extensionClasses;
        }

#### 1.2 `createAdaptiveExtensionClass` ####

此方法将生成一个动态的自适应类，它能根据参数决定执行方法的实现类,主要做了三件事。

1.  **生成类代码字符串**。生成代码的逻辑主要分为7步。
    
    1.1 生成与扩展点相同位置的**package**。**import** `ExtensionLoader`这个类。为了不写其他的**import**方法，其他调用都使用全路径名。同时设置类名为“接口名称+**$Adaptive**”的格式。例如`SimpleExt`接口会生成`SimpleExt&Adaptive`。
    
    1.2 遍历接口的所有方法，获取方法的返回类型，参数类型，异常类型等。
    
    1.3 生成校验参数是否为空的代码。
    
    1.4 生成默认实现类名称。如果`@Adaptive`注解没有默认值，则会先根据此名称去寻找它的扩展实现类。如`SimpleExt`的默认类名称为**simple.ext**。
    
    1.5 生成获取扩展点名称的代码。例如对于前面的示例接口**SimpleExt**的**printC**方法，会生成`url.getParameter("key3", url.getParameter("key2",url.getParameter("key1","impl1")));`
    
    1.6 生成获取具体实现类的代码。通过上一步获得的**extName**执行**getExtension(extName)** 方法获取实现类。
    
    1.7 生成用此实现类调用方法的代码。
2.  **获取编译器的自适应类**。实现`Compile`接口的`AdaptiveCompiler`类上有`@Adaptive`注解，因此此类会作为编译器的默认实现。
3.  **使用编译器编译类**

private Class<?> createAdaptiveExtensionClass() { 
            //生成自适应类的代码
            String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
            ClassLoader classLoader = findClassLoader();
            //获取编译器类
            org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
            //动态编译生成类
            return compiler.compile(code, classLoader);
        }

### 2`injectExtension` ###

这一部分是为了**给新创建的扩展点实现类注入属性**。只有当此属性也为扩展点（且该扩展点已被加载并生成实例）时才能注入。  
主要逻辑是遍历该类的所有方法，查看**setter**方法的返回类型对应的类是否为扩展点，是的话将其通过反射调用此**setter**方法注入。

private T injectExtension(T instance) { 
            //此工厂中存储了已经实例化的扩展点，若工厂不为空，则查找工厂中是否拥有可注入的类
            if (objectFactory == null) { 
                return instance;
            }
    
            try { 
                //通过反射获取并遍历实现类的所有方法
                for (Method method : instance.getClass().getMethods()) { 
                    //只遍历以"set"命名开头的方法
                    if (!isSetter(method)) { 
                        continue;
                    }
                    /** * Check {@link DisableInject} to see if we need auto injection for this property */
                    if (method.getAnnotation(DisableInject.class) != null) { 
                        continue;
                    }
                    //获得该构造方法第一个参数类型
                    Class<?> pt = method.getParameterTypes()[0];
                    //若是基础类型则跳过,如 int，double，String等
                    if (ReflectUtils.isPrimitives(pt)) { 
                        continue;
                    }
    
                    try { 
                        //获取该属性名，如"setVersion" => "version"
                        String property = getSetterProperty(method);
                        //从扩展类工厂中获取该属性的实例
                        Object object = objectFactory.getExtension(pt, property);
                        //如果成功获取，则将该扩展类实例注入进去
                        if (object != null) { 
                            method.invoke(instance, object);
                        }
                    } catch (Exception e) { 
                        logger.error("Failed to inject via method " + method.getName()
                                + " of interface " + type.getName() + ": " + e.getMessage(), e);
                    }
    
                }
            } catch (Exception e) { 
                logger.error(e.getMessage(), e);
            }
            return instance;
        }

整体的流程就到此结束了，代码多处是反射和缓存的应用，如有错误欢迎指出~

> 如果有疑问，欢迎评论~  
> 如果成功解决了你的问题，点个赞再走吖~

[dubbo SPI _Adaptive]: https://blog.csdn.net/qq_41960425/article/details/109348241
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTYwNDI1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/815c445d27764b4bbf24adf91461496a.png