天天看點
傳回

SpringBoot 插件化開發模式，強烈推薦！

作者：老誠不bug

一、前言

插件化開發模式正在很多程式設計語言或技術架構中得以廣泛的應用實踐，比如大家熟悉的jenkins，docker可視化管理平台rancher，以及日常編碼使用的編輯器idea，vscode等，随處可見的帶有熱插拔功能的插件，讓系統像插了翅膀一樣，大大提升了系統的擴充性和伸縮性，也拓展了系統整體的使用價值，那麼為什麼要使用插件呢？

1.1 使用插件的好處

1.1.1 子產品解耦

實作服務子產品之間解耦的方式有很多，但是插件來說，其解耦的程度似乎更高，而且更靈活，可定制化、個性化更好。

舉例來說，代碼中可以使用設計模式來選擇使用哪種方式發送短信給下單完成的客戶，問題是各個短信服務商并不一定能保證在任何情況下都能發送成功，怎麼辦呢？這時候設計模式也沒法幫你解決這個問題，如果使用定制化插件的方式，結合外部配置參數，假設系統中某種短信發送不出去了，這時候就可以利用插件動态植入，切換為不同的廠商發短信了。

1.1.2 提升擴充性和開放性

以spring來說，之是以具備如此廣泛的生态，與其自身内置的各種可擴充的插件機制是分不開的，試想為什麼使用了spring架構之後可以很友善的對接其他中間件，那就是spring架構提供了很多基于插件化的擴充點。

插件化機制讓系統的擴充性得以提升，進而可以豐富系統的周邊應用生态。

1.1.3 友善第三方接入

有了插件之後，第三方應用或系統如果要對接自身的系統，直接基于系統預留的插件接口完成一套适合自己業務的實作即可，而且對自身系統的侵入性很小，甚至可以實作基于配置參數的熱加載，友善靈活，開箱即用。

1.2 插件化常用實作思路

以java為例，這裡結合實際經驗，整理一些常用的插件化實作思路：

  • spi機制；
  • 約定配置和目錄，利用反射配合實作；
  • springboot中的Factories機制；
  • java agent（探針）技術；
  • spring内置擴充點；
  • 第三方插件包，例如：spring-plugin-core；
  • spring aop技術；

二、Java常用插件實作方案

2.1 serviceloader方式

serviceloader是java提供的spi模式的實作。按照接口開發實作類，而後配置，java通過ServiceLoader來實作統一接口不同實作的依次調用。而java中最經典的serviceloader的使用就是Java的spi機制。

2.1.1 java spi

SPI全稱 Service Provider Interface ，是JDK内置的一種服務發現機制，SPI是一種動态替換擴充機制，比如有個接口，你想在運作時動态給他添加實作，你隻需按照規範給他添加一個實作類即可。比如大家熟悉的jdbc中的Driver接口，不同的廠商可以提供不同的實作，有mysql的，也有oracle的，而Java的SPI機制就可以為某個接口尋找服務的實作。

下面用一張簡圖說明下SPI機制的原理

SpringBoot 插件化開發模式，強烈推薦！

2.1.2 java spi 簡單案例

如下工程目錄，在某個應用工程中定義一個插件接口，而其他應用工程為了實作這個接口，隻需要引入目前工程的jar包依賴進行實作即可，這裡為了示範我就将不同的實作直接放在同一個工程下；

SpringBoot 插件化開發模式，強烈推薦！

定義接口

public interface MessagePlugin {
 
    public String sendMsg(Map msgMap);
 
}

定義兩個不同的實作

public class AliyunMsg implements MessagePlugin {
 
    @Override
    public String sendMsg(Map msgMap) {
        System.out.println("aliyun sendMsg");
        return "aliyun sendMsg";
    }
}
           
public class TencentMsg implements MessagePlugin {
 
    @Override
    public String sendMsg(Map msgMap) {
        System.out.println("tencent sendMsg");
        return "tencent sendMsg";
    }
}

在resources目錄按照規範要求建立檔案目錄，并填寫實作類的全類名

SpringBoot 插件化開發模式，強烈推薦！

自定義服務加載類

