Java encapsulates http requests

import org.apache.http.*;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.CharArrayBuffer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io. *;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class HttpUtil {
    private HttpUtil() {
        throw new AssertionError("Utility classes are not meant to be instantiated.");
    }

    /**
     * Constant log.
     */
    private static final Logger logger = LoggerFactory.getLogger(HttpUtil.class);



    public static void main(String[] args) {
        
    }

    public static String http(String url, Map<String, String> paramMap) {
        DefaultHttpClient client = new DefaultHttpClient();
        try {
            List<BasicNameValuePair> nameValuePairs = new ArrayList<BasicNameValuePair>();
            nameValuePairs.add(new BasicNameValuePair("r", String.valueOf(Math.random())));
            if (paramMap != null) {
                for (Map.Entry entry : paramMap.entrySet()) {
                    nameValuePairs.add(new BasicNameValuePair(entry.getKey().toString(), entry.getValue().toString()));
                }
            }

            HttpPost post = new HttpPost(url);

            post.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 5000);// Request timeout
            post.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 6000);//Read timeout

            post.setEntity(new UrlEncodedFormEntity(new ArrayList(nameValuePairs), HTTP.UTF_8));

            HttpProtocolParams.setUseExpectContinue(client.getParams(), false);

            HttpResponse response = client.execute(post);
            if (response.getStatusLine().getStatusCode() == 200) {// If the status code is 200, it will return normally
                String ret = toString(response.getEntity());
                return ret;
            }
        } catch (Exception e) {
            logger.error("http异常", e);
        } finally {
            client.getConnectionManager().shutdown();
        }
        return null;
    }

    public static String getContentCharSet(HttpEntity entity) throws ParseException {
        if (entity == null) {
            throw new IllegalArgumentException("HTTP entity may not be null");
        }
        String charset = null;
        if (entity.getContentType() != null) {
            HeaderElement[] values = entity.getContentType().getElements();
            if (values.length > 0) {
                NameValuePair param = values[0].getParameterByName("charset");
                if (param != null) {
                    charset = param.getValue();
                }
            }
        }
        return charset;
    }

    public static String toString(HttpEntity entity) throws IOException, ParseException {
        return toString(entity, null);
    }

    public static String toString(HttpEntity entity, String defaultCharset) throws IOException, ParseException {
        if (entity == null) {
            throw new IllegalArgumentException("HTTP entity may not be null");
        }
        InputStream instream = entity.getContent();
        if (instream == null) {
            return null;
        }
        try {
            if (entity.getContentLength() > 2147483647L) {
                throw new IllegalArgumentException("HTTP entity too large to be buffered in memory");
            }
            int i = (int) entity.getContentLength();
            if (i < 0) {
                i = 4096;
            }
            String charset = getContentCharSet(entity);
            if (charset == null) {
                charset = defaultCharset;
            }
            if (charset == null) {
                charset = "UTF-8";
            }
            Reader reader = new InputStreamReader(instream, charset);
            CharArrayBuffer buffer = new CharArrayBuffer(i);
            char[] tmp = new char['?'];
            int l;
            while ((l = reader.read(tmp)) != -1) {
                buffer.append(tmp, 0, l);
            }
            return buffer.toString();
        } finally {
            instream.close();
        }
    }

    /**
     * Send a GET request
     *
     * @param url
     * Destination address
     * @param parameters
     * Request parameters, Map type.
     * @return remote response result
     */
    public static String sendGet(String url, Map<String, String> parameters) {
        String result="";
        BufferedReader in = null;// Read the response input stream
        StringBuffer sb = new StringBuffer();// store parameters
        String params = "";// parameters after encoding
        try {
            // encode request parameters
            if(parameters!=null){
                if(parameters.size()==1){
                    for(String name:parameters.keySet()){
                        sb.append(name).append("=").append(
                                java.net.URLEncoder.encode(parameters.get(name),
                                        "UTF-8"));
                    }
                    params=sb.toString();
                }else{
                    for (String name : parameters.keySet()) {
                        sb.append(name).append("=").append(
                                java.net.URLEncoder.encode(parameters.get(name),
                                        "UTF-8")).append("&");
                    }
                    String temp_params = sb.toString();
                    params = temp_params.substring(0, temp_params.length() - 1);
                }
            }
            String full_url = url + "?" + params;
            // System.out.println(full_url);
            // create URL object
            java.net.URL connURL = new java.net.URL(full_url);
            // open URL connection
            java.net.HttpURLConnection httpConn = (java.net.HttpURLConnection) connURL
                    .openConnection();
            // set common properties
            httpConn.setRequestProperty("Accept", "*/*");
            httpConn.setRequestProperty("Connection", "Keep-Alive");
            httpConn.setRequestProperty("User-Agent",
                    "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)");
            // establish the actual connection
            httpConn.connect();
            // get response header
            Map<String, List<String>> headers = httpConn.getHeaderFields();
            // loop through all response header fields
            for (String key : headers.keySet()) {
                //System.out.println(key + "\t：\t" + headers.get(key));
            }
            // Define the BufferedReader input stream to read the response of the URL and set the encoding method
            in = new BufferedReader(new InputStreamReader(httpConn
                    .getInputStream(), "UTF-8"));
            String line;
            // read the returned content
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            e.printStackTrace ();
        }finally{
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return result ;
    }
    /**
     * Send POST request
     *
     * @param url
     * Destination address
     * @param parameters
     * Request parameters, Map type.
     * @return remote response result
     */
    public static String sendPost(String url, Map<String, String> parameters) {
        String result = "";// Returned result
        BufferedReader in = null;// Read the response input stream
        PrintWriter out = null;
        StringBuffer sb = new StringBuffer();// Process request parameters
        String params = "";// parameters after encoding
        try {
            // encode request parameters
            if(parameters!=null){
                if (parameters.size() == 1) {
                    for (String name : parameters.keySet()) {
                        sb.append(name).append("=").append(
                                java.net.URLEncoder.encode(parameters.get(name),
                                        "UTF-8"));
                    }
                    params = sb.toString();
                } else {
                    for (String name : parameters.keySet()) {
                        sb.append(name).append("=").append(
                                java.net.URLEncoder.encode(parameters.get(name),
                                        "UTF-8")).append("&");
                    }
                    String temp_params = sb.toString();
                    params = temp_params.substring(0, temp_params.length() - 1);
                }
            }
            // create URL object
            java.net.URL connURL = new java.net.URL(url);
            // open URL connection
            java.net.HttpURLConnection httpConn = (java.net.HttpURLConnection) connURL
                    .openConnection();
            // set common properties
            httpConn.setRequestProperty("Accept", "*/*");
            httpConn.setRequestProperty("Connection", "Keep-Alive");
            httpConn.setRequestProperty("User-Agent",
                    "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)");
            // set the POST method
            httpConn.setDoInput(true);
            httpConn.setDoOutput(true);
            // Get the output stream corresponding to the HttpURLConnection object
            out = new PrintWriter(httpConn.getOutputStream());
            // send request parameters
            out.write(params);
            // flush the buffer of the output stream
            out.flush();
            // Define the BufferedReader input stream to read the response of the URL and set the encoding method
            in = new BufferedReader(new InputStreamReader(httpConn
                    .getInputStream(), "UTF-8"));
            String line;
            // read the returned content
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            e.printStackTrace ();
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return result;
    }


}