تزریق وابستگی دستی

معماری اپلیکیشن پیشنهادی اندروید ، تقسیم کد شما به کلاس‌ها را تشویق می‌کند تا از جداسازی نگرانی‌ها بهره‌مند شوید، اصلی که در آن هر کلاس از سلسله مراتب یک مسئولیت تعریف‌شده واحد دارد. این منجر به ایجاد طبقات بیشتر و کوچکتر می شود که باید به یکدیگر متصل شوند تا وابستگی های یکدیگر را برآورده کنند.

شکل 1. مدلی از گراف برنامه اندروید

وابستگی‌های بین کلاس‌ها را می‌توان به صورت یک نمودار نشان داد که در آن هر کلاس به کلاس‌هایی که به آن‌ها وابسته است متصل می‌شود. نمایش تمام کلاس‌های شما و وابستگی‌های آنها نمودار برنامه را تشکیل می‌دهد. در شکل 1، انتزاعی از نمودار برنامه را مشاهده می کنید. وقتی کلاس A ( ViewModel ) به کلاس B ( Repository ) وابسته است، خطی وجود دارد که از A به B نشان دهنده آن وابستگی است.

تزریق وابستگی به ایجاد این اتصالات کمک می کند و به شما امکان می دهد پیاده سازی ها را برای آزمایش تعویض کنید. به عنوان مثال، هنگام آزمایش یک ViewModel که به یک مخزن وابسته است، می‌توانید پیاده‌سازی‌های مختلف Repository را با جعلی یا ساختگی برای آزمایش موارد مختلف ارسال کنید.

اصول تزریق وابستگی دستی

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

یک جریان را به عنوان گروهی از صفحه نمایش در برنامه خود در نظر بگیرید که با یک ویژگی مطابقت دارد. ورود، ثبت نام و پرداخت همه نمونه هایی از جریان هستند.

هنگام پوشش یک جریان ورود به سیستم برای یک برنامه معمولی Android، LoginActivity به LoginViewModel بستگی دارد که به نوبه خود به UserRepository بستگی دارد. سپس UserRepository به یک UserLocalDataSource و یک UserRemoteDataSource بستگی دارد که به نوبه خود به یک سرویس Retrofit بستگی دارد.

LoginActivity نقطه ورود به جریان ورود است و کاربر با فعالیت تعامل دارد. بنابراین، LoginActivity باید LoginViewModel با تمام وابستگی هایش ایجاد کند.

کلاس های Repository و DataSource جریان به شکل زیر هستند:

کاتلین

class UserRepository(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

class UserLocalDataSource { ... }
class UserRemoteDataSource(
    private val loginService: LoginRetrofitService
) { ... }

جاوا

class UserLocalDataSource {
    public UserLocalDataSource() { }
    ...
}

class UserRemoteDataSource {

    private final Retrofit retrofit;

    public UserRemoteDataSource(Retrofit retrofit) {
        this.retrofit = retrofit;
    }

    ...
}

class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

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

    ...
}

LoginActivity به این صورت است:

کاتلین

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // In order to satisfy the dependencies of LoginViewModel, you have to also
        // satisfy the dependencies of all of its dependencies recursively.
        // First, create retrofit which is the dependency of UserRemoteDataSource
        val retrofit = Retrofit.Builder()
            .baseUrl("https://example.com")
            .build()
            .create(LoginService::class.java)

        // Then, satisfy the dependencies of UserRepository
        val remoteDataSource = UserRemoteDataSource(retrofit)
        val localDataSource = UserLocalDataSource()

        // Now you can create an instance of UserRepository that LoginViewModel needs
        val userRepository = UserRepository(localDataSource, remoteDataSource)

        // Lastly, create an instance of LoginViewModel with userRepository
        loginViewModel = LoginViewModel(userRepository)
    }
}

جاوا

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

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

        // In order to satisfy the dependencies of LoginViewModel, you have to also
        // satisfy the dependencies of all of its dependencies recursively.
        // First, create retrofit which is the dependency of UserRemoteDataSource
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://example.com")
                .build()
                .create(LoginService.class);

        // Then, satisfy the dependencies of UserRepository
        UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit);
        UserLocalDataSource localDataSource = new UserLocalDataSource();

        // Now you can create an instance of UserRepository that LoginViewModel needs
        UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

        // Lastly, create an instance of LoginViewModel with userRepository
        loginViewModel = new LoginViewModel(userRepository);
    }
}

در این رویکرد مشکلاتی وجود دارد:

1. تعداد زیادی کد دیگ بخار وجود دارد. اگر می‌خواهید نمونه دیگری از LoginViewModel را در قسمت دیگری از کد ایجاد کنید، کد تکراری خواهید داشت.

