ServiceLoader服务提供者加载设施帮助类

ServiceLoader是jdk提供的一个简单的服务提供者加载设施，一个服务（接口）的实现者在其资源目录META-INF/services 中放置提供者配置文件 来标识服务提供者。

文件名称是服务类型的完全限定名称。该文件包含一个具体提供者类的完全限定名称列表，每行一个。

通过ServiceLoader.load创建服务实现者加载器，通过iterator以延迟方式加载此加载器服务的可用提供者。

 

本帮助类对ServiceLoader的功能进行了增强：

1.对加载到的服务提供者进行缓存，避免重复加载。

2.提供一种按key/value的方式来配置服务提供者，按key来获取具体服务提供者的扩展。

 

代码如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 服务提供者加载设施帮助类，应用中每个ClassLoader都有不同的ServiceLoaderHelp，因为对同一个服务，使用不同的ClassLoader，
 * 加载的jar包可能不同，资源目录META-INF/services下放置的服务提供者配置文件也就可能不同，导致不同ClassLoader加载到的服务提供者不同。
 */
public class ServiceLoaderHelp {
    private static final Logger log = LoggerFactory.getLogger(ServiceLoaderHelp.class);

    private static final String PREFIX = "META-INF/services/";
    private static final ConcurrentHashMap<ClassLoader, ServiceLoaderHelp> MAP_Help_CACHE = new ConcurrentHashMap<ClassLoader, ServiceLoaderHelp>();

    private final ClassLoader classLoader;
    private final ConcurrentHashMap<Class<?>, Object> INSTANCE_CACHE = new ConcurrentHashMap<Class<?>, Object>();
    private final ConcurrentHashMap<Class<?>, Map<String, Class<?>>> MAP_CLASSES_CACHE = new ConcurrentHashMap<Class<?>, Map<String, Class<?>>>();
    private final ConcurrentHashMap<Class<?>, ConcurrentHashMap<String, Object>> MAP_INSTANCES_CACHE = new ConcurrentHashMap<Class<?>, ConcurrentHashMap<String, Object>>();

    private ServiceLoaderHelp(ClassLoader classLoader){
        this.classLoader = classLoader;
    }

    /**
     * 根据ClassLoader获取服务提供者加载设施帮助类。
     * @param classLoader
     * @return 服务提供者加载设施帮助类
     */
    public static ServiceLoaderHelp getHelpByClassLoader(ClassLoader classLoader){
        ServiceLoaderHelp help = MAP_Help_CACHE.get(classLoader);
        if (help == null){
            help = new ServiceLoaderHelp(classLoader);
            MAP_Help_CACHE.putIfAbsent(classLoader, help);
            return MAP_Help_CACHE.get(classLoader);
        } else {
            return help;
        }
    }

    /**
     * 根据服务接口Class获取服务提供者，若有多个服务提供者取ServiceLoader.load到的第一个服务提供者。
     * @param classType 服务接口Class
     * @return 服务提供者
     */
    @SuppressWarnings("unchecked")
    public <T> T getInstance(Class<T> classType) {
        T instance = (T) INSTANCE_CACHE.get(classType);
        if (instance == null) {
            try {
                instance = ServiceLoader.load(classType, classLoader).iterator().next();
                INSTANCE_CACHE.putIfAbsent(classType, instance);
                return (T) INSTANCE_CACHE.get(classType);
            } catch (Throwable e) {
                log.error("Cannot Load " + classType.getName());
                throw new RuntimeException("Cannot Load " + classType, e);
            }
        } else {
            if (classType.isAssignableFrom(instance.getClass())) {
                return instance;
            } else {
                throw new RuntimeException("instance not type " + classType);
            }
        }
    }

