SpringBoot 插件化开发模式

尚未崩坏  金牌会员 | 2023-7-2 15:09:37 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 952|帖子 952|积分 2856

1、Java常用插件实现方案

1.2、serviceloader方式

serviceloader是java提供的spi模式的实现。按照接口开发实现类，而后配置，java通过ServiceLoader来实现统一接口不同实现的依次调用。而java中最经典的serviceloader的使用就是Java的spi机制。
1.2.1、java spi

SPI全称 Service Provider Interface ，是JDK内置的一种服务发现机制，SPI是一种动态替换扩展机制，比如有个接口，你想在运行时动态给他添加实现，你只需按照规范给他添加一个实现类即可。比如大家熟悉的jdbc中的Driver接口，不同的厂商可以提供不同的实现，有mysql的，也有oracle的，而Java的SPI机制就可以为某个接口寻找服务的实现。
下面用一张简图说明下SPI机制的原理

1.2.2、java spi 简单案例

如下工程目录，在某个应用工程中定义一个插件接口，而其他应用工程为了实现这个接口，只需要引入当前工程的jar包依赖进行实现即可，这里为了演示我就将不同的实现直接放在同一个工程下；

定义接口
  1. public interface MessagePlugin {
  3.     public String sendMsg(Map msgMap);
  5. }
复制代码
定义两个不同的实现
  1. public class AliyunMsg implements MessagePlugin {
  3.     @Override
  4.     public String sendMsg(Map msgMap) {
  5.         System.out.println("aliyun sendMsg");
  6.         return "aliyun sendMsg";
  7.     }
  8. }
复制代码
  1. public class TencentMsg implements MessagePlugin {
  3.     @Override
  4.     public String sendMsg(Map msgMap) {
  5.         System.out.println("tencent sendMsg");
  6.         return "tencent sendMsg";
  7.     }
  8. }
复制代码
在resources目录按照规范要求创建文件目录（META-INF/services），文件名为接口的全限定名,并填写实现类的全限定类名。

自定义服务加载类
  1. public static void main(String[] args) {
  2.         ServiceLoader<MessagePlugin> serviceLoader = ServiceLoader.load(MessagePlugin.class);
  3.         Iterator<MessagePlugin> iterator = serviceLoader.iterator();
  4.         Map map = new HashMap();
  5.         while (iterator.hasNext()){
  6.             MessagePlugin messagePlugin = iterator.next();
  7.             messagePlugin.sendMsg(map);
  8.         }
  9.     }
复制代码
运行上面的程序后，可以看到下面的效果，这就是说，使用ServiceLoader的方式可以加载到不同接口的实现，业务中只需要根据自身的需求，结合配置参数的方式就可以灵活的控制具体使用哪一个实现。

1.2、自定义配置约定方式

serviceloader其实是有缺陷的，在使用中必须在META-INF里定义接口名称的文件，在文件中才能写上实现类的类名，如果一个项目里插件化的东西比较多，那很可能会出现越来越多配置文件的情况。所以在结合实际项目使用时，可以考虑下面这种实现思路：

  • A应用定义接口；
  • B,C,D等其他应用定义服务实现；
  • B,C,D应用实现后达成SDK的jar；
  • A应用引用SDK或者将SDK放到某个可以读取到的目录下；
  • A应用读取并解析SDK中的实现类；
在上文中案例基础上，我们做如下调整；
1.2.1、添加配置文件

在配置文件中，将具体的实现类配置进去
  1. server:
  2.   port: 8888
  3. impl:
  4.   name: com.wq.plugins.spi.MessagePlugin
  5.   clazz:
  6.     - com.wq.plugins.impl.AliyunMsg
  7.     - com.wq.plugins.impl.TencentMsg
复制代码
1.2.2、自定义配置文件加载类

通过这个类，将上述配置文件中的实现类封装到类对象中，方便后续使用；
  1. package com.wq.propertie;
  3. import lombok.ToString;
  4. import org.springframework.boot.context.properties.ConfigurationProperties;
  6. import java.util.Arrays;
  8. /**
  9. * @Description TODO
  10. * @Version 1.0.0
  11. * @Date 2023/7/1
  12. * @Author wandaren
  13. */
  14. // 启动类需要添加@EnableConfigurationProperties({ClassImpl.class})
  15. @ConfigurationProperties("impl")
  16. public class ClassImpl {
  17.    private String name;
  18.    private String[] clazz;
  20.    public String getName() {
  21.       return name;
  22.    }
  24.    public void setName(String name) {
  25.       this.name = name;
  26.    }
  28.    public String[] getClazz() {
  29.       return clazz;
  30.    }
  32.    public void setClazz(String[] clazz) {
  33.       this.clazz = clazz;
  34.    }
  36.    public ClassImpl(String name, String[] clazz) {
  37.       this.name = name;
  38.       this.clazz = clazz;
  39.    }
  41.    public ClassImpl() {
  42.    }
  44.    @Override
  45.    public String toString() {
  46.       return "ClassImpl{" +
  47.               "name='" + name + '\'' +
  48.               ", clazz=" + Arrays.toString(clazz) +
  49.               '}';
  50.    }
  51. }
