Spring For Android初步

绝地灬酷狼 2022-05-31 08:40 281阅读 0赞

# Spring For Android初步 #

Spring for Android 支持在Android环境下使用Spring框架，其意在简化Android本地开发。这包括能够在你的Android应用程序的Rest客户端使用RestTemplate。除了本次主要讲解的网络请求部分，Spring for Android还提供了基于OAuth支持将Spring Social的功能集成到Android应用程序, 授权客户机和实现流行的社交网站,如Twitter和Facebook。

RestTemplate Module

Spring的RestTemplate是一个健壮的、流行的基于java的REST client。Spring Android的RestTemplate模块提供一个能够在Android环境下工作的RestTemplate版本。

RestTemplate类是SFA RestTemplate组件包的核心类。他在概念上类似Spring框架其他同级项目中提供的模板类。RestTemlpate的行为表现取决于他提供的那些回调方法，同时通过配置合适的HttpMessageConverter 类，用户可以高效的将对象转换成HTTP请求中的信息或从响应消息中将信息转换回对应的对象。

每当创建一个新的RestTemplate实例，构造器就会生成配套的辅助对象用于支持RestTemplate的功能。以下是RestTemplate组件中一些提供支持的模块介绍。

HTTP Client

RestTemplate 提供了抽象的RESTful HTTP 请求的模块，内部实现中，RestTemplate 封装了原生的Android HTTP 客户端连接包。这包括标准的J2SE连接组件（用SimpleClientHttpRequestFactory封装）和HttpComponents HttpClient组件（用HttpComponentsClientHttpRequestFactory封装）。默认情况下具体使用哪种ClientHttpRequestFactory 取决于Android的版本。

@SuppressWarnings("deprecation")
    protected HttpAccessor() {
       if (httpClient43Present) {
          this.requestFactory = new HttpComponentsClientHttpRequestFactory();
       }
       else if (okHttpPresent) {
          this.requestFactory = new OkHttpClientHttpRequestFactory();
       }
       else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
          this.requestFactory = new SimpleClientHttpRequestFactory();
       }
       else {
          this.requestFactory = new org.springframework.http.client.HttpComponentsAndroidClientHttpRequestFactory();
       }
    }

（2.3之后建议使用标准的J2SE连接组件）

Gzip压缩器

HTTP规范中允许通过在请求头中加入Accept-Encoding参数指定传输字节流的压缩方式。目前为止，RestTemplate 可以通过Gzip压缩组件支持在发送和接受时通过gzip（仅支持gzip）格式压缩过的数据。

对象-Json转换

如果需要支持这种转换，SFA的RestTemplate需要第三方Json数据映射包的支持。目前SFA提供三种包支持：[Jackson JSON Processor][], [Jackson 2.x][], 和 [Google Gson][]。虽然Jackson 系列是有名的JSON解析包，但Gson的包更小，更适合生成小型的Android程序安装包。  
    SFA 将支持代码放在包 org.springframework.http.converter.json中。

RSS和Atom 摘要文件支持

RSS和Atom的支持也需要第三方包， [Android ROME Feed Reader][]包就提供了相应的功能。

SFA 将支持代码放在包org.springframework.http.converter.feed 中。

所需要的包文件

*  spring-android-rest-template-\{version\}.jar
 *  spring-android-core-\{version\}.jar

RestTemplate 构造器

下面列出四种RestTemplate 的构造方法。默认的构造方法不包含消息的转换器，因此必须自己添加消息转换器。

如上文所讲，如果需要一个特别ClientHttpRequestFactory ，也可以向构造器中传入一个ClientHttpRequestFactory 的实例参数。

*  RestTemplate();
 *  RestTemplate(boolean includeDefaultConverters);
 *  RestTemplate(ClientHttpRequestFactory requestFactory);
 *  RestTemplate(boolean includeDefaultConverters, ClientHttpRequestFactory requestFactory);

RestTemplate API简介

RestTemplate 对应主要的六种Http 访问方法封装了6类高层调用方法，通过他们可以非常轻松且高效的完成对RESTful 服务的服务请求。

RestTemplate 的API方法命名遵循同样的规则:  method+return

比如getForObject() 将调用HTTP GET方法，同时将HTTP响应数据转换成你指定的对象类型并返回。而postForLocation() 将调用HTTP POST方法，将给定的对象转换成HTTP请求内容发送，返回的信息中将标识新的对象资源所在的URL。

