关于Dagger2的一些个人理解

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u013762572/article/details/79647466

写作目的

现在基本上有一些规模的项目，都使用了Dagger2，也不是装13，个人感觉也的确是大势所趋，Dagger2的确有它的优势。借着手上的项目，学习了一下Dagger2，打算用在公司的项目中。今天就来以自己初学者的角度来谈谈dagger2的认识。

问题由来

我是目前是移动端开发者，主要从事的是Android端开发。在andorid开发过程中，按照套路我们会有SharePreferenceManager、DatabaseManager、NetWorkManager、CacheManager等各种Manager，当然你的叫法也可以不同，他们都会存在初始化，考虑到有种可能的初始化顺序，如下图：

我们可能需要先使用Application初始化SpManager(SharePreferenceManager)拿到一些关键数据，从而通过这些数据来初始化DbManager，NWManager或者CacheManager。可以看到我们的各个对象就存在初始化先后的问题，试想如果系统过于复杂，像这种对象初始化有相互依赖的各种关系，想必是非常复杂的；如果是我们用代码去写，也是很繁杂的而且没多大效率的；还有一个问题,看下图：

如果有一天，我们的E对象突然改变了初始化方法，而且很多地方都需要E对象的初始化，那我们是不是很懵，因为有很多地方需要修改，那苦逼的程序员是不是很难受，这也就是我们常说的程序的耦合性，改一处，就要变100处地方。很显然dagger的出现就是为了解决这个问题的。具体怎么解决，我还有想用一张图来说明我的想法：

假设dagger在初始化某对象时，同时需要a b c g四个对象，它就会在容器中寻找(这里的寻找有可能是上一次创建的)，找到了就拿来使用，没有找到就需要靠自身去创建了。你可以看到a d g对象都会存在，此时c对象不存在，那么此时的c对象的创建又变成了XObject对象的创建，此时需要找到c对象创建时，需要m对象和p对象，一环一环套下去，然后直到所有的需要的对象都创建完成，然后再递归到需要它需要创建的对象，直到所有的对象初始化完成。明白了这个道理，感觉学习dagger2就不难了。

开始Dagger2

配置

AS , gradle配置：

    //dagger2
    compile 'com.google.dagger:dagger:2.14.1'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.14.1'

新建Student类：

public class Student {
    private String name ;
    private int score ;

    @Inject
    public Student(){
        this.name = "zhangsan" ;
        this.score = 30 ;
    }

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

和普通java类一致，只是在构造方法上使用了注解@javax.inject.Inject注解，第一步完成；

创建接口StudentComponent,当然这个接口名字你可以乱写，但是为了规范我还是建议你初始化啥对象，就写这个名字，接口很简单：

@Component
public interface StudentComponent {
    void inject(SecondActivity activity);
}

我们需要一个@dagger.Component的注解，和一个SecondActivity，这个SecondActivity是我们需要用到的Activity，在这个Activity中我们需要对Student对象进行初始化：
SecondActivity源码：

public class SecondActivity extends AppCompatActivity {

    @Inject
    Student su;

    TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        tv = findViewById(R.id.id_tv_content);
    }

    public void getStudentInfo(View view) {
        tv.setText(su.toString());
    }
}

在我们需要的初始化的对象上Student也加上@Inject注解，其他的好像真的完事了，就这么简单？当然，你需要将make一下你的project(这里吐槽一下当年使用window系统最终放弃了dagger2无数次，make项目绝对是我不想坚持下去的最大原因，太尼玛花时间了)，然后加上一句话：

编译运行，我们可以看到：

的确，程序没有我们想象中报了异常，而是真的被初始化，而且被赋值了。第一次用Dagger2的感觉就是这么神奇。当然这算得上Dagger2最简单的应用场景吧。

