Dubbo SPI源码分析

看到ExtensionLoader主要方法和属性

	//静态属性
	//用于存放接口类型和ExtensionLoader的映射关系
	private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
	
	//每个接口的扩展类加载器的成员属性
	//扩展接口类型
	private final Class<?> type;
	//用来对扩展类的set方法属性进行赋值
    private final ExtensionFactory objectFactory;
	//存放接口对应的ExtensionLoader的有@Adaptive注解的实现类
	private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
	//加载不到@Adaptive注解修饰的实现类时,使得其他线程快速感知抛出异常的标识
	private volatile Throwable createAdaptiveInstanceError;
	//缓存扩展文件中key(扩展名称) value(接口实现类) 的映射关系 , 不包括@Adaptive注解的扩展类和包装扩展类
	private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
	//默认的接口实现类的 spi注解的value值 对应扩展文件中的扩展名称
	private String cachedDefaultName;
	//含有@Adaptive注解的扩展类
	private volatile Class<?> cachedAdaptiveClass = null;
	//记录包装扩展类(可以持有其他的扩展类实例)
    private Set<Class<?>> cachedWrapperClasses;
    //记录扩展名称 和 扩展类上@Activate注解的映射关系
    private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
    //记录扩展类 和 扩展名名称 的 映射关系
    private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
    //记录扩展名称和Holder的映射关系,Holder持有扩展类的实例
    private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
    //记录扩展类和扩展类实例的映射关系
    private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();


	//spi加载的扩展文件路径
	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/";