当HTTP请求发生异常时，异常信息将被封装在RestClientException 中并被抛出，可以通过在RestTemplate中实现ResponseErrorHandler来捕获并处理。

restTemplate.setErrorHandler(errorHandler);

/*捕获http请求发生异常RestClientException*/
    
    restTemplate.setErrorHandler(new ResponseErrorHandler() {
    
        @Override
        public boolean hasError(ClientHttpResponse response) throws IOException {
            //获得请求响应，通过判断执行不同的操作。。。
            return false;//返回true表示有错误，false表示没有错误
        }
    
        @Override
        public void handleError(ClientHttpResponse response) throws IOException {
            //处理相应的错误操作。。。
            //该方法只有在hasError方法中返回true时才会执行
        }
    });

网络请求方法(其他请求方式类似，可参考官方在线的API文档，链接在参考资料中)：

HTTP GET

public <T> T getForObject(String url, Class<T> responseType, Object… urlVariables) throws RestClientException;

public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> urlVariables) throws RestClientException;

public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException;

public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object… urlVariables);

public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> urlVariables);

public <T> ResponseEntity<T> getForEntity(URI url, Class<T> responseType) throws RestClientException;

HTTP POST

public URI postForLocation(String url, Object request, Object… urlVariables) throws RestClientException;

public URI postForLocation(String url, Object request, Map<String, ?> urlVariables);

public URI postForLocation(URI url, Object request) throws RestClientException;

public <T> T postForObject(String url, Object request, Class<T> responseType, Object… uriVariables);

public <T> T postForObject(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables);

public <T> T postForObject(URI url, Object request, Class<T> responseType) throws RestClientException;

public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Object… uriVariables);

public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException;

public <T> ResponseEntity<T> postForEntity(URI url, Object request, Class<T> responseType) throws RestClientException;

HTTP 消息转换器

对象通过getForObject(), getForEntity(), postForLocation(), postForEntity(), postForObject() and put() 发送或者返回消息时都是通过HttpMessageConverter 的具体实现，从而转换成Http请求或者从Http应答中转换。从下面的HttpMessageConverter  API我们能对他的功能有个更深的认识。

public interface HttpMessageConverter<T> {
    //判断给定的类型是否可以被转换器读取
    //clazz 用于测试是否能够读取
    //mediaType 读取的网络媒介类型，如果不指定，可以为null
    //如果返回true表示可读，false表示其他情况
    boolean canRead(Class<?> clazz, MediaType mediaType);
    // 判断给定的类型是否可以被转换器写入  
    //clazz 用于测试是否能够写入
    //mediaType 写入的网络媒介类型，如果不指定，可以为null
    //如果返回true表示可写，false表示其他情况
    boolean canWrite(Class<?> clazz, MediaType mediaType);

// 返回可被该转换器支持的header头消息类型   
    List<MediaType> getSupportedMediaTypes();
    
    // 将给定的inputMessage消息转换成相应的类型对象并返回  
    // clazz 返回的类型，这个类型必须预先通过canRead方法，返回true
    T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException;
    
        // 将给定的对象转换后写入outputMessage  
        // t 写入outputMessage的对象，这个对象的类型必须预先通过canWrite方法，并返回true
        // contentType  写入时的媒介类型，如果为null的话，则必须使用默认的内容类型转换器，否则，媒介类型必须预先通过canWrite方法且返回值为true
        // outputMessage  要写入的消息
       void write(T t, MediaType contentType, HttpOutputMessage outputMessage)
             throws IOException, HttpMessageNotWritableException;
    }

其中，SFA框架已经提供了现成的MediaType(即mime类型)。

部分类型：

\{ ".323", "text/h323" \},

\{ ".3gp", "video/3gpp" \},

\{ ".aab", "application/x-authoware-bin" \},

\{ ".aam", "application/x-authoware-map" \},

\{ ".aas", "application/x-authoware-seg" \},

\{ ".acx", "application/internet-property-stream" \},

\{ ".ai", "application/postscript" \},

\{ ".aif", "audio/x-aiff" \},

\{ ".aifc", "audio/x-aiff" \},

\{ ".aiff", "audio/x-aiff" \},

\{ ".als", "audio/X-Alpha5" \},

\{ ".amc", "application/x-mpeg" \},

\{ ".ani", "application/octet-stream" \},

