Dagger：Android依赖注入框架入门教程

前言

依赖注入这个概念听起来挺吓人的，对吧？我第一次接触时也觉得这是个高深莫测的技术！但其实，它就像是一个聪明的管家，帮你管理好各种"依赖关系"。今天我们就来聊聊Android世界中非常流行的依赖注入框架——Dagger。

为什么要学习Dagger？因为它能帮你写出更干净、更易测试、更容易维护的代码。当你的应用越来越大，组件之间的依赖关系越来越复杂时，Dagger的价值就会越发明显。（相信我，你会感谢自己早点学会它的！）

什么是依赖注入？

在讲Dagger之前，我们先搞清楚什么是"依赖注入"。

想象一下：你写了一个UserManager类，它需要一个NetworkService来从网络获取用户数据。传统做法是这样的：

```java public class UserManager { private NetworkService networkService;

} ```

看起来没问题，对吧？但实际上这会导致两个类紧密耦合。如果NetworkService的构造函数改变了，你还得修改UserManager。更糟的是，当你想测试UserManager时，你无法替换掉真实的NetworkService。

这时依赖注入就派上用场了：

```java public class UserManager { private NetworkService networkService;

} ```

这种方式中，UserManager不再关心如何创建NetworkService，它只管使用。这就是"控制反转"(IoC)的思想 - 依赖的控制权从使用者转移到了外部。

Dagger简介

Dagger是由Square公司开发的，后来被Google接手并大力推广的依赖注入框架。它的名字来源于"Directed Acyclic Graph"（有向无环图），因为依赖关系就像一个图。

Dagger最大的特点是： - 完全在编译时生成代码，没有运行时反射（这意味着性能好！） - 编译时检查依赖，错误早发现 - 自动生成工厂类，省去大量模板代码

安装Dagger

首先，在你的build.gradle文件中添加Dagger依赖：

gradle dependencies { implementation 'com.google.dagger:dagger:2.44' annotationProcessor 'com.google.dagger:dagger-compiler:2.44' }

如果你使用Kotlin，需要将annotationProcessor替换为kapt，并添加kapt插件。

Dagger核心概念

Dagger的学习曲线确实有点陡，但掌握了几个核心概念后就会豁然开朗。

1. @Inject注解

@Inject是最基础的注解，它有两个用途： - 标记构造函数，告诉Dagger如何创建这个类的实例 - 标记字段，告诉Dagger需要注入什么

例如：

```java public class Car { private Engine engine; private Wheels wheels;

} ```

这里告诉Dagger：要创建Car，你需要提供Engine和Wheels的实例。

2. @Component接口

@Component是连接注入请求和依赖提供者的桥梁。它是一个接口，Dagger会为它生成实现类：

