Android
Retrofit2

परिचय

टिप्पणियों

dependencies {
    ...
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'    
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    ...
}

<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>retrofit</artifactId>
  <version>2.3.0</version>
</dependency>

एक साधारण सा निवेदन

हम यह दिखाने जा रहे हैं कि JSON ऑब्जेक्ट या JSON सरणी के साथ प्रतिक्रिया करने वाले API के लिए GET अनुरोध कैसे GET । पहली चीज जो हमें करने की ज़रूरत है वह है हमारे मॉड्यूल की ग्रेडल फ़ाइल में रेट्रोफिट और GSON कन्वर्टर निर्भरता जोड़ना।

रिमार्क्स अनुभाग में वर्णित रिट्रोफिट लाइब्रेरी के लिए निर्भरताएं जोड़ें।

अपेक्षित JSON ऑब्जेक्ट का उदाहरण:

{
    "deviceId": "56V56C14SF5B4SF",
    "name": "Steven",
    "eventCount": 0
}

JSON सरणी का उदाहरण:

[
    {
        "deviceId": "56V56C14SF5B4SF",
        "name": "Steven",
        "eventCount": 0
    },
    {
        "deviceId": "35A80SF3QDV7M9F",
        "name": "John",
        "eventCount": 2
    }
]

संबंधित मॉडल वर्ग का उदाहरण:

public class Device
{
    @SerializedName("deviceId")
    public String id;

    @SerializedName("name")
    public String name;

    @SerializedName("eventCount")
    public int eventCount;
}

@SerializedName यहाँ व्याख्याओं से होने वाले हैं GSON पुस्तकालय और हमें करने की अनुमति देता serialize और deserialize करने के लिए इस वर्ग JSON कुंजी के रूप में धारावाहिक नाम का उपयोग कर। अब हम एपीआई के लिए इंटरफ़ेस का निर्माण कर सकते हैं जो वास्तव में सर्वर से डेटा प्राप्त करेगा।

public interface DeviceAPI
{
    @GET("device/{deviceId}")
    Call<Device> getDevice (@Path("deviceId") String deviceID);

    @GET("devices")
    Call<List<Device>> getDevices();
}

यहाँ एक बहुत कॉम्पैक्ट जगह में बहुत कुछ चल रहा है तो चलो इसे तोड़ दें:

• @GET एनोटेशन @GET से आता है और लाइब्रेरी को बताता है कि हम एक GET अनुरोध को परिभाषित कर रहे हैं।
• कोष्ठक में पथ समापन बिंदु है कि हमारा जीईटी अनुरोध हिट होना चाहिए (हम थोड़ी देर बाद आधार यूआरएल सेट करेंगे)।
• घुंघराले-कोष्ठक हमें चलने के समय पथ के कुछ हिस्सों को बदलने की अनुमति देते हैं ताकि हम तर्क पारित कर सकें।
• जिस फ़ंक्शन को हम परिभाषित कर रहे हैं, उसे getDevice कहा जाता है और डिवाइस आईडी को हम एक तर्क के रूप में चाहते हैं।
• @PATH एनोटेशन रिट्रोफिट को बताता है कि इस तर्क को "deviceId" प्लेसहोल्डर को रास्ते में बदलना चाहिए।
• फ़ंक्शन Device Call ऑब्जेक्ट को लौटाता है।

एक आवरण वर्ग बनाना:

अब हम अपने एपीआई के लिए थोड़ा रैपर क्लास बनाएंगे ताकि रेट्रोफिट इनिशियलाइज़ेशन कोड को अच्छी तरह से लपेटा जा सके।

public class DeviceAPIHelper
{
    public final DeviceAPI api;

    private DeviceAPIHelper ()
    {

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://example.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        api = retrofit.create(DeviceAPI.class);
    }
}

यह वर्ग JSON प्रतिक्रिया को पार्स करने में सक्षम होने के लिए एक GSON उदाहरण बनाता है, हमारे बेस url और GSONConverter के साथ एक Retrofit उदाहरण बनाता है और फिर हमारे API का एक उदाहरण बनाता है।

एपीआई कॉलिंग:

// Getting a JSON object
Call<Device> callObject = api.getDevice(deviceID);
callObject.enqueue(new Callback<Response<Device>>()
{
    @Override
    public void onResponse (Call<Device> call, Response<Device> response)
    {
        if (response.isSuccessful()) 
        {
           Device device = response.body();
        }
    }

    @Override
    public void onFailure (Call<Device> call, Throwable t)
    {
        Log.e(TAG, t.getLocalizedMessage());
    }
});

// Getting a JSON array
Call<List<Device>> callArray = api.getDevices();
callArray.enqueue(new Callback<Response<List<Device>>()
{
    @Override
    public void onResponse (Call<List<Device>> call, Response<List<Device>> response)
    {
        if (response.isSuccessful()) 
        {
           List<Device> devices = response.body();
        }
    }

    @Override
    public void onFailure (Call<List<Device>> call, Throwable t)
    {
        Log.e(TAG, t.getLocalizedMessage());
    }
});

यह Call<Device> करने के लिए हमारे API इंटरफ़ेस का उपयोग करता है क्रमशः Call<Device> ऑब्जेक्ट बनाने के लिए और Call<List<Device>> बनाने के लिए। कॉलिंग enqueue रेट्रॉफिट को पृष्ठभूमि के धागे पर कॉल करने के लिए कहता है और कॉलबैक के परिणाम को वापस करता है जो हम यहां बना रहे हैं।

नोट: आदिम वस्तुओं (जैसे स्ट्रिंग, इंटेगर, बुलियन , और डबल ) के एक JSON सरणी को पार्स करना एक JSON सरणी को पार्स करने के समान है। हालाँकि, आपको अपने मॉडल वर्ग की आवश्यकता नहीं है। उदाहरण के लिए स्ट्रिंग्स की सरणी को आप Call<List<String>> रूप में Call<List<String>> का रिटर्न प्रकार प्राप्त कर सकते हैं।

Retrofit2 में लॉगिंग जोड़ें

इंटरसेप्ट का उपयोग करके रेट्रोफिट अनुरोधों को लॉग किया जा सकता है। विस्तार के कई स्तर उपलब्ध हैं: कोई भी, बुनियादी, प्रमुख, शरीर। यहाँ Github प्रोजेक्ट देखें।

1. Build.gradle के लिए निर्भरता जोड़ें:

compile 'com.squareup.okhttp3:logging-interceptor:3.8.1'

2. रेट्रोफ़िट बनाते समय लॉगिंग इंटरसेप्टर जोड़ें:

  HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
  loggingInterceptor.setLevel(LoggingInterceptor.Level.BODY);
  OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
          .addInterceptor(loggingInterceptor)
          .build();
  Retrofit retrofit = new Retrofit.Builder()
          .baseUrl("http://example.com/")
          .client(okHttpClient)
          .addConverterFactory(GsonConverterFactory.create(gson))
          .build();

टर्मिनल (एंड्रॉइड मॉनिटर) में लॉग्स को एक्सपोज़ करना कुछ ऐसा है जिसे रिलीज़ संस्करण में टाला जाना चाहिए क्योंकि इससे महत्वपूर्ण जानकारी जैसे कि प्रामाणिक टोकन आदि का अवांछित खुलासा हो सकता है।

रन टाइम में लॉग के उजागर होने से बचने के लिए, निम्न स्थिति की जाँच करें

if(BuildConfig.DEBUG){
     //your interfector code here   
    }

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

HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
if(BuildConfig.DEBUG){
     //print the logs in this case   
    loggingInterceptor.setLevel(LoggingInterceptor.Level.BODY);
}else{
    loggingInterceptor.setLevel(LoggingInterceptor.Level.NONE);
}

OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
      .addInterceptor(loggingInterceptor)
      .build();

Retrofit retrofit = new Retrofit.Builder()
      .baseUrl("http://example.com/")
      .client(okHttpClient)
      .addConverterFactory(GsonConverterFactory.create(gson))
      .build();

मल्टीपार्ट के माध्यम से फाइल अपलोड करना

अपना इंटरफ़ेस Retrofit2 एनोटेशन के साथ घोषित करें:

public interface BackendApiClient {
    @Multipart
    @POST("/uploadFile")
    Call<RestApiDefaultResponse> uploadPhoto(@Part("file\"; filename=\"photo.jpg\" ") RequestBody photo);
}

