Zeichensatz

[Plumperquatsch]

Hallo allerseits,

ich habe ein Programm geschrieben, dass Objekte serialisiert (als File) und wieder deserialisiert. So schön so gut.

Im Netbeans deserialisiere ich ein Objekt (Attributinhalt ein Name mit einem 'ö') -> klappt wurderbar

Wenn ich genau das gleiche, auf genau dem gleichen Rechner unter dem gleichen Betriebssystem (Windows 7) mache aber nicht über Netbeans sondern per java -jar xy.jar mache, dann ließt er nicht 'ö' sondern '÷' ein.

Ich bin mittlerweile fast wahnsinnig, weil ich keine Ahnung habe, was das ganze soll. Kann ich irgendwo einstellen, wie Java Strings codiert?? Wenn nämlich dieser Wert in einem JTextField dargestellt wird, dann zeigt er wieder ein 'ö' an. Also über System.out kommt ein '÷'

Ich bin extrem Planlos.

Hat jemand eine Idee, wonach ich suchen kann. Ich weiß echt nicht weiter...

Vielen Dank im Voraus....

Jens

 

[The_S]

Wenn über System.out.println das falsche Sonderzeichen kommt, dann liegt das daran, weil die Konsole einen anderen Zeichensatz verwendet. In Java selbst passt alles, aber die Windows-Maschine ist halt Java unabhängig .

Schau mal hier:

Java Blog Buch : 09.07 Zeichenkodierung

letzter Abschnitt (Codepages und die Windows-Konsole)

 

[Plumperquatsch]

Gut,

ich habe jetzt - glaube ich - begriffen, dass es nichts mit dem Persistieren zu tun hat.

Prinzipiell gehe ich so vor, dass ich
1. ein Personen Objekt persistiere.
2. das gebe ich an eine andere Instanz des gleichen Programms (momentan gleicher Rechner, soll aber auch mal ein anderer Rechner sein)
3. in der anderen instanz lese ich das Objekt ein und verlgeiche den Wert (in diesem Fall ein Name) mit lokal in einer XML Datei abgelegten Daten
4. Ist die XML Datei zu diesem Zeitpunkt noch nicht vorhanden, wird sie mit den Werten (dem Namen) aus dem persistierten Objekt gefüllt. Der gefüllte Wert, also der, der in den später für die XML Datei relevanten Attributen steht, den gebe ich auf der GUI aus. Dort wird er korrekt dargestellt. An dieser Stelle habe ich (wie im ersten Post beschrieben) System.out.... mit dem Wert ausgegeben, dort stand der Wert falsch.
5. Wird das Programm beendet, wird die XML Datei gespeichert.
6. In der XML Datei steht jetzt der 'falsche' Wert drin.

XML Dateien verwalte ich per JDOM, die Datei ist in UTF-8 codiert. System.setOut ... habe ich jetzt ebenfalls (wie im Blog-Buch beschrieben) auf UTF-8 encodiert.

Und es ist nicht Windowsversionsabhängig.

Hat jemand vieleicht eine Idee, wieso es unter Netbeans funktoniert, und wenn man es 'normal' aufruft nicht?

 

[The_S]

XML Dateien verwalte ich per JDOM, die Datei ist in UTF-8 codiert. System.setOut ... habe ich jetzt ebenfalls (wie im Blog-Buch beschrieben) auf UTF-8 encodiert.

Bringt aber nix für die Konsolenausgabe, weil du für die Windows-Konsole (wie im Blog-Buch beschrieben) auf Cp850 umstellen musst.

Und es ist nicht Windowsversionsabhängig.

Versteh ich nicht. Was ist der Sinn dieser Aussage?

Hat jemand vieleicht eine Idee, wieso es unter Netbeans funktoniert, und wenn man es 'normal' aufruft nicht?

Was funktioniert denn nicht?

 

[Plumperquatsch]

Und es ist nicht Windowsversionsabhängig.

Versteh ich nicht. Was ist der Sinn dieser Aussage?

Nun ja, ich dachte, ich hätte die Probleme nicht unter Windows XP. Ich habe Win7 erst vor einer Woche oder so installiert und seit dem nicht am Programm geschrieben. und der Fehler ist mir eigentlich erst vorgesten das erste Mal aufgefallen. Seit dem bin ich da dran und habe heute auf meinem anderen Rechner die gleiche Unschärfe gehabp. insofern gehe ich davon aus, dass es nichts mit der WinVersion zu tun hat.

Hat jemand vieleicht eine Idee, wieso es unter Netbeans funktoniert, und wenn man es 'normal' aufruft nicht?

