Java加密技术（八）——数字证书

本篇的主要内容为Java证书体系的实现。![]()

请大家在阅读本篇内容时先阅读 Java加密技术（四），预先了解RSA加密算法。 在构建Java代码实现前，我们需要完成证书的制作。 1.生成keyStroe文件 在命令行下执行以下命令： Shell代码

1. keytool -genkey -validity 36000 -alias www.zlex.org -keyalg RSA -keystore d:\zlex.keystore

keytool -genkey -validity 36000 -alias www.zlex.org -keyalg RSA -keystore d:\zlex.keystore 其中 -genkey表示生成密钥 -validity指定证书有效期，这里是36000天 -alias指定别名，这里是www.zlex.org -keyalg指定算法，这里是RSA -keystore指定存储位置，这里是d:\zlex.keystore 在这里我使用的密码为 123456 控制台输出： Console代码

1. 输入keystore密码：
2. 再次输入新密码:
3. 您的名字与姓氏是什么？
4. [Unknown]： www.zlex.org
5. 您的组织单位名称是什么？
6. [Unknown]： zlex
7. 您的组织名称是什么？
8. [Unknown]： zlex
9. 您所在的城市或区域名称是什么？
10. [Unknown]： BJ
11. 您所在的州或省份名称是什么？
12. [Unknown]： BJ
13. 该单位的两字母国家代码是什么
14. [Unknown]： CN
15. CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正确吗？
16. [否]： Y
18. 输入的主密码
19. （如果和 keystore 密码相同，按回车）：
20. 再次输入新密码:

输入keystore密码：

再次输入新密码: 您的名字与姓氏是什么？

[Unknown]： www.zlex.org 您的组织单位名称是什么？

[Unknown]： zlex 您的组织名称是什么？

[Unknown]： zlex 您所在的城市或区域名称是什么？

[Unknown]： BJ 您所在的州或省份名称是什么？

[Unknown]： BJ 该单位的两字母国家代码是什么

[Unknown]： CN CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正确吗？

[否]： Y

输入的主密码 （如果和 keystore 密码相同，按回车）：

再次输入新密码:

这时，在D盘下会生成一个zlex.keystore的文件。 2.生成自签名证书 光有keyStore文件是不够的，还需要证书文件，证书才是直接提供给外界使用的公钥凭证。 导出证书： Shell代码

1. keytool -export -keystore d:\zlex.keystore -alias www.zlex.org -file d:\zlex.cer -rfc

keytool -export -keystore d:\zlex.keystore -alias www.zlex.org -file d:\zlex.cer -rfc 其中 -export指定为导出操作 -keystore指定keystore文件 -alias指定导出keystore文件中的别名 -file指向导出路径 -rfc以文本格式输出，也就是以BASE64编码输出 这里的密码是 123456 控制台输出： Console代码

1. 输入keystore密码：
2. 保存在文件中的认证

输入keystore密码：

保存在文件中的认证 当然，使用方是需要导入证书的！ 可以通过自签名证书完成CAS单点登录系统的构建！ Ok，准备工作完成，开始Java实现！ 通过java代码实现如下：Coder类见 Java加密技术（一） Java代码

1. import java.io.FileInputStream;
2. import java.security.KeyStore;
3. import java.security.PrivateKey;
4. import java.security.PublicKey;
5. import java.security.Signature;
6. import java.security.cert.Certificate;
7. import java.security.cert.CertificateFactory;
8. import java.security.cert.X509Certificate;
9. import java.util.Date;
11. import javax.crypto.Cipher;
13. ///
14. /* 证书组件
15. /*
16. /* @author 梁栋
17. /* @version 1.0
18. /* @since 1.0
19. /*/
20. public abstract class CertificateCoder extends Coder {
23. ///
24. /* Java密钥库(Java Key Store，JKS)KEY_STORE
25. /*/
26. public static final String KEY_STORE = "JKS";
28. public static final String X509 = "X.509";
30. ///
31. /* 由KeyStore获得私钥
32. /*
33. /* @param keyStorePath
34. /* @param alias
35. /* @param password
36. /* @return
37. /* @throws Exception
38. /*/
39. private static PrivateKey getPrivateKey(String keyStorePath, String alias,
40. String password) throws Exception {
41. KeyStore ks = getKeyStore(keyStorePath, password);
42. PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());
43. return key;
44. }
46. ///
47. /* 由Certificate获得公钥
48. /*
49. /* @param certificatePath
50. /* @return
51. /* @throws Exception
52. /*/
53. private static PublicKey getPublicKey(String certificatePath)
54. throws Exception {
55. Certificate certificate = getCertificate(certificatePath);
56. PublicKey key = certificate.getPublicKey();
57. return key;
58. }
60. ///
61. /* 获得Certificate
62. /*
63. /* @param certificatePath
64. /* @return
65. /* @throws Exception
66. /*/
67. private static Certificate getCertificate(String certificatePath)
68. throws Exception {
69. CertificateFactory certificateFactory = CertificateFactory
70. .getInstance(X509);
71. FileInputStream in = new FileInputStream(certificatePath);
73. Certificate certificate = certificateFactory.generateCertificate(in);
74. in.close();
76. return certificate;
77. }
79. ///
80. /* 获得Certificate
81. /*
82. /* @param keyStorePath
83. /* @param alias
84. /* @param password
85. /* @return
86. /* @throws Exception
87. /*/
88. private static Certificate getCertificate(String keyStorePath,
89. String alias, String password) throws Exception {
90. KeyStore ks = getKeyStore(keyStorePath, password);
91. Certificate certificate = ks.getCertificate(alias);
93. return certificate;
94. }
96. ///
97. /* 获得KeyStore
98. /*
99. /* @param keyStorePath
100. /* @param password
101. /* @return
102. /* @throws Exception
103. /*/
104. private static KeyStore getKeyStore(String keyStorePath, String password)
105. throws Exception {
106. FileInputStream is = new FileInputStream(keyStorePath);
107. KeyStore ks = KeyStore.getInstance(KEY_STORE);
108. ks.load(is, password.toCharArray());
109. is.close();
110. return ks;
111. }
113. ///
114. /* 私钥加密
115. /*
116. /* @param data
117. /* @param keyStorePath
118. /* @param alias
119. /* @param password
120. /* @return
121. /* @throws Exception
122. /*/
123. public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,
124. String alias, String password) throws Exception {
125. // 取得私钥
126. PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);
128. // 对数据加密
129. Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
130. cipher.init(Cipher.ENCRYPT_MODE, privateKey);
132. return cipher.doFinal(data);
134. }
136. ///
137. /* 私钥解密
138. /*
139. /* @param data
140. /* @param keyStorePath
141. /* @param alias
142. /* @param password
143. /* @return
144. /* @throws Exception
145. /*/
146. public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,
147. String alias, String password) throws Exception {
148. // 取得私钥
149. PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);
151. // 对数据加密
152. Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
153. cipher.init(Cipher.DECRYPT_MODE, privateKey);
155. return cipher.doFinal(data);
157. }
159. ///
160. /* 公钥加密
161. /*
162. /* @param data
163. /* @param certificatePath
164. /* @return
165. /* @throws Exception
166. /*/
167. public static byte[] encryptByPublicKey(byte[] data, String certificatePath)
168. throws Exception {
170. // 取得公钥
171. PublicKey publicKey = getPublicKey(certificatePath);
172. // 对数据加密
173. Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
174. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
176. return cipher.doFinal(data);
178. }
180. ///
181. /* 公钥解密
182. /*
183. /* @param data
184. /* @param certificatePath
185. /* @return
186. /* @throws Exception
187. /*/
188. public static byte[] decryptByPublicKey(byte[] data, String certificatePath)
189. throws Exception {
190. // 取得公钥
191. PublicKey publicKey = getPublicKey(certificatePath);
193. // 对数据加密
194. Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
195. cipher.init(Cipher.DECRYPT_MODE, publicKey);
197. return cipher.doFinal(data);
199. }
201. ///
202. /* 验证Certificate
203. /*
204. /* @param certificatePath
205. /* @return
206. /*/
207. public static boolean verifyCertificate(String certificatePath) {
208. return verifyCertificate(new Date(), certificatePath);
209. }
211. ///
212. /* 验证Certificate是否过期或无效
213. /*
214. /* @param date
215. /* @param certificatePath
216. /* @return
217. /*/
218. public static boolean verifyCertificate(Date date, String certificatePath) {
219. boolean status = true;
220. try {
221. // 取得证书
222. Certificate certificate = getCertificate(certificatePath);
223. // 验证证书是否过期或无效
224. status = verifyCertificate(date, certificate);
225. } catch (Exception e) {
226. status = false;
227. }
228. return status;
229. }
231. ///
232. /* 验证证书是否过期或无效
233. /*
234. /* @param date
235. /* @param certificate
236. /* @return
237. /*/
238. private static boolean verifyCertificate(Date date, Certificate certificate) {
239. boolean status = true;
240. try {
241. X509Certificate x509Certificate = (X509Certificate) certificate;
242. x509Certificate.checkValidity(date);
243. } catch (Exception e) {
244. status = false;
245. }
246. return status;
247. }
249. ///
250. /* 签名
251. /*
252. /* @param keyStorePath
253. /* @param alias
254. /* @param password
255. /*
256. /* @return
257. /* @throws Exception
258. /*/
259. public static String sign(byte[] sign, String keyStorePath, String alias,
260. String password) throws Exception {
261. // 获得证书
262. X509Certificate x509Certificate = (X509Certificate) getCertificate(
263. keyStorePath, alias, password);
264. // 获取私钥
265. KeyStore ks = getKeyStore(keyStorePath, password);
266. // 取得私钥
267. PrivateKey privateKey = (PrivateKey) ks.getKey(alias, password
268. .toCharArray());
270. // 构建签名
271. Signature signature = Signature.getInstance(x509Certificate
272. .getSigAlgName());
273. signature.initSign(privateKey);
274. signature.update(sign);
275. return encryptBASE64(signature.sign());
276. }
278. ///
279. /* 验证签名
280. /*
281. /* @param data
282. /* @param sign
283. /* @param certificatePath
284. /* @return
285. /* @throws Exception
286. /*/
287. public static boolean verify(byte[] data, String sign,
288. String certificatePath) throws Exception {
289. // 获得证书
290. X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);
291. // 获得公钥
292. PublicKey publicKey = x509Certificate.getPublicKey();
293. // 构建签名
294. Signature signature = Signature.getInstance(x509Certificate
295. .getSigAlgName());
296. signature.initVerify(publicKey);
297. signature.update(data);
299. return signature.verify(decryptBASE64(sign));
301. }
303. ///
304. /* 验证Certificate
305. /*
306. /* @param keyStorePath
307. /* @param alias
308. /* @param password
309. /* @return
310. /*/
311. public static boolean verifyCertificate(Date date, String keyStorePath,
312. String alias, String password) {
313. boolean status = true;
314. try {
315. Certificate certificate = getCertificate(keyStorePath, alias,
316. password);
317. status = verifyCertificate(date, certificate);
318. } catch (Exception e) {
319. status = false;
320. }
321. return status;
322. }
324. ///
325. /* 验证Certificate
326. /*
327. /* @param keyStorePath
328. /* @param alias
329. /* @param password
330. /* @return
331. /*/
332. public static boolean verifyCertificate(String keyStorePath, String alias,
333. String password) {
334. return verifyCertificate(new Date(), keyStorePath, alias, password);
335. }
336. }

