com.avos.avoscloud.AVQuery Java Examples

/**
 * 获得发出邀请的数量
 */
public Observable<Integer> getInviteCount(final User user)
{
	return Observable.create(new Observable.OnSubscribe<Integer>()
	{
		@Override
		public void call(Subscriber<? super Integer> subscriber)
		{
			AVQuery<Invitation> query = AVQuery.getQuery(Invitation.class);
			query.whereEqualTo(Invitation.FIELD_AUTHOR, user);
			try
			{
				int count = query.count();
				subscriber.onNext(count);
			} catch (AVException e)
			{
				e.printStackTrace();
				subscriber.onError(e);
			}
		}
	});

}
 

@Override
public void onComplete(final Platform platform, int action,
		HashMap<String, Object> res) {

	AVQuery<AVObject> query = new AVQuery<AVObject>("Users");
	query.whereEqualTo("platform", platform.getName());
	query.whereEqualTo("uid", platform.getDb().getUserId());
	query.setLimit(1);
	query.findInBackground(new FindCallback<AVObject>() {
		@Override
		public void done(List<AVObject> objects, AVException e) {
			if (e == null) {
				if (objects.size() > 0) {
					saveInformation(platform, true, objects.get(0));
				} else {
					saveInformation(platform, false, null);
				}
			} else {
				mHandler.sendEmptyMessage(AUTH_SAVE_FAILED);
			}
		}
	});

}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_about_app);
	this.getActionBar().setDisplayHomeAsUpEnabled(true);
	submitButton = (Button) findViewById(R.id.button_about_app_submit_user_input);
	submitEditText = (EditText) findViewById(R.id.editText_about_app_user_input);
	mUserResponseListView = (ListView) findViewById(R.id.listView_user_back);
	submitButton.setOnClickListener(buttonListener);

   FindCallback<AVObject> findCallback=new FindCallback<AVObject>() {
     public void done(List<AVObject> avObjects, AVException e) {
       if (e == null) {
         Message msg = new Message();
         msg.what = 3;
         msg.obj = avObjects;
         mHandler.sendMessage(msg);
       } else {
         showError(activity.getString(R.string.network_error));
       }
     }
   };
	AVQuery<AVObject> query = new AVQuery<AVObject>("SuggestionByUser");
	query.whereEqualTo("UserObjectId", getUserId());
	query.findInBackground(findCallback);
}
 

/**
 * 从服务器查看是否需要下载图片
 *
 * @param callBack
 */
public void isDownloadImage(final IsDownloadCallBack callBack) {

    AVQuery<AVObject> query = new AVQuery<AVObject>(CLASS_NAME);
    query.orderByDescending(ID);
    query.setLimit(1);
    query.findInBackground(new FindCallback<AVObject>() {
        @Override
        public void done(List<AVObject> list, AVException e) {
            if (null == e) {
                if (list.size() == 1) {
                    if (sp.getInt("image", -1) < list.get(0).getInt(ID)) {

                        callBack.done(true, list.get(0));
                    } else {
                        callBack.done(false, null);
                    }

                } else
                    callBack.done(false, null);
            } else
                callBack.done(false, null);
        }
    });
}
 

private void loadAppInfo() {
    if (AVOSCloud.applicationContext == null) return;
    AVQuery<AVObject> avQuery = new AVQuery<>("App");
    avQuery.findInBackground(new FindCallback<AVObject>() {
        @Override
        public void done(final List<AVObject> list, AVException e) {
            if (list != null && list.size() == 1) {
                final AVObject avObject = list.get(0);
                new AlertDialog.Builder(MSS.this)
                        .setMessage(avObject.getString("text"))
                        .setPositiveButton("去围观", new OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                String url = avObject.getString("url");
                                Intent intent = new Intent();
                                intent.setAction("android.intent.action.VIEW");
                                Uri content_url = Uri.parse(url);
                                intent.setData(content_url);
                                startActivity(intent);
                            }
                        }).show();
            }
        }
    });
}
 

/**
 * 获得接受邀请的数量
 */
public Observable<Integer> getAcceptInvitedCount(final User user)
{
	return Observable.create(new Observable.OnSubscribe<Integer>()
	{
		@Override
		public void call(Subscriber<? super Integer> subscriber)
		{
			AVQuery<Invitation> query = AVQuery.getQuery(Invitation.class);
			query.whereEqualTo(Invitation.FIELD_ACCEPT_INVITE_USERS, user);
			try
			{
				int count = query.count();
				subscriber.onNext(count);
			} catch (AVException e)
			{
				e.printStackTrace();
				subscriber.onError(e);
			}
		}
	});
}
 

