设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式在项目开发的重要性已经不言而喻，下面就让我们一起来走进设计模式的主题中

首先先来认识一下为更好的理解设计模式打基础的 UML 建模

我们都知道，随着祖国越来越繁荣昌盛，随着科技的进步，设备的更新换代，计算机体系结构、操作系统、编译程序都在不断地改革创新，但始终有一点是不变的（我对鸭血粉丝的热爱忠贞不渝）：那就是下面三者的性能耗时：CPU < 内存 < I/O

Redis 简介

什么是 Redis

Redis 的全称是 Remote Dictionary Server，它是一款 开源的 高性能的 NoSQL 数据库，它可以用作 数据库、缓存 和 消息队列。

什么是 NoSQL

NoSQL 最常见的解释是 non-relational，非关系型数据库，还有一种说法是 Not Only SQL，不仅仅是 SQL，NoSQL 仅仅是一个概念，泛指非关系型的数据库，区别于关系数据库，它们不保证关系数据的 ACID 特性。ACID 即

• A (Atomicity) 原子性
• C (Consistency) 一致性
• I (Isolation) 独立性
• D (Durability) 持久性

Redis 通过提供多种键值对的数据类型来适应不同场景下的存储需求。

NoSQL 的代表

作为 NoSQL 的代表主要有

• MongoDB
• Redis
• Memcached

NoSQL 的优点

Redis 相较于关系型数据库模型，它还是具有很多优点的

• 易扩展

NoSQL 数据库种类繁多，但是一个共同的特点就是去掉关系数据库的关系型特性，数据之间无关系，这样就非常容易扩展。

• 大数据量，高性能

NoSQL 数据库都具有非常高的读写性能，尤其在大数据量下，同样表现很优秀。

• 灵活的数据模型

NoSQL 无需事先建立字段，这省去了关系型数据库一旦建立字段，可扩展性非常差的不利局面。NoSQL 随时可以存储自定义的数据格式。

• 高可用

NoSQL 在不太影响性能的情况，就可以方便地实现高可用的架构。比如 Cassandra、HBase 模型，通过复制模型也能实现高可用。

Redis 数据类型

Redis 支持的数据类型主要有五种，它们分别是

• 字符串 - strings

string 字符串 是 Redis 中最简单的数据类型，它是与 Memcached 一样的类型，一个 key 对应一个 value，这种 key/value 对应的方式称为键值对。字符串对很多例子都有用，例如缓存 HTML 片段和网页。

• 集合 - set

set 是集合，和我们数学中的集合概念相似，对集合的操作有添加删除元素，有对多个集合求交并差等操作。操作中 key 理解为集合的名字。

• 散列 - hash

hash 是一个键值 (key=>value) 对集合；是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

• 列表 - list

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。list类型经常会被用于消息队列的服务，以完成多程序之间的消息交换。

• 有序集合 - zset

Redis zset 和 set 一样也是 string 类型元素的集合，且不允许重复的成员。当你需要一个有序的并且不重复的集合列表时，那么可以选择 sorted set 数据结构。

Redis 安装

Redis 支持在 Linux、OS X 、BSD 等 POSIX 系统中安装，也支持在 Windows 中安装，在 Windows 、Linux 下的安装请参考 https://www.runoob.com/redis/redis-install.html

我自己的电脑是 mac 系统，mac 系统的安装过程是 https://www.jianshu.com/p/bb7c19c5fc47

如果你用的是 Homebrew，它的安装过程是 https://www.jianshu.com/p/e1e5717049e8

Redis 启动

安装完成 Redis 后，我们需要启动 Redis，不过我们在启动 Redis 之前，需要先了解一下 Redis 的可执行文件，如果你是下载的 tar.gz 安装包，可以使用 make install 进行编译，编译完成后会在 /usr/local/bin 目录生成下面这几个可执行文件

下面我们来一起认识一下这些可执行文件的作用

