EnhancedServiceLoader功能说明

fescar在fescar-core工程的com.alibaba.fescar.core.context.ContextCoreLoader会使用fescar-common组件中的EnhancedServiceLoader类;
ContextCoreLoader就是用来加载ContextCore接口的实现类，其中主要的加载的实现逻辑就是由EnhancedServiceLoader来实现的，如果获取不到，主默认使用ThreadLocalContextCore：

public class ContextCoreLoader {
    private static class ContextCoreHolder {
        private static ContextCore INSTANCE;
        static {
            ContextCore contextCore = EnhancedServiceLoader.load(ContextCore.class);
            if (contextCore == null) {
                // Default
                contextCore = new ThreadLocalContextCore();
            }
            INSTANCE = contextCore;
        }
    }
    public static ContextCore load() {
        return ContextCoreHolder.INSTANCE;
    }
}

那么EnhancedServiceLoader的作用就是要通过一定规则加载指定接口服务的实现类。下面通过代码分析它的加载规则。

源码分析

providers 属性

EnhancedServiceLoader是一个单例对象，其中有一个Map类型的providers静态属性，由于该属性会被并发读写，为了保证线程安全，使用了ConcurrentHashMap的实例。其中键为要加载接口的类型，值为有序的链表类型，存储接口的实现类（一个要加载的接口有多个实现类）。

private static Map<Class, List<Class>> providers = new ConcurrentHashMap<Class, List<Class>>();

load(Class<S> service)方法

当调用EnhancedServiceLoader的load方法时，会直接调用内部的loadFile()方法

    public static <S> S load(Class<S> service) throws EnhancedServiceNotFoundException {
        return loadFile(service, null, findClassLoader());
    }

findAllExtensionClass()方法

在loadFile()方法中会先通过providers属性查找是否已经缓存有想要加载的实现类，如果没有就同步加载。加载逻辑由findAllExtensionClass()实现：

 synchronized (service) {
                    extensions = providers.get(service);
                    if (extensions == null) {
                        extensions = findAllExtensionClass(service, activateName, loader);
                        foundFromCache = false;
                        providers.put(service, extensions);
                    }
                }

加载完成以后对接口加载到的实现列表接注解的优化级进行排序。

 Collections.sort(extensions, new Comparator<Class>() {
            @Override
            public int compare(Class c1, Class c2) {
                Integer o1 = 0;
                Integer o2 = 0;
                @SuppressWarnings("unchecked")
                LoadLevel a1 = (LoadLevel) c1.getAnnotation(LoadLevel.class);
                @SuppressWarnings("unchecked")
                LoadLevel a2 = (LoadLevel) c2.getAnnotation(LoadLevel.class);

                if (a1 != null) {
                    o1 = a1.order();
                }

                if (a2 != null) {
                    o2 = a2.order();
                }

                return o1.compareTo(o2);

            }
        });

loadFile(Class<?> service, String dir, ClassLoader classLoader, List<Class> extensions)方法

在findAllExtensionClass()方法中会使用loadFile()来加载接口的实现类。

            loadFile(service, SERVICES_DIRECTORY, loader, extensions);
            loadFile(service, FESCAR_DIRECTORY, loader, extensions);

它会使用应用的classloader来加载classpath下的如下文件：

META-INF/services/com.alibaba.fescar.core.context.ContextCore
META-INF/fescar/com.alibaba.fescar.core.context.ContextCore

读取文件中的数据，如果是注释则忽略，否则读取该行数据（该数据就是接口的实现类名）转换为Class,添加到provider对象中。

                    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) {
                            extensions.add(Class.forName(line, true, classLoader));
                        }
                    }

最后从provider中取出实现类链表，取出优化级最高的类，并创建实例：

            Class<?> extension = extensions.get(extensions.size() - 1);// 最大的一个
            S result = service.cast(extension.newInstance());

以上就是EnhancedServiceLoader实现服务加载能力增强的整个过程。
其实有很多技术框架都是基于这种方式来扩展类加载的方式,比如：

• servlet3.0中对ServletContainerInitializer接口的实现。