Java 是否可以同时使用改装1.9.0和改装2.x？

我有一个应用程序，它有很多现有的1.9接口。我想开始 以增量方式升级到翻新2.x（目前不支持一次性升级） 为了获得对RxJava调用适配器的支持（因为1.9不再被开发）

让Reformation1的

RestAdapter

共享一个OkHttp3客户端是相当简单的 这将用于改型2接口中。版本1.9和2.x也有 不同的maven GroupID，因此这些类可以并排存在，不会出现任何问题

但是，我在运行时遇到以下异常：

java.lang.IllegalAccessError: Method 'com.google.gson.stream.JsonWriter com.google.gson.Gson.newJsonWriter(java.io.Writer)' is inaccessible to class 'retrofit2.converter.gson.GsonRequestBodyConverter'

改装1对GSON 2.3.1有严格的依赖性，相关方法已在GSON 2.4中公开。我已经设置了Gradle依赖项，以便GSON依赖项解析为v2.7（我发布本文时的最新版本）：

build.gradle

compile('com.squareup.retrofit:retrofit:1.9.0') {
    exclude module: 'gson'
}
compile 'com.jakewharton.retrofit:retrofit1-okhttp3-client:1.1.0'

compile "com.squareup.retrofit2:retrofit:2.3.0"
compile "com.squareup.retrofit2:converter-gson:2.3.0"
compile "com.squareup.retrofit2:adapter-rxjava:2.3.0"
compile 'com.google.code.gson:gson:2.7'

运行

/gradlew:app:dependencies

表示正在解决GSON 2.7，但运行时行为可疑

---

更新：我发现第三方硬件SDK在其AAR中捆绑了GSON 2.3.1。但是我不知道如何删除它。

我最近在

改型1.9的同时实施了
改型2.9.0
，因为版本2处理会话的能力要好得多，而且我的一个API调用由于缺少处理响应cookie（会话）而失败

我也有同样的问题，此时将整个项目迁移到改造2是不可行的。不过，我可以确认它正在工作

我将向您展示如何实现1.9和2.9.0的片段。有关完整类的链接，请参见底部

对于这两种情况：
创建一个类，从中可以访问改装对象并从以下位置调用接口：

public class ApiManager {

private static final String TAG = "API MANAGER";

private static final String API_URL = BuildConfig.API_URL;

private static Gson gson = new GsonBuilder()
    .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
    .setLenient()
    .create();

// The rest of the class to follow

然后具体到1.9：

private static RequestInterceptor requestInterceptor = new RequestInterceptor() {
    @Override
    public void intercept(RequestInterceptor.RequestFacade request) {
        SessionManager sessionManager = new SessionManager(ContextHandler.getContext());
        HashMap session = sessionManager.getUserDetails();
        Object session_id = session.get("session_id");
        Object token = session.get("token");

        if (session_id != null && token != null) {
            request.addHeader("Cookie", "session_id=" + session_id + ";");
            request.addHeader("Cookie", "token=" + token + ";");
            Log.i("INTERCEPT", "Sent Cookies");
        }
        request.addHeader("Accept", "application/json");
    }
};

public static OkHttpClient getClient() {

    // init okhttp 3 logger
    HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
    logging.setLevel(HttpLoggingInterceptor.Level.BODY);

    JavaNetCookieJar jncj = new JavaNetCookieJar(CookieHandler.getDefault());


    OkHttpClient client = new OkHttpClient();

    client.newBuilder()
            .addInterceptor(new AddCookiesInterceptor(ContextHandler.getContext()))
            .addInterceptor(new ReceivedCookiesInterceptor(ContextHandler.getContext()))
            .addNetworkInterceptor(logging)
            .cookieJar(jncj)
            .connectTimeout(10, TimeUnit.SECONDS)
            .writeTimeout(10, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.MINUTES);

    return client;
}

private static final RestAdapter REST_ADAPTER = new RestAdapter.Builder()
    .setEndpoint(API_URL) // On device
    .setRequestInterceptor(requestInterceptor)
    .setClient(new Ok3Client(getClient()))
    .setConverter(new GsonConverter(gson))
    .setLogLevel(RestAdapter.LogLevel.FULL) //log the request
    .build();


public interface AuthenticationInterface {
    @Headers("Content-type: application/json")
    @POST("/auth/getsession")
    void Authenticate(@Body Authentication Auth, Callback<SessionStore> response);

    @Headers("Content-type: application/json")
    @GET("/auth/logout")
    void logout(Callback<String> response);

