java中常用的对称加密与非对称加密

特殊说明

所有的算法都有main方法，可直接运行

对称机密

同一个秘钥

DES

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**

• 对称加密 【DES】

• @author it
  */
  public class DESUtil {
  private static final String KEY_ALGORITHM = “DES”;
  private static final String DEFAULT_CIPHER_ALGORITHM = “DES/ECB/PKCS5Padding”;// 默认的加密算法

  /**

  • DES 加密操作

  • @return 返回Base64转码后的加密数据
    */
    public static String encrypt(String content, String key) {
    try {
    Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器

     byte[] byteContent = content.getBytes("utf-8");
    
     cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器
    
     byte[] result = cipher.doFinal(byteContent);// 加密
    
     return Base64.getEncoder().encodeToString(result);// 通过Base64转码返回
    

    } catch (Exception ex) {
    Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  /**

  • DES 解密操作
    */
    public static String decrypt(String content, String key) {

    try {
    // 实例化
    Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

     // 使用**初始化，设置为解密模式
     cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));
    
     // 执行操作
     byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));
    
     return new String(result, "utf-8");
    

    } catch (Exception ex) {
    Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  /**

  • 生成加密秘钥

  • @return
    */
    private static SecretKeySpec getSecretKey(final String key) {
    // 返回生成指定算法**生成器的 KeyGenerator 对象
    KeyGenerator kg = null;

    try {
    kg = KeyGenerator.getInstance(KEY_ALGORITHM);

     // DES 要求**长度为 56
     kg.init(56, new SecureRandom(key.getBytes()));
    
     // 生成一个**
     SecretKey secretKey = kg.generateKey();
    
     return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为DES专用**
    

    } catch (NoSuchAlgorithmException ex) {
    Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  public static void main(String[] args) {
  String content = “hello,您好，李四，我喜欢你，这个内容加密了，别人不知道的”;
  String key = “[email protected]*^hsff%dfs$r344&df8543*er”;
  System.out.println(“原始内容:” + content);
  String s1 = DESUtil.encrypt(content, key);
  System.out.println(“加密后:” + s1);
  System.out.println(“解密后:” + DESUtil.decrypt(s1, key));
  }
  }

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
3DES

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**

• 对称加密 【3DES】

• @author it
  */
  public class TripDESUtil {
  private static final String KEY_ALGORITHM = “DESede”;
  private static final String DEFAULT_CIPHER_ALGORITHM = “DESede/ECB/PKCS5Padding”;// 默认的加密算法

  /**

  • DESede 加密操作

  • @return 返回Base64转码后的加密数据
    */
    public static String encrypt(String content, String key) {
    try {
    Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器

     byte[] byteContent = content.getBytes("utf-8");
    
     cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器
    
     byte[] result = cipher.doFinal(byteContent);// 加密
    
     return Base64.getEncoder().encodeToString(result);// 通过Base64转码返回
    

    } catch (Exception ex) {
    Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  /**

  • DESede 解密操作
    */
    public static String decrypt(String content, String key) {

    try {
    // 实例化
    Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

     // 使用**初始化，设置为解密模式
     cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));
    
     // 执行操作
     byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));
    
     return new String(result, "utf-8");
    

    } catch (Exception ex) {
    Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  /**

  • 生成加密秘钥
    */
    private static SecretKeySpec getSecretKey(final String key) {
    // 返回生成指定算法**生成器的 KeyGenerator 对象
    KeyGenerator kg = null;

    try {
    kg = KeyGenerator.getInstance(KEY_ALGORITHM);

     // DESede
     kg.init(new SecureRandom(key.getBytes()));
    
     // 生成一个**
     SecretKey secretKey = kg.generateKey();
    
     return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为DESede专用**
    

    } catch (NoSuchAlgorithmException ex) {
    Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  public static void main(String[] args) {
  String content = “hello,您好，李四，我喜欢你，这个内容加密了，别人不知道的”;
  String key = “[email protected]*^hsff%dfs$r344&df8543*er”;
  System.out.println(“原始内容:” + content);
  String s1 = TripDESUtil.encrypt(content, key);
  System.out.println(“加密后:” + s1);
  System.out.println(“解密后:” + TripDESUtil.decrypt(s1, key));
  }
  }

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
AES

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**

• 对称加密 【AES】

• @author it
  */
  public class AESUtil {
  private static final String KEY_ALGORITHM = “AES”;
  private static final String DEFAULT_CIPHER_ALGORITHM = “AES/ECB/PKCS5Padding”;// 默认的加密算法

  /**

  • AES 加密操作

  • @return 返回Base64转码后的加密数据
    */
    public static String encrypt(String content, String key) {
    try {
    Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器

     byte[] byteContent = content.getBytes("utf-8");
    
     cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器
    
     byte[] result = cipher.doFinal(byteContent);// 加密
    
     return Base64.getEncoder().encodeToString(result);// 通过Base64转码返回
    

    } catch (Exception ex) {
    Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  /**

  • AES 解密操作
    */
    public static String decrypt(String content, String key) {

    try {
    // 实例化
    Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

     // 使用**初始化，设置为解密模式
     cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));
    
     // 执行操作
     byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));
    
     return new String(result, "utf-8");
    

    } catch (Exception ex) {
    Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  /**

  • 生成加密秘钥
    */
    private static SecretKeySpec getSecretKey(final String key) {
    // 返回生成指定算法**生成器的 KeyGenerator 对象
    KeyGenerator kg = null;

    try {
    kg = KeyGenerator.getInstance(KEY_ALGORITHM);

     // AES 要求**长度为 128
     kg.init(128, new SecureRandom(key.getBytes()));
    
     // 生成一个**
     SecretKey secretKey = kg.generateKey();
    
     return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用**
    

    } catch (NoSuchAlgorithmException ex) {
    Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
    }

    return null;
    }

  public static void main(String[] args) {
  String content = “hello,您好，李四，我喜欢你，这个内容加密了，别人不知道的”;
  String key = “[email protected]*^hsff%dfs$r344&df8543*er”;
  System.out.println(“原始内容:” + content);
  String s1 = AESUtil.encrypt(content, key);
  System.out.println(“加密后:” + s1);
  System.out.println(“解密后:” + AESUtil.decrypt(s1, key));
  }
  }

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
非对称机密

RSA

import java.io.ByteArrayOutputStream;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

/**

• RSA公钥/私钥/签名工具包
• 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
• 字符串格式的**在未在特殊说明情况下都为BASE64编码格式
  
• 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，
  
• 非对称加密算法可以用来对对称加密的**加密，这样保证**的安全也就保证了数据的安全

*/
public class RSAUtils {

/**
 * 加密算法RSA
 */
public static final String KEY_ALGORITHM = "RSA";

/**
 * 签名算法
 */
public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

/**
 * 获取公钥的key
 */
private static final String PUBLIC_KEY = "RSAPublicKey";

/**
 * 获取私钥的key
 */
private static final String PRIVATE_KEY = "RSAPrivateKey";

/**
 * RSA最大加密明文大小
 */
private static final int MAX_ENCRYPT_BLOCK = 117;

/**
 * RSA最大解密密文大小
 */
private static final int MAX_DECRYPT_BLOCK = 128;

/**
 * <p>
 * 用私钥对信息生成数字签名
 * </p>
 *
 * @param data
 *            已加密数据
 * @param privateKey
 *            私钥(BASE64编码)
 *
 * @return
 * @throws Exception
 */
public static String sign(byte[] data, String privateKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(privateKey);
	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
	Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
	signature.initSign(privateK);
	signature.update(data);
	return Base64Utils.encode(signature.sign());
}

/**
 * <p>
 * 校验数字签名
 * </p>
 *
 * @param data
 *            已加密数据
 * @param publicKey
 *            公钥(BASE64编码)
 * @param sign
 *            数字签名
 *
 * @return
 * @throws Exception
 *
 */
public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
	byte[] keyBytes = Base64Utils.decode(publicKey);
	X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	PublicKey publicK = keyFactory.generatePublic(keySpec);
	Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
	signature.initVerify(publicK);
	signature.update(data);
	return signature.verify(Base64Utils.decode(sign));
}

/**
 * <P>
 * 私钥解密
 * </p>
 *
 * @param encryptedData
 *            已加密数据
 * @param privateKey
 *            私钥(BASE64编码)
 * @return
 * @throws Exception
 */
public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(privateKey);
	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
	cipher.init(Cipher.DECRYPT_MODE, privateK);
	int inputLen = encryptedData.length;
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	int offSet = 0;
	byte[] cache;
	int i = 0;
	// 对数据分段解密
	while (inputLen - offSet > 0) {
		if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
			cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
		} else {
			cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
		}
		out.write(cache, 0, cache.length);
		i++;
		offSet = i * MAX_DECRYPT_BLOCK;
	}
	byte[] decryptedData = out.toByteArray();
	out.close();
	return decryptedData;
}

/**
 * <p>
 * 公钥解密
 * </p>
 *
 * @param encryptedData
 *            已加密数据
 * @param publicKey
 *            公钥(BASE64编码)
 * @return
 * @throws Exception
 */
public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(publicKey);
	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	Key publicK = keyFactory.generatePublic(x509KeySpec);
	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
	cipher.init(Cipher.DECRYPT_MODE, publicK);
	int inputLen = encryptedData.length;
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	int offSet = 0;
	byte[] cache;
	int i = 0;
	// 对数据分段解密
	while (inputLen - offSet > 0) {
		if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
			cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
		} else {
			cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
		}
		out.write(cache, 0, cache.length);
		i++;
		offSet = i * MAX_DECRYPT_BLOCK;
	}
	byte[] decryptedData = out.toByteArray();
	out.close();
	return decryptedData;
}

