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

GET方式的毛病在于：请求参数只能以“参数名=参数值&参数名=参数值”这样的格式添加到接口地址末尾，使得它无法传送复杂结构的请求报文。

POST方式把接口地址与请求报文分开，允许使用自定义的报文格式(如JSON)，由此扩大了该方式的应用场景。

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

布局：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="5dp" >
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="40dp" >
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:gravity="center"
            android:text="请选择要更新的应用："
            android:textColor="@color/black"
            android:textSize="17sp" />
        <Spinner
            android:id="@+id/sp_app_name"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:spinnerMode="dialog" />
    </LinearLayout>
    <ImageView
        android:id="@+id/iv_app"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:scaleType="fitCenter" />
    <TextView
        android:id="@+id/tv_app_result"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textColor="@color/black"
        android:textSize="17sp" />
</LinearLayout>

主代码：

package com.example.myapplication;
import android.annotation.SuppressLint;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import com.example.myapplication.bean.PackageInfo;
import com.example.myapplication.constant.ApkConstant;
import com.example.myapplication.task.CheckUpdateTask;
import com.example.myapplication.task.req.CheckUpdateReq;
import com.example.myapplication.task.resp.CheckUpdateResp;
import com.google.gson.Gson;
@SuppressLint("DefaultLocale")
public class MainActivity extends AppCompatActivity implements CheckUpdateTask.OnCheckUpdateListener
{
    private static final String TAG = "HttpPostActivity";
    private Spinner sp_app_name; // 应用名称的下拉框
    private ImageView iv_app;
    private TextView tv_app_result;
    private boolean isFirstSelect = true; // 是否首次选择
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        iv_app = findViewById(R.id.iv_app);
        tv_app_result = findViewById(R.id.tv_app_result);
        initAppSpinner(); // 初始化应用名称的下拉框
    }
    // 初始化应用名称的下拉框
    private void initAppSpinner() {
        ArrayAdapter<String> apkNameAdapter = new ArrayAdapter<String>(this,
                R.layout.item_select, ApkConstant.NAME_ARRAY);
        sp_app_name = findViewById(R.id.sp_app_name);
        sp_app_name.setPrompt("请选择要更新的应用");
        sp_app_name.setAdapter(apkNameAdapter);
        sp_app_name.setOnItemSelectedListener(new AppNameSelectedListener());
        sp_app_name.setSelection(0);
    }
    class AppNameSelectedListener implements AdapterView.OnItemSelectedListener {
        public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
            if (isFirstSelect) { // 刚打开页面时不需要执行下载动作
                isFirstSelect = false;
                return;
            }
            queryAppInfo(arg2); // 查询应用的详细信息
        }
        public void onNothingSelected(AdapterView<?> arg0) {}
    }
    // 查询应用的详细信息
    private void queryAppInfo(int pos) {
        iv_app.setImageResource(ApkConstant.ICON_ARRAY[pos]); // 设置图像视图的资源图片
        CheckUpdateReq req = new CheckUpdateReq(); // 创建检查更新的请求对象
        req.package_list.add(new PackageInfo(ApkConstant.PACKAGE_ARRAY[pos]));
        String content = new Gson().toJson(req); // 把检查更新的请求对象转换为json字符串
        CheckUpdateTask task = new CheckUpdateTask(); // 创建一个检查应用更新的异步任务
        task.setCheckUpdateListener(this); // 设置应用更新检查的监听器
        task.execute(content); // 把应用更新检查任务加入到处理队列
    }
    // 在结束应用更新检查时触发
    @Override
    public void finishCheckUpdate(String resp) {
        if (TextUtils.isEmpty(resp)) {
            Toast.makeText(this, "应用检查更新失败", Toast.LENGTH_SHORT).show();
            return;
        }
        // 把JSON串转换为对应结构的实体对象
        CheckUpdateResp checkResp = new Gson().fromJson(resp, CheckUpdateResp.class);
        if (checkResp!=null && checkResp.package_list!=null && checkResp.package_list.size()>0) {
            PackageInfo info = checkResp.package_list.get(0);
            String desc = String.format("应用检查更新结果如下：\n应用名称：%s\n应用包名：%s\n最新版本：%s\n下载地址：%s",
                    info.app_name, info.package_name, info.new_version, info.download_url);
            tv_app_result.setText(desc); // 显示当前选中应用的检查更新结果
        }
    }
}
CheckUpdateResp
package com.example.myapplication.task.resp;
import com.example.myapplication.bean.PackageInfo;
import java.util.ArrayList;
import java.util.List;
public class CheckUpdateResp
{
    public List<PackageInfo> package_list = new ArrayList<PackageInfo>();
}
PackageInfo
package com.example.myapplication.bean;
public class PackageInfo
{
    public String app_name; // 应用名称
    public String package_name; // 应用包名
    public String download_url; // 下载地址
    public String new_version; // 新版本号
    public PackageInfo()
    {
        app_name = "";
        package_name = "";
        download_url = "";
        new_version = "";
    }
    public PackageInfo(String package_name)
    {
        this.package_name = package_name;
    }
}
UrlConstant
package com.example.myapplication.constant;
public class UrlConstant
{
    // 以下是HTTP接口调用的服务地址，根据实际情况修改IP和端口
    public static final String REQUEST_URL = "http://192.168.1.7:8080/NetServer";
    //public static final String REQUEST_URL = "http://192.168.1.2:6001/NetServer";
    // 检查应用更新的服务地址
    public static final String CHECK_UPDATE_URL = REQUEST_URL + "/checkUpdate";
    // 上传文件的服务地址
    public static final String UPLOAD_URL = REQUEST_URL + "/uploadServlet";
    // 获取旅游图片的服务地址
    public static final String GET_PHOTO_URL = REQUEST_URL + "/getPhoto";
    // 根据经纬度查询详细地址的网址(天地图)
    public static final String GET_ADDRESS_URL = "https://api.tianditu.gov.cn/geocoder?postStr={'lon':%f,'lat':%f,'ver':1}&type=geocode&tk=145897399844a50e3de2309513c8df4b";
   // 请求图片验证码的网址
    public static final String IMAGE_CODE_URL = "http://yx12.fjjcjy.com/Public/Control/GetValidateCode?time=";
}
CheckUpdateTask
package com.example.myapplication.task;
import android.os.AsyncTask;
import android.util.Log;
import com.example.myapplication.constant.UrlConstant;
import com.example.myapplication.util.HttpUtil;
// 检查应用更新的异步任务
public class CheckUpdateTask extends AsyncTask<String, Void, String>
{
    private final static String TAG = "CheckUpdateTask";
//    public CheckUpdateTask() {
//        super();
//    }
    // 线程正在后台处理
    protected String doInBackground(String... params)
    {
        String req = params[0]; // HTTP请求内容
        Log.d(TAG, "req = " + req);
        // 发送HTTP请求信息，并获得HTTP应答内容。检查更新的接口地址见UrlConstant.java
        String resp = HttpUtil.post(UrlConstant.CHECK_UPDATE_URL, req, null);
        Log.d(TAG, "resp = " + resp);
        return resp; // 返回HTTP应答内容
    }
    // 线程已经完成处理
    protected void onPostExecute(String resp)
    {
        mListener.finishCheckUpdate(resp); // HTTP调用完毕，触发监听器的结束检查事件
    }
    private OnCheckUpdateListener mListener; // 声明一个结束更新检查的监听器对象
    // 设置结束更新检查的监听器
    public void setCheckUpdateListener(OnCheckUpdateListener listener)
    {
        mListener = listener;
    }
    // 定义一个结束更新检查的监听器接口
    public interface OnCheckUpdateListener
    {
        void finishCheckUpdate(String resp);
    }
}
HttpUtil
package com.example.myapplication.util;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.Map;
import java.util.zip.GZIPInputStream;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
public class HttpUtil {
    private final static String TAG = "HttpUtil";
    private final static int CONNECT_TIMEOUT = 15000;
    private final static int READ_TIMEOUT = 15000;
    // 兼容https开头的调用地址
    private static void compatibleSSL(String callUrl) throws Exception {
        if (callUrl.toLowerCase().startsWith("https")) {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, new TrustManager[]{
     new X509TrustManager() {
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                @Override
                public void checkServerTrusted(X509Certificate[] arg0, String arg1) {
                }
                @Override
                public void checkClientTrusted(X509Certificate[] arg0, String arg1) {
                }
            }}, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });
        }
    }
    // 对指定接口地址发起GET调用
    public static String get(String callUrl, Map<String, String> headers)
    {
        String resp = ""; // 应答内容
        try
        {
            Log.d(TAG, "请求地址："+callUrl);
            compatibleSSL(callUrl); // 兼容https开头的调用地址
            URL url = new URL(callUrl); // 根据网址字符串构建URL对象
            // 打开URL对象的网络连接，并返回HttpURLConnection连接对象
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET"); // 设置请求方式
            setConnHeader(conn, headers);// 设置HTTP连接的头部信息
            conn.connect(); // 开始连接
            // 打印HTTP调用的应答内容长度、内容类型、压缩方式
            Log.d(TAG,  String.format("应答内容长度=%d, 内容类型=%s, 压缩方式=%s", conn.getContentLength(), conn.getContentType(), conn.getContentEncoding()) );
            // 对输入流中的数据解压和字符编码，得到原始的应答字符串
            resp = getUnzipString(conn);
            // 打印HTTP调用的应答状态码和应答报文
            Log.d(TAG,  String.format("应答状态码=%d, 应答报文=%s", conn.getResponseCode(), resp) );
            conn.disconnect(); // 断开连接
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return resp;
    }
    // 从指定url获取图片
    public static Bitmap getImage(String callUrl, Map<String, String> headers) {
        Bitmap bitmap = null; // 位图对象
        try {
            Log.d(TAG, "请求地址："+callUrl);
            compatibleSSL(callUrl); // 兼容https开头的调用地址
            URL url = new URL(callUrl); // 根据网址字符串构建URL对象
            // 打开URL对象的网络连接，并返回HttpURLConnection连接对象
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET"); // 设置请求方式
            setConnHeader(conn, headers);// 设置HTTP连接的头部信息
            conn.connect(); // 开始连接
            // 打印图片获取的应答内容长度、内容类型、压缩方式
            Log.d(TAG,  String.format("应答内容长度=%d, 内容类型=%s, 压缩方式=%s",
                    conn.getContentLength(), conn.getContentType(), conn.getContentEncoding()) );
            // 对输入流中的数据解码，得到位图对象
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            // 打印图片获取的应答状态码和位图大小
            Log.d(TAG,  String.format("应答状态码=%d, 位图大小=%s", conn.getResponseCode(), bitmap.getByteCount()) );
            conn.disconnect(); // 断开连接
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }
    // 对指定接口地址发起POST调用
    public static String post(String callUrl, String req, Map<String, String> headers) {
        String resp = ""; // 应答内容
        try {
            Log.d(TAG, "请求地址："+callUrl+", 请求报文="+req);
            compatibleSSL(callUrl); // 兼容https开头的调用地址
            URL url = new URL(callUrl); // 根据网址字符串构建URL对象
            // 打开URL对象的网络连接，并返回HttpURLConnection连接对象
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST"); // 设置请求方式
            setConnHeader(conn, headers);// 设置HTTP连接的头部信息
            conn.setRequestProperty("Content-Type", "application/json"); // 请求报文为json格式
            conn.setDoOutput(true); // 准备让连接执行输出操作。默认为false，POST方式需要设置为true
            //conn.setDoInput(true); // 准备让连接执行输入操作。默认为true
            conn.connect(); // 开始连接
            OutputStream os = conn.getOutputStream(); // 从连接对象中获取输出流
            os.write(req.getBytes()); // 往输出流写入请求报文
            // 打印HTTP调用的应答内容长度、内容类型、压缩方式
            Log.d(TAG,  String.format("应答内容长度=%s, 内容类型=%s, 压缩方式=%s",
                    conn.getHeaderField("Content-Length"), conn.getHeaderField("Content-Type"),
                    conn.getHeaderField("Content-Encoding")) );
            // 对输入流中的数据解压和字符编码，得到原始的应答字符串
            resp = getUnzipString(conn);
            // 打印HTTP调用的应答状态码和应答报文
            Log.d(TAG,  String.format("应答状态码=%d, 应答报文=%s", conn.getResponseCode(), resp) );
            conn.disconnect(); // 断开连接
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resp;
    }
    // 把文件上传给指定的URL
    public static String upload(String uploadUrl, String uploadFile, Map<String, String> headers)
    {
        String resp = ""; // 应答内容
        // 从本地文件路径获取文件名
        String fileName = uploadFile.substring(uploadFile.lastIndexOf("/"));
        String end = "\r\n"; // 结束字符串
        String hyphens = "--"; // 连接字符串
        String boundary = "WUm4580jbtwfJhNp7zi1djFEO3wNNm"; // 边界字符串
        try (FileInputStream fis = new FileInputStream(uploadFile)) {
            Log.d(TAG, "上传地址："+uploadUrl+", 上传文件="+uploadFile);
            compatibleSSL(uploadUrl); // 兼容https开头的调用地址
            URL url = new URL(uploadUrl); // 根据网址字符串构建URL对象
            // 打开URL对象的网络连接，并返回HttpURLConnection连接对象
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST"); // 设置请求方式
            setConnHeader(conn, headers);// 设置HTTP连接的头部信息
            conn.setDoOutput(true); // 准备让连接执行输出操作。默认为false，POST方式需要设置为true
            //conn.setDoInput(true); // 准备让连接执行输入操作。默认为true
            conn.setRequestProperty("Connection", "Keep-Alive"); // 连接过程要保持活跃
            // 请求报文要求分段传输，并且各段之间以边界字符串隔开
            conn.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary);
            // 根据连接对象的输出流构建数据输出流
            DataOutputStream ds = new DataOutputStream(conn.getOutputStream());
            // 以下写入请求报文的头部
            ds.writeBytes(hyphens + boundary + end);
            ds.writeBytes("Content-Disposition: form-data; "
                    + "name=\"file\";filename=\"" + fileName + "\"" + end);
            ds.writeBytes(end);
            // 以下写入请求报文的主体
            byte[] buffer = new byte[1024];
            int length;
            // 先将文件数据写入到缓冲区，再将缓冲数据写入输出流
            while ((length = fis.read(buffer)) != -1) {
                ds.write(buffer, 0, length);
            }
            ds.writeBytes(end);
            // 以下写入请求报文的尾部
            ds.writeBytes(hyphens + boundary + hyphens + end);
            ds.close(); // 关闭数据输出流
            // 打印HTTP调用的应答内容长度、内容类型、压缩方式
            Log.d(TAG,  String.format("应答内容长度=%s, 内容类型=%s, 压缩方式=%s",
                    conn.getHeaderField("Content-Length"), conn.getHeaderField("Content-Type"),
                    conn.getHeaderField("Content-Encoding")) );
            // 对输入流中的数据解压和字符编码，得到原始的应答字符串
            resp = getUnzipString(conn);
            // 打印HTTP上传的应答状态码和应答报文
            Log.d(TAG,  String.format("应答状态码=%d, 应答报文=%s", conn.getResponseCode(), resp) );
            conn.disconnect(); // 断开连接
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return resp;
    }
    // 设置HTTP连接的头部信息
    private static void setConnHeader(HttpURLConnection conn, Map<String, String> headers)
    {
        conn.setConnectTimeout(CONNECT_TIMEOUT); // 设置连接的超时时间，单位毫秒
        conn.setReadTimeout(READ_TIMEOUT); // 设置读取应答数据的超时时间，单位毫秒
        conn.setRequestProperty("Accept", "*/*"); // 设置数据格式
        conn.setRequestProperty("Accept-Language", "zh-CN"); // 设置文本语言
        conn.setRequestProperty("Accept-Encoding", "gzip, deflate"); // 设置编码格式
        // 设置用户代理，包括操作系统版本、浏览器版本等等
        conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:33.0) Gecko/20100101 Firefox/33.0");
        if (headers != null)
        {
            for (Map.Entry<String, String> item : headers.entrySet())
            {
                conn.setRequestProperty(item.getKey(), item.getValue());
            }
        }
    }
    // 把输入流中的数据按照指定字符编码转换为字符串。处理大量数据需要使用本方法
    private static String isToString(InputStream is, String charset)
    {
        String result = "";
        // 创建一个字节数组的输出流对象
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream())
        {
            int i = -1;
            while ((i = is.read()) != -1)   // 循环读取输入流中的字节数据
            {
                baos.write(i); // 把字节数据写入字节数组输出流
            }
            byte[] data = baos.toByteArray(); // 把字节数组输出流转换为字节数组
            result = new String(data, charset); // 将字节数组按照指定的字符编码生成字符串
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return result; // 返回转换后的字符串
    }
    // 从HTTP连接中获取已解压且重新编码后的应答报文
    private static String getUnzipString(HttpURLConnection conn) throws IOException
    {
        String contentType = conn.getContentType(); // 获取应答报文的内容类型(包括字符编码)
        String charset = "UTF-8"; // 默认的字符编码为UTF-8
        if (contentType != null)
        {
            if (contentType.toLowerCase().contains("charset=gbk"))   // 应答报文采用gbk编码
            {
                charset = "GBK"; // 字符编码改为GBK
            }
            else if (contentType.toLowerCase().contains("charset=gb2312"))  // 采用gb2312编码
            {
                charset = "GB2312"; // 字符编码改为GB2312
            }
        }
        String contentEncoding = conn.getContentEncoding(); // 获取应答报文的压缩方式
        InputStream is = conn.getInputStream(); // 获取HTTP连接的输入流对象
        String result = "";
        if (contentEncoding != null && contentEncoding.contains("gzip"))   // 应答报文使用gzip压缩
        {
            // 根据输入流对象构建压缩输入流
            try (GZIPInputStream gis = new GZIPInputStream(is))
            {
                // 把压缩输入流中的数据按照指定字符编码转换为字符串
                result = isToString(gis, charset);
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        else
        {
            // 把输入流中的数据按照指定字符编码转换为字符串
            result = isToString(is, charset);
        }
        return result; // 返回处理后的应答报文
    }
}