Comment Java implémente-t-il l'encodage et le décodage Base64 ? Implémenter 4 méthodes d'encodage et de décodage Base64

Le contenu de cet article est de présenter comment implémenter l'encodage et le décodage Base64 en Java ? Implémentez 4 méthodes d’encodage et de décodage Base64. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Pourquoi utiliser l'encodage Base64 ?

Les données sont transmises sur le réseau en utilisant l'ascii. Pour certaines images, vidéos et autres données, elles peuvent être codées dans la partie invisible du code ASCII. Différents périphériques de routage du réseau les traitent différemment et cette partie des données peut être perdue. Afin de garantir l'exactitude de la transmission des données, le codage Base64 peut être utilisé pour coder ces données invisibles en données visibles.

Plusieurs façons d'implémenter l'encodage et le décodage Base64 en Java

Méthode 1

Utilisez les classes BASE64Encoder et BASE64Decoder dans le package sun.misc pour l'encodage et décodage. Cette méthode est relativement ancienne et n’est pas recommandée.

Le code est le suivant :

  /**
   * sun.misc方式Base64编码
   * @param str
   * @return
   */
  public static String encodeBySunMisc(String str) {    
     try {      
         return new BASE64Encoder().encode(str.getBytes("UTF-8"));
    } 
    catch (UnsupportedEncodingException e) {
      e.printStackTrace();      
      return "";
    }
  }  
  /**
   * sun.misc方式Base64解码
   * @param str
   * @return
   */
  public static String decodeBySunMisc(String str) {    
     try {      
         byte[] result = new BASE64Decoder().decodeBuffer(str);      
         return new String(result);
    } 
    catch (IOException e) {
      e.printStackTrace();     
      return "";
    }
  }

Bien que l'outil Base64 de sun.misc soit dans le jdk, il n'appartient pas à la bibliothèque standard, il ne peut donc pas être utilisé directement dans Éclipse. Il peut être utilisé par introduction manuelle.

Solution :

Cliquez avec le bouton droit sur le projet->Propriétés->Chemin de construction Java->Bibliothèques, cliquez sur Ajouter des fichiers JAR externes et sélectionnez %JAVA_HOME%jrelibrt.jar.

Méthode 2

Utilisez le package commons-code d'Apache. Cette méthode est légèrement plus rapide que la méthode sun.misc.

Le code est le suivant

  /**
   * commons-code方式Base64编码
   * @param str
   * @return
   */
  public static String encodeByCommonsCode(String str) {    
      byte[] result;    
      try {
      result = org.apache.commons.codec.binary.Base64.encodeBase64(str.getBytes("UTF-8"));      
      return new String(result);
    } 
    catch (UnsupportedEncodingException e) {
      e.printStackTrace();      
      return "";
    }
  }  
  /**
   * commons-code方式Base64解码
   * @param str
   * @return
   */
  public static String decodeByCommonsCode(String str) {    
      byte[] result = org.apache.commons.codec.binary.Base64.decodeBase64(str.getBytes());    
      return new String(result);
  }

L'utilisation du code commons nécessite l'introduction de dépendances. En prenant le projet gradle comme exemple, vous devez ajouter les lignes suivantes à build.gradle :

implementation 'commons-codec:commons-codec:1.11'

Méthode 3

Utilisez l'outil xerces d'Apache. Cet outil est principalement utilisé pour analyser du XML et possède des fonctions d’encodage et de décodage Base64.

Le code est le suivant :

  /**
   * xerces方式Base64解码
   * @param str
   * @return
   */
  public static String decodeByXerces(String str) {    
     try {      
         byte[] result = com.sun.org.apache.xerces.internal.impl.dv.util.Base64.decode(str);      
         return new String(result);
    } 
    catch (Exception e) {
      e.printStackTrace();      return "";
    }
  }  
  /**
   * Java8中的Base64编码
   * @param str
   * @return
   */
  public static String encodeByJava8(String str) {    
      try {      
         return Base64.getEncoder().encodeToString(str.getBytes("UTF-8"));
    } 
    catch (Exception e) {
      e.printStackTrace();      
      return "";
    }
  }

Méthode 4

La suite d'utilitaires Java8 est déjà livrée avec des outils d'encodage et de décodage Base64, et elle est très efficace. Cette méthode est recommandée.

Le code est le suivant :

  /**
   * Java8中的Base64编码
   * @param str
   * @return
   */
  public static String encodeByJava8(String str) {    
      try {      
         return Base64.getEncoder().encodeToString(str.getBytes("UTF-8"));
    } 
    catch (Exception e) {
      e.printStackTrace();      
      return "";
    }
  }  
  /**
   * Java8中的Base64解码
   * @param str
   * @return
   */
  public static String decodeByJava8(String str) {    
       byte[] result = Base64.getDecoder().decode(str.getBytes());    
       return new String(result);
  }

