Base64 Codierung

[Airwolf89]

Hallo Leute,

ich habe hier ein kleines Problem.
Es geht darum, ich soll XMLs codieren.

Also, wir haben hier eine Klasse, die sieht so aus:

package Default;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.util.Map;
import sun.misc.*;

import com.sap.aii.mapping.api.StreamTransformation;

public class GenericToStringBase64 {

    private Map param = null;
    private String header = "<?xml version='1.0' encoding='UTF-8'?>";
    private String dummy_start = "<ns0:PayloadString xmlns:ns0='http://fresenius.de/XI/Global'>";
    private String dummy_end = "</ns0:PayloadString>";

    public void execute(InputStream in, OutputStream out) {

        try {
            String line = header + dummy_start;
            BufferedReader bufIn = new BufferedReader(new InputStreamReader(in));
            BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(out));
            bufOut.write(line, 0, line.length());

            line = encode(bufIn.readLine());
            while (line != null) {
                bufOut.write(line, 0, line.length());
                line = encode(bufIn.readLine());
            }
            line = dummy_end;
            bufOut.write(line);
            bufIn.close();
            bufOut.close();

        } catch (IOException e) {
        }
    }

    @SuppressWarnings("empty-statement")
    private String encode(String in) {

        BASE64Encoder encoder = new BASE64Encoder();
        String out = null;
        try {

            byte[] b = in.getBytes();
            out = encoder.encode(b);

        } catch (Exception e) {
        }

        return out;
    }
    
    public void setParameter(Map param) {

        this.param = param;

    }
}

Die gabs schon. Mit nem kleinen Testprogramm hatte ich damals das zeug was damit codiert wurde wieder decodiert, es hatte geklappt. In diesem Programm hatte ich mir die Datei geben lassen, sie durch nen Stringbuilder gejagt und dann decodiert.

Nun hab ich das teil wieder aufm Schreibtisch liegen. Das codierte zeugs kann von allen Base64 decodern im Internet nicht decodiert werden, kommt nur Murks raus.

Ja, hatte den Verdacht dass es an Steuerzeichen liegt. Also kleines testprogramm geschrieben welches die Klasse da oben nutzt. Das sieht dann so aus:

package SecondTry;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;


public class bla {

    public static void main(String[] args) throws FileNotFoundException, InstantiationException, IllegalAccessException, IOException {

        InputStream stream_in = null;
        InputStream stream_in_final = null;
        OutputStream stream_out = null;
        OutputStream stream_out_final = null;

        String line = "";

        File in = new File("D:/Daten/NetbeansProjects/GenericToStringBase64/src/SecondTry/input.xml");
        File out = new File("D:/Daten/NetbeansProjects/GenericToStringBase64/src/SecondTry/output.xml");

        stream_in = new FileInputStream(in);
        stream_out = new FileOutputStream(out);

        BufferedReader buffIn = new BufferedReader(new InputStreamReader(stream_in));
        BufferedWriter buffOut = new BufferedWriter(new OutputStreamWriter(stream_out));

        while (line != null) {
            line.replaceAll("[\\W\\s\\S]", "");
            buffOut.write(line, 0, line.length());
            line = buffIn.readLine();
        }

        File out_final = new File("D:/Daten/NetbeansProjects/GenericToStringBase64/src/SecondTry/output_final.xml");

        stream_in_final = new FileInputStream(out);
        stream_out_final = new FileOutputStream(out_final);

        GenericToStringBase64.class.newInstance().execute(stream_in_final, stream_out_final);

        stream_in.close();
        stream_out.close();
        stream_in_final.close();
        stream_out_final.close();

    }

}

Damit war das problem gelöst, hat funktioniert.

Nun musste ich, da ich im System nicht mit Dateien arbeiten kann mir was ausdenken um das Prinzip in die Klasse einzubauen.

Danach sah die Klasse dann so aus:

package SecondTry;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.misc.*;

import com.sap.aii.mapping.api.StreamTransformation;

public class GenericToStringBase64 implements StreamTransformation {

    private Map param = null;
    private String header = "<?xml version='1.0' encoding='UTF-8'?>";
    private String dummy_start = "<ns0:PayloadString xmlns:ns0='http://fresenius.de/XI/Global'>";
    private String dummy_end = "</ns0:PayloadString>";

    public void execute(InputStream in, OutputStream out) {

        try {
            String line = header + dummy_start;
            BufferedReader bufIn = new BufferedReader(new InputStreamReader(in));
            BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(out));
            bufOut.write(line, 0, line.length());

            line = bufIn.readLine();
            
            while (line != null) {

                if (line != null) {
                line.replaceAll("[\\W\\s\\S]", "");
                line = encode(line);
                }

                bufOut.write(line, 0, line.length());
                line = bufIn.readLine();
                
            }
            line = dummy_end;
            bufOut.write(line);
            bufIn.close();
            bufOut.close();
        } catch (IOException e) {
        }
    }

    private String encode(String in) {
        BASE64Encoder encoder = new BASE64Encoder();
        String out = null;
        try {
            byte[] b = in.getBytes();
            out = encoder.encode(b);
        } catch (Exception e) {
        }
        ;
        return out;

    }

    public void setParameter(Map param) {
        this.param = param;
    }
}