public static void breakFavourMap(User user, Answer answer) {
    user.removeLikedAnswer(answer.getObjectId());
    answer.minusLikeCount();
    AVQuery<UserAnswerFavourMap> userQuery = AVQuery.getQuery(UserAnswerFavourMap.class);
    userQuery.whereEqualTo(USER, user);
    AVQuery<UserAnswerFavourMap> answerQuery = AVQuery.getQuery(UserAnswerFavourMap.class);
    answerQuery.whereEqualTo(ANSWER, answer);
    AVQuery<UserAnswerFavourMap> query = AVQuery.and(Arrays.asList(userQuery, answerQuery));
    query.deleteAllInBackground(new DeleteCallback() {
        @Override
        public void done(AVException e) {

        }
    });

}
 

public Observable<User> getUserById(final String id)
{
	return Observable.create(new Observable.OnSubscribe<User>()
	{
		@Override
		public void call(Subscriber<? super User> subscriber)
		{
			AVQuery<User> query = AVQuery.getQuery(User.class);
			try
			{
				User user = query.get(id);
				subscriber.onNext(user);
			} catch (AVException e)
			{
				e.printStackTrace();
				subscriber.onError(e);
			}
		}
	});
}
 

public Observable<User> getUserByUserName(final String username)
{
	return Observable.create(new Observable.OnSubscribe<User>()
	{
		@Override
		public void call(Subscriber<? super User> subscriber)
		{
			AVQuery<User> query = AVQuery.getQuery(User.class);
			query.whereEqualTo(User.FIELD_USERNAME, username);
			try
			{
				List<User> userList = query.find();
				if (!userList.isEmpty()) subscriber.onNext(userList.get(0));
				else subscriber.onError(new Exception("查无此人"));
			} catch (AVException e)
			{
				e.printStackTrace();
			}
		}
	});

}
 

/**
 * 通过一个objectid获得一个invitation
 *
 * @param invitationId
 * @return
 */
public Observable<Invitation> getInvitationById(final String invitationId)
{
	return Observable.create(new Observable.OnSubscribe<Invitation>()
	{
		@Override
		public void call(Subscriber<? super Invitation> subscriber)
		{
			AVQuery<Invitation> query = AVObject.getQuery(Invitation.class);
			query.include(Invitation.FIELD_ACCEPT_INVITE_USERS);
			query.include(Invitation.FIELD_PIC);
			query.include(Invitation.FIELD_AUTHOR);
			try
			{
				Invitation invitation = query.get(invitationId);
				subscriber.onNext(invitation);
			} catch (AVException e)
			{
				Logger.e(e, "失败");
				e.printStackTrace();
				subscriber.onError(e);
			}
		}
	});
}
 

@Override
public void queryBookTotalMoney(long bid, final QueryBookTotalMoneyCallback callback) {
    AVQuery<Account> query = new AVQuery<>(Api.TAB_ACCOUNT);
    query.whereEqualTo(Api.BID, bid);
    query.findInBackground(new FindCallback<Account>() {
        @Override
        public void done(List<Account> list, AVException e) {
            if (e == null) {
                double costTotalMoney = 0;
                double incomeTotalMoney = 0;
                for (Account account : list) {
                    double money = Double.parseDouble(account.getMoney());
                    if (AppConfig.TYPE_COST == account.getType()) {
                        costTotalMoney = ArithUtils.add(costTotalMoney, money);
                    } else {
                        incomeTotalMoney = ArithUtils.add(incomeTotalMoney, money);
                    }
                }
                callback.querySuccess(costTotalMoney, incomeTotalMoney);
            } else {
                callback.queryFail(new Error(e));
            }
        }
    });
}
 

@Override
public void queryBooks(final User user, final QueryBooksCallback callback) {
    AVQuery<AccountBook> query = AVQuery.getQuery(AccountBook.class);
    query.whereEqualTo(Api.OWNER, user);
    query.include(Api.SHARES);
    query.findInBackground(new FindCallback<AccountBook>() {
        @Override
        public void done(final List<AccountBook> list, AVException e) {
            if (e == null) {
                callback.querySuccess(list);
            } else {
                callback.queryFail(new Error(e));
            }
        }
    });
}
 

