type - string to base64 java android




Codificação Base64 em Java (11)

Eu estou usando o Eclipse. Eu tenho a seguinte linha de código:

wr.write(new sun.misc.BASE64Encoder().encode(buf));

O Eclipse marca esta linha como um erro. Eu importei as bibliotecas necessárias:

import sun.misc.BASE64Encoder;
import sun.misc.BASE64Decoder;

Mas, novamente, ambos são mostrados como erros. Eu encontrei um post semelhante aqui .

Eu usei o Apache Commons como a solução sugerida, incluindo:

import org.apache.commons.*;

e importando os arquivos JAR baixados de: http://commons.apache.org/codec/

Mas o problema ainda existe. O Eclipse ainda mostra os erros mencionados anteriormente; Por favor informar.


Aqui estão meus dois centavos ... O Java 8 contém sua própria implementação do Base64 . No entanto, encontrei uma diferença ligeiramente perturbadora. Para ilustrar, vou fornecer um exemplo de código:

Meu wrapper CODEC:

public interface MyCodec
{
  static String apacheDecode(String encodedStr)
  {
     return new String(Base64.decodeBase64(encodedStr), Charset.forName("UTF-8"));
  }

  static String apacheEncode(String decodedStr)
  {
      byte[] decodedByteArr = decodedStr.getBytes(Charset.forName("UTF-8"));
      return Base64.encodeBase64String(decodedByteArr);
  }

  static String javaDecode(String encodedStr)
  {
      return new String(java.util.Base64.getDecoder().decode(encodedStr), Charset.forName("UTF-8"));
  }

  static String javaEncode(String decodedStr)
  {
    byte[] decodedByteArr = decodedStr.getBytes(Charset.forName("UTF-8"));
    return java.util.Base64.getEncoder().encodeToString(decodedByteArr);
  }
}

Classe de Teste:

public class CodecDemo
{
  public static void main(String[] args)
  {
    String decodedText = "Hello World!";

    String encodedApacheText = MyCodec.apacheEncode(decodedText);
    String encodedJavaText = MyCodec.javaEncode(decodedText);

    System.out.println("Apache encoded text: " + MyCodec.apacheEncode(encodedApacheText));
    System.out.println("Java encoded text: " + MyCodec.javaEncode(encodedJavaText));

    System.out.println("Encoded results equal: " + encodedApacheText.equals(encodedJavaText));

    System.out.println("Apache decode Java: " + MyCodec.apacheDecode(encodedJavaText));
    System.out.println("Java decode Java: " + MyCodec.javaDecode(encodedJavaText));

    System.out.println("Apache decode Apache: " + MyCodec.apacheDecode(encodedApacheText));
    System.out.println("Java decode Apache: " + MyCodec.javaDecode(encodedApacheText));
  }
}

SAÍDA:

Apache encoded text: U0dWc2JHOGdWMjl5YkdRaA0K

Java encoded text: U0dWc2JHOGdWMjl5YkdRaA==
Encoded results equal: false
Apache decode Java: Hello World!
Java decode Java: Hello World!
Apache decode Apache: Hello World!
Exception in thread "main" java.lang.IllegalArgumentException: Illegal base64 character d
    at java.util.Base64$Decoder.decode0(Base64.java:714)
    at java.util.Base64$Decoder.decode(Base64.java:526)
    at java.util.Base64$Decoder.decode(Base64.java:549)

Observe que o texto codificado pelo Apache contém quebras de linha adicionais (espaços em branco) no final. Portanto, para meu CODEC produzir o mesmo resultado, independentemente da implementação de Base64, tive que chamar trim() no texto codificado do Apache. No meu caso, eu simplesmente adicionei a chamada de método acima mencionada ao apacheDecode() do meu CODEC da seguinte forma:

return Base64.encodeBase64String(decodedByteArr).trim();

Depois que essa alteração foi feita, os resultados são o que eu esperava começar:

Apache encoded text: U0dWc2JHOGdWMjl5YkdRaA==
Java encoded text: U0dWc2JHOGdWMjl5YkdRaA==
Encoded results equal: true
Apache decode Java: Hello World!
Java decode Java: Hello World!
Apache decode Apache: Hello World!
Java decode Apache: Hello World!

