Java में Base64 के रूप में एन्कोडिंग

Question

मुझे Java में Base64 एन्कोडिंग में कुछ डेटा एनकोड करने की आवश्यकता है। मैं उसको कैसे करू? बेस 64 एनकोडर प्रदान करने वाले वर्ग का नाम क्या है?

---

मैंने sun.misc.BASE64Encoderसफलता के बिना, कक्षा का उपयोग करने की कोशिश की । मेरे पास जावा 7 कोड की निम्नलिखित पंक्ति है:

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

मैं ग्रहण का उपयोग कर रहा हूं। ग्रहण इस रेखा को एक त्रुटि के रूप में चिह्नित करता है। मैंने आवश्यक पुस्तकालयों का आयात किया:

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

लेकिन फिर, दोनों को त्रुटियों के रूप में दिखाया गया है। मुझे यहाँ एक समान पोस्ट मिली ।

मैं अपाचे कॉमन्स का उपयोग करके सुझाए गए समाधान के रूप में करता हूं:

import org.apache.commons.*;

और डाउनलोड की गई JAR फ़ाइलों को आयात करना: http://commons.apache.org/codec/

लेकिन समस्या अभी भी मौजूद है। ग्रहण अभी भी पहले बताई गई त्रुटियों को दर्शाता है। मुझे क्या करना चाहिए?

Comments

मेरी सलाह: त्रुटि संदेश पढ़ें, और यह समझने की कोशिश करें कि यह क्या कहता है।

— जेबी निज़ेट

आप के तहत उपयोग कक्षाएं नहीं करना पड़ेगाsun.**

— onon15

वे सार्वजनिक एपीआई का हिस्सा नहीं हैं; उन्हें बिना किसी सूचना के बदला जा सकता है, हटाया जा सकता है। उनमें से कुछ प्रयोगात्मक हो सकते हैं या केवल उत्पादन-ग्रेड नहीं हो सकते हैं। oracle.com/technetwork/java/faq-sun-packages-142232.html

— onon15

या JAXB DatatypeConverter का उपयोग करें जो जावा 6 और बाद में मानक के रूप में शामिल है।

— इयान रॉबर्ट्स

java.util.Base64 जावा 8 में उपलब्ध है

— इयरकैम

Answer 1

आपको अपनी कक्षा का आयात बदलने की आवश्यकता है:

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

और फिर बेस 64 वर्ग का उपयोग करने के लिए अपनी कक्षा बदलें।

यहाँ कुछ उदाहरण कोड है:

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

फिर पढ़ें कि आपको सूरज का उपयोग क्यों नहीं करना चाहिए। * पैकेज ।

---

अपडेट (2016-12-16)

अब आप java.util.Base64जावा 8 के साथ उपयोग कर सकते हैं । सबसे पहले, इसे सामान्य रूप से आयात करें:

import java.util.Base64;

फिर बेस 64 स्थैतिक विधियों का उपयोग इस प्रकार करें:

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 के लिए जावा प्रलेखन देखें ।

Comments

क्या मुझे काम करने के लिए किसी बाहरी पैकेज को डाउनलोड करने की आवश्यकता है? यदि हाँ, तो कौन?

— गर्भपात

कोई आप डाउनलोड कुछ भी afaik की जरूरत नहीं है

— pratnala

org.apache.commons.codec.binary.Base64 डिफ़ॉल्ट लाइब्रेरी की तरह नहीं दिखता है। मुझे लगता है कि आपको इसके लिए अपाचे कॉमन्स को शामिल करना होगा। सही?

— राबर्ट रीज

@Frank बाइट डिकोडिंग एक बार में OutOfMemory त्रुटि बढ़ाएं। किसी भी विचार को बफर में संसाधित करें

— xyz

Answer 2

जावा 8 का कभी-भी-देर-से-ज्वाइन-इन-द-फ़न क्लास का उपयोग करें: java.util.Base64

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

Comments

हालांकि एक तुच्छ टिप्पणी, ध्यान दें कि यदि आप उपयोग करते हैं तो आप जावा के पुराने संस्करणों के साथ संगत नहीं हैं, जो कि (कम से कम इस समय) शायद कहीं अधिक प्रचलित हैं।

— dcoder

