Mybatis框架_涉及技术与拓展

目录

一、Mybatis概述与ORM关系

        1、什么是ORM

        2、Mybatis与ORM的关系

二、ORM层半自动框架与全自动框架

1、为什么说 Mybatis是半自动 ORM框架，而 Hibenate是全自动 ORM框架？

1）Mybatis的实现机制

2）Hibenate 的实现机制

2、Mybatis 与 Hibernate 二者对比有什么特点？

相同点

不同点

三、缓存

1、为什么要用缓存

2、一级缓存

1）一级缓存

2）一级缓存的生命周期

3）一级缓存失效情况

3、二级缓存

1）二级缓存

2）二级缓存失效

4、自定义缓存

1.Cache组件

2.PerpetualCache

3.BlockingCache

4.FifoCache和LruCache

5.SoftCache和WeakCache

6.CacheKey

四、延迟加载原理

1、什么是延迟加载

lazyLoadingEnabled延迟加载的配置---简单入门

2、使用association实现延迟加载

3、延迟加载在mybatis核心配置文件sqlMapConfig.xml中的配置

4、MyBatis 延迟加载 懒加载

一、开启延时加载

二、一对多

三、多对一

五、Mybatis中#和$的区别

1、#占位符的特点

2、$占位符的特点

3、Mybatis中#和$的区别

1）#和$两者含义不同

2）两者的实现方式不同

3）#和$使用场景不同

六、动态Mysql语句

1、什么是动态sql

2、为什么使用动态sql

3、动态sql的标签

1）if标签-单条件判断

2）choose标签 多条件分支判断

3）where语句

4）set标签

5）foreach标签

6）SQL片段抽取

七、MyBatis环境搭建配置

1、MyBatis开发步骤

2、环境搭建

1.导入MyBatis的坐标和其他相关坐标

2.创建user数据表

​3.编写User实体

4.编写UserMapper映射文件

5.编写MyBatis核心文件

编写测试代码

3、MyBatis的映射文件概述

​八、MyBatis核心配置文件概述(#sqlMapConfig.xml#)

1、MyBatis核心配置文件层级关系

2、MyBatis常用配置解析

1)environments标签

2)mapper标签

3)Properties标签

4)typeAliases标签

 核心配置文件常用配置

 MyBatis核心配置文件常用标签

