搞定Android网络开发：协议、库、异步、安全、实战，5大维度解决你的所有困惑（上）

请求方法：如GET（获取资源）、POST（提交数据）、PUT（更新资源）、DELETE（删除资源）等。URL：请求的资源路径（如/api/user）。协议版本：如HTTP/1.1、HTTP/2.0。  

Host：目标服务器域名（如api.example.com）。  User-Agent：客户端标识（如Android应用的包名）。Content-Type：请求体的数据格式（如application/json、application/x-www-form-urlencoded）。  Authorization：身份验证信息（如Token）。 Connection：是否保持连接（如keep-alive）。  

JSON格式：{"name":"张三","age":20}。  表单格式：name=张三&age=20。二进制数据（如文件上传）。  

Content-Type：响应体的数据格式（如application/json、image/jpeg）。Content-Length：响应体的长度（字节数）。Cache-Control：缓存策略（如max-age=3600表示缓存1小时）。Set-Cookie：服务器向客户端设置Cookie。Server：服务器标识（如nginx）。  

  <application        ...        android:usesCleartextTraffic="true">    </application>  

     <?xml version="1.0" encoding="utf-8"?>       <network-security-config>           <domain-config cleartextTrafficPermitted="true">               <!-- 允许HTTP的域名（支持通配符，如*.example.com） -->               <domain includeSubdomains="true">test.example.com</domain>           </domain-config>       </network-security-config>  

     <application           ...           android:networkSecurityConfig="@xml/network_security_config">       </application>  

// 1. 定义请求URL（需在子线程中执行）  new Thread(() -> {      HttpURLConnection connection = null;      BufferedReader reader = null;      try {          // 创建URL对象          URL url = new URL("https://api.example.com/user?userId=123");          // 打开连接（默认是GET请求）          connection = (HttpURLConnection) url.openConnection();          // 2. 配置连接参数          connection.setRequestMethod("GET"); // 明确指定GET方法（默认就是GET，可省略）          connection.setConnectTimeout(5000); // 连接超时（5秒）          connection.setReadTimeout(5000);    // 读取超时（5秒）          connection.setDoInput(true);        // 允许读取响应（默认true，可省略）          // GET请求无需设置doOutput（默认false，POST才需要设为true）      } catch (Exception e) {          e.printStackTrace();      }  }).start();  

