개요

이 기사는 다음과 같은 섹션으로 구성된다.

• 환경 설정
• JAX-RS 웹 서비스 자원 작성
• Maven 플러그인 설치
• Spring Android 클라이언트 작성
• Maven 플러그인과 종속 항목 구성
• Android Maven 목표 구성
• Spring 클라이언트 Android 애플리케이션 실행

위로

환경 설정

환경을 설정하려면 다음과 같은 태스크를 완료한다. (링크는 참고자료를 참조한다.)

• Eclipse IDE를 설치한다.
• Eclipse용 ADT(Android Development Tools) 플러그인을 설치한다. Eclipse용 ADT 플러그인은 Eclipse로 Android 애플리케이션을 개발하는 데 필요한 확장 세트를 제공한다.
• SDK Platform Android 2.2를 설치한다. Android SDK에는 Android 애플리케이션을 개발하는 데 필요한 도구가 있다.
• Eclipse에서 Android용 에뮬레이터인 AVD(Android Virtual Device)를 작성한다.
• 또한, WebSphere나 WebLogic 서버와 같은 애플리케이션 서버나 Tomcat과 같은 웹 서버를 설치해야 한다.
• Jersey jar 파일과 핵심 종속 항목이 들어 있는 Jersey 아카이브(jersey-archive-1.4.zip)를 다운로드한다. Jersey 번들(JAR jersey-bundle-1.4.jar)도 다운로드한다. 또한, Jersey는 JDK 6.0을 사용하여 빌드되었으므로 JDK 6.0을 설치해야 한다. 목록 1에 있는 JAR 파일을 애플리케이션 서버와 웹 서버의 런타임 CLASSPATH에 추가한다.
  
  목록 1. 서버의 CLASSPATH에 추가할 JAR 파일
  

  C:\Jersey\jersey-bundle-1.4.jar;C:\Jersey\jersey-archive-1.4\lib\asm-3.1.jar; C:\Jersey\jersey-archive-1.4\lib\jsr311-api-1.1.1.jar

  
  
• Spring Android 프로젝트 ZIP 파일을 다운로드한다. 이 ZIP 파일을 디렉토리에 추출한다.

위로

JAX-RS 웹 서비스 자원 작성

이 섹션에서는 JAX-RS 웹 서비스 자원을 위한 Spring 클라이언트를 작성한다. JAX-RS 웹 서비스는 각각 MIME 유형이 다른 서로 다른 세 가지 유형(text/plain, text/xml 및 text/html)의 메시지를 생성한다.

먼저, Eclipse 프로젝트를 작성한다.

1. 웹 프로젝트를 작성하고 이 프로젝트에 JAX-RS 패싯을 추가한다. File > New를 선택하고 New 창에서 Web > Dynamic Web Project를 선택한다.
2. Next를 클릭한다. 프로젝트 이름을 지정하고 WebSphere, Tomcat 또는 WebLogic 서버를 위한 대상 런타임을 새로 구성한다.
3. default project settings를 선택하고 Finish를 클릭한다.

Eclipse에서 동적 웹 프로젝트가 작성되면 이 프로젝트를 Project Explorer에 추가한다.

1. Project Properties 창에서 JAX-RS(REST Web Services) 1.1 프로젝트 패싯을 구성한다.
2. JAX-RS Capabilities 창에서 Servlet name을 JAX-RS Servlet으로 지정하고 JAX-RS Implementation Library를 구성하고 Jersey JAR 파일을 사용자 라이브러리에 추가한다.
3. Jersey JAR 파일인 jersey-bundle-1.4.jar, C:\Jersey\jersey-archive-1.4\lib\asm-3.1.jar 및 C:\Jersey\jersey-archive-1.4\lib\jsr311-api-1.1.1.jar를 추가한다.
4. JAX-RS Capabilities 창에서 JAX-RS 서블릿 클래스의 이름을 com.sun.jersey.spi.container.servlet.ServletContainer로 지정한다.

   JAX-RS 사용자 라이브러리가 추가되고 web.xml에서 JAX-RS 서블릿과 서블릿 맵핑이 구성된다.

5. com.sun.jersey.config.property.resourceConfigClass와 com.sun.jersey.config.property.packages init 매개변수를 위해 init-param 요소를 추가한다.

