# RocketMQ 4.4.0 下载

作者已经在自己的服务器挂载了 RocketMQ 4.4.0 的安装包和控制台，点击链接下载

rocketMQ 4.4.0 安装包 http://124.222.229.230:8080/rocketmq-all-4.4.0-bin-release.zip

rocketMQ 控制台 安装包 http://124.222.229.230:8080/rocketmq-externals-rocketmq-console-1.0.0.zip

在使用前如果整合微服务，请注意 SpringCloudAliabba 与各组件之间的版本对应关系

作者使用 SpringCloudAlibaba 2.2.5 RELEASE 版本，所以对应使用 RocketMQ 4.4.0 版本

将下载好的安装包上传至 Linux 服务器

将压缩包解压至创建好的 rocketMQ 文件夹下

1

unzip rocketmq-all-4.4.0-bin-release.zip rocketMQ

按照官网流程，启动 nameServer，brokerServer 服务

# 启动 nameServer

1
2
3
4

#启动服务
nohup ./mqnamesrv -n 124.222.229.230:9876 &
#查看日志
tail -f ~/logs/rocketmqlogs/namesrv.log

# 启动 brokerServer

1
2
3
4

#启动服务
nohup ./mqbroker -n 124.222.229.230:9876 -c ../conf/broker.conf autoCreateTopicEnable=true &
#查看日志
tail -f ~/logs/rocketmqlogs/broker.log

# 发送消息测试

1

sh bin/tools.sh org.apache.rocketmq.example.quickstart.Producer

# 消费消息测试

1

sh bin/tools.sh org.apache.rocketmq.example.quickstart.Consumer

# SpringBoot 整合

pom.xml 添加

1
2
3
4
5
6

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot</artifactId>
    <version>2.0.4</version>
    <scope>compile</scope>
</dependency>

# 封装工具：

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

package cn.brath.common.rocketmq;

import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @Auther: Brath
 * Create By Administrator on 2022/3/31 13:59
 * Strive to create higher performance code
 * @My wechat: 17604868415
 * @My QQ: 2634490675
 * @My email 1: email_ guoqing@163.com
 * @My email 2: enjoy_ light_ sports@163.com
 * @PPseudonym: enjoy sports nutrition
 * @Program body: enjoy notes
 */
@Component
public class RocketMQUtil {

    /**
     * SLF4J日志
     */
    private static final Logger logger = LoggerFactory.getLogger(RocketMQUtil.class);

    /**
     * rocketmq模板注入
     */
    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @PostConstruct
    public void init() {
        logger.info("---RocketMq工具初始化---");
    }

    /**
     * 发送异步消息
     *
     * @param topic   消息Topic
     * @param message 消息实体
     */
    public void asyncSend(Enum topic, Message<?> message) {
        asyncSend(topic.name(), message, getDefaultSendCallBack());
    }


    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     */
    public void asyncSend(Enum topic, Message<?> message, SendCallback sendCallback) {
        asyncSend(topic.name(), message, sendCallback);
    }

    /**
     * 发送异步消息
     *
     * @param topic   消息Topic
     * @param message 消息实体
     */
    public void asyncSend(String topic, Message<?> message) {
        rocketMQTemplate.asyncSend(topic, message, getDefaultSendCallBack());
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback);
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     * @param timeout      超时时间
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback, long timeout) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback, timeout);
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     * @param timeout      超时时间
     * @param delayLevel   延迟消息的级别
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback, long timeout, int delayLevel) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback, timeout, delayLevel);
    }

    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     */
    public void syncSendOrderly(Enum topic, Message<?> message, String hashKey) {
        syncSendOrderly(topic.name(), message, hashKey);
    }


    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     */
    public void syncSendOrderly(String topic, Message<?> message, String hashKey) {
        logger.info("发送顺序消息，topic:" + topic + ",hashKey:" + hashKey);
        rocketMQTemplate.syncSendOrderly(topic, message, hashKey);
    }

    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     * @param timeout
     */
    public void syncSendOrderly(String topic, Message<?> message, String hashKey, long timeout) {
        logger.info("发送顺序消息，topic:" + topic + ",hashKey:" + hashKey + ",timeout:" + timeout);
        rocketMQTemplate.syncSendOrderly(topic, message, hashKey, timeout);
    }

    /**
     * 默认CallBack函数
     *
     * @return
     */
    private SendCallback getDefaultSendCallBack() {
        return new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                logger.info("---发送MQ成功---");
            }

            @Override
            public void onException(Throwable throwable) {
                throwable.printStackTrace();
                logger.error("---发送MQ失败---"+throwable.getMessage(), throwable.getMessage());
            }
        };
    }


    @PreDestroy
    public void destroy() {
        logger.info("---RocketMq工具注销---");
    }

}

测试发送消息

1
2
3
4
5
6
7
8
9
10
11

@Autowired
    private RocketMqUtil rocketMqutil;

    @Test
    public void Producter() {
        User user = new User();
        user.setName("brath");
        user.setAge(10);
        rocketMqHelper.asyncSend("REGIST_USER", MessageBuilder.withPayload(user).build());
       
}

测试消费消息

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

package com.hyh.core.listener;

import com.hyh.core.po.Person;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * @Auther: Brath
 * Create By Administrator on 2022/3/31 13:59
 * Strive to create higher performance code
 * @My wechat: 17604868415
 * @My QQ: 2634490675
 * @My email 1: email_ guoqing@163.com
 * @My email 2: enjoy_ light_ sports@163.com
 * @PPseudonym: enjoy sports nutrition
 * @Program body: enjoy notes
 */
@Component
@RocketMQMessageListener(consumerGroup = "${rocketmq.producer.groupName}", topic = "REGIST_USER")
public class PersonMqListener implements RocketMQListener<Person> {
    @Override
    public void onMessage(User user) {
        System.out.println("接收到消息，开始消费..name:" + user.getName() + ",age:" + user.getAge());
    }
}

1
2

IvUserloginLog
IvUserOperateLog

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# 介绍：

​ Hbase 是 bigtable 的开源山寨版本。是建立在 HDFS 之上，提供高可靠性、高性能、列存储、可伸缩、实时读写的数据库系统。它介于 nosql 和 RDBMS 之间，仅能通过主键 (row key) 和主键的 range 来检索数据，仅支持单行事务 (可通过 hive 支持来实现多表 join 等复杂操作)。主要用来存储非结构化和半结构化的松散数据。与 hadoop 一样，Hbase 目标主要依靠横向扩展，通过不断增加廉价的商用服务器，来增加计算和存储能力。

# 特点：

​ HBase 中的表一般有这样的特点：

1. 大：一个表可以有上亿行，上百万列

2. 面向列：面向列 (族) 的存储和权限控制，列 (族) 独立检索。

3. 稀疏：对于为空 (null) 的列，并不占用存储空间，因此，表可以设计的非常稀疏。

下面一幅图是 Hbase 在 Hadoop Ecosystem 中的位置。

# 二、 逻辑视图

HBase 以表的形式存储数据。表有行和列组成。列划分为若干个列族 (row family)

Row Key

与 nosql 数据库们一样，row key 是用来检索记录的主键。访问 hbase table 中的行，只有三种方式：

1 通过单个 row key 访问

2 通过 row key 的 range

3 全表扫描

Row key 行键 (Row key) 可以是任意字符串 (最大长度是 64KB，实际应用中长度一般为 10-100bytes)，在 hbase 内部，row key 保存为字节数组。

存储时，数据按照 Row key 的字典序 (byte order) 排序存储。设计 key 时，要充分排序存储这个特性，将经常一起读取的行存储放到一起。(位置相关性)

注意：

字典序对 int 排序的结果是 1,10,100,11,12,13,14,15,16,17,18,19,2,20,21,…,9,91,92,93,94,95,96,97,98,99。要保持整形的自然序，行键必须用 0 作左填充。

行的一次读写是原子操作 (不论一次读写多少列)。这个设计决策能够使用户很容易的理解程序在对同一个行进行并发更新操作时的行为。

列族

hbase 表中的每个列，都归属与某个列族。列族是表的 chema 的一部分 (而列不是)，必须在使用表之前定义。列名都以列族作为前缀。例如 courses:history ， courses:math 都属于 courses 这个列族。

访问控制、磁盘和内存的使用统计都是在列族层面进行的。实际应用中，列族上的控制权限能 帮助我们管理不同类型的应用：我们允许一些应用可以添加新的基本数据、一些应用可以读取基本数据并创建继承的列族、一些应用则只允许浏览数据（甚至可能因 为隐私的原因不能浏览所有数据）。

时间戳

HBase 中通过 row 和 columns 确定的为一个存贮单元称为 cell。每个 cell 都保存着同一份数据的多个版本。版本通过时间戳来索引。时间戳的类型是 64 位整型。时间戳可以由 hbase (在数据写入时自动) 赋值，此时时间戳是精确到毫秒的当前系统时间。时间戳也可以由客户显式赋值。如果应用程序要避免数据版本冲突，就必须自己生成具有唯一性的时间戳。每个 cell 中，不同版本的数据按照时间倒序排序，即最新的数据排在最前面。

为了避免数据存在过多版本造成的的管理 (包括存贮和索引) 负担，hbase 提供了两种数据版本回收方式。一是保存数据的最后 n 个版本，二是保存最近一段时间内的版本（比如最近七天）。用户可以针对每个列族进行设置。

Cell

由 *{row key, column (* = + ), version} 唯一确定的单元。cell 中的数据是没有类型的，全部是字节码形式存贮。

# 三、 物理存储

1 . 已经提到过，Table 中的所有行都按照 row key 的字典序排列。

2 . Table 在行的方向上分割为多个 Hregion。

3 . region 按大小分割的，每个表一开始只有一个 region，随着数据不断插入表，region 不断增大，当增大到一个阀值的时候，Hregion 就会等分会两个新的 Hregion。当 table 中的行不断增多，就会有越来越多的 Hregion。

4 . Hregion 是 Hbase 中分布式存储和负载均衡的最小单元。最小单元就表示不同的 Hregion 可以分布在不同的 HRegion server 上。但一个 Hregion 是不会拆分到多个 server 上的。

5 . HRegion 虽然是分布式存储的最小单元，但并不是存储的最小单元。

事实上，HRegion 由一个或者多个 Store 组成，每个 store 保存一个 columns family。

每个 Strore 又由一个 memStore 和 0 至多个 StoreFile 组成。如图：

StoreFile 以 HFile 格式保存在 HDFS 上。

HFile 的格式为：

Trailer 部分的格式:

HFile 分为六个部分：

Data Block 段–保存表中的数据，这部分可以被压缩

Meta Block 段 (可选的)–保存用户自定义的 kv 对，可以被压缩。

File Info 段–Hfile 的元信息，不被压缩，用户也可以在这一部分添加自己的元信息。

Data Block Index 段–Data Block 的索引。每条索引的 key 是被索引的 block 的第一条记录的 key。

Meta Block Index 段 (可选的)–Meta Block 的索引。

