Chloneda https://chloneda.github.io/ Less is more Tue, 31 Mar 2020 01:49:08 GMT http://hexo.io/ git config全局和本地配置 https://chloneda.github.io//blog/git-config/ https://chloneda.github.io//blog/git-config/ Tue, 31 Mar 2020 01:49:08 GMT <p><strong>注：本文出自博主 Chloneda</strong>：<a href="https://chloneda.github.io/">个人博客</a> | <a href="https://www.cnblogs.com/chloneda" target="_b 注：本文出自博主 Chloneda：个人博客 | 博客园 | Github | Gitee | 知乎

前言

程序开发人员在日常开发过程中，使用 git 可能会遇到这样一个情况：

  • 公司项目使用公司账号提交git信息。
  • 个人业余项目使用个人账户提交git信息。

也就是说，我们需要 git 根据不同项目使用不同的账号及邮箱提交相关记录，本文就是专门解决这个问题的。

本地设置

本地设置有两种方式，命令方式 和 配置文件方式，两种方式选择任意一种，都可以配置当前git项目提交git信息的账号及邮箱。

命令方式

对于本地 git repo 配置，先进入 本地git repo 目录，使用命令：

1
2
git config user.name "your-username"
git config user.email "your-email-address"

配置文件方式

对于本地 git repo 配置，先进入 本地git项目 目录，编辑 .git/config 文件，增加以下信息：

1
2
3
[user]
    name = your-username
    email = your-email-address

保存并退出。以上 命令方式 和 配置文件方式 两种方式，都可以在 本地git repo 目录下，通过以下命令查看本地项目的账号及邮箱是否更改成功。

1
git config user.name

对于很多个 本地git repo 来说，每个 本地git repo 都要设置自定义化git本地账号及邮箱，有时我们不想每个都设置，我们可以使用git的全局配置，所有 本地git repo 都是使用全局配置！

全局设置

全局设置有两种方式，命令方式 和 配置文件方式，两种方式选择任意一种，都可以配置全局git项目提交git信息的账号及邮箱。

命令方式

在git服务器中，任意非 本地git repo 中，使用以下命令配置全局配置：

1
2
git config --global user.name "your-username"
git config --global user.email "your-email-address"

配置文件方式

编辑 〜/.gitconfig，其内容与 .git/config 文件中的内容相同，即将 [user] 部分信息添加至 〜/.gitconfig 文件中，内容如下：

1
2
3
[user]
    name = your-username
    email = your-email-address

保存并退出。任意非 本地git repo 中，在使用以下命令查看是否配置成功

1
git config user.name

好了，这次git config全局及本地配置就到这里了！

]]> Vim命令速查表 https://chloneda.github.io//blog/vim-cheatsheet/ https://chloneda.github.io//blog/vim-cheatsheet/ Mon, 30 Mar 2020 14:33:48 GMT <p><strong>注：本文出自博主 Chloneda</strong>：<a href="https://chloneda.github.io/">个人博客</a> | <a href="https://www.cnblogs.com/chloneda" target="_b 注：本文出自博主 Chloneda：个人博客 | 博客园 | Github | Gitee | 知乎

Vim命令速查表

个人Vim命令速查表。

vim-cheatsheet | Vim官网 | Github | Vim中文文档

光标移动

注：一般模式下，任意一个动作都可以重复。

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
h                   # 光标左移，同 <Left> 键
j                   # 光标下移，同 <Down> 键
k                   # 光标上移，同 <Up> 键
l                   # 光标右移，同 <Right> 键
Ctrl+e              # 向上滚动一行
Ctrl+y              # 向下滚动一行
Ctrl+u              # 向上滚动半屏 --> move up 1/2 a screen
Ctrl+d              # 向下滚动半屏 --> move down 1/2 a screen
Ctrl+f              # 向下滚动一屏 --> move forward one full screen
Ctrl+b              # 向上滚动一屏 --> move back one full screen
0                   # 跳到行首（是数字零，不是字母O），效用等同于 <Home> 键
^                   # 跳到从行首开始第一个非空白字符
$                   # 跳到行尾，效用等同于 <End> 键
gg                  # 跳到第一行，效用等同于 Ctrl+<Home>
G                   # 跳到最后一行，效用等同于 Ctrl+<End>
nG                  # 跳到第n行，比如 10G 是移动到第十行
:n                  # 跳到第n行，比如 :10<回车> 是移动到第十行
10%                 # 移动到文件 10% 处
15|                 # 移动到当前行的 15列
w                   # 跳到下一个单词开头 (word: 标点或空格分隔的单词)
W                   # 跳到下一个单词开头 (WORD: 空格分隔的单词)
e                   # 跳到下一个单词尾部 (word: 标点或空格分隔的单词)
E                   # 跳到下一个单词尾部 (WORD: 空格分隔的单词)
b                   # 跳到上一个单词开头 (word: 标点或空格分隔的单词)
B                   # 跳到上一个单词开头 (WORD: 空格分隔的单词)
ge                  # 跳到前一个单词结尾
)                   # 向前移动一个句子（句号分隔）
(                   # 向后移动一个句子（句号分隔）
}                   # 向前移动一个段落（空行分隔）
{                   # 向后移动一个段落（空行分隔）
<enter>             # 移动到下一行首个非空字符
n<enter>            # 光标向下移动 n 行
+                   # 移动到下一行首个非空字符（同回车键）
-                   # 移动到上一行首个非空字符
H                   # 移动到屏幕上部
M                   # 移动到屏幕中部
L                   # 移动到屏幕下部
<S+Left>            # 按住 SHIFT 按左键，向左移动一个单词
<S+Right>           # 按住 SHIFT 按右键，向右移动一个单词
<S+Up>              # 按住 SHIFT 按上键，向上翻页
<S+Down>            # 按住 SHIFT 按下键，向下翻页
gm                  # 移动到行中
gj                  # 光标向下移动一个屏幕行（忽略自动换行）
gk                  # 光标向上移动一个屏幕行（忽略自动换行）
zz                  # 调整光标所在行到屏幕中央
zt                  # 调整光标所在行到屏幕上部
zb                  # 调整光标所在行到屏幕下部

插入模式

1
2
3
4
5
6
7
8
9
i                   # 在光标处进入插入模式
I                   # 在行首进入插入模式
a                   # 在光标后进入插入模式
A                   # 在行尾进入插入模式
o                   # 在下一行插入新行并进入插入模式
O                   # 在上一行插入新行并进入插入模式
gi                  # 进入到上一次插入模式的位置
<esc>               # 退出插入模式
Ctrl+[              # 退出插入模式（等价于 esc 键）

插入模式的命令

注：由 i, I, a, A, o, O 等命令进入插入模式

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
<Up>                # 光标向上移动
<Down>              # 光标向下移动
<Left>              # 光标向左移动
<Right>             # 光标向右移动
<S+Left>            # 按住 SHIFT 按左键，向左移动一个单词
<S+Right>           # 按住 SHIFT 按右键，向右移动一个单词
<S+Up>              # 按住 SHIFT 按上键，向上翻页
<S+Down>            # 按住 SHIFT 按下键，向下翻页
<PageUp>            # 上翻页
<PageDown>          # 下翻页
<Delete>            # 删除光标处字符
<BS>                # Backspace 向后删除字符
<Home>              # 光标跳转行首
<End>               # 光标跳转行尾
Ctrl+d              # 减少缩进
Ctrl+f              # 减少缩进
Ctrl+t              # 增加缩进
Ctrl+h              # 删除前一个字符，相当于回格键backspace
Ctrl+o              # 临时退出插入模式，执行单条命令又返回插入模式
Ctrl+u              # 当前行删除到行首所有字符
Ctrl+w              # 删除光标前的一个单词
Ctrl+\ Ctrl+O       # 临时退出插入模式（光标保持），执行单条命令又返回插入模式
Ctrl+R 0            # 插入寄存器（内部 0号剪贴板）内容，Ctrl+R 后可跟寄存器名
Ctrl+R "            # 插入匿名寄存器内容，相当于插入模式下 p粘贴
Ctrl+R =            # 插入表达式计算结果，等号后面跟表达式
Ctrl+R :            # 插入上一次命令行命令
Ctrl+R /            # 插入上一次搜索的关键字
Ctrl+v {char}       # 插入非数字的字面量
Ctrl+v {code}       # 插入用三位数字表示的ascii/unicode字符编码，如Ctrl+v 065
Ctrl+v 065          # 插入 10进制 ascii 字符（两数字） 065 即 A字符
Ctrl+v x41          # 插入 16进制 ascii 字符（三数字） x41 即 A字符
Ctrl+v o101         # 插入  8进制 ascii 字符（三数字） o101 即 A字符
Ctrl+v u1234        # 插入 16进制 unicode 字符（四数字）
Ctrl+v U12345678    # 插入 16进制 unicode 字符（八数字）
Ctrl+K {ch1} {ch2}  # 插入 digraph（见 :h digraph），快速输入日文或符号等

自动补全

在插入模式下，最常用的补全

1
2
3
Ctrl+n              # 插入模式下文字自动补全 
Ctrl+P              # 插入模式下文字自动补全
Ctrl+e              # 有补全列表时，终止这次补全，继续输入

智能补全

1
2
3
4
5
6
7
8
9
10
11
12
13
Ctrl+X              # 进入补全模式
Ctrl+X Ctrl+L       # 整行补全
Ctrl+X Ctrl+N       # 插入模式下，根据当前文件里关键字补全
Ctrl+X Ctrl+K       # 根据字典补全
Ctrl+X Ctrl+T       # 根据同义词字典补全
Ctrl+X Ctrl+F       # 插入模式下补全文件名
Ctrl+X Ctrl+I       # 根据头文件内关键字补全
Ctrl+X Ctrl+]       # 根据标签补全
Ctrl+X Ctrl+D       # 补全宏定义
Ctrl+X Ctrl+V       # 补全vim命令
Ctrl+X Ctrl+U       # 用户自定义补全方式
Ctrl+X Ctrl+S       # 拼写建议，例如：一个英文单词
Ctrl+X Ctrl+O       # 插入下 Omnifunc 补全

文本编辑

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
r                   # 替换当前字符
R                   # 进入替换模式，直至 ESC 离开
s                   # 替换字符（删除光标处字符，并进入插入模式，前可接数量）
S                   # 替换行（删除当前行，并进入插入模式，前可接数量）
cc                  # 改写当前行（删除当前行并进入插入模式），同 S
cw                  # 改写光标开始处的当前单词
ciw                 # 改写光标所处的单词
caw                 # 改写光标所处的单词，并且包括前后空格（如果有的话）
c0                  # 改写到行首
c^                  # 改写到行首（第一个非零字符）
c$                  # 改写到行末
C                   # 改写到行尾（同c$）
ci"                 # 改写双引号中的内容
ci'                 # 改写单引号中的内容
cib                 # 改写小括号中的内容
cab                 # 改写小括号中的内容（包含小括号本身）
ci)                 # 改写小括号中的内容
ci]                 # 改写中括号中内容
ciB                 # 改写大括号中内容
caB                 # 改写大括号中的内容（包含大括号本身）
ci}                 # 改写大括号中内容
cit                 # 改写 xml tag 中的内容
cis                 # 改写当前句子
c2w                 # 改写下两个单词
ct(                 # 改写到小括号前
x                   # 删除当前字符，前面可以接数字，3x代表删除三个字符
X                   # 向前删除字符
dd                  # 删除(剪切)当前行 --> delete (cut) a line 
d0                  # 删除(剪切)到行首
d^                  # 删除(剪切)到行首（第一个非零字符）
d$                  # 删除(剪切)到行末
D                   # 删除(剪切)到行末（同 d$）
dw                  # 删除(剪切)当前单词
diw                 # 删除(剪切)光标所处的单词
daw                 # 删除(剪切)光标所处的单词，并包含前后空格（如果有的话）
di"                 # 删除双引号中的内容
di'                 # 删除单引号中的内容
dib                 # 删除小括号中的内容
di)                 # 删除小括号中的内容
dab                 # 删除小括号内的内容（包含小括号本身）
di]                 # 删除中括号中内容
diB                 # 删除大括号中内容
di}                 # 删除大括号中内容
daB                 # 删除大括号内的内容（包含大括号本身）
dit                 # 删除 xml tag 中的内容
dis                 # 删除当前句子
d2w                 # 删除下两个单词
dt(                 # 删除到小括号前
dgg                 # 删除到文件头部
dG                  # 删除到文件尾部
d}                  # 删除下一段
d{                  # 删除上一段
10d                 # 删除当前行开始的10行
:10d                # 删除第10行
:1,10d              # 删除1-10行
J                   # 链接多行为一行
.                   # 重复上一次操作
~                   # 替换大小写
g~iw                # 替换当前单词的大小写
gUiw                # 将单词转成大写
guiw                # 将当前单词转成小写
guu                 # 全行转为小写
gUU                 # 全行转为大写
<<                  # 减少缩进
>>                  # 增加缩进
==                  # 自动缩进
Ctrl+A              # 增加数字
Ctrl+X              # 减少数字

复制粘贴

copy 命令的格式为：

1
:[range]copy{address}

参数说明：

  • [range] 表示要复制的行范围，其中copy可缩写为 :co 或 :t
  • {address} 表示复制的目标位置，这两个参数都可以缺省，用于表示Vim光标所在当前行。

例如，:5copy. 表示复制Vim当前打开的文件的第 5 行到当前行 (用 . 表示)，即为第 5 行创建一份副本，并放到当前行下方。

下标列出了使用 copy 命令的缩写形式 t 进行文件复制的一些实例及用途，用于理解复制命令 copy 的用途。

1
2
3
4
5
:3,5t.              # 把第 3 行到第 5 行的内容复制到当前行下方
:t5                 # 把当前行复制到第 5 行下方
:t.                 # 复制当前行到当前行下方 (等价于普通模式下的 yyp)
:t$                 # 把当前行复制到文本结尾
:'<,'>t0            # 把高亮选中的行复制到文件开头

常用复制粘贴命令：

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
p                   # 粘贴到光标后
P                   # 粘贴到光标前
v                   # 开始标记
y                   # 复制标记内容
V                   # 开始按行标记
Ctrl+V              # 开始列标记
y$                  # 复制当前位置到本行结束的内容
yy                  # 复制当前行 --> yank (copy) a line
Y                   # 复制当前行，同 yy
yiw                 # 复制当前单词
3yy                 # 复制光标下三行内容
v0                  # 选中当前位置到行首
v$                  # 选中当前位置到行末
viw                 # 选中当前单词
vib                 # 选中小括号内的东西
vi)                 # 选中小括号内的东西
vi]                 # 选中中括号内的东西
viB                 # 选中大括号内的东西
vi}                 # 选中大括号内的东西
vis                 # 选中句子中的东西
vab                 # 选中小括号内的东西（包含小括号本身）
va)                 # 选中小括号内的东西（包含小括号本身）
va]                 # 选中中括号内的东西（包含中括号本身）
vaB                 # 选中大括号内的东西（包含大括号本身）
va}                 # 选中大括号内的东西（包含大括号本身）
:set paste          # 允许粘贴模式（避免粘贴时自动缩进影响格式）
:set nopaste        # 禁止粘贴模式
"?yy                # 复制当前行到寄存器 ? ，问号代表 0-9 的寄存器名称
"?d3j               # 删除光标下三行内容，并放到寄存器 ? ，问号代表 0-9 的寄存器名称
"?p                 # 将寄存器 ? 的内容粘贴到光标后
"?P                 # 将寄存器 ? 的内容粘贴到光标前
:registers          # 显示所有寄存器内容
:[range]y           # 复制范围，比如 :20,30y 是复制20到30行，:10y 是复制第十行
:[range]d           # 删除范围，比如 :20,30d 是删除20到30行，:10d 是删除第十行
ddp                 # 交换两行内容：先删除当前行复制到寄存器，并粘贴
"_[command]         # 使用[command]删除内容，并且不进行复制（不会污染寄存器）
"*[command]         # 使用[command]复制内容到系统剪贴板（需要vim版本有clipboard支持）

