Invia HTTPS Inserisci richiesta al server

Question

Questo è il mio HTTP JSON

{ 
"User": {  
    "Name": "Compulsary","Password": "Compulsary" } 
} 

che ho di inviare al server mediante richiesta HTTPS POST. Quando provo ad inviare la richiesta, ottengo l'eccezione del certificato server SSL. Come posso risolvere questo problema?

Cosa ho provato?

Ho provato a utilizzare HTTPPost con HTTPClient. Eccezione SSL. Ho anche provato a utilizzare URLConnection e ho ignorato il controllo dei certificati SSL. Ricevo i codici di risposta 401 e 405.

Il problema dichiarazione:

Invia il sopra POST richiesta al server (La richiesta è sicuro accetta https). Come raggiungere questo in Android?

Ho provato questo, My Code, sto ricevendo errore 405?

// always verify the host - dont check for certificate 
final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() { 
    public boolean verify(String hostname, SSLSession session) { 
     return true; 
    } 
}; 

/** 
* Trust every server - dont check for any certificate 
*/ 
private static void trustAllHosts() { 
    // Create a trust manager that does not validate certificate chains 
    TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() { 
     public java.security.cert.X509Certificate[] getAcceptedIssuers() { 
      return new java.security.cert.X509Certificate[] {}; 
     } 

     public void checkClientTrusted(X509Certificate[] chain, 
       String authType) throws CertificateException { 
     } 

     public void checkServerTrusted(X509Certificate[] chain, 
       String authType) throws CertificateException { 
     } 
    } }; 

    // Install the all-trusting trust manager 
    try { 
     SSLContext sc = SSLContext.getInstance("TLS"); 
     sc.init(null, trustAllCerts, new java.security.SecureRandom()); 
     HttpsURLConnection 
       .setDefaultSSLSocketFactory(sc.getSocketFactory()); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 

private void makeRequest() { 
    URL url = null; 
    HttpsURLConnection urlConnection = null; 
    try { 
     url = new URL("https://wbapi.cloudapp.net:443/api/User/LocalLogin"); 
    } catch (MalformedURLException e2) { 
     // TODO Auto-generated catch block 
     e2.printStackTrace(); 
    } 
    StringBuilder sb = new StringBuilder(); 

    try { 
     trustAllHosts(); 
     urlConnection = (HttpsURLConnection) url.openConnection(); 
     urlConnection.setHostnameVerifier(DO_NOT_VERIFY); 
     urlConnection.setDoOutput(true); 
     urlConnection 
       .setRequestProperty("Content-Type", "application/json"); 
     urlConnection.setFixedLengthStreamingMode(urlConnection 
       .getContentLength()); 
    } catch (IOException e2) { 
     // TODO Auto-generated catch block 
     e2.printStackTrace(); 
    } 

    try { 
     urlConnection.connect(); 
    } catch (IOException e1) { 
     // TODO Auto-generated catch block 
     e1.printStackTrace(); 
    } 
    JSONObject jsonParam = new JSONObject(); 
    try { 
     jsonParam.put("Name", "dog"); 
     jsonParam.put("Password", "123"); 
     Log.v("Length", "" + urlConnection.getContentLength()); 
     int HttpResult = urlConnection.getResponseCode(); 
     Toast.makeText(LoginActivity.this, "Response" + HttpResult, 
       Toast.LENGTH_LONG).show(); 
     if (HttpResult == HttpsURLConnection.HTTP_OK) { 
      System.out.println("ok"); 
      Log.v("Hi", "" + "Trex"); 
      BufferedReader br = new BufferedReader(new InputStreamReader(
        urlConnection.getInputStream(), "utf-8")); 
      String line = null; 
      while ((line = br.readLine()) != null) { 
       sb.append(line + "\n"); 
      } 
      br.close(); 

      System.out.println("" + sb.toString()); 
      Toast.makeText(LoginActivity.this, "" + sb.toString(), 
        Toast.LENGTH_LONG).show(); 

     } else { 
      System.out.println("Here" + urlConnection.getResponseMessage()); 
     } 
    } catch (MalformedURLException e) { 

     e.printStackTrace(); 
    } catch (IOException e) { 

     e.printStackTrace(); 
    } catch (JSONException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
} 

Logcat voci

12-27 13:41:27.228: V/Length(3034): 72 
12-27 13:41:27.248: I/System.out(3034): HereMethod Not Allowed 

Answer 1

Fase 1: Creare una classe MySSLSocketFactory e comprendono sottostante Codice:

public 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 
    public Socket createSocket(Socket socket, String host, int port, 
        boolean autoClose) throws IOException, UnknownHostException { 
      return sslContext.getSocketFactory().createSocket(socket, host, port, 
          autoClose); 
    } 

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

} 

Fase 2: Creare una classe WebClientDevWrapper e includere il codice qui sotto:

public class WebClientDevWrapper { 

    public static HttpClient getNewHttpClient() { 
     try { 
      KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); 
      trustStore.load(null, null); 

      SSLSocketFactory sf = new MySSLSocketFactory(trustStore); 
      sf.setHostnameVerifier(
        SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); 

      HttpParams params = new BasicHttpParams(); 
      HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); 
      HttpProtocolParams.setContentCharset(params, HTTP.UTF_8); 

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

      ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry); 

      return new DefaultHttpClient(ccm, params); 
     } catch (Exception e) { 
      return new DefaultHttpClient(); 
     } 
    } 

} 

