欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

詳解Java實現(xiàn)簡單SPI流程

 更新時間:2023年03月02日 10:29:54   作者:Redick01  
這篇文章主要介紹了Java實現(xiàn)簡單SPI流程,SPI英文全稱為Service Provider Interface,顧名思義,服務提供者接口,它是jdk提供給“服務提供廠商”或者“插件開發(fā)者”使用的接口

參考dubboshenyu網(wǎng)關(guān)實現(xiàn)自定義的SPI

SPI標注注解

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

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

標準SPI實現(xiàn)的注解@Join

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

SPI核心實現(xiàn)

SPI的一些Class和擴展對象緩存

SPI實現(xiàn)是一個懶加載的過程,只有當通過get方法獲取擴展的實例時才會加載擴展,并創(chuàng)建擴展實例,這里我們定義一個集合用于緩存擴展類,擴展對象等,代碼如下:

@Slf4j
@SuppressWarnings("all")
public class ExtensionLoader<T> {
    /**
     * SPI配置擴展的文件位置
     * 擴展文件命名格式為 SPI接口的全路徑名,如:com.redick.spi.test.TestSPI
     */
    private static final String DEFAULT_DIRECTORY = "META-INF/log-helper/";
    /**
     * 擴展接口 {@link Class}
     */
    private final Class<T> tClass;
    /**
     * 擴展接口 和 擴展加載器 {@link ExtensionLoader} 的緩存
     */
    private static final Map<Class<?>, ExtensionLoader<?>> MAP = new ConcurrentHashMap<>();
    /**
     * 保存 "擴展" 實現(xiàn)的 {@link Class}
     */
    private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();
    /**
     * "擴展名" 對應的 保存擴展對象的Holder的緩存
     */
    private final Map<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<>();
    /**
     * 擴展class 和 擴展點的實現(xiàn)對象的緩存
     */
    private final Map<Class<?>, Object> joinInstances = new ConcurrentHashMap<>();
    /**
     * 擴展點默認的 "名稱" 緩存
     */
    private String cacheDefaultName;
    // 省略代碼后面介紹
}

獲取擴展器ExtensionLoader

    public static<T> ExtensionLoader<T> getExtensionLoader(final Class<T> tClass) {
        // 參數(shù)非空校驗
        if (null == tClass) {
            throw new NullPointerException("tClass is null !");
        }
        // 參數(shù)應該是接口
        if (!tClass.isInterface()) {
            throw new IllegalArgumentException("tClass :" + tClass + " is not interface !");
        }
        // 參數(shù)要包含@SPI注解
        if (!tClass.isAnnotationPresent(SPI.class)) {
            throw new IllegalArgumentException("tClass " + tClass + "without @" + SPI.class + " Annotation !");
        }
        // 從緩存中獲取擴展加載器,如果存在直接返回,如果不存在就創(chuàng)建一個擴展加載器并放到緩存中
        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);
    }

擴展加載器構(gòu)造方法

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

獲取SPI擴展對象

獲取SPI擴展對象是懶加載過程,第一次去獲取的時候是沒有的,會觸發(fā)從問家中加載資源,通過反射創(chuàng)建對象,并緩存起來。

    public T getJoin(String cacheDefaultName) {
        // 擴展名 文件中的key
        if (StringUtils.isBlank(cacheDefaultName)) {
            throw new IllegalArgumentException("join name is null");
        }
        // 擴展對象存儲緩存
        Holder<Object> objectHolder = cachedInstances.get(cacheDefaultName);
        // 如果擴展對象的存儲是空的,創(chuàng)建一個擴展對象存儲并緩存
        if (null == objectHolder) {
            cachedInstances.putIfAbsent(cacheDefaultName, new Holder<>());
            objectHolder = cachedInstances.get(cacheDefaultName);
        }
        // 從擴展對象的存儲中獲取擴展對象
        Object value = objectHolder.getT();
        // 如果對象是空的,就觸發(fā)創(chuàng)建擴展,否則直接返回擴展對象
        if (null == value) {
            synchronized (cacheDefaultName) {
                value = objectHolder.getT();
                if (null == value) {
                    // 創(chuàng)建擴展對象
                    value = createExtension(cacheDefaultName);
                    objectHolder.setT(value);
                }
            }
        }
        return (T) value;
    }

