Base64的Java代碼實現

歡迎拍磚~

在數據二進制和byte互相轉換的地方方法寫得有點挫，不知道有沒有更好的方法~

順便復習了java的一些基礎東西，如位操作，原碼反碼補碼

可以在這篇blog里學習到詳細的知識點：http://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html

直接上代碼吧，知識點在注釋上

編碼器：

package jdbc.pro.lin;

import java.util.HashMap;
import java.util.Map;

public class MyBase64Encoder {

    private static final Map<Integer, Character> INDEX_MAP = new HashMap<Integer, Character>();

    private static final char PADDING_CHAR = '=';
    static {
        int index = 0;
        for (int i = 0; i <= 25; i++) {
            INDEX_MAP.put(index, (char) ((int) 'A' + i));
            index++;
        }

        for (int j = 0; j <= 25; j++) {
            INDEX_MAP.put(index, (char) ((int) 'a' + j));
            index++;
        }

        for (int k = 0; k <= 9; k++) {
            INDEX_MAP.put(index, (char) ((int) '0' + k));
            index++;
        }

        INDEX_MAP.put(index, '+');
        index++;
        INDEX_MAP.put(index, '/');
    }

    public static String encode(byte[] bytes) throws Exception {
        /**
         * 1.轉成二進制的字符串(長度為6的倍數)
         * 2.獲取轉義后的字符串 
         * 3.不是4的位數，填充=號
         */
        String binaryString = convertByteArray2BinaryString(bytes);
        String escapeString = escapeBinaryString(binaryString);
        return paddingEscapeString(escapeString);
    }

    private static String convertByteArray2BinaryString(byte[] bytes) {

        StringBuilder binaryBuilder = new StringBuilder();
        for (byte b : bytes) {
            binaryBuilder.append(convertByte2BinaryString(b));
        }

        int paddingCount = binaryBuilder.length() % 6;
        int totalCount = paddingCount > 0 ? binaryBuilder.length() / 6 + 1
                : binaryBuilder.length() / 6;
        int actualLength = 6 * totalCount;

        //百分號后面的-號表示長度不夠規定長度時，右填充。否則左填充。
        return String.format("%-" + actualLength + "s",
                binaryBuilder.toString()).replace(' ', '0');
    }

    private static String escapeBinaryString(String binaryString)
            throws Exception {
        if (null == binaryString || binaryString.isEmpty()
                || binaryString.length() % 6 != 0) {
            System.out.println("error");
            throw new Exception("escape binary string error.");
        }

        StringBuilder escapeBuilder = new StringBuilder();
        for (int i = 0; i <= binaryString.length() - 1; i += 6) {
            String escapeString = binaryString.substring(i, i + 6);
            int index = Integer.parseInt(escapeString, 2);
            escapeBuilder.append(INDEX_MAP.get(index));
        }

        return escapeBuilder.toString();
    }

    private static String paddingEscapeString(String escapeString) {
        int paddingCount = escapeString.length() % 4;
        int totalCount = paddingCount > 0 ? escapeString.length() / 4 + 1
                : escapeString.length() / 4;
        int actualCount = 4 * totalCount;
        return String.format("%-" + actualCount + "s", escapeString).replace(
                ' ', PADDING_CHAR);
    }

    private static String convertByte2BinaryString(byte b) {
        
        /**
         * 對於非負數，直接使用Integer.toBinaryString方法把它打印出來
         */
        if (b >= 0) {
            StringBuilder builder = new StringBuilder();
            builder.append(Integer.toBinaryString(b));
            return String.format("%08d", Integer.parseInt(builder.toString()));
        } else {
            /**
             * 對於負數，要記住內存保存的是補碼。
             * 不能直接使用Byte.parseByte()方法。
             * 因為這個方法最終調的是Integer.parseInt()方法，也就是說，負數如：10000001
             * 對Integer.parseInt()來說並不會認為是負數，符號位1被當作數值位，是129
             * 同時Byte.parseByte()方法里還對數值范圍做了校驗，符號位1，已超出范圍，這樣
             * 會拋出異常。而Byte又沒有提供toBinaryString的方法
             * 為了保存byte的二進制值，可利用按位與的方法
             * 例如有一個負數1000 1111，要把它以字符串保留出來，利用它與1111 1111的與操作，
             * 再轉成int類型。1000 1111 & 1111 1111
             * 在內存中保存的就是 00000000 10001111，這時保存的是一個正整數。但我們不關心整數的正負，
             * 因為我們的目的是要把這串字符串截取出來
             * 再利用Integer.toBinaryString()打印出來。
             * Integer.toBinaryString()對於正數，會將前面的零去掉，如上將打印出1000 1111，這就是我們要的結果。
             */
            int value = b & 0xFF;
            return Integer.toBinaryString(value);
        }
    }

}

解碼器：

