جافا Base64 سلسلة من النص

Question

أريد أن أكتب سلسلة تحتوي base64 في ترميز النص إلى ملف نصي ثم في وقت لاحق قراءة هذه السلسلة من ملف نصي إلى متغير سلسلة.

كيف يمكن أن أفعل ذلك حتى لا يكون هناك أي فقدان البيانات بسبب ترميز القضايا ؟

Answer 1

باستخدام Base64 فقط A-Z، a-z و0-9، و+ / . لذلك ينبغي أن يكون هناك أي مشكلة الترميز. طالما كنت قادرا على ترميز أسكي بشكل صحيح. اخترع base64 في لتمثيل بايت في rel="noreferrer"> .

لتشفير وفك يمكنك استخدام المشتركة الترميز باستخدام Base64 .

Answer 2

وباستخدام Base64 التشفير:

// Sample program to encode a binary file into a Base64 text file.
// Author: Christian d'Heureuse (www.source-code.biz)

import java.io.BufferedInputStream;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.IOException;

public class Base64FileEncoder {

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

    private static void encodeFile (String inputFileName, String outputFileName) throws IOException {
        BufferedInputStream in = null;
        BufferedWriter out = null;
        try {
            in = new BufferedInputStream(new FileInputStream(inputFileName));
            out = new BufferedWriter(new FileWriter(outputFileName));
            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, len));
            out.newLine(); 
        }
    }

} // end class Base64FileEncoder

وباستخدام Base64 فك الرموز:

// Sample program to decode a Base64 text file into a binary file.
// Author: Christian d'Heureuse (www.source-code.biz)

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;

public class Base64FileDecoder {

    public static void main (String args[]) throws IOException {
        if (args.length != 2) {
            System.out.println ("Command line parameters: inputFileName outputFileName");
            System.exit (9); 
        }

        decodeFile (args[0], args[1]); 
    }

    private static void decodeFile (String inputFileName, String outputFileName) throws IOException {
        BufferedReader in = null;
        BufferedOutputStream out = null;
        try {
            in = new BufferedReader(new FileReader(inputFileName));
            out = new BufferedOutputStream(new FileOutputStream(outputFileName));
            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.decode(s);
            out.write (buf); 
        }
    }

} // end class Base64FileDecoder

واختبار باستخدام Base64 المبرمج:

// Test program for the Base64Coder class.

public class TestBase64Coder {

    public static void main (String args[]) throws Exception {
        System.out.println ("TestBase64Coder started");
        test1();
        test2();
        System.out.println ("TestBase64Coder completed"); 
    }

    // Test Base64Coder with constant strings.
    private static void test1() {
        System.out.println ("test1 started");
        check ("Aladdin:open sesame", "QWxhZGRpbjpvcGVuIHNlc2FtZQ==");  // example from RFC 2617
        check ("", "");
        check ("1", "MQ==");
        check ("22", "MjI=");
        check ("333", "MzMz");
        check ("4444", "NDQ0NA==");
        check ("55555", "NTU1NTU=");
        check ("abc:def", "YWJjOmRlZg==");
        System.out.println ("test1 completed"); 
    }

    private static void check (String plainText, String base64Text) {
        String s1 = Base64Coder.encodeString(plainText);
        String s2 = Base64Coder.decodeString(base64Text);
        if (!s1.equals(base64Text) || !s2.equals(plainText))
            System.out.println ("check failed for \""+plainText+"\" / \""+base64Text+"\"."); 
    }

