A New Stickerbox Experience — The Best AI-Integrated Hardware Product I’ve Seen Recently

Thu, 01 Jan 2026 00:00:00 +0000

Preface

This is the official website: https://stickerbox.com. It’s a kids product that combines AI image generation and printing, mainly targeting the children’s market. The logic is pretty simple: you can input a text prompt via voice or the app, generate an image, and then print it directly as a sticker.

AI is on fire right now—both software and hardware products are popping up nonstop. I recently saw this super interesting AI hardware product on Instagram, and I honestly think it’s one of the best AIGC + product combinations I’ve seen lately. I’m genuinely surprised the founder came up with this angle and nailed the kids segment so precisely—kids naturally love drawing and stickers.

When I checked the official site, it said new orders wouldn’t ship until February. But I got lucky: I saw it early, and the site shipped on 12/23 (even though I ordered in November). Really looking forward to it.

Official promo image — looks pretty fun

Order details

Unboxing

When the package arrived, I noticed the box was quite small—not bulky at all.

Outer packaging

After opening it, the overall build quality felt pretty nice. A pleasant surprise: there was a signed card inside. I even touched it on purpose—you can tell it’s actually handwritten, not something mass-printed. Little details like this feel genuinely sincere.

Everything in the box

Hand-signed card

The device itself comes with three rolls of printing paper, plus a small box of crayons so kids can color the black-and-white stickers after printing. The device is super light in hand—kids shouldn’t have any trouble holding or carrying it.

Three included paper rolls

The device itself — compact and lightweight

Included mini crayons

Connection & Setup

Before using it, you need to download a dedicated app for connection and setup.

App download guide

After powering on, you need to connect to Wi‑Fi and bind the device. The screen brightness is pretty good and the display looks clear.

Wi‑Fi connection screen

Device binding flow

Binding successful — screen quality is decent

User Experience

When installing the paper, I did something a bit dumb. After opening the compartment, I saw a black roller bar in the back. Out of habit, I assumed it was the kind of printer that needs a ribbon or carbon film, so I fed the paper in facing that black strip… and it just wouldn’t print no matter what.

Then it hit me: this is a thermal printer! That strip is simply for gripping and feeding the paper. Thermal paper changes color when heated. Once I corrected the direction, everything worked fine. Paper loading is actually pretty convenient.

Internal structure — classic thermal printer design

In real use, the responsiveness is way faster than I expected. Both AI image generation and printing feel very smooth.

For voice input, it supports Chinese, which is a big plus. The downside is that the device’s built-in small screen doesn’t handle Chinese well—it doesn’t support UTF-8, so Chinese prompts show up as garbled “tofu blocks.” But the mobile app displays Chinese prompts normally. Also, since the servers are overseas, I’m not sure how the direct connection speed is from within mainland China, or whether network latency becomes an issue.

Printed result — the detail is pretty solid

Closing Thoughts

This is honestly a naturally great application.

For AIGC-generated images, there’s still a gap before they can truly match professional Figma design drafts or commercial creative posters. Most of the time, they’re more of an assistive tool, and you still need professional designers involved.

But for kids, AI-generated images are already more than fun enough! Kids aren’t chasing pixel-perfect design. As long as it’s interesting and can turn what’s in their head into a real, visible sticker, that’s enough. Stickerbox nails this point perfectly.

I think the software-hardware integration is done really well, and the price isn’t bad either: $99, including the printer and three boxes of paper. Refills cost $9.99 per box (50 stickers). The idea is genuinely great.

But then again, the real masters of thermal printers are still China. Thermal printing has already penetrated every corner in China: shipping labels, supermarket receipts, restaurant receipts, delivery receipts, and so on. The cost of thermal printers has been pushed extremely low—you can buy a decent one for just a few dozen RMB. And China has tons of thermal paper manufacturers that can customize paper in all kinds of sizes.

If you built this domestically, the hardware cost might be covered with just 50 RMB. China really doesn’t lack technology, and the supply chain is insanely mature. What’s truly missing is this kind of creativity—perfectly matching technology with a real-world scenario.

Stickerbox新体验-近期觉得AI结合最好的硬件产品

Thu, 01 Jan 2026 00:00:00 +0000

前言

这是官网 https://stickerbox.com，这是一款结合了 AI 绘图和打印的儿童产品，主要面向儿童市场。它的逻辑很简单：可以通过语音或者 APP 输入文字描述，然后生成图片，最后直接打印出来成为贴纸。

AI 现在很火，不管是软件产品还是硬件产品层出不穷。最近在 Ins 上看到这个非常有意思的 AI 硬件产品，我觉得这是近期与 AIGC 结合最好的产品了。我很惊讶于为什么 Founder 可以想到这个结合点，精准地抓住了儿童领域——孩子们天生喜欢画画和贴纸。

我在官网看的时候发现现在下单要等到 2 月份才能发货，不过我运气不错，看到的时候很早，官网 12. 23 号就发货了(虽然我也是 11 月下单的)，非常期待。

官网的宣传图，看起来很有趣

订单详情

开箱

收到快递的时候，发现盒子还挺小的，并不笨重。

外包装盒子

打开包装，整体质感还是挺不错的。比较惊喜的是里面还有一张卡片带有签名，我特意摸了一下，确实是手写签名的痕迹，而不是批量印上去的，这种小细节让人感觉很有诚意。

开箱全家福

手写签名卡片

机器本身自带了三卷打印纸，还送了一盒小蜡笔，方便小朋友在打印出来的黑白贴纸上涂色。机器拿在手里非常轻，对于小朋友来说拿取应该没有任何负担。

自带的三卷纸

机器本体，很轻巧

附赠的小蜡笔

连接与设置

使用前需要下载一个专门的 App 进行连接和设置。

App下载引导

开机后需要链接 WiFi 并绑定设备。屏幕亮度还挺不错的，显示很清晰。

连接WiFi界面

设备绑定流程

绑定成功，屏幕素质还可以

使用体验

在安装打印纸的时候我稍微犯了个蠢。打开仓盖看到后面有一个黑色的滚条，我之前惯性思维以为是那种需要色带或者碳板的打印原理，把纸面对着这个黑色小条卡进去，结果死活打不出来。

后来才反应过来，这是热敏打印机啊！ 那个小条单纯就是用来卡纸和传输纸张的，热敏纸本身受热就能变色。调整好方向后就一切正常了，卡纸过程其实挺方便的。

内部结构，经典的热敏打印机构造

实际体验下来，响应速度比我想象中的快很多。不管是 AI 出图的速度还是打印的速度，都非常流畅。

在语音输入上，它是支持中文的，这点好评。但是美中不足的是，机器自带的小屏幕对中文显示支持不好，不支持 UTF-8 字符集，中文描述内容在屏幕上会乱码变成“豆腐块”。不过手机 App 端是可以正常显示中文描述内容的。另外因为服务器在海外，不知道在中国国内直连的速度怎么样，是否有网络延迟的问题。

打印出来的效果，精度还不错

后言

这其实是一个天然的好应用产品。

对于 AIGC 生成的图片来说，目前离真正专业的 Figma 设计稿或者商业创意海报还有距离，更多时候只能作为辅助工具，还是需要专业设计师介入。

但是对于儿童来说，AI 生成的图片已经足够好玩了！ 儿童本身并不追求 pixel-perfect 的设计感，只要有趣、能把脑子里的想法变成看得见的贴纸就行了。Stickerbox 这个产品就是精准地抓住了这个点。

我觉得软硬件结合得很好，而且价格也不算贵，99 美金，包含打印机和三盒纸。后续的耗材纸张是 9.99 美金一盒（50 张贴纸）。这个创意非常好。

不过转念一想，玩转热敏打印机最厉害的还得是中国。热敏技术在中国已经渗透到各个领域了：快递单、超市小票、餐厅小票、外卖小票等等。热敏打印机的成本也被压得非常低廉，几十块钱就能买到一个不错的热敏打印机了。而且中国有非常多的热敏打印纸厂家，可以提供各种规格的纸张定制。

如果在国内做这个，可能硬件成本 50 元人民币 就能 cover 下来。中国真的不缺技术，供应链极其成熟，缺的真的是这种把技术和场景完美结合的创意。

Data automatic caching annotations

Sun, 15 May 2022 00:00:00 +0000

Preface

Background

This post will introduce a library I wrote myself, library address here, the main role is to provide an annotation, use this annotation in your method, the library provides functionality will help you automatically cache the data, the next time you call this method as long as the input parameter is the same as the direct will be from the cache! The next time you call the method, as long as the input parameter is the same, you will get the data directly from the cache, and you will not execute the method again (the content of the method may be to go to the DB or PRC).

The reason for writing this library is that there is a similar tool within the company , at first did not Get to it has much use , as in the company to contact more business needs , found that this is really too usefull . And I have some of my own more ideas about it , so I intend to write their own open source out on the one hand can be used for their other open source projects , on the other hand, I think there are the same needs of the people are quite a lot , and Github does not have a perfect similar libraries.

Different levels of volume of users of the code is really different, I also do in the last company is also the C end of the business, for the use of cache, although very much, but mainly the use of Redis data structure features to do some business implementation will be more, for example, using string to do mutual exclusion lock/configuration switches/status logging, using zset to do the list/realization of the needs of the dmq, list/set/hash to do high-performance short-term database. set/hash to do high performance short duration database. For a lot of DB data are directly check, the main product at that time the user volume is very smooth, took the financing of the time the company has money, the database with a very good, from the library is also a lot of online do not need to pressure test, No requirement for RTT of the interface.