जहां RestApiDefaultResponse एक कस्टम वर्ग है जिसमें प्रतिक्रिया होती है।

अपने एपीआई के कार्यान्वयन का निर्माण करना और कॉल को लागू करना:

Retrofit retrofit = new Retrofit.Builder()
                                .addConverterFactory(GsonConverterFactory.create())
                                .baseUrl("http://<yourhost>/")
                                .client(okHttpClient)
                                .build();

BackendApiClient apiClient = retrofit.create(BackendApiClient.class);
RequestBody reqBody = RequestBody.create(MediaType.parse("image/jpeg"), photoFile);
Call<RestApiDefaultResponse> call = apiClient.uploadPhoto(reqBody);
call.enqueue(<your callback function>);

OkHttp इंटरसेप्टर के साथ रेट्रोफिट

यह उदाहरण दिखाता है कि OkHttp के साथ एक अनुरोध अवरोधक का उपयोग कैसे करें। इसके कई उपयोग मामले हैं जैसे:

• अनुरोध में सार्वभौमिक header जोड़ना। जैसे एक निवेदन को प्रमाणित करना
• नेटवर्क अनुप्रयोगों को डीबग करना
• कच्ची response प्राप्त करना
• लॉग इन नेटवर्क लेनदेन आदि।
• कस्टम उपयोगकर्ता एजेंट सेट करें

Retrofit.Builder builder = new Retrofit.Builder()
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .addConverterFactory(GsonConverterFactory.create())
        .baseUrl("https://api.github.com/");

if (!TextUtils.isEmpty(githubToken)) {
    // `githubToken`: Access token for GitHub
    OkHttpClient client = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
        @Override public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Request newReq = request.newBuilder()
                    .addHeader("Authorization", format("token %s", githubToken))
                    .build();
            return chain.proceed(newReq);
        }
    }).build();

    builder.client(client);
}

return builder.build().create(GithubApi.class);

अधिक जानकारी के लिए OkHttp विषय देखें।

हेडर और बॉडी: एक प्रमाणीकरण उदाहरण

@Header और @Body एनोटेशन को विधि हस्ताक्षर में रखा जा सकता है और रेट्रोफिट स्वचालित रूप से आपके मॉडल के आधार पर उन्हें बनाएगा।

public interface MyService {
     @POST("authentication/user")
     Call<AuthenticationResponse> authenticateUser(@Body AuthenticationRequest request, @Header("Authorization") String basicToken);
}

AuthenticaionRequest हमारा मॉडल है, एक POJO, जिसमें सर्वर की आवश्यकता होती है। इस उदाहरण के लिए, हमारा सर्वर क्लाइंट कुंजी और गुप्त चाहता है।

public class AuthenticationRequest {
     String clientKey;
     String clientSecret;
}

ध्यान दें कि @Header("Authorization") हम निर्दिष्ट कर रहे हैं कि हम प्राधिकरण हेडर को पॉप्युलेट कर रहे हैं। अन्य हेडर स्वचालित रूप से पॉपुलेट किए जाएंगे क्योंकि रिट्रोफिट यह अनुमान लगा सकता है कि वे उन वस्तुओं के प्रकार पर आधारित हैं जिन्हें हम भेज रहे हैं और बदले में उम्मीद कर रहे हैं।

हम कहीं न कहीं अपनी रेट्रोफिट सर्विस बनाते हैं। हम HTTPS का उपयोग करना सुनिश्चित करते हैं।

Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https:// some example site")
            .client(client)
            .build();
MyService myService = retrofit.create(MyService.class)

तब हम अपनी सेवा का उपयोग कर सकते हैं।

AuthenticationRequest request = new AuthenticationRequest();
request.setClientKey(getClientKey());
request.setClientSecret(getClientSecret());
String basicToken = "Basic " + token;
myService.authenticateUser(request, basicToken);

मल्टीपार्ट के रूप में रेट्रोफिट का उपयोग करके कई फ़ाइल अपलोड करें

एक बार जब आप अपनी परियोजना में रेट्रोफ़िट वातावरण सेट करते हैं, तो आप निम्न उदाहरण का उपयोग कर सकते हैं जो दर्शाता है कि रेट्रोफ़िट का उपयोग करके कई फ़ाइलों को कैसे अपलोड किया जाए:

private void mulipleFileUploadFile(Uri[] fileUri) {
    OkHttpClient okHttpClient = new OkHttpClient();
    OkHttpClient clientWith30sTimeout = okHttpClient.newBuilder()
            .readTimeout(30, TimeUnit.SECONDS)
            .build();

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(API_URL_BASE)
            .addConverterFactory(new MultiPartConverter())
            .client(clientWith30sTimeout)
            .build();

    WebAPIService service = retrofit.create(WebAPIService.class); //here is the interface which you have created for the call service
    Map<String, okhttp3.RequestBody> maps = new HashMap<>();

    if (fileUri!=null && fileUri.length>0) {
        for (int i = 0; i < fileUri.length; i++) {
            String filePath = getRealPathFromUri(fileUri[i]);
            File file1 = new File(filePath);

            if (filePath != null && filePath.length() > 0) {
                if (file1.exists()) {
                    okhttp3.RequestBody requestFile = okhttp3.RequestBody.create(okhttp3.MediaType.parse("multipart/form-data"), file1);
                    String filename = "imagePath" + i; //key for upload file like : imagePath0
                    maps.put(filename + "\"; filename=\"" + file1.getName(), requestFile);
                }
            }
        }
    }

    String descriptionString = " string request";//
    //hear is the your json request
    Call<String> call = service.postFile(maps, descriptionString);
    call.enqueue(new Callback<String>() {
        @Override
        public void onResponse(Call<String> call,
                               Response<String> response) {
            Log.i(LOG_TAG, "success");
            Log.d("body==>", response.body().toString() + "");
            Log.d("isSuccessful==>", response.isSuccessful() + "");
            Log.d("message==>", response.message() + "");
            Log.d("raw==>", response.raw().toString() + "");
            Log.d("raw().networkResponse()", response.raw().networkResponse().toString() + "");
        }

        @Override
        public void onFailure(Call<String> call, Throwable t) {
            Log.e(LOG_TAG, t.getMessage());
        }
    });
}
    
public String getRealPathFromUri(final Uri uri) { // function for file path from uri,
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(mContext, uri)) {
        // ExternalStorageProvider
        if (isExternalStorageDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            if ("primary".equalsIgnoreCase(type)) {
                return Environment.getExternalStorageDirectory() + "/" + split[1];
            }
        }
        // DownloadsProvider
        else if (isDownloadsDocument(uri)) {

            final String id = DocumentsContract.getDocumentId(uri);
            final Uri contentUri = ContentUris.withAppendedId(
                    Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));

            return getDataColumn(mContext, contentUri, null, null);
        }
        // MediaProvider
        else if (isMediaDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            Uri contentUri = null;
            if ("image".equals(type)) {
                contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
            } else if ("video".equals(type)) {
                contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
            } else if ("audio".equals(type)) {
                contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
            }

            final String selection = "_id=?";
            final String[] selectionArgs = new String[]{
                    split[1]
            };

            return getDataColumn(mContext, contentUri, selection, selectionArgs);
        }
    }
    // MediaStore (and general)
    else if ("content".equalsIgnoreCase(uri.getScheme())) {

        // Return the remote address
        if (isGooglePhotosUri(uri))
            return uri.getLastPathSegment();

        return getDataColumn(mContext, uri, null, null);
    }
    // File
    else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }

    return null;
}

इसके बाद इंटरफ़ेस है

public interface WebAPIService {
    @Multipart
    @POST("main.php")
    Call<String> postFile(@PartMap Map<String,RequestBody> Files, @Part("json") String description);
}

Retrofit2 का उपयोग कर सर्वर से एक फ़ाइल डाउनलोड करें

किसी फ़ाइल को डाउनलोड करने के लिए इंटरफ़ेस घोषणा

public interface ApiInterface {
    @GET("movie/now_playing")
    Call<MovieResponse> getNowPlayingMovies(@Query("api_key") String apiKey, @Query("page") int page);

    // option 1: a resource relative to your base URL
    @GET("resource/example.zip")
    Call<ResponseBody> downloadFileWithFixedUrl();

