常见数据结构与算法整理总结(上)

数据结构是以某种形式将数据组织在一起的集合,它不仅存储数据,还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容,如有错误,欢迎指出。

为了便于描述,文中涉及到的代码部分都是用Java语言编写的,其实Java本身对常见的几种数据结构,线性表、栈、队列等都提供了较好的实现,就是我们经常用到的Java集合框架,有需要的可以阅读这篇文章。Java – 集合框架完全解析

一、线性表
  1.数组实现
  2.链表
二、栈与队列
三、树与二叉树
  1.树
  2.二叉树基本概念
  3.二叉查找树
  4.平衡二叉树
  5.红黑树
四、图
五、总结

一、线性表

线性表是最常用且最简单的一种数据结构,它是n个数据元素的有限序列。

实现线性表的方式一般有两种,一种是使用数组存储线性表的元素,即用一组连续的存储单元依次存储线性表的数据元素。另一种是使用链表存储线性表的元素,即用一组任意的存储单元存储线性表的数据元素(存储单元可以是连续的,也可以是不连续的)。

数组实现

数组是一种大小固定的数据结构,对线性表的所有操作都可以通过数组来实现。虽然数组一旦创建之后,它的大小就无法改变了,但是当数组不能再存储线性表中的新元素时,我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。

  • 代码1 创建一个更大的数组来替换当前数组
int[] oldArray = new int[10];
        
int[] newArray = new int[20];
        
for (int i = 0; i < oldArray.length; i++) {
    newArray[i] = oldArray[i];
}

// 也可以使用System.arraycopy方法来实现数组间的复制     
// System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
        
oldArray = newArray;
  • 代码2 在数组位置index上添加元素e
//oldArray 表示当前存储元素的数组
//size 表示当前元素个数
public void add(int index, int e) {

    if (index > size || index < 0) {
        System.out.println("位置不合法...");
    }

    //如果数组已经满了 就扩容
    if (size >= oldArray.length) {
        // 扩容函数可参考代码1
    }

    for (int i = size - 1; i >= index; i--) {
        oldArray[i + 1] = oldArray[i];
    }

    //将数组elementData从位置index的所有元素往后移一位
    // System.arraycopy(oldArray, index, oldArray, index + 1,size - index);

    oldArray[index] = e;

    size++;
}

上面简单写出了数组实现线性表的两个典型函数,具体我们可以参考Java里面的ArrayList集合类的源码。数组实现的线性表优点在于可以通过下标来访问或者修改元素,比较高效,主要缺点在于插入和删除的花费开销较大,比如当在第一个位置前插入一个元素,那么首先要把所有的元素往后移动一个位置。为了提高在任意位置添加或者删除元素的效率,可以采用链式结构来实现线性表。

链表

链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成,这些节点不必在内存中相连。每个节点由数据部分Data和链部分Next,Next指向下一个节点,这样当添加或者删除时,只需要改变相关节点的Next的指向,效率很高。

单链表的结构

下面主要用代码来展示链表的一些基本操作,需要注意的是,这里主要是以单链表为例,暂时不考虑双链表和循环链表。

  • 代码3 链表的节点
class Node<E> {

    E item;
    Node<E> next;
    
    //构造函数
    Node(E element) {
       this.item = element;
       this.next = null;
   }
}
  • 代码4 定义好节点后,使用前一般是对头节点和尾节点进行初始化
//头节点和尾节点都为空 链表为空
Node<E> head = null;
Node<E> tail = null;
  • 代码5 空链表创建一个新节点
//创建一个新的节点 并让head指向此节点
head = new Node("nodedata1");

//让尾节点也指向此节点
tail = head;
  • 代码6 链表追加一个节点
//创建新节点 同时和最后一个节点连接起来
tail.next = new Node("node1data2");

//尾节点指向新的节点
tail = tail.next;
  • 代码7 顺序遍历链表
Node<String> current = head;
while (current != null) {
    System.out.println(current.item);
    current = current.next;
}
  • 代码8 倒序遍历链表
static void printListRev(Node<String> head) {
//倒序遍历链表主要用了递归的思想
    if (head != null) {
        printListRev(head.next);
        System.out.println(head.item);
    }
}
  • 代码 单链表反转
//单链表反转 主要是逐一改变两个节点间的链接关系来完成
static Node<String> revList(Node<String> head) {

    if (head == null) {
        return null;
    }

    Node<String> nodeResult = null;

    Node<String> nodePre = null;
    Node<String> current = head;

    while (current != null) {

        Node<String> nodeNext = current.next;

        if (nodeNext == null) {
            nodeResult = current;
        }

        current.next = nodePre;
        nodePre = current;
        current = nodeNext;
    }

    return nodeResult;
}

上面的几段代码主要展示了链表的几个基本操作,还有很多像获取指定元素,移除元素等操作大家可以自己完成,写这些代码的时候一定要理清节点之间关系,这样才不容易出错。

链表的实现还有其它的方式,常见的有循环单链表,双向链表,循环双向链表。 循环单链表 主要是链表的最后一个节点指向第一个节点,整体构成一个链环。 双向链表 主要是节点中包含两个指针部分,一个指向前驱元,一个指向后继元,JDK中LinkedList集合类的实现就是双向链表。** 循环双向链表** 是最后一个节点指向第一个节点。

二、栈与队列

栈和队列也是比较常见的数据结构,它们是比较特殊的线性表,因为对于栈来说,访问、插入和删除元素只能在栈顶进行,对于队列来说,元素只能从队列尾插入,从队列头访问和删除。

栈是限制插入和删除只能在一个位置上进行的表,该位置是表的末端,叫作栈顶,对栈的基本操作有push(进栈)和pop(出栈),前者相当于插入,后者相当于删除最后一个元素。栈有时又叫作LIFO(Last In First Out)表,即后进先出。

栈的模型

下面我们看一道经典题目,加深对栈的理解。

关于栈的一道经典题目

上图中的答案是C,其中的原理可以好好想一想。

因为栈也是一个表,所以任何实现表的方法都能实现栈。我们打开JDK中的类Stack的源码,可以看到它就是继承类Vector的。当然,Stack是Java2前的容器类,现在我们可以使用LinkedList来进行栈的所有操作。

队列

队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。

队列示意图

我们可以使用链表来实现队列,下面代码简单展示了利用LinkedList来实现队列类。

  • 代码9 简单实现队列类
public class MyQueue<E> {

    private LinkedList<E> list = new LinkedList<>();

    // 入队
    public void enqueue(E e) {
        list.addLast(e);
    }

    // 出队
    public E dequeue() {
        return list.removeFirst();
    }
}

普通的队列是一种先进先出的数据结构,而优先队列中,元素都被赋予优先级。当访问元素的时候,具有最高优先级的元素最先被删除。优先队列在生活中的应用还是比较多的,比如医院的急症室为病人赋予优先级,具有最高优先级的病人最先得到治疗。在Java集合框架中,类PriorityQueue就是优先队列的实现类,具体大家可以去阅读源码。

三、树与二叉树

树型结构是一类非常重要的非线性数据结构,其中以树和二叉树最为常用。在介绍二叉树之前,我们先简单了解一下树的相关内容。

** 树 是由n(n>=1)个有限节点组成一个具有层次关系的集合。它具有以下特点:每个节点有零个或多个子节点;没有父节点的节点称为节点;每一个非根节点有且只有一个 父节点 **;除了根节点外,每个子节点可以分为多个不相交的子树。

树的结构

二叉树基本概念

  • 定义

二叉树是每个节点最多有两棵子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。

  • 相关性质

二叉树的每个结点至多只有2棵子树(不存在度大于2的结点),二叉树的子树有左右之分,次序不能颠倒。

二叉树的第i层至多有2(i-1)个结点;深度为k的二叉树至多有2k-1个结点。

一棵深度为k,且有2^k-1个节点的二叉树称之为** 满二叉树 **;

深度为k,有n个节点的二叉树,当且仅当其每一个节点都与深度为k的满二叉树中,序号为1至n的节点对应时,称之为** 完全二叉树 **。

若设二叉树的深度为h,除第 h 层外,其它各层 (1~h-1) 的结点数都达到最大个数,第 h 层所有的结点都连续集中在最左边,这就是完全二叉树。

  • 三种遍历方法

在二叉树的一些应用中,常常要求在树中查找具有某种特征的节点,或者对树中全部节点进行某种处理,这就涉及到二叉树的遍历。二叉树主要是由3个基本单元组成,根节点、左子树和右子树。如果限定先左后右,那么根据这三个部分遍历的顺序不同,可以分为先序遍历、中序遍历和后续遍历三种。

(1) 先序遍历 若二叉树为空,则空操作,否则先访问根节点,再先序遍历左子树,最后先序遍历右子树。
(2) 中序遍历 若二叉树为空,则空操作,否则先中序遍历左子树,再访问根节点,最后中序遍历右子树。
(3) 后序遍历 若二叉树为空,则空操作,否则先后序遍历左子树访问根节点,再后序遍历右子树,最后访问根节点。

给定二叉树写出三种遍历结果
  • 树和二叉树的区别

(1) 二叉树每个节点最多有2个子节点,树则无限制。
(2) 二叉树中节点的子树分为左子树和右子树,即使某节点只有一棵子树,也要指明该子树是左子树还是右子树,即二叉树是有序的。
(3) 树决不能为空,它至少有一个节点,而一棵二叉树可以是空的。