But now the company, the C-terminal interface are done to limit the flow, in addition to paging data almost all the data to add a layer of cache, and even the first page of the paging data will be done. This is very troublesome, every time you have to write a lot of repetitive code, take the value from Redis, empty away on the DB/RPC, and then write back to Redis. the most horrible is the batch fetch value, from Redis to get after the hit after the batch out of the no hit and then go to DB/RPC fetch, and then write back to the value of this part of the Redis. because of the user volume is very large, and there is a wool party will brush the interface, the value of the no hit, may also need to do empty cache to prevent penetration to the DB. may also need to do empty cache to prevent penetration into the DB.

Contains

This repository contains the following:

@Cache annotation
Automatically cache the specified method
It can automatically cache non-existent data to prevent cache penetration under concurrency
Automatic mutex lock can be enabled when acquiring cache to prevent cache breakdown and protect DB

Functions similar to Spring-cache, I think this library is much better than Spring-cache, first of all Spring-cache does not support the key for each write to set a separate expiration time, which Gives me good reason not to use it; and then EL expression on the cost of getting started is also very high, but it implements the function of the function is very simple and senseless function, I think that this is the same as Spring’s own convention over configuration contrary to this library provides four types (described below) allows you to follow the convention to reduce the configuration, the simplest only need to provide prefix can be used. I think this and Spring’s own convention over configuration contrary to what this library provides four types (described below) allows you to follow the convention to reduce the configuration , the simplest only need to provide prefix can be used . Spring-cache also does not support the bulk query process to query only the incremental data , also does not support the empty cache , also does not support the anti-penetration …..

how-to-import

This library has been put on the maven central warehouse, only need to import the pom file of the project. Please note that version 1.x.x are testing version and cannot work properly

For all version queries click HERE HERE HERE

Maven

<!-- https://mvnrepository.com/artifact/cn.someget/cache-anno -->
<dependency>
    <groupId>cn.someget</groupId>
    <artifactId>cache-anno</artifactId>
    <version>2.0.0</version>
</dependency>

Gradle

// https://mvnrepository.com/artifact/cn.someget/cache-anno
implementation group: 'cn.someget', name: 'cache-anno', version: '2.0.0'

There is no configure need to for this library, all beans are exposed through spring.factories and can be directly scanned by the startup class.

How-to-use

Notes

This library relies on spring’s auto-assembled redis or manually assembled redisTemplate, and the configuration supports jedis and lettuce.
The data stored using this annotation is serialized as String, and of course, the automatic read data deserialization of annotations is also String. If you use annotations to store data, but do not use annotations to read data, please use String deserialization to read.
All redis io exceptions have been captured, and the exceptions will be printed to the log, which will not pollute the business code, will not affect your data reading, and will eventually read data from the db

Usage

1. Getting Started and Principles

	// It is recommended to define the prefix as a constant for easy reuse. One to one does not need to pass the clazz parameter
	@Cache(prefix = "user:info:%d")
    public UserInfoBO getIpUserInfo(Long uid) {
        UserInfo userInfo = userInfoMapper.selectByUid(uid);
        if (userInfo == null) {
            return null;
        }
        UserInfoBO bo = new UserInfoBO();
        BeanUtils.copyProperties(userInfo, bo);
        return bo;
    }

If the above method is not annotated with @Cache, it is a simple method to query user information from the user table via uid, but it is still such a simple method after adding @Cache.
Before the query, the parameter uid will be spliced according to the prefix in the annotation, and then try to get data from Redis.
If the execution function does not hit the cache, it will be automatically written to the cache after the execution is completed.
The next time this function is executed, the prefix splicing parameter will be executed and the data will be tried to obtain from Redis. Because it was written automatically last time, the data will be returned directly, and the function will not be executed again.

2. advanced comprehension

	// The return value is a collection type, clazz must be passed
	@Cache(prefix = "mall:item:%d", clazz = MallItemsBO.class)
    public Map<Long, MallItemsBO> listItems(List<Long> itemsIds) {
        BaseResult<List<MallItemsDTO>> result = itemsRemoteClient.listItems(new ItemsReqDTO());
        if (result == null || CollectionUtils.isEmpty(result.getData())) {
            return Collections.emptyMap();
        }
        return result.getData().stream()
                .map(mallItemsDTO -> {
                    MallItemsBO mallItemsBO = new MallItemsBO();
                    BeanUtils.copyProperties(mallItemsDTO, mallItemsBO);
                    return mallItemsBO;
                }).collect(Collectors.toMap(MallItemsBO::getItemId, Function.identity()));
    }

The method is not annotated with @Cache. It is a function to remotely obtain item details from other services in batches through itemId.
When @Cache is added, it is still the original method. Before the query, all itemIds in the parameters and the prefix in the annotation will be spliced together, and then the results will be obtained from redis at one time. If all itemIds are obtained, they will be returned directly. If there is an itemId that is not hit, the missed itemId will be unified and used for remote fetching. Finally, the summary in Redis (the remote fetching will be automatically written to the cache)

3. Supported method types

type	prefix	input	output	remark
one to one	custom: placeholder	wrapper type or String	? extends Object	The number of input parameters is equal to the number of placeholders
ont to list	custom: placeholder	wrapper type or String	List<? extends Object>	The same as above, in theory, List and object are same thing for this library, because I use String serialization
list to map_one	custom: placeholder	List	Map<Input wrapper type or String, ? extends Object>	If it is a batch query, the first input parameter must be the corresponding query List. Each element in the list will be spliced with the prefix, so the placeholder of the prefix is the placeholder corresponding to the element in the list.
list to map_map	custom: placeholder	List	Map<Input wrapper type or String, List<? extends Object»	This type is actually the same as above. Each element in the type List corresponds to an object. Each element of this type List corresponds to a list. I deserialize the same. Due to the limitation of java’s generic erasure, it is impossible to determine what the value generic of Map is. Please set the parameter hasMoreValue in @Cache to true

Placeholders should be noted that the string type requires the placeholder is %s, the integer placeholder is %d, and the floating-point placeholder is %f Please refer to here for details

The summary is divided into two categories. The input parameter is an object or a List, that is, a single acquisition and a batch acquisition. If it is a batch acquisition, remember that the List must be No. 1, and the method input parameters cannot exceed two, otherwise the unsupported method will be thrown. abnormal.

4. The meaning of the parameters in the annotation

name	meaning	remarks
prefix	The prefix of the key in Redis	To use a placeholder, if the input parameter is long, the placeholder is prefixKey:%d
expire	Expiration time (in seconds)	If you do not set the expiration time when using annotations, the default is 10 minutes. Note that the expiration time is enabled by default in the write cache of this library.
missExpire	Empty cache expiration time (in seconds)	If it is 0, it means that the empty cache is not enabled (the default is 0). The expiration time of the empty cache means that if the result is not found from the db, an empty cache will be generated to Redis. The expiration time of this empty cache (the normal cache must be short, recommended 3- 10 seconds)
hasMoreValue	Whether list to map_map type	Due to the limitation of generic erasure in java, it is impossible to determine what the value generic of Map is. Please set the parameter hasMoreValue in @Cache to true
clazz	Collection class return value corresponding type	If the return value is List or Map, this must be passed, because java generic erasure leads to inability to perceive the generic type of the collection, and deserialization needs to be used. If it is a one to one type, this can be omitted.
usingLocalCache	Whether to use local cache	After setting true, the local cache (using caffeine) will be queried before reading from Redis. Similarly, the data will be written back to caffeine after taking it.

5. Detailed description of other functions

Enable empty cache writes

@Cache contains the attribute missExpire. The meaning of the attribute is the expiration time of the value that does not exist in the DB (in seconds). The default value is 0. If it is 0, it means that if the value of the query does not exist in the DB, no empty cache processing will be performed. If it is not 0, then the query value from Redis will not be hit, and the method query will be performed. If the method query returns no result, a null value will be stored (if it is an object, it is "{\"id\":-1}" , if it is a collection, it is []), the expiration time is the value of missExpire (recommended 3-10 seconds), and all types in the table are supported.

Note：

After the empty cache is enabled, the cache processing needs to be deleted after inserting records, because the corresponding value may already exist in the DB, but there is still an empty value in Redis that is in the TTL.
If the empty cache is an object, it will cache an object with an id of -1. If it is a collection, an empty collection will be cached. An object with an id of -1 will not be returned to the method caller and will be filtered out directly, which is in line with your coding habits. It should be noted that the cache object must have an id field (both Integer and Long), otherwise it cannot be filtered, which will return an empty object with all properties null. Version 2.0.1 or later supports setting the object empty cache to "{}", so it does not have to contain an id. The caller of the method that hits the empty cache will get null, which is in line with everyone’s coding habits. All empty cache objects must be constructed without parameters, otherwise deserialization cannot generate empty objects.

enable local cache

@Cache contains the attribute usingLocalCache, which means enable local cache or not, In e-commerce marketing, commodity data is frequently obtained through RPC, because the QPS of the marketing scenario is very high. Even if there is Redis before RPC, the frequent acquisition of commodities leads to a very high QPS of Redis. The product data does not change very much, so it is necessary to add a local cache before redis, which will reduce the qps of redis

