为 Android 开发访问 JAX-RS Web 服务的 Apache HttpClient 客户端
顶0踩
简介： 使用 Apache HttpClient 库访问 JAX-RS web 服务。Jersey 是 JAX-RS 的参考实现，它简化了 Java? 环境下的 RESTful Web 服务的开发。Android 是一款流行的智能手机，本文将展示如何为 Android 创建一个 JAX-RS 客户端。您将创建一个访问 JAX-RS Web 服务的 Apache HttpClient 库客户端。
REST 软件架构基于具象资源传输。RESTful Web 服务提供了一些优势：简单、轻量级、快速。RESTful Web 服务公开了一组由 URI 标识的资源。资源将根据 HTTP 方法 GET、POST、PUT 和 DELETE 作出响应。资源可通过各种形式访问，如 HTML、普通文本、XML、PDF、JPEG 或 JSON。Java API for RESTful Web 服务 (JAX-RS) 在 JSR 311 中定义。Jersey 是 JAX-RS 的参考实现，简化了 Java 中 RESTful Web 服务的开发。
在本文中，使用 Apache HttpClient 库为流行的智能手机平台 Android 创建一个 JAX-RS 客户端。您可以 下载 本文使用的样例代码。
设置环境
安装 Eclipse。
为 Eclipse 安装 Android Development Tools (ADT) 插件，其中提供了一组供在 Eclipse 中开发 Android 应用程序的扩展。
为 Android 2.2 安装 SDK Platform。Android SDK 为开发 Android 应用程序提供了工具。
创建一个 Android Virtual Device (AVD)，这是 Eclipse 中的一个 Android 仿真器。
下载 Jersey 压缩文件 jersey-archive-1.4.zip，其中包含 Jersey JAR 和核心依赖文件。下载 Jersey 包 JAR jersey-bundle-1.4.jar。Jersey 是使用 JDK 6.0 构建的，因此还需要安装 JDK 6.0。
安装 Web 服务器，如 Tomcat，或应用程序服务器，如 WebSphere?，或 WebLogic 服务器。将清单 1 中的 Jersey JAR 文件添加到应用程序/Web 服务器的运行时 CLASSPATH 中。
清单 1. 清单 1. Jersey 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
创建一个 Eclipse 项目
在本节中，您将创建一个 Web 项目并将 JAX-RS facet 添加到该项目中。使用以下步骤创建 Eclipse 项目。
选择 File > New，在 New 窗口中，选择 Web > Dynamic Web Project。单击 Next。
指定项目名称（例如 AndroidJAX-RS）并单击 New Runtime，为您的 WebSphere、Tomcat 或 WebLogic 服务器配置一个新的目标运行时。图 1 展示了完成设置的 Dynamic Web Project 窗口。
图 1. 图 1. 配置一个新的运行时

在 New Server Runtime Environment 窗口中，选择一个服务器，如 Tomcat 服务器、WebSphere 服务器或 WebLogic 服务器。单击 Next，如图 2 所示。
图 2. 图 2. 选择一个应用程序或 Web 服务器

在 New IBM WebSphere v6.0 Runtime 窗口中，配置 JRE 和 IBM WebSphere Installation Directory。单击 Dynamic Web Project 对话框中的 Next。为 Source 文件夹和 Output 文件夹选择默认的 Java 设置，并单击 Next。
将 Context root 指定为 AndroidJAX-RS，选择默认的 Content Directory，并单击 Finish。将创建一个 Dynamic Web Project 并添加到 Project Explorer。右键单击项目节点并选择Properties。
选择 Project Facets，然后选择 JAX-RS (REST Web Services) 1.1 项目 facet。单击Further configuration required，如图 3 所示。
图 3. 图 3.配置 JAX-RS Project Facet

在 JAX-RS Capabilities 窗口中，指定一个 Servlet 名称 (JAX-RS Servlet) 并配置一个 JAX-RS Implementation 库。选择 Type as User Library 并单击 Manage。
在 User Libraries 窗口中，单击 New。在 New User Library 对话框中，指定 User library 名并单击 OK。将添加一个用户库。单击 Add JARs 以将 Jersey JARs 添加到用户库。如图 4 所示，添加以下 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
单击 OK。
图 4. 图 4.添加 Jersey JAR 文件

