HTTP POST接口 发送数据工具类

废话不多说了  直接贴图，贴代码。

希望能帮助给位。。。。。。

以下是我们需要准备的jar包：

下面就是通过HTTP POST接口 发送报文的工具类：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

public class HttpUtil {
    
    private static Logger logger = Logger.getLogger(HttpUtil.class);
    private static String METHOD = "POST";
    private static int TIMEOUT = 30000;
    private static final String ENCODE = "UTF-8";
        
        /**
         * 发送HTTP_GET请求
         * @see 该方法会自动关闭连接,释放资源
         * @param requestURL    请求地址(含参数)
         * @param decodeCharset 解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
         * @return 远程主机响应正文
         */
        public static String sendGetRequest(String reqURL, String decodeCharset){
            long responseLength = 0;       //响应长度
            String responseContent = null; //响应内容
            HttpClient httpClient = new DefaultHttpClient(); //创建默认的httpClient实例
            httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, TIMEOUT);
            httpClient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, TIMEOUT);
            HttpGet httpGet = new HttpGet(reqURL);           //创建org.apache.http.client.methods.HttpGet
            try{
                HttpResponse response = httpClient.execute(httpGet); //执行GET请求
                HttpEntity entity = response.getEntity();            //获取响应实体
                if(null != entity){
                    responseLength = entity.getContentLength();
                    responseContent = EntityUtils.toString(entity, decodeCharset==null ? "UTF-8" : decodeCharset);
                    EntityUtils.consume(entity); //Consume response content
                }
            }catch(ClientProtocolException e){
                logger.error("该异常通常是协议错误导致,比如构造HttpGet对象时传入的协议不对(将'http'写成'htp')或者服务器端返回的内容不符合HTTP协议要求等,堆栈信息如下", e);
            }catch(ParseException e){
                logger.error(e.getMessage(), e);
            }catch(IOException e){
                logger.error("该异常通常是网络原因引起的,如HTTP服务器未启动等,堆栈信息如下", e);
            }finally{
                httpClient.getConnectionManager().shutdown(); //关闭连接,释放资源
            }
            return responseContent;
        }
        
        
        /**
         * 发送HTTP_POST请求
         * @see 该方法为sendPostRequest(String,String,boolean,String,String)的简化方法
         * @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
         * @see 当isEncoder=true时,其会自动对sendData中的[中文][|][ ]等特殊字符进行URLEncoder.encode(string,"UTF-8")
         * @param isEncoder 用于指明请求数据是否需要UTF-8编码,true为需要
         */
        public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder){
            return sendPostRequest(reqURL, sendData, isEncoder, null, null);
        }
        
        
        /**
         * 发送HTTP_POST请求
         * @see 该方法会自动关闭连接,释放资源
         * @see 当isEncoder=true时,其会自动对sendData中的[中文][|][ ]等特殊字符进行URLEncoder.encode(string,encodeCharset)
         * @param reqURL        请求地址
         * @param sendData      请求参数,若有多个参数则应拼接成param11=value11¶m22=value22¶m33=value33的形式后,传入该参数中
         * @param isEncoder     请求数据是否需要encodeCharset编码,true为需要
         * @param encodeCharset 编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
         * @param decodeCharset 解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
         * @return 远程主机响应正文
         */
        public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder, String encodeCharset, String decodeCharset){
            String responseContent = null;
            HttpClient httpClient = new DefaultHttpClient();
            httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, TIMEOUT);
            httpClient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, TIMEOUT);
            HttpPost httpPost = new HttpPost(reqURL);
            //httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded; charset=UTF-8");
            httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");
            try{
                if(isEncoder){
                    List formParams = new ArrayList();
                    for(String str : sendData.split("&")){
                        formParams.add(new BasicNameValuePair(str.substring(0,str.indexOf("=")), str.substring(str.indexOf("=")+1)));
                    }
                    httpPost.setEntity(new StringEntity(URLEncodedUtils.format(formParams, encodeCharset==null ? "UTF-8" : encodeCharset)));
                }else{
                    httpPost.setEntity(new StringEntity(sendData));
                }
                
                HttpResponse response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    responseContent = EntityUtils.toString(entity, decodeCharset==null ? "UTF-8" : decodeCharset);
                    EntityUtils.consume(entity);
                }
            }catch(Exception e){
                logger.error("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下", e);
            }finally{
                httpClient.getConnectionManager().shutdown();
            }
            return responseContent;
        }
        
        
        /**
         * 发送HTTP_POST请求
         * @see 该方法会自动关闭连接,释放资源
         * @see 该方法会自动对params中的[中文][|][ ]等特殊字符进行URLEncoder.encode(string,encodeCharset)
         * @param reqURL        请求地址
         * @param params        请求参数
         * @param encodeCharset 编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
         * @param decodeCharset 解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
         * @return 远程主机响应正文
         */
        public static String sendPostRequest(String reqURL, Map params, String encodeCharset, String decodeCharset){
            String responseContent = null;
            HttpClient httpClient = new DefaultHttpClient();
            httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, TIMEOUT);
            httpClient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, TIMEOUT);
            HttpPost httpPost = new HttpPost(reqURL);
            List formParams = new ArrayList(); //创建参数队列
            for(Map.Entry entry : params.entrySet()){
                formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            try{
                httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset==null ? "UTF-8" : encodeCharset));
                
                HttpResponse response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    responseContent = EntityUtils.toString(entity, decodeCharset==null ? "UTF-8" : decodeCharset);
                    EntityUtils.consume(entity);
                }
            }catch(Exception e){
                logger.error("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下", e);
            }finally{
                httpClient.getConnectionManager().shutdown();
            }
            return responseContent;
        }
        
        
        /**
         * 发送HTTPS_POST请求
         * @see 该方法为sendPostSSLRequest(String,Map,String,String)方法的简化方法
         * @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
         * @see 该方法会自动对params中的[中文][|][ ]等特殊字符进行URLEncoder.encode(string,"UTF-8")
         */
        public static String sendPostSSLRequest(String reqURL, Map params){
            return sendPostSSLRequest(reqURL, params, null, null);
        }
        
        
        /**
         * 发送HTTPS_POST请求
         * @see 该方法会自动关闭连接,释放资源
         * @see 该方法会自动对params中的[中文][|][ ]等特殊字符进行URLEncoder.encode(string,encodeCharset)
         * @param reqURL        请求地址
         * @param params        请求参数
         * @param encodeCharset 编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
         * @param decodeCharset 解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
         * @return 远程主机响应正文
         */
        public static String sendPostSSLRequest(String reqURL, Map params, String encodeCharset, String decodeCharset){
            String responseContent = "";
            HttpClient httpClient = new DefaultHttpClient();
            httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, TIMEOUT);
            httpClient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, TIMEOUT);
            X509TrustManager xtm = new X509TrustManager(){
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {}
                public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {}
                public X509Certificate[] getAcceptedIssuers() {return null;}
            };
            try {
                SSLContext ctx = SSLContext.getInstance("TLS");
                ctx.init(null, new TrustManager[]{xtm}, null);
                SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
                httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", socketFactory, 443));
                
                HttpPost httpPost = new HttpPost(reqURL);
                List formParams = new ArrayList();
                for(Map.Entry entry : params.entrySet()){
                    formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
                }
                httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset==null ? "UTF-8" : encodeCharset));
                
                HttpResponse response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    responseContent = EntityUtils.toString(entity, decodeCharset==null ? "UTF-8" : decodeCharset);
                    EntityUtils.consume(entity);
                }
            } catch (Exception e) {
                logger.error("与[" + reqURL + "]通信过程中发生异常,堆栈信息为", e);
            } finally {
                httpClient.getConnectionManager().shutdown();
            }
            return responseContent;
        }
        
        
        /**
         * 发送HTTP_POST请求
         * @see 若发送的params中含有中文,记得按照双方约定的字符集将中文URLEncoder.encode(string,encodeCharset)
         * @see 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
         * @param reqURL 请求地址
         * @param params 发送到远程主机的正文数据,其数据类型为java.util.Map
         * @return 远程主机响应正文`HTTP状态码,如"SUCCESS`200"
若通信过程中发生异常则返回"Failed`HTTP状态码",如"Failed`500"
         */
        public static String sendPostRequestByHUC(String reqURL, Map params){
            StringBuilder sendData = new StringBuilder();
            for(Map.Entry entry : params.entrySet()){
                sendData.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
            }
            if(sendData.length() > 0){
                sendData.setLength(sendData.length() - 1); //删除最后一个&符号
            }
            return sendPostRequestByHUC(reqURL, sendData.toString());
        }
        
        
        /**
         * 发送HTTP_POST请求
         * @see 若发送的sendData中含有中文,记得按照双方约定的字符集将中文URLEncoder.encode(string,encodeCharset)
         * @see 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
         * @param reqURL   请求地址
         * @param sendData 发送到远程主机的正文数据
         * @return 远程主机响应正文`HTTP状态码,如"SUCCESS`200"
若通信过程中发生异常则返回"Failed`HTTP状态码",如"Failed`500"
         */
        public static String sendPostRequestByHUC(String reqURL, String sendData){
            HttpURLConnection httpURLConnection = null;
            BufferedReader br = null;
            OutputStream out = null; //写
            InputStream in = null;   //读
            int httpStatusCode = 0;  //远程主机响应的HTTP状态码
            String result = "";
            try{
                URL sendUrl = new URL(reqURL);
                httpURLConnection = (HttpURLConnection)sendUrl.openConnection();
                httpURLConnection.setRequestMethod(METHOD);
                httpURLConnection.setDoOutput(true);        //指示应用程序要将数据写入URL连接,其值默认为false
                httpURLConnection.setUseCaches(false);
                httpURLConnection.setConnectTimeout(TIMEOUT); //30秒连接超时
                httpURLConnection.setReadTimeout(TIMEOUT);    //30秒读取超时
                
                out = httpURLConnection.getOutputStream();
                out.write(sendData.toString().getBytes("UTF-8"));
                
                //清空缓冲区,发送数据
                out.flush();
                
                //获取HTTP状态码
                httpStatusCode = httpURLConnection.getResponseCode();
                
                //接收返回数据
                String readLine = "";
                StringBuffer sb=new StringBuffer();
                br = new BufferedReader(new InputStreamReader(
                        httpURLConnection.getInputStream(), "UTF-8"));
                while((readLine = br.readLine()) != null){
                    sb.append(readLine);
                }
                result = sb.toString();
                return result;
            }catch(Exception e){
                logger.error(e.getMessage());
                return "Failed`" + httpStatusCode;
            }finally{
                if(out != null){
                    try{
                        out.close();
                    }catch (Exception e){
                        logger.error("关闭输出流时发生异常,堆栈信息如下", e);
                    }
                }
                if(in != null){
                    try{
                        in.close();
                    }catch(Exception e){
                        logger.error("关闭输入流时发生异常,堆栈信息如下", e);
                    }
                }
                if(httpURLConnection != null){
                    httpURLConnection.disconnect();
                    httpURLConnection = null;
                }
            }
        }
}

具体怎么运用我就不作解释，有些地方还是需要我们自己动手的。