There are many scenarios where using local cache will reduce qps. This library supports local caching. Just use the annotation to set the attribute of usingLocalCache to true (default is false). The local cache used by this library is caffeine, which has recently overwhelmed Guava. , so that the local cache is queried before getting the data, and if the local cache does not hit, then Redis is queried.

Note: Multi-layer caching will increase the possibility of Cache-DB inconsistency. Here, the default TTL of the local cache is 3 seconds, and modification is not supported for the time being.

Post-word

next-steps

Improve unit testing, welcome everyone to pr
There are already good solutions to prevent cache breakdown, and the next version will merge
Evicting the cache using annotations

Your joining is very welcome! New Issue or Pull Request.

用无感知的方式为你的数据加上一层缓存

Sun, 15 May 2022 00:00:00 +0000

前言

背景

本篇文章会介绍一个我自己写的库，库地址在这里，主要作用是提供一个注解，在你方法上使用这个注解，库提供的功能会帮你把数据自动缓存起来，下次再调用这个方法只要入参是一致的则直接会从缓存里面拿数据，不会再执行方法了(方法里面的内容可能是走DB或者PRC)。

写这个库的原因是公司内部有一个类似工具，刚开始并没有Get到它有多大的用处，随着在公司接触更多的业务需求，发现这真的是太香了。并且我对它有一些自己的更多想法，所以打算自己写一个开源出来一方面是可以给自己其他开源项目使用，另外一方面我觉得有相同需求的人还蛮多的，而Github上也没有一个尽善尽美的类似库。

不同量级用户的代码真的是不一样，我在原来公司也做的也是C端的业务，对于缓存运用虽然非常多，但是主要是利用Redis数据结构特点来做一些业务上的实现会更多一些，例如用string来做互斥锁/配置开关/状态记录，用zset来做榜单/实现dmq需求，用list/set/hash来做高性能短时数据库。对于很多DB的数据都是直接查，主要当时的产品用户量非常平稳，拿了融资的那段时间公司有钱，数据库用的非常好，从库也多，上线不需要压测，随便点点RTT自己觉得过得去就行，所以我觉得偶尔写一下读写redis的代码也没啥用工作量。

但是现在的公司，C端接口都做限流，除了分页数据几乎所有数据都加一层缓存，甚至分页数据的第一页都会做。这就很麻烦，每次都要写一大堆重复代码，从Redis取值，空走就DB/RPC，然后回写Redis。最可怕的是批量取值，从Redis去拿完以后还要把没有命中的筛选出来然后去DB/RPC取，然后回写这部分值到Redis。因为用户量很大，还有羊毛党会刷接口，未命中的值可能还需要做空缓存防止穿透到DB。

内容

本仓库包含以下内容：

@Cache注解一个
对指定方法进行自动缓存(Redis或者caffeine本地缓存)
可对不存在的数据进行自动空缓存，并发下防止缓存穿透
可开启获取缓存时自动进行互斥锁，防止缓存击穿保护DB(下个版本更新)

功能类似Spring-cache，但是我普信男一次，我觉得本库比Springcache的好用很多，首先Spring-cache的不支持给每次写入的key单独设置过期时间，这个已经劝退我了；然后EL表达式上手成本也很高，但是它实现的功能是很简单的无感功能，我觉得这和Spring本身的约定大于配置相违背，相反呢本库提供四种类型(下面介绍)让你遵循约定减少配置，最简单只需要提供prefix就可以使用。Spring-cache也不支持批量查询过程中只查询增量数据，也不支持空缓存，也不支持防击穿…..

安装导入

本库已经上架maven中央仓库，已经引入到自己项目pom文件中就行，请注意直接在mvnrepository会出现很多2.0.0以下的版本，请不要使用，那…那…是我上架的是做测试不小心发到release上的debug版本。

所有版本查询请点击这里 这里这里

Maven

<!-- https://mvnrepository.com/artifact/cn.someget/cache-anno -->
<dependency>
    <groupId>cn.someget</groupId>
    <artifactId>cache-anno</artifactId>
    <version>2.0.0</version>
</dependency>

Gradle

// https://mvnrepository.com/artifact/cn.someget/cache-anno
implementation group: 'cn.someget', name: 'cache-anno', version: '2.0.0'

导入jar包就好了，除此之外无需为本库做任何配置，所有bean也已经spring.factories暴露出来，可以直接被启动类扫描到。

使用说明

一. 注意事项

导入本库后配置中必须要有redis相关的配置，支持jedis和lettuce，只要spring自动装配或者你手动装配一个redisTemplate就行(注意如果你有多个RedisTemplate<String, String>你需要给其中一个指定@Primary)，不然无法使用本库。
使用注解存入的数据，序列化方式均为String，当然注解自动读数据反序列化也是String，所以如果你有使用注解存入数据，但是不适用注解读取数据的需求，请使用String反序列化读取。
所有redis的io异常都已经捕获，有异常只会打日志，不会影响你的业务，不会影响你的数据读取，兜底会走db查询。

二. 使用方法

查询一个数据，例如下面，通过uid查询用户的详细数据，加上@Cache(注意不要导错包哈)注解，prefix是你缓存数据Redis的Key前缀，注意需要加一个占位符，我自动写入的时候会把入参拼接到这个prefix上。查询之前会根据注解中的prefix拼接上入参uid从Redis中尝试获取数据，如果没有数据则执行方法，执行完方法再自动写入缓存。那么下次在执行这个方法的时候，又会执行上面步骤prefix拼接入参尝试从Redis获取数据，但是因为上次自动写入了，所以拿到数据就直接返回了，不会再执行方法走DB查询了。

// 建议prefix定义成常量，便于复用, one to one可以不用传clazz参数
@Cache(prefix = "user:info:%d")
public UserInfoBO getIpUserInfo(Long uid) {
    UserInfo userInfo = userInfoMapper.selectByUid(uid);
    if (userInfo == null) {
     	 return null;
    }
    UserInfoBO bo = new UserInfoBO();
    BeanUtils.copyProperties(userInfo, bo);
    return bo;
}

查询多个数据，例如下面，通过一堆itemId获取多个item的详细数据，和上面一样你需要指定prefix，查询之前会通过把入参所有的itemId进行和注解里面的prefix拼接，然后批量一次性尝试从redis里面获取，如果所有itemId都获取到则直接返回，但是如果有未命中的itemId则会把这未命中的itemId再统一走方法进行远程获取最后和Redis里面的汇总(远程获取完会自动写入Redis,方便你下次命中)

// 返回值是集合类型，clazz必须要传
@Cache(prefix = "mall:item:%d", clazz = MallItemsBO.class)
public Map<Long, MallItemsBO> listItems(List<Long> itemsIds) {
    BaseResult<List<MallItemsDTO>> result = itemsRemoteClient.listItems(new ItemsReqDTO());
    if (result == null || CollectionUtils.isEmpty(result.getData())) {
     	 return Collections.emptyMap();
    }
    return result.getData().stream()
      .map(mallItemsDTO -> {
       	 MallItemsBO mallItemsBO = new MallItemsBO();
       	 BeanUtils.copyProperties(mallItemsDTO, mallItemsBO);
       	 return mallItemsBO;
      }).collect(Collectors.toMap(MallItemsBO::getItemId, Function.identity()));
}

三. 实现原理

核心原理是利用AOP对你为注解设置的参数和入参进行拼接成一个key，每次在方法执行前走缓存去查询一遍，如果缓存有数据则直接返回不再执行方法，如果缓存没有查数据，则执行方法拿到数据取写入缓存。

单个数据获取

如果是数据批量获取，还会看Redis命中的数量来判断是全部返回，还是把未命中的去执行方法，最后把缓存和方法查询结果一起汇总返回给方法调用方

多个数据获取

四. 所有支持的方法类型

类型	prefix	入参	出参	备注
one to one	自定义:占位符	包装类型或者String	? extends Object	有几个入参就要有几个占位符，不然无法使用
ont to list	自定义:占位符	包装类型或者String	List<? extends Object>	同上，理论上来说List和object对于本库是一个东西，因为我是用的是String的序列化，相同理解就好。
list to map_one	自定义:占位符	List<包装类型或者String>	Map<对应入参包装类型或者String, ? extends Object>	如果是批量查询，第一个入参一定要是对应的查询List。list里面的每一个元素都会与prefix拼接，所以prefix的占位符是List里面的元素对应的占位符。
list to map_map	自定义:占位符	List<包装类型或者String>	Map<对应入参包装类型或者String, List<? extends Object»	本类型其实也同上，上类型List中每一个元素对应的是一个对象，这个类型List每个元素对应的是一个list，我反序列化都是以一样的，所以本质一样。因为java的泛型擦除的限制我无法判断Map的value泛型具体是什么，请@Cache中的参数hasMoreValue需要设置成true，请切记

其中占位符要注意，如果是String占位符要%s，整型占位符%d，浮点型占位符%f 详情请参考这里

其实总的来说就是分为两类，入参是对象或者List，也就是单个获取和批量获取，如果是批量获取的话切记List要在一号位，并且方法入参不能超过两个，否则会报错提示不支持。

五. 注解里面的参数含义

