网络通信——HTTP接口访问——GET方式调用HTTP接口

桃扇骨 2024-04-03 12:54 215阅读 0赞

54f0eaf23f89a62e671351752107ef7c.png

HttpURLConnection访问HTTP接口的注意点：(1)HttpURLConnection默认采取UTF-8编码，但服务器可能返回GBK编码的报文；(2)有时服务器会先压缩应答报文，再把压缩后的数据送给调用方；(3)服务器返回报文超长的时候，不要企图一次性把返回数据读到某个字节数组，而要循环读取输入流中的字节数据，直到确定读完了全部的应答数据；

260f149ef5e41a162a273f35d7b3a4b6.png

643014e0d8a8b84152d0f382cdf9fb96.png

10b30e9006249de2b17137759bb7c3ae.png

1b514db9c4dd47a9fcdc7168d4c63d23.png

==============================================================================================================

AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:tools="http://schemas.android.com/tools"
  4.     package="com.example.myapplication">
  6.     <!-- 互联网 -->
  7.     <uses-permission android:name="android.permission.INTERNET" />
  8.     <!-- 定位 -->
  9.     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  10.     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
  11.     <!-- 存储卡读写 -->
  12.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  13.     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
  14.     <!-- 下载时不提示通知栏 -->
  15.     <uses-permission android:name="android.permission.DOWNLOAD_WITHOUT_NOTIFICATION" />
  20.     <!-- 相机 -->
  21.     <uses-permission android:name="android.permission.CAMERA" />
  22.     <!-- 录音 -->
  23.     <uses-permission android:name="android.permission.RECORD_AUDIO" />
  24.     <!-- 存储卡读写 -->
  25.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  26.     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
  27.     <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
  29.     <application
  30.         android:allowBackup="true"
  31.         android:dataExtractionRules="@xml/data_extraction_rules"
  32.         android:fullBackupContent="@xml/backup_rules"
  33.         android:icon="@mipmap/ic_launcher"
  34.         android:label="@string/app_name"
  35.         android:roundIcon="@mipmap/ic_launcher_round"
  36.         android:supportsRtl="true"
  37.         android:theme="@style/Theme.MyApplication"
  38.         android:usesCleartextTraffic="true"
  39.         tools:targetApi="31">
  40.         <activity
  41.             android:name=".MainActivity7"
  42.             android:exported="false" />
  43.         <activity
  44.             android:name=".MainActivity6"
  45.             android:exported="false" />
  46.         <activity
  47.             android:name=".MainActivity5"
  48.             android:exported="false"
  49.             android:label="@string/title_activity_main5" />
  50.         <activity
  51.             android:name=".MainActivity4"
  52.             android:exported="false"
  53.             android:label="@string/title_activity_main4" />
  54.         <activity
  55.             android:name=".MainActivity3"
  56.             android:exported="false"
  57.             android:label="@string/title_activity_main3" />
  58.         <activity
  59.             android:name=".MainActivity2"
  60.             android:exported="false"
  61.             android:label="@string/title_activity_main2" />
  62.         <activity
  63.             android:name=".MainActivity"
  64.             android:exported="true">
  66.             <!-- android:theme="@style/AppCompatTheme" /> -->
  67.             <intent-filter>
  68.                 <action android:name="android.intent.action.MAIN" />
  70.                 <category android:name="android.intent.category.LAUNCHER" />
  71.             </intent-filter>
  72.         </activity>
  73.     </application>
  75. </manifest>

布局：

  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2.     android:layout_width="match_parent"
  3.     android:layout_height="match_parent"
  4.     android:orientation="vertical"
  5.     android:padding="5dp" >
  7.     <TextView
  8.         android:id="@+id/tv_location"
  9.         android:layout_width="wrap_content"
  10.         android:layout_height="wrap_content"
  11.         android:text="暂未获取到定位对象"
  12.         android:textColor="@color/black"
  13.         android:textSize="17sp" />
  15. </LinearLayout>

b7fe8972b7c0df060b8fbcd31ed68a1a.png