2. وابستگی ها باید به ترتیب اعلام شوند. شما باید UserRepository قبل از LoginViewModel نمونه سازی کنید تا بتوانید آن را ایجاد کنید.

3. استفاده مجدد از اشیاء دشوار است. اگر می‌خواهید UserRepository در چندین ویژگی استفاده مجدد کنید، باید آن را از الگوی singleton پیروی کنید. الگوی سینگلتون تست را دشوارتر می کند زیرا همه آزمون ها نمونه تکی یکسانی دارند.

مدیریت وابستگی ها با کانتینر

برای حل مشکل استفاده مجدد از اشیاء، می توانید کلاس ظرف وابستگی خود را ایجاد کنید که از آن برای دریافت وابستگی استفاده می کنید. همه موارد ارائه شده توسط این کانتینر می توانند عمومی باشند. در مثال، از آنجا که شما فقط به یک نمونه از UserRepository نیاز دارید، می‌توانید وابستگی‌های آن را خصوصی کنید و در صورت نیاز به ارائه در آینده، آنها را عمومی کنید:

کاتلین

// Container of objects shared across the whole app
class AppContainer {

    // Since you want to expose userRepository out of the container, you need to satisfy
    // its dependencies as you did before
    private val retrofit = Retrofit.Builder()
                            .baseUrl("https://example.com")
                            .build()
                            .create(LoginService::class.java)

    private val remoteDataSource = UserRemoteDataSource(retrofit)
    private val localDataSource = UserLocalDataSource()

    // userRepository is not private; it'll be exposed
    val userRepository = UserRepository(localDataSource, remoteDataSource)
}

جاوا

// Container of objects shared across the whole app
public class AppContainer {

    // Since you want to expose userRepository out of the container, you need to satisfy
    // its dependencies as you did before
    private Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://example.com")
            .build()
            .create(LoginService.class);

    private UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit);
    private UserLocalDataSource localDataSource = new UserLocalDataSource();

    // userRepository is not private; it'll be exposed
    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);
}

از آنجایی که این وابستگی ها در کل برنامه مورد استفاده قرار می گیرند، باید در مکانی مشترک قرار گیرند که همه فعالیت ها می توانند از آن استفاده کنند: کلاس Application . یک کلاس Application سفارشی ایجاد کنید که حاوی یک نمونه AppContainer باشد.

کاتلین

// Custom Application class that needs to be specified
// in the AndroidManifest.xml file
class MyApplication : Application() {

    // Instance of AppContainer that will be used by all the Activities of the app
    val appContainer = AppContainer()
}

جاوا

// Custom Application class that needs to be specified
// in the AndroidManifest.xml file
public class MyApplication extends Application {

    // Instance of AppContainer that will be used by all the Activities of the app
    public AppContainer appContainer = new AppContainer();
}

توجه: AppContainer فقط یک کلاس معمولی است که یک نمونه منحصر به فرد در برنامه به اشتراک گذاشته شده است که در کلاس Application شما قرار داده شده است. با این حال، AppContainer از الگوی تک تن پیروی نمی کند. در Kotlin، یک object نیست، و در جاوا، با روش معمولی Singleton.getInstance() قابل دسترسی نیست.

اکنون می توانید نمونه AppContainer را از برنامه دریافت کنید و نمونه مشترک UserRepository را دریافت کنید:

کاتلین

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Gets userRepository from the instance of AppContainer in Application
        val appContainer = (application as MyApplication).appContainer
        loginViewModel = LoginViewModel(appContainer.userRepository)
    }
}

جاوا

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

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

        // Gets userRepository from the instance of AppContainer in Application
        AppContainer appContainer = ((MyApplication) getApplication()).appContainer;
        loginViewModel = new LoginViewModel(appContainer.userRepository);
    }
}

به این ترتیب، شما یک UserRepository تک تنی ندارید. در عوض، شما یک AppContainer دارید که در تمام فعالیت‌ها به اشتراک گذاشته شده است که شامل اشیایی از نمودار است و نمونه‌هایی از آن اشیاء ایجاد می‌کند که کلاس‌های دیگر می‌توانند مصرف کنند.

اگر LoginViewModel در مکان های بیشتری در برنامه مورد نیاز است، داشتن یک مکان متمرکز که در آن نمونه هایی از LoginViewModel را ایجاد می کنید منطقی است. می توانید ایجاد LoginViewModel را به کانتینر منتقل کنید و اشیاء جدیدی از آن نوع را با یک کارخانه ارائه دهید. کد LoginViewModelFactory به شکل زیر است:

کاتلین

// Definition of a Factory interface with a function to create objects of a type
interface Factory<T> {
    fun create(): T
}