名称	含义	备注
prefix	Redis中key的前缀,	注意要使用占位符，如入参是long, 占位符就是prefixKey:%d
expire	过期时间(单位秒)	如果使用注解的时候不设置则默认10分钟，注意本库写入缓存都有过期时间，因为我想不到你为啥要不设置TTL
missExpire	空缓存过期时间(单位秒)	如果是0则表示不开启空缓存(默认是0)，空缓存过期时间表示如果从db也没查到生成空缓存到Redis，这个空缓存的过期时间(肯定正常缓存短，推荐3-10秒)
hasMoreValue	是否list to map_map类型	因为java的泛型擦除的限制我无法判断Map的value泛型具体是什么，请@Cache中的参数hasMoreValue需要设置成true，请切记
clazz	集合类返回值对应类型	如果返回值是List或者Map，这个必传，因为java泛型擦除我不知道你集合泛型，反序列化需要使用。如果是one to one类型的话，这个可以省略。
usingLocalCache	是否使用本地缓存	设置true以后从Redis读取之前会查询一遍本地缓存(使用caffeine)，同理拿完数据也会回写到caffeine

六. 其他功能详细说明

启用空缓存写入

@Cache含有missExpire的属性，属性含义是DB中不存在的值的过期时间(单位是秒)，默认值是0，如果是0则表示如果查询的值DB中不存在的话，不进行空缓存处理。如果是非0，那么从Redis中查询值未命中会走方法查询，方法查询返回结果也是不存在那么会储存一个空值(如果是对象的是"{}"，如果是集合则是[])，过期时间是missExpire这个值(推荐3-10秒左右)，支持上述表格中的所有类型。

注意：

开启空缓存以后插入记录后也要进行删除缓存处理，因为可能对应值DB中已经有了，但是Redis还存在空值正处于TTL中。
空缓存如果是对象是会缓存id为-1的对象，如果是集合会缓存一个空集合，id为-1的对象不会返回给方法调用方，会直接被过滤掉，符合大家编码习惯。要注意的是缓存对象必须要有id字段(Integer和Long都可以)，否则无法过滤会返回的一个所有属性都是null的空对象。2.0.1版已经支持设置对象空缓存为"{}"所以不用必须含有id字段了，如果命中空缓存方法调用方拿到的是null，符合大家编码习惯，但是所有空缓存对象一定要有无参构造，否则反序列化无法生成空对象。

启用本地缓存

@Cache含有usingLocalCache的属性，属性含义是是否启用本地缓存，在一些场景下电商营销域要频繁通过RPC获取商品域的商品数据，因为营销场景QPS非常高，即便在RPC之前有一层Redis，但是频繁获取商品导致Redis的QPS非常高。而商品数据是不怎么变化的，所以在Redis之前再加一层本地缓存就显得非常有必要，Redis的QPS能降低不少。

有不少场景进行本地缓存提升都非常大，本库也支持进行本地缓存，只需使用注解是把usingLocalCache的属性设置为true(默认是false)，本库使用的本地缓存是最近风头压过guava的caffeine，这样获取数据之前先从本地缓存进行查询，如果本地缓存没有命中则再去查询Redis。

注意：多层缓存会增加Cache-DB不一致可能，一定程度抗流可以用，但是不要过分依赖，这里本地缓存默认TTL是3秒，暂时不支持修改。

后言

下一步计划是

写好单元测试，这个库我还会写一篇文章，基于单测的code更加直观来介绍它是怎么的好用。
防止缓存击穿已经有好的方案，下一个版本会迭代进去，对于高风险接口可以开启。
目前没有配套的缓存逐出注解，这个我想一下怎么做到最好

如果你感兴趣或者有相同的需求欢迎使用本库，更加提一个 Issue 或者提交一个 Pull Request。

Transaction Isolation Levels in Databases

Sat, 25 Dec 2021 00:00:00 +0000

Preface

Transaction isolation levels used to be one of those “must-memorize interview boilerplate” topics back when I was looking for internships and jobs. At the time I could recite them, but I didn’t really understand what they meant or how they were implemented. As I got deeper into engineering practice and accumulated more experience using databases, I started to see transaction isolation levels differently. Recently I’ve been asked about them a lot again, so I deliberately went back and reviewed Ding Qi’s MySQL 45 Lectures in Practice, and decided to summarize it once.

Everyone knows the ACID properties of transactions. In order to ensure these properties—especially isolation and consistency—databases generally rely on locking. Locks in databases exist to build these isolation levels. This post only introduces transaction isolation levels; the next post will analyze how MySQL’s InnoDB engine implements them.

Database Isolation Levels

Let’s start with a table. Note: this is the isolation-level definition from textbooks. Different database implementations may vary—for example, MySQL’s InnoDB prevents phantom reads under Repeatable Read.

Isolation Level	Dirty Read	Non-repeatable Read	Phantom Read
Read Uncommitted	Possible	Possible	Possible
Read Committed	Impossible	Possible	Possible
Repeatable Read	Impossible	Impossible	Possible (but impossible in MySQL InnoDB)
Serializable	Impossible	Impossible	Impossible

Read Uncommitted → dirty reads: Two transactions start at the same time. Transaction A can read changes made by transaction B that are not committed. That’s a dirty read. You don’t really need to memorize what a dirty read is—the name “Read Uncommitted” basically is dirty read, because it breaks isolation: two transactions should not affect each other directly.

Read Committed → non-repeatable reads: Two transactions start at the same time. Transaction A can read changes made by transaction B that are already committed. That’s a non-repeatable read. Same idea: you don’t need to force-memorize the definition—if you can read other transactions’ committed changes, isolation still isn’t guaranteed.

Repeatable Read → phantom reads: Two transactions start at the same time. Under this isolation level, changes made by transaction B (update existing rows and commit) won’t be visible to transaction A’s queries, meaning it can solve the non-repeatable read problem. But if transaction B inserts new rows and commits, transaction A may be able to query those newly inserted rows—this is a phantom read. The root cause is the locking mechanism. However, MySQL’s InnoDB can ensure those rows are not visible under Repeatable Read; we’ll discuss that in the next post.

Serializable → no issues due to serialized locking: Transactions execute serially. Each read needs to acquire a shared lock, and reads/writes block each other.

MySQL InnoDB defaults to REPEATABLE READ (RR below), while Alibaba Cloud RDS defaults to Read Committed (RC below). Next, let’s look at isolation levels through concrete SQL.

Demo

For the database client I’m using DataGrip (DG below). In DG, open two sessions and run begin in each to start two transactions.

The database is MySQL 8.0. The test table DDL is:

create table t_user
(
    id     bigint unsigned auto_increment
        primary key,
    name   varchar(255) default '' not null,
    gender tinyint      default 1  not null
);

Test data:

insert into t_user(name, gender) values ('zhangsan', 1);
insert into t_user(name, gender) values ('wangwu', 1);
insert into t_user(name, gender) values ('xiaohong', 0);
insert into t_user(name, gender) values ('xiaohua', 0);

Check the current session isolation level:

# 查看当前会话隔离级别 MySQL8.0+
select @@transaction_isolation;
# # 查看当前会话隔离级别 MySQL5.0+
select @@tx_isolation;

Set the current session isolation level:

# 设置当前会话的隔离级别
set session transaction isolation level read uncommitted;
set session transaction isolation level read committed;
set session transaction isolation level repeatable read;
set session transaction isolation level serializable;

Read Uncommitted

Set to Read Uncommitted

Both windows start a transaction with begin. Then transaction 1 queries the row where name='zhangsan' and sees gender is 1. Next, transaction 2 updates zhangsan’s gender to 0. Then transaction 1 queries name='zhangsan' again:

In transaction 1’s second query result, zhangsan’s gender is already the value modified by transaction 2. In other words, after transaction 2 modifies the data, transaction 1 can immediately perceive it—even though transaction 2 hasn’t committed yet. This is Read Uncommitted: reading data that other transactions haven’t committed.

Read Committed

Set to Read Committed

Both windows begin at the same time. Transaction 1 queries zhangsan and sees gender is 1. Then transaction 2 changes zhangsan’s gender to 0 but does not commit. Transaction 1 queries zhangsan again and still sees gender is 1. After that, transaction 2 commits. Finally, transaction 1 queries zhangsan again and finds gender has become 0:

Overall, isolation is a bit better than Read Uncommitted, but once another transaction commits, it can still break isolation—i.e., you still get non-repeatable reads.

Repeatable Read

Set to Repeatable Read

Let’s first verify whether Repeatable Read solves the non-repeatable read problem:

You can see that under RR, the non-repeatable read problem is solved. In database specifications, RR can still cause phantom reads, but in this InnoDB experiment, transaction 1’s select uses MVCC snapshot reads to read historical data, ensuring isolation.

Finally, let’s distinguish non-repeatable reads vs phantom reads. On the surface, phantom reads focus on insert, while non-repeatable reads focus on update and delete. Essentially, it’s about what data is locked at different isolation levels. Under Repeatable Read, after the first time a SQL statement reads data, those rows are locked so other transactions can’t modify them, enabling repeatable reads. But it can’t lock rows that don’t exist yet (i.e., inserts). So when transaction 1 previously read data (or even modified all existing data), transaction 2 can still insert new rows and commit. Then transaction 1 will suddenly find an extra row that didn’t exist before—this is a phantom read, and it can’t be avoided with row locks alone.

Serializable

I won’t demo Serializable, because it solves everything by serializing execution: reads use read locks, writes use write locks, and read/write locks are mutually exclusive. It effectively avoids phantom reads, non-repeatable reads, dirty reads, etc.—simple and brute-force.

Afterword

At their core, the four transaction isolation levels are about different degrees of isolation caused by different locking mechanisms. This post summarized what isolation levels exist and what problems each level can cause. Memorize the basics first—in the next post I’ll share how different isolation levels are achieved, and what locking mechanisms are used to solve dirty reads, non-repeatable reads, phantom reads, and so on.

