Java如何实现简单SPI

2023-07-05 08:07:18 485人浏览薄情痞子

摘要

本文小编为大家详细介绍“Java如何实现简单SPI”，内容详细，步骤清晰，细节处理妥当，希望这篇“Java如何实现简单SPI”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。SPI标注注解标注提供SPI能力接口的注解

本文小编为大家详细介绍“Java如何实现简单SPI”，内容详细，步骤清晰，细节处理妥当，希望这篇“Java如何实现简单SPI”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

SPI标注注解

标注提供SPI能力接口的注解

@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface SPI {        String value() default "";}

标准SPI实现的注解@Join

@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Join {}

SPI核心实现

SPI的一些Class和扩展对象缓存

SPI实现是一个懒加载的过程，只有当通过get方法获取扩展的实例时才会加载扩展，并创建扩展实例，这里我们定义一个集合用于缓存扩展类，扩展对象等，代码如下：

@Slf4j@SuppressWarnings("all")public class ExtensionLoader<T> {        private static final String DEFAULT_DIRECTORY = "META-INF/log-helper/";        private final Class<T> tClass;        private static final Map<Class<?>, ExtensionLoader<?>> MAP = new ConcurrentHashMap<>();        private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();        private final Map<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<>();        private final Map<Class<?>, Object> joinInstances = new ConcurrentHashMap<>();        private String cacheDefaultName;    // 省略代码后面介绍}

获取扩展器ExtensionLoader

    public static<T> ExtensionLoader<T> getExtensionLoader(final Class<T> tClass) {        // 参数非空校验        if (null == tClass) {            throw new NullPointerException("tClass is null !");        }        // 参数应该是接口        if (!tClass.isInterface()) {            throw new IllegalArgumentException("tClass :" + tClass + " is not interface !");        }        // 参数要包含@SPI注解        if (!tClass.isAnnotationPresent(SPI.class)) {            throw new IllegalArgumentException("tClass " + tClass + "without @" + SPI.class + " Annotation !");        }        // 从缓存中获取扩展加载器，如果存在直接返回，如果不存在就创建一个扩展加载器并放到缓存中        ExtensionLoader<T> extensionLoader = (ExtensionLoader<T>) MAP.get(tClass);        if (null != extensionLoader) {            return extensionLoader;        }        MAP.putIfAbsent(tClass, new ExtensionLoader<>(tClass));        return (ExtensionLoader<T>) MAP.get(tClass);    }

扩展加载器构造方法

    public ExtensionLoader(final Class<T> tClass) {        this.tClass = tClass;    }

获取SPI扩展对象

获取SPI扩展对象是懒加载过程，第一次去获取的时候是没有的，会触发从问家中加载资源，通过反射创建对象，并缓存起来。

    public T getJoin(String cacheDefaultName) {        // 扩展名 文件中的key        if (StringUtils.isBlank(cacheDefaultName)) {            throw new IllegalArgumentException("join name is null");        }        // 扩展对象存储缓存        Holder<Object> objectHolder = cachedInstances.get(cacheDefaultName);        // 如果扩展对象的存储是空的，创建一个扩展对象存储并缓存        if (null == objectHolder) {            cachedInstances.putIfAbsent(cacheDefaultName, new Holder<>());            objectHolder = cachedInstances.get(cacheDefaultName);        }        // 从扩展对象的存储中获取扩展对象        Object value = objectHolder.getT();        // 如果对象是空的，就触发创建扩展，否则直接返回扩展对象        if (null == value) {            synchronized (cacheDefaultName) {                value = objectHolder.getT();                if (null == value) {                    // 创建扩展对象                    value = createExtension(cacheDefaultName);                    objectHolder.setT(value);                }            }        }        return (T) value;    }

创建扩展对象

反射方式创建扩展对象的实例

    private Object createExtension(String cacheDefaultName) {        // 根据扩展名字获取扩展的Class，从Holder中获取 key-value缓存，然后根据名字从Map中获取扩展实现Class        Class<?> aClass = getExtensionClasses().get(cacheDefaultName);        if (null == aClass) {            throw new IllegalArgumentException("extension class is null");        }        Object o = joinInstances.get(aClass);        if (null == o) {            try {                // 创建扩展对象并放到缓存中                joinInstances.putIfAbsent(aClass, aClass.newInstance());                o = joinInstances.get(aClass);            } catch (InstantiationException e) {                e.printStackTrace();            } catch (IllegalAccessException e) {                e.printStackTrace();            }        }        return o;    }

从Holder中获取获取扩展实现的Class集合

    public Map<String, Class<?>> getExtensionClasses() {        // 扩区SPI扩展实现的缓存，对应的就是扩展文件中的 key - value        Map<String, Class<?>> classes = cachedClasses.getT();        if (null == classes) {            synchronized (cachedClasses) {                classes = cachedClasses.getT();                if (null == classes) {                    // 加载扩展                    classes = loadExtensionClass();                    // 缓存扩展实现集合                    cachedClasses.setT(classes);                }            }        }        return classes;    }

加载扩展实现Class

加载扩展实现Class，就是从文件中获取扩展实现的Class，然后缓存起来

    public Map<String, Class<?>> loadExtensionClass() {        // 扩展接口tClass，必须包含SPI注解        SPI annotation = tClass.getAnnotation(SPI.class);        if (null != annotation) {            String v = annotation.value();            if (StringUtils.isNotBlank(v)) {                // 如果有默认的扩展实现名，用默认的                cacheDefaultName = v;            }        }        Map<String, Class<?>> classes = new HashMap<>(16);        // 从文件加载        loadDirectory(classes);        return classes;    }    private void loadDirectory(final Map<String, Class<?>> classes) {        // 文件名        String fileName = DEFAULT_DIRECTORY + tClass.getName();        try {            ClassLoader classLoader = ExtensionLoader.class.getClassLoader();            // 读取配置文件            Enumeration<URL> urls = classLoader != null ? classLoader.getResources(fileName)                    : ClassLoader.getSystemResources(fileName);            if (urls != null) {                // 获取所有的配置文件                while (urls.hasMoreElements()) {                    URL url = urls.nextElement();                    // 加载资源                    loadResources(classes, url);                }            }        } catch (IOException e) {            log.error("load directory error {}", fileName, e);        }    }    private void loadResources(Map<String, Class<?>> classes, URL url) {        // 读取文件到Properties，遍历Properties，得到配置文件key（名字）和value（扩展实现的Class）        try (InputStream inputStream = url.openStream()) {            Properties properties = new Properties();            properties.load(inputStream);            properties.forEach((k, v) -> {                // 扩展实现的名字                String name = (String) k;                // 扩展实现的Class的全路径                String classPath = (String) v;                if (StringUtils.isNotBlank(name) && StringUtils.isNotBlank(classPath)) {                    try {                        // 加载扩展实现Class，就是想其缓存起来，缓存到集合中                        loadClass(classes, name, classPath);                    } catch (ClassNotFoundException e) {                        log.error("load class not found", e);                    }                }            });        } catch (IOException e) {            log.error("load resouces error", e);        }    }    private void loadClass(Map<String, Class<?>> classes, String name, String classPath) throws ClassNotFoundException {        // 反射创建扩展实现的Class        Class<?> subClass = Class.forName(classPath);        // 扩展实现的Class要是扩展接口的实现类        if (!tClass.isAssignableFrom(subClass)) {            throw new IllegalArgumentException("load extension class error " + subClass + " not sub type of " + tClass);        }        // 扩展实现要有Join注解        Join annotation = subClass.getAnnotation(Join.class);        if (null == annotation) {            throw new IllegalArgumentException("load extension class error " + subClass + " without @Join" +                    "Annotation");        }        // 缓存扩展实现Class        Class<?> oldClass = classes.get(name);        if (oldClass == null) {            classes.put(name, subClass);        } else if (oldClass != subClass) {            log.error("load extension class error, Duplicate class oldClass is " + oldClass + "subClass is" + subClass);        }    }

存储Holder

    public static class Holder<T> {        private volatile T t;        public T getT() {            return t;        }        public void setT(T t) {            this.t = t;        }    }

测试SPI

定义SPI接口

@SPIpublic interface TestSPI {    void test();}

扩展实现1和2

@Joinpublic class TestSPI1Impl implements TestSPI {    @Override    public void test() {        System.out.println("test1");    }}@Joinpublic class TestSPI2Impl implements TestSPI {    @Override    public void test() {        System.out.println("test2");    }}

在resources文件夹下创建META-INF/log-helper文件夹，并创建扩展文件

文件名称（接口全路径名）：com.redick.spi.test.TestSPI

文件内容

testSPI1=com.redick.spi.test.TestSPI1Impl
testSPI2=com.redick.spi.test.TestSPI2Impl

动态使用测试

public class SpiExtensionFactoryTest {    @Test    public void getExtensionTest() {        TestSPI testSPI = ExtensionLoader.getExtensionLoader(TestSPI.class).getJoin("testSPI1");        testSPI.test();    }}

测试结果：
test1

public class SpiExtensionFactoryTest {    @Test    public void getExtensionTest() {        TestSPI testSPI = ExtensionLoader.getExtensionLoader(TestSPI.class).getJoin("testSPI2");        testSPI.test();    }}