java.util.Base64.Decoder# decode ( ) 源码实例Demo

下面列出了java.util.Base64.Decoder# decode ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。

源代码1 项目： fido2 文件： MDSJwtVerifier.java


private List<Certificate> getCertificatesFromJsonArray(JsonArray x5c) throws CertificateException, NoSuchProviderException{
    List<Certificate> result = new ArrayList<>();
    if(x5c == null){
        return result;
    }
    Decoder decoder = Base64.getDecoder();
    for(int i = 0; i < x5c.size(); i++){
        byte[] certBytes = decoder.decode(x5c.getString(i));
        result.add(cryptoCommon.generateX509FromBytes(certBytes));
    }
    return result;
}

源代码2 项目： sk-admin 文件： Base64DecodeMultipartFile.java


public static MultipartFile base64Convert(String base64) {

        String[] baseStrs = base64.split(",");
        Decoder decoder = Base64.getDecoder();
        byte[] b = decoder.decode(baseStrs[1]);

        for (int i = 0; i < b.length; ++i) {
            if (b[i] < 0) {
                b[i] += 256;
            }
        }
        return new Base64DecodeMultipartFile(b, baseStrs[0]);
    }

源代码3 项目： AESCipher-Java 文件： AESCipher.java


public static String aesDecryptString(String content, String key) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
	Decoder decoder = Base64.getDecoder();
    byte[] encryptedBytes = decoder.decode(content);
    byte[] keyBytes = key.getBytes(charset);
	byte[] decryptedBytes = aesDecryptBytes(encryptedBytes, keyBytes);
    return new String(decryptedBytes, charset);		
}

源代码4 项目： native-obfuscator 文件： TestBase64Golden.java


private static void test1() throws Exception {
    byte[] src = new byte[] {
        46, -97, -35, -44, 127, -60, -39, -4, -112, 34, -57, 47, -14, 67,
        40, 18, 90, -59, 68, 112, 23, 121, -91, 94, 35, 49, 104, 17, 30,
        -80, -104, -3, -53, 27, 38, -72, -47, 113, -52, 18, 5, -126 };
    Encoder encoder = Base64.getMimeEncoder(49, new byte[] { 0x7e });
    byte[] encoded = encoder.encode(src);
    Decoder decoder = Base64.getMimeDecoder();
    byte[] decoded = decoder.decode(encoded);
    if (!Objects.deepEquals(src, decoded)) {
        throw new RuntimeException();
    }
}

源代码5 项目： jdk8u_jdk 文件： TestBase64Golden.java


private static void test1() throws Exception {
    byte[] src = new byte[] {
        46, -97, -35, -44, 127, -60, -39, -4, -112, 34, -57, 47, -14, 67,
        40, 18, 90, -59, 68, 112, 23, 121, -91, 94, 35, 49, 104, 17, 30,
        -80, -104, -3, -53, 27, 38, -72, -47, 113, -52, 18, 5, -126 };
    Encoder encoder = Base64.getMimeEncoder(49, new byte[] { 0x7e });
    byte[] encoded = encoder.encode(src);
    Decoder decoder = Base64.getMimeDecoder();
    byte[] decoded = decoder.decode(encoded);
    if (!Objects.deepEquals(src, decoded)) {
        throw new RuntimeException();
    }
}

源代码6 项目： jdk8u-dev-jdk 文件： TestBase64Golden.java


private static void test1() throws Exception {
    byte[] src = new byte[] {
        46, -97, -35, -44, 127, -60, -39, -4, -112, 34, -57, 47, -14, 67,
        40, 18, 90, -59, 68, 112, 23, 121, -91, 94, 35, 49, 104, 17, 30,
        -80, -104, -3, -53, 27, 38, -72, -47, 113, -52, 18, 5, -126 };
    Encoder encoder = Base64.getMimeEncoder(49, new byte[] { 0x7e });
    byte[] encoded = encoder.encode(src);
    Decoder decoder = Base64.getMimeDecoder();
    byte[] decoded = decoder.decode(encoded);
    if (!Objects.deepEquals(src, decoded)) {
        throw new RuntimeException();
    }
}

源代码7 项目： browserprint 文件： Encryption.java


/**
 * Decrypt an array of integers from a String.
 * 
 * @param encrypted
 * @param context
 * @return
 * @throws ServletException
 */
public static int[] decryptIntegers(String encrypted, String password) throws ServletException {
	String encryptedParts[] = encrypted.split("\\|");
	if (encryptedParts.length != 3) {
		throw new ServletException("Invalid encrypted string.");
	}

	/* Extract the encrypted data, initialisation vector, and salt from the cookie. */
	Decoder decoder = Base64.getDecoder();
	byte ciphertext[] = decoder.decode(encryptedParts[0]);
	byte iv[] = decoder.decode(encryptedParts[1]);
	byte salt[] = decoder.decode(encryptedParts[2]);
	byte plainbytes[];
	try {
		/* Derive the key, given password and salt. */
		SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
		KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 65536, 256);
		SecretKey tmp = factory.generateSecret(spec);
		SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");

		/* Decrypt the message, given derived key and initialization vector. */
		Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
		cipher.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(iv));
		plainbytes = cipher.doFinal(ciphertext);
	} catch (Exception ex) {
		throw new ServletException(ex);
	}
	IntBuffer buff = ByteBuffer.wrap(plainbytes).asIntBuffer();
	int integers[] = new int[buff.remaining()];
	for (int i = 0; i < integers.length; ++i) {
		integers[i] = buff.get();
	}
	return integers;
}

