Android の Spring クライアントを JAX-RS Web サービスに展開する

Spring Android クライアントを作成する方法を学んでください

REST (Representational State Transfer) ソフトトウェア・アーキテクチャーでは、リソースの表現を転送することが前提となります。RESTful な Web サービスとは、REST と HTTP プロトコルをベースとした Web サービスであり、URI パスとして提供されています。RESTful な Web サービスは、さまざまなメディア・タイプ (XML、HTML、JSON、テキストなど) のメッセージを生成するメソッドで構成され、これらのメソッドが HTTP メソッドの GET、PUT、POST、および DELETE に応答します。RESTful な Web サービスの Java API (JAX-RS: The Java API for RESTful Web Services) は、JSR 311 に定義されています。Jersey は、この JAX-RS のリファレンス実装です。

Java エンタープライズ・アプリケーションを実行するためのプラットフォームである Spring には、生産性やランタイム・パフォーマンスを向上させることができるなど、さまざまな利点があります。この Spring フレームワークを、Android アプリケーションの開発を単純化する目的で拡張したのが、Spring Android です。Spring Android の主な特徴としては、Android 対応の REST クライアント、そしてセキュア API にアクセスするための Auth サポートがあります。

この記事では、Spring Android REST クライアントを使って RESTful な Web サービスにアクセスします。

Deepak Vohra, Consultant, Independent

Deepak Vohra は Sun 認定 Java プログラマーであり、Sun 認定の Web コンポーネント開発者でもあります。彼は Java Developer's Journal と XML Journal に記事を発表しています。



2011年 9月 16日

概要

この記事は、以下のセクションで構成されています。

  • 環境の設定
  • JAX-RS Web サービス・リソースの作成
  • Maven プラグインのインストール
  • Spring Android クライアントの作成
  • Maven プラグインと依存関係の構成
  • Android Maven のゴールの構成
  • Spring クライアントでの Android アプリケーションの実行

環境の設定

よく使われる頭文字語

  • API: Application Programming Interface
  • HTML: HyperText Markup Language
  • HTTP: HyperText Transfer Protocol
  • IDE: Integrated Development Environment
  • JSON: JavaScript Object Notation
  • MIME: Multipurpose Internet Mail Extension
  • POJO: Plain Old Java Object
  • SDK: Software Development Kit
  • UI: User Interface
  • URI: Uniform Resource Identifier
  • URL: Uniform Resource Locator
  • XML: Extensible Markup Language

環境を設定するためのタスクは以下のとおりです (リンクについては、「参考文献」を参照)。

  • Eclipse IDE をインストールします。
  • Eclipse 対応の ADT (Android Development Tool) プラグインをインストールします。Eclipse 対応 ADT プラグインは、Eclipse で Android アプリケーションを開発するための一連の拡張機能を提供します。
  • SDK Platform Android 2.2 をインストールします。Android SDK は、Android アプリケーションの開発ツールを提供します。
  • Eclipse で AVD (Android Virtual Device) を作成します。AVD は、Android のエミュレーターです。
  • Web サーバー (Tomcat など) またはアプリケーション・サーバー (WebSphere または WebLogic サーバーなど) をインストールする必要もあります。
  • Jersey の JAR ファイルとコアの依存関係が含まれる Jersey アーカイブ、jersey-archive-1.4.zip をダウンロードします。さらに、Jersey バンドル JAR である jersey-bundle-1.4.jar をダウンロードします。Jersey をビルドするには JDK 6.0 を使用するため、JDK 6.0 もインストールする必要があります。リスト 1 に示す JAR ファイルを、アプリケーション・サーバーまたは Web サーバーのランタイム 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 Web サービス・リソースの作成

このセクションでは、JAX-RS Web サービス・リソースの Spring クライアントを作成します。サンプルの JAX-RS Web サービスは、MIME タイプがそれぞれ text/plain、text/xmltext/html に設定された、3 種類のメッセージを生成します。

