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

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

الشكل 1. نموذج للرسم البياني لتطبيق Android

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

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

المبادئ الأساسية لإضافة التبعية يدويًا

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

ضع في اعتبارك تدفق عبارة عن مجموعة من الشاشات في تطبيقك تتوافق مع إحدى الميزات. تسجيل الدخول والتسجيل والدفع كلها أمثلة على التدفقات.

عند تغطية مسار تسجيل الدخول لتطبيق Android عادي، يعتمد LoginActivity على LoginViewModel، والتي تعتمد بدورها على UserRepository. تعتمد السمة UserRepository بعد ذلك على UserLocalDataSource وUserRemoteDataSource، ما يعتمد بدوره على خدمة Retrofit.

LoginActivity هو نقطة الدخول إلى مسار تسجيل الدخول ويتفاعل المستخدم مع النشاط. وبالتالي، يحتاج LoginActivity إلى إنشاء LoginViewModel بكل تبعياته.

تبدو فئتا المسار Repository وDataSource على النحو التالي:

لغة Kotlin

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:

لغة Kotlin

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، يمكنك جعل تبعياته خاصة من خلال خيار جعلها علنية في المستقبل عند الحاجة إلى تقديمها:

لغة Kotlin

// 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.

لغة Kotlin

// 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 نمط سينغلتون، فهو ليس object في لغة البرمجة Kotlin، ولا يمكن الوصول إليها في لغة Java باستخدام طريقة Singleton.getInstance() المعتادة.

يمكنك الآن الحصول على مثيل AppContainer من التطبيق والحصول على مشاركة مثيل UserRepository:

لغة Kotlin

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 على النحو التالي:

لغة Kotlin

// 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 يستهلكها:

لغة Kotlin

// 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.

لغة Kotlin

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().

لغة Kotlin

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 لأتمتة هذه العملية وإنشاء الرمز نفسه الذي كنت ستكتبه يدويًا.