Android Http请求

悠悠 2022-06-17 12:28 247阅读 0赞

Android HTTP请求封装代码

复制代码

  1. /**
  2.  * This class is the Utils of other classes.
  3.  */
  4. public class HttpUtil {
  5.     /** 变量/常量说明 */
  6.     private static final String TAG              = "HttpUtils";
  7.     /** 超时时间 */
  8.     private static int          mTimeOut         = 20000;
  9.     /** 私钥密码 */
  10.     /** 使用协议 */
  11.     private static final String CLIENT_AGREEMENT = "TLS";
  12.     /** 密钥管理器 */
  13.     /** 变量/常量说明 */
  14.     private static HttpUtil     mHttpUtils       = null;
  16.     /**
  17.      * 获取HPPS对象实例
  18.      * 
  19.      * @param application
  20.      * @return
  21.      * @since V1.0
  22.      */
  23.     public static HttpUtil getInstace(Context context) {
  24.         if (mHttpUtils == null) {
  25.             mHttpUtils = new HttpUtil(context);
  26.         }
  27.         return mHttpUtils;
  28.     }
  30.     /**
  31.      * @param application
  32.      */
  33.     private HttpUtil(Context context) {
  34.     }
  36.     /**
  37.      * 这里对方法做描述
  38.      * 
  39.      * @param servAddr
  40.      * @param xmlBody
  41.      * @return
  42.      * @throws HttpException
  43.      * @since V1.0
  44.      */
  45.     public String httpGetRequest(String servAddr) throws HttpException {
  46.         // create connection
  47.         String response = null;
  48.         HttpURLConnection conn = null;
  49.         boolean ret = false;
  50.         InputStream in = null;
  52.         try {
  53.             URL url = new URL(servAddr);
  54.             conn = (HttpURLConnection) url.openConnection();
  55.             conn.setConnectTimeout(mTimeOut);
  56.             conn.setReadTimeout(mTimeOut);
  57.             conn.setDoInput(true);
  58.             conn.setRequestMethod("GET");
  59.             conn.setRequestProperty("Content-type", "text/xml; charset=utf-8");
  61.             if (conn.getResponseCode() == 200) {
  62.                 // getCookie(conn);
  63.                 in = new BufferedInputStream(conn.getInputStream());
  64.             } else {
  65.                 in = new BufferedInputStream(conn.getErrorStream());
  66.             }
  68.             response = inputStream2String(in);
  70.             in.close();
  71.             in = null;
  72.             ret = true;
  73.         } catch (MalformedURLException e) {
  74.             ret = false;
  75.             e.printStackTrace();
  76.         } catch (ProtocolException e) {
  77.             ret = false;
  78.             e.printStackTrace();
  79.         } catch (IOException e) {
  80.             ret = false;
  81.             e.printStackTrace();
  82.         } finally {
  83.             if (in != null) {
  84.                 try {
  85.                     in.close();
  86.                 } catch (IOException e) {
  87.                     // TODO Auto-generated catch block
  88.                     e.printStackTrace();
  89.                 }
  90.                 in = null;
  91.             }
  92.             if (conn != null) {
  93.                 // 断开连接
  94.                 conn.disconnect();
  95.                 conn = null;
  96.             }
  97.         }
  99.         // 抛出异常
  100.         if (!ret) {
  101.             throw new HttpException("network exception", HttpException.HTTP_NETWORD_EXCEPTION);
  102.         }
  104.         return response;
  105.     }
  107.     /**
  108.      * 这里对方法做描述
  109.      * 
  110.      * @return
  111.      * @throws InvalidFormatException
  112.      * @see
  113.      * @since V1.0
  114.      */
  115.     public static String httpPostRequest(String path) {
  116.         // create connection
  117.         String response = null;
  118.         HttpURLConnection conn = null;
  119.         try {
  120.             URL url = new URL(path);
  121.             conn = (HttpURLConnection) url.openConnection();
  122.             conn.setConnectTimeout(mTimeOut);
  123.             conn.setDoInput(true);
  124.             conn.setDoOutput(true);
  125.             conn.setRequestMethod("POST");
  126.             conn.setRequestProperty("Content-type", "text/xml; charset=utf-8");
  128.             InputStream in = new BufferedInputStream(conn.getInputStream());
  129.             response = inputStream2String(in);
  130.         } catch (MalformedURLException e) {
  131.             e.printStackTrace();
  132.         } catch (ProtocolException e) {
  133.             e.printStackTrace();
  134.         } catch (IOException e) {
  135.             e.printStackTrace();
  136.         } catch (Exception e) {
  137.             e.printStackTrace();
  138.         } finally {
  139.             if (conn != null) {
  140.                 // 断开连接
  141.                 conn.disconnect();
  142.                 conn = null;
  143.             }
  144.         }
  146.         return response;
  147.     }
  149.     /**
  150.      * httpPost方式
  151.      * 
  152.      * @param servAddr
  153.      * @param xmlBody
  154.      * @return
  155.      * @throws HttpException
  156.      * @since V1.0
  157.      */
  158.     public String httpPostRequest(String servAddr, String xmlBody) throws HttpException {
  159.         // create connection
  160.         String response = null;
  161.         HttpURLConnection conn = null;
  162.         boolean ret = false;
  163.         InputStream in = null;
  164.         DataOutputStream os = null;
  165.         try {
  166.             URL url = new URL(servAddr);
  167.             conn = (HttpURLConnection) url.openConnection();
  168.             conn.setConnectTimeout(mTimeOut);
  169.             conn.setReadTimeout(mTimeOut);
  170.             conn.setDoInput(true);
  171.             conn.setDoOutput(true);
  172.             conn.setRequestMethod("POST");
  173.             conn.setRequestProperty("Content-type", "text/xml; charset=utf-8");
  175.             // send xml contant to server
  176.             os = new DataOutputStream(conn.getOutputStream());
  177.             os.write(xmlBody.getBytes(), 0, xmlBody.getBytes().length);
  178.             os.flush();
  179.             os.close();
  180.             os = null;
  181.             if (conn.getResponseCode() == 200) {
  182.                 // getCookie(conn);
  183.                 in = new BufferedInputStream(conn.getInputStream());
  184.             } else {
  185.                 in = new BufferedInputStream(conn.getErrorStream());
  186.             }
  188.             response = inputStream2String(in);
  190.             in.close();
  191.             in = null;
  192.             ret = true;
  193.         } catch (MalformedURLException e) {
  194.             ret = false;
  195.             e.printStackTrace();
  196.         } catch (ProtocolException e) {
  197.             ret = false;
  198.             e.printStackTrace();
  199.         } catch (IOException e) {
  200.             ret = false;
  201.             e.printStackTrace();
  202.         } finally {
  204.             try {
  205.                 if (in != null) {
  206.                     in.close();
  207.                 }
  208.                 if (os != null) {
  209.                     os.close();
  210.                 }
  211.             } catch (IOException e) {
  212.                 e.printStackTrace();
  213.             }
  214.             in = null;
  216.             if (conn != null) {
  217.                 // 断开连接
  218.                 conn.disconnect();
  219.                 conn = null;
  220.             }
  221.         }
  223.         // 抛出异常
  224.         if (!ret) {
  225.             throw new HttpException("network exception", HttpException.HTTP_NETWORD_EXCEPTION);
  226.         }
  228.         return response;
  229.     }
  231.     /**
  232.      * 这里对方法做描述
  233.      * 
  234.      * @return
  235.      * @throws HttpException
  236.      * @see
  237.      * @since V1.0
  238.      */
  239.     public String httpsGetRequest(String servHttpsAddr) {
  240.         if (servHttpsAddr == null || servHttpsAddr.equals("")) {
  241.             CLog.d(TAG, "sslGetRequest servHttpsAddr == null");
  242.             return "";
  243.         }
  245.         boolean bRet = verifyHttpsUrl(servHttpsAddr);
  246.         if (!bRet) {
  247.             CLog.d(TAG, "sslGetRequest verifyHttpsUrl fail");
  248.             return "";
  249.         }
  251.         String response = "";
  252.         try {
  253.             response = getSslRequest(servHttpsAddr);
  254.         } catch (HttpException e) {
  255.             e.printStackTrace();
  256.             CLog.d(TAG, "sslGetRequest verifyHttpsUrl fail");
  257.             return "";
  258.         }
  260.         return response;
  261.     }
  263.     /**
  264.      * httpsPost方式发送
  265.      * 
  266.      * @return
  267.      * @throws HttpException
  268.      * @see
  269.      * @since V1.0
  270.      */
  271.     public String httpsPostRequest(String servHttpsAddr, String xmlBody) {
  272.         if (servHttpsAddr == null || servHttpsAddr.equals("")) {
  273.             CLog.d(TAG, "postHttpsRequest servHttpsAddr == null");
  274.             return "";
  275.         }
  277.         if (xmlBody == null || xmlBody.equals("")) {
  278.             CLog.d(TAG, "postHttpsRequest xmlBody == null");
  279.             return "";
  280.         }
  282.         boolean bRet = verifyHttpsUrl(servHttpsAddr);
  283.         if (!bRet) {
  284.             CLog.d(TAG, "postHttpsRequest verifyHttpsUrl fail");
  285.             return "";
  286.         }
  288.         String response = "";
  289.         try {
  290.             response = postSslRequest(servHttpsAddr, xmlBody);
  291.         } catch (HttpException e) {
  292.             e.printStackTrace();
  293.             CLog.d(TAG, "postHttpsRequest postSslRequest fail");
  294.             return "";
  295.         }
  297.         return response;
  298.     }
  300.     /**
  301.      * 把输入流转化成string
  302.      * 
  303.      * @param is
  304.      * @return
  305.      * @see
  306.      * @since V1.0
  307.      */
  308.     private static String inputStream2String(InputStream is) {
  309.         InputStreamReader inputStreamReader = new InputStreamReader(is);
  310.         BufferedReader in = new BufferedReader(inputStreamReader);
  311.         StringBuffer buffer = new StringBuffer();
  312.         String line = "";
  313.         try {
  314.             while ((line = in.readLine()) != null) {
  315.                 buffer.append(line);
  316.             }
  317.         } catch (IOException e) {
  318.             e.printStackTrace();
  319.         } finally {
  321.             try {
  322.                 if (inputStreamReader != null) {
  323.                     inputStreamReader.close();
  324.                 }
  325.                 inputStreamReader = null;
  326.                 if (in != null) {
  327.                     in.close();
  328.                 }
  329.                 in = null;
  330.             } catch (IOException e) {
  331.                 e.printStackTrace();
  332.             }
  334.         }
  335.         return buffer.toString();
  336.     }
  338.     /**
  339.      * 这里对方法做描述
  340.      * 
  341.      * @param servHttpsAddr
  342.      * @param xmlBody
  343.      * @return
  344.      * @throws HttpException
  345.      * @since V1.0
  346.      */
  347.     private String getSslRequest(String servHttpsAddr) throws HttpException {
  348.         // create connection
  349.         String response = null;
  350.         HttpURLConnection conn = null;
  351.         boolean ret = false;
  352.         InputStream in = null;
  353.         try {
  354.             URL url = new URL(servHttpsAddr);
  355.             trustAllHosts();
  356.             conn = (HttpsURLConnection) url.openConnection();
  357.             ((HttpsURLConnection) conn).setHostnameVerifier(DO_NOT_VERIFY);// 不进行主机名确认
  359.             // ((HttpsURLConnection)
  360.             // conn).setSSLSocketFactory(getPushSSLSocketFactory());
  362.             conn.setConnectTimeout(mTimeOut);
  363.             conn.setReadTimeout(mTimeOut);
  364.             conn.setDoInput(true);
  365.             conn.setRequestMethod("GET");
  366.             conn.setRequestProperty("Content-type", "text/xml; charset=utf-8");
  368.             if (conn.getResponseCode() == 200) {
  369.                 // getCookie(conn);
  370.                 in = new BufferedInputStream(conn.getInputStream());
  371.             } else {
  372.                 in = new BufferedInputStream(conn.getErrorStream());
  373.             }
  375.             response = inputStream2String(in);
  377.             in.close();
  378.             in = null;
  379.             ret = true;
  380.         } catch (MalformedURLException e) {
  381.             ret = false;
  382.             e.printStackTrace();
  383.         } catch (ProtocolException e) {
  384.             ret = false;
  385.             e.printStackTrace();
  386.         } catch (IOException e) {
  387.             ret = false;
  388.             e.printStackTrace();
  389.         }
  390.         // catch (NoSuchAlgorithmException e) {
  391.         // ret = false;
  392.         // e.printStackTrace();
  393.         // } catch (KeyManagementException e) {
  394.         // ret = false;
  395.         // e.printStackTrace();
  396.         // } catch (KeyStoreException e) {
  397.         // ret = false;
  398.         // e.printStackTrace();
  399.         // } catch (CertificateException e) {
  400.         // ret = false;
  401.         // e.printStackTrace();
  402.         // } catch (UnrecoverableKeyException e) {
  403.         // ret = false;
  404.         // e.printStackTrace();
  405.         // }
  406.         finally {
  407.             if (in != null) {
  408.                 try {
  409.                     in.close();
  410.                 } catch (IOException e) {
  411.                     // TODO Auto-generated catch block
  412.                     e.printStackTrace();
  413.                 }
  414.                 in = null;
  415.             }
  416.             if (conn != null) {
  417.                 // 断开连接
  418.                 conn.disconnect();
  419.                 conn = null;
  420.             }
  421.         }
  423.         // 抛出异常
  424.         if (!ret) {
  425.             throw new HttpException("network exception", HttpException.HTTP_NETWORD_EXCEPTION);
  426.         }
  428.         return response;
  429.     }
  431.     /**
  432.      * 验证https地址
  433.      * 
  434.      * @since V1.0
  435.      */
  436.     public boolean verifyHttpsUrl(String httpsAddr) {
  437.         // TODO Auto-generated method stub
  438.         if (httpsAddr == null || httpsAddr.equals("")) {
  439.             CLog.e(TAG, "verifyHttpsUrl httpsAddr == null");
  440.             return false;
  441.         }
  443.         URL httpsUurl;
  444.         try {
  445.             httpsUurl = new URL(httpsAddr);
  446.         } catch (MalformedURLException e) {
  447.             // TODO Auto-generated catch block
  448.             e.printStackTrace();
  449.             CLog.e(TAG, "verifyHttpsUrl httpsAddr not url, error url:" + httpsAddr);
  450.             return false;
  451.         }
  453.         if (!httpsUurl.getProtocol().equalsIgnoreCase("https")) {
  454.             CLog.e(TAG, "verifyHttpsUrl httpsAddr not https, error url:" + httpsAddr);
  455.             return false;
  456.         }
  458.         return true;
  459.     }
  461.     /**
  462.      * post ssl请求
  463.      * 
  464.      * @param servHttpsAddr
  465.      * @param xmlBody
  466.      * @return
  467.      * @throws HttpException
  468.      * @since V1.0
  469.      */
  470.     private String postSslRequest(String servHttpsAddr, String xmlBody) throws HttpException {
  471.         // 回复信令
  472.         String response = null;
  473.         //
  474.         boolean ret = false;
  475.         // 输入流
  476.         InputStream in = null;
  477.         DataOutputStream os = null;
  478.         HttpsURLConnection httpsConn = null;
  479.         InputStream inputStream = null;
  480.         try {
  481.             URL url = new URL(servHttpsAddr);
  483.             // solution: javax.net.ssl.SSLException: Not trusted server
  484.             // certificate
  485.             trustAllHosts();
  487.             // 打开连接
  488.             httpsConn = (HttpsURLConnection) url.openConnection();
  489.             // 不进行主机名确认
  490.             httpsConn.setHostnameVerifier(DO_NOT_VERIFY);
  491.             httpsConn.setConnectTimeout(mTimeOut);
  492.             httpsConn.setReadTimeout(mTimeOut);
  493.             httpsConn.setDoInput(true);
  494.             httpsConn.setDoOutput(true);
  495.             httpsConn.setRequestMethod("POST");
  496.             httpsConn.setRequestProperty("Content-type","text/xml; charset=utf-8");
  498.             // send xml contant to server
  499.             os = new DataOutputStream(httpsConn.getOutputStream());
  500.             os.write(xmlBody.getBytes(), 0, xmlBody.getBytes().length);
  501.             os.flush();
  502.             os.close();
  503.             os = null;
  505.             if (httpsConn.getResponseCode() == 200) {
  506.                 // getCookie(conn);
  507.                 inputStream = httpsConn.getInputStream();
  508.                 in = new BufferedInputStream(inputStream);
  509.             } else {
  510.                 inputStream = httpsConn.getErrorStream();
  511.                 in = new BufferedInputStream(inputStream);
  512.             }
  514.             response = inputStream2String(in);
  515.             if (inputStream != null) {
  516.                 inputStream.close();
  517.                 inputStream = null;
  518.             }
  520.             in.close();
  521.             in = null;
  522.             ret = true;
  523.         } catch (MalformedURLException e) {
  524.             ret = false;
  525.             e.printStackTrace();
  526.         } catch (ProtocolException e) {
  527.             ret = false;
  528.             e.printStackTrace();
  529.         } catch (IOException e) {
  530.             ret = false;
  531.             e.printStackTrace();
  532.         } finally {
  534.             try {
  535.                 if (inputStream != null) {
  536.                     inputStream.close();
  537.                 }
  538.                 if (in != null) {
  539.                     in.close();
  540.                 }
  541.                 in = null;
  542.                 if (os != null) {
  543.                     os.close();
  544.                 }
  546.             } catch (IOException e) {
  547.                 e.printStackTrace();
  548.             }
  550.             if (httpsConn != null) {
  551.                 // 断开连接
  552.                 httpsConn.disconnect();
  553.                 httpsConn = null;
  554.             }
  555.         }
  557.         // 抛出异常
  558.         if (!ret) {
  559.             throw new HttpException("network exception", HttpException.HTTP_NETWORD_EXCEPTION);
  560.         }
  562.         return response;
  563.     }
  565.     /** always verify the host - dont check for certificate */
  566.     final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
  567.                                                     public boolean verify(String hostname, SSLSession session) {
  568.                                                         return true;
  569.                                                     }
  570.                                                 };
  572.     /**
  573.      * Trust every server - dont check for any certificate
  574.      * 
  575.      * @since V1.0
  576.      */
  577.     private static void trustAllHosts() {
  578.         // Create a trust manager that does not validate certificate chains
  579.         TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
  580.             public java.security.cert.X509Certificate[] getAcceptedIssuers() {
  581.                 return new java.security.cert.X509Certificate[] {};
  582.             }
  584.             public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
  585.             }
  587.             public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
  588.             }
  589.         } };
  591.         // Install the all-trusting trust manager
  592.         try {
  593.             SSLContext sc = SSLContext.getInstance(CLIENT_AGREEMENT);
  594.             sc.init(null, trustAllCerts, new java.security.SecureRandom());
  595.             HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  596.         } catch (Exception e) {
  597.             e.printStackTrace();
  598.         }
  599.     }
  601.     /**
  602.      * 在此对类做相应的描述 */
  603.     public static class _FakeX509TrustManager implements X509TrustManager {
  605.         /** 变量/常量说明 */
  606.         private static TrustManager[]          trustManagers;
  607.         /** 变量/常量说明 */
  608.         private static final X509Certificate[] _AcceptedIssuers = new X509Certificate[] {};
  610.         @Override
  611.         public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
  612.         }
  614.         @Override
  615.         public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
  616.         }
  618.         /**
  619.          * 这里对方法做描述
  620.          * 
  621.          * @param chain
  622.          * @return
  623.          * @since V1.0
  624.          */
  625.         public boolean isClientTrusted(X509Certificate[] chain) {
  626.             return true;
  627.         }
  629.         /**
  630.          * 这里对方法做描述
  631.          * 
  632.          * @param chain
  633.          * @return
  634.          * @since V1.0
  635.          */
  636.         public boolean isServerTrusted(X509Certificate[] chain) {
  637.             return true;
  638.         }
  640.         /*
  641.          * (non-Javadoc)
  642.          * @see javax.net.ssl.X509TrustManager#getAcceptedIssuers()
  643.          */
  644.         @Override
  645.         public X509Certificate[] getAcceptedIssuers() {
  646.             return _AcceptedIssuers;
  647.         }
  649.         /**
  650.          * 这里对方法做描述
  651.          * 
  652.          * @since V1.0
  653.          */
  654.         public static void allowAllSSL() {
  655.             HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
  656.                 @Override
  657.                 public boolean verify(String hostname, SSLSession session) {
  658.                     return true;
  659.                 }
  661.             });
  663.             SSLContext context = null;
  664.             if (trustManagers == null) {
  665.                 trustManagers = new TrustManager[] { new _FakeX509TrustManager() };
  666.             }
  668.             try {
  669.                 context = SSLContext.getInstance(CLIENT_AGREEMENT);
  670.                 if (context == null) {
  671.                     return;
  672.                 }
  673.                 context.init(null, trustManagers, new SecureRandom());
  674.                 SSLSocketFactory defaultSSLSocketFactory = context.getSocketFactory();
  675.                 if (defaultSSLSocketFactory != null) {
  676.                     HttpsURLConnection.setDefaultSSLSocketFactory(defaultSSLSocketFactory);
  677.                 }
  678.             } catch (NoSuchAlgorithmException e) {
  679.                 e.printStackTrace();
  680.             } catch (KeyManagementException e) {
  681.                 e.printStackTrace();
  682.             }
  684.         }
  685.     }
  686. }

复制代码

发表评论

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

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

相关阅读

    相关 android 发送http请求

    好久没写博客了，因为公司要做android，笔者也是第一次接触。 这是在项目中遇到一个比较麻烦的问题，记录下来备忘（本人刚接触，有不对的地方请指教）。 发送请求的

    青旅半醒青旅半醒/ 0 赞/ 275 阅读