package jdbc.pro.lin;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MyBase64Decoder {
    private static final char PADDING_CHAR = '=';

    private static final Map<Character, Integer> VALUE_MAP = new HashMap<Character, Integer>();
    static {
        int index = 0;
        for (char i = 'A'; i <= 'Z'; i++, index++) {
            VALUE_MAP.put(i, index);
        }

        for (char j = 'a'; j <= 'z'; j++, index++) {
            VALUE_MAP.put(j, index);
        }

        for (char k = '0'; k <= '9'; k++, index++) {
            VALUE_MAP.put(k, index);
        }

        VALUE_MAP.put('+', index);
        index++;
        VALUE_MAP.put('/', index);
    }

    public static byte[] decode(String base64String) {

        if (null == base64String || base64String.isEmpty()) {
            return null;
        }
        /**
         * 1.去掉末尾拼湊的=符號 2.轉成二進制 3.去掉末尾拼湊的0 4.截取每8位取數
         */
        base64String = removePaddingChar(base64String);
        String binaryString = getBinaryString(base64String);
        binaryString = removePaddingNumber(binaryString);

        return convertBinaryString2Bytes(binaryString);

    }

    /**
     * 刪除末尾拼湊的=符號
     * 
     * @param base64String
     * @return
     */
    private static String removePaddingChar(String base64String) {
        int firstPaddingIndex = base64String.indexOf(PADDING_CHAR);
        return firstPaddingIndex >= 0 ? base64String.substring(0,
                firstPaddingIndex) : base64String;
    }

    /**
     * 將base64字符串轉成二進制字符串
     * 
     * @param base64String
     * @return
     */
    private static String getBinaryString(String base64String) {
        StringBuilder binaryBuilder = new StringBuilder();
        for (char c : base64String.toCharArray()) {
            int value = VALUE_MAP.get(c);
            binaryBuilder.append(String.format("%6s",
                    Integer.toBinaryString(value)).replace(" ", "0"));
        }

        return binaryBuilder.toString();
    }

    /**
     * 二進制字符串中的末尾有一些0是因為不足6的倍數而填充的，需要刪除
     * 
     * @param binaryString
     * @return
     */
    private static String removePaddingNumber(String binaryString) {
        int remainder = binaryString.length() % 8;

        binaryString = binaryString.substring(0, binaryString.length()
                - remainder);

        return binaryString;
    }

    private static byte[] convertBinaryString2Bytes(String binaryString) {
        if (null == binaryString || binaryString.length() % 8 != 0) {
            System.out.println("binary string not well formatted.");
            return null;
        }
        int size = binaryString.length() / 8;
        byte[] bytes = new byte[size];
        int arrayIndex = 0;
        for (int i = 0; i <= binaryString.length() - 1; i += 8, arrayIndex++) {
            String byteString = binaryString.substring(i, i + 8);
            /**
             * 非負數，直接使用Byte.parseByte()方法
             */
            if (byteString.startsWith("0")) {
                bytes[arrayIndex] = Byte.parseByte(byteString, 2);
            } else {
                /**
                 * 10000000為-128是規定而來的。 -128並沒有原碼和反碼表示。對-128的補碼表示[10000000]補
                 * 算出來的原碼是[0000 0000]原, 這是不正確的)
                 */
                if (byteString.equals("1000000")) {
                    bytes[arrayIndex] = (byte) -128;
                    continue;
                }
                /**
                 * 其他的負數，就要按照補碼的規則來計算 即，原碼取反+1=補碼 那么，補碼-1取反=原碼
                 * 注意這都是真值部分的計算，符號位不能變
                 */
                // 補碼
                String twosComplement = byteString.substring(1);
                byte twoComplementValue = Byte.parseByte(twosComplement, 2);

                // 反碼
                byte oneComplementValue = (byte) (twoComplementValue - 1);

                /**
                 * 這里用到的是0x7F而不是0xFF。因為oneComplementValue是0開頭
                 * 若與1開頭的異或，結果為1，而在int中該位不是符號位，會當成數值計算，造成數值錯誤。
                 * 因此，必須結果是0，即，兩個0的異或。
                 */
                // 真值 8位的計算
                int trueValue = oneComplementValue ^ 0x7F;

                bytes[arrayIndex] = (byte) (trueValue * (-1));

            }
        }

        return bytes;
    }
}

 

測試代碼：

package jdbc.pro.lin;

import oracle.net.aso.i;

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

public class TestMain {
    public static void main(String[] args) throws Exception {
        byte[] binaryData = { 0, -2, -128, 127, 1, -1, 3, 4, 89, 45, 0 };
        String thirdPartyBase64String = Base64.encodeBase64String(binaryData);
        String myBase64String = MyBase64Encoder.encode(binaryData);
        System.out.println("ThirdParty encode: " + thirdPartyBase64String);
        System.out.println("MyBase64 encode: " + myBase64String);

        System.out.print("ThirdParty decode: ");
        printBytes(Base64.decodeBase64(thirdPartyBase64String.getBytes()));

        System.out.print("MyBase64 decode: ");
        printBytes(MyBase64Decoder.decode(thirdPartyBase64String));
        
    }

    private static void printBytes(byte[] bytes) {
        for (byte b : bytes) {
            System.out.print(b);
            System.out.print(" ");
        }
        System.out.println("");
    }
}

 

測試結果：

附Byte.parseByte()的反編譯源碼，確實是調用了Integer.parseInt()方法，導致符號位失效，對於10001111這樣的數值認為是正數