まず始めに、Eclipse プロジェクトを作成します。

  1. 新しい Web プロジェクトを作成し、この新規プロジェクトに JAX-RS ファセットを追加します。それにはまず、「File (ファイル)」 > 「New (新規)」 > 「Other (その他)」の順に選択し、表示される「New (新規)」ウィンドウで「Web」 > 「Dynamic Web Project (動的 Web プロジェクト)」の順に選択します。
  2. Next (次へ)」をクリックします。プロジェクト名を指定して、WebSphere、Tomcat または WebLogic サーバー用の新規ターゲット・ランタイムを構成します。
  3. デフォルトのプロジェクト設定を選択して、「Finish (完了)」をクリックします。

この操作によって、Eclipse が動的 Web プロジェクトを作成し、この新規プロジェクトを「Project Explorer (プロジェクト・エクスプローラー)」に追加するので、続いて次の作業を行います。

  1. Project Properties (プロジェクトのプロパティー)」ウィンドウで、JAX-RS (REST Web Services) 1.1 プロジェクト・ファセットを構成します。
  2. JAX-RS Capabilities (JAX-RS 機能)」ウィンドウで、サーブレット名として JAX-RS Servlet を指定し、JAX-RS 実装ライブラリーを構成して、Jersey JAR をこのユーザー・ライブラリーに追加します。
  3. Jersey JAR の jersey-bundle-1.4.jarC:\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 機能)」ウィンドウで、JAX-RS サーブレット・クラス名として com.sun.jersey.spi.container.servlet.ServletContainer と指定します。

    JAX-RS ユーザー・ライブラリーがプロジェクトに追加され、JAX-RS Servlet とサーブレット・マッピングが web.xml に構成されます。

  5. com.sun.jersey.config.property.resourceConfigClasscom.sun.jersey.config.property.packages のそれぞれに、初期化パラメーターとして init-param 要素を追加します。

リスト 2 に、web.xml ファイルを記載します。

リスト 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 な Web サービス・リソースを作成します。ルート・リソース・クラスは @PATH というアノテーションの付いた POJO であり、HTTP GET リクエストを処理することを示す @GET アノテーション付きの 3 つ以上のメソッドで構成します。この Java クラスをホストする URI パスには、/helloworld を指定してください (リスト 3 を参照)。

リスト 3. リソースの URI パス
@Path("/helloworld")
public class HelloWorldResource {...
}

3 つの異なる MIME タイプを生成するリソース・メソッドを追加します。リソース・クラスに以下のメソッドを追加して、メソッドのそれぞれに @GET アノテーションを付けてください。

  • getClichedMessage(): MIME タイプ text/plain を使用した「Hello JAX-RS」メッセージを出力します。
  • getXMLMessage(): MIME タイプ text/xml を使用した「Hello JAX-RS」メッセージを出力します。
  • getHTMLMessage(): MIME タイプ text/html を使用した「Hello JAX-RS」メッセージを出力します。

各メソッドには @PRODUCES アノテーションを付け、戻りタイプを String として指定して、メソッドごとに異なる MIME タイプを指定します。具体的に言うと、getXMLMessage メソッドには、XML メッセージを生成する @Produces("text/xml") アノテーションを付けるなどです。@GET アノテーション付きメソッドのうち、デプロイメントごとに 1 つのメソッドのみをコメント解除してください。リスト 4 にルート・リソース・クラスを示します。

リスト 4. JAX-RS Web サービス・リソース・クラス
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. JAX-RS Web サービス・プロジェクト
JAX-RS Web サービス・リソース・クラス・プロジェクトのディレクトリー構造を示すスクリーン・キャプチャー

今度は、異なるタイプの出力を生成するリソース・クラスを実行します。

  1. テストを実行するごとに、そのテストで対象とするメソッドのコメントを外します。
  2. text/plain MIME タイプの出力をテストします。
  3. アプリケーション/Web サーバーを起動します (まだ起動していない場合)。
  4. リソース・クラスを右クリックして、「Run As (実行)」 > 「Run on Server (サーバーで実行)」を選択します

