Android 使用HttpURLConnection调用Web

最近项目中遇到需要调用其他平台WebService接口，故记录下来。
本人使用的是HttpURLConnection 上传xml文件的方法上传，也有Soap框架可以使用，但针对这个平台的接口并未调通。
大概流程如下：
1.读取assets中的文件，讲读取到的流转为String,替换String中的参数；
2调用接口上传数据，处理返回的数据。

我对接的这个平台的上传报文如下，是对方后台提供的

<?xml version="1.0" encoding="utf-8"?>
<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:sgc="http://sgcscws.webservice.core.epm"><soapenv:Header/>
    <soapenv:Body><sgc:SgpmsGetData   soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
        <xmlStr xsi:type="xsd:string">
            <![CDATA[<ORDER>
   <servicecode>SET_DATAS_PRS</servicecode>
  <source>cq</source>
  <target>31102</target>
  <data>
    <USER_NO>ss</USER_NO>
    <DATAS_LIST>
        <DATA_NAME>userName</DATA_NAME>
    </DATAS_LIST>
  </data>
</ORDER>]]></xmlStr></sgc:SgpmsGetData></soapenv:Body></soapenv:Envelope>

其中 <servicecode>SET_DATAS_PRS</servicecode> 是这个接口的方法名，[<ORDER> </ORDER>] 中是所有的传参。

1首先是读取assets目录文件

 InputStream is=null;
        try {
            is =  getResources().getAssets().open("login.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
  String soap = WebServiceUtil.stream2String(is);
        // 替换我们调用方法的参数
        soap = soap.replaceAll("userName", tvUserName.getText().toString().trim() );

将流转为String的方法如下

public class WebServiceUtil {

    /**
     * 把流转换为String
     * @param is
     *            需要转换的流
     * @return 返回转化后的数据 返回null则代表是有异常
     *
     */
    public static String stream2String(InputStream is) {
        String result = null;
        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            // 转化流
            byte[] buffer = new byte[1024];
            int len = -1;
            while ((len = is.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            // 转换为字符串
            result = baos.toString();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    is = null;
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    baos = null;
                }
            }
        }
        return result;
    }

//InputStream  转 String
    public static String readInputStream(InputStream is){
        try {
            ByteArrayOutputStream baos=new ByteArrayOutputStream();
            int length=0;
            byte[] buffer=new byte[1024];
            while((length=is.read(buffer))!=-1){
                baos.write(buffer, 0, length);
            }
            is.close();
            baos.close();
            //或者用这种方法
            //byte[] result=baos.toByteArray();
            //return new String(result);
            return baos.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return "获取失败";
        }
    }

  }

2调用接口 处理数据

 // 把需要传输的数据转换为字节数组
        byte[] datas = soap.getBytes();

        try {
            // 获取连接
            HttpURLConnection conn = (HttpURLConnection) new URL(path)
                    .openConnection();
            // 设置超时时间
            conn.setConnectTimeout(4000);
            // 设置请求方式
            conn.setRequestMethod("POST");
            // 允许发送数据
            conn.setDoOutput(true);
            conn.setRequestProperty("SOAPAction", path);
            // 设置请求头信息--不是固定的，有wenxml网站提供的
            conn.setRequestProperty("Content-Type", "text/xml; charset=utf-8");
            conn.setRequestProperty("Content-Length", String.valueOf(datas.length));

            conn.getOutputStream().write(datas);
            conn.getOutputStream().flush();
            conn.getOutputStream().close();
            conn.connect();
            Log.e("-----", "==响应码======" + conn.getResponseCode());
            if (conn.getResponseCode() == 200) {
                // 访问网络成功--获取返回的流数据
                InputStream resultIs = conn.getInputStream();
                // 我们知道这个流数据里面就是一个xml文件，我们解析xml文档
                String    resultString = WebServiceUtil.readInputStream(resultIs);
                Log.e("-----", "==响应码======" + resultString );
                //解析resultString 

            }

        } catch (Exception exception) {
            exception.printStackTrace();
         
        }

这里需要注意的地方是 conn.setRequestProperty("SOAPAction", path);
一定要设置SOAPAction， 目前发现SOAPAction 就是你访问的path，

最终封装成HttpUtils方便调用

public class HttpUtils {

    //线程池
    private static ExecutorService executor;
    private static Handler mHandler;

    static {
        executor = Executors.newFixedThreadPool(5);
        mHandler = new Handler();
    }

    public interface Callback {
        void onFaileure(int code, Exception e);
    }
    public interface StringCallback extends Callback {
        void onSuccess(String result);
    }

    /**
     * 执行网络请求操作,返回数据会解析成字符串String
     * @param url    请求的url
     * @param params 请求的参数
     */
    public static String doHttpReqeust( final String url,
                                       final String params, final StringCallback callback) {

       final byte[] datas = params.getBytes();

        executor.execute(new Runnable() {
            @Override
            public void run() {
                HttpURLConnection connection = null;
                OutputStream outputStream = null;
                try {
                    URL u = new URL(url);
                    connection = (HttpURLConnection) u.openConnection();

                    connection.setRequestProperty("SOAPAction", url);
                    // 设置输入可用
                    connection.setDoInput(true);
                    // 设置输出可用
                    connection.setDoOutput(true);
                    // 设置请求方式
                    connection.setRequestMethod("POST");
                    // 设置连接超时 建立连接的超时时间
                    connection.setConnectTimeout(5000);
                    // 设置读取超时 传递数据的超时时间
                    connection.setReadTimeout(30000);
                    // 设置缓存不可用
                    connection.setUseCaches(false);
                    // 设置请求头信息--不是固定的，有wenxml网站提供的
                    connection.setRequestProperty("Content-Type", "text/xml; charset=utf-8");
                    connection.setRequestProperty("Content-Length", String.valueOf(datas.length));

                    // 开始连接
                    connection.connect();
                    connection.getOutputStream().write(datas);
                    connection.getOutputStream().flush();
                    // 只有当POST请求时才会执行此代码段
                /*    if (params != null) {
                        // 获取输出流,connection.getOutputStream已经包含了connect方法的调用
                        outputStream = connection.getOutputStream();
                        StringBuilder sb = new StringBuilder();
                        Set<Map.Entry<String, String>> sets = params.entrySet();
                        // 将Hashmap转换为string
                        for (Map.Entry<String, String> entry : sets) {
                            sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
                        }
                        String param = sb.substring(0, sb.length() - 1);
                        // 使用输出流将string类型的参数写到服务器
                        outputStream.write(param.getBytes());
                        outputStream.flush();
                    }
*/
                    int responseCode = connection.getResponseCode();
                    if (responseCode == 200) {
                        InputStream inputStream = connection.getInputStream();
                        String result = inputStream2String(inputStream);

                        //截取有用的数据
                        String data=result.split("<apkServiceReturn>")[1];
                        data=data.split("</apkServiceReturn>")[0];

                        if (data != null && callback != null) {
//                            xml 转为 json
//                            postSuccessString(callback, XmlJsonTool.documentToJSONObject(data).toJSONString());

                            // FastJson解析  根据自己的格式解析  1、 十进制Unicode转中文
                            JSONArray jsonArray =JSONArray.parseArray(StringEscapeUtils.unescapeHtml3(data));
                            Log.e("CallBack", ""+StringEscapeUtils.unescapeHtml3(data) );
                            if(jsonArray!=null){
                                  //取 JSONArray 第一个；
                                postSuccessString(callback,  jsonArray.get(0).toString());
                            }
                        }else {
                            postFailed(callback, responseCode, new Exception("请求数据失败：" + responseCode));
                        }

                    } else {
                        if (callback != null) {
                            postFailed(callback, responseCode, new Exception("请求数据失败：" + responseCode));
                        }
                    }

                } catch ( Exception e) {
                    e.printStackTrace();
                    if (callback != null) {
                        postFailed(callback, 0, e);
                    }
                    Log.e("CallBack_Exception", "run: "+e.getMessage() );

                } finally {
                    if (connection != null) {
                        connection.disconnect();
                    }
                    if (outputStream != null) {
                        try {
                            outputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
        return null;
    }


    private static void postSuccessString(final StringCallback callback, final String result) {
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                callback.onSuccess(result);
            }
        },400);
    }

    private static void postFailed(final Callback callback, final int code, final Exception e) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                callback.onFaileure(code, e);
            }
        });
    }

    /**
     * 字节流转换成字符串
     *
     * @param inputStream
     * @return
     */
    private static String inputStream2String(InputStream inputStream) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] bytes = new byte[1024];
        int len = 0;
        try {
            while ((len = inputStream.read(bytes)) != -1) {
                baos.write(bytes, 0, len);
            }
            return new String(baos.toByteArray());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}