数据库的事务隔离级别

Sat, 25 Dec 2021 00:00:00 +0000

前言

事务隔离级别原来实习找工作的时候是必背八股文了，当时只会背却没深刻理解里面的意思和具体实现，随着工程实践的深入，对数据库使用的积累，对事务隔离级别有不一样的认识。最近又常常被问到，然后特意去复习了一遍丁奇大大的《MySQL实战45讲》，就想着总结一遍。

大家都知道事务的ACID性质，数据库为了让事务能保证这些性质尤其是隔离性和一致性，一般都会采用加锁的方式来做到。数据库中的锁是为了构建这些隔离级别来存在的。本篇只介绍事务隔离级别，下一篇会分析MySQL中InnoDB引擎中事务隔离级别的实现。

数据库隔离级别

先上表格，要说明的是这是教材中数据库隔离级别，不同的数据库实现会有不一样，例如MySQL的innoDB就在可重复读的情况下防止了幻读。

隔离级别	脏读	不可重复读	幻读
读未提交(Read Uncommitted)	可能	可能	可能
读已提交(Read Committed)	不可能	可能	可能
可重复读(Repeated Read)	不可能	不可能	可能(若MySQL的InnoDB则不可能)
可串行化(Serializable)	不可能	不可能	不可能

读未提交-导致脏读：两个事务同时开启，事务a可以读到另外一个事务b的未提交的修改内容，这个其实就是脏读，不用特意去记脏读是什么，读未提交的名字其实就是脏读，因为它破坏了隔离性，两个事务直接应该是互不影响的。

读已提交-导致不可重复读：两个事务同时开启，事务a可以读到另外一个事务b的已提交的修改内容，这个其实就是不可重复读，也不用特意去记不可重复读是什么，读到其他事务已提交的内容也没有保证隔离性。

可重复读-导致幻读：两个事务同时开启，在这个隔离级别下事务b更改记录并且提交不会被事务a查询到，也就是说可以解决重复读问题。但是当事务b对数据进行插入新增数据并且提交，这条新数据会被事务a所查询到，这成为是幻读。具体原因是因为加锁机制导致的，但是MySQL的innoDB在可重复读的情况下可以可以保证不被查询到，下一篇会讨论。

串行化读-串行化加锁不存在任何问题：两个事务是串行执行的，每次读都需要获取标记的共享锁，读写相互都会堵塞。

MySQL的innoDB默认是REPEATABLE READ(下称RR)，阿里云的RDB默认是Read Committed(下称RC)，下面通过具体的sql来看事务隔离级别。

演示

数据库连接工具我是用的是DataGrip(下称DG)，在DG开两个会话分别开始begin表示开启两个事务。

数据库使用的MySQL8.0版本，测试的表DDL如下

create table t_user
(
    id     bigint unsigned auto_increment
        primary key,
    name   varchar(255) default '' not null,
    gender tinyint      default 1  not null
);

产生的测试数据如下

insert into t_user(name, gender) values ('zhangsan', 1);
insert into t_user(name, gender) values ('wangwu', 1);
insert into t_user(name, gender) values ('xiaohong', 0);
insert into t_user(name, gender) values ('xiaohua', 0);

查看当前会话隔离级别

# 查看当前会话隔离级别 MySQL8.0+
select @@transaction_isolation;
# # 查看当前会话隔离级别 MySQL5.0+
select @@tx_isolation;

设置当前会话隔离级别

# 设置当前会话的隔离级别
set session transaction isolation level read uncommitted;
set session transaction isolation level read committed;
set session transaction isolation level repeatable read;
set session transaction isolation level serializable;

读未提交

设置成读未提交

两个窗口的事务都开始begin，然后事务1先查询name='zhangsan'的数据，发现zhangsan的gender是1，然后事务2在更新zhagnsan的gender为0，然后事务1再查询name='zhangsan'的数据

最后的事务1中的第二次查询结果，zhangshan的gender是事务2修改以后的数据，也就是说事务2修改数据后，在事务1中查询可以立马感知到，哪怕是事务2都没有提交这个事务。这就是读未提交，也就是读到其他事务未提交的数据。

读已提交

设置成读已提交

两个窗口的事务同时begin，然后事务1先查询zhangsan发现gender是1，然后事务2对zhangsan的gender修改成0后不提交事务，然后事务1再次查询zhangsan的gender还是1，随后事务2对事务进行提交，最后事务1再次查询zhangsan的gender发现已经被修改成0了

总的来说隔离性比读未提交稍好一些，但是其他事务提交事务请求后依然会破坏隔离性，也就是没有达到不可重复读。

可重复度

设置成可重复度

我们先来验证这个可重复度是否解决了不可重复读的问题

可以看到RR的隔离级别下已经解决了不可重复读的问题，在数据库规范中RR隔离级别下其实还会导致幻读，但是实验中的InnoDB中事务1进行select会读取MVCC的快照读进行历史数据的读取，来保证隔离性。

最后做一个区分，不可重复读和幻读的区别。表面上的区别在于幻读的重点在insert，但不可重复读重点在于update和delete，本质上是隔离级别锁住的数据不同，在可重复读中，执行SQL第一次读取到数据后，就将这些数据加锁，其它事务无法修改这些数据，然后就可以进行重复读了。但是却无法锁住insert的数据，所以当事务1先前读取了数据，或者修改了全部数据，事务2还是可以insert数据提交，这时事务1就会发现莫名其妙多了一条之前没有的数据，这就是幻读，不能通过行锁来避免。

串行化

可串行化(Serializable)就不演示了，因为它通过串行来解决所有问题，读用读锁，写用写锁，读锁和写锁互斥，来有效的避免幻读、不可重复读、脏读等问题，简单粗暴。

后言

四种事务隔离级别本质就在于通过锁机制导致的隔离性不一样，这篇总结了有哪些隔离级别，不同隔离级别会导致哪些问题。先背好，下一篇将分享不同事务隔离级别是怎么做到的，脏读、不可重复读、幻读等问题是使用什么锁机制来解决。

MyBatis-Plus SQL Performance Analysis Log Output

Sat, 11 Dec 2021 00:00:00 +0000

Preface

In the last project I introduced Mybatis-Plus (the name is way too long, so I’ll call it MP from now on). I habitually enable the performance analysis plugin locally so I can print SQL info, but this time I couldn’t find the PerformanceInterceptor class. After checking MP’s release notes, I found that PerformanceInterceptor was actually removed in version 3.2. And our project is using 3.4.0.

Release notes on MP's GitHub

It also mentions using p6spy as a replacement. After some digging, I summarized three ways to print SQL logs, and I’m sharing them here.

The code for this project has been uploaded to GitHub, click here

Three approaches

Also! Also! Also! Printing SQL logs has a pretty big impact on performance, so never enable it in production. I usually turn it on when debugging locally—especially for cross-module calls in microservices, it’s insanely useful. You only need to set a breakpoint on the caller side; on the callee side you just print the SQL. If the data isn’t what you expect, check the SQL printed in the console, or paste it into DataGrip and run it.

Create a table in the DB for testing. Here I’m creating a t_user table under the test database, with the DDL below:

create table t_user
(
    id          int unsigned primary key auto_increment comment 'pk',
    username    varchar(255) not null default '' comment '用户名',
    password    varchar(100) not null default '123456' comment '用户密码',
    gender      char         not null default '0' comment '性别',
    phone       varchar(30)  not null default '' comment '手机',
    create_time datetime     not null default CURRENT_TIMESTAMP comment '创建时间'
) comment '用户表';

Import dependencies in advance 🔗

<dependency>
  	<groupId>mysql</groupId>
  	<artifactId>mysql-connector-java</artifactId>
  	<version>8.0.19</version>
</dependency>
<dependency>
  	<groupId>com.baomidou</groupId>
  	<artifactId>mybatis-plus-boot-starter</artifactId>
  	<!-- Just import any version for now -->
  	<version>3.1.2</version>
</dependency>

Then create a BO

@Data
@TableName("t_user")
public class TUser {

    /**
     * pk
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * Mock username
     */
    private String username;

    /**
     * Mock password, stored in plaintext for demo purposes
     */
    private String password;

    /**
     * Mock gender
     */
    private Integer gender;

    /**
     * Mock phone number
     */
    private String phone;

    /**
     * Created time
     */
    private LocalDateTime createTime;

}

Then write a Mapper

@Mapper
public interface TUserMapper extends BaseMapper<TUser> {
}

Finally, write a Test runner class

public class MybatisSqlLogTest {

    /**
     * Being lazy here—using the mapper to demonstrate how query logs look
     */
    @Resource
    private TUserMapper tUserMapper;

    @Test
    public void selectPrintLogTest() {
        LambdaQueryWrapper<TUser> query = new LambdaQueryWrapper<TUser>()
                .select(TUser::getId, TUser::getPhone, TUser::getGender)
                .eq(TUser::getGender, 0)
                .likeRight(TUser::getUsername, "小");
        TUser result = tUserMapper.selectOne(query);
        System.out.printf("The queried id is %s, phone is %s\n", result.getId(), result.getPhone());
    }
}

Enable MyBatis built-in log output (SQL + params)

This is a built-in MyBatis feature. Enabling it is super simple: just add the following line to your config file. Usually we have multiple config files, so I recommend enabling it only in dev—just add it to your dev config.

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