// Factory for LoginViewModel.
// Since LoginViewModel depends on UserRepository, in order to create instances of
// LoginViewModel, you need an instance of UserRepository that you pass as a parameter.
class LoginViewModelFactory(private val userRepository: UserRepository) : Factory {
    override fun create(): LoginViewModel {
        return LoginViewModel(userRepository)
    }
}

جاوا

// Definition of a Factory interface with a function to create objects of a type
public interface Factory<T> {
    T create();
}

// Factory for LoginViewModel.
// Since LoginViewModel depends on UserRepository, in order to create instances of
// LoginViewModel, you need an instance of UserRepository that you pass as a parameter.
class LoginViewModelFactory implements Factory {

    private final UserRepository userRepository;

    public LoginViewModelFactory(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public LoginViewModel create() {
        return new LoginViewModel(userRepository);
    }
}

می توانید LoginViewModelFactory در AppContainer قرار دهید و LoginActivity آن را مصرف کنید:

کاتلین

// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory
class AppContainer {
    ...
    val userRepository = UserRepository(localDataSource, remoteDataSource)

    val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Gets LoginViewModelFactory from the application instance of AppContainer
        // to create a new LoginViewModel instance
        val appContainer = (application as MyApplication).appContainer
        loginViewModel = appContainer.loginViewModelFactory.create()
    }
}

جاوا

// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory
public class AppContainer {
    ...

    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

    public LoginViewModelFactory loginViewModelFactory = new LoginViewModelFactory(userRepository);
}

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

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

        // Gets LoginViewModelFactory from the application instance of AppContainer
        // to create a new LoginViewModel instance
        AppContainer appContainer = ((MyApplication) getApplication()).appContainer;
        loginViewModel = appContainer.loginViewModelFactory.create();
    }
}

این رویکرد بهتر از روش قبلی است، اما هنوز چالش هایی وجود دارد که باید در نظر بگیرید:

1. شما باید AppContainer خودتان مدیریت کنید و نمونه هایی را برای همه وابستگی ها با دست ایجاد کنید.

2. هنوز تعداد زیادی کد دیگ بخار وجود دارد. بسته به اینکه می خواهید از یک شی دوباره استفاده کنید یا نه، باید کارخانه ها یا پارامترها را با دست ایجاد کنید.

مدیریت وابستگی ها در جریان برنامه ها

AppContainer زمانی پیچیده می شود که می خواهید عملکرد بیشتری را در پروژه قرار دهید. هنگامی که برنامه شما بزرگتر می شود و شما شروع به معرفی جریان های ویژگی های مختلف می کنید، حتی مشکلات بیشتری ایجاد می شود:

1. وقتی جریان های مختلفی دارید، ممکن است بخواهید که اشیا فقط در محدوده آن جریان زندگی کنند. به عنوان مثال، هنگام ایجاد LoginUserData (که ممکن است شامل نام کاربری و رمز عبوری باشد که فقط در جریان ورود به سیستم استفاده می شود) نمی خواهید داده های یک جریان ورود قدیمی از یک کاربر دیگر را حفظ کنید. شما یک نمونه جدید برای هر جریان جدید می خواهید. همانطور که در مثال کد بعدی نشان داده شده است، می توانید با ایجاد اشیاء FlowContainer در داخل AppContainer به آن دست یابید.

2. بهینه سازی نمودار برنامه و کانتینرهای جریان نیز می تواند دشوار باشد. شما باید به یاد داشته باشید که بسته به جریانی که در آن هستید، مواردی را که نیازی ندارید حذف کنید.

تصور کنید یک جریان ورود به سیستم دارید که از یک فعالیت ( LoginActivity ) و چند قطعه ( LoginUsernameFragment و LoginPasswordFragment ) تشکیل شده است. این دیدگاه ها می خواهند:

1. به همان نمونه LoginUserData دسترسی داشته باشید که باید تا زمانی که جریان ورود به سیستم به پایان برسد به اشتراک گذاشته شود.

2. با شروع مجدد جریان، یک نمونه جدید از LoginUserData ایجاد کنید.

شما می توانید با یک کانتینر جریان ورود به سیستم به آن دست پیدا کنید. این محفظه باید با شروع جریان ورود ایجاد شود و پس از پایان جریان از حافظه حذف شود.

بیایید یک LoginContainer به کد مثال اضافه کنیم. شما می خواهید بتوانید چندین نمونه از LoginContainer را در برنامه ایجاد کنید، بنابراین به جای اینکه آن را به صورت تکی درآورید، آن را به یک کلاس با وابستگی هایی که جریان ورود به سیستم نیاز دارد از AppContainer تبدیل کنید.

کاتلین

