SCMLife.com

 找回密码
 立即注册

QQ登录

只需一步,快速开始

扫一扫,访问微社区

查看: 3449|回复: 1

[推荐] 面向 Android 应用程序的基于 Parse 云的服务

[复制链接]
发表于 2013-2-17 16:56:21 | 显示全部楼层 |阅读模式
本帖最后由 技术狂人 于 2013-2-17 17:06 编辑
1 b* ~3 E2 l, Q; }8 E
9 z& y7 q1 F% \7 f3 m" O  t  c. wParse 移动 SDK 为 iOS、Android 和 Windows® 应用程序提供了基于云的 API 和服务。Parse SDK 还提供了 JavaScript 和 REST API。使用 Parse API,您可以极快地以最少工作量让您的移动应用程序支持云处理。集成了 Parse API 的移动应用程序可以轻松地在 Parse 云上存储数据对象和文件,发送并侦听推送通知,管理用户,处理地理位置数据,并使用 Twitter 和 Facebook 等社交媒体平台。对于需要扩展的移动应用程序,Parse SDK 可以提供所有灵活的云平台。
# P! m; }5 S- S; a% ^开始之前                                                    出于本文的目的,我假设您已经非常熟悉使用 JSON、Android 和 Eclipse 进行移动应用编程的基本概念。在您继续阅读本文之前,请访问 Parse.com 并定义您的应用程序。只需遵循注册页面中的简单指令即可。            
+ y5 f5 `5 R) s& c1 f$ d- y7 z+ G' t5 m0 }! g
本文介绍了面向 Parse 用户、数据对象和文件的核心 Parse API 类。您将学习如何使用访问控制列表 (ACL),以及如何在数据对象上执行 CRUD 操作,还有如何在 Parse 云中存储和检索文件。示例均构建于 Parse SDK for Android 之上(请参阅 参考资料)。( ^0 V) C; d/ s1 m/ z
Parse 仪表板
6 t9 W" t7 o3 W& O! C- y. w! cParse 仪表板可以帮助开发人员管理应用程序。该仪表板为 API、文件和推送的通知提供了一般指标和应用程序特定的使用指标。通过仪表板可管理应用程序的键和设置。该仪表板还提供了数据浏览器,使开发人员能够浏览(甚至编辑)所存储的 Parse 对象。数据浏览器对于调试非常有用。图 1 是 Parse 仪表板的屏幕截图:
3 g8 I+ K0 m9 _! D8 L" O4 @. {
  W2 r% t& e! p' w* l/ ^图 1. Parse 仪表板
7 T6 H! F0 n, S  m! [
+ H3 I. b  X6 g, a, V+ [' Q$ u" R通过一个应用程序 ID 和客户端 ID 对应用程序进行身份验证。为了获得您的应用程序和客户端 ID,必须通过 Parse 仪表板注册您的应用程序。在您的应用程序上初始化 Parse 库时,会用到这些键。
* ~* N) Z! c1 k/ ]+ LParse 数据对象% s! ~3 H2 L/ H+ i( N$ ~+ D1 G
在 Parse 中,使用 “名称-值” 对的容器 ParseObject 表示数据。ParseObject 可以存储任何与 JSON 兼容的数据,如清单 1 所示:6 B5 n# |9 B6 b% W7 |

6 S# O2 {% k6 }清单 1. ParseObject 示例8 e6 \0 f) `+ Q: s- _8 h2 k
ParseObject myParseObject = new ParseObject("MyObject"); // Class Name
# V0 C: X: D) R" v% J# e! }myParseObject.put("name", "C. Enrique Ortiz");3 b5 r: e5 \! Y( S# Q! q- l' L4 I
myParseObject.put("twitterHandle", "eortiz");
; ?9 [7 d8 x2 RmyParseObject.put("followers", 123456);

8 B! F6 D' z0 U0 F1 ]; {$ \- J5 aParseObject 在实例化时被赋予一个 classname(类名称)。在 清单 1 中,类名称是 "MyObject"。类名称与关系数据库中的表名称相似,同一类的 Parse 对象相当于表中的行。& d- ~: i7 o! |7 A8 g' r2 [7 r* U8 }
ParseObject 暴露的方法类似于 Java Map 类中的方法,如                putgetremove,以及大量特定于 ParseObject 的其他方法。
  R3 i$ F2 _( S* C" W# LParseObject名称键 必须是字母数字的,作为一个指导方针,请对名称键使用驼峰式大小写 (camel-casing) 格式。值可以是存储在 JSON 中的任何数据类型,也就是说,可以是数字、字符串、布尔值、数组、JSONObject.NULL、JSONObject 和 JSONArray。ParseObject 所支持的其他数据类型是 Java Date 和 byte[] 数组。ParseObject 还可以包含其他 ParseObject。
2 D) Y# y' m( C# ~( J" Y清单 2 显示了部分受支持的 ParseObject  值数据类型:5 m. N7 o" Z! J

, i0 J; U* R! m清单 2. ParseObject: 部分支持的值数据类型
5 P  a4 V+ W4 A
// Byte Array
$ v% e+ d$ k$ Ybyte[] byteArray = {1, 2, 3, 4, 5};8 H1 B% @9 Q$ z: X7 P7 H) C
) P5 T1 M" g; z9 R
// A date
4 C& O3 a0 U6 v3 J# PDate d = new Date(); // java.util.Date
; d) ~- |& B& n. o- M# o) |- @. A& d4 h
" ~1 d- ~8 R) d6 c; o: u" w, G// A number
7 f; p/ {' u, bint number = 21;
! Y! ]- U% J+ n# c. n9 [8 f
" T3 _* T" |1 k3 e# v( v& p9 r// A String
# z0 B) Y. M! i# g' {2 x& `( vString name = "Enrique";! B- [; Y; B( W+ G8 H( Y/ S3 S
" M7 [) J5 g8 J- l! f; s/ H
// A JSONArray - any mix of JSONObjects, JSONArrays, Strings, Booleans,
7 k, B# E1 F) j. U* J3 x//   Integers, Longs, Doubles, null or NULL.8 T) Z( q6 W" S! ?6 z- C* d- @
JSONArray jArray = new JSONArray();! O8 F7 }7 |" R' B: [
jArray.put(number);
+ c, v/ d& @% x: i- ~2 q. ejArray.put(name);
  q. F" ~& z, i7 @; ^! ^( n3 L4 R/ [; P7 n: M* D' p) a