Talvez alguém possa comentar por que isso acontece, mas encontrei minha solução alternativa como um compromisso aceitável.


Eu tentei com o seguinte trecho de código. Funcionou bem. :-)

com.sun.org.apache.xml.internal.security.utils.Base64.encode("The string to encode goes here");

No Android, use os métodos estáticos da classe de utilitários android.util.Base64 . A documentação referenciada diz que a classe Base64 foi adicionada no nível 8 da API (Froyo).

import android.util.Base64;

byte[] encodedBytes = Base64.encode("Test".getBytes());
Log.d("tag", "encodedBytes " + new String(encodedBytes));

byte[] decodedBytes = Base64.decode(encodedBytes);
Log.d("tag", "decodedBytes " + new String(decodedBytes));

No Java 7 eu codifiquei esse método

import javax.xml.bind.DatatypeConverter;

public static String toBase64(String data) {
    return DatatypeConverter.printBase64Binary(data.getBytes());
}

O Eclipse fornece um erro / aviso porque você está tentando usar classes internas que são específicas de um fornecedor de JDK e não fazem parte da API pública. O Jakarta Commons fornece sua própria implementação de codecs base64, que naturalmente residem em um pacote diferente. Exclua essas importações e deixe o Eclipse importar as classes apropriadas do Commons para você.


O apache commons tem uma boa implementação de base64. você pode fazer isso tão simples quanto

// encrypt data on your side using BASE64
byte[]   bytesEncoded = Base64.encodeBase64(str .getBytes());
System.out.println("ecncoded value is " + new String(bytesEncoded ));

// Decrypt data on other side, by processing encoded data
byte[] valueDecoded= Base64.decodeBase64(bytesEncoded );
System.out.println("Decoded value is " + new String(valueDecoded));

você pode encontrar mais detalhes sobre codificação de base64 em http://faisalbhagat.blogspot.com/2014/06/base64-encoding-using-java-and.html




Use a classe "nunca é tarde demais para entrar na diversão" do Java 8: java.util.Base64


Você precisa alterar a importação da sua classe:

import org.apache.commons.codec.binary.Base64;

E então mude sua classe para usar a classe Base64.

Aqui está um código de exemplo:

byte[] encodedBytes = Base64.encodeBase64("Test".getBytes());
System.out.println("encodedBytes " + new String(encodedBytes));
byte[] decodedBytes = Base64.decodeBase64(encodedBytes);
System.out.println("decodedBytes " + new String(decodedBytes));

Então leia oracle.com/technetwork/java/faq-sun-packages-142232.html .

Atualização (16/12/2016)

Você pode agora java.util.Base64 com Java8. Primeiro, importe-o como você faz normalmente:

import java.util.Base64;

Em seguida, use os métodos estáticos Base64 da seguinte maneira:

byte[] encodedBytes = Base64.getEncoder().encode("Test".getBytes());
System.out.println("encodedBytes " + new String(encodedBytes));
byte[] decodedBytes = Base64.getDecoder().decode(encodedBytes);
System.out.println("decodedBytes " + new String(decodedBytes));

Se você quiser codificar diretamente a string e obter o resultado como uma string codificada, poderá usá-la.

String encodeBytes = Base64.getEncoder().encodeToString((userName + password).getBytes());

Veja Javadocs for Base64 para mais: https://docs.oracle.com/javase/8/docs/api/java/util/Base64.html


O Google Guava é uma boa opção para codificar e decodificar dados base64:

Configuração do POM:

<dependency>
   <artifactId>guava</artifactId>
   <groupId>com.google.guava</groupId>
   <type>jar</type>
   <version>14.0.1</version>
</dependency>

Código de amostra:

String inputContent = "Hello Việt Nam";
String base64String = BaseEncoding.base64().encode(inputContent.getBytes("UTF-8"));
//decode
System.out.println("Base64:" + base64String);//SGVsbG8gVmnhu4d0IE5hbQ==
byte[] contentInBytes = BaseEncoding.base64().decode(base64String);
System.out.println("Source content: " + new String(contentInBytes, "UTF-8"));//Hello Việt Nam




base64