Java中HashMap底层实现原理(JDK1.8)源码分析
这几天学习了HashMap的底层实现,但是发现好几个版本的，代码不一，而且看了包的HashMap和JDK中的HashMap的也不是一样，原来他们没有指定JDK版本，很多文章都是旧版本JDK1.6.JDK1.7的。现在我来分析一哈最新的JDK1.8的HashMap及性能优化。
在JDK1.6，JDK1.7中，HashMap采用位桶+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。
简单说下HashMap的实现原理：
首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。
当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中
即HashMap的原理图是：
一，JDK1.8中的涉及到的数据结构
1，位桶数组
transient Node[]//存储（位桶）的数组
2，数组元素Node实现了Entry接口
//Node是单向链表，它实现了Map.Entry接口
static class Node implements Map.Entry {
//构造函数Hash值 键 值 下一个节点
Node(int hash, K key, V value, Node next) {
this.hash =
this.key =
this.value =
this.next =
public final K getKey()
public final V getValue()
public final String toString() { return key + = + }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
public final V setValue(V newValue) {
V oldValue =
value = newV
return oldV
//判断两个node是否相等,若key和value都相等，返回true。可以与自身比较为true
public final boolean equals(Object o) {
if (o == this)
if (o instanceof Map.Entry) {
Map.Entry e = (Map.Entry)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
static final class TreeNode extends LinkedHashMap.Entry {
TreeNode //左子树
TreeNode//右子树
// needed to unlink next upon deletion
//颜色属性
TreeNode(int hash, K key, V val, Node next) {
super(hash, key, val, next);
//返回当前节点的根节点
final TreeNode root() {
for (TreeNode r = this,;) {
if ((p = r.parent) == null)
二，中的数据域
加载因子（默认0.75）：为什么需要使用加载因子，为什么需要扩容呢？因为如果填充比很大，说明利用的空间很多，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率
HashMap本来是以空间换时间，所以填充比没必要太大。但是填充比太小又会导致空间浪费。如果关注内存，填充比可以稍大，如果主要关注查找性能，填充比可以稍小。
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable {
private static final long serialVersionUID = 181265L;
static final int DEFAULT_INITIAL_CAPACITY = 1 && 4; // aka 16
static final int MAXIMUM_CAPACITY = 1 && 30;//最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//填充比
//当add一个元素到某个位桶，其链表长度达到8时将链表转换为红黑树
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
transient Node[]//存储元素的数组
transient Set<map.entry& entryS
//存放元素的个数
transient int modC//被修改的次数fast-fail机制
//临界值 当实际大小(容量*填充比)超过临界值时，会进行扩容
final float loadF//填充比（......后面略）</map.entry
三，HashMap的构造函数
HashMap的构造方法有4种，主要涉及到的参数有，指定初始容量，指定填充比和用来初始化的Map
//构造函数1
public HashMap(int initialCapacity, float loadFactor) {
//指定的初始容量非负
if (initialCapacity & 0)
throw new IllegalArgumentException(Illegal initial capacity:
initialCapacity);
//如果指定的初始容量大于最大容量,置为最大容量
if (initialCapacity & MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//填充比为正
if (loadFactor &= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException(Illegal load factor:
loadFactor);
this.loadFactor = loadF
this.threshold = tableSizeFor(initialCapacity);//新的扩容临界值
//构造函数2
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
//构造函数3
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
//构造函数4用m的元素初始化散列映射
public HashMap(Map m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
四，HashMap的存取机制
1，HashMap如何getValue值，看源码
public V get(Object key) {
return (e = getNode(hash(key), key)) == null ? null : e.
* Implements Map.get and related methods
* @param hash hash for key
* @param key the key
* @return the node, or null if none
final Node getNode(int hash, Object key) {
Node[]//Entry对象数组
Node first,e; //在tab数组中经过散列的第一个位置
/*找到插入的第一个Node，方法是hash值和n-1相与，tab[(n - 1) & hash]*/
//也就是说在一条链上的hash值相同的
if ((tab = table) != null && (n = tab.length) & 0 &&(first = tab[(n - 1) & hash]) != null) {
/*检查第一个Node是不是要找的Node*/
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))//判断条件是hash值要相同，key值要相同
/*检查first后面的node*/
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode)first).getTreeNode(hash, key);
/*遍历后面的链表，找到key值和hash值都相同的Node*/
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
} while ((e = e.next) != null);
get(key)方法时获取key的hash值，计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等，不等就遍历后面的链表找到相同的key值返回对应的Value值即可
2，HashMap如何put(key，value);看源码
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
* Implements Map.put and related methods
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).
/*如果table的在（n-1）&hash的值是空，就新建一个节点插入在该位置*/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
/*表示有冲突,开始处理冲突*/
/*检查第一个Node，p是不是要找的值*/
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
else if (p instanceof TreeNode)
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
for (int binCount = 0; ; ++binCount) {
/*指针为空就挂在后面*/
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果冲突的节点数已经达到8个，看是否需要改变冲突节点的存储结构，
//treeifyBin首先判断当前hashMap的长度，如果不足64，只进行
//resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树
if (binCount &= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
/*如果有相同的key值就结束遍历*/
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
/*就是链表上有相同的key值*/
if (e != null) { // existing mapping for key，就是key的Value存在
V oldValue = e.
if (!onlyIfAbsent || oldValue == null)
afterNodeAccess(e);
return oldV//返回存在的Value值
/*如果当前大小大于门限，门限原本是初始容量*0.75*/
if (++size & threshold)
resize();//扩容两倍
afterNodeInsertion(evict);
下面简单说下添加键值对put(key,value)的过程：
1，判断键值对数组tab[]是否为空或为null，否则以默认大小resize()；
2，根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加，否则转入3
3，判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理
五，HasMap的扩容机制resize();
构造hash表时，如果不指明初始大小，默认大小为16（即Node数组大小16），如果Node[]数组中的元素达到（填充比*Node.length）重新调整HashMap大小 变为原来2倍大小,扩容很耗时
* Initializes or doubles table size.
If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
* @return the table
final Node[] resize() {
Node[] oldTab =
int oldCap = (oldTab == null) ? 0 : oldTab.
int oldThr =
int newCap, newThr = 0;
/*如果旧表的长度不是空*/
if (oldCap & 0) {
if (oldCap &= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldT
/*把新表的长度设置为旧表长度的两倍，newCap=2*oldCap*/
else if ((newCap = oldCap && 1) & MAXIMUM_CAPACITY &&
oldCap &= DEFAULT_INITIAL_CAPACITY)
/*把新表的门限设置为旧表门限的两倍，newThr=oldThr*2*/
newThr = oldThr && 1; // double threshold
/*如果旧表的长度的是0，就是说第一次初始化表*/
else if (oldThr & 0) // initial capacity was placed in threshold
newCap = oldT
// zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
if (newThr == 0) {
float ft = (float)newCap * loadF//新表长度乘以加载因子
newThr = (newCap & MAXIMUM_CAPACITY && ft & (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
threshold = newT
@SuppressWarnings({&rawtypes&,&unchecked&})
/*下面开始构造新表，初始化表中的数据*/
Node[] newTab = (Node[])new Node[newCap];
table = newT//把新表赋值给table
if (oldTab != null) {//原表不是空要把原表中数据移动到新表中
/*遍历原来的旧表*/
for (int j = 0; j & oldC ++j) {
if ((e = oldTab[j]) != null) {
oldTab[j] =
if (e.next == null)//说明这个node没有链表直接放在新表的e.hash & (newCap - 1)位置
newTab[e.hash & (newCap - 1)] =
else if (e instanceof TreeNode)
((TreeNode)e).split(this, newTab, j, oldCap);
/*如果e后边有链表,到这里表示e后面带着个单链表，需要遍历单链表，将每个结点重*/
else { // preserve order保证顺序
////新计算在新表的位置，并进行搬运
Node loHead = null, loTail =
Node hiHead = null, hiTail =
next = e.//记录下一个结点
//新表是旧表的两倍容量，实例上就把单链表拆分为两队，
//e.hash&oldCap为偶数一队，e.hash&oldCap为奇数一对
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loTail.next =
if (hiTail == null)
hiTail.next =
} while ((e = next) != null);
if (loTail != null) {//lo队不为null，放在新表原位置
loTail.next =
newTab[j] = loH
if (hiTail != null) {//hi队不为null，放在新表j+oldCap位置
hiTail.next =
newTab[j + oldCap] = hiH
return newT
六，JDK1.8使用红黑树的改进
在java jdk8中对HashMap的源码进行了优化，在jdk7中，HashMap处理&碰撞&的时候，都是采用链表来存储，当碰撞的结点很多时，查询时间是O（n）。
在jdk8中，HashMap处理&碰撞&增加了红黑树这种数据结构，当碰撞结点较少时，采用链表存储，当较大时（&8个），采用红黑树（特点是查询时间是O（logn））存储（有一个阀值控制，大于阀值(8个)，将链表存储转换成红黑树存储）
问题分析：
你可能还知道哈希碰撞会对hashMap的性能带来灾难性的影响。如果多个hashCode()的值落到同一个桶内的时候，这些值是存储到一个链表中的。最坏的情况下，所有的key都映射到同一个桶中，这样hashmap就退化成了一个链表&&查找时间从O(1)到O(n)。
随着HashMap的大小的增长，get()方法的开销也越来越大。由于所有的记录都在同一个桶里的超长链表内，平均查询一条记录就需要遍历一半的列表。
JDK1.8HashMap的红黑树是这样解决的：
如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。
它是如何工作的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'java 查看JDK中底层源码,Java教程,Java案例,Java实例
本站中文域名：、
| | | |
| | |
您的位置： &&
&& java 查看JDK中底层源码
java 查看JDK中底层源码
&&& 1.点 “window”-& "Preferences" -& "Java" -& "Installed JRES"
&&& 2.此时"Installed JRES"右边是列表窗格，列出了系统中的 JRE 环境，
取舍你的JRE，
而后点边上的 "Edit..."， 会浮现一个窗口(Edit JRE)
&&& 3.选中rt.jar文件的这一项：“c:\program files\java\jre_1.5.0_06\lib\rt.jar”
&&& 点 左边的“+” 号铺开它，
&&& 4.铺开后，
可以看到“Source Attachment:(none)”，点这一项，点右边的按钮“Source Attachment...”,
取舍你的JDK目录下的 “src.zip”文件
&&& 5.一路点"ok",
&&& 1.点 “window”-& "Preferences" -& "Java" -& "Installed JRES"
&&& 2.此时"Installed JRES"右边是列表窗格，列出了系统中的 JRE 环境，
取舍你的JRE，
而后点边上的 "Edit..."， 会浮现一个窗口(Edit JRE)
&&& 3.选中rt.jar文件的这一项：“c:\program files\java\jre_1.5.0_06\lib\rt.jar”
&&& 点 左边的“+” 号铺开它，
&&& 4.铺开后，
可以看到“Source Attachment:(none)”，点这一项，点右边的按钮“Source Attachment...”,
取舍你的JDK目录下的 “src.zip”文件
&&& 5.一路点"ok",
Google搜索中
搜狗搜索中
在线教程导航
数据库开发
产品库推荐
| 站长工具：
All Rights Reserved.
珠江路在线版权所有
苏ICP备号 中文域名：
| | 1693人阅读
head first java（18）
不会看ＪＤＫ源代码，相当于没学过Ｊａｖａ。
网上不容易找到一篇帮助我解决了如何在Ｅｃｌｉｐｓｅ下查看JDK源代码 的文章。
核心提示：在Eclipse中查看JDK类库的源代码！！！ 设置： 1.点 window- Preferences - Java - Installed JRES 2.此时Installed JRES右边是列表窗格，列出了系统中的 JRE 环境，选择你的JRE，然后点边上的 Edit...， 会出现一个窗口(Edit JRE) 3.选中rt.jar文件的这一项
在Eclipse中查看JDK类库的源代码！！！&
1.点 “window”-& &Preferences& -& &Java& -& &Installed JRES&
2.此时&Installed JRES&右边是列表窗格，列出了系统中的 JRE 环境，选择你的JRE，然后点边上的 &Edit...&， 会出现一个窗口(Edit JRE)
3.选中rt.jar文件的这一项：“c:\program files\java\jre_1.5.0_06\lib\rt.jar”&
点 左边的“+” 号展开它，
4.展开后，可以看到“Source Attachment:(none)”，点这一项，点右边的按钮“Source Attachment...”, 选择你的JDK目录下的 “src.zip”文件
5.一路点&ok&,结束。
dt.jar是关于运行环境的类库,主要是swing的包&
tools.jar是关于一些工具的类库&
rt.jar包含了jdk的基础类库，也就是你在java doc里面看到的所有的类的class文件
可以在 Java 源代码编辑器或代码片段编辑测试窗中选择类型、方法或字段的名称，然后对元素的定义打开编辑器。
在 Java 编辑器中，选择类型、方法或字段的名称。您也可以仅仅在名称中单击一次。&
执行下列其中一项操作：&
1.从菜单栏中，选择浏览 & 打开声明&
2.从编辑器的弹出菜单中，选择打开声明&
3.按 F3 键
1，你把鼠标放在一个jkd的类上按下F3，如果这时迁移到一个class文件拿去的话&
2，class文件画面会有一个“关联源代码”按钮，点击这个按钮，然后从系统文件选择jdk下的src.zip文件&
这样就ok了，以后你就可以直接看到源码了。
刚才在论坛不经意间，看到有关源码阅读的。回想自己前几年，阅读源码那种兴奋和成就感()，不禁又有一种激动。
源码阅读，我觉得最核心有三点：技术基础+强烈的求知欲+耐心。
说到技术基础，我打个比方吧，如果你从来没有学过Java，或是任何一门编程语言如C++，一开始去啃《Core Java》，你是很难从中吸收到营养的，特别是《深入Java虚拟机》这类书，别人觉得好，未必适合现在的你。
虽然Tomcat的源码很漂亮，但我绝不建议你一开始就读它。我文中会专门谈到这个，暂时不展开。
强烈的求知欲，我认为是阅读源码的最核心驱动力。我见到绝大多数程序员，对学习的态度，基本上就是这几个层次(很偏激哦)：
1、只关注项目本身，不懂就baidu一下。
2、除了做好项目，还会阅读和项目有关的技术书籍，看wikipedia。
3、除了阅读和项目相关的书外，还会阅读IT行业的书，比如学Java时，还会去了解函数语言，如LISP。
4、找一些开源项目看看，大量试用第三方框架，还会写写demo。
5、阅读基础框架、J2EE规范、Debug服务器内核。
大多数程序都是第1种，到第5种不光需要浓厚的兴趣，还需要勇气：我能读懂吗？其实，你能够读懂的。
耐心，真的很重要。因为你极少看到阅读源码的指导性文章或书籍，也没有人要求或建议你读。你读的过程中经常会卡住，而一卡主可能就陷进了迷宫。这时，你需要做的，可能是暂时中断一下，再从外围看看它：如API结构、框架的设计图。
我就说说如何读Java源码，以及我曾经的阅读感悟。
Java源码初接触
如果你进行过一年左右的开发，喜欢用eclipse的debug功能。好了，你现在就有阅读源码的技术基础。
我建议从JDK源码开始读起，这个直接和eclipse集成，不需要任何配置。
可以从JDK的工具包开始，也就是我们学的《数据结构和算法》Java版，如List接口和ArrayList、LinkedList实现，HashMap和TreeMap等。这些数据结构里也涉及到排序等算法，一举两得。
面试时，考官总喜欢问ArrayList和Vector的区别，你花10分钟读读源码，估计一辈子都忘不了。
然后是core包，也就是String、StringBuffer等。
如果你有一定的Java IO基础，那么不妨读读FileReader等类。我建议大家看看《Java In A Nutshell》，里面有整个Java IO的架构图。Java IO类库，如果不理解其各接口和继承关系，则阅读始终是一头雾水。
Java IO 包，我认为是对继承和接口运用得最优雅的案例。如果你将来做架构师，你一定会经常和它打交道，如项目中部署和配置相关的核心类开发。
读这些源码时，只需要读懂一些核心类即可，如和ArrayList类似的二三十个类，对于每一个类，也不一定要每个方法都读懂。像String有些方法已经到虚拟机层了(native方法)，如hashCode方法。
当然，如果有兴趣，可以对照看看JRockit的源码，同一套API，两种实现，很有意思的。
如果你再想钻的话，不妨看看针对虚拟机的那套代码，如System ClassLoader的原理，它不在JDK包里，JDK是基于它的。JDK的源码Zip包只有10来M，它像是有50来M，Sun公司有下载的，不过很隐秘。我曾经为自己找到、读过它很兴奋了一阵。
Java Web开发源码
在阅读Tomcat等源码前，一定要有一定的积累。我的切实体会，也可以说是比较好的阶梯是：
1、写过一些Servlet和JSP代码。注意，不是用什么Struts，它是很难接触到Servlet精髓的。用好Struts只是皮毛。
2、看过《Servlet和JSP核心编程》
3、看过Sun公司的Servlet规范
4、看过http协议的rfc，debug过http的数据包
如果有以上基础，我也不建议你开始读Tomcat源码。我建议你在阅读Tomcat源码前，读过Struts源码，Struts源码比WebWork要简单得多。这个框架是可以100%读懂的，至少WebWork我没有100%读懂。我曾经因为读懂了Struts源码，自己写过一个Web框架。
当然，在读Struts框架前，最好看过它的MailReader等demo，非常非常不错的。
如果你做过一些Struts项目，那么读它时就更得心应手了。
在读Struts前，建议看看mvnforum的源码，它部分实现了Struts的功能，虽然这个BBS做得不敢恭维。
如果你读过Struts，再开始考虑Tomcat源码阅读吧。
不过，我还是不建议直接读它，先读读onJava网站上的系列文章《How Tomcat Works》吧，它才是Tomcat的最最简易版。它告诉你HttpServletRequest如何在容器内部实现的，Tomcat如何通过Socket来接受外面的请求，你的Servlet代码如何被Tomcat容器调用的(回调)。
学习JSP，一定要研读容器将JSP编译后的Servlet源码。
为什么我总是称呼Tomcat为容器，而不是服务器？这个疑问留给大家吧。
如果你一定要读Tomcat，那么就读Jetty吧。至少它是嵌入式，可以直接在eclispe里面设置断点debug。虽然Tomcat也有嵌入式版本。
Java数据库源码阅读
我建议，先读读Sun的JDBC规范。
我想你一定写过JDBC的代码，那么这时候可以开始阅读源码了。
如果了解JDBC规范(接口)，那么它的实现，JDBC Driver就一定要开始了解，我的建议是，读读mysql的jdbc驱动，因为它开源、设计优雅。在读mysql的JDBC驱动源码时，建议看看mysql的内幕，官方正好有本书，《Mysql Internals》，我五年前读过一部分。比如你可以知道mysql的JDBC驱动，如何通过socket数据包(connect、query)，给这个C++开发的mysql服务器交互的。
通过上面的阅读，你可以知道，你的业务代码、JDBC规范、JDBC驱动、以及数据库，它们是如何一起协作的。
如果你了解这些内幕，那么你再学习Hibernate、iBatis等持久化框架时，就会得心应手的。
读过JDBC驱动，那么下一步一定要读读数据库了。而正好有一个强大的数据库是用Java开发的，Hsqldb。它是嵌入式数据库，比如用在桌面客户端软件里，如Mail Client。
我四年前为此写过，就不介绍了。
Java通讯及客户端软件
我强烈推荐即时通讯软件wildfire和Spark。你可以把wildfire理解成MSN服务器，Spark理解成MSN客户端。它们是通过XMPP协议通讯的。
我曾经在一个项目中，定制过Spark，当然也包括服务端的一些改动。所以它们的源码我都读过。
我之所以推荐它们。是因为：
1、XMPP够轻量级，好理解
2、学习Socket通讯实现，特别是C/S架构设计
3、模块化设计。它们都是基于module的，你既可以了解模块化架构，还可以了解模块化的技术支撑：Java虚拟机的ClassLoader的应用场景。
4、Event Driven架构。虽然GUI都是Event驱动的，但Spark的设计尤其优雅
这么说吧，读它们的源码，你会为做一名程序员而自豪，因为无论是他们的架构设计还是代码,都太漂亮了。
Java企业级应用
当然了，就是Hibernate、Spring这类框架。
在读Spring源码前，一定要先看看Rod Johnson写的那边《J2EE Design and Development》，它是Spring的设计思路。注意，不是中文版，中文版完全被糟蹋了。
在读Hibernate源码前，一定要读读Gavin King写的那本《Hibernate in Action》，同时，应该再读读Martin Fowler写的《企业应用架构模式》，它专门谈到持久化框架的设计思路。当你觉得这两本书读透了,再去看它们源码吧。
而且，在读源码前，你会发现它们用到很多第三方Jar包，二三十个，你最好把那些Jar包先一个个搞明白。
说到企业应用，一定会涉及到工作流。我当年读过jBPM的源码，网上有介绍jBPM内核的文章(银狐)。我感觉它的内核也就两千行，不要害怕。我曾经。
当然了，读工作流源码，前提是一定要对其理论模型有深入的了解，以及写过一些demo、或做过一些项目。
我上面介绍的这些，是我自己读过的，也适合一般人阅读。
我也读过一些非Java源码，感觉不错，也推荐给大家：
dojo源码&它的架构设计得很优雅，仿Java的import和extends。但实际应用起来一塌糊涂。我们当年基于这个开发了自己的框架，不过我不是主力。
Flex源码&Flex 08年底刚刚开源后，我就用它做过一个中型项目，应该说是国内的技术先行者。当时市面没有有深度的书，也没有开源项目。我纯粹是看Flex的Help文档和源码，把项目搞定的。两三年过去了，现在觉得系统设计得蛮优雅的。
好了，先介绍到这里。
上面说到的这些Java源码，我都是4年前、甚至更早读过的。技术变化这么快，像互联网的高速发展，催生很多高性能、分布式数据库，如hadoop。我一看，发现自己已经落伍了。
这几年，想必已经出现了很多优秀的框架，大家不妨分享出来。
这三年，一直在创业，主要是技术应用，偏业务，源码阅读不多，但很欣赏那些专注于技术的狂热者。
现暂别创业，进入一家电子商务公司，负责其B2C网站的改版和运营。
(广告)如果你对技术、对高负载的大型B2C开发也情有独钟，不妨看看。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：88867次
积分：1497
积分：1497
排名：千里之外
原创：56篇
转载：19篇
评论：17条
(1)(1)(2)(1)(3)(3)(1)(2)(7)(2)(12)(21)(14)(7)
