GuiceBundle.Builder (dropwizard-guicey 5.0.0-rc.1 API)

java.lang.Object
- ru.vyarus.dropwizard.guice.GuiceBundle.Builder<T>

Type Parameters:

T - configuration type

Enclosing class:

GuiceBundle<T extends io.dropwizard.Configuration>
```
public static class GuiceBundle.Builder<T extends io.dropwizard.Configuration>
extends java.lang.Object
```
Builder encapsulates bundle configuration options.

Constructor Summary

Constructors
Constructor and Description

Builder()

Constructors
Constructor and Description
`Builder()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`GuiceBundle<T>`	`build()`
`GuiceBundle<T>`	`build(com.google.inject.Stage stage)`
`GuiceBundle.Builder<T>`	`bundleLookup(GuiceyBundleLookup bundleLookup)` Configure custom `GuiceyBundleLookup`.
`GuiceBundle.Builder<T>`	`bundles(GuiceyBundle... bundles)` Guicey bundles are mainly useful for extensions (to group installers and extensions installation without auto scan).
`GuiceBundle.Builder<T>`	`disable(java.util.function.Predicate<ItemInfo>... predicates)` Disable items using disable predicate: all matched items will be disabled.
`GuiceBundle.Builder<T>`	`disableBundleLookup()` Disables default bundle lookup.
`GuiceBundle.Builder<T>`	`disableBundles(java.lang.Class<? extends GuiceyBundle>... bundles)` Bundles disable is mostly useful for testing.
`GuiceBundle.Builder<T>`	`disableDropwizardBundles(java.lang.Class<? extends io.dropwizard.ConfiguredBundle>... bundles)` Dropwizard bundles disable is mostly useful for testing.
`GuiceBundle.Builder<T>`	`disableExtensions(java.lang.Class<?>... extensions)` Extensions disable is mostly useful for testing.
`GuiceBundle.Builder<T>`	`disableInstallers(java.lang.Class<? extends FeatureInstaller>... installers)` Disabling installer will lead to avoiding all relative installed extensions.
`GuiceBundle.Builder<T>`	`disableModules(java.lang.Class<? extends com.google.inject.Module>... modules)` Modules disable is mostly useful for testing.
`GuiceBundle.Builder<T>`	`dropwizardBundles(io.dropwizard.ConfiguredBundle... bundles)` Dropwizard bundles registration.
`GuiceBundle.Builder<T>`	`duplicateConfigDetector(DuplicateConfigDetector detector)` Duplicate configuration detector decides what configuration items, registered as instance (guicey bundle, guice module) to consider duplicate (and so avoid duplicates installation).
`GuiceBundle.Builder<T>`	`enableAutoConfig(java.lang.String... basePackages)` Enables auto scan feature.
`GuiceBundle.Builder<T>`	`extensions(java.lang.Class<?>... extensionClasses)` Beans could be registered automatically when auto scan enabled, but if you don't want to use it, you can register beans manually.
`GuiceBundle.Builder<T>`	`hookAlias(java.lang.String name, java.lang.Class<? extends GuiceyConfigurationHook> hook)` Guicey hooks (`GuiceyConfigurationHook`) may be loaded with system property "guicey.hooks".
`GuiceBundle.Builder<T>`	`injectorFactory(InjectorFactory injectorFactory)` Configures custom `InjectorFactory`.
`GuiceBundle.Builder<T>`	`installers(java.lang.Class<? extends FeatureInstaller>... installers)` Feature installers registered automatically when auto scan enabled, but if you don't want to use it, you can register installers manually (note: without auto scan default installers will not be registered).
`GuiceBundle.Builder<T>`	`listen(GuiceyLifecycleListener... listeners)` Guicey broadcast a lot of events in order to indicate lifecycle phases (`GuiceyLifecycle`).
`GuiceBundle.Builder<T>`	`modules(com.google.inject.Module... modules)` Multiple module instances of the same type could be registered.
`GuiceBundle.Builder<T>`	`modulesOverride(com.google.inject.Module... modules)` Register overriding modules, used to override bindings of normal modules.
`GuiceBundle.Builder<T>`	`noDefaultInstallers()` Disables automatic `CoreInstallersBundle` and `WebInstallersBundle` registration (no installers will be registered by default).
`GuiceBundle.Builder<T>`	`noGuiceFilter()` Disables `GuiceFilter` registration for both application and admin contexts.
`<K extends java.lang.Enum & Option> GuiceBundle.Builder<T>`	`option(K option, java.lang.Object value)` Options is a generic mechanism to provide internal configuration values for guicey and 3rd party bundles.
`<K extends java.lang.Enum & Option> GuiceBundle.Builder<T>`	`options(java.util.Map<java.lang.Enum,java.lang.Object> options)` Sets multiple options at once.
`GuiceBundle.Builder<T>`	`printAllGuiceBindings()` Prints all bindings in guice injector.
`GuiceBundle.Builder<T>`	`printAvailableInstallers()` Prints all registered (not disabled) installers with registration source.
`GuiceBundle.Builder<T>`	`printConfigurationBindings()` Prints available configuration bindings.
`GuiceBundle.Builder<T>`	`printCustomConfigurationBindings()` The same as `printConfigurationBindings()`, but hides all dropwizard related paths.
`GuiceBundle.Builder<T>`	`printDiagnosticInfo()` Print additional diagnostic logs with startup statistics, installed bundles, installers and resolved extensions and configuration tree.
`GuiceBundle.Builder<T>`	`printGuiceAopMap()` Prints all configured guice AOP interceptors and how they apply to methods.
`GuiceBundle.Builder<T>`	`printGuiceAopMap(GuiceAopConfig config)` Supposed to be used to understand how guice AOP works (the most often reasons: check aop applied to method and check interceptors order).
`GuiceBundle.Builder<T>`	`printGuiceBindings()` Prints guice bindings configured in user-provided modules (excluding guicey and guice own bindings).
`GuiceBundle.Builder<T>`	`printLifecyclePhases()` Split logs with major lifecycle stage names.
`GuiceBundle.Builder<T>`	`printLifecyclePhasesDetailed()` Same as `printLifecyclePhases()`, but also prints resolved and disabled configuration items.
`GuiceBundle.Builder<T>`	`searchCommands()` NOTE: will not scan if auto scan not enabled (packages not configured with `enableAutoConfig(String...)`).
`GuiceBundle.Builder<T>`	`strictScopeControl()` Enables strict control of beans instantiation context: all beans must be instantiated by guice, except beans annotated with `JerseyManaged`.
`GuiceBundle.Builder<T>`	`useHK2ForJerseyExtensions()` Manage jersey extensions (resources, jersey filters etc.) with HK2 by default instead of guice (the same effect as if `JerseyManaged` annotation would be set on all beans).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Builder
```
public Builder()
```
- Method Detail
  - listen
```
public GuiceBundle.Builder<T> listen(GuiceyLifecycleListener... listeners)
```
    Guicey broadcast a lot of events in order to indicate lifecycle phases (GuiceyLifecycle). This could be useful for diagnostic logging (like printLifecyclePhases()) or to implement special behaviours on installers, bundles, modules extensions (listeners have access to everything). For example, ConfigurationAwareModule like support for guice modules could be implemented with listeners.
    Configuration items (modules, extensions, bundles) are not aware of each other and listeners could be used to tie them. For example, to tell bundle if some other bundles registered (limited applicability, but just for example).
    Listener can't directly affect configuration (can't register or disable extensions, modules etc). But listener could implement GuiceyConfigurationHook interface and it would be automatically registered. This could be used to register special extensions required by listener logic (some diagnostic, monitoring or special features support).
    You can also use GuiceyLifecycleAdapter when you need to handle multiple events (it replaces direct events handling with simple methods).
    Listener is not registered if equal listener were already registered (Set used as listeners storage), so if you need to be sure that only one instance of some listener will be used implement Object.equals(Object) and Object.hashCode().
    
    Parameters:
    
    listeners - guicey lifecycle listeners (listener could be also a hook)
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    GuiceyLifecycle, GuiceyConfigurationHook, GuiceyLifecycleAdapter
  - option
```
public <K extends java.lang.Enum & Option> GuiceBundle.Builder<T> option(K option,
                                                                         java.lang.Object value)