Trailer–这一段是定长的。保存了每一段的偏移量，读取一个 HFile 时，会首先 读取 Trailer，Trailer 保存了每个段的起始位置 (段的 Magic Number 用来做安全 check)，然后，DataBlock Index 会被读取到内存中，这样，当检索某个 key 时，不需要扫描整个 HFile，而只需从内存中找到 key 所在的 block，通过一次磁盘 io 将整个 block 读取到内存中，再找到需要的 key。DataBlock Index 采用 LRU 机制淘汰。

HFile 的 Data Block，Meta Block 通常采用压缩方式存储，压缩之后可以大大减少网络 IO 和磁盘 IO，随之而来的开销当然是需要花费 cpu 进行压缩和解压缩。

目标 Hfile 的压缩支持两种方式：Gzip，Lzo。

HLog(WAL log)

WAL 意为 Write ahead log (http://en.wikipedia.org/wiki/Write-ahead_logging)，类似 mysql 中的 binlog, 用来 做灾难恢复只用，Hlog 记录数据的所有变更，一旦数据修改，就可以从 log 中进行恢复。

每个 Region Server 维护一个 Hlog, 而不是每个 Region 一个。这样不同 region (来自不同 table) 的日志会混在一起，这样做的目的是不断追加单个 文件相对于同时写多个文件而言，可以减少磁盘寻址次数，因此可以提高对 table 的写性能。带来的麻烦是，如果一台 region server 下线，为了恢复其上的 region，需要将 region server 上的 log 进行拆分，然后分发到其它 region server 上进行恢复。

HLog 文件就是一个普通的 Hadoop Sequence File，Sequence File 的 Key 是 HLogKey 对象，HLogKey 中记录了写入数据的归属信息，除了 table 和 region 名字外，同时还包括 sequence number 和 timestamp，timestamp 是” 写入时间”，sequence number 的起始值为 0，或者是最近一次存入文件系统中 sequence number。HLog Sequece File 的 Value 是 HBase 的 KeyValue 对象，即对应 HFile 中的 KeyValue，可参见上文描述。

# 四、 系统架构

Client

1 包含访问 hbase 的接口，client 维护着一些 cache 来加快对 hbase 的访问，比如 regione 的位置信息。

Zookeeper

1 保证任何时候，集群中只有一个 master

2 存贮所有 Region 的寻址入口。

3 实时监控 Region Server 的状态，将 Region server 的上线和下线信息实时通知给 Master

4 存储 Hbase 的 schema, 包括有哪些 table，每个 table 有哪些 column family

Master

1 为 Region server 分配 region

2 负责 region server 的负载均衡

3 发现失效的 region server 并重新分配其上的 region

4 GFS 上的垃圾文件回收

5 处理 schema 更新请求

Region Server

1 Region server 维护 Master 分配给它的 region，处理对这些 region 的 IO 请求

2 Region server 负责切分在运行过程中变得过大的 region

可以看到，client 访问 hbase 上数据的过程并不需要 master 参与（寻址访问 zookeeper 和 region server，数据读写访问 regione server），master 仅仅维护者 table 和 region 的元数据信息，负载很低。

# 五、关键算法 / 流程

region 定位

系统如何找到某个 row key (或者某个 row key range) 所在的 region

bigtable 使用三层类似 B + 树的结构来保存 region 位置。

第一层是保存 zookeeper 里面的文件，它持有 root region 的位置。

第二层 root region 是.META. 表的第一个 region 其中保存了.META.z 表其它 region 的位置。通过 root region，我们就可以访问.META. 表的数据。

.META. 是第三层，它是一个特殊的表，保存了 hbase 中所有数据表的 region 位置信息。

说明：

1 root region 永远不会被 split，保证了最需要三次跳转，就能定位到任意 region 。

2.META. 表每行保存一个 region 的位置信息，row key 采用表名 + 表的最后一样编码而成。

3 为了加快访问，.META. 表的全部 region 都保存在内存中。

假设，.META. 表的一行在内存中大约占用 1KB。并且每个 region 限制为 128MB。

那么上面的三层结构可以保存的 region 数目为：

(128MB/1KB) * (128MB/1KB) = = 2 (34) 个 region

4 client 会将查询过的位置信息保存缓存起来，缓存不会主动失效，因此如果 client 上的缓存全部失效，则需要进行 6 次网络来回，才能定位到正确的 region (其中三次用来发现缓存失效，另外三次用来获取位置信息)。

读写过程

上文提到，hbase 使用 MemStore 和 StoreFile 存储对表的更新。

数据在更新时首先写入 Log (WAL log) 和内存 (MemStore) 中，MemStore 中的数据是排序的，当 MemStore 累计到一定阈值时，就会创建一个新的 MemStore，并 且将老的 MemStore 添加到 flush 队列，由单独的线程 flush 到磁盘上，成为一个 StoreFile。于此同时，系统会在 zookeeper 中 记录一个 redo point，表示这个时刻之前的变更已经持久化了。(minor compact)

当系统出现意外时，可能导致内存 (MemStore) 中的数据丢失，此时使用 Log (WAL log) 来恢复 checkpoint 之后的数据。

前面提到过 StoreFile 是只读的，一旦创建后就不可以再修改。因此 Hbase 的更 新其实是不断追加的操作。当一个 Store 中的 StoreFile 达到一定的阈值后，就会进行一次合并 (major compact), 将对同一个 key 的修改合并到一起，形成一个大的 StoreFile，当 StoreFile 的大小达到一定阈值后，又会对 StoreFile 进行 split，等分为两个 StoreFile。

由于对表的更新是不断追加的，处理读请求时，需要访问 Store 中全部的 StoreFile 和 MemStore，将他们的按照 row key 进行合并，由于 StoreFile 和 MemStore 都是经过排序的，并且 StoreFile 带有内存中索引，合并的过程还是比较快。

写请求处理过程

1 client 向 region server 提交写请求

2 region server 找到目标 region

3 region 检查数据是否与 schema 一致

4 如果客户端没有指定版本，则获取当前系统时间作为数据版本

5 将更新写入 WAL log

6 将更新写入 Memstore

7 判断 Memstore 的是否需要 flush 为 Store 文件。

region 分配

任何时刻，一个 region 只能分配给一个 region server。master 记录了当前有哪些可用的 region server。以及当前哪些 region 分配给了哪些 region server，哪些 region 还没有分配。当存在未分配的 region，并且有一个 region server 上有可用空间时，master 就给这个 region server 发送一个装载请求，把 region 分配给这个 region server。region server 得到请求后，就开始对此 region 提供服务。

region server 上线

master 使用 zookeeper 来跟踪 region server 状态。当某个 region server 启动时，会首先在 zookeeper 上的 server 目录下建立代表自己的文件，并获得该文件的独占锁。由于 master 订阅了 server 目录上的变更消息，当 server 目录下的文件出现新增或删除操作时，master 可以得到来自 zookeeper 的实时通知。因此一旦 region server 上线，master 能马上得到消息。

region server 下线

当 region server 下线时，它和 zookeeper 的会话断开，zookeeper 而自动释放代表这台 server 的文件上的独占锁。而 master 不断轮询 server 目录下文件的锁状态。如果 master 发现某个 region server 丢失了它自己的独占锁，(或者 master 连续几次和 region server 通信都无法成功),master 就是尝试去获取代表这个 region server 的读写锁，一旦获取成功，就可以确定：

1 region server 和 zookeeper 之间的网络断开了。

2 region server 挂了。

的其中一种情况发生了，无论哪种情况，region server 都无法继续为它的 region 提供服务了，此时 master 会删除 server 目录下代表这台 region server 的文件，并将这台 region server 的 region 分配给其它还活着的同志。

如果网络短暂出现问题导致 region server 丢失了它的锁，那么 region server 重新连接到 zookeeper 之后，只要代表它的文件还在，它就会不断尝试获取这个文件上的锁，一旦获取到了，就可以继续提供服务。

master 上线

master 启动进行以下步骤:

1 从 zookeeper 上获取唯一一个代码 master 的锁，用来阻止其它 master 成为 master。

2 扫描 zookeeper 上的 server 目录，获得当前可用的 region server 列表。

3 和 2 中的每个 region server 通信，获得当前已分配的 region 和 region server 的对应关系。

4 扫描.META.region 的集合，计算得到当前还未分配的 region，将他们放入待分配 region 列表。

master 下线

由于 master 只维护表和 region 的元数据，而不参与表数据 IO 的过 程，master 下线仅导致所有元数据的修改被冻结 (无法创建删除表，无法修改表的 schema，无法进行 region 的负载均衡，无法处理 region 上下线，无法进行 region 的合并，唯一例外的是 region 的 split 可以正常进行，因为只有 region server 参与)，表的数据读写还可以正常进行。因此 master 下线短时间内对整个 hbase 集群没有影响。从上线过程可以看到，master 保存的 信息全是可以冗余信息（都可以从系统其它地方收集到或者计算出来），因此，一般 hbase 集群中总是有一个 master 在提供服务，还有一个以上 的’master’在等待时机抢占它的位置。

六、访问接口

• HBase Shell
• Java clietn API
• HBase non-java access
• • languages talking to the JVM
  • • Jython interface to HBase
    • Groovy DSL for HBase
    • Scala interface to HBase
  • languages with a custom protocol
  • • REST gateway specification for HBase
    • 充分利用 HTTP 协议：GET POST PUT DELETE

§

• • • text/plain
    • text/xml
    • application/json
    • application/x-protobuf
  • Thrift gateway specification for HBase
  • • java
    • cpp
    • rb
    • py
    • perl
    • php
• HBase Map Reduce
• Hive/Pig

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

01 ZGC 简介
ZGC 是一个可扩展的低延迟垃圾收集器，能够处理 8MB 到 16TB 大小的堆，最大暂停时间为亚毫秒。

OpenJDK 的官网只写到这里，然后让我们自己去看 Wiki（链接 2）…… 好偷懒……

    Wiki的介绍是更详细一些。

    Z Garbage Collector，也称为 ZGC，是一种可扩展的低延迟垃圾收集器，旨在满足以下目标：

亚毫秒最大暂停时间

暂停时间不会随着堆、live-set 或 root-set 的大小而增加

处理大小从 8MB 到 16TB 的堆

ZGC 最初是作为 JDK 11 中的一项实验性功能引入的，并在 JDK 15 中被宣布为 Production Ready。

ZGC 的几个特征：

并发

基于区域

基于压缩

NUMA 感知

使用染色指针

使用负载屏障（原文为 load barriers）

ZGC 的核心是一个并发垃圾收集器，这意味着所有繁重的工作都在 Java 线程继续执行的同时完成。这极大地减少了垃圾收集对应用程序响应时间的影响。

ZGC 项目由 HotSpot Group 赞助。

下图是截止目前为止（2020-04-17）的 ZGC 的发布时间表，可以看出 ZGC 总 JDK11 开始实验性推出，JDK15 开始正式发布。

    ZGC的部分参数：

ZGC 部分操作：

使用下述命令选项启用 ZGC

-XX:+UseZGC
启用 ZGC

设置堆大小

ZGC 最重要的调优选项是设置最大堆大小（-Xmx<size>）。由于 ZGC 是一个并发收集器，因此必须选择最大堆大小，以便 

1. 堆可以容纳应用程序的实时集，

2. 堆中有足够的空间来允许在 GC 时处理处理分配。

需要多少空间取决于应用程序的分配率和 live-set 大小。一般而言，给 ZGC 的内存越多越好。但与此同时，浪费内存是不可取的，所以这一切都是为了在内存使用和 GC 需要运行的频率之间找到一个平衡点。

3. 设置并发 GC 线程数

    第二个重要的选项是设置并发 GC 线程的数量 (-XX:ConcGCThreads=<number>)。ZGC 具有自动选择此数字的启发式方法。这种启发式通常效果很好，但根据应用程序的特性，这可能需要进行调整。这个选项本质上决定了应该给 GC 多少 CPU-time（ps：这个不知道咋翻译，就叫CPU时间？先不翻译）。给了ZGC太多运行时间，GC 将从应用程序中占用过多的 CPU-time。给它太少，应用程序分配垃圾的速度可能比 GC 收集它的速度快。

    一般来说，如果低延迟（即低应用程序响应时间）是工业环境中的最大痛点，在配置相应操作时候就不需要太吝啬。理想情况下，系统的 CPU 利用率不应超过 70%。

4. 返回未使用内存给操作系统

    默认情况下，ZGC 取消提交未使用的内存，将其返回给操作系统。这对于注重内存占用的应用程序和环境很有用。可以使用 -XX:-ZUncommit 禁用此功能。此外，内存不会被取消提交，因此堆大小会缩小到最小堆大小 (-Xms) 以下。这意味着如果最小堆大小 (-Xms) 配置为等于最大堆大小 (-Xmx)，则此功能将被隐式禁用。

    可以使用 -XX:ZUncommitDelay=<seconds> 配置取消提交延迟（默认为 300 秒）。此延迟指定内存在有资格取消提交之前应该未使用多长时间。

注意事项：在 Linux 上，取消提交未使用的内存需要具有 FALLOC_FL_PUNCH_HOLE 支持的 fallocate(2)，此特性首先出现在内核版本 3.5（用于 tmpfs）和 4.3（用于 hugetlbfs）中。

5. 启用 Linux 的大页（large page）操作

    将 ZGC 配置为使用大页面通常会产生更好的性能（在吞吐量、延迟和启动时间方面）并且没有真正的缺点，只是设置起来稍微复杂一些。设置过程通常需要 root 权限，这就是默认情况下不启用它的原因。

    在 Linux/x86 上，大页面（英文原文为large page和huge page）的大小为 2MB。

    假设您需要一个 16G Java 堆。这意味着您需要 16G / 2M = 8192 个大页面。

    首先为大页面池分配至少 16G（8192 页）的内存。“至少”部分很重要，因为在 JVM 中启用大页面意味着不仅 GC 会尝试将这些用于 Java 堆，而且 JVM 的其他部分也会尝试将它们用于各种 内部数据结构（代码堆、标记位图等）。因此，在本例中，我们将保留 9216 个页面 (18G) 以允许 2G 的非 Java 堆分配来使用大页面。

6. 启用 Linux 的透明大页（transparent large page）操作

    使用显式大页面（explicit large pages，就是5小节的大页面）的替代方法是使用透明大页面（ transparent huge pages）。通常不建议对延迟敏感的应用程序使用透明大页面（ latency sensitive，因为它往往会导致不必要的延迟峰值。但是，可能值得尝试看看系统的工作负载是否/如何受到它的影响。

    注意事项：在 Linux 上，使用启用透明大页的 ZGC 需要kernel >= 4.7。

7. 启用 NUMA 支持

    ZGC 支持 NUMA，这意味着它会尽量将 Java 堆分配指向 NUMA 本地内存。默认情况下启用此功能。但是，如果 JVM 检测到它只能使用单个 NUMA 节点上的内存，它将自动被禁用。通常，无需担心此设置，但如果您想显式覆盖 JVM 的决定，可以使用 -XX:+UseNUMA 或 -XX:-UseNUMA 选项来实现。

    在 NUMA 机器（例如多插槽 x86 机器）上运行时，启用 NUMA 支持通常会显著提升性能。

    注:

   关于NUMA,即Non Uniform Memory Access，非统一内存管理技术。以下直接截图于百度百科：

8. 启用 GC 日志

打个日志而已，就截图了。

具体操作还是参考链接 2。

02 ZGC 在 JDK17 中的最新优化
翻译自链接 4。

   JDK 17 于2021年 9 月 14 日发布。这是一个长期支持 (LTS) 版本，这意味着它将得到多年的支持和更新。这也是第一个包含 ZGC 生产就绪版本（production ready version）的 LTS 版本。 稍微回忆一下，JDK 11（以前的 LTS 版本）中包含了 ZGC 的实验版本，而 ZGC 的第一个生产就绪版本出现在 JDK 15（非 LTS 版本）中。

    因此，可以说JDK17是第一个开始推出成熟的ZGC的长期支持的ZGC版本。

    （本来还想把JDK15，JDK16啥的ZGC的翻译一下，不过既然JDK17中ZGC这么重要，就只搬运JDK17的优化好了。）

1. 动态 GC 线程数

    长期以来，JVM 都有一个名为

    -XX:+UseDynamicNumberOfGCThreads 

的选项。它默认启用，并告诉 GC 智能地了解它用于各种操作的 GC 线程数。使用的线程数将不断重新评估，因此会随着时间而变化。这个选项很有用有几个原因。例如，很难确定给定工作负载的最佳 GC 线程数是多少。通常发生的情况是，运维人员尝试各种设置 -XX:ParallelGCThreads 和 / 或 -XX:ConcGCThreads （取决于使用的 GC），看看哪个似乎给出了最好的结果。更复杂的是，最佳 GC 线程数可能会随着应用程序经历不同阶段而随时间变化，因此设置固定数量的 GC 线程本质上可能不是最佳的。

    在 JDK 17 之前，ZGC 忽略 -XX:+UseDynamicNumberOfGCThreads 并始终使用固定数量的线程。在 JVM 启动期间，ZGC 使用启发式方法来决定该固定数字 (-XX:ConcGCThreads) 应该是什么。一旦设定了这个数字，它就再也不会改变了。从 JDK 17 开始，ZGC 现在支持 -XX:+UseDynamicNumberOfGCThreads 并尝试使用尽可能少、但是足够多的线程来保持以创建的速度收集垃圾。这有助于避免使用比需要更多的 CPU 时间，从而使 Java 线程可以使用更多的 CPU 时间。

    另请注意，启用此功能后，-XX:ConcGCThreads 的含义从“使用这么多线程”变为“最多使用这么多线程”。除非有一个非常规的工作负载，否则你通常不需要摆弄 -XX:ConcGCThreads。ZGC 的启发式算法会根据运行的系统的大小为机器选择合适的最大线程数。

    （注：就是说JDK17开始，ZGC的运行时线程数是动态的，-XX:ConcGCThreads 设置的是最大可用线程，但是如果更少的线程就能满足需求，ZGC就会使用更少的线程；如果运行中需要增加线程数，ZGC也会动态增加线程数）

为了说明此功能的实际作用，官方贴出了一下运行 SPECjbb2015 时的一些图表。

    第一张图显示了整个运行过程中使用的 GC 线程数。SPECjbb2015 有一个初始加速阶段，随后是一个较长的阶段，其中负载（注入速率）逐渐增加。我们可以看到 ZGC 使用的线程数反映了它需要做的工作量来跟上。只有在少数情况下，它需要所有（在本例中为 5 个）线程。

    JDK16和JDK17的打分比较图如下。

    如果出于某种原因希望始终使用固定数量的 GC 线程（如在 JDK 16 和更早版本中），则可以使用 -XX:-UseDynamicNumberOfGCThreads 禁用此功能（注：应该没人会用吧？）。

2. 快速 JVM 终止

    在之前使用版本的Java程序中，如果使用的垃圾回收器是 ZGC ，终止正在运行的 Java 进程（例如，通过按 Ctrl+C 或通过让应用程序调用 System.exit()）， JVM 有时可能需要一段时间（在最坏的情况下为数秒）才能真正终止。这在一些需要快速宕机的场景下很烦人，如果某个场景需要快速终止程序，JVM的慢停止会导致一定问题。。

    那么，为什么之前在使用 ZGC 时，JVM 有时会需要一些时间来终止呢？原因是 JVM 的关闭顺序需要与 GC 协调，让 GC 停止正在做的事情，进入“安全”状态。ZGC 仅在空闲时处于“安全”状态，即当前不收集垃圾。如果终止信号到达时正在进行一个非常长的 GC 周期，那么 JVM 关闭序列只需等待该 GC 周期完成，然后 ZGC 变为空闲并再次进入“安全”状态。

    这已在 JDK 17 中得到解决。ZGC 现在能够中止正在进行的 GC 循环，以按需快速达到“安全”状态。终止运行 ZGC 的 JVM 现在或多或少是即时的。

3. 减少标记堆栈内存使用

    ZGC做条纹标记。这是指将堆划分为条带，并分配每个 GC 线程来标记其中一个条带（strip）中的对象。这有助于最小化 GC 线程之间的共享状态，并使标记过程对缓存更加友好，因为两个 GC 线程不会在堆的同一部分标记对象。这种方法还可以在 GC 线程之间实现自然的工作平衡，因为一个条带（strip）中的工作量往往大致相同。

    下图是ZGC的基于多线程垃圾回收器对基于条带的Java堆内存的回收机制示意图。

    在 JDK 17 之前，ZGC 的标记严格遵守条带化。如果一个 GC 线程在跟踪对象图时遇到一个对象引用，该对象引用指向不属于其分配的条带的堆的一部分，则该对象引用被放置在与该其他对象关联的线程本地标记堆栈上条纹。一旦该堆栈已满（254 个条目），它就会被移交给分配给该条带处理标记的 GC 线程。将对象引用加载到尚未标记的对象的 Java 线程会做同样的事情，只是它总是将对象引用放在关联的线程本地标记堆栈上，并且不会自己做任何实际的标记工作。

    这种方法适用于大多数工作负载，但也存在病态问题。如果您有一个具有一个或多个 N:1 关系的对象图，其中 N 是一个非常大的数字，那么您可能会为标记堆栈使用大量内存（如许多 GB）。我们一直都知道这可能是一个问题，您可以编写一个小型综合测试来引发它，但我们从未真正遇到过暴露它的真实工作负载。也就是说，直到来自腾讯的 OpenJDK 贡献者报告他们在野外遇到了这个问题（注：我去，鹅厂！）。

    JDK 17 中对此的修复涉及通过以下方式放松严格条带化：

对于 GC 线程，无论对象引用指向哪个条带，首先尝试标记对象（即可能跳出 GC 线程分配的条带），如果尚未标记，则将对象引用推送到关联标记 堆。

对于 Java 线程，首先检查对象是否已标记，如果尚未标记，则将对象引用推送到关联的标记堆栈。

（注：这一块我其实看的不是很懂。要是有人有兴趣讨论的话欢迎交流）。

这些调整有助于阻止在病态 N:1 情况下过度使用标记堆栈内存，其中 GC 线程一遍又一遍地遇到相同的对象引用，将大量重复的对象引用推入标记堆栈。重复是没有用的，因为一个对象只需要标记一次。通过在推送之前进行标记，并且只推送以前未标记的对象，复制品的生产就会停止。

我们最初有点不愿意这样做，因为 GC 线程现在正在执行原子比较和交换操作，以标记内存中属于分配给其他 GC 线程工作的条带的对象。这打破了严格的条带化，使其对缓存不太友好。Java 线程现在也在进行原子加载以查看对象是否被标记，这是他们以前没有做过的事情。同时，GC 线程完成的其他工作（扫描/跟踪对象字段和跟踪每个堆区域的活动对象/字节数）仍然遵守严格的条带化。最后，基准测试表明我们最初的担忧是没有根据的。GC 标记时间不受影响，对 Java 线程的影响也不明显。另一方面，我们现在有一个更健壮的标记方案，不会出现过多的内存使用。

    （注：所以其实出现这个问题，是不是因为只是因为某厂的代码写的太烂了……）

支持 ARM 上的 macOS

    前段时间（注：苹果2020年的秋季发布会的消息），Apple 宣布了一项将其 Mac 计算机产品线从 x86 过渡到 ARM 的长期计划。不久之后，JEP 391: macOS/AArch64 Port 提出了 JDK 到这个新平台的移植。JVM 代码库是相当模块化的，特定于操作系统和 CPU 的代码与共享平台无关代码隔离。JDK 已经支持 macOS/x86 和 Linux/Aarch64，因此支持 macOS/Aarch64 所需的主要部分已经存在。当然，任何计划发布和支持 JDK 的 macOS/Aarch64 构建的人仍然需要做一些工作，比如投资新硬件，将这个新平台集成到 CI 管道中等。

    ZGC的故事几乎相同。macOS/x86 和 Linux/Aarch64 都已经得到支持，因此主要是启用构建和测试这种新的 OS/CPU 组合的问题。从 JDK 17 开始，ZGC 在以下平台上运行：

Linux/x64

Linux/AArch64

macOS/x64

macOS/AArch64

Window/x64

Windows/AArch64

大多数 ZGC 代码库继续独立于平台。当前的代码分布如下所示：

​

用于循环和暂停的 GarbageCollectorMXBeans

    GarbageCollectorMXBean 提供有关 GC 的信息。通过这个 bean，应用程序可以提取摘要信息（到目前为止完成的 GC 次数、累计花费的 GC 时间等）并监听 GarbageCollectionNotificationInfo 通知以获取有关单个 GC 的更细粒度的信息（GC 原因、开始时间、结束时间， ETC）。

    在 JDK 17 之前，ZGC 发布了一个名为 ZGC 的单个 bean。这个 bean 提供了有关 ZGC 周期的信息。一个循环包括从开始到结束的所有 GC 阶段。大多数阶段是并发的，但有些是 Stop-The-World 暂停。虽然有关周期的信息很有用，但您可能还想知道在执行 GC 上花费了多少时间在 Stop-The-World 暂停上。此信息不适用于单个 ZGC bean。为了解决这个问题，ZGC 现在发布了两个 bean，一个称为 ZGC Cycles，一个称为 ZGC Pauses。顾名思义，每个 bean 提供的信息分别映射到周期和暂停。

总结：

    作为第一个支持生产版本ZGC的LTS版本的JDK，JDK17中对ZGC做了下述优化：

支持 JVM 选项 -XX:+UseDynamicNumberOfGCThreads。此功能默认启用，并告诉 ZGC 对其使用的 GC 线程数保持智能，这通常会导致 Java 应用程序级别的更高吞吐量和更低延迟。

使用了 ZGC 的 JVM 在停止运行时， 基本上是实时的，而之前版本花费的时间更多。

标记算法现在通常使用更少的内存，并且不再容易出现过多的内存使用。

ZGC 现在可以在 macOS/Aarch64 上运行。

ZGC 现在发布了两个 GarbageCollectorMXBean，以提供有关 GC 周期和 GC 暂停的信息。

03 一些很搞笑的事情

    据说有哥们在面试时候被面试官问到，ZGC的Z代表的是啥？

    面试者老哥内心OS：我去葛格不讲武德啊，之前面经没有讲到这个啊。但是呆胶布，我现场编一个。

    于是他说，“ZGC的Z是英文字母的最后一个字母，这说明Oracle公司想把ZGC作为Java的最终解决方案，是一个革命性的Java垃圾回收机制解决方案，blabla。”

    面试官微微一笑贴出官网截屏：

​

翻译：ZGC 的 Z 毛线都不表示，莫得含义。

    面试者：不听不听王八念经。

    笑死。

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# 【ELK】SpringBoot 整合 ELK 实现分布式日志搜索

# 一。环境准备：

# 安装 ElasticSearch、Kibana、LogStash。

docker 内，下载需要的镜像。然后启动一个镜像。

# 1.Es 创建

创建并运行一个 ElasticSearch 容器：

1
2

#7.6.2 启动需要增加discovery.type=single-node
docker run -e ES_JAVA_OPTS="-Xms256m -Xmx256m" -e discovery.type=single-node  -d -p 9200:9200 -p 9300:9300 --name MyES elasticsearch:7.6.2

浏览器访问测试：http://127.0.0.1:9200，应输出如下结果：

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

{
    "name": "WQawbNC",
    "cluster_name": "docker-cluster",
    "cluster_uuid": "f6QviESlT_e5u3kaZFHoWA",
    "version": {
        "number": "7.6.2",
        "build_flavor": "default",
        "build_type": "docker",
        "build_hash": "2f4c224",
        "build_date": "2020-03-18T23:22:18.622755Z",
        "build_snapshot": false,
        "lucene_version": "7.7.2",
        "minimum_wire_compatibility_version": "5.6.0",
        "minimum_index_compatibility_version": "5.0.0"
    },
    "tagline": "You Know, for Search"
}

# 2.Kibana 创建

创建并运行运行一个 Kibana 容器：
创建之前，先查看 ES 在 docker 中的 ip 地址，因为我们的 kibana 在启动的时候需要连接到 ES。

1
2
3
4
5
6
7
8
9
10

#先使用命令 docker ps 查看ES容器ID
docker ps
#输出如下:
CONTAINER ID   IMAGE                   COMMAND      CREATED        STATUS        PORTS      NAMES
a266d1ff5c1b  elasticsearch:7.6.2   "/usr/local/bin/dock…"   19 hours ago   Up 18 hours   0.0.0.0:9200->9200/tcp, 0.0.0.0:9300->9300/tcp   MyES

#通过容器ID，查看容器IP地址。以上的a266d1ff5c1b就是我们ES的容器ID
docker inspect --format '{{ .NetworkSettings.IPAddress }}' a266d1ff5c1b
#输出如下:
172.17.0.3

得到了 ES 容器 IP 地址之后，创建并运行一个 Kibana 容器。

1
2

#注意，此处的ELASTICSEARCH_URL需替换成上面ES容器的IP地址，否则Kibana连接不到ES
docker run -d --name MyKibana -p 5601:5601 -e ELASTICSEARCH_URL=http://172.17.0.3:9200 kibana:7.6.2

浏览器访问测试：http://127.0.0.1:5601：

# 3.LogStash 创建

创建并运行运行一个 LogStash 容器：

1

docker run -d -p 9600:9600 -p 4560:4560 --name MyLogStash logstash:7.6.2

运行后，进入容器内部。修改 logstash.yml 配置文件：

1

docker exec -it 容器ID bash

1

cd config

1

vi logstash.yml

1
2
3
4
5

# 改成如下配置
http.host: "0.0.0.0"
xpack.monitoring.elasticsearch.hosts: [ "http://esIP地址:9200" ]
xpack.monitoring.elasticsearch.username: elastic
xpack.monitoring.elasticsearch.password: your password

修改 pipeline 下的 logstash.conf 文件

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

input {
  tcp {
    #模式选择为server
    mode => "server"
    #ip和端口对应docker对外暴露logstash的地址可以使用下面命令查看
    #docker inspect logstash | grep IPAddress
    host => "172.17.0.3"
    port => 4560
    codec => json_lines
  }
}
output {
  elasticsearch {
        action => "index"
    #这里是es的地址，多个es要写成数组的形式
    hosts  => "http://你的esIP:9200"
    user => elastic #如果es配置了账号密码，要配置账号密码
    password => password #如果es配置了账号密码，要配置账号密码
    manage_template => true
    #用于kibana过滤，可以填项目名称 必须必须必须小写。
    index  => "demologs"
  }
}

最后重启我们的 logstash

1

docker restart MyLogStash

# 二、 使 ELK 与 SpringBoot 集成

maven 相关依赖：

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.elk</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <ch.qos.logback.version>1.2.3</ch.qos.logback.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>${ch.qos.logback.version}</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>${ch.qos.logback.version}</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-access</artifactId>
            <version>${ch.qos.logback.version}</version>
        </dependency>
        <dependency>
        <groupId>net.logstash.logback</groupId>
        <artifactId>logstash-logback-encoder</artifactId>
        <version>5.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

logback 配置：

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

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false" scan="true" scanPeriod="1 seconds">
    <include resource="org/springframework/boot/logging/logback/base.xml" />
    <contextName>logback</contextName>

    <appender name="stash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <destination>你的LogStashIP地址:4560</destination>
        <!-- encoder必须配置,有多种可选 -->
        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder" />
    </appender>

    <root level="info">
        <appender-ref ref="stash" />
    </root>
</configuration>

日志记录：

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

@RestController
@RequestMapping("/test")
public class ElkController {

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

    @RequestMapping("/test")
    public String elkAdd(){
        logger.info("日志记录"+System.currentTimeMillis());
        return "1";
    }
}

在 Kibana 中查看创建索引及查看日志：

# 可以看到我们的 elk 已经走通了，后面就可以根据自己的实际业务需求去进行修改配置。

# 总结

本次通过 docker 搭建 elk+springboot 的过程还是花费了不少的时间的，还是有所收获的。碰到问题的话尽量去百度查资料，耐心点基本上都是可以解决的。有感兴趣的小伙伴可以一起交流学习呀。

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# 【Flutter】Flutter 状态管理框架：Bloc 的计数器应用示例

# Flutter 计数器教程

在下面的教程中，我们会使用 Flutter 和 Bloc 库来开发一个计数器应用。

# 核心要点

• BlocObserver：用于观察 Bloc 内状态变化的 Widget。
• BlocProvider：为它的 children 提供 Bloc 的 Widget。
• BlocBuilder：根据新的 state 来绘制对应 Widget 的 Widget。
• 用 Cubit 替代 Bloc。两者有何不同？
• 通过 context.read 来触发 Event⚡。

# 新建项目和配置文件 yaml

我们先新建一个全新的 flutter 应用

1

flutter create flutter_counter

将下面代码复制粘贴到 pubspec.yaml 文件中

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

name: flutter_counter
description: A new Flutter project.
version: 1.0.0+1
publish_to: none

environment:
  sdk: ">=2.19.0 <3.0.0"

dependencies:
  bloc: ^8.1.0
  flutter:
    sdk: flutter
  flutter_bloc: ^8.1.1

dev_dependencies:
  bloc_test: ^9.1.0
  flutter_test:
    sdk: flutter
  integration_test:
    sdk: flutter
  mocktail: ^0.3.0
  very_good_analysis: ^3.1.0

flutter:
  uses-material-design: true

安装依赖包 package

1

flutter packages get

# 项目架构

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

├── lib
│   ├── app.dart
│   ├── counter
│   │   ├── counter.dart
│   │   ├── cubit
│   │   │   └── counter_cubit.dart
│   │   └── view
│   │       ├── counter_page.dart
│   │       └── counter_view.dart
│   ├── counter_observer.dart
│   └── main.dart
├── pubspec.lock
├── pubspec.yaml

这个应用中我们使用的是功能驱动（feature-driven）的项目结构。这种项目结构可以让我们通过一个个独立的功能来扩展项目。在当前项目中，我们只需要做一个功能（也就是计数器），但是在将来我们可以通过加入更多功能来实现一个复杂的应用。

# BlocObserver

首先，我们需要了解如何创建一个 BlocObserver ， 它将帮助我们观察应用中所有的状态变化.

创建文件 lib/counter_observer.dart :

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

import 'package:bloc/bloc.dart';

/// {@template counter_observer}
/// [BlocObserver] for the counter application which
/// observes all state changes.
/// {@endtemplate}
class CounterObserver extends BlocObserver {
  /// {@macro counter_observer}
  const CounterObserver();

  @override
  void onChange(BlocBase<dynamic> bloc, Change<dynamic> change) {
    super.onChange(bloc, change);
    // ignore: avoid_print
    print('${bloc.runtimeType} $change');
  }
}

在这个文件中，我们只重写了 onChange ，用来查看所有产生的状态（state）变化

注意: onChange 在 Bloc 和 Cubit 中发挥的作用是相同的。

# main.dart

接下来，用下面的代码替换 main.dart 里面的内容:

1
2
3
4
5
6
7
8
9
10

import 'package:bloc/bloc.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_counter/app.dart';
import 'package:flutter_counter/counter_observer.dart';

void main() {
  Bloc.observer = const CounterObserver();
  runApp(const CounterApp());
}

在上面的代码中，我们初始化了之前创建的 CounterObserver 并且通过 runApp 调用我们即将创建的 CounterApp 。

# Counter App

创建 lib/app.dart :

CounterApp 是一个 home 是 CounterPage 的 MaterialApp 。

1
2
3
4
5
6
7
8
9
10
11

import 'package:flutter/material.dart';
import 'package:flutter_counter/counter/counter.dart';

/// {@template counter_app}
/// A [MaterialApp] which sets the `home` to [CounterPage].
/// {@endtemplate}
class CounterApp extends MaterialApp {
  /// {@macro counter_app}
  const CounterApp({super.key}) : super(home: const CounterPage());
}

注意: CounterApp 扩展（extends) 自 MaterialApp ，所以在这里它是一个 MaterialApp 。 在大多数的情况下，我们会创建一个 StatelessWidget 或者 StatefulWidget 实例，并且通过 build 来绘制 Widget。但是现在我们并不需要绘制任何 Widget，所以我们直接从 MaterialApp 进行扩展（extends)，这样更简单。