    @Headers("Content-type: application/json")
    @GET("/auth/logout")
    String logout();
}


// Bind REST_ADAPTER to Interface
public static final AuthenticationInterface AUTHENTICATION_INTERFACE = REST_ADAPTER.create(AuthenticationInterface.class);
// Use this when you want to run the request.
public static AuthenticationInterface getAuthenticationService(){ return AUTHENTICATION_INTERFACE;  }

private static RequestInterceptor RequestInterceptor=new RequestInterceptor（）{
@凌驾
公共无效拦截（RequestInterceptor.RequestFacade请求）{
SessionManager SessionManager=newsessionmanager（ContextHandler.getContext（））；
HashMap session=sessionManager.getUserDetails（）；
Object session_id=session.get（“session_id”）；
对象令牌=session.get（“令牌”）；
if（session_id！=null&&token！=null）{
addHeader（“Cookie”，“session_id=“+session_id+”；”）；
addHeader（“Cookie”，“token=“+token+”；”）；
Log.i（“拦截”、“发送Cookies”）；
}
addHeader（“接受”、“应用程序/json”）；
}
};
公共静态OkHttpClient getClient（）{
//init-okhttp3记录器
HttpLoggingInterceptor logging=新的HttpLoggingInterceptor（）；
logging.setLevel（HttpLoggingInterceptor.Level.BODY）；
JavaNetCookieJar jncj=新的JavaNetCookieJar（CookieHandler.getDefault（））；
OkHttpClient=新的OkHttpClient（）；
client.newBuilder（）
.addInterceptor（新的AddCookiesInterceptor（ContextHandler.getContext（）））
.addInterceptor（新的ReceivedCookiesInterceptor（ContextHandler.getContext（）））
.addNetworkInterceptor（日志记录）
.cookieJar（jncj）
.connectTimeout（10，时间单位为秒）
.writeTimeout（10，时间单位。秒）
.readTimeout（30，时间单位为分钟）；
返回客户；
}
私有静态最终RestAdapter REST_ADAPTER=new RestAdapter.Builder（）
.setEndpoint（API_URL）//在设备上
.setRequestInterceptor（requestInterceptor）
.setClient（新的Ok3Client（getClient（）））
.setConverter（新GsonConverter（gson））
.setLogLevel（RestAdapter.LogLevel.FULL）//记录请求
.build（）；
公共接口认证接口{
@标题（“内容类型：application/json”）
@POST（“/auth/getsession”）
void Authenticate（@Body Authentication Auth，回调响应）；
@标题（“内容类型：application/json”）
@获取（“/auth/logout”）
无效注销（回调响应）；
@标题（“内容类型：application/json”）
@获取（“/auth/logout”）
字符串注销（）；
}
//将REST_适配器绑定到接口
public static final AuthenticationInterface AUTHENTICATION\u INTERFACE=REST\u ADAPTER.create（AuthenticationInterface.class）；
//当您想要运行请求时，请使用此选项。
公共静态身份验证接口getAuthenticationService（）{return AUTHENTICATION_INTERFACE；}

因此，您可以按如下方式使用上述内容：

ApiManager.getAuthenticationService().Authenticate(auth, new Callback<SessionStore>() {

    @Override
    public void success(SessionStore sessionStore, Response response) {
        // Do somthing

    }

    @Override
    public void failure(RetrofitError error) {
        // Handle Error
    }
});

Call<Reports> reportsCall = ApiManager.getJasperReportsService().GetAgentReportView(agentsID, reportTypeID);
reportsCall.enqueue(new retrofit2.Callback<Reports>() {
    @Override
    public void onResponse(Call<Reports> call, retrofit2.Response<Reports> response) {
        if(response.isSuccessful()) {
            report = response.body();

        } else {
            int statusCode = response.code();

            // handle request errors yourself
            ResponseBody errorBody = response.errorBody();
        }

    }

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

    }
});

apimager.getAuthenticationService（）.Authenticate（auth，new Callback（））{
@凌驾
public void成功（SessionStore SessionStore，Response-Response）{
//干坏事
}
@凌驾
公共无效失败（错误）{
//处理错误
}
});

对于2.9.0：