不过，距离真正去使用Dagger2还有有一定的差距，因为我们还缺少一样叫module的类。真正的Dagger2是存在三部分的。
1. 对象的实例化部分，相当于我们的new Object(); Dagger提供类似容器功能，提供实例化的功能；这一个叫module；
2. 需要实例化的部分，你实例化的对象需要被用得到，这是个非常抽象的部分，可以使是Activity，也可以是Fragment，或者是任意的Java对象；
3. 连接部分，将实例化的对象和需要用到这些对象的部分连接起来。这一个在dagger中叫Component。

好了，有了上面的简单说明，我们来个真正的dagger用法。来个Student2对象，相当于我们的数据：

public class Student2 {
    private String name ;
    private int score ;

    public Student2(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

现在我们需要module组件，给我们提供对象实例化的，这个可能稍微有点拐弯：

@Module
public class Student2Module {

    @Provides
    public String provideName() {
        return "lisi" ;
    }

    @Provides
    public int provideScore(){
        return 98 ;
    }

    @Provides
    public Student2 provideStudent2(String name , int score){
        return new Student2(name,score);
    }
}

我们看到了@provides，这是来自Dagger的注解，正如翻译过来，就是给你提供数据量，它提供了一个Student2对象，那么问题来了，那name和score是哪里来的呢？同样我们看到了它提供另外两个方法provideScore()和provideName(),同样也被@Provides注解修饰，意思就是我给你提供数据量。

已经有数据可以提供了，那哪里需要这个数据呢？来，看一下我们的Activity，在Activity中有地方需要它:

public class ThirdActivity extends AppCompatActivity {

    @Inject     //这里使用@Inject 说明我需要被初始化
    Student2 stu ;

    TextView tv ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
       tv = findViewById(R.id.id_tv_content);
    }

    //这里是按钮的点击作用，我们需要看一下这个Student2对象是否被初始化  
    public void getStudentInfo(View v) {
        tv.setText(stu.toString());
    }

}

数据源和数据去向都有了，那我们就需要一个中间的连接着Component了，好了，我们来造一个Component，如下：

@Component(modules = Student2Module.class)  //这就是中间的链接部分，数据源就是这个modules所对应的数据类
public interface Student2Component {    //Component是接口，相当于中间件

    void inject(ThirdActivity activity);  //这个是数据去向，注意不要使用什么BaseActivity，一定要写具体的activity
}

好了，然后我们make(build,reBuild)一下我们的项目，然后在ThirdActivity中添加一句代码：

这个DaggerStudentComponent是Dagger框架自动生成的，它是由你的Component接口然后加上Dagger前缀生成的，作用是连接我们的数据源和数据接收者。点击按钮，可以看到结果：

结果就是我们想要的，也可以看到Student2Module中提供的name和score的确在Activity的Student2对象中了。是不是很简单呢？是啊，我们的dagger注入框架就好了，这就是注入的效果。

但是你有没有一种感觉，为啥Student类和Student2对象中，Student构造器中使用了@Inject注解，但是Student2构造器中没有使用@Inject呢；为啥Student对应的StudentComponent没有提供获取Student方法，而Student2Component中提供了获取Student2的方法呢？

这就需要我们理解Module作为数据提供者，提供数据也是有先后顺序的，一般顺序如下：
1. 我现在module数据提供者中找有没有提供初始化对象的方法；
2. 我找到了，我就返回该对象；
3. 我没有找到，我就去查看这个对象的构造器是否被@Inject找到
4. 找到了，那么自己执行new Object过程；没有找到，对不起，编译出错，说明你dagger方法使用错误。

所以，综上所述，一个对象的构造器Constructor没有被@Inject修饰，那么在Module中必须有方法提供初始化对象。

好了，我们接下来就说一说工作和生活中用得比较多的对象，也就是关于dagger的标识符问题了。

@Singleton

和Java思想中一致，就是单例的意思。这里的单例依据个人的理解，一个数据接收容器中存在多个数据接收者，那么多个数据接收者指向的对象是同一个。说的自己都有点不信了，举个例子：
定义StudentSingleton数据结构：

@Singleton
public class StudentSingleton {

    private String name ;
    private int score ;