源代码8 项目： browserprint 文件： SampleIDs.java


/**
 * Decrypt an integer from a String.
 * 
 * @param encrypted
 * @param context
 * @return
 * @throws ServletException
 */
private static Integer decryptInteger(String encrypted, ServletContext context) throws ServletException {
	String encryptedParts[] = encrypted.split("\\|");
	if (encryptedParts.length != 3) {
		throw new ServletException("Invalid encrypted string.");
	}
	/* Get password. */
	String password = context.getInitParameter("SampleSetIDEncryptionPassword");

	/* Extract the encrypted data, initialisation vector, and salt from the cookie. */
	Decoder decoder = Base64.getDecoder();
	byte ciphertext[] = decoder.decode(encryptedParts[0]);
	byte iv[] = decoder.decode(encryptedParts[1]);
	byte salt[] = decoder.decode(encryptedParts[2]);
	byte plainbytes[];
	try {
		/* Derive the key, given password and salt. */
		SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
		KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 65536, 256);
		SecretKey tmp = factory.generateSecret(spec);
		SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");

		/* Decrypt the message, given derived key and initialization vector. */
		Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
		cipher.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(iv));
		plainbytes = cipher.doFinal(ciphertext);
	} catch (Exception ex) {
		throw new ServletException(ex);
	}
	return ByteBuffer.wrap(plainbytes).asIntBuffer().get();
}

源代码9 项目： openjdk-jdk8u-backup 文件： TestBase64Golden.java


private static void test1() throws Exception {
    byte[] src = new byte[] {
        46, -97, -35, -44, 127, -60, -39, -4, -112, 34, -57, 47, -14, 67,
        40, 18, 90, -59, 68, 112, 23, 121, -91, 94, 35, 49, 104, 17, 30,
        -80, -104, -3, -53, 27, 38, -72, -47, 113, -52, 18, 5, -126 };
    Encoder encoder = Base64.getMimeEncoder(49, new byte[] { 0x7e });
    byte[] encoded = encoder.encode(src);
    Decoder decoder = Base64.getMimeDecoder();
    byte[] decoded = decoder.decode(encoded);
    if (!Objects.deepEquals(src, decoded)) {
        throw new RuntimeException();
    }
}

源代码10 项目： openjdk-jdk9 文件： TestBase64Golden.java


private static void test1() throws Exception {
    byte[] src = new byte[] {
        46, -97, -35, -44, 127, -60, -39, -4, -112, 34, -57, 47, -14, 67,
        40, 18, 90, -59, 68, 112, 23, 121, -91, 94, 35, 49, 104, 17, 30,
        -80, -104, -3, -53, 27, 38, -72, -47, 113, -52, 18, 5, -126 };
    Encoder encoder = Base64.getMimeEncoder(49, new byte[] { 0x7e });
    byte[] encoded = encoder.encode(src);
    Decoder decoder = Base64.getMimeDecoder();
    byte[] decoded = decoder.decode(encoded);
    if (!Objects.deepEquals(src, decoded)) {
        throw new RuntimeException();
    }
}

源代码11 项目： jdk8u-jdk 文件： TestBase64Golden.java


private static void test1() throws Exception {
    byte[] src = new byte[] {
        46, -97, -35, -44, 127, -60, -39, -4, -112, 34, -57, 47, -14, 67,
        40, 18, 90, -59, 68, 112, 23, 121, -91, 94, 35, 49, 104, 17, 30,
        -80, -104, -3, -53, 27, 38, -72, -47, 113, -52, 18, 5, -126 };
    Encoder encoder = Base64.getMimeEncoder(49, new byte[] { 0x7e });
    byte[] encoded = encoder.encode(src);
    Decoder decoder = Base64.getMimeDecoder();
    byte[] decoded = decoder.decode(encoded);
    if (!Objects.deepEquals(src, decoded)) {
        throw new RuntimeException();
    }
}

源代码12 项目： jdk8u-jdk 文件： TestBase64Golden.java