文本编辑、复制粘贴中的内容可以简单总结为：

1
2
3
4
ci'、ci"、ci(、ci[、ci{、ci<            # 分别更改这些配对标点符号中的文本内容
di'、di"、di(或dib、di[、di{或diB、di<   # 分别删除这些配对标点符号中的文本内容
yi'、yi"、yi(、yi[、yi{、yi<            # 分别复制这些配对标点符号中的文本内容
vi'、vi"、vi(、vi[、vi{、vi<            # 分别选中这些配对标点符号中的文本内容

cit、dit、yit、vit，分别操作一对标签之间的内容，编辑html、xml很好用！

另外，如果把上面的 i 改成 a 可以同时操作配对标点和配对标点内的内容。

移动文本

1
:[range]move{address}

参数说明：

  • [range] 表示要移动的行范围
  • {address} 表示移动的目标位置，这两个参数都可以缺省

例如：

1
2
3
:m+1                # 下移1行
:m-2                # 上移1行
:8,10m2             # 把当前打开文件的第8~10行内容移动到第 2 行下方

文本对象

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
$                   # 到行末
0                   # 到行首
^                   # 到行首非空字符
iw                  # 整个单词（不包括分隔符）
aw                  # 整个单词（包括分隔符）
iW                  # 整个 WORD（不包括分隔符）
aW                  # 整个 WORD（包括分隔符）
is                  # 整个句子（不包括分隔符）
ib                  # 小括号内
ab                  # 小括号内（包含小括号本身）
iB                  # 大括号内
aB                  # 大括号内（包含大括号本身）
i)                  # 小括号内
a)                  # 小括号内（包含小括号本身）
i]                  # 中括号内
a]                  # 中括号内（包含中括号本身）
i}                  # 大括号内
a}                  # 大括号内（包含大括号本身）
i'                  # 单引号内
a'                  # 单引号内（包含单引号本身）
i"                  # 双引号内
a"                  # 双引号内（包含双引号本身）
2i)                 # 往外两层小括号内
2a)                 # 往外两层小括号内（包含小括号本身）
2f)                 # 到第二个小括号处
2t)                 # 到第二个小括号前

撤销与恢复

1
2
3
4
u                   # 撤销命令可以组合，例如Nu N是任意整数，表示撤销N步操作，下同
U                   # 撤销整行操作
Ctrl+r              # 撤销上一次 u 命令
Ctrl+R              # 回退前一个命令

查找替换

一般模式下的查找命令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/pattern            # 从光标处向文件尾搜索 pattern
?pattern            # 从光标处向文件头搜索 pattern
n                   # 向同一方向执行上一次搜索
N                   # 向相反方向执行上一次搜索
*                   # 向前搜索光标下的单词
#                   # 向后搜索光标下的单词
f<char>             # 向后搜索当前行第一个为 <char> 的字符，2fv 可以找到第二个v字符
F<char>             # 向前搜索当前行第一个为 <char> 的字符
t<char>             # 向后搜索当前行第一个为 <char> 的字符前
T<char>             # 向前搜索当前行第一个为 <char> 的字符前
;                   # 重复上次的字符查找命令(f/t命令)
,                   # 反转方向查找上次的字符查找命令(f/t命令)
tx                  # 搜索当前行到指定 字符串 之前
fx                  # 搜索当前行到指定 字符串 之处

一般模式下的替换命令： 

1
:[range]s[ubstitute]/{pattern}/{string}/[flags]

参数说明：

  • pattern：就是要被替换掉的字串，可以用 regexp 來表示
  • string：將 pattern 由 string 所取代
  • [range]：有以下一些取值：
[range]取值含义
无默认光标所在行
.光标所在当前行
N第 N 行
$最后一行
‘a标记 a 所在的行（之前要用 ma 做过标记）
$-1倒数第二行，可以对某一行加减某个数值获得确定的某行
1,10第1~10行
1,$第一行到最后一行
1,.第一行到当前行
.,$当前行到最后一行
‘a,’b标记 a 所在的行 到 标记 b 所在的行（之前要用 ma、mb 做过标记）
%所有行（和 1,$ 等价）
?str?从当前位置向上搜索，找到第一个str的行（str可以是正则）
/str/从当前位置向下搜索，找到第一个str的行（str可以是正则）

注意，上面的所有用于range的表示方法都可以通过 +、- 操作来设置相对偏移量。

  • [flags]有以下一些取值：
[flags]取值含义
g对指定范围内的所有匹配项（global）进行替换
c在替换前请求用户进行确认（confirm）
e忽略执行过程中的错误
i不区分大小写
无只在指定范围内的第一个匹配项进行替换

举例：

1
2
3
4
5
6
7
8
9
10
:s/p1/p2/g          # 将当前行中全替换p1为p2
:%s/p1/p2/g         # 将当前文件中全替换p1为p2
:%s/p1/p2/gc        # 将当前文件中全替换p1为p2，并且每处询问你是否替换
:10,20s/p1/p2/g     # 将第10到20行中所有p1替换为p2
:%s/1\\2\/3/123/g   # 将“1\2/3” 替换为 “123”（特殊字符使用反斜杠标注）
:%s/\r//g           # 删除 DOS 换行符 ^M
:%s///gn            # 统计某个模式的匹配个数
:%s/^\s*$\n//g      # 删除Vim打开文件中所有空白行
:g/^\s*$/d          # 删除Vim打开文件中所有空白行
:%s/^M$//g          # 删除Vim文件中显式的 ^M 符号（操作系统换行符问题）

可视模式