AndroidJAX-RS アプリケーションがサーバーにデプロイされます。


Maven プラグインのインストール

これから、ソフトウェア管理ツールである Apache Maven を使用して、Android JAX-RS Web サービスの Spring クライアントを対象とした Android プロジェクトを作成します。Eclipse には、Maven Integration プロジェクトを使用して Maven サポートを追加します。Maven を使用して Android アプリケーションを開発するには、Maven Android プラグインが必要です。このプラグインは、この後の「Maven プラグインと依存関係の構成」セクションでインストールします。Maven Integration for Android Development Tools は、Android Development Tools と Maven Android プラグインが Maven Integration を使用できるようにするための Eclipse プラグインです。

Maven Integration は、Eclipse マーケットプレイスから Android Development Tools にインストールすることができます。

  1. Eclipse IDE を開いて「Help (ヘルプ)」 > 「Eclipse Marketplace (Eclipse マーケットプレイス)」の順に選択します。
  2. 「Eclipse Marketplace (Eclipse マーケットプレイス)」の「Search (検索)」タブで、「Find (検索)」フィールドに「m2eclipse-android」と指定して「Go (実行)」をクリックします (図 2 を参照)。
    図 2. m2eclipse-android プラグインの選択
    m2eclipse-android プラグインを選択する「Search (検索)」タブのスクリーン・キャプチャー
  3. 「Search (検索)」タブに「Maven Integration for Android Development Tools」がリストアップされるので、「Install (インストール)」をクリックします (図 3 を参照)。
    図 3. Maven Integration for Android Development Tools のインストール
    Maven Integration for Android Development Tools のインストール操作を示すスクリーン・キャプチャー
  4. Confirm Selected Features (選択されたフィーチャーの確認)」ウィンドウで、Android Development ToolsMaven Integration for Android Development Tools、および Maven Integration for Eclipse の各フィーチャーのチェック・ボックスにチェックを入れ、「Next (次へ)」をクリックします。
    図 4. インストールするプラグインの選択
    インストールするプラグインを選択する「Confirm Selected Features (選択されたフィーチャーの確認)」ウィンドウのスクリーン・ショット
  5. 使用条件の条項に同意し、「Finish (完了)」をクリッしてプラグイン・ソフトウェアのインストールを完了します。

    インストールされたプラグインを確認するには、「Help (ヘルプ)」 > 「About Eclipse (Eclipse プラットフォームについて)」の順に選択し、表示された画面で「Installation Details (インストール詳細)」をクリックします。


Spring Android クライアントの作成

このセクションでは、JAX-RS Webサービスの Android Spring クライアント・プロジェクトを作成します。Android プロジェクトを作成した後、そのプロジェクトで JAX-RS Web サービスにアクセスする Android 対応 Spring クライアントを作成します。

  1. Eclipse IDE で「File (ファイル)」 > 「New (新規)」 > 「Other (その他)」の順に選択します。
  2. New (新規)」ウィンドウで「Android」 > 「Android Project (Android プロジェクト)」の順に選択し、「Next (次へ)」をクリックします。
  3. New Android Project (新規 Android プロジェクト)」ウィンドウに、プロジェクト名 (AndroidSpring) を指定します。
  4. Build Target (ビルド・ターゲット)」では、「Android Platform 2.2 API 8」を選択します。
  5. Properties (プロパティー)」として、アプリケーション名とパッケージ名を指定します。
  6. Create Activity (アクティビティーの作成)」チェック・ボックスにチェックを入れ、Activity クラス (AndroidSpring) を指定します (図 5 を参照)。アクティビティーとはユーザー操作を表し、Activity クラスを継承するクラスが UI のウィンドウを作成します。
  7. 「Min SDK Version (最低 SDK バージョン)」には「8」を指定して、「Finish (完了)」をクリックします (図 5 を参照)。
    図 5. Spring Android クライアントの作成
    Spring Android クライアントを作成する「New Android Project (新規 Android プロジェクト)」ウィンドウのスクリーン・キャプチャー

