如何在 Android 项目中从头设置 DAGGER 依赖注入?

如何使用匕首? 如何配置匕首工作在我的 Android 项目?

我想在我的 Android 项目中使用 Dagger,但我发现它令人困惑。

编辑: 匕首2也是从2015年04年15日出来,它更令人困惑!

[这个问题是一个“存根”,当我了解更多关于 Dagger1和 Dagger2的知识时,我会在上面添加我的答案。这个问题更像是一个 向导而不是一个“问题”。]

22983 次浏览

Guide for Dagger 1.x:

The steps are the following:

1.) add Dagger to the build.gradle file for the dependencies

dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
...
compile 'com.squareup.dagger:dagger:1.2.2'
provided 'com.squareup.dagger:dagger-compiler:1.2.2'

Also, add packaging-option to prevent an error about duplicate APKs.

android {
...
packagingOptions {
// Exclude file to avoid
// Error: Duplicate files during packaging of APK
exclude 'META-INF/services/javax.annotation.processing.Processor'
}
}

2.) create an Injector class to handle the ObjectGraph.

public enum Injector
{
INSTANCE;


private ObjectGraph objectGraph = null;


public void init(final Object rootModule)
{


if(objectGraph == null)
{
objectGraph = ObjectGraph.create(rootModule);
}
else
{
objectGraph = objectGraph.plus(rootModule);
}


// Inject statics
objectGraph.injectStatics();


}


public void init(final Object rootModule, final Object target)
{
init(rootModule);
inject(target);
}


public void inject(final Object target)
{
objectGraph.inject(target);
}


public <T> T resolve(Class<T> type)
{
return objectGraph.get(type);
}
}

3.) Create a RootModule to link your future modules together. Please note that you must include injects to specify every class in which you will use @Inject annotation, because otherwise Dagger throws RuntimeException.

@Module(
includes = {
UtilsModule.class,
NetworkingModule.class
},
injects = {
MainActivity.class
}
)
public class RootModule
{
}

4.) In case you have other sub-modules within your modules specified in your Root, create modules for those:

@Module(
includes = {
SerializerModule.class,
CertUtilModule.class
}
)
public class UtilsModule
{
}

5.) create the leaf modules which receive the dependencies as constructor parameters. In my case, there was no circular dependency, so I don't know if Dagger can resolve that, but I find it unlikely. The constructor parameters must also be provided in a Module by Dagger, if you specify complete = false then it can be in other Modules too.

@Module(complete = false, library = true)
public class NetworkingModule
{
@Provides
public ClientAuthAuthenticator providesClientAuthAuthenticator()
{
return new ClientAuthAuthenticator();
}


@Provides
public ClientCertWebRequestor providesClientCertWebRequestor(ClientAuthAuthenticator clientAuthAuthenticator)
{
return new ClientCertWebRequestor(clientAuthAuthenticator);
}


@Provides
public ServerCommunicator providesServerCommunicator(ClientCertWebRequestor clientCertWebRequestor)
{
return new ServerCommunicator(clientCertWebRequestor);
}
}

6.) Extend Application and initialize the Injector.

@Override
public void onCreate()
{
super.onCreate();
Injector.INSTANCE.init(new RootModule());
}

7.) In your MainActivity, call the Injector in the onCreate() method.

@Override
protected void onCreate(Bundle savedInstanceState)
{
Injector.INSTANCE.inject(this);
super.onCreate(savedInstanceState);
...

8.) Use @Inject in your MainActivity.

public class MainActivity extends ActionBarActivity
{
@Inject
public ServerCommunicator serverCommunicator;


...

If you get the error no injectable constructor found, make sure you did not forget the @Provides annotations.

Guide for Dagger 2.x (Revised Edition 6):

The steps are the following:

1.) add Dagger to your build.gradle files:

  • top level build.gradle:

.

// Top-level build file where you can add configuration options common to all sub-projects/modules.


buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.2.0'
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' //added apt for source code generation
}
}


allprojects {
repositories {
jcenter()
}
}
  • app level build.gradle:

.