/**
 * <p>
 * 公钥加密
 * </p>
 *
 * @param data
 *            源数据
 * @param publicKey
 *            公钥(BASE64编码)
 * @return
 * @throws Exception
 */
public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(publicKey);
	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	Key publicK = keyFactory.generatePublic(x509KeySpec);
	// 对数据加密
	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
	cipher.init(Cipher.ENCRYPT_MODE, publicK);
	int inputLen = data.length;
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	int offSet = 0;
	byte[] cache;
	int i = 0;
	// 对数据分段加密
	while (inputLen - offSet > 0) {
		if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
			cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
		} else {
			cache = cipher.doFinal(data, offSet, inputLen - offSet);
		}
		out.write(cache, 0, cache.length);
		i++;
		offSet = i * MAX_ENCRYPT_BLOCK;
	}
	byte[] encryptedData = out.toByteArray();
	out.close();
	return encryptedData;
}

/**
 * <p>
 * 私钥加密
 * </p>
 *
 * @param data
 *            源数据
 * @param privateKey
 *            私钥(BASE64编码)
 * @return
 * @throws Exception
 */
public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(privateKey);
	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
	cipher.init(Cipher.ENCRYPT_MODE, privateK);
	int inputLen = data.length;
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	int offSet = 0;
	byte[] cache;
	int i = 0;
	// 对数据分段加密
	while (inputLen - offSet > 0) {
		if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
			cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
		} else {
			cache = cipher.doFinal(data, offSet, inputLen - offSet);
		}
		out.write(cache, 0, cache.length);
		i++;
		offSet = i * MAX_ENCRYPT_BLOCK;
	}
	byte[] encryptedData = out.toByteArray();
	out.close();
	return encryptedData;
}

