استفاده کردن از Dagger در برنامه‌های چندماژولی

پروژه‌ای با چند واحد Gradle به‌عنوان پروژه چندواحدی شناخته می‌شود. در پروژه‌های چندواحدی که به‌صورت یک APK تکی بدون واحد ویژگی عرضه می‌شوند، معمولاً یک واحد app وجود دارد که می‌تواند به اکثر واحدهای پروژه شما وابسته باشد و یک واحد base یا core که بقیه واحدها معمولاً به آن وابسته هستند. ماژول app معمولاً حاوی کلاس Application شما است، درحالی‌که ماژول base حاوی همه کلاس‌های مشترک هم‌رسانی‌شده در همه ماژول‌های پروژه شما است.

ماژول app مکان خوبی برای اعلام مؤلفه برنامه شما است (برای مثال، ApplicationComponent در تصویر زیر) که می‌تواند اشیایی را ارائه دهد که مؤلفه‌های دیگر ممکن است به آن‌ها نیاز داشته باشند، و همچنین تک‌قلوهای برنامه شما. به‌عنوان مثال، کلاس‌هایی مانند OkHttpClient، تجزیه‌کننده‌های JSON، دسترسی‌دهنده‌ها برای پایگاه داده شما، یا اشیاء SharedPreferences که ممکن است در ماژول core تعریف شده باشند، توسط ApplicationComponent تعریف‌شده در ماژول app ارائه خواهند شد.

در واحد app، ممکن است قطعات دیگری با طول عمر کوتاه‌تر نیز داشته باشید. برای مثال، UserComponent با پیکربندی مختص کاربر (مثل UserSession) پس‌از ورود به سیستم.

در واحدهای مختلف پروژه‌تان، می‌توانید حداقل یک زیرمؤلفه تعریف کنید که منطق خاص آن واحد را داشته باشد، همان‌طور که در شکل ۱ دیده می‌شود.

شکل ۱. نمونه‌ای از نمودار Dagger در پروژه چندماژولی

برای مثال، در پیمانه login، می‌توانید LoginComponent با حاشیه نویسی سفارشی @ModuleScope داشته باشید که می‌تواند اشیای مشترک با آن ویژگی را ارائه دهد، مانند LoginRepository. درون آن ماژول، می‌توانید مؤلفه‌های دیگری هم داشته باشید که به LoginComponent با دامنه سفارشی متفاوت وابسته باشند، برای مثال @FeatureScope برای LoginActivityComponent یا TermsAndConditionsComponent که در آن می‌توانید منطق خاص‌تر ویژگی را مانند اشیای ViewModel محدود کنید.

برای سایر ماژول‌ها مثل Registration، راه‌اندازی مشابهی خواهید داشت.

یک قانون کلی برای پروژه چندماژولی این است که ماژول‌های هم‌سطح نباید به یکدیگر وابسته باشند. اگر این کار را انجام می‌دهند، درنظر بگیرید که آیا آن منطق مشترک (وابستگی‌های بین آن‌ها) باید بخشی از ماژول اصلی باشد یا نه. اگر این‌طور است، کد را بازسازی کنید تا کلاس‌ها به پیمانه اصلی منتقل شوند؛ اگر این‌طور نیست، پیمانه جدیدی ایجاد کنید که پیمانه اصلی را گسترش دهد و هر دو پیمانه اصلی پیمانه جدید را گسترش دهند.

به‌عنوان روال مطلوب، معمولاً در موارد زیر مؤلفه‌ای را در یک ماژول ایجاد می‌کنید:

  • باید تزریق فیلد را انجام دهید، مانند LoginActivityComponent.

  • باید اشیاء را محدود کنید، مانند LoginComponent.

اگر هیچ‌کدام از این موارد صدق نمی‌کند و باید به Dagger بگویید چگونه اشیاء را از آن ماژول ارائه دهد، یک ماژول Dagger با روش‌های @Provides یا @Binds ایجاد و نمایش دهید، اگر تزریق ساخت برای آن کلاس‌ها امکان‌پذیر نیست.

پیاده‌سازی با زیرمؤلفه‌های Dagger

