홈으로 홈으로 | 무료회원가입 | 아이디/비번찾기 | 즐겨찾기
추천음악방송메인홈1대1상담음악방송청취
뽕짝아가씨(무료음악채널)
okTrot(무료음악채널)
전통가요(무료음악채널)

온라이브스토어(앱다운로드)
온라이브(방송등록및청취)

환상의뽕짝파티 무료음악
명작트로트메들리 무료음악
트로트메들리관광 무료음악
동영상노래방
가사검색

POP Player
신나는 고스톱
컴퓨터 오목
작은 음악다방
자동러시 웹플레이어신청

보안∵서버∵쿠키
윈도우∵프레임
이미지∵배경
시간∵달력∵계산
상태바∵타이틀바
음악∵영상
폼∵전송∵테이블
키보드∵마우스
효과∵링크∵메뉴
Script∵php
기타
PHP 강좌
윈도우관련팁
웹관련팁
홈페이지제작팁
기본강좌
레지스트리
윈도우서버
리눅스서버
Android
http 요청 [Android]
2년 전
서론
현재 시중에 나와 있는 안드로이드 책은 모두 Http로 데이터를 요청하는 예제만 수록하고 있다. 하지만 안드로이드 앱을 개발할 때 http 요청만 처리하는 것이 아니다. https 요청을 http와 동일하게 사용할수는 없다. 이번 프로젝트에서 https로 로그인 관련 작업을 하면서 우리가 안드로이드를 개발할 때 흔히 사용하는HttpClient로 https를 요청할 수 없다는 것을 확인하고 방법을 찾아서 해결했는데 그 방법에 대해서 포스팅하고자 한다.

Https 서버구축

첫번째로 우리가 해야할 일은 Https 서버를 구축해야한다. 하지만 개인 앱 개발자는 대부분 서버를 가지고 있지 않거나, 서버 작업을 하기 힘든 상황이다. 그래서 이전 포스팅에 OpenSSL과 Node.js를 사용해서 Https 서버를 구축할 수 있는 방법을 소개했다. http://blog.saltfactory.net/221 글을 참조해서 Https 서버를 만들어보자. https로 로그인하는 예제를 만들것이기 때문에 다음과 같이 POST로 /login 요청이 들어오는 부분을 수정한다.

var http=require('http'),
    https = require('https'),
    express = require('express'),
    fs = require('fs');

var options = {
    key: fs.readFileSync('key.pem'),
    cert: fs.readFileSync('cert.pem')
};


var port1 = 80;
var port2 = 443;

var app = express();
app.use(express.urlencoded());
app.use(express.logger());

http.createServer(app).listen(port1, function(){
  console.log("Express server listening on port " + port1);
});


https.createServer(options, app).listen(port2, function(){
  console.log("Express server listening on port " + port2);
});


app.get('/', function (req, res) {
    res.writeHead(200, {'Content-Type' : 'text/html'});
    res.write('<h3>Welcome</h3>');
    res.write('<a href="/login">Please login</a>');
    res.end();
});

app.get('/login', function (req, res){
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write('<h3>Login</h3>');
    res.write('<form method="POST" action="/login">');
    res.write('<label name="userId">UserId : </label>')
    res.write('<input type="text" name="userId"><br/>');
    res.write('<label name="password">Password : </label>')
    res.write('<input type="password" name="password"><br/>');
    res.write('<input type="submit" name="login" value="Login">');
    res.write('</form>');
    res.end();
})

// app.post('/login', function (req, res){
//  var userId = req.param("userId");
//  var password = req.param("password")
//
//  res.writeHead(200, {'Content-Type': 'text/html'});
//  res.write('Thank you, '+userId+', you are now logged in.');
//  res.write('<p><a href="/"> back home</a>');
//  res.end();
// });

app.post('/login', function (req, res){
        var userId = req.param("userId");
        var password = req.param("password")

    res.json({userId:userId, password:password});
});
테스트 프로젝트 생성 및 HttpClient 요청

Https 요청을 테스트하기 위해서 간단한 안드로이드 프로젝트를 생성한다. 버튼을 가지고 있고 버튼을 누르면 https를 요청하는 간단한 예제이다. 최종 소스코드는 github에 공개할 예정이다. 우선 간단히 안드로이드 프로젝트를 생성해서 onCreate 메소드 안에 다음과 같이 버튼을 클릭할때 온클릭 리스너를 등록한다. 서버로 넘기는 데이터는 userId와 password 이다. 서버로 데이터를 넘기면 json 데이터를 받아와서 console에 출력하는 간단한 코드이다.