// A JSONObject
, I7 ~- i, I; A2 ~4 J- I4 e9 eJSONObject jObject = new JSONObject();) x/ O  v( x$ |* t# Z! }
try {
  i: z; b* |; t: [3 Z    jObject.put("number", number);
+ d% V6 e. }# @) r" h. Z! f    jObject.put("name", name);
5 k2 P! ~! t/ i% \" ]# Z. C) Z} catch (JSONException e) {
0 p" j% H9 r5 l  K& k* ^1 \    e.printStackTrace();
1 }, u, Z8 {& j8 ]* i}1 X5 X! E3 p2 o; ^: f
% l0 u9 J6 u2 y3 w& F
// A ParseObject
2 ]5 t% m, `. d& a3 p' y# i6 tParseObject pObject = new ParseObject("MyObject"); // Class name: h+ ~" a1 U! h
pObject.put("myByteArray", byteArray);  |( k9 h3 ~) w/ X
pObject.put("myDate", d);- r' Z2 z  a$ Q9 d# g9 x
pObject.put("myString", name);
! A0 U6 ]- m8 _0 HpObject.put("myNumber", number);( ~* w. q. c- b" X
pObject.put("myJsonArray", jArray);
1 |9 {( U% z9 v2 L2 }. V, m9 tpObject.put("myJsonObject", jObject);( i: R5 Q$ @+ H! \  h( ^% |& J2 G
pObject.put("myNull", JSONObject.NULL);
6 s& Y& I: o1 x. _, T7 N
/ }9 Y  f1 }+ g
清单 2 中的代码创建了一个 ParseObject,它在 Parse 云中被存储为一个对象。然后,许多同一类的 MyObject 被存储为 ParseObject 数据对象的行,可以保存、查询和更新,并能从 Parse 的云存储中删除。甚至可以在应用程序离线时保存数据,Parse 库将数据保存在本地,直到重新建立网络连接。
/ U5 \% P" |  L2 {* `修改                ParseObject8 {! U: [: ^- s  T" J; [
如果您熟悉移动应用程序开发,那么您就会知道,网络操作等长时间操作一般都是在后台完成,或在一个工作线程上完成,而不是在主系统的 UI 线程上完成。这样可以避免主系统线程发生阻塞并影响用户界面的响应速度。稍后,在本文的后半部分,我会告诉您 Parse 如何为后台工作提供帮助,从而保存、删除和查找对象。现在,考虑下面的同步 remove() 方法,可以使用它从 Parse 对象删除一个键:# |9 B. }. |$ l; X' l3 U9 N/ J
pObject.remove("myNumber"); // remove the field/key "myNumber" from pObject
  N$ d( f  ?" [
在删除或添加字段后,或在更新当前字段后,您可以在云上保存(或更新)数据对象,只需调用其中一个 ParseObject 的 save...() 方法,我稍后会在本文中讨论它们。: Z" v/ y' U  Y" @6 }2 R& f9 W
摘要:ParseObjectParseObject 代表在 Parse 云上的一个数据对象。它提供各种方法,可以添加 “名称-值” 对,测试给定的键是否存在,从服务器删除或提取给定的 ParseObject。ParseObject 也让您可以使用多个 get...() 和 put...() 方法,操纵 ParseObject 数据,合并 ParseObject,在服务器中保存 ParseObject,等等。
5 |, T- H% O9 ~  g$ S. F$ x' {; U& h% t6 A3 {8 V

- v6 z  {% d: b. b" H( BParse 用户、角色和 ACL- f' \. ~/ W. \4 h8 I
在我告诉您如何在 Parse 对象上执行 CRUD 操作之前,您应该了解一下 Parse 用户、角色和 ACL(访问控制列表)。这三个都是非常重要的概念,有助于保护您的应用程序的数据对象。
6 K4 j' [4 B2 D7 S5 dParse                用户" |$ ?' G% w9 {( T: i1 Z! S
名称为 ParseUser 的类代表一个用户,并为 Parse 应用程序提供用户帐户功能。每个 Parse 应用程序都有与之关联的 Parse 用户。一个 ParseUser 是一个 ParseObject,但具有更多的属性,如用户名、密码和电子邮件。您可以添加任何您认为合适的其他数据值。
. R* l" w# U5 C0 ]3 WParse 中的匿名用户在 Parse 中,匿名用户是没有用户名或密码的用户。匿名用户对于那些不要求用户身份验证的移动应用程序功能非常有用。匿名用户可以创建数据对象,但这些对象寿命很短,并且在匿名用户登出之后就不再可用。! b; S0 W5 `2 b/ o# |

5 |$ w5 W3 S0 Q6 F% n/ q# [$ [+ [9 w; p) i; |. N
用户可以注册为您应用的 Parse 用户,如清单 3 所示:
5 v, |0 k+ D* X2 N1 c
+ K' c2 p5 F$ L2 N* w* f清单 3. ParseUser — 注册* {: S* p! I$ L5 {9 r9 Q
ParseUser user = new ParseUser();; |, W3 j6 j3 ~  R+ W2 E
user.setUsername("eortiz");
( ?3 ~: ]7 ]% D5 A! Uuser.setPassword("123456");
- B0 N* t1 g+ C4 M/ l, ~user.setEmail("eortiz@nospam.com");9 Z" L6 a1 t6 o0 ^
user.put("userType", "Author"); // add another field
. I- M/ _) v6 u( d; Z0 G: o$ U+ t4 g: {
// Call the asynchronous background method to sign up
6 I$ B* R+ ?. [4 Q; ?( Y" Y5 u  W. Quser.signUpInBackground(new SignUpCallback() {5 a& q# \# D6 W4 D
  public void done(ParseException e) {8 m$ v% ^2 q" U
    if (e == null) {7 l/ l# L- b, `1 S0 a
      // Successful. Allow access to app.
5 E) w$ B3 m" R* X7 d    } else {
" @" G" R/ `  \  k4 ~      // Failed....
* ]/ i2 G5 H9 y7 b# Y. [+ U    }. h1 e& V$ D& z" _
  }; \. Z/ c; e9 ?# e
});

& l: b( M0 f: k3 _# H2 yusername 和 email 必须是惟一的。如果 username 或 email 已经被使用,那么注册调用将会失败。您应该有一个通知用户字段限制的机制,并提供一个重试的进程。
8 s# l  d# T1 l* Z! ]在注册之后,用户就可以登录您的应用,如清单 4 所示:
& G' Z  a; J- e0 B- d& E' d# F/ r! @3 `$ U; m; a
清单 4. ParseUser — 登录* S4 D# J# D" z  K1 _0 u0 q
ParseUser.logInInBackground("eortiz", "123456", new LogInCallback() {  f9 b8 Y* Q5 V6 t, c( I/ @
  public void done(ParseUser user, ParseException e) {
% v4 f4 i( j" d  N  ]( Z$ p    if (user != null) {
* ?( |% m4 S) z4 C: A      // Successful. Allow access to app., F- E+ i* b9 O8 p- I  ~
    } else {; H' x( \( E6 o1 @# P
      // Failed
9 B4 \$ }; S9 E6 g. [9 H9 M. Y8 Q    }
6 f: f5 _% M+ i; f8 Q& W  }
$ V! [0 c1 N  T  d2 M2 s/ R});

" \. ?% {7 y0 j您可以通过调用 ParseUser.save() 更新用户信息。 但是请注意,只有 ParseUser 的所有者可以修改其内容,数据对于其他任何人都是只读的。
* ]2 L  X! ?$ a6 ]- eParse 会缓存当前登录的用户。您可以通过调用 ParseUser.currentUser() 查询当前用户。currentUser 方法使您能够快速访问当前用户信息,那么如果当前用户会话没有激活,您只需要根据提示输入验证。清单 5 显示了如何在 Parse 中检索当前用户:
$ @5 ^2 p, m* O+ l
' i* t9 t; \/ L& M4 N清单 5. ParseUser — 获得当前用户/ O1 P7 k# F: A
ParseUser currentUser = ParseUser.getCurrentUser();
* ~, S+ ]. E& o: Y0 j( ?if (currentUser != null) {6 y: T( B. F1 k
  // current user is valid! c- z* o# ]8 ]% v/ W5 ?8 e( q
} else {0 {( r4 b8 i3 T/ S, _  b; l
  // current user not valid, ask for credentials
& U1 T9 ]* R1 x}
4 ]( C) z& E. `! [' r: R
重置当前用户
: ^- U1 y- }# [1 s. C* R在 Parse 中,您可以通过调用                ParseUser.logOut() 来重置当前用户,如清单 6 所示:
; p* x- |4 ?4 g$ A& ?# M) B
& H, A- C; F; e6 n& x  l清单 6. ParseUser — 重置当前用户(登出)6 ]* c- _2 {9 N& z, w
ParseUser.logOut(); // static method
; G& g3 l) `& m( S0 i
Parse                ACL
( _/ u) M" N6 E' H# W/ Y$ S) fACL 是关联到数据对象的访问权限(或控制)列表。ParseACL 类允许您为给定的 ParseObject 定义权限。使用 ACL,您可以定义对您的应用程序数据对象的公共访问,并且可以(通过角色)限制对特定用户或用户组的访问。清单 7 演示了 Parse ACL 的用法:
8 R* N) |* e7 ~1 M2 r
7 N; H6 D8 E' W, x2 c6 x清单 7. 使用 ParseACL 实现访问权限控制
6 o& r0 y' t! T- G& A" V( k7 ?# |
// Define a Parse user
* E+ n. w+ y$ UParseUser user = new ParseUser();: X; `/ t/ o+ z' O! }: n( ~- t% e
user.setUsername(username);
! a+ t3 M# _/ H" U:4 t, [# c& g# d$ T4 D% E2 c
:5 ]2 }& h/ L, s) |6 ~2 [9 e8 }8 M
, S1 \, ?; i# A( P" r
// Define a read/write ACL# t) W( o. ^6 L- Q5 N
ParseACL rwACL = new ParseACL();
6 j" H( v& H& C0 E$ @/ m+ frwACL.setReadAccess(user, true); // allow user to do reads, x" _; N+ I$ H3 w0 Q( ~9 l" ?7 K6 o( u
rwACL.setWriteAccess(user, true); // allow user to do writes
) Z% V- K8 x. R5 k& o" b:! t7 \9 A0 h; N$ }3 i! G) w7 @
:
* X& K( z$ l/ D) m. ?4 s" d
6 W" ]7 c2 m3 G' g& H  t6 \// Define a Parse object and its ACL
- Z; O! e# G  F# N" ]0 y+ [& t/ c8 t+ YParseObject gameObject = new ParseObject("Game");- u" u/ H, N: F, R- c
gameObject.setACL(rwACL); // allow user do read/writes on gameObject
+ P* h& o, [6 X' wgameObject.saveInBackground(); // save the ACL'ed object to the cloud
; H1 D5 e9 d0 I9 K7 C  R:
) J5 j1 M! Z- S' r4 J8 i5 \  R:
* c. o" t4 @1 j$ d/ [" d
: s2 D& h3 U1 t# i- K4 I// You can define a public ACL that gives public access to the object
+ m. ^) u9 `( \" G+ TParseACL publicACL = new ParseACL();
7 M( D9 ~* H* s  g& X/ U/ a: _publicACL.setPublicReadAccess(true);
8 i) P8 B' j- [% jpublicACL.setPublicWriteAccess(true);      " _3 U* w; d; y( w. L( U( k5 K4 {
gameObject.setACL(publicACL); // allow public read/writes7 F. B6 I8 B& U; p/ }$ N
gameObject.saveInBackground(); // save the ACL'ed object to the cloud

" a+ p: U! [/ E) g& u& B您还可以为所有新创建的对象定义一个默认的 ACL。在清单 8 中,我已经将可读取和写入的默认 ACL 设置为 public,清单 7 中的 publicACL 定义。8 `5 i6 p4 ^; w8 R7 B
7 H/ M/ S( N  N! o1 K+ g3 q& c
清单 8. 设置默认的 ACL7 m; T, W, p8 ]. R' Z& t( N' f2 ^
// Set a default ACL for all newly created objects as public access/ q0 }4 V, k6 o
ParseACL.setDefaultACL(publicACL, true);

7 n6 N; R% J( N& S! R+ s9 o5 L虽然在这里没有演示,但我们也可以使用 ParseRole 类为用户组授予访问权限。6 K4 G( x) b" F$ N" b" \- w# U
接下来,我们将查看如何将 Parse 数据对象保存到 Parse 云,并在 Parse 云中检索它们。
+ p3 I+ u! f5 v在云上的 Parse 数据对象* o* {( ^3 F1 V  Q
一旦创建并填充了 ParseObject,就可以在 Parse 云上保存。在 Parse 云上保存数据对象实际上是利用 Parse 的最简单操作之一,其复杂性通常与数据表示、编组、网络通信和传输等有关联,Parse 完全隐藏了此复杂性。您需要使用 helper 方法来将数据对象实例映射到 ParseObject,并映射回来,您需要决定是在您自己的线程上调度 Parse 保存操作,还是使用 save-in-the-background 方法。
' P5 G% T0 h$ I2 i谨防系统线程阻塞!回想一下,在移动应用程序中,长时间的操作(如网络、文件或长的计算)不应该在主系统线程上完成。相反,应在一个单独的工作线程中执行它们。阻塞系统线程会对应用程序的用户界面的响应能力产生负面影响,有可能导致强行关闭您的应用程序。
; s, D0 K3 A0 L+ ]( k9 c, }
+ D/ x- O! G3 `4 O! p  t0 p+ _4 b( |" r/ F4 h* y3 P7 L9 f- l' O
ParseObject 提供两个保存方法:                save() 和                saveInBackground()。                saveInBackground() 是建议的保存方法,因为它在自己的工作线程上运行保存操作。如果您选择使用同步的 save() 方法,需要注意的是,您需要在该方法自己的工作线程上调用该方法,以避免 UI 被阻塞。* m  q5 B7 |0 T/ o8 [% a% f: O( k; q
清单 9 显示的代码在后台保存 Parse 数据对象:- M6 `6 k  {) e' ]8 S- f
/ |6 D( f; E% ^: _! t
清单 9. 在后台保存 ParseObject( E% t" U$ I$ X% G0 J
// ParseObject
* g/ U( y/ \) x, DParseObject pObject = new ParseObject("ExampleObject");
3 [8 X2 a  Q2 G3 o! |# tpObject.put("myNumber", number);
& S0 R& ?5 G, z1 F) opObject.put("myString", name);
" T. A8 m) Q% R, f( X, ~; cpObject.saveInBackground(); // asynchronous, no callback
+ F) ~) t& Q) [" \+ U
清单 10 显示的代码使用了一个回调,在后台保存 Parse 数据对象:
2 n$ y% g! ~: o$ o/ ^' @3 {4 E8 N0 c
清单 10. 使用回调,在后台保存& |( B3 V& V, i# v+ _
pObject.saveInBackground(new SaveCallback () {
5 P0 N2 n: I4 ]" h# ?    @Override
2 k! O1 _% Q& L( F- _    public void done(ParseException ex) {/ h/ X, N2 L' a0 J4 B! R
        if (ex == null) {
9 S* A, p7 y5 C& `% \. ?* j- z7 o            isSaved = true;9 c  v3 E- C) }
        } else {
( i7 O* O8 B+ l7 z9 B            // Failed) Z3 N! N8 U3 c1 J: u
            isSaved = false;
5 a3 e7 d9 h. r# ~. y; ]        }
" O' \% Y4 M4 ~% v    }, A$ m" A: Z, A: ^/ W  ^; [
  });

" O: B2 I7 z; Ssave...() 方法的变形包括以下几种:
  f% x* I- O) x( x8 W. K. M- V
  • 使用或不使用回调,saveAllinBackground() 保存 ParseObject。
  • saveAll(List<ParseObject> objects) 保存 ParseObjects 的列表。
  • saveAllinBackground(List<ParseObject> objects)在后台保存 ParseObjects 的列表。
  • saveEventually() 让您能够在未来某个时点将数据对象保存到服务器;如果 Parse 云目前不可访问,则使用该方法。
    : D2 m- d% d/ u2 E* F
一旦在云上已成功保存了 ParseObject ,就会为对象提供惟一的 Object-ID。此 Object-ID 非常重要,因为它惟一地标识了此 ParseObject 实例。例如,您可以使用 Object-ID 确定是否已在云上成功保存该对象,以便检索或刷新给定的 Parse 对象实例和删除特定的 ParseObject。% y7 P) e. o. d- M$ x
从云中检索数据对象# [  m* C7 X4 y( l; T
这一节将探讨查询和检索 Parse 云上的数据对象的方法。您可以通过 object-ID 查询一个 ParseObject,您也可以使用属性查询一个或多个 Parse 对象。如果您已经有一个 ParseObject,那么您可以通过从服务器提取最新的值,刷新或同步其内容。我们将在以下代码片段中探讨所有这些选项。; a+ l: \! K( e* c/ T7 \
提取 ParseObjects
# N& J- i9 H3 a* Z2 ^6 M: z为了从 Parse 云提取数据对象,使用 ParseObject 方法 fetch() 或 fetchInBackground(),如清单 11 所示:
, O% a- U. w8 u: y6 d. e: }
, d( }; ]* i# i6 f7 r清单 11. 提取(无条件)
, O  n) B" h6 E( X' b. T
// ParseObject9 d9 \/ W/ L2 [
ParseObject pObject = new ParseObject("ExampleObject");
+ I/ O9 c: r3 M6 b4 A4 U1 Z:9 s, z, M% ~  k! p( w
:
9 N; H5 j' K3 U+ Y5 _0 ?2 W" M" }
( k1 R  D, [6 w6 ~// Fetch the parse object unconditionally# S( ^! j6 {. u% s7 x6 I
try {/ p) f4 `0 P& W4 A4 q
    pObject.fetch();- G7 t2 [7 A( M" u* m% B
} catch (ParseException e) {
. L3 k+ z* Y; i1 D2 O) @    e.printStackTrace();8 g" e& t6 ^; D# ?8 B5 s
}* z3 }# O! D' I; o5 Y; x+ ?

; h; J  h$ j  B: y- f4 o// Fetch the parse object unconditionally, with Callback/ x. [: U# P9 _
pObject.fetchInBackground(new GetCallback() {/ Z% Z# N* w6 u" h. H
    @Override) \. O, d, X  C* \; {, u6 `
    public void done(ParseObject obj, ParseException ex) {: J9 I/ b, z: v1 v6 v$ l* z
        if (ex == null) {7 u1 R+ S, ~5 Z8 V6 c
            // Success
# Q/ K+ \; W2 k# T        } else {
3 s8 s4 z( p$ J2 E1 ^            // Failed4 ^" n6 o6 Q8 a& e; M
        }            
" {; [( ~! i& b& j0 |! P5 l. o; v  G) E    }
% Z9 s* o) F8 y});

" J0 I+ v2 |5 m您也可以仅在需要时提取数据,例如,提取一个相关 Parse 对象的 Parse 对象,如清单 12:
5 P/ d$ V6 g3 f& n' G$ k7 b2 `: W0 [& ?! R/ r
清单 12. 根据需要进行提取1 M. Q! ^% N! w1 V
ParseObject po = new ParseObject("ExampleObject");9 v. t& V- A6 Z% C
:
5 D& a9 i! H% K% d; Z
: {1 g) v& L) Z" }/ vParseObject po2 = po.getParseObject("key");
$ \5 m3 L6 @/ h8 L: W
: w6 j2 J4 x- p+ D! B- }6 @0 c6 S// Fetch only if needed# ~' D2 w+ ~1 r& i
try {
3 a. V  z6 D/ n* X/ V" i    po2.fetchIfNeeded();( q; K/ A9 t' _
} catch (ParseException e) {% D. I6 S# @% F0 T/ O
    e.printStackTrace();# ~4 b; k: g$ z- C4 ~% F7 }
}

! J0 M# x, J; k6 V6 c另一个选项是在后台根据需要执行提取操作,并使用一个回调。为此,可以使用 Parse 对象的 fetchIfNeededInBackground(GetCallback callback) 方法。2 I8 d) R' U& m1 s4 G
在某些情况下,您需要无条件地或仅在需要时一次提取一个 Parse 对象集合。ParseObject 为此提供了一组静态方法,每个方法都将一个 Parse 对象的列表作为输入,然后返回一个 Parse 对象的列表:
7 t4 w2 n0 }9 @- s, V
  • fetchAll(List<ParseObject> objects)
  • fetchAllIfNeeded(List<ParseObject> objects)
  • fetchAllIfNeededInBackground(List<ParseObject> objects,                    FindCallback callback)
  • fetchAllInBackground(List<ParseObject> objects, FindCallback                    callback)
    7 ?9 i6 F% ~2 f4 |0 \7 f1 ^5 b7 y" c& t
在云上查询数据对象
- ?. p6 i1 {3 P) Y9 `希望您现在已看到 Parse API 的强大,但是别着急,它还有更多功能!除了提取数据对象之外,Parse 还可以让您使用 object-ID 或属性来查询数据对象。要从 Parse 云查询一个数据对象,可以使用 ParseQuery。您可以使用 ParseQuery 进行基本的和复杂的数据查询,接收给定的对象或匹配对象的 List。
" x! y& s4 @! X3 S4 a- C清单 13 显示了如何在一个后台线程中使用给定 object-ID 从服务器检索特定的 Parse 对象:
+ x4 M: h4 M- B6 j& @( }* p& ]+ V
9 e* N/ X6 c6 q* m清单 13. 使用 ParseQuery 检索给定的 ParseObject7 z5 X! D& n4 x+ [$ O
String myID = "12345";
" q. o' x1 D% ~3 m- X: z' pParseQuery query = new ParseQuery("Players");
9 s: A) o" {+ G. `( s* Yquery.getInBackground(myID, new GetCallback() {2 F& _! K' J( {* g$ K
    @Override
+ v9 q, x  s4 T) k    public void done(ParseObject object, ParseException e) {
$ u7 [  P5 z* U        if (object != null) {; @  S8 z3 I2 d* }' {( b. p
            // Get object
- k  X1 w. S' D/ y* {% h        } else {
9 i$ X% \1 f" c- v6 o            // Not found5 A) X4 w8 ]3 c( [7 h
        }
2 R3 V2 c3 `* O, `# D0 s( q    }            + ]6 M4 O/ i8 O8 o6 ]% v  `) Y. K0 @
});
9 i8 V/ f  k  B8 J+ L/ B' i
请注意,query.getInBackground() 没有使用 ParseQuery 缓存。  f! v  v5 R* G. m0 l/ R2 p
清单 14 显示的查询检索 Players 类的所有数据对象。(没有提供约束。)
/ B* l% U. @$ e& b/ u; _# J2 T) |; v* I& X& I' q
清单 14. 对给定类的所有 ParseObjects 使用 ParseQuery  p0 p6 r: \9 T6 V: W
ParseQuery query = new ParseQuery("Players");
4 ?3 A3 B1 T! k# Z& gquery.findInBackground(new FindCallback() {5 [# s- ~" g4 x$ x2 x
    @Override+ ~. V/ h# i2 l
    public void done(List<ParseObject> players, ParseException e) {0 F+ I% ^9 N2 n' g
        if (players != null) {% v  y, s7 ~! V* {3 v
            // Get list of players
5 p: s+ D2 _" I$ P) [        } else {  K7 \# F' M' |+ i* ?
            // No players
& _4 W7 q# P% F5 f* n( P) C        }+ m) k+ i7 C. |0 \) L
    }
! o5 G: |( f) R9 O. r* Z/ d  k: s});
1 C$ J* _5 A2 ]- `) D4 \
在清单 15 中,我使用了一个查询约束来检索一个或多个匹配的 Parse 对象;在本例中,使用了一个活动的 Players:0 f% R  [0 o( q+ [' `$ r8 |7 t5 {! }0 [
7 T% q) ^) V3 v/ E! j( S
清单 15. 使用 ParseQuery 检索匹配的 ParseObjects
5 G+ M  W$ T0 a( Q7 N( |' k
ParseQuery query = new ParseQuery("Players");1 s( \% d& d, }: C+ K  _' \
query.whereEqualTo("status", "active");4 z* g& B) k+ `& P% ^! f
query.findInBackground(new FindCallback() {$ e8 |8 x  L; B* P, K
    @Override; T; N9 r) h1 D1 `
    public void done(List<ParseObject> players, ParseException e) {
# t4 c. G0 U# B% F0 N        if (players != null) {3 ~# Y  T; X: C9 s( X7 v
            // Success - players contain active players
0 a; V9 Z+ m- t7 @' M        } else {
7 r" }$ ?1 A5 ~1 t, W4 ]4 D2 G5 d% y            // Failed! E6 w& y" J* O8 o. U& y- t
        }0 c9 c" Q# j, F: x( P7 M/ a8 p
    }
* p  X0 T* d; g( C$ U& T});

) E% S$ o  ^3 h6 `, K! R! sParseQuery 还提供了一个方法来获得匹配对象的计数,不需要检索对象本身,这非常有用。清单 16 展示了如何获得活动玩家的计数:/ Q& i% q# K: O+ T4 ^

" C- f" k) ]% i8 H清单 16. 使用 ParseQuery 对匹配的 ParseObjects 进行计数
; `( W! j% K* I+ w/ u' `8 H
ParseQuery query = new ParseQuery("Players");
+ L7 q( D$ z0 ]' l2 z. ^query.whereEqualTo("status", "active"); //remove this line to count ALL
( p% t& q6 H: Equery.countInBackground(new CountCallback() {
! g5 D6 ?: X7 ]- ~9 ?3 J    @Override" g" z: H" }7 V1 Q) l
    public void done(int count, ParseException e) {
7 q1 @) A) U6 K' J        if (e == null) {
# N; J% n) R! c5 P, z            // Success, see count variable" n5 I8 C1 z" Z8 C8 X% B
        } else {
, H$ Y  B* y4 T: u            // Failed
- Q4 C' `+ }5 _0 T        }
% }; v" i# P2 J4 C/ G+ g$ k    }
* v# {9 [1 K1 A" y; k: ^; _});

$ C3 H% l  ^1 C1 g5 j+ a1 oParseQuery 方法和约束
6 z/ h" ]% v3 G0 s9 Q6 QParseQuery 支持 20 多个不同的查询约束方法,以下是一些示例:
! s+ l& R0 H3 \) B
  • whereMatches(String key, String regex)查找与所提供的正则表达式相匹配的字符串值。
  • whereStartsWith(String key, String prefix)查找使用所提供的字符串开头的字符串值。
  • whereContains(String key, String substring)查找包含所提供的字符串的值。
  • whereGreaterThan(String key, Object value)查找大于所提供的值的值。
  • whereWithinKilometers(String key, ParseGeoPoint point, double maxDistance)查找点值在给定点附近,并且在给定最大距离内的对象。, b+ a+ E# b; U. I. Q, w2 ~
查询结果可以被排序,如清单 17 所示。为了对查询结果进行排序,可以调用其中一个                query orderBy...() 方法,指定作为排序依据的字段。
  ]7 _- g7 [: n
9 p+ \" d2 ~' C" ]& x; {) x. |清单 17. 排序查询结果3 h) m  g- n" R% A* ~3 V
query.orderByAscending("name"); 9 T9 S+ s" X7 \+ F, g
/ I2 v$ X, B8 c' f
query.orderByDescending("name");# z. m! i; S6 x- t" d/ ]

* E, n( A. B  C0 M) o, w6 S* Q0 |/ Y! B0 @7 I! R3 ~5 i" ^3 `$ D  w
7 x5 D$ a9 U) `
For example:
* D$ z# U9 [3 [7 Q" J" O0 l2 G% e3 u* S8 U0 N1 v4 j

; @0 x3 C* \" B3 G
  |* o+ C/ E3 R) ?! h5 J+ @  V. ~1 jParseQuery query = new ParseQuery("Players");
2 S# ]; U6 l3 n! M- s0 M  @query.whereEqualTo("status", "active");6 |* J% ?$ F) B4 }
query.orderByAscending("lastName"); // By lastname ascending order& o4 w3 w0 r  C* L% C9 |/ w
query.findInBackground(new FindCallback() {( k( R, ]' U! C0 \" u: L
    @Override
1 m0 |* v: i. n  x4 [( c0 {" r. U
& a2 Z& i7 e$ Z! W7 ~4 i  public void done(List<ParseObject> players, ParseException e) {0 P) W2 v+ e% {% a* x3 a
5 p* u  I7 K" j1 i  G
    if (players != null) {6 a4 N3 z2 |* I2 S+ I
      // Success - players contain active players
0 k. O2 k5 y! m0 Z+ R3 L
9 `" C6 @5 O8 k8 x    } else {
/ v% h0 O9 T$ F- B/ x5 G0 T1 y1 J
' F5 J+ V$ h) z4 j8 a& j/ l  d      // Failed' f' a" b3 `" q& h& {
                . J5 k/ J! Y! O; ~+ E5 H
                          } 8 |8 Q1 @; o1 i! [" J$ h

) }0 u, U: [. f  G8 H             }        : E! Y, Y' w; ^- u! a

2 R. ]9 h; e+ X% }8 A# r0 k" }});
( p+ K( d/ b, @0 `
另外,需要注意的是,ParseQuery 结果被缓存。您可以根据应用程序的需求,采用不同的方式设置查询缓存策略。目前支持以下缓存策略:; E5 R# P! h; R. S6 B$ L
  • IGNORE_CACHE:不使用缓存,这是默认的缓存策略。
  • CACHE_ONLY:只从缓存加载。如果没有已缓存的结果,将会有一个                    ParseException。
  • NETWORK_ONLY:始终从网络加载,但将结果保存到缓存。
  • CACHE_ELSE_NETWORK:首先查找缓存。如果失败,则从网络加载。如果缓存与网络均不成功,结果将是                    ParseException。
  • NETWORK_ELSE_CACHE:首先查找网络。如果失败,则从缓存加载。如果缓存与网络均不成功,结果将是                    ParseException。
  • CACHE_THEN_NETWORK:首先查找缓存。如果失败,则从网络加载。请注意,FindCallback 实际上被调用了两次:第一次包括缓存的结果,然后包括网络结果。该策略只能与 findInBackground 异步使用。
    , r: {* V" A+ W6 ]8 _
设置缓存策略很简单。设置之前,首先要调用 find...() 方法,如清单 18 所示:
/ V) Y/ g. G1 e6 [4 q
/ k0 w) ~& t* h0 ]  r. M! q清单 18. 管理 CachePolicy
- T2 \, C2 r4 W5 D) S3 X* R
ParseQuery query = new ParseQuery("Players");, e" [/ W/ T9 P. w) B5 B6 h$ P
query.setCachePolicy(ParseQuery.CachePolicy.NETWORK_ELSE_CACHE);7 y4 n- e9 M7 N% F* f
query.findInBackground(new FindCallback() {" X0 q( n7 f1 q
    @Override3 s- R1 Z% [; t5 ~" z
    public void done(List<ParseObject> players, ParseException e) {
& }# X8 W, i1 M: N/ E        if (e == null) {& i3 }7 ^% k3 u2 d8 i  y
            // Success - players contain active players 6 O& \- v  \1 f& W1 y
        } else {5 z3 A, `1 J* T' H3 p- Z9 r
            // Failed1 z5 q! O. J/ g- ~' e# B0 y  Z; k
        }- r/ B7 P2 |# l/ |  {
    }
) n# B; G7 X4 |' [2 a" l4 S});

0 k3 M5 J/ Y* l& pParseQuery 类提供了查询存储在云中的数据对象所需的所有方法。有了 ParseQuery,就可以指定各种查询约束,对匹配的数据对象进行计数,设置限制,跳过数据对象,排序,清除缓存等。
4 g# t# q9 ]: S, d6 e' s9 G

9 U3 K/ J1 C, b4 ]3 H) N& O6 f5 [" c3 T
删除数据对象5 |( P- k. X* ]; M# {
从 Parse 云删除数据对象也很简单。如果您已经有了对象实例,那么您就可以通过调用ParseObject 的 delete() 或 deleteInBackground() 方法,从云中删除现有的 ParseObject。这两个方法如清单 19 所示: 6 e! B! S: H0 g- ]
9 ^  {2 z+ U" x$ W) M. y
清单 19. 从云中删除 Parse 对象
6 l3 f0 [  d5 R5 ~
parseObject.delete();
; n: k' b$ o3 T- aparseObject.deleteInBackground();
) s- F0 e" z9 @6 ?+ E0 i- ~5 s9 F
如您所料,delete() 是一个阻塞调用,这意味着您需要负责适当地在自己的工作线程上调用它。或者可以让 Parse 使用带有或不带有回调的 deleteInBackground() 方法来负责线程。5 k- ]" u  [, e
使用文件
6 ^6 m7 v3 |" ?0 h9 S) c1 O& y0 ~至此,我们一直在使用 Parse 对象和 Parse 查询。我还向您介绍了 Parse 用户、ACL 和角色。最后,我将示范如何在 Parse 中使用文件的读、写和保存函数。$ o( n+ S. z; \# x) ?
回想一下,您可以在 ParseObject 中存储原始 byte[] 数据,这对于小规模数剧来说是没问题的。但在存储较大的项目(如图像或文档)时,应改使用 Parse Files。; q' h4 z0 i8 R! d6 t
Parse 云中的文件使用 ParseFile 来表示,它提供获得文件名、URL、文件数据(假设数据可用)的方法。您也可以下载和上传文件,并访问其他一些辅助方法。7 m* ^% W' i" C: O" m
文件数据以 byte[] 语法表示。请注意,目前,给定的文件不得超过 10MB。在命名文件时,Parse 库需要避免潜在的名称冲突,提供文件扩展名可以帮助 Parse 处理文件的内容。
9 q+ D# z, p- R3 r0 c0 [# c清单 20 演示了保存一个 JPG 文件:$ Z' A- C1 I1 r) E; Q* N: g' \+ k/ V

7 @5 ~) O% H0 ?, k8 r6 |清单 20. 保存一个 ParseFile
+ {9 U8 `7 C/ i, t/ c
// Save image file
  }$ x5 E% y3 K4 [Drawable drawable = ...;, L- _% \% g! `6 Q) ^7 V3 y/ U/ U
Bitmap bitmap = (Bitmap)((BitmapDrawable) drawable).getBitmap();
( o2 d& u8 g' Z1 z% pByteArrayOutputStream stream = new ByteArrayOutputStream();! U$ l, G( \" ^! B, Y, Z; `# F
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
5 [( p* v& [  f' [: `. A( V; r; I% xbyte[] data = stream.toByteArray();                6 a: Y* k& x' }) j
ParseFile imageFile = new ParseFile("image.jpg", data);  Z2 A* t6 I; R( L+ m! w& ]5 w, _
imageFile.saveInBackground();

3 l3 \. z& }. ~- F清单 20 中最初的语句将位图转换成一个byte[]。然后,使用 ParseFile saveInBackground() 方法保存 byte[],这与将 ParseObject 保存在服务器上的方法类似。
/ r  {; ^: U' C  O% @' X8 v一旦将文件保存到 Parse 上,必须将它与 ParseOject 关联(放入 ParseOject)。换句话说,Parse 文件不是真正的独立对象,并且为了以后检索和使用,必须将它关联到给定的 ParseObject 实例。这种局限可能会在未来版本的 Parse 中进行处理。清单 21 将图像文件关联到一个 Player Parse 对象:! K0 s9 ^% A& c
: o5 M3 Q' Q0 ?$ r, Q( m9 {
清单 21. 关联 ParseFile 与 ParseObject! z' n7 u0 _3 s# Z  @* r  B
// Associate image with Parse object
/ [% s& y" G. m) sParseObject po = new ParseObject("Players");
  o4 f. s) Q; R+ o) qpo.put("name", "eortiz");
2 H: k/ S; `+ `! x8 E: q( Npo.put("photo", imageFile);
! `5 Z4 l& w, ?1 E, x, R+ M  ?1 ]po.saveInBackground();
$ @) ~0 `/ J4 u, x5 o# q7 [
我已将文件关联到数据对象,然后使用 saveInBackgroud() 方法将对象保存在服务器上,我在前面已讨论过这一点。
( m: ^9 M" S' A' ?清单 22 显示了如何检索与数据对象有关联的文件:% R4 P1 n$ o( Z6 G! K" d

% U9 Z7 c9 ]& n! _清单 22. 检索 ParseFile
! m4 f4 {7 g& `3 I, \! F2 L
// Retrieving the file 6 ], k9 ?/ L5 _8 T
ParseFile imageFile2 = (ParseFile)po.get("photo");9 ^: e7 r9 O" c+ J' ^8 o/ D8 U4 Q
imageFile2.getDataInBackground(new GetDataCallback() {
# Y( w$ c& E! `7 b6 ^  public void done(byte[] data, ParseException e) {
. T0 |" Y! \4 l: t- O( ?    if (data != null) {7 g2 h5 e! ?& n6 N5 i" |: _6 G
      // Success; data has the file7 U3 j+ w7 c  Z2 z
    } else {
2 S1 t; u, r  U* b+ j, z      // Failed( r! E) _  z4 X, k. O
    }+ Q: F: c$ l1 x5 K
  }1 ~( Z! F" r' f3 A+ t; f
});
% @6 H% A5 H; M+ b+ V, x
从 Parse 对象收到 ParseFile 引用之后,我调用 getDataInBackground() 从服务器中检索 ParseFile。请注意,我使用了回调 GetDataCallback 来检索 Parse 文件,并没有使用 GetCallback,后者用于通过 ParseQuery 检索 Parse 对象。
) E, j3 E+ O: i5 p5 p8 y结束语4 @/ O7 k/ U" v+ x! m( N
Parse API 非常全面,包括访问移动服务的类,比如推送通知,使用地理数据,集成社交媒体平台等。在本文中,我通过介绍 Parse API 实现数据和文件的云存储,简单介绍了如何使用 Parse。我们还了解了如何在 Parse 云中存储和操纵 Parse 用户、数据对象、文件和 ACL,这是进一步探索云平台进行移动开发的良好基础。7 [8 }# A0 I8 W1 I

* O; T+ Y( M3 a( g  b" ~0 {4 B

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
 楼主| 发表于 2013-2-17 16:57:14 | 显示全部楼层
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

关闭

SCMLife推荐上一条 /4 下一条

QQ|小黑屋|手机版|无图版|SCMLife.com ( 京ICP备06056490号-1 )

GMT+8, 2018-6-23 18:10 , Processed in 0.092367 second(s), 8 queries , Gzip On, MemCache On.

Powered by SCMLife X3.4 Licensed

© 2001-2017 JoyShare.

快速回复 返回顶部 返回列表