創(chuàng)建擴展對象

反射方式創(chuàng)建擴展對象的實例

    private Object createExtension(String cacheDefaultName) {
        // 根據(jù)擴展名字獲取擴展的Class,從Holder中獲取 key-value緩存,然后根據(jù)名字從Map中獲取擴展實現(xiàn)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 {
                // 創(chuàng)建擴展對象并放到緩存中
                joinInstances.putIfAbsent(aClass, aClass.newInstance());
                o = joinInstances.get(aClass);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return o;
    }

從Holder中獲取獲取擴展實現(xiàn)的Class集合

    public Map<String, Class<?>> getExtensionClasses() {
        // 擴區(qū)SPI擴展實現(xiàn)的緩存,對應的就是擴展文件中的 key - value
        Map<String, Class<?>> classes = cachedClasses.getT();
        if (null == classes) {
            synchronized (cachedClasses) {
                classes = cachedClasses.getT();
                if (null == classes) {
                    // 加載擴展
                    classes = loadExtensionClass();
                    // 緩存擴展實現(xiàn)集合
                    cachedClasses.setT(classes);
                }
            }
        }
        return classes;
    }

加載擴展實現(xiàn)Class

加載擴展實現(xiàn)Class,就是從文件中獲取擴展實現(xiàn)的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)) {
                // 如果有默認的擴展實現(xiàn)名,用默認的
                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(擴展實現(xiàn)的Class)
        try (InputStream inputStream = url.openStream()) {
            Properties properties = new Properties();
            properties.load(inputStream);
            properties.forEach((k, v) -> {
                // 擴展實現(xiàn)的名字
                String name = (String) k;
                // 擴展實現(xiàn)的Class的全路徑
                String classPath = (String) v;
                if (StringUtils.isNotBlank(name) && StringUtils.isNotBlank(classPath)) {
                    try {
                        // 加載擴展實現(xiàn)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 {
        // 反射創(chuàng)建擴展實現(xiàn)的Class
        Class<?> subClass = Class.forName(classPath);
        // 擴展實現(xiàn)的Class要是擴展接口的實現(xiàn)類
        if (!tClass.isAssignableFrom(subClass)) {
            throw new IllegalArgumentException("load extension class error " + subClass + " not sub type of " + tClass);
        }
        // 擴展實現(xiàn)要有Join注解
        Join annotation = subClass.getAnnotation(Join.class);
        if (null == annotation) {
            throw new IllegalArgumentException("load extension class error " + subClass + " without @Join" +
                    "Annotation");
        }
        // 緩存擴展實現(xiàn)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接口

@SPI
public interface TestSPI {
    void test();
}

擴展實現(xiàn)1和2

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

在resources文件夾下創(chuàng)建META-INF/log-helper文件夾,并創(chuàng)建擴展文件

文件名稱(接口全路徑名):com.redick.spi.test.TestSPI

文件內(nèi)容

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

動態(tài)使用測試

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

測試結(jié)果:

test1

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

測試結(jié)果:

test2

總結(jié)

實現(xiàn)一個自定義的SPI機制其核心的邏輯就是擴展的加載,本篇是參考Dubbo等開源項目簡單實現(xiàn)了一個SPI機制的核心代碼,核心邏輯就是從SPI擴展的配置文件中加載擴展實現(xiàn)的流程,通常情況下,SPI的應用場景出現(xiàn)在高度可擴展組件,并且在使用過程中有需求能夠靈活切換不同的實現(xiàn)的時候。比如程序使用限流組件,使用“令牌桶算法”和“漏桶算法”分別實現(xiàn)了限流邏輯,在業(yè)務使用限流算法的過程中,就可以通過SPI機制在程序啟動過程中將兩種算法實現(xiàn)的組件加載好,然后通過參數(shù)指定具體使用的限流算法。此外,SPI機制能夠?qū)U展開放,常用于開源軟件,用戶可以實現(xiàn)自己的擴展。

到此這篇關(guān)于詳解Java實現(xiàn)簡單SPI流程的文章就介紹到這了,更多相關(guān)Java實現(xiàn)SPI內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

相關(guān)文章

  • SpringBoot中的ImportSelector類動態(tài)加載bean詳解

    SpringBoot中的ImportSelector類動態(tài)加載bean詳解

    這篇文章主要介紹了SpringBoot中的ImportSelector類動態(tài)加載bean詳解,ImportSelector接口是spring中導入外部配置的核心接口,根據(jù)給定的條件(通常是一個或多個注釋屬性)判定要導入那個配置類,在spring自動化配置和@EnableXXX中都有它的存在,需要的朋友可以參考下
    2024-01-01
  • maven引入kabeja依賴的實現(xiàn)步驟

    maven引入kabeja依賴的實現(xiàn)步驟

    本文主要介紹了maven引入kabeja依賴的實現(xiàn)步驟,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2023-09-09
  • 基于Java回顧之多線程同步的使用詳解

    基于Java回顧之多線程同步的使用詳解

    在這篇文章里,我們關(guān)注線程同步的話題。這是比多線程更復雜,稍不留意,我們就會“掉到坑里”,而且和單線程程序不同,多線程的錯誤是否每次都出現(xiàn),也是不固定的,這給調(diào)試也帶來了很大的挑戰(zhàn)
    2013-05-05
  • Springboot @WebFilter無法注入其他Bean的示例問題

    Springboot @WebFilter無法注入其他Bean的示例問題

    這篇文章主要介紹了Springboot @WebFilter無法注入其他Bean的示例問題,本文通過示例代碼給大家分享解決方法,需要的朋友可以參考下
    2021-09-09
  • Mybatis中傳遞多個參數(shù)的4種方法總結(jié)

    Mybatis中傳遞多個參數(shù)的4種方法總結(jié)

    這篇文章主要給大家介紹了關(guān)于Mybatis中傳遞多個參數(shù)的4種方法,并且介紹了關(guān)于使用Mapper接口時參數(shù)傳遞方式,文中通過示例代碼介紹的非常詳細,需要的朋友可以參考借鑒,下面隨著小編來一起學習學習吧。
    2018-04-04
  • 使用springmvc的controller層獲取到請求的數(shù)據(jù)方式

    使用springmvc的controller層獲取到請求的數(shù)據(jù)方式

    這篇文章主要介紹了使用springmvc的controller層獲取到請求的數(shù)據(jù)方式,具有很好的參考價值,希望對大家有所幫助。如有錯誤或未考慮完全的地方,望不吝賜教
    2021-08-08
  • 詳解SpringBoot集成消息隊列的案例應用

    詳解SpringBoot集成消息隊列的案例應用

    Message?Queue又名消息隊列,是一種異步通訊的中間件。可以理解為郵局,發(fā)送者將消息投遞到郵局,然后郵局幫我們發(fā)送給具體的接收者,具體發(fā)送過程和時間與我們無關(guān)。?消息隊列是分布式系統(tǒng)中重要的組件,消息隊列主要解決了應用耦合、異步處理、流量削鋒等問題
    2022-04-04
  • Java中的Timer和TimerTask詳細解讀

    Java中的Timer和TimerTask詳細解讀

    這篇文章主要介紹了Java中的Timer和TimerTask詳細解讀,??Timer和TimerTask可以做為實現(xiàn)線程的第三種方式,前兩中方式分別是繼承自Thread類和實現(xiàn)Runnable接口,需要的朋友可以參考下
    2023-10-10
  • Scheduled如何會在上次任務執(zhí)行完才會執(zhí)行下次任務

    Scheduled如何會在上次任務執(zhí)行完才會執(zhí)行下次任務

    這篇文章主要介紹了Scheduled如何會在上次任務執(zhí)行完才會執(zhí)行下次任務問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
    2024-08-08
  • Spring注解實現(xiàn)自動裝配過程解析

    Spring注解實現(xiàn)自動裝配過程解析

    這篇文章主要介紹了Spring注解實現(xiàn)自動裝配過程解析,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
    2020-03-03

最新評論