Android プロジェクトは、以下のファイルで構成されます。

  • アクティビティー・クラス(AndroidSpring)。このクラスは Activity クラスを継承します。
  • res/layout/main.xml ファイル。Android アプリケーションのレイアウトを指定するファイルです。
  • AndroidManifest.xml ファイル。このファイルに、アプリケーション構成 (パッケージ名、アプリケーション・コンポーネント、プロセス、パーミッション、Android システムの最低 API レベルなど) を含めます。

res/layout/main.xml ファイルでは LinearLayout 要素に Android UI コンポーネントのレイアウトを指定します。android:orientation 属性の値には、vertical を指定します。Web サービスからのレスポンスをテキスト・メッセージとして表示する UI を作成します。

また id を springmessage に設定した TextView 要素を追加します。この要素で、get メソッドのいずれかのメソッド呼び出しに対する JAX-WS Web サービス・レスポンスを表示します。メソッド呼び出しは、Hello メッセージを XML、HTML、またはテキスト形式のレスポンスとして表示します。リスト 5main.xml ファイルを記載します。

リスト 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 Web サービスにアクセスするには、AndroidManifest.xmlandroid.permission.INTERNET のユーザー許可を有効にして、アプリケーションがネットワーク・ソケットを開けるようにしなければなりません。それには、リスト 6uses-permission 要素を追加します。

リスト 6. インターネット・アクセスに関するユーザー許可の追加
 <uses-permission android:name="android.permission.INTERNET"></uses-permission>

最低限必要な Android バージョンは、uses-sdk 要素で指定します。これに続く要素で、AndroidSpring アクティビティー、intent-filter、および action を指定します。リスト 7 に、AndroidManifest.xml ファイルを記載します。

リスト 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 ファイルを示します。

図 6. Eclipse IDE に表示された AndroidManifest.xml ファイル
Eclipse IDE に表示された AndroidManifest.xml ファイルのスクリーン・キャプチャー

Java Build Path (Java ビルド・パス)」を選択します。「Libraries (ライブラリー)」タブで、spring-android-rest-template JAR ファイルを Java ビルド・パスに追加します (図 7 を参照)。

図 7. Java ビルド・パスに追加された Spring Android REST テンプレートの JAR
Java ビルド・パスに追加された Spring Android REST テンプレートの JAR のスクリーン・キャプチャー

RESTful な原則を実装するorg.springframework.web.client.RestTemplate は、クライアント・サイドの 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 に定義されている springmessage という id を TextView 要素の findViewById メソッドで指定して、Android ウィジェットの TextView オブジェクトを作成します。
     TextView springmessage = (TextView) findViewById(R.id.springmessage);
  4. HTTP リクエスト・ヘッダーおよびレスポンス・ヘッダーを表す HttpHeaders オブジェクトを作成します。
     HttpHeaders requestHeaders = new HttpHeaders();
  5. Content-Type ヘッダーの指定に従って、本体のメディア・タイプを設定します。メディア・タイプは、JAX-RS Web サービスが生成するメディア・タイプと同じでなければなりません。
     requestHeaders.setContentType(new MediaType("text","plain"));
  6. リクエスト・ヘッダーからなる HTTP リクエスト・エンティティーを作成します。
     HttpEntity<String> requestEntity = new HttpEntity<String>(requestHeaders);
  7. コンストラクターをデフォルト設定で使用して、RestTemplate の新しいインスタンスを作成します。
     RestTemplate restTemplate = new RestTemplate();
  8. URL を、URI パス /helloworld でホストされるリソースに指定します。
    String url = "http://192.168.1.68:7001/AndroidJAX-RS/jaxrs/helloworld";
  9. 指定の URI テンプレートに対して HTTP メソッドを呼び出すために、exchange メソッドを使用してリクエスト・エンティティーをリクエストに送信します。exchange メソッドは、レスポンスを ResponseEntity として返します。
    ResponseEntity<String> responseEntity = 
    restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
  10. getBody メソッドを使用して、ResponseEntity からレスポンス String を取得します。
    ResponseEntity<String> String result = responseEntity.getBody();
  11. String メッセージを TextView UI コンポーネントに設定します。
    springmessage.setText(result);