    /**
     * 根据服务接口Class获取服务提供者列表。
     * @param classType 服务接口Class
     * @return 服务提供者列表
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> getInstances(Class<T> classType) {
        List<T> list = (List<T>) INSTANCE_CACHE.get(classType);
        if (list == null) {
            try {
                list = new ArrayList<T>();
                for (T instance : ServiceLoader.load(classType, classLoader)) {
                    list.add(instance);
                }
                INSTANCE_CACHE.putIfAbsent(classType, list);
                return (List<T>) INSTANCE_CACHE.get(classType);
            } catch (RuntimeException e) {
                log.error("Cannot Load List By" + classType.getName());
                throw new RuntimeException("Cannot Load List By" + classType, e);
            }
        } else {
            if (List.class.isAssignableFrom(list.getClass())) {
                return list;
            } else {
                throw new RuntimeException("instance not List, type " + classType);
            }
        }
    }

    /**
     * 根据服务接口Class和服务提供者key获取服务提供者。
     * 此种服务提供者加载方式，在资源目录META-INF/services下放置的服务提供者配置文件的内容不是ServiceLoader
     * 规范中的每行一个“具体服务提供者类的完全限定名称”，
     * 而是每行一个“key=具体服务提供者类的完全限定名称”。
     * 此方式提供了根据配置选取服务提供者的便利。
     *
     * @param classType 服务接口Class
     * @param key 服务提供者key
     * @return 服务提供者
     */
    @SuppressWarnings("unchecked")
    public <T> T getInstance(Class<T> classType, String key) {
        ConcurrentHashMap<String, Object> objMap = MAP_INSTANCES_CACHE.get(classType);
        if (objMap == null) {
            objMap = new ConcurrentHashMap<String, Object>();
            MAP_INSTANCES_CACHE.putIfAbsent(classType, objMap);
        }
        objMap = MAP_INSTANCES_CACHE.get(classType);
        T obj = (T) objMap.get(key);
        if (obj != null) {
            return obj;
        }
        Map<String, Class<?>> classMap = MAP_CLASSES_CACHE.get(classType);
        if (classMap == null) {
            loadFile(classType);
        }
        classMap = MAP_CLASSES_CACHE.get(classType);
        if (classMap == null) {
            throw new IllegalStateException("Failed to load extension class(interface: " + classType + ", key: " + key
                    + ")");
        }
        Class<?> clazz = classMap.get(key);
        if (clazz != null) {
            try {
                Object newObj = clazz.newInstance();
                Object provious = objMap.putIfAbsent(key, newObj);
                return null == provious ? (T) newObj : (T) provious;
            } catch (Exception e) {
                throw new IllegalStateException("Failed to load extension class(interface: " + classType + ", key: "
                        + key + ")", e);
            }
        }
        throw new IllegalStateException("Failed to load extension class(interface: " + classType + ", key: " + key
                + ")");
    }

    private void loadFile(Class<?> type) {
        String fileName = PREFIX + type.getName();
        Map<String, Class<?>> map = new HashMap<String, Class<?>>();
        try {
            Enumeration<URL> urls;
            if (classLoader != null) {
                urls = classLoader.getResources(fileName);
            } else {
                urls = ClassLoader.getSystemResources(fileName);
            }
            if (urls != null) {
                while (urls.hasMoreElements()) {
                    URL url = urls.nextElement();
                    try {
                        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
                        try {
                            String line = null;
                            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) {
                                            Class<?> clazz = Class.forName(line, false, 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.");
                                            }
                                            map.put(name, clazz);
                                        }
                                    } catch (Throwable t) {
                                    }
                                }
                            } // end of while read lines
                        } finally {
                            reader.close();
                        }
                    } catch (Throwable t) {
                        log.error("", "Exception when load extension class(interface: " + type + ", class file: "
                                + url + ") in " + url, t);
                    }
                } // end of while urls
            }
        } catch (Throwable t) {
            log.error("", "Exception when load extension class(interface: " + type + ", description file: "
                    + fileName + ").", t);
        }
        MAP_CLASSES_CACHE.put(type, map);
    }
}