public static void test0(Base64Type type, Encoder encoder, Decoder decoder,
                         String srcFile, String encodedFile) throws Exception {

    String[] srcLns = Files.readAllLines(Paths.get(SRCDIR, srcFile), DEF_CHARSET)
                           .toArray(new String[0]);
    String[] encodedLns = Files.readAllLines(Paths.get(SRCDIR, encodedFile),
                                             DEF_CHARSET)
                               .toArray(new String[0]);
    int lns = 0;
    for (String srcStr : srcLns) {
        String encodedStr = null;
        if (type != Base64Type.MIME) {
            encodedStr = encodedLns[lns++];
        } else {
            while (lns < encodedLns.length) {
                String s = encodedLns[lns++];
                if (s.length() == 0)
                    break;
                if (encodedStr != null) {
                    encodedStr += DEFAULT_CRLF + s;
                } else {
                    encodedStr = s;
                }
            }
            if (encodedStr == null && srcStr.length() == 0) {
                encodedStr = "";
            }
        }
        System.out.printf("%n    src[%d]: %s%n", srcStr.length(), srcStr);
        System.out.printf("encoded[%d]: %s%n", encodedStr.length(), encodedStr);

        byte[] srcArr = srcStr.getBytes(DEF_CHARSET);
        byte[] encodedArr = encodedStr.getBytes(DEF_CHARSET);

        ByteBuffer srcBuf = ByteBuffer.wrap(srcArr);
        ByteBuffer encodedBuf = ByteBuffer.wrap(encodedArr);
        byte[] resArr = new byte[encodedArr.length];

        // test int encode(byte[], byte[])
        int len = encoder.encode(srcArr, resArr);
        assertEqual(len, encodedArr.length);
        assertEqual(resArr, encodedArr);

        // test byte[] encode(byte[])
        resArr = encoder.encode(srcArr);
        assertEqual(resArr, encodedArr);

        // test ByteBuffer encode(ByteBuffer)
        int limit = srcBuf.limit();
        ByteBuffer resBuf = encoder.encode(srcBuf);
        assertEqual(srcBuf.position(), limit);
        assertEqual(srcBuf.limit(), limit);
        assertEqual(resBuf, encodedBuf);
        srcBuf.rewind(); // reset for next test

        // test String encodeToString(byte[])
        String resEncodeStr = encoder.encodeToString(srcArr);
        assertEqual(resEncodeStr, encodedStr);

        // test int decode(byte[], byte[])
        resArr = new byte[srcArr.length];
        len = decoder.decode(encodedArr, resArr);
        assertEqual(len, srcArr.length);
        assertEqual(resArr, srcArr);

        // test byte[] decode(byte[])
        resArr = decoder.decode(encodedArr);
        assertEqual(resArr, srcArr);

        // test ByteBuffer decode(ByteBuffer)
        limit = encodedBuf.limit();
        resBuf = decoder.decode(encodedBuf);
        assertEqual(encodedBuf.position(), limit);
        assertEqual(encodedBuf.limit(), limit);
        assertEqual(resBuf, srcBuf);
        encodedBuf.rewind(); // reset for next test

        // test byte[] decode(String)
        resArr = decoder.decode(encodedStr);
        assertEqual(resArr, srcArr);

        // test compatible with sun.misc.Base64Encoder
        if (type == Base64Type.MIME) {
            sun.misc.BASE64Encoder miscEncoder = new BASE64Encoder();
            sun.misc.BASE64Decoder miscDecoder = new BASE64Decoder();
            resArr = decoder.decode(miscEncoder.encode(srcArr));
            assertEqual(resArr, srcArr);

            resArr = encoder.encode(miscDecoder.decodeBuffer(encodedStr));
            assertEqual(new String(resArr, DEF_CHARSET), encodedStr);
        }
    }
}

源代码13 项目： dragonwell8_jdk 文件： TestBase64Golden.java


