Erreur pour lire fichier XML

**onda47** · 17/01/2013, 12h00

Bonjour à tous,
ça fait bientôt deux jours que je n'arrive pas à lire un fichier XML, le logcat m'indique toujours que je ne soulève pas une exception et donc qu'il ne peut pas continuer.
J'aimerais comprendre pourquoi...

Voilà ma première classe héritant de DefaultHandler:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package com.example.toolbook;
 
import java.util.ArrayList;
 
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
public class ParserXMLHandler extends DefaultHandler {
 
	private final String MOT_FRANCAIS = "motFrancais";
	private final String MOT_ANGLAIS = "motAnglais";
	private final String DEF_FRANCAIS = "definitionFrancais";
	private final String DEF_ANGLAIS = "definitionAnglais";
	private final String TEST1 = "test1";
	private final String TEST2 = "test2";
	private final String TEST3 = "test3";
	private final String TEST4 = "test4";
	private final String TEST5 = "test5";
 
	private ArrayList<String> entries;
 
	private Entry currentFeed;
 
	private StringBuffer buffer;
 
	public void processingInstruction(String target, String data)
	{
		try {
			super.processingInstruction(target, data);
		} catch (SAXException e) {
			e.printStackTrace();
		}
	}
 
	public ParserXMLHandler(){super();}
 
	public void startDocument() throws SAXException
	{
		super.startDocument();
		entries = new ArrayList<String>();
	}
 
	public void startElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void endElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(MOT_FRANCAIS))
		{
				this.currentFeed.setMotFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(MOT_ANGLAIS))
		{
				this.currentFeed.setMotAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_FRANCAIS))
		{
				this.currentFeed.setDefFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_ANGLAIS))
		{
				this.currentFeed.setDefAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void characters(char[] ch, int start, int length)
	{
		String lecture = new String(ch, start, length);
		if(buffer != null) buffer.append(lecture);
	}
 
	public ArrayList<String> getData()
	{
		return entries;
	}
}

Voilà maintenant ma classe qui me permet de récupérer les données :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
package com.example.toolbook;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
 
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
 
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
import android.content.Context;
import android.content.res.AssetManager;
 
public class ContainerData {
 
static public Context context;
 
	public ContainerData(){}
 
	public static ArrayList<String> getFeeds()
	{
		SAXParserFactory fabrique = SAXParserFactory.newInstance();
		SAXParser parseur = null;
		ArrayList<String> entries = null;
		try
		{
			parseur = fabrique.newSAXParser();
		}
		catch(ParserConfigurationException e){e.printStackTrace();}
		catch(SAXException e){e.printStackTrace();}
 
		AssetManager asset = context.getAssets();
 
		InputStream inputStream = null;
		try {
			inputStream = asset.open("dico.xml");
		} catch (IOException e2) {
			e2.printStackTrace();
		}
 
		InputSource input = null;
		input = new InputSource(inputStream);
 
		DefaultHandler handler = new ParserXMLHandler();
		try {
			parseur.parse(input, handler);
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		entries = ((ParserXMLHandler) handler).getData();
 
		return entries;
	}
}

et enfin le logcat :

Si vous pouviez m'aider, ce serait vraiment très gentil !

**onda47** · 17/01/2013, 12h07

Le log cat ressemble à ça pardon

**tchize_** · 17/01/2013, 14h47

Bien,

NullpointerException ton erreur indiquée, probablement due à une de ces construction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
		SAXParser parseur = null;
		ArrayList<String> entries = null;
		try
		{
			parseur = fabrique.newSAXParser();
		}
		catch(ParserConfigurationException e){e.printStackTrace();}
		catch(SAXException e){e.printStackTrace();}

Tu tente d'initialiser un parser (et plus bas un inputstream), mais en cas d'exception.... tu continue quand même, alors que tu as un null maintenant dans parseur. Ce n'est pas possible de continuer. Il faut

1) récupérer le message de cette exception (envoie la dans le logcat plutot que de faire un e.printStackTrace())
2) arrêter immédiatement le travail ou alors avoir une solution de secours. Mais pas continuer comme si de rien n'était

