Flux XML pour application client/serveur

**le y@m's** · 10/10/2005, 08h56

Salut à tous,

Je developpe une application client/serveur qui doit echanger des flux XML, j'ai donc créé une classe gérant l'envoie et la reception des flux. Malheureusement je me retrouve avec une SAXParseException que je n'arrive pas à corriger.
voici mon code :

classe gérant l'échange des flux XML : XMLTransfertManager

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import java.io.*;
import java.net.*;
import javax.swing.*;
 
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
import org.w3c.dom.*;
import org.xml.sax.*;
 
public class XMLTransfertManager extends Thread
{
 
    /**
     * Creates a new instance of XMLTransfertManager 
     */
    public XMLTransfertManager(Socket socket, String directory) 
    {
        this.socket = socket;
        this.directory = directory;
        try
        {
            OS = socket.getOutputStream();
            IS = socket.getInputStream();
            OOS = new ObjectOutputStream(OS);
            OIS = new ObjectInputStream(IS);
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
 
    public void closeStreams()
    {
        stopListen();
        while(isListening())
        {}
        try
        {
            OOS.close();
            OIS.close();
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
 
    public void sendXML()
    {
        try
        {
            Document document = null;
            DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder constructor = dbfactory.newDocumentBuilder();
            document = constructor.newDocument();
            document.setXmlVersion("1.0");
            document.setXmlStandalone(true);
            Element root = document.createElement("root");
            Element test = document.createElement("test");
            test.setTextContent("ceci est un test");
            root.appendChild(test);
            document.appendChild(root);
            File fileToSend = new File(directory + "\\send" + 
                                           String.valueOf(nbSent) + ".xml");
            nbSent ++;
            fileToSend.createNewFile();       
            Source source = new DOMSource(document);			
            Result resultat1 = new StreamResult(fileToSend);
            Result resultat2 = new StreamResult(OS);
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer();
            transformer.transform(source, resultat1);
            transformer.transform(source, resultat2);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
 
    public void run()
    {
        endListening = false;
        isListeningEnd = false;
        while(!endListening)
        {
            try
            {
                Document document = null;
                DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance();
                DocumentBuilder constructor = dbfactory.newDocumentBuilder();
                document = constructor.parse(IS);
 
                File receivedFile = new File(directory + "\\receive" +
                                             String.valueOf(nbReceive) +".xml");
                nbReceive ++;
                receivedFile.createNewFile();
                Source source = new DOMSource(document);			
                Result resultat = new StreamResult(receivedFile);
                TransformerFactory factory = TransformerFactory.newInstance();
                Transformer transformer = factory.newTransformer();
                transformer.transform(source, resultat);
            }
            catch(Exception e)
            {
                e.printStackTrace();
                endListening = true;
            }
        }
        isListeningEnd = true; 
    }
 
    public void stopListen()
    {
        endListening = true;
    }
 
    public boolean isListening()
    {
        return(!isListeningEnd);
    }
 
    private Socket socket;
    private OutputStream OS;
    private InputStream IS;
    private ObjectOutputStream OOS;
    private ObjectInputStream OIS;
    private boolean endListening;
    private boolean isListeningEnd;
    private String directory;
    private int nbSent = 0;
    private int nbReceive = 0;
}

Client

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
import java.io.*;
import java.net.*;
 
public class Client 
{
    private XMLTransfertManager xmltm;
    private Socket server;
 
    /** Creates a new instance of Client */
    public Client(String host, int port) 
    {
        try
        {
            server = new Socket(host, port);
            xmltm = new XMLTransfertManager(server, "C:\\MonTemp\\client");
            xmltm.start();
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
 
    public void send()
    {
        xmltm.sendXML();
    }
 
    public void stop()
    {
        xmltm.closeStreams();
        try
        {
            server.close();
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
 
    static public void main(String ...args)
    {
        Client c = new Client("localhost", 50000);
        c.send();
        c.send();
        c.stop();
    }
}

Serveur

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
import java.io.*;
import java.net.*;
 
 
/**
 *
 * @author D'Isanto Yann
 */
public class Server 
{
    private XMLTransfertManager xmltm;
    private ServerSocket listener;
    private Socket client;
 
    /** Creates a new instance of Server */
    public Server(int port) 
    {
        try
        {
             listener = new ServerSocket(port);
             client = listener.accept();
             xmltm = new XMLTransfertManager(client,
                                             "C:\\MonTemp\\server");
             xmltm.start();
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
 
    public void send()
    {
        xmltm.sendXML();
    }
 
    public void stop()
    {
        xmltm.closeStreams();
        try
        {
            client.close();
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
 
    static public void main(String ...args)
    {
        Server s = new Server(50000);
        s.send();
        s.send();
        s.send();
        s.send();
        s.stop();
    }
}

Quand je lance le serveur puis le client, j'ai l'erreur suivante (pour le client et pour le serveur) :

[Fatal Error] :1:86: The processing instruction target matching "[xX][mM][lL]" is not allowed.
org.xml.sax.SAXParseException: The processing instruction target matching "[xX][mM][lL]" is not allowed.
at com.sun.org.apache.xerces.internal.parsers.DOMParser.parse(DOMParser.java:264)
at com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderImpl.parse(DocumentBuilderImpl.java:292)
at javax.xml.parsers.DocumentBuilder.parse(DocumentBuilder.java:98)
at test.XMLTransfertManager.run(XMLTransfertManager.java:113)

J'ai l'impression que le flux XML n'est pas envoyé correctement.
Merci d'avance pour votre aide.

**le y@m's** · 10/10/2005, 16h36

Y'a vraiment personne pour m'aider ?

Please

**benratti** · 10/10/2005, 18h35

En debut d'annee, je m'etais interesse a faire un client/serveur dialoguant a l'aide de flux xml et j'avais utilise SAX. J'avais rencontre quelques soucis mais au final ca marchait plutot bien. Voici un post qui avait partiellement resolu mes problemes.

Il y a en particulier le code d'un simple client/serveur qui fonctionne.

Je ne sais pas ca peut t'etre utile... mais on ne sais jamais.

**le y@m's** · 10/10/2005, 19h45

J'ai regardé le post, en fait tu n'utilise pas de transformer mais tu passe directement le texte du document. J'ai déjà pensé à cette solution mais je prefererais la garder en dernier recours.
J'utilise un transformer pour pour envoyer le document vers l'OutputStream :

Code :

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

1
2
3
4
Result resultat2 = new StreamResult(OS);
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
transformer.transform(source, resultat2)

Le probleme semble venir de là car l'exception est levée lors de la "lecture" du flux

Code :

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

document = constructor.parse(IS);

et semble indiquer que celui-ci n'est pas un document XML valide

.
Je n'arrive pas à comprendre d'où viens le problème

.

**le y@m's** · 11/10/2005, 15h42

Je m'excuse pour cette remontée mais je me permet d'insister car c'est vraiment important et je n'arrive toujours pas à trouver la cause de mon problème

Flux XML pour application client/serveur

Format d'échange (XML, JSON...) Java

Discussions similaires

Partager

Partager