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>

간단한 GET 요청

우리는 JSON 객체 또는 JSON 배열로 응답하는 API에 GET 요청을하는 방법을 보여줄 것입니다. 우리가해야 할 첫 번째 일은 모듈의 gradle 파일에 Retrofit 및 GSON Converter 의존성을 추가하는 것입니다.

비고 섹션에서 설명한대로 갱신 라이브러리에 대한 종속성을 추가하십시오.

예상 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 라이브러리에서 가져온 것으로 직렬화 된 이름을 키로 사용하여이 클래스를 JSON 으로 serialize 및 deserialize serialize 할 수 있습니다. 이제 실제로 서버에서 데이터를 가져올 API 인터페이스를 빌드 할 수 있습니다.

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

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

꽤 컴팩트 한 공간에서 많은 일이 일어나고 있습니다.

• @GET 주석은 Retrofit에서 가져온 것으로 GET 요청을 정의하고 있음을 라이브러리에 알려줍니다.
• 괄호 안의 경로는 GET 요청이 발생해야하는 엔드 포인트입니다 (기본 URL을 조금 나중에 설정합니다).
• 중괄호를 사용하면 런타임에 경로의 일부를 대체하여 인수를 전달할 수 있습니다.
• 우리가 정의하고있는 함수는 getDevice 이며, 우리가 원하는 장치 ID를 인수로 취합니다.
• @PATH 주석은 Retrofit에게이 인수가 경로의 "deviceId"자리 표시자를 대체해야한다고 알려줍니다.
• 이 함수는 Device 유형의 Call 객체를 반환합니다.

래퍼 클래스 만들기 :

이제 Retrofit 초기화 코드를 멋지게 꾸준히 유지하기 위해 API 용 약간의 래퍼 클래스를 만들 것입니다.

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의 인스턴스를 만듭니다.

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());
    }
});

이것은 우리의 API 인터페이스를 사용하여 Call<Device> 객체를 생성하고 Call<List<Device>> 를 생성합니다. enqueue 를 호출하면 Retrofit이 백그라운드 스레드에서 해당 호출을 수행하고 여기서 생성하는 콜백에 결과를 반환합니다.

참고 : 기본 객체 (JSON 배열의 구문 분석, String, Integer, Boolean , Double 등 )의 JSON 배열 구문 분석은 JSON 배열 구문 분석과 유사합니다. 그러나 자신 만의 모델 클래스는 필요하지 않습니다. Call<List<String>> 과 같은 Call<List<String>> 의 반환 유형을 사용하여 String 배열을 가져올 수 있습니다.

Retrofit2에 로깅 추가

개장 요청은 인터셉터를 사용하여 기록 할 수 있습니다. 사용 가능한 세부 수준에는 NONE, BASIC, HEADERS, BODY가 있습니다. 여기 Github 프로젝트를 참조 하십시오 .

1. build.gradle에 종속성 추가 :

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

2. Retrofit을 만들 때 로깅 인터셉터 추가 :

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

Multipart를 통해 파일 업로드

Retrofit2 주석으로 인터페이스 선언 :

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

여기서 RestApiDefaultResponse 는 응답을 포함하는 사용자 정의 클래스입니다.

API 구현 구현 및 호출 대기열에 추가하기 :

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 주석은 메소드 서명에 배치 할 수 있으며 Retrofit은 모델을 기반으로 메소드를 자동으로 작성합니다.

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") 에서 Authorization 헤더를 @Header("Authorization") 지정합니다. Retrofit에서는 보내고 예상하는 개체 유형에 따라 그 개체가 무엇인지 추측 할 수 있기 때문에 다른 헤더가 자동으로 채워집니다.

우리는 어딘가에서 개장 서비스를 제공합니다. 우리는 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);

Retrofit을 멀티 파트로 사용하여 여러 파일 업로드

프로젝트에서 Retrofit 환경을 설정하고 나면 Retrofit을 사용하여 여러 파일을 업로드하는 방법을 보여주는 다음 예제를 사용할 수 있습니다.

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을 요청 URL로 전체 URL로 전달하는 데 사용됩니다. 이는 사용자 또는 시간과 같은 매개 변수에 의존하는 파일을 다운로드 할 때 유용 할 수 있습니다.

API 호출을위한 설치 갱신

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);
    }

}

이제, 서버에서 파일을 다운로드하기위한 API 구현하기

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;
        }
    }

ResponseBody 를 반환 유형으로 지정 했음을 유의하십시오. 그렇지 않으면 Retrofit에서 파싱하고 변환하려고 시도하지만 파일을 다운로드 할 때 의미가 없습니다.

Retrofit에 대해 더 알고 싶다면이 링크를 클릭하십시오. 매우 유용합니다. [1] : https://futurestud.io/blog/retrofit-getting-started-and-android-client

Stetho로 디버깅하기

응용 프로그램에 다음 종속성을 추가하십시오.

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

Application 클래스의 onCreate 메소드에서 다음을 호출하십시오.

Stetho.initializeWithDefaults(this);

Retrofit 인스턴스를 만들 때 사용자 정의 OkHttp 인스턴스를 만듭니다.

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

그런 다음 Retrofit 인스턴스에서이 사용자 지정 OkHttp 인스턴스를 설정합니다.

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

이제 휴대 전화를 컴퓨터에 연결하고 앱을 실행 한 다음 Chrome 브라우저에 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 Annotation을 작성하면됩니다.

그런 다음 Retrofit 인스턴스를 만듭니다.

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 
            } 

        });

Retrofit 2로 XML 양식 URL 읽기

추가 기능 2와 SimpleXmlConverter를 사용하여 url에서 xml 데이터를 가져 와서 Java 클래스로 파싱합니다.

Gradle 스크립트에 종속성 추가 :

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

인터페이스 만들기

우리의 경우 Rss 클래스에서 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 주석이있는 Java 클래스의 예입니다.

주석에 대한 추가 정보 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;