# XMLStreamReader mit ObjectInputStream



## Hurby (8. Jun 2009)

Hallo Java-Freunde,

ich habe folgendes Problem:

Ich übertrage eine XML-Struktur über Sockets, also als ByteArray. Auf der Empfängerseite, kann ich den InputStream in ein ObjectInputStream konvertieren und ausgeben, alles Top.

Nun möchte ich aber den Stream gleich von einem XMLStreamReader verarbeiten lassen und da liegt das Problem.
Ich weiss nicht so recht, wie ich den InputStream oder den daraus erzeugten ObjectInputStream der Sockets an den XMLStreamReader übergebe...

Der Konstruktor von XMLStreamReader lässt einen InputStream oder ObjectInputStream durch, aber beim ersten "next" -Befehl vom XMLStreamReader knallts dann...

Ich könnte mir vorstellen, das der XMLStreamReader nicht in der lage ist die Methode "readObject" vom ObjectInputStream aufzurufen, oder so ähnlich...

Eine Möglichkeit wäre ja, aus dem übertragenen Stream eine XML-Datei zu erzeugen und diese dann mit dem XMLStreamReader weiter zuverarbeiten, aber ich wollte mal wissen ob das auch eleganter bzw. performanter geht???

(Auf Anfrage gibts auch gerne Quellcode...)

MfG Hurby


----------



## Noctarius (8. Jun 2009)

Keine Ahnung ob das hier dein Problem löst (noch nicht damit gearbeitet) aber vielleicht interessanter Hinweis:
https://xmlinputstream.dev.java.net/


----------



## Wildcard (8. Jun 2009)

Warum überhaupt ein Object Stream? Schick doch die Rohdaten rüber.


----------



## Hurby (9. Jun 2009)

Wildcard hat gesagt.:


> Warum überhaupt ein Object Stream? Schick doch die Rohdaten rüber.



Ist nicht der InputStream die grundlegenste Form der Datenübertragung bei Sockets also bereits Rohdaten???

MfG Hurby

PS: den Link von Noctarius prüfe ich gleich...


----------



## Wildcard (9. Jun 2009)

Ja, aber wenn du einen ObjectOutputStream darüberlegst überträgst du eben nicht das XML, sondern irgendeine Objektstruktur und da ist die Frage: warum?
Es spricht zwar erstmal nichts dagegen direkt einen Objektbaum zu übertragen wie du es zur Zeit wohl tust, aber was willst du auf Empfängerseite dann mit einem XML Parser? Du bekommst doch gar kein XML mehr, sondern den fertigen Baum.


----------



## Hurby (10. Jun 2009)

Hallo, ich glaube da haben wir aneinander vorbeigeredet...

Auf der "Sender-Seite" werden die Daten wie folgt übertragen:
(Der ObjectOutputStream ist nur um das Objekt vom Typ String zu serialisieren)

>Das Leerzeichen zwischen XML existiert gar nicht...


```
out.write(StringToByteArray(AuftragsDoc.generateXML()));

    //Konvertiert einen String in ein ByteArray zum übermitteln per Streams
    private static byte[] StringToByteArray(String Text) throws Exception{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(Text);
        return bos.toByteArray();
    }
```
Auf der "Empfänger-Seite" kommt also ein ByteArray an...

Auch hier nochmal etwas Code:


