阿里技術（一）：基於JAVA的模塊化開發框架JarsLink

導讀：JarsLink是一個基於JAVA的模塊化開發框架，它提供在運行時動態加載模塊（JAR包）、卸載模塊和模塊間調用的API，它能夠幫助你進行模塊化開發，也能幫助你的系統在運行時動態添加新功能，減少編譯、打包和部署帶來的發佈耗時，同時它也是阿里巴巴的開源項目之一，目前在螞蟻金服微貸事業羣各團隊廣泛使用。

開源地址：https://github.com/alibaba/jarslink

需求背景：

應用拆分的多或少都有問題。多則維護成本高，每次發佈一堆應用。少則拆分成本高，無用功能很難下線。
故障不隔離。當一個系統由多人同時參與開發時，修改A功能，可能會影響B功能，引發故障。
多分支開發引發衝突。多分支開發完之後合併會產生衝突。
牽一髮動全身。一處核心代碼的改動，或一個基礎Jar的升級需要回歸整個系統。
升級和遷移成本高。中間件升級每個應用都有升級成本。

模塊化開發的好處

可插拔，一個應用由多個模塊組成，應用裏的模塊可拆和合，模塊可快速在多個系統中遷移和部署。
模塊化開發，模塊之間互相隔離，實現故障隔離。
一個模塊一個分支，不會引發代碼衝突。
在模塊中增加或修改功能，只會影響當前模塊，不會影響整個應用。
動態部署，在運行時把模塊部署到應用中，快速修復故障，提高發布效率。
多版本部署，可以在運行時同時部署某個模塊的新舊版本，進行AB TEST。
減少資源消耗，通過部署模塊的方式減少應用數量和機器數量。

JarsLink的應用場景

數據管理中心，如果你需要開發一個數據管理系統，這個系統需要去不同的異構系統採集數據，這些系統會提供不同類型的接口，如RPC，HTTP等。並且數據採集的數據源多，每種數據源都需要對接和開發，數據質量比較差，需要經常修改代碼進行發佈。在這種場景下，通過模塊化開發，實現一個數據源使用一個模塊進行對接，上線新數據源只需要新增模塊，修改BUG只需要修改某個模塊，並能快速上線。
後臺管理系統，互聯網應用發展到一定階段會出現很多後臺需求，如客服查詢用戶的信息幫助解答問題，開發查後臺數據排查系統BUG，運營使用後臺功能發送運營活動等。這些功能發佈頻率會大於核心系統，如果放在覈心繫統裏會影響其穩定性，所以我們必須要建一個後臺系統來開發後臺功能，但是這樣又帶來一個新的問題，很多開發都會來這個系統進行開發，拉多分支造成代碼衝突，A業務的BUG影響到B業務。所以如果每個業務線一個模塊，每個模塊使用一個單獨的分支進行開發，就能進行隔離開發，提高開發速度，開發完後在運行時加載到系統中。
微服務集成測試, 目前一個微服務是一個FAT JAR,如果有幾十個微服務,則需要啓動很多進程,DEBUG端口會很多,使用JarsLink框架合併FAT JAR,再路由請求到其他JAR,就可以只啓動一個進程進行DEBUG測試。
指標計算系統，可以把消息轉發到不同的模塊中進行處理，並輸出指標。
目前螞蟻金服微貸事業部幾個系統和幾十個模塊已經使用JarsLink框架。

JarsLink的應用場景

隔離性

類隔離：框架爲每個模塊的Class使用單獨的ClassLoader來加載，每個模塊可以依賴同一種框架的不同的版本。
實例隔離：框架爲每個模塊創建了一個獨立的Spring上下文，來加載模塊中的BEAN，實例化失敗不會影響其他模塊。
資源隔離：後續會支持模塊之間的資源隔離，每個模塊使用獨立的CPU和內存資源。
動態性
類隔離：動態發佈：模塊能在運行時動態加載到系統中，實現不需要重啓和發佈系統新增功能。支持突破雙親委派機制，在運行時加載父加載器已經加載過的類，實現模塊升級依賴包不需要系統發佈。
動態卸載：模塊能在運行時被動態卸載乾淨，實現快速下線不需要功能。
易用性
- 提供了通用靈活的API讓系統和模塊進行交互。

