getbytes java base64

getbytes - java 8 base64



Codificación Base64 en Java (16)

Aquí están mis dos centavos ... Java 8 contiene su propia implementación de Base64 . Sin embargo, encontré una diferencia ligeramente inquietante. Para ilustrar, daré un ejemplo de código:

Mi envoltorio 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); } }

Clase de prueba:

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)); } }

SALIDA:

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 el texto codificado de Apache contiene saltos de línea adicionales (espacios en blanco) al final. Por lo tanto, para que mi CODEC produzca el mismo resultado independientemente de la implementación de Base64, tuve que llamar a trim() en el texto codificado de Apache. En mi caso, simplemente agregué la llamada al método antes mencionado al apacheDecode() mi CODEC de la siguiente manera:

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

Una vez que se realizó este cambio, los resultados son los que esperaba comenzar:

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!

Tal vez alguien podría comentar por qué esto es así, pero encontré mi solución como un compromiso aceptable.

Estoy usando Eclipse. Tengo la siguiente línea de código:

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

Eclipse marca esta línea como un error. He importado las bibliotecas requeridas:

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

Pero de nuevo, ambos se muestran como errores. Encontré un post similar aquí .

Usé Apache Commons como la solución sugerida al incluir:

import org.apache.commons.*;

e importar los archivos JAR descargados desde: http://commons.apache.org/codec/

Pero el problema sigue existiendo. Eclipse sigue mostrando los errores mencionados anteriormente; por favor avise.

Eclipse le da un error / advertencia porque está tratando de usar clases internas que son específicas de un proveedor de JDK y no son parte de la API pública. Jakarta Commons proporciona su propia implementación de codecs base64, que por supuesto residen en un paquete diferente. Borre esas importaciones y deje que Eclipse importe las clases de Commons adecuadas para usted.

Ejemplo simple con Java 8:

import java.util.Base64; String str = "your string"; String encodedStr = Base64.getEncoder().encodeToString(str.getBytes("utf-8"));

En Android, use los métodos estáticos de la clase de utilidad android.util.Base64 . La documentación a la que se hace referencia dice que la clase Base64 se agregó en el nivel 8 de 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));

En Java 7 codifiqué este método.

import javax.xml.bind.DatatypeConverter; public static String toBase64(String data) { return DatatypeConverter.printBase64Binary(data.getBytes()); }

En Java 8 se puede hacer como

Base64.getEncoder().encodeToString(string.getBytes(StandardCharsets.UTF_8))

Aquí hay un breve ejemplo completo, autónomo

import java.nio.charset.StandardCharsets; import java.util.Base64; public class Temp { public static void main(String... args) throws Exception { final String s = "old crow medicine show"; final byte[] authBytes = s.getBytes(StandardCharsets.UTF_8); final String encoded = Base64.getEncoder().encodeToString(authBytes); System.out.println(s + " => " + encoded); } }

da salida

old crow medicine show => b2xkIGNyb3cgbWVkaWNpbmUgc2hvdw==

Lo intenté con el siguiente fragmento de código. Funciono bien :-)

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

Necesitas cambiar la importación de tu clase:

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

Y luego cambia tu clase para usar la clase Base64.

Aquí hay un código de ejemplo:

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));

Luego lee oracle.com/technetwork/java/faq-sun-packages-142232.html .

Actualización (16/12/2016)

Ahora puedes java.util.Base64 con Java8. Primero, importa como lo haces normalmente:

import java.util.Base64;

Luego use los métodos estáticos Base64 de la siguiente manera:

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));

Consulte Javadocs para Base64 para obtener más información: https://docs.oracle.com/javase/8/docs/api/java/util/Base64.html

Para convertir esto, necesita el codificador y el decodificador que obtendrá de http://www.source-code.biz/base64coder/java/ . Es el archivo Base64Coder.java que necesitará.

Ahora para acceder a esta clase según su requisito, necesitará la siguiente clase:

import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.InputStream; import java.io.IOException; import java.io.OutputStream; public class Base64 { public static void main(String args[]) throws IOException { /* * if (args.length != 2) {System.out.println( * "Command line parameters: inputFileName outputFileName"); * System.exit(9); } encodeFile(args[0], args[1]); */ File sourceImage = new File("back3.png"); File sourceImage64 = new File("back3.txt"); File destImage = new File("back4.png"); encodeFile(sourceImage, sourceImage64); decodeFile(sourceImage64, destImage); } private static void encodeFile(File inputFile, File outputFile) throws IOException { BufferedInputStream in = null; BufferedWriter out = null; try { in = new BufferedInputStream(new FileInputStream(inputFile)); out = new BufferedWriter(new FileWriter(outputFile)); encodeStream(in, out); out.flush(); } finally { if (in != null) in.close(); if (out != null) out.close(); } } private static void encodeStream(InputStream in, BufferedWriter out) throws IOException { int lineLength = 72; byte[] buf = new byte[lineLength / 4 * 3]; while (true) { int len = in.read(buf); if (len <= 0) break; out.write(Base64Coder.encode(buf, 0, len)); out.newLine(); } } static String encodeArray(byte[] in) throws IOException { StringBuffer out = new StringBuffer(); out.append(Base64Coder.encode(in, 0, in.length)); return out.toString(); } static byte[] decodeArray(String in) throws IOException { byte[] buf = Base64Coder.decodeLines(in); return buf; } private static void decodeFile(File inputFile, File outputFile) throws IOException { BufferedReader in = null; BufferedOutputStream out = null; try { in = new BufferedReader(new FileReader(inputFile)); out = new BufferedOutputStream(new FileOutputStream(outputFile)); decodeStream(in, out); out.flush(); } finally { if (in != null) in.close(); if (out != null) out.close(); } } private static void decodeStream(BufferedReader in, OutputStream out) throws IOException { while (true) { String s = in.readLine(); if (s == null) break; byte[] buf = Base64Coder.decodeLines(s); out.write(buf); } } }

En Android, puede convertir su mapa de bits a Base64 para cargarlo en el servidor / servicio web.

Bitmap bmImage = //Data ByteArrayOutputStream baos = new ByteArrayOutputStream(); bmImage.compress(Bitmap.CompressFormat.JPEG, 100, baos); byte[] imageData = baos.toByteArray(); String encodedImage = Base64.encodeArray(imageData);

Esta “imagen codificada” es una representación de texto de su imagen. Puede usar esto para propósitos de carga o para mostrar directamente en la página HTML como se muestra a continuación ( Reference ):

<img alt="" src="data:image/png;base64,<?php echo $encodedImage; ?>" width="100px" /> <img alt="" src="data:image/png;base64,/9j/4AAQ...........1f/9k=" width="100px" />

Documentación: http://dwij.co.in/java-base64-image-encoder

Si está utilizando Spring Framework al menos la versión 4.1, puede usar la clase org.springframework.util.Base64Utils :

byte[] raw = { 1, 2, 3 }; String encoded = Base64Utils.encodeToString(raw); byte[] decoded = Base64Utils.decodeFromString(encoded);

Se delegará en Base64 de Java 8, Apache Commons Codec o JAXB DatatypeConverter, dependiendo de lo que esté disponible.

Use la clase nunca más tardía en unirse a la diversión de Java 8: java.util.Base64

apache commons tiene una buena implementación de base64. Usted puede hacer esto tan simple como

// 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));

puede encontrar más detalles sobre la codificación base64 en http://faisalbhagat.blogspot.com/2014/06/base64-encoding-using-java-and.html

Google Guava es una buena opción para codificar y decodificar datos base64:

Config pom:

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

Código de muestra:

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