    // Test Base64Coder against sun.misc.BASE64Encoder/Decoder with
    // random strings.
    private static void test2() throws Exception {
        System.out.println ("test2 started");
        sun.misc.BASE64Encoder enc = new sun.misc.BASE64Encoder();
        sun.misc.BASE64Decoder dec = new sun.misc.BASE64Decoder();
        java.util.Random rnd = new java.util.Random(0x538afb92);

        for (int i = 0; i < 50000; i++) {
            int len = rnd.nextInt(55);
            byte[] b0 = new byte[len];
            rnd.nextBytes(b0);
            String e1 = new String(Base64Coder.encode(b0));
            String e2 = enc.encode(b0);
            if (!e1.equals(e2)) 
                System.out.println ("Error\ne1=" + e1 + " len=" + e1.length() + "\ne2=" + e2 + " len=" + e2.length());

            byte[] b1 = Base64Coder.decode(e1);
            byte[] b2 = dec.decodeBuffer(e2);
            if (!compareByteArrays(b1, b0) || !compareByteArrays(b2, b0))
                System.out.println ("Decoded data not equal. len1=" + b1.length + " len2=" + b2.length); 
        }

        System.out.println ("test2 completed"); 
    }

    // Compares two byte arrays.
    private static boolean compareByteArrays (byte[] a1, byte[] a2) {
        if (a1.length != a2.length) return false;
        for (int p = 0; p < a1.length; p++)
            if (a1[p] != a2[p]) return false;

        return true; 
    }

} // end class TestBase64Coder

Answer 3

هنا هو رمز بسيط والتي سوف ترميز وفك ترميز:

خطوات الترميز

1. ترميز بايت
2. تحويل ترميز بايت إلى Hex String

خطوات فك

1. تحويل Hex String إلى ترميز بايت
2. فك بايت
3. تحويل فك بايت إلى Hex String

4. تحويل عرافة سلسلة إلى أحرف ASCII سلسلة (عادي سلسلة)

   // Encoding Bytes
   byte[] b64ENC = Base64.encode("Hello World".getBytes("UTF-8"));
   String ENCStr = getHexString(b64ENC,b64ENC.length);
   T1.setText(ENCStr);  //-- for output
   
   // Decoding Bytes
   byte[] DECBarray = hexStringToByteArray(ENCStr);
   byte[] b64DEC = Base64.decode(DECBarray);
   
   // Displaying Decoded Byte Array by Converting it To String
   try {
       String ResDec = new String(b64DEC,"UTF-8");
       T2.setText(ResDec);   //This Displays Hello World :)
   
   } catch (UnsupportedEncodingException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
   }
   
   // Following are the functions that I used above !
   public String getHexString(byte[] b, int length) {
       // TODO Auto-generated method stub
       String result = "";
   
       for (int i = 0; i < length; i++) {
           result += Integer.toString( ( b[i] & 0xff ) + 0x100, 16).substring(1);
       }
       return result;
   }
   
   public static String bytesToHex(byte[] data) {
       StringBuffer buf = new StringBuffer();
       for (int i = 0; i < data.length; i++) {
           buf.append(byteToHex(data[i]));
           buf.append(" ");
       }
       return (buf.toString());
   }
   
   public static String byteToHex(byte data) {
       StringBuffer buf = new StringBuffer();
       buf.append(toHexChar((data >>> 4) & 0x0F));
       buf.append(toHexChar(data & 0x0F));
       return buf.toString();
   }
   
   public static char toHexChar(int i) {
       if ((0 <= i) && (i <= 9)) {
           return (char) ('0' + i);
       } else {
           return (char) ('a' + (i - 10));
       }
   }
   
   public static byte[] hexStringToByteArray(String s) {
       int len = s.length();
       byte[] data = new byte[len / 2];
       for (int i = 0; i < len; i += 2) {
           data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                   + Character.digit(s.charAt(i+1), 16));
       }
   
       return data;
   }
   

Answer 4

وهناك فئة الشمس من شأنها أن تفعل ذلك بالنسبة لك (على الرغم من أنه سيتم إنشاء تحذيرات المترجم:

import sun.misc.BASE64Encoder;

BASE64Encoder encoder = new BASE64Encoder();

String toEncode = "encodeMe";

String encoded = encodeBuffer(toEncode.getBytes());

ومن الذاكرة، وهناك أيضا BASE64Decoder، ولكني لم تستخدم هذا، وأنا أذهب سوى طريقة واحدة للمقارنة بين أسماء الإفراط في السلك.