實現原理

模塊加載

JarsLink爲每個模塊創建一個新的URLClassLoader來加載模塊。並且支持突破雙親委派，設置了overridePackages的包將由子類加載進行加載，不優先使用父類加載器已加載的。

模塊的卸載
卸載模塊需要滿足三個條件：

模塊裏的實例對象沒有被引用
模塊裏的Class沒有被引用
類加載器沒有被引用

所以需要做到三點卸載實例，卸載類和卸載類加載器，整個模塊的卸載順序如下：

- 關閉資源：關閉HTTP連接池或線程池。
- 關閉IOC容器：調用applicationContext.close()方法關閉IOC容器。
- 移除類加載器：去掉模塊的引用。
- 卸載JVM租戶（開發中）：卸載該模塊使用的JVM租戶，釋放資源。

模塊間隔離

模塊化開發需要解決隔離性問題，否則各模塊之間會互相影響。模塊之間的隔離有三個層次：

類隔離：爲每個模塊創建一個類加載器來實現類隔離。
實例隔離：爲每個模塊創建一個新的IOC容器來加載模塊裏面的BEAN。
資源隔離：對每個模塊只能使用指定的CPU和內存。

目前JarsLink實現了類隔離和實例隔離，資源隔離準備引入ALIJVM多租戶來解決。

模塊間通訊
模塊之間的通訊也有三種方式，RPC，本地調用，深克隆/反射。

本地調用：目前JarsLink的doAction就是使用的這種通訊方式，這種方式要求模塊的類加載器是父子關係，且IOC容器也是父子容器。
RPC調用：用於跨JVM的模塊之間調用，利用SOFA 4動態API在模塊中發佈和引用TR服務來實現。
深克隆/反射：深克隆其他模塊的入參，反射其他模塊的方法實現調用。

類加載機制

OSGI類加載機制的關係採用的是網狀結構，每個模塊通過 Export-Package 來聲明我要給別人用哪些類，通過 Import-Package來聲明我要用別人的哪些類。JarsLink採用扁平化管理，每個模塊都有一個共同的父類，這個父類加載器就是加載ModuleLoader類的加載器，如果是SOFA應用，模塊的父加載器是KernelAceClassLoader，類加載器關係如下：

如果所有模塊都需要使用的類，可以通過KernelAceClassLoader加載，如果是SOFA系統可以通過POM引入。

JarsLink框架類圖

JarsLink框架的類圖如下：

AbstractModuleRefreshScheduler：入口類，負責定期掃描本地和內存中的模塊是否發生變更，如果變更，則更新模塊。
ModuleLoader：模塊加載引擎，負責模塊加載。
ModuleManager：模塊管理者，負責在運行時註冊，卸載，查找模塊和執行Action。
Module：模塊，一個模塊有多個Action。
Action：模塊裏的執行者。

如何使用？

1：引入POM

2：引入jarslink BEAN
系統中引入以下兩個BEAN。

<!-- 模塊加載引擎 -->
    <bean name="moduleLoader" class="com.alipay.jarslink.api.impl.ModuleLoaderImpl"></bean>

    <!-- 模塊管理器 -->
    <bean name="moduleManager" class="com.alipay.jarslink.api.impl.ModuleManagerImpl"></bean>

    <!-- 模塊服務 -->
    <bean name="moduleService" class="com.alipay.jarslink.api.impl.ModuleServiceImpl">
        <property name="moduleLoader" ref="moduleLoader"></property>
        <property name="moduleManager" ref="moduleManager"></property>
    </bean>

3：集成JarsLink API

使用JarsLink API非常簡單，只需要繼承AbstractModuleRefreshScheduler，並提供模塊的配置信息，代碼如下：

package com.alipay.jarslink.api.impl;

import com.alipay.jarslink.api.ModuleConfig;

import java.util.List;

/**
 * 模塊刷新調度器
 *
 * @author tengfei.fangtf
 * @version $Id: AbstractModuleRefreshSchedulerImpl.java, v 0.1 2017年07月21日 2:50 PM tengfei.fangtf Exp $
 */