    @Inject //看这里被@Inject修饰了
    public StudentSingleton(String name, int score) {
        this.name = name;
        this.score = score;
    }

}

数据提供者StudentSingletonModule：

@Module
public class StudentSingletonModule {

    @Provides
    public String getName(){
        return "tom";
    }

    @Provides
    public int score() {
        return 20;
    }

}

数据需求者SingletonActivity，可以看得到里面有两个StudentSingleton对象等待被初始化：

public class SingletonActivity extends AppCompatActivity {

    @Inject
    StudentSingleton singleton1 ;

    @Inject
    StudentSingleton singleton2 ;

    TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        tv = findViewById(R.id.id_tv_content);

        //build之后 进行对象注入
        DaggerStudentSingleComponent.builder().build().inject(this);
    }

    public void getStudentInfo(View v) {
        tv.setText(singleton1 + "\n" + singleton2);
    }
}

我们看一下结果：

我们可以看到两个StudentSingleton对象指向的相同的地址，那么说明它们是同一个对象。
同样，我们在另外一个Activity中也需要一个StudentSingleton，如下代码：

public class AnotherStudentSingletonActivity extends AppCompatActivity {

    @Inject
    StudentSingleton stu ;

    TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_another_student_singleton);

        tv = findViewById(R.id.id_tv_content);

        DaggerStudentSingleComponent.builder().build().inject(this);
    tv.setText(stu.toString());
    }
}

获取的结果为：

由此可见，@Singleton注解并不是我们平常意义上的单例，只是在同一个容器的中，指向同一个对象才可能被称为单例。

当然了，你去掉@Singleton注解，去看看在一个Activity同时获取两个StudentSingleton对象，地址是不是一样呢？答案肯定是不一样的。

初始化对象时，需要获取外部参数

这个在Andorid中需求的比较多，很多时候我们需要一个Context对象，到处都是Context对象，举个例子：
先来个StudentContext对象：

public class StudentContext {
    private String name ;
    private int score ;
    private Context context;

    public StudentContext(){}

    @Inject  //注意@Inject注解修饰的这个构造器
    public StudentContext(String name, int score, Context context) {
        this.name = name;
        this.score = score;
        this.context = context;
    }

    @Override
    public String toString() {
        return "StudentContext{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", context=" + context +
                '}';
    }
}

在我们的Module中，我们这时需要传入一下个Context对象：

@Module
public class StudentContextModule {

    private Context context;

    //此时需要你传入一个Context对象进入  
    public StudentContextModule(Context context) {
        this.context = context;
    }

    @Provides
    public String provideName() {
        return "jerry" ;
    }

    @Provides
    public int provideScore() {
        return 20 ;
    }

    //这里提供一个Context对象方法 
    @Provides
    public Context provideContext() {
        return context;
    }
}

我们桥接对象为：

@Component(modules = StudentContextModule.class)
public interface StudentContextComponent {
    void inject(StudentContextActivity activity);
}

make一下我们的项目，在数据接收容器StudentContextActivity中，这么写：

public class StudentContextActivity extends AppCompatActivity {
    @Inject
    StudentContext sContext;

    TextView tv ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        tv = findViewById(R.id.id_tv_content);

    //这里我们就需要提供一个StudentContextModule对象
    //是的，这个对象是我们New的
        DaggerStudentContextComponent.builder().studentContextModule(new StudentContextModule(this)).build().inject(this);
    }

    public void getStudentInfo(View v) {
        tv.setText(sContext.toString());
    }
}

结果为：

你可以看到，我们的Context对象也被传入进去了，其实就是我们的StudentContextModule被new时传入的this写入的。

依赖Module

这个意义，就相当我们每个应用中只有一个Application，我们的Activity可以依赖于这个Application，然后可以Toast，SharePreference我们想要的东西。那么就来一个AppModule，全局来一个Context：

@Module
public class AppModule {

    private Context context ;

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

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

    @Provides
    public String provideGlobalName() {
        return "globalName" ;
    }

}