import java.io.FileInputStream;

import java.security.KeyStore; import java.security.PrivateKey;

import java.security.PublicKey; import java.security.Signature;

import java.security.cert.Certificate; import java.security.cert.CertificateFactory;

import java.security.cert.X509Certificate; import java.util.Date;

import javax.crypto.Cipher;

///

/ 证书组件 /

/ @author 梁栋 / @version 1.0

/ @since 1.0 //

public abstract class CertificateCoder extends Coder {

//*/*

 /* Java密钥库(Java Key Store，JKS)KEY_STORE
 /*/

public static final String KEY_STORE = "JKS";


public static final String X509 = "X.509";


//*/*
 /* 由KeyStore获得私钥

 /*
 /* @param keyStorePath

 /* @param alias
 /* @param password

 /* @return
 /* @throws Exception

 /*/
private static PrivateKey getPrivateKey(String keyStorePath, String alias,

        String password) throws Exception {
    KeyStore ks = getKeyStore(keyStorePath, password);

    PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());
    return key;

}


//*/*
 /* 由Certificate获得公钥

 /*
 /* @param certificatePath

 /* @return
 /* @throws Exception

 /*/
private static PublicKey getPublicKey(String certificatePath)

        throws Exception {
    Certificate certificate = getCertificate(certificatePath);

    PublicKey key = certificate.getPublicKey();
    return key;

}


//*/*
 /* 获得Certificate

 /*
 /* @param certificatePath

 /* @return
 /* @throws Exception

 /*/
private static Certificate getCertificate(String certificatePath)

        throws Exception {
    CertificateFactory certificateFactory = CertificateFactory

            .getInstance(X509);
    FileInputStream in = new FileInputStream(certificatePath);


    Certificate certificate = certificateFactory.generateCertificate(in);

    in.close();


    return certificate;
}


//*/*

 /* 获得Certificate
 /*

 /* @param keyStorePath
 /* @param alias

 /* @param password
 /* @return

 /* @throws Exception
 /*/

private static Certificate getCertificate(String keyStorePath,
        String alias, String password) throws Exception {

    KeyStore ks = getKeyStore(keyStorePath, password);
    Certificate certificate = ks.getCertificate(alias);


    return certificate;

}


//*/*
 /* 获得KeyStore

 /*
 /* @param keyStorePath

 /* @param password
 /* @return

 /* @throws Exception
 /*/

private static KeyStore getKeyStore(String keyStorePath, String password)
        throws Exception {

    FileInputStream is = new FileInputStream(keyStorePath);
    KeyStore ks = KeyStore.getInstance(KEY_STORE);

    ks.load(is, password.toCharArray());
    is.close();

    return ks;
}


//*/*

 /* 私钥加密
 /*

 /* @param data
 /* @param keyStorePath

 /* @param alias
 /* @param password

 /* @return
 /* @throws Exception

 /*/
public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,

        String alias, String password) throws Exception {
    // 取得私钥

    PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);


    // 对数据加密
    Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());

    cipher.init(Cipher.ENCRYPT_MODE, privateKey);


    return cipher.doFinal(data);


}


//*/*
 /* 私钥解密

 /*
 /* @param data

 /* @param keyStorePath
 /* @param alias

 /* @param password
 /* @return

 /* @throws Exception
 /*/

public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,
        String alias, String password) throws Exception {

    // 取得私钥
    PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);


    // 对数据加密

    Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, privateKey);


    return cipher.doFinal(data);


}


//*/*

 /* 公钥加密
 /*

 /* @param data
 /* @param certificatePath

 /* @return
 /* @throws Exception

 /*/
public static byte[] encryptByPublicKey(byte[] data, String certificatePath)

        throws Exception {


    // 取得公钥
    PublicKey publicKey = getPublicKey(certificatePath);

    // 对数据加密
    Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());

    cipher.init(Cipher.ENCRYPT_MODE, publicKey);


    return cipher.doFinal(data);


}


//*/*
 /* 公钥解密

 /*
 /* @param data

 /* @param certificatePath
 /* @return

 /* @throws Exception
 /*/

public static byte[] decryptByPublicKey(byte[] data, String certificatePath)
        throws Exception {

    // 取得公钥
    PublicKey publicKey = getPublicKey(certificatePath);


    // 对数据加密

    Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, publicKey);


    return cipher.doFinal(data);


}


//*/*

 /* 验证Certificate
 /*

 /* @param certificatePath
 /* @return

 /*/
public static boolean verifyCertificate(String certificatePath) {

    return verifyCertificate(new Date(), certificatePath);
}


//*/*

 /* 验证Certificate是否过期或无效
 /*

 /* @param date
 /* @param certificatePath

 /* @return
 /*/

public static boolean verifyCertificate(Date date, String certificatePath) {
    boolean status = true;

    try {
        // 取得证书

        Certificate certificate = getCertificate(certificatePath);
        // 验证证书是否过期或无效

        status = verifyCertificate(date, certificate);
    } catch (Exception e) {

        status = false;
    }

    return status;
}


//*/*

 /* 验证证书是否过期或无效
 /*

 /* @param date
 /* @param certificate

 /* @return
 /*/

private static boolean verifyCertificate(Date date, Certificate certificate) {
    boolean status = true;

    try {
        X509Certificate x509Certificate = (X509Certificate) certificate;

        x509Certificate.checkValidity(date);
    } catch (Exception e) {

        status = false;
    }

    return status;
}


//*/*

 /* 签名
 /*

 /* @param keyStorePath
 /* @param alias

 /* @param password
 /*

 /* @return
 /* @throws Exception

 /*/
public static String sign(byte[] sign, String keyStorePath, String alias,

        String password) throws Exception {
    // 获得证书

    X509Certificate x509Certificate = (X509Certificate) getCertificate(
            keyStorePath, alias, password);

    // 获取私钥
    KeyStore ks = getKeyStore(keyStorePath, password);

    // 取得私钥
    PrivateKey privateKey = (PrivateKey) ks.getKey(alias, password

            .toCharArray());


    // 构建签名
    Signature signature = Signature.getInstance(x509Certificate

            .getSigAlgName());
    signature.initSign(privateKey);

    signature.update(sign);
    return encryptBASE64(signature.sign());

}


//*/*
 /* 验证签名

 /*
 /* @param data

 /* @param sign
 /* @param certificatePath

 /* @return
 /* @throws Exception

 /*/
public static boolean verify(byte[] data, String sign,

        String certificatePath) throws Exception {
    // 获得证书

    X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);
    // 获得公钥

    PublicKey publicKey = x509Certificate.getPublicKey();
    // 构建签名

    Signature signature = Signature.getInstance(x509Certificate
            .getSigAlgName());

    signature.initVerify(publicKey);
    signature.update(data);


    return signature.verify(decryptBASE64(sign));


}


//*/*

 /* 验证Certificate
 /*

 /* @param keyStorePath
 /* @param alias

 /* @param password
 /* @return

 /*/
public static boolean verifyCertificate(Date date, String keyStorePath,

        String alias, String password) {
    boolean status = true;

    try {
        Certificate certificate = getCertificate(keyStorePath, alias,

                password);
        status = verifyCertificate(date, certificate);

    } catch (Exception e) {
        status = false;

    }
    return status;

}


//*/*
 /* 验证Certificate

 /*
 /* @param keyStorePath

 /* @param alias
 /* @param password

 /* @return
 /*/

public static boolean verifyCertificate(String keyStorePath, String alias,
        String password) {

    return verifyCertificate(new Date(), keyStorePath, alias, password);
}

} 再给出一个测试类： Java代码

1. import static org.junit.Assert./*;
3. import org.junit.Test;
5. ///
6. /*
7. /* @author 梁栋
8. /* @version 1.0
9. /* @since 1.0
10. /*/
11. public class CertificateCoderTest {
12. private String password = "123456";
13. private String alias = "www.zlex.org";
14. private String certificatePath = "d:/zlex.cer";
15. private String keyStorePath = "d:/zlex.keystore";
17. @Test
18. public void test() throws Exception {
19. System.err.println("公钥加密——私钥解密");
20. String inputStr = "Ceritifcate";
21. byte[] data = inputStr.getBytes();
23. byte[] encrypt = CertificateCoder.encryptByPublicKey(data,
24. certificatePath);
26. byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
27. keyStorePath, alias, password);
28. String outputStr = new String(decrypt);
30. System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
32. // 验证数据一致
33. assertArrayEquals(data, decrypt);
35. // 验证证书有效
36. assertTrue(CertificateCoder.verifyCertificate(certificatePath));
38. }
40. @Test
41. public void testSign() throws Exception {
42. System.err.println("私钥加密——公钥解密");
44. String inputStr = "sign";
45. byte[] data = inputStr.getBytes();
47. byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
48. keyStorePath, alias, password);
50. byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
51. certificatePath);
53. String outputStr = new String(decodedData);
54. System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
55. assertEquals(inputStr, outputStr);
57. System.err.println("私钥签名——公钥验证签名");
58. // 产生签名
59. String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
60. password);
61. System.err.println("签名:\r" + sign);
63. // 验证签名
64. boolean status = CertificateCoder.verify(encodedData, sign,
65. certificatePath);
66. System.err.println("状态:\r" + status);
67. assertTrue(status);
69. }
70. }

import static org.junit.Assert./*;

import org.junit.Test;

///

/ / @author 梁栋

/ @version 1.0 / @since 1.0

/*/ public class CertificateCoderTest {

private String password = "123456";
private String alias = "www.zlex.org";

private String certificatePath = "d:/zlex.cer";
private String keyStorePath = "d:/zlex.keystore";


@Test

public void test() throws Exception {
    System.err.println("公钥加密——私钥解密");

    String inputStr = "Ceritifcate";
    byte[] data = inputStr.getBytes();


    byte[] encrypt = CertificateCoder.encryptByPublicKey(data,

            certificatePath);


    byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
            keyStorePath, alias, password);

    String outputStr = new String(decrypt);


    System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);


    // 验证数据一致
    assertArrayEquals(data, decrypt);


    // 验证证书有效

    assertTrue(CertificateCoder.verifyCertificate(certificatePath));


}


@Test
public void testSign() throws Exception {

    System.err.println("私钥加密——公钥解密");


    String inputStr = "sign";
    byte[] data = inputStr.getBytes();


    byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,

            keyStorePath, alias, password);


    byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
            certificatePath);


    String outputStr = new String(decodedData);

    System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
    assertEquals(inputStr, outputStr);


    System.err.println("私钥签名——公钥验证签名");

    // 产生签名
    String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,

            password);
    System.err.println("签名:\r" + sign);


    // 验证签名

    boolean status = CertificateCoder.verify(encodedData, sign,
            certificatePath);

    System.err.println("状态:\r" + status);
    assertTrue(status);


}

} 控制台输出： Console代码

