Créer des données binaires de longueur variable en Java

Cet article

Ceci est un mémo qui a fait un programme Java qui convertit les données de longueur variable (avec code de saut de ligne) en données de longueur variable avec champ de longueur (LL) (sans code de saut de ligne).

Auto-introduction

Je développe principalement des applications web Java (Spring Boot).

Livrables

Le code source et les fichiers d'entrée peuvent être trouvés sur GitHub.

Contexte

――J'étais en charge du développement d'outils de migration de données pour un projet de migration hérité dans lequel j'étais impliqué dans mon travail.

La source de migration est constituée des données de segment IMS (hiérarchique DB). --La destination de la migration est une colonne de type bytea de PostgreSQL «Il était difficile de créer des données de test avec un éditeur de texte, j'ai donc créé un programme.

Spécifications des données de test

--Fichier de données binaires de longueur variable avec champ de longueur (LL) 2 octets. ――Le contenu des données binaires peut être n'importe quoi.

Strictement parlant, les données provenant de l'IMS source sont une représentation binaire du code de caractère EBCDIC, mais le contenu des données n'est pas traité par texte dans l'outil de migration. «Donc, je ne suis pas particulier sur le contenu des données pour tester l'outil de migration. J'utiliserai le fichier texte UTF-8, qui est facile à gérer dans le traitement d'entrée de texte Java, comme matériau source.

Préparation du dossier matériel original

--Préparez un fichier texte de longueur variable UTF-8 comme matériau source.

input.txt ―― L'image est la suivante. --Premier enregistrement: 100 caractères (11111 ...) --Deuxième enregistrement: 200 caractères (22222 ...)
Troisième enregistrement: 300 caractères (33333 ...) ―― 4ème enregistrement: 400 caractères (44444 ...) ―― Cinquième enregistrement: 500 caractères (55555 ...)
Si vous regardez le contenu de input.txt avec l'éditeur binaire mac "Hex Fiend", vous pouvez voir qu'il y a un code de saut de ligne LF (0x0A) à la fin de l'enregistrement.

Explication du code source

`EditBinary.java`


//Abréviation
    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();
//Abréviation

(1) Utilisez BufferedReader pour le flux d'entrée et BufferedOutputStream pour le flux de sortie.
Traitez le fichier d'entrée en tant que données texte et le fichier de sortie en tant que données binaires.
(2) Lire un enregistrement à la fois avec BufferedReader (readLine).
(3) Conservez la taille d'enregistrement lue par readLine dans le champ de longueur LL en tant que données d'octet. --LL n'inclura pas votre propre taille (2 octets) --recSize est de type int (4 octets) et ne tient pas dans LL (2 octets), donc transtypez-le en type court (2 octets)
(4) Contient les données d'enregistrement lues par readLine comme données UTF-8 octets.
(5) Réservez une zone avec ByteBuffer pour combiner LL et enregistrer les données en un seul enregistrement, et définir LL et enregistrer les données.
(6) Sortie du tableau binaire de LL et enregistrement des données dans un fichier.

Compiler et exécuter

La compilation et l'exécution sont simples.

--Compiler

javac EditBinary.java

--Exécuter

java EditBinary

Résultat d'exécution

Jetons un œil au contenu de output.txt avec "Hex Fiend". Le code de saut de ligne à la fin de chaque enregistrement a été supprimé et remplacé par un LL au début. Vous pouvez voir que la valeur de LL est la suivante. Le nombre entre parenthèses est le nombre d'octets décimaux, c'est-à-dire la longueur de l'enregistrement.

--Premier enregistrement LL: 0x0064 (100) --Deuxième enregistrement LL: 0x00C8 (200)

Troisième enregistrement LL: 0x012C (300) ―― 4ème enregistrement LL: 0x0190 (400) ―― 5ème enregistrement LL: 0x01F4 (500)

Ainsi, j'ai pu créer des données binaires de longueur variable avec LL.

prime

Code de saut de ligne comme délimiteur

Je ne pense pas qu'il existe de nombreux cas où un code de saut de ligne est utilisé comme délimiteur pour les données binaires (je ne l'ai pas non plus utilisé dans cet article), mais si vous le faites, vous devez faire attention car la représentation binaire peut changer en fonction de l'environnement. C'est une histoire.

Le code de saut de ligne est CRLF pour Win et LF pour Unix / Linux. --La représentation binaire (hexadécimale) de CRLF est (0x0D 0x0A) --La représentation binaire (hexagonale) de LF est (0x0A) ――Il semble que ce soit 2 octets ou 4 octets selon le code de caractère