public static void test0(Base64Type type, Encoder encoder, Decoder decoder,
                         String srcFile, String encodedFile) throws Exception {

    String[] srcLns = Files.readAllLines(Paths.get(SRCDIR, srcFile), DEF_CHARSET)
                           .toArray(new String[0]);
    String[] encodedLns = Files.readAllLines(Paths.get(SRCDIR, encodedFile),
                                             DEF_CHARSET)
                               .toArray(new String[0]);
    int lns = 0;
    for (String srcStr : srcLns) {
        String encodedStr = null;
        if (type != Base64Type.MIME) {
            encodedStr = encodedLns[lns++];
        } else {
            while (lns < encodedLns.length) {
                String s = encodedLns[lns++];
                if (s.length() == 0)
                    break;
                if (encodedStr != null) {
                    encodedStr += DEFAULT_CRLF + s;
                } else {
                    encodedStr = s;
                }
            }
            if (encodedStr == null && srcStr.length() == 0) {
                encodedStr = "";
            }
        }
        System.out.printf("%n    src[%d]: %s%n", srcStr.length(), srcStr);
        System.out.printf("encoded[%d]: %s%n", encodedStr.length(), encodedStr);

        byte[] srcArr = srcStr.getBytes(DEF_CHARSET);
        byte[] encodedArr = encodedStr.getBytes(DEF_CHARSET);

        ByteBuffer srcBuf = ByteBuffer.wrap(srcArr);
        ByteBuffer encodedBuf = ByteBuffer.wrap(encodedArr);
        byte[] resArr = new byte[encodedArr.length];

        // test int encode(byte[], byte[])
        int len = encoder.encode(srcArr, resArr);
        assertEqual(len, encodedArr.length);
        assertEqual(resArr, encodedArr);

        // test byte[] encode(byte[])
        resArr = encoder.encode(srcArr);
        assertEqual(resArr, encodedArr);

        // test ByteBuffer encode(ByteBuffer)
        int limit = srcBuf.limit();
        ByteBuffer resBuf = encoder.encode(srcBuf);
        assertEqual(srcBuf.position(), limit);
        assertEqual(srcBuf.limit(), limit);
        assertEqual(resBuf, encodedBuf);
        srcBuf.rewind(); // reset for next test

        // test String encodeToString(byte[])
        String resEncodeStr = encoder.encodeToString(srcArr);
        assertEqual(resEncodeStr, encodedStr);

        // test int decode(byte[], byte[])
        resArr = new byte[srcArr.length];
        len = decoder.decode(encodedArr, resArr);
        assertEqual(len, srcArr.length);
        assertEqual(resArr, srcArr);

        // test byte[] decode(byte[])
        resArr = decoder.decode(encodedArr);
        assertEqual(resArr, srcArr);

        // test ByteBuffer decode(ByteBuffer)
        limit = encodedBuf.limit();
        resBuf = decoder.decode(encodedBuf);
        assertEqual(encodedBuf.position(), limit);
        assertEqual(encodedBuf.limit(), limit);
        assertEqual(resBuf, srcBuf);
        encodedBuf.rewind(); // reset for next test

        // test byte[] decode(String)
        resArr = decoder.decode(encodedStr);
        assertEqual(resArr, srcArr);

        // test compatible with sun.misc.Base64Encoder
        if (type == Base64Type.MIME) {
            sun.misc.BASE64Encoder miscEncoder = new BASE64Encoder();
            sun.misc.BASE64Decoder miscDecoder = new BASE64Decoder();
            resArr = decoder.decode(miscEncoder.encode(srcArr));
            assertEqual(resArr, srcArr);

            resArr = encoder.encode(miscDecoder.decodeBuffer(encodedStr));
            assertEqual(new String(resArr, DEF_CHARSET), encodedStr);
        }
    }
}

源代码14 项目： TencentKona-8 文件： TestBase64Golden.java


public static void test0(Base64Type type, Encoder encoder, Decoder decoder,
                         String srcFile, String encodedFile) throws Exception {

    String[] srcLns = Files.readAllLines(Paths.get(SRCDIR, srcFile), DEF_CHARSET)
                           .toArray(new String[0]);
    String[] encodedLns = Files.readAllLines(Paths.get(SRCDIR, encodedFile),
                                             DEF_CHARSET)
                               .toArray(new String[0]);
    int lns = 0;
    for (String srcStr : srcLns) {
        String encodedStr = null;
        if (type != Base64Type.MIME) {
            encodedStr = encodedLns[lns++];
        } else {
            while (lns < encodedLns.length) {
                String s = encodedLns[lns++];
                if (s.length() == 0)
                    break;
                if (encodedStr != null) {
                    encodedStr += DEFAULT_CRLF + s;
                } else {
                    encodedStr = s;
                }
            }
            if (encodedStr == null && srcStr.length() == 0) {
                encodedStr = "";
            }
        }
        System.out.printf("%n    src[%d]: %s%n", srcStr.length(), srcStr);
        System.out.printf("encoded[%d]: %s%n", encodedStr.length(), encodedStr);

        byte[] srcArr = srcStr.getBytes(DEF_CHARSET);
        byte[] encodedArr = encodedStr.getBytes(DEF_CHARSET);

        ByteBuffer srcBuf = ByteBuffer.wrap(srcArr);
        ByteBuffer encodedBuf = ByteBuffer.wrap(encodedArr);
        byte[] resArr = new byte[encodedArr.length];

        // test int encode(byte[], byte[])
        int len = encoder.encode(srcArr, resArr);
        assertEqual(len, encodedArr.length);
        assertEqual(resArr, encodedArr);

        // test byte[] encode(byte[])
        resArr = encoder.encode(srcArr);
        assertEqual(resArr, encodedArr);

        // test ByteBuffer encode(ByteBuffer)
        int limit = srcBuf.limit();
        ByteBuffer resBuf = encoder.encode(srcBuf);
        assertEqual(srcBuf.position(), limit);
        assertEqual(srcBuf.limit(), limit);
        assertEqual(resBuf, encodedBuf);
        srcBuf.rewind(); // reset for next test

        // test String encodeToString(byte[])
        String resEncodeStr = encoder.encodeToString(srcArr);
        assertEqual(resEncodeStr, encodedStr);

        // test int decode(byte[], byte[])
        resArr = new byte[srcArr.length];
        len = decoder.decode(encodedArr, resArr);
        assertEqual(len, srcArr.length);
        assertEqual(resArr, srcArr);

        // test byte[] decode(byte[])
        resArr = decoder.decode(encodedArr);
        assertEqual(resArr, srcArr);

        // test ByteBuffer decode(ByteBuffer)
        limit = encodedBuf.limit();
        resBuf = decoder.decode(encodedBuf);
        assertEqual(encodedBuf.position(), limit);
        assertEqual(encodedBuf.limit(), limit);
        assertEqual(resBuf, srcBuf);
        encodedBuf.rewind(); // reset for next test

        // test byte[] decode(String)
        resArr = decoder.decode(encodedStr);
        assertEqual(resArr, srcArr);

        // test compatible with sun.misc.Base64Encoder
        if (type == Base64Type.MIME) {
            sun.misc.BASE64Encoder miscEncoder = new BASE64Encoder();
            sun.misc.BASE64Decoder miscDecoder = new BASE64Decoder();
            resArr = decoder.decode(miscEncoder.encode(srcArr));
            assertEqual(resArr, srcArr);

            resArr = encoder.encode(miscDecoder.decodeBuffer(encodedStr));
            assertEqual(new String(resArr, DEF_CHARSET), encodedStr);
        }
    }
}