1. 公钥加密——私钥解密
2. 加密前: Ceritificate
4. 解密后: Ceritificate
6. 私钥加密——公钥解密
7. 加密前: sign
9. 解密后: sign
10. 私钥签名——公钥验证签名
11. 签名:
12. pqBn5m6PJlfOjH0A6U2o2mUmBsfgyEY1NWCbiyA/I5Gc3gaVNVIdj/zkGNZRqTjhf3+J9a9z9EI7
13. 6F2eWYd7punHx5oh6hfNgcKbVb52EfItl4QEN+djbXiPynn07+Lbg1NOjULnpEd6ZhLP1YwrEAuM
14. OfvX0e7/wplxLbySaKQ=
16. 状态:
17. true

公钥加密——私钥解密

加密前: Ceritificate

解密后: Ceritificate

私钥加密——公钥解密 加密前: sign

解密后: sign

私钥签名——公钥验证签名 签名:

pqBn5m6PJlfOjH0A6U2o2mUmBsfgyEY1NWCbiyA/I5Gc3gaVNVIdj/zkGNZRqTjhf3+J9a9z9EI7 6F2eWYd7punHx5oh6hfNgcKbVb52EfItl4QEN+djbXiPynn07+Lbg1NOjULnpEd6ZhLP1YwrEAuM

OfvX0e7/wplxLbySaKQ=

状态: true 由此完成了证书验证体系！ 同样，我们可以对代码做签名——代码签名！ 通过工具JarSigner可以完成代码签名。 这里我们对tools.jar做代码签名，命令如下： Shell代码

1. jarsigner -storetype jks -keystore zlex.keystore -verbose tools.jar www.zlex.org

jarsigner -storetype jks -keystore zlex.keystore -verbose tools.jar www.zlex.org 控制台输出： Console代码

1. 输入密钥库的口令短语：
2. 正在更新： META-INF/WWW_ZLEX.SF
3. 正在更新： META-INF/WWW_ZLEX.RSA
4. 正在签名： org/zlex/security/Security.class
5. 正在签名： org/zlex/tool/Main$1.class
6. 正在签名： org/zlex/tool/Main$2.class
7. 正在签名： org/zlex/tool/Main.class
9. 警告：
10. 签名者证书将在六个月内过期。

输入密钥库的口令短语：

正在更新： META-INF/WWW_ZLEX.SF 正在更新： META-INF/WWW_ZLEX.RSA

正在签名： org/zlex/security/Security.class 正在签名： org/zlex/tool/Main$1.class

正在签名： org/zlex/tool/Main$2.class 正在签名： org/zlex/tool/Main.class

警告：

签名者证书将在六个月内过期。 此时，我们可以对签名后的jar做验证！ 验证tools.jar，命令如下： Shell代码

1. jarsigner -verify -verbose -certs tools.jar

jarsigner -verify -verbose -certs tools.jar 控制台输出： Console代码

1. 402 Sat Jun 20 16:25:14 CST 2009 META-INF/MANIFEST.MF
2. 532 Sat Jun 20 16:25:14 CST 2009 META-INF/WWW_ZLEX.SF
3. 889 Sat Jun 20 16:25:14 CST 2009 META-INF/WWW_ZLEX.RSA
4. sm 590 Wed Dec 10 13:03:42 CST 2008 org/zlex/security/Security.class
6. X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
7. [证书将在 09-9-18 下午3:27 到期]
9. sm 705 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main$1.class
11. X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
12. [证书将在 09-9-18 下午3:27 到期]
14. sm 779 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main$2.class
16. X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
17. [证书将在 09-9-18 下午3:27 到期]
19. sm 12672 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main.class
21. X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
22. [证书将在 09-9-18 下午3:27 到期]
25. s = 已验证签名
26. m = 在清单中列出条目
27. k = 在密钥库中至少找到了一个证书
28. i = 在身份作用域内至少找到了一个证书
30. jar 已验证。
32. 警告：

33. 此 jar 包含签名者证书将在六个月内过期的条目。

      402 Sat Jun 20 16:25:14 CST 2009 META-INF/MANIFEST.MF
    
      532 Sat Jun 20 16:25:14 CST 2009 META-INF/WWW_ZLEX.SF
      889 Sat Jun 20 16:25:14 CST 2009 META-INF/WWW_ZLEX.RSA
    

sm 590 Wed Dec 10 13:03:42 CST 2008 org/zlex/security/Security.class

  X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
  [证书将在 09-9-18 下午3:27 到期]

sm 705 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main$1.class

  X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN

  [证书将在 09-9-18 下午3:27 到期]

sm 779 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main$2.class

  X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
  [证书将在 09-9-18 下午3:27 到期]

sm 12672 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main.class

  X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN

  [证书将在 09-9-18 下午3:27 到期]

s = 已验证签名

m = 在清单中列出条目 k = 在密钥库中至少找到了一个证书

i = 在身份作用域内至少找到了一个证书

jar 已验证。

警告： 此 jar 包含签名者证书将在六个月内过期的条目。 代码签名认证的用途主要是对发布的软件做验证，支持 Sun Java .jar (Java Applet) 文件(J2SE)和 J2ME MIDlet Suite 文件。 相关链接： Java加密技术（一）——BASE64与单向加密算法MD5&SHA&MAC Java加密技术（二）——对称加密DES&AES Java加密技术（三）——PBE算法 Java加密技术（四）——非对称加密算法RSA Java加密技术（五）——非对称加密算法的由来 Java加密技术（六）——数字签名算法DSA Java加密技术（七）——非对称加密算法最高ECC Java加密技术（八）——数字证书 Java加密技术（九）——初探SSL Java加密技术（十）——单向认证 Java加密技术（十一）——双向认证 Java加密技术（十二）——/.PFX(/.p12)&个人信息交换文件

Java加密技术（二）——对称加密算法DES&AES

接下来我们介绍对称加密算法，最常用的莫过于DES数据加密算法。

DES DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。 DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。 通过java代码实现如下：Coder类见 Java加密技术（一） Java代码

1. import java.security.Key;
2. import java.security.SecureRandom;
4. import javax.crypto.Cipher;
5. import javax.crypto.KeyGenerator;
6. import javax.crypto.SecretKey;
7. import javax.crypto.SecretKeyFactory;
8. import javax.crypto.spec.DESKeySpec;
11. ///
12. /* DES安全编码组件
13. /*
14. /*

15. /* 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR)
16. /* DES key size must be equal to 56
17. /* DESede(TripleDES) key size must be equal to 112 or 168
18. /* AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
19. /* Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
20. /* RC2 key size must be between 40 and 1024 bits
21. /* RC4(ARCFOUR) key size must be between 40 and 1024 bits
22. /* 具体内容 需要关注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html
23. /*
24. /*
25. /* @author 梁栋
26. /* @version 1.0
27. /* @since 1.0
28. /*/
29. public abstract class DESCoder extends Coder {
30. ///
31. /* ALGORITHM 算法
    
32. /* 可替换为以下任意一种算法，同时key值的size相应改变。
33. /*
34. /*

35. /* DES key size must be equal to 56
36. /* DESede(TripleDES) key size must be equal to 112 or 168
37. /* AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
38. /* Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
39. /* RC2 key size must be between 40 and 1024 bits
40. /* RC4(ARCFOUR) key size must be between 40 and 1024 bits
41. /*
42. /*
43. /* 在Key toKey(byte[] key)方法中使用下述代码
44. /* SecretKey secretKey = new SecretKeySpec(key, ALGORITHM); 替换
46. /*
47. /* DESKeySpec dks = new DESKeySpec(key);
48. /* SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
49. /* SecretKey secretKey = keyFactory.generateSecret(dks);
50. /*
51. /*/
52. public static final String ALGORITHM = "DES";
54. ///
55. /* 转换密钥
    
56. /*
57. /* @param key
58. /* @return
59. /* @throws Exception
60. /*/
61. private static Key toKey(byte[] key) throws Exception {
62. DESKeySpec dks = new DESKeySpec(key);
63. SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
64. SecretKey secretKey = keyFactory.generateSecret(dks);
66. // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码
67. // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);
69. return secretKey;
70. }
72. ///
73. /* 解密
74. /*
75. /* @param data
76. /* @param key
77. /* @return
78. /* @throws Exception
79. /*/
80. public static byte[] decrypt(byte[] data, String key) throws Exception {
81. Key k = toKey(decryptBASE64(key));
83. Cipher cipher = Cipher.getInstance(ALGORITHM);
84. cipher.init(Cipher.DECRYPT_MODE, k);
86. return cipher.doFinal(data);
87. }
89. ///
90. /* 加密
91. /*
92. /* @param data
93. /* @param key
94. /* @return
95. /* @throws Exception
96. /*/
97. public static byte[] encrypt(byte[] data, String key) throws Exception {
98. Key k = toKey(decryptBASE64(key));
99. Cipher cipher = Cipher.getInstance(ALGORITHM);
100. cipher.init(Cipher.ENCRYPT_MODE, k);
102. return cipher.doFinal(data);
103. }
105. ///
106. /* 生成密钥
107. /*
108. /* @return
109. /* @throws Exception
110. /*/
111. public static String initKey() throws Exception {
112. return initKey(null);
113. }
115. ///
116. /* 生成密钥
117. /*
118. /* @param seed
119. /* @return
120. /* @throws Exception
121. /*/
122. public static String initKey(String seed) throws Exception {
123. SecureRandom secureRandom = null;
125. if (seed != null) {
126. secureRandom = new SecureRandom(decryptBASE64(seed));
127. } else {
128. secureRandom = new SecureRandom();
129. }
131. KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);
132. kg.init(secureRandom);
134. SecretKey secretKey = kg.generateKey();
136. return encryptBASE64(secretKey.getEncoded());
137. }
138. }

import java.security.Key;

import java.security.SecureRandom;

import javax.crypto.Cipher; import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

///

/ DES安全编码组件 /

/

/ 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR)

 / DES                  key size must be equal to 56
 / DESede(TripleDES)     key size must be equal to 112 or 168
 / AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
 / Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
 / RC2                  key size must be between 40 and 1024 bits
 / RC4(ARCFOUR)         key size must be between 40 and 1024 bits
/ 具体内容 需要关注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html
/ 

/ / @author 梁栋

/ @version 1.0 / @since 1.0

/*/ public abstract class DESCoder extends Coder {

//*/*
 /* ALGORITHM 算法 <br>

 /* 可替换为以下任意一种算法，同时key值的size相应改变。
 /*

 /* <pre>
 /* DES                  key size must be equal to 56

 /* DESede(TripleDES)     key size must be equal to 112 or 168
 /* AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available

 /* Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
 /* RC2                  key size must be between 40 and 1024 bits

 /* RC4(ARCFOUR)         key size must be between 40 and 1024 bits
 /* </pre>

 /*
 /* 在Key toKey(byte[] key)方法中使用下述代码

 /* <code>SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);</code> 替换


 /* <code>
 /* DESKeySpec dks = new DESKeySpec(key);

 /* SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
 /* SecretKey secretKey = keyFactory.generateSecret(dks);

 /* </code>
 /*/