صفحه سند استفاده از Dagger در برنامه‌های Android نحوه ایجاد و استفاده از زیرمؤلفه‌ها را پوشش می‌دهد. اما نمی‌توانید از همان کد استفاده کنید چون واحدهای ویژگی از واحد app اطلاعی ندارند. به‌عنوان مثال، اگر به یک جریان «ورود به سیستم» معمولی و کدی که در صفحه قبلی داریم فکر کنید، دیگر کامپایل نمی‌شود:

کاتلین

class LoginActivity: Activity() {
  ...

  override fun onCreate(savedInstanceState: Bundle?) {
    // Creation of the login graph using the application graph
    loginComponent = (applicationContext as MyDaggerApplication)
                        .appComponent.loginComponent().create()

    // Make Dagger instantiate @Inject fields in LoginActivity
    loginComponent.inject(this)
    ...
  }
}

جاوا

public class LoginActivity extends Activity {
    ...

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Creation of the login graph using the application graph
        loginComponent = ((MyApplication) getApplicationContext())
                                .appComponent.loginComponent().create();

        // Make Dagger instantiate @Inject fields in LoginActivity
        loginComponent.inject(this);

        ...
    }
}

دلیلش این است که واحد login از MyApplication یا appComponent اطلاعی ندارد. برای اینکه کار کند، باید واسطی در واحد ویژگی تعریف کنید که FeatureComponent را که MyApplication باید پیاده‌سازی کند ارائه دهد.

در مثال زیر، می‌توانید میانای LoginComponentProvider را تعریف کنید که LoginComponent را در پیمانه login برای جریان «ورود به سیستم» ارائه می‌دهد:

کاتلین

interface LoginComponentProvider {
    fun provideLoginComponent(): LoginComponent
}

جاوا

public interface LoginComponentProvider {
   public LoginComponent provideLoginComponent();
}

اکنون، LoginActivity به‌جای تکه‌کد تعریف‌شده در بالا، از آن میانای تعریف‌شده استفاده خواهد کرد:

کاتلین

class LoginActivity: Activity() {
  ...

  override fun onCreate(savedInstanceState: Bundle?) {
    loginComponent = (applicationContext as LoginComponentProvider)
                        .provideLoginComponent()

    loginComponent.inject(this)
    ...
  }
}

جاوا

public class LoginActivity extends Activity {
    ...

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        loginComponent = ((LoginComponentProvider) getApplicationContext())
                                .provideLoginComponent();

        loginComponent.inject(this);

        ...
    }
}

اکنون، MyApplication باید آن میانجی را پیاده‌سازی کند و روش‌های لازم را پیاده‌سازی کند:

کاتلین

class MyApplication: Application(), LoginComponentProvider {
  // Reference to the application graph that is used across the whole app
  val appComponent = DaggerApplicationComponent.create()

  override fun provideLoginComponent(): LoginComponent {
    return appComponent.loginComponent().create()
  }
}

جاوا

public class MyApplication extends Application implements LoginComponentProvider {
  // Reference to the application graph that is used across the whole app
  ApplicationComponent appComponent = DaggerApplicationComponent.create();

  @Override
  public LoginComponent provideLoginComponent() {
    return appComponent.loginComponent.create();
  }
}

به این ترتیب می‌توانید از زیرمؤلفه‌های Dagger در یک پروژه چندماژولی استفاده کنید. با پیمانه‌های ویژگی، راه‌حل متفاوت است زیرا پیمانه‌ها به یکدیگر وابسته هستند.

وابستگی‌های مؤلفه با واحدهای ویژگی

با پیمانه‌های ویژگی، روشی که پیمانه‌ها معمولاً به یکدیگر وابسته هستند معکوس می‌شود. به‌جای اینکه واحد app شامل واحدهای ویژگی باشد، واحدهای ویژگی به واحد app وابسته هستند. برای مشاهده نحوه ساختاردهی ماژول‌ها، شکل ۲ را ببینید.

شکل ۲. نمونه‌ای از نمودار Dagger در پروژه‌ای با واحدهای ویژگی