复制代码
1.2.3、自定义测试接口

使用上述的封装对象通过类加载的方式动态的在程序中引入
  1. package com.wq.contorller;
  3. import com.wq.plugins.spi.MessagePlugin;
  4. import com.wq.propertie.ClassImpl;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RestController;
  10. import java.util.HashMap;
  12. /**
  13. * @Description TODO
  14. * @Version 1.0.0
  15. * @Date 2023/7/1
  16. * @Author wandaren
  17. */
  18. @RestController
  19. public class HelloController {
  21.     @Autowired
  22.     private ClassImpl classImpl;
  24.     @GetMapping("/sendMsg")
  25.     public String sendMsg() throws Exception{
  26.         for (int i=0;i<classImpl.getClazz().length;i++) {
  27.             Class pluginClass= Class.forName(classImpl.getClazz()[i]);
  28.             MessagePlugin messagePlugin = (MessagePlugin) pluginClass.newInstance();
  29.             messagePlugin.sendMsg(new HashMap());
  30.         }
  31.         return "success";
  32.     }
  33. }
复制代码
1.3.3、添加测试接口
  1. package com.wq;
  3. import com.wq.propertie.ClassImpl;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  9. @EnableConfigurationProperties({ClassImpl.class})
  10. @SpringBootApplication
  11. public class DemoApplication {
  13.     public static void main(String[] args) {
  14.         SpringApplication.run(DemoApplication.class, args);
  15.     }
  17. }
复制代码
以上全部完成之后，启动工程，测试一下该接口，仍然可以得到预期结果；

在上述的实现中还比较粗糙的，实际运用时，还需要做较多的优化改进以满足实际的业务需要，比如接口传入类型参数用于控制具体使用哪个依赖包的方法进行执行等；
2、SpringBoot中的插件化实现

在大家使用较多的springboot框架中，其实框架自身提供了非常多的扩展点，其中最适合做插件扩展的莫过于spring.factories的实现；
2.1、 Spring Boot中的SPI机制

在Spring中也有一种类似与Java SPI的加载机制。它在META-INF/spring.factories文件中配置接口的实现类名称，然后在程序中读取这些配置文件并实例化，这种自定义的SPI机制是Spring Boot Starter实现的基础。
2.2、 Spring Factories实现原理

spring-core包里定义了SpringFactoriesLoader类，这个类实现了检索META-INF/spring.factories文件，并获取指定接口的配置的功能。在这个类中定义了两个对外的方法：

  • loadFactories 根据接口类获取其实现类的实例，这个方法返回的是对象列表；
  • loadFactoryNames 根据接口获取其接口类的名称，这个方法返回的是类名的列表；
上面的两个方法的关键都是从指定的ClassLoader中获取spring.factories文件，并解析得到类名列表，具体代码如下：
  1. public interface MessagePlugin {
  3.     public String sendMsg(Map msgMap);
  5. }
复制代码
从代码中我们可以知道，在这个方法中会遍历整个ClassLoader中所有jar包下的spring.factories文件，就是说我们可以在自己的jar中配置spring.factories文件，不会影响到其它地方的配置，也不会被别人的配置覆盖。
spring.factories的是通过Properties解析得到的，所以我们在写文件中的内容都是安装下面这种方式配置的：
  1.         <dependency>
  2.             <groupId>com.wq</groupId>
  3.             <artifactId>spi-00</artifactId>
  4.             <version>1</version>
  5.         </dependency>
复制代码
如果一个接口希望配置多个实现类，可以使用’,’进行分割
2.3、Spring Factories案例实现

接下来看一个具体的案例实现来体验下Spring Factories的使用；
2.3.1、定义一个服务接口

自定义一个接口，里面添加一个方法；
  1. public class AliyunMsg implements MessagePlugin {
  3.     @Override
  4.     public String sendMsg(Map msgMap) {
  5.         System.out.println("aliyun sendMsg");
  6.         return "aliyun sendMsg";
  7.     }
  8. }
