是什么决定了 Dagger 2 中组件(对象图)的生命周期?

2022-08-31 08:00:44

我试图在Dagger 2中围绕范围,特别是作用域图的生命周期。如何创建将在离开作用域时清理的组件。

对于 Android 应用程序,使用 Dagger 1.x,您通常在应用程序级别有一个根作用域,您可以扩展该根作用域以在活动级别创建子作用域。

public class MyActivity {

    private ObjectGraph mGraph;

    public void onCreate() {
        mGraph = ((MyApp) getApplicationContext())
            .getObjectGraph()
            .plus(new ActivityModule())
            .inject(this);
    }

    public void onDestroy() {
        mGraph = null;
    }
}

只要您保留对子作用域的引用,子作用域就存在,在本例中,子作用域是活动的生命周期。在 onDestroy 中删除引用可确保范围图可以自由地进行垃圾回收。

编辑

杰西·威尔逊(Jesse Wilson)最近发布了一个罪魁祸首

Dagger 1.0严重搞砸了它的范围名称...@Singleton注释同时用于根图和自定义图,因此很难弄清楚事物的实际范围是什么。

以及我所读到/听到的所有其他内容都指向Dagger 2改进了示波器的工作方式,但我正在努力理解其中的区别。根据@Kirill Boyarshinov在下面的评论,组件或依赖项的生命周期仍然像往常一样由具体的引用决定。那么,Dagger 1.x 和 2.0 范围之间的区别纯粹是语义清晰的问题吗?

我的理解

匕首 1.x

依赖关系要么是,要么是没有。根图和子图中的依赖关系也是如此,导致依赖关系绑定到哪个图的模糊性(请参阅在 Dagger 中,子图中的单例是缓存的,还是在构造新的活动子图时始终重新创建它们?@Singleton)

匕首 2.0

自定义作用域允许您创建语义清晰的作用域,但在功能上等效于在 Dagger 1.x 中应用。@Singleton

// Application level
@Singleton
@Component( modules = MyAppModule.class )
public interface MyAppComponent {
    void inject(Application app);
}

@Module
public class MyAppModule {

    @Singleton @Named("SingletonScope") @Provides
    StringBuilder provideStringBuilderSingletonScope() {
        return new StringBuilder("App");
    }
}

// Our custom scope
@Scope public @interface PerActivity {}

// Activity level
@PerActivty
@Component(
    dependencies = MyAppComponent.class,
    modules = MyActivityModule.class
)
public interface MyActivityComponent {
    void inject(Activity activity);
}

@Module
public class MyActivityModule {

    @PerActivity @Named("ActivityScope") @Provides
    StringBuilder provideStringBuilderActivityScope() {
        return new StringBuilder("Activity");
    }

    @Name("Unscoped") @Provides
    StringBuilder provideStringBuilderUnscoped() {
        return new StringBuilder("Unscoped");
    }
}

// Finally, a sample Activity which gets injected
public class MyActivity {

    private MyActivityComponent component;

    @Inject @Named("AppScope")
    StringBuilder appScope

    @Inject @Named("ActivityScope")
    StringBuilder activityScope1

    @Inject @Named("ActivityScope")
    StringBuilder activityScope2

    @Inject @Named("Unscoped")
    StringBuilder unscoped1

    @Inject @Named("Unscoped")
    StringBuilder unscoped2

    public void onCreate() {
        component = Dagger_MyActivityComponent.builder()
            .myApplicationComponent(App.getComponent())
            .build()
            .inject(this);

        appScope.append(" > Activity")
        appScope.build() // output matches "App (> Activity)+" 

        activityScope1.append("123")
        activityScope1.build() // output: "Activity123"

        activityScope2.append("456")
        activityScope1.build() // output: "Activity123456"

        unscoped1.append("123")
        unscoped1.build() // output: "Unscoped123"

        unscoped2.append("456")
        unscoped2.build() // output: "Unscoped456"

    }

    public void onDestroy() {
        component = null;
    }

}