• redis-benchmark 是 Redis 性能测试工具，可以使用 redis-benchmark 进行基准测试，比如redis-benchmark -q -n 100000 ，这个工具使用起来非常方便，同时你可以使用自己的基准测试工具
• redis-check-rdb RDB 文件检查工具，rdb 是 Redis 的一种持久化方式
• redis-check-aof AOF 文件检查工具，aof 也是 Redis 的一种持久化方式，关于这两种持久化方式我们后面会说
• redis-sentinel redis-sentinel 就是一个独立运行的进程，用于监控多个 master-slave 集群， 自动发现 master 宕机，进行自动切换 slave > master。
• redis-cli，redis-cli 和 后面的 redis-server 都是常用的而且比较重要的命令，是你登录 redis 的指令
• redis-server，redis-server 是 redis 的后台服务器

Redis 启动分为两种，一种是直接运行 redis-server，一种是通过 redis 脚本启动，前者一般用于开发环境，脚本启动一般用于生产环境，这里我们直接使用直接启动的方式。

直接运行 redis-server 即可启动 redis

也可以通过指定 Redis 的端口来运行 Redis

1

redis-server --port 6380

这里我们就不贴出图了。

Redis 停止

考虑到 Redis 有可能正在将内存中的数据同步到硬盘中，强制执行 Redis 的停止命令可能导致数据丢失。正确停止 Redis 的方式应该是向 Redis 发送 SHUTDOWN 命令，如下

1

redis-cli SHUTDOWN

这里你可能还不清楚 redis-cli 是什么指令，我们下面会说。

当 Redis 收到 SHUTDOWN 指令后，会先断开所有客户端连接，然后根据配置执行持久化，最后完成退出。

也可以使用 kill Redis 端口 来正常结束 Redis ，效果与 SHUTDOWN 命令一样。

Redis 命令行客户端

下面我们来说一下 redis-cli 指令，redis-cli 和 redis-server 都是 Redis 中非常重要的工具，你一定要知道，redis-cli 的全称是 Redis Command Line Interface，是 Redis 自带的命令行工具，它主要有下面这几种用法

发送命令

通过 redis-cli 向 Redis 发送命令的方式有两种，一种是将命令作为 redis-cli 的参数执行，比如上面的 redis-cli SHUTDOWN 命令，redis-cli 在执行时会按照默认的主机和端口号来进行连接，默认的主机和端口号分别是 127.0.0.1 和 6379 连接 Redis

也可以通过 -h 和 -p 参数自定义地址和端口号

1

redis-cli -h 127.0.0.1 -p 6379

Redis 提供了 PING 命令来测试客户端与 Redis 的连接是否正常，如果正常会回复到 PONG 响应，如下

1

redis-cli PING

命令返回值

在大多数情况下，执行一条命令后我们会希望获得命令的返回值，在 Redis 中，Redis 的命令返回值主要有 5 种类型，对于每种类型 redis-cli 的展现结果都不同，下面分别进行说明

状态回复

状态回复（status reply）是一种最简单的回复，比如向 Redis 发送 SET 命令设置某个键的值时，Redis 会回复 OK 表示设置成功。我们上面说到的 PING 和 PONG 也是一种状态回复。状态回复会直接显示状态信息。

错误回复

错误回复(error reply)指的是，当出现命令不存在或者命令有错误时，会出现错误回复，并在后面跟上错误信息。比如执行一个不存在的指令

整数回复

Redis 虽然没有整数类型，但是却提供了一些用于整数操作的指令，如递增键值的 INCR 命令会以整数形式返回递增后的键值。除此之外，一些其他的命令也会返回整数。整数回复(integer reply) 以 integer 为开头然后在后面跟上整型数据

字符串回复

字符串回复(bulk reply) 是最常见的一种回复类型，当请求一个字符串类型的键的键值或一个其他类型键中的某个元素时就会得到一个字符串回复。字符串回复以双引号包裹

还有一种情况时这个请求的键值不存在时会返回 nli，表示返回的是一个空结果。

多行字符串回复

多行字符串回复(multi-bulk reply) 同样很常见，如当请求一个非字符串类型的键的元素列表时就会收到多行字符串回复

Redis 配置

redis 可以支持自定义配置，比如是否开启持久化、配置日志级别等。由于可配置的选项比较多，通过启动来配置这些选项并不合理，因此可以通过程序员手动配置。启用配置文件的方法是在启动时将配置文件的路径作为启动参数传递给 redis-server，如下

1

redis-server /路径/redis.conf

通过参数传递同名的配置选项会覆配置文件中相应的参数，如下

