http请求

心已赠人 2022-01-15 01:23 376阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

import java.io.\*;  
import java.net.\*;  
import java.security.KeyManagementException;  
import java.security.KeyStore;  
import java.security.KeyStoreException;  
import java.security.NoSuchAlgorithmException;  
import java.security.UnrecoverableKeyException;  
import java.security.cert.CertificateException;  
import java.security.cert.X509Certificate;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Map;  
import java.util.Map.Entry;  
import java.util.Set;

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

import org.apache.commons.httpclient.HttpException;  
import org.apache.commons.lang3.StringUtils;  
import org.apache.commons.logging.Log;  
import org.apache.commons.logging.LogFactory;  
import org.apache.http.\*;  
import org.apache.http.auth.AuthScope;  
import org.apache.http.auth.UsernamePasswordCredentials;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.config.RequestConfig;  
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.conn.ClientConnectionManager;  
import org.apache.http.conn.params.ConnRoutePNames;  
import org.apache.http.conn.scheme.PlainSocketFactory;  
import org.apache.http.conn.scheme.Scheme;  
import org.apache.http.conn.scheme.SchemeRegistry;  
import org.apache.http.conn.ssl.\*;  
import org.apache.http.entity.StringEntity;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;  
import org.apache.http.params.BasicHttpParams;  
import org.apache.http.params.CoreConnectionPNames;  
import org.apache.http.params.HttpParams;  
import org.apache.http.params.HttpProtocolParams;  
import org.apache.http.protocol.HTTP;  
import org.apache.http.util.EntityUtils;

@SuppressWarnings("deprecation")  
public class HttpUtil \{

//注册端口  
    //private static int port = 443;  
    //超时时间（毫秒）  
    private final static int CONNECTION\_TIME\_OUT = 10000;

public static final int READDATA\_TIMEOUT = 10000;// 数据读取等待超时

protected static Log log = LogFactory.getLog(HttpUtil.class);

public synchronized static String sendDataByGet(String url,  
                                                    Map<String, String> params, boolean enableProxy, int timeout) \{

if (params != null && params.size() > 0) \{  
            StringBuffer sb = new StringBuffer();  
            Set<Entry<String, String>> set = params.entrySet();  
            for (Iterator<Entry<String, String>> iterator = set.iterator(); iterator.hasNext(); ) \{  
                Entry<String, String> entry = (Entry<String, String>) iterator.next();  
                sb.append("&" + entry.getKey() + "=" + URLEncoder.encode(entry.getValue()));  
            \}  
            if (url.indexOf("?") == -1) \{  
                sb.deleteCharAt(0);  
                url = url + "?" + sb.toString();  
            \} else \{  
                url = url + sb.toString();  
            \}  
        \}

DefaultHttpClient client = null;

if (client == null) \{  
            client = createHttpClient(timeout);  
        \}

if (enableProxy) \{  
            HttpHost host = new HttpHost("10.37.84.16", 80);  
            client.getParams().setParameter(ConnRoutePNames.DEFAULT\_PROXY, host);  
            client.getCredentialsProvider().setCredentials(new AuthScope("10.37.84.16", 80), new UsernamePasswordCredentials("um", "密码"));  
        \}  
        HttpGet get = new HttpGet(url);  
        HttpResponse resp = null;  
        String result = null;  
        try \{  
            resp = client.execute(get);  
            if (resp.getStatusLine().getStatusCode() == HttpStatus.SC\_OK  
                    || resp.getStatusLine().getStatusCode() == 400) \{  
                result = EntityUtils.toString(resp.getEntity(), HTTP.UTF\_8);  
                System.out.println(result);  
            \}  
        \} catch (UnsupportedEncodingException e) \{  
            e.printStackTrace();  
        \} catch (ClientProtocolException e) \{  
            e.printStackTrace();  
        \} catch (IOException e) \{

e.printStackTrace();  
        \} catch (Exception e) \{

e.printStackTrace();  
        \}  
        return result;  
    \}

public synchronized static String sendDataByPost(String url,  
                                                     List<NameValuePair> datas, boolean enableProxy, int timeout) \{  
        DefaultHttpClient client = null;

if (client == null) \{  
            client = createHttpClient(timeout);  
        \}  
        if (enableProxy) \{  
            HttpHost host = new HttpHost("10.37.84.16", 80);  
            client.getParams().setParameter(ConnRoutePNames.DEFAULT\_PROXY, host);  
            client.getCredentialsProvider().setCredentials(new AuthScope("10.37.84.16", 80), new UsernamePasswordCredentials("gengqian499", "gq1234!@\#$"));  
        \}  
        HttpPost post = new HttpPost(url);

HttpResponse resp = null;  
        String result = null;  
        try \{  
            post.setEntity(new UrlEncodedFormEntity(datas, HTTP.UTF\_8));  
            resp = client.execute(post);  
            if (resp.getStatusLine().getStatusCode() == HttpStatus.SC\_OK  
                    || resp.getStatusLine().getStatusCode() == 400) \{  
                result = EntityUtils.toString(resp.getEntity(), HTTP.UTF\_8);  
                System.out.println(result);  
            \}  
        \} catch (UnsupportedEncodingException e) \{  
            e.printStackTrace();  
        \} catch (ClientProtocolException e) \{  
            e.printStackTrace();  
        \} catch (IOException e) \{

e.printStackTrace();  
        \} catch (Exception e) \{

e.printStackTrace();  
        \}  
        return result;  
    \}  
    public static String doGet(String url) throws IOException \{  
        CloseableHttpClient httpClient = HttpClients.createDefault();  
        HttpGet httpGet = new HttpGet(url);  
        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(CONNECTION\_TIME\_OUT).setConnectTimeout(CONNECTION\_TIME\_OUT).build();  
        httpGet.setConfig(requestConfig);  
        try \{  
            HttpResponse resp = httpClient.execute(httpGet);  
            String result = EntityUtils.toString(resp.getEntity(), HTTP.UTF\_8);  
            int statusCode = resp.getStatusLine().getStatusCode();  
            if (statusCode == HttpStatus.SC\_OK) \{  
                return result;  
            \} else \{  
                throw new HttpException("Unsuccessful request -------->  The response is statusCode= " + statusCode + " and message= " + result);  
            \}  
        \} finally \{  
            httpClient.close();  
        \}  
    \}

private static DefaultHttpClient createHttpClient(int soTimeout) \{  
        if (soTimeout == 0) \{  
            soTimeout = CONNECTION\_TIME\_OUT;  
        \}  
        try \{  
            HttpParams params = new BasicHttpParams();  
            HttpProtocolParams.setVersion(params, HttpVersion.HTTP\_1\_1);  
            HttpProtocolParams.setContentCharset(params, HTTP.DEFAULT\_CONTENT\_CHARSET);  
            HttpProtocolParams.setUseExpectContinue(params, true);  
            // 设置超时时间  
            params.setParameter(CoreConnectionPNames.CONNECTION\_TIMEOUT, soTimeout);  
            // 读取超时  
            params.setParameter(CoreConnectionPNames.SO\_TIMEOUT, soTimeout);  
            params.setParameter("Connection", "Keep-Alive");  
            params.setParameter("Content-Length", " 12");

KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());  
            trustStore.load(null, null);  
            MySSLSocketFactory sf = new MySSLSocketFactory(trustStore);  
            sf.setHostnameVerifier(MySSLSocketFactory.ALLOW\_ALL\_HOSTNAME\_VERIFIER);

SchemeRegistry registry = new SchemeRegistry();  
            registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));  
            registry.register(new Scheme("https", sf, 443));  
            ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, registry);