getExtensionLoader

	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) {
        	//实例化ExtensionLoader(扩展类加载器),放入EXTENSION_LOADERS中
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        //返回ExtensionLoader
        return loader;
    }
    private static <T> boolean withExtensionAnnotation(Class<T> type) {
        return type.isAnnotationPresent(SPI.class);
    }
    private ExtensionLoader(Class<?> type) {
    	//记录扩展接口
        this.type = type;
        //如果接口类型不是ExtensionFactory
        //对应的被加载的文件为META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory
        //则objectFactory为实现了ExtensionFactory接口且有@Adaptive注解的实现类(AdaptiveExtensionFactory)。
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

getAdaptiveExtension,获取扩展接口的有@Adaptive注解的实现类

	public T getAdaptiveExtension() {
		//首次进来肯定没有
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
        	//加载不到对应的实现类时,createAdaptiveInstanceError会被设置为对应的Throwable 
            if (createAdaptiveInstanceError == null) {
                synchronized (cachedAdaptiveInstance) {
                	//再拿一次,之前没抢到锁等待的线程,此时可以获取到
                    instance = cachedAdaptiveInstance.get();
                    //第一个进来设置值的线程
                    if (instance == null) {
                        try {
                        	//创建对应的实现类
                            instance = createAdaptiveExtension();
                            //设置到cachedAdaptiveInstance中
                            cachedAdaptiveInstance.set(instance);
                        } catch (Throwable t) {
                        	//获取不到,则设置createAdaptiveInstanceError 变量
                            createAdaptiveInstanceError = t;
                            throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
                        }
                    }
                }
            }
            //加载不到对应的实现类时,抛出异常
            else {
                throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
            }
        }
        return (T) instance;
    }
    private T createAdaptiveExtension() {
        try {
        	//getAdaptiveExtensionClass获取Adaptive的扩展类
        	//injectExtension调用扩展类set方法进行属性赋值
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }
    //获取有@Adaptive注解的实现类
    private Class<?> getAdaptiveExtensionClass() {	
    	//加载扩展文件
        getExtensionClasses();
        //如果有,直接返回
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        //没有@Adaptive注解的实现类,自动生成一个,返回
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }
    private Map<String, Class<?>> getExtensionClasses() {
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
        	//classes 没值说明没有加载过扩展文件
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                	//加载扩展文件 返回扩展名称和扩展类的map
                    classes = loadExtensionClasses();
                    //将classes  放入cachedClasses中
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }
    private Map<String, Class<?>> loadExtensionClasses() {
    	//获取扩展接口上的spi注解
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation != null) {
        	//获取注解的value值 (默认的扩展实现类 该注解的value值对应扩展文件中的扩展名称)
            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));
                }
                //将注解的value值赋值给cachedDefaultName 
                if (names.length == 1) cachedDefaultName = names[0];
            }
        }
		
        Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
        //加载对应路径下的扩展文件
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
        loadDirectory(extensionClasses, DUBBO_DIRECTORY);
        loadDirectory(extensionClasses, SERVICES_DIRECTORY);
        return extensionClasses;
    }
    private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
    	//文件名称为 路径 加上 扩展接口名
        String fileName = dir + type.getName();
        try {
            Enumeration<java.net.URL> urls;
            //获取ExtensionLoader.class对应的类加载器
            ClassLoader classLoader = findClassLoader();
            //加载文件
            if (classLoader != null) {
                urls = classLoader.getResources(fileName);
            } else {
                urls = ClassLoader.getSystemResources(fileName);
            }
            if (urls != null) {  
                while (urls.hasMoreElements()) {
                    java.net.URL resourceURL = urls.nextElement();
                    //解析处理文件内容
                    loadResource(extensionClasses, classLoader, resourceURL);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }
    private static ClassLoader findClassLoader() {
        return ExtensionLoader.class.getClassLoader();
    }
    private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
        try {
        	//读取文件内容
            BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "utf-8"));
            try {
                String line;
                //一行一行读
                while ((line = reader.readLine()) != null) {
                	//可以在行开头加#注释掉一行的内容
                	//可以在行尾加#和说明文字
                    final int ci = line.indexOf('#');
                    //截取掉#后续的内容
                    if (ci >= 0) line = line.substring(0, ci);
                    //去空格
                    line = line.trim();
                    if (line.length() > 0) {
                        try {
                            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) {
                            	//建立扩展名称和扩展类的映射关系
                                loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
                            }
                        } catch (Throwable t) {
                            IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);							//解析失败的行内容,记录下来,可以调用findException来获取exceptions的内容
                            exceptions.put(line, e);
                        }
                    }
                }
            } finally {
                reader.close();
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", class file: " + resourceURL + ") in " + resourceURL, t);
        }
    }
    private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
        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.");
        }
        //如果扩展类有@Adaptive注解
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            if (cachedAdaptiveClass == null) {
            	//将该扩展类赋值给cachedAdaptiveClass 
                cachedAdaptiveClass = clazz;
            } 
            //只能有一个扩展类有@Adaptive注解
            else if (!cachedAdaptiveClass.equals(clazz)) {
                throw new IllegalStateException("More than 1 adaptive class found: "
                        + cachedAdaptiveClass.getClass().getName()
                        + ", " + clazz.getClass().getName());
            }
        } 
        //是否为包装类
        else if (isWrapperClass(clazz)) {
        	//cachedWrapperClasses记录所有的WrapperClass
            Set<Class<?>> wrappers = cachedWrapperClasses;
            if (wrappers == null) {
                cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                wrappers = cachedWrapperClasses;
            }
            wrappers.add(clazz);
        } 
        else {
            clazz.getConstructor();
            //扩展文件中,可以不写扩展名称
            if (name == null || name.length() == 0) {
            	//根据类名生成一个扩展名称
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }
            //可以用,分隔取多个名称
            String[] names = NAME_SEPARATOR.split(name);
            if (names != null && names.length > 0) {
            	//获取类上的Activate注解
                Activate activate = clazz.getAnnotation(Activate.class);
                if (activate != null) {
                	//建立扩展名称 和 扩展类上Activate注解的映射关系
                    cachedActivates.put(names[0], activate);
                }  
                for (String n : names) {
                	//如果有多个名称,只记录了第一个名称的
                    if (!cachedNames.containsKey(clazz)) {
                    	//记录扩展类 和 扩展名名称 的 映射关系
                        cachedNames.put(clazz, n);
                    }
                    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());
                    }
                }
            }
        }
    }
    //是否为WrapperClass(可以持有其他的扩展类实例)
    private boolean isWrapperClass(Class<?> clazz) {
        try {
        	//拥有 一个入参,且入参为扩展接口类型的 构造函数 
            clazz.getConstructor(type);
            return true;
        } catch (NoSuchMethodException e) {
            return false;
        }
    }
    private String findAnnotationName(Class<?> clazz) {
    	//获取类上的Extension注解
        com.alibaba.dubbo.common.Extension extension = clazz.getAnnotation(com.alibaba.dubbo.common.Extension.class);
        //如果没有Extension注解值
        if (extension == null) {
        	//获取类的SimpleName
            String name = clazz.getSimpleName();
            //如果名称结尾 和 扩展接口类型一致
            //则截取   比如(HttpProtocol 实现 Protocol接口) 则此时name为Http
            if (name.endsWith(type.getSimpleName())) {
                name = name.substring(0, name.length() - type.getSimpleName().length());
            }
            //返回小写形式
            return name.toLowerCase();
        }
        //返回注解的value值
        return extension.value();
    }
    private Class<?> createAdaptiveExtensionClass() {
    	//可以没有@Adaptive注解的实现类,这里动态生成一个。
        String code = createAdaptiveExtensionClassCode();
        //获取类加载器
        ClassLoader classLoader = findClassLoader();
        //spi获取编译器
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        //返回编译后的class对象
        return compiler.compile(code, classLoader);
    }
    private T injectExtension(T instance) {
        try {
        	//objectFactory不为空
            if (objectFactory != null) {
                for (Method method : instance.getClass().getMethods()) {
                	//方法名称set开头,只有一个入参,访问权限为public
                    if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) {
						//方法上有DisableInject注解,则不处理
                        if (method.getAnnotation(DisableInject.class) != null) {
                            continue;
                        }
                        //获取入参的类型
                        Class<?> pt = method.getParameterTypes()[0];
                        try {
                        	//截取掉set方法的set字母,并把第4个字母小写
                            String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                            //获取对象
                            Object object = objectFactory.getExtension(pt, property);
                            //调用set方法
                            if (object != null) {
                                method.invoke(instance, object);
                            }
                        } catch (Exception e) {
                            logger.error("fail to inject via method " + method.getName()
                                    + " of interface " + type.getName() + ": " + e.getMessage(), e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }
    public Set<String> getSupportedExtensions() {
    	//获取扩展名称和扩展类的映射关系
        Map<String, Class<?>> clazzes = getExtensionClasses();
        //返回所有的扩展名称
        return Collections.unmodifiableSet(new TreeSet<String>(clazzes.keySet()));
    }
    public T getDefaultExtension() {
        getExtensionClasses();
        if (null == cachedDefaultName || cachedDefaultName.length() == 0
                || "true".equals(cachedDefaultName)) {
            return null;
        }
        //根据cachedDefaultName获取扩展类返回
        return getExtension(cachedDefaultName);
    }
    public T getExtension(String name) {
        if (name == null || name.length() == 0)
            throw new IllegalArgumentException("Extension name == null");
        if ("true".equals(name)) {
        	//name等于"true",返回默认扩展类
            return getDefaultExtension();
        }
        //根据名称获取扩展类的Holder
        Holder<Object> holder = cachedInstances.get(name);
        if (holder == null) {
        	//建立扩展名称和Holder的映射关系
            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中
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }
    private T createExtension(String name) {
    	//根据名称获取到扩展类
        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);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            //获取到包装扩展类
            if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
            	//循环所有的包装扩展类
                for (Class<?> wrapperClass : wrapperClasses) {
                	//实例化包装扩展类,并持有instance实例
                    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);
        }
    }
    public List<T> getActivateExtension(URL url, String[] values, String group) {
        List<T> exts = new ArrayList<T>();
        //values数组赋值给names集合
        List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
        //名称不包含 "-default"  Constants.REMOVE_VALUE_PREFIX为"-" 表示排除 。
        //如果包含则这里排除了group和url可以匹配到扩展类
        if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
            getExtensionClasses();
            //(cachedActivates 记录扩展名称 和 扩展类上@Activate注解的映射关系)
            for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
                String name = entry.getKey();
                Activate activate = entry.getValue();
                //匹配注解的group值 和 入参的group值
                if (isMatchGroup(group, activate.group())) {
                	//判断names 是否有和 扩展类的扩展名一致的,一致的在下面的循环加入exts
                	//判断names 不排除该name
                	//匹配url参数和 @Activate注解的value值
                    if (!names.contains(name)
                            && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
                            && isActive(activate, url)) {
                        //使用扩展名获取扩展类加入到exts
                        T ext = getExtension(name);
                        exts.add(ext);
                    }
                }
            }
            //排序,限于篇幅这里就不再写了了,比较简单。Activate注解的before after order属性值
            Collections.sort(exts, ActivateComparator.COMPARATOR);
        }
        List<T> usrs = new ArrayList<T>();
        //循换names
        for (int i = 0; i < names.size(); i++) {
            String name = names.get(i);
            //name不以"-"开头 且 names不排除该name
            if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
                    && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
                //如果name是"default" , 将usrs放到exts的前面,然后将usrs清空
                if (Constants.DEFAULT_KEY.equals(name)) {
                    if (!usrs.isEmpty()) {
                        exts.addAll(0, usrs);
                        usrs.clear();
                    }
                } else {
                	//使用扩展名获取到扩展类加入到usrs中
                    T ext = getExtension(name);
                    usrs.add(ext);
                }
            }
        }
        if (!usrs.isEmpty()) {
        	//usrs不空加入到exts
            exts.addAll(usrs);
        }
        //返回符合条件的扩展类
        return exts;
    }
    private boolean isMatchGroup(String group, String[] groups) {
    	//group为空,则不用和注解上的group匹配。直接返回true
        if (group == null || group.length() == 0) {
            return true;
        }
        if (groups != null && groups.length > 0) {
        	//判断group 和 注解上的group值是否一致
            for (String g : groups) {
                if (group.equals(g)) {
                    return true;
                }
            }
        }
        //不匹配 返回false
        return false;
    }
    private boolean isActive(Activate activate, URL url) {
    	//获取注解配置的value值
        String[] keys = activate.value();
        //没有配置返回true
        if (keys.length == 0) {
            return true;
        }
        //循环注解配置的所有的value值
        for (String key : keys) {
            //循环当前url携带的参数
            for (Map.Entry<String, String> entry : url.getParameters().entrySet()) {
                String k = entry.getKey();
                String v = entry.getValue();
                //url参数key和注解的value值一致 或者 参数key结尾为.加上注解的value值
                //url参数key对应的值不能为空
                if ((k.equals(key) || k.endsWith("." + key))
                        && ConfigUtils.isNotEmpty(v)) {
                    return true;
                }
            }
        }
        //不匹配返回false
        return false;
    }

createAdaptiveExtensionClassCode方法

private String createAdaptiveExtensionClassCode() {
        StringBuilder codeBuilder = new StringBuilder();
        Method[] methods = type.getMethods();
        boolean hasAdaptiveAnnotation = false;
        //遍历扩展接口的所有方法
        for (Method m : methods) {
        	//方法上需要有Adaptive注解修饰
            if (m.isAnnotationPresent(Adaptive.class)) {
                hasAdaptiveAnnotation = true;
                break;
            }
        }
        // no need to generate adaptive class since there's no adaptive method found.
        //没有一个方法有Adaptive注解修饰,直接抛出异常,无法自动生成
        if (!hasAdaptiveAnnotation)
            throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
		
        codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
       	//限于篇幅省略大段的代码字符串拼接逻辑,具体逻辑可以看官方文档https://dubbo.apache.org/zh/docsv2.7/dev/source/adaptive-extension/
       	//日志debug级别下,控制台会打印这里的字符串
       	//或者直接打断点到这里来看,生成的类比较简单,完全可以看懂
		//这里自动生成的类实现的 扩展接口中有@Adaptive注解修饰的方法 主要逻辑为交给其他扩展实现类去完成方法调用。 没有注解的方法,则实现的逻辑为直接抛出UnsupportedOperationException
        return codeBuilder.toString();
    }

objectFactory的getExtension方法

@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {

    private final List<ExtensionFactory> factories;

    public AdaptiveExtensionFactory() {
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
        //循环所有的扩展名称(不包括@Adaptive注解的扩展类和包装扩展类), 这里能找到两个
        for (String name : loader.getSupportedExtensions()) {
        	//获取到扩展类
            list.add(loader.getExtension(name));
        }
     	//赋值给factories
        factories = Collections.unmodifiableList(list);
    }

    @Override
    public <T> T getExtension(Class<T> type, String name) {
        for (ExtensionFactory factory : factories) {
        	//从dubbo的spi容器 和 spring容器找
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }
}

META-INF\dubbo\internal\com.alibaba.dubbo.common.extension.ExtensionFactory

adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
spring=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory

SpiExtensionFactory

public class SpiExtensionFactory implements ExtensionFactory {

    @Override
    public <T> T getExtension(Class<T> type, String name) {
    	//接口类型 且有 @SPI注解修饰
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
            if (!loader.getSupportedExtensions().isEmpty()) {
            	//获取@Adaptive修饰的扩展类
                return loader.getAdaptiveExtension();
            }
        }
        return null;
    }

}

SpringExtensionFactory

public class SpringExtensionFactory implements ExtensionFactory {
    private static final Logger logger = LoggerFactory.getLogger(SpringExtensionFactory.class);

    private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();

    private static final ApplicationListener shutdownHookListener = new ShutdownHookListener();
    //暂时还没讲到ServiceBean 和 ReferenceBean 不过没关系只需要spring的基础知识
	// ServiceBean 和 ReferenceBean实现了ApplicationContextAware接口 ,实现了setApplicationContext方法来调用该方法
	// 实例化时会调用该方法 将当前spring容器加入到contexts
    public static void addApplicationContext(ApplicationContext context) {
        contexts.add(context);
        //这里还添加了一个监听事件
        BeanFactoryUtils.addApplicationListener(context, shutdownHookListener);
    }

    public static void removeApplicationContext(ApplicationContext context) {
        contexts.remove(context);
    }

    public static Set<ApplicationContext> getContexts() {
        return contexts;
    }

    // currently for test purpose
    public static void clearContexts() {
        contexts.clear();
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T getExtension(Class<T> type, String name) {
    	//根据name从spring容器中获取bean
        for (ApplicationContext context : contexts) {
            if (context.containsBean(name)) {
                Object bean = context.getBean(name);
                if (type.isInstance(bean)) {
                    return (T) bean;
                }
            }
        }

        logger.warn("No spring extension (bean) named:" + name + ", try to find an extension (bean) of type " + type.getName());

        if (Object.class == type) {
            return null;
        }
		//根据type从spring容器中获取bean
        for (ApplicationContext context : contexts) {
            try {
                return context.getBean(type);
            } catch (NoUniqueBeanDefinitionException multiBeanExe) {
                logger.warn("Find more than 1 spring extensions (beans) of type " + type.getName() + ", will stop auto injection. Please make sure you have specified the concrete parameter type and there's only one extension of that type.");
            } catch (NoSuchBeanDefinitionException noBeanExe) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Error when get spring extension(bean) for type:" + type.getName(), noBeanExe);
                }
            }
        }

        logger.warn("No spring extension (bean) named:" + name + ", type:" + type.getName() + " found, stop get bean.");

        return null;
    }
	//这里监听ContextClosedEvent
    private static class ShutdownHookListener implements ApplicationListener {
        @Override
        public void onApplicationEvent(ApplicationEvent event) {
            if (event instanceof ContextClosedEvent) {
                // we call it anyway since dubbo shutdown hook make sure its destroyAll() is re-entrant.
                // pls. note we should not remove dubbo shutdown hook when spring framework is present, this is because
                // its shutdown hook may not be installed.
                DubboShutdownHook shutdownHook = DubboShutdownHook.getDubboShutdownHook();
                //这里会清理registries和protocols (也还没讲到注册配置类和协议配置类)
                shutdownHook.destroyAll();
            }
        }
    }

}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值