HttpClient를 DefaultHttpClient로 요청

흔히 우리가 http 요청을 처리할 때 DefaultHttpClient를 사용한다. 다음 코드는 HttpClient를 DefaultHttpClient로 사용하는 예제이다. 여기서 urlString은 여러분들이 테스트하는 ip를 입력하면 된다. 공유기로 사설네트워크에서 테스트를 진행했기 때문에 현재 맥북프로의 http 서버 ip는 192.168.1.101 이다.

public class MyActivity extends Activity {
    final String TAG = "saltfactory.net";

    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Button buttonGet = (Button) findViewById(R.id.sf_button_post);
        buttonGet.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {


                Thread thread = new Thread() {
                    @Override
                    public void run() {
                        HttpClient httpClient = new DefaultHttpClient();


                        String urlString = "http://192.168.1.101/login";
                        try {
                            URI url = new URI(urlString);

                            HttpPost httpPost = new HttpPost();
                            httpPost.setURI(url);

                            List<BasicNameValuePair> nameValuePairs = new ArrayList<BasicNameValuePair>(2);
                            nameValuePairs.add(new BasicNameValuePair("userId", "saltfactory"));
                            nameValuePairs.add(new BasicNameValuePair("password", "password"));

                            httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));


                            HttpResponse response = httpClient.execute(httpPost);
                            String responseString = EntityUtils.toString(response.getEntity(), HTTP.UTF_8);

                            Log.d(TAG, responseString);

                        } catch (URISyntaxException e) {
                            Log.e(TAG, e.getLocalizedMessage());
                            e.printStackTrace();
                        } catch (ClientProtocolException e) {
                            Log.e(TAG, e.getLocalizedMessage());
                            e.printStackTrace();
                        } catch (IOException e) {
                            Log.e(TAG, e.getLocalizedMessage());
                            e.printStackTrace();
                        }

                    }
                };


                thread.start();
            }
        });

    }

}
결과는 다음과 같다. 단순하게 http요청을 DefaultHttpClient로 요청한 데이터는 POST를 정상적으로 처리하고 응답을 json으로 받아 왔다.



그러면 http 요청이 아닌 https를 DefaultHttpClient로 요청하면 어떤 결과가 나타나는지 살펴보자. urlString을 http://에서 https://로 변경하고 실행한다.



결과는 No Peer Certificate라는 에러를 발생시키면서 요청을 제대로 완료하지 못한다는 것을 확인할 수 있다. 왜냐면 https는 인증서를 인증하는 과정이 있어야하는데 http는 단순 http 요청만 처리하기 때문이다.

HttpClient에 SSLSocketFactory 속성 추가

흔히 우리가 Http 요청을 할 때 사용하는 HttpClient는 DefaultHttpClient 이다. 하지만 이렇게 구현하면 Https 요청을 할 수 없다. 그래서 HttpClient에 SSLSocketFactory를 사용해서 SSL 인증을 할 수 있도록 속성을 추가한다. 먼저 SSLSocketFactory를 상속받아 다음과 같이 SSLSocketFactory를 만든다.

package net.saltfactory.tutorial.httpsdemo;

import org.apache.http.conn.ssl.SSLSocketFactory;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.*;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

/**
* Created by saltfactory on 1/27/14.
*/
public class SFSSLSocketFactory extends SSLSocketFactory {
    SSLContext sslContext = SSLContext.getInstance("TLS");

    public SFSSLSocketFactory(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);
//        sslContext.init(null, new TrustManager[] { tm }, new SecureRandom());
    }

    @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();
    }
}
다음은 https를 요청하기 위해서 DefaultHttpClient를 생성한 곳에 다음과 같이 수정한다.

package net.saltfactory.tutorial.httpsdemo;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
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.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.KeyStore;
import java.util.ArrayList;
import java.util.List;