public static void main(String[] args) {
        ServiceLoader<MessagePlugin> serviceLoader = ServiceLoader.load(MessagePlugin.class);
        Iterator<MessagePlugin> iterator = serviceLoader.iterator();
        Map map = new HashMap();
        while (iterator.hasNext()){
            MessagePlugin messagePlugin = iterator.next();
            messagePlugin.sendMsg(map);
        }
    }

運作上面的程式後，可以看到下面的效果，這就是說，使用ServiceLoader的方式可以加載到不同接口的實作，業務中隻需要根據自身的需求，結合配置參數的方式就可以靈活的控制具體使用哪一個實作。

SpringBoot 插件化開發模式，強烈推薦！

2.2 自定義配置約定方式

serviceloader其實是有缺陷的，在使用中必須在META-INF裡定義接口名稱的檔案，在檔案中才能寫上實作類的類名，如果一個項目裡插件化的東西比較多，那很可能會出現越來越多配置檔案的情況。是以在結合實際項目使用時，可以考慮下面這種實作思路：

  • A應用定義接口；
  • B,C,D等其他應用定義服務實作；
  • B,C,D應用實作後達成SDK的jar；
  • A應用引用SDK或者将SDK放到某個可以讀取到的目錄下；
  • A應用讀取并解析SDK中的實作類；

在上文中案例基礎上，我們做如下調整；

2.2.1 添加配置檔案

在配置檔案中，将具體的實作類配置進去

server :
  port : 8081
impl:
  name : com.congge.plugins.spi.MessagePlugin
  clazz :
    - com.congge.plugins.impl.TencentMsg
    - com.congge.plugins.impl.AliyunMsg

2.2.2 自定義配置檔案加載類

通過這個類，将上述配置檔案中的實作類封裝到類對象中，友善後續使用；

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("impl")
@ToString
public class ClassImpl {
    @Getter
    @Setter
    String name;
 
    @Getter
    @Setter
    String[] clazz;
}

2.2.3 自定義測試接口

使用上述的封裝對象通過類加載的方式動态的在程式中引入

import com.congge.config.ClassImpl;
import com.congge.plugins.spi.MessagePlugin;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.HashMap;
 
@RestController
public class SendMsgController {
 
    @Autowired
    ClassImpl classImpl;
 
    //localhost:8081/sendMsg
    @GetMapping("/sendMsg")
    public String sendMsg() throws Exception{
        for (int i=0;i<classImpl.getClazz().length;i++) {
            Class pluginClass= Class.forName(classImpl.getClazz()[i]);
            MessagePlugin messagePlugin = (MessagePlugin) pluginClass.newInstance();
            messagePlugin.sendMsg(new HashMap());
        }
        return "success";
    }
 
}

2.2.4 啟動類 

@EnableConfigurationProperties({ClassImpl.class})
@SpringBootApplication
public class PluginApp {
 
    public static void main(String[] args) {
        SpringApplication.run(PluginApp.class,args);
    }
 
}

啟動工程代碼後，調用接口：localhost:8081/sendMsg，在控制台中可以看到下面的輸出資訊，即通過這種方式也可以實作類似serviceloader的方式，不過在實際使用時，可以結合配置參數進行靈活的控制；

SpringBoot 插件化開發模式，強烈推薦！

2.3 自定義配置讀取依賴jar的方式

更進一步，在很多場景下，可能我們并不想直接在工程中引入接口實作的依賴包，這時候可以考慮通過讀取指定目錄下的依賴jar的方式，利用反射的方式進行動态加載，這也是生産中一種比較常用的實踐經驗。

具體實踐來說，主要為下面的步驟：

  • 應用A定義服務接口；
  • 應用B,C,D等實作接口（或者在應用内部實作相同的接口）；
  • 應用B,C,D打成jar，放到應用A約定的讀取目錄下；
  • 應用A加載約定目錄下的jar，通過反射加載目标方法；

在上述的基礎上，按照上面的實作思路來實作一下；

2.3.1 建立約定目錄

在目前工程下建立一個lib目錄，并将依賴的jar放進去

SpringBoot 插件化開發模式，強烈推薦！

2.3.2 新增讀取jar的工具類

添加一個工具類，用于讀取指定目錄下的jar，并通過反射的方式，結合配置檔案中的約定配置進行反射方法的執行；

@Component
public class ServiceLoaderUtils {
 
