• Android 网络请求方式

    前言

    最近需要将Android 项目接入物联网公司提供的接口，所以顺便给大家分享一下Android中我们常用的网络请求吧！提醒大家一下，我们遇到接口需求，一定要先在Postman上测试接口是否正确，然后再去项目上写程序来请求接口；否则，请求出问题，你都不确定是你程序写的有问题还是接口本身提供的有问题。

    Android网络请求程序演练

    HttpUrlConnection

    这是 Android 中最常用的网络请求方式，可以通过该类建立连接并进行 HTTP 请求和响应的读写操作。使用简单，支持多种数据格式。

    GET请求

    1. public void sendGetRequest() {
    2.     String url = "http://example.com/api/getData";
    3.     HttpURLConnection connection = null;
    4.  
    5.     try {
    6.         URL requestUrl = new URL(url);
    7.         connection = (HttpURLConnection) requestUrl.openConnection();
    8.         connection.setRequestMethod("GET");
    9.  
    10.         // 添加header
    11.         connection.setRequestProperty("Content-Type", "application/json");
    12.         connection.setRequestProperty("Accept", "application/json");
    13.  
    14.         // 设置连接和读取超时时间
    15.         connection.setConnectTimeout(8000);
    16.         connection.setReadTimeout(8000);
    17.  
    18.         int responseCode = connection.getResponseCode();
    19.         if (responseCode == 200) { // 请求成功
    20.             InputStream inputStream = connection.getInputStream();
    21.             BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    22.             StringBuilder builder = new StringBuilder();
    23.             String line;
    24.             while ((line = reader.readLine()) != null) {
    25.                 builder.append(line);
    26.             }
    27.  
    28.             String response = builder.toString();
    29.             Log.d(TAG, "response: " + response);
    30.         } else { // 请求失败
    31.             Log.e(TAG, "Error response code: " + responseCode);
    32.         }
    33.  
    34.     } catch (Exception e) {
    35.         e.printStackTrace();
    36.     } finally {
    37.         if (connection != null) {
    38.             connection.disconnect();
    39.         }
    40.     }
    41. }

    其中，我们使用HttpURLConnection的openConnection()方法打开一个连接，然后设置请求方式为GET，再添加headers，设置连接和读取超时时间，最后通过getResponseCode()方法获取响应码，如果是200则表示请求成功，接着就可以获取响应数据了。

    POST请求

    1. public class MainActivity extends AppCompatActivity {
    2.     
    3.     private EditText editText;
    4.     private TextView textView;
    5.     private String url = "http://example.com/api";
    6.     
    7.     @Override
    8.     protected void onCreate(Bundle savedInstanceState) {
    9.         super.onCreate(savedInstanceState);
    10.         setContentView(R.layout.activity_main);
    11.         
    12.         editText = findViewById(R.id.editText);
    13.         textView = findViewById(R.id.textView);
    14.         
    15.         Button button = findViewById(R.id.button);
    16.         button.setOnClickListener(new View.OnClickListener() {
    17.             @Override
    18.             public void onClick(View view) {
    19.                 String postData = editText.getText().toString().trim();
    20.                 if (!TextUtils.isEmpty(postData)) {
    21.                     new PostTask().execute(postData);
    22.                 } else {
    23.                     Toast.makeText(MainActivity.this, "请输入内容", Toast.LENGTH_SHORT).show();
    24.                 }
    25.             }
    26.         });
    27.     }
    28.     
    29.     private class PostTask extends AsyncTask {
    30.         @Override
    31.         protected String doInBackground(String... params) {
    32.             try {
    33.                 URL reqUrl = new URL(url);
    34.                 HttpURLConnection conn = (HttpURLConnection) reqUrl.openConnection();
    35.                 conn.setReadTimeout(10000);
    36.                 conn.setConnectTimeout(15000);
    37.                 conn.setRequestMethod("POST");
    38.                 conn.setDoInput(true);
    39.                 conn.setDoOutput(true);
    40.                 conn.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
    41.                 OutputStream outputStream = conn.getOutputStream();
    42.                 outputStream.write(params[0].getBytes("UTF-8"));
    43.                 outputStream.flush();
    44.                 outputStream.close();
    45.                 int responseCode = conn.getResponseCode();
    46.                 if (responseCode == HttpURLConnection.HTTP_OK) {
    47.                     InputStream inputStream = conn.getInputStream();
    48.                     BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
    49.                     StringBuilder response = new StringBuilder();
    50.                     String line = null;
    51.                     while ((line = reader.readLine()) != null) {
    52.                         response.append(line);
    53.                     }
    54.                     reader.close();
    55.                     inputStream.close();
    56.                     return response.toString();
    57.                 }
    58.             } catch (Exception e) {
    59.                 e.printStackTrace();
    60.             }
    61.             return null;
    62.         }
    63.         
    64.         @Override
    65.         protected void onPostExecute(String result) {
    66.             if (result != null) {
    67.                 textView.setText(result);
    68.             } else {
    69.                 Toast.makeText(MainActivity.this, "请求出错", Toast.LENGTH_SHORT).show();
    70.             }
    71.         }
    72.     }
    73. }

    Volley

    Volley 是 Google 推出的一款网络请求框架，专门用于简化 Android 应用开发中的网络请求，具有自动请求队列、网络请求缓存、图片加载等功能。

    GET请求

    1. // 创建一个 RequestQueue 对象
    2. RequestQueue queue = Volley.newRequestQueue(this);
    3.  
    4. // 指定请求的 URL
    5. String url = "https://www.example.com/api/get_data";
    6.  
    7. // 创建一个 StringRequest 对象
    8. StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
    9.         new Response.Listener() {
    10.             @Override
    11.             public void onResponse(String response) {
    12.                 // 响应成功时的回调函数
    13.                 Log.d(TAG, "Response: " + response);
    14.             }
    15.         }, new Response.ErrorListener() {
    16.             @Override
    17.             public void onErrorResponse(VolleyError error) {
    18.                 // 响应失败时的回调函数
    19.                 Log.e(TAG, "Error: " + error.getMessage());
    20.             }
    21.         });
    22.  
    23. // 将 StringRequest 对象添加到 RequestQueue 中
    24. queue.add(stringRequest);

    POST请求

    1. RequestQueue queue = Volley.newRequestQueue(this);
    2. String url = "http://your-url.com/post-endpoint";
    3. StringRequest postRequest = new StringRequest(Request.Method.POST, url, 
    4.     new Response.Listener() 
    5.     {
    6.         @Override
    7.         public void onResponse(String response) {
    8.             // 处理响应
    9.         }
    10.     }, 
    11.     new Response.ErrorListener() 
    12.     {
    13.          @Override
    14.          public void onErrorResponse(VolleyError error) {
    15.              // 处理错误
    16.          }
    17.     }
    18. ) {     
    19.     @Override
    20.     protected Map getParams() 
    21.     {  
    22.         // 请求参数
    23.         Map params = new HashMap();  
    24.         params.put("param1", "value1");  
    25.         params.put("param2", "value2");  
    26.  
    27.         return params;  
    28.     }
    29.  
    30.     @Override
    31.     public Map getHeaders() throws AuthFailureError {
    32.         Map headers = new HashMap();
    33.         // 添加headers
    34.         headers.put("Authorization", "Bearer your-access-token");
    35.         return headers;
    36.     }
    37. };
    38.  
    39. queue.add(postRequest);

    Retrofit

    Retrofit 是一个基于 OkHttp 的类型安全的 RESTful 客户端，可以使用注解的方式实现接口的定义，高效易用，支持多种数据格式。

    GET请求

    1. 添加Retrofit依赖项：在您的Android项目中的build.gradle文件中添加以下依赖项：

    1. dependencies {
    2.     implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    3.     implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    4. }

    2. 创建Retrofit实例：在您的Java类中创建Retrofit实例。

    1. Retrofit retrofit = new Retrofit.Builder()
    2.          .baseUrl("https://yourapi.com/")
    3.          .addConverterFactory(GsonConverterFactory.create())
    4.          .build();

    3. 创建API接口：创建一个Java接口，其中定义GET请求以及其参数和返回类型。

    1. public interface YourApiService {
    2.     @GET("your_api_path")
    3.     Call getYourApiData(@Query("your_param_name") String yourParamValue);
    4. }

    4. 发送GET请求：在您的Java类中使用Retrofit实例创建API服务实例，并发送GET请求。这可以在Activity或Fragment中完成，也可以使用ViewModel和LiveData进行MVVM架构。

    1. YourApiService apiService = retrofit.create(YourApiService.class);
    2.  
    3. Call<YourApiResponse> call = apiService.getYourApiData("your_param_value");
    4.  
    5. call.enqueue(new Callback<YourApiResponse>() {
    6.      @Override
    7.       public void onResponse(Call<YourApiResponse> call, Response<YourApiResponse> response) {
    8.            // 处理响应
    9.       }
    10.  
    11.      @Override
    12.      public void onFailure(Call<YourApiResponse> call, Throwable t) {
    13.            // 处理失败
    14.      }
    15. });

    在上面的代码中，我们使用enqueue()方法异步发送GET请求，并在回调方法中处理响应。我们可以在onResponse()方法中处理成功的响应，并在onFailure()方法中处理失败的响应。

    POST请求

    使用Retrofit发送POST请求需要创建一个接口，接口中定义请求的参数和返回值类型，在方法上使用@POST注解，并且指定请求的URL，参数使用@Body注解标识。下面是一个简单的示例：

    首先，添加Retrofit的依赖：

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'

    然后，定义一个接口，例如：

    1. public interface ApiInterface {
    2.  
    3.     @POST("login")
    4.     Call login(@Body LoginRequest request);
    5.  
    6. }

    其中，@POST("login")表示请求的URL为"login"，@Body LoginRequest request表示请求的参数为一个LoginRequest对象。

    接下来，创建一个Retrofit实例，并调用接口中的请求方法，例如：

    1. //创建Retrofit实例
    2. Retrofit retrofit = new Retrofit.Builder()
    3.         .baseUrl(BASE_URL)
    4.         .addConverterFactory(GsonConverterFactory.create())
    5.         .build();
    6. //创建接口实例
    7. ApiInterface apiInterface = retrofit.create(ApiInterface.class);
    8. //创建请求对象
    9. LoginRequest request = new LoginRequest("username", "password");
    10. //发送请求
    11. Call call = apiInterface.login(request);
    12. call.enqueue(new Callback() {
    13.     @Override
    14.     public void onResponse(Call call, Response response) {
    15.         //请求成功处理逻辑
    16.     }
    17.  
    18.     @Override
    19.     public void onFailure(Call call, Throwable t) {
    20.         //请求失败处理逻辑
    21.     }
    22. });

    其中，BASE_URL需要替换为你的服务器地址，LoginRequest为请求参数的实体类，例如：

    1. public class LoginRequest {
    2.     private String username;
    3.     private String password;
    4.  
    5.     public LoginRequest(String username, String password) {
    6.         this.username = username;
    7.         this.password = password;
    8.     }
    9.  
    10.     public String getUsername() {
    11.         return username;
    12.     }
    13.  
    14.     public void setUsername(String username) {
    15.         this.username = username;
    16.     }
    17.  
    18.     public String getPassword() {
    19.         return password;
    20.     }
    21.  
    22.     public void setPassword(String password) {
    23.         this.password = password;
    24.     }
    25. }

    以上就是通过Retrofit发送POST请求的基本流程。

    OkHttp

    OkHttp 是一个高效的 HTTP 客户端，支持 HTTP/2 和持久连接，可以用于替代 HttpUrlConnection 和 Volley。

    GET请求

    1. OkHttpClient client = new OkHttpClient();
    2. Request request = new Request.Builder()
    3.         .url("https://www.example.com/get")
    4.         .build();
    5. try {
    6.     Response response = client.newCall(request).execute();
    7.     String responseData = response.body().string();
    8.     Log.d(TAG, "onResponse: " + responseData);
    9. } catch (IOException e) {
    10.     e.printStackTrace();
    11. }

    POST请求

    以下是一个使用OkHttp同步发送POST请求的示例代码：

    1. OkHttpClient client = new OkHttpClient();
    2.  
    3. // 构造请求体，这里使用JSON格式
    4. String json = "{\"username\":\"admin\",\"password\":\"123456\"}";
    5. RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), json);
    6.  
    7. // 构造请求对象
    8. Request request = new Request.Builder()
    9.         .url("http://www.example.com/login") // 请求URL
    10.         .addHeader("Content-Type", "application/json") // 设置请求头
    11.         .post(requestBody) // 设置请求体
    12.         .build();
    13.  
    14. // 创建Call对象并发起请求
    15. Call call = client.newCall(request);
    16. Response response = call.execute();
    17.  
    18. // 解析响应结果
    19. String result = response.body().string();

    需要注意的是，如果请求过程需要很长时间，建议使用enqueue方法异步发起请求，避免阻塞主线程。例如：

    1. OkHttpClient client = new OkHttpClient();
    2.  
    3. // 构造请求体
    4. String json = "{\"username\":\"admin\",\"password\":\"123456\"}";
    5. RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), json);
    6.  
    7. // 构造请求对象
    8. Request request = new Request.Builder()
    9.         .url("http://www.example.com/login") // 请求URL
    10.         .addHeader("Content-Type", "application/json") // 设置请求头
    11.         .post(requestBody) // 设置请求体
    12.         .build();
    13.  
    14. // 创建Call对象并异步发起请求
    15. Call call = client.newCall(request);
    16. call.enqueue(new Callback() {
    17.     @Override
    18.     public void onFailure(Call call, IOException e) {
    19.         // 处理请求失败的情况
    20.     }
    21.  
    22.     @Override
    23.     public void onResponse(Call call, Response response) throws IOException {
    24.         // 处理响应结果
    25.         String result = response.body().string();
    26.     }
    27. });

    AsyncHttpClient

    AsyncHttpClient 是一个轻量级的异步 HTTP 客户端，支持 HTTP、HTTPS、WebSocket 和 HTTP2.0 协议，可以实现全局的请求头和请求参数的设置。

    GET请求

    1. AsyncHttpClient client = new AsyncHttpClient();
    2. String url = "https://www.example.com/api/data";
    3. RequestParams params = new RequestParams();
    4. params.put("param1", "value1");
    5. params.put("param2", "value2");
    6.  
    7. client.get(url, params, new AsyncHttpResponseHandler() {
    8.     @Override
    9.     public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
    10.         // 请求成功
    11.         String response = new String(responseBody);
    12.         Log.d("AsyncHttpClient", "Response: " + response);
    13.     }
    14.  
    15.     @Override
    16.     public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
    17.         // 请求失败
    18.         Log.e("AsyncHttpClient", "Error: " + error.getMessage());
    19.     }
    20. });

    POST请求

    1. String url = "http://example.com/api/post";
    2. client.post(url, params, new AsyncHttpResponseHandler() {
    3.  
    4.     @Override
    5.     public void onStart() {
    6.         // 发送请求前调用
    7.     }
    8.  
    9.     @Override
    10.     public void onSuccess(int statusCode, Header[] headers, byte[] response) {
    11.         // 请求成功调用, statusCode为HTTP状态码
    12.         String result = new String(response);
    13.         Log.i(TAG, "onSuccess: " + result);
    14.     }
    15.  
    16.     @Override
    17.     public void onFailure(int statusCode, Header[] headers, byte[] errorResponse, Throwable e) {
    18.         // 请求失败调用，statusCode为HTTP状态码
    19.         Log.e(TAG, "onFailure: statusCode=" + statusCode, e);
    20.     }
    21.  
    22.     @Override
    23.     public void onRetry(int retryNo) {
    24.         // 请求重试调用
    25.     }
    26. });

  • 相关阅读:
    Springboot毕设项目办公用品在线销售系统25f35（java+VUE+Mybatis+Maven+Mysql）
    卷积神经网络 - 图像卷积
    Spring 接口日志切片记录
    申请HTTPS证书
    cmd打开idea
    【pytorch】从零开始，利用yolov5、crnn+ctc进行车牌识别
    Windows10专业版系统安装Hyper-V虚拟机软件
    9.25
    Android 天气APP（三十六）运行到本地AS、更新项目版本依赖、去掉ButterKnife
    Dubbo-RPC核心接口介绍
  • 原文地址：https://blog.csdn.net/Ai1114/article/details/132829990