```
    Options is a generic mechanism to provide internal configuration values for guicey and 3rd party bundles. See GuiceyOptions as options example. Bundles may define their own enums in the same way to use options mechanism.
    Options intended to be used for development time specific configurations (most likely low level options to slightly change behaviour). Also, in contrast to internal booleans (e.g. in main bundle), options are accessible everywhere and may be used by other 3rd party module or simply for reporting.
    Options may be set only on application level. Guicey bundles could access option values through bootstrap object. Guice service could access options through options bean. Installers could use WithOptions to get access to options. Options metadata for reporting is available through guice bean.
    Options may be used instead of shortcut methods when configuration value is dynamic (without options it would not be impossible to configure without breaking builder flow and additional if statements).
    Note: each option declares exact option type and provided value is checked for type compatibility.
    
    Type Parameters:
    
    K - helper type for option signature definition
    
    Parameters:
    
    option - option enum
    
    value - option value (not null)
    
    Returns:
    
    builder instance for chained calls
    
    Throws:
    
    java.lang.NullPointerException - is null value provided
    
    java.lang.IllegalArgumentException - if provided value incompatible with option type
    
    See Also:
    
    for more details, GuiceyOptions, InstallersOptions
  - options
```
public <K extends java.lang.Enum & Option> GuiceBundle.Builder<T> options(java.util.Map<java.lang.Enum,java.lang.Object> options)
```
    Sets multiple options at once. Method would be useful for options lookup implementations.
    Note: Option type is not mixed with enum in declaration to simplify usage, but used enums must be correct options.
    Use provided OptionsMapper utility to map options from system properties or environment variables. It supports basic string conversions. For example:
```
     .options(new OptionsMapper()
                 .env("STAGE", GuiceyOptions.InjectorStage)
                 .map())
 
