Récupération de données JSON d'un script PHP

Version imprimable

Salut j'ai suivi un tuto pour récupérer des données d'un serveur PHP au format json tout se passe très bien mais j'ai vraiment du mal a comprendre pourquoi on doit passer par toutes une procédure pour retrouver la donnée json comme dans ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
		public static long getOnlineAlarm(long taskID) {
 
		long alarm = -1;
 
		String result = null;
		InputStream is = null;
 
		ArrayList<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
 
		nameValuePairs.add(new BasicNameValuePair("taskID", String.valueOf(taskID)));
 
		try {
			HttpClient httpclient = InternetUtilities.getHttpclient();
			HttpPost httppost = new HttpPost(InternetUtilities.ressources.getString(R.string.serveraddress)+"/getOnlineAlarm.php");
			httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
			HttpResponse response = httpclient.execute(httppost);
 
			HttpEntity entity = response.getEntity();
			is = entity.getContent();
 
		} catch (Exception e) {
			Log.i("taghttppost", "" + e.toString());
 
		}
 
		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					is, "UTF-8"));
 
			StringBuilder sb = new StringBuilder();
 
			String line = null;
 
			while ((line = reader.readLine()) != null) {
				sb.append(line + "\n");
			}
 
			is.close();
 
			result = sb.toString();
		} catch (Exception e) {
			Log.i("tagconvertstr", "" + e.toString());
		}
 
		try {
			Log.i("tagconvertstr", "[" + result + "]");
 
			JSONObject jObj = new JSONObject(result);
 
			alarm = jObj.getLong("alarm");
			return alarm;
 
		} catch (JSONException e) {
			Log.i("tagjsonexp", "" + e.toString());
		} catch (ParseException e) {
			Log.i("tagjsonpars", "" + e.toString());
		}
 
		return alarm;
	}

et par exemple niveau PHP je met juste ca :

Code:

1
2
$alarm = -2;
echo(json_encode(array("alarm" => $alarm)));

Je ne comprends pas l'intérêt de toutes ces lignes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 
HttpEntity entity = response.getEntity();
			is = entity.getContent();
 
		} catch (Exception e) {
			Log.i("taghttppost", "" + e.toString());
 
		}
 
		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					is, "UTF-8"));
 
			StringBuilder sb = new StringBuilder();
 
			String line = null;
 
			while ((line = reader.readLine()) != null) {
				sb.append(line + "\n");
			}
 
			is.close();
 
			result = sb.toString();
		} catch (Exception e) {
			Log.i("tagconvertstr", "" + e.toString());
		}

on pourrait pas juste récupérer la variable json directement à partir de :

Code:

1
2
3
4
5
 
JSONObject jObj = new JSONObject(result);
 
			alarm = jObj.getLong("alarm");
			return alarm;

???

Tiens j'en parlais pas plus tard qu'hier de ce tutorial horrible....

En fait voila le code en question corrigé et expliqué:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
JSONArray   jsonArrayFromPOST(String postUrl, NameValuePair ... postParams) throws IOException
{
    // Les paramètres du POST
    ArrayList<NameValuePair> paramsList = new ArrayList<NameValuePair>();
    if (postParams != null) {
        for (NameValuePair nvp : postParams) { paramsList.add(nvp); }
    }
 
    // On récupère un client capable d'envoyer des requêtes, un peu comme un  browser offline
    HttpClient client = getHttpClient();
    // on va faire un POST vers l'url
    HttpPost postAction = new HttpPost(postUrl); 
post.
    // on lui passe les paramètres
    postAction.setEntity(new UrlEncodedFormEntity(postParams ));
 
    // on execute la requète
    HttpResponse response = client.execute(postAction);
 
    // on récupère le payload de la réponse en String
    HttpEntity entity = response.getEntity();
    String entityStr = (entity == null) ? null : EntityUtils.toString(entity);
 
    // on transforme en JSON
    try {
         return new JSONArray(entityStr);
    } catch (Exception ex) {
        throw new IOException("Invalid response from server !",ex);
    }
}

Et maintenant la fonction getHttpClient qui manque:

Code:

1
2
3
4
5
6
7
8
9
10
11
 
static private HttpClient  _baseClient = null;
 
public synchronized HttpClient getHttpClient()
{
    if (_baseClient == null) {
        _baseClient = new DefaultHttpClient();
        // ici on peut rajouter des parametres comme le "Agent" string, ou bien les valeurs de timeout.
    }
    return _baseClient;
}

Pourquoi n'est ce pas si compliqué en PHP ?
Parceque le PHP est executé par un serveur WEB (en général Apache), qui fait toute la partie HTTP à la place du PHP....

La partie "json_encode(...)" de PHP correspond à la partie "new JSONArray(entityStr);" de Java.

Merci de ta réponse !! Si je comprend bien, toute cette partie la du code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
	is = entity.getContent();
 
		} catch (Exception e) {
			Log.i("taghttppost", "" + e.toString());
 
		}
 
		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					is, "UTF-8"));
 
			StringBuilder sb = new StringBuilder();
 
			String line = null;
 
			while ((line = reader.readLine()) != null) {
				sb.append(line + "\n");
			}
 
			is.close();
 
			result = sb.toString();
		} catch (Exception e) {
			Log.i("tagconvertstr", "" + e.toString());
		}
 
		try {
			Log.i("tagconvertstr", "[" + result + "]");

ne sert à rien ?

12/08/2012, 13h07
nicroman

Non, elle est même fausse, puisque ne gère pas les encoding divers et variés que peut avoir une réponse HTTP, et part du principe que la réponse est en plain/text UTF-8
12/08/2012, 16h40
Nickonet

Ok ! Merci beaucoup ! Dernière petite question, quelle est la différence entre parser du JSON et encoder/décoder du json ? :S
12/08/2012, 18h18
nicroman

Heu... je ne sais pas... le verbe utilisé ?
:mrgreen:

En général on dit 'encode' quand on fait une sérialisation, c'est à dire on passe d'un Objet (ou d'une collection d'objet) à du JSON, et 'decode' quand on fait l'inverse (désérialise).
Et 'parsing' quand on ne fait que lire le JSON betêment pour aller chercher telle ou telle information...

Mais bon, il doit y avoir autant d'interprétations différente que de programmeurs je pense ;)