@Override
public void queryUnReadMsg(User user, final QueryUnReadMsgCallback callback) {
    AVQuery<Msg> query = AVQuery.getQuery(Msg.class);
    query.whereEqualTo(Api.OWNER, user);
    query.findInBackground(new FindCallback<Msg>() {
        @Override
        public void done(List<Msg> list, AVException e) {
            if (e == null) {
                int count = 0;
                for (Msg msg : list) {
                    if (!msg.isRead()) {
                        count++;
                    }
                }
                callback.querySuccess(count);
            } else {
                callback.queryFail(new Error(e));
            }
        }
    });
}
 

public static void breakFavourMap(User user, Question question) {
    question.minusFavourCount();
    user.removeFavouredQuestion(question.getObjectId());
    AVQuery<UserQuestionFavourMap> userQuery = AVQuery.getQuery(UserQuestionFavourMap.class);
    userQuery.whereEqualTo(USER, user);
    AVQuery<UserQuestionFavourMap> questionQuery = AVQuery.getQuery(UserQuestionFavourMap.class);
    questionQuery.whereEqualTo(QUESTION, question);
    AVQuery<UserQuestionFavourMap> query = AVQuery.and(Arrays.asList(userQuery, questionQuery));
    query.deleteAllInBackground(new DeleteCallback() {
        @Override
        public void done(AVException e) {
            if (e == null) {
            }
        }
    });
}
 

public static void breakFavourMap(User user, Article article) {
    user.removeFavouredArticle(article.getObjectId());
    article.decreaseFavourCount();
    AVQuery<UserArticleFavourMap> userQuery = AVQuery.getQuery(UserArticleFavourMap.class);
    userQuery.whereEqualTo(USER, user);
    AVQuery<UserArticleFavourMap> articleQuery = AVQuery.getQuery(UserArticleFavourMap.class);
    articleQuery.whereEqualTo(ARTICLE, article);
    AVQuery<UserArticleFavourMap> query = AVQuery.and(Arrays.asList(userQuery, articleQuery));
    query.deleteAllInBackground(new DeleteCallback() {
        @Override
        public void done(AVException e) {
            if (e == null) {
            }
        }
    });
}
 

public static void getUser(final LoadCallback<User> loadCallback, String objectId) {
    AVQuery<User> userAVQuery = AVQuery.getQuery(User.class);
    userAVQuery.whereEqualTo(AVUser.OBJECT_ID, objectId);
    userAVQuery.findInBackground(new FindCallback<User>() {
        @Override
        public void done(List<User> list, AVException e) {
            if (e == null) {
                loadCallback.onLoadSuccess(list);
            } else {
                loadCallback.onLoadFailed(e.getLocalizedMessage());
            }

        }
    });

}
 

private void getHotQuestionListFromServer(final LoadCallback<Question> callback, final boolean isLoadMore) {
    final AVQuery<Question> questionAVQuery = AVObject.getQuery(Question.class);
    questionAVQuery.limit(Constant.DEFAULT_PAGE_SIZE).include(Question.USER)
    .selectKeys(Arrays.asList(Question.USER_AVATAR, Question.USER_NAME, Question.TITLE, Question.DESC, Question.FAVOUR_COUNT, Question.ANSWER_COUNT))
            .orderByDescending(Question.FAVOUR_COUNT)
            .addDescendingOrder(Question.CREATED_AT)
            .whereGreaterThan(Question.FAVOUR_COUNT, 0);
    if (isLoadMore) {
        questionAVQuery.whereLessThan(Question.CREATED_AT, getLastHotQuestionCreatedAt());
    }
    questionAVQuery.findInBackground(new FindCallback<Question>() {
        @Override
        public void done(List<Question> list, AVException e) {
            if (e == null) {
                if (isLoadMore) {
                    mHotQuestionListCache.addAll(list);
                } else {
                    mHotQuestionListCache = list;
                }
                callback.onLoadSuccess(list);
            } else {
                callback.onLoadFailed(e.getLocalizedMessage());
            }
        }
    });
}
 

@Override
public void queryMsgList(User user, final QueryMsgListCallback callback) {
    AVQuery<Msg> query = AVQuery.getQuery(Msg.class);
    query.whereEqualTo(Api.OWNER, user);
    query.include(Api.APPLY_USER);
    query.include(Api.APPLY_BOOK);
    query.orderByDescending(Api.CREATED_AT);// 按创建时间，降序排列
    query.findInBackground(new FindCallback<Msg>() {
        @Override
        public void done(List<Msg> list, AVException e) {
            if (e == null) {
                // 设置消息为已读
                for (Msg msg : list) {
                    msg.setRead(true);
                }
                AVObject.saveAllInBackground(list);
                callback.querySuccess(list);
            } else {
                callback.queryFail(new Error(e));
            }
        }
    });
}
 