मैं यह भी चुनूँगा कि Java 8 की कक्षा संभव है। मैं वर्तमान में हमारे स्प्रिंग प्रोजेक्ट से अपाचे कॉमन्स लाइब्रेरी को हटाने के लिए एक वर्ग पर काम कर रहा हूं। अधिकांश सामान वसंत पुस्तकालयों या jdk से विधि के साथ आसानी से बदला जा सकता है।

— एड्रियन कॉस्मा

Answer 3

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==

Comments

क्यों जावा मानक पुस्तकालय में कोई चारसेट स्थिरांक नहीं हैं, ओह क्यों ?!

— लुकाज़ विकटोर

अच्छा सवाल है, लुकाज़! दरअसल, हैं। मैं भूल गया! java.nio.charset.StandardCharsets। मैं अपना उत्तर संपादित करूँगा। देखें stackoverflow.com/questions/1684040/...

— किर्बी

Answer 4

आप Base64 एन्कोडिंग का उपयोग करके भी परिवर्तित कर सकते हैं। ऐसा करने के लिए, आप javax.xml.bind.DatatypeConverter#printBase64Binaryविधि का उपयोग कर सकते हैं ।

उदाहरण के लिए:

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

Comments

जबकि यह काम करता है, प्रलेखन विशेष रूप से बताता है: DatatypeConverterInterface केवल JAXB प्रदाता उपयोग के लिए है।

— gebirgsbärbel

मुझे लगता है कि @gebirgsbaerbel गलत है, PrintX () और parseX () विधि का उपयोग किसी भी द्वारा किया जा सकता है, केवल JAXB के लिए केवल एक ही setDatatypeConverter()विधि है (जो तब JAXB प्रदाताओं के लिए कॉल की जानी चाहिए)।

— फोनिक्स

अंततः Java 8 से Base64 क्लास जाने का रास्ता होगा। लेकिन अगर आपको इस बीच जावा 7 को लक्षित करना है, तो यह समाधान अच्छा है क्योंकि यह बाहरी पुस्तकालयों पर निर्भर नहीं करता है।

— दाना

यह जावा 9 के तहत काम नहीं करता है। इससे भी बदतर, जावा 7 के लिए संकलित कोड javax.xml.bind का उपयोग कर। * जावा 9 के तहत रनटाइम में विफल हो जाएगा

— स्टीफन एम-ऑन हड़ताल-

Answer 5

Google Guava Base64 डेटा को एनकोड और डीकोड करने का एक और विकल्प है:

पोम विन्यास:

<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

Answer 6

ग्रहण आपको एक त्रुटि / चेतावनी देता है क्योंकि आप आंतरिक कक्षाओं का उपयोग करने की कोशिश कर रहे हैं जो JDK विक्रेता के लिए विशिष्ट हैं और सार्वजनिक API का हिस्सा नहीं हैं। जकार्ता कॉमन्स बेस 64 कोडेक्स का अपना कार्यान्वयन प्रदान करता है, जो निश्चित रूप से एक अलग पैकेज में रहते हैं। उन आयातों को हटा दें और ग्रहण को आपके लिए उचित कॉमन्स वर्ग आयात करने दें।

Comments

जकार्ता परियोजना नहीं रह गया है । इसे मिलाया और मिलान किया गया है (और जावा ईई के लिए पुन: उपयोग किया गया नाम )। क्या आप अपना जवाब अपडेट कर सकते हैं और कुछ संदर्भ प्रदान कर सकते हैं? उदाहरण के लिए, क्या यह अब कक्षा Base64में हैorg.apache.commons.codec.binary ? क्या अब इस संदर्भ के लिए अपाचे कॉमन्स हैं ?

— पीटर मोर्टेंसन

Answer 7

इसे परिवर्तित करने के लिए, आपको एक एनकोडर और डिकोडर की आवश्यकता होती है जो आपको Base64Coder से मिलेगा - जावा में एक ओपन-सोर्स Base64 एनकोडर / डिकोडर । यह फ़ाइल है 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);
        }
    }
}

एंड्रॉइड में आप सर्वर या वेब सेवा पर अपलोड करने के लिए अपने बिटमैप को बेस 64 में बदल सकते हैं।

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

यह "एनकोडेडमैज" आपकी छवि का पाठ प्रतिनिधित्व है। आप इसका उपयोग या तो अपलोड करने के उद्देश्य से कर सकते हैं या नीचे HTML पेज में सीधे डिप्लोमा करने के लिए ( संदर्भ ):