public static final String ALGORITHM = "DES";


//*/*
 /* 转换密钥<br>

 /*
 /* @param key

 /* @return
 /* @throws Exception

 /*/
private static Key toKey(byte[] key) throws Exception {

    DESKeySpec dks = new DESKeySpec(key);
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);

    SecretKey secretKey = keyFactory.generateSecret(dks);


    // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码
    // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);


    return secretKey;

}


//*/*
 /* 解密

 /*
 /* @param data

 /* @param key
 /* @return

 /* @throws Exception
 /*/

public static byte[] decrypt(byte[] data, String key) throws Exception {
    Key k = toKey(decryptBASE64(key));


    Cipher cipher = Cipher.getInstance(ALGORITHM);

    cipher.init(Cipher.DECRYPT_MODE, k);


    return cipher.doFinal(data);
}


//*/*

 /* 加密
 /*

 /* @param data
 /* @param key

 /* @return
 /* @throws Exception

 /*/
public static byte[] encrypt(byte[] data, String key) throws Exception {

    Key k = toKey(decryptBASE64(key));
    Cipher cipher = Cipher.getInstance(ALGORITHM);

    cipher.init(Cipher.ENCRYPT_MODE, k);


    return cipher.doFinal(data);
}


//*/*

 /* 生成密钥
 /*

 /* @return
 /* @throws Exception

 /*/
public static String initKey() throws Exception {

    return initKey(null);
}


//*/*

 /* 生成密钥
 /*

 /* @param seed
 /* @return

 /* @throws Exception
 /*/

public static String initKey(String seed) throws Exception {
    SecureRandom secureRandom = null;


    if (seed != null) {

        secureRandom = new SecureRandom(decryptBASE64(seed));
    } else {

        secureRandom = new SecureRandom();
    }


    KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);

    kg.init(secureRandom);


    SecretKey secretKey = kg.generateKey();


    return encryptBASE64(secretKey.getEncoded());
}

} 延续上一个类的实现，我们通过MD5以及SHA对字符串加密生成密钥，这是比较常见的密钥生成方式。 再给出一个测试类： Java代码

1. import static org.junit.Assert./*;
4. import org.junit.Test;
6. ///
7. /*
8. /* @author 梁栋
9. /* @version 1.0
10. /* @since 1.0
11. /*/
12. public class DESCoderTest {
14. @Test
15. public void test() throws Exception {
16. String inputStr = "DES";
17. String key = DESCoder.initKey();
18. System.err.println("原文:\t" + inputStr);
20. System.err.println("密钥:\t" + key);
22. byte[] inputData = inputStr.getBytes();
23. inputData = DESCoder.encrypt(inputData, key);
25. System.err.println("加密后:\t" + DESCoder.encryptBASE64(inputData));
27. byte[] outputData = DESCoder.decrypt(inputData, key);
28. String outputStr = new String(outputData);
30. System.err.println("解密后:\t" + outputStr);
32. assertEquals(inputStr, outputStr);
33. }
34. }

import static org.junit.Assert./*;

import org.junit.Test;

/// /*

/ @author 梁栋 / @version 1.0

/ @since 1.0 //

public class DESCoderTest {

@Test
public void test() throws Exception {

    String inputStr = "DES";
    String key = DESCoder.initKey();

    System.err.println("原文:\t" + inputStr);


    System.err.println("密钥:\t" + key);


    byte[] inputData = inputStr.getBytes();
    inputData = DESCoder.encrypt(inputData, key);


    System.err.println("加密后:\t" + DESCoder.encryptBASE64(inputData));


    byte[] outputData = DESCoder.decrypt(inputData, key);

    String outputStr = new String(outputData);


    System.err.println("解密后:\t" + outputStr);


    assertEquals(inputStr, outputStr);
}

} 得到的输出内容如下： Console代码

1. 原文: DES
2. 密钥: f3wEtRrV6q0=
4. 加密后: C6qe9oNIzRY=
6. 解密后: DES

原文: DES

密钥: f3wEtRrV6q0=

加密后: C6qe9oNIzRY=

解密后: DES 由控制台得到的输出，我们能够比对加密、解密后结果一致。这是一种简单的加密解密方式，只有一个密钥。 其实DES有很多同胞兄弟，如DESede(TripleDES)、AES、Blowfish、RC2、RC4(ARCFOUR)。这里就不过多阐述了，大同小异，只要换掉ALGORITHM换成对应的值，同时做一个代码替换SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);就可以了，此外就是密钥长度不同了。 Java代码

1. ///
2. /* DES key size must be equal to 56
3. /* DESede(TripleDES) key size must be equal to 112 or 168
4. /* AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
5. /* Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
6. /* RC2 key size must be between 40 and 1024 bits
7. /* RC4(ARCFOUR) key size must be between 40 and 1024 bits
8. ///

///

/ DES key size must be equal to 56 / DESede(TripleDES) key size must be equal to 112 or 168

/ AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available / Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)

/ RC2 key size must be between 40 and 1024 bits / RC4(ARCFOUR) key size must be between 40 and 1024 bits

/// 相关链接： Java加密技术（一）——BASE64与单向加密算法MD5&SHA&MAC Java加密技术（二）——对称加密算法DES&AES Java加密技术（三）——PBE算法 Java加密技术（四）——非对称加密算法RSA Java加密技术（五）——非对称加密算法的由来 Java加密技术（六）——数字签名算法DSA Java加密技术（七）——非对称加密算法最高ECC Java加密技术（八）——数字证书 Java加密技术（九）——初探SSL Java加密技术（十）——单向认证 Java加密技术（十一）——双向认证 Java加密技术（十二）——/.PFX(/.p12)&个人信息交换文件

Java加密技术（一）——BASE64与单向加密算法MD5&SHA&MAC

加密解密，曾经是我一个毕业设计的重要组件。在工作了多年以后回想当时那个加密、解密算法，实在是太单纯了。![]()
言归正传，这里我们主要描述Java已经实现的一些加密解密算法，最后介绍数字证书。
如基本的单向加密算法：

• BASE64 严格地说，属于编码格式，而非加密算法
• MD5(Message Digest algorithm 5，信息摘要算法)
• SHA(Secure Hash Algorithm，安全散列算法)

• HMAC(Hash Message Authentication Code，散列消息鉴别码) 复杂的对称加密（DES、PBE）、非对称加密算法：

• DES(Data Encryption Standard，数据加密算法)

• PBE(Password-based encryption，基于密码验证)
• RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)
• DH(Diffie-Hellman算法，密钥一致协议)
• DSA(Digital Signature Algorithm，数字签名)
• ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学) 本篇内容简要介绍BASE64、MD5、SHA、HMAC几种方法。 MD5、SHA、HMAC这三种加密算法，可谓是非可逆加密，就是不可解密的加密方法。我们通常只把他们作为加密的基础。单纯的以上三种的加密并不可靠。 BASE64 按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式。（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.） 常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE64加密的。 通过java代码实现如下： Java代码

1. ///
2. /* BASE64解密
3. /*
4. /* @param key
5. /* @return
6. /* @throws Exception
7. /*/
8. public static byte[] decryptBASE64(String key) throws Exception {
9. return (new BASE64Decoder()).decodeBuffer(key);
10. }
12. ///
13. /* BASE64加密
14. /*
15. /* @param key
16. /* @return
17. /* @throws Exception
18. /*/
19. public static String encryptBASE64(byte[] key) throws Exception {
20. return (new BASE64Encoder()).encodeBuffer(key);

21. }

    ///

    / BASE64解密 /

    / @param key / @return

    / @throws Exception //

    public static byte[] decryptBASE64(String key) throws Exception {

     return (new BASE64Decoder()).decodeBuffer(key);
    

    }

//*/*
 /* BASE64加密

 /*
 /* @param key

 /* @return
 /* @throws Exception

 /*/
public static String encryptBASE64(byte[] key) throws Exception {

    return (new BASE64Encoder()).encodeBuffer(key);
}

主要就是BASE64Encoder、BASE64Decoder两个类，我们只需要知道使用对应的方法即可。另，BASE加密后产生的字节位数是8的倍数，如果不够位数以=符号填充。 MD5 MD5 -- message-digest algorithm 5 （信息-摘要算法）缩写，广泛用于加密和解密技术，常用于文件校验。校验？不管文件多大，经过MD5后都能生成唯一的MD5值。好比现在的ISO校验，都是MD5校验。怎么用？当然是把ISO经过MD5后产生MD5的值。一般下载linux-ISO的朋友都见过下载链接旁边放着MD5的串。就是用来验证文件是否一致的。 通过java代码实现如下： Java代码

1. ///
2. /* MD5加密
3. /*
4. /* @param data
5. /* @return
6. /* @throws Exception
7. /*/
8. public static byte[] encryptMD5(byte[] data) throws Exception {
10. MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
11. md5.update(data);
13. return md5.digest();

15. }

    ///

    / MD5加密 /

    / @param data / @return

    / @throws Exception //

    public static byte[] encryptMD5(byte[] data) throws Exception {

    MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
    md5.update(data);


    return md5.digest();


}

通常我们不直接使用上述MD5加密。通常将MD5产生的字节数组交给BASE64再加密一把，得到相应的字符串。 SHA SHA(Secure Hash Algorithm，安全散列算法），数字签名等密码学应用中重要的工具，被广泛地应用于电子商务等信息安全领域。虽然，SHA与MD5通过碰撞法都被破解了， 但是SHA仍然是公认的安全加密算法，较之MD5更为安全。 通过java代码实现如下： Java代码

1. ///
2. /* SHA加密
3. /*
4. /* @param data
5. /* @return
6. /* @throws Exception
7. /*/
8. public static byte[] encryptSHA(byte[] data) throws Exception {
10. MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
11. sha.update(data);
13. return sha.digest();
15. }

16. }

    ///

    / SHA加密 /

    / @param data / @return

    / @throws Exception //

    public static byte[] encryptSHA(byte[] data) throws Exception {

    MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
    sha.update(data);


    return sha.digest();


}

} HMAC HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。 通过java代码实现如下： Java代码

1. ///
2. /* 初始化HMAC密钥
3. /*
4. /* @return
5. /* @throws Exception
6. /*/
7. public static String initMacKey() throws Exception {
8. KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
10. SecretKey secretKey = keyGenerator.generateKey();
11. return encryptBASE64(secretKey.getEncoded());
12. }
14. ///
15. /* HMAC加密
16. /*
17. /* @param data
18. /* @param key
19. /* @return
20. /* @throws Exception
21. /*/
22. public static byte[] encryptHMAC(byte[] data, String key) throws Exception {
24. SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
25. Mac mac = Mac.getInstance(secretKey.getAlgorithm());
26. mac.init(secretKey);
28. return mac.doFinal(data);

30. }

    ///

    / 初始化HMAC密钥 /

    / @return / @throws Exception

    /*/ public static String initMacKey() throws Exception {

     KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
    

    SecretKey secretKey = keyGenerator.generateKey();
    return encryptBASE64(secretKey.getEncoded());

}


//*/*
 /* HMAC加密

 /*
 /* @param data

 /* @param key
 /* @return

 /* @throws Exception
 /*/