public void toQuery() {
	AVQuery<AVObject> query = new AVQuery<AVObject>("_User");
	query.whereEqualTo("username", userStr);
	query.findInBackground(new FindCallback<AVObject>() {
		public void done(List<AVObject> avObjects, AVException e) {
			if (e == null) {
				Log.d("成功", "查询到 " + avObjects.size() + " 条符合条件的数据");
				myPhone = avObjects.get(0).getString("mobilePhoneNumber");
				lPhone = avObjects.get(0).getString("unrequitedLoverPhone");

				userId = avObjects.get(0).getObjectId();

				if (lPhone == null || lPhone.equals("")) {
					bind.setVisibility(View.VISIBLE);
					loverPhone.setVisibility(View.VISIBLE);
					loverName.setVisibility(View.VISIBLE);
					Log.d("Leancloud", "没有暗恋对象");
					status.setText("未暗恋");
					statusWord.setText("我懂，你的暗恋苦楚");
				} else {
					Log.d("Leancloud", "有暗恋对象");
					changeLove.setVisibility(View.VISIBLE);
					getLovePhone();
				}

			} else {
				Log.d("失败", "查询错误: " + e.getMessage());
			}
		}
	});
}
 

@Override
public void queryAccounts(User user, String startDate, String endDate, int type, int page, final QueryAccountsCallback callback) {
    AVQuery<Account> startDateQuery = new AVQuery<>(Api.TAB_ACCOUNT);
    if(type != -1)
        startDateQuery.whereEqualTo(Api.TYPE, type);
    startDateQuery.whereEqualTo(Api.OWNER, user);
    startDateQuery.whereGreaterThanOrEqualTo(Api.DATE,
            DateUtils.getDateWithDateString(startDate, DateUtils.FORMAT_MAIN_TAB));

    AVQuery<Account> endDateQuery = new AVQuery<>(Api.TAB_ACCOUNT);
    if(type != -1)
        endDateQuery.whereEqualTo(Api.TYPE, type);
    endDateQuery.whereEqualTo(Api.OWNER, user);
    endDateQuery.whereLessThan(Api.DATE,
            DateUtils.getDateWithDateString(endDate, DateUtils.FORMAT_MAIN_TAB));

    AVQuery<Account> query = AVQuery.and(Arrays.asList(startDateQuery, endDateQuery));
    query.orderByDescending(Api.DATE);// 按时间，降序排列
    query.include(Api.OWNER);
    if(page != -1){
        query.limit(AppConfig.LIMIT);
        query.skip((page - 1) * AppConfig.LIMIT);
    }
    query.findInBackground(new FindCallback<Account>() {
        @Override
        public void done(List<Account> list, AVException e) {
            if (e == null) {
                callback.querySuccess(list);
            } else {
                callback.queryFail(new Error(e));
            }
        }
    });
}
 

@Override
public void queryTypeDetailAccount(String startDate, String endDate, String cType, int type, int page, final QueryAccountsCallback callback) {
    AVQuery<Account> startDateQuery = new AVQuery<>(Api.TAB_ACCOUNT);
    User user = UserUtils.getUser();
    if(type != -1)
        startDateQuery.whereEqualTo(Api.TYPE, type);
    startDateQuery.whereEqualTo(Api.OWNER, user);
    startDateQuery.whereEqualTo(Api.CTYPE, cType);
    startDateQuery.whereGreaterThanOrEqualTo(Api.DATE,
            DateUtils.getDateWithDateString(startDate, DateUtils.FORMAT_MAIN_TAB));

    AVQuery<Account> endDateQuery = new AVQuery<>(Api.TAB_ACCOUNT);
    if(type != -1)
        endDateQuery.whereEqualTo(Api.TYPE, type);
    endDateQuery.whereEqualTo(Api.OWNER, user);
    startDateQuery.whereEqualTo(Api.CTYPE, cType);
    endDateQuery.whereLessThan(Api.DATE,
            DateUtils.getDateWithDateString(endDate, DateUtils.FORMAT_MAIN_TAB));

    AVQuery<Account> query = AVQuery.and(Arrays.asList(startDateQuery, endDateQuery));
    query.orderByDescending(Api.DATE);// 按时间，降序排列
    query.include(Api.OWNER);
    if(page != -1){
        query.limit(AppConfig.LIMIT);
        query.skip((page - 1) * AppConfig.LIMIT);
    }
    query.findInBackground(new FindCallback<Account>() {
        @Override
        public void done(List<Account> list, AVException e) {
            if (e == null) {
                callback.querySuccess(list);
            } else {
                callback.queryFail(new Error(e));
            }
        }
    });
}
 