class LoginContainer(val userRepository: UserRepository) {

    val loginData = LoginUserData()

    val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

// AppContainer contains LoginContainer now
class AppContainer {
    ...
    val userRepository = UserRepository(localDataSource, remoteDataSource)

    // LoginContainer will be null when the user is NOT in the login flow
    var loginContainer: LoginContainer? = null
}

جاوا

// Container with Login-specific dependencies
class LoginContainer {

    private final UserRepository userRepository;

    public LoginContainer(UserRepository userRepository) {
        this.userRepository = userRepository;
        loginViewModelFactory = new LoginViewModelFactory(userRepository);
    }

    public LoginUserData loginData = new LoginUserData();

    public LoginViewModelFactory loginViewModelFactory;
}

// AppContainer contains LoginContainer now
public class AppContainer {
    ...
    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

    // LoginContainer will be null when the user is NOT in the login flow
    public LoginContainer loginContainer;
}

هنگامی که یک کانتینر خاص برای یک جریان دارید، باید تصمیم بگیرید که چه زمانی نمونه کانتینر را ایجاد و حذف کنید. از آنجایی که جریان ورود شما در یک اکتیویتی ( LoginActivity ) مستقل است، فعالیتی است که چرخه حیات آن ظرف را مدیریت می کند. LoginActivity می تواند نمونه را در onCreate() ایجاد کند و آن را در onDestroy() حذف کند.

کاتلین

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel
    private lateinit var loginData: LoginUserData
    private lateinit var appContainer: AppContainer


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        appContainer = (application as MyApplication).appContainer

        // Login flow has started. Populate loginContainer in AppContainer
        appContainer.loginContainer = LoginContainer(appContainer.userRepository)

        loginViewModel = appContainer.loginContainer.loginViewModelFactory.create()
        loginData = appContainer.loginContainer.loginData
    }

    override fun onDestroy() {
        // Login flow is finishing
        // Removing the instance of loginContainer in the AppContainer
        appContainer.loginContainer = null
        super.onDestroy()
    }
}

جاوا

public class LoginActivity extends Activity {

    private LoginViewModel loginViewModel;
    private LoginData loginData;
    private AppContainer appContainer;

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

        appContainer = ((MyApplication) getApplication()).appContainer;

        // Login flow has started. Populate loginContainer in AppContainer
        appContainer.loginContainer = new LoginContainer(appContainer.userRepository);

        loginViewModel = appContainer.loginContainer.loginViewModelFactory.create();
        loginData = appContainer.loginContainer.loginData;
    }

    @Override
    protected void onDestroy() {
        // Login flow is finishing
        // Removing the instance of loginContainer in the AppContainer
        appContainer.loginContainer = null;

        super.onDestroy();
    }
}

مانند LoginActivity ، قطعات لاگین می توانند از AppContainer به LoginContainer دسترسی داشته باشند و از نمونه مشترک LoginUserData استفاده کنند.

از آنجا که در این مورد شما با منطق چرخه حیات مشاهده سروکار دارید، استفاده از مشاهده چرخه حیات منطقی است.

توجه: اگر برای زنده ماندن از تغییرات پیکربندی به کانتینر نیاز دارید، راهنمای Saving UI States را دنبال کنید. شما باید به همان روشی که با مرگ فرآیند برخورد می کنید، با آن رفتار کنید. در غیر این صورت، برنامه شما ممکن است در دستگاه هایی با حافظه کمتر حالت خود را از دست بدهد.

نتیجه گیری

تزریق وابستگی یک تکنیک خوب برای ایجاد برنامه های اندرویدی مقیاس پذیر و قابل آزمایش است. از کانتینرها به عنوان راهی برای اشتراک‌گذاری نمونه‌های کلاس‌ها در بخش‌های مختلف برنامه‌تان و به‌عنوان مکانی متمرکز برای ایجاد نمونه‌هایی از کلاس‌ها با استفاده از کارخانه‌ها استفاده کنید.

هنگامی که برنامه شما بزرگتر می شود، خواهید دید که کدهای دیگ بخار زیادی (مانند کارخانه ها) می نویسید که ممکن است مستعد خطا باشد. شما همچنین باید دامنه و چرخه عمر کانتینرها را خودتان مدیریت کنید، و ظروف را که دیگر مورد نیاز نیستند را بهینه سازی و دور بیندازید تا حافظه آزاد شود. انجام نادرست این کار می تواند منجر به باگ های ظریف و نشت حافظه در برنامه شما شود.

در بخش Dagger ، یاد می‌گیرید که چگونه می‌توانید از Dagger برای خودکار کردن این فرآیند و تولید همان کدی که در غیر این صورت با دست می‌نوشتید، استفاده کنید.