public class AbstractModuleRefreshSchedulerImpl extends AbstractModuleRefreshScheduler {

    private List<ModuleConfig> moduleConfigs;

    @Override
    public List<ModuleConfig> queryModuleConfigs() {
        return moduleConfigs;
    }

    public void setModuleConfigs(List<ModuleConfig> moduleConfigs) {
        this.moduleConfigs = moduleConfigs;
    }

}

這個調度器在bean初始化的時候會啓動一個調度任務，每分鐘刷新一次模塊，如果模塊的版本號發生變更則會更新模塊。實現這個方法時，必須把模塊（jar包）下載到機器本地，模塊的配置信息說明如下：

name：全局唯一，建議使用英文，忽略大小寫。
enabled：當前模塊是否可用，默認可用，卸載模塊時可以設置成false。
version：模塊的版本，如果版本號和之前加載的不一致，框架則會重新加載模塊。
Properties：spring屬性配置文件。
moduleUrl：模塊的本地存放地址。
overridePackages：需要突破雙親委派的包名,一般不推薦使用，範圍越小越好，如com.alipay.XX。

你也可以使用API來加載並註冊模塊，詳細使用方式可以參考ModuleManagerTest，代碼如下。

/*
 */
package com.alipay.jarslink.api.impl;

import com.alipay.jarslink.api.Module;
import com.alipay.jarslink.api.ModuleManager;
import com.alipay.jarslink.api.Action;
import com.alipay.jarslink.api.ModuleConfig;
import com.alipay.jarslink.api.ModuleLoader;
import com.google.common.collect.ImmutableList;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

/**
 * 模塊加載和執行測試
 *
 * @author tengfei.fangtf
 * @version $Id: ModuleManagerTest.java
 *
 * v 0.1 2017年06月20日 3:24 PM tengfei.fangtf Exp $
 *
 * */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:META-INF/spring/jarslink.xml"})
public class ModuleManagerTest {

    @Autowired
    private ModuleManager moduleManager;

    @Autowired
    private ModuleLoader moduleLoader;

    @Test
    public void shouldLoadModule() {
        //1:加載模塊
        Module module = loadModule();
        Assert.assertNotNull(module);
        Assert.assertNotNull(module.getCreation());
        Assert.assertNotNull(module.getChildClassLoader());
        //卸載模塊
        module.destroy();
        Assert.assertNotNull(module.getChildClassLoader());

    }

    @Test
    public void shouldRegisterModule() throws MalformedURLException {
        //2:註冊模塊
        Module module = loadModule();
        Module removedModule = moduleManager.register(module);
        Assert.assertNull(removedModule);

        //3:查找模塊
        Module findModule = moduleManager.find(module.getName());
        Assert.assertNotNull(findModule);

        Assert.assertNotNull(moduleManager.getErrorModuleContext());
        Assert.assertEquals(1, moduleManager.getModules().size());

        Module remove = moduleManager.remove(module.getName());

        Assert.assertNull(moduleManager.find(remove.getName()));
        Assert.assertEquals(0, moduleManager.getModules().size());
    }

    @Test
    public void shouldDoAction() {
        Module findModule = loadModule();
        Module removedModule = moduleManager.register(findModule);
        //4.1:查找和執行Action

        String actionName = "helloworld";
        ModuleConfig moduleConfig = new ModuleConfig();
        moduleConfig.setName("h");
        moduleConfig.setEnabled(true);
        ModuleConfig result = findModule.doAction(actionName, moduleConfig);
        Assert.assertEquals(1, findModule.getActions().size());
        Assert.assertNotNull(result);
        Assert.assertEquals(result.getName(), moduleConfig.getName());
        Assert.assertEquals(result.getEnabled(), moduleConfig.getEnabled());

        //4.2:查找和執行Action
        Action<ModuleConfig, ModuleConfig> action = findModule.getAction(actionName);
        Assert.assertNotNull(action);
        result = action.execute(moduleConfig);
        Assert.assertNotNull(result);
        Assert.assertEquals(result.getName(), moduleConfig.getName());
        Assert.assertEquals(result.getEnabled(), moduleConfig.getEnabled());

        //卸載模塊
        moduleManager.remove(findModule.getName());
    }