در Dagger، مؤلفه‌ها باید درباره زیرمؤلفه‌هایشان بدانند. این اطلاعات در ماژول Dagger که به مؤلفه والد اضافه شده است گنجانده می‌شود (مانند ماژول SubcomponentsModule در استفاده از Dagger در برنامه‌های Android).

متأسفانه، با وابستگی معکوس بین برنامه و واحد ویژگی، زیرمؤلفه از واحد app قابل‌مشاهده نیست زیرا در مسیر ساخت نیست. به‌عنوان مثال، LoginComponent تعریف‌شده در login واحد ویژگی نمی‌تواند زیرمؤلفه ApplicationComponent تعریف‌شده در واحد app باشد.

Dagger مکانیزمی به‌نام وابستگی‌های مؤلفه دارد که می‌توانید از آن برای حل این مشکل استفاده کنید. به‌جای اینکه مؤلفه فرزند زیرمؤلفه مؤلفه والد باشد، مؤلفه فرزند به مؤلفه والد وابسته است. با این کار، هیچ رابطه والد-فرزندی وجود ندارد؛ اکنون مؤلفه‌ها برای دریافت وابستگی‌های خاص به دیگران وابسته هستند. مؤلفه‌ها باید انواع را از نمودار نشان دهند تا مؤلفه‌های وابسته بتوانند آن‌ها را مصرف کنند.

برای مثال: یک پیمانه ویژگی به‌نام login می‌خواهد یک LoginComponent بسازد که به AppComponent موجود در پیمانه Gradle app بستگی دارد.

در زیر تعاریف کلاس‌ها و AppComponent که بخشی از app ماژول Gradle هستند آورده شده است:

کاتلین

// UserRepository's dependencies
class UserLocalDataSource @Inject constructor() { ... }
class UserRemoteDataSource @Inject constructor() { ... }

// UserRepository is scoped to AppComponent
@Singleton
class UserRepository @Inject constructor(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

@Singleton
@Component
interface AppComponent { ... }

جاوا

// UserRepository's dependencies
public class UserLocalDataSource {

    @Inject
    public UserLocalDataSource() {}
}

public class UserRemoteDataSource {

    @Inject
    public UserRemoteDataSource() { }
}

// UserRepository is scoped to AppComponent
@Singleton
public class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

    @Inject
    public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) {
        this.userLocalDataSource = userLocalDataSource;
        this.userRemoteDataSource = userRemoteDataSource;
    }
}

@Singleton
@Component
public interface ApplicationComponent { ... }

در ماژول gradle login که شامل ماژول gradle app است، LoginActivity دارید که نیاز به تزریق نمونه LoginViewModel دارد:

کاتلین

// LoginViewModel depends on UserRepository that is scoped to AppComponent
class LoginViewModel @Inject constructor(
    private val userRepository: UserRepository
) { ... }

جاوا

// LoginViewModel depends on UserRepository that is scoped to AppComponent
public class LoginViewModel {

    private final UserRepository userRepository;