It starts with mybatis-plus because MP is compatible with MyBatis config. You can also change the top-level key to mybatis: and it will still work.

Finally, run the test class (the setup demo is above—scroll up and check it)

The downside is that the output isn’t a final executable SQL log; you need to assemble/convert the format yourself. The output looks like this:

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@16132f21] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1271323139 wrapping com.mysql.cj.jdbc.ConnectionImpl@4f59a516] will not be managed by Spring
==>  Preparing: SELECT id,phone,gender FROM t_user WHERE gender = ? AND username LIKE ? 
==> Parameters: 0(Integer), 小%(String)
<==    Columns: id, phone, gender
<==        Row: 1, 13333333333, 0
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@16132f21]

You need to take the two lines containing ==> and convert them using some plugin or third-party tool. For example, I use the mybatisLog tool inside uTools, and the converted result looks like this:

Third-party tool

This is “native”, but kind of annoying and not very intuitive. If the SQL is long and a single request session has lots of statements, it’s basically unreadable—might as well not look at it.

Use the plugin in MP versions below 3.2

Use the PerformanceInterceptor plugin provided by MP before 3.2. This is the approach I used the most before, and it’s the most convenient. The configuration is also very straightforward, and it’s easy to separate by environment.

Just like other MP plugins (e.g., pagination), you create a bean, set it up, and put it into the IoC container. When MP runs, it will use your bean to apply the plugin behavior.

First, make sure your MP version is below 3.2:

<dependency>
  	<groupId>com.baomidou</groupId>
  	<artifactId>mybatis-plus-boot-starter</artifactId>
  	<!-- Make sure the version is below 3.2 -->
  	<version>3.1.2</version>
</dependency>

Then create a config class and inject a PerformanceInterceptor bean:

@Configuration
public class MybatisPlusSqlLogConfig {


    /**
     * Print SQL, performance analysis interceptor
     * Since every SQL needs to be intercepted, there will be performance overhead
     * So it's recommended to enable it only in dev or test for debugging
     * If multiple environments -> @Profile({"dev", "test"})
     * @return PerformanceInterceptor bean
     */
    @Bean
    @Profile("mp")
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        // Enable formatting, similar to DataGrip's SQL beautification, looks nicer in console
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }
}

One thing worth noting: you can add @Profile("dev") after @Bean. As long as your dev config file is application-dev.yml, this bean will only be injected in the dev environment. So you don’t have to worry about performance impact in production. In my code I use mp as the profile for the plugin demo, so here it only takes effect under mp.

Finally, run the test class (the setup demo is above—scroll up and check it)

The result looks like this—very intuitive, and it’s also in red text:

 Time：22 ms - ID：cn.someget.mybatis.sqllog.mapper.TUserMapper.selectOne
Execute SQL：
    SELECT
        id,
        phone,
        gender 
    FROM
        t_user 
    WHERE
        gender = 0 
        AND username LIKE '小%'

查询到的id是1, 电话是13333333333

Eye-catching red text

It used to be super handy. Maybe the author thought the performance impact was too big, and to prevent misuse, they removed it in version 3.2….

Use p6spy in MP 3.2 and above

So now I know for sure this isn’t suitable for production, but I still want something convenient for local debugging. Besides downgrading MP, what else can I do? The author also recommends p6spy in the release notes.

P6Spy is an open-source framework that can intercept and modify data operation statements in your application. Its GitHub repo is here. It’s very powerful; here I’ll only cover the parts that meet the needs of SQL performance analysis and log output.

First, add the dependency. I’ll just pick a random version here—see all versions here.

<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.8.2</version>
</dependency>

Then in your config file, when configuring the datasource connection, change the driver class name and the URL:

# Configure MySQL connection info
spring:
  datasource:
#   driver-class-name: com.mysql.cj.jdbc.Driver  this was the original
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
#   url: jdbc:mysql://${mysql.host}  this was the original URL prefix
    url: jdbc:p6spy:mysql://${mysql.host}:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&useSSL=false
    username: root
    password: 123456

Finally, create a spy.properties file under resources and write some basic config:

# Output logs to console
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger

# Formatting (without it, it's a long unreadable line; this is a built-in formatter.
# You can also implement your own based on the source code and configure it here)
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger

# Remove JDBC URL prefix
useprefix=true

p.s. Note that p6spy only requires adding the dependency and configuring it—no code needed.

Finally, run the test class (the setup demo is above—scroll up and check it)

 Consume Time：10 ms 1639215721188
 Execute SQL：SELECT id,phone,gender FROM t_user WHERE gender = 0 AND username LIKE '小%'

查询到的id是1, 电话是13333333333

It looks pretty straightforward. But after skimming the source code, it seems there isn’t a built-in formatting config class. If you need formatting, you can implement your own by extending MessageFormattingStrategy and writing it similar to P6SpyLogger.

Afterword

For foundational components, when creating a project you usually pick a stable version to start with. After it goes to production and stabilizes, you typically lock the versions. I only noticed recently—when introducing MP into a new project—that the performance analysis plugin had been removed, so I’m writing this down as a reminder for anyone who also likes to enable SQL log output locally.

And yeah, using this for local debugging is genuinely awesome—just don’t turn it on in production.

Mybatis-Plus的Sql性能分析日志打印

Sat, 11 Dec 2021 00:00:00 +0000

前言

上次项目中引入Mybatis-Plus(名字时间太长了，后面简称MP)，我习惯性在本地开启性能分析插件方便打印sql的信息，但是这一次居然找不到PerformanceInterceptor这个类，后面查看MP的更新日志发现，居然在3.2版本移除了PerformanceInterceptor，我们项目中引入的是3.4.0版本。

MP的GIthub上release日志

其中提到建议使用p6spy替代，经过我一番研究我总结了三个打印sql日志的方法，特意来分享一下。

本项目代码已经上传至Github，点击这里

三种方法

另外！另外！另外！打印Sql日志对执行的性能影响还算挺大的，生产环境上可千万不要启用，我一般在本地Debug的时候开启，尤其是微服务的跨模块调用真的是太太太好用了，只需要调用方打断点，被调用方的话只需要把这个Sql打出来。如果数据不符合预期，则看一下控制台打印的Sql或者把Sql放到DataGrip里面跑一下看看。

在db里面创建一张方便测试的表，我这里是在test的数据库下创建一张t_user表附上DDL

create table t_user
(
    id          int unsigned primary key auto_increment comment 'pk',
    username    varchar(255) not null default '' comment '用户名',
    password    varchar(100) not null default '123456' comment '用户密码',
    gender      char         not null default '0' comment '性别',
    phone       varchar(30)  not null default '' comment '手机',
    create_time datetime     not null default CURRENT_TIMESTAMP comment '创建时间'
) comment '用户表';

提前导入🔗

<dependency>
  	<groupId>mysql</groupId>
  	<artifactId>mysql-connector-java</artifactId>
  	<version>8.0.19</version>
</dependency>
<dependency>
  	<groupId>com.baomidou</groupId>
  	<artifactId>mybatis-plus-boot-starter</artifactId>
  	<!-- 先随便导入一个版本 -->
  	<version>3.1.2</version>
</dependency>

然后创建一个BO

@Data
@TableName("t_user")
public class TUser {

    /**
     * pk
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 模拟用户名字
     */
    private String username;

    /**
     * 模拟用户密码, 方便演示 明文存储
     */
    private String password;

    /**
     * 模拟用户性别
     */
    private Integer gender;

    /**
     * 模拟用户手机
     */
    private String phone;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

}

然后写一个Mapper

@Mapper
public interface TUserMapper extends BaseMapper<TUser> {
}

最后写一个Test执行类

public class MybatisSqlLogTest {

    /**
     * 偷懒, 用mapper来演示查询日志展示效果
     */
    @Resource
    private TUserMapper tUserMapper;

    @Test
    public void selectPrintLogTest() {
        LambdaQueryWrapper<TUser> query = new LambdaQueryWrapper<TUser>()
                .select(TUser::getId, TUser::getPhone, TUser::getGender)
                .eq(TUser::getGender, 0)
                .likeRight(TUser::getUsername, "小");
        TUser result = tUserMapper.selectOne(query);
        System.out.printf("查询到的id是%s, 电话是%s\n", result.getId(), result.getPhone());
    }
}

开启Mybatis的日志拼接功能

这个是mybatis就自带的功能，开启方法也非常简单，只需要在你的配置文件里面把下面这行加上即可，一般我们有多个配置文件，建议只在dev开启，那么这一行只需要加到dev的配置文件里面就好啦。

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

mybatis-plus开头的原因是因为MP也兼容mybatis的配置，顶层的key换成mybatis: 也可以生效。

最后测试类来执行一下(上面的准备工作有demo，翻上去看一下)

这个缺点就是，输出的日志并非执行日志，日志格式需要自己拼接。输出的结果如下

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@16132f21] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1271323139 wrapping com.mysql.cj.jdbc.ConnectionImpl@4f59a516] will not be managed by Spring
==>  Preparing: SELECT id,phone,gender FROM t_user WHERE gender = ? AND username LIKE ? 
==> Parameters: 0(Integer), 小%(String)
<==    Columns: id, phone, gender
<==        Row: 1, 13333333333, 0
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@16132f21]

你需要把含有==>的两行放到一些插件或者三方工具里面进行转换，例如我是用uTools里面的mybatisLog工具转换结果如下

三方工具

