Go语言视频零基础入门到精通

javalearner

Base64是网络上最常见的用于加密传输8Bit字节代码的编码方式之一，大家可以查看RFC2045～RFC2049，上面有MIME的详细规范。

       Base64要求把每三个8Bit的字节转换为四个6Bit的字节（3*8 = 4*6 = 24），然后把6Bit再添两位高位0，组成四个8Bit的字节，也就是说，转换后的字符串理论上将要比原来的长1/3。

这样说会不会太抽象了？不怕，我们来看一个例子：
   
     
      
      转换前
      aaaaaabb
      ccccdddd
      eeffffff
      
      
      
      转换后
      00aaaaaa
      00bbcccc
      00ddddee
      00ffffff
      
     
   
     应该很清楚了吧？上面的三个字节是原文，下面的四个字节是转换后的Base64编码，其前两位均为0。

  
   
   
   

   
  
     转换后，我们用一个码表来得到我们想要的字符串（也就是最终的Base64编码），这个表是这样的：（摘自RFC2045）


                             Table 1: The Base64 Alphabet

       Value Encoding  Value Encoding  Value Encoding  Value Encoding
            0 A                  17 R                 34 i                  51 z
            1 B                  18 S                 35 j                  52 0
            2 C                  19 T                 36 k                 53 1
            3 D                  20 U                 37 l                  54 2
            4 E                  21 V                 38 m                55 3
            5 F                  22 W                 39 n                56 4
            6 G                  23 X                  40 o                57 5
            7 H                  24 Y                 41 p                 58 6
            8 I                   25 Z                 42 q                 59 7
            9 J                   26 a                 43 r                  60 8
           10 K                 27 b                 44 s                  61 9
           11 L                 28 c                  45 t                  62 +
           12 M                29 d                  46 u                  63 /
           13 N                30 e                  47 v
           14 O                31 f                  48 w                (pad) =
           15 P                32 g                  49 x
           16 Q                33 h                  50 y


让我们再来看一个实际的例子，加深印象！

  

  
   
   转换前
   10101101
   10111010
   01110110
   
   
   
   转换后
   00101011
   00011011
   00101001
   00110110
   
   
   十进制
   43
   27
   41
   54
   
   
   对应码表中的值
   r
   b
   p
   2
   
  
所以上面的24位编码，编码后的Base64值为 rbp2
解码同理，把 rbq2 的二进制位连接上再重组得到三个8位值，得出原码。
（解码只是编码的逆过程，在此我就不多说了，另外有关MIME的RFC还是有很多的，如果需要详细情况请自行查找。） 下面的Base64编码/解码程序来自网上。 一、用SUN的API解码和编码

1. import java.io.*;
   
2. import sun.misc.BASE64Decoder;
   
3. import sun.misc.BASE64Encoder;
   
4. public class Base64
   
5. {
   
6.   public static void main(String[] args) {
   
7.     if (args.length == 2) {
   
8.       String string = Base64.encode(args[0]);
   
9.       Base64.decode(string, args[1]);
   
10.     } else
    
11.       System.out.println("usage: java Base64 inputFile outputFile");
    
12.   }
    
13.   public static String encode(String fileName) {
    
14.     String string = null;
    
15.     try {
    
16.       InputStream in = new FileInputStream(fileName);
    
17.       // in.available()返回文件的字节长度
    
18.       byte[] bytes = new byte[in.available()];
    
19.       // 将文件中的内容读入到数组中
    
20.       in.read(bytes);
    
21.       string = new BASE64Encoder().encode(bytes);
    
22.       in.close();
    
23.     } catch (FileNotFoundException fe) {
    
24.       fe.printStackTrace();
    
25.     } catch(IOException ioe) {
    
26.       ioe.printStackTrace();
    
27.     }
    
28.     return string;
    
29.   }
    
30.   public static void decode(String string, String fileName) {
    
31.     try {
    
32.       // 解码，然后将字节转换为文件
    
33.       byte[] bytes = new BASE64Decoder().decodeBuffer(string);
    
34.       ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    
35.       byte[] buffer = new byte[1024];
    
36.       FileOutputStream out = new FileOutputStream(fileName);
    
37.       int bytesum = 0;
    
38.       int byteread = 0;
    
39.       while ((byteread = in.read(buffer)) != -1) {
    
40.         bytesum += byteread;
    
41.         out.write(buffer, 0, byteread);
    
42.       }
    
43.     } catch(IOException ioe) {
    
44.       ioe.printStackTrace();
    
45.     }
    
46.   }
    
47. }
    

