See: Description
Interface | Description |
---|---|
Lazy<T> |
A handle to a lazily-computed value.
|
MembersInjector<T> |
Injects dependencies into the fields and methods on instances of type
T . |
Annotation Type | Description |
---|---|
Binds |
Annotates abstract methods of a
Module that delegate bindings. |
BindsInstance |
Marks a method on a component builder or subcomponent builder that allows an instance to be bound
to some type within the component.
|
BindsOptionalOf |
Annotates methods that declare bindings for
Optional containers of values from bindings
that may or may not be present in the component. |
Component |
Annotates an interface or abstract class for which a fully-formed, dependency-injected
implementation is to be generated from a set of Component.modules().
|
Component.Builder |
A builder for a component.
|
MapKey |
Identifies annotation types that are used to associate keys with values returned by provider methods in order to compose a map.
|
Module |
Annotates a class that contributes to the object graph.
|
Provides |
Annotates methods of a module to create a provider method binding.
|
Reusable |
A scope that indicates that the object returned by a binding may be (but might not be) reused.
|
Subcomponent |
A subcomponent that inherits the bindings from a parent
Component or
Subcomponent . |
Subcomponent.Builder |
A builder for a subcomponent.
|
The entry point into the API is the Component
, which annotates abstract types for
Dagger 2 to implement. The dependency graph is configured using using annotations such as Module
, Provides
and Inject
.
dagger.internal.codegen.ComponentProcessor
is the processor responsible for generating
the implementation. Dagger uses the annotation procesor service loader to automatically configure the processor, so explict build configuration
shouldn't be necessary.
Copyright © 2012���2017 The Dagger Authors. All rights reserved.