那么它对应的Component为：

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

    /**
     * 向下提供Context
     * @return
     */
    Context getContext();

    /**
     * 向下提供Name
     * @return
     */
    String getStringName();
}

这里有一点需要声明一下，APPComponent将要被依赖，那么它需要暴露出提供初始化对象的方法，然后依赖它的Component将找不到。
好了，基类被依赖的APPComponent已经有了，现在来一个ActivityComponent，它提供了StudentContext对象方法和score对象方法。

@Module
public class ActivityModule {

    @Provides
    public StudentContext provideStudentContext(Context context,String name , int score) {
        return new StudentContext(name,score,context);
    }

    @Provides
    public int provideActivityScore() {
        return 78 ;
    }

}

那么重点来了，ActivityComponent将会依赖AppComponent，AppComponent将会提供Context对象方法和name对象方法，注意dependencies关键字，它指向了依赖的对象，同时依赖的对象也是一个Component。

@Component(modules = ActivityModule.class, dependencies = AppComponent.class)
public interface ActivityComponent {

    void inject(DependencyActivity activity);
}

在DependencyActivity中：

public class DependencyActivity extends AppCompatActivity {

    @Inject
    StudentContext sContext;

    TextView tv ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        tv  = findViewById(R.id.id_tv_content);

        //先获取AppComponent对象
        AppComponent appComponent =  DaggerAppComponent.builder().appModule(new AppModule(this)).build();

        //ActivityComponent对象将会依赖于AppComponent
        DaggerActivityComponent.
                builder().
                appComponent(appComponent).
                build().inject(this);
    }

    public void getStudentInfo(View v) {
        tv.setText(sContext.toString());
    }

}

同样我们打印结果为：

@Name注解

主要解决同一个容器中，同时又多个相同对象需要被注入，如果你不做任何指导，那么dagger就不确定数据注入的唯一性(数据提供者 -> 数据接收者)，此时有一种方法就是使用@Name注解：
还是定义一个StudentForNameAt对象，可以看到它有一个name和context属性

public class StudentForNameAt {

    private String name ;

    private Context context;

    public StudentForNameAt(String name) {
        this.name = name;
    }

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

    @Override
    public String toString() {
        return "StudentForNameAt{" +
                "name='" + name + '\'' +
                ", context=" + context +
                '}';
    }
}

那么NameAtModule需要这么写：

@Module
public class NameAtModule {

    private Context context ;
    private String name ;


    public NameAtModule(Context context,String name) {
        this.context = context;
        this.name = name;
    }

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

    @Named("context")  //这里使用"contex"标识
    @Provides
    public StudentForNameAt provideStudentForNameAtContext() {
        return new StudentForNameAt(context);
    }

    @Named("name")   //这里使用"name"标识
    @Provides
    public StudentForNameAt provideStudentForNameAtName(){
        return new StudentForNameAt(name);
    }

}

最后，在我们的NameAtActivity中，同时也需要@Name("name")和@Name("context")标识对象的注入：

public class NameAtActivity extends AppCompatActivity {

    @Named("name")   //这里标识
    @Inject
    StudentForNameAt at1 ;

    @Named("context")  //这里标识
    @Inject
    StudentForNameAt at2 ;

    TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        tv = findViewById(R.id.id_tv_content);

        DaggerNameAtComponent.builder().nameAtModule(new NameAtModule(this,"hello world")).build().inject(this);
    }

    public void getStudentInfo(View v) {
        tv.setText(at1.toString() + "\n" + at2.toString());

    }
}

获取结果为：

可以看到，我们的两个StudentForNameAt对象分别被注入了Name和Context。

当然这只是其中一种方法，还有一种方法就是自定义的Qualifier标识符。

@Qualifier 自定义标识符

@Qualifier标识符也是为了解决上面的问题，我们来同时定义一下两个注解标识符@StudentForName和StudentForScore：

