Je me demande simplement - où le Par exemple, j'utilise Volley Bibliothèque: P> jsonObject code> ou jsonarray code> reçu du serveur Web doit être analysé dans l'application Android - dans l'interface utilisateur principale ou doit être livrée à l'autre une ? private void fetchResults(){
RequestQueue queue = Volley.newRequestQueue(mContext);
String url = AuthenticationRequester.URL_GET_ALL_ORDERS;
JsonArrayRequest jsonDepartureObj = new JsonArrayRequest(url, new Response.Listener<JSONArray>() {
@Override
public void onResponse(JSONArray jsonArray) {
iVolleyCallback.onJSONArraySuccess(jsonArray);
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
VolleyLog.d(TAG, "Error: " + error.getMessage());
// hide the progress dialog
}
});
queue.add(jsonDepartureObj);
}
5 Réponses :
Il est préférable que toute tâche qui prend Lestanks d'asyncaptage doivent idéalement être utilisés pour des opérations courtes (quelques secondes au plus.) Si vous devez garder les threads courants pendant de longues périodes, il est fortement recommandé d'utiliser les différentes API fournies par le Java.Util.ConCurrent package tel que exécuteur , threadpoolexecuteur et futuretask .
Donc, si vous savez que vous avez gros données et cela prendra du temps, vous utiliserez nouveau thread , mais si les données sont petites > et prend moins de temps, pourquoi prendre le risque? Déplacez-le sur le nouveau thread maintenance :
Est-ce que c'est asynccable la meilleure solution pour cela? Peut-être que la volley, la rénovation des fils utilisant sont de meilleurs?
Je ne sais pas si c'est le meilleur, mais je peux dire que tout ce qui se passe dans maintenir l'affectera et s'il n'est pas lié à aucun ui il vous donnera un retard (cela peut même être un décalage extrêmement petit aussi). Donc, je vous suggère de mieux analyser que jsonarray dans nouveau thread .
Si, comme vous le dites vous-même, les données JSON pourraient être énormes, et cela pourrait prendre un certain temps pour traiter, je pense que vous pourriez (ou devriez-vous?) Essayez de le traiter dans un AsynccTask . En faisant cela, votre fil d'interface utilisateur ne sera pas congelé pendant le traitement.
Dans la plupart des conceptions d'interface graphique (non seulement Android), plusieurs threads ont différents rôles et responsabilités:
Le "fil principal", fonctionnant à la priorité d'expédition "normale", a essentiellement rien d'autre à faire, mais pour répondre rapidement aux exigences du système d'interface utilisateur. Lorsque des "messages" arrivent pour sa consommation, ce fil préemple immédiatement les autres threads de sorte que le message puisse être traité rapidement. Comme tout bon manager ... ;-) ... ils ne font pas le travail eux-mêmes. Ils le transmettent à d'autres personnes.
Lorsque des demandes asynchrones (JSON ... etc.) sont impliquées, il existe généralement une petite "piscine" de threads responsables de l'envoi de ceux à l'hôte, recevant la réponse, faire le codage / décodage, et puis soit agissant - sur la réponse ou le transmettre. Ces discussions passent presque tout leur temps à attendre l'hôte. Ils fonctionnent à une priorité d'expédition légèrement inférieure.
threads de travailleur, fonctionnant à une priorité inférieure plus inférieure, faisons-vous un travail qui prend beaucoup de temps. Autant que possible, ces threads ne font pas beaucoup d'E / S. Ils abandonnent leurs tranches de temps rapidement et facilement à tout autre fil, mais ils consomment généralement toute leur tranche de temps lorsqu'ils peuvent en obtenir un.
Les opérations de course potentiellement longues devraient toujours se produire sur un fil séparé, ou vraiment tout travail (dans la raison ...) qui peut être fait sur un thread distinct.
Dans votre cas, vous utilisez Volley, il est donc très facile de remplacer votre parsenetworkResponse (réponse NetworkResponse) ; méthode, et analyser la réponse sur un fil d'arrière-plan (puisque cette méthode fonctionne déjà sur un fil d'arrière-plan) avant sa livraison. Comme il est relativement transparent de le faire, il n'y a pas vraiment de raison de ne pas analyser la réponse sur un fil de fond.
Essayez ceci https://github.com/yakivmospan/volley-request-manager
//Queue using custom listener
RequestManager.queue()
.useBackgroundQueue()
.addRequest(new TestJsonRequest(), mRequestCallback)
.start();
private RequestCallback mRequestCallback = new RequestCallback<JSONObject, ResultType>() {
@Override
public ResultType doInBackground(JSONObject response) {
//parse and save response data
return new ResultType();
}
@Override
public void onPostExecute(ResultType result) {
//update UI here
Toast.makeText(getApplicationContext(), "Toast from UI", Toast.LENGTH_SHORT).show();
}
@Override
public void onError(VolleyError error) {
//handle errors here (UI thread)
L.e(error.toString());
}
};
Avez-vous vraiment besoin de toutes ces données à la fois? Ou pouvez-vous seulement charger les 20 premiers enregistrements pour réduire la taille? Ensuite, si l'utilisateur fait défiler ou se rapproche de la visualisation de l'ensemble d'enregistrements suivant, chargez le 20 suivant.