Dubbo(一)-SPI 机制之javaSPI基础
一 、java 的 SPI 机制
SPI 是什么
SPI 全称 Service Provider Interface,是 Java 提供的一套用来被第三方实现或者扩展的 API,它可以用来启用框架扩展和替换组件。是“接口的编程+策略模式+配置文件”组合实现的动态加载机制
流程架构图:
在 java 代码中,我们编写接口实现类,往往是事先确定的,在启动时候加载类具体的实现类,一旦我们需要变更选择某一实现类,我们就需要修改代码。为了实现这一个可以动态的选择实现的方式,就出现了 SPI 技术,简单说:SPI 其实就是一种服务发现机制。其核心思想就是结偶
SPI 的应用场景
- 日志模块之日志门面,可以选择不同的实现进行加载
- 数据库驱动加载接口实现类的加载 JDBC 加载不同类型数据库的驱动
- Dubbo 中的服务发现机制
SPI 的使用
SPI 的应用分 4 步:
- 创建接口类
- 编写接口实现类
- 编辑配置文件。
- 程序运行起来
全他妈废话
- 第一步创建接口类,我们这边先定义一个 SayWord 的接口,定义了一个 saySomething 的方法。可以说不同的话语。SayWord 接口代码
public interface SayWord {
String saySomething();
}
复制代码
- 第二步创建实现类,我这边定义类两个实现,一个是中文的,一个是英文的。 SayChineseWord 实现代码
public class SayChineseWord implements SayWord {
@Override
public String saySomething() {
return "你好啊";
}
}
复制代码
public class SayEnglishWord implements SayWord {
@Override
public String saySomething() {
return "Hello";
}
}
复制代码
- 第三步,编写配置文件, 配置文件是有严格的要求的,第一 :文件位置:META-INF/services 下面,而且目录必须是在 classPath 下面,不然就找不到了。原因后续会解释。 第二:文件名:必须和接口名称一致(包括包路径)。第三:文件内容:实现类的 名称(包括包路径 ) 文件路径
com.pangxie.server.dubbo.spi.impl.SayChineseWord
com.pangxie.server.dubbo.spi.impl.SayEnglishWord
复制代码
- 全部 ok 后就可以写程序跑起来了~~~ Main 代码
ServiceLoader<SayWord> sayWords=ServiceLoader.load(SayWord.class);
for(SayWord sayWord:sayWords){
System.out.println(sayWord.saySomething());
}
复制代码
原理解释
其实从代码编写中可以明白,核心类是ServiceLoader,这个是一个加载服务的一个类,那么具体是怎么实现的呢?来让我们look一下
成员组成: 大致分为5个成员遍量,分别为:service-接口class对象;loader-类加载器;acc-创建时候用来控制访问权限的上下文;providers-服务实现类列表;lookupIterator-懒加载的迭代器
// 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;
// The access control context taken when the ServiceLoader is created
private final AccessControlContext acc;
// Cached providers, in instantiation order
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
// The current lazy-lookup iterator
private LazyIterator lookupIterator;
复制代码
提供了唯一的一个静态方法(使用都是它~,或者直接构造吧~):
public static <S> ServiceLoader<S> load(Class<S> service) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return ServiceLoader.load(service, cl);
}
复制代码
为嘛路径要是META-INF/services下?在看源码就发现了路径配置:
private static final String PREFIX = "META-INF/services/";
复制代码
load调用发生了啥?其实没啥,就是构建了一个LazyIterator对象,然后就没有然后了。所以构建的时候并没有直接加载,只是存储了基本信息。
public void reload() {
providers.clear();
lookupIterator = new LazyIterator(service, loader);
}
复制代码
只有在调用迭代器的时候,判断是否有有配置调用hasNextService方法会获取实例信息,但是这一步没有加载。
if (configs == null) {
try {
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);
}
}
复制代码
在next方法中判断有实例信息后就利用Class.forName,并且实例化,后存储在链表里。
String cn = nextName;
nextName = null;
Class<?> c = null;
try {
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());
providers.put(cn, p);
return p;
} catch (Throwable x) {
fail(service,
"Provider " + cn + " could not be instantiated",
x);
}
复制代码
总结
- 优点:SPI还是很简单的,基于配置来改变实现类。避免了直接修改代码的情况,做到接口形式的解偶。就可以实现在不同情况下使用不同的框架来。
- 缺点: 多个并发多线程使用ServiceLoader类的实例是不安全的。 需要使用迭代器才会加载,感觉怪怪的。
来写一个ServiceLoader吧~
为了熟悉ServiceLoader的实现就随便自己写了一个,可以通过网络请求形式获取配置,简单的扩展下啦啦啦,再加个配置文件变更监听,就可以真的随心所欲了!!! 代码连接
public class NewServiceLoader<S> {
private static final String PREFIX = "META-INF/services/";
private String prefix = "META-INF/services/";
/**
* 接口的class
*/
private final Class<S> service;
/**
* 类加载器
*/
private final ClassLoader loader;
/**
* 权限上下文
*/
private final AccessControlContext acc;
/**
* 提供者列表
*/
private LinkedHashMap<String, S> providers = new LinkedHashMap<>();
private HashSet<String> providersName = new HashSet<>();
private NewServiceLoader(Class<S> svc, String prefix, ClassLoader cl) {
service = Objects.requireNonNull(svc, "Service interface cannot be null");
loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
this.prefix = prefix;
reload();
}
public static <S> NewServiceLoader<S> load(Class<S> sClass, String urlFix) {
return new NewServiceLoader<S>(sClass, urlFix, null);
}
public static <S> NewServiceLoader<S> load(Class<S> sClass) {
return new NewServiceLoader<S>(sClass, PREFIX, null);
}
public static <S> NewServiceLoader<S> load(Class<S> sClass, ClassLoader classLoader) {
return new NewServiceLoader<S>(sClass, PREFIX, classLoader);
}
public LinkedHashMap<String, S> getProviders() {
//如果两者长度不一致,说明没有加载全实例,需要加载实例
if (providers.size() != providersName.size()) {
instanceClass(providersName, providers, service);
}
return providers;
}
public void setProviders(LinkedHashMap<String, S> providers) {
this.providers = providers;
}
/**
* 重新加载
*/
private void reload() {
//清除一下,然后解析url文件
providers.clear();
providersName.clear();
parse();
}
/**
* 解析文件内容
*/
private void parse() {
//加载远程的或者当前的url
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new InputStreamReader(getUrlInfo()));
String line=null;
while ((line=bufferedReader.readLine())!=null) {
providersName.add(line);
}
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
/**
* 获取路径文件的资源
* @return
* @throws IOException
*/
private InputStream getUrlInfo() throws IOException {
//如果不是http开头的,那么是类文件路径啦~
if (!prefix.startsWith("http")) {
return getClass().getClassLoader().getResource(prefix + service.getName()).openStream();
}
// TODO 区分本地机器文件
URL url = new URL(prefix + service.getName());
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5 * 1000);
InputStream inStream = conn.getInputStream();
return inStream;
}
/**
* 实例化变量
*
* @param providersName
* @param providers
* @param sClass
*/
private void instanceClass(HashSet<String> providersName, LinkedHashMap<String, S> providers, Class<S> sClass) {
for (String className : providersName) {
Class c = null;
Object instance = null;
try {
c = Class.forName(className);
instance = c.newInstance();
} catch (Throwable e) {
throw new RuntimeException(e);
}
//转化类对象
S s = sClass.cast(instance);
providers.put(className, s);
}
}
}
复制代码
public static void main(String[] args) {
NewServiceLoader<SayWord> sayWords=NewServiceLoader.load(SayWord.class);
LinkedHashMap<String,SayWord> linkedHashMap=sayWords.getProviders();
for(SayWord sayWord:linkedHashMap.values()){
System.out.println(sayWord.saySomething());
}
}
复制代码