Android
खंजर २

वाक्य - विन्यास

• @मापांक
• @Component (निर्भरताएं = {OtherComponent.class}, मॉड्यूल = {ModuleA.class, ModuleB.class})
• DaggerMyComponent.create ()
• DaggerMyComponent.builder ()। MyModule (newMyModule ())। Create ()

टिप्पणियों

अनुप्रयोग और गतिविधि इंजेक्शन के लिए घटक सेटअप

एक मूल AppComponent जो अनुप्रयोग-व्यापी सिंगलटन ऑब्जेक्ट्स प्रदान करने के लिए एकल AppModule पर निर्भर करता है।

@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {

    void inject(App app);

    Context provideContext();

    Gson provideGson();
}

एक मॉड्यूल AppComponent साथ उपयोग करने के लिए जो अपने सिंगलटन ऑब्जेक्ट्स प्रदान करेगा, उदाहरण के लिए पूरे आवेदन में पुन: उपयोग करने के लिए Gson का एक उदाहरण।

@Module
public class AppModule {

    private final Application mApplication;

    public AppModule(Application application) {
        mApplication = application;
    }

    @Singleton
    @Provides
    Gson provideGson() {
        return new Gson();
    }

    @Singleton
    @Provides
    Context provideContext() {
        return mApplication;
    }
}

डैगर और सिंगलटन घटक को सेटअप करने के लिए एक उपवर्गित अनुप्रयोग।

public class App extends Application {

    @Inject
    AppComponent mAppComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        DaggerAppComponent.builder().appModule(new AppModule(this)).build().inject(this);
    }

    public AppComponent getAppComponent() {
        return mAppComponent;
    }
}

अब एक गतिविधि ने घटक को AppComponent दिया, जो AppComponent वस्तुओं पर पहुंच प्राप्त करने के लिए AppComponent पर निर्भर करता है।

@ActivityScope
@Component(dependencies = AppComponent.class, modules = ActivityModule.class)
public interface MainActivityComponent {

    void inject(MainActivity activity);
}

और एक पुन: प्रयोज्य ActivityModule जो मूल निर्भरता प्रदान करेगा, जैसे FragmentManager

@Module
public class ActivityModule {

    private final AppCompatActivity mActivity;

    public ActivityModule(AppCompatActivity activity) {
        mActivity = activity;
    }

    @ActivityScope
    public AppCompatActivity provideActivity() {
        return mActivity;
    }


    @ActivityScope
    public FragmentManager provideFragmentManager(AppCompatActivity activity) {
        return activity.getSupportFragmentManager();
    }
}

सब कुछ एक साथ Gson हम सेट हो गए हैं और अपनी गतिविधि को इंजेक्ट कर सकते हैं और पूरे ऐप में एक ही Gson का उपयोग करना सुनिश्चित कर सकते हैं!

public class MainActivity extends AppCompatActivity {

    @Inject
    Gson mGson;

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

        DaggerMainActivityComponent.builder()
                .appComponent(((App)getApplication()).getAppComponent())
                .activityModule(new ActivityModule(this))
                .build().inject(this);
    }
}

कस्टम स्कोप्स

@Scope
@Documented
@Retention(RUNTIME)
public @interface ActivityScope {
}

स्कोप्स केवल एनोटेशन हैं और आप अपनी खुद की जरूरत के अनुसार बना सकते हैं।

कंस्ट्रक्टर इंजेक्शन

निर्भरता के बिना कक्षाएं आसानी से खंजर द्वारा बनाई जा सकती हैं।

public class Engine {

    @Inject // <-- Annotate your constructor.
    public Engine() {
    }
}

यह वर्ग किसी भी घटक द्वारा प्रदान किया जा सकता है। इसकी अपनी कोई निर्भरता नहीं है और इसे स्कूप नहीं किया गया है । कोई और कोड आवश्यक नहीं है।

कंस्ट्रक्टर में निर्भरता को पैरामीटर के रूप में घोषित किया जाता है। डैगर कंस्ट्रक्टर को कॉल करेगा और निर्भरता की आपूर्ति करेगा, जब तक कि उन पर निर्भरता प्रदान की जा सकती है।

public class Car {

    private Engine engine;

    @Inject
    public Car(Engine engine) {
        this.engine = engine;
    }
}

यह घटक हर घटक द्वारा प्रदान किया जा सकता है यदि यह घटक इस मामले में अपने सभी निर्भरता- Engine भी प्रदान कर सकता है। चूंकि Engine को कंस्ट्रक्टर इंजेक्ट भी किया जा सकता है, कोई भी घटक एक Car प्रदान कर सकता है।

जब भी घटक द्वारा सभी निर्भरताएं प्रदान की जा सकती हैं आप कंस्ट्रक्टर इंजेक्शन का उपयोग कर सकते हैं। एक घटक एक निर्भरता प्रदान कर सकता है, यदि

• यह कंस्ट्रक्टर इंजेक्शन का उपयोग करके इसे बना सकता है
• घटक का एक मॉड्यूल इसे प्रदान कर सकता है
• यह मूल घटक द्वारा प्रदान किया जा सकता है (यदि यह @Subcomponent )
• यह उस घटक पर निर्भर एक वस्तु का उपयोग कर सकता है जिस पर यह निर्भर करता है (घटक निर्भरता)