/**
 * <p>
 * 生成**对(公钥和私钥)
 * </p>
 *
 * @return
 * @throws Exception
 */
public static Map<String, Object> genKeyPair() throws Exception {
	KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
	keyPairGen.initialize(1024);
	KeyPair keyPair = keyPairGen.generateKeyPair();
	RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
	RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
	Map<String, Object> keyMap = new HashMap<String, Object>(2);
	keyMap.put(PUBLIC_KEY, publicKey);
	keyMap.put(PRIVATE_KEY, privateKey);
	return keyMap;
}

/**
 * <p>
 * 获取私钥
 * </p>
 *
 * @param keyMap
 *            **对
 * @return
 * @throws Exception
 */
public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
	Key key = (Key) keyMap.get(PRIVATE_KEY);
	return Base64Utils.encode(key.getEncoded());
}

/**
 * <p>
 * 获取公钥
 * </p>
 *
 * @param keyMap
 *            **对
 * @return
 * @throws Exception
 */
public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
	Key key = (Key) keyMap.get(PUBLIC_KEY);
	return Base64Utils.encode(key.getEncoded());
}

public static void main(String[] args) throws Exception {
	Map<String, Object> keyPairs = RSAUtils.genKeyPair();
	String privateKey = RSAUtils.getPrivateKey(keyPairs);
	String publicKey = RSAUtils.getPublicKey(keyPairs);

	System.out.println("私钥：" + privateKey);
	System.out.println("公钥：" + publicKey);

	// 公钥加密，私钥解密
	String content = "hello,您好，李四，我喜欢你，这个内容加密了，别人不知道的";
	byte[] encryptedData = RSAUtils.encryptByPublicKey(content.getBytes(Charset.defaultCharset()), publicKey);
	byte[] decryptedData = RSAUtils.decryptByPrivateKey(encryptedData, privateKey);
	System.out.println(new String(decryptedData));

	// 数字签名验证
	// 私钥签名，生产一个key
	String sign = RSAUtils.sign(encryptedData, privateKey);
	// 公钥验证
	boolean verify = RSAUtils.verify(encryptedData, publicKey, sign);
	System.out.println("内容是否安全：" + verify);

	// 私钥加密，公钥解密
	content = "滚你妈的";
	byte[] encryptedData2 = RSAUtils.encryptByPrivateKey(content.getBytes(Charset.defaultCharset()), privateKey);
	byte[] decryptedData2 = RSAUtils.decryptByPublicKey(encryptedData2, publicKey);
	System.out.println(new String(decryptedData2));
}

}
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
附加工具类base64

import java.util.Base64;

public class Base64Utils {

/**
 * <p>
 * BASE64字符串解码为二进制数据
 * </p>
 *
 * @param base64
 * @return
 * @throws Exception
 */
public static byte[] decode(String base64) throws Exception {
    return Base64.getDecoder().decode(base64.getBytes());
}

/**
 * <p>
 * 二进制数据编码为BASE64字符串
 * </p>
 *
 * @param bytes
 * @return
 * @throws Exception
 */
public static String encode(byte[] bytes) throws Exception {
	return new String(Base64.getEncoder().encode(bytes));
}

}

作者：dengjili
来源：CSDN
原文：https://blog.csdn.net/dengjili/article/details/85862201
版权声明：本文为博主原创文章，转载请附上博文链接！