    @Autowired
    ClassImpl classImpl;
 
 
    public static void loadJarsFromAppFolder() throws Exception {
        String path = "E:\\code-self\\bitzpp\\lib";
        File f = new File(path);
        if (f.isDirectory()) {
            for (File subf : f.listFiles()) {
                if (subf.isFile()) {
                    loadJarFile(subf);
                }
            }
        } else {
            loadJarFile(f);
        }
    }
 
    public static void loadJarFile(File path) throws Exception {
        URL url = path.toURI().toURL();
        // 可以擷取到AppClassLoader，可以提到前面，不用每次都擷取一次
        URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
        // 加載
        //Method method = URLClassLoader.class.getDeclaredMethod("sendMsg", Map.class);
        Method method = URLClassLoader.class.getMethod("sendMsg", Map.class);
 
        method.setAccessible(true);
        method.invoke(classLoader, url);
    }
 
    public  void main(String[] args) throws Exception{
        System.out.println(invokeMethod("hello"));;
    }
 
    public String doExecuteMethod() throws Exception{
        String path = "E:\\code-self\\bitzpp\\lib";
        File f1 = new File(path);
        Object result = null;
        if (f1.isDirectory()) {
            for (File subf : f1.listFiles()) {
                //擷取檔案名稱
                String name = subf.getName();
                String fullPath = path + "\\" + name;
                //執行反射相關的方法
                //ServiceLoaderUtils serviceLoaderUtils = new ServiceLoaderUtils();
                //result = serviceLoaderUtils.loadMethod(fullPath);
                File f = new File(fullPath);
                URL urlB = f.toURI().toURL();
                URLClassLoader classLoaderA = new URLClassLoader(new URL[]{urlB}, Thread.currentThread()
                        .getContextClassLoader());
                String[] clazz = classImpl.getClazz();
                for(String claName : clazz){
                    if(name.equals("biz-pt-1.0-SNAPSHOT.jar")){
                        if(!claName.equals("com.congge.spi.BitptImpl")){
                            continue;
                        }
                        Class<?> loadClass = classLoaderA.loadClass(claName);
                        if(Objects.isNull(loadClass)){
                            continue;
                        }
                        //擷取執行個體
                        Object obj = loadClass.newInstance();
                        Map map = new HashMap();
                        //擷取方法
                        Method method=loadClass.getDeclaredMethod("sendMsg",Map.class);
                        result = method.invoke(obj,map);
                        if(Objects.nonNull(result)){
                            break;
                        }
                    }else if(name.equals("miz-pt-1.0-SNAPSHOT.jar")){
                        if(!claName.equals("com.congge.spi.MizptImpl")){
                            continue;
                        }
                        Class<?> loadClass = classLoaderA.loadClass(claName);
                        if(Objects.isNull(loadClass)){
                            continue;
                        }
                        //擷取執行個體
                        Object obj = loadClass.newInstance();
                        Map map = new HashMap();
                        //擷取方法
                        Method method=loadClass.getDeclaredMethod("sendMsg",Map.class);
                        result = method.invoke(obj,map);
                        if(Objects.nonNull(result)){
                            break;
                        }
                    }
                }
                if(Objects.nonNull(result)){
                    break;
                }
            }
        }
        return result.toString();
    }
 
    public Object loadMethod(String fullPath) throws Exception{
        File f = new File(fullPath);
        URL urlB = f.toURI().toURL();
        URLClassLoader classLoaderA = new URLClassLoader(new URL[]{urlB}, Thread.currentThread()
                .getContextClassLoader());
        Object result = null;
        String[] clazz = classImpl.getClazz();
        for(String claName : clazz){
            Class<?> loadClass = classLoaderA.loadClass(claName);
            if(Objects.isNull(loadClass)){
                continue;
            }
            //擷取執行個體
            Object obj = loadClass.newInstance();
            Map map = new HashMap();
            //擷取方法
            Method method=loadClass.getDeclaredMethod("sendMsg",Map.class);
            result = method.invoke(obj,map);
            if(Objects.nonNull(result)){
                break;
            }
        }
        return result;
    }
 
 
    public static String invokeMethod(String text) throws Exception{
        String path = "E:\\code-self\\bitzpp\\lib\\miz-pt-1.0-SNAPSHOT.jar";
        File f = new File(path);
        URL urlB = f.toURI().toURL();
        URLClassLoader classLoaderA = new URLClassLoader(new URL[]{urlB}, Thread.currentThread()
                .getContextClassLoader());
        Class<?> product = classLoaderA.loadClass("com.congge.spi.MizptImpl");
        //擷取執行個體
        Object obj = product.newInstance();
        Map map = new HashMap();
        //擷取方法
        Method method=product.getDeclaredMethod("sendMsg",Map.class);
        //執行方法
        Object result1 = method.invoke(obj,map);
        // TODO According to the requirements , write the implementation code.
        return result1.toString();
    }
 