Was funktioniert denn nicht?

Also, ich entwickel in Netbeans. Da teste ich ja auch das Programm. Und das macht natürlich genau das gleiche, wie das Programm aus der Konsole gestartet. Ich starte das Programm direkt aus der IDE. Und da tritt dieser Fehler nicht auf. Da muss ich nichts Codieren oder so, ein ö wird als ö abgespeichert, egal von wo es kommt.

Das gleiche Programm, alles gleich - wirklich - habe ich in einem anderen Verzeichnis auf dem gleichen Rechner eingerichtet. dort starte ich es aus der Konsole heraus über 'java - jar programm.jar'. Und dann kommt ein ö eben nicht als ein ö im XML File an, sondern als irgend ein anderes Zeichen. Windows ist das sehr kreativ und ich dem Wahnsinn nahe!

Ich habe das mit der Codepage 850 jetzt mal versuch - dann kommt auch unter Netbeans mist raus, aber anderer Mist als aus der Konsole... Ich glaub ich werde noch bekloppt!

 

[Plumperquatsch]

Bringt aber nix für die Konsolenausgabe, weil du für die Windows-Konsole (wie im Blog-Buch beschrieben) auf Cp850 umstellen musst.

Hamm, ich habe es mit cp850 versucht, leider funktioniert es nur mit UTF-8. Alles andere führt zu den unterschiedlichsten Ergebnissen. Wenn ich dann aber auf einen Rechner mit Win XP gehe, dann funktioniert es mit UTF-8 nicht.

Ich habe das Gefühl, dass das irgendwie doch mit Win7 zu tun hat... Ich werde mal ein bisschen rumprobieren. Aber mit Plan hat das im Moment nicht zu tun..

Trotzdem danke, Stefan!

 

[Plumperquatsch]

So, jetzt habe ich mal ein Programm geschrieben, dass vom Prinzip her das macht, was mein Programm tun soll.

package unicodetest;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import org.xml.sax.InputSource;

/**
 *
 * @author Jens
 */
public class Main {
    private String path = "d:/";
    private SerializableObject so = null;

    private static String XML_ENCODING = "ISO-8859-1";
    private static String FILE_ENCODING = "ISO-8859-1";
    private static String SYS_ENCODING  = "ISO-8859-1";

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            System.setProperty("file.encoding",FILE_ENCODING);
            if (!SYS_ENCODING.isEmpty())
                System.setOut(new PrintStream(System.out, true, SYS_ENCODING));
        } catch (Exception ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
        Main m = new Main("d:/");
        // --> Serialisieren................
        m.serialize();
        
        // --> Serialisierte Daten in XML Datei ausgeben
        if (m.so != null){
            Document doc = new Document(new Element("test"));
            Element root = doc.getRootElement();
            Element elm = root.addContent(new Element("Umlaute"));
            elm.setText(m.so.getAStringValue());
            m.writeXML(doc, "output.xml");

            m.so = null;
        }
        // --> Deserialisieren................
        m.deserialize();
        
        // --> XML datei zurücklesen
        Document doc2 = m.readXML("output.xml");

        // --> Daten vom Serialisierten Objekt mit den der XML Datei vergleichen
        Element root = doc2.getRootElement();
        String aString = root.getText();
        System.out.println("Wert aus XMLDatei entspricht dem Wert im deserialisierten Objekt: "+m.so.getAStringValue().equals(aString));
    }

    public Main(String path) {
        this.path = path;
    }



    private void serialize(){
        ObjectOutputStream oos = null;
        FileOutputStream fos = null;
        try {
          File f = new File("d:/test.ser");
          if (!f.exists()){
              f.createNewFile();
              fos = new FileOutputStream(this.path+"test.ser");
              oos = new ObjectOutputStream(fos);
              so = new SerializableObject("äöüß", 100, true);
              System.out.println(so.toString());
              oos.writeObject(so);
          }
        }
        catch (Exception e) {
          e.printStackTrace();
        }
        finally {
          if (oos != null) try { oos.close(); } catch (IOException e) {}
          if (fos != null) try { fos.close(); } catch (IOException e) {}
        }
    }

    private void deserialize(){
        // -->Deserialisieren................
        ObjectInputStream ois = null;
        FileInputStream fis = null;
        try {
          fis = new FileInputStream(this.path+"test.ser");
          ois = new ObjectInputStream(fis);
          Object obj = ois.readObject();
          if (obj instanceof SerializableObject) {
            so = (SerializableObject)obj;
            System.out.println(so.toString());
            System.out.println("Deserialisiertes Objekt entspricht Ursprung: "+so.getAStringValue().equals("äöüß"));
          }
        }
        catch (Exception e) {
          e.printStackTrace();
        }
        finally {
          if (ois != null) try { ois.close(); } catch (IOException e) {}
          if (fis != null) try { fis.close(); } catch (IOException e) {}
        }
    }

    private void writeXML(Document doc, String filename){
        BufferedWriter output = null;
        File f = new File(this.path+filename);
        try {
            if (!f.exists()) {
                f.createNewFile();
            }
            output = new BufferedWriter(new FileWriter(f));
            XMLOutputter xmlOut = new XMLOutputter(Format.getPrettyFormat().setEncoding(XML_ENCODING));
            xmlOut.output(doc, output);
            xmlOut.output(doc, System.out);
        } catch (IOException iOException) {
        }
    }

    private Document readXML(String filename){
        SAXBuilder builder = new SAXBuilder();
        Document locDoc = null;
        InputSource is;
        try {
            is = new InputSource(this.path+filename);
            is.setEncoding("ISO-8859-1");
            return builder.build(is);
        } catch (JDOMException jDOMException) {
        } catch (IOException iOException) {
        }
        return null;
    }

}

