본문 바로가기
[ Developer ]/Android

[Android] 안드로이드 웹 서버 연동 Android to Spring

by 김현섭. 2016. 7. 29.
336x280(권장), 300x250(권장), 250x250, 200x200 크기의 광고 코드만 넣을 수 있습니다.
Android Spring 연동

@ 연동이 필요한 이유
  • 안드로이드는 외부의 Remote DB를 접근이 불가능하다
    • 안드로이드는 Web Server로 통신을 하고
    • Web Server가 Remote DB를 접근해서 다시 돌려주게 된다
  • 기존의 Web Server 방식
    • 기존에 Web Server가 Web Brower와 통신을 할 때는 HTML로 렌더링을 해준다
    • 하지만 Android에서는 HTML로 받을 필요가 없다
  • Android to Web Server 방식
    • HTML로 받을 필요가 없기 때문에 JSON으로 요청을 하고 JSON으로 결과를 받는다
  • Web Server가 2가지를 받아야 한다
    • 모바일 용
      • JSON 리턴
    • 웹 브라우저용
      • HTML 리턴
    • 모바일이나 웹 브라우저나 같은 기능을 수행한다 
    • 리턴만 달라질 뿐이지 수행은 같다
  • 모바일로 받는 방식 즉 JSON을 가지고 처리하는 방식 AJAX와 비슷한 로직이다
  • Open API / restFul API
    • 모바일이며 웹이며 구분해서 같은 기능을 수행하게 끔 보장해 주는 것

Android와 Spring을 연동하기 위해 우선 Spring 프로젝트를 하나 생성한다
Spring 프로젝트 생성 후 Spring 세팅을 우선 해준다

그런 후 간단하게 article패키지로 Controller를 생성한다


RequestMapping으로 /android를 하나 맵핑시킨다 우선은 테스트를 진행해보기 위해서 sysout을 통해서 콘솔에 테스트해본다

 


잘 뜬 것을 볼 수 있다 이제는 자신의 IP를 알아 둔다
그런 후 이제 Android Studio에서 프로젝트를 하나 생성한다
My Remote Web 이란 프로젝트 이름으로 생성한다

이제는 HttpClient로 클래스를 생성하여 다음의 소스를 붙여넣는다
다음의 소스는 HTTP로 요청을 보낼 때 간단하게 사용할 수 있는 클래스이다

*HttpClient - source
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
package com.ktds.hskim.myremoteweb;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
 
 
public class HttpClient {
 
    private static final String WWW_FORM = "application/x-www-form-urlencoded";
 
    private int httpStatusCode;
    private String body;
 
    public int getHttpStatusCode() {
        return httpStatusCode;
    }
 
    public String getBody() {
        return body;
    }
 
    private Builder builder;
 
    private void setBuilder(Builder builder) {
        this.builder = builder;
    }
 
    public void request() {
        HttpURLConnection conn = getConnection();
        setHeader(conn);
        setBody(conn);
        httpStatusCode = getStatusCode(conn);
        body = readStream(conn);
        conn.disconnect();
    }
 