**onda47** · 17/01/2013, 20h47

j'ai corrigé mon code en mettant un signe distinctif sur les erreurs pouvant être soulevé.
Il suffit bien de mettre un System.out.println pour afficher les soulèvement d'exception dans le LogCat ? Je ne vois pas l'erreur, peut-être faut-il implémenter le endDocument dans ma classe ParserXMLHandler ? Je ne comprends vraiment pas.
Voilà ma nouvelle classe ContainerData, suivit de ParserXMLHandler et enfin du LogCat.
ContainerData.java :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public class ContainerData {
 
	public ContainerData(){}
 
	public static ArrayList<Entry> getFeeds(Context context) throws SAXException
	{
		SAXParserFactory fabrique = SAXParserFactory.newInstance();
		SAXParser parseur;
		DefaultHandler handler = new ParserXMLHandler();
 
		InputStream inputStream;
		InputSource input = new InputSource();;
 
		AssetManager asset = context.getAssets();
		ArrayList<Entry> entries = new ArrayList<Entry>();
 
		try
		{
			parseur = fabrique.newSAXParser();
			inputStream = asset.open("dico.xml");
			input = new InputSource(inputStream);
			parseur.parse(input, handler);
			entries = ((ParserXMLHandler) handler).getData();
		}
		catch(ParserConfigurationException e){System.out.println("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + e);}
		catch(SAXException e){System.out.println("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" + e);}
		catch (IOException e) {System.out.println("CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" + e);}
 
		return entries;
	}
}

ParserXMLHandler :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
public class ParserXMLHandler extends DefaultHandler {
 
	private final String MOT_FRANCAIS = "motFrancais";
	private final String MOT_ANGLAIS = "motAnglais";
	private final String DEF_FRANCAIS = "definitionFrancais";
	private final String DEF_ANGLAIS = "definitionAnglais";
	private final String TEST1 = "test1";
	private final String TEST2 = "test2";
	private final String TEST3 = "test3";
	private final String TEST4 = "test4";
	private final String TEST5 = "test5";
 
	private ArrayList<Entry> entries;
 
	private Entry currentFeed;
 
	private StringBuffer buffer;
 
	public void processingInstruction(String target, String data)
	{
		try {
			super.processingInstruction(target, data);
		} catch (SAXException e) {
			e.printStackTrace();
		}
	}
 
	public ParserXMLHandler(){super();}
 
	public void startDocument() throws SAXException
	{
		super.startDocument();
		entries = new ArrayList<Entry>();
		currentFeed = new Entry();
	}
 
	public void startElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void endElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(MOT_ANGLAIS))
		{
				this.currentFeed.setMotAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(MOT_FRANCAIS))
		{
				this.currentFeed.setMotFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_ANGLAIS))
		{
				this.currentFeed.setDefAnglais(buffer.toString());
				entries.add(currentFeed);
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_FRANCAIS))
		{
				this.currentFeed.setDefFrancais(buffer.toString());
				buffer = null;
		}
	}
 
	public void characters(char[] ch, int start, int length)
	{
		String lecture = new String(ch, start, length);
		if(buffer != null) buffer.append(lecture);
	}
 
	public ArrayList<Entry> getData()
	{
		return entries;
	}
}

LogCat :

**tchize_** · 17/01/2013, 21h05

Envoyé par onda47

j'ai corrigé mon code en mettant un signe distinctif sur les erreurs pouvant être soulevé.
Il suffit bien de mettre un System.out.println pour afficher les soulèvement d'exception dans le LogCat ?

Mmmm non, je ne pense pas

http://developer.android.com/tools/d...gging-log.html

**onda47** · 17/01/2013, 22h53

oh je te remercie beaucoup pour cette très précieuse information !
c'est vraiment génial (je suis débutant dans la programmation android)