上面我们主要对二叉树的相关概念进行了介绍,下面我们将从二叉查找树开始,介绍二叉树的几种常见类型,同时将之前的理论部分用代码实现出来。

二叉查找树

  • 定义

二叉查找树就是二叉排序树,也叫二叉搜索树。二叉查找树或者是一棵空树,或者是具有下列性质的二叉树:

(1) 若左子树不空,则左子树上所有结点的值均小于它的根结点的值;
(2) 若右子树不空,则右子树上所有结点的值均大于它的根结点的值;
(3) 左、右子树也分别为二叉排序树;
(4) 没有键值相等的结点。

典型的二叉查找树的构建过程
  • 性能分析

对于二叉查找树来说,当给定值相同但顺序不同时,所构建的二叉查找树形态是不同的,下面看一个例子。

不同形态平衡二叉树的ASL不同

可以看到,含有n个节点的二叉查找树的平均查找长度和树的形态有关。最坏情况下,当先后插入的关键字有序时,构成的二叉查找树蜕变为单支树,树的深度为n,其平均查找长度(n+1)/2(和顺序查找相同),最好的情况是二叉查找树的形态和折半查找的判定树相同,其平均查找长度和log2(n)成正比。平均情况下,二叉查找树的平均查找长度和logn是等数量级的,所以为了获得更好的性能,通常在二叉查找树的构建过程需要进行“平衡化处理”,之后我们将介绍平衡二叉树和红黑树,这些均可以使查找树的高度为O(log(n))。

  • 代码10 二叉树的节点

class TreeNode<E> {

    E element;
    TreeNode<E> left;
    TreeNode<E> right;

    public TreeNode(E e) {
        element = e;
    }
}

二叉查找树的三种遍历都可以直接用递归的方法来实现:

  • 代码12 先序遍历
protected void preorder(TreeNode<E> root) {

    if (root == null)
        return;

    System.out.println(root.element + " ");

    preorder(root.left);

    preorder(root.right);
}
  • 代码13 中序遍历
protected void inorder(TreeNode<E> root) {

    if (root == null)
        return;

    inorder(root.left);

    System.out.println(root.element + " ");

    inorder(root.right);
}
  • 代码14 后序遍历
protected void postorder(TreeNode<E> root) {

    if (root == null)
        return;

    postorder(root.left);

    postorder(root.right);

    System.out.println(root.element + " ");
}
  • 代码15 二叉查找树的简单实现
/**
 * @author JackalTsc
 */
public class MyBinSearchTree<E extends Comparable<E>> {

    // 根
    private TreeNode<E> root;

    // 默认构造函数
    public MyBinSearchTree() {
    }

    // 二叉查找树的搜索
    public boolean search(E e) {

        TreeNode<E> current = root;

        while (current != null) {

            if (e.compareTo(current.element) < 0) {
                current = current.left;
            } else if (e.compareTo(current.element) > 0) {
                current = current.right;
            } else {
                return true;
            }
        }

        return false;
    }

    // 二叉查找树的插入
    public boolean insert(E e) {

        // 如果之前是空二叉树 插入的元素就作为根节点
        if (root == null) {
            root = createNewNode(e);
        } else {
            // 否则就从根节点开始遍历 直到找到合适的父节点
            TreeNode<E> parent = null;
            TreeNode<E> current = root;
            while (current != null) {
                if (e.compareTo(current.element) < 0) {
                    parent = current;
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    parent = current;
                    current = current.right;
                } else {
                    return false;
                }
            }
            // 插入
            if (e.compareTo(parent.element) < 0) {
                parent.left = createNewNode(e);
            } else {
                parent.right = createNewNode(e);
            }
        }
        return true;
    }

    // 创建新的节点
    protected TreeNode<E> createNewNode(E e) {
        return new TreeNode(e);
    }

}

// 二叉树的节点
class TreeNode<E extends Comparable<E>> {

    E element;
    TreeNode<E> left;
    TreeNode<E> right;

    public TreeNode(E e) {
        element = e;
    }
}

上面的代码15主要展示了一个自己实现的简单的二叉查找树,其中包括了几个常见的操作,当然更多的操作还是需要大家自己去完成。因为在二叉查找树中删除节点的操作比较复杂,所以下面我详细介绍一下这里。

  • 二叉查找树中删除节点分析

要在二叉查找树中删除一个元素,首先需要定位包含该元素的节点,以及它的父节点。假设current指向二叉查找树中包含该元素的节点,而parent指向current节点的父节点,current节点可能是parent节点的左孩子,也可能是右孩子。这里需要考虑两种情况:

  1. current节点没有左孩子,那么只需要将parent节点和current节点的右孩子相连。
  2. current节点有一个左孩子,假设rightMost指向包含current节点的左子树中最大元素的节点,而parentOfRightMost指向rightMost节点的父节点。那么先使用rightMost节点中的元素值替换current节点中的元素值,将parentOfRightMost节点和rightMost节点的左孩子相连,然后删除rightMost节点。
    // 二叉搜索树删除节点
    public boolean delete(E e) {

        TreeNode<E> parent = null;
        TreeNode<E> current = root;

        // 找到要删除的节点的位置
        while (current != null) {
            if (e.compareTo(current.element) < 0) {
                parent = current;
                current = current.left;
            } else if (e.compareTo(current.element) > 0) {
                parent = current;
                current = current.right;
            } else {
                break;
            }
        }

        // 没找到要删除的节点
        if (current == null) {
            return false;
        }

        // 考虑第一种情况
        if (current.left == null) {
            if (parent == null) {
                root = current.right;
            } else {
                if (e.compareTo(parent.element) < 0) {
                    parent.left = current.right;
                } else {
                    parent.right = current.right;
                }
            }
        } else { // 考虑第二种情况
            TreeNode<E> parentOfRightMost = current;
            TreeNode<E> rightMost = current.left;
            // 找到左子树中最大的元素节点
            while (rightMost.right != null) {
                parentOfRightMost = rightMost;
                rightMost = rightMost.right;
            }

            // 替换
            current.element = rightMost.element;

            // parentOfRightMost和rightMost左孩子相连
            if (parentOfRightMost.right == rightMost) {
                parentOfRightMost.right = rightMost.left;
            } else {
                parentOfRightMost.left = rightMost.left;
            }
        }

        return true;
    }

平衡二叉树

平衡二叉树又称AVL树,它或者是一棵空树,或者是具有下列性质的二叉树:它的左子树和右子树都是平衡二叉树,且左子树和右子树的深度之差的绝对值不超过1。

平衡二叉树

AVL树是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为1,所以它也被称为高度平衡树,n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

红黑树

红黑树是平衡二叉树的一种,它保证在最坏情况下基本动态集合操作的事件复杂度为O(log n)。红黑树和平衡二叉树区别如下:

(1) 红黑树放弃了追求完全平衡,追求大致平衡,在与平衡二叉树的时间复杂度相差不大的情况下,保证每次插入最多只需要三次旋转就能达到平衡,实现起来也更为简单。
(2) 平衡二叉树追求绝对平衡,条件比较苛刻,实现起来比较麻烦,每次插入新节点之后需要旋转的次数不能预知。点击查看更多

四、图

  • 简介

图是一种较线性表和树更为复杂的数据结构,在线性表中,数据元素之间仅有线性关系,在树形结构中,数据元素之间有着明显的层次关系,而在图形结构中,节点之间的关系可以是任意的,图中任意两个数据元素之间都可能相关。图的应用相当广泛,特别是近年来的迅速发展,已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。

  • 相关阅读

因为图这部分的内容还是比较多的,这里就不详细介绍了,有需要的可以自己搜索相关资料。

(1) 《百度百科对图的介绍》
(2) 《数据结构之图(存储结构、遍历)》

五、总结

到这里,关于常见的数据结构的整理就结束了,断断续续大概花了两天时间写完,在总结的过程中,通过查阅相关资料,结合书本内容,收获还是很大的,在下一篇博客中将会介绍常用数据结构与算法整理总结(下)之算法篇,欢迎大家关注。

POSIX I/O模型之阻塞、非阻塞、同步、异步浅析

服务端编程常需要接触I/O。最近对I/O模型有了进一步的认识,这里就总结一下POSIX I/O模型,并简略总结一下Java中的Network I/O模型。常见的POSIX I/O模型有四种:

  • 同步阻塞I/O(Synchrohous, blocking I/O)
  • 同步非阻塞I/O(Synchrohous, non-blocking I/O)
  • I/O多路复用(I/O Multiplexing),较为典型的有selectepoll模型
  • 异步I/O(Asynchronous I/O)

通俗解释

在详细解释各个I/O模型之前,我们先来通俗地解释一下各个I/O模型,便于理解。

  • 同步阻塞I/O:去餐厅吃饭,等餐的时候需要在取餐处一直等着,不能干其他事情。
  • 同步非阻塞I/O:去餐厅吃饭,等餐的时候可以干别的事,但需要不断去窗口询问饭是否准备好了(轮询)。
  • 异步I/O:去餐厅吃饭,等餐的时候只需要坐着等人送来即可。

下面我们来详细解释一下各个I/O模型,为了简单起见这里采用UDP协议作为示例。

