我写了一篇关于Dagger0.1初体验的文章，如何没有了解伙伴可以先看上一篇，可能会对本文章有比较好的体验。
我是wzg，也是墨。
Dagger2使用0.1快捷链接：
https://www.jianshu.com/p/587e0b9e1ce6
1.为了加深记忆，我把注解放在文章的开头
/**
*
* @Inject 通常再需要依赖的地方使用这个注解。换句话说，你用它告诉你Dagger这个类的或者字段需要依赖注入，这样dagger就会构造一个这个类的实例并满足他们的依赖
*
* @module module 类里面的方法专门提供依赖 ，也就是存储实例的容器
*
* @Provide 再module中，我们定义的方法是用这个依赖，以此告诉Dagger我们想要构建对象并提供这些依赖
*
* @Component 注入器（也就是万我理解的桥梁），提供所有定义的实例，只能使用在接口上
*
*/
2.上一篇中介绍了如何调用一个无参数的构造并且运行使用正在的Dagger例子，本文讲介绍如何调用有参数的构造方法，可能这时候你想到了 会比无参数更加复杂，是的，废话不多说：
假设我有一个这样的需求，我们需要在别的地方使用register（）
public class UserManager {
LocalStore localStore;
ApiService apiService;
public UserManager(LocalStore mLocalStore, ApiService mApiService) {
localStore = mLocalStore;
apiService = mApiService;
}
public void register() {
LogR.logDateE("UserManager----->register（）");
apiService.register();
localStore.register();
}
}
mainActivity 和ApiService及LocalStore是这样的
####MainActivity
@Inject
UserManager userManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
userManager.register();
}
####ApiService
public class ApiService {
OkHttpClient mOkHttpClient;
public ApiService(OkHttpClient mOkHttpClient) {
LogR.logDateE("服务端----->ApiService()");
this.mOkHttpClient = mOkHttpClient;
}
//服务端保存数据
public void register() {
LogR.logDateE("服务端----->register()");
mOkHttpClient.newCall(request)
.enqueue(new Callback() {
......
});
}
}
###LocalStore
public class LocalStore {
private Context mContext;
public LocalStore(Context mContext) {
this.mContext = mContext;
}
//用户端保存数据
public Boolean register() {
LogR.logDateE("用户端保存数据");
//这里的sp对象过程被简写了，因为没有意义
return sp.edit().putString("", "").commit();;
}
}
我们使用Dagger如何才能正常工作呢？
记得上一篇中，我有讲过使用了@Inject 注解，Dagger会从@Component的接口中查找，
所以我需要创建一个带@Component的接口
@Component(modules ={UserModule.class })
public interface UserComponent {
//通常写法：内部是使用者
void inject(MainActivity mainActivity);
}
上面中我们可以看到@Component(modules ={UserModule.class })依赖于Module
，所以我们需要一个Module：
@Module()
public class UserModule {
/**
* 我个人理解的规则就是
*
* 1.调用无参数的构造方法 建议使用@Inject就可以了（直接在构造中方法中使用@Inject）
* 2.使用有参数的构造方法 可以通过传递的方式或者依赖其他的module【比如：@Module(includes = {HttpModule.class})//引用okHttpModule】
*/
@Provides
public UserManager provideUserManager(ApiService mApiService, LocalStore mLocalStore) {
LogR.logDateE("UserModule----->provideUserManager(ApiService mApiService,UserStore mUserStore)");
return new UserManager(mLocalStore, mApiService);
}
}
写完上面我们就会发现，光是这样是不行的，我们需要的参数没有地方可以传入，
这个时候就有了下面的代码：
Context mContext;
//被调用一定要有对应的参数传递
public UserModule(Context context) {
this.mContext = context;
}
@Provides
public ApiService provideApiService(OkHttpClient client) {
LogR.logDateE("UserModule----->provideApiService(OkHttpClient client)");
return new ApiService(client);
}
@Provides
public LocalStore provideUserStore() {
LogR.logDateE("UserModule----->provideUserStore()");
return new LocalStore(mContext);
}
这个时候细心的你一定发现构造中的Context对象和client对象也需要传入
，但是client对象一般都是要保持单利模式的，保持神秘感，下一篇我们再讨论这个问题
，这个两个参数该如何传递呢？
@Module
public class HttpModule {
// @Singleton//表明单例，默认多实例
@Provides//提供者
public OkHttpClient provideOkHttpClient(){
return new OkHttpClient().newBuilder().build();
}
}
看完上面的代码心里有没有多出来疑惑，为什么要这样子？
我个人做法是考虑到client对象需要全局使用，各方可以进行依赖并使用它.
接下来如何传递和依赖这个HttpModule类呢？
@Module(includes = {HttpModule.class})//引用okHttpModule
public class UserModule {
......
}
有没有茅塞顿开的感觉，一下子全通了、、、
最后使用只需要在MainActivity中这样使用即可：
MainActivity全代码：
@Inject
UserManager userManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//再次提醒需要ReBuild才有DaggerxxComponent对象
DaggerUserComponent.builder()
.userModule(new UserModule(this))
.httpModule(new HttpModule())
.build()
.inject(this);
userManager.register();
}
本文到了这里就结束了，但是Dagger2还没有结束，请期待下一篇文章。
看完这一篇文章是否对Dagger2有了的感悟，感觉也没有说的那么那么上手，
如果这样的话，首先你该给我一颗个星星，谢谢，我们下篇继续。