\{ ".apk", "application/vnd.android.package-archive" \},

\{ ".asc", "text/plain" \}

默认的消息转换器

基于性能的选择考虑，默认的RestTemplate无参构造方法不包含任何消息转换器。但是，如果调用了布尔版本的构造方法并传递true，则构造器会为一些主要的mime类型增加转换器。当然自己也可以编写自定义的转换器，并通过messageConverters属性添加。  
    RestTemplate生成的转换器包括：ByteArrayHttpMessageConverter, StringHttpMessageConverter, 和ResourceHttpMessageConverter。如果Android的版本在2.2或以上，那么XmlAwareFormHttpMessageConverter 和SourceHttpMessageConverter也会被添加。否则，若在2,.1版本，因为缺少对XML的必要支持，这两个转换器会被FormHttpMessageConverter 代替。我们来看看代码中是如何初始化的。

如果不设置，则使用该默认的消息转换器：

/**
     * Identifies and initializes default {
        @link HttpMessageConverter} implementations.
     */
    
    private static class DefaultMessageConverters {
       private static final boolean javaxXmlTransformPresent = 
             ClassUtils.isPresent("javax.xml.transform.Source", RestTemplate.class.getClassLoader());
    
       private static final boolean simpleXmlPresent =
             ClassUtils.isPresent("org.simpleframework.xml.Serializer", RestTemplate.class.getClassLoader());
    
       private static final boolean jackson2Present =
             ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", RestTemplate.class.getClassLoader()) &&

ClassUtils.isPresent("com.fasterxml.jackson.core.JsonGenerator", RestTemplate.class.getClassLoader());
    
       private static final boolean gsonPresent =
             ClassUtils.isPresent("com.google.gson.Gson", RestTemplate.class.getClassLoader());
    
       public static void init(List<HttpMessageConverter<?>> messageConverters) {
          messageConverters.add(new ByteArrayHttpMessageConverter());
          messageConverters.add(new StringHttpMessageConverter());
          messageConverters.add(new ResourceHttpMessageConverter());
    
          // if javax.xml.transform is not available, fall back to standard Form message converter
          if (javaxXmlTransformPresent) {
             messageConverters.add(new SourceHttpMessageConverter<Source>());
             messageConverters.add(new AllEncompassingFormHttpMessageConverter());
          }
          else {
             messageConverters.add(new FormHttpMessageConverter());
          }
          if (simpleXmlPresent) {
             messageConverters.add(new SimpleXmlHttpMessageConverter());
          }
          if (jackson2Present) {
             messageConverters.add(new MappingJackson2HttpMessageConverter());
          } 
          else if (gsonPresent) {
             messageConverters.add(new GsonHttpMessageConverter());
          }
       }
    }

ByteArrayHttpMessageConverter

该转换器可以从HTTP请求或应答中读写字节数组，默认情况下，该转换器支持所有的media types (\*/\*)，同时写数据会以Content-Type为application/octet-stream（任意二进制数据）的形式。

FormHttpMessageConverter

能处理格式化的数据。支持用application/x-www-form-urlencoded(格式化编码数据)和multipart/form-data（多组件格式数据）的读写转换，格式化的数据通常用一个MultiValueMap<String, String>数据结构来读写。

XmlAwareFormHttpMessageConverter

是FormHttpMessageConverter的扩展，通过SourceHttpMessageConverter增加了对XML转换的支持。

ResourceHttpMessageConverter

能处理资源。支持对所有类型的读操作，写资源支持application/octet-stream。

SourceHttpMessageConverter

可以将请求或应答数据转换成javax.xml.transform.Source类型，只支持DOMSource, SAXSource, 和StreamSource三种类型。默认情况下支持text/xml和 application/xml两种XML可扩展标记语言MIME类型。

StringHttpMessageConverter

可以将请求或应答数据转换成String类型，支持所有的text media类型(text/\*)，支持Content-Type为text/plain（原文数据）写数据。

SimpleXmlHttpMessageConverter

支持对XML格式的读写处理，需要第三方包[Simple XML serializer][]。XML的映射工作可以通过该包提供的注解方式进行配置。如果有需要提供附加的控制功能，可以通过切面的形式通过一个可定制的Serializer进行功能的加强。默认情况下，支持读写application/xml, text/xml, 和application/\*+xml这几种MIME类型。