Blocking I/O

首先对于一个从socket读取数据的操作,通常将其分为两个阶段:

  1. 等待远程数据就绪。网卡会将数据报文传给协议栈,封装处理之后拷贝到内核缓冲区中
  2. 将数据从内核缓冲区拷贝到进程中

最简单的模型就是blocking I/O模型了。进行recvfrom系统调用(读取数据)以后,调用者进程会被阻塞,直到内核接收到数据并拷贝到进程中才返回。进行recvfrom系统调用后,内核首先会等待数据就绪,这通常需要一段时间。当数据就绪并到达内核缓冲区后,内核就会将数据拷贝至用户内存空间,并且返回结果,此时调用者进程才会解除阻塞状态,恢复执行。Blocking I/O不会浪费CPU时间片,但是只能处理一个连接,对于多个连接的情况就需要用到下面要提到的的I/O多路复用了。

可以看出,blocking I/O会阻塞上面两个阶段:

Synchrohous, blocking IO

Non-blocking I/O

与blocking I/O不同,non-blocking I/O的意思是在读取数据(recvfrom)时,如果数据没有就绪则立刻返回一个错误,而不会被阻塞住,这样我们还可以继续进行其它的操作。为了读取到数据,我们需要不断调用recvfrom进行轮询操作,一旦数据准备好了,内核就会将数据拷贝至用户内存空间,并且返回读取成功的结果。这种模型的弊端就是轮询操作会占用时间片,浪费CPU资源。可以看出,non-blocking I/O会阻塞上面的阶段(2):

Non-blocking IO

I/O multiplexing

I/O多路复用(multiplexing)是网络编程中最常用的模型,像我们最常用的selectepoll都属于这种模型。以select为例:

IO Multiplexing

看起来它与blocking I/O很相似,两个阶段都阻塞。但它与blocking I/O的一个重要区别就是它可以等待多个文件描述符就绪,即可以处理多个连接。这里的select相当于一个“代理”,调用select以后进程会被select阻塞,这时候在内核空间内select会监听指定的的多个文件描述符(如socket连接),如果其中任意一个数据就绪了就返回。此时程序再进行数据读取操作,将数据拷贝至当前进程内。由于select可以监听多个socket,我们可以用它来处理多个连接。

select模型中每个socket一般都设置成non-blocking,虽然阶段(1)仍然是阻塞状态,但是它是被select调用阻塞的,而不是直接被I/O阻塞的。select底层通过轮询机制来判断每个socket读写是否就绪。

当然select也有一些缺点,比如底层轮询机制会增加开销、支持的文件描述符数量过少等。为此,Linux引入了epoll作为select的改进版本,具体的区别和改进后面会另开一篇总结。

Asynchronous I/O

Asynchronous I/O的过程:

Asynchronous IO

这里面的读取操作的语义与上面的几种模型都不同。这里的读取操作(aio_read)会通知内核进行读取操作并将数据拷贝至进程中,完事后通知进程整个操作全部完成(绑定一个回调函数处理数据)。读取操作会立刻返回,程序可以进行其它的操作,所有的读取、拷贝工作都由内核去做,做完以后通知进程,进程调用绑定的回调函数来处理数据。

异步I/O在网络编程中几乎用不到,在File I/O中可能会用到。

Java中的Network I/O模型

Java原生的Network I/O模型分为以下几种:

  • BIO(如ServerSocket)
  • NIO(JDK 1.4引入,如ServerSocketChannel)
  • NIO.2(AIO, JDK 1.7引入,如AsynchronousServerSocketChannel)

其中BIO对应传统的同步阻塞I/O,而NIO对应I/O多路复用(select模型,Reactor模式),NIO.2则对应异步IO模型(依然是基于I/O多路复用,和POSIX的asynchronous I/O模型不同)。在Linux下,NIO和NIO.2底层都是通过epoll实现的。

Netty的I/O模型也类似,分为OIO和NIO两种。

总结

我们来总结一下阻塞、非阻塞,同步和异步这两组概念。

先来说阻塞和非阻塞。阻塞调用会一直等待远程数据就绪再返回,即上面的阶段(1)会阻塞调用者,直到读取结束。而非阻塞无论在什么情况下都会立即返回。

接下来是同步和异步。POSIX标准里是这样定义同步和异步的:

  • A synchronous I/O operation causes the requesting process to be blocked until that I/O operation completes.
  • An asynchronous I/O operation does not cause the requesting process to be blocked.

同步方法会一直阻塞进程,直到I/O操作结束,注意这里相当于上面的(1)(2)两个阶段都会阻塞调用者。而异步方法不会阻塞调用者进程,即使是从内核空间的缓冲区将数据拷贝到进程中这一操作也不会阻塞进程,拷贝完毕后内核会通知进程数据拷贝结束。

下面的这张图很好地总结了之前讲的这几种POSIX I/O模型(来自Unix Network Programming):

IO模型比较


References

Spring Boot 使用Redis缓存

续接上文:Spring Boot 1.5.4集成Redis

Spring Cache的官方文档,请看这里

缓存存储

Spring 提供了很多缓存管理器,例如:

  • SimpleCacheManager
  • EhCacheCacheManager
  • CaffeineCacheManager
  • GuavaCacheManager
  • CompositeCacheManager
    这里我们要用的是除了核心的Spring框架之外,Spring Data提供的缓存管理器:RedisCacheManager

在Spring Boot中通过@EnableCaching注解自动化配置合适的缓存管理器(CacheManager),默认情况下Spring Boot根据下面的顺序自动检测缓存提供者:

  • Generic
  • JCache (JSR-107)
  • EhCache 2.x
  • Hazelcast
  • Infinispan
  • Redis
  • Guava
  • Simple

但是因为我们之前已经配置了redisTemplate了,Spring Boot就无法自动给RedisCacheManager设置redisTemplate了,所以接下来要自己配置CacheManager 。

  1. 首先修改RedisConfig配置类,添加@EnableCaching注解,并继承CachingConfigurerSupport,重写CacheManager 方法
...
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
        redisTemplate.setConnectionFactory(factory);
        redisTemplate.afterPropertiesSet();
        setSerializer(redisTemplate);
        return redisTemplate;
    }

    private void setSerializer(RedisTemplate<String, String> template) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }

@Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
        // 设置缓存过期时间,秒
        rcm.setDefaultExpiration(60);
        return rcm;
    }
...

Spring提供了如下注解来声明缓存规则:

  • @Cacheable triggers cache population
  • @CacheEvict triggers cache eviction
  • @CachePut updates the cache without interfering with the method execution
  • @Caching regroups multiple cache operations to be applied on a method
  • @CacheConfig shares some common cache-related settings at class-level
注  解 描  述
@Cacheable 表明Spring在调用方法之前,首先应该在缓存中查找方法的返回值。如果这个值能够找到,就会返回缓存的值。否则的话,这个方法就会被调用,返回值会放到缓存之中
@CachePut 表明Spring应该将方法的返回值放到缓存中。在方法的调用前并不会检查缓存,方法始终都会被调用
@CacheEvict 表明Spring应该在缓存中清除一个或多个条目
@Caching 这是一个分组的注解,能够同时应用多个其他的缓存注解
@CacheConfig 可以在类层级配置一些共用的缓存配置

@Cacheable和@CachePut有一些共有的属性

属  性 类  型 描  述
value String[] 要使用的缓存名称
condition String SpEL表达式,如果得到的值是false的话,不会将缓存应用到方法调用上
key String SpEL表达式,用来计算自定义的缓存key
unless String SpEL表达式,如果得到的值是true的话,返回值不会放到缓存之中
  1. 在一个请求方法上加上@Cacheable注解,测试下效果
    @Cacheable(value="testallCache")
    @RequestMapping(value = "/redis/user/{userId}", method = RequestMethod.GET)
    public User getUser(@PathVariable() Integer userId) {
        User user = userService.getUserById(userId);
        return user;
    }
  2. 然后访问这个请求,控制台就报错啦。
    java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at org.springframework.data.redis.serializer.StringRedisSerializer.serialize(StringRedisSerializer.java:33)
    at org.springframework.data.redis.cache.RedisCacheKey.serializeKeyElement(RedisCacheKey.java:74)
    at org.springframework.data.redis.cache.RedisCacheKey.getKeyBytes(RedisCacheKey.java:49)
    at org.springframework.data.redis.cache.RedisCache$1.doInRedis(RedisCache.java:176)
    at org.springframework.data.redis.cache.RedisCache$1.doInRedis(RedisCache.java:172)
    at org.springframework.data.redis.core.RedisTemplate.execute(RedisTemplate.java:207)

    原因如下:
    先看一下Redis缓存默认的Key生成策略

    • If no params are given, return SimpleKey.EMPTY.
    • If only one param is given, return that instance.
    • If more the one param is given, return a SimpleKey containing all parameters.