接下来，让我们来看下 CounterPage !

# Counter Page

创建 lib/counter/view/counter_page.dart :

CounterPage 是用来创建一个 CounterCubit 实例 (也就是接下来我们要创建的类的实例) 并把它提供给 CounterView 使用。

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

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_counter/counter/counter.dart';

/// {@template counter_page}
/// A [StatelessWidget] which is responsible for providing a
/// [CounterCubit] instance to the [CounterView].
/// {@endtemplate}
class CounterPage extends StatelessWidget {
  /// {@macro counter_page}
  const CounterPage({super.key});

  @override
  Widget build(BuildContext context) {
    return BlocProvider(
      create: (_) => CounterCubit(),
      child: const CounterView(),
    );
  }
}

注意：分离（或者解耦） Cubit 创建部分的代码和 Cubit 使用部分的代码是非常重要的。这样使得代码更容易被测试或者被重复使用。

# Counter Cubit

创建 lib/counter/cubit/counter_cubit.dart :

CounterCubit 类将提供两种方法:

• increment : 给当前状态（state）加 1
• decrement : 给当前状态（state）减 1

设置 CounterCubit 状态的数据类型为 int ， 初始值是 0 。

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

import 'package:bloc/bloc.dart';

/// {@template counter_cubit}
/// A [Cubit] which manages an [int] as its state.
/// {@endtemplate}
class CounterCubit extends Cubit<int> {
  /// {@macro counter_cubit}
  CounterCubit() : super(0);