목록 2에는 web.xml 파일이 표시되어 있다.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
xmlns="http://java.sun.com/xml/ns/javaee" 
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>EclipseJAX-RS</display-name>
  <servlet>
    <description>JAX-RS Tools Generated - Do not modify</description>
    <servlet-name>JAX-RS Servlet</servlet-name>
    <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
    <init-param>  
            <param-name>com.sun.jersey.config.property.resourceConfigClass</param-name>  
            <param-value>com.sun.jersey.api.core.PackagesResourceConfig</param-value>  
        </init-param>  
        <init-param>  
            <param-name>com.sun.jersey.config.property.packages</param-name>  
            <param-value>jaxrs</param-value>  
        </init-param>  
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>JAX-RS Servlet</servlet-name>
    <url-pattern>/jaxrs/*</url-pattern>
  </servlet-mapping>
</web-app>

다음에는 루트 자원 클래스를 사용하여 RESTful 웹 서비스를 작성한다. 루트 자원 클래스는 @PATH로 어노테이션된 POJO이며 @GET으로 어노테이션된 세 개 이상의 메소드로 구성된다. (이는 메소드가 HTTP GET 요청을 처리한다는 점을 나타낸다.) Java 클래스를 호스트할 URI 경로를 /helloworld로 지정한다. 목록 3을 참조한다.

@Path("/helloworld")
public class HelloWorldResource {...
}

서로 다른 세 가지 MIME 유형을 생성할 자원 메소드를 추가한다. 다음 메소드를 자원 클래스에 추가하고 각 메소드를 @GET으로 어노테이션한다.

• getClichedMessage(). MIME 유형 text/plain을 사용하여 "Hello JAX-RS" 메시지를 출력한다.
• getXMLMessage(). MIME 유형 text/xml을 사용하여 "Hello JAX-RS" 메시지를 출력한다.
• getHTMLMessage(). MIME 유형 text/html을 사용하여 "Hello JAX-RS" 메시지를 출력한다.

각 메소드의 리턴 유형을 String으로 지정하고 각 메소드를 @PRODUCES로 어노테이션하고 각 메소드에 맞는 다양한 MIME 유형을 지정한다. getXMLMessage 메소드는 XML 메시지를 생성하는 @Produces("text/xml")로 어노테이션된다. 각 배치를 위해 @GET로 어노테이션된 메소드 중 하나만 주석을 해제한다. 목록 4에는 루트 자원 클래스가 표시되어 있다.

package jaxrs;
import javax.ws.rs.GET;
import javax.ws.rs.Produces;
import javax.ws.rs.Path;
import javax.ws.rs.core.MediaType;


// The Java class will be hosted at the URI path "/helloworld"
@Path("/helloworld")
public class HelloWorldResource {

     // The Java method will process HTTP GET requests
     // @GET
     // The Java method will produce content identified by the MIME Media
     // type "text/plain"
      //@Produces("text/plain")
      //public String getClichedMessage() {
     // Return some cliched textual content
      //return "Hello Android";
      //}

     // @GET
     // @Produces("text/xml")
     // public String getXMLMessage() {
     // return "<?xml version=\"1.0\"?>" + "<hello> //Hello Android" + "</hello>";
     // }

//     @GET
     //@Produces("text/html")
     //public String getHTMLMessage() {
          //return "<html> " + "<title>" + "Hello Android" + "</title>"
          //+ "<body><h1>" + "Hello Android" + "</body></h1>" + "</html> ";
//     }

}

그림 1에는 AndroidJAX-RS 클라이언트의 디렉토리 구조가 표시되어 있다.

다음에는 다양한 유형의 출력을 생성하는 자원 클래스를 실행한다.

1. 각 테스트 실행 과정에서 테스트할 메소드를 주석 해제한다.
2. text/plain MIME 유형을 출력으로 테스트한다.
3. 애플리케이션 서버와 웹 서버를 아직 시작하지 않았다면 지금 시작한다.
4. 마우스 오른쪽 단추로 자원 클래스를 클릭한 후, Run As > Run on Server를 선택한다.

AndroidJAX-RS 애플리케이션이 서버에 배치된다.

위로

Maven 플러그인 설치

여기에서는 Android JAX-RS 웹 서비스에 필요한 Spring 클라이언트용 Android 프로젝트를 빌드하기 위해 소프트웨어 개발 도구인 Apache Maven을 사용한다. Maven 통합 프로젝트를 사용하여 Eclipse에 Maven 지원을 추가한다. Maven을 사용하여 Android 애플리케이션을 개발하는 경우에는 Maven 플러그인과 종속 항목 구성 섹션에서 설치하게 될 Maven Android 플러그인이 필요하다. Maven Integration for Android Development Tools는 Maven Integration 지원을 Android Development Tools와 Maven Android 플러그인에 추가하는 Eclipse 플러그인이다.

Eclipse Marketplace에서 Maven Integration을 Android Development Tools에 설치할 수 있다.

1. Eclipse IDE를 열고 Help > Eclipse Marketplace를 선택한다.
2. Eclipse Marketplace의 Search 탭에 있는 Find 필드에 m2eclipse-android를 지정하고 Go를 클릭한다(그림 2 참조).
   
   그림 2. m2eclipse-android 플러그인 선택
   
   
   
3. 그러면 Search tab 탭에 Maven Integration for Android Development Tools가 표시된다. Install을 클릭한다(그림 3 참조).
   
   그림 3. Maven Integration for Android Development Tools 설치
   
   
   
4. Confirm Selected Features 창에서 Android Development Tools, Maven Integration for Android Development Tools 및 Maven Integration for Eclipse 기능을 선택한다(그림 4 참조). Next를 클릭한다.
   
   그림 4. 설치할 플러그인 선택
   
   
   
5. 라이센스 계약 조항을 수락한 후, Finish를 클릭하여 플러그인 소프트웨어를 설치하는 작업을 완료한다.

   설치된 플러그인을 확인하려면 Help > About Eclipse 및 Installation Details in About Eclipse를 선택한다.

위로

Spring Android 클라이언트 작성

이 섹션에서는 JAX-RS 웹 서비스용 Android Spring 클라이언트 프로젝트를 작성한다. JAX-RS 웹 서비스에 액세스하는 데 필요한 Android Spring 클라이언트를 작성할 Android 프로젝트를 작성한다.

1. Eclipse IDE에서 File > New를 선택한다.
2. New 창에서 Android > Android Project를 선택한다. Next를 클릭한다.
3. New Android Project 창에서 프로젝트 이름(AndroidSpring)을 지정한다.
4. Build Target으로는 Android Platform 2.2 API 8을 선택한다.
5. Properties에는 애플리케이션 이름과 패키지 이름을 지정한다.
6. Create Activity 선택란을 선택하고 그림 5와 같이 Activity 클래스(AndroidSpring)를 지정한다. 활동은 사용자 상호 작용을 나타내며 Activity 클래스를 확장하는 클래스는 UI 창을 작성한다.
7. 그림 5와 같이 Min SDK Version을 8로 지정하고 Finish를 클릭한다.
   
   그림 5. Spring Android 클라이언트 작성
   
   
   

Android 프로젝트는 다음과 같은 파일로 구성된다.

• Activity 클래스를 확장하는 활동 클래스(AndroidSpring)
• Android 애플리케이션의 레이아웃을 지정하는 데 필요한 res/layout/main.xml 파일
• 패키지 이름, 애플리케이션 컴포넌트, 프로세스, 권한 및 Android 시스템의 최소 API 레벨과 같은 애플리케이션 정보가 포함된 AndroidManifest.xml 파일

res/layout/main.xml 파일의 LinearLayout 요소에서 Android UI 컴포넌트의 레이아웃을 지정한다. android:orientation 속성 값을 vertical로 지정한다. 웹 서비스의 응답을 테스트 메시지로 표시하는 UI를 작성한다.

id가 "springmessage"인 TextView 요소를 추가하여, 메소드 호출에 대한 JAX-WS 웹 서비스 응답을 get 메소드 중 하나에 표시한다. 메소드를 호출하면 XML이나 HTML 또는 텍스트 형태의 응답으로 Hello 메시지를 얻게 된다. 목록 5에는 main.xml 파일이 표시되어 있다.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView android:id="@+id/springmessage"
               android:layout_width="fill_parent" 
android:layout_height="wrap_content"/>
</LinearLayout>

Android 디바이스에서 JAX-RS 웹 서비스를 액세스하려면 애플리케이션이 네트워크 소켓을 열 수 있도록 AndroidManifest.xml에서 android.permission.INTERNET 권한을 사용한다. 목록 6과 같이 uses-permission 요소를 추가한다.

 <uses-permission android:name="android.permission.INTERNET"></uses-permission>

uses-sdk 요소를 사용하여 최소 Android 버전을 지정한다. AndroidSpring 활동, intent-filter 및 action은 다음과 같은 요소를 사용하여 지정한다. 목록 7에는 AndroidManifest.xml 파일이 표시되어 있다.

 <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="android.spring" android:versionCode="1" android:versionName="1.0">
     <uses-sdk android:minSdkVersion="8" />
     <application android:icon="@drawable/icon" android:label="@string/app_name">
          <activity android:name=".AndroidSpring" android:label="@string/app_name">
               <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
               </intent-filter>
          </activity>
     </application>
     <uses-sdk android:minSdkVersion="8" />
     <uses-permission 
android:name="android.permission.INTERNET"></uses-permission>
</manifest>

그림 6에는 Eclipse IDE에 표시되어 있는 AndroidManifest.xml 파일이 있다.

Java Build Path를 선택한다. Libraries 탭에서 그림 7과 같이 spring-android-rest-template JAR 파일을 Java 빌드 경로에 추가한다.

org.springframework.web.client.RestTemplate는 RESTful 원리를 구현하며 클라이언트 측 HTTP 액세스를 위한 중심 클래스이다. org.springframework.http 패키지는 기본적으로 클라이언트와 서버측 HTTP상에서 추상화되어 있다.

1. AndroidSpring 클래스는 RestTemplate 클래스와 org.springframework.http 패키지를 가져온다. AndroidSpring 클래스는 Activity 클래스를 확장한다. onCreate(Bundle savedInstanceState) 메소드는 활동이 처음 호출될 때 호출된다.
2. setContentView 메소드와 레이아웃 자원을 사용하여 사용자 인터페이스를 정의한다.

   setContentView(R.layout.main);

   
   
3. main.xml에 정의된 TextView 요소(id가 "springmessage"인)에서 findViewById 메소드를 사용하여 Android 위젯 TextView 오브젝트를 작성한다.

   TextView springmessage = (TextView) findViewById(R.id.springmessage);

   
   
4. HTTP 요청과 응답 헤더를 의미하는 HttpHeaders 오브젝트를 작성한다.

   HttpHeaders requestHeaders = new HttpHeaders();

   
   
5. body의 매체 유형을 Content-Type 헤더에 정의된 대로 설정한다. 매체 유형은 JAX-RS 웹 서비스에서 생성된 매체 유형과 일치한다.

   requestHeaders.setContentType(new MediaType("text","plain"));

   
   
6. 요청 헤더를 구성하는 HTTP 요청 엔티티를 작성한다.

   HttpEntity<String> requestEntity = new HttpEntity<String>(requestHeaders);

   
   
7. 기본 설정으로 생성자를 사용하여 RestTemplate 인스턴스를 새로 작성한다.

   RestTemplate restTemplate = new RestTemplate();

   
   
8. URI 경로 /helloworld에서 호스트되는 자원에 URL을 지정한다.

   String url = "http://192.168.1.68:7001/AndroidJAX-RS/jaxrs/helloworld";

   
   
9. exchange 메소드를 사용하여 요청 엔티티를 해당 요청에 전송하여 지정된 URI 템플리트로 HTTP 메소드를 호출한다. exchange 메소드는 응답으로 ResponseEntity를 리턴한다.

   ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);

   
   
10. getBody 메소드를 사용하여 ResponseEntity에서 응답 문자열을 검색한다.

    ResponseEntity<String> String result = responseEntity.getBody();

    
    
11. TextView UI 컴포넌트에서 문자열 메시지를 설정한다.

    springmessage.setText(result);

    
    

목록 8에는 AndroidSpring 클래스가 표시되어 있다.

package anrdoid.spring;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import org.springframework.web.client.RestTemplate;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;


public class AndroidSpring extends Activity {
    /** Called when the activity is first created. */
    @Override