调用方式如下

  InputStream is=null;
        try {
            is =  context.getResources().getAssets().open("set_datas_prs.xml");
        } catch (IOException e) {
            e.printStackTrace();
            Log.e("----", "result "+ e.getMessage());
        }
        // 调用工具类中的方法，把流转换为String
        String params = WebServiceUtil.stream2String(is);
        // 替换我们调用方法的参数
        params = params.replaceAll("APP_NO_placeholder", app_no );
        params = params.replaceAll("CONS_NO_placeholder", todolistBean.getCONS_NO() );
        params = params.replaceAll("USER_NO_placeholder",   
        params = params.replaceAll("FILE_NAME_placeholder", app_no+"log.zip" );

       HttpUtils.doHttpReqeust(BaseUrl.GetBaseUrl, params, new HttpUtils.StringCallback() {
            @Override
            public void onSuccess(String result) {
                Log.e("----", "onSuccess: "+result );
                ResultBean resultBean = JSON.parseObject(result, ResultBean.class);

                if(resultBean!=null && resultBean.getRESULT()!=null && resultBean.getRESULT().equals(Constant.SUCCESS)){

                    // 上传文件成功 保存文件路径 继续上传工单
                    saveFileUrl(resultBean);

                }else if (resultBean!=null && resultBean.getRESULT()!=null && resultBean.getRESULT().equals("0")){

                    ToastUtil.showShortToast(resultBean.getERRORMSG()+"上传文件异常");
               
                }else {

                    ToastUtil.showShortToast("上传文件异常");
                   
                }
            }

            @Override
            public void onFaileure(int code, Exception e) {
                Log.e("----", "onFaile: "+e.getMessage() );
                ToastUtil.showShortToast(e.getMessage());
         
            }
        });