j'ai trouvé ce qui ne va pas :
maintenant je comprends que c'est le fichier xml qui ne va pas ou bien le ma classe ParserXMLHandler.
Après avoir regardé et reregardé mon fichier xml je pense que c'est ma classe.
Je poste les deux à la suite. Peut-être pouvez-vous m'aider ? Je ne comprends pas.

Classe ParserXMLHandler :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
public class ParserXMLHandler extends DefaultHandler {
 
	private final String MOT_FRANCAIS = "motFrancais";
	private final String MOT_ANGLAIS = "motAnglais";
	private final String DEF_FRANCAIS = "definitionFrancais";
	private final String DEF_ANGLAIS = "definitionAnglais";
	private final String TEST1 = "test1";
	private final String TEST2 = "test2";
	private final String TEST3 = "test3";
	private final String TEST4 = "test4";
	private final String TEST5 = "test5";
 
	private static final String TAG = "ParserXMLHandler";
 
	private ArrayList<Entry> entries;
 
	private Entry currentFeed;
 
	private StringBuffer buffer;
 
	public void processingInstruction(String target, String data)
	{
		try 
		{
			super.processingInstruction(target, data);
		} 
		catch (SAXException e) {Log.e(TAG, "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" + e.getMessage());}
	}
 
	public ParserXMLHandler(){super();}
 
	public void startDocument()
	{
		try {
			super.startDocument();
		} catch (SAXException e) {
			Log.e(TAG, "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" + e.getMessage());
		}
		entries = new ArrayList<Entry>();
		currentFeed = new Entry();
	}
 
	public void startElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void endElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(MOT_ANGLAIS))
		{
				this.currentFeed.setMotAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(MOT_FRANCAIS))
		{
				this.currentFeed.setMotFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_ANGLAIS))
		{
				this.currentFeed.setDefAnglais(buffer.toString());
				entries.add(currentFeed);
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_FRANCAIS))
		{
				this.currentFeed.setDefFrancais(buffer.toString());
				buffer = null;
		}
	}
 
	public void characters(char[] ch, int start, int length)
	{
		String lecture = new String(ch, start, length);
		if(buffer != null) buffer.append(lecture);
	}
 
	public ArrayList<Entry> getData()
	{
		return entries;
	}
}

Fichier Dico.xml :

Code xml :

Sélectionner tout - Visualiser dans une fenêtre à part

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
62
63
64
65
66
67
<?xml version='1.0' encoding="UTF-8" ?>
 
<test1>
	<motAnglais>Abort</motAnglais>
	<motFrancais>Interrompre</motFrancais>
	<definitionAnglais>To stop the running of a computer program, usually when things go wrong. The computer returns to the operating system after aborting the program, prints a message to warn the operator and waits for a new command.</definitionAnglais>
	<definitionFrancais>Arrêter l'exécution d'un programme informatique, le plus souvent lorsque surgit un problème. L'ordinateur renvoie au système d'exploitation, après avoir interrompu le programme, affiche un message pour alerter l'utilisateur et attend de sa part d'autres commandes.</definitionFrancais>
 
	<motAnglais>Access time</motAnglais>
	<motFrancais>Temps d'accès</motFrancais>
	<definitionAnglais>The time taken by the computer to fetch data from an address within the computer or other storage device. It is also the time between being told to fetch and having the data ready.</definitionAnglais>
	<definitionFrancais>Temps pris par l'ordinateur pour aller chercher des données à partir d'une adresse de l'ordinateur ou de tout autre dispositif de stockage. Il s'agit également du temps écoulé entre le moment où l'on a dit à l'ordinateur d'aller chercher les données et celui où les données sont prêtes.</definitionFrancais>
 
	<motAnglais>Accumulator</motAnglais>
	<motFrancais>Accumulateur</motFrancais>
	<definitionAnglais>A special location used to hold the result of calculations during processing.</definitionAnglais>
	<definitionFrancais>Emplacement particulier utilisé pour conserver le résultat de calculs pendant le traitement des données.</definitionFrancais>