从上面的生成策略可以知道,上面的缓存testallCache使用的key是整形的userId参数,但是我们之前在redisTemplate里设置了template.setKeySerializer(new StringRedisSerializer());,所以导致类型转换错误。虽然也可以使用SpEL表达式生成Key(详见这里),但是返回结果还是需要是string类型(比如#root.methodName就是,#root.method就不是),更通用的办法是重写keyGenerator定制Key生成策略。

  1. 修改RedisConfig类,重写keyGenerator方法:
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(":" + method.getName());
                for (Object obj : params) {
                    sb.append(":" + obj.toString());
                }
                return sb.toString();
            }
        };
    }
  2. 再次进行刚才的请求(分别以1,2作为userId参数),浏览器结果如下图:image
    image
    使用redisclient工具查看下:image
    image
    可以看到Redis里保存了:
  • 两条string类型的键值对:key就是上面方法生成的结果,value就是user对象序列化成json的结果
  • 一个有序集合:其中key为@Cacheable里的value+~keys,分数为0,成员为之前string键值对的key

这时候把userId为1的用户的username改为ansel(原来是ansel1),再次进行https://localhost:8443/redis/user/1 请求,发现浏览器返回结果仍是ansel1,证明确实是从Redis缓存里返回的结果。

image

image

缓存更新与删除

  1. 更新与删除Redis缓存需要用到@CachePut和@CacheEvict。这时候我发现如果使用上面那种key的生成策略,以用户为例:它的增删改查方法无法保证生成同一个key(方法名不同,参数不同),所以修改一下keyGenerator,使其按照缓存名称+userId方式生成key:
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                String[] value = new String[1];
                // sb.append(target.getClass().getName());
                // sb.append(":" + method.getName());
                Cacheable cacheable = method.getAnnotation(Cacheable.class);
                if (cacheable != null) {
                    value = cacheable.value();
                }
                CachePut cachePut = method.getAnnotation(CachePut.class);
                if (cachePut != null) {
                    value = cachePut.value();
                }
                CacheEvict cacheEvict = method.getAnnotation(CacheEvict.class);
                if (cacheEvict != null) {
                    value = cacheEvict.value();
                }
                sb.append(value[0]);
                for (Object obj : params) {
                    sb.append(":" + obj.toString());
                }
                return sb.toString();
            }
        };
    }
  2. 接下来编写user的增删改查方法:
    @CachePut(value = "user", key = "#root.caches[0].name + ':' + #user.userId")
    @RequestMapping(value = "/redis/user", method = RequestMethod.POST)
    public User insertUser(@RequestBody User user) {
        user.setPassword(SystemUtil.MD5(user.getPassword()));
        userService.insertSelective(user);
        return user;
    }
    
    @Cacheable(value = "user")
    @RequestMapping(value = "/redis/user/{userId}", method = RequestMethod.GET)
    public User getUser(@PathVariable Integer userId) {
        User user = userService.getUserById(userId);
        return user;
    }
    //#root.caches[0].name:当前被调用方法所使用的Cache, 即"user"
    @CachePut(value = "user", key = "#root.caches[0].name + ':' + #user.userId")
    @RequestMapping(value = "/redis/user", method = RequestMethod.PUT)
    public User updateUser(@RequestBody User user) {
        user.setPassword(SystemUtil.MD5(user.getPassword()));
        userService.updateByPrimaryKeySelective(user);
        return user;
    }
    
    @CacheEvict(value = "user")
    @RequestMapping(value = "/redis/user/{userId}", method = RequestMethod.DELETE)
    public void deleteUser(@PathVariable Integer userId) {
        userService.deleteByPrimaryKey(userId);
    }

    因为新增和修改传递的参数为user对象,keyGenerator无法获取到userId,只好使用SpEL显示标明key了。

然后进行测试:

进行insert操作:

image

插入后,进行get请求:

image

查看Redis存储:

image

image


进行update操作:

image

更新后,进行get请求:

image

查看Redis存储:

image


进行delete操作:

image

查看Redis存储:

image

发现user:3的记录已经没有了,只剩user:1,user:2了


一直很想知道网上很多用之前那种keyGenerator方法的,他们是怎么进行缓存更新和删除的,有知道的可以告知下。

Spring Boot 1.5.4集成Redis

本文示例源码,请看这里

如何安装与配置Redis,请看这里


  1. 首先添加起步依赖:
    <dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-data-redis</artifactId>  
    </dependency>  

    该依赖里默认包含了spring-data-redis和Jedis依赖,见这里

  2. 编辑application.properties,配置Redis
    # Redis 配置
    # Redis数据库索引(默认为0)
    spring.redis.database=0
    # Redis服务器地址
    spring.redis.host=192.168.10.128
    # Redis服务器连接端口
    spring.redis.port=6379
    # Redis服务器连接密码(默认为空)
    spring.redis.password=123qwe
    # 连接池最大连接数(使用负值表示没有限制)
    spring.redis.pool.max-active=8
    # 连接池最大阻塞等待时间(使用负值表示没有限制)
    spring.redis.pool.max-wait=-1
    # 连接池中的最大空闲连接
    spring.redis.pool.max-idle=8
    # 连接池中的最小空闲连接
    spring.redis.pool.min-idle=0
    # 连接超时时间(毫秒)
    spring.redis.timeout=0
  3. 添加一个string类型的键值对,测试一下
@RestController
public class RedisController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping(value = "/redis/string", method = RequestMethod.GET)
    public void insertString() {
        stringRedisTemplate.opsForValue().set("stringKey", "stringValue");
    }   
}

可以看到已经添加进去了:

[root@localhost ~]# redis-cli
127.0.0.1:6379> get stringKey
"stringValue"

如果这不是一个Spring Boot项目,要想使用spring-data-redis还至少需要进行下面的配置:

    @Bean
    public RedisConnectionFactory jedisConnectionFactory() {
        JedisConnectionFactory jcf = new JedisConnectionFactory();
        jcf.setHostName("192.168.10.128");
        jcf.setPort(6379);
        jcf.setPassword("123qwe");
        return jcf;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory());
        return redisTemplate;
    }

但是,从springboot的Redis自动配置类RedisAutoConfiguration.java里可以看到,springboot已经帮我们配置好了。

Spring Data Redis提供了两个模板:

  • RedisTemplate
  • StringRedisTemplate

RedisTemplate会使用JdkSerializationRedisSerializer,这意味着key和value都会通过Java进行序列化。 StringRedisTemplate默认会使用StringRedisSerializer

所以要是操作字符串的话,用StringRedisTemplate就可以了。但要是想要存储一个对象(比如:User),我们就需要使用RedisTemplate,并对key采用string序列化方式,对value采用json序列化方式,这时候就需要对redisTemplate自定义配置了:

@Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();

        redisTemplate.setConnectionFactory(factory);
        redisTemplate.afterPropertiesSet();
        setSerializer(redisTemplate);
        return redisTemplate;
    }

    private void setSerializer(RedisTemplate<String, String> template) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }

添加一条数据,测试效果:

    @RequestMapping(value = "/redis/string/object", method = RequestMethod.GET)
    public void insertStringObject() {
        User user = new User();
        user.setUserId(1);
        user.setUsername("user1");
        user.setPassword("password1");
        redisTemplate.opsForValue().set("stringKeyObject", user);
    }

在redis-cli里查看一下:

127.0.0.1:6379> get stringKeyObject
"[\"com.ansel.testall.mybatis.model.User\",{\"userId\":1,\"username\":\"user1\",\"password\":\"password1\"}]"

使用代码获取刚才存储的对象:

    @RequestMapping(value = "/redis/string/object/get", method = RequestMethod.GET)
    public User getStringObject() {
        User user = (User) redisTemplate.opsForValue().get("stringKeyObject");
        return user;
    }

image

更多方法详见下表:

方  法 子API接口 描  述
opsForValue() ValueOperations 操作具有简单值的条目
opsForList() ListOperations 操作具有list值的条目
opsForSet() SetOperations 操作具有set值的条目
opsForZSet() ZSetOperations 操作具有ZSet值(排序的set)的条目
opsForHash() HashOperations 操作具有hash值的条目
boundValueOps(K) BoundValueOperations 以绑定指定key的方式,操作具有简单值的条目
boundListOps(K) BoundListOperations 以绑定指定key的方式,操作具有list值的条目
boundSetOps(K) BoundSetOperations 以绑定指定key的方式,操作具有set值的条目
boundZSet(K) BoundZSetOperations 以绑定指定key的方式,操作具有ZSet值(排序的set)的条目
boundHashOps(K) BoundHashOperations 以绑定指定key的方式,操作具有hash值的条目

Java NIO 基础知识

前言

前言部分是科普,读者可自行选择是否阅读这部分内容。

为什么我们需要关心 NIO?我想很多业务猿都会有这个疑问。

我在工作的前两年对这个问题也很不解,因为那个时候我认为自己已经非常熟悉 IO 操作了,读写文件什么的都非常溜了,IO 包无非就是 File、RandomAccessFile、字节流、字符流这些,感觉没什么好纠结的。最混乱的当属 InputStream/OutputStream 一大堆的类不知道谁是谁,不过了解了装饰者模式以后,也都轻松破解了。

在 Java 领域,一般性的文件操作确实只需要和 java.io 包打交道就可以了,尤其对于写业务代码的程序员来说。不过,当你写了两三年代码后,你的业务代码可能已经写得很溜了,蒙着眼睛也能写增删改查了。这个时候,也许你会想要开始了解更多的底层内容,包括并发、JVM、分布式系统、各个开源框架源码实现等,处于这个阶段的程序员会开始认识到 NIO 的用处,因为系统间通讯无处不在。