リスト 8 に AndroidSpring クラスを示します。

リスト 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 (Project Object Model) を定義する pom.xml で指定されます。pom.xml ファイルに指定する構成情報には、プロジェクトの依存関係、リポジトリー、およびプラグインが含まれます。具体的には、以下のリポジトリー、依存関係、プラグインを pom.xml に構成します。

  • Spring Maven リポジトリー ― Maven で Spring 3 成果物を取得します。
  • Spring Maven Milestone リポジトリー ― 最新の Spring マイルストーン版で開発できるようにします。
  • Maven Android プラグイン ― Android 用の Maven プラグインです。
  • Maven コンパイラー・プラグイン ― プロジェクトのソースをコンパイルします。
  • Google Android 依存関係 ― Google Android プラットフォームの依存関係を指定します。
  • Spring Android REST Template Module 依存関係 ― spring-android-rest-template の依存関係を指定します。

まずは、AndroidSpring Web プロジェクトに pom.xml を作成します。

  1. 「File (ファイル)」 > 「New (新規)」 > 「Other (その他)」の順に選択します。
  2. New (新規)」ウィンドウで「XML」 > 「XML File (XML ファイル)」の順に選択し、「Next (次へ)」をクリックします。
  3. New XML File (新規 XML ファイル)」ウィザードで、「AndroidSpring」フォルダーを選択します。
  4. ファイル名として「pom.xml」を指定し (図 8 を参照)、「Next (次へ)」をクリックします。
    図 8. pom.xml の作成
    pom.xml ファイルの作成操作を示すスクリーン・キャプチャー
  5. Create XML File from an XML template (XML テンプレートから XML ファイルを作成)」を選択して、「Next (次へ)」をクリックします。
  6. XML 宣言テンプレートを選択して「Finish (完了)」をクリックします。

    SpringAndroid プロジェクトに、pom.xml 構成ファイルが表示されます (図 9 を参照)。

    図 9. pom.xml
    SpringAndroid プロジェクトに表示された pom.xml ファイルのスクリーン・キャプチャー

このセクションの最初のほうで記載したプラグイン、リポジトリー、依存関係を構成します。Spring Maven Snapshot リポジトリーを指定するには、以下の値を設定します (リスト 9 を参照)。

  • <id> 要素には、org.springframework.maven.snapshot を指定します。
  • <url> 要素には、http://maven.springframework.org/snapshot を指定します。
  • releases の enabled 要素では、値を false に設定します。
  • snapshots の enabled 要素では、値を true に設定します。
リスト 9. Spring Maven Snapshot リポジトリー
<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 リポジトリーを以下の値で構成します。

  • id 要素には、org.springframework.maven.milestone を指定します。
  • releasesenabled 要素では、値を true に設定します。
  • snapshots の enabled 要素では、値を false に設定します。

Maven Android プラグインは、以下の値を使用して構成します (リスト 10 を参照)。

  • 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> を使用するように指定します。
リスト 10. Spring Maven Snapshot リポジトリー
<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> 要素内に、<artifactId>android に設定した Google Android 依存関係を構成します。Spring Android REST Template Module の <dependency> 要素を構成するには、<artifactId>spring-android-rest-template に設定します。リスト 11 に、pom.xml 構成ファイルを記載します。

リスト 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 を参照)

図 10. pom.xml
Eclipse で pom.xml が表示され、メニューで「Maven」 > 「Enable Dependency Management (依存関係管理を使用可能にする)」が選択されているところのスクリーン・キャプチャー

Maven リポジトリーから必要な Maven 依存関係とソースがダウンロードされて更新され、プロジェクトがビルドされます。そして SpringAndroid ディレクトリーに、target フォルダーが追加されます。


