Décodage base64 Chaîne Java 5
https://stackoverflow.com/questions/917604
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Y at-il une voie à suivre directement à décoder une chaîne base64 en utilisant seulement les JAVA 1.5 BIBLIOTHEQUES?
Je dois utiliser Java 1.5 en raison de problèmes de compatibilité inter-plateformes entre Windows et Mac OS X (Mac uniquement 10.5 prend en charge Java 1.6, tout inférieur à 10,5 a Java 1.5 par défaut).
L'objet "sun.misc.Base64Decoder" existe en Java 6, mais pas en Java 5.
La solution
Non, il est impossible sur la base juste en utilisant JDK 5.0.
Vous aurez besoin de rouler votre propre implémentation (il est pas difficile) ou d'utiliser de préférence l'une des implémentations open source. Il y a beaucoup, y compris Commons Codec qui fournit base64 http://commons.apache.org/codec/api-release/org/apache/commons/codec/binary/Base64.html
JavaMail fournit également l'encodage base64 / décodage via MimeUtility qui également cité l'encodage imprimable etc ...
http://java.sun.com/ produits / javamail / javadocs / javax / mail / internet / MimeUtility.html
Autres conseils
Pour votre information, vous devez utiliser ce même en Java 6. ne pas utiliser les classes soleil. *
Il suffit d'utiliser http://iharder.sourceforge.net/current/java/base64/ . Il est dans le domaine public. Ainsi, vous pouvez simplement laisser tomber le code dans votre projet sans se soucier des problèmes de licence ou autres, y compris les pots. La classe que vous cherchez ne figure pas dans JDK 1.5.
Voici ma version - il devrait être complètement autonome:
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
Il y a aussi différentes implémentations sur cette page: http: //www.rgagnon. com / javadetails / java-0598.html
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