    /**
     * 構建模塊配置信息
     */
    public static ModuleConfig buildModuleConfig() {
        return buildModuleConfig(true);
    }

    public static ModuleConfig buildModuleConfig(boolean enabled) {
        URL demoModule = Thread.currentThread().getContextClassLoader().getResource("jarslink-module-demo-1.0.0.jar");
        ModuleConfig moduleConfig = new ModuleConfig();
        moduleConfig.setName("demo");
        moduleConfig.setEnabled(enabled);
        moduleConfig.setOverridePackages(ImmutableList.of("com.alipay.jarslink.demo"));
        moduleConfig.setVersion("1.0.0.20170621");
        Map<String, Object> properties = new HashMap();
        properties.put("url", "127.0.0.1");
        moduleConfig.setProperties(properties);
        moduleConfig.setModuleUrl(ImmutableList.of(demoModule));
        return moduleConfig;
    }

    private Module loadModule() {return moduleLoader.load(buildModuleConfig());}

}

3：開發模塊
在模塊中只需要實現並開發Action，代碼如下：

package com.alipay.jarslink.demo;

import com.alipay.jarslink.api.Action;
import com.alipay.jarslink.api.ModuleConfig;

/**
 * 一個簡單的Action實現
 *
 */
public class HelloWorldAction implements Action<ModuleConfig, ModuleConfig> {

    @Override
    public ModuleConfig execute(ModuleConfig actionRequest) {
        ModuleConfig moduleConfig = new ModuleConfig();
        moduleConfig.setName(actionRequest.getName());
        moduleConfig.setEnabled(actionRequest.getEnabled());
        moduleConfig.setVersion(actionRequest.getVersion());
        moduleConfig.setModuleUrl(actionRequest.getModuleUrl());
        moduleConfig.setProperties(actionRequest.getProperties());
        moduleConfig.setOverridePackages(actionRequest.getOverridePackages());
        return moduleConfig;
    }

    @Override
    public String getActionName() {
        return "helloworld";
    }

}

5：調用接口
開發者需要利用JarsLink API把請求轉發給模塊，先根據模塊名查找模塊，再根據aciton name查找Action，最後執行Action。

@Test
    public void shouldAddModule() {
        //裝載模塊
        abstractModuleRefreshSchedulerImpl.setModuleConfigs(ImmutableList.of(ModuleManagerTest.buildModuleConfig()));
        Assert.assertEquals(1, abstractModuleRefreshSchedulerImpl.queryModuleConfigs().size());
        abstractModuleRefreshSchedulerImpl.run();
        Module demo = moduleManager.find("demo");
        Assert.assertNotNull(demo.getAction("helloworld"));

        ////修改模塊
        //ModuleConfig moduleConfig = ModuleManagerTest.buildModuleConfig(false);
        //moduleConfig.setVersion("1.1");
        //abstractModuleRefreshSchedulerImpl.queryModuleConfigs().add(moduleConfig);
        //abstractModuleRefreshSchedulerImpl.run();

        //卸載模塊
        abstractModuleRefreshSchedulerImpl.setModuleConfigs(new ArrayList<ModuleConfig>());
        Assert.assertEquals(0, abstractModuleRefreshSchedulerImpl.queryModuleConfigs().size());
        abstractModuleRefreshSchedulerImpl.run();
        Assert.assertNull(moduleManager.find("demo"));

    }

其他特性

通過moduleConfig的Properties屬性可以設置Spring bean變量的配置信息。

最佳實踐

HTTP請求轉發

消息請求轉發

可以把消息轉發給模塊進行處理。遵循默認大於配置的方式，你可以把TOPIC當做模塊名，EventCode當做ActionName來轉發請求。

接口說明

JarsLink框架最重要的兩個接口是ModuleManager和ModuleLoader。

ModuleManager接口

/*
 *  * Copyright 1999-2018 Alibaba Group Holding Ltd
 */
package com.alipay.jarslink.api;

import java.util.List;
import java.util.Map;

/**
 * 模塊管理者, 提供註冊,移除和查找模塊能力
 *
 * @author tengfei.fangtf
 * @version $Id: ModuleManager.java, v 0.1 2017年05月30日 2:55 PM tengfei.fangtf Exp $
 */