结论是,使用传达了您关于此组件生命周期的意图,但最终您可以随时随地使用该组件。Dagger 的唯一承诺是,对于给定的组件,作用域注释的方法将返回单个实例。我还假设 Dagger 2 使用组件上的范围注释来验证模块是否仅提供位于相同作用域或非作用域中的依赖项。@PerActivity

总结

依赖项仍然是单例或非单例,但现在适用于应用程序级单一实例,自定义作用域是注释生命周期较短的单一实例依赖项的首选方法。@Singleton

开发人员负责通过删除不再需要的引用来管理组件/依赖项的生命周期,并负责确保组件仅在其预期范围内创建一次,但自定义范围注释使标识该范围变得更加容易。

$64k 问题*

我对 Dagger 2 范围和生命周期的理解是否正确?

*实际上不是一个64'000美元的问题。


答案 1

至于你的问题

是什么决定了 Dagger 2 中组件(对象图)的生命周期?

简短的答案是你确定它。可以为您的组件指定一个范围,例如

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

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

这些对你有两点用:

  • 范围验证:组件只能具有无作用域提供程序,或与组件具有相同作用域的作用域提供程序。

.

@Component(modules={ApplicationModule.class})
@ApplicationScope
public interface ApplicationComponent {
    Something something();
    AnotherThing anotherThing();

    void inject(Whatever whatever);
}

@Module
public class ApplicationModule {
    @ApplicationScope //application-scoped provider, only one can exist per component
    @Provides
    public Something something() {
         return new Something();
    }

    @Provides //unscoped, each INJECT call creates a new instance
    public AnotherThing anotherThing() {
        return new AnotherThing();
    }
}
  • 允许对作用域内的依赖项进行子作用域,从而允许您创建一个“子作用域”组件,该组件使用“超级作用域”组件中提供的实例。

这可以通过注释或元件依赖项来完成。我个人更喜欢依赖关系。@Subcomponent

@Component(modules={ApplicationModule.class})
@ApplicationScope
public interface ApplicationComponent {
    Something something();
    AnotherThing anotherThing();

    void inject(Whatever whatever);

    ActivityComponent newActivityComponent(ActivityModule activityModule); //subcomponent factory method
}

@Subcomponent(modules={ActivityModule.class})
@ActivityScope
public interface ActivityComponent {
    ThirdThingy thirdThingy();

    void inject(SomeActivity someActivity);
}

@Module
public class ActivityModule {
    private Activity activity;

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

    //...
}

ApplicationComponent applicationComponent = DaggerApplicationComponent.create();
ActivityComponent activityComponent = applicationComponent.newActivityComponent(new ActivityModule(SomeActivity.this));

或者,您可以使用组件依赖关系,如下所示

@Component(modules={ApplicationModule.class})
@ApplicationScope
public class ApplicationComponent {
    Something something(); 
    AnotherThing anotherThing();

    void inject(Whatever whatever);
}

@Component(dependencies={ApplicationComponent.class}, modules={ActivityModule.class})
@ActivityScope
public interface ActivityComponent extends ApplicationComponent {
    ThirdThingy thirdThingy();

    void inject(SomeActivity someActivity);
}

@Module
public class ActivityModule {
    private Activity activity;

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

    //...
}

ApplicationComponent applicationComponent = DaggerApplicationComponent.create();
ActivityComponent activityComponent = DaggerActivityComponent.builder().activityModule(new ActivityModule(SomeActivity.this)).build();

需要了解的重要事项:

  • 作用域提供程序为每个组件的给定作用域创建一个实例。这意味着一个组件会跟踪自己的实例,但其他组件没有共享的作用域池或一些魔力。若要在给定范围内有一个实例,需要该组件的一个实例。这就是为什么必须提供 以访问其自己的作用域依赖项的原因。ApplicationComponent

  • 一个组件只能对一个作用域内组件进行子作用域。不允许使用多个作用域内的组件依赖项。


答案 2

推荐