public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        TextView 
springmessage = (TextView) findViewById(R.id.springmessage);
      //  RestTemplate restTemplate = new RestTemplate();
      //  String url = 

"http://192.168.1.68:7001/AndroidJAX-RS/jaxrs/helloworld";
      //  String result = restTemplate.getForObject(url, String.class);

        HttpHeaders 
requestHeaders = new HttpHeaders();
       requestHeaders.setContentType(new MediaType("text","xml"));
       HttpEntity<String> requestEntity = new HttpEntity<String>(requestHeaders);
        String url = "http://192.168.1.68:7001/AndroidJAX-RS/jaxrs/helloworld";
        RestTemplate restTemplate = new RestTemplate();
ResponseEntity<String> responseEntity = 
restTemplate.exchange(url,  HttpMethod.GET, requestEntity, String.class);
       String result = 
responseEntity.getBody();
        springmessage.setText(result);

    }
}

위로

Maven 플러그인과 종속 항목 구성

Maven으로 프로젝트를 빌드하는 데 사용되는 구성 세부사항은 Maven 프로젝트 오브젝트 모델을 정의하는 pom.xml에 지정되어 있다. 프로젝트 종속 항목, 저장소 및 플러그인은 pom.xml 파일에 지정되어 있는 구성 세부사항 중 일부이다. pom.xml에서 다음과 같은 저장소, 종속 항목 및 플러그인을 구성하게 된다.