1

redis-server /路径/redis.conf --loglevel warning

Redis 提供了一个配置文件的模版 redis.conf，Redis 也支持动态修改配置，可以使用 CONFIG SET 命令在不重新 Redis 的情况下动态修改 Redis

1

CONFIG SET loglevel warning

Redis 多数据库切换

Redis 是一个字典结构的存储服务器，实际上一个 Redis 实例提供了多个用来存储数据的字典，客户端可以指定将数据存放在哪个字典中。

每个数据库对外都是以一个从 0 开始的递增数字命名，Redis 默认支持 16 个数据库，可以通过配置 databases 来修改这一数字。客户端与 Redis 建立连接后会默认选择 0 号数据库，不过可以使用 select 命令切换数据库。

1

select 1

这条指令就会选择 1 号数据库

这些数据库与我们平常理解的 MySQL 数据库不同。首先 Redis 不支持自定义数据库的名字，每个数据库都以编号命名，开发者必须自己记录哪些数据库存储了哪些数据。另外，Redis 也不支持为每个不同的数据库设置不同的访问密码。最重要的是多个数据库之间并没有完全隔离，比如 FLUSHALL 命令会清楚所有数据库中的数据。

文章参考：

《Redis 入门指南》

https://baike.baidu.com/item/NoSQL/8828247?fr=aladdin

https://www.php.cn/redis/421950.html

《Redis 官网》

http://www.redis.cn/topics/benchmarks.html

大家好，我是鸭血粉丝，今天我想跟你们聊聊《Java 极客技术》知识星球的故事，因为再过几天我们就要涨价，最后几天的最低价我觉得有必要告诉你们。

还记得年前公号上发的那一篇年终总结的文章吗？2020 年已经到来，是时候总结一下过去的 2019 年了 没看过没关系，现在看也还来的及，看过的朋友我们接着往下看。

相信大家都知道，Stack (栈): 后进先出( Last In First Out )，也就是说后面进来的，会先出去。

0x00. 前言

依赖冲突是日常开发中经常碰到的过程，如果运气好，并不会有什么问题。偏偏阿粉有点背，碰到好几次生产问题，排查一整晚，最后发现却是依赖冲突的引起的问题。

没碰到过这个问题同学可能没什么感觉，阿粉举两个最近碰到例子，让大家感受一些。

例子 1：

我们公司有个古老的业务基础包 A。B，C 业务依赖这个包。某个团队拷贝 A 的部分代码进行重构，类名与路径完全一样，然后重新打包成 D 发布。

一次业务改动，B 业务也引入了 D 包，测试环境运行的时候，一切 OK，但是在生产运行时，却抛出 NoSuchMethodError。

问题原因在于 B 业务依赖 A，D。而 A,D 存在两个同包同名类，运行的时候，具体加载谁，不同环境还真不一样。

例子 2：

A 业务使用 Dubbo 进行 RPC 调用， Dubbo 需要依赖 javassist。当前依赖关系为：

A------->Dubbo------->javassist-3.18.1.GA

某次改动中引入另外一个第三方开源包，其依赖 javassist-3.15.0-GA 。生产发布的时候，将 javassist-3.15.0-GA 打包到应用中，由于生产环节为 JDK1.8，从而导致运行直接失败。

除了上述问题，依赖冲突还可能导致应用抛出 ClassNotFoundException，NoClassDefFoundError 等错误。

抛出错误这种情况还算好，还比较容易定位问题。怕就怕，不同版本同一个类内部逻辑不同，从而导致业务异常。这种问题，真的很让人抓狂，让人头秃。