java @Component public interface AppComponent { Car getCar(); // 这个方法告诉Dagger我们需要提供Car实例 }

使用生成的Component：

java AppComponent component = DaggerAppComponent.create(); Car car = component.getCar();

注意那个DaggerAppComponent类？它是Dagger自动生成的！

3. @Module和@Provides

但如果某些类不是我们能修改的呢？比如第三方库的类，我们无法在它们的构造函数上添加@Inject。

这时就需要@Module和@Provides登场了：

java @Module public class AppModule { @Provides NetworkService provideNetworkService() { return new NetworkService(); } }

然后，将Module添加到Component中：

java @Component(modules = AppModule.class) public interface AppComponent { Car getCar(); }

现在Dagger知道如何创建NetworkService了！

4. @Scope和自定义作用域

默认情况下，Dagger每次注入都会创建新的实例。但有时我们希望在某个范围内复用同一个实例（比如单例）。

Dagger提供了@Scope注解来定义作用域：

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

然后可以用它来标记提供方法或组件：

```java @ApplicationScope @Component(modules = AppModule.class) public interface AppComponent { Car getCar(); }

@Module public class AppModule { @Provides @ApplicationScope NetworkService provideNetworkService() { return new NetworkService(); } } ```

这样，NetworkService在AppComponent的生命周期内就是单例的了。

5. @Qualifier和自定义限定符

如果需要提供同一类型的不同实例怎么办？比如，我们需要两种不同的HttpClient：一种用于普通请求，一种用于加密请求。

这时就需要@Qualifier来区分：

```java @Qualifier @Retention(RetentionPolicy.RUNTIME) public @interface AuthClient {}

@Qualifier @Retention(RetentionPolicy.RUNTIME) public @interface NormalClient {}

@Module public class NetworkModule { @Provides @NormalClient HttpClient provideNormalClient() { return new HttpClient(); }

} ```

使用时：

```java public class AuthService { private HttpClient httpClient;

} ```

实际例子：构建一个简单的天气应用

让我们用一个简单的例子来整合所学知识。假设我们要构建一个显示天气的应用：

```java // 1. 定义我们的类 public class WeatherRepository { private final WeatherApi weatherApi;

}

public class WeatherViewModel { private final WeatherRepository repository;

}

// 2. 对于第三方API，我们需要提供它 @Module public class NetworkModule { @Provides WeatherApi provideWeatherApi() { return new RetrofitWeatherApi(); // 假设这是Retrofit实现 } }

// 3. 创建Component @Component(modules = NetworkModule.class) public interface AppComponent { WeatherViewModel getViewModel(); }

// 4. 在Activity中使用 public class MainActivity extends AppCompatActivity { private WeatherViewModel viewModel;

} ```

这个例子展示了Dagger如何帮我们管理依赖链：MainActivity -> WeatherViewModel -> WeatherRepository -> WeatherApi。

Dagger在实际项目中的最佳实践

经过几年的Dagger使用经验，我总结了一些最佳实践：

1. 组件层次结构：为不同生命周期创建不同的Component，比如ApplicationComponent、ActivityComponent等。
2. 适当使用Subcomponent：子组件可以访问父组件的依赖，这对于Activity作用域的依赖很有用。
3. 避免过度使用Scope：只有确实需要在作用域内共享实例时才使用Scope，否则会增加内存占用。
4. 使用Dagger.Android简化：如果你的应用有很多Activity和Fragment，考虑使用Dagger.Android扩展来减少模板代码。
5. 合理组织Module：按功能或层次组织Module，而不是把所有Provider方法都放在一个大Module中。

组件层次结构：为不同生命周期创建不同的Component，比如ApplicationComponent、ActivityComponent等。

适当使用Subcomponent：子组件可以访问父组件的依赖，这对于Activity作用域的依赖很有用。

避免过度使用Scope：只有确实需要在作用域内共享实例时才使用Scope，否则会增加内存占用。

使用Dagger.Android简化：如果你的应用有很多Activity和Fragment，考虑使用Dagger.Android扩展来减少模板代码。

合理组织Module：按功能或层次组织Module，而不是把所有Provider方法都放在一个大Module中。

常见问题及解决方案

使用Dagger时，你可能会遇到这些问题：

1. 无法解析依赖：检查你是否提供了所有必要的依赖，以及Component是否包含了所有必要的Module。
2. 循环依赖：A依赖B，B又依赖A，这会导致编译错误。解决方法是使用Provider或Lazy，或者重新设计你的类。
3. 生成的代码太复杂：这是Dagger的一个痛点。建议使用"Build->Analyze APK"来查看生成的代码大小，必要时简化依赖图。
4. 与其他库集成：例如，将Dagger与ViewModel集成时，可能需要自定义Factory。

无法解析依赖：检查你是否提供了所有必要的依赖，以及Component是否包含了所有必要的Module。

循环依赖：A依赖B，B又依赖A，这会导致编译错误。解决方法是使用Provider或Lazy，或者重新设计你的类。

生成的代码太复杂：这是Dagger的一个痛点。建议使用"Build->Analyze APK"来查看生成的代码大小，必要时简化依赖图。

与其他库集成：例如，将Dagger与ViewModel集成时，可能需要自定义Factory。

结语

Dagger确实有一定的学习曲线，但一旦掌握，它将极大提高你的代码质量和开发效率。依赖注入不仅是一种技术，更是一种思想，它教会我们如何设计松耦合、可测试的代码。

记住，熟能生巧！刚开始可能会觉得概念很多很复杂，但多写几个例子，你会发现Dagger其实很符合直觉。（我当初也是被它的术语吓到了，但坚持下来后发现真的很值得！）

希望这篇教程能帮助你入门Dagger。依赖注入是Android开发的重要技能，掌握它会让你的代码更加专业和健壮。

你有什么Dagger使用中的疑问吗？欢迎在评论区讨论！

参考资源

• Dagger官方文档
• Google Codelab: Using Dagger in Android Apps
• Android开发者文档: 依赖注入

Happy coding!