springboot下如何发起http、https的请求

我就是我 2023-06-19 09:48 58阅读 0赞

本篇将贴出一些springboot下发起http、https请求的常用方法  
1.发起http请求

import java.net.URI;
    import java.util.List;
    import java.util.Map;
    import org.apache.http.HttpEntity;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.client.utils.URIBuilder;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    import org.jsoup.Jsoup;
    import org.jsoup.nodes.Document;
    import org.springframework.http.MediaType;
    
    public class httpUtils{ 
    	public static String getJsonUsePost(String url,List<BasciNameValuePair> formParams) throws Exception{ 
    		CloseableHttpClient httpClient = HttpClients.createDefault();
    		HttpPost httpPost = new HttpPost(url);
    		httpPost.setHeader("Accept",MediaType.APPLICATION_JSON_VALUE);
    		httpPost.setHeader("Content-type",MediaType.APPLICATION_FORM_URLENCODED_VALUE);
    		
    		UrlEncodedFormEntity form = new UrlEncodedFormEntity(formParams,"UTF-8");
    		httpPost.setEntity(form);
    		
    		CloseableHttpResponse resp = httpClient.execute(httpPost);
    		HttpEntity entity = resp.getEntity();
    		String res= EntityUtils.toString(entity,"UTF-8");
    		Document doc = Jsoup.parse(res);
    		return doc.text();
    	}
    
    	public static String getJsonUseGet(String url,Map<String,String> paramMap) throws Exception{ 
    		CloseableHttpClient  httpClient = HttpClients.createDefault();
    		URIBuilder uriBuilder = new URIBuilder(url);
    		if(paramMap!=null&&1paramMap.isEmpty()){ 
    			for(String key:paramMap.keySet()){ 
    				uriBuilder.addParameter(key,paramMap.get(key));
    			}
    		}
    		URI uri = uriBuilder.build();
    		HttpGet httpGet = new HttpGet(uri);
    		httpGet.setHeader("Accept",MediaType.APPLICATION_JSON_VALUE);
    		HttpEntity entity = response.getEntity();
    		String res = EntityUtils.toString(entity,"UTF-8");
    		Document doc = Jsoup.parse(res);
    		return doc.text();
    	}
    }

2.发起https请求  
1)发起rest请求（下述代码仅能运行在jdk1.8版本及以上）

//下面列举的方法在jdk1.8版本及以上适用
    import org.springframework.web.client.RestTemplate;
    import java.security.cert.X509Certificate;
    import org.apache.http.ssl.TrustStrategy;
    import javax.net.ssl.SSLContext;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.springframework.http.client.HttpComponetsClientHttpRequestFactory;
    
    public class httpsUtils{ 
    	public static String getJsonUseRest(String url,Map headerMap){ 
    		RestTemplate rest = HttpsRestTemplate.getHttpsRestTemplate();
    		HttpHeaders header = new HttpHeaders();
    		for(String key:headerMap.keySet()){ 
    			header.add(key,headerMap.get(key));
    		}
    		return rest.postForObject(url,new HttpEntity<String>(header),String.class);
    	}
    	public static RestTemplate getHttpsRestTemplate() throws Exception{ 
    		TrustStrategy acceptingTrustStrategy = new TrustStrategy(){ 
    			@Override
    			public boolean isTrusted(X509Certificate[] arg0,String arg1)throws Exception{ 
    					return true
    			}
    		}
    	};
    	SSLContext sslContext = SSLContexts.custom()
    		.laodTrustMaterial(null,acceptingTrustStrategy)
    		.build();
    	SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext);
    	CloseableHttpClient httpClient = HttpClients.custom()
    		.setSSLSocketFactory(csf).buuild();
    	HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponetsClientHttpRequestFactory();
    	requestFactory.setHttpClients(httpClient);
    	RestTemplate restTemplate = new RestTemplate(requestFactory);
    	return restTemplate;
    }

2）jdk1.7版本及以下发起https请求  
jdk7版本及以下版本需要引入第三方jar包

<dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk15on</artifactId>
        <version>1.54</version>
    </dependency>

