La migration du soleil.misc.BASE64 to Java 8 java.util.Base64

il n'y a aucun changement à la spécification base64 entre rfc1521 et rfc2045.

toutes les implémentations de base64 peuvent être considérées comme des remplacements directs les unes des autres, les seules différences entre les implémentations de base64 sont:

1. l'alphabet utilisé.
2. les API fournies (par exemple, certaines ne peuvent agir que sur un tampon d'entrée complet, tandis que d'autres peuvent être des machines à états finis vous permettant de continuer à pousser des morceaux d'entrée à travers eux jusqu'à ce que vous avez terminé).

l'alphabet MIME base64 est resté constant entre les versions RFC (il a ou des logiciels plus anciens de casser) et est: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/

Wikipédia notes, seuls les 2 derniers caractères peuvent changer entre base64 implémentations.

comme exemple d'une implémentation de base64 qui changer les 2 derniers caractères, le IMAP MUTF-7 la spécification utilise ce qui suit: base64 alphabet:ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+,

La raison de ce changement est que l' / le caractère est souvent utilisé comme délimiteur de chemin et comme L'encodage MUTF-7 est utilisé pour aplatir les chemins de répertoire non-ASCII en ASCII, le / le caractère doit être évité dans les segments encodés.

en supposant que les deux encodeurs sont libres de bogues, alors la RFC requiert des encodages distincts pour chaque séquence de 0 octet, 1 octet, 2 octets et 3 octets. Les séquences plus longues sont divisées en autant de séquences de 3 octets que nécessaire, suivies d'une séquence finale. Par conséquent, si les deux implémentations gèrent toutes 16,843,009 (1+256+65536+16777216) les séquences possibles correctement, puis les deux implémentations sont également identiques.

ces tests ne prennent que quelques minutes. En modifiant légèrement votre test code, je l'ai fait et mon installation Java 8 a passé tous les tests. Par conséquent, la mise en œuvre publique peut être utilisée pour remplacer le soleil en toute sécurité.divers mise en œuvre.

Voici mon code de test:

import java.util.Base64;
import java.util.Arrays;
import java.io.IOException;

public class Base64EncodingDecodingRoundTripTest {

    public static void main(String[] args) throws IOException {
        System.out.println("Testing zero byte encoding");
        encodeDecode(new byte[0]);

        System.out.println("Testing single byte encodings");
        byte[] test = new byte[1];
        for(int i=0;i<256;i++) {
            test[0] = (byte) i;
            encodeDecode(test);
        }
        System.out.println("Testing double byte encodings");
        test = new byte[2];
        for(int i=0;i<65536;i++) {
            test[0] = (byte) i;
            test[1] = (byte) (i >>> 8);
            encodeDecode(test);
        }
        System.out.println("Testing triple byte encodings");
        test = new byte[3];
        for(int i=0;i<16777216;i++) {
            test[0] = (byte) i;
            test[1] = (byte) (i >>> 8);
            test[2] = (byte) (i >>> 16);
            encodeDecode(test);
        }
        System.out.println("All tests passed");
    }

    static void encodeDecode(final byte[] testInput) throws IOException {
        sun.misc.BASE64Encoder unsupportedEncoder = new sun.misc.BASE64Encoder();
        sun.misc.BASE64Decoder unsupportedDecoder = new sun.misc.BASE64Decoder();

        Base64.Encoder mimeEncoder = java.util.Base64.getMimeEncoder();
        Base64.Decoder mimeDecoder = java.util.Base64.getMimeDecoder();

        String sunEncoded = unsupportedEncoder.encode(testInput);
        String mimeEncoded = mimeEncoder.encodeToString(testInput);

        // check encodings equal
        if( ! sunEncoded.equals(mimeEncoded) ) {
            throw new IOException("Input "+Arrays.toString(testInput)+" produced different encodings (sun=\""+sunEncoded+"\", mime=\""+mimeEncoded+"\")");
        }

        // Check cross decodes are equal. Note encoded forms are identical
        byte[] mimeDecoded = mimeDecoder.decode(sunEncoded);
        byte[] sunDecoded = unsupportedDecoder.decodeBuffer(mimeEncoded); // throws IOException
        if(! Arrays.equals(mimeDecoded,sunDecoded) ) {
            throw new IOException("Input "+Arrays.toString(testInput)+" was encoded as \""+sunEncoded+"\", but decoded as sun="+Arrays.toString(sunDecoded)+" and mime="+Arrays.toString(mimeDecoded));
        }

    }
}