Giải mã chuỗi Java BASE64 utf8

Question

Tôi đang sử dụng org.apache.commons.codec.binary.Base64 làm chuỗi giải mã là utf8. Đôi khi tôi nhận được chuỗi mã hóa base64 mà sau khi giải mã trông giống như ví dụ ^@k��@@. Làm thế nào tôi có thể kiểm tra xem base64 là đúng hay nếu chuỗi utf8 được giải mã là chuỗi utf8 hợp lệ?

Để làm rõ. Tôi đang sử dụng

public static String base64Decode(String str) { 
    try { 
     return new String(base64Decode(str.getBytes(Constants.UTF_8)), Constants.UTF_8); 
    } catch (UnsupportedEncodingException e) { 
     ... 
    } 
} 

public static byte[] base64Decode(byte[] byteArray) { 
    return Base64.decodeBase64(byteArray); 
} 

Answer 1

Bạn nên xác định các charset trong chuyển đổi String để byte[] và ngược lại.

byte[] bytes = string.getBytes("UTF-8"); 
// feed bytes to Base64 

và

// get bytes from Base64 
String string = new String(bytes, "UTF-8"); 

Nếu không mã hóa mặc định nền tảng sẽ được sử dụng mà không nhất thiết phải là UTF-8 cho mỗi gia nhập.

Answer 2

Hãy thử điều này:

var B64 = { 
    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/=', 
    lookup: null, 
    ie: /MSIE /.test(navigator.userAgent), 
    ieo: /MSIE [67]/.test(navigator.userAgent), 
    encode: function (s) { 
     var buffer = B64.toUtf8(s), 
      position = -1, 
      len = buffer.length, 
      nan1, nan2, enc = [, , , ]; 
     if (B64.ie) { 
      var result = []; 
      while (++position < len) { 
       nan1 = buffer[position + 1], nan2 = buffer[position + 2]; 
       enc[0] = buffer[position] >> 2; 
       enc[1] = ((buffer[position] & 3) << 4) | (buffer[++position] >> 4); 
       if (isNaN(nan1)) enc[2] = enc[3] = 64; 
       else { 
        enc[2] = ((buffer[position] & 15) << 2) | (buffer[++position] >> 6); 
        enc[3] = (isNaN(nan2)) ? 64 : buffer[position] & 63; 
       } 
       result.push(B64.alphabet[enc[0]], B64.alphabet[enc[1]], B64.alphabet[enc[2]], B64.alphabet[enc[3]]); 
      } 
      return result.join(''); 
     } else { 
      result = ''; 
      while (++position < len) { 
       nan1 = buffer[position + 1], nan2 = buffer[position + 2]; 
       enc[0] = buffer[position] >> 2; 
       enc[1] = ((buffer[position] & 3) << 4) | (buffer[++position] >> 4); 
       if (isNaN(nan1)) enc[2] = enc[3] = 64; 
       else { 
        enc[2] = ((buffer[position] & 15) << 2) | (buffer[++position] >> 6); 
        enc[3] = (isNaN(nan2)) ? 64 : buffer[position] & 63; 
       } 
       result += B64.alphabet[enc[0]] + B64.alphabet[enc[1]] + B64.alphabet[enc[2]] + B64.alphabet[enc[3]]; 
      } 
      return result; 
     } 
    }, 
    decode: function (s) { 
     var buffer = B64.fromUtf8(s), 
      position = 0, 
      len = buffer.length; 
     if (B64.ieo) { 
      result = []; 
      while (position < len) { 
       if (buffer[position] < 128) result.push(String.fromCharCode(buffer[position++])); 
       else if (buffer[position] > 191 && buffer[position] < 224) result.push(String.fromCharCode(((buffer[position++] & 31) << 6) | (buffer[position++] & 63))); 
       else result.push(String.fromCharCode(((buffer[position++] & 15) << 12) | ((buffer[position++] & 63) << 6) | (buffer[position++] & 63))); 
      } 
      return result.join(''); 
     } else { 
      result = ''; 
      while (position < len) { 
       if (buffer[position] < 128) result += String.fromCharCode(buffer[position++]); 
       else if (buffer[position] > 191 && buffer[position] < 224) result += String.fromCharCode(((buffer[position++] & 31) << 6) | (buffer[position++] & 63)); 
       else result += String.fromCharCode(((buffer[position++] & 15) << 12) | ((buffer[position++] & 63) << 6) | (buffer[position++] & 63)); 
      } 
      return result; 
     } 
    }, 
    toUtf8: function (s) { 
     var position = -1, 
      len = s.length, 
      chr, buffer = []; 
     if (/^[\x00-\x7f]*$/.test(s)) while (++position < len) 
     buffer.push(s.charCodeAt(position)); 
     else while (++position < len) { 
      chr = s.charCodeAt(position); 
      if (chr < 128) buffer.push(chr); 
      else if (chr < 2048) buffer.push((chr >> 6) | 192, (chr & 63) | 128); 
      else buffer.push((chr >> 12) | 224, ((chr >> 6) & 63) | 128, (chr & 63) | 128); 
     } 
     return buffer; 
    }, 
    fromUtf8: function (s) { 
     var position = -1, 
      len, buffer = [], 
      enc = [, , , ]; 
     if (!B64.lookup) { 
      len = B64.alphabet.length; 
      B64.lookup = {}; 
      while (++position < len) 
      B64.lookup[B64.alphabet[position]] = position; 
      position = -1; 
     } 
     len = s.length; 
     while (position < len) { 
      enc[0] = B64.lookup[s.charAt(++position)]; 
      enc[1] = B64.lookup[s.charAt(++position)]; 
      buffer.push((enc[0] << 2) | (enc[1] >> 4)); 
      enc[2] = B64.lookup[s.charAt(++position)]; 
      if (enc[2] == 64) break; 
      buffer.push(((enc[1] & 15) << 4) | (enc[2] >> 2)); 
      enc[3] = B64.lookup[s.charAt(++position)]; 
      if (enc[3] == 64) break; 
      buffer.push(((enc[2] & 3) << 6) | enc[3]); 
     } 
     return buffer; 
    } 
}; 

Xem Here

Answer 3

Tôi tạo ra phương pháp này:

public static String descodificarDeBase64(String stringCondificado){ 
    try { 
     return new String(Base64.decode(stringCondificado.getBytes("UTF-8"),Base64.DEFAULT)); 
    } catch (UnsupportedEncodingException e) { 
     e.printStackTrace(); 
     return ""; 
    } 
} 

Vì vậy, tôi có thể giải mã từ Base64 characthers Tây Ban Nha như a, n, i, ü.

Ví dụ:

descodificarDeBase64("wr9xdcOpIHRhbD8="); 

sẽ trở lại: ¿Que tal?