Ja, selbstverständlich funktioniert das nicht. Was mache ich falsch dabei? Ich krieg hier noch die Krise....

Ich hoffe ihr könnt mir helfen.

Danke im voraus.

 

[Jango]

Bündel dein Problem mal auf ein überschaubares Maß.
Dann stell eine ordendliche Frage.
Darauf antwortet dann vielleicht jemand.

 

[Airwolf89]

Ok, dann ganz klar, warum funktioniert das Programm, also die Klasse die ich zuletzt aufgeführt hab, nicht?

 

[Murray]

Etwas genauer dürfte es denn doch sein: was soll das Programm machen und was passiert stattdessen?

<OT1>sun.misc.*-Klassen sollte man eigentlich nicht nutzen</OT1>
<OT2>leere catch-Blöcke sind schlecht; wer sich auch noch die Mühe macht, per @SuppressWarnings den Compiler zum Schweigen zu bringen, der frisst bestimmt auch kleine Kinder</OT2>

 

[Airwolf89]

OK, also ich bekomme schon Base64 Code raus, das Problem ist wenn ich das decodieren will kommt nur Murks raus. Kann also nicht wieder korrekt decodiert werden.

Allerdings habe ich jetzt festgestellt, auf Eclipse funktioniert es korrekt, in Netbeans nicht. Wie kann denn das sein?

@OT1: Warum soll man diese Klassen nicht verwenden?
@OT2: In dem System wo es läuft ist das vollkommen unnötig, entweder funktionierts oder es knallt, von daher hab ichs so gemacht. Außerdem hab ich den Part nicht geschrieben, die war in seinen Grundzügen schon so vorhanden.

 

[Murray]

Allerdings habe ich jetzt festgestellt, auf Eclipse funktioniert es korrekt, in Netbeans nicht. Wie kann denn das sein?Grundzügen schon so vorhanden.

Dann müsste die Ausgabedatei ja anders sein, je nachdem, ob du das Programm in Eclipse oder in Netbeans laufen lässt. Hast du die Dateien schon mal verglichen?

Wie sieht denn der Code zum Decodieren aus?

Hat es einen tieferen Sinn, dass die Datei zeilenweise encoded wird?

@OT1: Warum soll man diese Klassen nicht verwenden?

Weil solche Klassen a) nicht in jeder Java-Umgebung vorhanden sind, sondern nur in denen von Sun und b) diese Klassen in neuen Releases ohne Ankündigung verändert werden oder auch ganz wegfallen könnten.

@OT2: In dem System wo es läuft ist das vollkommen unnötig, entweder funktionierts oder es knallt, von daher hab ichs so gemacht. Außerdem hab ich den Part nicht geschrieben, die war in seinen Grundzügen schon so vorhanden.

Es "knallt" eben nicht, sondern das Programm funktioniert einfach nicht. Sollte z.B. in deiner encode-Methode im try-catch-Block irgendeine Exception auftreten, so würde die betroffene Zeile einfach übersprungen, ohne dass es irgendeinen Hinweis gäbe.

 

[Airwolf89]

Die Ausgabedatei sieht in der Tat anders aus. In Eclipse wird ein schöner gleichbleibend breiter Block generiert. In Netbeans sind die zeilen unterschiedlich und teiweise elend lang.
Allerdings unterscheidet sich der Code selbst. In Netbeans wird ein anderer Code generiert als unter Eclipse.

Ja, das mit dem zeilwenweise einlesen. Welche Vorteile hätte es denn das zeug blockweise einzulesen? Habe schon irgendwie gehört dass man das Blockweise machen kann, wüsste jetzt aber auf Anhieb nicht was das für Vorteile haben sollte. Womit müsste ich denn arbeiten um das Blockweise einlesen zu können?

@OT1: Danke für die Info, das war mir nicht bewusst.

@OT2: So habe ich das ja auch gemeint. Es knallt nicht während der Verarbeitung, erst später gibt es Monitoring Programme die nach fehlern suchen und es uns anzeigen.
Das ist halt das Problem selbst wenn ich da die dollsten Dinger reinschreiben würde beim Exceptionhandling, das geht im System schlicht und einfach unter, wenn da tausende Meldungen von Exceptions kommen würden, wir würdens nicht mitkriegen.
Ist doof so, aber es gibt soweit wir wissen keine andere Möglichkeit.

 

[maki]

@OT2: So habe ich das ja auch gemeint. Es knallt nicht während der Verarbeitung, erst später gibt es Monitoring Programme die nach fehlern suchen und es uns anzeigen.
Das ist halt das Problem selbst wenn ich da die dollsten Dinger reinschreiben würde beim Exceptionhandling, das geht im System schlicht und einfach unter, wenn da tausende Meldungen von Exceptions kommen würden, wir würdens nicht mitkriegen.
Ist doof so, aber es gibt soweit wir wissen keine andere Möglichkeit.

Schon mal was von Logging gehört?

Brauchst gar nciht erst anfangen Fehler zu suchen mit solchen try/catch Konstrukten, verschlucken doch alle wichtigen Infos.