可能很多人不知道 Netty 或 Mina 有什么用?和 Tomcat 有什么区别?为什么我用 HTTP 请求就可以解决应用间调用的问题却要使用 Netty?

当然,这些问题的答案很简单,就是为了提升性能。那意思是 Tomcat 性能不好?当然不是,它们的使用场景就不一样。当初我也不知道 Nginx 摆在 Tomcat 前面有什么用,也是经过实践慢慢领悟到了那么些意思。

Nginx 是 web 服务器,Tomcat/Jetty 是应用服务器,Netty 是通讯工具。

也许你现在还不知道 NIO 有什么用,但是一定不要放弃学习它。

缓冲区操作

缓冲区是 NIO 操作的核心,本质上 NIO 操作就是缓冲区操作。

写操作是将缓冲区的数据排干,如将数据从缓冲区持久化到磁盘中。

读操作是将数据填充到缓冲区中,以便应用程序后续使用数据。

当然,我们这里说的缓冲区是指用户空间的缓冲区。

Java NIO 基础知识

.

简单分析下上图。应用程序发出读操作后,内核向磁盘控制器发送命令,要求磁盘返回相应数据,磁盘控制器通过 DMA 直接将数据发送到内核缓冲区。一旦内核缓冲区满了,内核即把数据拷贝到请求数据的进程指定的缓冲区中。

DMA: Direct Memory Access

Wikipedia:直接内存访问是计算机科学中的一种内存访问技术。它允许某些电脑内部的硬件子系统(电脑外设),可以独立地直接读写系统内存,而不需中央处理器(CPU)介入处理 。在同等程度的处理器负担下,DMA 是一种快速的数据传送方式。很多硬件的系统会使用 DMA,包含硬盘控制器、绘图显卡、网卡和声卡。

也就是说,磁盘控制器可以在不用 CPU 的帮助下就将数据从磁盘写到内存中,毕竟让 CPU 等待 IO 操作完成是一种浪费

很容易看出来,数据先到内核,然后再从内核复制到用户空间缓冲区的做法并不高效,下面简单说说为什么需要这么设计。

  • 首先,用户空间运行的代码是不可以直接访问硬件的,需要由内核空间来负责和硬件通讯,内核空间由操作系统控制。
  • 其次,磁盘存储的是固定大小的数据块,磁盘按照扇区来组织数据,而用户进程请求的一般都是任意大小的数据块,所以需要由内核来负责协调,内核会负责组装、拆解数据。

内核空间会对数据进行缓存和预读取,所以,如果用户进程需要的数据刚好在内核空间中,直接拷贝过来就可以了。如果内核空间没有用户进程需要的数据的话,需要挂起用户进程,等待数据准备好。

虚拟内存

这个概念大家都懂,这里就继续啰嗦一下了,虚拟内存是计算机系统内存管理的一种技术。前面说的缓存区操作看似简单,但是具体到底层细节,还是蛮复杂的。

下面的描述,我尽量保证准确,但是不会展开得太具体,因为虚拟内存还是蛮复杂的,要完全介绍清楚,恐怕需要很大的篇幅,如果读者对这方面的内容感兴趣的话,建议读者寻找更加专业全面的介绍资料,如《深入理解计算机系统》。

物理内存被组织成一个很大的数组,每个单元是一个字节大小,然后每个字节都有一个唯一的物理地址,这应该很好理解。

虚拟内存是对物理内存的抽象,它使得应用程序认为它自己拥有连续可用的内存(一个连续完整的地址空间),而实际上,应用程序得到的全部内存其实是一个假象,它通常会被分隔成多个物理内存碎片(后面说的页),还有部分暂时存储在外部磁盘存储器上,在需要时进行换入换出。

举个例子,在 32 位系统中,每个应用程序能访问到的内存是 4G(32 位系统的最大寻址空间 2^32),这里的 4G 就是虚拟内存,每个程序都以为自己拥有连续的 4G 空间的内存,即使我们的计算机只有 2G 的物理内存。也就是说,对于机器上同时运行的多个应用程序,每个程序都以为自己能得到连续的 4G 的内存。这中间就是使用了虚拟内存。

我们从概念上看,虚拟内存也被组织成一个很大的数组,每个单元也是一个字节大小,每个字节都有唯一的虚拟地址。它被存储于磁盘上,物理内存是它的缓存。

物理内存作为虚拟内存的缓存,当然不是以字节为单位进行组织的,那样效率太低了,它们之间是以页(page)进行缓存的。虚拟内存被分割为一个个虚拟页,物理内存也被分割为一个个物理页,这两个页的大小应该是一致的,通常是 4KB – 2MB。

举个例子,看下图:

Java NIO 基础知识

.

进程 1 现在有 8 个虚拟页,其中有 2 个虚拟页缓存在主存中,6 个还在磁盘上,需要的时候再读入主存中;进程 2 有 7 个虚拟页,其中 4 个缓存在主存中,3 个还在磁盘上。

在 CPU 读取内存数据的时候,给出的是虚拟地址,将一个虚拟地址转换为物理地址的任务我们称之为地址翻译。在主存中的查询表存放了虚拟地址到物理地址的映射关系,表的内容由操作系统维护。CPU 需要访问内存时,CPU 上有一个叫做内存管理单元的硬件会先去查询真实的物理地址,然后再到指定的物理地址读取数据。

上面说的那个查询表,我们称之为页表,虚拟内存系统通过页表来判断一个虚拟页是否已经缓存在了主存中。如果是,页表会负责到物理页的映射;如果不命中,也就是我们经常会见到的概念缺页,对应的英文是 page fault,系统首先判断这个虚拟页存放在磁盘的哪个位置,然后在物理内存中选择一个牺牲页,并将虚拟页从磁盘复制到内存中,替换这个牺牲页。

在磁盘和内存之间传送页的活动叫做交换(swapping)或者页面调度(paging)。

下面,简单介绍下虚拟内存带来的好处。

SRAM缓存:表示位于 CPU 和主存之间的 L1、L2 和 L3 高速缓存。

DRAM缓存:表示虚拟内存系统的缓存,缓存虚拟页到主存中。

物理内存访问速度比高速缓存要慢 10 倍左右,而磁盘要比物理内存慢大约 100000 倍。所以,DRAM 的缓存不命中比 SRAM 缓存不命中代价要大得多,因为 DRAM 缓存一旦不命中,就需要到磁盘加载虚拟页。而 SRAM 缓存不命中,通常由 DRAM 的主存来服务。而从磁盘的一个扇区读取第一个字节的时间开销比起读这个扇区中连续的字节要慢大约 100000 倍。

了解 Kafka 的读者应该知道,消息在磁盘中的顺序存储对于 Kafka 的性能至关重要。

结论就是,IO 的性能主要是由 DRAM 的缓存是否命中决定的。

内存映射文件

英文名是 Memory Mapped Files,相信大家也都听过这个概念,在许多对 IO 性能要求比较高的 java 应用中会使用到,它是操作系统提供的支持,后面我们在介绍 NIO Buffer 的时候会碰到的 MappedByteBuffer 就是用来支持这一特性的。

是什么:

我们可以认为内存映射文件是一类特殊的文件,我们的 Java 程序可以直接从内存中读取到文件的内容。它是通过将整个文件或文件的部分内容映射到内存页中实现的,操作系统会负责加载需要的页,所以它的速度是非常快的。

优势:

  • 一旦我们将数据写入到了内存映射文件,即使我们的 JVM 挂掉了,操作系统依然会帮助我们将这部分内存数据持久化到磁盘上。当然了,如果是断电的话,还是有可能会丢失数据的。
  • 另外,它比较适合于处理大文件,因为操作系统只会在我们需要的页不在内存中时才会去加载页数据,而用其处理大量的小文件反而可能会造成频繁的缺页。
  • 另一个重要的优势就是内存共享。我们可以在多个进程中同时使用同一个内存映射文件,也算是一种进程间协作的方式吧。想像下进程间的数据通讯平时我们一般采用 Socket 来请求,而内存共享至少可以带来 10 倍以上的性能提升。

我们还没有接触到 NIO 的 Buffer,下面就简单地示意一下:

import
 java.io.RandomAccessFile;import java.nio.MappedByteBuffer;import 
