إدخال الاعتمادية اليدوية

تشجّع بنية التطبيقات المقترَحة من Android على تقسيم التطبيق التعليمات البرمجية إلى فئات للاستفادة من فصل المخاوف، وهو مبدأ حيث يكون لكل فئة من الفئات في التسلسل الهرمي مسئولية محددة واحدة. يؤدي ذلك إلى عدد أكبر من الصفوف الأصغر حجمًا والتي تحتاج إلى التواصل معًا لتلبية تبعيات بعضنا البعض.

يمكن تمثيل التبعيات بين الفئات في شكل رسم بياني، وفيه كل ارتباطك بالفئات التي تعتمد عليها. يمثل تمثيل جميع وتبعياتها يشكل الرسم البياني للتطبيق. في الشكل 1، يمكنك الاطلاع على تجريد للرسم البياني للتطبيق. عندما تعتمد الفئة أ (ViewModel) على الفئة ب (Repository)، تكون هناك خطًا يشير من A إلى B يمثل تلك التبعية.

يساعد إدخال التبعية في إجراء هذه الروابط ويتيح لك التبديل التنفيذات للاختبار. على سبيل المثال، عند اختبار ViewModel التي تعتمد على المستودع، يمكنك تمرير عمليات تنفيذ مختلفة Repository تتضمّن إما نماذج زائفة أو مزيفة لاختبار الحالات المختلفة.

أساسيات إدخال التبعية اليدوية

يتناول هذا القسم كيفية تطبيق إدخال التبعية يدويًا في جهاز Android حقيقي. المستخدم في تطبيقك. فهو يستعرض نهجًا مكررًا لكيفية البدء في باستخدام إدخال التبعية في تطبيقك. يتحسن النهج حتى تصل نقطة تشبه إلى حد كبير ما ينشئه 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" عبر ميزات متعددة، فسيتعين عليك جعلها تتبع نمط سينغلتون. يجعل النمط المفردتون الاختبار أكثر صعوبة لأن جميع الاختبارات تشترك في نفس مثيل المفردتون.

إدارة التبعيات باستخدام حاوية

لحلّ مشكلة إعادة استخدام العناصر، يمكنك إنشاء عناصرك الخاصة. حاويات التبعيات التي تستخدمها للحصول على التبعيات. جميع النُسخ الافتراضية التي تقدمها هذه الحاوية يمكن أن تكون عامة. في المثال، لأنك تحتاج فقط هو مثيل لـ 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 من التطبيق الحصول على مشترك مثيل 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، يمكن لأجزاء تسجيل الدخول الوصول إلى LoginContainer من AppContainer واستخدام مثيل LoginUserData المشترَك.

لأنه في هذه الحالة، تتعامل مع منطق العرض المنطقي، باستخدام ملاحظة دورة الحياة منطقية.

الخاتمة

ويُعد حقن التبعية أسلوبًا جيدًا لإنشاء محتوى قابل للتطوير والاختبار. تطبيقات Android يمكنك استخدام الحاويات كوسيلة لمشاركة مثيلات الفئات بمختلف في تطبيقك كمكان مركزي لإنشاء مثيلات الفئات باستخدام المصانع.

عندما يزداد حجم تطبيقك، ستبدأ في ملاحظة أنك تكتب الكثير من الرموز النموذجية (مثل المصانع)، والتي يمكن أن تكون عرضة للخطأ. يجب عليك أيضًا إدارة نطاق ودورة حياة الحاويات بنفسك، وتحسين تجاهل الحاويات التي لم تعُد مطلوبة لإخلاء مساحة من الذاكرة. وقد يؤدي ذلك بشكل غير صحيح إلى حدوث أخطاء بسيطة وتسرّب للذاكرة في تطبيقك.

في قسم أداة Dagger، ستظهر لك ستتعلّم كيف يمكنك استخدام Dagger لأتمتة هذه العملية وإنشاء الرمز نفسه كنت ستكتبها يدويًا بخلاف ذلك.