九、Mybatis的Dao层实现(#标签#)

1、传统开发方式

编写UserDao接口

编写UserDaoImpl实现

测试传统方式

2、代理开发方式

代理开发方式介绍

编写UserMapper接口

测试代理方式

十、Mybatis的注解开发

1、MyBatis的常用注解

2、MyBatis的增删改查

3、MyBatis的注解实现复杂映射开发

十一、Mybatis多表查询

1、一对一查询

1）一对一查询的模型

2）一对一查询的语句

3）创建Order和User实体

5）创建OrderMapper接口

6）配置OrderMapper.xml

测试结果

​2、一对多查询

1）一对多查询的模型

2）一对多查询的语句

3）修改User实体

4）配置UserMapper.xml

5）配置UserMapper.xml

测试结果

3、多对多查询

1）多对多查询的模型

2）多对多查询的语句

3）创建Role实体，修改User实体

4）添加UserMapper接口方法

5）配置UserMapper.xml

测试结果

多表查询小结

十二、Mybatis实现分页查询

1、Mybatis实现分页查询步骤

1）导入通用PageHelper坐标

2）在mybatis核心配置文件中配置PageHelper插件

3）测试分页代码实现

4）获得分页相关的其他参数

一、Mybatis概述与ORM关系

        它是一款半自动的ORM持久层框架，它内部封装了jdbc，支持高级映射(一对一，一对多)，动态SQL，延迟加载和缓存等特性，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。

        mybatis通过xml或注解的方式将要执行的各种 statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句。

        最后mybatis框架执行sql并将结果映射为java对象并返回。采用ORM思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与jdbc api 打交道，就可以完成对数据库的持久化操作。

        1、什么是ORM

        ORM(Object Relation Mapping)，对象关系映射。对象指的是Java对象，关系指的是数据库中的关系模型，对象关系映射，指的就是在Java对象和数据库的关系模型之间建立一种对应关系，比如用一个Java的Student类，去对应数据库中的一张student表，类中的属性和表中的列一一对应。Student类就对应student表，一个Student对象就对应student表中的一行数据，一个字段也能够对应到类的一个属性。

        2、Mybatis与ORM的关系

        用mybatis进行开发，需要手动编写SQL语句。而全自动的ORM框架，如hibernate，则不需要编写SQL语句。用hibernate开发，只需要定义好ORM映射关系，就可以直接进行CRUD操作了。由于mybatis需要手写SQL语句，所以它有较高的灵活性，可以根据需要，自由地对SQL进行定制，也因为要手写SQL，当要切换数据库时，SQL语句可能就要重写，因为不同的数据库有不同的方言(Dialect)，所以mybatis的数据库关联性高。

        虽然mybatis需要手写SQL，但相比JDBC，它提供了输入映射和输出映射，可以很方便地进行SQL参数设置，以及结果集封装。并且还提供了关联查询和动态SQL等功能，极大地提升了开发的效率。并且它的学习成本也比hibernate低很多。

二、ORM层半自动框架与全自动框架

1、为什么说 Mybatis是半自动 ORM框架，而 Hibenate是全自动 ORM框架？

1）Mybatis的实现机制

1、读取 Mybatis的全局配置文件 mybatis-config.xml

2、创建 SqlSessionFactory会话工厂

3、创建 SqlSession会话

4、执行查询操作

mybatis-config.xml文件中包括一系列配置信息，其中包括标签 ，此标签配置了映射节点，映射节点内部定义了SQL语句。

Mybatis将 SQL的定义工作独立出来，让用户自定义，而 SQL的解析，执行等工作交由 Mybatis处理执行。

2）Hibenate 的实现机制

1、构建 Configuration实例，初始化该实例中的变量

2、加载 hibenate.cfg.xml 文件到内存

3、通过 hibenate.cfg.xml 文件中的 mapping 节点配置并加载 xxx.hbm.xml 文件至内存

4、利用 Configuration实例构建 SessionFactory 实例

5、由SessionFactory 实例构建 session实例

6、由 session实例创建事务操作接口 Transaction 实例

7、执行查询操作

总结

传统的 jdbc 是手工的，需要程序员加载驱动、建立连接、创建 Statement 对象、定义SQL语句、处理返回结果、关闭连接等操作。

Hibernate 是自动化的，内部封装了JDBC，连 SQL 语句都封装了，理念是即使开发人员不懂SQL语言也可以进行开发工作，向应用程序提供调用接口，直接调用即可。

Mybatis 是半自动化的，是介于 jdbc 和 Hibernate之间的持久层框架，也是对 JDBC 进行了封装，不过将SQL的定义工作独立了出来交给用户实现，负责完成剩下的SQL解析，处理等工作。

2、Mybatis 与 Hibernate 二者对比有什么特点？

相同点

• 二者都是对优秀的持久层框架，帮助开发人员简化了开发工作
• 都是对 JDBC 进行封装
• 都是通过 SessionFactory 创建 session对象，由 session对象执行对数据库的操作语句

不同点

• Mybatis是半自动的映射持久层框架；Hibernate是全自动的映射持久层框架
• Hibernate不需要手动编写SQL，只需要操作相应对象即可，大大降低了对象与数据库的耦合性，而Mybatis需要手动编写 SQL，可移植性Hibernate比Mybatis更高
• Mybatis支持动态SQL，处理列表，存储过程，开发工作量相对大些；Hibernate提供了 HQL操作数据库，如果项目需要支持多种数据库，代码开发量少，但 SQL语句的优化困难
• Mybaits入门简单，即学即用；Hibernate学习门槛相对较高

三、缓存

1、为什么要用缓存

在计算机的世界中，缓存无处不在，操作系统有操作系统的缓存，数据库也会有数据库的缓存，各种中间件如Redis也是用来充当缓存的作用，编程语言中又可以利用内存来作为缓存。 MyBatis作为一款优秀的ORM框架，也用到了缓存，本文的目的就是探究一下MyBatis的缓存是如何实现的。尤其是I/O操作，除了那种CPU密集型的系统，其余大部分的业务系统性能瓶颈最后或多或少都会出现在I/O操作上，所以为了减少磁盘的I/O次数，缓存是必不可少的，通过缓存的使用我们可以大大减少I/O操作次数，从而在一定程度上弥补了I/O操作和CPU处理速度之间的鸿沟。在ORM框架中引入缓存的目的就是为了减少读取数据库的次数，从而提升查询的效率。

2、一级缓存

1）一级缓存

1、也叫本地缓存，在会话层面sqlsession进行缓存的。默认开启的，不需要配置，也不能关闭。

2、同一个会话中，update、delete、insert？会清空一级缓存。

3、问题：不同的会话之间对于相同的数据，可能有不同的缓存。在有多个会话，或者分布式的情况下，会存在脏数据。

使用MyBatis开启一次和数据库的会话，MyBatis会创建出一个SqlSession对象表示一次数据库会话，在对数据库的一次会话中， 有可能会反复地执行完全相同的查询语句，每一次查询都会去查一次数据库,为了减少资源浪费，mybaits提供了一种缓存的方式(一级缓存)。 mybatis的SQL执行最后是交给了Executor执行器来完成的，看下BaseExecutor类的源码：
 

 @Override
    public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameter);
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
 
    @SuppressWarnings("unchecked")
    @Override
    public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (closed) {
            throw new ExecutorException("Executor was closed.");
        }
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
            clearLocalCache();
        }
        List list;
        try {
            queryStack++;
            list = resultHandler == null ? (List) localCache.getObject(key) : null;//localCache 本地缓存
            if (list != null) {
                handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
            } else {
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);  //如果缓存没有就走DB
            }
        } finally {
            queryStack--;
        }
        if (queryStack == 0) {
            for (DeferredLoad deferredLoad : deferredLoads) {
                deferredLoad.load();
            }
            // issue #601
            deferredLoads.clear();
            if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                // issue #482
                clearLocalCache();
            }
        }
        return list;
    }
 
    private  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        List list;
        localCache.putObject(key, EXECUTION_PLACEHOLDER);
        try {
            list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
            localCache.removeObject(key);//清空现有缓存数据
        }
        localCache.putObject(key, list);//新的结果集存入缓存
        if (ms.getStatementType() == StatementType.CALLABLE) {
            localOutputParameterCache.putObject(key, parameter);
        }
        return list;
    }