public static byte[] encryptHMAC(byte[] data, String key) throws Exception {


    SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
    Mac mac = Mac.getInstance(secretKey.getAlgorithm());

    mac.init(secretKey);


    return mac.doFinal(data);


}

给出一个完整类，如下： Java代码

1. import java.security.MessageDigest;
3. import javax.crypto.KeyGenerator;
4. import javax.crypto.Mac;
5. import javax.crypto.SecretKey;
7. import sun.misc.BASE64Decoder;
8. import sun.misc.BASE64Encoder;
10. ///
11. /* 基础加密组件
12. /*
13. /* @author 梁栋
14. /* @version 1.0
15. /* @since 1.0
16. /*/
17. public abstract class Coder {
18. public static final String KEY_SHA = "SHA";
19. public static final String KEY_MD5 = "MD5";
21. ///
22. /* MAC算法可选以下多种算法
23. /*
24. /*

25. /* HmacMD5
26. /* HmacSHA1
27. /* HmacSHA256
28. /* HmacSHA384
29. /* HmacSHA512
30. /*
31. /*/
32. public static final String KEY_MAC = "HmacMD5";
34. ///
35. /* BASE64解密
36. /*
37. /* @param key
38. /* @return
39. /* @throws Exception
40. /*/
41. public static byte[] decryptBASE64(String key) throws Exception {
42. return (new BASE64Decoder()).decodeBuffer(key);
43. }
45. ///
46. /* BASE64加密
47. /*
48. /* @param key
49. /* @return
50. /* @throws Exception
51. /*/
52. public static String encryptBASE64(byte[] key) throws Exception {
53. return (new BASE64Encoder()).encodeBuffer(key);
54. }
56. ///
57. /* MD5加密
58. /*
59. /* @param data
60. /* @return
61. /* @throws Exception
62. /*/
63. public static byte[] encryptMD5(byte[] data) throws Exception {
65. MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
66. md5.update(data);
68. return md5.digest();
70. }
72. ///
73. /* SHA加密
74. /*
75. /* @param data
76. /* @return
77. /* @throws Exception
78. /*/
79. public static byte[] encryptSHA(byte[] data) throws Exception {
81. MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
82. sha.update(data);
84. return sha.digest();
86. }
88. ///
89. /* 初始化HMAC密钥
90. /*
91. /* @return
92. /* @throws Exception
93. /*/
94. public static String initMacKey() throws Exception {
95. KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
97. SecretKey secretKey = keyGenerator.generateKey();
98. return encryptBASE64(secretKey.getEncoded());
99. }
101. ///
102. /* HMAC加密
103. /*
104. /* @param data
105. /* @param key
106. /* @return
107. /* @throws Exception
108. /*/
109. public static byte[] encryptHMAC(byte[] data, String key) throws Exception {
111. SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
112. Mac mac = Mac.getInstance(secretKey.getAlgorithm());
113. mac.init(secretKey);
115. return mac.doFinal(data);
117. }
118. }

import java.security.MessageDigest;

import javax.crypto.KeyGenerator;

import javax.crypto.Mac; import javax.crypto.SecretKey;

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

/// /* 基础加密组件

/ / @author 梁栋

/ @version 1.0 / @since 1.0

/*/ public abstract class Coder {

public static final String KEY_SHA = "SHA";
public static final String KEY_MD5 = "MD5";


//*/*

 /* MAC算法可选以下多种算法
 /*

 /* <pre>
 /* HmacMD5

 /* HmacSHA1
 /* HmacSHA256

 /* HmacSHA384
 /* HmacSHA512

 /* </pre>
 /*/

public static final String KEY_MAC = "HmacMD5";


//*/*
 /* BASE64解密

 /*
 /* @param key

 /* @return
 /* @throws Exception

 /*/
public static byte[] decryptBASE64(String key) throws Exception {

    return (new BASE64Decoder()).decodeBuffer(key);
}


//*/*

 /* BASE64加密
 /*

 /* @param key
 /* @return

 /* @throws Exception
 /*/

public static String encryptBASE64(byte[] key) throws Exception {
    return (new BASE64Encoder()).encodeBuffer(key);

}


//*/*
 /* MD5加密

 /*
 /* @param data

 /* @return
 /* @throws Exception

 /*/
public static byte[] encryptMD5(byte[] data) throws Exception {


    MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);

    md5.update(data);


    return md5.digest();


}


//*/*
 /* SHA加密

 /*
 /* @param data

 /* @return
 /* @throws Exception

 /*/
public static byte[] encryptSHA(byte[] data) throws Exception {


    MessageDigest sha = MessageDigest.getInstance(KEY_SHA);

    sha.update(data);


    return sha.digest();


}


//*/*
 /* 初始化HMAC密钥

 /*
 /* @return

 /* @throws Exception
 /*/

public static String initMacKey() throws Exception {
    KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);


    SecretKey secretKey = keyGenerator.generateKey();

    return encryptBASE64(secretKey.getEncoded());
}


//*/*

 /* HMAC加密
 /*

 /* @param data
 /* @param key

 /* @return
 /* @throws Exception

 /*/
public static byte[] encryptHMAC(byte[] data, String key) throws Exception {


    SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);

    Mac mac = Mac.getInstance(secretKey.getAlgorithm());
    mac.init(secretKey);


    return mac.doFinal(data);


}

} 再给出一个测试类： Java代码

1. import static org.junit.Assert./*;
3. import org.junit.Test;
5. ///
6. /*
7. /* @author 梁栋
8. /* @version 1.0
9. /* @since 1.0
10. /*/
11. public class CoderTest {
13. @Test
14. public void test() throws Exception {
15. String inputStr = "简单加密";
16. System.err.println("原文:\n" + inputStr);
18. byte[] inputData = inputStr.getBytes();
19. String code = Coder.encryptBASE64(inputData);
21. System.err.println("BASE64加密后:\n" + code);
23. byte[] output = Coder.decryptBASE64(code);
25. String outputStr = new String(output);
27. System.err.println("BASE64解密后:\n" + outputStr);
29. // 验证BASE64加密解密一致性
30. assertEquals(inputStr, outputStr);
32. // 验证MD5对于同一内容加密是否一致
33. assertArrayEquals(Coder.encryptMD5(inputData), Coder
34. .encryptMD5(inputData));
36. // 验证SHA对于同一内容加密是否一致
37. assertArrayEquals(Coder.encryptSHA(inputData), Coder
38. .encryptSHA(inputData));
40. String key = Coder.initMacKey();
41. System.err.println("Mac密钥:\n" + key);
43. // 验证HMAC对于同一内容，同一密钥加密是否一致
44. assertArrayEquals(Coder.encryptHMAC(inputData, key), Coder.encryptHMAC(
45. inputData, key));
47. BigInteger md5 = new BigInteger(Coder.encryptMD5(inputData));
48. System.err.println("MD5:\n" + md5.toString(16));
50. BigInteger sha = new BigInteger(Coder.encryptSHA(inputData));
51. System.err.println("SHA:\n" + sha.toString(32));
53. BigInteger mac = new BigInteger(Coder.encryptHMAC(inputData, inputStr));
54. System.err.println("HMAC:\n" + mac.toString(16));
55. }
56. }

import static org.junit.Assert./*;

import org.junit.Test;

///

/ / @author 梁栋

/ @version 1.0 / @since 1.0

/*/ public class CoderTest {

@Test

public void test() throws Exception {
    String inputStr = "简单加密";

    System.err.println("原文:\n" + inputStr);


    byte[] inputData = inputStr.getBytes();
    String code = Coder.encryptBASE64(inputData);


    System.err.println("BASE64加密后:\n" + code);


    byte[] output = Coder.decryptBASE64(code);


    String outputStr = new String(output);


    System.err.println("BASE64解密后:\n" + outputStr);


    // 验证BASE64加密解密一致性

    assertEquals(inputStr, outputStr);


    // 验证MD5对于同一内容加密是否一致
    assertArrayEquals(Coder.encryptMD5(inputData), Coder

            .encryptMD5(inputData));


    // 验证SHA对于同一内容加密是否一致
    assertArrayEquals(Coder.encryptSHA(inputData), Coder

            .encryptSHA(inputData));


    String key = Coder.initMacKey();
    System.err.println("Mac密钥:\n" + key);


    // 验证HMAC对于同一内容，同一密钥加密是否一致

    assertArrayEquals(Coder.encryptHMAC(inputData, key), Coder.encryptHMAC(
            inputData, key));


    BigInteger md5 = new BigInteger(Coder.encryptMD5(inputData));

    System.err.println("MD5:\n" + md5.toString(16));


    BigInteger sha = new BigInteger(Coder.encryptSHA(inputData));
    System.err.println("SHA:\n" + sha.toString(32));


    BigInteger mac = new BigInteger(Coder.encryptHMAC(inputData, inputStr));

    System.err.println("HMAC:\n" + mac.toString(16));
}

} 控制台输出： Console代码

1. 原文:
2. 简单加密
3. BASE64加密后:
4. 566A5Y2V5Yqg5a+G
6. BASE64解密后:
7. 简单加密
8. Mac密钥:
9. uGxdHC+6ylRDaik++leFtGwiMbuYUJ6mqHWyhSgF4trVkVBBSQvY/a22xU8XT1RUemdCWW155Bke
10. pBIpkd7QHg==
12. MD5:
13. -550b4d90349ad4629462113e7934de56
14. SHA:
15. 91k9vo7p400cjkgfhjh0ia9qthsjagfn
16. HMAC:
17. 2287d192387e95694bdbba2fa941009a

原文:

简单加密 BASE64加密后:

566A5Y2V5Yqg5a+G

BASE64解密后: 简单加密

Mac密钥: uGxdHC+6ylRDaik++leFtGwiMbuYUJ6mqHWyhSgF4trVkVBBSQvY/a22xU8XT1RUemdCWW155Bke

pBIpkd7QHg==

MD5: -550b4d90349ad4629462113e7934de56

SHA: 91k9vo7p400cjkgfhjh0ia9qthsjagfn

HMAC: 2287d192387e95694bdbba2fa941009a

注意 编译时，可能会看到如下提示： 引用