复制代码

二、

1. 
   
2. /* @author CuCuChen
   
3. * @version $Id$
   
4. */
   
5. import java.io.*;
   
6. class Base64Helper {
7. 
   
8. //从文本文件对象中读取内容并转换为字符数组
   
9. public static char[] readChars(File file)
   
10. {
    
11.      CharArrayWriter caw = new CharArrayWriter();
    
12.      try
    
13.      {
    
14.          Reader fr = new FileReader(file);
    
15.         Reader in = new BufferedReader(fr);
    
16.          int count = 0;
    
17.          char[] buf = new char[16384];
    
18.         while ((count=in.read(buf)) != -1) {
    
19.              if (count > 0) caw.write(buf, 0, count);
    
20.          }
    
21.          in.close();
    
22.      }
    
23.      catch (Exception e) { e.printStackTrace(); }
    
24.      return caw.toCharArray();
    
25. }
26. 
    
27. //从字符串对象中读取内容并转换为字符数组
    
28. public static char[] readChars(String string)
    
29. {
    
30.      CharArrayWriter caw = new CharArrayWriter();
    
31.      try
    
32.      {
    
33.          Reader sr = new StringReader(string.trim());
    
34.         Reader in = new BufferedReader(sr);
    
35.          int count = 0;
    
36.          char[] buf = new char[16384];
    
37.         while ((count=in.read(buf)) != -1) {
    
38.              if (count > 0) caw.write(buf, 0, count);
    
39.          }
    
40.          in.close();
    
41.      }
    
42.      catch (Exception e) { e.printStackTrace(); }
    
43.      return caw.toCharArray();
    
44. }
45. 
    
46. //从二进制文件对象中读取内容并转换为字节数组
    
47. public static byte[] readBytes(File file)
    
48. {
    
49.      ByteArrayOutputStream baos = new ByteArrayOutputStream();
    
50.      try
    
51.      {
    
52.          InputStream fis = new FileInputStream(file);
    
53.          InputStream is = new BufferedInputStream(fis);
    
54.         int count = 0;
    
55.          byte[] buf = new byte[16384];
    
56.          while ((count=is.read(buf)) != -1) {
    
57.              if (count > 0) baos.write(buf, 0, count);
    
58.          }
    
59.          is.close();
    
60.     }
    
61.      catch (Exception e) { e.printStackTrace(); }
    
62.      return baos.toByteArray();
    
63. }
64. 
    
65. //写字节数组内容到二进制文件
    
66. public static void writeBytes(File file, byte[] data) {
    
67.      try {
    
68.          OutputStream fos = new FileOutputStream(file);
    
69.          OutputStream os = new BufferedOutputStream(fos);
    
70.          os.write(data);
    
71.          os.close();
    
72.      }
    
73.      catch (Exception e) { e.printStackTrace(); }
    
74. }
    
75. //写字符数组内容到文本文件
    
76. public static void writeChars(File file, char[] data) {
    
77.      try {
    
78.          Writer fos = new FileWriter(file);
    
79.          Writer os = new BufferedWriter(fos);
    
80.         os.write(data);
    
81.          os.close();
    
82.      }
    
83.      catch (Exception e) { e.printStackTrace(); }
    
84. }
    
85. }
    
86. 
    