它的本地缓存使用的是PerpetualCache类，内部是一个HashMap作了一个封装来存数据。缓存Key的生成：

CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
 
    @Override
    public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
        if (closed) {
            throw new ExecutorException("Executor was closed.");
        }
        CacheKey cacheKey = new CacheKey();
        cacheKey.update(ms.getId());
        cacheKey.update(Integer.valueOf(rowBounds.getOffset()));
        cacheKey.update(Integer.valueOf(rowBounds.getLimit()));
        cacheKey.update(boundSql.getSql());
        List parameterMappings = boundSql.getParameterMappings();
        TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
        // mimic DefaultParameterHandler logic
        for (int i = 0; i < parameterMappings.size(); i++) {
            ParameterMapping parameterMapping = parameterMappings.get(i);
            if (parameterMapping.getMode() != ParameterMode.OUT) {
                Object value;
                String propertyName = parameterMapping.getProperty();
                if (boundSql.hasAdditionalParameter(propertyName)) {
                    value = boundSql.getAdditionalParameter(propertyName);
                } else if (parameterObject == null) {
                    value = null;
                } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                    value = parameterObject;
                } else {
                    MetaObject metaObject = configuration.newMetaObject(parameterObject);
                    value = metaObject.getValue(propertyName);
                }
                cacheKey.update(value);
            }
        }
        if (configuration.getEnvironment() != null) {
            // issue #176
            cacheKey.update(configuration.getEnvironment().getId());
        }
        return cacheKey;
    }

通过statementId,params,rowBounds，BoundSql来构建一个key值，根据这个key值去缓存Cache中取出对应缓存结果。

2）一级缓存的生命周期

比如要执行一个查询操作时，Mybatis会创建一个新的SqlSession对象，SqlSession对象找到具体的Executor， Executor持有一个PerpetualCache对象；当查询结束(会话结束)时，SqlSession、Executor、PerpetualCache对象占有的资源一并释放掉。

如果SqlSession调用了close()方法，会释放掉一级缓存PerpetualCache对象，一级缓存将不可用。

如果SqlSession调用了clearCache()，会清空PerpetualCache对象中的数据，但是该对象仍可使用。

