Android 使用翻新2（多服务）的最佳实践

我正在使用Kotlin编写一个Android应用程序，集成了第2个

据我所知（如果我错了，请纠正我），这样做的“传统”方式是：

创建一个接口，其中包括我所有API的方法定义

使用reformation.create（）将其传递给reformation，它为我实现了它，然后我可以使用步骤#1中的函数访问它们

在看了之后，我的问题是： 为我的每个请求创建单独的接口是更好的做法吗

e、 g.如果我有一个“LoginRequest”，并按照下面所示实现它（“create”实质上调用reformation.create（）），那么下次我想添加/删除API时，我只需要添加/删除1个文件，而不是几个地方（请求本身、步骤#1中的服务以及使用步骤#2中的方法的所有地方）。另一方面，这会导致我的应用程序“知道”2，我也不确定这是否是一个好的做法

interface MyRequest {
    fun execute()
}

class LoginRequest (private val email: String, private val password: String) : MyRequest {
    interface LoginRequestService {
        @POST("login")
        fun emailLogin(
                @Body loginRequestBody: LoginRequestBody):
                retrofit2.Call<GetUserDetailsResponse>
    }

    override fun execute() {
        val requestBody = LoginRequestBody(email, password)
        val call = MyRequestManager.create(LoginRequestService::class.java).emailLogin(requestBody)
        MyRequestManager.executeCall(call)
    }
}

接口请求{
乐趣执行（）
}
类LoginRequest（private-val-email:String，private-val-password:String）：MyRequest{
接口登录请求服务{
@发布（“登录”）
有趣的电子邮件登录(
@正文loginRequestBody:loginRequestBody）：
2.打电话
}
重写fun execute（）{
val requestBody=LoginRequestBody（电子邮件、密码）
val call=MyRequestManager.create（LoginRequestService:：class.java）。emailLogin（requestBody）
MyRequestManager.executeCall（调用）
}
}

如果您按照官方指南操作会更好

公共接口服务{
@获取（“用户/{user}/repos”）
调用listRepos（@Path（“user”）字符串user）；
}
改装改装=新改装.Builder（）
.baseUrl（“https://api.github.com/")
.build（）；
GitHubService服务=改造.create（GitHubService.class）；
Call repos=service.listRepos（“octocat”）；

然后您可以为服务创建一个单例，这样更简单，我还喜欢为每个调用创建接口，如bellow，它将在我想要的任何类中使用

interface IListRepos {
    fun listRepos(user: String, onResponse: (MutableList<Repo>?) -> Unit) {
        ServiceSingleton.client.create(GitHubService::class.java)
                .listRepos(user)
                .enqueue(object : Callback<MutableList<Repo>> {
                    override fun onResponse(call: Call<MutableList<Repo>>,
                                            response: retrofit2.Response<MutableList<Repo>>) {
                        onResponse(response.body())
                    }

                    override fun onFailure(call: Call<MutableList<Repo>>, t: Throwable) {
                        onResponse(null)
                    }
                })
    }
}

接口IListRepos{
趣味列表库（用户：字符串，onResponse:（可变列表？->Unit）{
ServiceSingleton.client.create（GitHubService:：class.java）
.listRepos（用户）
.enqueue（对象：回调{
覆盖fun onResponse（调用：调用，
答复：2.答复）{
onResponse（response.body（））
}
覆盖失效时的乐趣（调用：调用，t:可丢弃）{
onResponse（空）
}
})
}
}

如果您按照官方指南操作会更好

公共接口服务{
@获取（“用户/{user}/repos”）
调用listRepos（@Path（“user”）字符串user）；
}
改装改装=新改装.Builder（）
.baseUrl（“https://api.github.com/")
.build（）；
GitHubService服务=改造.create（GitHubService.class）；
Call repos=service.listRepos（“octocat”）；

然后您可以为服务创建一个单例，这样更简单，我还喜欢为每个调用创建接口，如bellow，它将在我想要的任何类中使用

interface IListRepos {
    fun listRepos(user: String, onResponse: (MutableList<Repo>?) -> Unit) {
        ServiceSingleton.client.create(GitHubService::class.java)
                .listRepos(user)
                .enqueue(object : Callback<MutableList<Repo>> {
                    override fun onResponse(call: Call<MutableList<Repo>>,
                                            response: retrofit2.Response<MutableList<Repo>>) {
                        onResponse(response.body())
                    }

                    override fun onFailure(call: Call<MutableList<Repo>>, t: Throwable) {
                        onResponse(null)
                    }
                })
    }
}