源代码15 项目： jdk8u_jdk 文件： TestBase64Golden.java


public static void test0(Base64Type type, Encoder encoder, Decoder decoder,
                         String srcFile, String encodedFile) throws Exception {

    String[] srcLns = Files.readAllLines(Paths.get(SRCDIR, srcFile), DEF_CHARSET)
                           .toArray(new String[0]);
    String[] encodedLns = Files.readAllLines(Paths.get(SRCDIR, encodedFile),
                                             DEF_CHARSET)
                               .toArray(new String[0]);
    int lns = 0;
    for (String srcStr : srcLns) {
        String encodedStr = null;
        if (type != Base64Type.MIME) {
            encodedStr = encodedLns[lns++];
        } else {
            while (lns < encodedLns.length) {
                String s = encodedLns[lns++];
                if (s.length() == 0)
                    break;
                if (encodedStr != null) {
                    encodedStr += DEFAULT_CRLF + s;
                } else {
                    encodedStr = s;
                }
            }
            if (encodedStr == null && srcStr.length() == 0) {
                encodedStr = "";
            }
        }
        System.out.printf("%n    src[%d]: %s%n", srcStr.length(), srcStr);
        System.out.printf("encoded[%d]: %s%n", encodedStr.length(), encodedStr);

        byte[] srcArr = srcStr.getBytes(DEF_CHARSET);
        byte[] encodedArr = encodedStr.getBytes(DEF_CHARSET);

        ByteBuffer srcBuf = ByteBuffer.wrap(srcArr);
        ByteBuffer encodedBuf = ByteBuffer.wrap(encodedArr);
        byte[] resArr = new byte[encodedArr.length];

        // test int encode(byte[], byte[])
        int len = encoder.encode(srcArr, resArr);
        assertEqual(len, encodedArr.length);
        assertEqual(resArr, encodedArr);

        // test byte[] encode(byte[])
        resArr = encoder.encode(srcArr);
        assertEqual(resArr, encodedArr);

        // test ByteBuffer encode(ByteBuffer)
        int limit = srcBuf.limit();
        ByteBuffer resBuf = encoder.encode(srcBuf);
        assertEqual(srcBuf.position(), limit);
        assertEqual(srcBuf.limit(), limit);
        assertEqual(resBuf, encodedBuf);
        srcBuf.rewind(); // reset for next test

        // test String encodeToString(byte[])
        String resEncodeStr = encoder.encodeToString(srcArr);
        assertEqual(resEncodeStr, encodedStr);

        // test int decode(byte[], byte[])
        resArr = new byte[srcArr.length];
        len = decoder.decode(encodedArr, resArr);
        assertEqual(len, srcArr.length);
        assertEqual(resArr, srcArr);

        // test byte[] decode(byte[])
        resArr = decoder.decode(encodedArr);
        assertEqual(resArr, srcArr);

        // test ByteBuffer decode(ByteBuffer)
        limit = encodedBuf.limit();
        resBuf = decoder.decode(encodedBuf);
        assertEqual(encodedBuf.position(), limit);
        assertEqual(encodedBuf.limit(), limit);
        assertEqual(resBuf, srcBuf);
        encodedBuf.rewind(); // reset for next test

        // test byte[] decode(String)
        resArr = decoder.decode(encodedStr);
        assertEqual(resArr, srcArr);

        // test compatible with sun.misc.Base64Encoder
        if (type == Base64Type.MIME) {
            sun.misc.BASE64Encoder miscEncoder = new BASE64Encoder();
            sun.misc.BASE64Decoder miscDecoder = new BASE64Decoder();
            resArr = decoder.decode(miscEncoder.encode(srcArr));
            assertEqual(resArr, srcArr);

            resArr = encoder.encode(miscDecoder.decodeBuffer(encodedStr));
            assertEqual(new String(resArr, DEF_CHARSET), encodedStr);
        }
    }
}

源代码16 项目： jdk8u-jdk 文件： TestBase64Golden.java


