sofa-ark使用说明及源码解析

一.使用方法及示例

简介:当引入二方依赖包或三方依赖包时,可能出现外部依赖jar包与自己的工程需要依赖的冲突,或者多个二方三方依赖包互相冲突。这时候就需要一个隔离容器对他们进行隔离,其依赖的原理就是jvm认为不同classloader加载的类即使包名类名相同,也认为他们是不同的。sofa-ark将需要隔离的jar包打成plugin,对每个plugin都用独立的classloader去加载。

(温馨提示:若对sofa-ark不太了解的,最好先去看看官方文档,简单了解下)

使用的基本步骤:

  1. 在会发生冲突的jar包的POM文件加入sofa-ark提供的maven插件,将其打成特定格式的jar包(plugin)。
  2. 在外部工程按照约定引入jar包。如果外部工程想打包成可执行的jar(fat-jar),还需要加入特定的maven插件。
  3. 直接运行。

名词解释:

  • Ark Container: Ark 容器,是组件 SOFAArk 的核心,运行 Ark 包时,Ark 容器会最先启动,负责应用运行时的管理,主要包括构建 Ark Plugin 和 Ark Biz 的类导入导出关系表、启动并初始化 Ark Plugin 和 Ark Biz、管理 Ark Plugin 服务的发布和引用等等。
  • Biz:即业务工程,该工程引用一个或多个外部jar包。
  • plugin:会发生冲突的外部依赖jar包经过提供的Maven插件打成的fat-jar包。运行时,由独立的类加载器加载,因此有隔离需求的 Jar 包建议打包成 Ark Plugin 供应用依赖。

1.0 sofa-ark原理

在sofa-ark中,使用container容器启动外部工程(Biz)和冲突jar包(plugin),sofa-ark的plugin maven插件将冲突的jar包打包成为plugin,外部工程只能引用plugin exported出来的类,并且这个类是由独立的PluginClassLoader加载的,从而解决了jar包冲突的问题。

image-20180724204016919

1.1 冲突示例

jar冲突

1.2 安装sofa-ark

sofa-ark官网 将整个工程下载下来,在最外层pom.xml所在路径执行mvn packagemvn install 将sofa-ark依赖jar包安装到本地。

1.3 创建基础依赖Jar包(冲突的包)

自己创建myjar工程,先后正常打包两个版本安装到本地maven仓库。

如:v1版本

image-20180724185922039

v2版本

image-20180724190102751

1.4 创建service包(plugin)

创建如图所示两个工程:

myJarservice-v1myJarservice-v2的pom中分别引用之前写的两个基础依赖jar包。然后在MyJarService1MyJarService2中分别引用对应版本的myjar包里的方法。

如MyJarService1.java:

image-20180724190836319

MyJarService2.java

image-20180724191026890

注意:这里两个Service引用的是不同版本的myjar。

接下来需要对两个工程打包,和平常打包不一样的是需要加入sofa-ark-plugin的maven插件。两个工程下的pom.xml都要加入:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<build>
<plugins>
<plugin>
<groupId>com.alipay.sofa</groupId>
<artifactId>sofa-ark-plugin-maven-plugin</artifactId>
<version>0.4.0-SNAPSHOT</version>
<executions>
<execution>
<id>default-cli</id>
<goals>
<goal>ark-plugin</goal>
</goals>

<configuration>
<!-- configure exported class -->
<exported>
<!-- configure class-level exported class -->
<classes>

<class>com.netease.sofaservice.MyJar1Service</class>
</classes>
</exported>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>

exported标签里写出要对外提供的方法,外部要引用的所有方法都必须写在这里,可以以类(<classes>)为单位和包(packages)为单位导出。

到parent工程路径下mvn packagemvn install 即可。

1.5 外部工程引用(Biz)

新建一个工程,在pom.xml引入以下依赖:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<dependencies>
<dependency>
<groupId>com.alipay.sofa</groupId>
<artifactId>sofa-ark-support-starter</artifactId>
<version>0.4.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.netease</groupId>
<artifactId>myjarservice-v1</artifactId>
<classifier>ark-plugin</classifier>
<version>1.0</version>
</dependency>

<dependency>
<groupId>com.netease</groupId>
<artifactId>myjarservice-v2</artifactId>
<classifier>ark-plugin</classifier>
<version>1.0</version>
</dependency>

<dependency>
<groupId>com.netease</groupId>
<artifactId>myjarservice-v1</artifactId>
<version>1.0</version>
<scope>provided</scope>
</dependency>