@Component (निर्भरता = {...}) के बजाय @Subcomponent का उपयोग करना

@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {
    void inject(App app);

    Context provideContext();
    Gson provideGson();

    MainActivityComponent mainActivityComponent(ActivityModule activityModule);
}

@ActivityScope
@Subcomponent(modules = ActivityModule.class)
public interface MainActivityComponent {
    void inject(MainActivity activity);
}

public class MainActivity extends AppCompatActivity {

    @Inject
    Gson mGson;

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

        ((App)getApplication()).getAppComponent()
                .mainActivityComponent(new ActivityModule(this)).inject(this);
    }
}

बिल्ड.ग्रेड में डैगर 2 कैसे जोड़ें

ग्रैडल 2.2 के जारी होने के बाद से, एंड्रॉइड-एप प्लगइन का उपयोग अब उपयोग नहीं किया जाता है। डैगर 2 को स्थापित करने की निम्नलिखित विधि का उपयोग किया जाना चाहिए। ग्रेडल के पुराने संस्करण के लिए, नीचे दिखाए गए पिछले तरीके का उपयोग करें।

ग्रेडेल के लिए = = 2.2

dependencies {
    // apt command comes from the android-apt plugin
    annotationProcessor 'com.google.dagger:dagger-compiler:2.8'
    compile 'com.google.dagger:dagger:2.8'
    provided 'javax.annotation:jsr250-api:1.0'
}

ग्रेडेल <2.2 के लिए

Dagger 2 का उपयोग करने के लिए android-apt प्लगइन जोड़ना आवश्यक है, इसे जड़ build.gradle में जोड़ें:

buildscript {
    dependencies {
        classpath 'com.android.tools.build:gradle:2.1.0'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}

तब अनुप्रयोग मॉड्यूल के build.gradle में होना चाहिए:

apply plugin: 'com.android.application'
apply plugin: 'com.neenbedankt.android-apt'
    

android {
    …
}

final DAGGER_VERSION = '2.0.2'
dependencies {
    …

    compile "com.google.dagger:dagger:${DAGGER_VERSION}"
    apt "com.google.dagger:dagger-compiler:${DAGGER_VERSION}"
}

संदर्भ: https://github.com/codepath/android_guides/wiki/D dependency-Injection-with-Digger-2

कई मॉड्यूल से एक घटक बनाना

डैगर 2 कई मॉड्यूल से एक घटक बनाने का समर्थन करता है। आप अपना कंपोनेंट इस तरह से बना सकते हैं:

@Singleton
@Component(modules = {GeneralPurposeModule.class, SpecificModule.class})
public interface MyMultipleModuleComponent {
    void inject(MyFragment myFragment);
    void inject(MyService myService);
    void inject(MyController myController);
    void inject(MyActivity myActivity);
}

दो संदर्भ मॉड्यूल GeneralPurposeModule और SpecificModule को निम्न प्रकार से लागू किया जा सकता है:

GeneralPurposeModule.java

@Module
public class GeneralPurposeModule {
    @Provides
    @Singleton
    public Retrofit getRetrofit(PropertiesReader propertiesReader, RetrofitHeaderInterceptor headerInterceptor){
        // Logic here...
        return retrofit;
    }

    @Provides
    @Singleton
    public PropertiesReader getPropertiesReader(){
        return new PropertiesReader();
    }

    @Provides
    @Singleton
    public RetrofitHeaderInterceptor getRetrofitHeaderInterceptor(){
         return new RetrofitHeaderInterceptor();
    }
}

SpecificModule.java

@Singleton
@Module
public class SpecificModule {
    @Provides @Singleton
    public RetrofitController getRetrofitController(Retrofit retrofit){
        RetrofitController retrofitController = new RetrofitController();
        retrofitController.setRetrofit(retrofit);
        return retrofitController;
    }

    @Provides @Singleton
    public MyService getMyService(RetrofitController retrofitController){
        MyService myService = new MyService();
        myService.setRetrofitController(retrofitController);
        return myService;
    }
}

निर्भरता इंजेक्शन चरण के दौरान, घटक दोनों मॉड्यूल से वस्तुओं को आवश्यकताओं के अनुसार ले जाएगा।

यह दृष्टिकोण प्रतिरूपकता की दृष्टि से बहुत उपयोगी है। उदाहरण में, एक सामान्य उद्देश्य मॉड्यूल है जो कि Retrofit ऑब्जेक्ट (नेटवर्क संचार को संभालने के लिए) और एक PropertiesReader (कॉन्फ़िगरेशन फ़ाइलों को संभालने के प्रभारी) जैसे घटकों को Retrofit करने के लिए उपयोग किया जाता है। एक विशिष्ट मॉड्यूल भी है जो उस विशिष्ट एप्लिकेशन घटक के संबंध में विशिष्ट नियंत्रकों और सेवा वर्गों की तात्कालिकता को संभालता है।