警告：sun.misc.BASE64Decoder 是 Sun 的专用 API，可能会在未来版本中删除 import sun.misc.BASE64Decoder; ^ 警告：sun.misc.BASE64Encoder 是 Sun 的专用 API，可能会在未来版本中删除 import sun.misc.BASE64Encoder; ^ BASE64Encoder和BASE64Decoder是非官方JDK实现类。虽然可以在JDK里能找到并使用，但是在API里查不到。JRE 中 sun 和 com.sun 开头包的类都是未被文档化的，他们属于 java, javax 类库的基础，其中的实现大多数与底层平台有关，一般来说是不推荐使用的。 BASE64的加密解密是双向的，可以求反解。 MD5、SHA以及HMAC是单向加密，任何数据加密后只会产生唯一的一个加密串，通常用来校验数据在传输过程中是否被修改。其中HMAC算法有一个密钥，增强了数据传输过程中的安全性，强化了算法外的不可控因素。 单向加密的用途主要是为了校验数据在传输过程中是否被修改。 相关链接： Java加密技术（一）——BASE64与单向加密算法MD5&SHA&MAC Java加密技术（二）——对称加密DES&AES Java加密技术（三）——PBE算法 Java加密技术（四）——非对称加密算法RSA Java加密技术（五）——非对称加密算法的由来DH Java加密技术（六）——数字签名算法DSA Java加密技术（七）——非对称加密算法最高ECC Java加密技术（八）——数字证书 Java加密技术（九）——初探SSL Java加密技术（十）——单向认证 Java加密技术（十一）——双向认证 Java加密技术（十二）——/.PFX(/.p12)&个人信息交换文件

跟我一起阅读Java源代码之HashMap

最近闲的很，想和大家一起学习并讨论下Java的一些源代码以及其实现的数据结构，

不是什么高水平的东西，有兴趣的随便看看

1. 为什么要用Map，以HashMap为例

   很多时候我们有这样的需求，我们需要将数据成键值对的方式存储起来，根据key来获取value(value可以是简单值，也可以是自定义对象)

   当然用对象数组也能实现这个目的，查找时可以遍历数组，比较关键字来获取对应的value

   从性能上来讲，遍历大数组会消耗性能

   从API易用性来讲，需要自己实现查找的逻辑

   所以用HashMap是必要的

1. HashMap的数据结构是怎么样的

我一直对HashMap的内部结构很好奇，看了源码之后发现他是用散列实现的，即基于hashcode

大体思想是这样的

1. 首先建立一个数组用来存取数据，假设我们定义一个Object[] table用来存取map的value

这个很容易理解，key存在哪里呢？暂时我不想存储key

2. 获得key的hashcode经过一定算法转成一个整数

    index，这个index的取值范围必须是0=<index<table.length，然后我将其作为数组元素的下标

    比如执行这样的操作：table[index] = value;

    这样存储的问题解决了

3. 如何通过key去获取这个value呢

    这个太简单了，首先获取key的hashcode，然后通过刚才一样的算法得出元素下标index

    然后value = table[index]

简单的HashTable实现如下

Java代码

1. public class SimpleHashMap {
3. private Object[] table;
5. public SimpleHashMap() {
6. table = new Object[10];
7. }
9. public Object get(Object key) {
10. int index = indexFor(hash(key.hashCode()), 10);
11. return table[index];
12. }
14. public void put(Object key, Object value) {
15. int index = indexFor(hash(key.hashCode()), 10);
16. table[index] = value;
17. }
19. ///
20. /* 通过hash code 和table的length得到对应的数组下标
21. /*
22. /* @param h
23. /* @param length
24. /* @return
25. /*/
26. static int indexFor(int h, int length) {
27. return h & (length - 1);
28. }
30. ///
31. /* 通过一定算法计算出新的hash值
32. /*
33. /* @param h
34. /* @return
35. /*/
36. static int hash(int h) {
37. h ^= (h >>> 20) ^ (h >>> 12);
38. return h ^ (h >>> 7) ^ (h >>> 4);
39. }
42. public static void main(String[] args){
43. SimpleHashMap hashMap = new SimpleHashMap();
44. hashMap.put("key", "value");
45. System.out.println(hashMap.get("key"));
46. }
47. }

这个简单的例子大概描述了散列实现hashmap的过程

但是还很不成熟，我发现至少存在以下两个问题

1. hashmap的size是固定的

2. 如果不同的key通过hashcode得出的index相同呢，这样的情况是存在的，如何解决？ 来源： [http://tangyanbo.iteye.com/blog/1755636](http://tangyanbo.iteye.com/blog/1755636) 由于table的大小是有限的，而key的集合范围是无限大的，所以寄希望于hashcode散落，肯定会出现多个key散落在同一个数组下标下面，

因此我们要引入另外一个概念，将key和value同时存入table[index]中，即将key和value构成一个对象放在table[index]，而且可能存放多个，他们的key对应的index相同，但是key本身不同

现在我们就该讨论以什么样的方式存储这些散落在同一个数组下标的元素

可以考虑数组？

也可以考虑链表存储

源码里面是用链表存储的，其实我也没明白这两种方式在这里有什么区别

，感觉无论在检索和存储上都是差不多的效率，

检索都是需要遍历的方式，而存储也可以是顺序的

那这个问题留给大家吧。

我们来实现链式存储的方式，首先定义一个链表数据结构Entry：

Java代码

1. public class Entry {
2. //存储key
3. final K key;
4. //存储value
5. V value;
6. //存储指向下一个节点的指针
7. Entry next;
8. //存储key映射的hash
9. final int hash;
10. }

新的EntryHashMap实现方式

Java代码

1. public class EntryHashMap {
3. transient Entry[] table;
5. transient int size;
7. public V put(K key, V value) {
8. //计算出新的hash
9. int hash = hash(key.hashCode());
10. //计算出数组小标i
11. int i = indexFor(hash, table.length);
12. //遍历table[i]，如果table[i]没有与新加入的key相等的，则新加入
13. //一个value到table[i]中的entry，否则将新的value覆盖旧的value并返回旧的value
14. for (Entry e = table[i]; e != null; e = e.next) {
15. Object k;
16. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
17. V oldValue = e.value;
18. e.value = value;
19. return oldValue;
20. }
21. }
22. addEntry(hash, key, value, i);
23. return null;
24. }
26. public void addEntry(int hash, K key, V value, int bucketIndex) {
27. Entry e = table[bucketIndex];
28. //将新的元素插入链表前端
29. table[bucketIndex] = new Entry<>(hash, key, value, e);
30. size++;
31. }
33. ///
34. /* 通过hash code 和table的length得到对应的数组下标
35. /*
36. /* @param h
37. /* @param length
38. /* @return
39. /*/
40. static int indexFor(int h, int length) {
41. return h & (length - 1);
42. }
44. ///
45. /* 通过一定算法计算出新的hash值
46. /*
47. /* @param h
48. /* @return
49. /*/
50. static int hash(int h) {
51. h ^= (h >>> 20) ^ (h >>> 12);
52. return h ^ (h >>> 7) ^ (h >>> 4);
53. }
54. }

