Dubbo的自适应扩展实现原理

最新推荐文章于 2024-04-23 06:12:36 发布

原创最新推荐文章于 2024-04-23 06:12:36 发布 · 709 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

dubbo

本文探讨了Dubbo的自适应扩展原理，通过动态代理实现根据运行时参数加载相应扩展。介绍了@Adaptive注解的作用，并详细解析了ExtensionLoader的getAdaptiveExtension方法，包括缓存检查、自适应扩展类的创建、实例化及依赖注入过程。文章还简述了自适应扩展类的生成代码逻辑。

Dubbo的自适应扩展原理

Dubbo支持多种协议，多种序列化方式，多注册中心等等，使用起来非常的灵活简便。内置了很多常见的组件，比如协议支持dubbo, redis,thrift,grpc,hessian等，也支持用户自定义协议去完成业务功能。这种灵活便捷，正是Dubbo的SPI带来的好处。有时，有些扩展我们不想在框架启动时就直接加载，而是希望在扩展方法被调用的时候，根据运行时的参数去加载具体的扩展类。这么一说，是不是很快就想到了一种实现方式：动态代理。我们可以直接根据每一个SPI接口，封装出一个代理类，由代理类去找到对应的扩展实现，然后调用扩展方法。我们来举一个例子说明这个问题：

/**
 * 接口：Reporter，有两个实现类ChineseReporter， EnglishReporter
 */
interface Reporter {
    
    String report(URL url);
}

class ChineseReporter implements Reporter {
    
    @Override
    String report(URL url) {
        return "你好";
    }
}

class EnglishReporter implements Reporter {
    
    @Override
    String report(URL url) {
        return "hello";
    }
}

现在我们如果想根据传入的url参数中属性nation，来决定初始化对应实例，调用该方法，应该怎么做呢，是不是要新编写一个代理类，来帮助我们完成这个功能

public class AdaptiveReporter implements Reporter {
    @Override
    public String report(URL url) {
        if (url == null) {
            throw new IllegalArgumentException("url == null");
        }
        
    	// 1.从 URL 中获取 nation 名称
        String nation = url.getParameter("nation");
        if (nation == null) {
            throw new IllegalArgumentException("nation == null");
        }
        
        // 2.通过 SPI 加载具体的 Reporter, 如果传入的nation是chinese，得到就是ChineseReporter，如果传入的是english,得到的就是EnglishReporter
        Reporter reporter = ExtensionLoader
            .getExtensionLoader(Reporter.class).getExtension(nation);
        
        // 3.调用目标方法
        return reporter.report(url);
    }
}

Dubbo的自适应扩展正是这么实现的，只不过这里我们不需要主动为每一个SPI接口编写代理类，而是由Dubbo自动为我们生成具有代理功能的代码，通过javassist或者jdk编译这个代理类，得到Class对象，通过反射创建出代理实例。

源码分析（apache dubbo 2.7.8）

自使用扩展实现中有一个很重要的注解@Adaptive，先来看一下它的说明

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {

/**
 * Decide which target extension to be injected. The name of the target extension is decided by the parameter    * passed in the URL, and the parameter names are given by this method.
 * 决定要注入哪个目标扩展。目标扩展名由URL中传递的参数决定，参数名由该方法给出。
 * If the specified parameters are not found from URL, then the default extension will be used for dependency *injection (specified in its interface's SPI).
 * 如果在URL中找不到指定的参数，那么默认扩展将用于依赖项注入(在其接口的SPI中指定)。
 * For example, given String[] {"key1", "key2"}:
 *   1. find parameter 'key1' in URL, use its value as the extension's name
 *      在url上找到key1对应的value，作为扩展类的name
 *   2. try 'key2' for extension's name if 'key1' is not found (or its value is empty) in URL
 *      如果key1对应的value为空或者key1不存在，尝试使用key2
 *   3. use default extension if 'key2' doesn't exist either
 *      key2也不存在，那么使用默认的扩展name，SPI上指定的
 *   4. otherwise, throw IllegalStateException
 *      否则，抛出异常
 * If the parameter names are empty, then a default parameter name is generated from interface's class name with *the rule: divide classname from capital char into several parts, and separate the parts with dot '.', for *example, for org.apache.dubbo.xxx.YyyInvokerWrapper, the generated name is String[] {"yyy.invoker.wrapper"}.
 * 如果该参数为空，会从接口的名称上生成一个name
 * @return parameter names in URL 返回URL对应的参数名
 */
 String[] value() default {};

Adaptive注解可以放在类上，也可以放在方法上，放在类上不会为该类生成代理类，一般情况下，Adaptive注解都是放在SPI接口的方法上面。通过ExtensionLoader的getAdaptiveExtension方法，获取到自适应扩展实例，我们就来分析下该方法。

    @SuppressWarnings("unchecked")
    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;
    }
    
    @SuppressWarnings("unchecked")
    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 方法获取自适应拓展 Class 对象
2. 通过反射进行实例化
3. 调用 injectExtension 方法向拓展实例中注入依赖
  为什么这里第3步，还要注入依赖，我们生成的代理类，默认是不包含外部依赖的。原来Dubbo存在两种自适应扩展，一种是自动生成的，一种是手动编写的，手工编写的自适应扩展很可能会存在一些依赖，所以这里是为了手动编写的扩展类做注入的。我们接着分析getAdaptiveExtensionClass方法

    private Class<?> getAdaptiveExtensionClass() {
        // 通过 SPI 获取所有的拓展类
        getExtensionClasses();
        // 检查缓存，若缓存不为空，则直接返回缓存。这里可以看到，当Adaptive注解标注到类上，不会去创建代理类
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        // 创建自适应拓展类
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }
    
    // 创建出代理类，并编译成Class对象
    private Class<?> createAdaptiveExtensionClass() {
        // 生成自适应拓展代码,这里的cachedDefaultName，就是缓存默认的实现name
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
        ClassLoader classLoader = findClassLoader();
        // 获取到编译器实现类，有jdk,javassist两种，默认是javassist
        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        // 编译代码，生成Class
        return compiler.compile(code, classLoader);
    }

