Interprétation des nouvelles fonctionnalités de Java8--Base64

Cet article présente principalement les informations pertinentes de la nouvelle fonctionnalité de Java8, Base64, en détail. Il a une certaine valeur de référence.

Le codage BASE64 est un caractère couramment utilisé. est utilisé dans de nombreux endroits. Mais base64 n’est pas un algorithme de chiffrement et de déchiffrement dans le domaine de la sécurité. L'effet de sécurité est très médiocre et il est facile de le déchiffrer. Sa fonction principale devrait être l'exactitude des données transmises. Certaines passerelles ou systèmes ne peuvent utiliser que des caractères ASCII. Base64 est une méthode utilisée pour convertir des données de caractères non ASCII en caractères ASCII, et base64 est particulièrement adapté à la transmission rapide de données sous les protocoles http et mime.

API pour l'implémentation de Base64 dans le JDK

Avant le JDK1.6, il n'y avait pas de classe d'implémentation Base64 pour les classes principales du JDK. Sun /Sun.misc.BASE64Encoder et sun.misc.BASE64Decoder dans Oracle JDK L'avantage de leur utilisation est qu'ils n'ont pas besoin de s'appuyer sur des bibliothèques de classes tierces. supprimé dans les versions futures (la compilation avec maven émettra un avertissement), et les performances ne sont pas bonnes, il y aura des tests de performances plus tard.

JDK1.6 a ajouté une autre implémentation Base64, javax.xml.bind.DatatypeConverter avec deux méthodes statiques parseBase64Binary et printBase64Binary, cachées dans le package javax.xml.bind Ci-dessous, non connu de nombreux développeurs.

Dans Java 8, l'API d'encodage et de décodage BASE64 est implémentée sous le package java.util, et les performances sont bonnes, et l'API est simple et facile à comprendre. Vous trouverez ci-dessous un exemple d'utilisation de. cette classe.

java.util.Base64

Cette classe fournit un ensemble de méthodes statiques pour obtenir les trois codecs BASE64 suivants :

1) Encodage de base : il s'agit d'un encodage BASE64 standard, utilisé pour gérer les besoins courants

// 编码
String asB64 = Base64.getEncoder().encodeToString("some string".getBytes("utf-8"));
System.out.println(asB64); // 输出为: c29tZSBzdHJpbmc=
// 解码
byte[] asBytes = Base64.getDecoder().decode("c29tZSBzdHJpbmc=");
System.out.println(new String(asBytes, "utf-8")); // 输出为: some string

2) Encodage d'URL : utiliser des traits de soulignement Remplacer la barre oblique inverse "/" dans l'URL

String urlEncoded = Base64.getUrlEncoder().encodeToString("subjects?abcd".getBytes("utf-8"));
System.out.println("Using URL Alphabet: " + urlEncoded);
// 输出为:
Using URL Alphabet: c3ViamVjdHM_YWJjZA==

3) Encodage MIME : utilise des caractères alphanumériques de base pour produire une sortie BASE64 et est compatible avec le format MIME : chaque La ligne de sortie ne doit pas dépasser 76 caractères et chaque ligne doit se terminer par le caractère « rn ».

StringBuilder sb = new StringBuilder();
for (int t = 0; t < 10; ++t) {
 sb.append(UUID.randomUUID().toString());
}
byte[] toEncode = sb.toString().getBytes("utf-8");
String mimeEncoded = Base64.getMimeEncoder().encodeToString(toEncode);
System.out.println(mimeEncoded);

Implémentation tierce de l'API Base64

Le premier est Apache couramment utilisé Commons Codec org.apache.commons.codec.binary.Base64 dans la bibliothèque ;
La deuxième est la méthode statique com.google.common.io.BaseEncoding.base64() dans la bibliothèque Google Guava ;
La troisième ; Le premier est net.iharder.Base64, ce package jar n'est qu'une classe
Le dernier est MigBase64, qui est connu comme la vitesse d'encodage Base64 la plus rapide, et il a été implémenté il y a 10 ans ; maintenez ce titre maintenant. Sachez

Test de performances d'encodage Base64

Ce qui précède mentionne un total de 7 façons d'implémenter l'encodage Base64, 3 dans Jdk et 4 chez des tiers, une fois que vous avez le choix, il faut les comparer. Les tests de performances sont le moyen le plus direct

