मैन्युअल डिपेंडेंसी इंजेक्शन

Android के सुझाए गए ऐप्लिकेशन का आर्किटेक्चर, डेटा को अलग-अलग कैटगरी में बांटने को बढ़ावा देता है समस्याओं को अलग करने, एक सिद्धांत, जहां हर क्लास की एक तय ज़िम्मेदारी होती है. इससे कई छोटी क्लास हो जाती हैं, जिन्हें एक-दूसरे से कनेक्ट करना पड़ता है एक-दूसरे की डिपेंडेंसी पूरी करने में मदद मिलती है.

क्लास के बीच की डिपेंडेंसी को एक ग्राफ़ के रूप में दिखाया जा सकता है, जिसमें हर क्लास से कनेक्ट की गई हैं. आपके सभी इवेंट क्लास और उनकी डिपेंडेंसी से ऐप्लिकेशन ग्राफ़ बनता है. पहली इमेज में, ऐप्लिकेशन ग्राफ़ की अलग जानकारी देखी जा सकती है. जब क्लास A (ViewModel) क्लास B (Repository) पर निर्भर करती है, तो आपके लिए A से B तक ले जाने वाली लाइन, जो उस डिपेंडेंसी को दिखाती है.

डिपेंडेंसी इंजेक्शन इन कनेक्शन को बनाने में मदद करता है और स्वैप करने में आपकी मदद करता है टेस्टिंग के लिए लागू करना. उदाहरण के लिए, ViewModel की जांच करते समय जो डेटा स्टोर करने की जगह पर निर्भर करता है, आप अलग-अलग तरीके से लागू करने के लिए अलग-अलग मामलों की जांच करने के लिए, Repository का इस्तेमाल करें.

मैन्युअल डिपेंडेंसी इंजेक्शन के बारे में बुनियादी बातें

इस सेक्शन में बताया गया है कि किसी असल Android में मैन्युअल डिपेंडेंसी इंजेक्शन कैसे लागू किया जाता है ऐप्लिकेशन से जुड़ी ज़रूरतों को भी पूरा कर सकता है. इसमें बार-बार आने वाले बदलाव की जानकारी दी जाती है. इससे आपको यह पता चलता है कि शुरुआत कैसे की जाए डिपेंडेंसी इंजेक्शन का इस्तेमाल करके. यह रणनीति तब तक बेहतर होती जाती है, जब तक ऐसा पॉइंट जो डैगर के अपने-आप जनरेट होने वाले पॉइंट से काफ़ी मिलता-जुलता है आपको. डैगर के बारे में ज़्यादा जानकारी के लिए, डैगर की बुनियादी बातें पढ़ें.

अपने ऐप्लिकेशन में, स्क्रीन के उस ग्रुप को flow पर विचार करें जो सुविधा. लॉगिन, रजिस्ट्रेशन, और चेकआउट जैसे सभी फ़्लो के उदाहरण हैं.

किसी सामान्य 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. डिपेंडेंसी को क्रम से तय किया जाना चाहिए. आपको इंस्टैंशिएट करना होगा इसे बनाने के लिए, LoginViewModel से पहले UserRepository.

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 ऐप्लिकेशन. अलग-अलग क्लास के इंस्टेंस शेयर करने के लिए, कंटेनर का इस्तेमाल करें आपके ऐप्लिकेशन के कुछ हिस्सों को और एक ही जगह से कारखानों में काम करते हुए क्लास लेते हैं.

जब आपका ऐप्लिकेशन बड़ा हो जाता है, तो आपको दिखाई देगा कि आप बहुत सारे कोड लिखते हैं बॉयलरप्लेट कोड (जैसे कि फ़ैक्ट्री) का इस्तेमाल करने पर गड़बड़ी हो सकती है. आपको यह भी करना होगा कंटेनर के स्कोप और लाइफ़साइकल को खुद मैनेज करके, ऐसे कंटेनर को हटाना जिनकी अब मेमोरी खाली करने की ज़रूरत नहीं है. ऐसा गलत तरीके से करने से, आपके ऐप्लिकेशन में छोटे-मोटे बग हो सकते हैं और मेमोरी लीक हो सकती है.

डैगर सेक्शन में, आपको जानें कि इस प्रोसेस को ऑटोमेट करने और वही कोड जनरेट करने के लिए, डैगर का इस्तेमाल कैसे किया जा सकता है नहीं तो आप उसे हाथ से लिखते.