Decode Base64 String Java 5

Question

Esiste un modo semplice per decodificare una stringa base64 utilizzando SOLO LE LIBRERIE JAVA 1.5?

Devo utilizzare Java 1.5 a causa di problemi di compatibilità multipiattaforma tra Windows e Mac OS X (solo Mac 10.5 supporta Java 1.6, tutto inferiore a 10.5 ha Java 1.5 come predefinito).

L'oggetto "sun.misc.Base64Decoder" esiste in Java 6, ma non in Java 5.

Answer 1

No, non è possibile sulla base di solo usando JDK 5.0.

Avrai bisogno di implementare la tua implementazione (non è così difficile) o preferibilmente utilizzare una delle implementazioni open source. Ci sono un sacco tra cui Commons Codec che fornisce Base64 http://commons.apache.org/codec/api-release/org/apache/commons/codec/binary/Base64.html

JavaMail fornisce anche la codifica Base64/decodifica tramite MimeUtility che non cita anche la codifica stampabile ecc ...

http://java.sun.com/products/javamail/javadocs/javax/mail/internet/MimeUtility.html

Answer 2

Basta usare http://iharder.sourceforge.net/current/java/base64/. È di dominio pubblico. Quindi puoi semplicemente inserire il codice nel tuo progetto senza preoccuparti di problemi di licenza o di includere altri vasi. La classe che stai cercando non è in JDK 1.5.

Answer 3

Ci sono anche diverse implementazioni in questa pagina: http://www.rgagnon.com/javadetails/java-0598.html

Answer 4

Apache Commons Codec

FYI, si dovrebbe utilizzare questo anche in Java 6. Don't use classes in sun.*

Answer 5

Ecco la mia versione - dovrebbe essere completamente standalone: ​​