  /// Add 1 to the current state.
  void increment() => emit(state + 1);

  /// Subtract 1 from the current state.
  void decrement() => emit(state - 1);
}

小贴士：可以使用 VSCode Extension 或者 IntelliJ Plugin 自动创建新的 Cubit。

接下来我们来写 CounterView ，它将使用 state 并且和 CounterCubit 交互。

# Counter View

创建 lib/counter/view/counter_view.dart :

CounterView 是用来绘制计数器上的数字以及两个用于增加和减少数字的 FloatingActionButtons。

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

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_counter/counter/counter.dart';

/// {@template counter_view}
/// A [StatelessWidget] which reacts to the provided
/// [CounterCubit] state and notifies it in response to user input.
/// {@endtemplate}
class CounterView extends StatelessWidget {
  /// {@macro counter_view}
  const CounterView({super.key});

  @override
  Widget build(BuildContext context) {
    final textTheme = Theme.of(context).textTheme;
    return Scaffold(
      appBar: AppBar(title: const Text('Counter')),
      body: Center(
        child: BlocBuilder<CounterCubit, int>(
          builder: (context, state) {
            return Text('$state', style: textTheme.displayMedium);
          },
        ),
      ),
      floatingActionButton: Column(
        mainAxisAlignment: MainAxisAlignment.end,
        crossAxisAlignment: CrossAxisAlignment.end,
        children: <Widget>[
          FloatingActionButton(
            key: const Key('counterView_increment_floatingActionButton'),
            child: const Icon(Icons.add),
            onPressed: () => context.read<CounterCubit>().increment(),
          ),
          const SizedBox(height: 8),
          FloatingActionButton(
            key: const Key('counterView_decrement_floatingActionButton'),
            child: const Icon(Icons.remove),
            onPressed: () => context.read<CounterCubit>().decrement(),
          ),
        ],
      ),
    );
  }
}