das zu serialisierende Objekt:

package unicodetest;

import java.io.Serializable;

/**
 *
 * @author Jens
 */

public class SerializableObject implements Serializable {

  private String aStringValue;
  private int aIntValue;
  private boolean aBooValue;

  public SerializableObject() {}

  public SerializableObject(String stringValue, int intValue, boolean booValue) {
    this.aStringValue = stringValue;
    this.aIntValue = intValue;
    this.aBooValue = booValue;
  }

  public String getAStringValue() {
    return this.aStringValue;
  }

  public void setAStringValue(String stringValue) {
    this.aStringValue = stringValue;
  }

  public int getAIntValue() {
    return this.aIntValue;
  }

  public void setAIntValue(int intValue) {
    this.aIntValue = intValue;
  }

  public boolean isABooValue() {
    return this.aBooValue;
  }

  public void setABooValue(boolean booValue) {
    this.aBooValue = booValue;
  }

    @Override
  public String toString(){
      return "String: "+ aStringValue + "\n" +
             "Integer: " + String.valueOf(aIntValue) + "\n" +
             "Boolean: " + String.valueOf(aBooValue);
  }
}

Es soll letztendlich folgende Ausgabe erscheinen:

String: äöüß
Integer: 100
Boolean: true
<?xml version="1.0" encoding="ISO-8859-1"?>
<test>äöüß</test>

String: äöüß
Integer: 100
Boolean: true
Deserialisiertes Objekt entspricht Ursprung: true
Wert aus XMLDatei entspricht dem Wert im deserialisierten Objekt: true

Momentan erscheint folgendes:

String: õ÷³▀
Integer: 100
Boolean: true
<?xml version="1.0" encoding="ISO-8859-1"?>
<test>õ÷³▀</test>

String: õ÷³▀
Integer: 100
Boolean: true
Deserialisiertes Objekt entspricht Ursprung: true
Wert aus XMLDatei entspricht dem Wert im deserialisierten Objekt: false

Ich habe es auch mit cp850 probiert, aber irgendwas tut's da nicht. Also ich habe immer noch das Problem, dass die XML Datei Zeichenenthält, die nicht mit dem Urpsung übereinstimmen.

Wenn ich das ganze mit 'UTF-8' ausführe kommt folgendes:

String: äöüß
Integer: 100
Boolean: true
<?xml version="1.0" encoding="UTF-8"?>
<test>äöüß</test>

String: äöüß
Integer: 100
Boolean: true
Deserialisiertes Objekt entspricht Ursprung: true
Wert aus XMLDatei entspricht dem Wert im deserialisierten Objekt: false

Im Debugging kommt für die letzte Zeile:

äöüß

und das ist natürlich nicht 'äöüß'

 

[Plumperquatsch]

Nun ja,

ich glaube ich bin einfach nur doof. Jetzt funktioniert es. Ich hatte wohl einman nicht kompiliert. Hm... Ich bekomme zwar im Debuggingfenster vom Netbeans immer noch Müll angezeigt, aber in der XML Dati landet es richtig, in der Konsole wird es jetzt korrekt dargestellt und offensichtlich im eigentlichen Programm auch.

Und das ganze mit 'cp850', Sorry, Stefan, dass ich zu blöd war Danke Dir!

Jens

 

[The_S]

Kein Problem. Sorry, dass ich jetzt erst antworte, ich war aber im Wochenende .