@Qualifier       //dagger Qualifier标识符
@Retention(RetentionPolicy.RUNTIME)  //标识为运行时状态
public @interface StudentForName {}

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

定义一个StudentQualifier对象，如下：

public class StudentQualifier {

    private String name ;
    private int score ;

    public StudentQualifier(){  //空的构造器 name是Tom score是77
        this.name = "Tom";
        this.score = 77 ;
    }

    public StudentQualifier(String name , int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "StudentQualifier{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

数据提供者Module为：

@Module
public class StudentQualifierModule {

    @Provides
    public String provideName(){
        return "zhangsan" ;
    }

    @Provides
    public int provideScore(){
        return 22 ;
    }

    @StudentForScore    //默认构造器被@StudentForScore修饰
    @Provides
    public StudentQualifier provideStudent(){
        return new StudentQualifier();
    }

    @StudentForName     //有参构造器被@StudentForName修饰
    @Provides
    public StudentQualifier provideStudentWithParams(String name , int score){
        return new StudentQualifier(name,score);
    }
}

然后在数据QualifierActivity接收器中：

public class QualifierActivity extends AppCompatActivity {

    TextView tv;

    @StudentForName     //被@StudentForName修饰，按道理应该是调用了有参构造器
    @Inject
    StudentQualifier qualifier1 ;

    @StudentForScore   //这个就是无参数的
    @Inject
    StudentQualifier qualifier2 ;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        tv = findViewById(R.id.id_tv_content);

        DaggerStudentQualifierComponent.builder().build().inject(this);
    }

    public void getStudentInfo(View v) {

        tv.setText(qualifier1.toString() + "\n" + qualifier2.toString());
    }

}

我们猜测一下结果，qualifier1应该为zhangsan和22；qualifier2应该为这Tom和77，结果为：

结果一致。

@PerApp and @PerActivity

我也不知道为什么，上github上看dagger写的代码，都少不了这个两个注解。如果理解了@Singleton注解的意义，那么@PerApp和@PerActivity意义就差不多。上面已经说过，一个App中只有一个Applicataion,那么我们可以定义一个注解@PerApp
生命周期可以与Application一致，那么就可以理解为@PerApp修饰的方法，提供的对象在全局范围是单例的；如果定义一个@PerActivity,那么@PerActivity修饰的方法返回的对象，生命周期是与Activity是一致的。举个例子吧：
定义一个@AndroidPerApp

@Scope        //这里是@Scope 注意不是@Qualifier
@Documented  //文档标记
@Retention(RetentionPolicy.RUNTIME)
public @interface AndroidPerApp {

}

再定义一个Module,此时有个方法被@AndroidPerApp修饰：

@Module
public class AndroidPerAppModule {

    private Context context;

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

    @Provides
    @AndroidPerApp  //标记该方法只产生一个实例 该实例的生命周期与绑定的Context生命周期一致
    public Context provideContext(){
        return context;
    }

}

此时我们的AndroidPerAppComponent

@AndroidPerApp   //AndroidPerAppModule有方法被@AndroidPerApp修饰 那么此时AndroidPerAppComponent也要被@AndroidPerApp修饰
@Component(modules = AndroidPerAppModule.class)
public interface AndroidPerAppComponent {

    /**
     * 向下提供Context
     * @return
     */
    Context getContext();
}

此时，既然是AppComponent，那么需要与App绑定了：

public class MyApp extends Application{

   //这里使用静态的 因为MyApp全局就一个   
    static AndroidPerAppComponent component ;

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

        component = DaggerAndroidPerAppComponent.builder().androidPerAppModule(new AndroidPerAppModule(this)).build();
    }

    public static AndroidPerAppComponent getAppComponent(){
       return component;
    }

}

那么我们可以全局调用MyApp.getAppComponent()了，这个等会再用，现在再来顶一个@PerActivity：

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

在AndroidPerActivityModule中，Activity生命周期范围内，返回的数据是单例的，其实是和@Singleton作用是一致的，它并没有像市面上说的，具有和Activity相同生命周期的说法。