用 BlocBuilder 把 Text 包起来，这样每一次 CounterCubit 状态变化的时候里面的文字就会更新。 另外，使用 context.read<CounterCubit>() 来接入 CounterCubit 实例。

注意：只有 Text 需要被 BlocBuilder 包起来，因为这是唯一一个会随着 CounterCubit 状态（state) 变化而变化的组件。请不要包裹任何不随状态（state) 改变而改变的 Widget， 从而避免绘制不必要的组件。

# Barrel

创建 lib/counter/counter.dart :

加入 counter.dart 用来导出所有有关计数器的公共接口。

1
2

export 'cubit/counter_cubit.dart';
export 'view/view.dart';

大功告成！我们已经将表现层（presentation layer）从数据逻辑层（business logic layer）中分离出来。 CounterView 不会知道用户点击按钮的时候发生了什么，它只是通知了 CounterCubit 。 而且， CounterCubit 不会知道状态（也就是计数器的值）是什么， 它只是根据被调用的方法来发出新的状态。

最后，通过执行 flutter run 让我们在真实设备或者模拟器上运行它。

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# ThreadLocal 详解

ThreadLocal 概述
ThreadLocal 类用来提供线程内部的局部变量，不同的线程之间不会相互干扰
这种变量在多线程环境下访问（通过 get 和 set 方法访问）时能保证各个线程的变量相对独立于其他线程内的变量
在线程的生命周期内起作用，可以减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度
使用
常用方法

案例
场景：让每个线程获取其设置的对应的共享变量值
共享变量访问问题案例

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

/**
 * 线程间访问共享变量之间问题
 * */
public class DemoQuestion {
    private String name;
    private int age;