复制代码
2.3.2、 定义2个服务实现

实现类1
  1. public class TencentMsg implements MessagePlugin {
  3.     @Override
  4.     public String sendMsg(Map msgMap) {
  5.         System.out.println("tencent sendMsg");
  6.         return "tencent sendMsg";
  7.     }
  8. }
复制代码
实现类2
  1. package com.wq.utils;
  3. import com.wq.propertie.ClassImpl;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Component;
  7. import java.io.File;
  8. import java.lang.reflect.Method;
  9. import java.net.URL;
  10. import java.net.URLClassLoader;
  11. import java.util.HashMap;
  12. import java.util.Map;
  13. import java.util.Objects;
  15. @Component
  16. public class ServiceLoaderUtils {
  18.     @Autowired
  19.     ClassImpl classImpl;
  22.     public static void loadJarsFromAppFolder() throws Exception {
  23.         String path = "/Users/wandaren/develop/study/spi-00/lib";
  24.         File f = new File(path);
  25.         if (f.isDirectory()) {
  26.             for (File subf : f.listFiles()) {
  27.                 if (subf.isFile()) {
  28.                     loadJarFile(subf);
  29.                 }
  30.             }
  31.         } else {
  32.             loadJarFile(f);
  33.         }
  34.     }
  36.     public static void loadJarFile(File path) throws Exception {
  37.         URL url = path.toURI().toURL();
  38.         // 可以获取到AppClassLoader，可以提到前面，不用每次都获取一次
  39.         URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
  40.         // 加载
  41.         //Method method = URLClassLoader.class.getDeclaredMethod("sendMsg", Map.class);
  42.         Method method = URLClassLoader.class.getMethod("sendMsg", Map.class);
  44.         method.setAccessible(true);
  45.         method.invoke(classLoader, url);
  46.     }
  48.     public  void main(String[] args) throws Exception{
  49.         System.out.println(invokeMethod("hello"));;
  50.     }
  52.     public String doExecuteMethod() throws Exception{
  53.         String path = "/Users/wandaren/develop/study/spi-00/lib";
  54.         File f1 = new File(path);
  55.         Object result = null;
  56.         if (f1.isDirectory()) {
  57.             for (File subf : f1.listFiles()) {
  58.                 //获取文件名称
  59.                 String name = subf.getName();
  60.                 String fullPath = path + "/" + name;
  61.                 //执行反射相关的方法
  62.                 File f = new File(fullPath);
  63.                 URL urlB = f.toURI().toURL();
  64.                 URLClassLoader classLoaderA = new URLClassLoader(new URL[]{urlB}, Thread.currentThread()
  65.                         .getContextClassLoader());
  66.                 String[] clazz = classImpl.getClazz();
  67.                 for(String claName : clazz){
  68.                     if(name.equals("spi-01-1.jar")){
  69.                         if(!claName.equals("com.wq.plugins.impl.AliyunMsg")){
  70.                             continue;
  71.                         }
  72.                         Class<?> loadClass = classLoaderA.loadClass(claName);
  73.                         if(Objects.isNull(loadClass)){
  74.                             continue;
  75.                         }
  76.                         //获取实例
  77.                         Object obj = loadClass.newInstance();
  78.                         Map map = new HashMap();
  79.                         //获取方法
  80.                         Method method=loadClass.getDeclaredMethod("sendMsg",Map.class);
  81.                         result = method.invoke(obj,map);
  82.                         if(Objects.nonNull(result)){
  83.                             break;
  84.                         }
  85.                     }else if(name.equals("spi-02-1.jar")){
  86.                         if(!claName.equals("com.wq.plugins.impl.TencentMsg")){
  87.                             continue;
  88.                         }
  89.                         Class<?> loadClass = classLoaderA.loadClass(claName);
  90.                         if(Objects.isNull(loadClass)){
  91.                             continue;
  92.                         }
  93.                         //获取实例
  94.                         Object obj = loadClass.newInstance();
  95.                         Map map = new HashMap();
  96.                         //获取方法
  97.                         Method method=loadClass.getDeclaredMethod("sendMsg",Map.class);
  98.                         result = method.invoke(obj,map);
  99.                         if(Objects.nonNull(result)){
  100.                             break;
  101.                         }
  102.                     }
  103.                 }
  104.                 if(Objects.nonNull(result)){
  105.                     break;
  106.                 }
  107.             }
  108.         }
  109.         return result.toString();
  110.     }
  112.     public Object loadMethod(String fullPath) throws Exception{
  113.         File f = new File(fullPath);
  114.         URL urlB = f.toURI().toURL();
  115.         URLClassLoader classLoaderA = new URLClassLoader(new URL[]{urlB}, Thread.currentThread()
  116.                 .getContextClassLoader());
  117.         Object result = null;
  118.         String[] clazz = classImpl.getClazz();
  119.         for(String claName : clazz){
  120.             Class<?> loadClass = classLoaderA.loadClass(claName);
  121.             if(Objects.isNull(loadClass)){
  122.                 continue;
  123.             }
  124.             //获取实例
  125.             Object obj = loadClass.newInstance();
  126.             Map map = new HashMap();
  127.             //获取方法
  128.             Method method=loadClass.getDeclaredMethod("sendMsg",Map.class);
  129.             result = method.invoke(obj,map);
  130.             if(Objects.nonNull(result)){
  131.                 break;
  132.             }
  133.         }
  134.         return result;
  135.     }
  138.     public static String invokeMethod(String text) throws Exception{
  139.         String path = "/Users/wandaren/develop/study/spi-00/lib/spi-01-1.jar";
  140.         File f = new File(path);
  141.         URL urlB = f.toURI().toURL();
  142.         URLClassLoader classLoaderA = new URLClassLoader(new URL[]{urlB}, Thread.currentThread()
  143.                 .getContextClassLoader());
  144.         Class<?> product = classLoaderA.loadClass("com.wq.plugins.impl.AliyunMsg");
  145.         //获取实例
  146.         Object obj = product.newInstance();
  147.         Map map = new HashMap();
  148.         //获取方法
  149.         Method method=product.getDeclaredMethod("sendMsg",Map.class);
  150.         //执行方法
  151.         Object result1 = method.invoke(obj,map);
  152.         // TODO According to the requirements , write the implementation code.
  153.         return result1.toString();
  154.     }
  156.     public static String getApplicationFolder() {
  157.         String path = ServiceLoaderUtils.class.getProtectionDomain().getCodeSource().getLocation().getPath();
  158.         return new File(path).getParent();
  159.     }
  163. }