```
    Will set injector stage option from STAGE environment variable. If variable is not set - default value used. If STAGE set to, for example "DEVELOPMENT" (must be Stage enum value) then Stage.DEVELOPMENT will be set as option value.
    Also, mapper could map generic options definitions from system properties (prefixed):
```
 .options(new OptionsMapper()
                 .props("option.")
                 .map())
 
```
    See OptionsMapper for more usage details.
    Type Parameters:
    
    K - helper type for option signature definition
    
    Parameters:
    
    options - options map (not null)
    
    Returns:
    
    builder instance for chained calls
    
    Throws:
    
    java.lang.NullPointerException - is null value provided for any option
    
    java.lang.IllegalArgumentException - if any provided value incompatible with option type
    
    See Also:
    
    for more info, OptionsMapper
  - injectorFactory
```
public GuiceBundle.Builder<T> injectorFactory(InjectorFactory injectorFactory)
```
    Configures custom InjectorFactory. Required by some guice extensions like governator.
    
    Parameters:
    
    injectorFactory - custom guice injector factory
    
    Returns:
    
    builder instance for chained calls
  - bundleLookup
```
public GuiceBundle.Builder<T> bundleLookup(GuiceyBundleLookup bundleLookup)
```
    Configure custom GuiceyBundleLookup. Lookup provides an easy way to indirectly install GuiceyBundle bundles. Default implementation support lookup by system property.
    
    Parameters:
    
    bundleLookup - custom bundle lookup implementation
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    DefaultBundleLookup, duplicateConfigDetector(DuplicateConfigDetector)
  - disableBundleLookup
```
public GuiceBundle.Builder<T> disableBundleLookup()
```
    Disables default bundle lookup.
    
    Returns:
    
    builder instance for chained calls
  - enableAutoConfig
```
public GuiceBundle.Builder<T> enableAutoConfig(java.lang.String... basePackages)
```
    Enables auto scan feature. When enabled, all core installers are registered automatically.
    
    Parameters:
    
    basePackages - packages to scan extensions in
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    GuiceyOptions.ScanPackages
  - duplicateConfigDetector
```
public GuiceBundle.Builder<T> duplicateConfigDetector(DuplicateConfigDetector detector)
```
    Duplicate configuration detector decides what configuration items, registered as instance (guicey bundle, guice module) to consider duplicate (and so avoid duplicates installation). By default, multiple instances of the same type allowed (the same as with dropwizard bundles - you can register multiple instances). But same instances or equal (Object.equals(Object)) instances are considered duplicate. If you need to accept only one instance of bundle or module, simply implement equals method to make all instances equal. Custom deduplicatation implementation may be required for 3rd party instances, where proper equals implementation is impossible (or for more complicated duplicates detection logic).
    Example situation: suppose one common bundle (or guice module) is used by two other bundles, so it would be registered in two bundles, but, if these bundles would be used together, then two instances of common bundle would be registered, which is often not desired. To workaround such case, bundle must implement proper equals method or custom duplication detector implementation must be used.
    Use LegacyModeDuplicatesDetector to simulate legacy guicey behaviour when only one instance of type is allowed (if old behaviour is important).
    
    Parameters:
    
    detector - detector implementation
    
    Returns:
    
    builder instance for chained calls
  - modules
```
public GuiceBundle.Builder<T> modules(com.google.inject.Module... modules)
```
    Multiple module instances of the same type could be registered. If module uniqueness is important use UniqueModule with correct equals implementation or implement custom deduplication logic in duplicateConfigDetector(DuplicateConfigDetector).
    These modules are registered under initialization phase where you don't have access for configuration or environment objects. To workaround this you can use *AwareModule interfaces, or extend from DropwizardAwareModule and required objects will be set just before configuration start. Another option is to register module inside GuiceyBundle.run(GuiceyEnvironment), which is called under run phase.
    
    Parameters:
    
    modules - one or more guice modules
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    BootstrapAwareModule, ConfigurationAwareModule, EnvironmentAwareModule, OptionsAwareModule, DropwizardAwareModule
  - modulesOverride
```
public GuiceBundle.Builder<T> modulesOverride(com.google.inject.Module... modules)
```
    Register overriding modules, used to override bindings of normal modules. Internally guice Modules.override(Module...) is used. If binding is present in normal module and overriding module then overriding module binding is used. Bindings in overriding modules, not present in normal modules are simply added to context (as usual module).
    The main purpose for overriding modules is testing, but it also could be used (in rare cases) to amend existing guice context (for example, in case when you do not control all bindings, but need to hot fix something).
    Overriding modules behave the same as normal modules: they are inspected for *AwareModule interfaces to inject dropwizard objects. Overriding module could be disabled with disableModules(Class[]) or generic disable(Predicate[]).
    
    Parameters:
    
    modules - overriding modules
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    modules(Module...), to override overridden bindings in test (edge case(
  - searchCommands
```
public GuiceBundle.Builder<T> searchCommands()
```
    NOTE: will not scan if auto scan not enabled (packages not configured with enableAutoConfig(String...)).
    Enables commands classpath search. All found commands are instantiated and registered in bootstrap. Default constructor is used for simple commands, but EnvironmentCommand must have constructor with Application argument.
    By default, commands search is disabled.
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    CommandSupport, GuiceyOptions.SearchCommands
  - noDefaultInstallers
```
public GuiceBundle.Builder<T> noDefaultInstallers()
```
    Disables automatic CoreInstallersBundle and WebInstallersBundle registration (no installers will be registered by default).
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    GuiceyOptions.UseCoreInstallers
  - noGuiceFilter
```
public GuiceBundle.Builder<T> noGuiceFilter()
```
    Disables GuiceFilter registration for both application and admin contexts. Without guice filter registered, guice ServletModule registrations are useless (because they can't be used). So guice servlet modules support will be disabled: no request or session scopes may be used and registrations of servlet modules will be denied (binding already declared exception). Even with disabled guice filter, request and response objects provider injections still may be used in resources (will work through HK2 provider).
    Guice servlets initialization took ~50ms, so injector creation will be a bit faster after disabling.
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    GuiceyOptions.GuiceFilterRegistration
  - installers
```
@SafeVarargs
public final GuiceBundle.Builder<T> installers(java.lang.Class<? extends FeatureInstaller>... installers)
```
    Feature installers registered automatically when auto scan enabled, but if you don't want to use it, you can register installers manually (note: without auto scan default installers will not be registered).
    Also, could be used to add installers from packages not included in auto scanning.
    
    Parameters:
    
    installers - feature installer classes to register
    
    Returns:
    
    builder instance for chained calls
  - extensions
```
public GuiceBundle.Builder<T> extensions(java.lang.Class<?>... extensionClasses)
```
    Beans could be registered automatically when auto scan enabled, but if you don't want to use it, you can register beans manually.
    Guice injector will instantiate beans and registered installers will be used to recognize and properly register provided extension beans.
    
    Also, could be used to add beans from packages not included in auto scanning.
    
    NOTE: startup will fail if bean not recognized by installers.
    
    NOTE: Don't register commands here: either enable auto scan, which will install commands automatically or register command directly to bootstrap object and dependencies will be injected to it after injector creation.
    
    Parameters:
    
    extensionClasses - extension bean classes to register
    
    Returns:
    
    builder instance for chained calls
  - bundles
```
public GuiceBundle.Builder<T> bundles(GuiceyBundle... bundles)
```
    Guicey bundles are mainly useful for extensions (to group installers and extensions installation without auto scan). Bundles lifecycle is the same as dropwizard bundles and so it could be used together.
    Multiple bundle instances of the same type could be registered. If bundle uniqueness is important use UniqueGuiceyBundle with correct equals implementation or implement custom deduplication logic in duplicateConfigDetector(DuplicateConfigDetector).
    
    Parameters:
    
    bundles - guicey bundles
    
    Returns:
    
    builder instance for chained calls
  - dropwizardBundles
```
public GuiceBundle.Builder<T> dropwizardBundles(io.dropwizard.ConfiguredBundle... bundles)
```
    Dropwizard bundles registration. There is no difference with direct bundles registration (with Bootstrap.addBundle(ConfiguredBundle), which is actually called almost immediately), except guicey tracking (registered bundles are showed in diagnostic report), ability to disable bundle and automatic duplicates detection (see duplicateConfigDetector(DuplicateConfigDetector)).
    Only bundles registered with guicey api are checked! For example, if you register one instance of the same bundle directly into bootstrap and another one with guicey api - guicey will not be able to track duplicate registration. So it's better to register all bundles through guicey api.
    By default, guicey will also track transitive bundles registrations (when registered bundle register other bundles) so disable and deduplication logic will apply to them too. Tracking could be disabled with GuiceyOptions.TrackDropwizardBundles option.
    
    Parameters:
    
    bundles - guicey bundles
    
    Returns:
    
    builder instance for chained calls
  - disableInstallers
```
@SafeVarargs
public final GuiceBundle.Builder<T> disableInstallers(java.lang.Class<? extends FeatureInstaller>... installers)
```
    Disabling installer will lead to avoiding all relative installed extensions. If you have manually registered extensions for disabled installer then remove their registration. Classpath scan extensions will be ignored (not installed, because no installer to recognize them).
    Disabling installer may be used to replace some existing installer with modified version (probably fixed): disable existing installer and register new custom installer.
    
    Parameters:
    
    installers - feature installer types to disable
    
    Returns:
    
    builder instance for chained calls
  - disableExtensions
```
public final GuiceBundle.Builder<T> disableExtensions(java.lang.Class<?>... extensions)
```
    Extensions disable is mostly useful for testing. In some cases, it could be used to disable some extra extensions installed with classpath scan or bundle. But, generally, try to avoid manual extensions disabling for clearer application configuration.
    
    Parameters:
    
    extensions - extensions to disable (manually added, registered by bundles or with classpath scan)
    
    Returns:
    
    builder instance for chained calls
  - disableModules
```
@SafeVarargs
public final GuiceBundle.Builder<T> disableModules(java.lang.Class<? extends com.google.inject.Module>... modules)
```
    Modules disable is mostly useful for testing. In some cases, it could be used to disable some extra modules installed by some bundle. But, generally, try to avoid manual modules disabling for clearer application configuration.
    Option could also disable inner modules (registered by modules transitively), but only if bindings analysis is not disabled (by GuiceyOptions.AnalyzeGuiceModules). Inner modules can't be removed from overriding modules, because only normal modules are analyzed.
    When bindings analysis is disabled this option can disable only directly registered modules (with modules(Module...) or in bundle GuiceyBootstrap.modules(Module...).
    
    Parameters:
    
    modules - guice module types to disable
    
    Returns:
    
    builder instance for chained calls
  - disableBundles
```
@SafeVarargs
public final GuiceBundle.Builder<T> disableBundles(java.lang.Class<? extends GuiceyBundle>... bundles)
```
    Bundles disable is mostly useful for testing. In some cases, it could be used to disable some transitive bundle (bundle installed by some registered bundle with GuiceyBootstrap.bundles(GuiceyBundle...)).
    
    Parameters:
    
    bundles - guicey bundles to disable
    
    Returns:
    
    builder instance for chained calls
  - disableDropwizardBundles
```
@SafeVarargs
public final GuiceBundle.Builder<T> disableDropwizardBundles(java.lang.Class<? extends io.dropwizard.ConfiguredBundle>... bundles)
```
    Dropwizard bundles disable is mostly useful for testing. Note that it can disable only bundles directly registered through guicey api or bundles registered by them (if dropwizard bundles tracking not disabled with GuiceyOptions.TrackDropwizardBundles).
    
    Parameters:
    
    bundles - guicey bundles to disable
    
    Returns:
    
    builder instance for chained calls
  - disable
```
@SafeVarargs
public final GuiceBundle.Builder<T> disable(java.util.function.Predicate<ItemInfo>... predicates)
```
    Disable items using disable predicate: all matched items will be disabled. Predicate is called just after first item registration and, if it will evaluate to true, then item marked as disabled. Predicate receive only disableable items: guicey bundle, installer, extension or guice module (directly registered).
    Also, predicate is called on registration for all already registered items to make predicate registration moment not important.
    Essentially, predicates are the same as calling direct disable methods: items, disabled by predicate, will be marked as disabled by predicate registration context (application or guicey bundle).
    Mostly useful for testing, but in some cases could be used directly.
    Use Predicate.and(Predicate), Predicate.or(Predicate) and Predicate.negate() to combine complex predicates from simple ones from Disables helper.
    Item passed only one time after initial registration and so item object will have only basic fields: item type, item class and item registration scope (who register it).
    For example, disable all installers, registered from application root except SomeInstallerType:
```
 import static ru.vyarus.dropwizard.guice.module.context.Disables.*

 builder.disable(installer()
             .and(registeredBy(Application.class))
             .and(type(SomeInstallerType.class).negate());
 
```
    Items could be disabled just by class, no matter what type they are:
```
 import static ru.vyarus.dropwizard.guice.module.context.Disables.*

 builder.disable(type(MyExtension.class,
                      MyInstaller.class,
                      MyBundle.class,
                      MyModule.class));
 
```
    For instance types (bundles, modules), when multiple instances of the same class may appear, exact instance could be disabled (predicate would be called for each new instance separately, avoiding equal duplicates).
    Parameters:
    
    predicates - disable predicates
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    for common predicates
  - strictScopeControl
```
public GuiceBundle.Builder<T> strictScopeControl()
```
    Enables strict control of beans instantiation context: all beans must be instantiated by guice, except beans annotated with JerseyManaged. When bean instantiated in wrong context exception would be thrown.
    It is useful if you write your own installers or to simply ensure correctness in doubtful cases.
    Do not use for production! It is intended to be used mostly in tests or to diagnose problems during development.
    To implicitly enable this check in all tests use PropertyBundleLookup.enableBundles(HK2DebugBundle.class).
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    HK2DebugBundle
  - useHK2ForJerseyExtensions
```
public GuiceBundle.Builder<T> useHK2ForJerseyExtensions()
```
    Manage jersey extensions (resources, jersey filters etc.) with HK2 by default instead of guice (the same effect as if JerseyManaged annotation would be set on all beans). Use this option if you want to use jersey specific resource features (like @Context bindings) and completely delegate management to HK2.
    IMPORTANT: this will activate HK2 bridge usage (to be able to inject guice beans) and so you will need to provide bridge dependency (org.glassfish.hk2:guice-bridge:2.5.0). Startup will fail if dependency is not available.
    WARNING: you will not be able to use guice AOP on beans managed by HK2!
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    InstallersOptions.JerseyExtensionsManagedByGuice, JerseyManaged, GuiceManaged
  - printDiagnosticInfo
```
public GuiceBundle.Builder<T> printDiagnosticInfo()
```
    Print additional diagnostic logs with startup statistics, installed bundles, installers and resolved extensions and configuration tree.
    Statistics shows mainly where guice spent most time. Configuration info is useful for configuration problems resolution. Also, logs useful for better understanding how guicey works.
    If custom logging format is required use ConfigurationDiagnostic directly.
    May be enabled on compiled application with a system property: -Dguicey.hooks=diagnostic (hook will also enable some other reports).
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    ConfigurationDiagnostic
  - printAvailableInstallers
```
public GuiceBundle.Builder<T> printAvailableInstallers()
```
    Prints all registered (not disabled) installers with registration source. Useful to see all supported extension types when multiple guicey bundles registered and available features become not obvious from application class.
    In contrast to printDiagnosticInfo() shows all installers (including installers not used by application extensions). Installers report intended only to show available installers and will not show duplicate installers registrations or installers disabling (use diagnostic reporting for all configuration aspects). Also, report will indicate installers marker interfaces and so it will be obvious what installer did: install by type or by object, perform custom guice bindings or perform jersey specific installations.
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    ConfigurationDiagnostic
  - printConfigurationBindings
```
public GuiceBundle.Builder<T> printConfigurationBindings()
```
    Prints available configuration bindings. Use it to see available bindings or debug missed bindings as report shown before actual injector start. Use printCustomConfigurationBindings() to see only custom paths (without dropwizard configurations).
    Safe to use with other print* options.
    Info: guicey analyze configuration object (prepared by dropwizard) with jackson serialization api and binds all readable configuration values by path (e.g. @inject @Config("some.path") String prop;. Also, unique sub configuration objects are recognized and may be used directly (@Inject @Config SubConfig subConf). Introspected configuration object is accessible from lifecycle events, gucie modules, guicey bundles and by direct injection.
    May be enabled on compiled application with a system property: -Dguicey.hooks=diagnostic (hook will also enable some other reports).
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    ConfigurationTree, Config
  - printCustomConfigurationBindings
```
public GuiceBundle.Builder<T> printCustomConfigurationBindings()
```
    The same as printConfigurationBindings(), but hides all dropwizard related paths. Use to see bindings of your custom configuration classes.
    
    Returns:
    
    builder instance for chained calls
  - printGuiceBindings
```
public GuiceBundle.Builder<T> printGuiceBindings()
```
    Prints guice bindings configured in user-provided modules (excluding guicey and guice own bindings). Identifies bindings overrides from overriding modules, aop and undeclared (JIT) bindings.
    May be enabled on compiled application with a system property: -Dguicey.hooks=diagnostic (hook will also enable some other reports).
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    to show entire injector state
  - printAllGuiceBindings
```
public GuiceBundle.Builder<T> printAllGuiceBindings()
```
    Prints all bindings in guice injector.
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    to show only user-provided bindings
  - printGuiceAopMap
```
public GuiceBundle.Builder<T> printGuiceAopMap()
```
    Prints all configured guice AOP interceptors and how they apply to methods. In most cases this general report will be not useful as it will contain too much information. It's better to use printGuiceAopMap(GuiceAopConfig) and filter all non interesting bindings.
    
    Returns:
    
    builder instance for chained calls
  - printGuiceAopMap
```
public GuiceBundle.Builder<T> printGuiceAopMap(GuiceAopConfig config)
```
    Supposed to be used to understand how guice AOP works (the most often reasons: check aop applied to method and check interceptors order). In contrast to other reports, this one is more a specialized tool for development.
    Multiple reports could be configured (in some cases it is simpler to declare few different but simple configurations rather then one complex).
    
    Parameters:
    
    config - report configuration
    
    Returns:
    
    builder instance for chained calls
  - printLifecyclePhases
```
public GuiceBundle.Builder<T> printLifecyclePhases()
```
    Split logs with major lifecycle stage names. Useful for debugging (to better understand at what stage your code is executed). Also, could be used for light profiling as time since startup is printed for each phase (and for shutdown phases). And, of course, could be used for better guicey understanding.
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    LifecycleDiagnostic
  - printLifecyclePhasesDetailed
```
public GuiceBundle.Builder<T> printLifecyclePhasesDetailed()
```
    Same as printLifecyclePhases(), but also prints resolved and disabled configuration items.
    May be enabled on compiled application with a system property: -Dguicey.hooks=diagnostic (hook will also enable some other reports).
    
    Returns:
    
    builder instance for chained calls
    
    See Also:
    
    LifecycleDiagnostic
  - hookAlias
```
public GuiceBundle.Builder<T> hookAlias(java.lang.String name,
                                        java.lang.Class<? extends GuiceyConfigurationHook> hook)
```
    Guicey hooks (GuiceyConfigurationHook) may be loaded with system property "guicey.hooks". But it may be not comfortable to always declare full class name (e.g. -Dguicey.hooks=com.foo.bar.Hook,..). Instead short alias name may be used: -Dguicey.hooks=alias1, alias2.
    By default, diagnostic hook is aliased as "diagnostic" in order to be able to enable diagnostic reporting for compiled application (-Dguicey.hooks=diagnostic).
    
    Parameters:
    
    name - alias name
    
    hook - hook class to alias
    
    Returns:
    
    builder instance for chained calls
  - build
```
public GuiceBundle<T> build(com.google.inject.Stage stage)
```
    Parameters:
    
    stage - stage to run injector with
    
    Returns:
    
    bundle instance
    
    See Also:
    
    GuiceyOptions.InjectorStage
  - build
```
public GuiceBundle<T> build()
```
    Returns:
    
    bundle instance with implicit PRODUCTION stage
    
    See Also:
    
    GuiceyOptions.InjectorStage

Class GuiceBundle.Builder<T extends io.dropwizard.Configuration>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Builder

Method Detail

listen

option

options

injectorFactory

bundleLookup

disableBundleLookup

enableAutoConfig

duplicateConfigDetector

modules

modulesOverride

searchCommands

noDefaultInstallers

noGuiceFilter

installers

extensions

bundles

dropwizardBundles

disableInstallers

disableExtensions

disableModules

disableBundles

disableDropwizardBundles

disable

strictScopeControl

useHK2ForJerseyExtensions

printDiagnosticInfo

printAvailableInstallers

printConfigurationBindings

printCustomConfigurationBindings

printGuiceBindings

printAllGuiceBindings

printGuiceAopMap

printGuiceAopMap

printLifecyclePhases

printLifecyclePhasesDetailed

hookAlias

build

build