compile 'com.squareup.retrofit2:retrofit:2.0.2'

public interface GitHubService { 
	@GET("users/{user}/repos") 
	Call<List<Repo>> listRepos(@Path("user") String user); 
}
 

建議採用第二種方式來配置，並儘量使用同一種路徑形式。

構造 Retrofit:

Retrofit retrofit = new Retrofit.Builder.baseUrl("https://api.github.com/").build;
GitHubService service = retrofit.create(GitHubService.class);
//service發起請求
Call<List<Repo>> repos = service.listRepos("octocat");

返回的repos其實並不是真正的資料結果，它更像一條指令，你可以在合適的時機去執行它：

Lisg<Repo> data = repos.execute();//同步呼叫
repos.enqueue(new Callback<List<repo>>(){
	@Override
	public void onResponse(Call<List<rpo>> call, Response<List<Repo>> response){
		List<Repo> data = response.body();
	}	
	@Override
	public void onFailure(Call<List<Repo>> call,Throwable t){
		t.printStackTrace();
	}
});

認識Query & QueryMap

@GET("/list") Call<ResponseBody> list(@Query("page") int page);

interface PrintlnServer{
	@GET("/") 
	Call<String> cate(@Query("cate") String cate); 
}

認識Field & FieldMap

@FormUrlEncoded 
@POST("/") 
Call<ResponseBody> example( @Field("name") String name, @Field("occupation") String occupation);

認識Part & PartMap

public interface FileUploadService { 
	@Multipart @POST("upload") 
	Call<ResponseBody> upload(@Part("description") RequestBody description, @Part MultipartBody.Part file); 
}

如果你需要上傳檔案，和我們前面的做法類似，定義一個介面方法，需要注意的是，這個方法不再有 @FormUrlEncoded這個註解，而換成了@Multipart，後面只需要在引數中增加Part就可以了。也許你會問，這裡的Part和Field究竟有什麼區別，其實從功能上講，無非就是客戶端向服務端發起請求攜帶引數的方式不同，並且前者可以攜帶的引數型別更加豐富，包括資料流。也正是因為這一點，我們可以通過這種方式來上傳檔案，下面我們就給出這個介面的使用方法：

//先建立Service
FileUploadService service = retrofit.create(FileUploadService.class);
//構建要上傳的檔案
File file = new File(filename);
RequestBody requestFile = RequestBody.crate(MediaType.parse("application/otcet-stream"),file);
MultipartBody.Part body = MultipartBody.Part.crateFormData("aFile",file.getNmae(),requestFile);
String description = RequestBody.create(MediaType.parse("multipart/form-data"),descriptionString);
Call<ResponseBody> call = service.upload(description,body);
call.enqueue(new Callback<ResponseBody>(){
	@Override
	public void onResponse(Call<ResponseBody call,Response<ResponseBody> response){
		Log.d("success","success");
	}
	@Override
	public void onFailure(Call<ResponseBody> call,Throwable t){
		t.printStackTrace();
	}
});

public interface FileUploadService { 
	@Multipart @POST("upload") 
	Call<ResponseBody> upload(@Part("description") RequestBody description, //注意這裡的引數 "aFile" 之前是在建立 MultipartBody.Part 的時候傳入的 @Part("aFile")
	File file); 	
}
static class FileRequestBodyConverterFactory extends Converter.Factory { 
	@Override
	public Converter<File, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) { 
		return new FileRequestBodyConverter; 
	} 
} 
static class FileRequestBodyConverter implements Converter<File, RequestBody> { 
	@Override 
	public RequestBody convert(File file) throws IOException { 
		return RequestBody.create(MediaType.parse("application/otcet-stream"), file); 
	} 
}

addConverterFactory(new FileRequestBodyConverterFactory)

public interface Call<T> extends Cloneable { 
	//同步發起請求 
	Response<T> execute throws IOException; 
	//非同步發起請求，結果通過回撥返回 
	void enqueue(Callback<T> callback); 
	boolean isExecuted; 
	void cancel; 
	boolean isCanceled; 
	Call<T> clone; 
	//返回原始請求 
	Request request;
}

Call<List<Repo>> repos = service.listRepos("octocat");
List<Repo> data = repos.execute;

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException { 
	ResponseBody rawBody = rawResponse.body; //略掉一些程式碼 
	try { 
		//在這裡完成了原始 Response 的解析，T 就是我們想要的結果，比如 GitHubService.listRepos 的 List<Repo> T body = serviceMethod.toResponse(catchingBody); 
		return Response.success(body, rawResponse); 
	} catch (RuntimeException e) { 
		// If the underlying source threw an exception, propagate that rather than indicating it was // a runtime exception. catchingBody.throwIfCaught; 
		throw e; 		
	} 
}

public interface GitHub { 
	@GET("/repos/{owner}/{repo}/contributors") 
	Observable<List<Contributor>> contributors( @Path("owner") String owner, @Path("repo") String repo); 
}

addCallAdapterFactory(RxJavaCallAdapterFactory.create)

/**
*  只給大家列出來比較重要的程式碼段
*/
public final class RxJavaCallAdapterFactory extends CallAdapter.Factory{
		@Override
		public CallAdapger<?> get(Type returnType,Annotation[] annotations,Retrofit retrofit){
			//判斷returnType是否為RxJava支援的型別
			Class<?> rawType = getRawType(returnType);
			String CanonicalName = RawType.getCanonicalName();
			boolean isSingle = "rx.Single".equals(CanonicalName);
			boolean isCompletable = "rx.Completable".equals(CanonicalName);
			if(rawType != Observable.class && !isSingle && !isCompletable){
				return null;
			}
			return Adapter;//"獲取你需要的Adapter 返回"
		}

		static final class SimpleCallAdapter implements CallAdapter<Ovservable<?>>{
			private final Type responseType;
			private final Scheduler scheduler;

			SimpleCallAdpter(Type responseType ,Scheduler scheduler){
				this.responseType = responseType;
				this.scheduler = scheduler;
			}

			@Override
			public Type responseType(){
				return responseType;
			}
			
			@Override
			public <R> Observable<R> adapt(Call<R> call){
				//在這裡建立需要作為返回值的Observable例項，並持有call例項，所以在Observable.subscribe觸發時，call.execute將會被呼叫
				Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)).lift(OperatorMapResponseToBodyOrError.<R>instance());
				if(scheduler != null){
					return observable.subscribeOn(scheduler);
				}
				return observable;
			}
		}
}