复制代码
2.3.3、 添加spring.factories文件

在resources目录下，创建一个名叫：META-INF的目录，然后在该目录下定义一个spring.factories的配置文件，内容如下，其实就是配置了服务接口，以及两个实现类的全类名的路径；
  1.     @Autowired
  2.     private ServiceLoaderUtils serviceLoaderUtils;
  4.     @GetMapping("/sendMsgV2")
  5.     public String index() throws Exception {
  6.         String result = serviceLoaderUtils.doExecuteMethod();
  7.         return result;
  8.     }
复制代码
2.3.4、 添加自定义接口

添加一个自定义的接口，有没有发现，这里和java 的spi有点类似，只不过是这里换成了SpringFactoriesLoader去加载服务；
  1.         public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
  2.                 ClassLoader classLoaderToUse = classLoader;
  3.                 if (classLoaderToUse == null) {
  4.                         classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
  5.                 }
  6.                 String factoryTypeName = factoryType.getName();
  7.                 return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
  8.         }
  10.         private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
  11.                 Map<String, List<String>> result = cache.get(classLoader);
  12.                 if (result != null) {
  13.                         return result;
  14.                 }
  16.                 result = new HashMap<>();
  17.                 try {
  18.                         Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
  19.                         while (urls.hasMoreElements()) {
  20.                                 URL url = urls.nextElement();
  21.                                 UrlResource resource = new UrlResource(url);
  22.                                 Properties properties = PropertiesLoaderUtils.loadProperties(resource);
  23.                                 for (Map.Entry<?, ?> entry : properties.entrySet()) {
  24.                                         String factoryTypeName = ((String) entry.getKey()).trim();
  25.                                         String[] factoryImplementationNames =
  26.                                                         StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
  27.                                         for (String factoryImplementationName : factoryImplementationNames) {
  28.                                                 result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
  29.                                                                 .add(factoryImplementationName.trim());
  30.                                         }
  31.                                 }
  32.                         }
  34.                         // Replace all lists with unmodifiable lists containing unique elements
  35.                         result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
  36.                                         .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
  37.                         cache.put(classLoader, result);
  38.                 }
  39.                 catch (IOException ex) {
  40.                         throw new IllegalArgumentException("Unable to load factories from location [" +
  41.                                         FACTORIES_RESOURCE_LOCATION + "]", ex);
  42.                 }
  43.                 return result;
  44.         }
复制代码

启动工程之后，调用一下该接口进行测试，localhost:8080/sendMsgV3?msg=hello，通过控制台，可以看到，这种方式能够正确获取到系统中可用的服务实现；