注：Vim 可视模式下可以选择一块编辑区域，然后对选中的文件内容执行插入、删除、替换、改变大小写等操作。！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
v                   # 切换到面向字符的可视模式
V                   # 切换到面向行的可视模式
Ctrl-V              # 切换到面向列块的可视模式
>                   # 增加缩进
<                   # 减少缩进
d                   # 删除高亮选中的文字
x                   # 删除高亮选中的文字
c                   # 改写文字，即删除高亮选中的文字并进入插入模式
s                   # 改写文字，即删除高亮选中的文字并进入插入模式
y                   # 拷贝文字
~                   # 转换大小写
o                   # 跳转到标记区的另外一端
O                   # 跳转到标记块的另外一端
u                   # 标记区转换为小写
U                   # 标记区转换为大写
gv                  # 重选上次的高亮选区
g Ctrl+G            # 显示所选择区域的统计信息
ggVG                # 选择全文
esc                 # 按esc键退出可视模式

此外： Vim normal 命令可以在命令行模式执行普通模式下的命令，当 normal 命令与 Vim 可视化模式结合时，只需很少的操作就能完成大量重复性工作。

注释命令

多行注释

1
2
3
Ctrl+v              # 进入命令行模式，按Ctrl + v进入可视模式，然后按j, 或者k选中多行，把需要注释的行标记起来
I                   # 按大写字母I，再插入注释符，例如#、//
esc                 # 按esc键就会全部注释了

取消多行注释

1
2
3
Ctrl+v              # 进入命令行模式，按Ctrl + v进入可视模式，按字母l横向选中列的个数，例如#、//（需要选中2列）
j 或 k              # 按字母j，或者k选中注释符号
d                   # 按d键就可全部取消注释

复杂注释

1
2
3
4
5
6
7
8
9
10
11
:起始行号,结束行号s/^/注释符/g（注意冒号）       # 在指定的行首添加注释
:起始行号,结束行号s/^注释符//g（注意冒号）       # 在指定的行首取消注释

:3,5 s/^/#/g        # 注释第3-5行
:3,5 s/^#//g        # 解除3-5行的注释

:1,$ s/^/#/g        # 注释整个文档
:1,$ s/^#//g        # 取消注释整个文档

:%s/^/#/g           # 注释整个文档，此法更快
:%s/^#//g           # 取消注释整个文档