public class MyActivity extends Activity {
    final String TAG = "saltfactory.net";

    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Button buttonGet = (Button) findViewById(R.id.sf_button_post);
        buttonGet.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {


                Thread thread = new Thread() {
                    @Override
                    public void run() {
                        //HttpClient HttpClient = new DefaultHttpClient();
                        HttpClient httpClient = getHttpClient();


                        String urlString = "https://192.168.1.101/login";
                        try {
                            URI url = new URI(urlString);

                            HttpPost httpPost = new HttpPost();
                            httpPost.setURI(url);

                            List<BasicNameValuePair> nameValuePairs = new ArrayList<BasicNameValuePair>(2);
                            nameValuePairs.add(new BasicNameValuePair("userId", "saltfactory"));
                            nameValuePairs.add(new BasicNameValuePair("password", "password"));

                            httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));


                            HttpResponse response = httpClient.execute(httpPost);
                            String responseString = EntityUtils.toString(response.getEntity(), HTTP.UTF_8);

                            Log.d(TAG, responseString);

                        } catch (URISyntaxException e) {
                            Log.e(TAG, e.getLocalizedMessage());
                            e.printStackTrace();
                        } catch (ClientProtocolException e) {
                            Log.e(TAG, e.getLocalizedMessage());
                            e.printStackTrace();
                        } catch (IOException e) {
                            Log.e(TAG, e.getLocalizedMessage());
                            e.printStackTrace();
                        }

                    }
                };

                thread.start();
            }
        });


    }

    private HttpClient getHttpClient() {
        try {
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            trustStore.load(null, null);

            SSLSocketFactory sf = new SFSSLSocketFactory(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();
        }
    }
}
이렇게 코드를 SFSSLFactory를 추가해서 HttpClient에 Scheme을 두가지로 추가했다. http와 https를 처리할 수 있는 Scheme을 가지게 하였고 SSL 인증을 TLS로 HostNameVerifier를 처리하게 했다. 이제 다시 실행을 해보자.



정상적으로 https로 데이터를 요청해서 응답을 받아 온 것을 확인할 수 있다. WireShark로 패킷을 캡쳐해보면 테스트를 진행한 안드로이드 디바이스에서 https로 요청했고 TLS로 보안 요청을 처리한 것을 확인할 수 있다.



HttpURLConnection 사용