利用spring的这种机制，可以很好的对系统中的某些业务逻辑通过插件化接口的方式进行扩展实现；
3、插件化机制案例实战

结合上面掌握的理论知识，下面基于Java SPI机制进行一个接近真实使用场景的完整的操作步骤；
3.1、 案例背景


  • 3个微服务模块，在A模块中有个插件化的接口；
  • 在A模块中的某个接口，需要调用插件化的服务实现进行短信发送；
  • 可以通过配置文件配置参数指定具体的哪一种方式发送短信；
  • 如果没有加载到任何插件，将走A模块在默认的发短信实现；
3.1.1、 模块结构

1、spi-00，插件化接口工程；
2、spi-01，aliyun短信发送实现；
3、spi-02，tncent短信发送实现；
3.1.2、 整体实现思路

本案例完整的实现思路参考如下：

  • spi-00定义服务接口，并提供出去jar被其他实现工程依赖；
  • spi-01与spi-02依赖spi-00的jar并实现SPI中的方法；
  • spi-01与spi-02按照API规范实现完成后，打成jar包，或者安装到仓库中；
  • spi-00在pom中依赖spi-01与的jar，spi-02或者通过启动加载的方式即可得到具体某个实现；
3.2、spi-00添加服务接口

3.2.1、 添加服务接口
  1. public interface MessagePlugin {
  3.     public String sendMsg(Map msgMap);
  5. }
复制代码
3.2.2、 打成jar包并安装到仓库

idea执行install

3.3、spi-01与spi-02实现

maven引入spi-00依赖坐标
  1. public interface SmsPlugin {
  3.     public void sendMessage(String message);
  5. }
复制代码
3.3.1、spi-01
  1. public class AliyunMsg implements MessagePlugin {
  3.     @Override
  4.     public String sendMsg(Map msgMap) {
  5.         System.out.println("aliyun sendMsg");
  6.         return "aliyun sendMsg";
  7.     }
  8. }
复制代码
3.3.2、spi-02
  1. public class TencentMsg implements MessagePlugin {
  3.     @Override
  4.     public String sendMsg(Map msgMap) {
  5.         System.out.println("tencent sendMsg");
  6.         return "tencent sendMsg";
  7.     }
  8. }
复制代码

3.3.3、将spi-01与spi-02打成jar

idea执行install
3.4、spi-00添加服务依赖与实现

3.4.1、添加服务依赖
  1. com.wq.plugin.SmsPlugin=\
  2. com.wq.plugin.impl.BizSmsImpl,\
  3. com.wq.plugin.impl.SystemSmsImpl
复制代码
3.4.2、自定义服务加载工具类
  1. package com.wq.controller;
  3. import com.wq.plugin.SmsPlugin;
  4. import org.springframework.core.io.support.SpringFactoriesLoader;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  8. import java.util.List;
  10. /**
  11. * @Description TODO
  12. * @Version 1.0.0
  13. * @Date 2023/7/2
  14. * @Author wandaren
  15. */
  16. @RestController
  17. public class SmsController {
  18.     @GetMapping("/sendMsgV3")
  19.     public String sendMsgV3(String msg) throws Exception{
  21.         List<SmsPlugin> smsServices= SpringFactoriesLoader.loadFactories(SmsPlugin.class, null);
  22.         for(SmsPlugin smsService : smsServices){
  23.             smsService.sendMessage(msg);
  24.         }
  25.         return "success";
  26.     }
  27. }
复制代码
3.4.3、接口实现
  1. public interface MessagePlugin {
  3.     public String sendMsg(Map msgMap);
  5. }
复制代码
  1. <dependencies>
  2.         <dependency>
  3.             <groupId>com.wq</groupId>
  4.             <artifactId>spi-00</artifactId>
  5.             <version>1</version>
  6.         </dependency>
  7.     </dependencies>
复制代码
3.4.4、测试controller
  1. public class AliyunMsg implements MessagePlugin {
  3.     @Override
  4.     public String sendMsg(Map msgMap) {
  5.         System.out.println("aliyun sendMsg");
  6.         return "aliyun sendMsg";
  7.     }
  8. }
复制代码
3.4.5、测试

通过修改配置application.yml中msg.type的值切换不同实现
  1. public class TencentMsg implements MessagePlugin {
  3.     @Override
  4.     public String sendMsg(Map msgMap) {
  5.         System.out.println("tencent sendMsg");
  6.         return "tencent sendMsg";
  7.     }
  8. }
复制代码


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

正序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

尚未崩坏

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表