Fase 3 : Crea un metodo all'interno della tua attività o altrove, questo metodo verrà utilizzato per effettuare una chiamata web.

/** 
    * Request JSON based web service to get response 
    * 
    * @param url 
    *   - base URL 
    * @param request 
    *   - JSON request 
    * @return response 
    * @throws ClientProtocolException 
    * @throws IOException 
    * @throws IllegalStateException 
    * @throws JSONException 
    */ 
    public HttpResponse request(String url, JSONObject request) 
      throws ClientProtocolException, IOException, IllegalStateException, 
      JSONException { 

     DefaultHttpClient client = (DefaultHttpClient) WebClientDevWrapper.getNewHttpClient(); 

      HttpPost post = new HttpPost(url); 
      post.setEntity(new StringEntity(request.toString(), "utf-8")); 
      HttpResponse response = client.execute(post); 
      return response; 
     } 
    } 

Fase 4: chiamare un metodo e ottenere la risposta.

Answer 2

sto utilizzando i seguenti codici per la combinazione di https/http/wift/3G, speriamo vi sia utile

public class CustomHttpClient { 
private static DefaultHttpClient customHttpClient; 

/** A private Constructor prevents instantiation */ 
private CustomHttpClient() { 
} 

public static synchronized DefaultHttpClient getHttpClient() { 
    if (customHttpClient == null) { 
     HttpParams params = new BasicHttpParams(); 
     HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); 
     HttpProtocolParams.setContentCharset(params, 
       HTTP.DEFAULT_CONTENT_CHARSET); 
     HttpProtocolParams.setUseExpectContinue(params, true); 
     HttpProtocolParams.setUserAgent(params, "Mozilla/5.0 (Linux; U; Android 2.2.1; en-us; Nexus One Build/FRG83) AppleWebKit/533.1(KHTML, like Gecko) Version/4.0 Mobile Safari/533.1"); 
     ConnManagerParams.setTimeout(params, 1000); 
     HttpConnectionParams.setConnectionTimeout(params, 5000); 
     HttpConnectionParams.setSoTimeout(params, 10000); 
     SchemeRegistry schReg = new SchemeRegistry(); 
     schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); 
     schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); 
     ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params,schReg); 
     customHttpClient = new DefaultHttpClient(conMgr, params); 
    } 
    return customHttpClient; 
} 

public Object clone() throws CloneNotSupportedException { 
    throw new CloneNotSupportedException(); 
} 

}

e il campione

public static String Call(String URL, List<NameValuePair> postParameters) 
{ 
    BufferedReader in = null; 
    DefaultHttpClient httpClient; 
    StringBuffer sb = new StringBuffer(); 
    try{ 
     httpClient = CustomHttpClient.getHttpClient(); 

     HttpProtocolParams.setUseExpectContinue(httpClient.getParams(), false); //making 3G network works* 
     HttpPost request = new HttpPost(URL); 
     UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(postParameters); 
     request.setEntity(formEntity); 
     HttpResponse response = httpClient.execute(request); 
     in = new BufferedReader(new InputStreamReader(response.getEntity().getContent())); 
     String line = ""; 
     String NL = System.getProperty("line.separator"); 
     while ((line = in.readLine()) != null) { 
     sb.append(line + NL); 
     } 
     in.close(); 

    }catch(Exception ex) 
    { 
     ex.printStackTrace(); 

    } 
    return sb.toString(); 
}