• Spring Maven 저장소 - Maven으로 Spring 3 아티팩트를 얻는다.
• Spring Maven Milestone Repository - 최신 Spring 마일스톤으로 개발하는 것이 가능하다.
• Maven Android 플러그인 - Android용 Maven 플러그인이다.
• Maven 컴파일러 플러그인 - 프로젝트 소스를 컴파일한다.
• Google Android 종속성 - Google Android 플랫폼에 대한 종속성을 지정한다.
• Spring Android REST Template Module 종속성 - spring-android-rest-template에 대한 종속성을 지정한다.

먼저, AndroidSpring 웹 프로젝트에서 pom.xml을 작성한다.

1. File > New를 선택한다.
2. New 창에서 XML > XML File을 선택하고 Next를 클릭한다.
3. New XML File 마법사에서 AndroidSpring 폴더를 선택한다.
4. 그림 8과 같이 File Name을 pom.xml로 지정하고 Next를 클릭한다.
   
   그림 8. pom.xml 작성
   
   
   
5. Create XML File from an XML template를 선택하고 Next를 클릭한다.
6. xml 선언 템플리트를 선택한 후, Finish를 클릭한다.

   그러면 그림 9와 같이 SpringAndroid 프로젝트에 pom.xml 구성 파일이 표시된다.

   
   
   그림 9. pom.xml
   
   
   

