Zeppelin 源码分析-Interpreter 相关类（3）

和 Interpreter 直接相关类有以下几个：

Interpreter, InterpreterFactory, RemoteInterpreter, InterpreterGroup, InterpreterSetting。

由于篇幅有限，这里分开介绍。

InterpreterFactor 类

InterpreterFactor 类是 Interpreter 接口的工厂类，各种 Interpreter （其实这个类创建出来的全部都是主进程中的代理）都是从这个类中创造出来的，换句话说，这个类专门为独立的解释器进程创建代理对象，这个类比较关键，因此下面一个一个函数介绍。

该类的所有函数如下：



除了画圈部分，其余函数均需要调用本类的其余函数才能完成指定功能，因此先从三个独立的函数说起。

creatRepl

creatRepl 是创建一个在主进程中创建解释器的函数，但是鉴于目前所有的解释器都在独立的进程中，因此此函数目前来说其实没有什么意义。

connectToRemoteRepl

这个函数是为远程的解释器 JVM 创建本地代理对象，关键代码如下：

LazyOpenInterpreter intp = new LazyOpenInterpreter(
new RemoteInterpreter(property, interpreterSessionKey, className, host, port, localRepoPath,
connectTimeout, maxPoolSize, remoteInterpreterProcessListener, appEventListener,
userName, isUserImpersonate, conf.getInt(ConfVars.ZEPPELIN_INTERPRETER_OUTPUT_LIMIT)));

createRemoteRepl

这个函数除了构建本地代理的时候不需要传送 ip 地址和端口号外，其余基本相似，另外还需要传送一个 interpreterRunnerPath 参数，这个参数指定了启动 Thirf 服务器的脚本的路径，代码比较简单，这里不再赘述。

createInterpreterGroup

这个函数就是根据给定的 id 建立一个 InterpreterGroup ，是在 InterpreterSetting 中的 getInterpreterGroup 方法被唯一调用，新建之后立即加入到该类的 interpreterGroupRef 中，该属性是一个 Map，key 为 InterpreterGroup 的 id，value 为 InterpreterGroup 对象，属性的作用就是根据 id 获取到真实的对象。这个函数在 2 中说过，这里不再赘述。

createInterpretersForNote

这个函数的调用层次如下，可见也是一个相对基础的函数



这个函数只有在 interpreterGroup 中找不到对应的代理解释器的时候才会被调用，因此首先需要做的就是处理正要创建的代理解释器所在的 InterpreterGroup 中的原来的解释器对象正在被移除的情况：

InterpreterGroup interpreterGroup = interpreterSetting.getInterpreterGroup(user, noteId);
synchronized (interpreterGroup) {
long interpreterRemovalWaitStart = System.nanoTime();
long minTimeout = 10L * 1000 * 1000000; // 10 sec
long interpreterRemovalWaitTimeout = Math.max(minTimeout,
conf.getInt(ConfVars.ZEPPELIN_INTERPRETER_CONNECT_TIMEOUT) * 1000000L * 2);
while (interpreterGroup.containsKey(interpreterSessionKey)) {
if (System.nanoTime() - interpreterRemovalWaitStart > interpreterRemovalWaitTimeout) {
throw new InterpreterException("Can not create interpreter");
}
try {
interpreterGroup.wait(1000);
} catch (InterruptedException e) {
logger.debug(e.getMessage(), e);
}
}
}

然后需要做的就是将某组中所有的解释器代理对象创建出来,具体的创建过程如下：之前说过 InterpreterSetting 对象其实就是记录了网页中一组解释器的一些配置信息，因此首先将这些配置信息找出，然后使用这些配置信息一次性创建该组的所有解释器的代理，对于 interpreterInfos 中每个对象，首先判断该解释器是运行在主 JVM 还是运行在独立的 JVM 中，当然目前为止 option.isRemote() 返回总是 true ，然后再判断该解释器是在本地的 JVM 还是在 另一台机器的 JVM，如果在本地调用 createRemoteRepl 方法，否则调用 connectToRemoteRepl 方法，创建完代理对象之后，就需要为代理对象设置 InterpreterGroup，并在该代理对象对应的 InterpreterGroup 中加入该代理对象，其中每组解释器的默认解释器放在 list 的第一个位置。

List<InterpreterInfo> interpreterInfos = interpreterSetting.getInterpreterInfos();
Interpreter interpreter;
for (InterpreterInfo info : interpreterInfos) {
if (option.isRemote()) {
if (option.isExistingProcess()) {
interpreter = connectToRemoteRepl(interpreterSessionKey, info.getClassName(), option.getHost(),option.getPort(), properties, interpreterSetting.getId(), user, option.isUserImpersonate);
} else {
interpreter = createRemoteRepl(path, interpreterSessionKey, info.getClassName(),
properties, interpreterSetting.getId(), user, option.isUserImpersonate(), runner);
}
} else {
interpreter = createRepl(interpreterSetting.getPath(), info.getClassName(), properties);
}
// 省略
}

createOrGetInterpreterList

