标签: dagger

我让我的项目与Butterknife一起工作,以观察注射.但是我需要添加Dagger才能注入依赖项.

我添加了Annotation Processor Tool Gradle插件以及相应的Dagger要求(为简洁起见,仅显示修改过的部分);

buildScript {
    repositories {
        maven {
            url "https://oss.sonatype.org/content/repositories/snapshots/"
        }
    }
    dependencies {
        ...
        classpath 'com.jimdo.gradle:gradle-apt-plugin:0.2-SNAPSHOT'
    }
}

apply plugin: 'apt'

dependencies {
    apt "com.squareup.dagger:dagger-compiler:${daggerVersion}"

    ...
}

此时,当我构建并运行应用程序时,标记有@InjectView注释的属性不会被注入Butterknife发出的以下调试消息;

D/ButterKnife? Looking up view injector for com.example.MainActivity
D/ButterKnife? Not found. Trying superclass com.example.FactListAbstractActivity
D/ButterKnife? Not found. Trying superclass android.app.Activity

我还是Dagger的新手并试图抓住一些东西.我想将我的模块分成逻辑组,每个组都提供自己的功能,但基本上就像在一个模块中一样.

例如,假设我的主应用程序模块定义如下:

//com.example.android.MyAppModule.java
@Module(
   includes = AnalyticsModule.class,
   injects = { <snip> }
)
public class MyAppModule {
   // various provides
}

我有另一个像这样定义的模块,它设置一个ErrorReporter接口并为它提供具体的实现.

// com.example.android.analytics.AnalyticsModule.java
@Module(
   addsTo = MyAppModule.class,
   injects = { MyApp.class }
)
public class AnalyticsModule(){

    // ErrorReporter is a public interface and ErrorReporterImpl is a package-local final concrete class that implements it
    @Provides @Singleton
    ErrorReporter providesErrorReporter(ErrorReporterImpl reporter) { return reporter };
}

在我的Application类中,我设置了如下对象图:

// com.example.android.MyApp.java
public class MyApp extends Application {
    @Inject ErrorReporter errorReporter;

    @Override
    public void onCreate() …

我即将开始一个相对较大的项目并且想知道

使用这些依赖注入框架的真正好处是什么？

DI会增加应用加载时间吗？或提供任何性能价值？

Googles文档反对使用Robojuice因为它的RAM使用,这是所有DI的共同点吗？

有兴趣听取大家的意见.

在我的Android应用程序中,我使用Otto作为事件总线,使用Dagger进行依赖注入.

在Otto的用户指南和许多博客文章中,建议使用注入来获取总线单例.我已经做了一段时间,但最近我更加怀疑如果注入总线比使用简单的静态单例有任何优势.

使用注入时,我必须注入我希望能够在总线上发布UI事件的每个自​​定义View或ViewHolder.尤其是匕首,在我需要公共汽车的地方注入每个班级似乎有点笨拙.当然,我可以通过构造函数或setter方法传递总线,但是如果您考虑具有许多不同视图类型的适配器,那也可能有点笨拙.

我注意到注入总线没有任何好处.在Otto的情况下,注入了一个具体的实现(Bus的一个实例),并且永远不会改变.由于订阅的工作方式,包装Otto进行解耦对于思考是没有任何意义的.

那么,有没有人看到注入奥托的任何优点,我没有看到？

假设这里已经说过,开发人员有责任保留组件实例以实现自己的范围逻辑(因为范围方法将为给定组件返回相同的实例).

通过活动生命周期保持此组件引用的干净方法是什么？

示例:您正在实施MVP模式,因此您需要在Activity中使用Presenter.此演示者可以执行网络操作来下载项目.当设备旋转时,您的Activity将被销毁并重新创建,但您希望保持网络运行并返回预旋转演示者.

在为Presenter提供自定义PerActivity范围的组件范围是解决方案,因此您必须通过此循环保持Component实例,以便在首次启动Activity时注入相同的Presenter实例.

我们怎么处理这个？我想到了一种组件缓存(如HashMap？),它可以由Application类中的Application Component提供.

我一直试图在ViewUtils类中注入Activity,但没有成功.我已经关注了几个不同的帖子,但我似乎无法理解我在实现中缺少的内容.

我知道这可能是下面帖子的重复,我真的为此道歉但老实说我看不出我错过了什么.这些是我发现的帖子:

• Dagger 2.10 Android子组件和构建器
• 如何在dagger 2.10中创建自定义范围模块
• https://google.github.io/dagger/subcomponents.html

我的实现如下:

AppComponent

@Component(modules = {
        AppModule.class, AndroidSupportInjectionModule.class, ActivityBindingModule.class
}) @Singleton public interface AppComponent extends AndroidInjector<EmblyApp> {

    @Component.Builder abstract class Builder extends AndroidInjector.Builder<EmblyApp> {}
}

ActivityBindingModule

@Module public abstract class ActivityBindingModule {