//自定义Factory
    import java.io.*;
    import java.net.InetAddress;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    import java.net.UnknownHostException;
    import java.security.*;
    import java.security.cert.*;
    import java.util.*;
    
    import javax.net.ssl.*;
    import javax.security.cert.X509Certificate;
    
    import org.bouncycastle.crypto.tls.*;
    import org.bouncycastle.crypto.tls.Certificate;
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    
    public class TLSSocketConnectionFactory extends SSLSocketFactory { 
    
        static { 
            if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) { 
                Security.addProvider(new BouncyCastleProvider());
            }
        }
    
        @Override
        public Socket createSocket(Socket socket, final String host, int port,
                boolean arg3) throws IOException { 
            if (socket == null) { 
                socket = new Socket();
            }
            if (!socket.isConnected()) { 
                socket.connect(new InetSocketAddress(host, port));
            }
    
            final TlsClientProtocol tlsClientProtocol = new     TlsClientProtocol(socket.getInputStream(), socket.getOutputStream(), new     SecureRandom());
    
            return _createSSLSocket(host, tlsClientProtocol);
        }
    
        @Override public String[] getDefaultCipherSuites() {  return null; }
        @Override public String[] getSupportedCipherSuites() {  return null; }
        @Override public Socket createSocket(String host, int port) throws IOException, UnknownHostException {  throw new UnsupportedOperationException(); }
        @Override public Socket createSocket(InetAddress host, int port) throws IOException {  throw new UnsupportedOperationException(); }
        @Override public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {  return null; }
        @Override public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {  throw new UnsupportedOperationException(); }
    
        private SSLSocket _createSSLSocket(final String host, final TlsClientProtocol tlsClientProtocol) { 
            return new SSLSocket() { 
                private java.security.cert.Certificate[] peertCerts;
    
                @Override public InputStream getInputStream() throws IOException {  return tlsClientProtocol.getInputStream(); }
                @Override public OutputStream getOutputStream() throws IOException {  return tlsClientProtocol.getOutputStream(); }
                @Override public synchronized void close() throws IOException {  tlsClientProtocol.close(); }
                @Override public void addHandshakeCompletedListener( HandshakeCompletedListener arg0) {  }
                @Override public boolean getEnableSessionCreation() {  return false; }
                @Override public String[] getEnabledCipherSuites() {  return null; }
                @Override public String[] getEnabledProtocols() {  return null; }
                @Override public boolean getNeedClientAuth() {  return false; }
    
                @Override
                public SSLSession getSession() { 
                    return new SSLSession() { 
    
                        public int getApplicationBufferSize() { 
                            return 0;
                        }
    
                        public String getCipherSuite() {  return "";//throw new UnsupportedOperationException(); 
                        
                        }
                        public long getCreationTime() {  throw new UnsupportedOperationException(); }
                         public byte[] getId() {  throw new UnsupportedOperationException(); }
                         public long getLastAccessedTime() {  throw new UnsupportedOperationException(); }
                         public java.security.cert.Certificate[] getLocalCertificates() {  throw new UnsupportedOperationException(); }
                         public Principal getLocalPrincipal() {  throw new UnsupportedOperationException(); }
                         public int getPacketBufferSize() {  throw new UnsupportedOperationException(); }
                         public X509Certificate[] getPeerCertificateChain() throws SSLPeerUnverifiedException {  return null; }
                         public java.security.cert.Certificate[] getPeerCertificates() throws SSLPeerUnverifiedException {  return peertCerts; }
                         public String getPeerHost() {  throw new UnsupportedOperationException(); }
                         public int getPeerPort() {  return 0; }
                         public Principal getPeerPrincipal() throws SSLPeerUnverifiedException {  return null; }
                         public String getProtocol() {  throw new UnsupportedOperationException(); }
                         public SSLSessionContext getSessionContext() {  throw new UnsupportedOperationException(); }
                         public Object getValue(String arg0) {  throw new UnsupportedOperationException(); }
                         public String[] getValueNames() {  throw new UnsupportedOperationException(); }
                         public void invalidate() {  /*throw new UnsupportedOperationException(); */}
                         public boolean isValid() {  throw new UnsupportedOperationException(); }
                         public void putValue(String arg0, Object arg1) {  throw new UnsupportedOperationException(); }
                         public void removeValue(String arg0) {  throw new UnsupportedOperationException(); }
                };
            }
    
            @Override public String[] getSupportedProtocols() {  return null; }
            @Override public boolean getUseClientMode() {  return false; }
            @Override public boolean getWantClientAuth() {  return false; }
            @Override public void removeHandshakeCompletedListener(HandshakeCompletedListener arg0) {  }
            @Override public void setEnableSessionCreation(boolean arg0) {  }
            @Override public void setEnabledCipherSuites(String[] arg0) {  }
            @Override public void setEnabledProtocols(String[] arg0) {  }
            @Override public void setNeedClientAuth(boolean arg0) {  }
            @Override public void setUseClientMode(boolean arg0) {  }
            @Override public void setWantClientAuth(boolean arg0) {  }
            @Override public String[] getSupportedCipherSuites() {  return null; }
    
                @Override
                public void startHandshake() throws IOException { 
                    tlsClientProtocol.connect(new DefaultTlsClient() { 
    
                        @SuppressWarnings("unchecked")
                        @Override
                        public Hashtable<Integer, byte[]> getClientExtensions() throws IOException { 
                            Hashtable<Integer, byte[]> clientExtensions = super.getClientExtensions();
                            if (clientExtensions == null) { 
                                clientExtensions = new Hashtable<Integer, byte[]>();
                            }
    
                            //Add host_name
                            byte[] host_name = host.getBytes();
    
                            final ByteArrayOutputStream baos = new ByteArrayOutputStream();
                            final DataOutputStream dos = new DataOutputStream(baos);
                            dos.writeShort(host_name.length + 3);
                            dos.writeByte(0);
                            dos.writeShort(host_name.length);
                            dos.write(host_name);
                            dos.close();
                            clientExtensions.put(ExtensionType.server_name, baos.toByteArray());
                            return clientExtensions;
                        }
    
                        public TlsAuthentication getAuthentication() throws IOException { 
                            return new TlsAuthentication() { 
                                public void notifyServerCertificate(Certificate serverCertificate) throws IOException { 
                                    try { 
                                        KeyStore ks = _loadKeyStore();
    
                                        CertificateFactory cf = CertificateFactory.getInstance("X.509");
                                        List<java.security.cert.Certificate> certs = new LinkedList<java.security.cert.Certificate>();
                                        boolean trustedCertificate = false;
                                        for ( org.bouncycastle.asn1.x509.Certificate c : serverCertificate.getCertificateList()) { 
                                            java.security.cert.Certificate cert = cf.generateCertificate(new ByteArrayInputStream(c.getEncoded()));
                                            certs.add(cert);
    
                                            String alias = ks.getCertificateAlias(cert);
                                            if(alias != null) { 
                                                if (cert instanceof java.security.cert.X509Certificate) { 
                                                    try { 
                                                        ( (java.security.cert.X509Certificate) cert).checkValidity();
                                                        trustedCertificate = true;
                                                    } catch(CertificateExpiredException cee) { 
                                                       // Accept all the certs!
                                                    }
                                                }
                                            } else { 
                                                // Accept all the certs!
                                            }
    
                                        }
                                        if (!trustedCertificate) { 
                                            // Accept all the certs!
                                        }
                                        peertCerts = certs.toArray(new java.security.cert.Certificate[0]);
                                    } catch (Exception ex) { 
                                        ex.printStackTrace();
                                        throw new IOException(ex);
                                    }
                                }
    
                                public TlsCredentials getClientCredentials(CertificateRequest certificateRequest) throws IOException { 
                                    return null;
                                }
    
                                private KeyStore _loadKeyStore() throws Exception { 
                                    FileInputStream trustStoreFis = null;
                                    try { 
                                        KeyStore localKeyStore = null;
    
                                        String trustStoreType = System.getProperty("javax.net.ssl.trustStoreType")!=null?System.getProperty("javax.net.ssl.trustStoreType"):KeyStore.getDefaultType();
                                        String trustStoreProvider = System.getProperty("javax.net.ssl.trustStoreProvider")!=null?System.getProperty("javax.net.ssl.trustStoreProvider"):"";
    
                                        if (trustStoreType.length() != 0) { 
                                            if (trustStoreProvider.length() == 0) { 
                                                localKeyStore = KeyStore.getInstance(trustStoreType);
                                            } else { 
                                                localKeyStore = KeyStore.getInstance(trustStoreType, trustStoreProvider);
                                            }
    
                                            char[] keyStorePass = null;
                                            String str5 = System.getProperty("javax.net.ssl.trustStorePassword")!=null?System.getProperty("javax.net.ssl.trustStorePassword"):"";
    
                                            if (str5.length() != 0) { 
                                                keyStorePass = str5.toCharArray();
                                            }
    
                                            localKeyStore.load(trustStoreFis, keyStorePass);
    
                                            if (keyStorePass != null) { 
                                                for (int i = 0; i < keyStorePass.length; i++) { 
                                                    keyStorePass[i] = 0;
                                                }
                                            }
                                        }
                                        return localKeyStore;
                                    } finally { 
                                        if (trustStoreFis != null) { 
                                            trustStoreFis.close();
                                        }
                                    }
                                }
                            };
                        }
    
                    });
                } // startHandshake
            };
        }
    }