87. public class Base64{
    
88. //编码文件对象所指的文件
    
89. static public char[] encode(File file){
    
90.   if (!file.exists()) {
    
91.   System.err.println("错误:文件不存在！");
    
92.   return null;
    
93.   }
    
94. return encode(Base64Helper.readBytes(file));
    
95. }
96. 
    
97. //编码文件名所指的文件
    
98. static public char[] encode(String filename){
    
99. File file = new File(filename);
    
100.   if (!file.exists()) {
     
101.   System.err.println("错误:文件“"+filename+"”不存在！");
     
102.   return null;
     
103.   }
     
104. return encode(Base64Helper.readBytes(file));
     
105. }
     
106. //编码传入的字节数组，输出编码后的字符数组
     
107. static public char[] encode(byte[] data)
     
108. {
     
109.   char[] out = new char[((data.length + 2) / 3) * 4];
     
110. //
     
111.   // 对字节进行Base64编码,每三个字节转化为4个字符.
     
112.   // 输出总是能被4整除的偶数个字符
     
113.   //
     
114.   for (int i=0, index=0; i< data.length; i+=3, index+=4) {
     
115.   boolean quad = false;
     
116.   boolean trip = false;
     
117.   int val = (0xFF & (int) data[i]);
     
118.   val <<= 8;
     
119.   if ((i+1) < data.length) {
     
120.   val |= (0xFF & (int) data[i+1]);
     
121.   trip = true;
     
122.   }
     
123.   val <<= 8;
     
124.   if ((i+2) < data.length) {
     
125.   val |= (0xFF & (int) data[i+2]);
     
126.   quad = true;
     
127.   }
     
128.   out[index+3] = alphabet[(quad? (val & 0x3F): 64)];
     
129.   val >>= 6;
     
130.   out[index+2] = alphabet[(trip? (val & 0x3F): 64)];
     
131.   val >>= 6;
     
132.   out[index+1] = alphabet[val & 0x3F];
     
133.   val >>= 6;
     
134.   out[index+0] = alphabet[val & 0x3F];
     
135.   }
     
136.     return out;
     
137. }
     
138. static public byte[] decode(char[] data)
     
139. {
     
140.   // 程序中有判断如果有回车、空格等非法字符，则要去掉这些字符
     
141.   // 这样就不会计算错误输出的内容
     
142.   int tempLen = data.length;
     
143.   for( int ix=0; ix< data.length; ix++ )
     
144.   {
     
145.   if( (data[ix] > 255) || codes[ data[ix] ] < 0 )
     
146.   --tempLen; // 去除无效的字符
     
147.   }
     
148.   // 计算byte的长度
     
149.   // -- 每四个有效字符输出三个字节的内容
     
150.   // -- 如果有额外的3个字符，则还要加上2个字节,
     
151.   // 或者如果有额外的2个字符，则要加上1个字节
     
152.   int len = (tempLen / 4) * 3;
     
153.   if ((tempLen % 4) == 3) len += 2;
     
154.   if ((tempLen % 4) == 2) len += 1;
     
155.   byte[] out = new byte[len];
     
156.   int shift = 0;
     
157.   int accum = 0;
     
158.   int index = 0;
     
159.   // 一个一个字符地解码（注意用的不是tempLen的值进行循环）
     
160.   for (int ix=0; ix< data.length; ix++)
     
161.   {
     
162.   int value = (data[ix]>255)? -1: codes[ data[ix] ];
     
163.   if ( value >= 0 ) // 忽略无效字符
     
164.   {
     
165.   accum <<= 6;
     
166.   shift += 6;
     
167.   accum |= value;
     
168.   if ( shift >= 8 )
     
169.   {
     
170.   shift -= 8;
     
171.   out[index++] =
     
172.   (byte) ((accum >> shift) & 0xff);
     
173.   }
     
174.   }
     
175.   }
     
176.   //如果数组长度和实际长度不符合，那么抛出错误
     
177.   if( index != out.length)
     
178.   {
     
179.   throw new Error("数据长度不一致(实际写入了 " + index + "字节，但是系统指示有" + out.length + "字节)");
     
180.   }
     
181.   return out;
     
182. }
     
183. //
     
184. // 用于编码的字符
     
185. //
     
186. static private char[] alphabet ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();
     
187. //
     
188. // 用于解码的字节（0-255）
     
189. //
     
190. static private byte[] codes = new byte[256];
     
191. static {
     
192.   for (int i=0; i<256; i++) codes[i] = -1;
     
193.   for (int i = "A"; i <= "Z"; i++) codes[i] = (byte)( i - "A");
     
194.   for (int i = "a"; i <= "z"; i++) codes[i] = (byte)(26 + i - "a");
     
195.   for (int i = "0"; i <= "9"; i++) codes[i] = (byte)(52 + i - "0");
     
196.   codes["+"] = 62;
     
197.   codes["/"] = 63;
     
198. }
     
199. public static void main (String [] args){
     
200.   String key = new String("Spider");
     
201.   byte[] a = key.getBytes();
     
202.   char[] b = Base64.encode(a) ;
     
203.   System.out.println(new String(b));
     
204.    //for(int i=0;i< b.length;i++){
     
205.    //  System.out.println(b[i]);
     
206.    //}
     
207.   byte[] c = Base64. decode(b);
     
208.   System.out.println(new String(c));
     
209. }
     
210. }  
     
211. 运行结果：
     
212. C:java>java Base64
213. U3BpZGVy
214. Spider

复制代码

  
  
   
   

     
   

     
   
  



源码下载：http://file.javaxxz.com/2014/11/8/000503375.zip