Erstellen Sie Binärdaten variabler Länge in Java

Dieser Beitrag

Dies ist ein Memo, das ein Java-Programm erstellt hat, das Daten variabler Länge (mit Zeilenvorschubcode) in Daten variabler Länge mit Längenfeld (LL) (ohne Zeilenvorschubcode) konvertiert.

Vorstellen

Ich entwickle hauptsächlich Java-Webanwendungen (Spring Boot).

Ergebnisse

Der Quellcode und die Eingabedateien finden Sie unter GitHub.

Hintergrund

――Ich war für die Entwicklung des Datenmigrations-Tools für ein Legacy-Migrationsprojekt verantwortlich, an dem ich an meiner Arbeit beteiligt war.

Die Migrationsquelle sind IMS-Segmentdaten (hierarchische DB).
Das Migrationsziel ist eine Spalte vom Typ Bytea von PostgreSQL ――Das Erstellen von Testdaten mit einem Texteditor war schwierig, daher habe ich ein Programm erstellt.

Testdaten Spezifikationen

Binärdatendatei variabler Länge mit einem Längenfeld (LL) von 2 Bytes. ――Der Inhalt der Binärdaten kann beliebig sein.
Genau genommen sind die vom Quell-IMS stammenden Daten eine binäre Darstellung des Zeichencodes EBCDIC, aber der Inhalt der Daten wird im Migrationstool nicht in Textform verarbeitet. ――So bin ich nicht besonders über den Inhalt der Daten zum Testen des Migrationstools. Ich werde die UTF-8-Textdatei, die in der Java-Texteingabeverarbeitung einfach zu handhaben ist, als Quellmaterial verwenden.

Vorbereitung der Originalmaterialdatei

Bereiten Sie eine UTF-8-Textdatei mit variabler Länge als Quellmaterial vor.
input.txt ――Das Bild sieht wie folgt aus.
Erster Datensatz: 100 Zeichen (11111 ...)
Zweiter Datensatz: 200 Zeichen (22222 ...)
Dritter Datensatz: 300 Zeichen (33333 ...) ―― 4. Datensatz: 400 Zeichen (44444 ...) ――Fünfter Datensatz: 500 Zeichen (55555 ...)
Wenn Sie den Inhalt von input.txt mit dem Mac-Binäreditor "Hex Fiend" betrachten, sehen Sie, dass sich am Ende des Datensatzes ein Zeilenvorschubcode LF (0x0A) befindet.

Erklärung des Quellcodes

`EditBinary.java`


//Abkürzung
    public static void main(String[] args) {
        // (1)
        BufferedReader br = null;
        BufferedOutputStream bos = null;
        int LLSIZE = 2; 

        try {
            br = new BufferedReader(new FileReader("input.txt"));
            bos = new BufferedOutputStream(new FileOutputStream("output.txt"));
            String line = null；
            // (2)
            while ((line = br.readLine()) != null) {
                int recSize = line.length()；
                // (3)
                byte ll[] = ByteBuffer.allocate(LLSIZE).putShort((short)recSize).array();
                // (4)
                byte data[] = ByteBuffer.allocate(recSize).put(line.getBytes("UTF-8")).array();
                // (5)
                ByteBuffer lineBuf = ByteBuffer.allocate(LLSIZE + recSize);
                lineBuf.put(ll);
                lineBuf.put(data);
                // (6)
                bos.write(lineBuf.array());
            }
            bos.flush();
//Abkürzung

(1) Verwenden Sie BufferedReader für den Eingabestream und BufferedOutputStream für den Ausgabestream.
Verarbeiten Sie die Eingabedatei als Textdaten und die Ausgabedatei als Binärdaten.
(2) Lesen Sie jeweils einen Datensatz mit BufferedReader (readLine).
(3) Halten Sie die von readLine gelesene Datensatzgröße im Längenfeld LL als Byte-Daten. --LL enthält keine eigene Größe (2 Byte) --recSize ist vom Typ int (4 Byte) und passt nicht in LL (2 Byte). Verwandeln Sie es daher in einen kurzen Typ (2 Byte).
(4) Enthält die von readLine gelesenen Datensatzdaten als UTF-8-Byte-Daten.
(5) Reservieren Sie einen Bereich mit ByteBuffer, um LL- und Datensatzdaten in einem Datensatz zu kombinieren und LL- und Datensatzdaten festzulegen.
(6) Geben Sie das binäre Array von LL aus und zeichnen Sie Daten in eine Datei auf.

Kompilieren und ausführen

Das Kompilieren und Ausführen ist einfach.

--Kompilieren

javac EditBinary.java

--Ausführen

java EditBinary

Ausführungsergebnis

Werfen wir einen Blick auf den Inhalt von output.txt mit "Hex Fiend". Der Zeilenvorschubcode am Ende jedes Datensatzes wurde entfernt und am Anfang durch einen LL ersetzt. Sie können sehen, dass der Wert von LL wie folgt ist. Die Zahl in Klammern ist die Anzahl der Dezimalbytes, dh die Datensatzlänge.

Erster Datensatz LL: 0x0064 (100)
Zweiter Datensatz LL: 0x00C8 (200)
Dritter Datensatz LL: 0x012C (300) ―― 4. Datensatz LL: 0x0190 (400) ―― 5. Aufzeichnung LL: 0x01F4 (500)

So konnte ich mit LL Binärdaten variabler Länge erstellen.

Bonus

Zeilenvorschubcode als Trennzeichen

――Ich glaube nicht, dass es viele Fälle gibt, in denen ein Zeilenvorschubcode als Trennzeichen für Binärdaten verwendet wird (ich habe ihn auch in diesem Artikel nicht verwendet), aber wenn Sie dies tun, müssen Sie vorsichtig sein, da sich die Binärdarstellung je nach Umgebung ändern kann. Es ist eine Geschichte.

Der Zeilenvorschubcode lautet CRLF für Win und LF für Unix / Linux. --CRLFs binäre (hexäre) Darstellung ist (0x0D 0x0A)
Die binäre (hexare) Darstellung von LF ist (0x0A) ――Es scheint, dass es je nach Zeichencode 2 Bytes oder 4 Bytes sind