import javax.net.ssl.HostnameVerifier;
    import javax.net.ssl.HttpsURLConnection;
    import javax.net.ssl.SSLSession;
    
    import java.io.*;
    import java.net.URL;
    
    public class HttpsClientUtils { 
        public static String getJSONByPostForm(String urlPath,String data,String charSet,String[] header){ 
        	String result = httpPostData(urlPath,data,charSet,header,MediaType.APPLICATION_FORM_URLENCODED_VALUE,MediaType.APPLICATION_JSON_VALUE);
        	return result;
        }    
        private static String httpPostData(String urlPath, String data, String charSet, String[] header, String contentType, String accpect) { 
            String result = "";
            URL url = null;
            HttpsURLConnection httpurlconnection = null;
            OutputStreamWriter out = null;
            BufferedReader in = null;
            BufferedReader reader = null;
            try { 
            //如果是weblogic服务器，此处有坑，weblogic服务器默认使用soaphttpsurlconnection，而不是httpsURLconnection
            //weblogic服务器请用这句 url = new URL(null,urlString,new sun.net.www.protocol.https.Handler()); 
                url = new URL(urlPath);
                httpurlconnection = (HttpsURLConnection) url.openConnection();
                httpurlconnection.setSSLSocketFactory(new TLSSocketConnectionFactory());
                httpurlconnection.setDoInput(true);
                httpurlconnection.setDoOutput(true);
                httpurlconnection.setHostnameVerifier(new HostnameVerifier() { 
                    public boolean verify(String hostname, SSLSession session) { 
                        return true;
                    }
                });
    
                if (header != null) { 
                    for (int i = 0; i < header.length; i++) { 
                        String[] content = header[i].split(":");
                        httpurlconnection.setRequestProperty(content[0], content[1]);
                    }
                }
    
                httpurlconnection.setRequestMethod("POST");
                httpurlconnection.setRequestProperty("Content-Type", contentType);
                httpurlconnection.connect();
                out = new OutputStreamWriter(httpurlconnection.getOutputStream(), charSet); // utf-8编码
                out.append(data);
                out.flush();
                out.close();
    
                int code = httpurlconnection.getResponseCode();
                if(code == 200) { 
                	in = new BufferedReader(new InputStreamReader(httpurlconnection.getInputStream(),"utf-8"));
                }else{ 
                	if(httpurlconnection.getErrorStream()==null){ 
                		in = new BufferedReader(new InputStreamReader(httpurlconnection.getInputStream(),"utf-8"));
                	}else{ 
                		in = new BufferedReader(new InputStreamReader(httpurlconnection.getErrorStream(),"utf-8"));
                	}
                }
                String line;
                while ((line = in.readLine()) != null) { 
                    result += line;
                }
                
                return result;
    
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                url = null;
                if (httpurlconnection != null) { 
                    httpurlconnection.disconnect();
                }
                try { 
                    if (out != null) { 
                        out.close();
                    }
                    if (reader != null) { 
                        reader.close();
                    }
                } catch (IOException e) { 
                    // TODO
                }
            }
            return result;
        }
    }