Java SPI详解

末蓝、 2022-10-10 13:57 142阅读 0赞

### Java SPI详解 ###

*  1. SPI概述
 *   *  1.1 什么是SPI
     *  1.2 适用场景
 *  2. SPI原理
 *  3.SPI案例
 *   *  3.1 项目需求
     *  3.2 项目结构
     *  3.3 项目地址

# 1. SPI概述 #

## 1.1 什么是SPI ##

SPI全称Service Provider Interface，是一种服务发现机制。为了被第三方实现或扩展的 API，它可以用于实现框架扩展或组件替换。

SPI 机制本质是将 接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载文件中的实现类，这样运行时可以动态的为接口替换实现类。

SPI本质上就是动态指定接口的实现类，比如FileStoreService有3个实现类，具体要使用哪一个实现类可以通过SPI动态的获取某一个实现类。

SPI实现了接口与实现类的解耦，提高了应用的可扩展性。

具体步骤就是，首先创建一个接口与多个实现类，然后再META-INF/services目录下创建接口的权限定名称文件，配置内容是接口实现类的权限定名称，这样就可以通过Service.load获取所有的实现类，根据配置获取指定实现类。

## 1.2 适用场景 ##

SPI 最合适的还是没有统一业务实现场景，就像通过sharding-jdbc的数据加密算法就是通过SPI方式扩展的，其中还有dubbo的SPI等等。

# 2. SPI原理 #

public final class ServiceLoader<S> implements Iterable<S> { 
        //扫描目录前缀
        private static final String PREFIX = "META-INF/services/";
        // 被加载的类或接口
        private final Class<S> service;
        // 用于定位、加载和实例化实现方实现的类的类加载器
        private final ClassLoader loader;
        // 上下文对象
        private final AccessControlContext acc;
        // 按照实例化的顺序缓存已经实例化的类
        private LinkedHashMap<String, S> providers = new LinkedHashMap<>();
        // 懒查找迭代器
        private java.util.ServiceLoader.LazyIterator lookupIterator;
    
        // 私有内部类，提供对所有的service的类的加载与实例化
        private class LazyIterator implements Iterator<S> { 
            Class<S> service;
            ClassLoader loader;
            Enumeration<URL> configs = null;
            String nextName = null;
            //...
            private boolean hasNextService() { 
                if (configs == null) { 
                    try { 
                        //获取目录下所有的类 转换为-URL，工作流的方式获取每一行的数据并截取第一个‘#’之前的数据，并去除前后的空格
                        String fullName = PREFIX + service.getName();
                        if (loader == null)
                            configs = ClassLoader.getSystemResources(fullName);
                        else
                            configs = loader.getResources(fullName);
                    } catch (IOException x) { 
                        //...
                    }
                    //....
                }
            }
    
            private S nextService() { 
                String cn = nextName;
                nextName = null;
                Class<?> c = null;
                try { 
                    //反射加载类 将上面获取的url进行转换为对象类
                    c = Class.forName(cn, false, loader);
                } catch (ClassNotFoundException x) { 
                }
                try { 
                    //实例化
                    S p = service.cast(c.newInstance());
                    //放进缓存
                    providers.put(cn, p);
                    return p;
                } catch (Throwable x) { 
                    //..
                }
                //..
            }
        }
    }

# 3.SPI案例 #

## 3.1 项目需求 ##

这里举的例子是存储服务，实现可以支持不同云服务的存储，当然需求可以有很多实现方式，策略设计模式亦可以，SPI也没问题，只是为了说明问题。  
为了提高可扩展性，支持不同云存储，采用SPI动态加载不同服务实现类。

## 3.2 项目结构 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70]

## 3.3 项目地址 ##

gitee地址：[https://gitee.com/rjzhu/spi/tree/master][https_gitee.com_rjzhu_spi_tree_master]

application.properties

file.store.type=OSS

路径：META-INF.services  
文件名：com.hello.spi.service.FileStoreService

com.hello.spi.service.impl.COSFileStoreServiceImpl
    com.hello.spi.service.impl.OBSFileStoreServiceImpl
    com.hello.spi.service.impl.OSSFileStoreServiceImpl

Constants

package com.hello.spi.common;
    
    /** * @author zrj * @since 2021/6/28 **/
    public class Constants { 
        /** * 阿里云OSS */
        public static final String OSS_FILE_STORE = "OSS";
    
        /** * 腾讯云COS */
        public static final String COS_FILE_STORE = "COS";
    
        /** * 华为云OBS */
        public static final String OBS_FILE_STORE = "OBS";
    
    }

FileStoreController

package com.hello.spi.controller;
    
    import com.hello.spi.factory.FileServiceFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.io.ByteArrayInputStream;
    import java.io.InputStream;
    
    /**
     * SPI测试控制器
     *
     * @author zrj
     * @since 2021/6/28
     **/
    @RestController
    @RequestMapping("/file")
    public class FileStoreController {
    
        @Autowired
        private FileServiceFactory fileServiceFactory;
    
        /**
         * SPI测试，文件下载
         */
        @GetMapping("download")
        public String fileDownload() {
            fileServiceFactory.download("");
    
            return "hello SPI download";
        }
    
        /**
         * SPI测试，文件上传
         */
        @GetMapping("upload")
        public String fileUpload() {
            InputStream inputStream = new ByteArrayInputStream("".getBytes());
            fileServiceFactory.upload(inputStream);
    
            return "hello SPI upload";
        }
    }

FileServiceFactory

package com.hello.spi.factory;
    
    import com.hello.spi.service.FileStoreService;
    import lombok.var;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import java.io.InputStream;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.ServiceLoader;
    
    /** * @author zrj * @since 2021/6/28 **/
    @Component
    public class FileServiceFactory implements InitializingBean { 
    
        @Value("${file.store.type:OSS}")
        private String fileStoreType;
    
        private FileStoreService fileStoreService;
    
        private Map<String, FileStoreService> fileStoreServiceMap = new HashMap<>();
    
        public Object upload(InputStream inputStream) { 
            return fileStoreService.upload(inputStream);
        }
    
        public Object download(String fileId) { 
            return fileStoreService.download(fileId);
        }
    
    
        @Override
        public void afterPropertiesSet() throws Exception { 
            var serviceLoader = ServiceLoader.load(FileStoreService.class);
            var fileStoreServiceIterator = serviceLoader.iterator();
            while (fileStoreServiceIterator.hasNext()) { 
                var customerFileStoreService = fileStoreServiceIterator.next();
                fileStoreServiceMap.put(customerFileStoreService.getType(), customerFileStoreService);
            }
    
            fileStoreService = fileStoreServiceMap.get(fileStoreType);
        }
    }

FileStoreService

package com.hello.spi.service;
    
    import java.io.InputStream;
    
    /** * 存储服务接口 * * @author zrj * @since 2021/6/28 **/
    public interface FileStoreService { 
    
        /** * 文件上传 * * @param inputStream 文件流 * @return Object 返回对象 */
        Object upload(InputStream inputStream);
    
    
        /** * 文件上传 * * @param fileId 文件ID * @return Object 返回对象 */
        Object download(String fileId);
    
        /** * 存储类型 */
        String getType();
    }

3个实现类都是空方法，只是为了验证SPI，就不在列举了，具体建gitee。

参考：[如何优雅使用 SPI 机制][SPI]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70]: /images/20221005/dade19e98ed943fc9d93753d3e4e7617.png
[https_gitee.com_rjzhu_spi_tree_master]: https://gitee.com/rjzhu/spi/tree/master
[SPI]: https://cloud.tencent.com/developer/article/1830990