Android Maven のゴールの構成

Maven 2.0 ビルド・ライフサイクルは、さまざまなビルド・フェーズで構成されています。表 1 に、デフォルトでのビルド・サイクルの各フェーズとその説明を記載します。

表 1. デフォルト・ビルド・サイクルのフェーズ
フェーズ説明
validateプロジェクトの有効性を確認する
compileプロジェクトのソース・コードをコンパイルする
testコンパイルされたソース・コードをユニット・テスト・フレームワークでテストする
packageコンパイル済みコードをパッケージ化する
integration-test結合テストを実行する
verifyパッケージングの有効性を検証する
installパッケージングをローカル・リポジトリーにインストールする
deploy統合およびリリース環境で、パッケージをリモート・リポジトリーにコピーする

あるビルド・フェーズを呼び出すと、それに先行するすべてのビルド・フェーズも呼び出されることになります。ビルド・フェーズを構成するのは、複数のゴールです。ゴールは、細分化された特定のタスクを表します。ビルド・フェーズにはゴールが関連付けられていない場合もあれば、複数のゴールが関連付けられている場合もあります。ビルド・フェーズにゴールが関連付けられていなければ、そのビルド・フェーズは実行されません。ゴールをビルド・フェーズに割り当てるには、パッケージングとプラグインを使用します。pom.xml で、以下のようにパッケージングを apk に設定してください。

<packaging>apk</packaging>

指定されたパッケージングのタイプに応じて、それぞれのビルド・フェーズに特定のゴールが関連付けられます。パッケージング・タイプのいくつかは、pom.xml 内で構成されたプラグインによって使用できるようになります。apk パッケージング・タイプは Maven Android プラグインによって使用できるようになりますが、Maven Android プラグインは pom.xml 内で構成されているので、Maven Android プラグインに関連付けられたパッケージ・タイプを使用するには、このファイル内で extensions 要素を true に設定する必要があります (リスト 12 を参照)。

リスト 12. pom.xml
 <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 ライフサイクルに対するカスタマイズの内容を記載します。

表 2. デフォルトの Maven フェーズに対するカスタマイズの内容
Maven のフェーズ内容
generate-sourcesAndroid 固有のリソース (AndroidManifest.xml など) を、AAPT (Android Asset Packaging Tool) を使用してパッケージ化する
process-classeshttp://ptt.pok.ibm.com/track/asig/displaya_q.php?editID=818849
packageAndroid パッケージ・ツール (apk) を使用して、エミュレーターまたは機器にインストールする Android パッケージ・ファイル (apk) を作成する
pre-integration-test依存関係を含めた Android パッケージ・ファイル (apk) をエミュレーターまたは機器にデプロイする
integration-testデプロイされたアプリケーションに対してインスツルメンテーション・テスト・クラスを実行する

表 3 に、Maven Android プラグインが提供する各ゴールとその内容を記載します。

表 3. Maven Android プラグインのゴール
ゴール内容
android:apkAndroid パッケージ・ファイル (apk) を作成する。
android:deployビルドした (または別の) apk をエミュレーターまたは機器にデプロイする。
android:deploy-dependenciesapk タイプのすべての依存関係をデプロイする。
android:dexJava クラスを Android Dalvik Executable (dex) フォーマットに変換する。
android:emulator-startAndroid エミュレーターを起動する。Maven Android プラグインのエミュレーターは pom.xml に構成しました
(<emulator><avd>rhoAndroid30</avd></emulator>)。emulator 要素には、起動パラメーターおよびオプションを構成することもできます。
android:generate-sourcesAndroid エミュレーターを停止する。
installR.java ファイルを生成し、ソース・ディレクトリーのすべての R.java を削除する。.aidl ファイルをベースに Java ファイルを生成し、.aidl ファイルと同じ名前の .java ファイルをすべて削除する。
android:instrumentエミュレーターまたは機器上でインスツルメンテーション用 Android パッケージを実行する。
android:internal-integration-testintegration-test フェーズに関連付けられた内部ゴール。
android:internal-pre-integration-testpre-integration-test フェーズに関連付けられた内部ゴール。
android:pullエミュレーターまたは機器からファイルおよびディレクトリーをコピーする。
android:pushエミュレーターまたは機器にファイルおよびディレクトリーをコピーする。
android:undeployエミュレーターまたは機器から、現行のビルド・プロジェクトに関連付けられた apk、または指定された別の apk をアンデプロイする。

