Dependency injection is an idea where objects can get any other required objects from the outside environment. This concept can be implemented in various languages. Inversion of Control is what runs behind dependency injection. For enterprise android app development, dependency injection plays a crucial role.
If a Java class uses an instance of another class, it means the former Java class has a dependency on the later one. It is known as class dependency. However, Java classes should remain independent from other Java classes, if it is possible. It boosts the possibilities of reusing the classes and also lets you test each class independently.
Dependency Injection with Dagger 2
Introduction to Dagger 2
A dependency injection framework, Dagger 2, is based on JSR or Java Specification Request 330. The framework requires code generation and is based on various annotations. These generated codes are easy to read and debug in comparison to other codes. You can hire a reputed enterprise android application development team for the task and focus on other things.
Annotations for Dagger 2:
@Module and @Provides: These two annotations define classes and methods that provide dependencies
@Inject: With this annotation, a programmer requests dependencies. It can be used with a field, a constructor, or a method.
@Component: This annotation enables selected modules and is used for performing dependency injection.
Dagger 2 here uses generated code for accessing the fields over reflection. So, for field injection, it can’t use private fields as it is not allowed to use it.
Definition Of Dependency Providers (object providers)
To describe a set of objects that can be injected, we use the term dependency injection context. In Dagger 2, classes, where @Module annotation is in use, are responsible for providing objects that are ready to be injected. Such classes define methods that are annotated with @Provides. Returned objects from those methods are available for dependency injection.
Methods that are annotated with @Provides are enabled to express dependencies through method parameters. If possible, Dagger 2 format helps to fulfill these dependencies.
Defining Dependencies (object consumers)
By using @Inject annotation, you can define a dependency. Suppose you have annotated a constructor with @Inject. Dagger 2 can use an instance of the object for fulfilling dependencies. It is done to avoid the definition of multiple @Provides methods for those objects.
Connecting Consumers And Providers
The @Component annotation is to be used on the interface. Dagger 2 uses such an interface for generating code. So, what’s the base pattern for the generated class? Dagger is the prefix followed by interface name. The generated class offers a “create” method that allows object configuration based on the given layout.
The methods denoted on the interface are always available for accessing the generated objects. A @Component interface defines the connection between objects or modules provider and the objects. It expresses a dependency.
Scope Annotations
@Singleton annotations indicate a single instance of the provided object that has been shared and created.
Dagger With Special Treatment Of Fields
Dagger 2 doesn’t inject the fields automatically. It doesn’t inject private fields. In the case of using field injection, you must define a particular method in your @Component interface that takes the instance. You would want to inject this instance as a parameter.
Using Dagger 2 With Maven And Eclipse
For using Eclipse and Maven with Dagger 2, installing Maven tooling along with the apt plug-in will do the work. The plug-in allows Maven to configure the annotation processors.
Dependency Injection With Dagger 2 And Android
Dependency Injection Usage With Android
Various Android components like activities are represented by the Android framework instead of your code. It makes things difficult to supply dependencies through constructors to The Android components.
Dagger 2 Usage In Android
Do you want to use classes from dagger.android package? Then you can also add the following dependencies to your build.gradle file. This is important in case you want to inject Activities components like fragments or activities. If you wish to use the support libraries with Dagger 2, you would have to add a build.gradle.
Advantages Of Dagger 2
ButterKnife library makes it way smoother to define references to event handlers, Views, and various resources. Dagger 2 provides a particular way for obtaining references to shared instances.
Easy Configuration Of The Complex Dependencies
Most often, your objects are created in an implicit order. Here, Dagger 2 generates code walking through the dependency graph. It is easy to understand and trace and saves your time and effort from writing the boilerplate code in a large amount. Otherwise, you would have to write them by hand or type to get references and pass them to other objects as dependencies. For refactoring simplification, it is important. You will be able to focus on what modules you can build. It lets you focus on the order in the way they need to be created.
Scoped Instances
Dependency injection with Dagger 2 does more than managing instances. It can last the entire application lifecycle. You are allowed to leverage Dagger 2 for defining instances with shorter lifetimes. It is bound to activity lifecycle, user session, etc.)
Easy Unit And Integration Testing
The dependency graph is specifically designed for us. This graph can swap out modules that make and mock the network responses.
Author Bio
Hermit Chawla is a MD at AIS Technolabs which is a Web/App design and Development Company, helping global businesses to grow by Global Clients. He love to share his thoughts on Web & App Development, Clone App Development and Game Development.
For More:
LinkedIn:https://www.linkedin.com/in/hermit-chawla-lion-82b6513b