位置跳转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Ctrl+O              # 跳转到上一个位置
Ctrl+I              # 跳转到下一个位置
Ctrl+^              # 跳转到 alternate file (当前窗口的上一个文件）
%                   # 跳转到 {} () [] 的匹配
gd                  # 跳转到局部定义（光标下的单词的定义）
gD                  # 跳转到全局定义（光标下的单词的定义）
gf                  # 打开名称为光标下文件名的文件
[[                  # 跳转到上一个顶层函数（比如C语言以大括号分隔）
]]                  # 跳转到下一个顶层函数（比如C语言以大括号分隔）
[m                  # 跳转到上一个成员函数
]m                  # 跳转到下一个成员函数
[{                  # 跳转到上一处未匹配的 {
]}                  # 跳转到下一处未匹配的 }
[(                  # 跳转到上一处未匹配的 (
])                  # 跳转到下一处未匹配的 )
[c                  # 上一个不同处（diff时）
]c                  # 下一个不同处（diff时）
[/                  # 跳转到 C注释开头
]/                  # 跳转到 C注释结尾
``                  # 回到上次跳转的位置
''                  # 回到上次跳转的位置
`.                  # 回到上次编辑的位置
'.                  # 回到上次编辑的位置

文件操作

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
:w                  # 保存文件（会修改文件的时间戳）
:w <filename>       # 按名称保存文件
:x                  # 保存文件并退出（不会修改文件的时间戳）
:e <filename>       # 打开文件并编辑
:saveas <filename>  # 另存为文件
:o <filename>       # 在当前窗口打开另一个文件
:r <filename>       # 读取文件并将内容插入到光标后
:r !dir             # 将 dir 命令的输出捕获并插入到光标后
:only               # 关闭除光标所在的窗口之外的其他窗口
:close              # 关闭光标所在窗口的文件
:q                  # 关闭光标所在的窗口并退出
:q!                 # 强制退出
:qa！               # 关闭所有窗口(不保存)
:qall               # 放弃所有操作并退出
:wa                 # 保存所有文件
:wall               # 保存所有
:wqall              # 保存所有并退出。
:cd <path>          # 切换 Vim 当前路径
:pwd                # 显示 Vim 当前路径
:new                # 打开一个新的窗口编辑新文件
:enew               # 在当前窗口创建新文件
:vnew               # 在左右切分的新窗口中编辑新文件
:tabnew             # 在新的标签页中编辑新文件
:version            # 查看Vim版本
ZZ                  # 保存文件（如果有改动的话），并关闭窗口
ZQ                  # 不保存文件关闭窗口

打开文件

1
2
3
4
5
6
7
8
9
10
11
12
13
vim filename        # 打开或新建文件，并将光标置于第一行首
vim + filename      # 打开文件，并将光标置于最后一行首
vim +n filename     # 打开文件，并将光标置于第 n 行首
vim -c cmd file     # 在打开文件 file 前，先执行指定的Vim命令cmd
vim -b file         # 以二进制模式打开文件，该模式某些特殊字符 (如换行符 ^M) 都可以显示出来
vim -d file1 file2  # 使用Vim同时打开 file1 和 file2 文件并diff两个文件的差异
vim -r filename     # 在上次正用 vim编辑时发生系统崩溃，恢复文件
vim -R file         # 以只读形式打开文件，但是仍然可以使用 :wq! 写入
vim -M file         # 强制性关闭修改功能，无法使用 :wq! 写入 
vim -o file1 file2  # 终端中要打开vim文件时，横向分割显示多个文件
vim -O file1 file2  # 终端中要打开vim文件时，纵向分割显示多个文件
vim -x file         # 以加密方式打开文件
vim +/target file   # 打开 file 并将光标移动到找到的第一个 target 字符串上

已打开文件操作

1
2
3
4
5
6
7
8
9
10
:ls                 # 查案缓存列表
:bn                 # 切换到下一个缓存
:bp                 # 切换到上一个缓存
:bd                 # 删除缓存
:b 1                # 切换到1号缓存
:b abc              # 切换到文件名为 abc 开头的缓存
:badd <filename>    # 将文件添加到缓存列表
:set hidden         # 设置隐藏模式（未保存的缓存可以被切换走，或者关闭）
:set nohidden       # 关闭隐藏模式（未保存的缓存不能被切换走，或者关闭）
n Ctrl+^            # 切换缓存，先输入数字的缓存编号，再按 Ctrl + 6

窗口操作

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
:sp <filename>      # 上下切分窗口并在新窗口打开文件 filename
:vs <filename>      # 左右切分窗口并在新窗口打开文件 filename
:split              # 将当前窗口再复制一个纵向窗口出来，内容同步，游标可以不同
:vsplit             # 将当前窗口再复制一个横向窗口出来，内容同步，游标可以不同
Ctrl+W s            # 上下切分窗口
Ctrl+W v            # 左右切分窗口
Ctrl+W w            # 循环切换到下一个窗口
Ctrl+W W            # 循环切换到上一个窗口
Ctrl+W p            # 跳到上一个访问过的窗口
Ctrl+W c            # 关闭当前窗口
Ctrl+W o            # 关闭其他窗口
Ctrl+W h            # 跳到左边的窗口
Ctrl+W j            # 跳到下边的窗口
Ctrl+W k            # 跳到上边的窗口
Ctrl+W l            # 跳到右边的窗口
Ctrl+W +            # 增加当前窗口的行高，前面可以加数字
Ctrl+W -            # 减少当前窗口的行高，前面可以加数字
Ctrl+W <            # 减少当前窗口的列宽，前面可以加数字
Ctrl+W >            # 增加当前窗口的列宽，前面可以加数字
Ctrl+W =            # 让所有窗口宽高相同
Ctrl+W H            # 将当前窗口移动到最左边
Ctrl+W J            # 将当前窗口移动到最下边
Ctrl+W K            # 将当前窗口移动到最上边
Ctrl+W L            # 将当前窗口移动到最右边
Ctrl+W x            # 交换窗口
Ctrl+W f            # 在新窗口中打开名为光标下文件名的文件
Ctrl+W gf           # 在新标签页中打开名为光标下文件名的文件
Ctrl+W R            # 旋转窗口
Ctrl+W T            # 将当前窗口移到新的标签页中
Ctrl+W P            # 跳转到预览窗口
Ctrl+W z            # 关闭预览窗口
Ctrl+W _            # 纵向最大化当前窗口
Ctrl+W |            # 横向最大化当前窗口

标签页

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
:tabs               # 显示所有标签页
:tabe <filename>    # 在新标签页中打开文件 filename
:tabn               # 下一个标签页
:tabp               # 上一个标签页
:tabc               # 关闭当前标签页
:tabo               # 关闭其他标签页
:tabn n             # 切换到第n个标签页，比如 :tabn 3 切换到第三个标签页
:tabm n             # 标签移动
:tabfirst           # 切换到第一个标签页
:tablast            # 切换到最后一个标签页
:tab help           # 在标签页打开帮助
:tab drop <file>    # 如果文件已被其他标签页和窗口打开则跳过去，否则新标签打开
:tab split          # 在新的标签页中打开当前窗口里的文件
:tab ball           # 将缓存中所有文件用标签页打开
:set showtabline=?  # 设置为 0 就不显示标签页标签，1会按需显示，2会永久显示
ngt                 # 切换到第n个标签页，比如 2gt 将会切换到第二个标签页
gt                  # 下一个标签页
gT                  # 上一个标签页

书签

1
2
3
4
5
6
7
8
9
10
:marks              # 显示所有书签
ma                  # 保存当前位置到书签 a ，书签名小写字母为文件内，大写全局
'a                  # 跳转到书签 a所在的行
`a                  # 跳转到书签 a所在位置
`.                  # 跳转到上一次编辑的行
'A                  # 跳转到全文书签 A
['                  # 跳转到上一个书签
]'                  # 跳转到下一个书签
'<                  # 跳到上次可视模式选择区域的开始
'>                  # 跳到上次可视模式选择区域的结束

帮助信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
:h tutor            # 入门文档
:h quickref         # 快速帮助
:h index            # 查询 Vim 所有键盘命令定义
:h summary          # 帮助你更好的使用内置帮助系统
:h Ctrl+H           # 查询普通模式下 Ctrl+H 是干什么的
:h i_Ctrl+H         # 查询插入模式下 Ctrl+H 是干什么的
:h i_<Up>           # 查询插入模式下方向键上是干什么的
:h pattern.txt      # 正则表达式帮助
:h eval             # 脚本编写帮助
:h function-list    # 查看 VimScript 的函数列表 
:h windows.txt      # 窗口使用帮助
:h tabpage.txt      # 标签页使用帮助
:h +timers          # 显示对 +timers 特性的帮助
:h :!               # 查看如何运行外部命令
:h tips             # 查看 Vim 内置的常用技巧文档
:h set-termcap      # 查看如何设置按键扫描码
:viusage            # NORMAL 模式帮助
:exusage            # EX 命令帮助
:version            # 显示当前 Vim 的版本号和特性

外部命令

1
2
3
4
5
6
7
8
9
:!command           # 执行一次性shell命令，如下命令：:!pwd
:shell              # 启动一个交互的 shell 执行多个命令，exit命令退出并返回 Vim
:!ls                # 运行外部命令 ls，并等待返回
:r !ls              # 将外部命令 ls 的输出捕获，并插入到光标后
:w !sudo tee %      # sudo以后保存当前文件
:call system('ls')  # 调用 ls 命令，但是不显示返回内容
:!start notepad     # Windows 下启动 notepad，最前面可以加 silent
:sil !start cmd     # Windows 下当前目录打开 cmd
:%!prog             # 运行文字过滤程序，如整理 json格式 :%!python -m json.tool

Quickfix 窗口

1
2
3
4
5
6
7
8
:copen              # 打开 quickfix 窗口（查看编译，grep等信息）
:copen 10           # 打开 quickfix 窗口，并且设置高度为 10
:cclose             # 关闭 quickfix 窗口
:cfirst             # 跳到 quickfix 中第一个错误信息
:clast              # 跳到 quickfix 中最后一条错误信息
:cc [nr]            # 查看错误 [nr]
:cnext              # 跳到 quickfix 中下一个错误信息
:cprev              # 跳到 quickfix 中上一个错误信息

拼写检查

1
2
3
4
5
6
7
:set spell          # 打开拼写检查
:set nospell        # 关闭拼写检查
]s                  # 下一处错误拼写的单词
[s                  # 上一处错误拼写的单词
zg                  # 加入单词到拼写词表中
zug                 # 撤销上一次加入的单词
z=                  # 拼写建议

代码折叠

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
za                  # 切换折叠
zA                  # 递归切换折叠
zc                  # 折叠光标下代码
zC                  # 折叠光标下所有代码
zd                  # 删除光标下折叠
zD                  # # 递归删除所有折叠
zE                  # 删除所有折叠
zf                  # 创建代码折叠
zF                  # 指定行数创建折叠
zi                  # 切换折叠
zm                  # 所有代码折叠一层
zr                  # 所有代码打开一层
zM                  # 折叠所有代码，设置 foldlevel=0，设置 foldenable
zR                  # 打开所有代码，设置 foldlevel 为最大值
zn                  # 折叠 none，重置 foldenable 并打开所有代码
zN                  # 折叠 normal，重置 foldenable 并恢复所有折叠
zo                  # 打开一层代码
zO                  # 打开光标下所有代码折叠

文档加密解密

文档加密

加密方式打开文件时，并在屏幕左下角提示输入密码两次才可进行操作，保存文件退出后必须输入正常密码才能正确打开文件，否则会显示乱码。

1
2
3
vim -x file_name# 输入加密密码 -> 确认密码! 注意：不修改内容也要保存。:wq，不然密码设定不会生效。
:X # 命令行模式下，输入加密密码 -> 确认密码! 注意：不修改内容也要保存。:wq，不然密码设定不会生效。
:set key=密码# 命令行模式下，输入加密密码 -> 确认密码! 注意：不修改内容也要保存。:wq，不然密码设定不会生效。

文档解密

1
2
:X # 命令行模式下，提示输入密码，不输入而是按 Enter。注意：不修改内容也要保存。:wq，不然解密设定不会生效。
:set key=# 命令行模式下，设置key的密码为空。注意：不修改内容也要保存。:wq，不然密码设定不会生效。

宏录制

1
2
3
4
5
qa                  # 开始录制名字为 a 的宏
q                   # 结束录制宏
@a                  # 播放名字为 a 的宏
@@                  # 播放上一个宏
@:                  # 重复上一个ex命令（即冒号命令）

其他命令

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
Ctrl+X Ctrl+E       # 插入模式下向上滚屏
Ctrl+X Ctrl+Y       # 插入模式下向下滚屏
Ctrl+G              # 显示正在编辑的文件名，以及大小和位置信息
g Ctrl+G            # 显示文件的：大小，字符数，单词数和行数，可视模式下也可用
ga                  # 显示光标下字符的 ascii 码或者 unicode 编码
g8                  # 显示光标下字符的 utf-8 编码字节序
gi                  # 回到上次进入插入的地方，并切换到插入模式
K                   # 查询光标下单词的帮助
Ctrl+PgUp           # 上个标签页，GVim OK，部分终端软件需设置对应键盘码
Ctrl+PgDown         # 下个标签页，GVim OK，部分终端软件需设置对应键盘码
Ctrl+R Ctrl+W       # 命令模式下插入光标下单词
Ctrl+Insert         # 复制到系统剪贴板（GVIM）
Shift+Insert        # 粘贴系统剪贴板的内容（GVIM）
:set ff=unix        # 设置换行为 unix
:set ff=dos         # 设置换行为 dos
:set ff?            # 查看换行设置
:set nohl           # 清除搜索高亮
:set termcap        # 查看会从终端接收什么以及会发送给终端什么命令
:set guicursor=     # 解决 SecureCRT/PenguiNet 中 NeoVim 局部奇怪字符问题
:set t_RS= t_SH=    # 解决 SecureCRT/PenguiNet 中 Vim8.0 终端功能奇怪字符
:set fo+=a          # 开启文本段的实时自动格式化
:earlier 15m        # 回退到15分钟前的文件内容
:map                # 来查看当前 Vim 配置的 map 快捷键
:inoremap           # 来查看当前 Vim 配置的 inoremap 快捷键
:nnoremap           # 来查看当前 Vim 配置的 nnoremap 快捷键
:.!date             # 在当前窗口插入时间
:%!xxd              # 开始二进制编辑
:%!xxd -r           # 保存二进制编辑
:r !curl -sL {URL}  # 读取 url 内容添加到光标后
:g/^\s*$/d          # 删除空行
:g/green/d          # 删除所有包含 green 的行
:v/green/d          # 删除所有不包含 green 的行
:g/gladiolli/#      # 搜索单词打印结果，并在结果前加上行号
:g/ab.*cd.*efg/#    # 搜索包含 ab,cd 和 efg 的行，打印结果以及行号
:v/./,/./-j         # 压缩空行
:Man bash           # 在 Vim 中查看 man，先调用 :runtime! ftplugin/man.vim 激活
/fred\|joe          # 搜索 fred 或者 joe
/\<\d\d\d\d\>       # 精确搜索四个数字
/^\n\{3}            # 搜索连续三个空行

查看命令历史

命令行模式下：

1
2
:history                # 查看所有命令行模式下输入的命令历史
:history search或 / 或？ # 查看搜索历史

普通模式下：

1
2
3
q/                  # 查看使用/输入的搜索历史
q?                  # 查看使用？输入的搜索历史
q:                  # 查看命令行历史

寄存器

查看寄存器值

1
2
:reg                   # 查看所有寄存器值
:reg "{register_name}  # 查看指定寄存器值

调取寄存器值

1
2
3
"{register_name}        # 普通模式下调取寄存器值
:Ctrl+r "寄存器名称      # 命令模式下（输入 Ctrl+r 后Vim会自动打出"寄存器引用符号）
Ctrl+r 寄存器名称        # 插入模式下（无需输入寄存器引用符号"）

Vim寄存器分类

名称引用方式说明
无名寄存器“”默认寄存器，所有的复制和修改操作（x、s、d、c、y）都会将该数据复制到无名寄存器
字母寄存器“a - “z 或 “A - “Z{register_name}只能是一位的26个英文字母，从a-z，A-Z寄存器内容将会合并到对应小写字母内容后边
复制专用寄存器“0（数字0）仅当使用复制操作(y)时，该数据将会同时被复制到无名寄存器和复制专用寄存器
逐级临时缓存寄存器“1 - “9所有不带范围（‘(’，‘)’，‘{’，‘}’）、操作涉及1行以上的删除修改操作（x、s、d、c）的数据都会复制到逐级临时缓存寄存器，并在新的数据加入时，逐级先后推移。1的数据复制到2，2的复制到3，最后的9寄存器内容将会被删除
黑洞寄存器“_几乎所有的操作涉及的数据都会被复制到寄存器，如果想让操作的数据不经过寄存器，可以指定黑洞寄存器，数据到该寄存器就会消失掉，不能显示，也不存在
系统剪切板“+ 或”*与Vim外部的GUI交互数据时，需要使用专用的系统剪切板
表达式寄存器“=所有寄存器里最特殊的一个，用于计算表达式。输入完该寄存器应用后，会在命令行里提示“=”，按需输入表达式，结果将会显示到光标处
其他寄存器

Vim设置

编辑Vim配置文件：

1
2
:edit $MYVIMRC      # 在Vim的命令模式下使用该命令打开 vim 配置文件
:source $MYVIMRC    # Vim 配置文件的改动后，使用该命令为vim配置文件加载新的配置选项，如果vimrc文件恰好是当前活动的缓冲区，则可把此命令简化为:so %。

Vim配置说明：

注：Vim配置可以在命令模式下单个设置，只在当前窗口生效！

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
syntax              # 列出已经定义的语法项
syntax clear        # 清除已定义的语法规则
syntax on           # 允许语法高亮
syntax off          # 禁止语法高亮
set history=200     # 记录 200 条历史命令
set bs=?            #  设置BS键模式，现代编辑器为 :set bs=eol,start,indent
set sw=4            # 设置缩进宽度为 4
set ts=4            # 设置制表符宽度为 4
set noet            # 设置不展开 tab 成空格
set et              # 设置展开 tab 成空格
set winaltkeys=no   # 设置 GVim 下正常捕获 ALT 键
set nowrap          # 关闭自动换行
set ttimeout        # 允许终端按键检测超时（终端下功能键为一串ESC开头的扫描码）
set ttm=100         # 设置终端按键检测超时为100毫秒
set term=?          # 设置终端类型，比如常见的 xterm
set ignorecase      # 设置搜索是否忽略大小写
set smartcase       # 智能大小写，默认忽略大小写，除非搜索内容里包含大写字母
set list            # 设置显示制表符和换行符
set nu              # 设置显示行号，禁止显示行号可以用 :set nonu
set number          # 设置显示行号，禁止显示行号可以用 :set nonumber
set relativenumber  # 设置显示相对行号（其他行与当前行的距离）
set paste           # 进入粘贴模式（粘贴时禁用缩进等影响格式的东西）
set nopaste         # 结束粘贴模式
set spell           # 允许拼写检查
set hlsearch        # 设置高亮查找
set ruler           # 总是显示光标位置
set nocompatible    # 设置不兼容原始 vi 模式（必须设置在最开头）
set incsearch       # 查找输入时动态增量显示查找结果
set insertmode      # Vim 始终处于插入模式下，使用 Ctrl+o 临时执行命令
set all             # 列出所有选项设置情况

Vim插件

插件 - vim-commentary

vim-commentary：批量注释工具, 可以注释多行和去除多行注释。

1
2
3
4
5
gcc                 # 注释当前行
gc{motion}          # 注释 {motion} 所标注的区域，比如 gcap 注释整段
gci{                # 注释大括号内的内容
gc                  # 在 Visual Mode 下面按 gc 注释选中区域
:7,17Commentary     # 注释 7 到 17 行

插件 - nerdtree

nerdtree：该插件用于列出当前路径的目录树。

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
?                   # 快速帮助文档
o                   # 打开一个目录或者打开文件，创建的是buffer，也可以用来打开书签
go                  # 打开一个文件，但是光标仍然留在NERDTree，创建的是buffer
t                   # 打开一个文件，创建的是Tab，对书签同样生效
T                   # 打开一个文件，但是光标仍然留在NERDTree，创建的是Tab，对书签同样生效
i                   # 水平分割创建文件的窗口，创建的是buffer
gi                  # 水平分割创建文件的窗口，但是光标仍然留在NERDTree
s                   # 垂直分割创建文件的窗口，创建的是buffer
gs                  # 和gi，go类似
x                   # 收起当前打开的目录
X                   # 收起所有打开的目录
e                   # 以文件管理的方式打开选中的目录
D                   # 删除书签
P                   # 大写，跳转到当前根路径
p                   # 小写，跳转到光标所在的上一级路径
K                   # 跳转到第一个子路径
J                   # 跳转到最后一个子路径
Ctrl+j和Ctrl+k      # 在同级目录和文件间移动，忽略子目录和子文件
C                   # 将根路径设置为光标所在的目录
u                   # 设置上级目录为根路径
U                   # 设置上级目录为跟路径，但是维持原来目录打开的状态
r                   # 刷新光标所在的目录
R                   # 刷新当前根路径
I                   # 显示或者不显示隐藏文件
f                   # 打开和关闭文件过滤器
q                   # 关闭NERDTree
A                   # 全屏显示NERDTree，或者关闭全屏

插件 - asyncrun.vim

1
2
:AsyncRun ls        # 异步运行命令 ls 结果输出到 quickfix 使用 :copen 查看
:AsyncRun -raw ls   # 异步运行命令 ls 结果不匹配 errorformat

Vim模式

1
2
3
4
5
普通模式            # 按 Esc 或 Ctrl+[ 进入，左下角显示文件名或为空
插入模式            # 按i进入，左下角显示 --INSERT--
可视模式            # 按v进入，左下角显示 --VISUAL--
替换模式            # 按r或R开始，左下角显示 --REPLACE--
命令行模式          # 按 : 或者 / 或者 ? 开始

网络资源

TIPS

  • 永远不要用 Ctrl+C 代替 完全不同的含义，容易错误中断运行的后台脚本
  • 很多人使用 Ctrl+[ 代替 ，左手小指 Ctrl，右手小指 [ 熟练后很方便
  • 某些终端中使用 Vim 8 内嵌终端如看到奇怪字符，使用 :set t_RS= t_SH= 解决
  • 某些终端中使用 NeoVim 如看到奇怪字符，使用 :set guicursor= 解决
  • 多使用 ciw, ci[, ci”, ci( 以及 diw, di[, di”, di( 命令来快速改写/删除文本
  • 在行内左右移动光标时，多使用w b e或W B E，而不是h l或方向键，这样会快很多
  • Shift 相当于移动加速键， w b e 移动光标很慢，但是 W B E 走的很快
  • 自己要善于总结新技巧，比如移动到行首非空字符时用 0w 命令比 ^ 命令更容易输入
  • 在空白行使用 dip 命令可以删除所有临近的空白行，viw 可以选择连续空白
  • 缩进时使用 >8j >} ap =i} == 会方便很多
  • 插入模式下，当你发现一个单词写错了，应该多用 Ctrl+W 这比 快
  • y d c 命令可以很好结合 f t 和 /X 比如 dt) 和 y/end
  • c d x 命令会自动填充寄存器 “1 到 “9 , y 命令会自动填充 “0 寄存器
  • 用 v 命令选择文本时，可以用 o 掉头选择，有时很有用
  • 写文章时，可以写一段代码块，然后选中后执行 :!python 代码块就会被替换成结果
  • 搜索后经常使用 :nohl 来消除高亮，使用很频繁，可以 map 到 上
  • 搜索时可以用 Ctrl+R Ctrl+W 插入光标下的单词，命令模式也能这么用
  • 映射按键时，应该默认使用 noremap ，只有特别需要的时候使用 map
  • 当你觉得做某事很低效时，你应该停下来，然后思考正确的高效方式来完成
  • 用 y 复制文本后，命令模式中 Ctrl+R 然后按双引号 0 可以插入之前复制内容
  • Windows 下的 GVim 可以设置 set rop=type:directx,renmode:5 增强显示

书籍

Vim实用技巧

Vim键盘图

vim.png

参考

]]> Spring文件上传下载 https://chloneda.github.io//blog/spring-ud/ https://chloneda.github.io//blog/spring-ud/ Sun, 15 Mar 2020 08:35:47 GMT <p><strong>注：本文原链接</strong>：<a href="https://www.cnblogs.com/chloneda/p/spring-ud.html" target="_blank" rel="noopener">https://www.cnblogs.c 注：本文原链接：https://www.cnblogs.com/chloneda/p/spring-ud.html

前言

开发人员多少都会遇到文件的上传下载，特别是Java的Spring框架。那么我们能不能实现一些通用工具类，实现文件上传和下载的功能，可以有效地避免重复开发代码。

因此，我在网上查找了相关资料，并在此基础上加以改进,支持文件上传及下载功能，而且代码非常精简。如有问题，欢迎大家指正！

文件上传

文件上传及下载需要两个依赖：

1
2
3
4
5
6
7
8
9
10
11
12
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>
<!--tomcat中也有servlet-api包，避免冲突添加<scope>provided</scope>-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
</dependency>

Spring文件上传一般从请求中获取文件对象，或者直接上传文件获取文件对象。这里提供两个方法，可以满足以上两种情形！当然，如果想自定义文件上传路径，也可以在这两个方法的基础上再增加一个文件路径参数，具体还是看大家的需求情况吧！

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
package com.chloneda.utils;

import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.util.*;

/**
 * @author chloneda
 * @description: 文件上传工具类
 */
public class RequestUtils {

    /**
     * 获取请求中的文件并上传
     *
     * @param request    请求对象
     * @param useNewName 是否使用原文件名称
     */
    public static void uploadFileFromRequest(HttpServletRequest request, boolean useNewName)
            throws IOException {
        CommonsMultipartResolver multipartResolver =
                new CommonsMultipartResolver(request.getSession().getServletContext());
        /** 判断 request 是否有文件上传 */
        if (multipartResolver.isMultipart(request)) {
            /** 向上转型获取更多功能 */
            MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest) request;
            Iterator<String> iter = multiRequest.getFileNames();
            while (iter.hasNext()) {
                MultipartFile multipartFile = multiRequest.getFile(iter.next());
                if (multipartFile.isEmpty()) {
                    System.out.println("文件未上传!");
                    continue;
                }
                uploadFileFromMultipartFile(multipartFile, request, useNewName);
            }
        }
    }

    /**
     * 获取文件并上传至指定目录
     *
     * @param file       上传的文件
     * @param useNewName 是否使用原文件名称
     * @throws IOException
     */
    public static void uploadFileFromMultipartFile(
            MultipartFile file, HttpServletRequest request, boolean useNewName) throws IOException {
        /** 获取服务器项目发布运行所在地址 */
        String uploadDir = request.getSession().getServletContext().getRealPath("/") + "upload";
        String originalName = file.getOriginalFilename();
        /** 使用时间缀解决文件重名问题 */
        if (useNewName) {
            long timestamp = System.currentTimeMillis();
            originalName = timestamp + "-" + originalName;
        }
        String destFilePath = uploadDir + File.separator + originalName;
        file.transferTo(new File(destFilePath));
    }

}

文件下载

文件下载需要知道文件所在路径，并通过文件流的响应方式返回给前端下载，具体代码如下：

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
package com.chloneda.utils;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

/**
 * @author chloneda
 * @description: 返回文件流至浏览器
 */
public class ResponseUtils {

    /**
     * 返回文件流至前端进行展示
     *
     * @param srcFilePath
     * @param contentType 展示contentType一般是image/jpeg、jpg、gif、png等
     * @param response
     */
    public static void responseFileForShow(
            HttpServletResponse response, String srcFilePath, String contentType) {
        File file = checkFile(srcFilePath, false);
        responseFile(response, file, contentType, false);
    }

    /**
     * 返回文件流至前端进行下载
     *
     * @param srcFilePath 返回文件的具体路径
     * @param response
     */
    public static void responseFileForLoad(HttpServletResponse response, String srcFilePath) {
        File file = checkFile(srcFilePath, false);
        responseFile(response, file, "application/octet-stream", true);
    }

    /**
     * 使用response返回文件流
     *
     * @param response    response进行流的返回
     * @param file        要返回的具体文件
     * @param contentType contentType类型
     * @param isLoad      true时下载，false时展示
     */
    private static void responseFile(
            HttpServletResponse response, File file, String contentType, boolean isLoad) {
        try (BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
             BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream())) {
            response.setContentType(contentType);
            /** 如果是下载,指定文件名称 */
            if (isLoad) {
                String fileName = file.getName();
                /** 指定字符集解决下载文件名乱码 */
                response.setHeader("Content-disposition", "attachment;filename="
                        + URLEncoder.encode(fileName, StandardCharsets.UTF_8.name()));
            }
            byte[] buffer = new byte[8192];
            int count = 0;
            while ((count = in.read(buffer, 0, 8192)) != -1) {
                out.write(buffer, 0, count);
            }
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static File checkFile(String filePath, boolean create) {
        File file = new File(filePath);
        if (!file.exists()) {
            if (create) {
                file.mkdirs();
            } else {
                throw new IllegalArgumentException("文件不存在：{}！" + filePath);
            }
        }
        return file;
    }

}

小结

文件的上传下载是比较普遍的功能需求，这里通过请求响应的方式实现，可以满足日常的开发需求！

]]> pom.xml配置文件详解(Maven) https://chloneda.github.io//blog/maven-pom/ https://chloneda.github.io//blog/maven-pom/ Thu, 05 Mar 2020 02:00:27 GMT <p><strong>注</strong>：本文转载自：<a href="https://blog.csdn.net/u012152619/article/details/51485297" target="_blank" rel="noopener">https://blog. 注：本文转载自：https://blog.csdn.net/u012152619/article/details/51485297

注：博主 Chloneda：个人博客 | 博客园 | Github | Gitee | 知乎

最近打算对Maven的pom.xml文件进行一下深入研究，做一下总结，惊喜的是网上已经有比较详细的资料，为避免重复造轮子，所以转载了这篇文章。

前言

setting.xml主要用于配置maven的运行环境等一系列通用的属性，是全局级别的配置文件；而pom.xml主要描述了项目的maven坐标，依赖关系，开发者需要遵循的规则，缺陷管理系统，组织和licenses，以及其他所有的项目相关因素，是项目级别的配置文件。

基础配置

一个典型的pom.xml文件配置如下：

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
<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
<!-- 模型版本。maven2.0必须是这样写，现在是maven2唯一支持的版本 -->
<modelVersion>4.0.0</modelVersion>
 
<!-- 公司或者组织的唯一标志，并且配置时生成的路径也是由此生成， 如com.winner.trade，maven会将该项目打成的jar包放本地路径：/com/winner/trade -->
<groupId>com.winner.trade</groupId>
 
<!-- 本项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
<artifactId>trade-core</artifactId>
 
<!-- 本项目目前所处的版本号 -->
<version>1.0.0-SNAPSHOT</version>
 
<!-- 打包的机制，如pom,jar, maven-plugin, ejb, war, ear, rar, par，默认为jar -->
<packaging>jar</packaging>
 
<!-- 帮助定义构件输出的一些附属构件,附属构件与主构件对应，有时候需要加上classifier才能唯一的确定该构件 不能直接定义项目的classifer,因为附属构件不是项目直接默认生成的，而是由附加的插件帮助生成的 -->
<classifier>...</classifier>
 
<!-- 定义本项目的依赖关系 -->
<dependencies>
 
<!-- 每个dependency都对应这一个jar包 -->
<dependency>
 
<!--一般情况下，maven是通过groupId、artifactId、version这三个元素值（俗称坐标）来检索该构件， 然后引入你的工程。如果别人想引用你现在开发的这个项目（前提是已开发完毕并发布到了远程仓库），--> 
<!--就需要在他的pom文件中新建一个dependency节点，将本项目的groupId、artifactId、version写入， maven就会把你上传的jar包下载到他的本地 -->
<groupId>com.winner.trade</groupId>
<artifactId>trade-test</artifactId>
<version>1.0.0-SNAPSHOT</version>
 
<!-- maven认为，程序对外部的依赖会随着程序的所处阶段和应用场景而变化，所以maven中的依赖关系有作用域(scope)的限制。 -->
<!--scope包含如下的取值：compile（编译范围）、provided（已提供范围）、runtime（运行时范围）、test（测试范围）、system（系统范围） -->
<scope>test</scope>
 
            <!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖（必须描述group ID和 artifact 
        ID信息），如果group ID和artifact ID以外的一些信息没有描述，则通过group ID和artifact ID 匹配到这里的依赖，并使用这里的依赖信息。 -->
            <dependencyManagement>
                <dependencies>
                    <!--参见dependencies/dependency元素 -->
                    <dependency>
                        ......
                    </dependency>
                </dependencies>
            </dependencyManagement>
    
<!-- 设置指依赖是否可选，默认为false,即子项目默认都继承:为true,则子项目必需显示的引入，与dependencyManagement里定义的依赖类似  -->
<optional>false</optional>
 
<!-- 屏蔽依赖关系。 比如项目中使用的libA依赖某个库的1.0版，libB依赖某个库的2.0版，现在想统一使用2.0版，就应该屏蔽掉对1.0版的依赖 -->
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
</exclusions>

</dependency>
</dependencies>
 
<!-- 为pom定义一些常量，在pom中的其它地方可以直接引用 使用方式 如下 ：${file.encoding} -->
<properties>
<file.encoding>UTF-8</file.encoding>
<java.source.version>1.5</java.source.version>
<java.target.version>1.5</java.target.version>
</properties>
 
...
</project>

一般来说，上面的几个配置项对任何项目都是必不可少的，定义了项目的基本属性。

这里有必要对一个不太常用的属性classifier做一下解释，因为有时候引用某个jar包，classifier不写的话会报错。

classifier元素用来帮助定义构件输出的一些附属构件。附属构件与主构件对应，比如主构件是 kimi-app-2.0.0.jar，该项目可能还会通过使用一些插件生成 如kimi-app-2.0.0-javadoc.jar （Java文档）、 kimi-app-2.0.0-sources.jar（Java源代码） 这样两个附属构件。这时候，javadoc、sources就是这两个附属构件的classifier，这样附属构件也就拥有了自己唯一的坐标。

classifier的用途

  • maven download javadoc / sources jar包的时候，需要借助classifier指明要下载那个附属构件
  • 引入依赖的时候，有时候仅凭groupId、artifactId、version无法唯一的确定某个构件，需要借助classifier来进一步明确目标。比如JSON-lib，有时候会同一个版本会提供多个jar包，在JDK1.5环境下是一套，在JDK1.3环境下是一套：

引用它的时候就要注明JDK版本，否则maven不知道你到底需要哪一套jar包：

1
2
3
4
5
6
<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
    <classifier>jdk15</classifier>
</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
<build>
 
<!-- 产生的构件的文件名，默认值是${artifactId}-${version}。 -->
<finalName>myPorjectName</finalName>
 
<!-- 构建产生的所有文件存放的目录,默认为${basedir}/target，即项目根目录下的target -->
<directory>${basedir}/target</directory>
 
<!--当项目没有规定目标（Maven2叫做阶段（phase））时的默认值， -->
<!--必须跟命令行上的参数相同例如jar:jar，或者与某个阶段（phase）相同例如install、compile等 -->
<defaultGoal>install</defaultGoal>
 
<!--当filtering开关打开时，使用到的过滤器属性文件列表。 -->
<!--项目配置信息中诸如${spring.version}之类的占位符会被属性文件中的实际值替换掉 -->
<filters>
<filter>../filter.properties</filter>
</filters>
 
<!--项目相关的所有资源路径列表，例如和项目相关的配置文件、属性文件，这些资源被包含在最终的打包文件里。 -->
<resources>
<resource>
 
<!--描述了资源的目标路径。该路径相对target/classes目录（例如${project.build.outputDirectory}）。 -->
<!--举个例子，如果你想资源在特定的包里(org.apache.maven.messages)，你就必须该元素设置为org/apache/maven/messages。 -->
<!--然而，如果你只是想把资源放到源码目录结构里，就不需要该配置。 -->
<targetPath>resources</targetPath>
 
<!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性，文件在filters元素里列出。 -->
<filtering>true</filtering>
 
<!--描述存放资源的目录，该路径相对POM路径 -->
<directory>src/main/resources</directory>
 
<!--包含的模式列表 -->
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
 
<!--排除的模式列表 如果<include>与<exclude>划定的范围存在冲突，以<exclude>为准 -->
<excludes>
<exclude>jdbc.properties</exclude>
</excludes>
 
</resource>
</resources>
 
<!--单元测试相关的所有资源路径，配制方法与resources类似 -->
<testResources>
<testResource>
<targetPath />
<filtering />
<directory />
<includes />
<excludes />
</testResource>
</testResources>
 
<!--项目源码目录，当构建项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
<sourceDirectory>${basedir}\src\main\java</sourceDirectory>
 
<!--项目脚本源码目录，该目录和源码目录不同， <!-- 绝大多数情况下，该目录下的内容会被拷贝到输出目录(因为脚本是被解释的，而不是被编译的)。 -->
         <scriptSourceDirectory>${basedir}\src\main\scripts
         </scriptSourceDirectory>
 
<!--项目单元测试使用的源码目录，当测试项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
<testSourceDirectory>${basedir}\src\test\java</testSourceDirectory>
 
<!--被编译过的应用程序class文件存放的目录。 -->
<outputDirectory>${basedir}\target\classes</outputDirectory>
 
<!--被编译过的测试class文件存放的目录。 -->
<testOutputDirectory>
          ${basedir}\target\test-classes
</testOutputDirectory>
 
<!--项目的一系列构建扩展,它们是一系列build过程中要使用的产品，会包含在running bulid‘s classpath里面。 -->
<!--他们可以开启extensions，也可以通过提供条件来激活plugins。 -->
<!--简单来讲，extensions是在build过程被激活的产品 -->
<extensions>
 
<!--例如，通常情况下，程序开发完成后部署到线上Linux服务器，可能需要经历打包、 -->
<!--将包文件传到服务器、SSH连上服务器、敲命令启动程序等一系列繁琐的步骤。 -->
<!--实际上这些步骤都可以通过Maven的一个插件 wagon-maven-plugin 来自动完成 -->
<!--下面的扩展插件wagon-ssh用于通过SSH的方式连接远程服务器， -->
<!--类似的还有支持ftp方式的wagon-ftp插件 -->
<extension>
<groupId>org.apache.maven.wagon</groupId>
<artifactId>wagon-ssh</artifactId>
<version>2.8</version>
</extension>
 
</extensions>
 
<!--使用的插件列表 。 -->
<plugins>
<plugin>
<groupId></groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.5.5</version>
 
<!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。 -->
<executions>
<execution>
 
<!--执行目标的标识符，用于标识构建过程中的目标，或者匹配继承过程中需要合并的执行目标 -->
<id>assembly</id>
 
<!--绑定了目标的构建生命周期阶段，如果省略，目标会被绑定到源数据里配置的默认阶段 -->
<phase>package</phase>
 
<!--配置的执行目标 -->
<goals>
<goal>single</goal>
</goals>
 
<!--配置是否被传播到子POM -->
<inherited>false</inherited>
 
</execution>
</executions>
 
<!--作为DOM对象的配置,配置项因插件而异 -->
<configuration>
<finalName>${finalName}</finalName>
<appendAssemblyId>false</appendAssemblyId>
<descriptor>assembly.xml</descriptor>
</configuration>
 
<!--是否从该插件下载Maven扩展（例如打包和类型处理器）， -->
<!--由于性能原因，只有在真需要下载时，该元素才被设置成true。 -->
<extensions>false</extensions>
 
<!--项目引入插件所需要的额外依赖 -->
<dependencies>
<dependency>...</dependency>
</dependencies>
 
<!--任何配置是否被传播到子项目 -->
<inherited>true</inherited>
 
</plugin>
</plugins>
 
<!--主要定义插件的共同元素、扩展元素集合，类似于dependencyManagement， -->
<!--所有继承于此项目的子项目都能使用。该插件配置项直到被引用时才会被解析或绑定到生命周期。 -->
<!--给定插件的任何本地配置都会覆盖这里的配置 -->
<pluginManagement>
<plugins>...</plugins>
</pluginManagement>
 
</build>

pom里面的仓库与setting.xml里的仓库功能是一样的。主要的区别在于，pom里的仓库是个性化的。比如一家大公司里的setting文件是公用的，所有项目都用一个setting文件，但各个子项目却会引用不同的第三方库，所以就需要在pom里设置自己需要的仓库地址。

分发配置

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
<!--项目分发信息，在执行mvn deploy后表示要发布的位置。 -->
<!--有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。 -->
<distributionManagement>
 
<!--部署项目产生的构件到远程仓库需要的信息 -->
<repository>
 
<!--是分配给快照一个唯一的版本号（由时间戳和构建流水号），还是每次都使用相同的版本号 -->
<!--参见repositories/repository元素 -->
<uniqueVersion>true</uniqueVersion>
 
<id> repo-id </id>
<name> repo-name</name>
<url>file://${basedir}/target/deploy </url>
<layout />
 
</repository>
 
<!--构件的快照部署到哪里,如果没有配置该元素，默认部署到repository元素配置的仓库 -->
<snapshotRepository>
<uniqueVersion />
<id />
<name />
<url />
<layout />
</snapshotRepository>
 
<!--部署项目的网站需要的信息 -->
<site>
 
<!--部署位置的唯一标识符，用来匹配站点和settings.xml文件里的配置 -->
<id> site-id </id>
 
<!--部署位置的名称 -->
<name> site-name</name>
 
<!--部署位置的URL，按protocol://hostname/path形式 -->
<url>scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web </url>
 
</site>
 
<!--项目下载页面的URL。如果没有该元素，用户应该参考主页。 -->
<!--使用该元素的原因是：帮助定位那些不在仓库里的构件（由于license限制）。 -->
<downloadUrl />
 
<!--如果构件有了新的groupID和artifact ID（构件移到了新的位置），这里列出构件的重定位信息。 -->
<relocation>
 
<!--构件新的group ID -->
<groupId />
 
<!--构件新的artifact ID -->
<artifactId />
 
<!--构件新的版本号 -->
<version />
 
<!--显示给用户的，关于移动的额外信息，例如原因。 -->
<message />
 
</relocation>
 
<!--给出该构件在远程仓库的状态。不得在本地项目中设置该元素，因为这是工具自动更新的。 -->
<!--有效的值有：none（默认），converted（仓库管理员从Maven 1 POM转换过来）， -->
<!--partner（直接从伙伴Maven 2仓库同步过来），deployed（从Maven 2实例部署），verified（被核实时正确的和最终的）。 -->
<status />
 
</distributionManagement>

仓库配置

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
<!--发现依赖和扩展的远程仓库列表。 -->
<repositories>
 
<!--包含需要连接到远程仓库的信息 -->
<repository>
 
<!--如何处理远程仓库里发布版本的下载 -->
<releases>
 
<!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。 -->
<enabled />
 
<!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。 -->
<!--这里的选项是：always（一直），daily（默认，每日）， -->
<!--interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
<updatePolicy />
 
<!--当Maven验证构件校验文件失败时该怎么做： -->
<!--ignore（忽略），fail（失败），或者warn（警告）。 -->
<checksumPolicy />
 
</releases>
 
<!--如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置， -->
<!--POM就可以在每个单独的仓库中，为每种类型的构件采取不同的策略。 -->
<!--例如，可能有人会决定只为开发目的开启对快照版本下载的支持 -->
<snapshots>
<enabled />
<updatePolicy />
<checksumPolicy />
</snapshots>
 
<!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库 -->
<id> repo-id </id>
 
<!--远程仓库名称 -->
<name> repo-name</name>
 
<!--远程仓库URL，按protocol://hostname/path形式 -->
<url>http://192.168.1.169:9999/repository/ </url>
 
<!--用于定位和排序构件的仓库布局类型-可以是default（默认）或者legacy（遗留）。 -->
<!--Maven 2为其仓库提供了一个默认的布局； -->
<!--然而，Maven1.x有一种不同的布局。 -->
<!--我们可以使用该元素指定布局是default（默认）还是legacy（遗留）。 -->
<layout> default</layout>
 
</repository>
 
</repositories>
 
<!--发现插件的远程仓库列表，这些插件用于构建和报表 -->
<pluginRepositories>
 
<!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素 -->
<pluginRepository />
 
</pluginRepositories>

profile配置

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
<!--在列的项目构建profile，如果被激活，会修改构建处理 -->
<profiles>
 
<!--根据环境参数或命令行参数激活某个构建处理 -->
<profile>
<!--自动触发profile的条件逻辑。Activation是profile的开启钥匙。 -->
<activation>
 
<!--profile默认是否激活的标识 -->
<activeByDefault>false</activeByDefault>
 
<!--activation有一个内建的java版本检测，如果检测到jdk版本与期待的一样，profile被激活。 -->
<jdk>1.7</jdk>
 
<!--当匹配的操作系统属性被检测到，profile被激活。os元素可以定义一些操作系统相关的属性。 -->
<os>
 
<!--激活profile的操作系统的名字 -->
<name>Windows XP</name>
 
<!--激活profile的操作系统所属家族(如 'windows') -->
<family>Windows</family>
 
<!--激活profile的操作系统体系结构 -->
<arch>x86</arch>
 
<!--激活profile的操作系统版本 -->
<version>5.1.2600</version>
 
</os>
 
<!--如果Maven检测到某一个属性（其值可以在POM中通过${名称}引用），其拥有对应的名称和值，Profile就会被激活。 -->
<!-- 如果值字段是空的，那么存在属性名称字段就会激活profile，否则按区分大小写方式匹配属性值字段 -->
<property>
 
<!--激活profile的属性的名称 -->
<name>mavenVersion</name>
 
<!--激活profile的属性的值 -->
<value>2.0.3</value>
 
</property>
 
<!--提供一个文件名，通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在，如果不存在则激活profile。 -->
<!--另一方面，exists则会检查文件是否存在，如果存在则激活profile。 -->
<file>
 
<!--如果指定的文件存在，则激活profile。 -->
<exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists>
 
<!--如果指定的文件不存在，则激活profile。 -->
<missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>
 
</file>
 
</activation>
<id />
<build />
<modules />
<repositories />
<pluginRepositories />
<dependencies />
<reporting />
<dependencyManagement />
<distributionManagement />
<properties />
</profile>

profile配置项在setting.xml中也有，是pom.xml中profile元素的裁剪版本，包含了id，activation, repositories, pluginRepositories和 properties元素。这里的profile元素只包含这五个子元素是因为setting.xml只关心构建系统这个整体（这正是settings.xml文件的角色定位），而非单独的项目对象模型设置。如果一个settings中的profile被激活，它的值会覆盖任何其它定义在POM中或者profile.xml中的带有相同id的profile。

pom.xml中的profile可以看做pom.xml的副本，拥有与pom.xml相同的子元素与配置方法。它包含可选的activation（profile的触发器）和一系列的changes。例如test过程可能会指向不同的数据库（相对最终的deployment）或者不同的dependencies或者不同的repositories，并且是根据不同的JDK来改变的。只需要其中一个成立就可以激活profile，如果第一个条件满足了，那么后面就不会在进行匹配。

报表配置

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
<!--描述使用报表插件产生报表的规范,特定的maven 插件能输出相应的定制和配置报表. -->
<!--当用户执行“mvn site”，这些报表就会运行,在页面导航栏能看到所有报表的链接。 -->
<reporting>
 
<!--true，则网站不包括默认的报表。这包括“项目信息”菜单中的报表。 -->
<excludeDefaults />
 
<!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。 -->
<outputDirectory />
 
<!--使用的报表插件和他们的配置。 -->
<plugins>
 
<plugin>
<groupId />
<artifactId />
<version />
<inherited />
<configuration>
<links>
<link>http://java.sun.com/j2se/1.5.0/docs/api/</link>
</links>
</configuration>
<!--一组报表的多重规范，每个规范可能有不同的配置。 -->
<!--一个规范（报表集）对应一个执行目标 。例如，有1，2，3，4，5，6，7，8，9个报表。 -->
<!--1，2，5构成A报表集，对应一个执行目标。2，5，8构成B报表集，对应另一个执行目标 -->
<reportSets>
 
<!--表示报表的一个集合，以及产生该集合的配置 -->
<reportSet>
 
<!--报表集合的唯一标识符，POM继承时用到 -->
<id>sunlink</id>
 
<!--产生报表集合时，被使用的报表的配置 -->
<configuration />
 
<!--配置是否被继承到子POMs -->
<inherited />
 
<!--这个集合里使用到哪些报表 -->
<reports>
<report>javadoc</report>
</reports>
 
</reportSet>
 
</reportSets>
 
</plugin>
 
</plugins>
 
</reporting>

环境配置

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
<!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL，本例为 jira -->
<issueManagement>
 
<!--问题管理系统（例如jira）的名字， -->
<system> jira </system>
 
<!--该项目使用的问题管理系统的URL -->
<url> http://jira.clf.com/</url>
 
</issueManagement>
 
<!--项目持续集成信息 -->
<ciManagement>
 
<!--持续集成系统的名字，例如continuum -->
<system />
 
<!--该项目使用的持续集成系统的URL（如果持续集成系统有web接口的话）。 -->
<url />
 
<!--构建完成时，需要通知的开发者/用户的配置项。包括被通知者信息和通知条件（错误，失败，成功，警告） -->
<notifiers>
 
<!--配置一种方式，当构建中断时，以该方式通知用户/开发者 -->
<notifier>
 
<!--传送通知的途径 -->
<type />
 
<!--发生错误时是否通知 -->
<sendOnError />
 
<!--构建失败时是否通知 -->
<sendOnFailure />
 
<!--构建成功时是否通知 -->
<sendOnSuccess />
 
<!--发生警告时是否通知 -->
<sendOnWarning />
 
<!--不赞成使用。通知发送到哪里 -->
<address />
 
<!--扩展配置项 -->
<configuration />
 
</notifier>
 
</notifiers>
 
</ciManagement>

项目信息配置

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
<!--项目的名称, Maven产生的文档用 -->
<name>banseon-maven </name>
 
<!--项目主页的URL, Maven产生的文档用 -->
<url>http://www.clf.com/ </url>
 
<!--项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时 -->
<!--（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标签），不鼓励使用纯文本描述。 -->
<!-- 如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。 -->
<description>A maven project to study maven. </description>
 
<!--描述了这个项目构建环境中的前提条件。 -->
<prerequisites>
 
<!--构建该项目或使用该插件所需要的Maven的最低版本 -->
<maven />
 
</prerequisites>
 
<!--项目创建年份，4位数字。当产生版权信息时需要使用这个值。 -->
<inceptionYear />
 
<!--项目相关邮件列表信息 -->
<mailingLists>
 
<!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。 -->
<mailingList>
 
<!--邮件的名称 -->
<name> Demo </name>
 
<!--发送邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<post> clf@126.com</post>
 
<!--订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<subscribe> clf@126.com</subscribe>
 
<!--取消订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
<unsubscribe> clf@126.com</unsubscribe>
 
<!--你可以浏览邮件信息的URL -->
<archive> http:/hi.clf.com/</archive>
 
</mailingList>
 
</mailingLists>
 
<!--项目开发者列表 -->
<developers>
 
<!--某个项目开发者的信息 -->
<developer>
 
<!--SCM里项目开发者的唯一标识符 -->
<id> HELLO WORLD </id>
 
<!--项目开发者的全名 -->
<name> banseon </name>
 
<!--项目开发者的email -->
<email> banseon@126.com</email>
 
<!--项目开发者的主页的URL -->
<url />
 
<!--项目开发者在项目中扮演的角色，角色元素描述了各种角色 -->
<roles>
<role> Project Manager</role>
<role>Architect </role>
</roles>
 
<!--项目开发者所属组织 -->
<organization> demo</organization>
 
<!--项目开发者所属组织的URL -->
<organizationUrl>http://hi.clf.com/ </organizationUrl>
 
<!--项目开发者属性，如即时消息如何处理等 -->
<properties>
<dept> No </dept>
</properties>
 
<!--项目开发者所在时区， -11到12范围内的整数。 -->
<timezone> -5</timezone>
 
</developer>
 
</developers>
 
<!--项目的其他贡献者列表 -->
<contributors>
 
<!--项目的其他贡献者。参见developers/developer元素 -->
<contributor>
<name />
<email />
<url />
<organization />
<organizationUrl />
<roles />
<timezone />
<properties />
</contributor>
 
</contributors>
 
<!--该元素描述了项目所有License列表。应该只列出该项目的license列表，不要列出依赖项目的license列表。 -->
<!--如果列出多个license，用户可以选择它们中的一个而不是接受所有license。 -->
<licenses>
 
<!--描述了项目的license，用于生成项目的web站点的license页面，其他一些报表和validation也会用到该元素。 -->
<license>
 
<!--license用于法律上的名称 -->
<name> Apache 2 </name>
 
<!--官方的license正文页面的URL -->
<url>http://www.clf.com/LICENSE-2.0.txt </url>
 
<!--项目分发的主要方式： repo，可以从Maven库下载 manual， 用户必须手动下载和安装依赖 -->
<distribution> repo</distribution>
 
<!--关于license的补充信息 -->
<comments> Abusiness-friendly OSS license </comments>
 
</license>
 
</licenses>
 
<!--SCM(Source Control Management)标签允许你配置你的代码库，供Maven web站点和其它插件使用。 -->
<scm>
 
<!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情，请看SCMs提供的URL格式和列表。该连接只读。 -->
<connection>scm:svn:http://svn.baidu.com/banseon/maven/</connection>
 
<!--给开发者使用的，类似connection元素。即该连接不仅仅只读 -->
<developerConnection>scm:svn:http://svn.baidu.com/banseon/maven/
</developerConnection>
 
<!--当前代码的标签，在开发阶段默认为HEAD -->
<tag />
 
<!--指向项目的可浏览SCM库（例如ViewVC或者Fisheye）的URL。 -->
<url> http://svn.baidu.com/banseon</url>
 
</scm>
 
<!--描述项目所属组织的各种属性。Maven产生的文档用 -->
<organization>
 
<!--组织的全名 -->
<name> demo </name>
 
<!--组织主页的URL -->
<url> http://www.clf.com/</url>
 
</organization>

Maven POM

]]> Java基础系列-如何优雅地使用close() https://chloneda.github.io//blog/java-close/ https://chloneda.github.io//blog/java-close/ Thu, 05 Mar 2020 01:58:22 GMT <p><strong>注：本文出自博主 Chloneda</strong>：<a href="https://chloneda.github.io/">个人博客</a> | <a href="https://www.cnblogs.com/chloneda" target="_b 注：本文出自博主 Chloneda：个人博客 | 博客园 | Github | Gitee | 知乎

前言

本文尽量采用通俗易懂、循序渐进的方式，让大家真正优雅地使用close()方法！

问题场景

平时我们使用资源后一般都会关闭资源，即close()方法，但这个步骤重复性很高，还面临上述执行顺序不明的风险，而且很多人还是不能正确合理地关闭资源。

我们来看看close()是怎么错误地关闭资源的？

错误的close()

先来看看如下的错误关闭资源方式：

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
package com.chloneda.jutils.test;

import java.sql.*;

/**
 * @author chloneda
 * @description: close()方法测试
 * 错误的close()
 */
public class CloseTest {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            //1.加载驱动程序
            Class.forName("com.mysql.jdbc.Driver");
            //2.获得数据库链接
            conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/common", "root", "123456");
            //3.通过数据库的连接操作数据库，实现增删改查
            st = conn.createStatement();
            rs = st.executeQuery("select * from new_table");
            //4.处理数据库的返回结果
            while (rs.next()) {
                System.out.println(rs.getString("id") + " " + rs.getString("name"));
            }
            //5.关闭资源
            rs.close();
            st.close();
            conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

上面代码的资源关闭写在了try代码块中，一旦close方法调用之前(比如3步骤)就抛出异常，那么关闭资源的代码就永远不会得到执行。

如果我们把关闭资源的代码放在finally中行不行呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
try {
    //1.加载驱动程序
    Class.forName("com.mysql.jdbc.Driver");
    //2.获得数据库链接
    conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/common", "root", "123456");
    //3.通过数据库的连接操作数据库，实现增删改查
    st = conn.createStatement();
    rs = st.executeQuery("select * from new_table");
    //4.处理数据库的返回结果
    while (rs.next()) {
        System.out.println(rs.getString("id") + " " + rs.getString("name"));
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //5.关闭资源
    try {
        rs.close();
        st.close();
        conn.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

答案是不行！如果在 2步骤 的try中conn获得数据库链接抛出异常，那么conn仍然为null，此时进入finally代码块中，执行close()就报空指针异常了，关闭资源没有意义！因此，我们需要在close()之前判断一下conn等是否为空，只有不为空的时候才需要close。

常见的close()

针对上述场景，得到常见的使用close()方式如下：

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
/**
 * @author chloneda
 * @description: close()方法测试
 * 常见的close()
 */
public class CloseTest {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            //1.加载驱动程序
            Class.forName("com.mysql.jdbc.Driver");
            //2.获得数据库链接
            conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/common", "root", "123456");
            //3.通过数据库的连接操作数据库，实现增删改查
            st = conn.createStatement();
            rs = st.executeQuery("select * from new_table");
            //4.处理数据库的返回结果
            while (rs.next()) {
                System.out.println(rs.getString("id") + " " + rs.getString("name"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.关闭资源
            if (null != rs) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (null != st) {
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (null != conn) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

这是常见的close()！但是finally代码块的代码重复性太高了，这还只是三个资源的关闭，如果有很多个资源需要在finally中关闭，那不是需要编写很多不优雅的代码？其实，关闭资源是没啥逻辑的代码，我们需要精简代码，减少代码重复性，优雅地编程！

使用AutoCloseable接口

自从Java7以后，我们可以使用 AutoCloseable接口 (Closeable接口也可以)来优雅的关闭资源了 看看修改例子：

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
/**
 * @author chloneda
 * @description: close()方法测试
 * 使用AutoCloseable接口
 */
public class CloseTest {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            //1.加载驱动程序
            Class.forName("com.mysql.jdbc.Driver");
            //2.获得数据库链接
            conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/common", "root", "123456");
            //3.通过数据库的连接操作数据库，实现增删改查
            st = conn.createStatement();
            rs = st.executeQuery("select * from new_table");
            //4.处理数据库的返回结果
            while (rs.next()) {
                System.out.println(rs.getString("id") + " " + rs.getString("name"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.关闭资源，调用自定义的close()方法
            close(rs);
            close(st);
            close(conn);
        }
    }

    public static void close(AutoCloseable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

上面的finally代码块的代码量是不是减少了许多，就单纯地调用的静态的 close(AutoCloseable closeable) 方法。为什么可以这样呢？

其实Connection、Statement、ResultSet三个接口都继承了AutoCloseable接口。所以只要涉及到资源的关闭，继承了AutoCloseable接口，实现了close()方法，我们都可以调用 close(AutoCloseable closeable) 方法进行资源关闭。

此外，java IO流的很多类都实现了 Closeable接口，而Closeable接口又继承自 AutoCloseable接口，也可以调用上面的 close(AutoCloseable closeable) 方法进行资源关闭。是不是一语惊醒梦中人啊？

使用try-with-resources

其实Java7以后，还有一种关闭资源的方式，也就是 try-with-resources，这种方式也是我们推荐的！很优雅！

我们来看看它是怎么优雅地关闭资源的！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * @author chloneda
 * @description: close()方法测试
 * 使用try-with-resources
 */
public class CloseTest {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.加载驱动程序
        Class.forName("com.mysql.jdbc.Driver");
        try (//2.获得数据库链接
             Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/common", "root", "123456");
             //3.通过数据库的连接操作数据库，实现增删改查
             Statement st = conn.createStatement();
             ResultSet rs = st.executeQuery("select * from new_table")
        ) {
            //4.处理数据库的返回结果
            while (rs.next()) {
                System.out.println(rs.getString("id") + " " + rs.getString("name"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这种方式就省略了finally，不必重复编写关闭资源的代码了！而且资源也得到了关闭！怎么验证这个问题？可以查看底下的 实际应用 章节！

其实try-with-resources关闭资源的操作，本质上是继承了java.lang.AutoCloseable接口，实现了close方法，所以使用try-with-resources能关闭资源。很神奇吧！

实际应用

这个章节就是验证使用try-with-resources可以关闭资源的问题的！

上面我们说了使用try-with-resources关闭资源，只要是继承了java.lang.AutoCloseable接口 实现close()方法就可以使用！

我们自定义一个资源类，来看看实际应用吧！

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
package com.chloneda.jutils.test;

/**
 * @author chloneda
 * @description: 资源类, 实现AutoCloseable接口.
 */
public class Resources implements AutoCloseable {
    public void useResource() {
        System.out.println("useResource:{} 正在使用资源!");
    }

    @Override
    public void close() {
        System.out.println("close:{} 自动关闭资源!");
    }
}

/**
 * @description: 使用try-with-resources自动关闭资源测试.
 */
class AutoClosableTest {
    public static void main(String[] args) {
        /** 使用try-with-resource，自动关闭资源 */
        try (
                Resources resource = new Resources()
        ) {
            resource.useResource();
        } catch (Exception e) {
            e.getMessage();
        } finally {
            System.out.println("Finally!");
        }
    }
}

结果输出。

1
2
3
useResource:{} 正在使用资源!
close:{} 自动关闭资源!
Finally!

看到运行结果了吗？Resources类实现AutoCloseable接口，实现了close()方法，try-with-resources 就会自动关闭资源！

一旦Resources类没有继承java.lang.AutoCloseable接口，没有实现close()方法，AutoClosableTest类的try模块就在编译期报错，提示信息如下。

1
2
3
Incompatible types.
Required: java.lang.AutoCloseable
Found: com.chloneda.jutils.test.Resources

最后，需要说明的是try-with-resources就是一个JVM语法糖！关于JVM语法糖可以查查相关资料，看看Java中有哪些有趣的语法糖！

尾语

《Effective Java》在第三版中也推荐使用try-with-resources语句替代try-finally语句。

所以在处理必须关闭的资源时，使用try-with-resources语句替代try-finally语句。生成的代码更简洁，更清晰，并且生成的异常更有用。 try-with-resources语句在编写必须关闭资源的代码时会更容易，也不会出错，而使用try-finally语句实际上是不可能的。

如此，推荐大家使用try-with-resources优雅地关闭资源！

]]>