在 JAX-RS Capabilities 窗口中，指定 JAX-RS servlet 类名为com.sun.jersey.spi.container.servlet.ServletContainer，如图 5 所示。单击 OK。
图 5. 图 5.指定 JAX-RS servlet 类

在 Project Facets 窗口中，单击 Apply，如图 6 所示，然后单击 OK。
图 6. 图 6.应用 JAX-RS Project Facet

目标运行时通过 JAX-RS project facet 进行配置。单击 Properties 对话框中的 OK。
JAX-RS User 库被添加到项目中，JAX-RS servlet 和 servlet 映射在 web.xml 中进行了配置。需要为 com.sun.jersey.config.property.resourceConfigClass 和com.sun.jersey.config.property.packages init 参数添加 init-param 元素。清单 2 显示了此web.xml。
清单 2. 清单 2. web.xml01
0204xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/
05ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
06  
07    JAX-RS Tools Generated - Do not modify
08    JAX-RS Servlet
09    com.sun.jersey.spi.container.servlet.ServletContainer
10    
11        com.sun.jersey.config.property.resourceConfigClass
12        com.sun.jersey.api.core.PackagesResourceConfig
13    
14    
15        com.sun.jersey.config.property.packages
16        jaxrs
17    
18    1
19  
20  
21    JAX-RS Servlet
22    /jaxrs/*
23  
24
创建和运行资源类
下一步是使用一个 root 资源类创建一个 RESTful Web 服务资源。root 资源类是带有 @PATH 注释的 POJO。它包含至少一个带注释的方法，该注释为 @PATH、@GET、@PUT、@POST 或 @DELETE。
选择 File > New > Other。在 New 对话框中，选择 Java > Class，然后单击 Finish。
在 New Java Class 窗口中，如图 7 所示，指定：一个 Source 文件夹：AndroidJAX-RS/src
包：jaxrs
类名：HelloWorldResource
单击 Finish。
图 7. 图 7.创建资源类

使用 @PATH 注释标注 Java 类。清单 3 中的代码指定了 URI 路径，Java 类在该路径中应该托管为/helloworld。
清单 3. 清单 3.使用 @Path 注释资源类1@Path("/helloworld")
2public class HelloWorldResource {
3....
4}
要添加资源方法以生成三个不同的 MIME 类型，添加 getClichedMessage()、getXMLMessage() 和getHTMLMessage() 方法。使用 @GET 注释每一个方法，这表示方法应当处理 HTTP GET 请求。指定String 作为每个方法的返回类型。使用 @PRODUCES 注释每一个方法，并为每个方法指定一个不同的 MIME 类型。
现在，需要用 MIME 类型 text/plain、text/xml 和 text/html 输出 “Hello JAX-RS” 方法。getXMLMessage 方法用 @Produces（"text/xml"）进行了注释，生成一条 XML 消息。对于使用@GET 注释了的方法，仅取消其中一个方法的注释。如果没有指定其他不同的路径组件，@GET 请求将被路由到用 @GET 注释的方法。如果有多个方法匹配某个请求 URI，将使用 JAX-RS 选择算法来选择资源方法。例如，可以指定带有 @GET 注释的多个方法，做法是对带有 @GET 注释的方法使用不同的 path id。清单 4 展示了 root 资源类。
清单 4. 清单 4.HelloWorldResource.java01package jaxrs;
02
03import javax.ws.rs.GET;
04import javax.ws.rs.Produces;
05import javax.ws.rs.Path;
06import javax.ws.rs.core.MediaType;
07
08// The Java class will be hosted at the URI path //"/helloworld"
09@Path("/helloworld")
10public class HelloWorldResource {
11
12    // The Java method will process HTTP GET requests
13     @GET
14    // The Java method will produce content identified by the MIME Media
15    // type "text/plain"
16     @Produces("text/plain")
17     public String getClichedMessage() {
18    // Return some cliched textual content
19     return "Hello Android";
20     }
21
22    // @GET
23    // @Produces("text/xml")
24    // public String getXMLMessage() {
25    // return "" + " Hello Android" + "";
26    // }
27
28//  @GET
29    //@Produces("text/html")
30    //public String getHTMLMessage() {
31        //return " " + ""
32            //  + "

" + "Hello Android" + "

" +
33    " ";
34//  }
35
36}
运行资源类以生成不同的输出类型。注释掉不执行测试的方法，对于每一次测试，保持一个方法未注释。首先，将 text/xml MIME 类型作为输出进行测试。启动应用程序/Web 服务器（如果尚未启动的话）。右键单击资源类并选择 Run As > Run on Server，如图 8 所示。
图 8. 图 8.运行资源类

在服务器上，按照 web.xml 的指定，init 参数com.sun.jersey.config.property.resourceConfigClass 作为com.sun.jersey.api.core.PackagesResourceConfig 启动，而 init 参数com.sun.jersey.config.property.packages 作为 jaxrs 启动。找到 root 资源类jaxrs.HelloWorldResource。启动 Jersey 应用程序 v1.4，AndroidJAX-RS 模块部署到服务器上。
创建 Android 客户端项目
在本节中，您将创建一个 Android 项目，在其中将为 Android 创建 JAX-RS 客户端。
在 Eclipse IDE 中，选择 File > New。在 New 对话框中，选择 Android > Android Project，然后单击 Next。
填充 New Android Project 窗口中的字段，如图 9 所示。项目名：AndroidJAXRSClient
构建目标：Android Platform 2.2 API 8
属性：应用程序名 AndroidJAXRSClient 和包名 android.jaxrs
选择 Create Activity，并指定 Activity 类 AndroidJAXRSClient。一项活动代表一个用户交互，而扩展 Activity 类的类为 UI 创建了一个窗口。
最低 SDK 版本：8
单击 Next
图 9. 图 9.创建 JAX-RS 客户端类

Android 项目中的文件包括：
一个活动类 (AndroidJAXRSClient)，该类扩展了 Activity 类
res/layout/main.xml 文件，指定 Android 应用程序的布局
AndroidManifest.xml 文件，包含应用程序配置信息，如包名、应用程序组件、流程、权限和 Android 系统的最低 API 级别。
在 res/layout/main.xml 文件中，指定 Android UI 组件的布局。使用android:orientation="vertical" 创建一个 LinearLayout。您将创建一个 UI，其中将以文本消息的形式显示来自 Web 服务的响应。添加 id 为 jaxrs 的 TextView 元素，显示方法调用对其中一个get 方法的 JAX-WS Web 服务响应。方法调用获得一条 Hello 消息作为响应，消息的格式为 XML、HTML 或文本。清单 5 显示了 main.xml 文件：
清单 5. 清单 5.main.xml1
23     android:orientation="vertical" android:layout_width="fill_parent"
4     android:layout_height="fill_parent">
5     6     android:layout_width="fill_parent" android:layout_height="wrap_content"
7                />
8
要从 Android 设备访问 JAX-RS web 服务，在 AndroidManifest.xml 中启用android.permission.INTERNET 权限，从而允许应用程序打开网络套接字。添加 uses-permission 元素，如清单 6 所示。
清单 6. 清单 6.设置 INTERNET 权限1
使用 uses-sdk 元素指定最低 Android 版本。AndroidJAXRSClient 活动、intent-filter 和 action在 activity 元素和子元素中指定。清单 7 显示了 AndroidManifest.xml 文件。
清单 7. 清单 7.AndroidManifest.xml01
0203     package="android.jaxrs" android:versionCode="1" android:versionName="1.0">
04     
05     
06       
07               
08                    
09                    
10               
11       
12     
13     
14     
15
Android SDK 包含 Apache HttpClient 库。将清单 8 中的类导入到 AndroidJAXRSClient。
清单 8. 清单 8 Apache HttpClient 库1org.apache.http.HttpEntity;
2org.apache.http.HttpResponse;
3org.apache.http.client.ClientProtocolException;
4org.apache.http.client.HttpClient;
5org.apache.http.client.methods.HttpGet;
6org.apache.http.impl.client.DefaultHttpClient;
AndroidJAXRSClient 类扩展了 Activity 类。在第一次调用 Activity 时用到了 onCreate(Bundle savedInstanceState) 方法。使用 setContentView 方法和布局资源定义用户界面，如清单 9 所示。
清单 9. 清单 9.定义 UI1setContentView(R.layout.main);
清单 10  展示了如何创建一个 Android 部件 TextView 对象，其中对 TextView 元素使用findViewById 方法，id 为 main.xml 中定义的 jaxrs。
清单 10. 清单 10.创建 Android 部件1TextView jaxrs = (TextView) findViewById(R.id.jaxrs);
HttpClient 的默认实现是 DefaultHttpClient。创建一个 DefaultHttpClient 对象，如清单 11 所示。
清单 11. 清单 11. 创建一个 HttpClient1HttpClient httpclient = new DefaultHttpClient();
创建一个 HttpGet 对象，从服务器检索信息，如清单 12 所示。为 URI 路径 /helloworld 上托管的资源指定 URL。为主机而不是本地主机指定 IP 地址。客户端运行在 Android 设备之上，Android 设备的本地主机并不是 JAX-RS Web 服务运行的主机（除非 JAX-RS Web 服务也托管在 Android 设备上，但是在本例中并不属于这种情况）。
清单 12. 清单 12.创建 HttpGet 对象1HttpGet request = new HttpGet("http://192.168.1.68:7001/AndroidJAX-RS/jaxrs/helloworld");
使用 Accept 头指定可接受的媒体类型。在 Accept 中只设置一种媒体类型，该类型与 JAX-RS Web 服务中生成的媒体类型对应。在首次运行时，将 Accept 头设置为 text/xml 以输出 text/xml 响应，如清单 13 所示。
清单 13. 清单 13. 设置 Accept 头1request.addHeader("Accept", "text/xml");
2//request.addHeader("Accept", "text/html");
3//request.addHeader("Accept", "text/plain");
测试每种响应类型的输出（普通文本、html 和 XML）。允许的响应类型应当匹配资源类中生成的 MIME 类型。资源类生成的 MIME 类型应当匹配一种可接受的 MIME 类型。如果生成的 MIME 类型和可接受的 MIME 类型不 匹配，那么将生成com.sun.jersey.api.client.UniformInterfaceException。例如，将可接受的 MIME 类型设置为text/xml，而将生成的 MIME 类型设置为 application/xml。将生成 UniformInterfaceException。如清单 14 清单 14 所示，调用 HttpClient 的 execute() 方法，其中 HttpGet 方法作为参数，以检索 HttpResponse 对象。
清单 14. 清单 14.获得 HttpResponse1HttpResponse response = httpclient.execute(request);
使用 getEntity 方法从 HttpResponse 获取 HttpEntity（清单 15 ）。
清单 15. 清单 15.获取 HttpEntity1HttpEntity entity = response.getEntity();
使用 getContent() 方法以 InputStream 的形式通过 HttpGet 获取内容（清单 16 ）。
清单 16. 清单 16.通过 HttpEntity 创建 InputStream1InputStream instream = entity.getContent();
为返回自 JAX-RS Web 服务的消息创建 StringBuilder（清单 17 ）。
清单 17. 清单 17.创建 StringBuilder1StringBuilder sb =  newStringBuilder();
从 InputStream 创建 BufferedReader（清单 18 ）。
清单 18. 清单 18.创建一个 BufferedReader1BufferedReader r = new BufferedReader(newInputStreamReader(instream));
读取 BufferedReader 中的每一行并添加到 StringBuilder（清单 19 ）。
清单 19. 清单 19.读取 BufferedReader1for (String line = r.readLine(); line != null; line = r.readLine()) {
2             sb.append(line);
3}
从 StringBuilder 获取 String 消息并结束 InputStream（清单 20 ）。
清单 20. 清单 20.获取 StringBuilder 消息1String jaxrsmessage = sb.toString();
2instream.close();
在 TextView UI 组件上设置 String 消息（清单 21 ）。
清单 21. 清单 21.设置 StringBuilder 消息1jaxrs.setText(jaxrsmessage);
清单 22 展示了 AndroidJAXRSClient 类。
清单 22. 清单 22.AndroidJAXRSClient.java01package android.jaxrs;
02import android.app.Activity;
03import android.os.Bundle;
04import android.widget.TextView;
05import java.io.BufferedReader;
06import java.io.InputStream;
07import java.io.InputStreamReader;
08import java.io.IOException;
09import org.apache.http.HttpEntity;
10import org.apache.http.HttpResponse;
11import org.apache.http.client.ClientProtocolException;
12import org.apache.http.client.HttpClient;
13import org.apache.http.client.methods.HttpGet;
14import org.apache.http.impl.client.DefaultHttpClient;
15
16public class AndroidJAXRSClient extends Activity {
17     /** Called when the activity is first created. */
18     @Override
19     public void onCreate(Bundle savedInstanceState) {
20          super.onCreate(savedInstanceState);
21          setContentView(R.layout.main);
22
23          TextView jaxrs = (TextView) findViewById(R.id.jaxrs);
24          try {
25               HttpClient httpclient = new DefaultHttpClient();
26               HttpGet request = new HttpGet(
27                  "http://192.168.1.68:7001/AndroidJAX-RS/jaxrs/helloworld");
28
29               //request.addHeader("Accept", "text/html");
30          //    request.addHeader("Accept", "text/xml");
31               request.addHeader("Accept", "text/plain");
32               HttpResponse response = httpclient.execute(request);
33               HttpEntity entity = response.getEntity();
34               InputStream instream = entity.getContent();
35               String jaxrsmessage = read(instream);
36               jaxrs.setText(jaxrsmessage);
37          } catch (ClientProtocolException e) {
38               e.printStackTrace();
39          } catch (IOException e) {
40               e.printStackTrace();
41          }
42
43     }
44
45     private static String read(InputStream instream) {
46          StringBuilder sb = null;
47          try {
48               sb = new StringBuilder();
49               BufferedReader r = new BufferedReader(new InputStreamReader(
50                         instream));
51          for (String line = r.readLine(); line != null; line = r.readLine()) {
52                sb.append(line);
53            }
54
55            instream.close();
56
57          } catch (IOException e) {
58          }
59          return sb.toString();
60
61     }
62
63}
图 10  展示了 Android 客户端应用程序的目录结构。（查看图 10 的 放大图）。
图 10. 图 10.Android 应用程序的目录结构

