JAVA实现MD5文件校验

MD5 的中文名叫做 “信息摘要算法第五版”，是一种不可逆的算法。通俗的话说就是没办法通过任何算法来对其加密的值进行破解。MD5经常被应用在验证文件一致性、数字证书和安全访问认证方面。

MD5 可以对任何文件产生独一无二的数字指纹，文件有任何改动，MD5 值的数据指纹都会发生变化。

一、环境的使用
在 Eclipse 中添加 swing 插件。在 help 中找到 install new software 添加源：

http://download.eclipse.org/windowbuilder/WB/release/R201406251200/4.4/

选择select All 勾选全部插件。

选择 select All 就可以勾选全部插件了。
选择后我们点击 next 进行下一步。

在这里，我们需要选择 I accept the terms of the license agreement

点击安装 Finish，安装完成之后重启 Eclipse。
二、公共类编写
首先我们创建一个 Java 的项目，名为 MD5 ，然后创建一个创建一个包，名为 com.mysiming.util，作为公共包，之后我们在包中创建名为 MD5 Util 类，该类主要编写 MD5 的算法，作为公共类调用。

import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.math.BigInteger;import java.nio.MappedByteBuffer;import java.nio.channels.FileChannel;import java.security.MessageDigest;public class Md5Util {       // 标准的构造函数，调用md5Init函数进行初始化工作     public Md5Util() {         md5Init();         return;     }     // RFC1321中定义的标准4*4矩阵的常量定义。     static final int S11 = 7, S12 = 12, S13 = 17, S14 = 22;     static final int S21 = 5, S22 = 9, S23 = 14, S24 = 20;     static final int S31 = 4, S32 = 11, S33 = 16, S34 = 23;     static final int S41 = 6, S42 = 10, S43 = 15, S44 = 21;     // 按RFC1321标准定义不可变byte型数组PADDING     static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };     // MD5计算过程中的3组核心数据，采用数组形式存放     private long[] state = new long[4]; // 计算状态(分别对应a b c d)     private byte[] buffer = new byte[64]; // 分配64个字节私有缓冲区     private long[] count = new long[2]; // 位个数     // 最新一次计算结果的16进制ASCII字符串表示，代表了16个字符串形式的MD5值     public String resultStr;     // 最新一次计算结果的2进制数组表示，一共16个字节，代表了128bit形式的MD5值     public byte[] digest = new byte[16];     /**     * 获得两次MD5加密的字符串     * @param str     * @return     */     public String getTwiceMD5ofString(String str){         return getMD5ofStr(getMD5ofStr(str));     }     /**     * MD5_Encoding类提供的主要的接口函数getMD5ofStr，用来进行数据加密变换。调用其可对任意字符串进行加密运算，并以字符串形式返回加密结果。     * @param in     * @return     */     public String getMD5ofStr(String in) {         md5Init(); // 初始化         md5Update(in.getBytes(), in.length());// 调用MD5的主计算过程         md5Final(); // 输出结果到digest数组中         for (int i = 0; i < 16; i++) {             resultStr += byteToHEX(digest[i]); // 将digest数组中的每个byte型数据转为16进制形式的字符串         }         return resultStr;     }     // md5初始化函数.初始化核心变量.     private void md5Init() {         state[0] = 0x67452301L; // 定义state为RFC1321中定义的标准幻数         state[1] = 0xefcdab89L; // 定义state为RFC1321中定义的标准幻数         state[2] = 0x98badcfeL; // 定义state为RFC1321中定义的标准幻数         state[3] = 0x10325476L; // 定义state为RFC1321中定义的标准幻数         count[0] = count[1] = 0L; // 初始化为0         resultStr = "";// 初始化resultStr字符串为空         for (int i = 0; i < 16; i++)             digest[i] = 0;// 初始化digest数组元素为0         return;     }     // 定义F G H I 为4个基数 ，即为4个基本的MD5函数,进行简单的位运算     private long F(long x, long y, long z) {         return (x & y) | ((~x) & z);     }     private long G(long x, long y, long z) {         return (x & z) | (y & (~z));     }     private long H(long x, long y, long z) {         return x ^ y ^ z;     }     private long I(long x, long y, long z) {         return y ^ (x | (~z));     }     // FF,GG,HH和II调用F,G,H,I函数进行进一步变换     private long FF(long a, long b, long c, long d, long x, long s, long ac) {         a += F(b, c, d) + x + ac;         a = ((int) a << s) | ((int) a >>> (32 - s)); // 这里long型数据右移时使用无符号右移运算符>>>         a += b;         return a;     }     private long GG(long a, long b, long c, long d, long x, long s, long ac) {         a += G(b, c, d) + x + ac;         a = ((int) a << s) | ((int) a >>> (32 - s)); // 这里long型数据右移时使用无符号右移运算符>>>         a += b;         return a;     }     private long HH(long a, long b, long c, long d, long x, long s, long ac) {         a += H(b, c, d) + x + ac;         a = ((int) a << s) | ((int) a >>> (32 - s));// 这里long型数据右移时使用无符号右移运算符>>>         a += b;         return a;     }     private long II(long a, long b, long c, long d, long x, long s, long ac) {         a += I(b, c, d) + x + ac;         a = ((int) a << s) | ((int) a >>> (32 - s));// 这里long型数据右移时使用无符号右移运算符>>>         a += b;         return a;     }     // MD5的主计算过程，input是需要变换的二进制字节串，inputlen是长度     private void md5Update(byte[] input, int inputLen) {         int i = 0, index, partLen;         byte[] block = new byte[64]; // 分配64个字节缓冲区         // 根据count计算index值。这里long型数据右移时使用无符号右移运算符>>>         index = (int) (count[0] >>> 3) & 0x3F;         if ((count[0] += (inputLen << 3)) < (inputLen << 3))             count[1]++;         count[1] += (inputLen >>> 29); // 这里int型数据右移时使用无符号右移运算符>>>         partLen = 64 - index; // 计算partLen值         if (inputLen >= partLen) {             md5Memcpy(buffer, input, index, 0, partLen);             md5Transform(buffer);             for (i = partLen; i + 63 < inputLen; i += 64) {                 md5Memcpy(block, input, 0, i, 64);                 md5Transform(block);             }             index = 0;         } else             i = 0;         md5Memcpy(buffer, input, index, i, inputLen - i);     }     // 整理和填写输出结果，结果放到数组digest中。     private void md5Final() {         byte[] bits = new byte[8];         int index, padLen;         Encode(bits, count, 8);         index = (int) (count[0] >>> 3) & 0x3f; // 这里long型数据右移时使用无符号右移运算符>>>         padLen = (index < 56) ? (56 - index) : (120 - index);         md5Update(PADDING, padLen);         md5Update(bits, 8);         Encode(digest, state, 16);     }     // byte数组的块拷贝函数，将input数组中的起始位置为inpos，长//度len的数据拷贝到output数组起始位置outpos处。     private void md5Memcpy(byte[] output, byte[] input, int outpos, int inpos, int len) {         int i;         for (i = 0; i < len; i++)             output[outpos + i] = input[inpos + i];     }     // MD5核心变换计算程序，由md5Update函数调用，block是分块的原//始字节数组     private void md5Transform(byte block[]) {         long a = state[0], b = state[1], c = state[2], d = state[3];         long[] x = new long[16];         Decode(x, block, 64);         // 进行4级级联运算         // 第1级         a = FF(a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */         d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */         c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */         b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */         a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */         d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */         c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */         b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */         a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */         d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */         c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */         b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */         a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */         d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */         c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */         b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */         // 第2级         a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */         d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */         c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */         b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */         a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */         d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */         c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */         b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */         a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */         d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */         c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */         b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */         a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */         d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */         c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */         b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */         // 第3级         a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */         d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */         c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */         b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */         a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */         d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */         c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */         b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */         a = HH(a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */         d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */         c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */         b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */         a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */         d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */         c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */         b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */         // 第4级         a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */         d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */         c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */         b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */         a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */         d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */         c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */         b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */         a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */         d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */         c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */         b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */         a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */         d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */         c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */         b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */         // 分别累加到state[0],state[1],state[2],state[3]         state[0] += a;         state[1] += b;         state[2] += c;         state[3] += d;     }     // 把byte型数据转换为无符号long型数据     private static long byteToul(byte b) {         return b > 0 ? b : (b & 0x7F + 128);     }     // 把byte类型的数据转换成十六进制ASCII字符表示     private static String byteToHEX(byte in) {         char[] DigitStr = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };         char[] out = new char[2];         out[0] = DigitStr[(in >> 4) & 0x0F]; // 取高4位         out[1] = DigitStr[in & 0x0F]; // 取低4位         String s = new String(out);         return s;     }     // 将long型数组按顺序拆成byte型数组,长度为len     private void Encode(byte[] output, long[] input, int len) {         int i, j;         for (i = 0, j = 0; j < len; i++, j += 4) {             output[j] = (byte) (input[i] & 0xffL);             output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);             output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);             output[j + 3] = (byte) ((input[i] >>> 24) & 0xffL);         }     }     // 将byte型数组按顺序合成long型数组，长度为len     private void Decode(long[] output, byte[] input, int len) {         int i, j;         for (i = 0, j = 0; j < len; i++, j += 4)             output[i] = byteToul(input[j]) | (byteToul(input[j + 1]) << 8) | (byteToul(input[j + 2]) << 16) | (byteToul(input[j + 3]) << 24);         return;     }    public static String getMd5ByFile(File file) {          String value = null;          FileInputStream in = null;        try {            in = new FileInputStream(file);        } catch (FileNotFoundException e1) {            e1.printStackTrace();        }      try {          MappedByteBuffer byteBuffer = in.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, file.length());          MessageDigest md5 = MessageDigest.getInstance("MD5");          md5.update(byteBuffer);          BigInteger bi = new BigInteger(1, md5.digest());          value = bi.toString(16);      } catch (Exception e) {          e.printStackTrace();      } finally {              if(null != in) {                  try {                  in.close();              } catch (IOException e) {                  e.printStackTrace();              }          }      }      return value;      }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384

三、图形界面
创建一个 swing 的图像类。创建一个名为 com.mysiming.view 的包，然后创建一个名为 MD5Frame 的 JFrame 的类，我们按下 ctrl+n 找到 JFrame 然后创建。

点击 Design 就能直接进行图形化界面的编辑。首先我们创建两个 JButton 分别命名为 Bowse 与 Cout Md5 这两个按钮主要负责获取文件以及计算 Md5 的值。然后我们创建两个 JTextField 用于显示文件与 Md5 值。最后我们还需要创建两个 JLabel 分别命名为 set File 与 Md5.

在 Bowse 按钮上点击右键，获取点击事件.
在 public void actionPerformed(ActionEvent e) 方法中我们写入：

jfc = new JFileChooser();int result = jfc.showOpenDialog(null);String filepath = "";                if (result == JFileChooser.APPROVE_OPTION){    filepath = jfc.getSelectedFile().getAbsolutePath();            textField.setText(filepath);}
1
2
3
4
5
6
7
1
2
3
4
5
6
7

在Cout Md5 按钮上获取事件代码：

File file = jfc.getSelectedFile();String filemd5 = MD5Util.getMd5ByFile(file);textField_1.setText(filemd5);
1
2
3
1
2
3

图形界面源代码：

package com.mysiming.view;import java.awt.BorderLayout;import java.awt.EventQueue;import javax.swing.JFileChooser;import javax.swing.JFrame;import javax.swing.JPanel;import javax.swing.border.EmptyBorder;import com.mysiming.util.Md5Util;import java.awt.Color;import javax.swing.JLayeredPane;import javax.swing.JTree;import java.awt.Button;import java.awt.event.ActionListener;import java.io.File;import java.awt.event.ActionEvent;import javax.swing.JTextField;import javax.swing.JLabel;public class frame extends JFrame {    private JPanel contentPane;    private JTextField textField;    private JTextField textField_1;    /**     * Launch the application.     */    public static void main(String[] args) {        EventQueue.invokeLater(new Runnable() {            public void run() {                try {                    frame frame = new frame();                    frame.setVisible(true);                } catch (Exception e) {                    e.printStackTrace();                }            }        });    }    /**     * Create the frame.     */    public frame() {        setBackground(Color.PINK);        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);        setBounds(100, 100, 450, 300);        contentPane = new JPanel();        contentPane.setBackground(Color.PINK);        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));        contentPane.setLayout(new BorderLayout(0, 0));        setContentPane(contentPane);        JLayeredPane layeredPane = new JLayeredPane();        layeredPane.setBackground(Color.CYAN);        contentPane.add(layeredPane, BorderLayout.CENTER);        /**         * JFileChooser 是Java Swing提供的文件选择对话框         * */        JFileChooser jfc = new JFileChooser();//构造一个指向用户默认目录的 JFileChooser。        Button btnSet = new Button("Browse");//Browse按钮用于获取文件        btnSet.addActionListener(new ActionListener() {//Browse按钮 的 监听事件            public void actionPerformed(ActionEvent arg0) {                int result = jfc.showOpenDialog(null);//弹出一个 "Open File" 文件选择器对话框。                String filepath = ""; //初始化变量filepath(文件路径)                            if (result == JFileChooser.APPROVE_OPTION){//JFileChooser.APPROVE_OPTION是个整型                    //常量，代表0，当返回0值时，执行相关操作。                    filepath = jfc.getSelectedFile().getAbsolutePath();//获得你选择的文件的绝对路径                              textField.setText(filepath);//将选择的文件的绝对路径在文本框textField中显示。                            }            }        });        btnSet.setBounds(269, 48, 76, 23);        layeredPane.add(btnSet);        Button btnMd = new Button("Count Md5");//********Count Md5用于计算MD5值***********        btnMd.addActionListener(new ActionListener() {//Count Md5按钮的监听事件            public void actionPerformed(ActionEvent e) {                File file = jfc.getSelectedFile();//返回选中的文件                String filemd5 = Md5Util.getMd5ByFile(file);//得到文件的MD5值                textField_1.setText(filemd5);//将文件的MD5值在文本框textField中显示出来。            }        });        btnMd.setBounds(269, 110, 76, 23);        layeredPane.add(btnMd);        textField = new JTextField();        textField.setBounds(116, 50, 66, 21);        layeredPane.add(textField);        textField.setColumns(10);        textField_1 = new JTextField();        textField_1.setBounds(116, 112, 66, 21);        layeredPane.add(textField_1);        textField_1.setColumns(10);        JLabel lblSetFile = new JLabel("set File");        lblSetFile.setBounds(27, 56, 54, 15);        layeredPane.add(lblSetFile);        JLabel lblMd5 = new JLabel("Md5");        lblMd5.setBounds(49, 118, 54, 15);        layeredPane.add(lblMd5);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

最后保存运行。

MD5_Encoding 类提供的主要的接口函数getMD5ofStr,用来进行数据加密交换。 调用其可以对任意字符串进行加密运算，并以字符串形式返回加密结果