Java에서 Base64로 인코딩

Java로 Base64 인코딩으로 일부 데이터를 인코딩해야합니다. 어떻게합니까? Base64 인코더를 제공하는 클래스의 이름은 무엇입니까?

나는 sun.misc.BASE64Encoder성공하지 않고 수업 을 사용하려고했습니다 . Java 7 코드의 다음 줄이 있습니다.

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

Eclipse를 사용하고 있습니다. Eclipse는이 행을 오류로 표시합니다. 필요한 라이브러리를 가져 왔습니다.

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

그러나 두 가지 모두 오류로 표시됩니다. 나는 비슷한 게시물을 여기 에서 발견 했다 .

다음을 포함하여 제안 된 솔루션으로 Apache Commons를 사용했습니다.

import org.apache.commons.*;

http://commons.apache.org/codec/ 에서 다운로드 한 JAR 파일 가져 오기

그러나 문제는 여전히 존재합니다. Eclipse는 여전히 앞서 언급 한 오류를 보여줍니다. 어떻게해야합니까?

수업 가져 오기를 변경해야합니다.

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

그런 다음 Base64 클래스를 사용하도록 클래스를 변경하십시오.

예제 코드는 다음과 같습니다.

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

그런 다음 sun. * 패키지를 사용하지 않아야하는 이유를 읽으십시오 .

업데이트 (2016-12-16)

이제 java.util.Base64Java 8과 함께 사용할 수 있습니다. 먼저 평소와 같이 가져옵니다.

import java.util.Base64;

그런 다음 다음과 같이 Base64 정적 메소드를 사용하십시오.

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

문자열을 직접 인코딩하고 결과를 인코딩 된 문자열로 얻으려면 다음을 사용할 수 있습니다.

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

자세한 내용 은 Base64에 대한 Java 설명서를 참조하십시오 .

Java 8의 절대 재미가없는 클래스를 사용하십시오. java.util.Base64

new String(Base64.getEncoder().encode(bytes));

Java 8에서는 다음과 같이 수행 할 수 있습니다. Base64.getEncoder (). encodeToString (string.getBytes (StandardCharsets.UTF_8))

다음은 짧고 독립적 인 완전한 예입니다.

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

산출:

old crow medicine show => b2xkIGNyb3cgbWVkaWNpbmUgc2hvdw==

Base64 인코딩을 사용하여 변환 할 수도 있습니다. 이렇게하려면이 javax.xml.bind.DatatypeConverter#printBase64Binary방법을 사용할 수 있습니다 .

예를 들면 다음과 같습니다.

byte[] salt = new byte[] { 50, 111, 8, 53, 86, 35, -19, -47 };
System.out.println(DatatypeConverter.printBase64Binary(salt));

Google Guava 는 Base64 데이터를 인코딩 및 디코딩하는 또 다른 선택입니다.

POM 구성 :

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

샘플 코드 :

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

Eclipse는 JDK 공급 업체에 고유하고 공개 API의 일부가 아닌 내부 클래스를 사용하려고하기 때문에 오류 / 경고를 표시합니다. Jakarta Commons는 물론 다른 패키지에있는 base64 코덱의 자체 구현을 제공합니다. 해당 가져 오기를 삭제하고 Eclipse가 적절한 Commons 클래스를 가져 오도록하십시오.

이것을 변환하려면 Java의 오픈 소스 Base64 인코더 / 디코더 인 Base64Coder 에서 얻을 수있는 인코더 및 디코더가 필요합니다 . 필요한 Base64Coder.java 파일 입니다.

요구 사항에 따라이 클래스에 액세스하려면 아래 클래스가 필요합니다.

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

Android에서는 서버 나 웹 서비스에 업로드하기 위해 비트 맵을 Base64로 변환 할 수 있습니다.

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

이 "encodedImage"는 이미지의 텍스트 표현입니다. 다음과 같이 업로드 목적 또는 HTML 페이지로 직접 재생하기 위해 이것을 사용할 수 있습니다 ( 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" />

설명서 : http://dwij.co.in/java-base64-image-encoder

를 들어 자바 6 -7, 최선의 선택은 안드로이드 저장소에서 코드를 차용하는 것입니다. 종속성이 없습니다.

https://github.com/android/platform_frameworks_base/blob/master/core/java/android/util/Base64.java

여기 내 두 센트가 있습니다 ... Java 8에는 자체 Base64 구현이 포함되어 있습니다 . 그러나 나는 약간 혼란스러운 차이점을 발견했습니다. 설명하기 위해 코드 예제를 제공합니다.

내 코덱 래퍼 :

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

테스트 클래스 :

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

산출:

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)

Apache 인코딩 텍스트에는 끝에 추가 줄 바꿈 (공백)이 포함되어 있습니다. 따라서 Base64 구현에 관계없이 코덱에서 동일한 결과를 얻으 trim()려면 Apache 인코딩 텍스트 를 호출해야했습니다 . 필자의 경우 위에서 언급 한 메소드 호출을 apacheDecode()다음과 같이 코덱에 추가했습니다 .

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

이 변경이 이루어지면 결과는 다음과 같습니다.

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!

결론 : Apache Base64에서 Java로 전환하려면 다음을 수행해야합니다.

1. Apache 디코더로 인코딩 된 텍스트를 디코딩하십시오.
2. 결과 텍스트 (일반)를 Java로 인코딩하십시오.

이러한 단계를 수행하지 않고 전환하면 문제가 발생할 가능성이 큽니다. 이것이 제가 발견 한 방법입니다.

Android에서는 android.util.Base64 유틸리티 클래스 의 정적 메소드를 사용하십시오 . 참조 문서는 Base64 클래스가 API 레벨 8 ( Android 2.2 (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));

Apache Commons 는 Base64를 훌륭하게 구현했습니다. 다음과 같이 간단하게 수행 할 수 있습니다.

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

Base64 인코딩 에 대한 자세한 내용은 Java 및 JavaScript를 사용하는 Base64 인코딩 에서 찾을 수 있습니다 .

당신이 사용하는 경우 스프링 프레임 워크 적어도 버전 4.1을, 당신은 사용할 수 있습니다 org.springframework.util.Base64Utils의 클래스를 :

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

사용 가능한 항목에 따라 Java 8의 Base64, Apache Commons Codec 또는 JAXB DatatypeConverter로 위임됩니다.

Java 8의 간단한 예 :

import java.util.Base64;

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

Java 7에서는이 방법을 코딩했습니다.

import javax.xml.bind.DatatypeConverter;

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

8 이전 버전의 Java를 사용하고 있지만 이미 AWS SDK for Java 를 사용하고 있다면 com.amazonaws.util.Base64 를 사용할 수 있습니다 .

다음 코드 스 니펫으로 시도했습니다. 잘 작동했습니다. :-)

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

public String convertImageToBase64(String filePath) {
    byte[] fileContent = new byte[0];
    String base64encoded = null;
    try {
        fileContent = FileUtils.readFileToByteArray(new File(filePath));
    } catch (IOException e) {
        log.error("Error reading file: {}", filePath);
    }
    try {
        base64encoded = Base64.getEncoder().encodeToString(fileContent);
    } catch (Exception e) {
        log.error("Error encoding the image to base64", e);
    }
    return base64encoded;
}