先检查实现类中有没有标识Adaptive注解的，存在直接返回该实现类，否则就创建出代理类，并编译成Class对象,这里重点在于generate方法，是如何生成具有代理功能的code

    /**
     * generate and return class code
     * 生成对应的class代码并返回
     */
    public String generate() {
        // no need to generate adaptive class since there's no adaptive method found.
        // SPI接口，至少有一个方法上含有Adaptive注解
        if (!hasAdaptiveMethod()) {
            throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
        }

        StringBuilder code = new StringBuilder();
        // 拼接package信息
        code.append(generatePackageInfo());
        // 拼接import信息
        code.append(generateImports());
        // 拼接class声明信息
        code.append(generateClassDeclaration());

        // 获取到方法信息
        Method[] methods = type.getMethods();
        for (Method method : methods) {
            // 拼接生成的每一个方法
            code.append(generateMethod(method));
        }
        code.append("}");

        if (logger.isDebugEnabled()) {
            logger.debug(code.toString());
        }
        return code.toString();
    }
    
    /**
     * generate method declaration
     * 生成方法的声明
     */
    private String generateMethod(Method method) {
        // 获取方法返回的全类型
        String methodReturnType = method.getReturnType().getCanonicalName();
        // 获取方法名
        String methodName = method.getName();
        // 生成方法内容，重点在此
        String methodContent = generateMethodContent(method);
        // 生成方法参数
        String methodArgs = generateMethodArguments(method);
        // 生成方法抛出的异常
        String methodThrows = generateMethodThrows(method);
        return String.format(CODE_METHOD_DECLARATION, methodReturnType, methodName, methodArgs, methodThrows, methodContent);
    }
    
    /**
     * generate method content
     */
    private String generateMethodContent(Method method) {
        Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
        StringBuilder code = new StringBuilder(512);
        // 方法上没有Adaptive注解，则会抛出不支持异常
        if (adaptiveAnnotation == null) {
            return generateUnsupported(method);
        } else {
            // 获取到方法参数类型是URL的数组下标
            int urlTypeIndex = getUrlTypeIndex(method);

            // found parameter in URL type
            if (urlTypeIndex != -1) {
                // Null Point check
                // 检查传入的url是否为空，否则抛出异常，参数的位置在第二个, 生成的参数名就是arg2
                code.append(generateUrlNullCheck(urlTypeIndex));
            } else {
                // did not find parameter in URL type
                // 参数中没有直接找到URL类型， 则查看参数中对应的方法是否有返回URL类型的
                code.append(generateUrlAssignmentIndirectly(method));
            }

            // 得到方法注解上面的值
            String[] value = getMethodAdaptiveValue(adaptiveAnnotation);

            // 方法参数上是否有Invocation类型的参数
            boolean hasInvocation = hasInvocationArgument(method);

            // 判空检查
            code.append(generateInvocationArgumentNullCheck(method));

            //获取URL参数name(就是Adaptive注解中的value值)对应的value，赋值给extName
            code.append(generateExtNameAssignment(value, hasInvocation));
            // check extName == null?
            code.append(generateExtNameNullCheck(value));

            // 得到具体的extension
            code.append(generateExtensionAssignment());

            // return statement
            code.append(generateReturnAndInvocation(method));
        }

        return code.toString();
    }

以上就是生成代理类code的大体过程了，中间有一些关于如何查找到url中参数中的value,即查询到对应的扩展类name，没有进行细致的分析，读者可以参考Adaptive注解中的说明进行分析。下面来看一下具体生成的一个自适应扩展类code(经过格式化以后的)

// SPI接口
package org.apache.dubbo.common.extension.adaptive;

import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.extension.Adaptive;
import org.apache.dubbo.common.extension.SPI;

@SPI
public interface HasAdaptiveExt {
    @Adaptive
    String echo(URL url, String s);
}

// 生成的自适应代理code

package org.apache.dubbo.common.extension.adaptive;

import org.apache.dubbo.common.extension.ExtensionLoader;

public class HasAdaptiveExt$Adaptive implements org.apache.dubbo.common.extension.adaptive.HasAdaptiveExt {

    public java.lang.String echo(org.apache.dubbo.common.URL arg0, java.lang.String arg1)  {
        if (arg0 == null) 
            throw new IllegalArgumentException("url == null");
            org.apache.dubbo.common.URL url = arg0;
        String extName = url.getParameter("has.adaptive.ext", "adaptive");
        if(extName == null) 
            throw new IllegalStateException("Failed to get extension (org.apache.dubbo.common.extension.adaptive.HasAdaptiveExt) name from url (" + url.toString() + ") use keys([has.adaptive.ext])");
        org.apache.dubbo.common.extension.adaptive.HasAdaptiveExt extension = (org.apache.dubbo.common.extension.adaptive.HasAdaptiveExt)ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.extension.adaptive.HasAdaptiveExt.class).getExtension(extName);
        return extension.echo(arg0, arg1);
    }
}

标签

#后端