</test1>
 
 
<test2>
	<motAnglais>Acronym</motAnglais>
	<motFrancais>Acronyme</motFrancais>
	<definitionAnglais>A word formed from the initial letters of a group of words or a phrase. The world of computing uses many acronyms, for example: ASCII. </definitionAnglais>
	<definitionFrancais>Un mot formé à partir des initiales d'un groupe de mots ou d'une expression. Le milieu de l'informatique utilise fréquemment des acronymes, par exemple ASCII.</definitionFrancais>
 
	<motAnglais>Adder</motAnglais>
	<motFrancais>Additionneur</motFrancais>
	<definitionAnglais>A device which performs addition on digital signals giving both the sum and the carry digit. A half-adder has two inputs whereas a full-adder has three inputs, each input being a 0 or 1.</definitionAnglais>
	<definitionFrancais>Dispositif qui fait des additions de signaux digitaux en donnant à la fois la somme et la retenue. Un demi-additionneur a deux entrées alors qu'un additionneur complet en a trois, chaque entrée correspondant à 0 ou à 1.</definitionFrancais>
 
	<motAnglais>Address</motAnglais>
	<motFrancais>Adresse</motFrancais>
	<definitionAnglais>The reference number given to each location in a computer's memory that stores data. Whenever a computer is asked to find a piece of data it has stored, it uses the address.</definitionAnglais>
	<definitionFrancais>Le numéro de référence donné à chaque emplacement dans la mémoire de l'ordinateur qui emmagasine les données. Chaque fois que l'ordinateur est appelé à trouver une donnée qui était emmagasinée, il utilise l'adresse.</definitionFrancais>
</test2>
 
 
<test3>
	<motAnglais>Address modification</motAnglais>
	<motFrancais>Modification d'adresse</motFrancais>
	<definitionAnglais>The process by which the address part of a program instruction is changed, say to one higher (i.e. the next address) each time the instruction is performed.</definitionAnglais>
	<definitionFrancais>Procédé par lequel la partie adresse d'une instruction de programme est modifiée, disons en une adresse supérieure (c'est-à-dire l'adresse suivante) chaque fois que l'instruction est exécutée.</definitionFrancais>
 
	<motAnglais>ADSL</motAnglais>
	<motFrancais>ADSL</motFrancais>
	<definitionAnglais>Provides a connection through telephone copper wires, which receives data between 2 and 8 Mbps, though is slower in the other direction.</definitionAnglais>
	<definitionFrancais>Fournit une connexion grâce aux fils de cuivre du téléphone et reçoit des données entre 2 et 8 Mbps bien que plus lent dans l'autre direction.</definitionFrancais>
</test3>
 
 
 
<test4>
	<motAnglais>ALGOL</motAnglais>
	<motFrancais>ALGOL</motFrancais>
	<definitionAnglais>ALGorithmic Oriented Language. A high-level programming language developed in Europe at the same time as FORTRAN was being developed in the United States.</definitionAnglais>
	<definitionFrancais>Langage orienté algorithmique. Langage de programmation de haut niveau développé en Europe en même temps que FORTRAN fut développé aux USA.</definitionFrancais>
</test4>
 
 
 
<test5>
	<motAnglais>Algorithm</motAnglais>
	<motFrancais>Algorithme</motFrancais>
	<definitionAnglais>A planned set of instructions or steps designed to solve a particular problem. There is only one starting point and all routes through the algorithm end at the same finishing point. Such steps can be carried out by a computer, or dry run on paper, using different inputs or values.</definitionAnglais>
	<definitionFrancais>Série d'instructions ou d'étapes organisées, conçues  pour résoudre un problème particulier. Il n'y a qu'un point de départ et tous les cheminements à travers l'algorithme aboutissent au même point d'arrivée. De telles étapes peuvent être exécutées par un ordinateur ou suivies sur papier, en utilisant différentes entrées ou valeurs.</definitionFrancais>
</test5>

Erreur pour lire fichier XML

Android

Vue hybride

Discussions similaires

Partager

Partager