    // option 2: using a dynamic URL
    @GET
    Call<ResponseBody> downloadFileWithDynamicUrl(@Url String fileUrl);
}

विकल्प 1 का उपयोग सर्वर से एक फ़ाइल को डाउनलोड करने के लिए किया जाता है, जिसमें निश्चित URL होता है। और विकल्प 2 का उपयोग कॉल के लिए पूर्ण URL के रूप में एक गतिशील मूल्य को पास करने के लिए किया जाता है। फ़ाइलों को डाउनलोड करते समय यह सहायक हो सकता है, जो उपयोगकर्ता या समय जैसे मापदंडों पर निर्भर हैं।

एपीआई कॉल करने के लिए सेटअप रेट्रोफिट

public class ServiceGenerator {

    public static final String API_BASE_URL = "http://your.api-base.url/";

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();

    private static Retrofit.Builder builder =
            new Retrofit.Builder()
            .baseUrl(API_BASE_URL)
            .addConverterFactory(GsonConverterFactory.create());

    public static <S> S createService(Class<S> serviceClass){
        Retrofit retrofit = builder.client(httpClient.build()).build();
        return retrofit.create(serviceClass);
    }

}

अब, सर्वर से फ़ाइल डाउनलोड करने के लिए एपीआई का कार्यान्वयन करें

private void downloadFile(){
        ApiInterface apiInterface = ServiceGenerator.createService(ApiInterface.class);

        Call<ResponseBody> call = apiInterface.downloadFileWithFixedUrl();

        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.isSuccessful()){
                    boolean writtenToDisk = writeResponseBodyToDisk(response.body());

                    Log.d("File download was a success? ", String.valueOf(writtenToDisk));
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {

            }
        });
    }

और कॉलबैक में प्रतिक्रिया मिलने के बाद, फ़ाइल को डिस्क पर सहेजने के लिए कुछ मानक IO कोड करें। यहाँ कोड है:

private boolean writeResponseBodyToDisk(ResponseBody body) {
        try {
            // todo change the file location/name according to your needs
            File futureStudioIconFile = new File(getExternalFilesDir(null) + File.separator + "Future Studio Icon.png");

            InputStream inputStream = null;
            OutputStream outputStream = null;

            try {
                byte[] fileReader = new byte[4096];

                long fileSize = body.contentLength();
                long fileSizeDownloaded = 0;

                inputStream = body.byteStream();
                outputStream = new FileOutputStream(futureStudioIconFile);

                while (true) {
                    int read = inputStream.read(fileReader);

                    if (read == -1) {
                        break;
                    }

                    outputStream.write(fileReader, 0, read);

                    fileSizeDownloaded += read;

                    Log.d("File Download: " , fileSizeDownloaded + " of " + fileSize);
                }

                outputStream.flush();

                return true;
            } catch (IOException e) {
                return false;
            } finally {
                if (inputStream != null) {
                    inputStream.close();
                }

                if (outputStream != null) {
                    outputStream.close();
                }
            }
        } catch (IOException e) {
            return false;
        }
    }

ध्यान दें कि हमने रिस्पॉन्सबॉडी को रिटर्न टाइप के रूप में निर्दिष्ट किया है, अन्यथा रेट्रोफ़िट इसे पार्स करने और बदलने की कोशिश करेगा, जो फ़ाइल डाउनलोड करते समय इसका कोई मतलब नहीं है।

यदि आप रेट्रोफिट सामान पर अधिक चाहते हैं, तो इस लिंक पर मिला क्योंकि यह बहुत उपयोगी है। [१]: https://futurestud.io/blog/retrofit-getting-started-and-android-client

स्टेथो के साथ डिबगिंग

अपने आवेदन में निम्नलिखित निर्भरताएं जोड़ें।

compile 'com.facebook.stetho:stetho:1.5.0' 
compile 'com.facebook.stetho:stetho-okhttp3:1.5.0' 

अपने एप्लिकेशन क्लास ' onCreate विधि में, निम्नलिखित को कॉल करें।

Stetho.initializeWithDefaults(this);

अपने Retrofit उदाहरण को बनाते समय, एक कस्टम OkHttp उदाहरण बनाएं।

OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
clientBuilder.addNetworkInterceptor(new StethoInterceptor());

फिर इस कस्टम OkHttp उदाहरण को Retrofit उदाहरण में सेट करें।

Retrofit retrofit = new Retrofit.Builder()
    // ...
    .client(clientBuilder.build())
    .build();

अब अपने फ़ोन को अपने कंप्यूटर से कनेक्ट करें, ऐप लॉन्च करें, और अपने क्रोम ब्राउज़र में chrome://inspect टाइप करें chrome://inspect करें। आपके द्वारा निरीक्षण करने के लिए अब रेट्रोफिट नेटवर्क कॉल दिखाई देनी चाहिए।

रेट्रोफिट 2 कस्टम Xml कन्वर्टर

Build.gradle फ़ाइल में निर्भरताएँ जोड़ना।

dependencies {
    ....
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile ('com.thoughtworks.xstream:xstream:1.4.7') {
        exclude group: 'xmlpull', module: 'xmlpull'
    }
    ....
}

फिर कनवर्टर फैक्ट्री बनाएं

public class XStreamXmlConverterFactory extends Converter.Factory {

    /** Create an instance using a default {@link com.thoughtworks.xstream.XStream} instance for conversion. */
    public static XStreamXmlConverterFactory create() {
        return create(new XStream());
    }

    /** Create an instance using {@code xStream} for conversion. */
    public static XStreamXmlConverterFactory create(XStream xStream) {
        return new XStreamXmlConverterFactory(xStream);
    }

    private final XStream xStream;

