java实践SPI机制及浅析源码

java实践SPI机制及浅析源码1.概念正式步入今天的核心内容之前,溪源先给大家介绍一下关于SPI机制的相关概念。SPI即ServiceProviderInterface,属于JDK内置的一种动态的服务提供发现机制,可以理解为运行时动态加载接口的实现类。更甚至,大家可以将SPI机制与设计模式中的策略模式建立联系。SPI机制:从上图中理解SPI机制:标准化接口+策略模式+配置文件;SPI机制核心思想:系统设计的各个抽象,往往有很多不同的实现方案,在面向的对象的设计里,一般推荐模块之间基于接口编程,模块之间不对实现类进行硬

1.概念

正式步入今天的核心内容之前,溪源先给大家介绍一下关于SPI机制的相关概念,最后会提供实践源代码。

SPI即Service Provider Interface,属于JDK内置的一种动态的服务提供发现机制,可以理解为运行时动态加载接口的实现类。更甚至,大家可以将SPI机制与设计模式中的策略模式建立联系。

  • SPI机制:
    在这里插入图片描述

从上图中理解SPI机制:标准化接口+策略模式+配置文件

SPI机制核心思想:系统设计的各个抽象,往往有很多不同的实现方案,在面向的对象的设计里,一般推荐模块之间基于接口编程,模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类,就违反了可拔插的原则,如果需要替换一种实现,就需要修改代码。为了实现在模块装配的时候能不在程序里动态指明,这就需要一种服务发现机制

  • 使用场景:

    1. 数据库驱动加载:面对不同厂商的数据库,JDBC需要加载不同类型的数据库驱动;
    2. 日志接口实现:SLF4J加载不同日志实现类;
    3. 溪源在实际开发中也使用了SPI机制:面对不同仪器平台的结果文件上传需要解析具体的结果,文件不同,解析逻辑不同,因此采用SPI机制能够解耦和降低维护成本;
  • SPI机制使用约定:

    从上面的图中,我们可以清晰的知道SPI的三部分:接口+实现类+配置文件;因此,项目中若要利用SPI机制,则需要遵循以下约定:

    1. 当服务提供者提供了接口的一种具体实现后,在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件,内容为实现类的全限定名
    2. 主程序通过java.util.ServiceLoder动态装载实现模块,它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名,把类加载到JVM;

2.实践

整体包结构如图:
在这里插入图片描述

  • 新建标准化接口:
public interface SayService { 
   
    void say(String word);
}
  • 建立两个实现类
@Service
public class ASayServiceImpl implements SayService { 
   
    @Override
    public void say(String word) { 
   
        System.out.println(word + " A say: I am a boy");
    }
}


@Service
public class BSayServiceImpl implements SayService { 
   
    @Override
    public void say(String word) { 
   
        System.out.println(word + " B say: I am a girl");
    }
}

  • 新建META-INF/services目录和配置文件(以接口全限定名)

配置文件内容为实现类全限定名

com.qxy.spi.impl.ASayServiceImpl
com.qxy.spi.impl.BSayServiceImpl
  • 单测
@SpringBootTest
@RunWith(SpringRunner.class)
public class SpiTest { 
   

    static ServiceLoader<SayService> services = ServiceLoader.load(SayService.class);

    @Test
    public void test1() { 
   
        for (SayService sayService : services) { 
   
            sayService.say("Hello");
        }
    }

}

  • 结果
Hello A say: I am a boy
Hello B say: I am a girl

3.源码

源码主要加载流程如下:

  • 应用程序调用ServiceLoader.load方法 ServiceLoader.load方法内先创建一个新的ServiceLoader,并实例化该类中的成员变量;
  1. loader(ClassLoader类型,类加载器)
  2. acc(AccessControlContext类型,访问控制器)
  3. providers(LinkedHashMap<String,S>类型,用于缓存加载成功的类)
  4. lookupIterator(实现迭代器功能)
  • 应用程序通过迭代器接口获取对象实例 ServiceLoader先判断成员变量providers对象中(LinkedHashMap<String,S>类型)是否有缓存实例对象,如果有缓存,直接返回。如果没有缓存,执行类的装载。
  1. 读取META-INF/services/下的配置文件,获得所有能被实例化的类的名称,值得注意的是,ServiceLoader可以跨越jar包获取META-INF下的配置文件;
  2. 通过反射方法Class.forName()加载类对象,并用instance()方法将类实例化。
  3. 把实例化后的类缓存到providers对象中,(LinkedHashMap<String,S>类型) 然后返回实例对象。