public static void test0(Base64Type type, Encoder encoder, Decoder decoder,
                         String srcFile, String encodedFile) throws Exception {

    String[] srcLns = Files.readAllLines(Paths.get(SRCDIR, srcFile), DEF_CHARSET)
                           .toArray(new String[0]);
    String[] encodedLns = Files.readAllLines(Paths.get(SRCDIR, encodedFile),
                                             DEF_CHARSET)
                               .toArray(new String[0]);
    int lns = 0;
    for (String srcStr : srcLns) {
        String encodedStr = null;
        if (type != Base64Type.MIME) {
            encodedStr = encodedLns[lns++];
        } else {
            while (lns < encodedLns.length) {
                String s = encodedLns[lns++];
                if (s.length() == 0)
                    break;
                if (encodedStr != null) {
                    encodedStr += DEFAULT_CRLF + s;
                } else {
                    encodedStr = s;
                }
            }
            if (encodedStr == null && srcStr.length() == 0) {
                encodedStr = "";
            }
        }
        System.out.printf("%n    src[%d]: %s%n", srcStr.length(), srcStr);
        System.out.printf("encoded[%d]: %s%n", encodedStr.length(), encodedStr);

        byte[] srcArr = srcStr.getBytes(DEF_CHARSET);
        byte[] encodedArr = encodedStr.getBytes(DEF_CHARSET);

        ByteBuffer srcBuf = ByteBuffer.wrap(srcArr);
        ByteBuffer encodedBuf = ByteBuffer.wrap(encodedArr);
        byte[] resArr = new byte[encodedArr.length];

        // test int encode(byte[], byte[])
        int len = encoder.encode(srcArr, resArr);
        assertEqual(len, encodedArr.length);
        assertEqual(resArr, encodedArr);

        // test byte[] encode(byte[])
        resArr = encoder.encode(srcArr);
        assertEqual(resArr, encodedArr);

        // test ByteBuffer encode(ByteBuffer)
        int limit = srcBuf.limit();
        ByteBuffer resBuf = encoder.encode(srcBuf);
        assertEqual(srcBuf.position(), limit);
        assertEqual(srcBuf.limit(), limit);
        assertEqual(resBuf, encodedBuf);
        srcBuf.rewind(); // reset for next test

        // test String encodeToString(byte[])
        String resEncodeStr = encoder.encodeToString(srcArr);
        assertEqual(resEncodeStr, encodedStr);

        // test int decode(byte[], byte[])
        resArr = new byte[srcArr.length];
        len = decoder.decode(encodedArr, resArr);
        assertEqual(len, srcArr.length);
        assertEqual(resArr, srcArr);

        // test byte[] decode(byte[])
        resArr = decoder.decode(encodedArr);
        assertEqual(resArr, srcArr);

        // test ByteBuffer decode(ByteBuffer)
        limit = encodedBuf.limit();
        resBuf = decoder.decode(encodedBuf);
        assertEqual(encodedBuf.position(), limit);
        assertEqual(encodedBuf.limit(), limit);
        assertEqual(resBuf, srcBuf);
        encodedBuf.rewind(); // reset for next test

        // test byte[] decode(String)
        resArr = decoder.decode(encodedStr);
        assertEqual(resArr, srcArr);

        // test compatible with sun.misc.Base64Encoder
        if (type == Base64Type.MIME) {
            sun.misc.BASE64Encoder miscEncoder = new BASE64Encoder();
            sun.misc.BASE64Decoder miscDecoder = new BASE64Decoder();
            resArr = decoder.decode(miscEncoder.encode(srcArr));
            assertEqual(resArr, srcArr);

            resArr = encoder.encode(miscDecoder.decodeBuffer(encodedStr));
            assertEqual(new String(resArr, DEF_CHARSET), encodedStr);
        }
    }
}

源代码17 项目： openjdk-jdk8u 文件： TestBase64Golden.java


