Base64加密、解密

package util;

import java.io.UnsupportedEncodingException;

/**
 * Provides encoding of raw bytes to base64-encoded characters, and decoding of
 * base64 characters to raw bytes.
 *
 * @author Kevin Kelley (kelley@ruralnet.net)
 * @version 1.3
 * @date 06 August 1998
 * @modified 14 February 2000
 * @modified 22 September 2000
 */
public class Base64
{

 private static final String URL_ENCODE = "UTF-8";
 
 private static final String BASE64_ENCODE = "GBK";
 
 public static String encodeURL(String str)
 {
  try
  {
   str = java.net.URLEncoder.encode(str, URL_ENCODE);
  } catch (UnsupportedEncodingException e)
  {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return str;
 }
 
 public static String decodeURL(String str)
 {
  try
  {
   str = java.net.URLDecoder.decode(str, URL_ENCODE);
  } catch (UnsupportedEncodingException e)
  {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return str;
 }
 
 /**
  * returns an array of base64-encoded characters to represent the passed
  * data array.
  *
  * @param data
  *            the array of bytes to encode
  * @return base64-coded character array.
  */
 static public char[] encode(byte[] data)
 {
  char[] out = new char[((data.length + 2) / 3) * 4];

  // 
  // 3 bytes encode to 4 chars. Output is always an even
  // multiple of 4 characters.
  // 
  for (int i = 0, index = 0; i < data.length; i += 3, index += 4)
  {
   boolean quad = false;
   boolean trip = false;

   int val = (0xFF & (int) data[i]);
   val <<= 8;
   if ((i + 1) < data.length)
   {
    val |= (0xFF & (int) data[i + 1]);
    trip = true;
   }
   val <<= 8;
   if ((i + 2) < data.length)
   {
    val |= (0xFF & (int) data[i + 2]);
    quad = true;
   }
   out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];
   val >>= 6;
   out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];
   val >>= 6;
   out[index + 1] = alphabet[val & 0x3F];
   val >>= 6;
   out[index + 0] = alphabet[val & 0x3F];
  }
  return out;
 }

 /**
  * Decodes a BASE-64 encoded stream to recover the original data. White
  * space before and after will be trimmed away, but no other manipulation of
  * the input will be performed.
  *
  * As of version 1.2 this method will properly handle input containing junk
  * characters (newlines and the like) rather than throwing an error. It does
  * this by pre-parsing the input and generating from that a count of VALID
  * input characters.
  */
 static public byte[] decode(char[] data)
 {
  // as our input could contain non-BASE64 data (newlines,
  // whitespace of any sort, whatever) we must first adjust
  // our count of USABLE data so that...
  // (a) we don't misallocate the output array, and
  // (b) think that we miscalculated our data length
  // just because of extraneous throw-away junk

  int tempLen = data.length;
  for (int ix = 0; ix < data.length; ix++)
  {
   if ((data[ix] > 255) || codes[data[ix]] < 0)
    --tempLen; // ignore non-valid chars and padding
  }
  // calculate required length:
  // -- 3 bytes for every 4 valid base64 chars
  // -- plus 2 bytes if there are 3 extra base64 chars,
  // or plus 1 byte if there are 2 extra.

  int len = (tempLen / 4) * 3;
  if ((tempLen % 4) == 3)
   len += 2;
  if ((tempLen % 4) == 2)
   len += 1;

  byte[] out = new byte[len];

  int shift = 0; // # of excess bits stored in accum
  int accum = 0; // excess bits
  int index = 0;

  // we now go through the entire array (NOT using the 'tempLen' value)
  for (int ix = 0; ix < data.length; ix++)
  {
   int value = (data[ix] > 255) ? -1 : codes[data[ix]];

   if (value >= 0) // skip over
   // non-code
   {
    accum <<= 6; // bits
    // shift up
    // by 6 each
    // time thru
    shift += 6; // loop,
    // with new
    // bits
    // being put
    // in
    accum |= value; // at the
    // bottom.
    if (shift >= 8) // whenever
    // there are
    // 8 or more
    // shifted
    // in,
    {
     shift -= 8; // write
     // them out
     // (from the
     // top,
     // leaving
     // any
     out[index++] = // excess at the
     // bottom for
     // next
     // iteration.
     (byte) ((accum >> shift) & 0xff);
    }
   }
   // we will also have skipped processing a padding null byte
   // ('=') here;
   // these are used ONLY for padding to an even length and do not
   // legally
   // occur as encoded data. for this reason we can ignore the fact
   // that
   // no index++ operation occurs in that special case: the out[]
   // array is
   // initialized to all-zero bytes to start with and that works to
   // our
   // advantage in this combination.
  }

  // if there is STILL something wrong we just have to throw up now!
  if (index != out.length)
  {
   throw new Error("Miscalculated   data   length   (wrote   " + index
     + "   instead   of   " + out.length + ")");
  }

  return out;
 }

 /**
  * added by Neal
  *
  * @param str
  *            String
  * @return String
  */

 public static String encodeString(String str)
 {
  byte[] bt = null;
  try
  {
   bt = str.getBytes(BASE64_ENCODE);
  } catch (UnsupportedEncodingException e)
  {
   // TODO Auto-generated catch block
   bt = str.getBytes();
   e.printStackTrace();
  }
  
  char[] cArray = Base64.encode(bt);
  return new String(cArray);
 }

 /**
  * added by Neal
  *
  * @param str
  *            String
  * @return String
  */
 public static String decodeString(String str)
 {
  char[] cArray = str.toCharArray();
  byte[] bt = Base64.decode(cArray);
  return (new String(bt));
 }

 // 
 // code characters for values 0..63
 // 
 static private char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
   .toCharArray();

 // 
 // lookup table for converting base64 characters to value in range 0..63
 // 
 static private byte[] codes = new byte[256];
 static
 {
  for (int i = 0; i < 256; i++)
   codes[i] = -1;
  for (int i = 'A'; i <= 'Z'; i++)
   codes[i] = (byte) (i - 'A');
  for (int i = 'a'; i <= 'z'; i++)
   codes[i] = (byte) (26 + i - 'a');
  for (int i = '0'; i <= '9'; i++)
   codes[i] = (byte) (52 + i - '0');
  codes['+'] = 62;
  codes['/'] = 63;
 }
 
 public static void main(String[] args)
 {
  String str = "中文测试";
  String encodeStr = Base64.encodeURL(Base64.encodeString(str));
  System.out.println(encodeStr);
  System.out.println(Base64.decodeString(Base64.decodeURL(encodeStr)));
 }
}