```
public void run(){
        try{
            //Auf Verbindungs-Port nach Anfragen lauschen
            ServerSocket server = new ServerSocket(Port);

            Socket client = null;
            client = server.accept();

            //I/O -Streams zuweisen
            InputStream In = client.getInputStream();
            OutputStream Out = client.getOutputStream();

            //Lotus-Notes-Session instanzieren, ZielDB öffnen und Dokument erstellen
            Session session = NotesFactory.createSession();
            Database database = session.getDatabase("", TargetDatabase);
            Document AuftragsDoc = database.createDocument();

            while(true){
                if(In.available() > 0){

                    String Doc = ByteArrayToString(In);

                    try{
                        FileWriter writer = new FileWriter(new File("Doc.xml"), false);
                        writer.append(Doc);
                        writer.close();
                    }catch (Exception e){
                        e.printStackTrace();
                    }

                    XMLInputFactory factory = XMLInputFactory.newInstance();
                    XMLStreamReader parser = factory.createXMLStreamReader( new FileInputStream( "Doc.xml" ), "ISO-8859-1" );

                    String Name="";
                    String Value="";

                    while ( parser.hasNext() ){

                        switch ( parser.getEventType() ){
                            case XMLStreamConstants.END_DOCUMENT:
                                 parser.close();
                                 break;

                            case XMLStreamConstants.START_ELEMENT:
                                 for ( int i = 0; i < parser.getAttributeCount(); i++ ){
                                     Name = parser.getAttributeLocalName(i);
                                     Value = parser.getAttributeValue(i);
                                     if(Name.equals("unid"))
                                         AuftragsDoc.setUniversalID(Value);
                                     else if(Name.equals("name")){
                                         Name = Value;
                                         Value = "";
                                     }else
                                         AuftragsDoc.replaceItemValue(Name, Value);
                                 }
                                 break;

                            case XMLStreamConstants.CHARACTERS:
                                 if (!parser.isWhiteSpace() && ((!Name.isEmpty()) && (Value.isEmpty()))){
                                     Value = parser.getText();
                                     AuftragsDoc.replaceItemValue(Name, Value);

                                     Value = "";
                                 }
                                 break;
                                 
                            default:
                                 break;
                        }
                        parser.next();
                    }

                    AuftragsDoc.save();
                    System.out.println("Dokument erfolgreich verarbeitet");
                }
            }

        }catch(Exception ex){
            ex.printStackTrace();
        }
    }
```

Klappt alles Top, nur statt den Weg über "Doc.xml" zu gehen würde ich gerne den InputStream des Sockets mit dem XMLStreamReader kombinieren...

Hoffe das schildert mein Prob. etwas genauer

PS: wie kann ich beim schreiben eines Artikels hier im Forum Syntaxhighlighting einstellen???

MfG Hurby


----------



## Noctarius (10. Jun 2009)

Hurby hat gesagt.:


> PS: wie kann ich beim schreiben eines Artikels hier im Forum Syntaxhighlighting einstellen???



[ java] dein code [/ java]


----------



## Wildcard (10. Jun 2009)

Warum denn so kompliziert? Um einen String in ein byte[] zu wandeln einfach getBytes aufrufen, oder direkt einen Writer verwenden, so wie jetzt ist's in jedem Fall Unsinn.
Auf Empfängerseite übergibst du der XMLInputFactory einfach den InputStream des Sockets und das encoding. XMLInputFactory (Java Platform SE 6)


----------



## Hurby (11. Jun 2009)

Ok, das umwandeln von String in Byte[] geht wirklich einfacher.
Aber wenn ich meinen Parser wie folgt erstelle:


```
XMLStreamReader parser = factory.createXMLStreamReader(In, "ISO-8859-1" );
```

bekomme ich beim Befehl


```
parser.next();
```

die Fehlermeldung:

javax.xml.stream.XMLStreamException: ParseError at [row,col]:[1,1]
Message: Content is not allowed in prolog.


Hab keine Idee, wie ich das beheben kann...


----------



## Wildcard (11. Jun 2009)

In dem Stream steht offensichtlich etwas unerlaubtes. Lass ihn dir ausgeben und zeig mal her was du jetzt schickst.
Übrigens: bitte gewöhne dir die Coding Conventions an, so ist es für alle besser zu lesen.
KlassenGroßCamelCase
variablenKleinCamelCase
methodenKleinCamelCase
KONSTANTEN_GROß_MIT_UNTERSTRICH


----------