public final class ServiceLoader<S>
    implements Iterable<S>
{ 
   
    // 加载具体实现类信息的前缀
    private static final String PREFIX = "META-INF/services/";

    // 需要加载的接口
    // The class or interface representing the service being loaded
    private final Class<S> service;

    // 用于加载的类加载器
    // The class loader used to locate, load, and instantiate providers
    private final ClassLoader loader;

    // 创建ServiceLoader时采用的访问控制上下文
    // The access control context taken when the ServiceLoader is created
    private final AccessControlContext acc;

    // 用于缓存已经加载的接口实现类,其中key为实现类的完整类名
    // Cached providers, in instantiation order
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

    // 用于延迟加载接口的实现类
    // The current lazy-lookup iterator
    private LazyIterator lookupIterator;

    
    public void reload() { 
   
        providers.clear();
        lookupIterator = new LazyIterator(service, loader);
    }

    private ServiceLoader(Class<S> svc, ClassLoader cl) { 
   
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
        reload();
    }

    private static void fail(Class<?> service, String msg, Throwable cause)
        throws ServiceConfigurationError
    { 
   
        throw new ServiceConfigurationError(service.getName() + ": " + msg,
                                            cause);
    }

    private static void fail(Class<?> service, String msg)
        throws ServiceConfigurationError
    { 
   
        throw new ServiceConfigurationError(service.getName() + ": " + msg);
    }

    private static void fail(Class<?> service, URL u, int line, String msg)
        throws ServiceConfigurationError
    { 
   
        fail(service, u + ":" + line + ": " + msg);
    }

    // Parse a single line from the given configuration file, adding the name
    // on the line to the names list.
    //具体解析资源文件中的每一行内容
    private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
                          List<String> names)
        throws IOException, ServiceConfigurationError
    { 
   
        String ln = r.readLine();
        if (ln == null) { 
   
        	//-1表示解析完成
            return -1;
        }
        // 如果存在'#'字符,截取第一个'#'字符串之前的内容,'#'字符之后的属于注释内容
        int ci = ln.indexOf('#');
        if (ci >= 0) ln = ln.substring(0, ci);
        ln = ln.trim();
        int n = ln.length();
        if (n != 0) { 
   
        	//不合法的标识:' '、'\t'
            if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
                fail(service, u, lc, "Illegal configuration-file syntax");
            int cp = ln.codePointAt(0);
            //判断第一个 char 是否一个合法的 Java 起始标识符
            if (!Character.isJavaIdentifierStart(cp))
                fail(service, u, lc, "Illegal provider-class name: " + ln);
           	//判断所有其他字符串是否属于合法的Java标识符
            for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) { 
   
                cp = ln.codePointAt(i);
                if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
                    fail(service, u, lc, "Illegal provider-class name: " + ln);
            }
            //不存在则缓存
            if (!providers.containsKey(ln) && !names.contains(ln))
                names.add(ln);
        }
        return lc + 1;
    }

    
    private Iterator<String> parse(Class<?> service, URL u)
        throws ServiceConfigurationError
    { 
   
        InputStream in = null;
        BufferedReader r = null;
        ArrayList<String> names = new ArrayList<>();
        try { 
   
            in = u.openStream();
            r = new BufferedReader(new InputStreamReader(in, "utf-8"));
            int lc = 1;
            while ((lc = parseLine(service, u, r, lc, names)) >= 0);
        } catch (IOException x) { 
   
            fail(service, "Error reading configuration file", x);
        } finally { 
   
            try { 
   
                if (r != null) r.close();
                if (in != null) in.close();
            } catch (IOException y) { 
   
                fail(service, "Error closing configuration file", y);
            }
        }
        return names.iterator();
    }

    // Private inner class implementing fully-lazy provider lookup
    //
    private class LazyIterator
        implements Iterator<S>
    { 
   

        Class<S> service;
        ClassLoader loader;
        // 加载资源的URL集合
	    Enumeration<URL> configs = null; 
	    // 需加载的实现类的全限定类名的集合
	    Iterator<String> pending = null;
	    // 下一个需要加载的实现类的全限定类名
	    String nextName = null;

        private LazyIterator(Class<S> service, ClassLoader loader) { 
   
            this.service = service;
            this.loader = loader;
        }

        private boolean hasNextService() { 
   
            if (nextName != null) { 
   
                return true;
            }
            if (configs == null) { 
   
                try { 
   
                // 资源名称,META-INF/services + 全限定名
                    String fullName = PREFIX + service.getName();
                    if (loader == null)
                        configs = ClassLoader.getSystemResources(fullName);
                    else
                        configs = loader.getResources(fullName);
                } catch (IOException x) { 
   
                    fail(service, "Error locating configuration files", x);
                }
            }
            // 从资源中解析出需要加载的所有实现类的全限定名
            while ((pending == null) || !pending.hasNext()) { 
   
                if (!configs.hasMoreElements()) { 
   
                    return false;
                }
                pending = parse(service, configs.nextElement());
            }
            //下一个需要加载的实现类全限定名
            nextName = pending.next();
            return true;
        }

        private S nextService() { 
   
            if (!hasNextService())
                throw new NoSuchElementException();
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try { 
   
            //反射构造Class实例
                c = Class.forName(cn, false, loader);
            } catch (ClassNotFoundException x) { 
   
                fail(service,
                     "Provider " + cn + " not found");
            }
            // 类型判断,校验实现类必须与当前加载的类/接口的关系是派生或相同,否则抛出异常终止
            if (!service.isAssignableFrom(c)) { 
   
                fail(service,
                     "Provider " + cn  + " not a subtype");
            }
            try { 
   
            	//强转
                S p = service.cast(c.newInstance());
                 // 实例完成,添加缓存,Key:实现类全限定类名,Value:实现类实例
                providers.put(cn, p);
                return p;
            } catch (Throwable x) { 
   
                fail(service,
                     "Provider " + cn + " could not be instantiated",
                     x);
            }
            throw new Error();          // This cannot happen
        }

        public boolean hasNext() { 
   
            if (acc == null) { 
   
                return hasNextService();
            } else { 
   
                PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() { 
   
                    public Boolean run() { 
    return hasNextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

        public S next() { 
   
            if (acc == null) { 
   
                return nextService();
            } else { 
   
                PrivilegedAction<S> action = new PrivilegedAction<S>() { 
   
                    public S run() { 
    return nextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

        public void remove() { 
   
            throw new UnsupportedOperationException();
        }

    }

    
    public Iterator<S> iterator() { 
   
        return new Iterator<S>() { 
   

            Iterator<Map.Entry<String,S>> knownProviders
                = providers.entrySet().iterator();

            public boolean hasNext() { 
   
                if (knownProviders.hasNext())
                    return true;
                return lookupIterator.hasNext();
            }

            public S next() { 
   
                if (knownProviders.hasNext())
                    return knownProviders.next().getValue();
                return lookupIterator.next();
            }

            public void remove() { 
   
                throw new UnsupportedOperationException();
            }

        };
    }

    
    public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    { 
   
    // 返回ServiceLoader的实例
        return new ServiceLoader<>(service, loader);
    }

    
    public static <S> ServiceLoader<S> loadInstalled(Class<S> service) { 
   
    
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        ClassLoader prev = null;
        while (cl != null) { 
   
            prev = cl;
            cl = cl.getParent();
        }
        return ServiceLoader.load(service, prev);
    }

   
    public String toString() { 
   
        return "java.util.ServiceLoader[" + service.getName() + "]";
    }

}

4.总结

SPI机制在实际开发中使用得场景也有很多。特别是统一标准的不同厂商实现,溪源也正是利用SPI机制(但略做改进,避免过多加载资源浪费)实现不同技术平台的结果文件解析需求。

优点

使用Java SPI机制的优势是实现解耦,使得第三方服务模块的装配控制的逻辑与调用者的业务代码分离,而不是耦合在一起。应用程序可以根据实际业务情况启用框架扩展或替换框架组件。

缺点

虽然ServiceLoader也算是使用的延迟加载,但是基本只能通过遍历全部获取,也就是接口的实现类全部加载并实例化一遍。如果你并不想用某些实现类,它也被加载并实例化了,这就造成了浪费。

源码传送门SPI Service

今天的文章java实践SPI机制及浅析源码分享到此就结束了,感谢您的阅读。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/4807.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注