앞에서 나열된 플러그인, 저장소 및 종속 항목을 구성한다. Spring Maven Snapshot Repository를 지정하려면 다음 값을 설정한다(목록 9 참조).

• <id> 요소에서 org.springframework.maven.snapshot을 지정한다.
• <url> 요소에서 http://maven.springframework.org/snapshot을 지정한다.
• release의 enabled 요소에서 값을 false로 지정한다.
• snapshots의 enabled 요소에서 값을 true로 설정한다.

<repository>
     <id>org.springframework.maven.snapshot</id>
     <name>Spring Maven Snapshot Repository</name>
     <url>http://maven.springframework.org/snapshot</url>
          <releases>
               <enabled>false</enabled>
          </releases>
          <snapshots>
               <enabled>true</enabled>
          </snapshots>
</repository>  

마찬가지로 다음 값을 사용하여 Spring Maven Milestone Repository를 구성한다.

• id 요소에서 org.springframework.maven.milestone을 지정한다.
• releases/enabled 요소에서 true를 지정한다.
• snapshots의 enabled 요소에서 값을 false로 지정한다.

목록 10에 있는 값으로 Maven Android 플러그인을 구성한다.

• groupId 요소에서 com.jayway.maven.plugins.android.generation을 지정한다.
• artifactId 요소에서 maven-android-plugin을 지정한다.
• Maven Android 플러그인의 <configuration> 요소에서 SDK 플랫폼을 8로 지정하고 SDK 경로를 C:/Android/android-sdk로 지정한다.
• Maven Android 플러그인의 <emulator> 요소에서, 사용될 <avd>를 지정한다.

<plugin>
     <groupId>com.jayway.maven.plugins.android.generation2</groupId>
          <artifactId>maven-android-plugin</artifactId>
                    <version>2.8.3</version>
                    <configuration>
                         <sdk>
                    <platform>8</platform>
                         <path>C:/Android/android-sdk</path>
                         </sdk>
                         <emulator>
                              <avd>rhoAndroid30</avd>
                         </emulator>
               <deleteConflictingFiles>true</deleteConflictingFiles>
               <undeployBeforeDeploy>true</undeployBeforeDeploy>
                    </configuration>
                    <extensions>true</extensions>
</plugin>