apply plugin: 'com.android.application'
apply plugin: 'com.neenbedankt.android-apt' //needed for source code generation


android {
compileSdkVersion 24
buildToolsVersion "24.0.2"


defaultConfig {
applicationId "your.app.id"
minSdkVersion 14
targetSdkVersion 24
versionCode 1
versionName "1.0"
}
buildTypes {
debug {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}


dependencies {
apt 'com.google.dagger:dagger-compiler:2.7' //needed for source code generation
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'com.android.support:appcompat-v7:24.2.1'
compile 'com.google.dagger:dagger:2.7' //dagger itself
provided 'org.glassfish:javax.annotation:10.0-b28' //needed to resolve compilation errors, thanks to tutplus.org for finding the dependency
}

2.) Create your AppContextModule class that provides the dependencies.

@Module //a module could also include other modules
public class AppContextModule {
private final CustomApplication application;


public AppContextModule(CustomApplication application) {
this.application = application;
}


@Provides
public CustomApplication application() {
return this.application;
}


@Provides
public Context applicationContext() {
return this.application;
}


@Provides
public LocationManager locationService(Context context) {
return (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
}
}

3.) create the AppContextComponent class that provides the interface to get the classes that are injectable.

public interface AppContextComponent {
CustomApplication application(); //provision method
Context applicationContext(); //provision method
LocationManager locationManager(); //provision method
}

3.1.) This is how you would create a module with an implementation:

@Module //this is to show that you can include modules to one another
public class AnotherModule {
@Provides
@Singleton
public AnotherClass anotherClass() {
return new AnotherClassImpl();
}
}


@Module(includes=AnotherModule.class) //this is to show that you can include modules to one another
public class OtherModule {
@Provides
@Singleton
public OtherClass otherClass(AnotherClass anotherClass) {
return new OtherClassImpl(anotherClass);
}
}


public interface AnotherComponent {
AnotherClass anotherClass();
}


public interface OtherComponent extends AnotherComponent {
OtherClass otherClass();
}


@Component(modules={OtherModule.class})
@Singleton
public interface ApplicationComponent extends OtherComponent {
void inject(MainActivity mainActivity);
}

Beware:: You need to provide the @Scope annotation (like @Singleton or @ActivityScope) on the module's @Provides annotated method to get a scoped provider within your generated component, otherwise it will be unscoped, and you'll get a new instance each time you inject.

3.2.) Create an Application-scoped component that specifies what you can inject (this is the same as the injects={MainActivity.class} in Dagger 1.x):

@Singleton
@Component(module={AppContextModule.class}) //this is where you would add additional modules, and a dependency if you want to subscope
public interface ApplicationComponent extends AppContextComponent { //extend to have the provision methods
void inject(MainActivity mainActivity);
}

3.3.) For dependencies that you can create via a constructor yourself and won't want to redefine using a @Module (for example, you use build flavors instead to change the type of implementation), you can use @Inject annotated constructor.

public class Something {
OtherThing otherThing;


@Inject
public Something(OtherThing otherThing) {
this.otherThing = otherThing;
}
}

Also, if you use @Inject constructor, you can use field injection without having to explicitly call component.inject(this):

public class Something {
@Inject
OtherThing otherThing;


@Inject
public Something() {
}
}

These @Inject constructor classes are automatically added to the component of the same scope without having to explicitly specify them in a module.

A @Singleton scoped @Inject constructor class will be seen in @Singleton scoped components.

@Singleton // scoping
public class Something {
OtherThing otherThing;


@Inject
public Something(OtherThing otherThing) {
this.otherThing = otherThing;
}
}

3.4.) After you've defined a specific implementation for a given interface, like so:

public interface Something {
void doSomething();
}


@Singleton
public class SomethingImpl {
@Inject
AnotherThing anotherThing;


@Inject
public SomethingImpl() {
}
}

You'll need to "bind" the specific implementation to the interface with a @Module.

@Module
public class SomethingModule {
@Provides
Something something(SomethingImpl something) {
return something;
}
}

A short-hand for this since Dagger 2.4 is the following:

@Module
public abstract class SomethingModule {
@Binds
abstract Something something(SomethingImpl something);
}

4.) create an Injector class to handle your application-level component (it replaces the monolithic ObjectGraph)

(note: Rebuild Project to create the DaggerApplicationComponent builder class using APT)

public enum Injector {
INSTANCE;


ApplicationComponent applicationComponent;


private Injector(){
}


static void initialize(CustomApplication customApplication) {
ApplicationComponent applicationComponent = DaggerApplicationComponent.builder()
.appContextModule(new AppContextModule(customApplication))
.build();
INSTANCE.applicationComponent = applicationComponent;
}


public static ApplicationComponent get() {
return INSTANCE.applicationComponent;
}
}

5.) create your CustomApplication class

public class CustomApplication
extends Application {
@Override
public void onCreate() {
super.onCreate();
Injector.initialize(this);
}
}

6.) add CustomApplication to your AndroidManifest.xml.

<application
android:name=".CustomApplication"
...

7.) Inject your classes in MainActivity

public class MainActivity
extends AppCompatActivity {
@Inject
CustomApplication customApplication;


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Injector.get().inject(this);
//customApplication is injected from component
}
}

8.) Enjoy!

+1.) You can specify Scope for your components with which you can create Activity-level scoped components. Subscopes allow you to provide dependencies that you only need only for a given subscope, rather than throughout the whole application. Typically, each Activity gets its own module with this setup. Please note that a scoped provider exists per component, meaning in order to retain the instance for that activity, the component itself must survive configuration change. For example, it could survive through onRetainCustomNonConfigurationInstance(), or a Mortar scope.

For more info on subscoping, check out the guide by Google. Also please see this site about provision methods and also the component dependencies section) and here.

To create a custom scope, you must specify the scope qualifier annotation:

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface YourCustomScope {
}

To create a subscope, you need to specify the scope on your component, and specify ApplicationComponent as its dependency. Obviously you need to specify the subscope on the module provider methods too.

@YourCustomScope
@Component(dependencies = {ApplicationComponent.class}, modules = {CustomScopeModule.class})
public interface YourCustomScopedComponent
extends ApplicationComponent {
CustomScopeClass customScopeClass();


void inject(YourScopedClass scopedClass);
}

And

@Module
public class CustomScopeModule {
@Provides
@YourCustomScope
public CustomScopeClass customScopeClass() {
return new CustomScopeClassImpl();
}
}

Please note that only one scoped component can be specified as a dependency. Think of it exactly like how multiple inheritance is not supported in Java.

+2.) About @Subcomponent: essentially, a scoped @Subcomponent can replace a component dependency; but rather than using a builder provided by the annotation processor, you would need to use a component factory method.

So this:

@Singleton
@Component
public interface ApplicationComponent {
}


@YourCustomScope
@Component(dependencies = {ApplicationComponent.class}, modules = {CustomScopeModule.class})
public interface YourCustomScopedComponent
extends ApplicationComponent {
CustomScopeClass customScopeClass();


void inject(YourScopedClass scopedClass);
}

Becomes this:

@Singleton
@Component
public interface ApplicationComponent {
YourCustomScopedComponent newYourCustomScopedComponent(CustomScopeModule customScopeModule);
}


@Subcomponent(modules={CustomScopeModule.class})
@YourCustomScope
public interface YourCustomScopedComponent {
CustomScopeClass customScopeClass();
}

And this:

DaggerYourCustomScopedComponent.builder()
.applicationComponent(Injector.get())
.customScopeModule(new CustomScopeModule())
.build();

Becomes this:

Injector.INSTANCE.newYourCustomScopedComponent(new CustomScopeModule());

+3.): Please check other Stack Overflow questions regarding Dagger2 as well, they provide a lot of info. For example, my current Dagger2 structure is specified in this answer.

Thanks

Thank you for the guides at Github, TutsPlus, Joe Steele, Froger MCS and Google.

Also for this step by step migration guide I found after writing this post.

And for scope explanation by Kirill.

Even more information in the official documentation.