Java StAX XML中的解析问题

Question

I've been searching for a solution to this problem and found nothing. I'm creating a simple chat over Java TCP/IP sockets as an assignment and I've encountered a problem creating an XML string containing the letter åäö.

Lets say I pass an XMLObject with the fields

name="Server", color="#FF0000" text="åäö"

the generated xmlstring that is returned by the parser will be

<?xml version="1.0"?><message sender="Server"><text color="#FF0000”>???</text></message>

åäö turns into ???. Any idea? Thanks!

** UPDATE** Ok, so I just realised the problem arises when getting some text from a JTextArea.

If I run this code:

package self.edu.javaprojekt.view;

import self.edu.javaprojekt.model.XMLObject;
import self.edu.javaprojekt.model.XMLParser;

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        XMLObject object = new XMLObject();
        object.setColor("#FF0000");
        object.setSender("Server");
        object.setText("åäö");
        String parsed = XMLParser.parse(object);
        System.out.println(parsed);
        System.out.println(XMLParser.parse(parsed));

    }

}

I get the proper result:

<?xml version="1.0" encoding="UTF-8"?><message sender="Server"><text color="#FF0000">åäö</text></message>
XMLObject [sender=Server, text=åäö, color=#FF0000]

But with a text area. The text that is returned in the following method is added to an XMLObject and then sent for parsing.

public String readAndClearMessageArea() {
        String text = messageTextArea.getText();
        appendToPane("\n" + controller.getName() + ": " + text, controller.getColor());
        messageTextArea.setText("");
        return text;
    }

I get the weird result. Any new ideas? Thanks!!

This is the parser

package self.edu.javaprojekt.model;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.Iterator;

import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;

public class XMLParser {
    public static final String MESSAGE_TAG = "message";
    public static final String SENDER_TAG = "sender";
    public static final String TEXT_TAG = "text";
    public static final String COLOR_TAG = "color";
    public static final String DISCONNECT_TAG = "disconnect";
    public static final String ENCRYPTED_TAG = "encrypted";
    public static final String ENCRYPTED_TYPE_TAG = "type";
    public static final String KEY_REQUEST_TAG = "keyrequest";

    public static String parse(XMLObject object) {
        // create an XMLOutputFactory
        XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
        // create XMLEventWriter
        XMLEventWriter eventWriter;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        String xmlString = "";
        try {
            eventWriter = outputFactory.createXMLEventWriter(out);

            // create an EventFactory
            XMLEventFactory eventFactory = XMLEventFactory.newInstance();
            //XMLEvent end = eventFactory.createDTD("\n");
            //XMLEvent tab = eventFactory.createDTD("\t");
            // create and write Start Tag
            StartDocument startDocument = eventFactory.createStartDocument("UTF-8");
            eventWriter.add(startDocument);

            // create message open tag
            //eventWriter.add(end);
            StartElement messageStartElement = eventFactory.createStartElement(
                    "", "", MESSAGE_TAG);
            eventWriter.add(messageStartElement);
            eventWriter.add(eventFactory.createAttribute(SENDER_TAG,
                    object.getSender()));
            //eventWriter.add(end);

            // create the text
            //eventWriter.add(tab);
            StartElement textStartElement = eventFactory.createStartElement("",
                    "", TEXT_TAG);
            eventWriter.add(textStartElement);
            eventWriter.add(eventFactory.createAttribute(COLOR_TAG,
                    object.getColor()));

            Characters characters = eventFactory.createCharacters(object.getText());
            eventWriter.add(characters);

            //eventWriter.add(tab);
            eventWriter.add(eventFactory.createEndElement("", "", TEXT_TAG));
            //eventWriter.add(end);

            eventWriter.add(eventFactory.createEndElement("", "", MESSAGE_TAG));
            //eventWriter.add(end);
            eventWriter.add(eventFactory.createEndDocument());
            eventWriter.close();
            xmlString = out.toString("UTF-8");
        } catch (XMLStreamException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return xmlString;
    }

    @SuppressWarnings("unchecked")
    public static XMLObject parse(String string) {
        XMLObject object = null;
        try {
            // First, create a new XMLInputFactory
            XMLInputFactory inputFactory = XMLInputFactory.newInstance();
            // Setup a new eventReader
            InputStream in;
            if (!string.equals("")) {
                in = new ByteArrayInputStream(Charset.forName("UTF-8")
                        .encode(string).array());
            } else {
                in = new FileInputStream("xmltest.txt");
            }
            XMLEventReader eventReader = inputFactory.createXMLEventReader(in);

            // read the XML document
            while (eventReader.hasNext()) {
                XMLEvent event = eventReader.nextEvent();
                if (event.isStartElement()) {
                    StartElement startElement = event.asStartElement();
                    // If we have a message
                    if (startElement.getName().getLocalPart()
                            .equals(MESSAGE_TAG)) {
                        object = new XMLObject();
                        // We read the attributes from this tag and add the
                        // sender
                        // attribute to our object
                        Iterator<Attribute> attributes = startElement
                                .getAttributes();
                        while (attributes.hasNext()) {
                            Attribute attribute = attributes.next();
                            if (attribute.getName().getLocalPart()
                                    .equals(SENDER_TAG)) {
                                object.setSender(attribute.getValue());
                            }

                        }
                    }

                    if (startElement.getName().getLocalPart().equals(TEXT_TAG)) {
                        // We read the attributes from this tag and add the
                        // color
                        // attribute to our object
                        Iterator<Attribute> attributes = startElement
                                .getAttributes();
                        while (attributes.hasNext()) {
                            Attribute attribute = attributes.next();
                            if (attribute.getName().getLocalPart()
                                    .equals(COLOR_TAG)) {
                                object.setColor(attribute.getValue());
                            }

                        }
                        // And then get the text
                        event = eventReader.nextEvent();
                        object.setText(event.asCharacters().getData());
                        continue;
                    }
                }
                // If we reach the end of the message, return the object
                if (event.isEndElement()) {
                    EndElement endElement = event.asEndElement();
                    if (endElement.getName().getLocalPart().equals(MESSAGE_TAG)) {
                        return object;
                    }
                }

            }
        } catch (XMLStreamException | FileNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

This is the class holding the xml values

package self.edu.javaprojekt.model;

public class XMLObject {
    private String sender, text, color;

    public String getSender() {
        return sender;
    }

    public String getText() {
        return text;
    }

    public String getColor() {
        return color;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public void setText(String text) {
        this.text = text;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "XMLObject [sender=" + sender + ", text=" + text + ", color="
                + color + "]";
    }

}

Answer 1

I have seen this before, you can use the different encoding to see which one work for you. But try ISO-8859-1 or UTF-16. Not sure which encoding you need.