    @ContributesAndroidInjector
    abstract LoginActivity loginActivity();
}

LoginSubcomponent

@Subcomponent(modules = LoginSubcomponent.LoginActivityModule.class)
public interface LoginSubcomponent extends AndroidInjector<LoginActivity> {

    @Subcomponent.Builder abstract class Builder extends AndroidInjector.Builder<LoginActivity> {}

    @Module abstract class LoginActivityModule {

        @Binds abstract Activity bindActivity(LoginActivity activity);

        @Provides @ActivityScope static ViewUtils viewUtils(Activity activity) {
            return new …

我正在尝试将单身经理添加到Android服务中.问题是注入的管理器与ViewModel中的管理器不同.

匕首组件

@Singleton
@Component(modules = {ApplicationModule.class, AppScreenModule.class, ServiceModule.class})
public interface AppComponent {

    void inject(App application);

    void inject(OpportunisticService opportunisticService);

    @Component.Builder
    interface Builder {
        AppComponent build();

        Builder applicationModule(ApplicationModule applicationModule);
    }
}

模块

@Module
class ApplicationModule {    
    private final App mApp;

    ApplicationModule(App app) {
        mApp = app;
    }

    @Provides
    @Named("ApplicationContext")
    Context provideContext() {
        return mApp.getApplicationContext();
    }

    @Provides
    App provideApplication() {
        return mApp;
    }

    @Provides
    PeersManager providePeersManager() {
        return new PeersManager();
    }
}

@Module
abstract class ServiceModule {

    @ContributesAndroidInjector
    abstract OpportunisticService bindOpportunisticService();
}

初始化 …

我对使用dagger-android的Dagger中的范围依赖感到困惑.

使用@ContributesAndroidInjetor我有一个类似如下的代码:

@Module
public abstract class ActivityBindingModule {

    @ContributesAndroidInjector(modules = PotatoesModule.class)
    public abstract MainActivity contributeMainActivityInjector();

    @ContributesAndroidInjector
    public abstract UserActivity contributeUserActivity();
}

ActivityBindingModule在我的AppComponent中定义为一个模块.但问题是.我该怎么办呢

@UserScope
@Component(dependencies = AppComponent.class)
public interface UserComponent {...}

并注释一个Activity来使用该范围？我的所有依赖都是活动"本地单身人士"吗？因为每个Activity注入器都是AppComponent的子组件.

也许我不理解使用dagger-android的"范围"的概念,如果有人能够解释它,我会很高兴.

我遇到的错误如下:

引起:java.lang.IllegalArgumentException:没有为Class绑定的进程工厂.注射器工厂被绑定为MyActivity_的超类型:[MyActivity].你的意思是绑定注射器工厂的子类型？

据我所知,这是因为我正在使用AndroidAnnotations库.

AppComponent.class:

@Singleton
@Component(modules = {
    AndroidInjectionModule.class,
    AppModule.class,
    ActivityBindingModule.class })
public interface AppComponent extends AndroidInjector<DaggerApplication> {

    @Component.Builder
    interface Builder {
         @BindsInstance Builder application(Application application);
         AppComponent build();
    }

    void inject(Application application);

    @Override
    void inject(DaggerApplication instance);
}

AppModule.class:

@Module
public abstract class AppModule {

    @Binds
    abstract Context provideContext(Application application);

    @Provides
    @Singleton
    static SharedPreferencesManager providesPreferences(Application application){
        return SharedPreferencesManager_.getInstance_(application);
    }
}

ActivityBindingModule.class:

@Module
public abstract class ActivityBindingModule {

    @ContributesAndroidInjector(modules = LoginActivityModule.class)
    @LoginActivityScope
    abstract LoginActivity bindLoginActivity();
}

Application.class:

@EApplication …

我正在尝试用Dagger2设置一个新项目,之前我使用过Dagger2,但现在我正试图自己设置它.我从Kotlin项目中得到了一个例子,但我不能像现在在Kotlin中那样设置Java(或者我可能缺少一些东西).

它只是一个组件,单个模块和应用程序.

零件

@Singleton
@Component(modules = {MainAppModule.class})
public interface AppComponent extends AndroidInjector<App> {
@Component.Builder
abstract class Builder implements AndroidInjector.Factory<App> {

    public AppComponent create(App application) {
        seedApplication(application);
        return build();
    }

    @BindsInstance
    abstract void seedApplication(App application);

    abstract AppComponent build();
}
}

模

@Module
abstract class MainAppModule {

@Binds
abstract public Application bindApplication(App application);

@ContributesAndroidInjector
abstract public MainActivity contributeActivityInjector();
}

*申请*

public class App extends DaggerApplication {

@Override
public AndroidInjector<? extends DaggerApplication> applicationInjector() {
    return DaggerAppComponent.builder().create(this);
}
}

在这一点上,我没有任何我调用的类,我@Inject 只是在构建时遇到错误:

 error: [dagger.android.AndroidInjector.inject(T)] …