public interface ModuleManager {

    /**
     * 根據模塊名查找Module
     * @param name
     * @return
     */
    Module find(String name);

    /**
     * 獲取所有已加載的Module
     *
     * @return
     */
    List<Module> getModules();

    /**
     * 註冊一個Module
     *
     * @param module 模塊
     * @return 舊模塊,如果沒有舊模塊則返回null
     */
    Module register(Module module);

    /**
     * 移除一個Module
     *
     * @param name 模塊名
     * @return 被移除的模塊
     */
    Module remove(String name);

    /**
     * 獲取發佈失敗的模塊異常信息
     *
     * @return key:模塊名,value:錯誤信息
     */
    Map<String, String> getErrorModuleContext();

}

現實類

/*
 *  * Copyright 1999-2018 Alibaba Group Holding Ltd
 */
package com.alipay.jarslink.api.impl;

import com.alipay.jarslink.api.Module;
import com.alipay.jarslink.api.ModuleManager;
import com.google.common.collect.ImmutableList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;

import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Predicates.instanceOf;
import static com.google.common.collect.Iterables.filter;

/**
 * 模塊管理，包含獲取模塊，執行模塊裏的方法
 *
 * @author tengfei.fangtf
 *
 */
public class ModuleManagerImpl implements ModuleManager, DisposableBean {

    private static final Logger LOGGER = LoggerFactory
            .getLogger(ModuleManagerImpl.class);

    /**
     * 運行時模塊,模塊名:模塊對象
     */
    private final ConcurrentHashMap<String, Module> modules = new ConcurrentHashMap();

    /**
     * 加載模塊錯誤信息
     */
    private final ConcurrentHashMap<String, String> errorContext = new ConcurrentHashMap();

    @Override
    public List<Module> getModules() {
        return ImmutableList
                .copyOf(filter(modules.values(), instanceOf(SpringModule.class)));
    }

    @Override
    public Module find(String name) {
        checkNotNull(name, "module name is null");
        return modules.get(name.toUpperCase());
    }

    @Override
    public Module register(Module module) {
        checkNotNull(module, "module is null");
        String name = module.getName();
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Put Module: {}-{}", name, module.getVersion());
        }

        return modules.put(name.toUpperCase(Locale.CHINESE), module);
    }

    @Override
    public Module remove(String name) {
        checkNotNull(name, "module name is null");
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Remove Module: {}", name);
        }
        return modules.remove(name.toUpperCase());
    }

    @Override
    public void destroy() throws Exception {
        for (Module each : modules.values()) {
            try {
                each.destroy();
            } catch (Exception e) {
                LOGGER.error("Failed to destroy module: " + each.getName(), e);
            }
        }
        modules.clear();
    }

    @Override
    public Map<String, String> getErrorModuleContext() {
        return errorContext;
    }

}

ModuleLoader接口

/*
 *  * Copyright 1999-2018 Alibaba Group Holding Ltd.
 */
package com.alipay.jarslink.api;

/**
 * 模塊加載器
 *
 * @author tengfei.fangtf
 * @version $Id: ModuleLoader.java, v 0.1 2017年05月30日 2:55 PM tengfei.fangtf Exp $
 */
public interface ModuleLoader {

    /**
     * 根據配置加載一個模塊，創建一個新的ClassLoadr加載jar裏的class，初始化Spring ApplicationContext等
     *
     * @param moduleConfig 模塊配置信息
     *
     * @return 加載成功的模塊
     */
    Module load(ModuleConfig moduleConfig);

}

實現類

/*
 *  * Copyright 1999-2018 Alibaba Group Holding Ltd.
 */
package com.alipay.jarslink.api.impl;

import com.alipay.jarslink.api.Module;
import com.alipay.jarslink.api.ModuleConfig;
import com.alipay.jarslink.api.ModuleLoader;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.CachedIntrospectionResults;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.Iterables.toArray;
import static org.apache.commons.lang.StringUtils.isBlank;

/**
 * 模塊加載器實現
 *
 * @author tengfei.fangtf
 * @version $Id: ModuleLoaderImpl.java, v 0.1 2017-4-24 上午9:58:12 tengfei.fangtf Exp $
 */