    public static String getApplicationFolder() {
        String path = ServiceLoaderUtils.class.getProtectionDomain().getCodeSource().getLocation().getPath();
        return new File(path).getParent();
    }
 
 
 
}

2.3.3 添加測試接口

添加如下測試接口

@GetMapping("/sendMsgV2")
public String index() throws Exception {
    String result = serviceLoaderUtils.doExecuteMethod();
    return result;
}

以上全部完成之後，啟動工程，測試一下該接口，仍然可以得到預期結果；

SpringBoot 插件化開發模式，強烈推薦！

在上述的實作中還是比較粗糙的，實際運用時，還需要做較多的優化改進以滿足實際的業務需要，比如接口傳入類型參數用于控制具體使用哪個依賴包的方法進行執行等；

三、SpringBoot中的插件化實作

在大家使用較多的springboot架構中，其實架構自身提供了非常多的擴充點，其中最适合做插件擴充的莫過于spring.factories的實作；

3.1 Spring Boot中的SPI機制

在Spring中也有一種類似與Java SPI的加載機制。它在META-INF/spring.factories檔案中配置接口的實作類名稱，然後在程式中讀取這些配置檔案并執行個體化，這種自定義的SPI機制是Spring Boot Starter實作的基礎。

3.2 Spring Factories實作原理

spring-core包裡定義了SpringFactoriesLoader類，這個類實作了檢索META-INF/spring.factories檔案，并擷取指定接口的配置的功能。在這個類中定義了兩個對外的方法：

  • loadFactories 根據接口類擷取其實作類的執行個體，這個方法傳回的是對象清單；
  • loadFactoryNames 根據接口擷取其接口類的名稱，這個方法傳回的是類名的清單；

上面的兩個方法的關鍵都是從指定的ClassLoader中擷取spring.factories檔案，并解析得到類名清單，具體代碼如下：

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
    try {
        Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        List<String> result = new ArrayList<String>();
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
            String factoryClassNames = properties.getProperty(factoryClassName);
            result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
        }
        return result;
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
                "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

從代碼中我們可以知道，在這個方法中會周遊整個ClassLoader中所有jar包下的spring.factories檔案，就是說我們可以在自己的jar中配置spring.factories檔案，不會影響到其它地方的配置，也不會被别人的配置覆寫。

spring.factories的是通過Properties解析得到的，是以我們在寫檔案中的内容都是安裝下面這種方式配置的：

com.xxx.interface=com.xxx.classname

如果一個接口希望配置多個實作類，可以使用’,’進行分割

3.3 Spring Factories案例實作

接下來看一個具體的案例實作來體驗下Spring Factories的使用；

3.3.1 定義一個服務接口

自定義一個接口，裡面添加一個方法；

public interface SmsPlugin {
 
    public void sendMessage(String message);
 
}

3.3.2 定義2個服務實作

實作類1

public class BizSmsImpl implements SmsPlugin {
 
    @Override
    public void sendMessage(String message) {
        System.out.println("this is BizSmsImpl sendMessage..." + message);
    }
}

實作類2

public class SystemSmsImpl implements SmsPlugin {
 
    @Override
    public void sendMessage(String message) {
        System.out.println("this is SystemSmsImpl sendMessage..." + message);
    }
}

3.3.3 添加spring.factories檔案

在resources目錄下，建立一個名叫：META-INF的目錄，然後在該目錄下定義一個spring.factories的配置檔案，内容如下，其實就是配置了服務接口，以及兩個實作類的全類名的路徑；

