Dagger2自定义范围:自定义范围(@ActivityScope)实际如何工作?

我正在阅读GitHub上的Dagger2 Component Scopes Test的源代码,并且看到了为名为Activity-level scopes的活动定义的“自定义范围”,但是我在其他项目中也看到了它,包括具有@PerActivity范围的4模块CleanArchitecture 。

但实际上,Activity-level scopes批注的代码如下:

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

import javax.inject.Scope;

/**
 * Created by joesteele on 2/15/15.
 */
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface ActivityScope {
}

它在模块中“神奇地”可用:

@Module
public class ActivityModule {
  @Provides @ActivityScope Picasso providePicasso(ComponentTest app, OkHttpClient client) {
    return new Picasso.Builder(app)
        .downloader(new OkHttpDownloader(client))
        .listener(new Picasso.Listener() {
          @Override public void onImageLoadFailed(Picasso picasso, Uri uri, Exception e) {
            Log.e("Picasso", "Failed to load image: " + uri.toString(), e);
          }
        })
        .build();
  }
}

或CleanArchitecture示例:

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

@PerActivity
@Component(dependencies = ApplicationComponent.class, modules = ActivityModule.class)
public interface ActivityComponent {
  //Exposed to sub-graphs.
  Activity activity();
}

@Module
public class ActivityModule {
  private final Activity activity;

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

  /**
  * Expose the activity to dependents in the graph.
  */
  @Provides @PerActivity Activity activity() {
    return this.activity;
  }
}

我可以清楚地看到这与JSR-330自定义作用域有关,但是我真的不明白在这里到底发生了什么,因此该代码启用了给定的模块和/或给定的模块所提供的功能。 取决于实际的Activity-level scopes生命周期,并且仅存在一个实例,但前提是该给定活动处于活动状态。

文档说:

Scope

Dagger 1 only supported a single scope: @Singleton. 
Dagger 2 allows users to any well-formed scope annotation. 
The Component docs describe the details of 
    how to properly apply scope to a component.

它说要看Component docs页面,但这给了我404。我也看到了,但是...

我是否可以寻求帮助,以澄清为什么指定此自定义范围可以神奇地使Activity-level scopes正常工作?

(答案是,子作用域可以从其超级作用域接收依赖关系,并且子作用域只要组件可以接受就可以存在。并且您需要在模块上指定作用域,并且需要指定组件依赖关系才能对一个超级作用域进行子作用域划分。 )

2个解决方案
32 votes

其实没有魔术。 自定义范围注释仅仅是注释。 他们可以有任何名字。

作用域的第一个功能是一种告诉Dagger编译器作用域组件中允许哪些作用域的方法。 这就是为什么在非Provider组件中使用@ActivityScope依赖项会引发编译错误的原因。

实际上,组件可以声明许多作用域(例如@ActivityScopeProvider),Dagger会将它们都视为单个作用域-这称为作用域别名。 例如,它在多模块项目中很有用-当一个Gradle模块使用其Dagger模块定义一个范围,而另一个Gradle模块定义另一个范围时,而这两个都可以在定义Dagger组件的第三个Gradle模块中用作单个别名范围。

第二个功能是限制作用域组件内允许的实例数量。 支持多种类型的范围:

无作用域-未声明任何注释时。 不受作用域的依赖项将生成简单的@ActivityScope,而无需任何缓存,并且在组件中创建的该依赖项的任何实例对于每次新注入都是新的(例如在构造函数中,在模块提供方法中或在字段中)。

自定义范围,例如 用Provider注释定义的@ActivityScope注释-用该范围声明的依赖项具有已缓存的Provider并具有双重检查锁的缓存,并且将在具有相同范围的声明的组件中为其创建单个实例,并且其创建将是线程安全的。 请注意,将为组件本身的每个实例创建该依赖关系的新实例。

可重用范围-用@ActivityScope批注声明-可以通过公共父组件在不同组件之间共享用该范围声明的依赖项,并且将缓存Provider并生成单检查锁。 当依赖关系不一定需要具有单个实例,而是可以共享以提高单个组件中或组件之间的性能(减少分配)时,它很有用。

有关作用域如何工作的更多信息,请参考用户指南和Dagger生成的代码。

如何定义实际范围是您的特权。 定义范围组件的生命周期,创建时间和销毁时间-这就是您的范围。 例如。 @ActivityScope与“活动”生命周期相关联,其定义如下:

private ActivityComponent component;

@Override
protected void onCreate(Bundle savedInstanceState) {
    component = DaggerActivityComponent.builder().build();
    component.inject(this);
}

@Override
protected void onDestroy() {
    component = null;
    super.onDestroy();
}

因此,没有魔术。 通过使用范围的语义来定义范围。您可能还会发现此答案和这些示例有用。

编辑2018年10月14日扩展了作用域功能和类型,以消除先前答案中的歧义。

Kirill Boyarshinov answered 2020-08-10T11:10:19Z
18 votes

值得注意的是,显然Dagger2在每个组件的模块中为每个作用域提供程序创建了一个实例。

因此,为了在模块中获取作用域提供者,您需要为模块的提供者方法指定作用域。

@Module
public class YourModule {
    @Provides
    @YourScope //one per component
    public Something something() { return new SomethingImpl(); }

    @Provides //new instance per injection
    public Otherthing otherthing() { return new OtherthingImpl(); }
}

@Component
@YourScope
public interface YourComponent {
    Something something();
    Otherthing otherthing();

    void inject(YourThing yourThing); // only if you want field injection
}

编辑开始:虽然通常来说,您不需要在模块内部实例化自己的实现,所以实际上您可以这样做:

@Module
public abstract class YourModule {
    @Binds
    @YourScope //one per component
    public abstract Something something(SomethingImpl impl);

    @Binds //normally new instance per injection, depends on scope of Impl
    public abstract Otherthing otherthing(OtherthingImpl impl);
}

@Singleton
public class SomethingImpl implements Something {
    @Inject
    SomethingImpl() {
    }
}

// unscoped
public class OtherThingImpl implements OtherThing {
    @Inject
    OtherThingImpl() {
    }
}

@Component
@YourScope
public interface YourComponent {
    Something something();
    Otherthing otherthing();

    void inject(YourThing yourThing); // only if you want field injection
}

编辑结束

然后,参考基里尔的答案; 本质上,一个“范围”本身只能确定它与另一个范围不同。 使用组件依赖关系(或子组件)创建一个子作用域。

@Module
public class SubModule {
    @Provides
    @SubScope
    public ThatThing thatThing() { return new ThatThingImpl(); }
}

@Component(dependencies={YourComponent.class}, modules={SubModule.class})
@SubScope
public interface SubComponent extends YourComponent {
    ThatThing thatThing();

    void inject(SubThing subThing); // only if you want field injection
}

一个组件只能依赖一个其他作用域组件。

EpicPandaForce answered 2020-08-10T11:11:02Z
translate from https://stackoverflow.com:/questions/29923376/dagger2-custom-scopes-how-do-custom-scopes-activityscope-actually-work