SqlSession中执行了任何一个update操作(update()、delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用。

3）一级缓存失效情况

注意：一级缓存为sqlSession级别的缓存，默认开启的，不能关闭。一级缓存失效的四种情况：
1）sqlSession不同，缓存失效。
2）sqlSession相同，查询条件不同，缓存失效，因为缓存中可能还没有相关数据。
3）sqlSession相同，在两次查询期间，执行了增删改操作，缓存失效。
4）sqlSession相同，但是手动清空了一级缓存，缓存失效。
清除缓存情况：
1、就是获取缓存之前会先进行判断用户是否配置了flushCache=true属性（参考一级缓存的创建代码截图），
如果配置了则会清除一级缓存。
2、MyBatis全局配置属性localCacheScope配置为Statement时，那么完成一次查询就会清除缓存。
3、在执行commit，rollback，update方法时会清空一级缓存

3、二级缓存

1）二级缓存

概述：二级缓存主要用来解决一级缓存不能跨会话共享的问题，范围是namespace级别，可以被多个sqlsession共享。

1、开启方式

2、先获取二级缓存，获取不到再获取一级缓存

3、select之后必须提交事务，才能写入二级缓存

4、执行update、delete、insert后，使得缓存失效（namespace级别的失效）

5、适用于查询为主的应用；一表一namespace

Mybatis默认对二级缓存是关闭的，一级缓存默认开启，如果需要开启只需在mapper上加入配置就好了。Executor是执行查询的最终接口，它有两个实现类一个是BaseExecutor另外一个是CachingExecutor。CachingExecutor(二级缓存查询)，一级缓存因为只能在同一个SqlSession中共享，所以会存在一个问题，在分布式或者多线程的环境下，不同会话之间对于相同的数据可能会产生不同的结果，因为跨会话修改了数据是不能互相感知的，所以就有可能存在脏数据的问题，正因为一级缓存存在这种不足，需要一种作用域更大的缓存，这就是二级缓存。

CachingExecutor实现类里面的query查询方法：

@Override
ublic List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
            throws SQLException {
        Cache cache = ms.getCache();//二级缓存对象
        if (cache != null) {
            flushCacheIfRequired(ms);
            if (ms.isUseCache() && resultHandler == null) {
                ensureNoOutParams(ms, parameterObject, boundSql);
                @SuppressWarnings("unchecked")
                List list = (List) tcm.getObject(cache, key);//从缓存中读取
                if (list == null) {
                    //这段走到一级缓存或者DB
                    list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                    tcm.putObject(cache, key, list); // issue #578 and #116  //数据放入缓存
                }
                return list;
            }
        }
        return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

一个事务方法运行时，数据查询出来，缓存在一级缓存了，但是没有到二级缓存，当事务提交后(sqlSession.commit()或客户端代码创建sqlSessionFactory设置openSession(true))，数据才放到二级缓存。查询的顺序是，先查二级缓存再查一级缓存然后才去数据库查询。

一级缓存作用域是SqlSession级别，所以它存储的SqlSession中的BaseExecutor之中，但是二级缓存目的要实现作用范围更广，所以要实现跨会话共享，MyBatis二级缓存的作用域是namespace，专门用了一个装饰器来维护，这就是：CachingExecutor。

      二级缓存相关的配置有三个地方：
      1、mybatis-config中有一个全局配置属性，这个不配置也行，因为默认就是true。
      
      想详细了解mybatis-config的可以点击这里。
      2、在Mapper映射文件内需要配置缓存标签：
      
      或
      
      想详细了解Mapper映射的所有标签属性配置可以点击这里。
      3、在select查询语句标签上配置useCache属性，如下：
      
          select * from lw_user
      
      以上配置第1点是默认开启的，也就是说我们只要配置第2点就可以打开二级缓存了，
      而第3点是当我们需要针对某一条语句来配置二级缓存时候则可以使用。
      1、需要commit事务之后才会生效
      2、如果使用的是默认缓存，那么结果集对象需要实现序列化接口(Serializable)
      如果不实现序列化接口则会报如下错误
      
      * 二级缓存工作机制(？)
      1）一个会话，查询一条数据，该数据会放在当前会话的一级缓存中。
      2）如果当前会话关闭，对应的一级缓存会被保存到二级缓存中，新的会话查询信息，就可以参照二级缓存。
      3）不同namespace查询出的数据会放在自己对应的缓存中。
      注意：查出的数据都会默认放在一级缓存中，只有会话提交或关闭后，一级缓存的数据才会被转移到二级缓存中。
      
      * 需要注意的是在事务提交之前，并不会真正存储到二级缓存，而是先存储到一个临时属性，
      * 等事务提交之后才会真正存储到二级缓存。（？）
      Mybatis缓存包装汇总：
      PerpetualCache	缓存默认实现类	-	基本功能，默认携带
      LruCache	LRU淘汰策略缓存（默认淘汰策略）	当缓存达到上限，删除最近最少使用缓存	eviction=“LRU”
      FifoCache	FIFO淘汰策略缓存	当缓存达到上限，删除最先入队的缓存	eviction=“FIFO”
      SoftCache	JVM软引用淘汰策略缓存	基于JVM的SoftReference对象	eviction=“SOFT”
      WeakCache	JVM弱引用淘汰策略缓存	基于JVM的WeakReference对象	eviction=“WEAK”
      LoggingCache	带日志功能缓存	输出缓存相关日志信息	基本功能，默认包装
      SynchronizedCache	同步缓存	基于synchronized关键字实现，用来解决并发问题	基本功能，默认包装
      BlockingCache	阻塞缓存	get/put操作时会加锁，防止并发，基于Java重入锁实现	blocking=true
      SerializedCache	支持序列化的缓存	通过序列化和反序列化来存储和读取缓存	readOnly=false(默认)
      ScheduledCache	定时调度缓存	操作缓存时如果缓存已经达到了设置的最长缓存时间时会移除缓存	flushInterval属性不为空
      TransactionalCache	事务缓存	在TransactionalCacheManager中用于维护缓存map的value值	

2）二级缓存失效

所有的update操作(insert,delete,uptede)都会触发缓存的刷新，从而导致二级缓存失效，所以二级缓存适合在读多写少的场景中开启。

二级缓存针对的是同一个namespace，所以建议是在单表操作的Mapper中使用，或者是在相关表的Mapper文件中共享同一个缓存。

4、自定义缓存

一级缓存可能存在脏读情况，那么二级缓存是否也可能存在呢？是的，默认的二级缓存也是存储在本地缓存，对于微服务下是可能出现脏读的情况的，这时可能会需要自定义缓存，比如利用redis来存储缓存，而不是存储在本地内存当中。

      MyBatis官方也提供了第三方缓存的支持引入pom文件：
      
          org.mybatis.caches
          mybatis-redis
          1.0.0-beta2
      
      然后缓存配置如下：
      
      然后在默认的resource路径下新建一个redis.properties文件：
      host=localhost
      port=6379

1.Cache组件

MyBatis 中缓存模块相关的代码位于 org.apache.ibatis.cache 包 下，其中 Cache 接口 是缓存模块中最核心的接口，它定义了所有缓存的基本行为。

public interface Cache {
 
  /**
   * 获取当前缓存的 Id
   */
  String getId();
 
  /**
   * 存入缓存的 key 和 value，key 一般为 CacheKey对象
   */
  void putObject(Object key, Object value);
 
  /**
   * 根据 key 获取缓存值
   */
  Object getObject(Object key);
 
  /**
   * 删除指定的缓存项
   */
  Object removeObject(Object key);
 
  /**
   * 清空缓存
   */
  void clear();
 
  /**
   * 获取缓存的大小
   */
  int getSize();
 
  /**
   * ！！！！！！！！！！！！！！！！！！！！！！！！！！
   * 获取读写锁，可以看到，这个接口方法提供了默认的实现！！
   * 这是 Java8 的新特性！！只是平时开发时很少用到！！！
   * ！！！！！！！！！！！！！！！！！！！！！！！！！！
   */
  default ReadWriteLock getReadWriteLock() {
    return null;
  }
}

Cache接口的实现类有很多，大部分都是装饰器，只有PerpetualCache 提供了 Cache 接口 的基本实现

2.PerpetualCache

PerpetualCache（Perpetual：永恒的，持续的）在缓存模块中扮演着被装饰的角色，其实现比较简单，底层使用 HashMap 记录缓存项，也是通过该 HashMap 对象 的方法实现的 Cache 接口 中定义的相应方法。

public class PerpetualCache implements Cache {
 
  // Cache对象 的唯一标识
  private final String id;
 
  // 其所有的缓存功能实现，都是基于 JDK 的 HashMap 提供的方法
  private Map cache = new HashMap<>();
 
  public PerpetualCache(String id) {
    this.id = id;
  }
 
  @Override
  public String getId() {
    return id;
  }
 
  @Override
  public int getSize() {
    return cache.size();
  }
 
  @Override
  public void putObject(Object key, Object value) {
    cache.put(key, value);
  }
 
  @Override
  public Object getObject(Object key) {
    return cache.get(key);
  }
 
  @Override
  public Object removeObject(Object key) {
    return cache.remove(key);
  }
 
  @Override
  public void clear() {
    cache.clear();
  }
 
  /**
   * 其重写了 Object 中的 equals() 和 hashCode()方法，两者都只关心 id字段
   */
  @Override
  public boolean equals(Object o) {
    if (getId() == null) {
      throw new CacheException("Cache instances require an ID.");
    }
    if (this == o) {
      return true;
    }
    if (!(o instanceof Cache)) {
      return false;
    }
 
    Cache otherCache = (Cache) o;
    return getId().equals(otherCache.getId());
  }
 
  @Override
  public int hashCode() {
    if (getId() == null) {
      throw new CacheException("Cache instances require an ID.");
    }
    return getId().hashCode();
  }
}

cache.decorators包下提供的装饰器，它们都直接实现了Cache接口，扮演着装饰器的角色。这些装饰器会在 PerpetualCache 的基础上提供一些额外的功能，通过多个组合后满足一个特定的需求。

3.BlockingCache

BlockingCache 是阻塞版本的缓存装饰器，它会保证只有一个线程到数据库中查找指定 key 对应的数据

public class BlockingCache implements Cache {
 
  // 阻塞超时时长
  private long timeout;
  // 持有的被装饰者
  private final Cache delegate;
  // 每个 key 都有其对应的 ReentrantLock锁对象
  private final ConcurrentHashMap locks;
 
  // 初始化 持有的持有的被装饰者 和 锁集合
  public BlockingCache(Cache delegate) {
    this.delegate = delegate;
    this.locks = new ConcurrentHashMap<>();
  }
}

假设线程A在BlockingCache中未查找到 keyA 对应的缓存项时，线程 A 会获取 keyA 对应的锁，这样，线程 A 在后续查找 keyA 时，其它线程会被阻塞

// 根据 key 获取锁对象，然后上锁
  private void acquireLock(Object key) {
    // 获取 key 对应的锁对象
    Lock lock = getLockForKey(key);
    // 获取锁，带超时时长
    if (timeout > 0) {
      try {
        boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
        if (!acquired) { // 超时，则抛出异常
          throw new CacheException("Couldn't get a lock in " + timeout + " for the key " +  key + " at the cache " + delegate.getId());
        }
      } catch (InterruptedException e) {
        // 如果获取锁失败，则阻塞一段时间
        throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
      }
    } else {
      // 上锁
      lock.lock();
    }
  }
 
  private ReentrantLock getLockForKey(Object key) {
    // Java8 新特性，Map系列类 中新增的方法
    // V computeIfAbsent(K key, Function mappingFunction)
    // 表示，若 key 对应的 value 为空，则将第二个参数的返回值存入该 Map集合 并返回
    return locks.computeIfAbsent(key, k -> new ReentrantLock());
  }

假设 线程 A 从数据库中查找到 keyA 对应的结果对象后，将结果对象放入到 BlockingCache 中，此时 线程 A 会释放 keyA 对应的锁，唤醒阻塞在该锁上的线程。其它线程即可从 BlockingCache 中获取 keyA 对应的数据，而不是再次访问数据库。

 @Override
  public void putObject(Object key, Object value) {
    try {
      // 存入 key 和其对应的缓存项
      delegate.putObject(key, value);
    } finally {
      // 最后释放锁
      releaseLock(key);
    }
  }
 
  private void releaseLock(Object key) {
    ReentrantLock lock = locks.get(key);
    // 锁是否被当前线程持有
    if (lock.isHeldByCurrentThread()) {
      // 是，则释放锁
      lock.unlock();
    }
  }

4.FifoCache和LruCache

为了控制缓存的大小，系统需要按照一定的规则清理缓存。FifoCache 是先入先出版本的装饰器，当向缓存添加数据时，如果缓存项的个数已经达到上限，则会将缓存中最老（即最早进入缓存）的缓存项删除。

public class FifoCache implements Cache {
 
  // 被装饰对象
  private final Cache delegate;
  // 用一个 FIFO 的队列记录 key 的顺序，其具体实现为 LinkedList
  private final Deque