<dependency>
<groupId>com.netease</groupId>
<artifactId>myjarservice-v2</artifactId>
<version>1.0</version>
<scope>provided</scope>
</dependency>
</dependencies>

注意要添加<classifier>标签,因为IDE识别不了ark-plugin的jar包,所以需要再引入一个范围为provided的jar包。

然后pom.xml还要添加maven插件:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<build>
<plugins>
<plugin>
<groupId>com.alipay.sofa</groupId>
<artifactId>sofa-ark-maven-plugin</artifactId>
<version>0.4.0-SNAPSHOT</version>
<executions>
<execution>
<id>default-cli</id>

<!--goal executed to generate executable-ark-jar -->
<goals>
<goal>repackage</goal>
</goals>
<configuration>
<!--specify destination where executable-ark-jar will be saved, default saved to ${project.build.directory}-->
<outputDirectory>./</outputDirectory>

<!--default none-->
<arkClassifier>executable-ark</arkClassifier>
</configuration>
</execution>
</executions>
</plugin>

</plugins>
</build>

然后再随便写个类引入两个版本service包的类使用即可,在main函数入口处需要加上一句:

SofaArkBootstrap.launch(args);

image-20180724203423465

可以看到打印结果:

image-20180724203546696

二.sofa-ark-plugin-maven-plugin插件原理分析

2.1 查看plugin jar包内容

使用sofa-ark-plugin-maven-plugin Maven插件即可将jar包打包成可在container中隔离加载的jar包(如myjarservice-v1-1.0-ark-plugin.jarr和myjarservice-v2-1.0-ark-plugin.jar)。进入本地maven仓库myJarservice-v1工程所在位置,可以看到maven打了两个包:一个是maven自带的插件打的普通的包:myjarservice-v1-1.0.jar ,另一个是sofa-ark提供的maven插件打的包myjarservice-v1-1.0-ark-plugin.jar,打开myjarservice-v1-1.0-ark-plugin.jar 可以看到如下目录:

相关目录说明:

  • com/alipay/sofa/ark/plugin/mark :标记文件,标记该 Jar 包是 sofa-ark-plugin-maven-plugin 打包生成的 Ark Plugin 文件。
  • META-INF/MANIFEST.MF :记录插件元信息,其中包含要导出的和导入的类
1
2
3
4
5
6
7
8
9
10
11
12
13
Manifest-Version: 1.0
groupId: com.netease
artifactId: myjarservice-v1
version: 1.0
priority: 100
pluginName: myjarservice-v1
activator:
import-packages:
import-classes:
import-resources:
export-packages:
export-classes: com.netease.sofaservice.MyJar1Service
export-resources:
  • conf/export.index :插件导出类索引文件;为了避免在运行时计算MANIFEST.MFexport-packages 下面具体的导出类,在打包生成 Ark Plugin 时,会生成插件所有导出类的索引文件,缩短 Ark Container 解析配置时间。
  • lib/ : lib 目录存放插件工程依赖的普通 Jar 包,一般包含插件需要和其他插件或者业务有隔离需求的 Jar 包;插件配置的导出类都包含在这些 Jar 包中。

2.2 分析sofa-ark-plugin-maven-plugin源码

进入下载的sofa-ark源码中的ark-plugin-maven-plugin工程,可以看到ArkPluginMojo继承了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Mojo(name = "ark-plugin", defaultPhase = LifecyclePhase.PACKAGE, requiresDependencyResolution = ResolutionScope.RUNTIME)
public class ArkPluginMojo extends AbstractMojo {
@Parameter(defaultValue = "${project.artifactId}")
public String pluginName;

@Parameter(defaultValue = "100", property = "sofa.ark.plugin.priority")
protected Integer priority;

@Parameter
protected String activator;

@Parameter
protected ExportConfig exported;

@Parameter
protected ImportConfig imported;
...

@Mojo 就是一个 goal,可以绑定到某个 phase (这里是package)执行,@Parameter 是从外面传进来的参数,可以直接获取xml中配置的参数。Maven插件标准要求必须重写execute()方法,插件执行时主要就是执行execute()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
public void execute() throws MojoExecutionException
{
Archiver archiver;//zip归档
archiver = getArchiver();
outputDirectory.mkdirs();
String fileName = getFileName();
File destination = new File(outputDirectory, fileName);
archiver.setDestFile(destination);
Set<Artifact> artifacts = project.getArtifacts();
artifacts = filterExcludeArtifacts(artifacts);
Set<Artifact> conflictArtifacts = filterConflictArtifacts(artifacts);
addArkPluginArtifact(archiver, artifacts, conflictArtifacts);
addArkPluginConfig(archiver);
archiver.createArchive();
projectHelper.attachArtifact(project, destination, getClassifier());
}

这里的将execute()方法进行了精简,这个方法主要做了一下几件事情:

  1. 建立一个zip格式的归档,用来保存引入的jar包和其他文件,建立输出路径。
  2. 获取引入的所有依赖(Artifacts),并且将需要exclude的包排除出去。
  3. 将所有依赖写入zip归档中的lib目录下

image-20180725153520102

  1. 将配置信息写入zip归档中,包括之前提到的export.indexMANIFEST.MFmarkimage-20180725153659204

经过上述步骤后即把依赖的dependence和配置文件都写入zip中了,然后将其转换为jar后缀即可。

三. Sofa-ark原理分析

3.1 初始化ArkContainer

前面讲解了plugin插件如何工作,这节讲述外部工程是如何引用运用plugin插件打包而成的plugin jar包来解决隔离冲突的。可以从main方法加入的SofaArkBootstrap.launch(args)进行单步跟踪,这句代码主要是将Container启动起来,然后让Container去加载Plugin和Biz。在launch方法里通过反射调用了SofaArkBootstrapremain方法,在remain方法里主要干了两件事:

1
2
3
4
5
private static void remain(String[] args) throws Exception {// NOPMD
URL[] urls = getURLClassPath();
new ClasspathLauncher(new ClassPathArchive(urls)).launch(args, getClasspath(urls),
entryMethod.getMethod());
}
  1. 获取classpath下的所有jar包,包括jdk自己的jar包和maven引入的jar包。
  2. 将所有依赖jar包和自己写的启动类及其main函数以url的形式传入ClasspathLauncherClasspathLauncher反射调用ArkContainermain方法,并且使用ContainerClassLoader加载ArkContainer。至此,就开始启动ArkContainer了。

3.2 启动ArkContainer

接着就运行到了ArkContainer中的main方法,传入的参数args即之前ClasspathLauncher传入的url

1
2
3
4
5
6
7
8
9
public static Object main(String[] args) throws ArkException
{
//使用LaunchCommand将传入的参数按类型分类
LaunchCommand launchCommand = LaunchCommand.parse(args[ARK_COMMAND_ARG_INDEX], Arrays.copyOfRange(args, MINIMUM_ARGS_SIZE, args.length));
//ClassPathArchive将传入依赖的Jar包分类,并提供获得plugin和biz的filter方法
ClassPathArchive classPathArchive = new ClassPathArchive(launchCommand.getEntryClassName(), launchCommand.getEntryMethodName(), launchCommand.getEntryMethodDescriptor(), launchCommand.getClasspath());
return new ArkContainer(classPathArchive, launchCommand).start();
}
}

这个方法主要做了一下几件事:

  1. 使用LaunchCommand将传入的参数分类,将classpath的url和自己写的启动类的main方法提取出来image-20180726151249913
  2. LaunchCommand传入ArkContainer并启动:

ArkContainer.start()中:

1
2
3
4
5
6
7
8
9
10
public Object start() throws ArkException
{
if (started.compareAndSet(false, true))
{
arkServiceContainer.start();
Pipeline pipeline = arkServiceContainer.getService(Pipeline.class);
pipeline.process(pipelineContext);
}
return this;
}

arkServiceContainer中包含了一些Container启动前需要运行的Service,这些Service被封装到一个个的PipelineStage中,这些PipelineStage又被封装成List到一个pipeline中。主要包含这么几个PipelineStage,依次执行:

  1. HandleArchiveStage筛选所有第三方jar包中含有mark标记的plugin jar,说明这些jar是sofa ark maven插件打包成的需要隔离的jar。从jar中的export.index中提取需要隔离的类,把他们加入一个PluginList中,并给每个plugin,分配一个独立的PluginClassLoader。同时以同样的操作给Biz也分配一个BizClassLoader
  2. DeployPluginStage 创建一个map,key是需要隔离的类,value是这个加载这个类使用的PluginClassLoader实例。
  3. DeployBizStage 使用BizClassLoader反射调用Biz的main方法。

至此,Container就启动完了。后面再调用需要隔离的类时,由于启动Biz的线程已经被换成了BizClassLoader,在loadClass时BizClassLoader会首先看看在DeployPluginStage创建的Map中是否有PluginClassLoader能加载这个类,如果能就委托PluginClassLoader加载。就实现了不同类使用不同的类加载器加载。