![(http://www.justdojava.com/assets/images/2019/java/image_andyxh/20200216/0082zybply1gbyaxes5fpj306n06n0sp.jpg)

仔细分析依赖冲突，主要可以分为两类：

• 项目同一依赖应用，存在多版本，每个版本同一个类，可能存在差异。
• 项目不同依赖应用，存在包名，类名完全一样的类。

下面我们分析一下依赖冲突产生的原因。

0x01. 依赖冲突原因

1.1 依赖机制

Maven 依赖分为两种情况，直接依赖与间接依赖，这个比较好理解，大家直接看图就好。

1.2 仲裁机制

如果 A 应用间接依赖多个 C 应用，且版本都不一样，Maven 将会通过仲裁机制选择：

• 优先按照依赖管理元素中指定的版本声明进行仲裁时，下面的两个原则都无效了
• 短路径优先
• 若路径相同，将看 pom 中声明的顺序。

第一条原则，我们下面再说。

第二条原则，如下图：

A 间接依赖两个版本 E，这种情况下，由于 A 到 E-1.0 路径最短，所以 A 中将会使用 E-1.0。

如果路径恰好一样，那么这种情况下 Maven 只能根据 pom 中的顺序，选择最先声明的，这也是个无奈的选择。

1.3 scope 属性

Maven 项目可以分为三个阶段：编译阶段，测试阶段，运行阶段了。通过 scope 属性，我们可以决定依赖应用是否参与以上阶段，也将会影响依赖传递。

Maven 提供 6 种 scope ：

• compile
• provided
• runtime
• test
• system
• import

compile

compile 是 Maven 默认属性，将会使依赖包参与项目的编译，测试，运行阶段。当然，项目打包之后将会包含该依赖。

provided

provided 意味着依赖仅参与项目编译，测试的阶段。若有如下依赖关系：

A----->B----->C

C 的 scope 为provided，C 将会参与 B 的编译，测试阶段，但是 C 不会传递给 A。如果 A 运行过程需要 C，需要自己直接引入 C 依赖。典型如 Servlet API，因为 Tomcat 等容器内部会提供。

runtime

runtime 代表依赖不再参与项目编译阶段，只参与测试，运行阶段。

若依赖不参与编译阶段，这种情况 IDE 中是无法导入相应的类的。若存在依赖类，编译过程中将会报错。

典型的例子是 JDBC 驱动包，如 mysql :

1
2
3
4
5
6

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>6.0.6</version>
    <scope>runtime</scope>
</dependency>

知识点：这个好处在于，只能使用 JDBC 标准接口，这样就不会与特定的数据库绑定。后续若切换数据库，只需要更换 pom，然后修改相应的参数即可。

test

test 仅参与测试阶段的工作，典型的例子为 junit：

1
2
3
4
5
6

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

system

system 与 provided 范围一致，只不过 system 需要使用 systemPath 属性指定本地路径，而 provided 将会从 Maven 仓库拉取。

import

import 比较特殊，不会参与以上阶段运行。其只能在 dependencyManagement下使用，且 type 需要为 pom。典型的例子为 Spring-boot 依赖。

1
2
3
4
5
6
7
8
9
10
11
12

    <dependencyManagement>
        <dependencies>
            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.1.6.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

知识点：通过这种方式，解决单继承问题，也可以更好将依赖分类。

另外 Maven scope 将会影响依赖传递。

如果依赖关系为： A—>B—>C,A 依赖 B，B 依赖 C。最左列代表 B 的 scope 属性，第一行代表 C 的 scope 属性

如上所示，当 C 的 scope 为 provided/test, C 只在 B 中起作用，不会通过间接依赖传递给 A。

当且仅当 B 的 scope 为 compile，且 C scope 为 runtime ，A 将会间接依赖 C，且 scope 为 runtime。其他情况下，C 的 scope 将会与 B 的 scope 一致。

0x02. 解决冲突的方法

2.1 使用 Maven 属性控制依赖传递

依赖冲突时，根据错误日志，定位到冲突类，定位相应 jar 包，最后通过 excludes 排除相应的包。

另外可以结合 IDEA Maven Helper 插件，主动检查冲突依赖，提前排除。

通过插件，我们可以清晰看到冲突包，以及依赖路径，还有相应的 Scope。

除了排除依赖，我们可以通过合理的设置 scope 属性，不让依赖传播下去。比如说，A 需要是使用 Spring-beans 包中某些类。如果其他项目铁定会使用 Spring，那么我们可以将 A 中 Spring-beans scope 设置为 provided，让其他项目自己选择引入 Spring-beans 的版本。

这个适合公共基础包，其他包不要随便使用provided，若使用一定要写清楚，使用过程中需要引入的依赖。

以上方法虽然治标，但是不治本。如果想依赖冲突不发生，我们需要提前建立一定的规范，团队一起遵守，才能有效避免该类问题。

1. 应用项目中使用 dependencyManagement 统一管理基础依赖，定义统一的版本，如常用中间包，工具包，日志包。
2. 二方包中不要引入无关的依赖，做到尽量少的依赖。团队开发中，比较常见情况是二方包继承公共的父 pom，从而导致继承许多无相关的依赖，这种情况可以单独管理。
3. 二方包做好向下兼容，不要随意改动现有类名，方法名，字段名。
4. 项目应用上线之前，将 snapshot 替换成正式版本。虽然 snapshot 修改起来很方便，但是正因为这个特性，可以被随便修改。如果某次生产打包发布不注意，就会引入。
5. 二方包不要使用同一个包名，类名。一般来说，团队开发中，包名，类名一样概率比较小。这种比较容易出现在一些重构项目，复制原来类，重构打包发布。对于情况下可以修改包名。如 cmomon-lang3 是 common-lang 升级版， cmomon-lang3 包名为 org.apache.commons.lang3,而 common-lang 包名为 org.apache.commons.lang

0x03. 总结

如果我们把 NPE 问题当做新手村普通怪物，那么依赖冲突问题就是人马这种精英怪。刚开始遇到，我们会被虐的比较惨。只有我们不断升级，学习掌握技巧，然后才能可以从容不迫解决。

ps:塞尔达中，你们第一次遇见人马，打了几次？阿粉记得那天整整从晚上九点打到凌晨两点，就是打不过啊~

0x04. 帮助文档

Maven Dependency Scopes

Maven optional关键字透彻图解

这篇文章写的很好，大家可以看下。，重新看待Jar包冲突问题及解决方案

包管理原则

所谓二叉查找树，就是按照二分进行查找，每次查询只需要选择其中一个子树就进行查找，从而减少查找次数，提升查询效率！

hello~各位读者好，我是鸭血粉丝（大家可以称呼我为「阿粉」），在这个特殊的日子里,大家要注意安全，尽量不要出门，无聊的话，就像阿粉一样，把时间愉快的花在学习上吧。

1.上期回顾

前面初识 mybatis 章节，阿粉首先搭建了一个简单的项目，只用了 mybatis 的 jar 包。然后通过一个测试代码，讲解了几个重要的类和步骤。

先看下这个测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class MybatisTest {
    @Test
    public void testSelect() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();
        try {
            FruitMapper mapper = session.getMapper(FruitMapper.class);
            Fruit fruit = mapper.findById(1L);
            System.out.println(fruit);
        } finally {
            session.close();
        }
    }
}

这章的话，阿粉会带着大家理解一下源码，基于上面测试的代码。阿粉先申明一下，源码一章肯定是讲不完的，所以阿粉会分成几个章节，并且讲源码的话，代码肯定比较多，比较干，所以请大家事先准备好开水哦。

2.源码分析

这里阿粉会根据 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream) 这段代码来分析 mybatis 做了哪些事情。