主代码：

  1. package com.example.myapplication;
  3. import android.Manifest;
  4. import android.annotation.SuppressLint;
  5. import android.content.Context;
  6. import android.content.pm.PackageManager;
  7. import android.location.Location;
  8. import android.location.LocationManager;
  9. import android.os.Bundle;
  10. import android.util.Log;
  11. import android.widget.TextView;
  12. import android.widget.Toast;
  13. import androidx.appcompat.app.AppCompatActivity;
  14. import androidx.core.app.ActivityCompat;
  16. import com.example.myapplication.task.GetAddressTask;
  17. import com.example.myapplication.util.DateUtil;
  18. import com.example.myapplication.util.SwitchUtil;
  20. @SuppressLint("DefaultLocale")
  21. public class MainActivity extends AppCompatActivity implements GetAddressTask.OnAddressListener
  22. {
  24.     private final static String TAG = "HttpGetActivity";
  26.     private TextView tv_location;
  27.     private Location mLocation; // 定位信息
  29.     @Override
  30.     protected void onCreate(Bundle savedInstanceState)
  31.     {
  32.         super.onCreate(savedInstanceState);
  33.         setContentView(R.layout.activity_main);
  35.         tv_location = findViewById(R.id.tv_location);
  37.         SwitchUtil.checkGpsIsOpen(this, "需要打开定位功能才能查看定位结果信息");      // 检查定位功能是否打开，若未打开则跳到系统的定位功能设置页面
  38.     }
  40.     @Override
  41.     protected void onResume()
  42.     {
  44.         super.onResume();
  46.         // 检查当前设备是否已经开启了定位功能
  47.         if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED)
  49.         {
  50.             Toast.makeText(this, "请授予定位权限并开启定位功能", Toast.LENGTH_SHORT).show();
  52.             return;
  53.         }
  56.         // 从系统服务中获取定位管理器
  57.         LocationManager mgr = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
  59.         // 获取最后一次成功定位的位置信息(network表示网络定位方式)
  60.         Location location = mgr.getLastKnownLocation("network");
  62.         getLocationText(location); // 获取定位结果文本
  64.         // 获取最后一次成功定位的位置信息(gps表示卫星定位方式)
  65.         location = mgr.getLastKnownLocation("gps");
  67.         getLocationText(location); // 获取定位结果文本
  70.     }
  72.     // 获取定位结果文本
  73.     private void getLocationText(Location location)
  74.     {
  76.         if (location != null)
  77.         {
  79.             mLocation = location;
  81.             refreshLocationInfo(""); // 刷新定位信息
  83.             GetAddressTask task = new GetAddressTask(); // 创建一个详细地址查询的异步任务
  85.             task.setOnAddressListener(this); // 设置详细地址查询的监听器
  87.             task.execute(location); // 把详细地址查询任务加入到处理队列
  88.         }
  89.     }
  91.     // 在找到详细地址后触发
  92.     @Override
  93.     public void onFindAddress(String address)
  94.     {
  96.         refreshLocationInfo(address); // 刷新定位信息
  97.     }
  99.     // 刷新定位信息
  100.     private void refreshLocationInfo(String address)
  101.     {
  103.         String desc = String.format("定位类型=%s\n定位对象信息如下： " + "\n\t其中时间：%s" + "\n\t其中经度：%f，纬度：%f" + "\n\t其中高度：%d米，精度：%d米" + "\n\t其中地址：%s",
  104.                 mLocation.getProvider(), DateUtil.formatDate(mLocation.getTime()),
  105.                 mLocation.getLongitude(), mLocation.getLatitude(),
  106.                 Math.round(mLocation.getAltitude()), Math.round(mLocation.getAccuracy()), address);
  108.         tv_location.setText(desc);
  109.     }
  111. }
  113. DateUtil
  115. package com.example.myapplication.util;
  117. import android.annotation.SuppressLint;
  118. import android.text.TextUtils;
  120. import java.text.SimpleDateFormat;
  121. import java.util.Date;
  123. @SuppressLint("SimpleDateFormat")
  124. public class DateUtil {
  125.     // 获取当前的日期时间
  126.     public static String getNowDateTime() {
  127.         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
  128.         return sdf.format(new Date());
  129.     }
  131.     // 获取当前的时间
  132.     public static String getNowTime() {
  133.         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
  134.         return sdf.format(new Date());
  135.     }
  137.     // 获取当前的时间(精确到毫秒)
  138.     public static String getNowTimeDetail() {
  139.         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
  140.         return sdf.format(new Date());
  141.     }
  143.     // 获取指定格式的日期时间
  144.     public static String getNowDateTime(String formatStr) {
  145.         String format = formatStr;
  146.         if (TextUtils.isEmpty(format)) {
  147.             format = "yyyyMMddHHmmss";
  148.         }
  149.         SimpleDateFormat sdf = new SimpleDateFormat(format);
  150.         return sdf.format(new Date());
  151.     }
  153.     public static String formatDate(long time) {
  154.         Date date = new Date(time);
  155.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  156.         return sdf.format(date);
  157.     }
  159.     // 重新格式化日期字符串
  160.     public static String convertDateString(String strTime) {
  161.         String newTime = strTime;
  162.         try {
  163.             SimpleDateFormat oldFormat = new SimpleDateFormat("yyyyMMddHHmmss");
  164.             Date date = oldFormat.parse(strTime);
  165.             SimpleDateFormat newFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  166.             newTime = newFormat.format(date);
  167.         } catch (Exception e) {
  168.             e.printStackTrace();
  169.         }
  170.         return newTime;
  171.     }
  173. }
  175. SwitchUtil
  177. package com.example.myapplication.util;
  179. import android.content.Context;
  180. import android.content.Intent;
  181. import android.location.LocationManager;
  182. import android.net.wifi.WifiManager;
  183. import android.provider.Settings;
  184. import android.widget.Toast;
  186. public class SwitchUtil
  187. {
  189.     // 获取定位功能的开关状态
  190.     public static boolean getGpsStatus(Context ctx)
  191.     {
  192.         // 从系统服务中获取定位管理器
  193.         LocationManager lm = (LocationManager) ctx.getSystemService(Context.LOCATION_SERVICE);
  195.         return lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
  197.     }
  199.     // 检查定位功能是否打开，若未打开则跳到系统的定位功能设置页面
  200.     public static void checkGpsIsOpen(Context ctx, String hint)
  201.     {
  202.         if (!getGpsStatus(ctx))
  203.         {
  205.             Toast.makeText(ctx, hint, Toast.LENGTH_SHORT).show();
  207.             Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
  209.             ctx.startActivity(intent);
  210.         }
  211.     }
  213. }
  215. GetAddressTask
  217. package com.example.myapplication.task;
  219. import android.location.Location;
  220. import android.os.AsyncTask;
  221. import android.text.TextUtils;
  222. import android.util.Log;
  223. import com.example.myapplication.util.HttpUtil;
  224. import org.json.JSONException;
  225. import org.json.JSONObject;
  226. import java.io.UnsupportedEncodingException;
  227. import java.net.URLEncoder;
  229. // 根据经纬度获取详细地址的异步任务
  230. public class GetAddressTask extends AsyncTask<Location, Void, String> {
  231.     private final static String TAG = "GetAddressTask";
  232.     private String mQueryUrl = "https://api.tianditu.gov.cn/geocoder?postStr=%s&type=geocode&tk=253b3bd69713d4bdfdc116255f379841";
  234.     // 线程正在后台处理
  235.     protected String doInBackground(Location... params) {
  236.         Location location = params[0];
  237.         //String url = String.format(mQueryUrl, mLocation.getLongitude(), mLocation.getLatitude());
  238.         String param = String.format("{'lon':%f,'lat':%f,'ver':1}", location.getLongitude(), location.getLatitude());
  239.         try {
  240.             param = URLEncoder.encode(param, "utf8");
  241.         } catch (UnsupportedEncodingException e) {
  242.             e.printStackTrace();
  243.         }
  246.         String url = String.format(mQueryUrl, param);
  247. //        // 把经度和纬度代入到URL地址。天地图的地址查询url在UrlConstant.java中定义
  248. //        String url = String.format(UrlConstant.GET_ADDRESS_URL,
  249. //                location.getLongitude(), location.getLatitude());
  250.         Log.d(TAG, "url = " + url);
  252.         String resp = HttpUtil.get(url, null); // 发送HTTP请求信息，并获得HTTP应答内容
  254.         Log.d(TAG, "resp = " + resp);
  256.         String address = "未知";
  258.         // 下面从JSON串中解析formatted_address字段获得详细地址描述
  260.         if (!TextUtils.isEmpty(resp))
  261.         {
  263.             try
  264.             {
  266.                 JSONObject obj = new JSONObject(resp);
  267.                 JSONObject result = obj.getJSONObject("result");
  268.                 address = result.getString("formatted_address");
  269.             }
  270.             catch (JSONException e)
  271.             {
  273.                 e.printStackTrace();
  274.             }
  275.         }
  276.         Log.d(TAG, "address = " + address);
  277.         return address; // 返回HTTP应答内容中的详细地址
  278.     }
  280.     // 线程已经完成处理
  281.     protected void onPostExecute(String address)
  282.     {
  284.         mListener.onFindAddress(address); // HTTP调用完毕，触发监听器的找到地址事件
  285.     }
  288.     private OnAddressListener mListener; // 声明一个查询详细地址的监听器对象
  291.     // 设置查询详细地址的监听器
  292.     public void setOnAddressListener(OnAddressListener listener)
  293.     {
  295.         mListener = listener;
  296.     }
  299.     // 定义一个查询详细地址的监听器接口
  300.     public interface OnAddressListener
  301.     {
  303.         void onFindAddress(String address);
  304.     }
  306. }
  308. HttpUtil
  310. package com.example.myapplication.util;
  312. import android.graphics.Bitmap;
  313. import android.graphics.BitmapFactory;
  314. import android.util.Log;
  316. import java.io.ByteArrayOutputStream;
  317. import java.io.DataOutputStream;
  318. import java.io.FileInputStream;
  319. import java.io.IOException;
  320. import java.io.InputStream;
  321. import java.io.OutputStream;
  322. import java.net.HttpURLConnection;
  323. import java.net.URL;
  324. import java.security.SecureRandom;
  325. import java.security.cert.X509Certificate;
  326. import java.util.Map;
  327. import java.util.zip.GZIPInputStream;
  329. import javax.net.ssl.HostnameVerifier;
  330. import javax.net.ssl.HttpsURLConnection;
  331. import javax.net.ssl.SSLContext;
  332. import javax.net.ssl.SSLSession;
  333. import javax.net.ssl.TrustManager;
  334. import javax.net.ssl.X509TrustManager;
  336. public class HttpUtil {
  337.     private final static String TAG = "HttpUtil";
  338.     private final static int CONNECT_TIMEOUT = 15000;
  339.     private final static int READ_TIMEOUT = 15000;
  341.     // 兼容https开头的调用地址
  342.     private static void compatibleSSL(String callUrl) throws Exception {
  343.         if (callUrl.toLowerCase().startsWith("https")) {
  344.             SSLContext sc = SSLContext.getInstance("TLS");
  345.             sc.init(null, new TrustManager[]{
  346.      new X509TrustManager() {
  347.                 @Override
  348.                 public X509Certificate[] getAcceptedIssuers() {
  349.                     return null;
  350.                 }
  352.                 @Override
  353.                 public void checkServerTrusted(X509Certificate[] arg0, String arg1) {
  354.                 }
  356.                 @Override
  357.                 public void checkClientTrusted(X509Certificate[] arg0, String arg1) {
  358.                 }
  359.             }}, new SecureRandom());
  360.             HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  361.             HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
  362.                 @Override
  363.                 public boolean verify(String hostname, SSLSession session) {
  364.                     return true;
  365.                 }
  366.             });
  367.         }
  368.     }
  370.     // 对指定接口地址发起GET调用
  371.     public static String get(String callUrl, Map<String, String> headers)
  372.     {
  373.         String resp = ""; // 应答内容
  374.         try
  375.         {
  376.             Log.d(TAG, "请求地址："+callUrl);
  378.             compatibleSSL(callUrl); // 兼容https开头的调用地址
  379.             URL url = new URL(callUrl); // 根据网址字符串构建URL对象
  381.             // 打开URL对象的网络连接，并返回HttpURLConnection连接对象
  382.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  383.             conn.setRequestMethod("GET"); // 设置请求方式
  384.             setConnHeader(conn, headers);// 设置HTTP连接的头部信息
  385.             conn.connect(); // 开始连接
  387.             // 打印HTTP调用的应答内容长度、内容类型、压缩方式
  388.             Log.d(TAG,  String.format("应答内容长度=%d, 内容类型=%s, 压缩方式=%s", conn.getContentLength(), conn.getContentType(), conn.getContentEncoding()) );
  390.             // 对输入流中的数据解压和字符编码，得到原始的应答字符串
  391.             resp = getUnzipString(conn);
  393.             // 打印HTTP调用的应答状态码和应答报文
  394.             Log.d(TAG,  String.format("应答状态码=%d, 应答报文=%s", conn.getResponseCode(), resp) );
  396.             conn.disconnect(); // 断开连接
  398.         }
  399.         catch (Exception e)
  400.         {
  402.             e.printStackTrace();
  403.         }
  404.         return resp;
  405.     }
  407.     // 从指定url获取图片
  408.     public static Bitmap getImage(String callUrl, Map<String, String> headers) {
  409.         Bitmap bitmap = null; // 位图对象
  410.         try {
  411.             Log.d(TAG, "请求地址："+callUrl);
  412.             compatibleSSL(callUrl); // 兼容https开头的调用地址
  413.             URL url = new URL(callUrl); // 根据网址字符串构建URL对象
  414.             // 打开URL对象的网络连接，并返回HttpURLConnection连接对象
  415.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  416.             conn.setRequestMethod("GET"); // 设置请求方式
  417.             setConnHeader(conn, headers);// 设置HTTP连接的头部信息
  418.             conn.connect(); // 开始连接
  419.             // 打印图片获取的应答内容长度、内容类型、压缩方式
  420.             Log.d(TAG,  String.format("应答内容长度=%d, 内容类型=%s, 压缩方式=%s",
  421.                     conn.getContentLength(), conn.getContentType(), conn.getContentEncoding()) );
  422.             // 对输入流中的数据解码，得到位图对象
  423.             bitmap = BitmapFactory.decodeStream(conn.getInputStream());
  424.             // 打印图片获取的应答状态码和位图大小
  425.             Log.d(TAG,  String.format("应答状态码=%d, 位图大小=%s", conn.getResponseCode(), bitmap.getByteCount()) );
  426.             conn.disconnect(); // 断开连接
  427.         } catch (Exception e) {
  428.             e.printStackTrace();
  429.         }
  430.         return bitmap;
  431.     }
  433.     // 对指定接口地址发起POST调用
  434.     public static String post(String callUrl, String req, Map<String, String> headers) {
  435.         String resp = ""; // 应答内容
  436.         try {
  437.             Log.d(TAG, "请求地址："+callUrl+", 请求报文="+req);
  438.             compatibleSSL(callUrl); // 兼容https开头的调用地址
  439.             URL url = new URL(callUrl); // 根据网址字符串构建URL对象
  440.             // 打开URL对象的网络连接，并返回HttpURLConnection连接对象
  441.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  442.             conn.setRequestMethod("POST"); // 设置请求方式
  443.             setConnHeader(conn, headers);// 设置HTTP连接的头部信息
  444.             conn.setRequestProperty("Content-Type", "application/json"); // 请求报文为json格式
  445.             conn.setDoOutput(true); // 准备让连接执行输出操作。默认为false，POST方式需要设置为true
  446.             //conn.setDoInput(true); // 准备让连接执行输入操作。默认为true
  447.             conn.connect(); // 开始连接
  448.             OutputStream os = conn.getOutputStream(); // 从连接对象中获取输出流
  449.             os.write(req.getBytes()); // 往输出流写入请求报文
  450.             // 打印HTTP调用的应答内容长度、内容类型、压缩方式
  451.             Log.d(TAG,  String.format("应答内容长度=%s, 内容类型=%s, 压缩方式=%s",
  452.                     conn.getHeaderField("Content-Length"), conn.getHeaderField("Content-Type"),
  453.                     conn.getHeaderField("Content-Encoding")) );
  454.             // 对输入流中的数据解压和字符编码，得到原始的应答字符串
  455.             resp = getUnzipString(conn);
  456.             // 打印HTTP调用的应答状态码和应答报文
  457.             Log.d(TAG,  String.format("应答状态码=%d, 应答报文=%s", conn.getResponseCode(), resp) );
  458.             conn.disconnect(); // 断开连接
  459.         } catch (Exception e) {
  460.             e.printStackTrace();
  461.         }
  462.         return resp;
  463.     }
  465.     // 把文件上传给指定的URL
  466.     public static String upload(String uploadUrl, String uploadFile, Map<String, String> headers)
  467.     {
  469.         String resp = ""; // 应答内容
  470.         // 从本地文件路径获取文件名
  471.         String fileName = uploadFile.substring(uploadFile.lastIndexOf("/"));
  472.         String end = "\r\n"; // 结束字符串
  473.         String hyphens = "--"; // 连接字符串
  474.         String boundary = "WUm4580jbtwfJhNp7zi1djFEO3wNNm"; // 边界字符串
  475.         try (FileInputStream fis = new FileInputStream(uploadFile)) {
  476.             Log.d(TAG, "上传地址："+uploadUrl+", 上传文件="+uploadFile);
  477.             compatibleSSL(uploadUrl); // 兼容https开头的调用地址
  478.             URL url = new URL(uploadUrl); // 根据网址字符串构建URL对象
  479.             // 打开URL对象的网络连接，并返回HttpURLConnection连接对象
  480.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  481.             conn.setRequestMethod("POST"); // 设置请求方式
  482.             setConnHeader(conn, headers);// 设置HTTP连接的头部信息
  483.             conn.setDoOutput(true); // 准备让连接执行输出操作。默认为false，POST方式需要设置为true
  484.             //conn.setDoInput(true); // 准备让连接执行输入操作。默认为true
  485.             conn.setRequestProperty("Connection", "Keep-Alive"); // 连接过程要保持活跃
  486.             // 请求报文要求分段传输，并且各段之间以边界字符串隔开
  487.             conn.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary);
  489.             // 根据连接对象的输出流构建数据输出流
  490.             DataOutputStream ds = new DataOutputStream(conn.getOutputStream());
  491.             // 以下写入请求报文的头部
  492.             ds.writeBytes(hyphens + boundary + end);
  493.             ds.writeBytes("Content-Disposition: form-data; "
  494.                     + "name=\"file\";filename=\"" + fileName + "\"" + end);
  495.             ds.writeBytes(end);
  496.             // 以下写入请求报文的主体
  497.             byte[] buffer = new byte[1024];
  498.             int length;
  499.             // 先将文件数据写入到缓冲区，再将缓冲数据写入输出流
  500.             while ((length = fis.read(buffer)) != -1) {
  501.                 ds.write(buffer, 0, length);
  502.             }
  503.             ds.writeBytes(end);
  504.             // 以下写入请求报文的尾部
  505.             ds.writeBytes(hyphens + boundary + hyphens + end);
  506.             ds.close(); // 关闭数据输出流
  507.             // 打印HTTP调用的应答内容长度、内容类型、压缩方式
  508.             Log.d(TAG,  String.format("应答内容长度=%s, 内容类型=%s, 压缩方式=%s",
  509.                     conn.getHeaderField("Content-Length"), conn.getHeaderField("Content-Type"),
  510.                     conn.getHeaderField("Content-Encoding")) );
  511.             // 对输入流中的数据解压和字符编码，得到原始的应答字符串
  512.             resp = getUnzipString(conn);
  513.             // 打印HTTP上传的应答状态码和应答报文
  514.             Log.d(TAG,  String.format("应答状态码=%d, 应答报文=%s", conn.getResponseCode(), resp) );
  515.             conn.disconnect(); // 断开连接
  516.         }
  517.         catch (Exception e)
  518.         {
  520.             e.printStackTrace();
  521.         }
  522.         return resp;
  523.     }
  525.     // 设置HTTP连接的头部信息
  526.     private static void setConnHeader(HttpURLConnection conn, Map<String, String> headers)
  527.     {
  529.         conn.setConnectTimeout(CONNECT_TIMEOUT); // 设置连接的超时时间，单位毫秒
  530.         conn.setReadTimeout(READ_TIMEOUT); // 设置读取应答数据的超时时间，单位毫秒
  531.         conn.setRequestProperty("Accept", "*/*"); // 设置数据格式
  532.         conn.setRequestProperty("Accept-Language", "zh-CN"); // 设置文本语言
  533.         conn.setRequestProperty("Accept-Encoding", "gzip, deflate"); // 设置编码格式
  535.         // 设置用户代理，包括操作系统版本、浏览器版本等等
  536.         conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:33.0) Gecko/20100101 Firefox/33.0");
  537.         if (headers != null)
  538.         {
  540.             for (Map.Entry<String, String> item : headers.entrySet())
  541.             {
  543.                 conn.setRequestProperty(item.getKey(), item.getValue());
  544.             }
  545.         }
  546.     }
  548.     // 把输入流中的数据按照指定字符编码转换为字符串。处理大量数据需要使用本方法
  549.     private static String isToString(InputStream is, String charset)
  550.     {
  552.         String result = "";
  553.         // 创建一个字节数组的输出流对象
  554.         try (ByteArrayOutputStream baos = new ByteArrayOutputStream())
  555.         {
  557.             int i = -1;
  558.             while ((i = is.read()) != -1)   // 循环读取输入流中的字节数据
  559.             {
  560.                 baos.write(i); // 把字节数据写入字节数组输出流
  561.             }
  562.             byte[] data = baos.toByteArray(); // 把字节数组输出流转换为字节数组
  563.             result = new String(data, charset); // 将字节数组按照指定的字符编码生成字符串
  564.         }
  565.         catch (Exception e)
  566.         {
  568.             e.printStackTrace();
  569.         }
  571.         return result; // 返回转换后的字符串
  572.     }
  574.     // 从HTTP连接中获取已解压且重新编码后的应答报文
  575.     private static String getUnzipString(HttpURLConnection conn) throws IOException
  576.     {
  577.         String contentType = conn.getContentType(); // 获取应答报文的内容类型(包括字符编码)
  579.         String charset = "UTF-8"; // 默认的字符编码为UTF-8
  581.         if (contentType != null)
  582.         {
  584.             if (contentType.toLowerCase().contains("charset=gbk"))   // 应答报文采用gbk编码
  585.             {
  586.                 charset = "GBK"; // 字符编码改为GBK
  587.             }
  588.             else if (contentType.toLowerCase().contains("charset=gb2312"))  // 采用gb2312编码
  589.             {
  590.                 charset = "GB2312"; // 字符编码改为GB2312
  591.             }
  592.         }
  594.         String contentEncoding = conn.getContentEncoding(); // 获取应答报文的压缩方式
  596.         InputStream is = conn.getInputStream(); // 获取HTTP连接的输入流对象
  598.         String result = "";
  600.         if (contentEncoding != null && contentEncoding.contains("gzip"))   // 应答报文使用gzip压缩
  601.         {
  602.             // 根据输入流对象构建压缩输入流
  603.             try (GZIPInputStream gis = new GZIPInputStream(is))
  604.             {
  605.                 // 把压缩输入流中的数据按照指定字符编码转换为字符串
  606.                 result = isToString(gis, charset);
  607.             }
  608.             catch (Exception e)
  609.             {
  611.                 e.printStackTrace();
  612.             }
  613.         }
  614.         else
  615.         {
  617.             // 把输入流中的数据按照指定字符编码转换为字符串
  618.             result = isToString(is, charset);
  619.         }
  621.         return result; // 返回处理后的应答报文
  622.     }
  624. }

b74d4c6a7854d820e0270c47bf879b12.png

4ec938c0a60695d6cd403ef17e713259.png

a69d91fcbf5a5640cd6ddcc75f8fac1d.png

c7d356ae292197200e767c366c91cbc3.png

7e9e7add966299c3cfbd3da757c3f5f4.png

12bdad4dd2e7b83a8d8f2074cc8eaedd.png

c3d344f946c051b4cc2d2ebecd1ed2c4.png

dbae420ccbf34a059d5dbfb43ea75847.png

0916643385e0076181cfb8c59784e289.png

b6ef8a81de93e3b466f41edf2c1c2cf0.png

5dd04cd4c8d76122b8c7d5678cdea6d4.png

发表评论

表情：
评论列表 （有 0 条评论，215人围观）

还没有评论，来说两句吧...

相关阅读