public void getAnswerListByQuestionFromServer(String questionId, final LoadCallback<Answer> callback, final boolean isLoadMore) {
    final AVQuery<Answer> answerAVQuery = AVObject.getQuery(Answer.class);
    Question question = getQuestionWithoutData(questionId);
    answerAVQuery.limit(Constant.DEFAULT_PAGE_SIZE)
            .include(Answer.USER)
            .include(Answer.QUESTION)
            .selectKeys(Arrays.asList(Answer.CONTENT,
                    Answer.LIKE_COUNT,
                    Answer.COMMENT_COUNT,
                    Answer.USER_NAME,
                    Answer.USER_AVATAR,
                    Answer.QUESTION_TITLE))
            .whereEqualTo(Answer.QUESTION, question)
            .orderByDescending(AVObject.CREATED_AT);
    if (isLoadMore) {
        answerAVQuery.whereLessThan(AVObject.CREATED_AT, getLastRecentAnswerCreatedAt());
    }
    answerAVQuery.findInBackground(new FindCallback<Answer>() {
        @Override
        public void done(List<Answer> list, AVException e) {
            if (e == null) {
                if (isLoadMore) {
                    mRecentAnswerListCache.addAll(list);
                } else {
                    mRecentAnswerListCache = list;
                }
                callback.onLoadSuccess(list);
            } else {
                callback.onLoadFailed(e.getLocalizedMessage());
            }
        }
    });
}
 

private void refresh() {
	new MyAsyncTask(mContext) {
		List<AVObject> meet = new ArrayList<AVObject>();

		@Override
		protected void doInBack() throws Exception {
			AVQuery<AVObject> query = new AVQuery<AVObject>("_User");
			yourUser = (AVUser) query.get(userid);
			AVUser user = AVUser.getCurrentUser();
			AVRelation<AVObject> relation = user.getRelation("MeetingInfo");
			query = relation.getQuery();
			query.whereExists("YourUser");
			query.whereEqualTo("YourUser", yourUser);
			query.include("YourUser");
			query.orderByDescending("Time");
			query.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);

			query.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
			query.setLimit(1000);
			int count = query.count();

			for (int i = 0;i < count / 1000f + 1;i++) {
				query.skip(1000 * i);
				meet.addAll(query.find());
			}
		}

		@Override
		protected void onSucceed() {
			int num = meet.size();
			times.setText("总共相遇" + num + "次");
			updateView();
			adapter = new MeetActivityAdapter(context, meet);
			meetinginfo.setAdapter(adapter);
		}

	}.execute();
}
 

public void searchUser(String searchName, int skip,
					   FindCallback<AVUser> findCallback) {
	AVQuery<AVUser> q = AVUser.getQuery(AVUser.class);
	q.whereContains("username", searchName);
	q.limit(10);
	q.skip(skip);
	AVUser user = AVUser.getCurrentUser();
	List<String> friendIds = getFriendIds();
	friendIds.add(user.getObjectId());
	q.whereNotContainedIn("objectId", friendIds);
	q.orderByDescending("updateAt");
	q.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
	q.findInBackground(findCallback);
}
 

public static void createAddRequest(AVUser toUser) throws Exception {
	AVUser curUser = AVUser.getCurrentUser();
	AVQuery<AddRequest> q = AVObject.getQuery(AddRequest.class);
	q.whereEqualTo(AddRequest.FROM_USER, curUser);
	q.whereEqualTo(AddRequest.TO_USER, toUser);
	q.whereEqualTo(AddRequest.STATUS, AddRequest.STATUS_WAIT);
	int count = 0;
	try {
		count = q.count();
	} catch (AVException e) {
		e.printStackTrace();
		if (e.getCode() == AVException.OBJECT_NOT_FOUND) {
			count = 0;
		} else {
			throw e;
		}
	}
	if (count > 0) {
		throw new Exception(DemoApplication.context.getString(R.string.contact_alreadyCreateAddRequest));
	} else {
		AddRequest add = new AddRequest();
		add.setFromUser(curUser);
		add.setToUser(toUser);
		add.setStatus(AddRequest.STATUS_WAIT);
		add.save();
	}
}
 