2.1设计模式

通过这段代码，我们首先分析一下用到了哪些设计模式呢？

首先 SqlSessionFactory 这个类用到了工厂模式，并且上一章阿粉也说到了，这个类是全局唯一的，所以它还使用了单列模式。

然后是 SqlSessionFactoryBuilder 这个类，一看就知道用到了建造者模式。

所以，只看这段代码就用到了工厂模式，单列模式和建造者模式。

2.2mybatis做了什么事情

这里就开始源码之旅了，首先 ctrl + 左键点击 build 方法，我们会看到

1
2
3

 public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
  }

再点击 build ，然后就是

1
2
3
4
5
6
7
8

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      return build(parser.parse());
        //后面代码省略
        ...
    }
}

首先 XMLConfigBuilder 这个类就是用来解析我们的配置文件 mybatis-config.xml ,调用这个类的构造函数,主要是创建一个 Configuration 对象，这个对象的属性就对应mybatis-config.xml 里面的一级标签。这里不贴代码，有兴趣的自己点开看下。

然后就是 build(parser.parse()) 这段代码，先执行 parse() 方法，再执行 build() 方法。不过这里，阿粉先说下 build() 这个方法，首先parse() 方法返回的就是 Configuration 对象,然后我们点击 build

1
2
3

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

这里就是返回的默认的SqlSessionFactory 。