안드로이드에서 Http 요청을 처리하는데 HttpClient를 사용하는 방법 말고 또다른 방법이 있는데 바로 HttpURLConnection을 사용하는 방법이다. 위에서 DefaultHttpClient를 사용한 코드를 다음과 같이 HttpURLConnection으로 변경한다.

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Button buttonGet = (Button) findViewById(R.id.sf_button_post);
        buttonGet.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {


                Thread thread = new Thread() {
                    @Override
                    public void run() {
//                      HttpClient HttpClient = new DefaultHttpClient();


                        String urlString = "http://192.168.1.101/login";
//                        try {
//                            URI url = new URI(urlString);
//
//                            HttpPost httpPost = new HttpPost();
//                            httpPost.setURI(url);
//
//                            List<BasicNameValuePair> nameValuePairs = new ArrayList<BasicNameValuePair>(2);
//                            nameValuePairs.add(new BasicNameValuePair("userId", "saltfactory"));
//                            nameValuePairs.add(new BasicNameValuePair("password", "password"));
//
//                            httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
//
//
//                            HttpResponse response = httpClient.execute(httpPost);
//                            String responseString = EntityUtils.toString(response.getEntity(), HTTP.UTF_8);
//
//                            Log.d(TAG, responseString);
//
//                        } catch (URISyntaxException e) {
//                            Log.e(TAG, e.getLocalizedMessage());
//                            e.printStackTrace();
//                        } catch (ClientProtocolException e) {
//                            Log.e(TAG, e.getLocalizedMessage());
//                            e.printStackTrace();
//                        } catch (IOException e) {
//                            Log.e(TAG, e.getLocalizedMessage());
//                            e.printStackTrace();
//                        }
//
                        try {
                            URL url = new URL(urlString);

                            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                            connection.setRequestMethod("POST");
                            connection.setDoInput(true);
                            connection.setDoOutput(true);

                            List<BasicNameValuePair> nameValuePairs = new ArrayList<BasicNameValuePair>(2);
                            nameValuePairs.add(new BasicNameValuePair("userId", "saltfactory"));
                            nameValuePairs.add(new BasicNameValuePair("password", "password"));

                            OutputStream outputStream = connection.getOutputStream();
                            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8"));
                            bufferedWriter.write(getURLQuery(nameValuePairs));
                            bufferedWriter.flush();
                            bufferedWriter.close();
                            outputStream.close();

                            connection.connect();


                            StringBuilder responseStringBuilder = new StringBuilder();
                            if (connection.getResponseCode() == HttpURLConnection.HTTP_OK){
                                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                                for (;;){
                                    String stringLine = bufferedReader.readLine();
                                    if (stringLine == null ) break;
                                    responseStringBuilder.append(stringLine + '\n');
                                }
                                bufferedReader.close();
                            }

                            connection.disconnect();

                            Log.d(TAG, responseStringBuilder.toString());



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


                    }
                };

                thread.start();
            }
        });
    }

    private String getURLQuery(List<BasicNameValuePair> params){
        StringBuilder stringBuilder = new StringBuilder();
        boolean first = true;

        for (BasicNameValuePair pair : params)
        {
            if (first)
                first = false;
            else
                stringBuilder.append("&");

            try {
                stringBuilder.append(URLEncoder.encode(pair.getName(), "UTF-8"));
                stringBuilder.append("=");
                stringBuilder.append(URLEncoder.encode(pair.getValue(), "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }

        return stringBuilder.toString();
    }
디바이스에서 실행을 해보자. 앞에서 HttpClient에 DefaultHttpClient로 요청한 결과를 HttpURLConnection으로 동일하게 받을 수 있는 것을 확인할 수 있다.



HttpsURLConnection을 사용하기

앞에서 살펴봤듯 안드로이드에서 http요청을 HttpClient를 사용하는 대신에 HttpURLConnection을 사용하듯, Https를 요청하는 방법은 HttpClient를 SSLSocketFactory를 사용하는 방법 말고도 HttpsURLConnection을 이용하는 방법이 있다. 위의 HttpURLConnection을 사용한 코드를 다음과 같이 수정한다.

package net.saltfactory.tutorial.httpsdemo;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
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.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.*;
import java.io.*;
import java.net.*;
import java.security.KeyStore;
import java.util.ArrayList;
import java.util.List;

public class MyActivity extends Activity {
    final String TAG = "saltfactory.net";

    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Button buttonGet = (Button) findViewById(R.id.sf_button_post);
        buttonGet.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {


                Thread thread = new Thread() {
                    @Override
                    public void run() {
                        //HttpClient HttpClient = new DefaultHttpClient();
//                        HttpClient httpClient = getHttpClient();

                        String urlString = "https://192.168.1.101/login";

                        try {
                            URL url = new URL(urlString);

//                            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

                            trustAllHosts();

                            HttpsURLConnection httpsURLConnection = (HttpsURLConnection) url.openConnection();
                            httpsURLConnection.setHostnameVerifier(new HostnameVerifier() {
                                @Override
                                public boolean verify(String s, SSLSession sslSession) {
                                    return true;
                                }
                            });

                            HttpURLConnection connection = httpsURLConnection;

                            connection.setRequestMethod("POST");
                            connection.setDoInput(true);
                            connection.setDoOutput(true);

                            List<BasicNameValuePair> nameValuePairs = new ArrayList<BasicNameValuePair>(2);
                            nameValuePairs.add(new BasicNameValuePair("userId", "saltfactory"));
                            nameValuePairs.add(new BasicNameValuePair("password", "password"));

                            OutputStream outputStream = connection.getOutputStream();
                            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8"));
                            bufferedWriter.write(getURLQuery(nameValuePairs));
                            bufferedWriter.flush();
                            bufferedWriter.close();
                            outputStream.close();

                            connection.connect();


                            StringBuilder responseStringBuilder = new StringBuilder();
                            if (connection.getResponseCode() == HttpURLConnection.HTTP_OK){
                                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                                for (;;){
                                    String stringLine = bufferedReader.readLine();
                                    if (stringLine == null ) break;
                                    responseStringBuilder.append(stringLine + '\n');
                                }
                                bufferedReader.close();
                            }

                            connection.disconnect();

                            Log.d(TAG, responseStringBuilder.toString());



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


                    }
                };

                thread.start();
            }
        });

    }

    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[]{};
            }

            @Override
            public void checkClientTrusted(
                    java.security.cert.X509Certificate[] chain,
                    String authType)
                    throws java.security.cert.CertificateException {
                // TODO Auto-generated method stub

            }

            @Override
            public void checkServerTrusted(
                    java.security.cert.X509Certificate[] chain,
                    String authType)
                    throws java.security.cert.CertificateException {
                // TODO Auto-generated method stub

            }
        }};

        // 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 String getURLQuery(List<BasicNameValuePair> params){
        StringBuilder stringBuilder = new StringBuilder();
        boolean first = true;

        for (BasicNameValuePair pair : params)
        {
            if (first)
                first = false;
            else
                stringBuilder.append("&");

            try {
                stringBuilder.append(URLEncoder.encode(pair.getName(), "UTF-8"));
                stringBuilder.append("=");
                stringBuilder.append(URLEncoder.encode(pair.getValue(), "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }

        return stringBuilder.toString();
    }


}
이제 디바이스에서 실행을 해보자. 다음과 같이 HttpURLConnection을 실행한 결과와 동일하게 동작하는 것을 확인 할 수 있다.



결론
우리는 안드로이드 앱을 개발할 때 Http 요청을 HttpClient를 사용했다. 그리고 DefaultHttpClient를 사용해서 POST나 GET 요청을 했는데 Http 요청은 HttpURLConnection으로도 할 수 있다는 것을 확인 했다. 하지만 Https는 DefaultHttpClient와 HttpURLConnection을 사용할 수 없다. 이유는 인증처리하는 속성이 있어야하는데 DefaultHttpClient와 HttpURLConnection은 SSL 인증 처리가 없기 때문이다. 그래서 HttpClient에 SSLSocketFactory를 사용했고 HttpURLConnection을 HttpsURLConnection으로 사용해서 인증처리 속성을 가지게 할 수 있다는 것을 확인했다.

소스코드
https://github.com/saltfactory/saltfactory-android-tutorial/tree/sf-https-demo
참고
http://stackoverflow.com/questions/9767952/how-to-add-parameters-to-httpurlconnection-using-post
http://cafe.naver.com/jzsdn/21091
http://stackoverflow.com/questions/2642777/trusting-all-certificates-using-httpclient-over-https
추천추천 : 126 추천 목록
번호 제목
1,317
 프로그램 없이 하드디스크 복사 및 백업하기
1,316
 Windows7 업데이트 기록 삭제방법
1,315
 포토샵 psd 파일 연결 레지스트리(registry) 편집
1,314
 윈도 10 최신 업데이트 후 인터넷 속도의 저하가 발생할 때 조치 사항
1,313
 Autotuning level 해제 (윈도우비스타 이상 윈도우)인터넷 속도 빠르게 하는 방법
1,312
 윈도우에서 특정프로세스를 일괄 종료하는법
1,311
 MediaPlayer 클래스 사용법
1,310
 안드로이드에서 audio player 실행하기
1,309
 [Android] MediaPlayer 음악재생기 만들기
1,308
 Eclipse와 Android NDK 연동하기
1,307
 Android Sliding Drawer Functionality 안드로이드 슬라이딩 드로우 예제 sample
1,306
 Android Speech To Text
1,305
 Android WebPageLoader with progress-bar
1,304
 Android Text To Speech(TTS)
1,303
 Android Playing Audio from a web url
1,302
 Button height different from background height in Android image design
1,301
 Android Getting Started with Material Design
1,300
 Using toast inside timertask perfect
1,299
 네트워크 상태 [Android]
1,298
 Webview source [Android]
1,297
 공유 Intent [Android]
1,296
 intent uri 모음 [Android]
1,295
 http requestWebViewClient [Android]
1,294
 캐시 삭제
1,293
 캐시 지우기 [Android]
1,292
 바로풀어(수학 문제 질의응답 SNS) 에 사용된 오픈소스 라이브러리 [Android]
1,291
 Webviw [Android]
1,290
 오픈소스 라이브러리 모음 [Android]
1,289
 Android webview 개발시 알아둬야 할 것들 [Android]
1,288
 webview 동영상 재생 [Android]
1,287
 [Android] Webview 404 에러 처리
1,286
 [Android] webview ssl 문제
1,285
 [Android] Webview url 숨기기
1,284
 [Android] AlarmManager 일정시간 이벤트 실행
1,283
 안드로이드 오픈소스 끝판
목록
인기절정뽕짝파티
트로트재생목록
인기트로트모음
지루박디스코메들리
밤무대애창곡
전자올겐경음악
종합성인가요방
못잊을옛날노래
카바레 음악
트롯디스코팡팡
관광 메들리
트롯카페
가요감상실
추억의옛노래
스페셜가요광장
BillBoard Free
추천가요모음
경음악.전자올겐
스페셜음악여행
WOLRD POPs
K-POP\BillBoard
JP\CN
POP TOP BEST
K.R.노래방

추천가요\인기
F뮤직 인기\발라드
F뮤직 애창\트로트
트로트성인가요
인기가요
프리미엄 POP
경음악\기타
프리미엄 최신가요
프리미엄 성인가요
가요1번지(종합)
뮤직하우스
동요\연변\반주\기타
가요축제\트롯1번지
댄스\메들리\리믹스
카페\명상\경음악\기타
뮤직트로트 부산광역시부산진구 가야동 ㅣ 개인정보취급방침
Copyright (C) musictrot All rights reserved.