com.congge.plugin.spi.SmsPlugin=\
com.congge.plugin.impl.SystemSmsImpl,\
com.congge.plugin.impl.BizSmsImpl

3.3.4 添加自定義接口

添加一個自定義的接口，有沒有發現，這裡和java 的spi有點類似，隻不過是這裡換成了SpringFactoriesLoader去加載服務；

@GetMapping("/sendMsgV3")
public String sendMsgV3(String msg) throws Exception{
    List<SmsPlugin> smsServices= SpringFactoriesLoader.loadFactories(SmsPlugin.class, null);
    for(SmsPlugin smsService : smsServices){
        smsService.sendMessage(msg);
    }
    return "success";
}

啟動工程之後，調用一下該接口進行測試，localhost:8087/sendMsgV3?msg=hello，通過控制台，可以看到，這種方式能夠正确擷取到系統中可用的服務實作；

SpringBoot 插件化開發模式，強烈推薦！

利用spring的這種機制，可以很好的對系統中的某些業務邏輯通過插件化接口的方式進行擴充實作；

四、插件化機制案例實戰

結合上面掌握的理論知識，下面基于Java SPI機制進行一個接近真實使用場景的完整的操作步驟；

4.1 案例背景

  • 3個微服務子產品，在A子產品中有個插件化的接口；
  • 在A子產品中的某個接口，需要調用插件化的服務實作進行短信發送；
  • 可以通過配置檔案配置參數指定具體的哪一種方式發送短信；
  • 如果沒有加載到任何插件，将走A子產品在預設的發短信實作；

4.1.1 子產品結構

1、biz-pp，插件化接口工程；

2、bitpt，aliyun短信發送實作；

3、miz-pt，tencent短信發送實作；

4.1.2 整體實作思路

本案例完整的實作思路參考如下：

  • biz-pp定義服務接口，并提供出去jar被其他實作工程依賴；
  • bitpt與miz-pt依賴biz-pp的jar并實作SPI中的方法；
  • bitpt與miz-pt按照API規範實作完成後，打成jar包，或者安裝到倉庫中；
  • biz-pp在pom中依賴bitpt與miz-pt的jar，或者通過啟動加載的方式即可得到具體某個實作；

4.2 biz-pp 關鍵代碼實作過程

4.2.1 添加服務接口 

public interface MessagePlugin {
 
    public String sendMsg(Map msgMap);
 
}

4.2.2 打成jar包并安裝到倉庫

這一步比較簡單就不展開了

4.2.3 自定義服務加載工具類

這個類，可以了解為在真實的業務編碼中，可以根據業務定義的規則，具體加載哪個插件的實作類進行發送短信的操作；

import com.congge.plugin.spi.MessagePlugin;
import com.congge.spi.BitptImpl;
import com.congge.spi.MizptImpl;
 
import java.util.*;
 
public class PluginFactory {
 
    public void installPlugin(){
        Map context = new LinkedHashMap();
        context.put("_userId","");
        context.put("_version","1.0");
        context.put("_type","sms");
        ServiceLoader<MessagePlugin> serviceLoader = ServiceLoader.load(MessagePlugin.class);
        Iterator<MessagePlugin> iterator = serviceLoader.iterator();
        while (iterator.hasNext()){
            MessagePlugin messagePlugin = iterator.next();
            messagePlugin.sendMsg(context);
        }
    }
 
    public static MessagePlugin getTargetPlugin(String type){
        ServiceLoader<MessagePlugin> serviceLoader = ServiceLoader.load(MessagePlugin.class);
        Iterator<MessagePlugin> iterator = serviceLoader.iterator();
        List<MessagePlugin> messagePlugins = new ArrayList<>();
        while (iterator.hasNext()){
            MessagePlugin messagePlugin = iterator.next();
            messagePlugins.add(messagePlugin);
        }
        MessagePlugin targetPlugin = null;
        for (MessagePlugin messagePlugin : messagePlugins) {
            boolean findTarget = false;
            switch (type) {
                case "aliyun":
                    if (messagePlugin instanceof BitptImpl){
                        targetPlugin = messagePlugin;
                        findTarget = true;
                        break;
                    }
                case "tencent":
                    if (messagePlugin instanceof MizptImpl){
                        targetPlugin = messagePlugin;
                        findTarget = true;
                        break;
                    }
            }
            if(findTarget) break;
        }
        return targetPlugin;
    }
 