然后我们再说 parse() 方法，因为这个是核心方法。我们点进去看下

1
2
3
4
5
6
7
8

public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

首先是 if 判断，就是防止解析多次。看 parseConfiguration 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

这里就开始了解析mybatis-config.xml里面的一级标签了。阿粉不全部讲，只说几个主要的。

1. settings：全局配置，比如我们的二级缓存，延迟加载，日志打印等
2. mappers：解析dao层的接口和mapper.xml文件
3. properties：这个一般是配置数据库的信息，如：数据库连接，用户名和密码等，不讲
4. typeAliases ：参数和返回结果的实体类的别名，不讲
5. plugins：插件，如：分页插件，不讲
6. objectFactory，objectWrapperFactory：实例化对象用的，比如返回结果是一个对象，就是通过这个工厂反射获取的，不讲
7. environments：事物和数据源的配置，不讲
8. databaseIdProvider：这个是用来支持不同厂商的数据库
9. typeHandlers：这个是java类型和数据库的类型做映射，比如数据库的 varchar 类型对应 java 的String 类型，不讲

2.3解析settings

我们点击 settingsElement(settings) 这个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

private void settingsElement(Properties props) {
  configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
  configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
  configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
  configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
  configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
  configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
  configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
  configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
  configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
  configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
  configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
  configuration.setDefaultFetchSize(integerValueOf(props.getProperty("defaultFetchSize"), null));
  configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
  configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
  configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
  configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
  configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
  configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
  configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
  configuration.setDefaultEnumTypeHandler(resolveClass(props.getProperty("defaultEnumTypeHandler")));
  configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
  configuration.setUseActualParamName(booleanValueOf(props.getProperty("useActualParamName"), true));
  configuration.setReturnInstanceForEmptyRow(booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
    configuration.setLogPrefix(props.getProperty("logPrefix"));
  configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
  }

这个就是设置我们的全局配置信息, setXXX 方法的第一个参数是 mybatis-config.xml 里面标签里面配置的。有的同学就会问了，阿粉阿粉，我们里面没有配置那么多啊，这里怎么设置那么多属性，值是什么呢？那我们看下方法的第二个参数，这个就是默认值。比如 `cacheEnabled` 这个属性，缓存开关，没有配置的话，默认是开启的 `true`。所有以后看全局配置的默认值，不用去官网看了，直接在这个方法里面看。

2.4解析mappers

点击 mapperElement 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }

这里有4个判断 page (包)，resource（相对路径，阿粉配的就是这个，所有按照这个讲解源码），url（绝对路径），class（单个接口）

XMLMapperBuilder 这个类是用来解析mapper.xml文件的。然后我们点击 parse 方法

1
2
3
4
5
6
7
8
9
10

public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      bindMapperForNamespace();
    }
    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

if 判断是判断 mapper 是不是已经注册了，单个Mapper重复注册会抛出异常。

1. configurationElement：解析 mapper 里面所有子标签

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   private void configurationElement(XNode context) { try { String namespace = context.getStringAttribute("namespace"); if (namespace == null || namespace.equals("")) { throw new BuilderException("Mapper's namespace cannot be empty"); } builderAssistant.setCurrentNamespace(namespace); cacheRefElement(context.evalNode("cache-ref")); cacheElement(context.evalNode("cache")); parameterMapElement(context.evalNodes("/mapper/parameterMap")); resultMapElements(context.evalNodes("/mapper/resultMap")); sqlElement(context.evalNodes("/mapper/sql")); buildStatementFromContext(context.evalNodes("select|insert|update|delete")); } catch (Exception e) { throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e); } }

   cacheRefElement：缓存

   cacheElement：是否开启二级缓存

   parameterMapElement：配置的参数映射

   resultMapElements：配置的结果映射

   sqlElement：公用sql配置

   buildStatementFromContext：解析 select|insert|update|delete 标签，获得 MappedStatement 对象,一个标签一个对象