public class ModuleLoaderImpl implements ModuleLoader, ApplicationContextAware {

    private static final Logger LOGGER = LoggerFactory.getLogger(ModuleLoaderImpl.class);

    /**
     * Spring bean文件所在目錄
     */
    public static String SPRING_XML_PATTERN  = "classpath*:META-INF/spring/*.xml";
    /**
     * Spring bean文件所在目錄,不同的路徑確保能取到資源
     */
    public static String SPRING_XML_PATTERN2 = "classpath*:*META-INF/spring/*.xml";

    /**
     * 模塊版本屬性
     */
    private static final String MODULE_PROPERTY_VERSION = "module_version";

    /**
     * 模塊名屬性
     */
    private static final String MODULE_PROPERTY_NAME = "module_name";

    /**
     * 不加載的Spring配置文件
     */
    private static final String MODULE_EXCLUSION_CONFIGE_NAME = "exclusion_confige_name";

    /**
     * 注入父applicationContext
     */
    private ApplicationContext applicationContext;

    @Override
    public Module load(ModuleConfig moduleConfig) {
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Loading module: {}", moduleConfig);
        }
        List<String> tempFileJarURLs = moduleConfig.getModuleUrlPath();
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Local jars: {}", tempFileJarURLs);
        }

        ConfigurableApplicationContext moduleApplicationContext = loadModuleApplication(moduleConfig, tempFileJarURLs);

        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Loading module  complete：{}", moduleConfig);
        }
        return new SpringModule(moduleConfig, moduleConfig.getVersion(), moduleConfig.getName(), moduleApplicationContext);
    }

    /**
     * 根據本地臨時文件Jar，初始化模塊自己的ClassLoader，初始化Spring Application Context，同時要設置當前線程上下文的ClassLoader問模塊的ClassLoader
     *
     * @param moduleConfig
     * @param tempFileJarURLs
     * @return
     */
    private ClassPathXmlApplicationContext loadModuleApplication(ModuleConfig moduleConfig, List<String> tempFileJarURLs) {
        ClassLoader currentClassLoader = Thread.currentThread().getContextClassLoader();
        //獲取模塊的ClassLoader
        ClassLoader moduleClassLoader = new ModuleClassLoader(moduleConfig.getModuleUrl(), applicationContext.getClassLoader(),
                getOverridePackages(moduleConfig));

        try {
            //把當前線程的ClassLoader切換成模塊的
            Thread.currentThread().setContextClassLoader(moduleClassLoader);
            ModuleApplicationContext moduleApplicationContext = new ModuleApplicationContext(applicationContext);
            Properties properties = getProperties(moduleConfig);
            moduleApplicationContext.setProperties(properties);
            moduleApplicationContext.setClassLoader(moduleClassLoader);
            moduleApplicationContext.setConfigLocations(findSpringConfigs(tempFileJarURLs, moduleClassLoader,
                    getExclusionConfigeNameList(properties)));
            moduleApplicationContext.refresh();
            return moduleApplicationContext;
        } catch (Throwable e) {
            CachedIntrospectionResults.clearClassLoader(moduleClassLoader);
            throw Throwables.propagate(e);
        } finally {
            //還原當前線程的ClassLoader
            Thread.currentThread().setContextClassLoader(currentClassLoader);
        }
    }

    /**
     * 獲取不加載的spring配置文件名稱
     * @param properties
     * @return
     */
    private List<String> getExclusionConfigeNameList(Properties properties) {
        String property = properties.getProperty(MODULE_EXCLUSION_CONFIGE_NAME);
        if (property != null) {
            return Lists.newArrayList(property.split(","));
        }
        return Lists.newArrayList();

    }

    /**
     * 獲得模塊的配置，並會增加一些模塊的常量信息
     *
     * @param moduleConfig
     * @return
     */
    private Properties getProperties(ModuleConfig moduleConfig) {
        Properties properties = toProperties(moduleConfig.getProperties());
        properties.setProperty(MODULE_PROPERTY_NAME, moduleConfig.getName());
        properties.setProperty(MODULE_PROPERTY_VERSION, moduleConfig.getVersion());
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Module Properties: {}", properties);
        }
        return properties;
    }

    /**
     * 查找資源(JAR)中的Spring配置文件
     *
     * @param tempFileJarURLs
     * @param moduleClassLoader
     * @return
     */
    private String[] findSpringConfigs(List<String> tempFileJarURLs, ClassLoader moduleClassLoader, List<String> exclusionConfigeNameList) {
        try {
            PathMatchingResourcePatternResolver pmr = new PathMatchingResourcePatternResolver(
                    moduleClassLoader);
            Resource[] resources = ImmutableSet.builder().add(pmr.getResources(SPRING_XML_PATTERN)).add(
                    pmr.getResources(SPRING_XML_PATTERN2)).build().toArray(new Resource[] {});
            checkNotNull(resources, "resources is null");
            checkArgument(resources.length > 0, "resources length is 0");
            // 因爲ClassLoader是樹形結構，這裏會找到ModuleClassLoader以及其父類中所有符合規範的spring配置文件，所以這裏需要過濾，只需要Module Jar中的
            return filterURLsIncludedResources(tempFileJarURLs, resources, exclusionConfigeNameList);
        } catch (IOException e) {
            throw new IllegalStateException("Failed to find spring configs from " + tempFileJarURLs, e);
        }
    }

    /**
     * 過濾查找到的spring配置文件資源，只查找tempFileJarURLs中的spring配置文件
     *
     * @param tempFileJarURLs
     * @param resources
     * @param exclusionConfigeNameList
     * @return
     * @throws IOException
     */
    private String[] filterURLsIncludedResources(List<String> tempFileJarURLs, Resource[] resources, List<String> exclusionConfigeNameList)
            throws IOException {
        List<String> configLocations = Lists.newArrayList();
        for (Resource resource : resources) {
            String configLocation = resource.getURL().toString();
            for (String url : tempFileJarURLs) {
                if (isExclusionConfig(configLocation, exclusionConfigeNameList)) {
                    if (LOGGER.isInfoEnabled()) {
                        LOGGER.info("exclusion url: {}", configLocation);
                    }
                    continue;
                }
                if (configLocation.contains(url)) {
                    configLocations.add(configLocation);
                }
            }
        }
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Config locations: {}", configLocations);
        }
        return toArray(configLocations, String.class);
    }

    /**
     * 是否是需要不載入的spring配置
     *
     * @param url
     * @param exclusionConfigeNameList
     * @return
     */
    private boolean isExclusionConfig(String url, List<String> exclusionConfigeNameList) {
        for (String tmp : exclusionConfigeNameList) {
            if (url.contains(tmp)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 去除list中的空白元素，string.startWith("")==true
     *
     * @param moduleConfig
     * @return
     */
    private List<String> getOverridePackages(ModuleConfig moduleConfig) {
        List<String> list = Lists.newArrayList();
        for (String s : moduleConfig.getOverridePackages()) {
            if (!StringUtils.isBlank(s)) {
                list.add(s);
            }
        }
        return list;
    }

    /**
     * Map 轉換爲Properties
     *
     * @param map
     * @return
     */
    private static Properties toProperties(Map<String, Object> map) {
        Properties properties = new Properties();
        for (Entry<String, Object> each : map.entrySet()) {
            if (each.getKey() == null || each.getValue() == null) {
                if (LOGGER.isWarnEnabled()) {
                    LOGGER.warn("Ignore null properties: {}={}", each.getKey(), each.getValue());
                }
                continue;
            }
            if (isBlank(each.getKey())) {
                continue;
            }
            properties.setProperty(each.getKey(), each.getValue().toString());
        }
        return properties;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

}

JarsLink會支持多版本加載，並陸續支持模塊間調用、資源隔離等特性。還在不斷更新和強化。

阿里技術（一）：基於JAVA的模塊化開發框架JarsLink

JarsLink的應用場景

JarsLink的應用場景

實現原理

JarsLink框架類圖

如何使用？

其他特性

最佳實踐

HTTP URL 詳解

springboot 定時器設置，自動推送郵件

容器二：centos7下部署docker環境

容器一：Windows下整一套Linux環境，配置支持

報表的操作（一）

springboot下的websocket服務端和客戶端編寫

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結