是否有一种直接的方法可以仅使用 JAVA 1.5 库来解码 Base64 字符串?

由于 Windows 和 Mac OS X 之间的跨平台兼容性问题,我必须使用 Java 1.5(只有 Mac 10.5 支持 Java 1.6,低于 10.5 的所有版本都默认使用 Java 1.5)。

对象“sun.misc.Base64Decoder”存在于 Java 6 中,但不存在于 Java 5 中。

有帮助吗?

解决方案

没有,它基于只使用JDK 5.0是不可能的。

您将需要推出自己的实现(这并不难),或者最好使用开源实现之一。有很多,包括共享编解码器提供的Base64 http://commons.apache.org/codec/api-release/org/apache/commons/codec/binary/Base64.html

的JavaMail还提供Base64编码/经由MimeUtility解码这也确实引述可打印的编码等...

http://java.sun.com/产品/ javamail的/ javadocs中/的javax /邮件/互联网/ MimeUtility.html

其他提示

Apache 通用编解码器

仅供参考,即使在 Java 6 中您也应该使用它。 不要在阳光下使用课程。*

只要使用 http://iharder.sourceforge.net/current/java/base64/ 。它是在公共领域。所以,你可以只下降代码到您的项目,而不用担心牌照问题还是包括其他罐子。你正在寻找的类是在JDK 1.5。

下面是我的版本 - 它应该是完全独立的:

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

有也这个页面上各种实施方式: HTTP://www.rgagnon。 COM / javadetails / java的0598.html

许可以下: CC-BY-SA归因
不隶属于 StackOverflow
scroll top