运行 Android 客户端
现在，我们准备运行 Android 客户端以调用 JAX-RS Web 服务和输出 XML 消息。右键单击AndroidJAXRSClient 项目并选择 Run As > Android Application，如图 11 所示。
图 11. 图 11.运行 Android JAX-RS 客户端

Android AVD 启动，JAX-RS 客户端应用程序安装在 Android 设备上，如图 12 所示。
图 12. 图 12.Android 上安装的 Android JAX-RS 客户端

AndroidJAXRSClient 活动启动，并且 JAX-RS Web 服务生成的 XML 消息被输出到 Android 设备，如图 13 所示。
图 13. 图 13.输出 XML 消息到 Android 设备

类似地，如果在资源类中，生成 text/html 媒体类型的方法是未注释的，那么输出为 HTML 消息，而 Accept 头被设置为接收相同的媒体类型。例如，在资源类中，取消清单 23 中的方法的注释。
清单 23. 清单 23.在资源类中生成 HTML1@GET
2@Produces("text/html")
3public String getHTMLMessage() {
4          return " " + ""
5     + "

" + "Hello Android" + "

" + " ";
6}
在客户端类中，取消清单 24 中 addHeader 调用的注释。
清单 24. 清单 24.将媒体类型设置为 Accept
request.addHeader("Accept", "text/html");
重新运行 AndroidJAXRSClient 应用程序以获取 HTML 响应，如图 14 所示。
图 14. 图 14.到 Android 设备的 HTML 输出

要获得文本响应，对清单 25 中资源类中的方法取消注释。
清单 25. 清单 25.在资源类中生成文本媒体类型1@GET
2@Produces("text/plain")
3public String getClichedMessage() {
4    return "Hello Android";
5}
在客户端类中，取消清单 26 中的以下 Accept 头媒体类型设置的注释。
清单 26. 清单 26.设置 Accept 头1request.addHeader("Accept", "text/plain");
重新运行 AndroidJAXRSClient 应用程序以获取文本消息输出，如图 15 所示。
图 15. 图 15.输出文本消息到 Android 设备

结束语
在本文中，您了解了如何创建一个 JAX-RS Web 服务并从 Android 客户端调用该 Web 服务。您向 Android 设备发送了 XML、HTML 和文本输出。
范例代码： android-jaxrs-sourcecode.zip
文章出处：IBM developerWorks
标签：HttpClient Android SDK Jersey Eclipse ADT Eclipse RESTful Web服务