这种虽然是原生，但是略显麻烦，不是很直观，如果是sql特别长，一次请求会话特别多，看了和没看一个样。

MP 3.2以下版本使用插件

使用MP在3.2以下版本提供的PerformanceInterceptor插件，这一种方式是我原来用的最多，也用的最顺手的，配置起来也非常方便，也可以很方便的做环境区分。

使用方法和MP其他插件例如分页插件一样，只需要创建一个bean，设置好输入然后放入ioc中即可，MP运行的时候就会使用你的bean完成相应的插件功能。

首先确认好你的MP版本是在3.2一下

<dependency>
  	<groupId>com.baomidou</groupId>
  	<artifactId>mybatis-plus-boot-starter</artifactId>
  	<!-- 确定版本号是3.2以下 -->
  	<version>3.1.2</version>
</dependency>

然后创建一个配置类，然后在里面注入一个PerformanceInterceptor的bean

@Configuration
public class MybatisPlusSqlLogConfig {


    /**
     * 打印 sql，性能分析拦截器
     * 因为每次sql都需要做拦截, 会有性能损耗
     * 所以建议只在dev或者test环境下方便debug的时候查看
     * 如果多个环境 -> @Profile({"dev", "test"})
     * @return PerformanceInterceptor bean
     */
    @Bean
    @Profile("mp")
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        // 设置格式化, 类似于datagrip的美化sql语句, 在控制台好看一些
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }
}

值得注意的是在@Bean后面可以再打一个注解@Profile("dev")，只要你的dev配置文件是application-dev.yml，那么这个bean只会在dev环境里面注入。在生产上你也不用担心这个会影响性能啦，因为我代码中是mp-表示的插件demo，所以我这里只在mp下生效。

最后测试类来执行一下(上面的准备工作有demo，翻上去看一下)

然后结果如下，这样的效果就非常的直观，并且还是红色字体

 Time：22 ms - ID：cn.someget.mybatis.sqllog.mapper.TUserMapper.selectOne
Execute SQL：
    SELECT
        id,
        phone,
        gender 
    FROM
        t_user 
    WHERE
        gender = 0 
        AND username LIKE '小%'

查询到的id是1, 电话是13333333333

红色醒目字体

本来是非常好用的，可能是作者觉得这个对性能影响非常大，为了防止这个插件大家误用就在3.2版本中下架了….

MP 3.2及以上版本使用p6spy

那我已经明确知道这个是不适合上生产，但是我现在本地方便debug看，除了降低MP版本，那还有什么解决办法呢。作者也在更新日志中提到推荐使用p6spy。

P6Spy是一个可以用来在应用程序中拦截和修改数据操作语句的开源框架，GitHub地址请点击这里。它的功能很强大，这里只介绍它满足sql性能分析和日志输出的需求。

首先先导入他的依赖，我这里随便导入一个版本，所有版本请点击这里

<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.8.2</version>
</dependency>

然后再配置文件里面配置datasource连接的时候，更换驱动类名以及url

# 配置一下mysql的连接信息
spring:
  datasource:
#   driver-class-name: com.mysql.cj.jdbc.Driver 这是原来的
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
#   url: jdbc:mysql://${mysql.host} 这是原来的url头部
    url: jdbc:p6spy:mysql://${mysql.host}:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&useSSL=false
    username: root
    password: 123456

最后在resources创建一个spy.properties的文件里面写入一些基本配置

#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger

# 格式化(不设置的话一大串阅读性不强, 这个是内置的格式器可以按照源码自己写一个然后配置)
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger

# 取消JDBC的url前缀
useprefix=true

p.s. 注意p6spy只需要导包和在配置文件中配置即可，不需要编写代码

最后测试类来执行一下(上面的准备工作有demo，翻上去看一下)

 Consume Time：10 ms 1639215721188
 Execute SQL：SELECT id,phone,gender FROM t_user WHERE gender = 0 AND username LIKE '小%'

查询到的id是1, 电话是13333333333

看起来也很直观，但是我翻了一下源码，好像没有自带格式化的配置类，如果大家有格式化需求，可以继承MessageFormattingStrategy自己照着P6SpyLogger写一个。

后言

一般基础组件，创建项目的时候就会选择一个稳定版开始搭建。后期上生产稳定以后一般都是锁版本的，我也是最近新项目引入MP才发现居然性能分析的插件已经被移除了，特意记录一下，给也习惯在本地开启sql日志输出的人提个醒。

最后这个本地debug看一下是真的爽，不能在生产环境打开哈。

A Simple Vim Makeover

Sun, 05 Dec 2021 00:00:00 +0000

Preface

A coworker picked up a Magic Keyboard Gen1 on Xianyu. After just a few days, the escape key broke, and he’d already confirmed receipt… He didn’t want to waste the money and still wanted to keep using it, so he listed out the scenarios where he needed escape and found the most frequent one was switching modes in vim. With that as a trigger, I’m sharing a few simple tweaks I use for vim on macOS—super handy, and you can basically ditch escape.

Quick intro to vim: it’s a text editor—honestly kind of like the TextEdit app on macOS—but its interaction philosophy is “do everything with the keyboard.” I’m not here to hype vim though. As a Java dev, is there really anything better than IntelliJ IDEA? Let alone a text editor 🤡 (runs away~). That said, I have seen real vim masters. At my previous company we had a PHP team, and some seniors wrote code directly on servers most of the time and barely used an IDE—hands on the keyboard like playing the piano, tap tap tap~.

Why do I call it a simple tweak? Because I used to be obsessed with vim too. I thought writing code in vim looked insanely cool, and I did all the tinkering—highlighting, hints, search, jumps, all the flashy stuff. But when it comes to writing JVM code, I still need IntelliJ. The learning/onboarding cost goes up, and the payoff is tiny. Still, even if you don’t code on servers, you’ll definitely run into cases where you need to edit config files, so I’d recommend doing a small quality-of-life setup first. Later, if you actually need server-side coding, you can add plugins and custom key mappings then.

Configuration and Plugins

Quick note: macOS ships with vim. Some folks online recommend replacing the system vim with MacVim. I don’t recommend it—partly because I’m lazy, and partly because MacVim’s biggest feature (besides internal vim improvements) is that it comes with a GUI. But vim is all about ditching the mouse, so that feels a bit against the philosophy. And it’s 2021 and MacVim’s shell support is still pretty lacking. If, like me, you only need a simple CLI setup, I’d say don’t switch.

Also, starting from Mojave (10.14.x), the built-in vim on macOS is already 8.x. Whatever you need is basically covered by the stock vim.

How to modify the config

The default config file for the built-in vim on macOS is at /usr/share/vim/vimrc. This is a system-level (global) vimrc file. To keep vim running normally, you generally don’t edit this file. Instead, you create a new user-level vimrc file under your home directory. In Terminal, type touch ~/.vimrc to create a config file manually (don’t worry—vim will automatically load it). Note that I’m creating a hidden file here, while the global config file is a normal non-hidden file. Hidden vs non-hidden is up to personal preference (.xxx is hidden, xxx is not).

Make sure there is a .vimrc file under your home directory

After that, if you want to tweak built-in vim settings or add custom key mappings, just put them in here. No restart needed—changes take effect immediately.

How to install plugins

For installing vim plugins, you can follow the official vim guide and install manually. But I strongly recommend using a package manager—it makes updates much easier later. Here I recommend vim-plug. You might see people recommend vundle, but it’s no longer maintained. vim-plug not only promises ongoing maintenance, it also has very solid documentation.

Installation is super simple. Their github has guides for different platforms. For Unix (macOS and Linux), just run this in your shell:

curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

That’s it. If the progress bar hangs forever, you can check my post on Terminal proxy, or download the .vim script from their site and manually place it under ~/.vim/autoload/ (create the directory if it doesn’t exist).

Successful installation screen (this curl is basically just downloading the script to a specific local path)

After installing, you’ll need a plugin marketplace to find the package name—kind of like Maven coordinates. vim-plug is like Maven managing your dependencies, and Maven Central is like the plugin marketplace. Unless you can memorize all coordinates, you go to the central repo, copy the coordinates, and put them into pom.xml. For vim plugins, you go to the marketplace, find the corresponding command, put it into .vimrc, and then run the install command (kind of like…).

The marketplace I use is vimawesome. It has a huge collection, and it supports not only vim-plug but also other package managers.

The command provided for a plugin on vimawesome

Once you have vim-plug and have bookmarked vimawesome, just follow the vim-plug docs to install plugins. I’ll also share a plugin below and show you how to install it.

Recommended config tweaks

Enable syntax highlighting

By default, vim on macOS doesn’t have syntax highlighting. I might not understand the code, but the code must be highlighted. I randomly edited a startup file with some default and custom configs to show the difference between highlighted vs not.

No highlighting

With highlighting

I don’t think I need to say much about this comparison. Every time I see the Android folks in my team with a screen full of colorful code, I’m like “wow so pro”—more colors must mean better skills, right? 🤡

Enabling highlighting is super easy: in your shell, run vim ~/.vimrc, then add syntax on, then :wq to save. After that, open vim again and check your code—highlighting should be there.

Just add one line

Highlight the current line

In your shell, run vim ~/.vimrc, then add set cursorline.

Split config by lines

Then you’ll get the effect below: the line where your cursor is will be underlined/highlighted. This is super useful when editing configs—especially when you use / to search and your eyes have to scan around to figure out where you landed.

Cursor positioning effect

Keep indentation consistent

