Differences

This shows you the differences between two versions of the page.

--- java:http-test [2010/04/13 12:54] – percy
+++ java:http-test [2016/05/05 13:07] (current) – external edit 127.0.0.1
@@ Line 1: / Line 1: @@
+====== 说明 ======
+这个测试文件,测试了如何通过http和https获取数据,如何设置代理,包括http prox,https proxy.
+以及如何post数据.
+====== HttpTest.java ======
+<file java HttpTest.java>
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLEncoder;
+import java.nio.charset.Charset;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLSession;
+/**
+ * A test class for how to get data from {@link #getHttpData(String) HttpURL},
+ * {@link #getHttpsData(String) HttpsURL},and how to {@link #setProxy setProxy},{@link #post(String,String) PostData}
+ *
+ * @author Percy.Peng
+ * @see #getHttpData(String)
+ * @see #getHttpsData(String)
+ * @see #post(String, String)
+ * @see #setProxy()
+ */
+public class HttpTest {
+    public static final String httpURL = "http://twitter.com/";
+    public static final String httpsURL = "https://twitter.com/";
+    public static void main(String[] args) {
+        System.out.println("main");
+        setProxy();
+        String httpHtml = getHttpData(httpURL);
+        String httpsHtml = getHttpsData(httpsURL);
+        System.out.println(httpHtml);
+        System.out.println(httpsHtml);
+    }
+    /**
+     * Set Proxy here,including http proxy and https proxy
+     */
+    public static void setProxy() {
+        // Set Http Proxy
+        System.getProperties().setProperty("http.proxyHost", "10.85.40.153");
+        System.getProperties().setProperty("http.proxyPort", "8000");
+        // Set Https Proxy
+        // FIXME Should import the certificates to avoid the trust problem.
+        // To avoid the certification problems,just trust all the certs.
+        SSLUtilities.trustAllHttpsCertificates();
+        System.getProperties().setProperty("https.proxyHost", "10.85.40.153");
+        System.getProperties().setProperty("https.proxyPort", "8000");
+    }
+    /**
+     * Post a data to the url
+     *
+     * @param urlString a URL String
+     * @param data The data to be posted
+     */
+    private static void post(String urlString, String data) {
+        try { // Construct data
+            String encodedData = URLEncoder.encode(data, "UTF-8");
+            // Send data
+            URL url = new URL(urlString);
+            URLConnection conn = url.openConnection();
+            conn.setDoOutput(true);
+            OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
+            wr.write(encodedData);
+            wr.flush();
+            // Get the response
+            BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+            String line;
+            while ((line = rd.readLine()) != null) {
+                // Process line...
+            }
+            wr.close();
+            rd.close();
+        } catch (Exception e) {
+        }
+    }
+    private static String LOGTAG = "UserAgent";
+    private static String UA = "Mozilla/5.0 (MOT-XT800/TITA_M2_15.10.1:U:Android/2.0.1:480*320;CTC/2.0) AppleWebKit/528.5+(KHTML,like Gecko) Version/3.1.2 Mobile/5G77 Safari/525.20.1";
+    // private static String URL = "http://10.234.63.196/portal/wap";
+    /**
+     * Get data(Html) from a http url
+     *
+     * @param url A url String
+     * @return The contents for the url or null if failed
+     */
+    public static String getHttpData(String urlString) {
+        String result = null;
+        try {
+            URL url = new URL(urlString);
+            URLConnection conn = url.openConnection();
+            conn.setDoOutput(true);
+            // conn.setRequestProperty("User-Agent", UA);
+            InputStreamReader isr = new InputStreamReader(conn.getInputStream());
+            readFromInputStream(isr);
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (Exception e) {
+            // TODO: handle exception
+            e.printStackTrace();
+        }
+        return result;
+    }
+    /**
+     * Get data(Html) from a https url
+     *
+     * @param urlString A URL String
+     * @return The Data from the urlString or null if failed
+     */
+    public static String getHttpsData(String urlString) {
+        String result = null;
+        URL url = null;
+        HostnameVerifier hv = new HostnameVerifier() {
+            public boolean verify(String arg0, SSLSession arg1) {
+                // TODO Auto-generated method stub
+                //System.out.println("Warning: URL Host: " + arg0 + " vs. " + arg1.getPeerHost());
+                return true;
+            }
+        };
+        try {
+            url = new java.net.URL(urlString);
+        } catch (MalformedURLException e1) {
+            // TODO Auto-generated catch block
+            e1.printStackTrace();
+            System.out.println("Get data Failed:" + urlString);
+            return result;
+        }
+        HttpsURLConnection.setDefaultHostnameVerifier(hv);
+        HttpsURLConnection conn;
+        try {
+            conn = (javax.net.ssl.HttpsURLConnection)url.openConnection();
+            conn.setDoOutput(true);
+            InputStreamReader isr = new InputStreamReader(conn.getInputStream());
+            result = readFromInputStream(isr);
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (Exception e) {
+            // TODO: handle exception
+            e.printStackTrace();
+        }
+        return result;
+    }
+    /**
+     * Read data from InputStreamReader
+     *
+     * @param isr InputStreamReader
+     * @return The Data read from The InputStreamReader
+     */
+    public static String readFromInputStream(InputStreamReader isr) {
+        String result = null;
+        BufferedReader rd = new BufferedReader(isr);
+        String line;
+        try {
+            while ((line = rd.readLine()) != null) {
+                result += line + '\n';
+            }
+            isr.close();
+            rd.close();
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+        return result;
+    }
+}
+</file>
+====== SSLUtilities.java ======
+如果要把上面的代码正常跑起来,还要添加下面这个文件:
+<file java SSLUtilities.java>
+ import java.security.GeneralSecurityException;
+ import java.security.SecureRandom;
+ import java.security.cert.X509Certificate;
+ import javax.net.ssl.HostnameVerifier;
+ import javax.net.ssl.HttpsURLConnection;
+ import javax.net.ssl.SSLContext;
+ import javax.net.ssl.TrustManager;
+ import javax.net.ssl.X509TrustManager;
+ /**
+  * This class provide various static methods that relax X509 certificate and
+  * hostname verification while using the SSL over the HTTP protocol.
+  *
+  * @author    Francis Labrie
+  */
+ public final class SSLUtilities {
+   /**
+    * Hostname verifier for the Sun's deprecated API.
+    *
+    * @deprecated see {@link #_hostnameVerifier}.
+    */
+   private static com.sun.net.ssl.HostnameVerifier __hostnameVerifier;
+   /**
+    * Thrust managers for the Sun's deprecated API.
+    *
+    * @deprecated see {@link #_trustManagers}.
+    */
+   private static com.sun.net.ssl.TrustManager[] __trustManagers;
+   /**
+    * Hostname verifier.
+    */
+   private static HostnameVerifier _hostnameVerifier;
+   /**
+    * Thrust managers.
+    */
+   private static TrustManager[] _trustManagers;
+   /**
+    * Set the default Hostname Verifier to an instance of a fake class that
+    * trust all hostnames. This method uses the old deprecated API from the
+    * com.sun.ssl package.
+    *
+    * @deprecated see {@link #_trustAllHostnames()}.
+    */
+   private static void __trustAllHostnames() {
+       // Create a trust manager that does not validate certificate chains
+       if(__hostnameVerifier == null) {
+           __hostnameVerifier = new _FakeHostnameVerifier();
+       } // if
+       // Install the all-trusting host name verifier
+       com.sun.net.ssl.HttpsURLConnection.
+           setDefaultHostnameVerifier(__hostnameVerifier);
+   } // __trustAllHttpsCertificates
+   /**
+    * Set the default X509 Trust Manager to an instance of a fake class that
+    * trust all certificates, even the self-signed ones. This method uses the
+    * old deprecated API from the com.sun.ssl package.
+    *
+    * @deprecated see {@link #_trustAllHttpsCertificates()}.
+    */
+   private static void __trustAllHttpsCertificates() {
+       com.sun.net.ssl.SSLContext context;
+       // Create a trust manager that does not validate certificate chains
+       if(__trustManagers == null) {
+           __trustManagers = new com.sun.net.ssl.TrustManager[]
+               {new _FakeX509TrustManager()};
+       } // if
+       // Install the all-trusting trust manager
+       try {
+           context = com.sun.net.ssl.SSLContext.getInstance("SSL");
+           context.init(null, __trustManagers, new SecureRandom());
+       } catch(GeneralSecurityException gse) {
+           throw new IllegalStateException(gse.getMessage());
+       } // catch
+       com.sun.net.ssl.HttpsURLConnection.
+           setDefaultSSLSocketFactory(context.getSocketFactory());
+   } // __trustAllHttpsCertificates
+   /**
+    * Return true if the protocol handler property java.
+    * protocol.handler.pkgs is set to the Sun's com.sun.net.ssl.
+    * internal.www.protocol deprecated one, false
+    * otherwise.
+    *
+    * @return                true if the protocol handler
+    * property is set to the Sun's deprecated one, false
+    * otherwise.
+    */
+   private static boolean isDeprecatedSSLProtocol() {
+       return("com.sun.net.ssl.internal.www.protocol".equals(System.
+           getProperty("java.protocol.handler.pkgs")));
+   } // isDeprecatedSSLProtocol
+   /**
+    * Set the default Hostname Verifier to an instance of a fake class that
+    * trust all hostnames.
+    */
+   private static void _trustAllHostnames() {
+       // Create a trust manager that does not validate certificate chains
+       if(_hostnameVerifier == null) {
+           _hostnameVerifier = new FakeHostnameVerifier();
+       } // if
+         // Install the all-trusting host name verifier:
+       HttpsURLConnection.setDefaultHostnameVerifier(_hostnameVerifier);
+   } // _trustAllHttpsCertificates
+   /**
+    * Set the default X509 Trust Manager to an instance of a fake class that
+    * trust all certificates, even the self-signed ones.
+    */
+   private static void _trustAllHttpsCertificates() {
+       SSLContext context;
+       // Create a trust manager that does not validate certificate chains
+       if(_trustManagers == null) {
+           _trustManagers = new TrustManager[] {new FakeX509TrustManager()};
+       } // if
+       // Install the all-trusting trust manager:
+       try {
+       context = SSLContext.getInstance("SSL");
+       context.init(null, _trustManagers, new SecureRandom());
+       } catch(GeneralSecurityException gse) {
+           throw new IllegalStateException(gse.getMessage());
+       } // catch
+       HttpsURLConnection.setDefaultSSLSocketFactory(context.
+           getSocketFactory());
+   } // _trustAllHttpsCertificates
+   /**
+    * Set the default Hostname Verifier to an instance of a fake class that
+    * trust all hostnames.
+    */
+   public static void trustAllHostnames() {
+       // Is the deprecated protocol setted?
+       if(isDeprecatedSSLProtocol()) {
+           __trustAllHostnames();
+       } else {
+           _trustAllHostnames();
+       } // else
+   } // trustAllHostnames
+   /**
+    * Set the default X509 Trust Manager to an instance of a fake class that
+    * trust all certificates, even the self-signed ones.
+    */
+   public static void trustAllHttpsCertificates() {
+       // Is the deprecated protocol setted?
+       if(isDeprecatedSSLProtocol()) {
+           __trustAllHttpsCertificates();
+       } else {
+           _trustAllHttpsCertificates();
+       } // else
+   } // trustAllHttpsCertificates
+   /**
+    * This class implements a fake hostname verificator, trusting any host
+    * name. This class uses the old deprecated API from the com.sun.
+    * ssl package.
+    *
+    * @author    Francis Labrie
+    *
+    * @deprecated see {@link SSLUtilities.FakeHostnameVerifier}.
+    */
+   public static class _FakeHostnameVerifier
+       implements com.sun.net.ssl.HostnameVerifier {
+       /**
+        * Always return true, indicating that the host name is an
+        * acceptable match with the server's authentication scheme.
+        *
+        * @param hostname        the host name.
+        * @param session         the SSL session used on the connection to
+        * host.
+        * @return                the true boolean value
+        * indicating the host name is trusted.
+        */
+       public boolean verify(String hostname, String session) {
+           return(true);
+       } // verify
+   } // _FakeHostnameVerifier
+   /**
+    * This class allow any X509 certificates to be used to authenticate the
+    * remote side of a secure socket, including self-signed certificates. This
+    * class uses the old deprecated API from the com.sun.ssl
+    * package.
+    *
+    * @author    Francis Labrie
+    *
+    * @deprecated see {@link SSLUtilities.FakeX509TrustManager}.
+    */
+   public static class _FakeX509TrustManager
+       implements com.sun.net.ssl.X509TrustManager {
+       /**
+        * Empty array of certificate authority certificates.
+        */
+       private static final X509Certificate[] _AcceptedIssuers =
+           new X509Certificate[] {};
+       /**
+        * Always return true, trusting for client SSL
+        * chain peer certificate chain.
+        *
+        * @param chain           the peer certificate chain.
+        * @return                the true boolean value
+        * indicating the chain is trusted.
+        */
+       public boolean isClientTrusted(X509Certificate[] chain) {
+           return(true);
+       } // checkClientTrusted
+       /**
+        * Always return true, trusting for server SSL
+        * chain peer certificate chain.
+        *
+        * @param chain           the peer certificate chain.
+        * @return                the true boolean value
+        * indicating the chain is trusted.
+        */
+       public boolean isServerTrusted(X509Certificate[] chain) {
+           return(true);
+       } // checkServerTrusted
+       /**
+        * Return an empty array of certificate authority certificates which
+        * are trusted for authenticating peers.
+        *
+        * @return                a empty array of issuer certificates.
+        */
+       public X509Certificate[] getAcceptedIssuers() {
+           return(_AcceptedIssuers);
+       } // getAcceptedIssuers
+   } // _FakeX509TrustManager
+   /**
+    * This class implements a fake hostname verificator, trusting any host
+    * name.
+    *
+    * @author    Francis Labrie
+    */
+   public static class FakeHostnameVerifier implements HostnameVerifier {
+       /**
+        * Always return true, indicating that the host name is
+        * an acceptable match with the server's authentication scheme.
+        *
+        * @param hostname        the host name.
+        * @param session         the SSL session used on the connection to
+        * host.
+        * @return                the true boolean value
+        * indicating the host name is trusted.
+        */
+       public boolean verify(String hostname,
+           javax.net.ssl.SSLSession session) {
+           return(true);
+       } // verify
+   } // FakeHostnameVerifier
+   /**
+    * This class allow any X509 certificates to be used to authenticate the
+    * remote side of a secure socket, including self-signed certificates.
+    *
+    * @author    Francis Labrie
+    */
+   public static class FakeX509TrustManager implements X509TrustManager {
+       /**
+        * Empty array of certificate authority certificates.
+        */
+       private static final X509Certificate[] _AcceptedIssuers =
+           new X509Certificate[] {};
+       /**
+        * Always trust for client SSL chain peer certificate
+        * chain with any authType authentication types.
+        *
+        * @param chain           the peer certificate chain.
+        * @param authType        the authentication type based on the client
+        * certificate.
+        */
+       public void checkClientTrusted(X509Certificate[] chain,
+           String authType) {
+       } // checkClientTrusted
+       /**
+        * Always trust for server SSL chain peer certificate
+        * chain with any authType exchange algorithm types.
+        *
+        * @param chain           the peer certificate chain.
+        * @param authType        the key exchange algorithm used.
+        */
+       public void checkServerTrusted(X509Certificate[] chain,
+           String authType) {
+       } // checkServerTrusted
+       /**
+        * Return an empty array of certificate authority certificates which
+        * are trusted for authenticating peers.
+        *
+        * @return                a empty array of issuer certificates.
+        */
+       public X509Certificate[] getAcceptedIssuers() {
+           return(_AcceptedIssuers);
+       } // getAcceptedIssuers
+   } // FakeX509TrustManager
+ } // SSLUtilities
+</file>