Tester plusieurs effets d'encodage :

Le code du test est le suivant :

  private static void testEncodeAndDecode(String src) {
    String encedeStr1 = encodeBySunMisc(src);
    System.out.println("encode by sun misc: " + encedeStr1);
    
    String decedeStr1 = decodeBySunMisc(encedeStr1);
    System.out.println("decode by sun misc: " + decedeStr1);
    
    
    String encedeStr2 = encodeByCommonsCode(src);
    System.out.println("encode by commons-code: " + encedeStr2);
    
    String decedeStr2 = decodeByCommonsCode(encedeStr2);
    System.out.println("decode by commons-code: " + decedeStr2);

    
    String encedeStr3 = encodeByXerces(src);
    System.out.println("encode by xerces: " + encedeStr3);
    
    String decodeStr3 = decodeByXerces(encedeStr3);
    System.out.println("decode by xerces: " + decodeStr3);

    
    String encedeStr4 = encodeByJava8(src);
    System.out.println("encode by java8: " + encedeStr4);
    
    String decedeStr4 = decodeByJava8(encedeStr4);
    System.out.println("decode by java8: " + decedeStr4);
  }

Le test les résultats sont les suivants :

encode by sun misc: YWJjZGVmZ2hpamtsbW5vcHFyc3Q7
decode by sun misc: abcdefghijklmnopqrst;
encode by commons-code: YWJjZGVmZ2hpamtsbW5vcHFyc3Q7
decode by commons-code: abcdefghijklmnopqrst;
encode by xerces: YWJjZGVmZ2hpamtsbW5vcHFyc3Q7
decode by xerces: abcdefghijklmnopqrst;
encode by java8: YWJjZGVmZ2hpamtsbW5vcHFyc3Q7
decode by java8: abcdefghijklmnopqrst;

Comparez l'efficacité de plusieurs codecs. Utilisez plus de 20 caractères pour chaque méthode de codage pour encoder puis décoder. Il est exécuté au total 1 million de fois. Comparez le temps d'exécution total.

Le code du test est le suivant :

  // 测试sun.misc编解码效率
  private static void testSunMisc(String src) {    
     long begin = System.currentTimeMillis();    
     for(int i = 0; i < 1000000; i++) {
      String encedeStr1 = encodeBySunMisc(src + i);
      decodeBySunMisc(encedeStr1);
    }    long finish = System.currentTimeMillis();
    System.out.println("sun misc consume: " + (finish - begin) + "ms");
  }  
  // 测试commons-code编解码效率
  private static void testCommonsCode(String src) {    
     long begin = System.currentTimeMillis();    
     for(int i = 0; i < 1000000; i++) {
      String encedeStr1 = encodeByCommonsCode(src + i);
      decodeByCommonsCode(encedeStr1);
    }    long finish = System.currentTimeMillis();
    System.out.println("commons-code consume: " + (finish - begin) + "ms");
  }  
  // 测试xerces编解码效率
  private static void testXerces(String src) {    
      long begin = System.currentTimeMillis();    
      for(int i = 0; i < 1000000; i++) {
      String encedeStr1 = encodeByXerces(src + i);
      decodeByXerces(encedeStr1);
    }    long finish = System.currentTimeMillis();
    System.out.println("xerces consume: " + (finish - begin) + "ms");
  }  
  // 测试Java8编解码效率
  private static void testJava8(String src) {    
     long begin = System.currentTimeMillis();    
     for(int i = 0; i < 1000000; i++) {
      String encedeStr1 = encodeByJava8(src + i);
      decodeByJava8(encedeStr1);
    }    
    long finish = System.currentTimeMillis();
    System.out.println("java 8 consume: " + (finish - begin) + "ms");
  }
  public static void main(String[] args) {
    String src = "abcdefghijklmnopqrst;";

    testSunMisc(src);
    testCommonsCode(src);
    testXerces(src);
    testJava8(src);
  }

Un total de 3 tests ont été effectués et les résultats de sortie sont les suivants :

commons-code consume: 3337ms
sun misc consume: 6532ms
xerces consume: 554ms
java 8 consume: 547ms

commons-code consume: 3148ms
sun misc consume: 6445ms
xerces consume: 498ms
java 8 consume: 466ms

commons-code consume: 3442ms
sun misc consume: 6674ms
xerces consume: 470ms
java 8 consume: 512ms

Conclusion

L'ancienne méthode sun.misc est la moins efficace, tandis que les méthodes xerces et Java8 sont les plus efficaces. En raison de la commodité de Java8, il est recommandé d'utiliser directement l'outil Base64 fourni avec Java8 pour l'encodage et le décodage.

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!