<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

Comments

अंतिम लिंक (dwij.co.in) टूट गया है (404)।

— पीटर मॉर्टेंसन

Answer 8

के लिए जावा 6 -7, सबसे अच्छा विकल्प एंड्रॉयड रिपोजिटरी से कोड उधार लेने के लिए है। इसकी कोई निर्भरता नहीं है।

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

Answer 9

यहाँ मेरे दो सेंट हैं ... जावा 8 में बेस 64 का अपना कार्यान्वयन शामिल है । हालांकि, मुझे एक थोड़ा परेशान करने वाला अंतर मिला। उदाहरण के लिए, मैं एक कोड उदाहरण प्रदान करूंगा:

मेरा कोडेक आवरण:

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)

ध्यान दें कि अपाचे एन्कोडेड पाठ में अंत में अतिरिक्त लाइन ब्रेक (सफेद रिक्त स्थान) होते हैं। इसलिए, अपने कोडेक के लिए बेस 64 कार्यान्वयन की परवाह किए बिना एक ही परिणाम प्राप्त करने के लिए, मुझे trim()अपाचे एन्कोडेड पाठ पर कॉल करना था । मेरे मामले में, मैंने बस अपने कोडेक के लिए उपरोक्त विधि कॉल को इस 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. डिकोड एनकोडेड टेक्स्ट को अपने अपाचे डिकोडर के साथ।
2. जावा के साथ परिणामी (सादा) पाठ को एनकोड करें।

यदि आप इन चरणों का पालन किए बिना स्विच करते हैं, तो सबसे अधिक संभावना है कि आप समस्याओं में भाग लेंगे। इस तरह मैंने यह खोज की।

Answer 10

एंड्रॉइड पर, android.util.Base64 उपयोगिता वर्ग के स्थिर तरीकों का उपयोग करें । संदर्भित दस्तावेज में कहा गया है कि API64 स्तर 8 ( Android 2.2 (Froyo)) में Base64 वर्ग को जोड़ा गया था ।

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

Comments

यह सबसे अच्छा जवाब है अगर आप एंड्रॉइड के लिए विकसित कर रहे हैं और आप

— क्रेग ब्राउन

Answer 11

Apache Commons का बेस 64 का अच्छा कार्यान्वयन है। आप इसे बस के रूप में कर सकते हैं:

// 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 एन्कोडिंग पर Base64 एन्कोडिंग के बारे में अधिक जानकारी जावा और जावास्क्रिप्ट का उपयोग करके प्राप्त कर सकते हैं ।

Comments

ध्यान दें कि यह मान लिया गया है कि स्ट्रिंग डिफ़ॉल्ट चारसेट में एन्कोडेड है

— किर्बी

Answer 12

यदि आप कम से कम 4.1 संस्करण स्प्रिंग फ्रेमवर्क का उपयोग कर रहे हैं , तो आप org.springframework.util.Base64Utils वर्ग का उपयोग कर सकते हैं :

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

यह जावा 8 के Base64, Apache Commons Codec, या JAXB DatatypeConverter, जो उपलब्ध है, पर निर्भर करेगा।

Answer 13

जावा 8 के साथ सरल उदाहरण:

import java.util.Base64;

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

Answer 14

जावा 7 में मैंने इस विधि को कोडित किया है

import javax.xml.bind.DatatypeConverter;

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

Comments

जावा 7 और 8 के तहत काम करता है, लेकिन जावा 9 से नहीं। इससे भी बदतर, अगर आप इसे जावा 7 या 8 के तहत बनाते हैं, तो यह निर्माण करेगा और फिर आपको जावा 9 के तहत रनटाइम में एक ClassDefNotFoundException मिलेगी

— स्टीफन एम-ऑन स्ट्राइक-

Answer 15

यदि आप 8 से पहले के जावा संस्करण से चिपके हुए हैं लेकिन पहले से ही जावा के लिए AWS SDK का उपयोग कर रहे हैं, तो आप com.amazonaws.util.Base64 का उपयोग कर सकते हैं ।

Answer 16

मैंने निम्नलिखित कोड स्निपेट के साथ प्रयास किया। इसने अच्छा काम किया। :-)

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

Answer 17

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