Most of the time I use vim to edit server configs. Sometimes I add comments before modifying things. If I indent the first line, when I go to the next line it won’t keep the indentation automatically—I have to type it again. Add set autoindent to .vimrc and the next line will automatically keep the same indentation as the previous line.

Remember: one config per line

The effect: new lines keep the previous line’s indentation

Replace the escape key

The most common use of escape is switching from insert mode back to normal mode. escape is far away, and the most comfortable “core” keys are already taken. My solution is to use a combo key: quickly type j+k to act as escape.

The change is simple: add imap jk <Esc> to ~/.vimrc. You can replace jk with any other keys you like—I’m just used to jk.

Final effect: when typing, use the jk combo to quickly switch back to normal mode.

Replace the `:` key

To type :, you have to press shift+;. As a lazy person, I really don’t want to press two keys. But entering command-line mode from normal mode is something you do constantly when interacting with vim. After thinking about it, I realized the space key is basically wasted in normal mode, because editing in normal mode relies on letter keys and doesn’t use space. So I mapped space to : to enter command mode. It’s also super simple: add nmap <space> : to ~/.vimrc.

Effect:

Others

You can totally set things based on your own habits. For key mappings, you can use xmap. Here x is a dynamic value—different x means different modes/behaviors. I made a table for you; feel free to get creative and customize your mappings.

x	Meaning
nore	Non-recursive
n	Effective in normal mode
v	Effective in visual mode
i	Effective in insert mode
c	Effective in command-line mode
un	Followed by a key combo; removes the mapping
clear	Clears all mappings in the corresponding mode

For other configs, here’s a summary as well:

# 自动语法高亮
syntax on 
# 开启插件
filetype plugin indent on 
# 关闭 vi 兼容模式
set nocompatible
# 显示行号
set number 
# 突出显示当前行
set cursorline  
# 打开状态栏标尺
set ruler  
# 设定 << 和 >> 命令移动时的宽度为 4
set shiftwidth=4 
# 使得按退格键时可以一次删掉 4 个空格
set softtabstop=4 
# 设定 tab 长度为 4
set tabstop=4 
# 覆盖文件时不备份
set nobackup 
# 自动切换当前目录为当前文件所在的目录
set autochdir 
# 设置备份时的行为为覆盖
set backupcopy=yes 
# 搜索时忽略大小写，但在有一个或以上大写字母时仍保持对大小写敏感
set ignorecase smartcase 
# 禁止在搜索到文件两端时重新搜索
set nowrapscan 
# 输入搜索内容时就显示搜索结果
set incsearch 
# 搜索时高亮显示被找到的文本
set hlsearch 
# 关闭错误信息响铃
set noerrorbells 
# 关闭使用可视响铃代替呼叫
set novisualbell 
# 置空错误铃声的终端代码
set t_vb= 
# 插入括号时，短暂地跳转到匹配的对应括号
set showmatch 
# 短暂跳转到匹配括号的时间
set matchtime=2 
# 设置魔术
set magic 
# 允许在有未保存的修改时切换缓冲区，此时的修改由 vim 负责保存
set hidden 
# 隐藏工具栏
set guioptions-=T 
# 隐藏菜单栏
set guioptions-=m 
# 开启新行时使用智能自动缩进
set smartindent 
# 不设定在插入状态无法用退格键和 Delete 键删除回车符
set backspace=indent,eol,start
# 设定命令行的行数为 1
set cmdheight=1 
# 显示状态栏 (默认值为 1, 无法显示状态栏)
set laststatus=2 
# 设置在状态行显示的信息
set statusline=\ %<%F[%1*%M%*%n%R%H]%=\ %y\ %0(%{&fileformat}\ %{&encoding}\ %c:%l/%L%)\ 
# 开始折叠
set foldenable 
# 设置语法折叠
set foldmethod=syntax 
# 设置折叠区域的宽度
set foldcolumn=0 
# 设置折叠层数为1
set local foldlevel=1 

Recommended plugins

I’m only recommending one plugin here—mainly to demonstrate how to install plugins with vim-plug. You can go treasure-hunting on vimawesome yourself. After you find something, remember to share it in the comments.

The plugin I recommend is The NERD tree. It shows a basic file explorer tree like an IDE does, for example in VS Code:

VS Code directory tree

After using The NERD tree, in vim it looks like this:

The NERD tree UI

Here’s how to install it

Go to the plugin marketplace vimawesome and find The NERD tree
Copy this one-line command

Then open your shell and run vim ~/.vimrc. Yes!!! This config file again. Then add:

call plug#begin('~/.vim/autoload')
call plug#end()

Then paste the command you found on vimawesome between those two lines, like this:

call plug#begin('~/.vim/autoload')
Plug 'scrooloose/nerdtree'
call plug#end()

Then switch to command mode and enter PlugInstall (note: you must have vim-plug installed, otherwise it’ll say the command can’t be found)

Then in vim you can press ctrl+t to view the directory tree for the current file. The plugin’s documentation on vimawesome is way more detailed than what I’m writing here.

At this point, the plugin is installed. If you need other plugins, the process is the same: copy the command you find on vimawesome into the two call lines, then run PlugInstall.

END

Recommended resources

简单的对vim进行改造

Sun, 05 Dec 2021 00:00:00 +0000

前言

同事在闲鱼淘了一个Magic Keyboard Gen1结果没用几天，escape的按键就坏掉了，但是已经确认收货了…..他舍不得钱浪费还想继续用，就罗列了一下escape的场景，发现最高频的还是在vim中进行模式切换。有这个契机就分享一下我自己在mac下简单对vim的改造，不仅好用而且可以摆脱escape。

简单介绍一下vim，它是一个文本编辑器，其实就和mac上面的文本编辑.app差不多，只不过它的交互哲学是通过键盘完成一切。在这里我不想吹vim，作为javaer而言难道世界上还有比intellij还更香的IDE吗？更别说文本编辑器🤡(逃~)。当然我也见识过真正的vim大神，原来公司有php组，有前辈大部分时候都是直接在服务器上编写代码很少用IDE，摸键盘和弹琴一样，刷刷刷~。

为啥说简单改造呢，因为原来也痴迷过vim，也觉得在vim上写代码看起来好厉害，也曾经折腾过高亮，提示，搜索，跳转非常酷炫，可是真要写jvm代码还是得看intellij，增加学习上手成本并且收益非常低。不过即便没有在服务器上编码的需求，肯定会有修改配置文件场景，所以我更加建议先对vim进行小小的顺手改造，待以后有了服务器编码需求，可以再把相关插件以及自定义键位加上。

配置和插件

提一嘴，mac是自带vim，网上有大佬建议使用MacVim替换系统vim。我不建议，一方面是懒，另外一方面MacVim除了内部继承vim优化最大的特点就是自带GUI，但是vim本来就是强调丢弃鼠标，感觉和理念有点违背，更别说现在2021年了MacVim对shell的支持还是很不到位，如果你和我一样是这是简单的CLI需求，我也建议你别换。

另外从Mojave(10.14.x开始，MacOS内置的vim版本已经是8.x了，你要的需求自带的vim都可以满足。

修改配置方法

Mac自带vim的默认配置文件在/usr/share/vim/vimrc。这个文件是系统级(全局)的vimrc配置文件，为了保证vim的正常运行，一般并不会修改这个文件。而是在～目录下创建一个新的用户级vimrc文件。在终端中键入touch ~/.vimrc 手动创建一个配置文件(放心vim会自动读取这个文件)，值得注意的是，我这里创建的是隐藏文件，而全局配置文件是正常的非隐藏文件，隐藏和不隐藏都可以，看个人习惯(.xxx隐藏，xxx非隐藏)

保证home目录下面有.vimrc文件

然后如果需要对vim做内置配置修改或者自定义键位配置都往这里面加修好了，不用重启就可以生效。

安装插件的方法

vim安装插件的话，你可以直接按照vim官网的指南进行手动安装。但是我更加建议使用包管理器，后期更新都很方便，这里推荐vim-plug。如果你可能会看别人推荐vundle，但是它已经不再更新了，vim-plug不仅承诺会一直更新并且它提供非常翔实的文档

安装也非常简单，它github上有各个版本的安装指南，如果是unix(mac和linux都是)直接在shell里面输入

curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

即可，如果输入后一直卡进度条，可以看看我这篇文章的终端代理或者在它官网下载.vim脚本然后手动把脚本放到~/.vim/autoload/下(如果没有则自己创建一下就好了)

安装成功界面(其实这个curl也很简单就是把脚本放到指定你本地路径)

安装好了以后你需要一个插件市场然后找到对应的包名，有点像maven的坐标，vim-plug就是maven帮你管理各种依赖，maven远程中央仓库就是插件市场。除非你能把坐标背下来不然你需要去中央仓库获取坐标然后写到maven的pom文件中。在vim的插件中你需要去插件市场找到对应的命令然后写到.vimrc中，使用命令再安装(相当于。

我使用的插件市场vimawesome，插件非常全，并且不只是支持vim-pulg还支持市面上其他的包管理器

vimawesome页面上提供的某插件命令

你有了vim-plug以及收藏了vimawesome，安装插件按照vim-plug文档上的描述操作就好了。当然下面也会分享一些插件告诉大家怎么装。

x	含义
nore	非递归
n	普通模式生效
v	可视模式生效
i	插入模式生效
c	命令行模式生效
un	后面跟组合键, 表示删除这个映射
clear	清楚相关模式下所有映射