return new DefaultHttpClient(conMgr, params);  
        \} catch (Exception e) \{  
            e.printStackTrace();  
            return null;  
        \}  
    \}

public static String sendHttpsPost(String url, String requestBody, String contentType, String hostName) throws Exception \{  
        log.info("httpsClient访问开始..." + url);  
        CloseableHttpClient httpClient = null;  
        try \{  
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() \{  
                // 默认信任所有证书  
                public boolean isTrusted(X509Certificate\[\] arg0, String arg1) \{  
                    return false;  
                \}  
            \}).build();  
            SSLConnectionSocketFactory ssf = new SSLConnectionSocketFactory(sslContext, SSLConnectionSocketFactory.ALLOW\_ALL\_HOSTNAME\_VERIFIER);  
            httpClient = HttpClients.custom().setSSLSocketFactory(ssf).build();

HttpPost httpPost = new HttpPost(url);  
            Authenticator.setDefault(new MyAuthenticator("gaowei399","741asd\#fg"));              
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECTION\_TIME\_OUT).setSocketTimeout(READDATA\_TIMEOUT)  
                    .setProxy(new HttpHost("10.37.84.36", 8080))  
                    .build();  
            httpPost.setConfig(requestConfig);  
            httpPost.setEntity(new StringEntity(requestBody, "UTF-8"));  
            if (StringUtils.isNotBlank(hostName)) \{  
                httpPost.setHeader("HOST", hostName);  
            \}  
            if (StringUtils.isNotBlank(contentType)) \{  
                httpPost.setHeader("Content-Type", contentType);  
            \}  
            HttpResponse resp = httpClient.execute(httpPost);  
            String result = EntityUtils.toString(resp.getEntity(), HTTP.UTF\_8);  
            int statusCode = resp.getStatusLine().getStatusCode();  
            if (statusCode == HttpStatus.SC\_OK) \{  
                return result;  
            \} else \{  
                throw new HttpException("HTTP REQUEST FAIL ---- statusCode: " + statusCode + " and result: " + result);  
            \}  
        \} catch (Exception e) \{  
            log.error(e.getMessage(), e);  
            throw new RuntimeException("通讯未知系统异常", e);  
        \} finally \{  
            if (httpClient != null) \{  
                httpClient.close();  
            \}  
        \}  
    \}  
\}

/\*\*  
 \* 过滤证书  
 \*   
 \*/  
@SuppressWarnings("deprecation")  
class MySSLSocketFactory extends SSLSocketFactory \{  
    SSLContext sslContext = SSLContext.getInstance("TLS");

public MySSLSocketFactory(KeyStore truststore)  
            throws NoSuchAlgorithmException, KeyManagementException,  
            KeyStoreException, UnrecoverableKeyException \{  
        super(truststore);  
        TrustManager tm = 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;  
            \}  
        \};  
        sslContext.init(null, new TrustManager\[\]\{tm\}, null);  
    \}

[@Override][Override]  
    public Socket createSocket(Socket socket, String host, int port,  
                               boolean autoClose) throws IOException, UnknownHostException \{  
        return sslContext.getSocketFactory().createSocket(socket, host, port,  
                autoClose);  
    \}

[@Override][Override]  
    public Socket createSocket() throws IOException \{  
        return sslContext.getSocketFactory().createSocket();  
    \}  
\}

转载于:https://my.oschina.net/u/198077/blog/3047633

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220114/5d7e1658ae0247e785a51b3acc1b08e7.png
[Override]: https://my.oschina.net/u/1162528