2. bindMapperForNamespace：把namespace对应的接口的类型和代理工厂类绑定起来。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   private void bindMapperForNamespace() { String namespace = builderAssistant.getCurrentNamespace(); if (namespace != null) { Class<?> boundType = null; try { boundType = Resources.classForName(namespace); } catch (ClassNotFoundException e) { //ignore, bound type is not required } if (boundType != null) { if (!configuration.hasMapper(boundType)) { // Spring may not know the real resource name so we set a flag // to prevent loading again this resource from the mapper interface // look at MapperAnnotationBuilder#loadXmlResource configuration.addLoadedResource("namespace:" + namespace); configuration.addMapper(boundType); } } } }

   看最后 addMapper 方法

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   public <T> void addMapper(Class<T> type) { if (type.isInterface()) { if (hasMapper(type)) { throw new BindingException("Type " + type + " is already known to the MapperRegistry."); } boolean loadCompleted = false; try { knownMappers.put(type, new MapperProxyFactory<>(type)); // It's important that the type is added before the parser is run // otherwise the binding may automatically be attempted by the // mapper parser. If the type is already known, it won't try. MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type); parser.parse(); loadCompleted = true; } finally { if (!loadCompleted) { knownMappers.remove(type); } } } }

   判断 namespace 对应的类是否是接口，然后判断是否已经加载了这个接口，最后将namespace 对应的接口和 MapperProxyFactory 放到 map 容器中。MapperProxyFactory 工厂模式,创建 MapperProxy 对象,这个一看就是代理对象。这个就是根据接口里面的方法获取 mapper.xml里面对应的sql语句的关键所在。具体的等下次讲解getMapper()源码的时候在深入的讲解。

3.时序图

4.总结

在这一步，我们主要完成了 config 配置文件、Mapper 文件、Mapper 接口解析。我们得到了一个最重要的对象Configuration，这里面存放了全部的配置信息，它在属性里面还有各种各样的容器。最后，返回了一个DefaultSqlSessionFactory，里面持有了 Configuration 的实例。

阿粉发现大家在说链表的时候，就会常说另外一个概念：数组。

既然数组和链表，常常会拿到一起做比较。那咱们今天就先来说说数组和链表。

大家好，我是鸭血粉丝，今天阿粉带大家学习一下设计模式之原型模式，话不多说，我们往下看。

Hello~各位读者新年好！我是鸭血粉丝，一位经常踩坑的程序员，所谓 bug 如风，常伴吾身，hasaki~

这不最近又遇到个问题，Dubbo 服务 IP 注册错误，好了，下面进入正题。

临近假期，很多人都放松了学习，阿粉一阵激动，这可是超越别人的好机会啊，赶紧去补一补数据结构和算法方面的内容。

今天阿粉教你这样解锁单链表环的操作，让你面试手写代码再也不怕！

说到单链表，肯定会想到 5 种经典操作，饭要一口一口吃，算法要一个一个拿下。今天先来讲讲在单链表中环的操作。

判断链表中是否有环

先来看一张图：

我们能够清楚的看到，在这个单链表中，是有环的。那么使用代码，该如何判断它是否有环呢？

先别着急看代码，先和阿粉一起来分析一下，有了思路，代码实现相对就比较容易。

判断链表中是否有环，可以从头结点开始，依次遍历单链表中的每一个节点。 每遍历一个节点，就和前面的所有节点作比较，如果发现新节点和之前的某个节点相同，则说明此节点被遍历过两次，说明链表有环，反之就是没有。

但是仔细看一下这种方法，你会发现这种方法很耗时耗力，因为每遍历一个节点，都要把它和前面所有的节点都比较一遍。 别着急，阿粉还有一个很巧妙的方法，就是使用两个指针。这样思路就可以这样想：

使用两个指针，一个快指针，一个慢指针。 快指针每次走 2 步，慢指针每次走 1 步。 如果链表中没有环，则快指针会先指向 null 如果链表中有环，则快慢指针一定会相遇

思路打通，咱们就可以使用代码来进行实现了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

/**
 * 判断链表是否有环
 */
public class IsHasLoop {
    public static class Node{
        private int data;
        private Node next;
        public Node(int data,Node next){
            this.data=data;
            this.next=next;
        }
        public int getData(){
            return data;
        }
    }
    public static void main(String[] args){
        // 初始化单链表
        Node node5=new Node(5,null);
        Node node4=new Node(4,node5);
        Node node3=new Node(3,node4);
        Node node2=new Node(2,node3);
        Node node1=new Node(1,node2);
        // 让 node5 的指针指向 node1 形成一个环
        node5.next=node1;

        boolean flag=isHasLoop(node1);
        System.out.println(flag);

    }
    public static boolean isHasLoop(Node list){
        if (list == null){
            return false;
        }

        Node slow=list;
        Node fast=list;

        while (fast.next != null && fast.next.next != null){
            // 慢指针走一步,快指针走两步
            slow=slow.next;
            fast=fast.next.next;
            // 如果快慢指针相遇,则说明链表中有环
            if (slow==fast){
                return true;
            }
        }
		// 反之链表中没有环
        return false;
    }
}

求环长

现在判断链表中是否有环这个问题已经解决了，阿粉觉得不能到此为止，思路就向外扩散了一下，既然有环了，如果想要求环长该怎么办呢？

既然快慢指针相遇了，阿粉记录下此时的位置，接下来再让满指针继续向前走，每次走 1 步，这样当慢指针再次走到相遇时的位置时，慢指针走过的长度不就是环长嘛

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public static int getLength(Node list){
        // 定义环长初始值为 0
        int loopLength=0;
        Node slow=list;
        Node fast=list;

        while (fast != null && fast.next != null) {
            // 慢指针走一步,快指针走两步
            slow=slow.next;
            fast=fast.next.next;

            // 第一次相遇时跳出循环
            if (slow == fast) break;
        }
        // 如果 fast next 指针首先指向 null 指针,说明该链表没有环,则环长为 0
        if(fast.next == null || fast.next.next == null){
            return 0;
        }
        // 如果有环,使用临时变量保存当前的链表
        Node temp = slow;
        // 让慢指针一直走,直到走到原来位置
        do{
            slow = slow.next;
            loopLength++;
        } while(slow != temp);

        return loopLength;
}

求入环点

既然有环了，也求出了环长，那么入环点应该也知道了吧？ 阿粉对于求入环点这个问题有点儿懵，就画了一张图出来：

如上图，我们假设：

入环点距离头结点距离为 D 入环点与首次相遇点较短的距离为 S1 入环点与首次相遇点较长的距离为 S2 当两个指针首次相遇时，慢指针一次只走 1 步，则它所走的距离为： D+S1 快指针每次走 2 步，多走了 n(n>=1) 圈，则它所走的距离为： D+S1+n(S1+S2) 快指针速度为慢指针的 2 倍，则： 2(D+S1)=D+S1+n(S1+S2) 上面等式，整理可得： D=(n-1)(S1+S2)+S2

如果让 (n-1)(S1+S2) 为 0 ，是不是 D 和 S2 就相等了？也就是说，当两个指针第一次相遇时，只要把其中一个指针放回到头结点位置，另外一个指针保持在首次相遇点，接下来两个指针每次都向前走 1 步，接下来这两个指针相遇时，就是要求的入环点。

有点儿像做数学题的感觉，还好阿粉的数学功底还是有那么一丢丢的。

基于上面的思路，代码就很容易实现了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public static Node entryNodeOfLoop(Node list){
        Node slow=list;
        Node fast=list;
        while(fast.next != null && fast.next.next != null){
            // 慢指针走一步,快指针走两步
            slow=slow.next;
            fast=fast.next.next;

            // 第一次相遇时跳出循环
            if (slow == fast) break;
        }
        // 如果 fast next 指针首先指向 null 指针,说明该链表没有环,则入环点为 null
        if (fast.next == null || fast.next.next == null){
            return  null;
        }
        // 第一次相遇之后,让一个指针指向头结点,另外一个指针在相遇位置
        // 两个指针每次走 1 步,相遇为止,此时相遇节点即为入环点
        Node head=list; // 头结点
        Node entryNode=slow;    // 相遇节点
        while (entryNode != head){
            entryNode=entryNode.next;
            head=head.next;
        }
        return entryNode;
}

关于单链表环的操作，阿粉掌握的就是这些了。

最后总结一下：不管是求环长，还是找到入环点，最关键的就是找到第一次相遇时所在的位置，找到了这个位置，那么接下来的问题就比较容易解决了。

参考：

• 漫画算法：小灰的算法之旅