dagger2简单使用

1.首先应该创建一个全局的AppComponent，以提供全局使用的工具类进行使用，例如先创建一个ToastUtil类

public class ToastUtil {

    private Context mContext;

    public ToastUtil(Context context){
        this.mContext = context;
    }

    public void showToast(String message){
        Toast.makeText(mContext,message,Toast.LENGTH_LONG).show();
    }


}

对应的AppModule应该负责实现工具类的实例化操作，其中的Singleton并不能实现单利模式，但是可以表示是一个单例，帮助用户更好的理解。

@Module
public class AppModule {

    Context context;

    public AppModule(Context context){
        this.context = context;
    }

    @Provides @Singleton
    public Context provideContext(){
        return context;
    }

    @Provides @Singleton
    public Navigator provideNavigator(){
        return new Navigator();
    }

    @Provides @Singleton
    public ToastUtil provideToastUtil(){
        return new ToastUtil(context);
    }
}

至此，AppComponent实现如下：其中getContext（）等方法名可以任取，只要返回值对应Module中的返回值，调用时候即可找到。

@Singleton
@Component(modules={AppModule.class})
public interface AppComponent {

    Context getContext();

    Navigator getNavigator();
    ToastUtil getToastUtil();
//    Test test();

}

2.编写BaseActivity，这里提供一个方法，用来获取AppComPonent，因为需要在全局的App类中提供此方法

public class BaseActivity extends AppCompatActivity {

    public AppComponent getAppComponent(){
        return ((App)getApplication()).getAppComponent();
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
}

全局App类，用来提供AppComponet,

public class App extends Application {

    AppComponent mAppComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        mAppComponent = DaggerAppComponent.builder().appModule(new AppModule(this)).build();

    }

    public AppComponent getAppComponent(){
        return mAppComponent;
    }
}

3.接下来，就是一个主Activity和一个主Fragment进行方法调用，Activity中只放了一个Fragment，所以所有的方法调用均在Fragment中，并且使用MVP架构，通过

Presenter进行调度。

（1）MainPresenter实现，提供一个方法getUser，而GetUserDate类里面的构造方法直接添加@Inject注入，这样Module中就不用进行provite了。

public class MainPresenter {

    public GetUserData mUserData;
    private IUserView mUserView;



    @Inject
    public MainPresenter(GetUserData userData){
        this.mUserData = userData;
    }

    public void getUser(){
        UserData userData = this.mUserData.getUser();
        this.mUserView.setUserName(userData.mUserName);
    }
    public void setUserView(IUserView userView){
        this.mUserView = userView;
    }

    public static interface IUserView{
        void setUserName(String name);
    }
}

（2）MainActivity实现，这里向Fragment提供MainComPonent

public class MainActivity extends BaseActivity implements MainFragment.OnFragmentInteractionListener{

    private MainComponent mMainComponent;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mMainComponent = DaggerMainComponent.builder().appComponent(getAppComponent())
                .mainModule(new MainModule())
                .activityModule(new ActivityModule(this)).build();
        mMainComponent.inject(this);
    }

    public MainComponent getMainComponent(){
        return mMainComponent;
    }

    @Override
    public void onFragmentInteraction(Uri uri) {

    }

}

（3）MainComponent实现

MainComponent继承了ActivityComponent，假如ActivityComponent中定义了创建类实例方法，则MainComponent中必须提供@Inject或@Provides对应的

这里的PerActivity是自定义的Scopes，只是一个注解标识。MainComponent还向外提供了MainFragmentComponent。

PerActivity实现

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

MainComponent

@PerActivity
@Component(dependencies = AppComponent.class,modules = {MainModule.class, ActivityModule.class})
public interface MainComponent extends ActivityComponent{
    //对MainActivity进行依赖注入
    void inject(MainActivity mainActivity);


    MainFragmentComponent getMainFragmentComponent();
}

MainFragmentComponent实现，其中@Subcomponent表示包含关系，即，MainComponent包含了MainFragmentComPonent

@PerActivity
@Subcomponent
public interface MainFragmentComponent {


    void inject(MainFragment mainFragment);
}

ActivityComponent实现，是BaseActivity的Component。

@PerActivity
@Component(modules = {ActivityModule.class})
public interface ActivityComponent {

    Activity getActivity();
}

对应的ActivityModule

@Module
public class ActivityModule {

    private final Activity activity;
    public ActivityModule(Activity activity){
        this.activity = activity;
    }

    @Provides @PerActivity
    public Activity provideActivity(){
        return activity;
    }



}
对应的MainModule

@Module
public class MainModule {

    @Provides
    public GetUserData provideUserData(){
        return new GetUserData();
    }

}
这里需要说明的是，因为MainComPonent连着MainModule，而MainModule向外提供了GetUserDate，而MainPreSenter又有着@Ingect注入，因此，会自动通过

构造函数获取到userDate。


4.最后就是Fragment的实现了，这里只给出主要部分。

public class MainFragment extends BaseFragment implements MainPresenter.IUserView{
    // TODO: Rename parameter arguments, choose names that match

    @Inject
    MainPresenter mainPresenter;
    @Inject
    ToastUtil toastUtil;

    @Inject
    MultiConstruct multiConstruct;

    private MainFragmentComponent mainFragmentComponent;

    private OnFragmentInteractionListener mListener;

    public MainFragment(){

    }

    /**
     * Use this factory method to create a new instance of
     * this fragment using the provided parameters.
     *
     * @param param1 Parameter 1.
     * @param param2 Parameter 2.
     * @return A new instance of fragment MainFragment.
     */
    // TODO: Rename and change types and number of parameters
    public static MainFragment newInstance(String param1, String param2) {
        MainFragment fragment = new MainFragment();
        Bundle args = new Bundle();

        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        if(getActivity() instanceof MainActivity){
            mainFragmentComponent = ((MainActivity)getActivity() ).getMainComponent().getMainFragmentComponent();
            mainFragmentComponent.inject(this);
            mainPresenter.setUserView(this);
        }
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_main, container, false);

        view.findViewById(R.id.get_user).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                mainPresenter.getUser();
            }
        });
        view.findViewById(R.id.show_toast).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                toastUtil.showToast("依赖注入获取到的toast");
            }
        });

        return view;
    }