Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

SPI significa Interfaz de proveedor de servicios, que puede entenderse como una interfaz proporcionada específicamente a proveedores de servicios o desarrolladores que amplían las funciones del marco. SPI separa la interfaz del servicio de la implementación del servicio específico, desacopla al llamante del servicio y al implementador del servicio y puede mejorar la escalabilidad y la mantenibilidad del programa. Modificar o reemplazar la implementación de un servicio no requiere modificar a la persona que llama. Muchos marcos utilizan el mecanismo SPI de Java, como: marco Spring, controlador de carga de bases de datos, interfaz de registro e implementación de extensiones Dubbo, etc. Consulte el mecanismo SPI de Dubbo para implementar la parte SPI de este marco RPC.

Por ejemplo, cuando el cliente se comunica con el servidor, necesita serializar el mensaje. Existen muchos algoritmos de serialización que se pueden utilizar durante la serialización, incluidos Hessian, Kryo y ProtoStuff. El requisito del sistema es llamar al método en la clase correspondiente al algoritmo de serialización relevante según el nombre del algoritmo de serialización en el mensaje para realizar la serialización y deserialización. Además, para facilitar la expansión, se debe utilizar SPI para el desacoplamiento. .

SPI se utiliza de la siguiente manera:

Serializer serializer = ExtensionLoader.getExtensionLoader(Serializer.class)
                    .getExtension(codecName);

codecName es el nombre del algoritmo de serialización y la clase correspondiente debe cargarse de acuerdo con este nombre.

    private final Class<?> type;
 
    private ExtensionLoader(Class<?> type) {
        this.type = type;
    }
 
    // 每个SPI接口都有自身的ExtensionLoader
    public static <S> ExtensionLoader<S> getExtensionLoader(Class<S> type) {
        if (type == null) {
            throw new IllegalArgumentException("Extension type should not be null.");
        }
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type must be an interface.");
        }
        if (type.getAnnotation(SPI.class) == null) {
            throw new IllegalArgumentException("Extension type must be annotated by @SPI");
        }
        // firstly get from cache, if not hit, create one
        ExtensionLoader<S> extensionLoader = (ExtensionLoader<S>) EXTENSION_LOADERS.get(type);
        if (extensionLoader == null) {
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<S>(type));
            extensionLoader = (ExtensionLoader<S>) EXTENSION_LOADERS.get(type);
        }
        return extensionLoader;
    }

Cada interfaz SPI tiene su propio ExtensionLoader. Al llamar a getExtensionLoader, primero realizará una serie de operaciones de verificación legal y luego intentará obtener el ExtensionLoader de la interfaz. Primero, intente obtenerlo del CHM de caché local. obtenido, cree un objeto Loader.

Después de eso, la instancia se obtiene a través de getExtension y la instancia también se almacena en caché localmente. Si no está en la caché, se crea la instancia nuevamente.

    private final Map<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<>();
 
    public T getExtension(String name) {
        if (StringUtil.isBlank(name)) {
            throw new IllegalArgumentException("Extension name should not be null or empty.");
        }
        // firstly get from cache, if not hit, create one
        // 缓存holder
        Holder<Object> holder = cachedInstances.get(name);
        if (holder == null) {
            cachedInstances.putIfAbsent(name, new Holder<>());
            holder = cachedInstances.get(name);
        }
        // create a singleton if no instance exists
        // holder为空，双重检查锁创建示例
        Object instance = holder.get();
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

Después de obtener el objeto Clase de la clase, puede crear este objeto mediante la reflexión.

   // 缓存   
   private static final Map<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<>();
 
   private T createExtension(String name) {
        // load all extension classes of type T from file and get specific one by name
        // SPI接口对应的实现类，其标识名与class文件的映射，根据标识名获取class
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw new RuntimeException("No such extension of name " + name);
        }
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        if (instance == null) {
            try {
                // 缓存中不存在，则创建实例
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            } catch (Exception e) {
                log.error(e.getMessage());
            }
        }
        return instance;
    }