public class Base64 
{ 

// ***************************************************************************** 
// INSTANCE PROPERTIES 
// ***************************************************************************** 

private String       lineSeparator; 
private int        lineLength; 

// ***************************************************************************** 
// INSTANCE CONSTRUCTION/INITIALIZATON/FINALIZATION, OPEN/CLOSE 
// ***************************************************************************** 

public Base64() { 
    lineSeparator=System.getProperty("line.separator"); 
    lineLength=0; 
    } 

// ***************************************************************************** 
// INSTANCE METHODS 
// ***************************************************************************** 

public String encode(byte[] bin) { 
    return encode(bin,0,bin.length); 
    } 
/** 
* Encode an array of bytes as Base64. 
* It will be broken into lines if the line length is not 0. If broken into lines, 
* the last line is not terminated with a line separator. 
* 
* param ba   The byte array to encode. 
*/ 
public String encode(byte[] bin, int str, int len) { 
    int         ol;          // output length 
    StringBuffer      sb;          // string buffer for output(must be local for recursion to work). 
    int         lp;          // line position(must be local for recursion to work). 
    int         el;          // even multiple of 3 length 
    int         ll;          // leftover length 

    // CREATE OUTPUT BUFFER 
    ol=(((len+2)/3)*4); 
    if(lineLength!=0) { 
     int lines=(((ol+lineLength-1)/lineLength)-1); 
     if(lines>0) { ol+=(lines*lineSeparator.length()); } 
     } 
    sb=new StringBuffer(ol); 
    lp=0; 

    // EVEN MULTIPLES OF 3 
    el=(len/3)*3; 
    ll=(len-el); 
    for(int xa=0; xa<el; xa+=3) { 
     int cv; 
     int c0,c1,c2,c3; 

     if(lineLength!=0) { 
      lp+=4; 
      if(lp>lineLength) { sb.append(lineSeparator); lp=4; } 
      } 

     // get next three bytes in unsigned form lined up, in big-endian order 
     cv =(bin[xa+str+0]&0xFF); cv<<=8; 
     cv|=(bin[xa+str+1]&0xFF); cv<<=8; 
     cv|=(bin[xa+str+2]&0xFF); 

     // break those 24 bits into a 4 groups of 6 bits, working LSB to MSB. 
     c3=cv&0x3F; cv >>>=6; 
     c2=cv&0x3F; cv >>>=6; 
     c1=cv&0x3F; cv >>>=6; 
     c0=cv&0x3F; 

     // Translate into the equivalent alpha character emitting them in big-endian order. 
     sb.append(ENCODE[c0]); 
     sb.append(ENCODE[c1]); 
     sb.append(ENCODE[c2]); 
     sb.append(ENCODE[c3]); 
     } 

    // LEFTOVERS 
    if(lineLength!=0 && ll>0) { 
     lp+=4; 
     if(lp>lineLength) { sb.append(lineSeparator); lp=4; } 
     } 
    if(ll==1) { 
     sb.append(encode(new byte[] { bin[el+str], 0, 0 }).substring(0,2)).append("==");   // Use recursion so escaping logic is not repeated, replacing last 2 chars with "==". 
     } 
    else if(ll==2) { 
     sb.append(encode(new byte[] { bin[el+str], bin[el+str+1], 0 }).substring(0,3)).append("="); // Use recursion so escaping logic is not repeated, replacing last char and "=". 
     } 
    if(ol!=sb.length()) { throw new RuntimeException("Error in Base64 encoding method: Calculated output length of "+ol+" did not match actual length of "+sb.length()); } 
    return sb.toString(); 
    } 

public byte[] decode(String b64) { 
    return decode(b64,0,b64.length()); 
    } 

/** 
* Decode a Base64 string to an array of bytes. 
* The string must have a length evenly divisible by 4 (not counting line separators and other 
* ignorable characters, like whitespace). 
*/ 
public byte[] decode(String b64, int str, int len) { 
    byte[]        ba;          // target byte array 
    int         dc;          // decode cycle (within sequence of 4 input chars). 
    int         rv;          // reconstituted value 
    int         ol;          // output length 
    int         pc;          // padding count 

    ba=new byte[(len/4)*3];              // create array to largest possible size. 
    dc=0; 
    rv=0; 
    ol=0; 
    pc=0; 

    for(int xa=0; xa<len; xa++) { 
     int ch=b64.charAt(xa+str); 
     int value=(ch<=255 ? DECODE[ch] : IGNORE); 
     if(value!=IGNORE) { 
      if(value==PAD) { 
       value=0; 
       pc++; 
       } 
      switch(dc) { 
       case 0: { 
        rv=value; 
        dc=1; 
        } break; 

       case 1: { 
        rv<<=6; 
        rv|=value; 
        dc=2; 
        } break; 

       case 2: { 
        rv<<=6; 
        rv|=value; 
        dc=3; 
        } break; 

       case 3: { 
        rv<<=6; 
        rv|=value; 

        // Completed a cycle of 4 chars, so recombine the four 6-bit values in big-endian order 
        ba[ol+2]=(byte)rv; rv>>>=8; 
        ba[ol+1]=(byte)rv; rv>>>=8; 
        ba[ol]=(byte)rv; ol+=3; 
        dc=0; 
        } break; 
       } 
      } 
     } 
    if(dc!=0) { 
     throw new ArrayIndexOutOfBoundsException("Base64 data given as input was not an even multiple of 4 characters (should be padded with '=' characters)."); 
     } 
    ol-=pc; 
    if(ba.length!=ol) { 
     byte[] b2=new byte[ol]; 
     System.arraycopy(ba, 0, b2, 0, ol); 
     ba=b2; 
     } 
    return ba; 
    } 

/** 
* Set maximum line length for encoded lines. 
* Ignored by decode. 
* @param len  Length of each line. 0 means no newlines inserted. Must be a multiple of 4. 
*/ 
public void setLineLength(int len) { 
    this.lineLength=(len/4)*4; 
    } 

/** 
* Set the line separator sequence for encoded lines. 
* Ignored by decode. 
* Usually contains only a combination of chars \n and \r, but could be any chars except 'A'-'Z', 'a'-'z', '0'-'9', '+' and '/'. 
* @param linsep  Line separator - may be "" but not null. 
*/ 
public void setLineSeparator(String linsep) { 
    this.lineSeparator=linsep; 
    } 

// ***************************************************************************** 
// STATIC PROPERTIES 
// ***************************************************************************** 

static private final char[]    ENCODE=new char[64];     // translation array for encoding 
static private final int[]    DECODE=new int[256];     // translation array for decoding 
static private final int    IGNORE=-1;        // flag for values to ignore when decoding 
static private final int    PAD=-2;         // flag value for padding value when decoding 

static private final Base64    BASE64=new Base64();     // default converter 

// ***************************************************************************** 
// STATIC INIT & MAIN 
// ***************************************************************************** 

static { 
    for(int xa=0; xa<=25; xa++) { ENCODE[xa]=(char)('A'+xa); }     // 0..25 -> 'A'..'Z' 
    for(int xa=0; xa<=25; xa++) { ENCODE[xa+26]=(char)('a'+xa); }    // 26..51 -> 'a'..'z' 
    for(int xa=0; xa<= 9; xa++) { ENCODE[xa+52]=(char)('0'+xa); }    // 52..61 -> '0'..'9' 
    ENCODE[62]='+'; 
    ENCODE[63]='/'; 

    for(int xa=0; xa<256; xa++) { DECODE[xa]=IGNORE;  }      // set all chars to IGNORE, first 
    for(int xa=0; xa< 64; xa++) { DECODE[ENCODE[xa]]=xa; }      // set the Base 64 chars to their integer byte values 
    DECODE['=']=PAD; 
    } 

// ***************************************************************************** 
// STATIC METHODS 
// ***************************************************************************** 

static public String toString(byte[] dta) { 
    return BASE64.encode(dta); 
    } 

static public String toString(byte[] dta, int str, int len) { 
    return BASE64.encode(dta,str,len); 
    } 

static public byte[] toBytes(String b64) { 
    return BASE64.decode(b64); 
    } 

static public byte[] toBytes(String b64, int str, int len) { 
    return BASE64.decode(b64,str,len); 
    } 

} // END PUBLIC CLASS