接口IListRepos{
趣味列表库（用户：字符串，onResponse:（可变列表？->Unit）{
ServiceSingleton.client.create（GitHubService:：class.java）
.listRepos（用户）
.enqueue（对象：回调{
覆盖fun onResponse（调用：调用，
答复：2.答复）{
onResponse（response.body（））
}
覆盖失效时的乐趣（调用：调用，t:可丢弃）{
onResponse（空）
}
})
}
}

我用java做这件事的方式 有一个接口用于所有用户，具有单独的请求

里面

public interface ApiInterface {
}

我已经将所有URL设置在一个位置，以便以后编辑

String Base_Url = "http://url.com/store/web/app_dev.php/api/";
String Base_Url_Channel = "http://url.com/store/web/app_dev.php/api/APP_STORE/";
String Image_URL_Online = "http://url.com/store/web/media/image/";

对于

2

方法调用类

public class DataServiceGenerator {

    public static <S> S createService(Class<S> serviceClass) {

        String url = ApiInterface.Base_Url;
        Retrofit.Builder builder = new Retrofit.Builder()
                .addConverterFactory(GsonConverterFactory.create())
                .baseUrl(url);

        OkHttpClient.Builder httpClient = new OkHttpClient.Builder()
                .readTimeout(15, TimeUnit.SECONDS)
                .connectTimeout(15, TimeUnit.SECONDS)
                .writeTimeout(25, TimeUnit.SECONDS);

        if (BuildConfig.DEBUG) {
            HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor()
                    .setLevel(HttpLoggingInterceptor.Level.BODY);
            httpClient.addInterceptor(interceptor);
            httpClient.addNetworkInterceptor(new StethoInterceptor()); // for debugging
        }
        builder.client(httpClient.build());
        Retrofit retrofit = builder.build();
        return retrofit.create(serviceClass);
    }
 }

公共类DataServiceGenerator{
公共静态S createService（类serviceClass）{
字符串url=ApiInterface.Base\u url；
reformation.Builder=新的reformation.Builder（）
.addConverterFactory（GsonConverterFactory.create（））
.baseUrl（url）；
OkHttpClient.Builder httpClient=新建OkHttpClient.Builder（）
.readTimeout（15，时间单位为秒）
.connectTimeout（15，时间单位为秒）
.writeTimeout（25，时间单位为秒）；
if（BuildConfig.DEBUG）{
HttpLoggingInterceptor拦截器=新的HttpLoggingInterceptor（）
.setLevel（HttpLoggingInterceptor.Level.BODY）；
httpClient.addInterceptor（拦截器）；
httpClient.addNetworkInterceptor（新的StethoInterceptor（））；//用于调试
}
builder.client（httpClient.build（））；
改装改装=builder.build（）；
返回改装。创建（serviceClass）；
}
}

现在在接口中使用下面的方法调用API im

@Multipart
@Headers("Accept: Application/json")
@POST("oauth/v2/token")
Call<Token_Model> token(
        @Part("client_id") RequestBody id,
        @Part("client_secret") RequestBody secret,
        @Part("grant_type") RequestBody username,
        @Part("username") RequestBody name,
        @Part("password") RequestBody password);

@Multipart
@标题（“接受：应用程序/json”）
@POST（“oauth/v2/token”）
呼叫令牌(
@部分（“客户id”）请求主体id，
@部分（“客户机密”）请求主体机密，
@部分（“授权类型”）请求主体用户名，
@部分（“用户名”）请求主体名称，
@部分（“密码”）请求主体密码）；

对于方法本身：

Call<Token_Model> call = service.token(createPartFromString("13123khkjhfsdf"),
                createPartFromString("1asd234k234lkh24"),
                createPartFromString("password"), createPartFromString("api@example.com"), createPartFromString("test"));
        call.enqueue(new Callback<Token_Model>() {
            @Override
            public void onResponse(Call<Token_Model> call, retrofit2.Response<Token_Model> response) {
                if (response.isSuccessful()) {
                    token_model = response.body();
                    if (token_model != null) {
                        helper.setToken(token_model.getAccess_token());
                    }

                } else {
                    Toast.makeText(context, context.getString(R.string.failed_token), Toast.LENGTH_LONG).show();
                }
            }

            @Override
            public void onFailure(Call<Token_Model> call, Throwable t) {
                Toast.makeText(context, context.getString(R.string.failed_token), Toast.LENGTH_LONG).show();
            }
        });

Call Call=service.token（createPartFromString（“13123khkjhfsdf”），
createPartFromString（“1asd234k234lkh24”），
createPartFromString（“密码”），createPartFromString（“api@example.com），createPartFromString（“测试”）；
call.enqueue（新回调（）{
@凌驾
公共无效onResponse（呼叫，改装2.响应重新