Définissez d'abord deux interfaces
.

private static interface Base64Codec
  {
    public String encode(final byte[] data);
    public byte[] decode(final String base64) throws IOException;
  }
  private static interface Base64ByteCodec
  {
    public byte[] encodeBytes(final byte[] data);
    public byte[] decodeBytes(final byte[] base64) throws IOException;
  }

La différence entre les deux interfaces est que l'un des paramètres de la méthode d'interface reçoit un tableau d'octets et renvoie un tableau d'octets, car byte->byte est comparé à String->byte ou byte-> les performances de String seront plus rapides, alors séparez deux groupes pour les tests

private static final Base64Codec[] m_codecs = { new GuavaImpl(), new JavaXmlImpl(),
    new Java8Impl(), new SunImpl(), new ApacheImpl(),new MiGBase64Impl(),new IHarderImpl() };
private static final Base64ByteCodec[] m_byteCodecs = {
    new ApacheImpl(), new Java8Impl(),new MiGBase64Impl(),new IHarderImpl() };

Comme le montre le ci-dessus, il n'y a que 4 API qui prennent en charge byte->byte ;

7 classes d'implémentation Base64

private static class Java8Impl implements Base64Codec, Base64ByteCodec
  {
    private final Base64.Decoder m_decoder = Base64.getDecoder();
    private final Base64.Encoder m_encoder = Base64.getEncoder();
    @Override
    public String encode(byte[] data) {
      return m_encoder.encodeToString(data);
    }
    @Override
    public byte[] decode(String base64) throws IOException {
      return m_decoder.decode(base64);
    }
    public byte[] encodeBytes(byte[] data) {
      return m_encoder.encode( data );
    }
    public byte[] decodeBytes(byte[] base64) throws IOException {
      return m_decoder.decode( base64 );
    }
  }
  private static class JavaXmlImpl implements Base64Codec //no byte[] implementation
  {
    public String encode(byte[] data) {
      return DatatypeConverter.printBase64Binary( data );
    }
    public byte[] decode(String base64) throws IOException {
      return DatatypeConverter.parseBase64Binary( base64 );
    }
  }
..............

Les codes suivants sont essentiellement diverses API. Le code pour implémenter Base64 ne sera pas répertorié en détail.

La méthode de test principale consiste à générer 100 millions de nombres aléatoires, à les diviser en blocs de 100 octets ou 1 000 octets, puis à les encoder et à les décoder respectivement, et à enregistrer l'heure, comme suit

private static TestResult testByteCodec( final Base64ByteCodec codec, final List<byte[]> buffers ) throws IOException {
    final List<byte[]> encoded = new ArrayList<byte[]>( buffers.size() );
    final long start = System.currentTimeMillis();
    for ( final byte[] buf : buffers )
      encoded.add( codec.encodeBytes(buf) );
    final long encodeTime = System.currentTimeMillis() - start;
    final List<byte[]> result = new ArrayList<byte[]>( buffers.size() );
    final long start2 = System.currentTimeMillis();
    for ( final byte[] ar : encoded )
      result.add( codec.decodeBytes(ar) );
    final long decodeTime = System.currentTimeMillis() - start2;
    for ( int i = 0; i < buffers.size(); ++i )
    {
      if ( !Arrays.equals( buffers.get( i ), result.get( i ) ) )
        System.out.println( "Diff at pos = " + i );
    }
    return new TestResult( encodeTime / 1000.0, decodeTime / 1000.0 );
  }

Résultats des tests

Paramètres jvm : -Xms512m -Xmx4G

Tout est évident. D'après ce qui précède, on peut voir que les performances de sun ne sont pas très bonnes. Les performances d'IHarder et de MigBase64 sont acceptables. ce résultat de test, le nouveau java8 base64 fonctionne le plus rapidement. Eh bien, javaXml est le deuxième meilleur.

Résumé

Si vous avez besoin d'un codec Base64 performant et fiable, n'en cherchez pas en dehors du JDK, utilisez java dans java8 .util.Base64 et javax.xml.bind.DatatypeConverter, qui sont profondément cachés dans java6, sont tous deux de bons choix.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!