java.nio.channels.FileChannel;public class MemoryMappedFileInJava {  
private static int count = 10485760; //10 MB public static void 
main(String[] args) throws Exception { RandomAccessFile memoryMappedFile
 = new RandomAccessFile("largeFile.txt", "rw"); // 将文件映射到内存中,map 方法 
MappedByteBuffer out = 
memoryMappedFile.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, 
count); // 这一步的写操作其实是写到内存中,并不直接操作文件 for (int i = 0; i < count; i++) {
 out.put((byte) 'A'); } System.out.println("Writing to Memory Mapped 
File is completed"); // 这一步的读操作读的是内存 for (int i = 0; i < 10 ; i++) { 
System.out.print((char) out.get(i)); } System.out.println("Reading from 
Memory Mapped File is completed"); }}

我们需要注意的一点就是,用于加载内存映射文件的内存是堆外内存。

参考资料:Why use Memory Mapped File or MapppedByteBuffer in Java

分散/聚集 IO

scatter/gather IO,个人认为这个看上去很酷炫,实践中比较难使用到。

分散/聚集 IO(另一种说法是 vectored I/O 也就是向量 IO)是一种可以在单次操作中对多个缓冲区进行输入输出的方法,可以把多个缓冲区的数据写到单个数据流,也可以把单个数据流读到多个缓冲区中。

Java NIO 基础知识

.

Java NIO 基础知识

.

这个功能是操作系统提供的支持,Java NIO 包中已经给我们提供了操作接口 。这种操作可以提高一定的性能,因为一次操作相当于多次的线性操作,同时这也带来了原子性的支持,因为如果用多线程来操作的话,可能存在对同一文件的操作竞争。

非阻塞 IO

相信读者在很多地方都看到过说 NIO 其实不是代表 New IO,而是 Non-Blocking IO,我们这里不纠结这个。我想之所以会有这个说法,是因为在 Java 1.4 第一次推出 NIO 的时候,提供了 Non-Blocking IO 的支持。

在理解非阻塞 IO 前,我们首先要明白,它的对立面 阻塞模式为什么不好。

比如说 InputStream.read 这个方法,一旦某个线程调用这个方法,那么就将一直阻塞在这里,直到数据传输完毕,返回 -1,或者由于其他错误抛出了异常。

我们再拿 web 服务器来说,阻塞模式的话,每个网络连接进来,我们都需要开启一个线程来读取请求数据,然后到后端进行处理,处理结束后将数据写回网络连接,这整个流程需要一个独立的线程来做这件事。那就意味着,一旦请求数量多了以后,需要创建大量的线程,大量的线程必然带来创建线程、切换线程的开销,更重要的是,要给每个线程都分配一部分内存,会使得内存迅速被消耗殆尽。我们说多线程是性能利器,但是这就是过多的线程导致系统完全消化不了了。

通常,我们可以将 IO 分为两类:面向数据块(block-oriented)的 IO 和面向流(stream-oriented)的 IO。比如文件的读写就是面向数据块的,读取键盘输入或往网络中写入数据就是面向流的。

注意,这节混着用了流和通道这两个词,提出来这点是希望不会对读者产生困扰。

面向流的 IO 往往是比较慢的,如网络速度比较慢、需要一直等待用户新的输入等。

这个时候,我们可以用一个线程来处理多个流,让这个线程负责一直轮询这些流的状态,当有的流有数据到来后,进行相应处理,也可以将数据交给其他子线程来处理,这个线程继续轮询。

问题来了,不断地轮询也会带来资源浪费呀,尤其是当一个线程需要轮询很多的数据流的时候。

现代操作系统提供了一个叫做 readiness selection 的功能,我们让操作系统来监控一个集合中的所有的通道,当有的通道数据准备好了以后,就可以直接到这个通道获取数据。当然,操作系统不会通知我们,但是我们去问操作系统的时候,它会知道告诉我们通道 N 已经准备好了,而不需要自己去轮询(后面我们会看到,还要自己轮询的 select 和 poll)。

后面我们在介绍 Java NIO 的时候会说到 Selector,对应类 java.nio.channels.Selector,这个就是 java 对 readiness selection 的支持。这样一来,我们的一个线程就可以更加高效地管理多个通道了。

Java NIO 基础知识

.

上面这张图我想大家也都可能看过,就是用一个 Selector 来管理多个 Channel,实现了一个线程管理多个连接。说到底,其实就是解决了我们前面说的阻塞模式下线程创建过多的问题。

在 Java 中,继承自 SelectableChannel 的子类就是实现了非阻塞 IO 的,我们可以看到主要有 socket IO 中的 DatagramChannel 和 SocketChannel,而 FileChannel 并没有继承它。所以,文件 IO 是不支持非阻塞模式的。

在系统实现上,POSIX 提供了 select 和 poll 两种方式。它们两个最大的区别在于持有句柄的数量上,select 最多只支持到 FD_SETSIZE(一般常见的是 1024),显然很多场景都会超过这个数量。而 poll 我们想创建多少就创建多少。它们都有一个共同的缺点,那就是当有任务完成后,我们只能知道有几个任务完成了,而不知道具体是哪几个句柄,所以还需要进行一次扫描。

正是由于 select 和 poll 的不足,所以催生了以下几个实现。BSD& OS X 中的 kqueue,Solaris 中的 /dev/poll,还有 Linux 中的 epoll。

Windows 没有提供额外的实现,只能使用 select。

在不同的操作系统上,JDK 分别选择相应的系统支持的非阻塞实现方式。

异步 IO

我们知道 Java 1.4 引入了 New IO,从 Java 7 开始,就不再是 New IO 了,而是 More New IO 来临了,我们也称之为 NIO2。

Java7 在 NIO 上带来的最大的变化应该就属引入了 Asynchronous IO(异步 IO)。本来吧,异步 IO 早就提上日程了,可是大佬们没有时间完成,所以才一直拖到了 java 7 的。废话不多说,简单来看看异步 IO 是什么。

要说异步 IO 是什么,当然还得从 Non-Blocking IO 没有解决的问题入手。非阻塞 IO 很好用,它解决了阻塞式 IO 的等待问题,但是它的缺点是需要我们去轮询才能得到结果。

而异步 IO 可以解决这个问题,线程只需要初始化一下,提供一个回调方法,然后就可以干其他的事情了。当数据准备好以后,系统会负责调用回调方法。

异步 IO 最主要的特点就是回调,其实回调在我们日常的代码中也是非常常见的。

最简单的方法就是设计一个线程池,池中的线程负责完成一个个阻塞式的操作,一旦一个操作完成,那么就调用回调方法。比如 web 服务器中,我们前面已经说过不能每来一个请求就新开一个线程,我们可以设计一个线程池,在线程池外用一个线程来接收请求,然后将要完成的任务交给线程池中的线程并提供一个回调方法,这样这个线程就可以去干其他的事情了,如继续处理其他的请求。等任务完成后,池中的线程就可以调用回调方法进行通知了。

另外一种方式就是自己不设计线程池,让操作系统帮我们实现。流程也是基本一样的,提供给操作系统回调方法,然后就可以干其他事情了,等操作完成后,操作系统会负责回调。这种方式的缺点就是依赖于操作系统的具体实现,不过也有它的一些优势。

首先,我们自己设计处理任务的线程池的话,我们需要掌握好线程池的大小,不能太大,也不能太小,这往往需要凭我们的经验;其次,让操作系统来做这件事情的话,操作系统可以在一些场景中帮助我们优化性能,如文件 IO 过程中帮助更快找到需要的数据。

操作系统对异步 IO 的实现也有很多种方式,主要有以下 3 中:

  1. Linux AIO:由 Linux 内核提供支持
  2. POSIX AIO:Linux,Mac OS X(现在该叫 Mac OS 了),BSD,solaris 等都支持,在 Linux 中是通过 glibc 来提供支持的。
  3. Windows:提供了一个叫做 completion ports 的机制。

这篇文章 asynchronous disk I/O 的作者表示,在类 unix 的几个系统实现中,限制太多,实现的质量太差,还不如自己用线程池进行管理异步操作。

而 Windows 系统下提供的异步 IO 的实现方式有点不一样。它首先让线程池中的线程去自旋调用 GetQueuedCompletionStatus.aspx) 方法,判断是否就绪。然后,让任务跑起来,但是需要提供特定的参数来告诉执行任务的线程,让线程执行完成后将结果通知到线程池中。一旦任务完成,操作系统会将线程池中阻塞在 GetQueuedCompletionStatus 方法的线程唤醒,让其进行后续的结果处理。

Windows 智能地唤醒那些执行 GetQueuedCompletionStatus 方法的线程,以让线程池中活跃的线程数始终保持在合理的水平。这样就不至于创建太多的线程,降低线程切换的开销。

Java 7 在异步 IO 的实现上,如果是 Linux 或者其他类 Unix 系统上,是采用自建线程池实现的,如果是 Windows 系统上,是采用系统提供的 completion ports 来实现的。

所以,在非阻塞 IO 和异步 IO 之间,我们应该怎么选择呢?

如果是文件 IO,我们没得选,只能选择异步 IO。

如果是 Socket IO,在类 unix 系统下我们应该选择使用非阻塞 IO,Netty 是基于非阻塞模式的;在 Windows 中我们应该使用异步 IO。

当然了,Java 的存在就是为了实现平台无关化,所以,其实不需要我们选择,了解这些权当让自己涨点知识吧。

总结

和其他几篇文章一样,也没什么好总结的,要说的都在文中了,希望读者能学到点东西吧。

如果哪里说得不对了,我想也是正常的,我这些年写的都是 Java,对于底层了解得愈发的少了,所以如果读者发现有什么不合理的内容,非常希望读者可以提出来。

lambda 表达式和闭包

区分lambda表达式和闭包

熟悉的Javascript或者Ruby的同学,可能对另一个名词:闭包更加熟悉。因为一般闭包的示例代码,长得跟lambda差不多,导致我也在以前很长一段时间对这两个概念傻傻分不清楚。其实呢,这两个概念是完全不同维度的东西。

闭包是个什么东西呢?我觉得Ruby之父松本行弘在《代码的未来》一书中解释的最好:闭包就是把函数以及变量包起来,使得变量的生存周期延长。闭包跟面向对象是一棵树上的两条枝,实现的功能是等价的。

这样说可能不够直观,我们还是用代码说话吧。其实Java在很早的版本就支持闭包了,只是因为应用场景太少,这个概念一直没得到推广。在Java6里,我们可以这样写:

public static Supplier<Integer> testClosure(){

final int i = 1;

return new Supplier<Integer>() {

@Override

public Integer get() {

return i;

}

};

}

public interface Supplier<T> {

T get();

}

看出问题了么?这里i是函数testClosure的内部变量,但是最终返回里的匿名对象里,仍然返回了i。我们知道,函数的局部变量,其作用域仅限于函数内部,在函数结束时,就应该是不可见状态,而闭包则将i的生存周期延长了,并且使得变量可以被外部函数所引用。这就是闭包了。这里,其实我们的lambda表达式还没有出现呢!

而支持lambda表达式的语言,一般也会附带着支持闭包了,因为lambda总归在函数内部,与函数局部变量属于同一语句块,如果不让它引用局部变量,不会让人很别扭么?例如Python的lambda定义我觉得是最符合λ算子的形式的,我们可以这样定义lambda:

#!/usr/bin/python

y = 1

f=lambda x: x + y

print f(2)

y = 3

print f(2)

输出:

3

5

这里y其实是外部变量。

Java中闭包带来的问题

在Java的经典著作《Effective Java》、《Java Concurrency in Practice》里,大神们都提到:匿名函数里的变量引用,也叫做变量引用泄露,会导致线程安全问题,因此在Java8之前,如果在匿名类内部引用函数局部变量,必须将其声明为final,即不可变对象。(Python和Javascript从一开始就是为单线程而生的语言,一般也不会考虑这样的问题,所以它的外部变量是可以任意修改的)。

在Java8里,有了一些改动,现在我们可以这样写lambda或者匿名类了:

public static Supplier<Integer> testClosure() {

int i = 1;

return () -> {

return i;

};

}

这里我们不用写final了!但是,Java大神们说的引用泄露怎么办呢?其实呢,本质没有变,只是Java8这里加了一个语法糖:在lambda表达式以及匿名类内部,如果引用某局部变量,则直接将其视为final。我们直接看一段代码吧:

public static Supplier<Integer> testClosure() {

int i = 1;

i++;

return () -> {

return i; //这里会出现编译错误

};

}

明白了么?其实这里我们仅仅是省去了变量的final定义,这里i会强制被理解成final类型。很搞笑的是编译错误出现在lambda表达式内部引用i的地方,而不是改变变量值的i++…这也是Java的lambda的一个被人诟病的地方。我只能说,强制闭包里变量必须为final,出于严谨性我还可以接受,但是这个语法糖有点酸酸的感觉,还不如强制写final呢…

spring boot redis cache 缓存学习

spring boot redis cache 缓存学习

  1. 自定义redis key前缀
  2. 自定义redis key
  3. 自定义全局key过期时间
  4. 针对单个key自定义过期时间

引入依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

自定义redis key前缀

package com.km.config;

import org.springframework.data.redis.cache.RedisCachePrefix;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * <p>redis前缀配置,有时候多个工程共用一个db需要区分</p>
 * Created by zhezhiyong@163.com on 2017/9/22.
 */
public class RedisPrefix implements RedisCachePrefix {
    private final RedisSerializer serializer;
    private final String delimiter;

    public RedisPrefix() {
        this(":");
    }

    public RedisPrefix(String delimiter) {
        this.serializer = new StringRedisSerializer();
        this.delimiter = delimiter;
    }

    @Override
    public byte[] prefix(String cacheName) {
        return this.serializer.serialize(this.delimiter != null ? this.delimiter.concat(":").concat(cacheName).concat(":") : cacheName.concat(":"));
    }
}

自定义redis key

    @Override
    @Cacheable(value = "user", key = "'user'.concat(#id.toString())")
    public User findUserById(Long id) {
        log.info("findUserById query from db, id: {}", id);
        return userMap.get(id);
    }
    @Override
    @CachePut(value = "user", key = "'user'.concat(#user.id.toString())")
    public void update(User user) {
        log.info("update db, user: {}", user.toString());
        userMap.put(user.getId(), user);
    }

    @Override
    @CacheEvict(value = "user", key = "'user'.concat(#id.toString())")
    public void remove(Long id) {
        log.info("remove from db, id: {}", id);
        userMap.remove(id);
    }

自定义key过期时间

package com.km.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCachePrefix;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * <p>redis缓存配置</p>
 * Created by zhezhiyong@163.com on 2017/9/21.
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public KeyGenerator KeyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager manager = new RedisCacheManager(redisTemplate);
        manager.setUsePrefix(true);
        RedisCachePrefix cachePrefix = new RedisPrefix("prefix");
        manager.setCachePrefix(cachePrefix);
        // 整体缓存过期时间
        manager.setDefaultExpiration(3600L);
        // 设置缓存过期时间。key和缓存过期时间,单位秒
        Map<String, Long> expiresMap = new HashMap<>();
        expiresMap.put("user", 1000L);
        manager.setExpires(expiresMap);
        return manager;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

配置yml

server:
  port: 8080
spring:
  cache:
    type: redis
  redis:
     host: 192.168.97.57 # server host
     port: 6379 # connection port
     pool.max-idle: 8 # pool settings ...
     pool.min-idle: 1
     pool.max-active: 8
     pool.max-wait: -1
     database: 0

配置启动