<dependencies> 요소에서 Google Android 종속성을 <artifactId>를 android로 하여 구성한다. Spring Android REST Template Module에서 <artifactId>를 spring-android-rest-template로 하여 <dependency> 요소를 구성한다. 목록 11에는 pom.xml 구성 파일이 표시되어 있다.

<project
     xsi:schemaLocation=
     "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
     xmlns=
     "http://maven.apache.org/POM/4.0.0" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
     <modelVersion>4.0.0</modelVersion>
     <groupId>anrdoid.spring</groupId>
     <artifactId>spring-demo</artifactId>
     <name>Spring Demo</name>
     <packaging>apk</packaging>
     <version>1.0</version>

     <repositories>         
          <repository>
               <id>org.springframework.maven.snapshot</id>
               <name>Spring Maven Snapshot Repository</name>
               <url>http://maven.springframework.org/snapshot</url>
               <releases>
                    <enabled>false</enabled>
               </releases>
               <snapshots>
                    <enabled>true</enabled>
               </snapshots>
          </repository><!-- For developing against latest Spring milestones -->
          <repository>
               <id>org.springframework.maven.milestone</id>
               <name>Spring Maven Milestone Repository</name>
               <url>http://maven.springframework.org/milestone</url>
               <snapshots>
                    <enabled>false</enabled>
               </snapshots>
          </repository>
     </repositories>
     <build>
          <sourceDirectory>src</sourceDirectory>
          <finalName>${project.artifactId}</finalName>
          <plugins>
               <plugin>
<groupId>com.jayway.maven.plugins.android.generation2</groupId>
               <artifactId>maven-android-plugin</artifactId>
               <version>2.8.3</version>
               <configuration>
                    <sdk>
                         <platform>8</platform>
                         <path>C:/Android/android-sdk</path>
                         </sdk>
                         <emulator>
                              <avd>rhoAndroid30</avd>
                         </emulator>
               <deleteConflictingFiles>true</deleteConflictingFiles>
                         <undeployBeforeDeploy>true</undeployBeforeDeploy>
                    </configuration>
                    <extensions>true</extensions>
               </plugin>
               <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
               </plugin>
          </plugins>
     </build>
     <dependencies>
          <dependency>
               <groupId>com.google.android</groupId>
               <artifactId>android</artifactId>
               <version>2.2.1</version>
               <scope>provided</scope>
          </dependency>
          <dependency>
               <groupId>org.springframework.android</groupId>
               <artifactId>spring-android-rest-template</artifactId>
               <version>1.0.0.BUILD-SNAPSHOT</version>
          </dependency>
     </dependencies>
</project> 

