这个时候我们只能通过spi机制来自定义一套负载均衡策略进行实现了：
package com.sise.dubbo.config.loadBalanceSpi; import com.alibaba.dubbo.common.URL; import com.alibaba.dubbo.rpc.Invocation; import com.alibaba.dubbo.rpc.Invoker; import com.alibaba.dubbo.rpc.RpcException; import com.alibaba.dubbo.rpc.cluster.LoadBalance; import java.time.LocalTime; import java.util.List; import java.util.Random; /** * * @author idea * @data 2019/5/18 */ public class MyLoadBalance implements LoadBalance { private final String A_MACHINE_HOST_PORT = "192.168.43.191:20880"; private final String B_MACHINE_HOST_PORT = "192.168.43.191:20880"; @Override public <T> Invoker<T> select(List<Invoker<T>> list, URL url, Invocation invocation) throws RpcException { System.out.println("执行自定义的负载均衡算法"); //模拟场景 System.out.println(url); int currentHour = LocalTime.now().getHour(); if (currentHour >= 9 && currentHour <= 18) { System.out.println("请求A机器"); findInvokerInList(list, A_MACHINE_HOST_PORT); } else if (currentHour >= 18 && currentHour <= 23) { System.out.println("请求B机器"); findInvokerInList(list, B_MACHINE_HOST_PORT); } int randIndex = new Random().nextInt(list.size()); return list.get(randIndex); } /** * 从服务列表里面进行dubbo服务地址匹配 * * @param list * @param matchKey * @param <T> * @return */ private <T> Invoker findInvokerInList(List<Invoker<T>> list, String matchKey) { for (Invoker tInvoker : list) { String addr = tInvoker.getUrl().getHost() + tInvoker.getUrl().getPort(); if (matchKey.equals(addr)) { return tInvoker; } } return null; } }
然后在META-INF/dubbo文件夹底下配置一份纯文本的配置文件，文件命名为：
com.alibaba.dubbo.rpc.cluster.LoadBalance
（ps:不同版本的dubbo,LoadBalance的包名可能不同）
在这份文件里面写入这么一行内容（有点key，value的味道）
mylb=com.sise.dubbo.config.loadBalanceSpi.MyLoadBalance
在consumer端的配置文件中写入以下内容，这里的loadbalance需要和配置文件里的mylb一致。
<dubbo:reference interface="com.sise.dubbo.api.UserRpcService" id="userRpcService" loadbalance="mylb" />
然后我们可以启动多台provider，用consumer去调用这些服务进行测试，通过调整机器的时间点，控制台就会打印出不同的属性信息
请求B机器 执行自定义的负载均衡算法 zookeeper://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?anyhost=true&application=consumer&check=false&dubbo=2.5.3&interface=com.sise.dubbo.api.UserRpcService&loadbalance=mylb&methods=findByUsername,findAll,printStr&pid=12460&printStr.async=true&service.filter=MyFilter&side=consumer×tamp=1558143174084&weight=1600 请求A机器 执行自定义的负载均衡算法 zookeeper://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?anyhost=true&application=consumer&check=false&dubbo=2.5.3&interface=com.sise.dubbo.api.UserRpcService&loadbalance=mylb&methods=findByUsername,findAll,printStr&pid=12460&printStr.async=true&service.filter=MyFilter&side=consumer×tamp=1558143174084&weight=1600
通过上述的这种思路，我们借助dubbo的spi机制来加载满足自己特殊业务的负载均衡器，使得该框架的灵活性更高，扩展性更强。
自定义的dubbo过滤器
基于spi的扩展机制，dubbo里面还提供了对于filter类型的自定义拓展。开发者可以自定义一套filter来进行对于请求的功能拦截和校验，这个有点类似于springmvc里面的filter过滤器，通过特定的过滤器拦截数据之后，可以结合特殊的业务场景来做一些控制性的功能。
如何建立自己的filter过滤器？
首先我们需要在provider模块那定义一个filter类：
package com.sise.dubbo.config.filterSpi; import com.alibaba.dubbo.rpc.*; /** * @author idea * @date 2019/5/17 */ public class MyFilter implements Filter { @Override public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException { System.out.println("this is before"); Result result = invoker.invoke(invocation); System.out.println("this is after"); return result; } }
然后在META-INF/dubbo文件夹底下去创建相应的配置文件：（这个项目里面我还加入了其他的spi配置，不过对于过滤器配置没有影响）
配置里面需要加入下边的内容：
MyFilter=com.sise.dubbo.config.filterSpi.MyFilter
对于过滤器的xml配置只需要在相应的provider的xml中加入
<dubbo:provider filter="MyFilter"></dubbo:provider>
如果只是想对某个服务进行过滤操作的话，可以这么配置：
<!-- 需要暴露的服务接口 --> <dubbo:service interface="com.sise.dubbo.api.UserRpcService" ref="userRpcService" filter="MyFilter"/>
通常我们可以基于自定义的filter来实现一些服务调度的权限校验，调度次数统计等功能，但是注意在拦截请求的时候对于性能方面的把控，有时候也可以加入一些特殊ip的拦截校验功能，主要还是需要结合特殊的业务场景来实现。
dubbo本身的可扩展性极强，阿里巴巴团队在官方文档上边给出了十多种常用的spi扩展配置方式，这里主要只展示了两种常见的spi扩展，剩余的可以自行前往官网去查看文档讲解。
dubbo的spi加载原理
拿dubbo的spi来说，它在运行的时候会通过一个叫做ExtensionLoader的加载器来进行dubbo的扩展点加载。
我们可以进入ExtensionLoader这个类里面先进行初步的阅览：
这里面包含写明了dubbo在使用spi机制加载配置文件的基本目录，这里的internal目录我个人理解为dubbo内置服务的配置地址。
核心的加载逻辑图如下所示：
通过getExtension函数来加载类：
这里面有用到了加锁双重判断，主要是初始化加载之后，这些扩展类信息会被放入到一个ConcurrentMap<string, holder<="" object="" style="font-size: inherit; color: inherit; line-height: inherit;">> cachedInstances 里面。
进入createExtension函数里面，我们会看到以下内容：
这段代码的核心操作在于getExtensionClasses函数，再进入该函数中阅读源码：
会发现又是一次双重判断加锁的加载
这里面的loadExtensionClasses函数是加载扩展配置类信息的作用，进去之后进行源码阅读会发现：
loadFile函数对dubbo配置里面的 META-INF/services/，META-INF/dubbo/ ，META-INF/dubbo/internal/目录都进行了类的加载。这一点相比于jdk自带的spi加载所支持的目录要多。
再点进去loadFile源码里面，核心的类加载功能就会展示出来了：
private void loadFile(Map<String, Class<?>> extensionClasses, String dir) { String fileName = dir + type.getName(); try { Enumeration<java.net.URL> urls; ClassLoader classLoader = findClassLoader(); if (classLoader != null) { urls = classLoader.getResources(fileName); } else { urls = ClassLoader.getSystemResources(fileName); } if (urls != null) { while (urls.hasMoreElements()) { java.net.URL url = urls.nextElement(); try { BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8")); try { String line = null; while ((line = reader.readLine()) != null) { final int ci = line.indexOf('#'); if (ci >= 0) line = line.substring(0, ci); line = line.trim(); if (line.length() > 0) { try { String name = null; int i = line.indexOf('='); if (i > 0) { name = line.substring(0, i).trim(); line = line.substring(i + 1).trim(); } if (line.length() > 0) { Class<?> clazz = Class.forName(line, true, classLoader); if (! type.isAssignableFrom(clazz)) { throw new IllegalStateException("Error when load extension class(interface: " + type + ", class line: " + clazz.getName() + "), class " + clazz.getName() + "is not subtype of interface."); } if (clazz.isAnnotationPresent(Adaptive.class)) { if(cachedAdaptiveClass == null) { cachedAdaptiveClass = clazz; } else if (! cachedAdaptiveClass.equals(clazz)) { throw new IllegalStateException("More than 1 adaptive class found: " + cachedAdaptiveClass.getClass().getName() + ", " + clazz.getClass().getName()); } } else { try { clazz.getConstructor(type); Set<Class<?>> wrappers = cachedWrapperClasses; if (wrappers == null) { cachedWrapperClasses = new ConcurrentHashSet<Class<?>>(); wrappers = cachedWrapperClasses; } wrappers.add(clazz); } catch (NoSuchMethodException e) { clazz.getConstructor(); if (name == null || name.length() == 0) { name = findAnnotationName(clazz); if (name == null || name.length() == 0) { if (clazz.getSimpleName().length() > type.getSimpleName().length() && clazz.getSimpleName().endsWith(type.getSimpleName())) { name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase(); } else { throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url); } } } String[] names = NAME_SEPARATOR.split(name); if (names != null && names.length > 0) { Activate activate = clazz.getAnnotation(Activate.class); if (activate != null) { cachedActivates.put(names[0], activate); } for (String n : names) { if (! cachedNames.containsKey(clazz)) { cachedNames.put(clazz, n); } Class<?> c = extensionClasses.get(n); if (c == null) { extensionClasses.put(n, clazz); } else if (c != clazz) { throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName()); } } } } } } } catch (Throwable t) { IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t); exceptions.put(line, e); } } } // end of while read lines } finally { reader.close(); } } catch (Throwable t) { logger.error("Exception when load extension class(interface: " + type + ", class file: " + url + ") in " + url, t); } } // end of while urls } } catch (Throwable t) { logger.error("Exception when load extension class(interface: " + type + ", description file: " + fileName + ").", t); } }
这段代码由于比较冗长，因为dubbo在进行实际加载的过程中需要考虑很多的因素，主要目的就是实现加载指定目录底下的拓展类并且将其存入一个map中缓存起来。
这段代码我进行了稍微的改写之后，变成了一个比较简单的util类，简化学习和理解的难度
package com.sise.dubbo.spi.myspi; import com.sise.dubbo.spi.spidemo.UserService; import com.sise.dubbo.spi.spidemo.UserServiceImpl; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.URL; import java.util.Enumeration; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * @author idea * @date 2019/5/17 */ public class MySpiUtil { /** * 这里自定义了加载配置的文件夹 **/ private static final String SPI_DIR = "META-INF/idea/"; private Map<String, Class<?>> classMap = new ConcurrentHashMap<>(); /** * 加载目录底下的文件信息 * * @param clazz */ public void loadDirectory(Class clazz) { String fileName = SPI_DIR + clazz.getName(); ClassLoader classLoader = this.getClass().getClassLoader(); try { Enumeration<URL> resources = classLoader.getResources(fileName); if (resources != null) { while (resources.hasMoreElements()) { URL url = resources.nextElement(); loadResource(classLoader, url); } } } catch (IOException e) { e.printStackTrace(); } } public void loadResource(ClassLoader classLoader, URL url) { //读取配置文件里面的内容 try { BufferedReader reader = new BufferedReader( new InputStreamReader(url.openStream(), "utf-8")); String line; while ((line = reader.readLine()) != null) { int c = line.indexOf("#"); //该行内容没有注释 if (c <= 0) { line = line.trim(); if (line.length() > 0) { int splitIndex = line.indexOf("="); String name = line.substring(0, splitIndex).trim(); String className = line.substring(splitIndex + 1).trim(); classMap.put(name, Class.forName(className, true, classLoader)); } } } } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } public static void main(String[] args) throws IllegalAccessException, InstantiationException { MySpiUtil mySpiUtil = new MySpiUtil(); mySpiUtil.loadDirectory(UserService.class); UserServiceImpl userService = (UserServiceImpl) mySpiUtil.classMap.get("UserService").newInstance(); userService.say(); } }
相关的待加载服务代码：
然后根据代码里面的指定目录进行配置文件的放置：
配置文件也是按照dubbo的spi配置文件的格式来书写：
UserService=com.sise.dubbo.spi.spidemo.UserServiceImpl
运行程序之后，便可加载到相应的类并进行执行：
spi技术在java中应用场景比较广泛，通常在开发的时候为了实现接口自动寻找实现类的功能，可以通过spi来进行实现，将接口的实现类转移到一份配置文件中来进行控制。jdk自带的spi通常会一次性就将所有类进行实例化比较耗时，而dubbo在加载类的时候直接通过名称来定位具体的类，按实际需要加载，同时支持加载的路径也更加多，相比于传统jdk的spi加载要效率更高。