package com.km;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class SpringBootRedisCacheApplication {

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

示例

点击下载源码,如果对你有帮助请赏赐一个star

Spring Boot中的缓存支持(二)使用Redis做集中式缓存

上一篇介绍了在Spring Boot中如何引入缓存、缓存注解的使用、以及EhCache的整合。

虽然EhCache已经能够适用很多应用场景,但是由于EhCache是进程内的缓存框架,在集群模式下时,各应用服务器之间的缓存都是独立的,因此在不同服务器的进程间会存在缓存不一致的情况。即使EhCache提供了集群环境下的缓存同步策略,但是同步依然需要一定的时间,短暂的缓存不一致依然存在。

在一些要求高一致性(任何数据变化都能及时的被查询到)的系统和应用中,就不能再使用EhCache来解决了,这个时候使用集中式缓存是个不错的选择,因此本文将介绍如何在Spring Boot的缓存支持中使用Redis进行数据缓存。

下面以上一篇的例子作为基础进行改造,将缓存内容迁移到redis中。

准备工作

可以下载案例Chapter4-4-1,进行下面改造步骤。

先来回顾一下在此案例中,我们做了什么内容:

  • 引入了spring-data-jpaEhCache
  • 定义了User实体,包含idnameage字段
  • 使用spring-data-jpa实现了对User对象的数据访问接口UserRepository
  • 使用Cache相关注解配置了缓存
  • 单元测试,通过连续的查询和更新数据后的查询来验证缓存是否生效

开始改造

  • 删除EhCache的配置文件src/main/resources/ehcache.xml
  • pom.xml中删除EhCache的依赖,增加redis的依赖:
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
</dependency>
  • application.properties中增加redis配置,以本地运行为例,比如:
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1

我们需要做的配置到这里就已经完成了,Spring Boot会在侦测到存在Redis的依赖并且Redis的配置是可用的情况下,使用RedisCacheManager初始化CacheManager

为此,我们可以单步运行我们的单元测试,可以观察到此时CacheManager的实例是org.springframework.data.redis.cache.RedisCacheManager,并获得下面的执行结果:

Hibernate: insert into user (age, name) values (?, ?)
Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.name as name3_0_ from user user0_ where user0_.name=?
第一次查询:10
第二次查询:10
Hibernate: select user0_.id as id1_0_0_, user0_.age as age2_0_0_, user0_.name as name3_0_0_ from user user0_ where user0_.id=?
Hibernate: update user set age=?, name=? where id=?
第三次查询:10

可以观察到,在第一次查询的时候,执行了select语句;第二次查询没有执行select语句,说明是从缓存中获得了结果;而第三次查询,我们获得了一个错误的结果,根据我们的测试逻辑,在查询之前我们已经将age更新为20,但是我们从缓存中获取到的age还是为10。

问题思考

为什么同样的逻辑在EhCache中没有问题,但是到Redis中会出现这个问题呢?

在EhCache缓存时没有问题,主要是由于EhCache是进程内的缓存框架,第一次通过select查询出的结果被加入到EhCache缓存中,第二次查询从EhCache取出的对象与第一次查询对象实际上是同一个对象(可以在使用Chapter4-4-1工程中,观察u1==u2来看看是否是同一个对象),因此我们在更新age的时候,实际已经更新了EhCache中的缓存对象。

而Redis的缓存独立存在于我们的Spring应用之外,我们对数据库中数据做了更新操作之后,没有通知Redis去更新相应的内容,因此我们取到了缓存中未修改的数据,导致了数据库与缓存中数据的不一致。

因此我们在使用缓存的时候,要注意缓存的生命周期,利用好上一篇上提到的几个注解来做好缓存的更新、删除

进一步修改

针对上面的问题,我们只需要在更新age的时候,通过@CachePut来让数据更新操作同步到缓存中,就像下面这样:

@CacheConfig(cacheNames = "users")
public interface UserRepository extends JpaRepository<User, Long> {

    @Cacheable(key = "#p0")
    User findByName(String name);

    @CachePut(key = "#p0.name")
    User save(User user);

}

在redis-cli中flushdb,清空一下之前的缓存内容,再执行单元测试,可以获得下面的结果:

Hibernate: insert into user (age, name) values (?, ?)
第一次查询:10
第二次查询:10
Hibernate: select user0_.id as id1_0_0_, user0_.age as age2_0_0_, user0_.name as name3_0_0_ from user user0_ where user0_.id=?
Hibernate: update user set age=?, name=? where id=?
第三次查询:20

可以看到,我们的第三次查询获得了正确的结果!同时,我们的第一次查询也不是通过select查询获得的,因为在初始化数据的时候,调用save方法时,就已经将这条数据加入了redis缓存中,因此后续的查询就直接从redis中获取了。

本文内容到此为止,主要介绍了为什么要使用Redis做缓存,以及如何在Spring Boot中使用Redis做缓存,并且通过一个小问题来帮助大家理解缓存机制,在使用过程中,一定要注意缓存生命周期的控制,防止数据不一致的情况出现。

完整示例:Chapter-4-4-2

Spring Boot中的缓存支持(一)注解配置与EhCache使用

随着时间的积累,应用的使用用户不断增加,数据规模也越来越大,往往数据库查询操作会成为影响用户使用体验的瓶颈,此时使用缓存往往是解决这一问题非常好的手段之一。Spring 3开始提供了强大的基于注解的缓存支持,可以通过注解配置方式低侵入的给原有Spring应用增加缓存功能,提高数据访问性能。

在Spring Boot中对于缓存的支持,提供了一系列的自动化配置,使我们可以非常方便的使用缓存。下面我们通过一个简单的例子来展示,我们是如何给一个既有应用增加缓存功能的。

快速入门

首先,下载样例工程chapter3-2-2。本例通过spring-data-jpa实现了对User用户表的一些操作,若没有这个基础,可以先阅读《使用Spring-data-jpa简化数据访问层》一文对数据访问有所基础。

准备工作

为了更好的理解缓存,我们先对该工程做一些简单的改造。

  • application.properties文件中新增spring.jpa.properties.hibernate.show_sql=true,开启hibernate对sql语句的打印
  • 修改单元测试ApplicationTests,初始化插入User表一条用户名为AAA,年龄为10的数据。并通过findByName函数完成两次查询。
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(Application.class)
public class ApplicationTests {

	@Autowired
	private UserRepository userRepository;

	@Before
	public void before() {
		userRepository.save(new User("AAA", 10));
	}

	@Test
	public void test() throws Exception {
		User u1 = userRepository.findByName("AAA");
		System.out.println("第一次查询:" + u1.getAge());

		User u2 = userRepository.findByName("AAA");
		System.out.println("第二次查询:" + u2.getAge());
	}

}
  • 执行单元测试,我们可以在控制台中看到下面内容。
Hibernate: insert into user (age, name) values (?, ?)
Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.name as name3_0_ from user user0_ where user0_.name=?
第一次查询:10
Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.name as name3_0_ from user user0_ where user0_.name=?
第二次查询:10

在测试用例执行前,插入了一条User记录。然后每次findByName调用时,都执行了一句select语句来查询用户名为AAA的记录。

引入缓存

  • pom.xml中引入cache依赖,添加如下内容:
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
  • 在Spring Boot主类中增加@EnableCaching注解开启缓存功能,如下:
@SpringBootApplication
@EnableCaching
public class Application {

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

}
  • 在数据访问接口中,增加缓存配置注解,如:
@CacheConfig(cacheNames = "users")
public interface UserRepository extends JpaRepository<User, Long> {

    @Cacheable
    User findByName(String name);

}
  • 再来执行以下单元测试,可以在控制台中输出了下面的内容:
Hibernate: insert into user (age, name) values (?, ?)
Hibernate: select user0_.id as id1_0_, user0_.age as age2_0_, user0_.name as name3_0_ from user user0_ where user0_.name=?
第一次查询:10
第二次查询:10

到这里,我们可以看到,在调用第二次findByName函数时,没有再执行select语句,也就直接减少了一次数据库的读取操作。

为了可以更好的观察,缓存的存储,我们可以在单元测试中注入cacheManager。

@Autowired
private CacheManager cacheManager;

使用debug模式运行单元测试,观察cacheManager中的缓存集users以及其中的User对象的缓存加深理解。

Cache注解详解

回过头来我们再来看,这里使用到的两个注解分别作了什么事情。

  • @CacheConfig:主要用于配置该类中会用到的一些共用的缓存配置。在这里@CacheConfig(cacheNames = "users"):配置了该数据访问对象中返回的内容将存储于名为users的缓存对象中,我们也可以不使用该注解,直接通过@Cacheable自己配置缓存集的名字来定义。
  • @Cacheable:配置了findByName函数的返回值将被加入缓存。同时在查询时,会先从缓存中获取,若不存在才再发起对数据库的访问。该注解主要有下面几个参数:
    • valuecacheNames:两个等同的参数(cacheNames为Spring 4新增,作为value的别名),用于指定缓存存储的集合名。由于Spring 4中新增了@CacheConfig,因此在Spring 3中原本必须有的value属性,也成为非必需项了
    • key:缓存对象存储在Map集合中的key值,非必需,缺省按照函数的所有参数组合作为key值,若自己配置需使用SpEL表达式,比如:@Cacheable(key = "#p0"):使用函数第一个参数作为缓存的key值。 如果方法没有参数,则使用0作为key。如果只有一个参数的话则使用该参数作为key。如果参数多余一个的话则使用所有参数的hashCode作为key。除了上述使用方法参数作为key之外,Spring还为我们提供了一个root对象可以用来生成key。通过该root对象我们可以获取到以下信息。
      属性名称 描述 示例
      methodName 当前方法名 #root.methodName
      method 当前方法 #root.method.name
      target 当前被调用的对象 #root.target
      targetClass 当前被调用的对象的class #root.targetClass
      args 当前方法参数组成的数组 #root.args[0]
      caches 当前被调用的方法使用的Cache #root.caches[0].name
    • condition:缓存对象的条件,非必需,也需使用SpEL表达式,只有满足表达式条件的内容才会被缓存,比如:@Cacheable(key = "#p0", condition = "#p0.length() < 3"),表示只有当第一个参数的长度小于3的时候才会被缓存,若做此配置上面的AAA用户就不会被缓存,读者可自行实验尝试。
    • unless:另外一个缓存条件参数,非必需,需使用SpEL表达式。它不同于condition参数的地方在于它的判断时机,该条件是在函数被调用之后才做判断的,所以它可以通过对result进行判断。
    • keyGenerator:用于指定key生成器,非必需。若需要指定一个自定义的key生成器,我们需要去实现org.springframework.cache.interceptor.KeyGenerator接口,并使用该参数来指定。需要注意的是:该参数与key是互斥的
    • cacheManager:用于指定使用哪个缓存管理器,非必需。只有当有多个时才需要使用
    • cacheResolver:用于指定使用那个缓存解析器,非必需。需通过org.springframework.cache.interceptor.CacheResolver接口来实现自己的缓存解析器,并用该参数指定。

除了这里用到的两个注解之外,还有下面几个核心注解:

  • @CachePut:配置于函数上,能够根据参数定义条件来进行缓存,它与@Cacheable不同的是,它每次都会真是调用函数,所以主要用于数据新增和修改操作上。它的参数与@Cacheable类似,具体功能可参考上面对@Cacheable参数的解析
  • @CacheEvict:配置于函数上,通常用在删除方法上,用来从缓存中移除相应数据。除了同@Cacheable一样的参数之外,它还有下面两个参数:
    • allEntries:非必需,默认为false。当为true时,会移除所有数据
    • beforeInvocation:非必需,默认为false,会在调用方法之后移除数据。当为true时,会在调用方法之前移除数据。

缓存配置

完成了上面的缓存实验之后,可能大家会问,那我们在Spring Boot中到底使用了什么缓存呢?

在Spring Boot中通过@EnableCaching注解自动化配置合适的缓存管理器(CacheManager),Spring Boot根据下面的顺序去侦测缓存提供者:

  • Generic
  • JCache (JSR-107)
  • EhCache 2.x
  • Hazelcast
  • Infinispan
  • Redis
  • Guava
  • Simple

除了按顺序侦测外,我们也可以通过配置属性spring.cache.type来强制指定。我们可以通过debug调试查看cacheManager对象的实例来判断当前使用了什么缓存。

本文中不对所有的缓存做详细介绍,下面以常用的EhCache为例,看看如何配置来使用EhCache进行缓存管理。

在Spring Boot中开启EhCache非常简单,只需要在工程中加入ehcache.xml配置文件并在pom.xml中增加ehcache依赖,框架只要发现该文件,就会创建EhCache的缓存管理器。

  • src/main/resources目录下创建:ehcache.xml
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd">

    <cache name="users"
           maxEntriesLocalHeap="200"
           timeToLiveSeconds="600">
    </cache>

</ehcache>
  • pom.xml中加入
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

完成上面的配置之后,再通过debug模式运行单元测试,观察此时CacheManager已经是EhCacheManager实例,说明EhCache开启成功了。

对于EhCache的配置文件也可以通过application.properties文件中使用spring.cache.ehcache.config属性来指定,比如:

spring.cache.ehcache.config=classpath:config/another-config.xml

完整示例:Chapter-4-4-1