次に、Maven Android プラグインのいくつかのゴールを構成して Maven ライフサイクルに組み込みます。「AndroidSpring」を右クリックして、「Run As (実行)」 > 「Maven build (Maven ビルド)」の順に選択します (図 11 を参照)。

図 11. Maven 実行構成の構成
Maven 実行構成の構成を示すスクリーン・キャプチャー

Maven Build (Maven ビルド)」ノードで、android:emulator-start ゴールに対して「Run Configuration (実行構成)」を追加します。実行構成名 (AndroidSpring) を指定し、「Goals (ゴール)」には「android:emulator-start」を指定します (図 12 を参照)。「Maven Runtime (Maven ランタイム)」は「Embedded (3.0-SNAPSHOT) (埋め込み (3.0-SNAPSHOT))」です。「Apply (適用)」をクリックします。

図 12. android:emualtor-start ゴールの構成
android:emualtor-start ゴールの構成を示すスクリーン・キャプチャー

同じようにして、「AndroidSpring(2)」というもう 1 つの「Run Configuration (実行構成)」を構成します。「Goal (ゴール)」には、以下の Maven ビルド・フェーズと Maven Android プラグインのゴールを指定します。

clean package android:deploy

ビルド・フェーズ (および、それぞれのビルド・フェーズ・ライフサイクルの先行ビルド・フェーズ) とゴールは、指定された順序で呼び出されます。図 13 に、「AndroidSpring (2)」実行構成を示します。

図 13. Spring クライアントをパッケージングしてデプロイするための実行構成
Spring クライアントをパッケージングしてデプロイするための実行構成を示すスクリーン・キャプチャー

Spring クライアント Android アプリケーションの実行

次は、Android Spring アプリケーションを実行します。AndroidSpring を右クリックして、「Run As (実行)」 > 「Android Application (Android アプリケーション)」の順に選択します (図 14 を参照)。

図 14. Spring Android アプリケーションの実行
Android アプリケーションを実行するための操作を示すスクリーン・キャプチャー

すると、これまでに構成した Maven 構成が一覧表示されるので、まず始めに Android エミュレーターを起動するための構成を選択し (図 15 を参照)、「OK」をクリックします。

図 15. Android エミュレーターの起動構成の選択
Android エミュレーターの起動構成の選択を示すスクリーン・キャプチャー

続いて、Android apk ファイルをデプロイするための構成を選択します。AndroidSpring アプリケーションが apk としてパッケージングされて、Android エミュレーターにデプロイされます。図 16 に、Android エミュレーターに表示された AndroidSpring アプリケーションを示します。

図 16. Spring Android クライアント・アプリケーション
Android クライアント・アプリケーションのスクリーン・キャプチャー

AndroidSpring アプリケーションをクリックして実行します。JAX-RS Web サービスの Spring クライアントが Web サービスを呼び出すと、Web サービスから返されたメッセージが Android エミュレーターに表示されます (図 17 を参照)。

図 17. Spring Android クライアントの実行によって返されたテキスト形式のレスポンス
Spring Android クライアントの実行によって返されたテキスト形式のレスポンスを示すスクリーン・キャプチャー

今度は、text/plain メッセージではなく text/xml メッセージを生成するように JAX-RS Web サービス・リソース・クラスを変更します。リスト 13 を見てください。