需要注意的是，此框架和Spring OXM并不兼容。他是用在SFA中的独立的第三方XML串行化实现。基于maven的依赖如下

<dependency>
        <groupId>org.simpleframework</groupId>
        <artifactId>simple-xml</artifactId>
        <version>${simple-version}</version>
    </dependency>

MappingJackson2HttpMessageConverter  
    基于Jackson框架提供对请求与应答数据的Json-Obejct转换。对于Json的映射配置可以Jackson提供的注解支持。当串行化/反串行化需要时也支持切面式的控制管理，默认支持application/json类型的读写。  
    请注意该转换器和GsonHttpMessageConverter 转换器都支持application/json类型的数据转换，因此最好只添加一款转换器，因为RestTemplate 会优先选择他最早匹配到的转换器进行数据转换，所以两款转换器都添加会导致不可预料的结果。

MappingJackson2HttpMessageConverter如果不是通过maven而是手工添加，还需要在lib包中引入jackson-annotations和jackson-core jars。

<dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jackson-version}</version>
    </dependency>

也可以通过MappingJacksonHttpMessageConverter支持 [Jackson JSON Processor][]包。同样，手工导入需要引入jackson-core-asl jar。

<dependency>
        <groupId>org.codehaus.jackson</groupId>
        <artifactId>jackson-mapper-asl</artifactId>
        <version>${jackson-version}</version>
    </dependency>

GsonHttpMessageConverter  
    基本上和MappingJackson2HttpMessageConverter的功能一直，也支持注解和切面式。

<dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>${gson-version}</version>
    </dependency>

(以上也可以使用gradle插件进行配置)

使用gzip压缩

// 添加 Accept-Encoding 消息头属性，设置为gzip
    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.setAcceptEncoding(ContentCodingType.GZIP);
    HttpEntity<?> requestEntity = new HttpEntity<Object>(requestHeaders);
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
    // 注意调用的方法
    ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
    
    Gzip压缩能有效的减少通讯传输的信息量。Gzip格式传输必须在服务器端被支持。通过将内容的请求头Accept-Encoding设置为gzip，可以向服务器端请求使用gzip压缩传输。如果服务器端支持，将返回压缩后的数据。RestTemplate 将检查Content-Encoding属性判断应答返回数据是否是压缩过的，是则用GZIPInputStream 去解压缩。目前Content-Encoding仅支持gzip格式。
    需要注意，如果在2.3或以后的版本使用基于J2SE的标准连接SimpleClientHttpRequestFactory，Android框架会自动在Accept-Encoding中设置gzip，如果希望是gzip压缩失效，必须在header信息中增加其他标志值：

HttpHeaders requestHeaders = new HttpHeaders();
    //增加如下标识
    requestHeaders.setAcceptEncoding(ContentCodingType.IDENTITY);
    HttpEntity<?> requestEntity = new HttpEntity<Object>(requestHeaders);
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(new StringHttpMessageConverter
    ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);

通过GET方式获取JSON数据

首先需要定义一个与返回的JSON格式对应的POJO类。

public class Event {
        private Long id;
        private String title;
        public Long getId() {
            return id;
        }
        public void setId(Long id) {
            this.id = id;
        }
        public String getTitle() {
           return title;
        }
        public String setTitle(String title) {
           this.title = title;
        }
    }

使用Rest请求：

RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    Event[] events = restTemplate.getForObject(url, Event[].class);
    
    也可以通过设置请求头Accept信息的方式

// 显式设置 Accept header
    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.setAccept(Collections.singletonList(new MediaType("application","json")));
    HttpEntity<?> requestEntity = new HttpEntity<Object>(requestHeaders);
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    ResponseEntity<Event[]> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, Event[].class);
    Event[] events = responseEntity.getBody();

其中MappingJackson2HttpMessageConverter可以换成GsonHttpMessageConverter，作为另一种实现JSON解析的选择。

通过GET方式获取 XML 数据

我们使用刚刚用过的Event对象来演示XML的使用方法，注意Event的类及属性都有注解。

@Root
    public class Event {
        @Element
        private Long id;
        @Element
        private String title;
        public Long getId() {
            return id;
        }
        public void setId(Long id) {
            this.id = id;
        }
        public String getTitle() {
            return title;
        }
        public String setTitle(String title) {
            this.title = title;
        }
    }

如果需要解析一组Event的数据，我们还需要定义基于List的包装类。