@Module
public class AndroidPerActivityModule {

    @AndroidPerActivity   
    @Provides
    public Student provideStudent(){
        return new Student();
    }

}

然后最重要的是PerActivityComponent了：

@AndroidPerActivity    
@Component(modules = AndroidPerActivityModule.class,
           dependencies = AndroidPerAppComponent.class)
public interface AndroidPerActivityComponent {

    void inject(AndroidAnnotationActivity activity);
}

在AndroidAnnotationActivity中：

public class AndroidAnnotationActivity extends AppCompatActivity {

    @Inject
    Student st1 ;

    @Inject
    Student st2;

    TextView tv ;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        tv = findViewById(R.id.id_tv_content);
        //直接使用App.getAppComponent()获取全局的AppComponent对象
            DaggerAndroidPerActivityComponent.builder().androidPerAppComponent(MyApp.getAppComponent()).build().inject(this);
    }

    public void getStudentInfo(View v) {
        //Toast.makeText(this, "---->>" + MyApp.getAppComponent(), Toast.LENGTH_SHORT).show();

        tv.setText(st1.toString() + "--\n--" + st2.toString());
    }
}

我们此时开看一下st1和st2的结果：

可以看出，它们在AndroidAnnotationActivity范围内是单例的，这个和@Singleton注解是一致的。工作中我们会用到@PerApp，它解决了我们全局需要Context的问题。

Lazy 和 Provider

根据词义，Lazy相当于我们懒加载机制，调用了本方法才会去加载，没有调用就不加载；Provider很类似@Provides注解，但是它在的含义是每次调用都会去重复调用Module被@Provides修饰的方法。举个例子：
定义一个对象类型StudentOther：

public class StudentOther {
    private String name ;
    private int score ;
    private String address ;

    //初始化过程中会使用random对象 以此来模拟是否为重复创建    
    public StudentOther(Random random) {
        this.name  = "zhansgan" + random.nextDouble()  ;
        this.score  = random.nextInt(200);
        this.address = "shanghai" + random.nextGaussian();
    }

    @Override
    public String toString() {
        return "StudentOther{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", address='" + address + '\'' +
                '}';
    }
}

定义一个OtherActivityModule对象，提供了Random方法，还有两个@StudentForName和@StudentForScore注解修饰的方法：

@Module
public class OtherActivityModule {

    public Random random ;

    public OtherActivityModule(){
        random  = new Random();
    }

    @Provides
    public Random provideRandom(){
        return random;
    }

    @StudentForName
    @Provides
    public StudentOther provideStudentOther(Random random){
        return new StudentOther(random);
    }

    @StudentForScore
    @Provides
    public StudentOther provideStudentOtherWidth(Random random){
        return new StudentOther(random);
    }
}

在数据接收器OtherActivity中，如下：

public class OtherActivity extends AppCompatActivity {

    @StudentForScore
    @Inject
    Lazy<StudentOther> other;

    @StudentForName
    @Inject
    Provider<StudentOther> other2 ;

    TextView tv;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        tv = findViewById(R.id.id_tv_content);

        DaggerOtherActivityComponent.builder().build().inject(this);
    }

    public void getStudentInfo(View v){
        StudentOther innerOther = other.get();       //调用该方法时才会去创建
        StudentOther innerOther2 = other2.get();     //调用该方法时才会去创建，但是每次都会重新加载Module中的方法 返回值有可能相同 也有可能不同

        tv.setText(innerOther.toString() + "---\n---" + innerOther2.toString());
    }
}

我们来看一下结果：

我们可以看到innerOther始终是同一个值，而innerOther2却一直是变化的，说明每次调用Provide.get()时都去刷新了

@StudentForName
    @Provides
    public StudentOther provideStudentOther(Random random){
        return new StudentOther(random);
    }

方法。

好了，基本上总结的差不多了，文章写了很久。稍后会把代码上传一下，也算是给自己的一个交代了吧。
基本上样式如下：