    @Inject
    public LoginViewModel(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

‫LoginViewModel به UserRepository وابسته است که دردسترس است و به AppComponent محدود شده است. بیایید LoginComponent ایجاد کنیم که به AppComponent برای تزریق LoginActivity وابسته است:

کاتلین

// Use the dependencies attribute in the Component annotation to specify the
// dependencies of this Component
@Component(dependencies = [AppComponent::class])
interface LoginComponent {
    fun inject(activity: LoginActivity)
}

جاوا

// Use the dependencies attribute in the Component annotation to specify the
// dependencies of this Component
@Component(dependencies = AppComponent.class)
public interface LoginComponent {

    void inject(LoginActivity loginActivity);
}

LoginComponent با افزودن AppComponent به پارامتر وابستگی‌های حاشیه‌نویسی مؤلفه، وابستگی به آن را مشخص می‌کند. چون LoginActivity توسط Dagger تزریق خواهد شد، روش inject() را به میانجی اضافه کنید.

هنگام ایجاد LoginComponent، باید نمونه‌ای از AppComponent ارسال شود. برای انجام این کار، از کارخانه مؤلفه استفاده کنید:

کاتلین

@Component(dependencies = [AppComponent::class])
interface LoginComponent {

    @Component.Factory
    interface Factory {
        // Takes an instance of AppComponent when creating
        // an instance of LoginComponent
        fun create(appComponent: AppComponent): LoginComponent
    }

    fun inject(activity: LoginActivity)
}

جاوا

@Component(dependencies = AppComponent.class)
public interface LoginComponent {

    @Component.Factory
    interface Factory {
        // Takes an instance of AppComponent when creating
        // an instance of LoginComponent
        LoginComponent create(AppComponent appComponent);
    }

    void inject(LoginActivity loginActivity);
}

اکنون LoginActivity می‌تواند نمونه‌ای از LoginComponent ایجاد کند و روش inject() را فراخوانی کند.

کاتلین

class LoginActivity: Activity() {

    // You want Dagger to provide an instance of LoginViewModel from the Login graph
    @Inject lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        // Gets appComponent from MyApplication available in the base Gradle module
        val appComponent = (applicationContext as MyApplication).appComponent

        // Creates a new instance of LoginComponent
        // Injects the component to populate the @Inject fields
        DaggerLoginComponent.factory().create(appComponent).inject(this)

        super.onCreate(savedInstanceState)

        // Now you can access loginViewModel
    }
}

جاوا

public class LoginActivity extends Activity {

    // You want Dagger to provide an instance of LoginViewModel from the Login graph
    @Inject
    LoginViewModel loginViewModel;

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

        // Gets appComponent from MyApplication available in the base Gradle module
        AppComponent appComponent = ((MyApplication) getApplicationContext()).appComponent;

        // Creates a new instance of LoginComponent
        // Injects the component to populate the @Inject fields
        DaggerLoginComponent.factory().create(appComponent).inject(this);

        // Now you can access loginViewModel
    }
}

LoginViewModel به UserRepository بستگی دارد؛ و برای اینکه LoginComponent بتواند از AppComponent به آن دسترسی داشته باشد، AppComponent باید آن را در میانای خود نشان دهد:

کاتلین

@Singleton
@Component
interface AppComponent {
    fun userRepository(): UserRepository
}

جاوا

@Singleton
@Component
public interface AppComponent {
    UserRepository userRepository();
}

قوانین دامنه‌بندی با مؤلفه‌های وابسته به همان روشی کار می‌کنند که با زیرمؤلفه‌ها کار می‌کنند. چون LoginComponent از نمونه‌ای از AppComponent استفاده می‌کند، نمی‌توانند از حاشیه‌نویسی دامنه یکسانی استفاده کنند.

اگر می‌خواستید LoginViewModel را به LoginComponent محدود کنید، این کار را همان‌طور که قبلاً بااستفاده از حاشیه‌نویسی سفارشی @ActivityScope انجام می‌دادید، انجام می‌دادید.

کاتلین

@ActivityScope
@Component(dependencies = [AppComponent::class])
interface LoginComponent { ... }

@ActivityScope
class LoginViewModel @Inject constructor(
    private val userRepository: UserRepository
) { ... }

جاوا

@ActivityScope
@Component(dependencies = AppComponent.class)
public interface LoginComponent { ... }

@ActivityScope
public class LoginViewModel {

    private final UserRepository userRepository;

    @Inject
    public LoginViewModel(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

روال‌های مطلوب

  • ApplicationComponent باید همیشه در واحد app باشد.

  • اگر لازم است تزریق فیلد را در آن ماژول انجام دهید یا لازم است اشیاء را برای جریان خاصی از برنامه‌تان محدود کنید، مؤلفه‌های Dagger را در ماژول‌ها ایجاد کنید.

  • For Gradle modules that are meant to be utilities or helpers and don't need to build a graph (that's why you'd need a Dagger component), create and expose public Dagger modules with @Provides and @Binds methods of those classes that don't support constructor injection.

  • برای استفاده از Dagger در برنامه Android با واحدهای ویژگی، از وابستگی‌های مؤلفه استفاده کنید تا بتوانید به وابستگی‌های ارائه‌شده توسط ApplicationComponent تعریف‌شده در واحد app دسترسی داشته باشید.