@Root(name="events")
    public class EventList {
       @ElementList(inline=true)
       private List<Event> events;
       public List<Event> getEvents() {
          return events;
       }
       public void setEvents(List<Event> events) {
           this.events = events;
       }
    }

编写请求代码如下：

RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(new SimpleXmlHttpMessageConverter());
    EventList eventList = restTemplate.getForObject(url, EventList.class);

和刚才一样，也可以通过设置请求头Accept信息的方式：

HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.setAccept(Collections.singletonList(new MediaType("application","xml")));
    HttpEntity<?> requestEntity = new HttpEntity<Object>(requestHeaders);
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(new SimpleXmlHttpMessageConverter());
    ResponseEntity<EventList> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, EventList.class);
    EventList eventList = responseEntity.getBody();

通过POST的方式发送 JSON 数据

我们定义了如下的POJO用于演示：

public class Message {
        private long id;
        private String subject;
        private String text;
        public void setId(long id) {
            this.id = id;
        }
        public long getId() {
            return id;
        }
        public void setSubject(String subject) {
            this.subject = subject;
        }
        public String getSubject() {
            return subject;
        }
        public void setText(String text) {
            this.text = text;
        }
        public String getText() {
            return text;
        }
    }

接着是编辑数据和发送请求的代码

// 编辑数据

Message message = new Message();
    message.setId(555);
    message.setSubject("test subject");
    message.setText("test text");
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
    String response = restTemplate.postForObject(url, message, String.class);

同样，通过设置请求头Content-Type信息也是可以的

// 编辑数据
    Message message = new Message();
    message.setId(555);
    message.setSubject("test subject");
    message.setText("test text");
    // 设置 Content-Type
    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.setContentType(new MediaType("application","json"));
    HttpEntity<Message> requestEntity = new HttpEntity<Message>(message, requestHeaders);
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
    ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
    String result = responseEntity.getBody();

(注意：如果想用spring for android的json解析功能，服务器需要返回的type类型应该为application/json而不是通常的text/html)

其他： Spring for Android还提供了三方授权，本身提供facebook和twtter的三方授，需要第三方包的支持。提供了Spring Social组件用于创建自己的连接工厂，并提供加密和保存信息的功能。

Spring for Android的核心部分比较强调服务器和客户端之间的数据交流，服务器需要确实返回指定的MIME类型，客户端才能进行更加简便的数据解析。

参考资料：

[http://projects.spring.io/spring-android/][http_projects.spring.io_spring-android]

[http://docs.spring.io/spring-android/docs/1.0.x/reference/htmlsingle/][http_docs.spring.io_spring-android_docs_1.0.x_reference_htmlsingle]

[http://tool.oschina.net/apidocs/apidoc?api=springforandroid][http_tool.oschina.net_apidocs_apidoc_api_springforandroid]

[http://blog.csdn.net/yoara/article/details/37963497][http_blog.csdn.net_yoara_article_details_37963497]

[http://blog.csdn.net/icyfox\_bupt/article/details/9572813][http_blog.csdn.net_icyfox_bupt_article_details_9572813]

[http://www.tuicool.com/articles/qu6v2eJ][http_www.tuicool.com_articles_qu6v2eJ]

[Jackson JSON Processor]: http://jackson.codehaus.org/
[Jackson 2.x]: https://github.com/FasterXML/jackson-databind
[Google Gson]: http://code.google.com/p/google-gson/
[Android ROME Feed Reader]: http://code.google.com/p/android-rome-feed-reader
[Simple XML serializer]: http://simple.sourceforge.net/
[http_projects.spring.io_spring-android]: http://projects.spring.io/spring-android/
[http_docs.spring.io_spring-android_docs_1.0.x_reference_htmlsingle]: http://docs.spring.io/spring-android/docs/1.0.x/reference/htmlsingle/
[http_tool.oschina.net_apidocs_apidoc_api_springforandroid]: http://tool.oschina.net/apidocs/apidoc?api=springforandroid
[http_blog.csdn.net_yoara_article_details_37963497]: http://blog.csdn.net/yoara/article/details/37963497
[http_blog.csdn.net_icyfox_bupt_article_details_9572813]: http://blog.csdn.net/icyfox_bupt/article/details/9572813
[http_www.tuicool.com_articles_qu6v2eJ]: http://www.tuicool.com/articles/qu6v2eJ