    private XStreamXmlConverterFactory(XStream xStream) {
        if (xStream == null) throw new NullPointerException("xStream == null");
        this.xStream = xStream;
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {

        if (!(type instanceof Class)) {
            return null;
        }

        Class<?> cls = (Class<?>) type;

        return new XStreamXmlResponseBodyConverter<>(cls, xStream);
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type,
          Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {

        if (!(type instanceof Class)) {
            return null;
        }

        return new XStreamXmlRequestBodyConverter<>(xStream);
    }
}

बॉडी रिक्वेस्ट को हैंडल करने के लिए एक क्लास बनाएं।

final class XStreamXmlResponseBodyConverter <T> implements Converter<ResponseBody, T> {

    private final Class<T> cls;
    private final XStream xStream;

    XStreamXmlResponseBodyConverter(Class<T> cls, XStream xStream) {
        this.cls = cls;
        this.xStream = xStream;
    }

    @Override
    public T convert(ResponseBody value) throws IOException {

        try {

            this.xStream.processAnnotations(cls);
            Object object =  this.xStream.fromXML(value.byteStream());
            return (T) object;

        }finally {
            value.close();
        }
    }
}

शरीर की प्रतिक्रिया को संभालने के लिए एक कक्षा बनाएं।

final class XStreamXmlRequestBodyConverter<T> implements Converter<T, RequestBody> {

    private static final MediaType MEDIA_TYPE = MediaType.parse("application/xml; charset=UTF-8");
    private static final String CHARSET = "UTF-8";

    private final XStream xStream;

    XStreamXmlRequestBodyConverter(XStream xStream) {
        this.xStream = xStream;
    }

    @Override
    public RequestBody convert(T value) throws IOException {

        Buffer buffer = new Buffer();

        try {
            OutputStreamWriter osw = new OutputStreamWriter(buffer.outputStream(), CHARSET);
            xStream.toXML(value, osw);
            osw.flush();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
    }
}

तो, यह बिंदु हम किसी भी XML को भेज और प्राप्त कर सकते हैं, हमें बस संस्थाओं के लिए XStream एनोटेशन बनाने की आवश्यकता है।

फिर एक रेट्रोफिट उदाहरण बनाएं:

XStream xs = new XStream(new DomDriver());
xs.autodetectAnnotations(true);

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("http://example.com/")
    .addConverterFactory(XStreamXmlConverterFactory.create(xs))
    .client(client)
    .build();

GSON के साथ एक सरल POST अनुरोध

नमूना JSON:

{ 
    "id": "12345",
    "type": "android"
}

अपने अनुरोध को परिभाषित करें:

public class GetDeviceRequest {

    @SerializedName("deviceId")
    private String mDeviceId;

    public GetDeviceRequest(String deviceId) {
        this.mDeviceId = deviceId;
    }

    public String getDeviceId() {
        return mDeviceId;
    }

}

अपनी सेवा को परिभाषित करें (हिट करने के लिए समापन बिंदु):

public interface Service {

    @POST("device")
    Call<Device> getDevice(@Body GetDeviceRequest getDeviceRequest);

}

नेटवर्क क्लाइंट के अपने एकल उदाहरण को परिभाषित करें:

public class RestClient {

    private static Service REST_CLIENT;

    static {
        setupRestClient();
    }

    private static void setupRestClient() {
        
        // Define gson 
        Gson gson = new Gson();

        // Define our client 
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://example.com/")
                .addConverterFactory(GsonConverterFactory.create(gson))
                .build();

        REST_CLIENT = retrofit.create(Service.class);
    }

    public static Retrofit getRestClient() {
        return REST_CLIENT;
    }

} 

डिवाइस के लिए एक साधारण मॉडल ऑब्जेक्ट को परिभाषित करें:

public class Device {

    @SerializedName("id")
    private String mId;

    @SerializedName("type")
    private String mType;

    public String getId() {
        return mId;
    }

    public String getType() {
        return mType;
    }

}

डिवाइस के लिए अनुरोधों को संभालने के लिए नियंत्रक को परिभाषित करें

public class DeviceController {

    // Other initialization code here...

    public void getDeviceFromAPI() {

        // Define our request and enqueue 
        Call<Device> call = RestClient.getRestClient().getDevice(new GetDeviceRequest("12345"));

        // Go ahead and enqueue the request 
        call.enqueue(new Callback<Device>() {
            @Override
            public void onSuccess(Response<Device> deviceResponse) {
                // Take care of your device here 
                if (deviceResponse.isSuccess()) {
                    // Handle success
                    //delegate.passDeviceObject();
                }
            }

            @Override
            public void onFailure(Throwable t) {
                // Go ahead and handle the error here 
            } 

        });

एक्सट्रॉफ़ 2 के साथ एक्सएमएल फॉर्म URL पढ़ना

हम url और parse से Java वर्ग के लिए xml डेटा प्राप्त करने के लिए रेट्रोफिट 2 और सिंपलएक्सलायूमोर्टर का उपयोग करेंगे।

ग्रेड स्क्रिप्ट में निर्भरता जोड़ें:

compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.squareup.retrofit2:converter-simplexml:2.1.0'

इंटरफ़ेस बनाएँ

हमारे मामले में रुपये वर्ग में भी xml वर्ग आवरण बनाएँ

    public interface ApiDataInterface{
    
        // path to xml link on web site
    
        @GET (data/read.xml)
    
        Call<Rss> getData();

}

Xml पढ़ें समारोह

private void readXmlFeed() {
        try {

            // base url - url of web site
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(http://www.google.com/)
                    .client(new OkHttpClient())
                    .addConverterFactory(SimpleXmlConverterFactory.create())
                    .build();

            ApiDataInterface apiService = retrofit.create(ApiDataInterface.class);

            Call<Rss> call = apiService.getData();
            call.enqueue(new Callback<Rss>() {

                @Override
                public void onResponse(Call<Rss> call, Response<Rss> response) {

                    Log.e("Response success", response.message());
                    
                }

                @Override
                public void onFailure(Call<Rss> call, Throwable t) {
                    Log.e("Response fail", t.getMessage());
                }
            });

        } catch (Exception e) {
            Log.e("Exception", e.getMessage());
        }


    }

यह SimpleXML एनोटेशन के साथ जावा वर्ग का उदाहरण है

एनोटेशन SimpleXmlDocumentation के बारे में अधिक

@Root (name = "rss")

public class Rss
{


    public Rss() {

    }



    public Rss(String title, String description, String link, List<Item> item, String language) {

        this.title = title;
        this.description = description;
        this.link = link;
        this.item = item;
        this.language = language;

    }

    @Element (name = "title")
    private String title;

    @Element(name = "description")
    private String description;

    @Element(name = "link")
    private String link;

    @ElementList (entry="item", inline=true)
    private List<Item> item;

    @Element(name = "language")
    private String language;