Elasticsearch 中的 Guice

前言

Elasticsearch 源代碼中使用了Guice框架進行依賴注入. 爲了方便閱讀源碼, 此處我先經過模仿ES guice的使用方式簡單寫了一個基本Demo 方便理解, 以後再來理一下ES的Guice使用. 編寫的測試類原理圖以下:php

ES Guice Demo

總共有兩個Module,一個是ToolModule,用於綁定IAnimal接口、ITool接口以及Map對象. 另外一個是HumanModule 用於綁定Person對象。java

其中Person的構造函數經過 @Inject 註解注入其餘實例node

gradle 須要引入的 Jar 包git

compile group'com.google.inject.extensions', name: 'guice-multibindings', version: '4.2.0'
compile group'com.google.inject', name: 'guice', version: '4.2.0'

一、Demo

iTool接口與實現類

public interface ITool {
    public void doWork();
}
import com.whirly.guice.example.ITool;

public class IToolImpl implements ITool {
    @Override
    public void doWork() {
        System.out.println("use tool to work");
    }
}

IAnimal 接口與實現類

public interface IAnimal {
    void work();
}
public class IAnimalImpl implements IAnimal {
    @Override
    public void work() {
        System.out.println("animals can also do work");
    }
}

ToolModule的實現, 它綁了三個實例

public class ToolModule extends AbstractModule {

    @Override
    protected void configure() {
        //此處注入的實例能夠注入到其餘類的構造函數中, 只要那個類使用@Inject進行注入便可
        bind(IAnimal.class).to(IAnimalImpl.class);
        bind(ITool.class).to(IToolImpl.class);

        // 注入Map實例
        MapBinder<StringString> mapBinder = MapBinder.newMapBinder(binder(), String.classString.class);
        mapBinder.addBinding("test1").toInstance("test1");
        mapBinder.addBinding("test2").toInstance("test2");
    }
}

bind(IAnimal.class).to(IAnimalImpl.class);bind(ITool.class).to(IToolImpl.class);  是將接口與其具體實現綁定起來github

MapBinder<String,String> mapBinder =MapBinder.newMapBinder(binder(), String.class, String.class);mapBinder.addBinding("test1").toInstance("test1");mapBinder.addBinding("test2").toInstance("test2"); 則是完成Map的綁定.sql

後面來看看Person類和HumanModule微信

Person 類

public class Person {

    private IAnimal iAnimal;
    private ITool iTool;
    private Map<String, String> map;

    @Inject
    public Person(IAnimal iAnimal, ITool iTool, Map<String, String> map) 
{
        this.iAnimal = iAnimal;
        this.iTool = iTool;
        this.map = map;
    }

    public void startwork() {
        iTool.doWork();
        iAnimal.work();
        for (Map.Entry entry : map.entrySet()) {
            System.out.println("注入的map 是 " + entry.getKey() + " value " + entry.getValue());
        }
    }
}

Person 類中由 IAnimalIToolMap<String, String> 這三個接口定義的變量,對象將經過 @Inject 從構造方法中注入進來app

public class HumanModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Person.class).asEagerSingleton();
    }
}

Person類的構造函數是經過注入的方式,注入對象實例的框架

最後 CustomModuleBuilder 進行統一管理全部的Module,實例化全部Module中的對象. 完成依賴注入。dom

這裏的CustomModuleBuilder是修改自Elasticsearch中的ModulesBuilder,其原理是同樣的。

就是一個迭代器,內部封裝的是Module集合, 統一管理全部的Module

CustomModuleBuilder 統一管理 Module

public class CustomModuleBuilder implements Iterable<Module{

    private final List<Module> modules = new ArrayList<>();

    public CustomModuleBuilder add(Module... newModules) {
        for (Module module : newModules) {
            modules.add(module);
        }
        return this;
    }

    @Override
    public Iterator<Module> iterator() {
        return modules.iterator();
    }

    public Injector createInjector() {
        Injector injector = Guice.createInjector(modules);
        return injector;
    }
}

這樣就能夠從Main方法是如何進行使用的

Main 方法

