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

معماری پیشنهادی اندروید برای اپلیکیشن‌ها، تقسیم کد به کلاس‌ها را توصیه می‌کند تا از جداسازی وظایف (separation of concerns) بهره‌مند شوید. این اصل در سلسله مراتب کد، مسئولیت تعریف‌شده‌ی واحدی را بر عهده دارد. این امر منجر به ایجاد کلاس‌های کوچک‌تر و بیشتری می‌شود که برای انجام وظایفشان به یکدیگر نیاز به اتصال دارند.

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

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

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

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

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

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

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

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

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

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

در Compose، ComponentActivity نقطه ورود است؛ اتصال وابستگی‌ها یک بار در onCreate اتفاق می‌افتد و رابط کاربری توسط composableهایی که از setContent فراخوانی می‌شوند، توصیف می‌شود:

class ApiService {
    /* Your API implementation here */
}

class UserRepository(private val apiService: ApiService) {
    /* Your implementation here */
}

class LoginActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Satisfy the dependencies of LoginViewModel recursively,
        // then pass what the UI needs into setContent.
        val apiService = ApiService()
        val userRepository = UserRepository(apiService)

        setContent {
            LoginScreen(userRepository)
        }
    }
}

@Composable
fun LoginScreen(userRepository: UserRepository) {
    val viewModel: LoginViewModel = viewModel(
        factory = LoginViewModelFactory(userRepository)
    )
    // ...
}

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

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

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

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

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

    // apiService and userRepository aren't private and will be exposed
    val apiService = ApiService()
    val userRepository = UserRepository(apiService)
}

از آنجا که این وابستگی‌ها در کل برنامه استفاده می‌شوند، باید در یک مکان مشترک که همه فعالیت‌ها می‌توانند از آن استفاده کنند، قرار گیرند: کلاس 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()
}

با Compose، همان AppContainer همچنان در زیرکلاس Application ایجاد می‌شود. شما می‌توانید قبل از فراخوانی setContent ، در activity یا از داخل یک composable با استفاده از LocalContext به آن دسترسی پیدا کنید:

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

        val appContainer = (application as MyApplication).appContainer

        setContent {
            LoginScreen(appContainer.userRepository)
        }
    }
}

// Alternatively, read AppContainer from inside a composable:
@Composable
fun LoginScreen() {
    val context = LocalContext.current
    val appContainer = (context.applicationContext as MyApplication).appContainer
    val viewModel: LoginViewModel = viewModel(
        factory = LoginViewModelFactory(appContainer.userRepository)
    )
    // ...
}

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

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

اگر LoginViewModel در مکان‌های بیشتری از برنامه مورد نیاز باشد، داشتن یک مکان متمرکز که در آن نمونه‌هایی از LoginViewModel را ایجاد کنید، منطقی است. می‌توانید ایجاد LoginViewModel را به کانتینر منتقل کنید و اشیاء جدیدی از آن نوع را با یک factory ارائه دهید. کد 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<LoginViewModel> {
    override fun create(): LoginViewModel {
        return LoginViewModel(userRepository)
    }
}

با Compose، به‌روزرسانی AppContainer همچنان factory را در معرض نمایش قرار می‌دهد. سپس factory توسط viewModel composable مصرف می‌شود، بنابراین ViewModel به نزدیکترین ViewModelStoreOwner (معمولاً فعالیت میزبان یا با Navigation Compose، یک ورودی nav) محدود می‌شود:

// AppContainer exposing the factory (unchanged from the snippet above)
class AppContainer {
    // ...
    val userRepository = UserRepository(localDataSource, remoteDataSource)
    val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

// Compose entry point + screen composable
class LoginActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val appContainer = (application as MyApplication).appContainer
        setContent {
            LoginScreen(appContainer.loginViewModelFactory)
        }
    }
}

@Composable
fun LoginScreen(factory: LoginViewModelFactory) {
    val viewModel: LoginViewModel = viewModel(factory = factory)
    // ...
}

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

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

2. هنوز کدهای تکراری زیادی وجود دارد. بسته به اینکه می‌خواهید از یک شیء دوباره استفاده کنید یا نه، باید factoryها یا پارامترها را به صورت دستی ایجاد کنید.

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

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

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

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

بیایید یک LoginContainer به کد مثال اضافه کنیم. شما می‌خواهید بتوانید چندین نمونه از LoginContainer را در برنامه ایجاد کنید، بنابراین به جای اینکه آن را به صورت تک‌گانی (singleton) بسازید، آن را به یک کلاس با وابستگی‌هایی که جریان ورود به سیستم از 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
}

در Compose، طول عمر کانتینر جریان به جای Activity میزبان، به composition گره خورده است. نیازی نیست AppContainer.loginContainer مشترک را تغییر دهید، زیرا composableها وابستگی‌های خود را به عنوان پارامتر دریافت می‌کنند یا آنها را از یک ViewModel hoisted می‌خوانند. شما دو گزینه دارید:

1. ناوبری، گراف تودرتو را ایجاد می‌کند (برای جریان‌های چندصفحه‌ای ترجیح داده می‌شود). تمام صفحات را در جریان ورود به سیستم، زیر یک گراف ناوبری تودرتو قرار می‌دهد و محدوده‌ی کانتینر را به NavBackStackEntry آن گراف محدود می‌کند. کانتینر زمانی ایجاد می‌شود که کاربر وارد جریان می‌شود و زمانی که ورودی back stack ظاهر می‌شود، پاک می‌شود، بدون نیاز به فراخوانی‌های دستی چرخه‌ی حیات. برای اطلاعات بیشتر، به Design your navigation graph مراجعه کنید.
2. remember که در ریشه صفحه نمایش (برای یک جریان تک صفحه‌ای یا زمانی که از Navigation Compose استفاده نمی‌کنید) قرار دارد. کانتینر را درون آن بسازید، remember که به ازای هر ورودی به ترکیب، یک بار ایجاد می‌شود و وقتی ترکیب‌پذیر از ترکیب خارج می‌شود، زباله‌روب می‌شود:

@Composable
fun LoginFlow(appContainer: AppContainer) {
    val loginContainer = remember(appContainer) {
        LoginContainer(appContainer.userRepository)
    }
    val viewModel: LoginViewModel = viewModel(
        factory = loginContainer.loginViewModelFactory
    )
    // Render the login flow using loginContainer.loginData and viewModel.
}

نتیجه‌گیری

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

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

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

منابع اضافی

محتوا را مشاهده می‌کند

• تزریق وابستگی دستی (Views)