try {      // ... 延续上面的代码      // 3. 获取响应码（200表示成功）      int responseCode = connection.getResponseCode();      if (responseCode == HttpURLConnection.HTTP_OK) {          // 4. 读取响应体（通过输入流）          InputStream inputStream = connection.getInputStream();          reader = new BufferedReader(new InputStreamReader(inputStream));          StringBuilder response = new StringBuilder();          String line;          while ((line = reader.readLine()) != null) {              response.append(line);          }          // 响应数据：response.toString()          Log.d("GET_RESPONSE", "结果：" + response.toString());      } else {          Log.e("GET_ERROR", "请求失败，响应码：" + responseCode);      }  } catch (Exception e) {      e.printStackTrace();  }  

finally {      // 5. 关闭资源      if (reader != null) {          try {              reader.close();          } catch (IOException e) {              e.printStackTrace();          }      }      if (connection != null) {          connection.disconnect(); // 关闭连接      }  }  

new Thread(() -> {      HttpURLConnection connection = null;      OutputStream outputStream = null;      try {          URL url = new URL("https://api.example.com/login");          connection = (HttpURLConnection) url.openConnection();          // 1. 配置POST请求          connection.setRequestMethod("POST");          connection.setConnectTimeout(5000);          connection.setReadTimeout(5000);          connection.setDoOutput(true); // 允许写入请求体（POST必须设置）          connection.setDoInput(true);          // 2. 设置请求头：表单数据格式          connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");          // 3. 构建表单数据（键值对）          String postData = "username=test&password=123456";          // 4. 写入请求体（通过输出流）          outputStream = connection.getOutputStream();          outputStream.write(postData.getBytes(StandardCharsets.UTF_8));          outputStream.flush(); // 刷新缓冲区          // 5. 读取响应（同GET步骤）          int responseCode = connection.getResponseCode();          if (responseCode == HttpURLConnection.HTTP_OK) {              // 处理响应...          }      } catch (Exception e) {          e.printStackTrace();      } finally {          // 关闭资源...      }  }).start();  

new Thread(() -> {      HttpURLConnection connection = null;      OutputStream outputStream = null;      try {          URL url = new URL("https://api.example.com/user");          connection = (HttpURLConnection) url.openConnection();          // 1. 配置POST请求（同表单）          connection.setRequestMethod("POST");          connection.setDoOutput(true);          // 2. 设置请求头：JSON格式          connection.setRequestProperty("Content-Type", "application/json; charset=UTF-8");          // 3. 构建JSON数据          String jsonData = "{\"name\":\"张三\",\"age\":20}";          // 4. 写入请求体          outputStream = connection.getOutputStream();          outputStream.write(jsonData.getBytes(StandardCharsets.UTF_8));          outputStream.flush();          // 5. 读取响应...      } catch (Exception e) {          e.printStackTrace();      } finally {          // 关闭资源...      }  }).start();  

// 定义AsyncTask：泛型参数分别为输入参数、进度、结果  class NetworkTask extends AsyncTask<String, Void, String> {      // 1. 后台执行（子线程）：发起网络请求      @Override      protected String doInBackground(String... urls) {          String url = urls[0];          HttpURLConnection connection = null;          BufferedReader reader = null;          try {              URL requestUrl = new URL(url);              connection = (HttpURLConnection) requestUrl.openConnection();              connection.setRequestMethod("GET");              connection.setConnectTimeout(5000);              if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {                  reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));                  StringBuilder response = new StringBuilder();                  String line;                  while ((line = reader.readLine()) != null) {                      response.append(line);                  }                  return response.toString(); // 返回结果给onPostExecute              }          } catch (Exception e) {              e.printStackTrace();              return "请求失败：" + e.getMessage();          } finally {              // 关闭资源...          }          return null;      }      // 2. 主线程回调：处理结果并更新UI      @Override      protected void onPostExecute(String result) {          super.onPostExecute(result);          // 更新UI（如TextView显示结果）          textView.setText(result);      }  }  // 启动任务（在主线程调用）  new NetworkTask().execute("https://api.example.com/data");  

public class MainActivity extends AppCompatActivity {      private TextView textView;      // 主线程的Handler（默认与主线程Looper绑定）      private Handler mainHandler = new Handler(Looper.getMainLooper()) {          @Override          public void handleMessage(@NonNull Message msg) {              super.handleMessage(msg);              // 3. 主线程处理消息：更新UI              if (msg.what == 1) { // 消息标识                  String result = (String) msg.obj; // 消息内容                  textView.setText(result);              }          }      };      @Override      protected void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.activity_main);          textView = findViewById(R.id.text_view);          // 启动网络请求线程          startNetworkRequest();      }  }  

private void startNetworkRequest() {      new Thread(() -> {          // 1. 子线程执行网络请求（使用HttpURLConnection）          String result = fetchDataFromNetwork("https://api.example.com/data");          // 2. 发送结果到主线程（通过Handler）          Message message = Message.obtain();          message.what = 1; // 消息标识（区分不同类型消息）          message.obj = result; // 携带数据（需序列化，如String、Parcelable等）          mainHandler.sendMessage(message); // 发送消息      }).start();  }  // 网络请求实现（同前文HttpURLConnection GET逻辑）  private String fetchDataFromNetwork(String url) {      // ... 省略HttpURLConnection请求代码 ...      return "请求结果";  }  

HttpURLConnection connection = (HttpURLConnection) url.openConnection();  connection.setConnectTimeout(5000); // 连接超时：5秒  connection.setReadTimeout(10000);   // 读取超时：10秒  

try {      // 执行网络请求...  } catch (SocketTimeoutException e) {      // 超时处理      Log.e("TIMEOUT", "网络超时：" + e.getMessage());      // 发送消息到主线程提示用户      mainHandler.sendMessage(Message.obtain(mainHandler, 2, "网络超时，请稍后重试"));  } catch (IOException e) {      // 其他网络错误（如无网络）      e.printStackTrace();  }  

dependencies {      // OkHttp核心库      implementation 'com.squareup.okhttp3:okhttp:4.12.0'      // 可选：日志拦截器（用于打印请求/响应日志）      implementation 'com.squareup.okhttp3:logging-interceptor:4.12.0'  }  

import okhttp3.OkHttpClient;  import java.util.concurrent.TimeUnit;  public class OkHttpManager {      // 单例实例      private static OkHttpClient sClient;      // 初始化OkHttpClient（配置超时、拦截器等）      public static OkHttpClient getInstance() {          if (sClient == null) {              synchronized (OkHttpManager.class) {                  if (sClient == null) {                      sClient = new OkHttpClient.Builder()                              .connectTimeout(10, TimeUnit.SECONDS) // 连接超时                              .readTimeout(10, TimeUnit.SECONDS)    // 读取超时                              .writeTimeout(10, TimeUnit.SECONDS)   // 写入超时                              // 可添加拦截器、缓存等配置                              .build();                  }              }          }          return sClient;      }  }  

// 子线程中执行  new Thread(() -> {      // 1. 获取OkHttpClient实例      OkHttpClient client = OkHttpManager.getInstance();      // 2. 构建GET请求（Request）      Request request = new Request.Builder()              .url("https://api.example.com/user?userId=123") // 请求URL              .get() // 默认为GET，可省略              .addHeader("Accept", "application/json") // 可选：添加请求头              .build();      // 3. 创建Call对象（请求任务）      Call call = client.newCall(request);      try {          // 4. 同步执行请求（阻塞当前线程）          Response response = call.execute();          // 5. 处理响应          if (response.isSuccessful()) { // 响应码200-299              String responseBody = response.body().string(); // 获取响应体（注意：string()只能调用一次）              Log.d("GET_SYNC", "成功：" + responseBody);          } else {              Log.e("GET_SYNC", "失败，响应码：" + response.code());          }      } catch (IOException e) {          e.printStackTrace(); // 处理异常（如网络错误、超时）      }  }).start();  

// 可在主线程调用（内部自动切换到子线程执行）  OkHttpClient client = OkHttpManager.getInstance();  Request request = new Request.Builder()          .url("https://api.example.com/user?userId=123")          .build();  Call call = client.newCall(request);  // 异步执行：回调在子线程中  call.enqueue(new Callback() {      @Override      public void onFailure(@NonNull Call call, @NonNull IOException e) {          // 请求失败（如网络错误、超时）          e.printStackTrace();      }      @Override      public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {          // 请求完成（无论成功与否）          if (response.isSuccessful()) {              String responseBody = response.body().string();              Log.d("GET_ASYNC", "成功：" + responseBody);              // 如需更新UI，需切换到主线程（如用Handler、runOnUiThread）              runOnUiThread(() -> textView.setText(responseBody));          } else {              Log.e("GET_ASYNC", "失败，响应码：" + response.code());          }      }  });  

  // 构建表单数据    FormBody formBody = new FormBody.Builder()            .add("username", "test")            .add("password", "123456")            .build();    // 构建POST请求    Request request = new Request.Builder()            .url("https://api.example.com/login")            .post(formBody)            .build();  

  // 构建文件请求体（上传图片）    RequestBody fileBody = RequestBody.create(            new File("/sdcard/avatar.jpg"),            MediaType.parse("image/jpeg")    );    // 构建混合请求体    MultipartBody multipartBody = new MultipartBody.Builder()            .setType(MultipartBody.FORM) // 必须指定类型为FORM            .addFormDataPart("username", "test") // 文本字段            .addFormDataPart("avatar", "avatar.jpg", fileBody) // 文件字段（name、文件名、文件体）            .build();    // 构建POST请求    Request request = new Request.Builder()            .url("https://api.example.com/upload")            .post(multipartBody)            .build();  

  // JSON数据    String json = "{\"name\":\"张三\",\"age\":20}";    // 创建JSON请求体（指定媒体类型为application/json）    RequestBody jsonBody = RequestBody.create(            json,            MediaType.parse("application/json; charset=utf-8")    );    // 构建POST请求    Request request = new Request.Builder()            .url("https://api.example.com/user")            .post(jsonBody)            .build();  

public class HeaderInterceptor implements Interceptor {      @Override      public Response intercept(Chain chain) throws IOException {          // 1. 获取原始请求          Request originalRequest = chain.request();          // 2. 构建新请求，添加统一头信息（如Token）          Request newRequest = originalRequest.newBuilder()                  .addHeader("Authorization", "Bearer " + getToken()) // 添加Token                  .addHeader("App-Version", "1.0.0") // 添加App版本                  .build();          // 3. 继续执行请求          return chain.proceed(newRequest);      }      // 获取本地Token（示例）      private String getToken() {          return "user_token_123456";      }  }  // 配置到OkHttpClient  OkHttpClient client = new OkHttpClient.Builder()          .addInterceptor(new HeaderInterceptor()) // 应用拦截器          .build();  

// 自定义日志拦截器（简化版）  public class LogInterceptor implements Interceptor {      @Override      public Response intercept(Chain chain) throws IOException {          // 打印请求信息          Request request = chain.request();          Log.d("OkHttp", "请求URL：" + request.url());          Log.d("OkHttp", "请求头：" + request.headers());          // 执行请求          long startTime = System.currentTimeMillis();          Response response = chain.proceed(request);          long endTime = System.currentTimeMillis();          // 打印响应信息          Log.d("OkHttp", "响应码：" + response.code());          Log.d("OkHttp", "耗时：" + (endTime - startTime) + "ms");          Log.d("OkHttp", "响应体：" + response.body().string()); // 注意：string()会消耗响应体，需复制后使用          return response;      }  }  // 配置（推荐用网络拦截器打印真实网络请求）  OkHttpClient client = new OkHttpClient.Builder()          .addNetworkInterceptor(new LogInterceptor()) // 网络拦截器          .build();  

public class CacheInterceptor implements Interceptor {      @Override      public Response intercept(Chain chain) throws IOException {          Request request = chain.request();          // 无网络时，强制使用缓存（仅适用于GET请求）          if (!isNetworkAvailable()) {              request = request.newBuilder()                      .cacheControl(CacheControl.FORCE_CACHE) // 强制使用缓存                      .build();          }          Response response = chain.proceed(request);          // 有网络时，设置缓存有效期（如60秒）          if (isNetworkAvailable()) {              response = response.newBuilder()                      .header("Cache-Control", "public, max-age=60") // 缓存60秒                      .removeHeader("Pragma") // 移除干扰缓存的头                      .build();          } else {              // 无网络时，延长缓存有效期（如1小时）              response = response.newBuilder()                      .header("Cache-Control", "public, only-if-cached, max-stale=3600")                      .removeHeader("Pragma")                      .build();          }          return response;      }      // 判断网络是否可用（需权限ACCESS_NETWORK_STATE）      private boolean isNetworkAvailable() {          // 实现略（通过ConnectivityManager判断）          return true;      }  }  // 配置缓存目录和拦截器  File cacheDir = new File(context.getCacheDir(), "okhttp_cache");  int cacheSize = 10 * 1024 * 1024; // 10MB  Cache cache = new Cache(cacheDir, cacheSize);  OkHttpClient client = new OkHttpClient.Builder()          .cache(cache)          .addInterceptor(new CacheInterceptor()) // 应用拦截器          .build();  

// 自定义连接池：最大空闲连接数10，存活时间10分钟  ConnectionPool connectionPool = new ConnectionPool(          10, // 最大空闲连接数          10, // 存活时间          TimeUnit.MINUTES // 时间单位  );  // 配置到OkHttpClient  OkHttpClient client = new OkHttpClient.Builder()          .connectionPool(connectionPool)          .build();  

// 创建信任所有证书的TrustManager  X509TrustManager trustAllCert = 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];      }  };  // 创建SSLSocketFactory  SSLContext sslContext = SSLContext.getInstance("TLS");  sslContext.init(null, new TrustManager[]{trustAllCert}, new SecureRandom());  SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();  // 配置OkHttpClient  OkHttpClient client = new OkHttpClient.Builder()          .sslSocketFactory(sslSocketFactory, trustAllCert)          .hostnameVerifier((hostname, session) -> true) // 跳过主机名验证          .build();  

// 加载证书  InputStream certInputStream = context.getResources().openRawResource(R.raw.server);  CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");  X509Certificate cert = (X509Certificate) certificateFactory.generateCertificate(certInputStream);  // 创建KeyStore并添加证书  KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());  keyStore.load(null);  keyStore.setCertificateEntry("server", cert);  // 创建TrustManagerFactory（仅信任KeyStore中的证书）  TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(          TrustManagerFactory.getDefaultAlgorithm());  trustManagerFactory.init(keyStore);  TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();  // 创建SSLSocketFactory  SSLContext sslContext = SSLContext.getInstance("TLS");  sslContext.init(null, trustManagers, new SecureRandom());  SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();  // 配置OkHttpClient  OkHttpClient client = new OkHttpClient.Builder()          .sslSocketFactory(sslSocketFactory, (X509TrustManager) trustManagers[0])          .build();  

OkHttpClient client = new OkHttpClient.Builder()          .certificatePinner(new CertificatePinner.Builder()                  // 指定主机名和允许的证书公钥哈希（SHA-256）                  .add("api.example.com",                          "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=") // 证书哈希1                  .add("api.example.com",                          "sha256/BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB=") // 证书哈希2（备用）                  .build())          .build();  

dependencies {      // Retrofit核心库（最新版本参考官网：https://square.github.io/retrofit/）      implementation 'com.squareup.retrofit2:retrofit:2.9.0'      // JSON序列化库（可选，根据需求选择，这里以Gson为例）      implementation 'com.squareup.retrofit2:converter-gson:2.9.0'      // OkHttp（Retrofit默认依赖，若需自定义配置可单独添加，版本需匹配）      implementation 'com.squareup.okhttp3:okhttp:4.12.0'  }  

OkHttpClient okHttpClient = new OkHttpClient.Builder()             .connectTimeout(10, TimeUnit.SECONDS) // 连接超时             .readTimeout(10, TimeUnit.SECONDS)    // 读取超时             .addInterceptor(new HeaderInterceptor()) // 自定义拦截器（如添加Token）             .build();

public class RetrofitManager {         private static Retrofit sRetrofit;         private static final String BASE_URL = "https://api.example.com/"; // 基础URL         public static Retrofit getInstance() {             if (sRetrofit == null) {                 synchronized (RetrofitManager.class) {                     if (sRetrofit == null) {                         sRetrofit = new Retrofit.Builder()                                 .baseUrl(BASE_URL) // 接口基础URL（必须以/结尾）                                 .client(okHttpClient) // 关联自定义的OkHttpClient                                 .addConverterFactory(GsonConverterFactory.create()) // 配置JSON解析器                                 .build();                     }                 }             }             return sRetrofit;         }         // 获取API接口实例         public static <T> T createService(Class<T> serviceClass) {             return getInstance().create(serviceClass);         }     }  

public class User {      private int userId;      private String name;      private int age;      //  getter/setter 省略  }  

import retrofit2.Call;  import retrofit2.http.GET;  import retrofit2.http.Path;  public interface UserService {      // GET请求：路径参数userId      @GET("user/{userId}")      Call<User> getUserById(@Path("userId") int userId);  }  

// 获取接口实例  UserService userService = RetrofitManager.createService(UserService.class);  // 发起异步请求  Call<User> call = userService.getUserById(123);  call.enqueue(new Callback<User>() {      @Override      public void onResponse(Call<User> call, Response<User> response) {          if (response.isSuccessful()) {              User user = response.body(); // 响应体（已被Gson解析为User对象）              // 更新UI...          } else {              // 处理HTTP错误（如404、500）          }      }      @Override      public void onFailure(Call<User> call, Throwable t) {          // 处理网络异常（如无网络、超时）          t.printStackTrace();      }  });  

import retrofit2.Call;  import retrofit2.http.Body;  import retrofit2.http.POST;  public interface UserService {      // POST请求：JSON请求体（User对象会被Gson转换为JSON）      @POST("user")      Call<User> addUser(@Body User user);  }  

// 构建请求体对象  User newUser = new User();  newUser.setName("张三");  newUser.setAge(20);  // 发起异步请求  UserService userService = RetrofitManager.createService(UserService.class);  Call<User> call = userService.addUser(newUser);  call.enqueue(new Callback<User>() {      @Override      public void onResponse(Call<User> call, Response<User> response) {          if (response.isSuccessful()) {              User addedUser = response.body(); // 服务器返回的新增用户信息          }      }      @Override      public void onFailure(Call<User> call, Throwable t) {          // 处理异常...      }  });  

implementation 'com.squareup.retrofit2:converter-gson:2.9.0'  

Retrofit retrofit = new Retrofit.Builder()         .baseUrl(BASE_URL)         .client(okHttpClient)         .addConverterFactory(GsonConverterFactory.create()) // 配置Gson         .build();  自定义Gson配置（如字段重命名、日期格式）：  Gson gson = new GsonBuilder()          .setDateFormat("yyyy-MM-dd HH:mm:ss") // 自定义日期格式          .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES) // 下划线命名（如user_name → userName）          .create();  Retrofit retrofit = new Retrofit.Builder()          .baseUrl(BASE_URL)          .addConverterFactory(GsonConverterFactory.create(gson)) // 使用自定义Gson          .build();  

implementation 'com.squareup.retrofit2:converter-moshi:2.9.0'  implementation 'com.squareup.moshi:moshi:1.15.0'

Moshi moshi = new Moshi.Builder().build();  Retrofit retrofit = new Retrofit.Builder()          .baseUrl(BASE_URL)          .addConverterFactory(MoshiConverterFactory.create(moshi))          .build();  

implementation 'com.squareup.retrofit2:converter-jackson:2.9.0'  implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2'  

ObjectMapper objectMapper = new ObjectMapper();  Retrofit retrofit = new Retrofit.Builder()          .baseUrl(BASE_URL)          .addConverterFactory(JacksonConverterFactory.create(objectMapper))          .build();  

// RxJava2核心库  implementation 'io.reactivex.rxjava2:rxjava:2.2.21'  // RxJava2 Android绑定（用于切换到主线程）  implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'  // Retrofit-RxJava2适配器  implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'  

Retrofit retrofit = new Retrofit.Builder()          .baseUrl(BASE_URL)          .client(okHttpClient)          .addConverterFactory(GsonConverterFactory.create())          .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 配置RxJava2适配器          .build();  

import io.reactivex.Observable;  import retrofit2.http.GET;  import retrofit2.http.Path;  public interface UserService {      @GET("user/{userId}")      Observable<User> getUserById(@Path("userId") int userId); // 返回Observable<User>  }  

UserService userService = RetrofitManager.createService(UserService.class);  userService.getUserById(123)          .subscribeOn(Schedulers.io()) // 网络请求在IO线程执行          .observeOn(AndroidSchedulers.mainThread()) // 结果回调在主线程          .subscribe(                  user -> { /* 成功：处理User对象，更新UI */ },                  throwable -> { /* 失败：处理异常 */ }          ); 

implementation 'com.squareup.retrofit2:retrofit:2.9.0'  implementation 'com.squareup.retrofit2:converter-gson:2.9.0'  

val retrofit = Retrofit.Builder()      .baseUrl("https://api.example.com/")      .client(okHttpClient)      .addConverterFactory(GsonConverterFactory.create())      .build()  

interface UserService {      // GET请求：suspend函数，返回User      @GET("user/{userId}")      suspend fun getUserById(@Path("userId") userId: Int): User      // POST请求：suspend函数，返回AddUserResponse      @POST("user")      suspend fun addUser(@Body user: User): AddUserResponse  }  

// 在ViewModel中使用viewModelScope（需添加Jetpack ViewModel依赖）  class UserViewModel : ViewModel() {      private val userService = RetrofitManager.createService(UserService::class.java)      fun fetchUser(userId: Int) {          viewModelScope.launch { // 协程作用域，自动在子线程执行              try {                  // 调用suspend函数（挂起，不阻塞主线程）                  val user = userService.getUserById(userId)                  // 成功：更新UI（viewModelScope.launch默认在主线程回调）                  _userLiveData.value = user              } catch (e: Exception) {                  // 失败：处理异常（如网络错误、解析错误）                  _errorLiveData.value = e.message              }          }      }  }  

  viewModelScope.launch {        // 并行请求        val userDeferred = async { userService.getUserById(123) }        val userListDeferred = async { userService.getUserList(1, 20) }        val user = userDeferred.await()        val userList = userListDeferred.await()        // 处理结果...    }  

OkHttpClient okHttpClient = new OkHttpClient.Builder()          // 全局超时时间          .connectTimeout(10, TimeUnit.SECONDS)          .readTimeout(10, TimeUnit.SECONDS)          .writeTimeout(10, TimeUnit.SECONDS)          // 全局拦截器（如添加Token、打印日志）          .addInterceptor(new HeaderInterceptor()) // 应用拦截器          .addNetworkInterceptor(new LogInterceptor()) // 网络拦截器          .build();  

Retrofit retrofit = new Retrofit.Builder()          .baseUrl(BASE_URL)          .client(okHttpClient) // 传入配置好的OkHttpClient          .addConverterFactory(GsonConverterFactory.create())          .build();  

userService.getUserById(123).enqueue(new Callback<User>() {      @Override      public void onResponse(Call<User> call, Response<User> response) {          if (response.isSuccessful()) {              // 成功：处理User对象              User user = response.body();          } else {              // 处理HTTP错误码              int errorCode = response.code();              String errorMsg = "";              try {                  // 解析错误响应体                  errorMsg = response.errorBody().string();              } catch (IOException e) {                  e.printStackTrace();              }              Log.e("ERROR", "HTTP错误：" + errorCode + "，信息：" + errorMsg);          }      }      @Override      public void onFailure(Call<User> call, Throwable t) {          // 处理网络异常或解析异常          if (t instanceof IOException) {              Log.e("ERROR", "网络异常：" + t.getMessage());          } else if (t instanceof JsonParseException) {              Log.e("ERROR", "解析异常：" + t.getMessage());          }      }  });  

viewModelScope.launch {      try {          val user = userService.getUserById(123)          // 成功：处理User对象      } catch (e: IOException) {          // 网络异常          Log.e("ERROR", "网络异常：" + e.message)      } catch (e: JsonParseException) {          // 解析异常          Log.e("ERROR", "解析异常：" + e.message)      } catch (e: HttpException) {          // HTTP错误（Retrofit将4xx/5xx包装为HttpException）          val errorCode = e.code()          val errorMsg = e.response()?.errorBody()?.string() ?: "未知错误"          Log.e("ERROR", "HTTP错误：$errorCode，信息：$errorMsg")      }  }  

{    "userId": 123,    "name": "张三",    "age": 20,    "address": {      "city": "北京",      "street": "朝阳路"    },    "tags": ["学生", "Android开发"]  }  

public class User {      private int userId;      private String name;      private int age;      private Address address;      private List<String> tags;      // getter/setter 省略      public static class Address {          private String city;          private String street;          // getter/setter 省略      }  }  // 解析方法  public User parseUser(String jsonStr) {      User user = new User();      try {          // 1. 解析外层JSONObject          JSONObject rootObj = new JSONObject(jsonStr);          // 2. 提取基本类型字段          user.setUserId(rootObj.getInt("userId"));          user.setName(rootObj.getString("name"));          user.setAge(rootObj.getInt("age"));          // 3. 解析嵌套的Address对象          JSONObject addressObj = rootObj.getJSONObject("address");          User.Address address = new User.Address();          address.setCity(addressObj.getString("city"));          address.setStreet(addressObj.getString("street"));          user.setAddress(address);          // 4. 解析tags数组          JSONArray tagsArray = rootObj.getJSONArray("tags");          List<String> tags = new ArrayList<>();          for (int i = 0; i < tagsArray.length(); i++) {              tags.add(tagsArray.getString(i));          }          user.setTags(tags);      } catch (JSONException e) {          e.printStackTrace(); // 处理解析异常（如字段缺失、类型不匹配）      }      return user;  }  

implementation 'com.google.code.gson:gson:2.10.1' // 最新版本参考官网  

data class User(        val userId: Int,        val name: String,        val age: Int,        val address: Address,        val tags: List<String>    )    data class Address(        val city: String,        val street: String    )  

// 1. 创建Gson实例（可全局单例）  Gson gson = new Gson();  // 2. 反序列化：JSON字符串 → User对象  String jsonStr = "{\"userId\":123,\"name\":\"张三\",\"age\":20,...}";  User user = gson.fromJson(jsonStr, User.class);  // 3. 反序列化泛型集合（如List<User>）  String userListJson = "[{\"userId\":123,...}, {\"userId\":456,...}]";  Type userListType = new TypeToken<List<User>>(){}.getType(); // 解决泛型擦除  List<User> userList = gson.fromJson(userListJson, userListType);  

// 1. 创建对象  User.Address address = new User.Address("北京", "朝阳路");  User user = new User(123, "张三", 20, address, Arrays.asList("学生", "Android开发"));  // 2. 序列化：User对象 → JSON字符串  Gson gson = new Gson();  String jsonStr = gson.toJson(user);  // 输出结果：{"userId":123,"name":"张三","age":20,"address":{"city":"北京","street":"朝阳路"},"tags":["学生","Android开发"]}  

public class User {      @SerializedName("user_id") // JSON键名为user_id，对象字段名为userId      private int userId;      private String name;      // 其他字段省略  }  // 序列化后：{"user_id":123,"name":"张三"...}  

@SerializedName(value = "user_id", alternate = {"uid", "userID"})  private int userId;  

public class User {      private int userId;      transient private String password; // 忽略password字段      // 其他字段省略  }  // 序列化后：{"userId":123,...}（无password字段）

public class User {      @Expose // 参与序列化      private int userId;      @Expose(serialize = false) // 仅反序列化，不序列化      private String name;      private String password; // 未标记，不参与序列化    }  // 创建Gson实例  Gson gson = new GsonBuilder()          .excludeFieldsWithoutExposeAnnotation()          .build();  

Gson gson = new GsonBuilder()         .excludeFieldsWithName("password") // 排除name为password的字段         .excludeFieldsWithModifiers(Modifier.TRANSIENT) // 排除transient字段        .build();  

Gson gson = new GsonBuilder()          .setDateFormat("yyyy-MM-dd HH:mm:ss") // 自定义日期格式          .build();  Date date = new Date();  String json = gson.toJson(date); // 输出："2024-05-20 14:30:00"

// 解析List<User>  Type userListType = new TypeToken<List<User>>(){}.getType();  List<User> userList = gson.fromJson(userListJson, userListType);  // 解析复杂泛型（如网络响应Result<User>）  public class Result<T> {     private int code;     private String msg;     private T data;     // getter/setter 省略  }  Type resultType = new TypeToken<Result<User>>(){}.getType();  Result<User> result = gson.fromJson(resultJson, resultType);  

// 自定义TypeAdapter：将JSON中的日期字符串（yyyy-MM-dd）转换为Date对象  public class CustomDateTypeAdapter extends TypeAdapter<Date> {        private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");        @Override        public void write(JsonWriter out, Date value) throws IOException {            // 序列化：Date → JSON字符串            if (value == null) {                out.nullValue();                return;            }            out.value(sdf.format(value));        }        @Override        public Date read(JsonReader in) throws IOException {            // 反序列化：JSON字符串 → Date            if (in.peek() == JsonToken.NULL) {                in.nextNull();                return null;            }            String dateStr = in.nextString();            try {                return sdf.parse(dateStr);            } catch (ParseException e) {                throw new IOException("日期格式错误");            }        }    }    // 注册TypeAdapter到Gson    Gson gson = new GsonBuilder()            .registerTypeAdapter(Date.class, new CustomDateTypeAdapter())            .build();    // 使用：JSON中的"2024-05-20"会被解析为Date对象    String json = "{\"createTime\":\"2024-05-20\"}";    User user = gson.fromJson(json, User.class);  

implementation 'com.squareup.moshi:moshi:1.15.1'  

implementation 'com.squareup.moshi:moshi:1.15.1'  implementation 'com.squareup.moshi:moshi-kotlin:1.15.1'  kapt 'com.squareup.moshi:moshi-kotlin-codegen:1.15.1' // 代码生成  

@JsonClass(generateAdapter = true) // 开启代码生成（Kotlin必需） data class User(      @Json(name = "user_id") // JSON键名为user_id，对象字段名为userId      val userId: Int,      val name: String,      val age: Int,      val address: Address,      val tags: List<String>  )  @JsonClass(generateAdapter = true)  data class Address(      val city: String,      val street: String  )  序列化与反序列化：// 1. 创建Moshi实例（Kotlin需传入KotlinJsonAdapterFactory）  val moshi = Moshi.Builder()      .add(KotlinJsonAdapterFactory()) // Kotlin项目必需      .build()  // 2. 获取JsonAdapter（数据模型与JSON的适配器）  val userAdapter = moshi.adapter(User::class.java)  // 3. 反序列化：JSON字符串 → User对象  val jsonStr = "{\"user_id\":123,\"name\":\"张三\",\"age\":20,...}"  val user = userAdapter.fromJson(jsonStr)  // 4. 序列化：User对象 → JSON字符串  val json = userAdapter.toJson(user)  // 5. 解析泛型集合（如List<User>）  val listAdapter = moshi.adapter<List<User>>(Types.newParameterizedType(List::class.java, User::class.java))  val userList = listAdapter.fromJson(userListJson)  

class LocalDateTimeAdapter : JsonAdapter<LocalDateTime>() {      private val formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME      override fun fromJson(reader: JsonReader): LocalDateTime? {          return reader.nextString()?.let { LocalDateTime.parse(it, formatter) }      }      override fun toJson(writer: JsonWriter, value: LocalDateTime?) {          if (value == null) {              writer.nullValue()              return          }          writer.value(formatter.format(value))      }  }  // 注册到Moshi  val moshi = Moshi.Builder()      .add(KotlinJsonAdapterFactory())      .add(LocalDateTimeAdapter()) // 注册自定义JsonAdapter      .build()  

// 1. 定义Retrofit接口（suspend函数）  interface UserService {      @GET("user/{userId}")      suspend fun getUserById(@Path("userId") userId: Int): User  }  // 2. 在ViewModel中使用viewModelScope发起请求  class UserViewModel : ViewModel() {      private val userService = RetrofitManager.createService(UserService::class.java)      // 用于向UI层发送数据（如LiveData/StateFlow）      private val _userLiveData = MutableLiveData<User>()      val userLiveData: LiveData<User> = _userLiveData      fun fetchUser(userId: Int) {          // 启动协程（自动在子线程执行）          viewModelScope.launch {              try {                  // 调用suspend函数（挂起，不阻塞主线程）                  val user = userService.getUserById(userId)                  // 发送结果到UI层（viewModelScope.launch默认在主线程回调）                  _userLiveData.postValue(user)              } catch (e: Exception) {                  // 3. 异常处理（网络错误、解析错误等）                  when (e) {                      is IOException -> _errorLiveData.postValue("网络异常")                      is JsonParseException -> _errorLiveData.postValue("数据解析错误")                      else -> _errorLiveData.postValue("请求失败")                  }              }          }      }  }  // 3. UI层（Activity/Fragment）观察数据  class UserActivity : AppCompatActivity() {      override fun onCreate(savedInstanceState: Bundle?) {          super.onCreate(savedInstanceState)          val viewModel = ViewModelProvider(this)[UserViewModel::class.java]          viewModel.userLiveData.observe(this) { user ->              // 更新UI              textView.text = user.name          }      }  }  

// 1. 定义Retrofit接口（返回Observable<UserResponse>）  public interface UserService {      @GET("user/{userId}")      Observable<UserResponse> getUserById(@Path("userId") int userId);  }  // 2. 使用map转换数据  UserService userService = RetrofitManager.createService(UserService.class);  userService.getUserById(123)          .map(userResponse -> {              // 转换：UserResponse → User（提取UI需要的字段）              return new User(                      userResponse.getUserId(),                      userResponse.getUserName(),                      userResponse.getUserAge()              );          })          .subscribeOn(Schedulers.io()) // 网络请求在IO线程          .observeOn(AndroidSchedulers.mainThread()) // 结果在主线程处理          .subscribe(                  user -> { /* 成功：更新UI */ },                  throwable -> { /* 失败：处理异常 */ }          );  

// 1. 定义Retrofit接口（用户、订单）  public interface UserService {      @GET("user/{userId}")      Observable<User> getUserById(@Path("userId") int userId);  }  public interface OrderService {      @GET("order")      Observable<List<Order>> getOrdersByUserId(@Query("userId") int userId);  }  // 2. 使用flatMap实现嵌套请求  UserService userService = RetrofitManager.createService(UserService.class);  OrderService orderService = RetrofitManager.createService(OrderService.class);  userService.getUserById(123)          .flatMap(user -> {              // 第一个请求成功后，发起第二个请求（根据用户ID获取订单）              return orderService.getOrdersByUserId(user.getUserId());          })          .subscribeOn(Schedulers.io())          .observeOn(AndroidSchedulers.mainThread())          .subscribe(                  orders -> { /* 成功：获取到用户的订单列表，更新UI */ },                  throwable -> { /* 失败：处理任一请求的异常 */ }          );

// 1. 定义Retrofit接口（返回Observable<User>）  public interface UserService {      @GET("user/{userId}")      Observable<User> getUserById(@Path("userId") int userId);  }  // 2. 线程切换示例  UserService userService = RetrofitManager.createService(UserService.class);  userService.getUserById(123)          // 1. 指定网络请求（订阅）的线程：IO子线程（只生效一次）          .subscribeOn(Schedulers.io())          // 2. 第一个observeOn：切换到计算线程处理数据（如解析、转换）          .observeOn(Schedulers.computation())          .map(user -> {              // 数据处理：在计算线程执行              user.setNickname("用户：" + user.getName());              return user;          })          // 3. 第二个observeOn：切换到主线程更新UI          .observeOn(AndroidSchedulers.mainThread())          // 4. 订阅：结果在主线程处理          .subscribe(                  user -> {                      // 更新UI（主线程安全）                      textView.setText(user.getNickname());                  },                  throwable -> {                      // 异常处理（主线程）                      Toast.makeText(context, "请求失败", Toast.LENGTH_SHORT).show();                  }          );  

// 1. ViewModel中封装网络请求和LiveData  class UserViewModel : ViewModel() {      private val userService = RetrofitManager.createService(UserService::class.java)      // 私有MutableLiveData（仅ViewModel内部修改）      private val _userLiveData = MutableLiveData<User>()      // 公开LiveData（UI层只读观察）      val userLiveData: LiveData<User> = _userLiveData      // 发起网络请求      fun fetchUser(userId: Int) {          viewModelScope.launch {              try {                  val user = userService.getUserById(userId)                  // 将结果存入LiveData（自动通知观察者）                  _userLiveData.postValue(user)              } catch (e: Exception) {                  // 处理异常（可通过另一个LiveData发送错误信息）              }          }      }  }  // 2. UI层（Activity）观察LiveData  class UserActivity : AppCompatActivity() {      override fun onCreate(savedInstanceState: Bundle?) {          super.onCreate(savedInstanceState)          val viewModel = ViewModelProvider(this)[UserViewModel::class.java]          // 观察LiveData（生命周期感知，页面销毁时自动取消观察）          viewModel.userLiveData.observe(this) { user ->              // 配置变更（如旋转）后，LiveData会重新发送最新数据，无需重复请求              textView.text = user.name          }          // 发起请求（仅在首次创建时调用，配置变更后不会重复调用）          if (savedInstanceState == null) {              viewModel.fetchUser(123)          }      }  }  

class UserViewModel : ViewModel() {      private var isLoading = false // 请求状态标记      fun fetchUser(userId: Int) {          if (isLoading) return // 若正在请求，直接返回          isLoading = true          viewModelScope.launch {              try {                  val user = userService.getUserById(userId)                  _userLiveData.postValue(user)              } catch (e: Exception) {                  // 处理异常              } finally {                  isLoading = false // 请求结束，重置状态              }          }      }  }  

class UserViewModel : ViewModel() {      // 存储用户ID的LiveData（参数变化触发新请求）      private val _userIdLiveData = MutableLiveData<Int>()      // 通过switchMap，userId变化时自动发起新请求      val userLiveData: LiveData<User> = Transformations.switchMap(_userIdLiveData) { userId ->          liveData(viewModelScope.coroutineContext) {              try {                  val user = userService.getUserById(userId)                  emit(user) // 发送结果              } catch (e: Exception) {                  // 处理异常              }          }      }      // 外部调用：更新用户ID，触发新请求      fun setUserId(userId: Int) {          _userIdLiveData.value = userId      }  }  

// 1. 数据模型（UI与ViewModel共享，无业务逻辑）  data class User(val userId: Int, val name: String, val age: Int)  // 2. 网络请求接口（Retrofit）  interface UserService {      @GET("user/{userId}")      suspend fun getUserById(@Path("userId") userId: Int): User  }  // 3. ViewModel（封装请求逻辑，持有数据）  class UserViewModel : ViewModel() {      private val userService = RetrofitManager.createService(UserService::class.java)      private val _userLiveData = MutableLiveData<User>()      val userLiveData: LiveData<User> = _userLiveData      private val _errorLiveData = MutableLiveData<String>()      val errorLiveData: LiveData<String> = _errorLiveData      // 对外暴露的方法（UI层调用）      fun loadUser(userId: Int) {          viewModelScope.launch {              try {                  val user = userService.getUserById(userId)                  _userLiveData.postValue(user) // 发送数据到UI              } catch (e: IOException) {                  _errorLiveData.postValue("网络异常，请重试")              } catch (e: Exception) {                  _errorLiveData.postValue("请求失败")              }          }      }  }  // 4. UI层（Activity，仅观察数据和更新UI）  class UserActivity : AppCompatActivity() {      override fun onCreate(savedInstanceState: Bundle?) {          super.onCreate(savedInstanceState)          setContentView(R.layout.activity_user)          val viewModel = ViewModelProvider(this)[UserViewModel::class.java]          // 观察用户数据，更新UI          viewModel.userLiveData.observe(this) { user ->              tvUserId.text = "ID: ${user.userId}"              tvUserName.text = "姓名: ${user.name}"              tvUserAge.text = "年龄: ${user.age}"          }          // 观察错误信息，提示用户          viewModel.errorLiveData.observe(this) { errorMsg ->              Toast.makeText(this, errorMsg, Toast.LENGTH_SHORT).show()          }          // 发起请求（UI层只调用方法，不关心内部逻辑）          btnLoadUser.setOnClickListener {              viewModel.loadUser(123)          }      }  }  

class UserActivity : AppCompatActivity() {      private val userService = RetrofitManager.createService(UserService::class.java)      private var isRequesting = false // 请求状态标志位      override fun onCreate(savedInstanceState: Bundle?) {          super.onCreate(savedInstanceState)          btnLogin.setOnClickListener {              if (isRequesting) return // 若正在请求，直接返回              val username = etUsername.text.toString()              val password = etPassword.text.toString()              login(username, password)          }      }      private fun login(username: String, password: String) {          isRequesting = true          viewModelScope.launch {              try {                  val response = userService.login(username, password)                  // 处理登录成功              } catch (e: Exception) {                  // 处理登录失败              } finally {                  isRequesting = false // 请求结束，重置标志位              }          }      }  }  

// 1. 将按钮点击事件转换为Observable  Observable<Object> clickObservable = RxView.clicks(btnLogin)          // Debounce：延迟500ms执行，若500ms内再次点击，重新计时          .debounce(500, TimeUnit.MILLISECONDS)          .subscribeOn(AndroidSchedulers.mainThread());  // 2. 订阅点击事件，发起网络请求  clickObservable.flatMap(o -> {      String username = etUsername.getText().toString();      String password = etPassword.getText().toString();      // 发起登录请求（IO线程）      return userService.login(username, password)              .subscribeOn(Schedulers.io())              .observeOn(AndroidSchedulers.mainThread());  })  .subscribe(          response -> { /* 处理成功 */ },          throwable -> { /* 处理失败 */ }  );