    private HttpURLConnection getConnection() {
        try {
            URL url = new URL(builder.getUrl());
            return (HttpURLConnection) url.openConnection();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
 
    private void setHeader(HttpURLConnection connection) {
        setContentType(connection);
        setRequestMethod(connection);
 
        connection.setConnectTimeout(5000);
        connection.setDoOutput(true);
        connection.setDoInput(true);
    }
 
    private void setContentType(HttpURLConnection connection) {
        connection.setRequestProperty("Content-Type", WWW_FORM);
    }
 
    private void setRequestMethod(HttpURLConnection connection) {
        try {
            connection.setRequestMethod(builder.getMethod());
        } catch (ProtocolException e) {
            e.printStackTrace();
        }
    }
 
    private void setBody(HttpURLConnection connection) {
 
        String parameter = builder.getParameters();
        if ( parameter != null && parameter.length() > 0 ) {
            OutputStream outputStream = null;
            try {
                outputStream = connection.getOutputStream();
                outputStream.write(parameter.getBytes("UTF-8"));
                outputStream.flush();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if ( outputStream != null )
                        outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
 
    }
 
    private int getStatusCode(HttpURLConnection connection) {
        try {
            return connection.getResponseCode();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        return -10;
    }
 
    private String readStream(HttpURLConnection connection) {
        String result = "";
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line = null;
            while ( (line = reader.readLine()) != null ) {
                result += line;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(reader != null)
                    reader.close();
            } catch (IOException e) {}
        }
 
        return result;
    }
 
    public static class Builder {
 
        private Map<StringString> parameters;
        private String method;
        private String url;
 
        public String getMethod() {
            return method;
        }
 
        public String getUrl() {
            return url;
        }
 
        public Builder(String method, String url) {
            if(method == null) {
                method = "GET";
            }
            this.method = method;
            this.url = url;
            this.parameters = new HashMap<StringString>();
        }
 
        public void addOrReplace(String key, String value) {
            this.parameters.put(key, value);
        }
 
        public void addAllParameters(Map<StringString> param) {
            this.parameters.putAll(param);
        }
 
        public String getParameters() {
            return generateParameters();
        }
 
        public String getParameter(String key) {
            return this.parameters.get(key);
        }
 
        private String generateParameters() {
            StringBuffer parameters = new StringBuffer();
 
            Iterator<String> keys = getKeys();
 
            String key = "";
            while ( keys.hasNext() ) {
                key = keys.next();
                parameters.append(String.format("%s=%s", key, this.parameters.get(key)));
                parameters.append("&");
            }
 
            String params = parameters.toString();
            if ( params.length() > 0 ) {
                params = params.substring0, params.length() - 1 );
            }
 
            return params;
        }
 
        private Iterator<String> getKeys() {
            return this.parameters.keySet().iterator();
        }
 
        public HttpClient create() {
            HttpClient client = new HttpClient();
            client.setBuilder(this);
            return client;
        }
 
    }
 
}
 
cs

그런 후 AsyncTask를 선언해준다


위와 같이 AsyncTask를 상속받아 처리하고 3가지 메소드를 생성한다




위와 같이 3가지 메소드를 이용해서 Web Server로 응답을 보내고 받을 수 있게 된다
그런 후 위의 onCreate에서 NetworkTask를 추가해주면 된다


그런 후에 manifests에서 INTERNET 권한을 추가해주면 된다


이제 AVD를 이용해서 실행을 시켜본다


위와 같은 실행화면이 뜨고 STS로 가보면 콘솔창에 안드로이드가 떠있다면 문제없는 것이다



*NetworkTask - class
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    public class NetworkTask extends AsyncTask<StringStringString> {
        /**
         * doInBackground 이전
         */
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }
 
        /**
         * 실제로 등장하는 on 작업을 Thread로 처리
         *
         * @param params
         * @return
         */
        @Override
        protected String doInBackground(String... params) {
 
            // HTTP 요청 준비 작업
            HttpClient.Builder http = new HttpClient.Builder("POST""http://10.225.152.165:8080/SpringToAndroid/android");
 
            // HTTP 요청 전송
            HttpClient post = http.create();
            post.request();
 
            // 응답 상태코드 가져오기
            int statusCode = post.getHttpStatusCode();
 
            // 응답 본문
            String body = post.getBody();
 
            return body;
        }
 
        /**
         * doInBackground 이후
         * @param s
         */
        @Override
        protected void onPostExecute(String s) {
            Log.d("HTTP_RESULT", s);
        }
    }
cs


@ Parameter 전송
이제 Parameter Test를 해보기 위해서 STS의 Controller에서 또 하나의 맵핑을 만든다


그리고 나서 Android Studio에서 파라미터를 넣어본다


http.addOrReplace라는 메소드가 존재하는데 key와 value 형태로 보낼 수 있다
이제 테스트를 해보기 위해서 STS에서 서버를 재 가동한 후 
Android에서 URL을 2로 바꾸고 실행을 해본다

그러면 콘솔에 파라미터 값이 찍힌 것을 볼 수 있다