    public static void main(String[] args) {
        DemoQuestion demoQuestion = new DemoQuestion();
        for (int i = 0; i < 5; i++) {
            // int j = i;
            new Thread(() ->{
                // demoQuestion.setAge(j);
                demoQuestion.setName(Thread.currentThread().getName() + "的数据");
                System.out.println("=================");
                System.out.println(Thread.currentThread().getName() + "--->" + demoQuestion.getName());
                // System.out.println(Thread.currentThread().getName() + "--->" + demoQuestion.getAge());
            },"t" + i).start();
        }
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

• 使用关键字 Synchronized 关键字加锁解决方案

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

/**
 * 使用加锁的方式解决：线程间访问共享变量之间问题
 * 将对共享变量的操作进行加锁，保证其原子性
 * */
public class SolveDemoQuestionBySynchronized {
    private String name;
    private int age;

    public static void main(String[] args) {
        SolveDemoQuestionBySynchronized demoQuestion = new SolveDemoQuestionBySynchronized();
        for (int i = 0; i < 5; i++) {
            // int j = i;
            new Thread(() ->{
                synchronized (SolveDemoQuestionBySynchronized.class){
                    demoQuestion.setName(Thread.currentThread().getName() + "的数据");
                    System.out.println("=================");
                    System.out.println(Thread.currentThread().getName() + "--->" + demoQuestion.getName());
                }
            },"t" + i).start();
        }
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

• 使用 ThreadLocal 方式解决

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

public class SolveDemoQuestionByThreadLocal {
    private  ThreadLocal<String> name = new ThreadLocal<>();
    private int age;

    public static void main(String[] args) {
        SolveDemoQuestionByThreadLocal demoQuestion = new SolveDemoQuestionByThreadLocal();
        for (int i = 0; i < 5; i++) {
            new Thread(() ->{
                demoQuestion.setName(Thread.currentThread().getName() + "的数据");
                System.out.println("=================");
                System.out.println(Thread.currentThread().getName() + "--->" + demoQuestion.getName());
            },"t" + i).start();
        }
    }
    public String getName() {
        return name.get();
    }
    private void setName(String content) {
        name.set(content);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

# ThreadLocalMap 内部结果

JDK8 之前的设计
每个 ThreadLocal 都创建一个 ThreadLocalMap，用线程作为 ThreadLocalMap 的 key，要存储的局部变量作为 ThreadLocalMap 的 value，这样就能达到各个线程的局部变量隔离的效果

JDK8 之后的设计
每个 Thread 维护一个 ThreadLocalMap，这个 ThreadLocalMap 的 key 是 ThreadLocal 实例本身，value 才是真正要存储的值 Object
每个 Thread 线程内部都有一个 ThreadLocalMap
Map 里面存储 ThreadLocal 对象（key）和线程的变量副本（value）
Thread 内部的 Map 是由 ThreadLocal 维护的，由 ThreadLocal 负责向 map 获取和设置线程的变量值
对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰

JDK 对 ThreadLocal 这样改造的好处
减少 ThreadLocalMap 存储的 Entry 数量：因为之前的存储数量由 Thread 的数量决定，现在是由 ThreadLocal 的数量决定。在实际运用当中，往往 ThreadLocal 的数量要少于 Thread 的数量
当 Thread 销毁之后，对应的 ThreadLocalMap 也会随之销毁，能减少内存的使用（但是不能避免内存泄漏问题，解决内存泄漏问题应该在使用完后及时调用 remove () 对 ThreadMap 里的 Entry 对象进行移除，由于 Entry 继承了弱引用类，会在下次 GC 时被 JVM 回收）

# ThreadLocal 相关方法源码解析

# set 方法

• 源码及相关注释

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

 /**
    * 设置当前线程对应的ThreadLocal的值
    * @param value 将要保存在当前线程对应的ThreadLocal的值
    */
   public void set(T value) {
       // 获取当前线程对象
       Thread t = Thread.currentThread();
       // 获取此线程对象中维护的ThreadLocalMap对象
       ThreadLocalMap map = getMap(t);
       // 判断map是否存在
       if (map != null)
           // 存在则调用map.set设置此实体entry,this这里指调用此方法的ThreadLocal对象
           map.set(this, value);
       else
           // 1）当前线程Thread 不存在ThreadLocalMap对象
           // 2）则调用createMap进行ThreadLocalMap对象的初始化
           // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
           createMap(t, value);
   }

/**
    * 获取当前线程Thread对应维护的ThreadLocalMap 
    * 
    * @param  t the current thread 当前线程
    * @return the map 对应维护的ThreadLocalMap 
    */
   ThreadLocalMap getMap(Thread t) {
       return t.threadLocals;
   }
   
/**
    *创建当前线程Thread对应维护的ThreadLocalMap 
    * @param t 当前线程
    * @param firstValue 存放到map中第一个entry的值
    */
void createMap(Thread t, T firstValue) {
       //这里的this是调用此方法的threadLocal
       t.threadLocals = new ThreadLocalMap(this, firstValue);
   }

• 相关流程图

• 执行流程

1. 获取当前线程，并根据当前线程获取一个 Map
2. 如果获取的 Map 不为空，则将参数设置到 Map 中（当前 ThreadLocal 的引用作为 key）
3. 如果 Map 为空，则给该线程创建 Map，并设置初始值

# get () 方法

• 源码及相关注释

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
51
52
53
54
55

/**
    * 返回当前线程中保存ThreadLocal的值
    * 如果当前线程没有此ThreadLocal变量，
    * 则它会通过调用{@link #initialValue} 方法进行初始化值
    * @return 返回当前线程对应此ThreadLocal的值
    */
   public T get() {
       // 获取当前线程对象
       Thread t = Thread.currentThread();
       // 获取此线程对象中维护的ThreadLocalMap对象
       ThreadLocalMap map = getMap(t);
       // 如果此map存在
       if (map != null) {
           // 以当前的ThreadLocal 为 key，调用getEntry获取对应的存储实体e
           ThreadLocalMap.Entry e = map.getEntry(this);
           // 对e进行判空 
           if (e != null) {
               @SuppressWarnings("unchecked")
               // 获取存储实体 e 对应的 value值,即为我们想要的当前线程对应此ThreadLocal的值
               T result = (T)e.value;
               return result;
           }
       }
       /*
       	初始化 : 有两种情况有执行当前代码
       	第一种情况: map不存在，表示此线程没有维护的ThreadLocalMap对象
       	第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
        */
       return setInitialValue();
   }

   /**
    * 初始化
    * @return the initial value 初始化后的值
    */
   private T setInitialValue() {
       // 调用initialValue获取初始化的值
       // 此方法可以被子类重写, 如果不重写默认返回null
       T value = initialValue();
       // 获取当前线程对象
       Thread t = Thread.currentThread();
       // 获取此线程对象中维护的ThreadLocalMap对象
       ThreadLocalMap map = getMap(t);
       // 判断map是否存在
       if (map != null)
           // 存在则调用map.set设置此实体entry
           map.set(this, value);
       else
           // 1）当前线程Thread 不存在ThreadLocalMap对象
           // 2）则调用createMap进行ThreadLocalMap对象的初始化
           // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
           createMap(t, value);
       // 返回设置的值value
       return value;
   }

• 流程图

执行流程
获取当前线程，根据当前线程获取一个 Map
如果获取的 Map 不为空，则在 Map 中以 ThreadLocal 的引用作为 key 来在 Map 中获取对应的 Entrye，否则转到 4
如果 e 不为 null，则返回 e.value，否则转到 4
Map 为空或者 e 为空，则通过 initialValue 函数获取初始值 value，然后用 ThreadLocal 的引用和 value 作为 firstKey 和 firstValue 创建一个新的 Map

# remove 方法

• 源码及相关注释

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

/**
     * 删除当前线程中保存的ThreadLocal对应的实体entry
     */
     public void remove() {
        // 获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
         if (m != null)
            // 存在则调用map.remove
            // 以当前ThreadLocal为key删除对应的实体entry
             m.remove(this);
     }

• 执行流程

1. 首先获取当前线程，并根据当前线程获取一个 Map
2. 如果获取的 Map 不为空，则移除当前 ThreadLocal 对象对应的 entry

initialValue 方法
此方法的作用是返回该线程局部变量的初始值
这个方法是一个延迟调用方法，从上面的代码我们得知，在 set 方法还未调用而先调用了 get 方法时才执行，并且仅执行 1 次
这个方法缺省实现直接返回一个 null
如果想要一个除 null 之外的初始值，可以重写此方法。（备注： 该方法是一个 protected 的方法，显然是为了让子类覆盖而设计的）
源码及相关注释

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

/**
  * 返回当前线程对应的ThreadLocal的初始值
  * 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
  * 除非线程先调用了set方法，在这种情况下，initialValue 才不会被这个线程调用。
  * 通常情况下，每个线程最多调用一次这个方法。
  *
  * <p>这个方法仅仅简单的返回null {@code null};
  * 如果想ThreadLocal线程局部变量有一个除null以外的初始值，
  * 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
  * 通常, 可以通过匿名内部类的方式实现
  *
  * @return 当前ThreadLocal的初始值
  */
protected T initialValue() {
    return null;
}

ThreadLocalMap 解析

# 内部结构

ThreadLocalMap 是 ThreadLocal 的内部类，没有实现 Map 接口，用独立的方式实现了 Map 的功能，其内部的 Entry 也是独立实现的，而 Entry 又是 ThreadLocalMap 的内部类，且集成弱引用 (WeakReference) 类。

# 成员变量

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

		/**
        * The entries in this hash map extend WeakReference, using
        * its main ref field as the key (which is always a
        * ThreadLocal object).  Note that null keys (i.e. entry.get()
        * == null) mean that the key is no longer referenced, so the
        * entry can be expunged from table.  Such entries are referred to
        * as "stale entries" in the code that follows.
        * 
			* Entry继承WeakReference，并且用ThreadLocal作为key.
				* 如果key为null(entry.get() == null)，意味着key不再被引用，
				* 因此这时候entry也可以从table中清除。
        */
       static class Entry extends WeakReference<ThreadLocal<?>> {
           /** The value associated with this ThreadLocal. */
           Object value;

           Entry(ThreadLocal<?> k, Object v) {
               super(k);
               value = v;
           }
       }

/**
    * 初始容量 —— 必须是2的整次幂
    *  The initial capacity -- MUST be a power of two.  
    */
   private static final int INITIAL_CAPACITY = 16;

   /**
    * 存放数据的table，Entry类的定义在下面分析
    * 同样，数组长度必须是2的整次幂。
    * The table, resized as necessary.
    * table.length MUST always be a power of two.
    */
   private Entry[] table;

   /**
    * 数组里面entrys的个数，可以用于判断table当前使用量是否超过阈值。
    * The number of entries in the table
    */
   private int size = 0;

   /**
    * 进行扩容的阈值，表使用量大于它的时候进行扩容。
    * The next size value at which to resize
    */
   private int threshold; // Default to 0

# 弱引用和内存泄漏

弱引用相关概念
强引用（“Strong” Reference），就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还 “活着”，垃圾回收器就不会回收这种对象
弱引用（WeakReference），垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存

# 内存泄漏相关概念

Memory overflow: 内存溢出，没有足够的内存提供申请者使用
Memory leak: 内存泄漏是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积终将导致内存溢出

# 内存泄漏与强弱引用关系

ThreadLocal 内存结构

如果 key 使用强引用，也就是上图中的红色背景框部分
业务代码中使用完 ThreadLocal ，threadLocal Ref 被回收了
因为 threadLocalMap 的 Entry 强引用了 threadLocal，造成 threadLocal 无法被回收
在没有手动删除这个 Entry 以及 CurrentThread 依然运行的前提下，始终有强引用链 threadRef->currentThread->threadLocalMap->entry，Entry 就不会被回收（Entry 中包括了 ThreadLocal 实例和 value），导致 Entry 内存泄漏
如果 key 使用弱引用，也就是上图中的红色背景框部分
业务代码中使用完 ThreadLocal ，threadLocal Ref 被回收了
由于 ThreadLocalMap 只持有 ThreadLocal 的弱引用，没有任何强引用指向 threadlocal 实例，所以 threadlocal 就可以顺利被 gc 回收，此时 Entry 中的 key=null
但是在没有手动删除这个 Entry 以及 CurrentThread 依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry -> value ，value 不会被回收， 而这块 value 永远不会被访问到了，导致 value 内存泄漏

# 出现内存泄漏的真实原因

没有手动删除对应的 Entry 节点信息
ThreadLocal 对象使用完后，对应线程仍然在运行

# 避免内存泄漏的的两种方式

使用完 ThreadLocal，调用其 remove 方法删除对应的 Entry
使用完 ThreadLocal，当前 Thread 也随之运行结束
对于第一种方式很好控制，调用对应 remove () 方法即可，但是对于第二种方式，我们是很难控制的，正因为不好控制，这也是为什么 ThreadLocalMap 里对应的 Entry 对象继承弱引用的原因，因为使用了弱引用，当 ThreadLocal 使用完后，key 的引用就会为 null，而在调用 ThreadLocal 中的 get ()/set () 方法时，当判断 key 为 null 时会将 value 置为 null，这就就会在 jvm 下次 GC 时将对应的 Entry 对象回收，从而避免内存泄漏问题的出现。

# hash 冲突问题及解决方法

首先从 ThreadLocal 的 set () 方法入手

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

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocal.ThreadLocalMap map = getMap(t);
        if (map != null)
            //调用了ThreadLocalMap的set方法
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    ThreadLocal.ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
        	//调用了ThreadLocalMap的构造方法
        t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
    }

• 构造方法 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)

•  /*
    * firstKey : 本ThreadLocal实例(this)
    * firstValue ： 要保存的线程本地变量
    */
  ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
          //初始化table
          table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
          //计算索引(重点代码）
          int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
          //设置值
          table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
          size = 1;
          //设置阈值
          setThreshold(INITIAL_CAPACITY);
      }
  1
  2
  3
  4
  5
  6
  
  构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold
  
  分析：int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)
  关于：firstKey.threadLocalHashCode
  
  
  private final int threadLocalHashCode = nextHashCode();
      
      private static int nextHashCode() {
          return nextHashCode.getAndAdd(HASH_INCREMENT);
      }
  //AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减,适合高并发情况下的使用
      private static AtomicInteger nextHashCode =  new AtomicInteger();
       //特殊的hash值
      private static final int HASH_INCREMENT = 0x61c88647;
  1
  2
  3
  4
  5
  6
  7
  
  这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT，HASH_INCREMENT = 0x61c88647,这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里, 也就是Entry[] table中，这样做可以尽量避免hash冲突
  
  关于：& (INITIAL_CAPACITY - 1)
  计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现。正是因为这种算法，我们要求size必须是2的整次幂，这也能保证在索引不越界的前提下，使得hash发生冲突的次数减小
  ThreadLocalMap中的set方法
  
  
  private void set(ThreadLocal<?> key, Object value) {
          ThreadLocal.ThreadLocalMap.Entry[] tab = table;
          int len = tab.length;
          //计算索引(重点代码，刚才分析过了）
          int i = key.threadLocalHashCode & (len-1);
          /**
           * 使用线性探测法查找元素（重点代码）
           */
          for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
               e != null;
               e = tab[i = nextIndex(i, len)]) {
              ThreadLocal<?> k = e.get();
              //ThreadLocal 对应的 key 存在，直接覆盖之前的值
              if (k == key) {
                  e.value = value;
                  return;
              }
              // key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，
             // 当前数组中的 Entry 是一个陈旧（stale）的元素
              if (k == null) {
                  //用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏
                  replaceStaleEntry(key, value, i);
                  return;
              }
          }
      
      	//ThreadLocal对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry。
              tab[i] = new Entry(key, value);
              int sz = ++size;
              /**
               * cleanSomeSlots用于清除那些e.get()==null的元素，
               * 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置null。
               * 如果没有清除任何entry,并且当前使用量达到了负载因子所定义(长度的2/3)，那么进行				 * rehash（执行一次全表的扫描清理工作）
               */
              if (!cleanSomeSlots(i, sz) && sz >= threshold)
                  rehash();
  }
  