public static void test0(Base64Type type, Encoder encoder, Decoder decoder,
                         String srcFile, String encodedFile) throws Exception {

    String[] srcLns = Files.readAllLines(Paths.get(SRCDIR, srcFile), DEF_CHARSET)
                           .toArray(new String[0]);
    String[] encodedLns = Files.readAllLines(Paths.get(SRCDIR, encodedFile),
                                             DEF_CHARSET)
                               .toArray(new String[0]);
    int lns = 0;
    for (String srcStr : srcLns) {
        String encodedStr = null;
        if (type != Base64Type.MIME) {
            encodedStr = encodedLns[lns++];
        } else {
            while (lns < encodedLns.length) {
                String s = encodedLns[lns++];
                if (s.length() == 0)
                    break;
                if (encodedStr != null) {
                    encodedStr += DEFAULT_CRLF + s;
                } else {
                    encodedStr = s;
                }
            }
            if (encodedStr == null && srcStr.length() == 0) {
                encodedStr = "";
            }
        }
        System.out.printf("%n    src[%d]: %s%n", srcStr.length(), srcStr);
        System.out.printf("encoded[%d]: %s%n", encodedStr.length(), encodedStr);

        byte[] srcArr = srcStr.getBytes(DEF_CHARSET);
        byte[] encodedArr = encodedStr.getBytes(DEF_CHARSET);

        ByteBuffer srcBuf = ByteBuffer.wrap(srcArr);
        ByteBuffer encodedBuf = ByteBuffer.wrap(encodedArr);
        byte[] resArr = new byte[encodedArr.length];

        // test int encode(byte[], byte[])
        int len = encoder.encode(srcArr, resArr);
        assertEqual(len, encodedArr.length);
        assertEqual(resArr, encodedArr);

        // test byte[] encode(byte[])
        resArr = encoder.encode(srcArr);
        assertEqual(resArr, encodedArr);

        // test ByteBuffer encode(ByteBuffer)
        int limit = srcBuf.limit();
        ByteBuffer resBuf = encoder.encode(srcBuf);
        assertEqual(srcBuf.position(), limit);
        assertEqual(srcBuf.limit(), limit);
        assertEqual(resBuf, encodedBuf);
        srcBuf.rewind(); // reset for next test

        // test String encodeToString(byte[])
        String resEncodeStr = encoder.encodeToString(srcArr);
        assertEqual(resEncodeStr, encodedStr);

        // test int decode(byte[], byte[])
        resArr = new byte[srcArr.length];
        len = decoder.decode(encodedArr, resArr);
        assertEqual(len, srcArr.length);
        assertEqual(resArr, srcArr);

        // test byte[] decode(byte[])
        resArr = decoder.decode(encodedArr);
        assertEqual(resArr, srcArr);

        // test ByteBuffer decode(ByteBuffer)
        limit = encodedBuf.limit();
        resBuf = decoder.decode(encodedBuf);
        assertEqual(encodedBuf.position(), limit);
        assertEqual(encodedBuf.limit(), limit);
        assertEqual(resBuf, srcBuf);
        encodedBuf.rewind(); // reset for next test

        // test byte[] decode(String)
        resArr = decoder.decode(encodedStr);
        assertEqual(resArr, srcArr);

        // test compatible with sun.misc.Base64Encoder
        if (type == Base64Type.MIME) {
            sun.misc.BASE64Encoder miscEncoder = new BASE64Encoder();
            sun.misc.BASE64Decoder miscDecoder = new BASE64Decoder();
            resArr = decoder.decode(miscEncoder.encode(srcArr));
            assertEqual(resArr, srcArr);

            resArr = encoder.encode(miscDecoder.decodeBuffer(encodedStr));
            assertEqual(new String(resArr, DEF_CHARSET), encodedStr);
        }
    }
}

源代码18 项目： multiapps-controller 文件： TokenFactory.java


private String decode(String string) {
    Decoder decoder = Base64.getUrlDecoder();
    return new String(decoder.decode(string), StandardCharsets.UTF_8);
}

源代码19 项目： jdk8u-dev-jdk 文件： TestBase64Golden.java


public static void test0(Base64Type type, Encoder encoder, Decoder decoder,
                         String srcFile, String encodedFile) throws Exception {

    String[] srcLns = Files.readAllLines(Paths.get(SRCDIR, srcFile), DEF_CHARSET)
                           .toArray(new String[0]);
    String[] encodedLns = Files.readAllLines(Paths.get(SRCDIR, encodedFile),
                                             DEF_CHARSET)
                               .toArray(new String[0]);
    int lns = 0;
    for (String srcStr : srcLns) {
        String encodedStr = null;
        if (type != Base64Type.MIME) {
            encodedStr = encodedLns[lns++];
        } else {
            while (lns < encodedLns.length) {
                String s = encodedLns[lns++];
                if (s.length() == 0)
                    break;
                if (encodedStr != null) {
                    encodedStr += DEFAULT_CRLF + s;
                } else {
                    encodedStr = s;
                }
            }
            if (encodedStr == null && srcStr.length() == 0) {
                encodedStr = "";
            }
        }
        System.out.printf("%n    src[%d]: %s%n", srcStr.length(), srcStr);
        System.out.printf("encoded[%d]: %s%n", encodedStr.length(), encodedStr);

        byte[] srcArr = srcStr.getBytes(DEF_CHARSET);
        byte[] encodedArr = encodedStr.getBytes(DEF_CHARSET);

        ByteBuffer srcBuf = ByteBuffer.wrap(srcArr);
        ByteBuffer encodedBuf = ByteBuffer.wrap(encodedArr);
        byte[] resArr = new byte[encodedArr.length];

        // test int encode(byte[], byte[])
        int len = encoder.encode(srcArr, resArr);
        assertEqual(len, encodedArr.length);
        assertEqual(resArr, encodedArr);

        // test byte[] encode(byte[])
        resArr = encoder.encode(srcArr);
        assertEqual(resArr, encodedArr);

        // test ByteBuffer encode(ByteBuffer)
        int limit = srcBuf.limit();
        ByteBuffer resBuf = encoder.encode(srcBuf);
        assertEqual(srcBuf.position(), limit);
        assertEqual(srcBuf.limit(), limit);
        assertEqual(resBuf, encodedBuf);
        srcBuf.rewind(); // reset for next test

        // test String encodeToString(byte[])
        String resEncodeStr = encoder.encodeToString(srcArr);
        assertEqual(resEncodeStr, encodedStr);

        // test int decode(byte[], byte[])
        resArr = new byte[srcArr.length];
        len = decoder.decode(encodedArr, resArr);
        assertEqual(len, srcArr.length);
        assertEqual(resArr, srcArr);

        // test byte[] decode(byte[])
        resArr = decoder.decode(encodedArr);
        assertEqual(resArr, srcArr);

        // test ByteBuffer decode(ByteBuffer)
        limit = encodedBuf.limit();
        resBuf = decoder.decode(encodedBuf);
        assertEqual(encodedBuf.position(), limit);
        assertEqual(encodedBuf.limit(), limit);
        assertEqual(resBuf, srcBuf);
        encodedBuf.rewind(); // reset for next test

        // test byte[] decode(String)
        resArr = decoder.decode(encodedStr);
        assertEqual(resArr, srcArr);

        // test compatible with sun.misc.Base64Encoder
        if (type == Base64Type.MIME) {
            sun.misc.BASE64Encoder miscEncoder = new BASE64Encoder();
            sun.misc.BASE64Decoder miscDecoder = new BASE64Decoder();
            resArr = decoder.decode(miscEncoder.encode(srcArr));
            assertEqual(resArr, srcArr);

            resArr = encoder.encode(miscDecoder.decodeBuffer(encodedStr));
            assertEqual(new String(resArr, DEF_CHARSET), encodedStr);
        }
    }
}