リスト 13. text/xml メッセージの生成
@GET
@Produces("text/xml")
      public String getXMLMessage() {
      return "<?xml version=\"1.0\"?>" + "<hello> Hello Android" + "</hello>";
      }

さらに、SpringAndroid クライアント・アプリケーションを変更して、リクエスト・ヘッダーのコンテンツ・タイプを text/xml に設定します。リスト 14 を見てください。

リスト 14. text/xml に設定したリクエスト・ヘッダー
 requestHeaders.setContentType(new MediaType("text","xml"));

AndroidJAX-RS Web サービス・リソース・クラスを再デプロイし、続いて SpringAndroid クライアント・アプリケーションを再デプロイします。エミュレーターで SpringAndroid アプリケーションを実行して、JAX-RS Web サービスから受信した XML メッセージを出力します (図 18 を参照)。

図 18. Spring Android クライアントの実行によって返された Android での text/xml レスポンス
Spring Android クライアントの実行によって返された Android での text/xml レスポンスを示すスクリーン・キャプチャー

この記事では、Spring Android プラグインを使用して、JAX-RS Web サービスの Spring クライアントを作成しました。


ダウンロード

内容ファイル名サイズ
Spring Android Client Eclipse Projectandroid-spring.zip627KB

参考文献

学ぶために

製品や技術を入手するために

  • Android SDK: この SDK をダウンロードして、ツール、サンプル・コード、資料を入手してください。
  • Spring Android: Spring Framework をダウンロードして、Android 環境で使い始めてください。
  • Eclipse for Java EE: Java EE および Web アプリケーションを作成するための最新ツールをダウンロードしてください。これらのツールには、Java IDE、Java EE 用ツール、JPA、JSE、Mylyn などがあります。
  • Jersey: Jersey バンドルと Jersey アーカイブをダウンロードしてください。
  • JDK 6.0: JDK 6.0 バイナリーをダウンロードしてください。
  • WebSphere Application Server: Java EE 5 認定の EJB 3.0 対応技術をベースとしたアプリケーション・プラットフォームをダウンロードしてください。SOA 環境の革新的でハイパフォーマンスな基盤として、業界のありとあらゆるプラットフォームでビジネス・アジリティを促進します。
  • IBM 製品の評価版: DB2、Lotus、Rational、Tivoli、および WebSphere のアプリケーション開発ツールとミドルウェア製品を体験するには、評価版をダウンロードするか、IBM SOA Sandbox のオンライン試用版を試してみてください。

議論するために

コメント

developerWorks: サイン・イン

必須フィールドは(*)で示されます。


IBM ID が必要ですか?
IBM IDをお忘れですか?


パスワードをお忘れですか?
パスワードの変更

「送信する」をクリックすることにより、お客様は developerWorks のご使用条件に同意したことになります。 ご使用条件を読む

 


お客様が developerWorks に初めてサインインすると、お客様のプロフィールが作成されます。会社名を非表示とする選択を行わない限り、プロフィール内の情報(名前、国/地域や会社名)は公開され、投稿するコンテンツと一緒に表示されますが、いつでもこれらの情報を更新できます。

送信されたすべての情報は安全です。

ディスプレイ・ネームを選択してください



developerWorks に初めてサインインするとプロフィールが作成されますので、その際にディスプレイ・ネームを選択する必要があります。ディスプレイ・ネームは、お客様が developerWorks に投稿するコンテンツと一緒に表示されます。

ディスプレイ・ネームは、3文字から31文字の範囲で指定し、かつ developerWorks コミュニティーでユニークである必要があります。また、プライバシー上の理由でお客様の電子メール・アドレスは使用しないでください。

必須フィールドは(*)で示されます。

3文字から31文字の範囲で指定し

「送信する」をクリックすることにより、お客様は developerWorks のご使用条件に同意したことになります。 ご使用条件を読む

 


送信されたすべての情報は安全です。


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=60
Zone=XML, Open source, Web development
ArticleID=756793
ArticleTitle=Android の Spring クライアントを JAX-RS Web サービスに展開する
publish-date=09162011