   /**
       * 获取环形数组的下一个索引
       */
      private static int nextIndex(int i, int len) {
          return ((i + 1 < len) ? i + 1 : 0);
      }
  

  # 代码执行流程：

  1. 首先还是根据 key 计算出索引 i，然后查找 i 位置上的 Entry

  2. 若是 Entry 已经存在并且 key 等于传入的 key，那么这时候直接给这个 Entry 赋新的 value 值

  3. 若是 Entry 存在，但是 key 为 null，则调用 replaceStaleEntry 来更换这个 key 为空的 Entry

  4. 不断循环检测，直到遇到为 null 的地方，这时候要是还没在循环过程中 return，那么就在这个 null 的位置新建一个 Entry，并且插入，同时 size 增加 1

  5. 最后调用 cleanSomeSlots，清理 key 为 null 的 Entry，最后返回是否清理了 Entry，接下来再判断 sz 是否 >= thresgold 达到了 rehash 的条件，达到的话就会调用 rehash 函数执行一次全表的扫描清理

  • 分析 ： ThreadLocalMap 使用线性探测法来解决哈希冲突的

  1. 该方法一次探测下一个地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出
  2. 假设当前 table 长度为 16，也就是说如果计算出来 key 的 hash 值为 14，如果 table [14] 上已经有值，并且其 key 与当前 key 不一致，那么就发生了 hash 冲突，这个时候将 14 加 1 得到 15，取 table [15] 进行判断，这个时候如果还是冲突会回到 0，取 table [0], 以此类推，直到可以插入

  3. 可以把 Entry [] table 看成一个环形数组

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# 【Java】SpringBoot 整合 Redis 对查询数据做缓存（ 利用 Spring 的 AOP 技术）

# 本篇主要介绍 SpringBoot 整合 Redis 做数据缓存，利用的是 SpringAop 切面编程技术，利用注解标识切面。

# 这里不再介绍 spring boot 操作数据库，有兴趣的话，我最后会给出源码链接

# 一，引入依赖

1
2
3
4
5
6
7
8
9
10

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
    <version>1.3.2.RELEASE</version>
</dependency>12345678910

# 二，配置 redis 连接

配置文件我里这用的是 yml 格式的，tab 缩进，如果是 properties 格式的，请自己改造
redis 安装请参考 Redis 安装
windows 管理工具可以用 RedisDesktopManager，测试的时候，可以直接删除缓存。

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

spring:
  redis:
    database: 0
    ## Redis服务器地址
    host: 127.0.0.1.128
    ## Redis服务器连接端口
    port: 6379
    ## Redis服务器连接密码（默认为空）
    password:
    ## 连接超时时间（毫秒）
    timeout: 0
    ## 连接池最大连接数（使用负值表示没有限制）
    pool:
      max-active: 8
      ## 连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1
      ## 连接池中的最大空闲连接
      max-idle: 8
      ## 连接池中的最小空闲连接
      min-idle: 01234567891011121314151617181920

# 三，注解

注解 QueryCache 用来标识查询数据库的方法，参数 nameSpace 用来区分应用的，后面会用来添加到缓存的 key 中。比如，登陆应用缓存的数据 key 值全部都是 sso 开头。

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

package com.example.common.annotation;

import com.example.common.CacheNameSpace;

import java.lang.annotation.*;

/**
 * @author Brath
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface QueryCache {
    CacheNameSpace nameSpace();
}

注解 QueryCacheKey 是方法级别的注解，用来标注要查询数据的主键，会和上面的 nameSpace 组合做缓存的 key 值

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

package com.example.common.annotation;

import java.lang.annotation.*;

/**
 * @author Brath
 */

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.PARAMETER})
@Documented
public @interface QueryCacheKey {
}

枚举 CacheNameSpace 用来保存 nameSpace 的

1
2
3
4
5
6
7
8

package com.example.common;

/**
 * @author Brath
 */
public enum CacheNameSpace {
    SSO_USER
}

下面就是组合起来的用法，userMapper.findById (id) 是用来查询数据库的方法

1
2
3
4
5
6
7

@QueryCache(nameSpace = CacheNameSpace.SSO_USER)
public UserInfo findUserById(@QueryCacheKey Long id) {

    UserInfo userInfo = userMapper.findById(id);

    return userInfo;
}

# 四，Aop 切面

下面是重点，代码中的注释已经很多了，应该能看的懂，如有问题，可以留言。

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

package com.example.common.aspect;

import com.example.common.CacheNameSpace;
import com.example.common.annotation.QueryCache;
import com.example.common.annotation.QueryCacheKey;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.core.annotation.SynthesizingMethodParameter;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;

/**
 * @author Brath
 */
@Aspect
@Service
public class DBCacheAspect {
    private static final Logger LOGGER = LoggerFactory.getLogger(DBCacheAspect.class);

    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 定义拦截规则：拦截所有@QueryCache注解的方法。
     */
    /*@Pointcut("execution(* com.example.service.impl..*(..)) , @annotation(com.example.common.annotation.QueryCache)")
    public void queryCachePointcut(){}*/
    @Pointcut("@annotation(com.example.common.annotation.QueryCache)")
    public void queryCachePointcut(){}

    /**
     * 拦截器具体实现
     * @param pjp
     * @return
     * @throws Throwable
     */
    @Around("queryCachePointcut()")
    public Object Interceptor(ProceedingJoinPoint pjp) throws Throwable {
        long beginTime = System.currentTimeMillis();
        LOGGER.info("AOP 缓存切面处理 >>>> start ");
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod(); //获取被拦截的方法
        CacheNameSpace cacheType = method.getAnnotation(QueryCache.class).nameSpace();
        String key = null;
        int i = 0;

        // 循环所有的参数
        for (Object value : pjp.getArgs()) {
            MethodParameter methodParam = new SynthesizingMethodParameter(method, i);
            Annotation[] paramAnns = methodParam.getParameterAnnotations();

            // 循环参数上所有的注解
            for (Annotation paramAnn : paramAnns) {
                if ( paramAnn instanceof QueryCacheKey) { //
                    QueryCacheKey requestParam = (QueryCacheKey) paramAnn;
                    key = cacheType.name() + "_" + value;   // 取到QueryCacheKey的标识参数的值
                }
            }
            i++;
        }

        // 获取不到key值，抛异常
        if (StringUtils.isBlank(key)) throw new Exception("缓存key值不存在");

        LOGGER.info("获取到缓存key值 >>>> " + key);
        ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {

            // 缓存中获取到数据，直接返回。
            Object object = operations.get(key);
            LOGGER.info("从缓存中获取到数据 >>>> " + object.toString());
            LOGGER.info("AOP 缓存切面处理 >>>> end 耗时：" + (System.currentTimeMillis() - beginTime));

            return object;
        }

        // 缓存中没有数据，调用原始方法查询数据库
        Object object = pjp.proceed();
        operations.set(key, object, 30, TimeUnit.MINUTES); // 设置超时时间30分钟

        LOGGER.info("DB取到数据并存入缓存 >>>> " + object.toString());
        LOGGER.info("AOP 缓存切面处理 >>>> end 耗时：" + (System.currentTimeMillis() - beginTime));
        return object;
    }


}

# 五，测试

1
2
3
4

@Test
public void testFindById(){
    UserInfo userInfo = userService.findUserById(210001L);
}

# 六，执行结果

两张图对比一下很明显，从 redis 缓存中取数据耗时要少的多。

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# 荔知，开启不知与荔知的奇妙旅程

# 对予以支持的人们，致以崇高的问候.

# 荔知 Web 端以及小程序均已发布上线

荔知官网：【https://meznymppws.cloudpages.cn】

荔知网页端：【https://www.brath.cn】

荔知小程序端：【微信搜索 “荔知知道”】

​

