org.apache.druid.guice

Class LifecycleModule

java.lang.Object

org.apache.druid.guice.LifecycleModule

All Implemented Interfaces:

com.google.inject.Module

public class LifecycleModule
extends Object
implements com.google.inject.Module

A Module to add lifecycle management to the injector. DruidGuiceExtensions must also be included.

Constructor Summary

Constructors

Constructor and Description
LifecycleModule()

Method Summary

Modifier and Type	Method and Description
void	configure(com.google.inject.Binder binder)
Lifecycle	getLifecycle(com.google.inject.Injector injector)
static void	register(com.google.inject.Binder binder, Class<?> clazz) Registers a class to instantiate eagerly.
static void	register(com.google.inject.Binder binder, Class<?> clazz, Class<? extends Annotation> annotation) Registers a class/annotation combination to instantiate eagerly.
static void	registerKey(com.google.inject.Binder binder, com.google.inject.Key<?> key) Registers a key to instantiate eagerly.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LifecycleModule

public LifecycleModule()

Method Detail

register

public static void register(com.google.inject.Binder binder,
                            Class<?> clazz)

Registers a class to instantiate eagerly. Classes mentioned here will be pulled out of the injector with an injector.getInstance() call when the lifecycle is created. Eagerly loaded classes will *not* be automatically added to the Lifecycle unless they are bound to the proper scope. That is, they are generally eagerly loaded because the loading operation will produce some beneficial side-effect even if nothing actually directly depends on the instance. This mechanism exists to allow the Lifecycle to be the primary entry point from the injector, not to auto-register things with the Lifecycle. It is also possible to just bind things eagerly with Guice, but that is almost never the correct option. Guice eager bindings are pre-instantiated before the object graph is materialized and injected, meaning that objects are not actually instantiated in dependency order. Registering with the LifecyceModule, on the other hand, will instantiate the objects after the normal object graph has already been instantiated, meaning that objects will be created in dependency order and this will only actually instantiate something that wasn't actually depended upon.

Parameters:

clazz - the class to instantiate

register

public static void register(com.google.inject.Binder binder,
                            Class<?> clazz,
                            Class<? extends Annotation> annotation)

Registers a class/annotation combination to instantiate eagerly. Classes mentioned here will be pulled out of the injector with an injector.getInstance() call when the lifecycle is created. Eagerly loaded classes will *not* be automatically added to the Lifecycle unless they are bound to the proper scope. That is, they are generally eagerly loaded because the loading operation will produce some beneficial side-effect even if nothing actually directly depends on the instance. This mechanism exists to allow the Lifecycle to be the primary entry point from the injector, not to auto-register things with the Lifecycle. It is also possible to just bind things eagerly with Guice, but that is almost never the correct option. Guice eager bindings are pre-instantiated before the object graph is materialized and injected, meaning that objects are not actually instantiated in dependency order. Registering with the LifecyceModule, on the other hand, will instantiate the objects after the normal object graph has already been instantiated, meaning that objects will be created in dependency order and this will only actually instantiate something that wasn't actually dependend upon.

Parameters:

clazz - the class to instantiate

annotation - The annotation class to register with Guice

registerKey

public static void registerKey(com.google.inject.Binder binder,
                               com.google.inject.Key<?> key)

Registers a key to instantiate eagerly. Keys mentioned here will be pulled out of the injector with an injector.getInstance() call when the lifecycle is created. Eagerly loaded classes will *not* be automatically added to the Lifecycle unless they are bound to the proper scope. That is, they are generally eagerly loaded because the loading operation will produce some beneficial side-effect even if nothing actually directly depends on the instance. This mechanism exists to allow the Lifecycle to be the primary entry point from the injector, not to auto-register things with the Lifecycle. It is also possible to just bind things eagerly with Guice, but that is almost never the correct option. Guice eager bindings are pre-instantiated before the object graph is materialized and injected, meaning that objects are not actually instantiated in dependency order. Registering with the LifecyceModule, on the other hand, will instantiate the objects after the normal object graph has already been instantiated, meaning that objects will be created in dependency order and this will only actually instantiate something that wasn't actually dependend upon.

Parameters:

key - The key to use in finding the DruidNode instance

configure

public void configure(com.google.inject.Binder binder)

Specified by:

configure in interface com.google.inject.Module

getLifecycle

@Provides
public Lifecycle getLifecycle(com.google.inject.Injector injector)