源代码20 项目： openjdk-jdk9 文件： TestBase64Golden.java


public static void test0(Base64Type type, Encoder encoder, Decoder decoder,
                         String srcFile, String encodedFile) throws Exception {

    String[] srcLns = Files.readAllLines(Paths.get(SRCDIR, srcFile), DEF_CHARSET)
                           .toArray(new String[0]);
    String[] encodedLns = Files.readAllLines(Paths.get(SRCDIR, encodedFile),
                                             DEF_CHARSET)
                               .toArray(new String[0]);
    int lns = 0;
    for (String srcStr : srcLns) {
        String encodedStr = null;
        if (type != Base64Type.MIME) {
            encodedStr = encodedLns[lns++];
        } else {
            while (lns < encodedLns.length) {
                String s = encodedLns[lns++];
                if (s.length() == 0)
                    break;
                if (encodedStr != null) {
                    encodedStr += DEFAULT_CRLF + s;
                } else {
                    encodedStr = s;
                }
            }
            if (encodedStr == null && srcStr.length() == 0) {
                encodedStr = "";
            }
        }
        System.out.printf("%n    src[%d]: %s%n", srcStr.length(), srcStr);
        System.out.printf("encoded[%d]: %s%n", encodedStr.length(), encodedStr);

        byte[] srcArr = srcStr.getBytes(DEF_CHARSET);
        byte[] encodedArr = encodedStr.getBytes(DEF_CHARSET);

        ByteBuffer srcBuf = ByteBuffer.wrap(srcArr);
        ByteBuffer encodedBuf = ByteBuffer.wrap(encodedArr);
        byte[] resArr = new byte[encodedArr.length];

        // test int encode(byte[], byte[])
        int len = encoder.encode(srcArr, resArr);
        assertEqual(len, encodedArr.length);
        assertEqual(resArr, encodedArr);

        // test byte[] encode(byte[])
        resArr = encoder.encode(srcArr);
        assertEqual(resArr, encodedArr);

        // test ByteBuffer encode(ByteBuffer)
        int limit = srcBuf.limit();
        ByteBuffer resBuf = encoder.encode(srcBuf);
        assertEqual(srcBuf.position(), limit);
        assertEqual(srcBuf.limit(), limit);
        assertEqual(resBuf, encodedBuf);
        srcBuf.rewind(); // reset for next test

        // test String encodeToString(byte[])
        String resEncodeStr = encoder.encodeToString(srcArr);
        assertEqual(resEncodeStr, encodedStr);

        // test int decode(byte[], byte[])
        resArr = new byte[srcArr.length];
        len = decoder.decode(encodedArr, resArr);
        assertEqual(len, srcArr.length);
        assertEqual(resArr, srcArr);

        // test byte[] decode(byte[])
        resArr = decoder.decode(encodedArr);
        assertEqual(resArr, srcArr);

        // test ByteBuffer decode(ByteBuffer)
        limit = encodedBuf.limit();
        resBuf = decoder.decode(encodedBuf);
        assertEqual(encodedBuf.position(), limit);
        assertEqual(encodedBuf.limit(), limit);
        assertEqual(resBuf, srcBuf);
        encodedBuf.rewind(); // reset for next test

        // test byte[] decode(String)
        resArr = decoder.decode(encodedStr);
        assertEqual(resArr, srcArr);

    }
}

方法所在类

java.util.Base64.Decoder