# 你是否曾经对某个问题困惑不已，却苦于找不到准确的答案？你是否曾经渴望拥有一个智慧的伙伴，能够帮助你解决疑惑、获取知识？现在，荔知知道 - 微信小程序和网页应用应运而生，为你打开了一扇通向知识宝库的大门。

​ 荔知知道微信小程序是你身边的智慧助手，只需在微信中搜索【荔知知道】，即可进入这个神奇的世界。在这里，你将发现一个集合了海量知识的平台，涵盖了各个领域的精华。无论是学术知识、实用技巧还是生活常识，荔知知道都能为你提供准确、全面的答案。

​ 荔知知道小程序的魅力不仅仅在于它的内容丰富，更在于它的智能化能力。底层使用文心一言大模型，荔知知道拥有强大的 AI 支持，能够理解你的问题并给出精准的回答。无论你遇到什么难题，荔知知道都能为你提供及时、准确的解决方案，让你的疑虑烟消云散。

​ 而荔知网页应用是你探索知识的新航向，只需点击链接【https://www.brath.cn】，你将进入一个全新的学习世界。在这里，你将享受到更加丰富的学习资源和更便捷的使用体验。荔知网页应用为你提供了一个开放的平台，你可以通过浏览、搜索和互动来获取你感兴趣的知识，无论是阅读文章、观看视频还是参与讨论，荔知都会给你带来全新的学习体验。

# 最后

# 荔知的口号：“你不知道的，荔知知道！” 让荔知知道微信小程序和网页应用陪伴你，带你进入一个充满智慧和惊喜的世界！快来加入我们吧！

# Linux 下 docer 部署 mysql

部署方法：

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64

1.首先在Linux系统中启动已经安装好的docker
service docker start

2.查看docker进程，确认docker启动成功
ps -ef|grep docker

3.在docker容器中查询MySQL
docker search mysql

4.在docker中安装MySQL
docker pull mysql

5.查看MySQL镜像
docker images

6.创建MySQL用户并且将root账户密码设置为你需要的密码
docker run --name mysqlserver -v $PWD/conf:/etc/mysql/conf.d -v $PWD/logs:/logs -v $PWD/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=『你的账户密码』 -d -i -p 外网端口:3306 mysql:latest

docker run -p 33001:3306 --name mysqlSlave2 -v /mydata/mysql/log:/var/log/mysql -v /mydata/mysql/data:/var/lib/mysql -v /mydata/mysql/conf:/etc/mysql -e MYSQL_ROOT_PASSWORD=Lgq081538 -d mysql:5.7

#指定配置文件容器
docker run -p 33001:3306 --name mysqlSlave2 \
-v /usr/local/docker/mysql/logs:/var/log/mysql \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
-v /usr/local/docker/mysql/conf/my.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf \
-e MYSQL_ROOT_PASSWORD=Lgq081538 \
-d mysql:5.7

7.在docker中启动MySQL
docker exec -it mysqlSlave2 bash

8.输入用户名和密码
mysql -uroot -p

9.开启MySQL远程访问权限
use mysql;
select host,user from user;
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'Lgq081538';
flush privileges;

一些在docker的常用命令：
1、列出正在运行的容器
docker ps -a

2、列出包括未运行的所有的容器
docker ps

3、查看某进程最近10条运行日志
docker logs -f --tail 10 "所查询的进程ID"

4、关闭docker中运行的进程，以MySQL为例
docker stop mysql

或者
docker stop "要停止的进程ID"

5、重启docker中运行的进程
docker restart "要重启的进程ID"

6、重启docker
systemctl restart docker

7、停止docker
systemctl stop docker

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

购买好服务器后，进入 Xshell：

1. 安装宝塔面板

1

yum install -y wget && wget -O install.sh http://download.bt.cn/install/install_6.0.sh && sh install.sh

获得：

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

==================================================================
Congratulations! Installed successfully!
==================================================================
外网面板地址: http://42.193.125.92:8888/ef1f509f
内网面板地址: http://172.21.0.3:8888/ef1f509f
username: upqknxq4
password: f3701931
If you cannot access the panel,
release the following panel port [8888] in the security group
若无法访问面板，请检查防火墙/安全组是否有放行面板[8888]端口
==================================================================
Time consumed: 1 Minute!

访问 http://ip:8888/ef1f509f 打开宝塔

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# Docker 环境下安装 vim

在使用 docker 容器时，容器一般没有安装 vim，就需要安装 vim
apt-get install vim 命令用于安装 vim，但是下载过慢。
第一步 配置国内镜像源
进入某个容器

例如进入 mysql

1

docker exec -it mysql /bin/bash

第二步：更新源

1

apt update

第三步安装 vim

1

apt-get install vim

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

RequestParam 和 PathVariable 注解是用于从 request 中接收请求的，两个都可以接收参数，关键点不同的是 RequestParam 是从 request 里面拿取值，而 PathVariable 是从一个 URI 模板里面来填充

PathVariable
主要用于接收 http://host:port/path/{参数值} 数据:

http://localhost:8887/test1/id1/name1

根据上面的这个 url，你可以用这样的方式来进行获取:

RequestMapping("test1/{id}/{name}")
public String testPathVariable(PathVariable String id, PathVariable String name) {
    return "id=" + id + ", name=" + name;
}
PathVariable 支持下面三种参数：

name 绑定本次参数的名称，要跟 URL 上面的一样
required 这个参数是否必须的
value 跟 name 一样的作用，是 name 属性的一个别名
RequestParam
主要用于接收 http://host:port/path? 参数名 = 参数值数据，这里后面也可以不跟参数值；

http://localhost:8887/test2?id=id2&name=name2

根据上面的这个 url，你可以用这样的方式来进行获取:

RequestMapping("test2")
public String testRequestParam(RequestParam("id") String id, RequestParam("name") String name) {
    return "id=" + id + ", name=" + name;
}
RequestParam 支持下面四种参数：

defaultValue 如果本次请求没有携带这个参数，或者参数为空，那么就会启用默认值
name 绑定本次参数的名称，要跟 URL 上面的一样
required 这个参数是否必须的
value 跟 name 一样的作用，是 name 属性的一个别名
PathVariable 和 RequestParam 混合使用
http://localhost:8887/test3/id3?name=name3

根据上面的这个 url，你可以用这样的方式来进行获取:

RequestMapping("test3/{id}")
public String test3(PathVariable String id, RequestParam("name") String name) {
    return "id=" + id + ", name=" + name;
}
对比
1.用法上的不同：
PathVariable只能用于接收url路径上的参数，而RequestParam只能用于接收请求带的params
2.内部参数不同：
PathVariable有value，name，required这三个参数，而RequestParam也有这三个参数，并且比PathVariable多一个参数defaultValue（该参数用于当请求体中不包含对应的参数变量时，参数变量使用defaultValue指定的默认值）
3.PathVariable一般用于get和delete请求，RequestParam一般用于post请求。

# 关于我

Brath 是一个热爱技术的 Java 程序猿，公众号「InterviewCoder」定期分享有趣有料的精品原创文章！

非常感谢各位人才能看到这里，原创不易，文章如果有帮助可以关注、点赞、分享或评论，这都是对我的莫大支持！

# 【Flutter】Flutter 学习文档

# 前言：如果你要学习 flutter，那么你一定要会 dart 语言，因为 flutter 是基于 dart 来封装的一个 UI 组件包

# 本文使用 Typort 书写，禁止转载。

# 学习基础要求：

# 后端：有语言基础（C/C++/C#/Java/python/Golang 都可以）

# 前端 ：(JavaScript，Html，CSS) 的人来学习。如果 0 基础，请先学习任意一门后端语言并熟练掌握！

# Dart 语言学习：

​ 安装 Dart：https://github.com/GeKorm/dart-windows/releases/download/v1.6.0/Dart_x64.stable.setup.exe

​ 安装好后配置环境变量：DART_HOME E:\dart\bin 安装路径

​ 配置好后 cmd 输入 dart --version 查看环境

1

Dart VM version: 2.3.3-dev.0.0.flutter-b37aa3b036 (Tue Jun 11 13:00:50 2019 +0000) on "windows_x64"

# 注释：

1
2
3
4
5
6
7
8
9
10

/*
 *多行注释
 *多行注释
 */
 
 /**
  * 文档注释 与Java相同
  */
  
 ///文档注释 dart独有

# 变量定义：

dart 语言特点：

​ 自动类型转换，var 声明的变量可以是任意类型！

dart 拥有两种变量定义方式。

指定类型：

String name = “brath”;

或者

类型推导

var name = “brath”; // 推导为任意类型

final name = “brath”; // 不可修改，定义常量，可以初始化

const name = “brath”; // 不可修改，定义常量，不可以初始化，可以被构造修改

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

void main(){
  var name = 111111;
  String name1 = "brath用类型定义";
  print("Hello World! Brath~");
  print(name.runtimeType);
  print(name1.runtimeType);
} 

console:
Hello World! Brath~
int
String

# 变量拼接：

与 Java 不同，拼接方式用 ${}

如果只拼接普通变量，可以直接 $ 变量名

如果拼接变量引用方法，必须要 $

# 集合类型：

list 集合： var names = [“111”,“222”,“333”];

set 集合: var movies = {“111”,“222”,"333”};

map 集合：var info =

默认情况下，dart 的所有 class 都是隐式接口！

# Dart 函数使用：

1
2
3
4
5
6
7
8

void main(List<String> args) {
    print(sum(51, 14891));
}


int sum(int a,int b){
  return a + b;
}

# 函数参数：

必选参数，不能有默认值，可选参数，可以有默认值

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

main(){
    sayHello("why");
}

//必选参数：String name 必须传参
void sayHello(String name){
    print(name)
}

//可选参数：位置可选参数 
void sayHello2(String name, [int age, String desc]){
    sayHello2("brath",12,"waa");
    //位置可选参数：用[]包围的参数可传可不传，但是位置必须对应
}

//可选参数：命名可选参数 重点，多用！
void sayHello3(String name, {int age, String desc}){
    sayHello3("brath",age: 13,desc: "212");
    //位置可选参数：用{}包围的参数可传可不传，但是必须指定参数名
}

# 函数是一等公民:

函数可以作为另外一个函数的参数！

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

void main(List<String> args) {
  // test(see);

  //匿名函数
  // test((){
  //   print("匿名");
  //   return 10;
  // });

  test(() => print("箭头"));
}

void test(Function foo){
    see();

}

void see(){
  print("see！");
}

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

void main(List<String> args) {

    // test((num1,num2){
    //   return num1+num2;
    // });
  
  var num = demo();
  print(num(20,12));
}

//将函数声明式显示，利用 typedef 声明一个函数列表，调用 typedef 声明的函数
typedef Calculate = int Function(int num1,int num2);

void test(Calculate calculate){
  calculate(20,30);
}
// void test(int foo(int num1,int num2)){
//   foo(20,30);
// }

Calculate demo(){
  return (num1,num2){
    return num1 * num2;
  };
}