createInterpretersForNote 只在 createOrGetInterpreterList 方法中会被调用， createOrGetInterpreterList 方法先根据 setting,user,noteId 创建或者获取需要执行的解释器所在的组，之后再检查该组中是否有指定 interpreterSessionKey 的解释器代理列表，如果没有就创建，否则就直接返回，代码如下：

private List<Interpreter> createOrGetInterpreterList(String user, String noteId, InterpreterSetting setting) {
InterpreterGroup interpreterGroup = setting.getInterpreterGroup(user, noteId);
synchronized (interpreterGroup) {
String interpreterSessionKey =
interpreterSettingManager.getInterpreterSessionKey(user, noteId, setting);
if (!interpreterGroup.containsKey(interpreterSessionKey)) {
createInterpretersForNote(setting, user, noteId, interpreterSessionKey);
}
return interpreterGroup.get(interpreterSessionKey);
}
}

getInterpreter(String user, String noteId, String replName)

这个方法才是 InterpreterFactor 类供外界使用的得到一个解释器代理对象的方法。

这个方法首先根据 noteID（即你在网页中创建的 NoteBook 的 ID），得到该 NoteBook 绑定的所有解释器的信息，其中，你建立该 NoteBook 时设置的默认解释器放在 settings 的第一个位置：

List<Interpre
b97e
terSetting> settings = interpreterSettingManager.getInterpreterSettings(noteId);

在 replName 是 null 或者 “” 的时候返回该 NoteBook 的默认解释器，这在程序刚开始初始化的时候调用，就算你没点进你创建的 NoteBook ，他也会调用这块, getDefaultInterpreterSetting 方法其实就是返回 settings[0] 。

if (replName == null || replName.trim().length() == 0) {
// get default settings (first available)
// TODO(jl): Fix it in case of returning null
InterpreterSetting defaultSettings = interpreterSettingManager
.getDefaultInterpreterSetting(settings);
return createOrGetInterpreterList(user, noteId, defaultSettings).get(0);
}

如果 replName 非空，即是 spark,spark.sql 等，则分情况分析：

* 首先解析类似于 spark.sql 这种 replName ，根据组名 group 和 settings 获取需要的解释器的设置信息，getInterpreter(String user, String noteId, InterpreterSetting setting, String name) 方法就是根据 setting 中的 interpreterGroupRef 属性获取到对应 InterpreterGroup 中名字为 name 的代理解释器对象，获取到之后即返回解释器代理对象。

* 如果输入的是 spark,mysql 这种 replName ，首先找到默认解释器组，然后如果这里有的话直接返回，没有的话继续寻找，这时只能把 replName 参数当成解释器组名，从 settings 中寻找第一个组名为 replName 的解释器组，如果这里面依然没有的话，那么就从所有的 setting 里面搜索。

if (replNameSplit.length == 2) {
String group = null;
String name = null;
group = replNameSplit[0];
name = replNameSplit[1];
setting = getInterpreterSettingByGroup(settings, group);
if (null != setting) {
interpreter = getInterpreter(user, noteId, setting, name);
if (null != interpreter) {
return interpreter;
}
}
throw new InterpreterException(replName + " interpreter not found");
} else {
setting = interpreterSettingManager.getDefaultInterpreterSetting(settings);
interpreter = getInterpreter(user, noteId, setting, replName);
if (null != interpreter) {
return interpreter;
}
setting = getInterpreterSettingByGroup(settings, replName);
if (null != setting) {
List<Interpreter> interpreters = createOrGetInterpreterList(user, noteId, setting);
if (null != interpreters) {
return interpreters.get(0);
}
}
for (InterpreterSetting s : settings) {
if (s.getGroup().equals(replName)) {
List<Interpreter> interpreters = createOrGetInterpreterList(user, noteId, s);
if (null != interpreters) {
return interpreters.get(0);
}
}
}
}

这里举个例子说明第二种情况，假设我建了两个解释器，组名都是 spark ，id 分别为 2CPNNU13C 和 2CPNNU13D，然后都是以共享进程启动：





然后我新建一个 NoteBook（ID 为 2CPNNU13E），网页中选的默认解释器是 spark1，绑定的解释器是所有，那么程序刚启动时 id 分别为 2CPNNU13D 的 InterpreterSetting 对象中的 interpreterGroupRef 属性中就会存有这个 id 为 2CPNNU13E 的 NoteBook 对象对应的解释器组对象，这个解释器组对象的 id 为 2CPNNU13E:share_progress ,只有一个元祖，key为 share_progress，value 就是 spark 的五个代理对象。这个函数的第一句话 interpreterSettingManager.getInterpreterSettings(noteId) 返回的是所有解释器设置，其中第一项就是 id 分别为 2CPNNU13D 的 InterpreterSetting 对象。当我在一个 ParaGraph 输入 %spark1 的时候，由于默认解释器就是 spark1，因此会进入第一个分支，而输入 %spark 的时候其实会进入第三个分支因为 settings 中寻找第一个组名为 spark 的解释器组其实返回的是 id 分别为 2CPNNU13D 的 InterpreterSetting 对象。