elasticsearch通过guice注入Node组装启动过程

public InternalNode(Settings preparedSettings, boolean loadConfigSettings) throws ElasticsearchException {

         final Settings pSettings = settingsBuilder().put(preparedSettings)

                 .put(Client.CLIENT_TYPE_SETTING, CLIENT_TYPE).build();

         Tuple<Settings, Environment> tuple = InternalSettingsPreparer.prepareSettings(pSettings, loadConfigSettings);

         tuple = new Tuple<>(TribeService.processSettings(tuple.v1()), tuple.v2());

         logger.info( "initializing ..." );

        //启动插件service，加载并启动插件

         this .pluginsService = new PluginsService(tuple.v1(), tuple.v2());

         this .settings = pluginsService.updatedSettings();

         // create the environment based on the finalized (processed) view of the settings

         this .environment = new Environment( this .settings());

         CompressorFactory.configure(settings);

        //配置node环境

         final NodeEnvironment nodeEnvironment;

         try {

             nodeEnvironment = new NodeEnvironment( this .settings, this .environment);

         } catch (IOException ex) {

             throw new ElasticsearchIllegalStateException( "Failed to created node environment" , ex);

         }

         boolean success = false ;

         try {

        //加载各个模块

             ModulesBuilder modules = new ModulesBuilder();

             modules.add( new Version.Module(version));

             modules.add( new CacheRecyclerModule(settings));

             modules.add( new PageCacheRecyclerModule(settings));

             modules.add( new CircuitBreakerModule(settings));

             modules.add( new BigArraysModule(settings));

             modules.add( new PluginsModule(settings, pluginsService));

             modules.add( new SettingsModule(settings));

             modules.add( new NodeModule( this ));

             modules.add( new NetworkModule());

             modules.add( new ScriptModule(settings));

             modules.add( new EnvironmentModule(environment));

……

}

public Node start() {

         if (!lifecycle.moveToStarted()) {

             return this ;

         } // hack around dependency injection problem (for now...)

         injector.getInstance(Discovery. class ).setAllocationService(injector.getInstance(AllocationService. class ));

         for (Class<? extends LifecycleComponent> plugin : pluginsService.services()) {

             injector.getInstance(plugin).start();

         }

　　　　 //通过guice获取各个模块的service接口并启动

         injector.getInstance(MappingUpdatedAction. class ).start();

         injector.getInstance(IndicesService. class ).start();

         injector.getInstance(IndexingMemoryController. class ).start();

         injector.getInstance(IndicesClusterStateService. class ).start();

         injector.getInstance(IndicesTTLService. class ).start();

         injector.getInstance(RiversManager. class ).start();

         injector.getInstance(SnapshotsService. class ).start();

         injector.getInstance(TransportService. class ).start();

……

}

public PluginsService(Settings settings, Environment environment) {

         super (settings);

         this .environment = environment;

         ……

         ImmutableList.Builder<Tuple<PluginInfo, Plugin>> tupleBuilder = ImmutableList.builder();

         // 加载配置插件

         String[] defaultPluginsClasses = settings.getAsArray( "plugin.types" );

         for (String pluginClass : defaultPluginsClasses) {

             Plugin plugin = loadPlugin(pluginClass, settings);

             PluginInfo pluginInfo = new PluginInfo(plugin.name(), plugin.description(), hasSite(plugin.name()), true , PluginInfo.VERSION_NOT_AVAILABLE);

             if (logger.isTraceEnabled()) {

                 logger.trace( "plugin loaded from settings [{}]" , pluginInfo);

             }

             tupleBuilder.add( new Tuple<>(pluginInfo, plugin));

         }

         // 查找classpatch中的所有插件

         loadPluginsIntoClassLoader();

         if (loadClasspathPlugins) {

             tupleBuilder.addAll(loadPluginsFromClasspath(settings));

         }

         this .plugins = tupleBuilder.build();

         // We need to build a List of jvm and site plugins for checking mandatory plugins

         Map<String, Plugin> jvmPlugins = Maps.newHashMap();

         List<String> sitePlugins = Lists.newArrayList();

         for (Tuple<PluginInfo, Plugin> tuple : this .plugins) {

             jvmPlugins.put(tuple.v2().name(), tuple.v2());

             if (tuple.v1().isSite()) {

                 sitePlugins.add(tuple.v1().getName());

             }

         }

         // 加载site插件

         ImmutableList<Tuple<PluginInfo, Plugin>> tuples = loadSitePlugins();

         for (Tuple<PluginInfo, Plugin> tuple : tuples) {

             sitePlugins.add(tuple.v1().getName());

         }

         // 检验代理插件，如果有加载不成功的插件就抛出异常，停止node启动。

         String[] mandatoryPlugins = settings.getAsArray( "plugin.mandatory" , null );

         if (mandatoryPlugins != null ) {

             Set<String> missingPlugins = Sets.newHashSet();

             for (String mandatoryPlugin : mandatoryPlugins) {

                 if (!jvmPlugins.containsKey(mandatoryPlugin) && !sitePlugins.contains(mandatoryPlugin) && !missingPlugins.contains(mandatoryPlugin)) {

                     missingPlugins.add(mandatoryPlugin);

                 }

             }

             if (!missingPlugins.isEmpty()) {

                 throw new ElasticsearchException( "Missing mandatory plugins [" + Strings.collectionToDelimitedString(missingPlugins, ", " ) + "]" );

             }

         }

……

}