필요에 따라 pom.xml의 XML 스키마(http://maven.apache.org/xsd/maven-4.0.0.xsd)에서 기타 요소와 추가 종속 항목을 지정한다. 이제까지 Maven Android 플러그인과 Android 종속성, Spring Android REST Template 종속성, Maven Integration for Eclipse 플러그인 및 Maven Integration for Android Development Tools를 구성했으므로 이제 Maven을 사용하여 Eclipse에서 Spring 클라이언트를 사용하는 Android 애플리케이션을 개발할 수 있다. 그러나 Maven을 Eclipse와 통합하는 작업은 아직 완료되지 않았다. Maven Integration for Eclipse 플러그인에서 제공하는 종속성 관리 기능을 사용해야 한다. 마우스 오른쪽 단추로 AndroidSpring 프로젝트를 클릭한 후, Maven > Enable Dependency Management를 선택한다. 그림 10을 참조한다.

Maven 저장소의 필수 Maven 종속 항목과 소스가 다운로드되고 업데이트되며 해당 프로젝트가 빌드된다. 대상 폴더가 SpringAndroid 디렉토리에 추가된다.

위로

Android Maven 목표 구성

Maven 2.0 빌드 라이프사이클은 다양한 빌드 단계로 구성된다. 표 1에는 기본 빌드 주기 단계가 표시되어 있다.

빌드 단계를 호출하면 이전의 모든 빌드 단계도 호출된다. 빌드 단계는 세밀하게 조정된 특정 태스크를 의미하는 목표로 구성된다. 빌드 단계는 0개 이상의 목표와 연관될 수 있다. 빌드 단계에 이 단계에 바인드된 목표가 없으면 빌드 단계는 실행되지 않는다. 패키징과 플러그인을 사용하여 목표를 빌드 단계에 지정한다. pom.xml에서 packaging을 apk에 설정한다.

<packaging>apk</packaging>

지정된 패키징 유형을 기반으로 특정 목표가 다양한 빌드 단계에 바인드된다. pom.xml에 구성된 플러그인에서 일부 패키징 유형을 사용할 수 있다. apk 패키징 유형은 Maven Android 플러그인과 함께 사용 가능하다. pom.xml에서 Maven Android 플러그인을 구성했다. Maven Android 플러그인과 연관된 패키징 유형을 사용하려면 목록 12와 같이 extensions 요소를 true로 설정한다.

 <plugin>
<groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>maven-android-plugin</artifactId>
......
<extensions>true</extensions>
</plugin>

pom.xml에서 플러그인을 구성하여 목표를 추가할 수도 있다. 각 플러그인은 pom.xml에서 구성할 수 있는 일부 목표(예: 특정 빌드 단계에 바인드하는 것)를 제공한다. 패키징 유형 apk를 사용하면 Maven Android 플러그인이 기본 Maven 라이프사이클을 사용자 정의하고 일부 추가 태스크를 실행한다. 표 2에는 기본 Maven 라이프사이클에 대한 사용자 정의가 기술되어 있다.

표 3에는 Maven Android 플러그인에서 제공하는 목표가 기술되어 있다.

다음에는 Maven Android 플러그인의 목표를 일부 구성하여 Maven 라이프사이클에 적용한다. 그림 11과 같이 마우스 오른쪽 단추로 AndroidSpring을 클릭하고 Run As > Maven build를 선택한다.

Maven Build 노드에서 android:emulator-start 목표용 Run Configuration을 추가한다. Run Configuration 이름(AndroidSpring)을 지정하고 그림 12와 같이 android:emulator-start를 Goals로 지정한다. Maven Runtime은 Embedded 3.0-Snapshot으로 지정한다. Apply를 클릭한다.

마찬가지로 또 다른 Run Configuration(AndroidSpring(2))을 구성한다. Goals에 다음과 같은 Maven 빌드 단계와 Maven Android 플러그인 목표를 지정한다.

clean package android:deploy

이 빌드 단계(그리고 각 빌드 단계 라이프사이클의 이전의 모든 빌드 단계)와 목표는 지정된 순서에 따라 호출된다. 그림 13에는 Run Configuration AndroidSpring(2)이 표시되어 있다.

위로

Spring 클라이언트 Android 애플리케이션 실행

다음에는 Android Spring 애플리케이션을 실행한다. 그림 14와 같이 마우스 오른쪽 단추로 AndroidSpring을 클릭하고 Run As > Android Application을 선택한다.

구성한 Maven 구성이 나열된다. 먼저, 그림 15와 같이 Android 에뮬레이터를 시작할 구성을 선택한다. OK를 클릭한다.

이어서 Android apk 파일을 배치할 구성을 선택한다. AndroidSpring 애플리케이션이 apk로 패키지된 후에 Android 에뮬레이터에 배치된다. 그림 16에는 Android 에뮬레이터에 배치된 AndroidSpring 애플리케이션이 표시되어 있다.

AndroidSpring 애플리케이션을 클릭하여 애플리케이션을 실행한다. JAX-RS 웹 서비스용 Spring 클라이언트는 웹 서비스를 호출하며 웹 서비스에서 리턴된 메시지는 그림 17과 같은 Android 에뮬레이터에 표시된다.

text/plain 대신 text/xml 메시지를 생성하도록 JAX-RS 웹 서비스 자원 클래스를 수정한다. 목록 13을 참조한다.

@GET
@Produces("text/xml")
      public String getXMLMessage() {
      return "<?xml version=\"1.0\"?>" + "<hello> Hello Android" + "</hello>";
      }

요청 헤더 컨텐츠 유형이 text/xml로 설정되도록 SpringAndroid 클라이언트 애플리케이션을 수정한다. 목록 14를 참조한다.

 requestHeaders.setContentType(new MediaType("text","xml"));
 

AndroidJAX-RS 웹 서비스 자원 클래스와 SpringAndroid 클라이언트 애플리케이션을 재배치한다. 에뮬레이터에서 SpringAndroid 애플리케이션을 실행하여 그림 18과 같이 JAX-RS 웹 서비스에서 수신된 XML 메시지를 출력한다.

이 기사에서는 Spring Android 플러그인을 사용하여 JAX-RS 웹 서비스용 Spring 클라이언트를 작성했다.

위로

다운로드 하십시오

다운로드 방식에 대한 정보

참고자료

교육

• Android: Android 도구에 관해 배우고 Android 애플리케이션을 작성하는 방법과 관련된 문서를 읽자.
  
  
• developerWorks의 SOA 및 웹 서비스 영역에서 웹 서비스 기술을 향상시키는 데 필요한 프로젝트 참고자료를 얻자.
  
  
• IBM JAX-RS: Developer's Guide에서 IBM JAX-RS 및 WebSphere Application Server에 관한 조언을 얻자.
  
  
• JAX-RS Selection Algorithm에서 웹 자원을 의미하는 JAX-RS 어노테이션으로 어노테이션된 Java 클래스에 관해 자세히 배우자.
  
  
• 필자가 작성한 기타 기사(Deepak Vohra, developerWorks, 2005년 4월 현재): Android, Ajax, PHP, XML, 웹 서비스, Ruby on Rails, EJB와 같은 기술에 관한 기사를 읽자.
  
  
• XML 입문 XML을 배우는 데 필요한 참고자료를 얻자.
  
  
• developerWorks의 XML 영역: XML 분야의 기술을 향상시키는 데 도움이 되는 참고자료를 얻을 수 있다. XML 기술 자료에서 다양한 기술 관련 기사와 팁, 튜토리얼, 표준 및 IBM Redbook을 볼 수 있다.
  
  
• IBM XML 인증: XML 및 관련 기술에 대한 IBM 인증 개발자가 되는 방법을 찾아볼 수 있다.
  
  
• developerWorks 기술 행사 및 웹 캐스트: 이러한 세션에 참가하여 최신 기술에 대한 정보를 얻을 수 있다.
  
  
• Twitter의 developerWorks 페이지: 오늘 가입하여 developerWorks 트윗을 팔로우하자.
  
  
• developerWorks podcasts: 소프트웨어 개발자의 흥미로운 인터뷰와 토론을 확인할 수 있다.
  
  
• developerWorks on-demand demos: 입문자를 위한 제품 설치 및 설정 과정에서 숙련된 개발자를 위한 고급 기능의 활용에 이르기까지 다양한 데모를 제공한다.
  
  

제품 및 기술

• Android SDK에서 이 SDK를 다운로드하여 도구와 샘플 코드 및 문서를 얻자.
  
  
• Spring Android에서 Spring 프레임워크를 다운로드하여 Android 환경에서 사용해보자.
  
  
• Eclipse for Java EE에서 Java IDE, Java EE용 도구, JPA, JSF, Mylyn 등을 포함하여 Java EE와 웹 애플리케이션을 작성하는 데 필요한 최신 버전의 도구를 다운로드하자.
  
  
• Jersey에서 Jersey 번들과 Jersey 아카이브를 다운로드하자.
  
  
• JDK 6.0에서 JDK 6.0 2진 파일을 다운로드하자.
  
  
• WebSphere Application Server에서 Java EE 5 인증을 받은, EJB 3.0 지원 기술을 기반으로 하는 애플리케이션 플랫폼을 다운로드하자. 이 플랫폼은 업계의 광범위한 플랫폼에서 성능을 기반으로 하는 혁신적인 SOA 환경 기반을 사용하여 비즈니스 민첩성을 추구한다.
  
  
• IBM 제품 평가판: IBM SQA Sandbox의 온라인 시험판을 다운로드하거나 살펴보고 DB2®, Lotus®, Rational®, Tivoli® 및 WebSphere® 애플리케이션 개발 도구 및 미들웨어 제품을 사용해 볼 수 있다.
  
  

토론

• XML 영역 토론 포럼: 여러 XML 관련 토론에 참여해 볼 수 있다.
  
  
• developerWorks 커뮤니티: 개발자가 운영하고 있는 블로그, 포럼, 그룹 및 위키를 살펴보면서 다른 developerWorks 사용자와 의견을 나눌 수 있다.
  
  

필자소개

아티클 순위

의견

위로

목차

• 개요
• 환경 설정
• JAX-RS 웹 서비스 자원 작성
• Maven 플러그인 설치
• Spring Android 클라이언트 작성
• Maven 플러그인과 종속 항목 구성
• Android Maven 목표 구성
• Spring 클라이언트 Android 애플리케이션 실행
• 다운로드 하십시오
• 참고자료
• 필자소개
• 의견