    public static void main(String[] args) {
        new PluginFactory().installPlugin();
    }
 
 
}

4.2.4 自定義接口 

@RestController
public class SmsController {
 
    @Autowired
    private SmsService smsService;
 
    @Autowired
    private ServiceLoaderUtils serviceLoaderUtils;
 
    //localhost:8087/sendMsg?msg=sendMsg
    @GetMapping("/sendMsg")
    public String sendMessage(String msg){
        return smsService.sendMsg(msg);
    }
 
}

4.2.5 接口實作 

@Service
public class SmsService {
 
    @Value("${msg.type}")
    private String msgType;
 
    @Autowired
    private DefaultSmsService defaultSmsService;
 
    public String sendMsg(String msg) {
        MessagePlugin messagePlugin = PluginFactory.getTargetPlugin(msgType);
        Map paramMap = new HashMap();
        if(Objects.nonNull(messagePlugin)){
            return messagePlugin.sendMsg(paramMap);
        }
        return defaultSmsService.sendMsg(paramMap);
    }
}

4.2.6 添加服務依賴

在該子產品中，需要引入對具體實作的兩個工程的jar依賴（也可以通過啟動加載的指令方式）

<dependencies>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--依賴具體的實作-->
    <dependency>
        <groupId>com.congge</groupId>
        <artifactId>biz-pt</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

    <dependency>
        <groupId>com.congge</groupId>
        <artifactId>miz-pt</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

</dependencies>

biz-pp的核心代碼實作就到此結束了，後面再具體測試的時候再繼續；

4.3 bizpt 關鍵代碼實作過程

接下來就是插件化機制中具體的SPI實作過程，兩個子產品的實作步驟完全一緻，挑選其中一個說明，工程目錄結構如下：

SpringBoot 插件化開發模式，強烈推薦！

4.3.1 添加對biz-app的jar的依賴

将上面biz-app工程打出來的jar依賴過來

<dependencies>
    <dependency>
        <groupId>com.congge</groupId>
        <artifactId>biz-app</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

4.3.2 添加MessagePlugin接口的實作 

public class BitptImpl implements MessagePlugin {
 
    @Override
    public String sendMsg(Map msgMap) {
        Object userId = msgMap.get("userId");
        Object type = msgMap.get("_type");
        //TODO 參數校驗
        System.out.println(" ==== userId :" + userId + ",type :" + type);
        System.out.println("aliyun send message success");
        return "aliyun send message success";
    }
}

4.3.3 添加SPI配置檔案

按照前文的方式，在resources目錄下建立一個檔案，注意檔案名稱為SPI中的接口全名，檔案内容為實作類的全類名

com.congge.spi.BitptImpl

4.3.4 将jar安裝到倉庫中

完成實作類的編碼後，通過maven指令将jar安裝到倉庫中，然後再在上一步的biz-app中引入即可；

4.4 效果示範

啟動biz-app服務，調用接口：localhost:8087/sendMsg?msg=sendMsg，可以看到如下效果

SpringBoot 插件化開發模式，強烈推薦！

為什麼會出現這個效果呢？因為我們在實作類配置了具體使用哪一種方式進行短信的發送，而加載插件的時候正好能夠找到對應的服務實作，這樣的話就給目前的業務提供了一個較好的擴充點。

SpringBoot 插件化開發模式，強烈推薦！

五、寫在文末

從目前的趨勢來看，插件化機制的思想已經遍布各種程式設計語言，架構，中間件，開源工具等領域，是以掌握插件化的實作機制對于當下做程式實作，或架構設計方面都有着很重要的意義，值得深入研究，本篇到此結束，感謝觀看！

來源：blog.csdn.net/zhangcongyi420/article/details/131139599
插件化開發 開發模式 spring pring ring
上一篇: 甩一張你覺得最nis的照片來看看#撩起衣服就是腹肌
下一篇: 剛剛說粘個闆，兩個月前買的膠皮放抽屜裡放得好好的結果找不到了😭那将就用舊的吧，一撕，我天，這絕對不是我暴力，看看這個老膠

繼續閱讀