public static OkHttpClient getHeader() {
    HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
    interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
    OkHttpClient okClient = new OkHttpClient.Builder()
            .addInterceptor(interceptor)
            .addInterceptor(new AddCookiesInterceptor(ContextHandler.getContext())) 
            .addInterceptor(new ReceivedCookiesInterceptor(ContextHandler.getContext())) 
            .cookieJar(cookieJar)
            .connectTimeout(10, TimeUnit.SECONDS)
            .writeTimeout(10, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.MINUTES)
            .addNetworkInterceptor(
                    new Interceptor() {
                        @Override
                        public Response intercept(Interceptor.Chain chain) throws IOException {
                            Request request = null;
                                Log.d("--Authorization-- ", "authorizationValue");

                            Request original = chain.request();
                            // Request customization: add request headers
                            Request.Builder requestBuilder = original.newBuilder();


                            SessionManager sessionManager = new SessionManager(ContextHandler.getContext());

                            HashMap session = sessionManager.getUserDetails();
                            Object session_id = session.get("session_id");
                            Object token = session.get("token");

                            if (session_id != null && token != null) {
                                requestBuilder.addHeader("Cookie", "session_id=" + session_id + ";");
                                requestBuilder.addHeader("Cookie", "token=" + token + ";");
                                Log.i("INTERCEPT", "Sent Cookies");
                            }
                            requestBuilder.addHeader("Accept", "application/json");

                                request = requestBuilder.build();

                            return chain.proceed(request);
                        }
                    })
            .build();
    return okClient;

}

private static final Retrofit REST_ADAPTER2 = new Retrofit.Builder()
    .baseUrl(API_URL) // On device
    .client(getHeader())
    .addConverterFactory(GsonConverterFactory.create(gson))
    .build();

public interface JasperReportsInterface {

    /**
     *
     * @param agent_id
     * @param report_id
     */
    @retrofit2.http.Headers("Content-type: application/json")
    @retrofit2.http.GET("/agents/{agent_id}/reports/{report_id}/")
    Call<Reports> GetAgentReportView(@retrofit2.http.Path("agent_id") String agent_id, @retrofit2.http.Path("report_id") String report_id);

    /**
     *
     * @param agent_id
     * @param report_id
     */
    @retrofit2.http.Headers("Content-type: application/json")
    @retrofit2.http.GET("/agents/{agent_id}/reports/{report_id}/jobs")
    Call<Jobs> PollAgentReportData(@retrofit2.http.Path("agent_id") String agent_id, @retrofit2.http.Path("report_id") String report_id);

    /**
     *
     * @param agent_id
     * @param report_id
     * @param jsonBody
     */
    @retrofit2.http.Headers("Content-type: application/json")
    @retrofit2.http.POST("/agents/{agent_id}/reports/{report_id}/jobs")
    Call<String> PostAgentReportData(@retrofit2.http.Path("agent_id") String agent_id, @retrofit2.http.Path("report_id") String report_id, @retrofit2.http.Body JsonObject jsonBody);

    /**
     *
     * @param agent_id
     * @param report_id
     * @param jsonBody
     */
    @retrofit2.http.Headers("Content-type: application/json")
    @retrofit2.http.POST("/agents/{agent_id}/reports/{report_id}/jobs")
    Call<String> DownloadAgentReportData(@retrofit2.http.Path("agent_id") String agent_id, @retrofit2.http.Path("report_id") String report_id, @retrofit2.http.Body JsonObject jsonBody);




}
// Bind REST_ADAPTER2 to Interface
public static final JasperReportsInterface JASPER_REPORTS_INTERFACE = REST_ADAPTER2.create(JasperReportsInterface.class);
// Use this when you want to run the request.
public static JasperReportsInterface getJasperReportsService(){  return JASPER_REPORTS_INTERFACE;  }

publicstaticokhttpclient getHeader（）{
HttpLoggingInterceptor拦截器=新的HttpLoggingInterceptor（）；
拦截器.setLevel（HttpLoggingInterceptor.Level.BODY）；
OkHttpClient okClient=新建OkHttpClient.Builder（）
.addInterceptor（拦截器）
.addInterceptor（新的AddCookiesInterceptor（ContextHandler.getContext（）））
.addInterceptor（新的ReceivedCookiesInterceptor（ContextHandler.getContext（）））
.cookieJar（cookieJar）
.connectTimeout（10，时间单位为秒）
.writeTimeout（10，时间单位。秒）
.readTimeout（30，时间单位为分钟）
.addNetworkInterceptor(
新拦截器（）{
@凌驾
公共响应拦截（Interceptor.Chain）引发IOException{
请求=null；
Log.d（“--Authorization--”和“authorizationValue”）；
Request original=chain.Request（）；
//请求自定义：添加请求头
Request.Builder requestBuilder=original.newBuilder（）；
SessionManager SessionManager=新SessionM