La clave es el proceso de obtención del objeto Clase, es decir, el método getExtensionCalsses:

    // 该SPI接口所有实现类的标识与其Class对象的缓存
    private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>(); 
 
    private static final String SERVICE_DIRECTORY = "META-INF/extensions/";  
 
    private Map<String, Class<?>> getExtensionClasses() {
        // get the loaded extension class from the cache
        // 根据Interface实现类的类名获取对应类的缓存
        Map<String, Class<?>> classes = cachedClasses.get();
        // double check
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    classes = new HashMap<>();
                    // load all extensions from our extensions directory
                    loadDirectory(classes);
                    // 将Map集合存储在Holder中进行缓存
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }
 
    private void loadDirectory(Map<String, Class<?>> extensionClasses) {
        // 固定路径下的文件，SPI接口的类名作为文件名，在此文件中规定需要加载的实现类
        String fileName = ExtensionLoader.SERVICE_DIRECTORY + type.getName();
        try {
            Enumeration<URL> urls;
            // 系统类加载器，它能够加载用户类路径（ClassPath）上的类和资源。对于SPI机制尤为重要，因为SPI的实现类通常是由应用程序提供并放置在应用程序的类路径下的
            ClassLoader classLoader = ExtensionLoader.class.getClassLoader();
            // 获取当前类加载器加载的URL资源，文件名确定一般urls是唯一的
            urls = classLoader.getResources(fileName);
            if (urls != null) {
                while (urls.hasMoreElements()) {
                    URL resourceUrl = urls.nextElement();
                    // 使用classLoader加载资源，资源目标在resourceUrl下，加载后的class存储在extensionClasses Map集合当中
                    loadResource(extensionClasses, classLoader, resourceUrl);
                }
            }
        } catch (IOException e) {
            log.error(e.getMessage());
        }
    }
 
    private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, URL resourceUrl) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceUrl.openStream(), UTF_8))) {
            String line;
            // read every line
            // #是注释，截取注释之前的部分
            while ((line = reader.readLine()) != null) {
                // get index of comment
                final int ci = line.indexOf('#');
                if (ci >= 0) {
                    // string after # is comment so we ignore it
                    line = line.substring(0, ci);
                }
                line = line.trim();
                if (line.length() > 0) {
                    try {
                        final int ei = line.indexOf('=');
                        // 标识与类名
                        String name = line.substring(0, ei).trim();
                        String clazzName = line.substring(ei + 1).trim();
                        // our SPI use key-value pair so both of them must not be empty
                        if (name.length() > 0 && clazzName.length() > 0) {
                            // 加载类
                            Class<?> clazz = classLoader.loadClass(clazzName);
                            // 在map中保存
                            extensionClasses.put(name, clazz);
                        }
                    } catch (ClassNotFoundException e) {
                        log.error(e.getMessage());
                    }
                }
 
            }
        } catch (IOException e) {
            log.error(e.getMessage());
        }
    }

kyro=github.javaguide.serialize.kyro.KryoSerializer
protostuff=github.javaguide.serialize.protostuff.ProtostuffSerializer
hessian=github.javaguide.serialize.hessian.HessianSerializer

La llamada al método capa por capa realiza el proceso de cargar el archivo de configuración SPI correspondiente en la ruta META-INF/extensions/ para cargar el objeto Clase y obtener la instancia. Consulte los comentarios para conocer las partes importantes.

Cabe señalar que el nombre del archivo en META-INF/extensions/ debe ser coherente con el código. El nombre del archivo especificado en el código es el nombre completo de la clase de interfaz SPI. El contenido del archivo también debe escribirse de acuerdo con (identificador de clase de implementación = nombre de clase completo de la clase de implementación), para que pueda ser coherente con el código y el programa pueda analizar correctamente el archivo y usar el cargador de clases para cargar la Clase correspondiente. Finalmente, almacene en caché de acuerdo con <identificador de clase de implementación, clase de implementación objeto de clase>.

Debido a la existencia de tres cachés (identificador de clase, objeto de clase), (objeto de clase, instancia de objeto) y (identificador de clase, instancia de objeto), puede pasar directamente el identificador para obtener la instancia de la clase correspondiente, que También optimiza el rendimiento del marco RPC.