io.druid.guice

Class LifecycleModule

java.lang.Object

io.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, Annotation annotation) Registers a class/annotation combination 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, it is not clear which is actually the best approach. This is more explicit, but eager bindings inside of modules is less error-prone.

Parameters:

clazz, - the class to instantiate

register

public static void register(com.google.inject.Binder binder,
                            Class<?> clazz,
                            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, it is not clear which is actually the best approach. This is more explicit, but eager bindings inside of modules is less error-prone.

Parameters:

clazz, - the class to instantiate

annotation - The annotation instance to register with Guice, usually a Named annotation

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, it is not clear which is actually the best approach. This is more explicit, but eager bindings inside of modules is less error-prone.

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, it is not clear which is actually the best approach. This is more explicit, but eager bindings inside of modules is less error-prone.

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)