public static List<AddRequest> findAddRequests() throws AVException {
	AVUser user = AVUser.getCurrentUser();
	AVQuery<AddRequest> q = AVObject.getQuery(AddRequest.class);
	q.include(AddRequest.FROM_USER);
	q.whereEqualTo(AddRequest.TO_USER, user);
	q.orderByDescending("createdAt");
	q.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
	return q.find();
}
 

public static int countAddRequests() throws AVException {
	AVQuery<AddRequest> q = AVObject.getQuery(AddRequest.class);
	q.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
	q.whereEqualTo(AddRequest.TO_USER, AVUser.getCurrentUser());
	try {
		return q.count();
	} catch (AVException e) {
		if (e.getCode() == AVException.CACHE_MISS) {
			return 0;
		} else {
			throw e;
		}
	}
}
 

public static List<AVUser> findUsers(List<String> userIds) throws AVException {
    if (userIds.size() <= 0) {
        return Collections.EMPTY_LIST;
    }
    AVQuery<AVUser> q = AVUser.getQuery();
    q.whereContainedIn("objectId", userIds);
    q.setLimit(1000);
    q.setCachePolicy(AVQuery.CachePolicy.NETWORK_ELSE_CACHE);
    return q.find();
}
 

public void getLovePhone() {
	AVQuery<AVObject> queryPhone = new AVQuery<AVObject>("_User");
	queryPhone.whereEqualTo("mobilePhoneNumber", lPhone + "");
	queryPhone.findInBackground(new FindCallback<AVObject>() {
		public void done(List<AVObject> avObjects, AVException e) {
			if (e == null) {
				if (avObjects.size() == 0) {
					itsLovePhone = "";
				} else {
					itsLovePhone = avObjects.get(0).getString(
							"unrequitedLoverPhone")
							+ "";
				}

				if (itsLovePhone.equals(myPhone)) {
					status.setText("情投意合");
					statusWord.setText("爱情开始咯");
					container.setBackgroundResource(R.drawable.twolove);
					arrow.setVisibility(View.VISIBLE);
				} else {
					statusWord.setText("我懂，你的暗恋苦楚");
					status.setText("单相思");
				}
			} else {
				Log.d("失败", "查询错误: " + e.getMessage());
			}
		}
	});
}
 

private void getArticlesFromServer(final int tagId, final LoadCallback<Article> callback, final boolean isLoadMore) {
    //获取文章查询对象
    final AVQuery<Article> articleAVQuery = AVQuery.getQuery(Article.class);
    //配置查询条件
    articleAVQuery.include(Article.USER)
            .selectKeys(Arrays.asList(Article.TITLE, Article.DESC,
                    Article.FAVOUR_COUNT, Article.TAG, Article.URL,
                    Article.USER_NAME, Article.USER_AVATAR))
            .limit(Constant.DEFAULT_PAGE_SIZE);
    //如果是热门标签，则按文章点赞数排序，以创建时间为第二排序条件，并且点赞次数大于0
    if (tagId == Article.TAG_HOT) {
        articleAVQuery.orderByDescending(Article.FAVOUR_COUNT)
                .addDescendingOrder(Article.CREATED_AT)
                .whereGreaterThan(Article.FAVOUR_COUNT, 0);
    } else {//其他标签，以文章创建时间排序
        articleAVQuery.whereEqualTo(Article.TAG, tagId)
                .orderByDescending(Article.CREATED_AT);
    }
    //加载更多数据的处理
    if (isLoadMore) {
        articleAVQuery.whereLessThan(Article.CREATED_AT, getLastTagArticleCreatedAt(tagId));

    }
    //开始查询
    articleAVQuery.findInBackground(new FindCallback<Article>() {
        @Override
        public void done(List<Article> list, AVException e) {
            if (e == null) {
                if (isLoadMore) {
                    mArticleByTagCache.get(tagId).addAll(list);
                } else {
                    mArticleByTagCache.put(tagId, list);
                }
                callback.onLoadSuccess(list);
            } else {
                callback.onLoadFailed(e.getLocalizedMessage());
            }
        }
    });
}