यह एक कार्यशील कोड है

मैं क्या समझने की कोशिश कर रहा हूं: रेट्रोफिट नीचे okhttp , gson , Cache जैसी चीजों का उपयोग कैसे करता है .... मैं समझता हूं कि हम इसे इंजेक्ट करते हैं लेकिन जैसा कि apimodule में देखा गया है, मैं देख सकता हूं कि एक वैश्विक चर है इसका उपयोग वहां retrofit द्वारा किया जाता है लेकिन gson और okhttp इसका उपयोग कैसे किया जा रहा है, इस बारे में कोई जानकारी नहीं है।

Apimodule.java

@Module
class ApiModule {

    String mBaseUrl;

    ApiModule(String mBaseUrl) {
        this.mBaseUrl = mBaseUrl;
    }


    @Provides
    @Singleton
    Cache provideHttpCache(Application application) {
        int cacheSize = 10 * 1024 * 1024;
        Cache cache = new Cache(application.getCacheDir(), cacheSize);
        return cache;
    }

    @Provides
    @Singleton
    Gson provideGson() {
        GsonBuilder gsonBuilder = new GsonBuilder();
        gsonBuilder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES);
        return gsonBuilder.create();
    }

    @Provides
    @Singleton
    OkHttpClient provideOkhttpClient(Cache cache) {
        OkHttpClient.Builder client = new OkHttpClient.Builder();
        client.cache(cache);
        return client.build();
    }

    @Provides
    @Singleton
    Retrofit provideRetrofit(Gson gson, OkHttpClient okHttpClient) {
        return new Retrofit.Builder()
                .addConverterFactory(GsonConverterFactory.create(gson))
                .baseUrl(mBaseUrl)
                .client(okHttpClient)
                .build();
    }
}

ApiComponent.java

@Singleton
@Component(modules = {AppModule.class, ApiModule.class})
public interface ApiComponent {
    void inject(MainActivity activity);
}

MyApplication.java

public class MyApplication extends Application {

    private ApiComponent mApiComponent;

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

        mApiComponent = DaggerApiComponent.builder()
                .appModule(new AppModule(this))
                .apiModule(new ApiModule("https://simplifiedcoding.net/demos/"))
                .build();
    }

    public ApiComponent getNetComponent() {
        return mApiComponent;
    }
}

MainActivity.java

public class MainActivity extends AppCompatActivity {

    //injecting retrofit
    @Inject Retrofit retrofit;
    ListView listView;

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

        ((MyApplication) getApplication()).getNetComponent().inject(this);


        listView = (ListView) findViewById(R.id.listViewHeroes);

        getHeroes();
    }

    private void getHeroes() {
        Api api = retrofit.create(Api.class);
        Call<List<Hero>> call = api.getHeroes();

        call.enqueue(new Callback<List<Hero>>() {
            @Override
            public void onResponse(Call<List<Hero>> call, Response<List<Hero>> response) {
                List<Hero> heroList = response.body();
                String[] heroes = new String[heroList.size()];

                for (int i = 0; i < heroList.size(); i++) {
                    heroes[i] = heroList.get(i).getName();
                }

                listView.setAdapter(new ArrayAdapter<String>(getApplicationContext(), android.R.layout.simple_list_item_1, heroes));
            }

            @Override
            public void onFailure(Call<List<Hero>> call, Throwable t) {
                Toast.makeText(getApplicationContext(), t.getMessage(), Toast.LENGTH_SHORT).show();
            }
        });
    }

}
0
Devrath 20 जुलाई 2019, 16:12

2 जवाब

सबसे बढ़िया उत्तर

डैगर का उपयोग करते समय, जब हम @Provide का उपयोग करते हैं, तो हम डैगर को एक विशिष्ट Dependency बनाने का तरीका बता रहे हैं, और यह निर्भरता किसी अन्य वस्तु के लिए उपलब्ध है जिसके लिए उस निर्भरता की आवश्यकता होती है। जब हम @Inject का उपयोग करते हैं, तब डैगर यह देखेगा कि किस प्रकार की वस्तु की आवश्यकता है, जांचें कि इसके लिए किन निर्भरताओं की आवश्यकता है, यदि आप जिस वस्तु को इंजेक्ट करने का प्रयास कर रहे हैं, उसके लिए किसी ऐसी चीज की आवश्यकता है जिसे खंजर पहले से जानता है कि कैसे बनाना है (@Provides) तब यह उस वस्तु के लिए इस निर्भरता का एक नया उदाहरण बनाएगा, और इस प्रक्रिया को तब तक जारी रखेगा जब तक कि इंजेक्शन के माध्यम से आपके द्वारा अनुरोधित संपूर्ण वस्तु नहीं बन जाती।

उदहारण के लिए :

@Provides
@Singleton
fun provideContext(app: YourApplication): Context = app

@Provides
@Singleton
fun provideDatabase(context: Context): YourAppDb = YourAppDb.create(context)

इस उदाहरण में, जब भी आप YourAppDb के उदाहरण के लिए अनुरोध करते हैं, तो डैगर इसकी निर्भरता की जांच करेगा, देखें कि इसके लिए context की आवश्यकता है, यह जांच करेगा कि क्या यह संदर्भ बनाने के लिए "जानता है" (कुछ एनोटेट की जांच करें) @Provides) के साथ और फिर डेटाबेस बनाने के लिए इस context का उपयोग करें

1
a_local_nobody 20 जुलाई 2019, 20:11

आप रेट्रोफिट बिल्डर को ओकेएचटीपी और जीसन प्रदान करते हैं, और फिर रेट्रोफिट उनका उपयोग अनुरोध करने और JSON को पार्स करने के लिए करता है।

0
Alex 20 जुलाई 2019, 16:13