来源： [http://tangyanbo.iteye.com/blog/1756074](http://tangyanbo.iteye.com/blog/1756074) 为什么要用链表而不是数组

链表的作用有如下两点好处

1. remove操作时效率高，只维护指针的变化即可，无需进行移位操作

2. 重新散列时，原来散落在同一个槽中的元素可能会被散落在不同的地方，对于数组需要进行移位操作，而链表只需维护指针

今天研究下数组长度不够时的处理办法

table为散列数组

1. 首先定义一个不可修改的静态变量存储table的初始大小 DEFAULT_INITIAL_CAPACITY

2. 定义一个全局变量存储table的实际元素长度，size

3. 定义一个全局变量存储临界点，即元素的size>=threshold这个临界点时，扩大table的容量

4. 因为index是根据hash和table的长度计算得到的，所以还需要重新对所有元素进行散列

实现如下：

Java代码

1. package sourcecoderead.collection.map;
4. public class EntryHashMap {
6. /// 初始容量 /*/
7. static final int DEFAULT_INITIAL_CAPACITY = 16;
9. static final float DEFAULT_LOAD_FACTOR = 0.75f;
11. /// 下次扩容的临界值 /*/
12. int threshold;
14. transient int size;
16. final float loadFactor;
18. transient Entry[] table;
20. public EntryHashMap() {
21. this.loadFactor = DEFAULT_LOAD_FACTOR;
22. threshold = (int) (DEFAULT_INITIAL_CAPACITY /* DEFAULT_LOAD_FACTOR);
23. table = new Entry[DEFAULT_INITIAL_CAPACITY];
24. }
26. public V put(K key, V value) {
27. // 计算出新的hash
28. int hash = hash(key.hashCode());
29. // 计算出数组小标i
30. int i = indexFor(hash, table.length);
31. // 遍历table[i]，如果table[i]没有与新加入的key相等的，则新加入
32. // 一个value到table[i]中的entry，否则将新的value覆盖旧的value并返回旧的value
33. for (Entry e = table[i]; e != null; e = e.next) {
34. Object k;
35. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
36. V oldValue = e.value;
37. e.value = value;
38. return oldValue;
39. }
40. }
41. addEntry(hash, key, value, i);
42. return null;
43. }
45. public V get(K key) {
46. // 计算出新的hash
47. int hash = hash(key.hashCode());
48. // 计算出数组小标i
49. int i = indexFor(hash, table.length);
50. for (Entry e = table[i]; e != null; e = e.next) {
51. Object k;
52. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
53. return e.value;
54. }
55. }
56. return null;
57. }
59. private void addEntry(int hash, K key, V value, int bucketIndex) {
60. Entry e = table[bucketIndex];
61. // 将新的元素插入链表前端
62. table[bucketIndex] = new Entry<>(hash, key, value, e);
63. if (size++ >= threshold)
64. resize(2 /* table.length);
65. }
67. void resize(int newCapacity) {
68. Entry[] oldTable = table;
69. int oldCapacity = oldTable.length;
70. Entry[] newTable = new Entry[newCapacity];
71. transfer(newTable);
72. table = newTable;
73. threshold = (int) (newCapacity /* loadFactor);
74. }
76. void transfer(Entry[] newTable) {
77. Entry[] src = table;
78. int newCapacity = newTable.length;
79. for (int j = 0; j < src.length; j++) {
80. Entry e = src[j];
81. if (e != null) {
82. src[j] = null;
83. do {
84. Entry next = e.next;
85. int i = indexFor(e.hash, newCapacity);
86. e.next = newTable[i];
87. newTable[i] = e;
88. e = next;
89. } while (e != null);
90. }
91. }
92. }
94. ///
95. /* 通过hash code 和table的length得到对应的数组下标
96. /*
97. /* @param h
98. /* @param length
99. /* @return
100. /*/
101. static int indexFor(int h, int length) {
102. return h & (length - 1);
103. }
105. ///
106. /* 通过一定算法计算出新的hash值
107. /*
108. /* @param h
109. /* @return
110. /*/
111. static int hash(int h) {
112. h ^= (h >>> 20) ^ (h >>> 12);
113. return h ^ (h >>> 7) ^ (h >>> 4);
114. }
116. public static void main(String[] args) {
117. EntryHashMap hashMap = new EntryHashMap();
118. hashMap.put("key", "value");
119. System.out.println(hashMap.get("key"));
120. }
121. }

来源： [http://tangyanbo.iteye.com/blog/1756536](http://tangyanbo.iteye.com/blog/1756536)

通过分析 JDK 源代码研究 Hash 存储机制

中国 [选择] 使用条款 dW 全部内容 ----------------- AIX and UNIX Information management Lotus Rational WebSphere ----------------- Architecture Grid computing Java 技术 Linux Multicore acceleration Open source Security SOA & Web services Web development XML ----------------- IBM 全部内容 首页 产品 服务与解决方案 支持与下载 个性化服务 developerWorks 中国 本文内容包括： 通过 HashMap、HashSet 的源代码分析其 Hash 存储机制 HashMap 的存储实现 Hash 算法的性能选项 HashMap 的读取实现 HashSet 的实现 参考资料 关于作者 对本文的评价 相关链接： Java technology 技术文档库 developerWorks 中国 > Java technology >

通过分析 JDK 源代码研究 Hash 存储机制

文档选项 未显示需要 JavaScript 的文档选项

级别： 中级

李 刚, 自由撰稿人

2009 年 11 月 26 日 HashMap 和 HashSet 是 Java Collection Framework 的两个重要成员，其中 HashMap 是 Map 接口的常用实现类，HashSet 是 Set 接口的常用实现类。虽然 HashMap 和 HashSet 实现的接口规范不同，但它们底层的 Hash 存储机制完全一样，甚至 HashSet 本身就采用 HashMap 来实现的。

通过 HashMap、HashSet 的源代码分析其 Hash 存储机制

集合和引用

就像引用类型的数组一样，当我们把 Java 对象放入数组之时，并不是真正的把 Java 对象放入数组中，只是把对象的引用放入数组中，每个数组元素都是一个引用变量。

实际上，HashSet 和 HashMap 之间有很多相似之处，对于 HashSet 而言，系统采用 Hash 算法决定集合元素的存储位置，这样可以保证能快速存、取集合元素；对于 HashMap 而言，系统 key-value 当成一个整体进行处理，系统总是根据 Hash 算法来计算 key-value 的存储位置，这样可以保证能快速存、取 Map 的 key-value 对。

在介绍集合存储之前需要指出一点：虽然集合号称存储的是 Java 对象，但实际上并不会真正将 Java 对象放入 Set 集合中，只是在 Set 集合中保留这些对象的引用而言。也就是说：Java 集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的 Java 对象。 回页首

HashMap 的存储实现

当程序试图将多个 key-value 放入 HashMap 中时，以如下代码片段为例： HashMap map = new HashMap(); map.put("语文" , 80.0); map.put("数学" , 89.0); map.put("英语" , 78.2);

HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置。

当程序执行 map.put("语文" , 80.0); 时，系统将调用"语文"的 hashCode() 方法得到其 hashCode 值——每个 Java 对象都有 hashCode() 方法，都可通过该方法获得它的 hashCode 值。得到这个对象的 hashCode 值之后，系统会根据该 hashCode 值来决定该元素的存储位置。

我们可以看 HashMap 类的 put(K key , V value) 方法的源代码： public V put(K key, V value) { // 如果 key 为 null，调用 putForNullKey 方法进行处理 if (key == null) return putForNullKey(value); // 根据 key 的 keyCode 计算 Hash 值 int hash = hash(key.hashCode()); // 搜索指定 hash 值在对应 table 中的索引 int i = indexFor(hash, table.length); // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素 for (Entry e = table[i]; e != null; e = e.next) { Object k; // 找到指定 key 与需要放入的 key 相等（hash 值相同 // 通过 equals 比较放回 true） if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry modCount++; // 将 key、value 添加到 i 索引处 addEntry(hash, key, value, i); return null; } JDK 源码

在 JDK 安装目录下可以找到一个 src.zip 压缩文件，该文件里包含了 Java 基础类库的所有源文件。只要读者有学习兴趣，随时可以打开这份压缩文件来阅读 Java 类库的源代码，这对提高读者的编程能力是非常有帮助的。需要指出的是：src.zip 中包含的源代码并没有包含像上文中的中文注释，这些注释是笔者自己添加进去的。

上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。

上面方法提供了一个根据 hashCode() 返回值来计算 Hash 码的方法：hash()，这个方法是一个纯粹的数学计算，其方法如下： static int hash(int h) { h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }

对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 Hash 码值总是相同的。接下来程序会调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。indexFor(int h, int length) 方法的代码如下： static int indexFor(int h, int length) { return h & (length-1); }

这个方法非常巧妙，它总是通过 h

& (table.length -1) 来得到该对象的保存位置——而 HashMap 底层数组的长度总是 2 的 n 次方，这一点可参看后面关于 HashMap 构造器的介绍。

当 length 总是 2 的倍数时，h

& (length-1)

将是一个非常巧妙的设计：假设 h=5,length=16, 那么 h & length - 1 将得到 5；如果 h=6,length=16, 那么 h & length - 1 将得到 6 ……如果 h=15,length=16, 那么 h & length - 1 将得到 15；但是当 h=16 时 , length=16 时，那么 h & length - 1 将得到 0 了；当 h=17 时 , length=16 时，那么 h & length - 1 将得到 1 了……这样保证计算得到的索引值总是位于 table 数组的索引之内。

根据上面 put 方法的源代码可以看出，当程序试图将一个 key-value 对放入 HashMap 中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但 key 不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部——具体说明继续看 addEntry() 方法的说明。

当向 HashMap 中添加 key-value 对，由其 key 的 hashCode() 返回值决定该 key-value 对（就是 Entry 对象）的存储位置。当两个 Entry 对象的 key 的 hashCode() 返回值相同时，将由 key 通过 eqauls() 比较值决定是采用覆盖行为（返回 true），还是产生 Entry 链（返回 false）。

上面程序中还调用了 addEntry(hash, key, value, i); 代码，其中 addEntry 是 HashMap 提供的一个包访问权限的方法，该方法仅用于添加一个 key-value 对。下面是该方法的代码： void addEntry(int hash, K key, V value, int bucketIndex) { // 获取指定 bucketIndex 索引处的 Entry Entry e = table[bucketIndex]; // ① // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry table[bucketIndex] = new Entry(hash, key, value, e); // 如果 Map 中的 key-value 对的数量超过了极限 if (size++ >= threshold) // 把 table 对象的长度扩充到 2 倍。 resize(2 /* table.length); // ② }

上面方法的代码很简单，但其中包含了一个非常优雅的设计：系统总是将新添加的 Entry 对象放入 table 数组的 bucketIndex 索引处——如果 bucketIndex 索引处已经有了一个 Entry 对象，那新添加的 Entry 对象指向原有的 Entry 对象（产生一个 Entry 链），如果 bucketIndex 索引处没有 Entry 对象，也就是上面程序①号代码的 e 变量是 null，也就是新放入的 Entry 对象指向 null，也就是没有产生 Entry 链。 回页首

Hash 算法的性能选项

根据上面代码可以看出，在同一个 bucket 存储 Entry 链的情况下，新放入的 Entry 总是位于 bucket 中，而最早放入该 bucket 中的 Entry 则位于这个 Entry 链的最末端。

上面程序中还有这样两个变量：

• size：该变量保存了该 HashMap 中所包含的 key-value 对的数量。
• threshold：该变量包含了 HashMap 能容纳的 key-value 对的极限，它的值等于 HashMap 的容量乘以负载因子（load factor）。

从上面程序中②号代码可以看出，当 size++ >= threshold 时，HashMap 会自动调用 resize 方法扩充 HashMap 的容量。每扩充一次，HashMap 的容量就增大一倍。

上面程序中使用的 table 其实就是一个普通数组，每个数组都有一个固定的长度，这个数组的长度就是 HashMap 的容量。HashMap 包含如下几个构造器：

• HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
• HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
• HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。

当创建一个 HashMap 时，系统会自动创建一个 table 数组来保存 HashMap 中的 Entry，下面是 HashMap 中一个构造器的代码： // 以指定初始化容量、负载因子创建 HashMap public HashMap(int initialCapacity, float loadFactor) { // 初始容量不能为负数 if (initialCapacity < 0) throw new IllegalArgumentException( "Illegal initial capacity: " + initialCapacity); // 如果初始容量大于最大容量，让出示容量 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; // 负载因子必须大于 0 的数值 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException( loadFactor); // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。 int capacity = 1; while (capacity < initialCapacity) capacity <<= 1; this.loadFactor = loadFactor; // 设置容量极限等于容量 / 负载因子 threshold = (int)(capacity / loadFactor); // 初始化 table 数组 table = new Entry[capacity]; // ① init(); }

上面代码中粗体字代码包含了一个简洁的代码实现：找出大于 initialCapacity 的、最小的 2 的 n 次方值，并将其作为 HashMap 的实际容量（由 capacity 变量保存）。例如给定 initialCapacity 为 10，那么该 HashMap 的实际容量就是 16。 initialCapacity 与 HashTable 的容量

创建 HashMap 时指定的 initialCapacity 并不等于 HashMap 的实际容量，通常来说，HashMap 的实际容量总比 initialCapacity 大一些，除非我们指定的 initialCapacity 参数值恰好是 2 的 n 次方。当然，掌握了 HashMap 容量分配的知识之后，应该在创建 HashMap 时将 initialCapacity 参数值指定为 2 的 n 次方，这样可以减少系统的计算开销。

程序①号代码处可以看到：table 的实质就是一个数组，一个长度为 capacity 的数组。

对于 HashMap 及其子类而言，它们采用 Hash 算法来决定集合中元素的存储位置。当系统开始初始化 HashMap 时，系统会创建一个长度为 capacity 的 Entry 数组，这个数组里可以存储元素的位置被称为“桶（bucket）”，每个 bucket 都有其指定索引，系统可以根据其索引快速访问该 bucket 里存储的元素。

无论何时，HashMap 的每个“桶”只存储一个元素（也就是一个 Entry），由于 Entry 对象可以包含一个引用变量（就是 Entry 构造器的的最后一个参数）用于指向下一个 Entry，因此可能出现的情况是：HashMap 的 bucket 中只有一个 Entry，但这个 Entry 指向另一个 Entry ——这就形成了一个 Entry 链。如图 1 所示： 图 1. HashMap 的存储示意 回页首

HashMap 的读取实现

当 HashMap 的每个 bucket 里存储的 Entry 只是单个 Entry ——也就是没有通过指针产生 Entry 链时，此时的 HashMap 具有最好的性能：当程序通过 key 取出对应 value 时，系统只要先计算出该 key 的 hashCode() 返回值，在根据该 hashCode 返回值找出该 key 在 table 数组中的索引，然后取出该索引处的 Entry，最后返回该 key 对应的 value 即可。看 HashMap 类的 get(K key) 方法代码： public V get(Object key) { // 如果 key 是 null，调用 getForNullKey 取出对应的 value if (key == null) return getForNullKey(); // 根据该 key 的 hashCode 值计算它的 hash 码 int hash = hash(key.hashCode()); // 直接取出 table 数组中指定索引处的值， for (Entry e = table[indexFor(hash, table.length)]; e != null; // 搜索该 Entry 链的下一个 Entr e = e.next) // ① { Object k; // 如果该 Entry 的 key 与被搜索 key 相同 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) return e.value; } return null; }

从上面代码中可以看出，如果 HashMap 的每个 bucket 里只有一个 Entry 时，HashMap 可以根据索引、快速地取出该 bucket 里的 Entry；在发生“Hash 冲突”的情况下，单个 bucket 里存储的不是一个 Entry，而是一个 Entry 链，系统只能必须按顺序遍历每个 Entry，直到找到想搜索的 Entry 为止——如果恰好要搜索的 Entry 位于该 Entry 链的最末端（该 Entry 是最早放入该 bucket 中），那系统必须循环到最后才能找到该元素。

归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据 Hash 算法来决定其存储位置；当需要取出一个 Entry 时，也会根据 Hash 算法找到其存储位置，直接取出该 Entry。由此可见：HashMap 之所以能快速存、取它所包含的 Entry，完全类似于现实生活中母亲从小教我们的：不同的东西要放在不同的位置，需要时才能快速找到它。

当创建 HashMap 时，有一个默认的负载因子（load factor），其默认值为 0.75，这是时间和空间成本上一种折衷：增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。

掌握了上面知识之后，我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值；如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；如果程序比较关心时间开销，内存比较宽裕则可以适当的减少负载因子。通常情况下，程序员无需改变负载因子的值。

如果开始就知道 HashMap 会保存多个 key-value 对，可以在创建时就使用较大的初始化容量，如果 HashMap 中 Entry 的数量一直不会超过极限容量（capacity / load factor），HashMap 就无需调用 resize() 方法重新分配 table 数组，从而保证较好的性能。当然，开始就将初始容量设置太高可能会浪费空间（系统需要创建一个长度为 capacity 的 Entry 数组），因此创建 HashMap 时初始化容量设置也需要小心对待。 [*回页首](http://www.ibm.com/developerworks/cn/java/j-lo-hash/?open&cm_mmc=6505-_-n-_-vrm_newsletter-_-10104_142587&cmibm_em=dm:0:10631101#main)

HashSet 的实现

对于 HashSet 而言，它是基于 HashMap 实现的，HashSet 底层采用 HashMap 来保存所有元素，因此 HashSet 的实现比较简单，查看 HashSet 的源代码，可以看到如下代码： public class HashSet extends AbstractSet implements Set, Cloneable, java.io.Serializable { // 使用 HashMap 的 key 保存 HashSet 中所有元素 private transient HashMap map; // 定义一个虚拟的 Object 对象作为 HashMap 的 value private static final Object PRESENT = new Object(); ... // 初始化 HashSet，底层会初始化一个 HashMap public HashSet() { map = new HashMap(); } // 以指定的 initialCapacity、loadFactor 创建 HashSet // 其实就是以相应的参数创建 HashMap public HashSet(int initialCapacity, float loadFactor) { map = new HashMap(initialCapacity, loadFactor); } public HashSet(int initialCapacity) { map = new HashMap(initialCapacity); } HashSet(int initialCapacity, float loadFactor, boolean dummy) { map = new LinkedHashMap(initialCapacity , loadFactor); } // 调用 map 的 keySet 来返回所有的 key public Iterator iterator() { return map.keySet().iterator(); } // 调用 HashMap 的 size() 方法返回 Entry 的数量，就得到该 Set 里元素的个数 public int size() { return map.size(); } // 调用 HashMap 的 isEmpty() 判断该 HashSet 是否为空， // 当 HashMap 为空时，对应的 HashSet 也为空 public boolean isEmpty() { return map.isEmpty(); } // 调用 HashMap 的 containsKey 判断是否包含指定 key //HashSet 的所有元素就是通过 HashMap 的 key 来保存的 public boolean contains(Object o) { return map.containsKey(o); } // 将指定元素放入 HashSet 中，也就是将该元素作为 key 放入 HashMap public boolean add(E e) { return map.put(e, PRESENT) == null; } // 调用 HashMap 的 remove 方法删除指定 Entry，也就删除了 HashSet 中对应的元素 public boolean remove(Object o) { return map.remove(o)==PRESENT; } // 调用 Map 的 clear 方法清空所有 Entry，也就清空了 HashSet 中所有元素 public void clear() { map.clear(); } ... }

由上面源程序可以看出，HashSet 的实现其实非常简单，它只是封装了一个 HashMap 对象来存储所有的集合元素，所有放入 HashSet 中的集合元素实际上由 HashMap 的 key 来保存，而 HashMap 的 value 则存储了一个 PRESENT，它是一个静态的 Object 对象。

HashSet 的绝大部分方法都是通过调用 HashMap 的方法来实现的，因此 HashSet 和 HashMap 两个集合在实现本质上是相同的。 HashMap 的 put 与 HashSet 的 add

由于 HashSet 的 add() 方法添加集合元素时实际上转变为调用 HashMap 的 put() 方法来添加 key-value 对，当新放入 HashMap 的 Entry 中 key 与集合中原有 Entry 的 key 相同（hashCode() 返回值相等，通过 equals 比较也返回 true），新添加的 Entry 的 value 将覆盖原来 Entry 的 value，但 key 不会有任何改变，因此如果向 HashSet 中添加一个已经存在的元素，新添加的集合元素（底层由 HashMap 的 key 保存）不会覆盖已有的集合元素。

掌握上面理论知识之后，接下来看一个示例程序，测试一下自己是否真正掌握了 HashMap 和 HashSet 集合的功能。 class Name { private String first; private String last; public Name(String first, String last) { this.first = first; this.last = last; } public boolean equals(Object o) { if (this == o) { return true; } if (o.getClass() == Name.class) { Name n = (Name)o; return n.first.equals(first) && n.last.equals(last); } return false; } } public class HashSetTest { public static void main(String[] args) { Set s = new HashSet(); s.add(new Name("abc", "123")); System.out.println( s.contains(new Name("abc", "123"))); } }

上面程序中向 HashSet 里添加了一个 new Name("abc", "123") 对象之后，立即通过程序判断该 HashSet 是否包含一个 new Name("abc", "123") 对象。粗看上去，很容易以为该程序会输出 true。

实际运行上面程序将看到程序输出 false，这是因为 HashSet 判断两个对象相等的标准除了要求通过 equals() 方法比较返回 true 之外，还要求两个对象的 hashCode() 返回值相等。而上面程序没有重写 Name 类的 hashCode() 方法，两个 Name 对象的 hashCode() 返回值并不相同，因此 HashSet 会把它们当成 2 个对象处理，因此程序返回 false。

由此可见，当我们试图把某个类的对象当成 HashMap 的 key，或试图将这个类的对象放入 HashSet 中保存时，重写该类的 equals(Object obj) 方法和 hashCode() 方法很重要，而且这两个方法的返回值必须保持一致：当该类的两个的 hashCode() 返回值相同时，它们通过 equals() 方法比较也应该返回 true。通常来说，所有参与计算 hashCode() 返回值的关键属性，都应该用于作为 equals() 比较的标准。 hashCode() 和 equals()

关于如何正确地重写某个类的 hashCode() 方法和 equals() 方法，请参考疯狂 Java 体系的《疯狂 Java 讲义》一书中相关内容。

如下程序就正确重写了 Name 类的 hashCode() 和 equals() 方法，程序如下： class Name { private String first; private String last; public Name(String first, String last) { this.first = first; this.last = last; } // 根据 first 判断两个 Name 是否相等 public boolean equals(Object o) { if (this == o) { return true; } if (o.getClass() == Name.class) { Name n = (Name)o; return n.first.equals(first); } return false; } // 根据 first 计算 Name 对象的 hashCode() 返回值 public int hashCode() { return first.hashCode(); } public String toString() { return "Name[first=" + first + ", last=" + last + "]"; } } public class HashSetTest2 { public static void main(String[] args) { HashSet set = new HashSet(); set.add(new Name("abc" , "123")); set.add(new Name("abc" , "456")); System.out.println(set); } }

上面程序中提供了一个 Name 类，该 Name 类重写了 equals() 和 toString() 两个方法，这两个方法都是根据 Name 类的 first 实例变量来判断的，当两个 Name 对象的 first 实例变量相等时，这两个 Name 对象的 hashCode() 返回值也相同，通过 equals() 比较也会返回 true。

程序主方法先将第一个 Name 对象添加到 HashSet 中，该 Name 对象的 first 实例变量值为"abc"，接着程序再次试图将一个 first 为"abc"的 Name 对象添加到 HashSet 中，很明显，此时没法将新的 Name 对象添加到该 HashSet 中，因为此处试图添加的 Name 对象的 first 也是" abc"，HashSet 会判断此处新增的 Name 对象与原有的 Name 对象相同，因此无法添加进入，程序在①号代码处输出 set 集合时将看到该集合里只包含一个 Name 对象，就是第一个、last 为"123"的 Name 对象。

参考资料

• “Java 理论与实践: 哈希”（developerWorks，2003 年 8 月）：介绍在创建 Java 类以有效和准确定义 hashCode() 和 equals() 时应遵循的规则和指南。
• “Java 理论与实践: 构建一个更好的 HashMap”（developerWorks，2003 年 8 月）：BrianGoetz 仔细分析了 ConcurrentHashMap 的代码，并探讨 Doug Lea 是如何在不损失线程安全的情况下取得这么骄人成绩的。
• “Merlin 的魔力：维护插入顺序使用新链接的 HashSet 和 HashMap 实现”（developerWorks，2001 年 10 月）：学习如何按插入顺序迭代散列集合中的各个元素，以及如何使用 J2SE，版本 1.4 中的新 Collections Framework 按存取顺序维护元素。
• 在 developerWorks Java 技术专区 上可以找到数百篇其他的 Java 参考资料。

关于作者 李刚，从事 Java EE 应用开发近 10 年。曾任 LITEON 公司的 J2EE 技术主管，负责该公司的企业信息化平台的架构设计。曾任广州电信、广东龙泉科技等公司的技术培训教师。疯狂 Java 联盟（http://www.crazyit.org）站长。疯狂 Java 实训营创始人，疯狂 Java 体系图书作者，曾任东方标准广州中心软件教学总监，曾兼任广东技术师范学院计算机科学系的兼职副教授。国内知名IT技术作家，已出版《疯狂 Java 讲义》、《轻量级 Java EE 企业应用实战》、《疯狂 Ajax 讲义》、《Struts 2.1 权威指南》、《Ruby On Rails 敏捷开发最佳实践》等著作。

对本文的评价 太差！ (1) 需提高 (2) 一般；尚可 (3) 好文章 (4) 真棒！(5) 建议？

IBM 公司保留在 developerWorks 网站上发表的内容的著作权。未经IBM公司或原始作者的书面明确许可，请勿转载。如果您希望转载，请通过 提交转载请求表单 联系我们的编辑团队。 关于 IBM 隐私条约 联系 IBM 使用条款