使用
//retrofit 的json解析器
compile 'com.squareup.retrofit2:converter-gson:2.3.0'
//Gson解析的依赖
compile 'com.google.code.gson:gson:2.8.1'
public interface KingApi {
//保存地址
@FormUrlEncoded
@POST("addresssave")
// Call<MineBean> uploadData(@Field("userid") int header, @Body MineBean bean);
Call<MineBean> uploadData(@Header("userid") int userid , @Field("addressArea") String addressArea,
@Field("addressDetail") String addressDetail,
@Field("city") String city,
@Field("isDefault") int isDefault,
@Field("name") String name,
@Field("phoneNumber") String phoneNumber,
@Field("province") String province,
@Field("zipCode") String zipCode);
// Call<MineBean> getData(@Body MineBean bean);
// Call<Integer> getData(@Header("userid"));
//模拟登陆使用
@FormUrlEncoded
@POST("login")
Call<ZJWLoginBean> zjwLogin(@Field("username") String username, @Field("password") String password);
//获取地址列表
// @FormUrlEncoded
@GET("addresslist")
Call<AddressDetailListBean> addressList(@Header("userid") int userid);
}
public class JDMallRetrofit {
private static JDMallRetrofit sJDMallRetrofit;
private final KingApi mKingApi;
private final Gson gson = new GsonBuilder()
.setLenient()
.create();
private JDMallRetrofit() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(Constant.HOST)
.addConverterFactory(GsonConverterFactory.create(gson))
.build();
mKingApi = retrofit.create(KingApi.class);
}
public static JDMallRetrofit getInstance() {
if (sJDMallRetrofit == null) {
synchronized (JDMallRetrofit.class) {
if (sJDMallRetrofit == null) {
sJDMallRetrofit = new JDMallRetrofit();
}
}
}
return sJDMallRetrofit;
}
public KingApi getKingApi() {
return mKingApi;
}
}
public class Constants {
public static final String HOST = "https://www.hzjr.com/Mobile/";
}
返回的bean对象格式不对会造成请求错误
Call<AddressDelete> call = JMRetrofit.getInstance().getKingApi().addressDeleteData(Integer.valueOf(mUserid), bean.getId());
call.enqueue(new Callback<AddressDelete>() {
@Override
public void onResponse(Call<AddressDelete> call, Response<AddressDelete> response) {
}
@Override
public void onFailure(Call<AddressDelete> call, Throwable throwable) {
}
});
Cookie获取
此方法会失效，不推荐使用
retrofit回调中获得的就是cookie，要去除分号后面的无用数据，看后台接受什么
Headers headers = response.headers();
String cookie = headers.get("Set-Cookie");
SaveCookiesInterceptor（正确获取方式）
public class SaveCookiesInterceptor implements Interceptor {
private Context mContext;
public SaveCookiesInterceptor(Context context) {
mContext = context;
}
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
Response originalResponse = chain.proceed(request);
String cookie = originalResponse.header(Constance.COOKIE);
if (!originalResponse.headers(Constance.COOKIE).isEmpty()) {
// HashSet<String> cookies = new HashSet<>();
// List<String> headers = originalResponse.headers("Set-Cookie");
//
// for (String header : originalResponse.headers("Set-Cookie")) {
// cookies.add(header);
// }
SPUtils.putString(mContext, Constance.COOKIE, cookie);
// Preferences.getDefaultPreferences().edit()
// .putStringSet(Preferences.PREF_COOKIES, cookies)
// .apply();
}
return originalResponse;
}
}
然后在retrofit的单例中添加
测试发现okHttpClient 同时添加saveCookie和addCookie的拦截器是不奏效的，所以这里不用addCookie
private HzjrRetrofit() {
LoadDataUtil.setCookieListener(new LoadDataUtil.CookieListener() {
@Override
public void cookieChange() {
cookie=preferencesUtil.getString(Constants.mContext,SharedPreferencesUtil.SET_COOKIE,"");
}
});
SaveCookiesInterceptor.setCookieListener(new SaveCookiesInterceptor.CookieListener() {
@Override
public void cookieChange() {
cookie=preferencesUtil.getString(Constants.mContext,SharedPreferencesUtil.SET_COOKIE,"");
}
});
CookieJarImpl cookieJar = new CookieJarImpl(new PersistentCookieStore(Constants.mContext));
OkHttpClient okHttpClient = new OkHttpClient.Builder()
// .addInterceptor(new SaveCookiesInterceptor(Constants.mContext))
.addInterceptor(new AddCookiesInterceptor(SharedPreferencesUtil.getInstance().getString(Constants.mContext,
SharedPreferencesUtil.SET_COOKIE,"")))
.cookieJar(cookieJar)
//其他配置
.build();
/*OkHttpClient client = new OkHttpClient.Builder().build();
client.interceptors().add(new SaveCookiesInterceptor(Constants.mContext));（最优方案）
client.interceptors().add(new AddCookiesInterceptor(SharedPreferencesUtil.getInstance().getString(Constants.mContext,"COOKIE","")));*/
Retrofit retrofit = new Retrofit.Builder()
// .client(okHttpClient)
.client(genericClient())
// .client(client)
.baseUrl(Constants.HOST)
.addConverterFactory(GsonConverterFactory.create(gson))
.build();
mHzjrApi = retrofit.create(HzjrApi.class);
}
public static OkHttpClient genericClient() {
LogUtil.showLog("www=genericClient","i am here");
OkHttpClient httpClient = new OkHttpClient.Builder()
.addInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request()
.newBuilder()
// .addHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
.addHeader("Content-Type", "application/json; charset=UTF-8")
注释下行 否则请求网络返回数据乱码
.addHeader("Accept-Encoding", "gzip, deflate")
.addHeader("Connection", "keep-alive")
.addHeader("Accept", "*/*")
.addHeader("Cookie", cookie)
.build();
return chain.proceed(request);
}
})
.build();
return httpClient;
}
AddCookiesInterceptor
public class AddCookiesInterceptor implements Interceptor {
private String mCookie;
public AddCookiesInterceptor(String cookie) {
mCookie = cookie;
}
@Override
public Response intercept(Chain chain) throws IOException {
//Request.Builder builder = chain.request().newBuilder();
// HashSet<String> preferences = (HashSet) Preferences.getDefaultPreferences().getStringSet(Preferences.PREF_COOKIES, new HashSet<>());
// for (String cookie : preferences) {
// builder.addHeader("Cookie", cookie);
// Log.v("OkHttp", "Adding Header: " + cookie); // This is done so I know which headers are being added; this interceptor is used after the normal logging of OkHttp
// }
Request request = chain.request();
Response originalResponse = chain.proceed(request);
CacheControl.Builder builder = new CacheControl.Builder().maxAge(10, TimeUnit.MINUTES);
return originalResponse.newBuilder()
.header("Cache-Control", builder.build().toString())
.addHeader("cookie", mCookie)
.build();
}
}
retrofit 2.2.0 上传头像
@Multipart
@POST("Member/cropImg")//上传图片
Call<PublicBean> uploadImg(@Part("token") RequestBody token,
@Part("timestamp") RequestBody timestamp,
@Part MultipartBody.Part file);
final File file = new File(Environment.getExternalStorageDirectory(),IMAGE_FILE_NAME);
RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file);
MultipartBody.Part body =
MultipartBody.Part.createFormData("avatarImg", file.getName(), requestBody);
RequestBody token =
RequestBody.create(
MediaType.parse("multipart/form-data"), timestampAndToken.get(1));
RequestBody time =
RequestBody.create(
MediaType.parse("multipart/form-data"), timestampAndToken.get(0));
Call<PublicBean> uploadImg = HzjrRetrofit.getInstance().getHzjrApi().uploadImg(token, time, body);
请求复用
首先要明确一点：每个Call实例可以且只能执行一次请求，不能使用相同的对象再次执行execute()或enqueue()。
但是，很多时候我们都需要再次执行请求，例如初次请求超时失败，这时候就要刷新再次请求。如果我们需要再次执行请求，可以使用call.clone()方法来创建call的一个副本，这个副本与call包含相同的配置，我们可以使用这个副本来再次执行相同的请求。代码示例如下：
WeiboService weiboService = ServiceGenerator.createService(WeiboService.class);
Call<Timeline> call = weiboService.timelineForPublic(COUNT_PER_REQ, page);
call.enqueue(callback);
Call<Timeline> newCall = call.clone();
newCall.enqueue(callback)；
取消请求
很多时候，当用户离开了当前页面，该页面中尚未完成的请求就没有必要了，这时候我们就需要取消请求了。在Retrofit中实现非常简单，使用call.cancel()来取消请求。
取消很简单，但是我们也应该处理取消之后的后续操作。当一个请求取消时，回调方法onFailure()会执行，而onFailure()方法在没有网络或网络错误的时候也会执行。这两种情况下我们的处理是不一样的，如果没有网络，我们会告诉用户连接网络，而取消请求则有可能只取消进度条。因此，需要对这两种情况进行区分，代码如下：
@Override
public void onFailure(Call<Timeline> call, Throwable t) {
if (call.isCanceled()) {
DebugLog.i(TAG, "request is canceled");
} else {
DebugLog.i(TAG, "error:" + t.getMessage());
}
}
通过call.isCanceled()方法来判断是否请求取消，从而对不同的情况分别处理。
跳过CA认证
在使用 Retrofit 进行 HTTPS 请求时，如果你需要绕过 CA 认证（例如在开发或测试环境中），可以通过自定义 OkHttpClient 来实现。Retrofit 本身并不直接处理 SSL 配置，但它允许你通过 OkHttpClient 来配置网络请求的 SSL 设置。
注意事项
- 安全性风险：绕过 SSL 证书验证会极大地降低应用程序的安全性，使应用容易受到中间人攻击（MITM）。因此，绝对不建议在生产环境中使用这些方法。
- 仅限于开发和测试环境：这些方法适用于开发和测试阶段，确保你在生产环境中始终启用 SSL 证书验证。
实现步骤
-
创建信任所有证书的 TrustManager 和 HostnameVerifier：
- 我们将创建一个信任所有证书的 X509TrustManager 和一个允许所有主机名的 HostnameVerifier。
-
配置 OkHttpClient：
- 使用 OkHttpClient.Builder 来配置 OkHttpClient，禁用 SSL 证书验证。
-
将 OkHttpClient 应用于 Retrofit：
- 将配置好的 OkHttpClient 传递给 Retrofit 的 build() 方法。
完整代码示例
import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
import javax.net.ssl.*;
import java.io.IOException;
import java.security.cert.X509Certificate;
public class RetrofitClient {
private static Retrofit retrofit = null;
// 创建一个信任所有证书的 OkHttpClient 实例
private static OkHttpClient createUnsafeOkHttpClient() {
try {
// 创建一个信任所有证书的 TrustManager
final TrustManager[] trustAllCerts = new TrustManager[]{
new X509TrustManager() {
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType) {
// 不做任何检查
}
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) {
// 不做任何检查
}
@Override
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
}
};
// 安装信任所有证书的 SSLContext
final SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
// 创建一个允许所有主机名的 HostnameVerifier
final HostnameVerifier allHostsValid = (hostname, session) -> true;
// 创建 OkHttpClient 并禁用 SSL 验证
OkHttpClient.Builder builder = new OkHttpClient.Builder()
.sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustAllCerts[0])
.hostnameVerifier(allHostsValid);
// 添加日志拦截器（可选）
HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(HttpLoggingInterceptor.Level.BODY);
builder.addInterceptor(logging);
return builder.build();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// 创建 Retrofit 实例
public static Retrofit getRetrofitInstance(String baseUrl) {
if (retrofit == null) {
retrofit = new Retrofit.Builder()
.baseUrl(baseUrl)
.client(createUnsafeOkHttpClient())
.addConverterFactory(GsonConverterFactory.create())
.build();
}
return retrofit;
}
}
代码解释
-
createUnsafeOkHttpClient()方法：-
TrustManager：我们创建了一个自定义的X509TrustManager，它不会对客户端或服务器的证书进行任何验证。 -
SSLContext：我们使用SSLContext来安装这个信任所有证书的TrustManager。 -
HostnameVerifier：我们创建了一个HostnameVerifier，它总是返回 true，这意味着它不会验证服务器的主机名是否匹配证书中的主机名。 -
OkHttpClient.Builder：我们使用OkHttpClient.Builder来配置OkHttpClient，并禁用 SSL 验证。此外，我们还可以添加日志拦截器来调试 HTTP 请求和响应。
-
-
getRetrofitInstance()方法：- 我们使用
Retrofit.Builder来创建Retrofit实例，并将配置好的OkHttpClient传递给它。 -
baseUrl是你的 API 基础 URL，例如"https://your-api-url.com/"。 -
GsonConverterFactory用于将 JSON 数据自动转换为 Java 对象。
- 我们使用
使用示例
假设你有一个 API 接口类 ApiService，你可以这样使用 Retrofit：
public interface ApiService {
@GET("endpoint")
Call<YourResponseModel> getSomeData();
}
// 在 Activity 或其他地方使用
ApiService apiService = RetrofitClient.getRetrofitInstance("https://your-api-url.com/").create(ApiService.class);
Call<YourResponseModel> call = apiService.getSomeData();
call.enqueue(new Callback<YourResponseModel>() {
@Override
public void onResponse(Call<YourResponseModel> call, Response<YourResponseModel> response) {
if (response.isSuccessful()) {
YourResponseModel data = response.body();
// 处理成功响应
} else {
// 处理错误响应
}
}
@Override
public void onFailure(Call<YourResponseModel> call, Throwable t) {
// 处理网络请求失败
}
});
注意事项
Android 7.0+ 的限制：从 Android 7.0（API 级别 24）开始，Google 引入了更严格的网络安全配置（Network Security Configuration），默认情况下会强制启用 TLS/SSL 验证。为了绕过这些限制，你需要在 res/xml/network_security_config.xml 文件中配置自定义的网络安全策略。
<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
<domain-config cleartextTrafficPermitted="true">
<domain includeSubdomains="true">your-domain.com</domain>
</domain-config>
</network-security-config>
然后在 AndroidManifest.xml 中引用该配置：
<application
...
android:networkSecurityConfig="@xml/network_security_config">
</application>
更好的替代方案：如果你需要与自签名证书的服务器通信，建议使用更安全的替代方案，例如：
- 将自签名证书添加到应用的信任库。
- 使用 Pinning（证书固定）。
- 使用合法的 CA 签发的证书。