public class Main {
    public static void main(String[] args{
        CustomModuleBuilder moduleBuilder = new CustomModuleBuilder();
        moduleBuilder.add(new ToolModule());
        moduleBuilder.add(new HumanModule());
        Injector injector = moduleBuilder.createInjector();
        Person person = injector.getInstance(Person.class);
        person.startwork();
    }
}

運行結果

use tool to work
animals can also do work
注入的map 是 test1 value test1
注入的map 是 test2 value test2

經過CustomModuleBuilder 的createInjector獲取Injector 對象, 根據Injector 對象取相應的具體實例對象.

二、ES 中Guice的使用

ES中TransportClient初始化時的Guice的使用是這樣的, 以下圖所示

ES中TransportClient初始化時的Guice的使用(ES版本不是6.3.2)

TransportClient的初始化代碼

Elasticsearch 6.3.2

private static ClientTemplate buildTemplate(Settings providedSettings, Settings defaultSettings,
                                            Collection<Class<? extends Plugin>> pluginsHostFailureListener failureListner{
    // 省略 ...
    try {
        // 省略 ...

        // 建立一個迭代器, 而後將各個Module經過add方法加入進去
        ModulesBuilder modules = new ModulesBuilder();
        // plugin modules must be added here, before others or we can get crazy injection errors...
        for (Module pluginModule : pluginsService.createGuiceModules()) {
            modules.add(pluginModule);
        }
        modules.add(b -> b.bind(ThreadPool.class).toInstance(threadPool));
        ActionModule actionModule = new ActionModule(true, settings, null, settingsModule.getIndexScopedSettings(),
                settingsModule.getClusterSettings(), settingsModule.getSettingsFilter(), threadPool,
                pluginsService.filterPlugins(ActionPlugin.class), nullnullnull);
        modules.add(actionModule);

        CircuitBreakerService circuitBreakerService = Node.createCircuitBreakerService(settingsModule.getSettings(),
            settingsModule.getClusterSettings());
        resourcesToClose.add(circuitBreakerService);
        PageCacheRecycler pageCacheRecycler = new PageCacheRecycler(settings);
        BigArrays bigArrays = new BigArrays(pageCacheRecycler, circuitBreakerService);
        resourcesToClose.add(bigArrays);
        modules.add(settingsModule);

        NetworkModule networkModule = new NetworkModule(settings, true, pluginsService.filterPlugins(NetworkPlugin.class), threadPool,
            bigArrays, pageCacheRecycler, circuitBreakerService, namedWriteableRegistry, xContentRegistry, networkService, null);
        final Transport transport = networkModule.getTransportSupplier().get();
        final TransportService transportService = new TransportService(settings, transport, threadPool,
            networkModule.getTransportInterceptor(),
            boundTransportAddress -> DiscoveryNode.createLocal(settings, new TransportAddress(TransportAddress.META_ADDRESS, 0),
                UUIDs.randomBase64UUID()), null, Collections.emptySet());
        modules.add((b -> {
            b.bind(BigArrays.class).toInstance(bigArrays);
            b.bind(PluginsService.class).toInstance(pluginsService);
            b.bind(CircuitBreakerService.class).toInstance(circuitBreakerService);
            b.bind(NamedWriteableRegistry.class).toInstance(namedWriteableRegistry);
            b.bind(Transport.class).toInstance(transport);
            b.bind(TransportService.class).toInstance(transportService);
            b.bind(NetworkService.class).toInstance(networkService);
        }));

        // 注入全部module下的實例
        Injector injector = modules.createInjector();
        final TransportClientNodesService nodesService =
            new TransportClientNodesService(settings, transportService, threadPool, failureListner == null
                ? (t, e) -> {} : failureListner);

        // construct the list of client actions
        final List<ActionPlugin> actionPlugins = pluginsService.filterPlugins(ActionPlugin.class);
        final List<GenericAction> clientActions =
                actionPlugins.stream().flatMap(p -> p.getClientActions().stream()).collect(Collectors.toList());
        // add all the base actions
        final List<? extends GenericAction<??>> baseActions =
                actionModule.getActions().values().stream().map(ActionPlugin.ActionHandler::getAction).collect(Collectors.toList());
        clientActions.addAll(baseActions);
        final TransportProxyClient proxy = new TransportProxyClient(settings, transportService, nodesService, clientActions);

        List<LifecycleComponent> pluginLifecycleComponents = new ArrayList<>(pluginsService.getGuiceServiceClasses().stream()
            .map(injector::getInstance).collect(Collectors.toList()));
        resourcesToClose.addAll(pluginLifecycleComponents);

        // 啓動服務
        transportService.start();
        transportService.acceptIncomingRequests();

        ClientTemplate transportClient = new ClientTemplate(injector, pluginLifecycleComponents, nodesService, proxy, namedWriteableRegistry);
        resourcesToClose.clear();
        return transportClient;
    } finally {
        IOUtils.closeWhileHandlingException(resourcesToClose);
    }
}

能夠看到確實是先通 過ModulesBuilder modules = new ModulesBuilder() 建立一個迭代器, 而後將各個Module經過add方法加入進去, 最後經過 Injector injector = modules.createInjector(); 建立Injector對象, 以後即可根據Injector對象去獲取實例了.

各個Module會綁定本身所須要的實例, 這裏以 SettingsModule 舉例:

public class SettingsModule extends AbstractModule {
    private final Settings settings;
    private final Set<String> settingsFilterPattern = new HashSet<>();
    private final Map<String, Setting<?>> nodeSettings = new HashMap<>();
    private final Map<String, Setting<?>> indexSettings = new HashMap<>();
    private final Logger logger;
    private final IndexScopedSettings indexScopedSettings;
    private final ClusterSettings clusterSettings;
    private final SettingsFilter settingsFilter;

    public SettingsModule(Settings settings, Setting<?>... additionalSettings) {
        this(settings, Arrays.asList(additionalSettings), Collections.emptyList());
    }

    @Override
    public void configure(Binder binder) {
        binder.bind(Settings.class).toInstance(settings);
        binder.bind(SettingsFilter.class).toInstance(settingsFilter);
        binder.bind(ClusterSettings.class).toInstance(clusterSettings);
        binder.bind(IndexScopedSettings.class).toInstance(indexScopedSettings);
    }

    //...
}

能夠看到它綁定了四個,分別是 Settings.class,SettingsFilter.class,ClusterSettings.class,IndexScopedSettings.class

它們的實例對象均可以經過Injector來獲取

小結

示例代碼可在 https://github.com/whirlys/elastic-example/tree/master/guice 處下載

參考:  
kason_zhang Elasticsearch Guice 的使用


更多內容請訪問個人我的博客:http://laijianfeng.org/

打開微信掃一掃,關注【小旋鋒】微信公衆號,及時接收博文推送

小旋鋒的微信公衆號


本文分享自微信公衆號 - 小旋鋒(whirlysBigData)。
若有侵權,請聯繫 support@oschina.cn 刪除。
本文參與「OSC源創計劃」,歡迎正在閱讀的你也加入,一塊兒分享。

相關文章
相關標籤/搜索