zsh必备插件

首先是 oh-my-zsh 自带的 alias 插件，这些东西能让你在终端少打很多字：

1. git

定义了有关 git 的 alias。常用的有

• gaa = git add –all
• gcmsg = git commit -m
• ga = git add
• gst = git status
• gp = git push

2. tmux

定义了有关 tmux 的 alias。常用的有

• tl = tmux list-sessions
• tkss = tmux kill-session -t
• ta = tmux attach -t
• ts = tmux new-session -s

然后是 oh-my-zsh 自带的，一些提供实用命令的插件。

1. extract

提供一个 extract 命令，以及它的别名 x。功能是：一！键！解！压！你知道tar的四种写法吗？我也不知道，所以我装了这个。从今以后 tar, gz, zip, rar 全部使用 extract 命令解压，再也不用天天查 cheatsheet 啦！

2. rand-quote

提供一条 quote 命令，显示随机名言。和fortune的作用差不多，但是我感觉fortune上面大多是冷笑话，还是quote的内容比较有意思。

当然这种东西很少有人会主动去按的。所以你可以在你的zshrc里面的最后一行加上quote，实现每次打开shell显示一条名言的效果～

再进一步，安装一个cowsay，把quote | cowsay放到zshrc的最后一行。于是每次打开终端你就可以看到一头牛对你说：

3. themes

提供一条 theme 命令，用来随时手动切换主题。在想要尝试各种主题的时候很实用，不需要一直改 zshrc 然后重载。

4. gitignore

提供一条 gi 命令，用来查询 gitignore 模板。比如你新建了一个 python 项目，就可以用

1

gi python > .gitignore 

来生成一份 gitignore 文件。

5. cp

提供一个 cpv 命令，这个命令使用 rsync 实现带进度条的复制功能。

6. zsh_reload

提供一个 src 命令，重载 zsh。对于经常折腾 zshrc 的我，这条命令非常实用。

7. git-open

提供一个 git-open 命令，在浏览器中打开当前所在 git 项目的远程仓库地址。

8. z

提供一个 z 命令，在常用目录之间跳转。类似 autojump，但是不需要额外安装软件。

接着是 oh-my-zsh 自带的，其他一些功能强大的实用工具。

1. vi-mode

vim输入模式，非常强大，不用多说。

2. per-directory-history

开启之后在一个目录下只能查询到这个目录下的历史命令。按 Ctrl+g 开启/关闭。对我来说很实用，但是不一定所有人都喜欢，可以考虑一下自己是否真的需要。

3. command-not-found

当你输入一条不存在的命令时，会自动查询这条命令可以如何获得。

4. safe-paste

像我这样的懒人，经常会从网上复制各种脚本。但是复制的命令有可能并不就是我要的，可能还需要改一改。但是往往我复制了几行脚本，粘贴到 zsh 里，就发现它直接运行了。这真是非常危险。

这个插件的功能就是：当你往 zsh 粘贴脚本时，它不会被立刻运行。给了我这种懒人修改别人脚本的机会。

5. colored-man-pages

给你带颜色的 man 命令。

6. sudo

apt 忘了加 sudo？开启这个插件，双击 Esc，zsh 会把上一条命令加上 sudo 给你。

7. history-substring-search

一般人会在 zsh 中绑定 history-search-backward 与 histor-search-forward 两个功能。

1
2

bindkey '^P' history-search-backward
bindkey '^N' history-search-forward

这样子，就可以在输入一个命令，比如 git 之后，按 Ctrl-P 与 Ctrl-N 在以 git为前缀的历史记录中浏览，非常方便。

但是这个做法有一个问题，就是这个功能只考虑输入的第一个单词。也就是说，如果之前输入了 git status, git commit, git push 等等命令，那么我输入 “git s” 再 Ctrl-P，并不会锁定到 “git status”, 而是会在所有以 git 开头的历史命令中循环。

这个插件的功能就是实现了一对更好用的 history-search-backward 与 histor-search-forward ，解决了上面所说的问题。开启之后，需要绑定按键：

1
2

bindkey '^P' history-substring-search-up
bindkey '^N' history-substring-search-down

这样子就可以以自己输入的所有内容为前缀，进行历史查找了。

然后下面是需要单独安装的：

1. zplug

zsh 的插件管理器，类似 vim 的 vundle，把你需要的所有插件写到 zshrc 里，然后运行 zplug install 就可以安装这些插件。就像这样：

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

if [[ -f ~/.zplug/init.zsh ]] {
  source ~/.zplug/init.zsh

  zplug "zsh-users/zsh-syntax-highlighting"
  zplug "zsh-users/zsh-autosuggestions"
  zplug "supercrabtree/k"
  zplug "denisidoro/navi"
  zplug "MichaelAquilina/zsh-you-should-use"
  zplug "changyuheng/zsh-interactive-cd"
  zplug "SleepyBag/zsh-confer"

  zplug "Powerlevel9k/powerlevel9k", from:github, as:theme, if:"[[ $ZSH_THEME_STYLE == 9k ]]"
  zplug "denysdovhan/spaceship-prompt", use:spaceship.zsh-theme, from:github, as:theme, if:"[[ $ZSH_THEME_STYLE == spaceship ]]"
  zplug "caiogondim/bullet-train.zsh", use:bullet-train.zsh-theme, from:github, as:theme, if:"[[ $ZSH_THEME_STYLE == bullet ]]"
  zplug "skylerlee/zeta-zsh-theme", from:github, as:theme, if:"[[ $ZSH_THEME_STYLE == zeta ]]"

  if ! zplug check --verbose; then
      echo 'Run "zplug install" to install'
  fi
  # Then, source plugins and add commands to $PATH
  zplug load
}

这个工具不仅可以用来装 zsh 插件，事实上它可以用来自动安装任何你认为有必要的插件、主题、脚本甚至二进制程序。但是对于非 zsh 插件的程序，在安装之前要先看看 zplug 的文档，搞清楚如何安装。

2. zsh-syntax-highlighting

shell 命令的代码高亮。你没有理由拒绝高亮。

3. zsh-autosuggestions

在输入命令的过程中根据你的历史记录显示你可能想要输入的命令，按 tab 补全。

不过 tab 键似乎与 zsh 的补全有冲突，所以我改成了 ctrl-y 直接运行命令，关于如何修改快捷键，项目主页上也有写。

在校外时利用Easy Connect连接西工大校园内网（FTP、内网资源）简易教程

1.使用场景

在校外或者电脑未连接校园网的情况下，想访问内网信息。

2.所需工具

能联网的电脑

3.使用步骤

1. 浏览器中输入https://vpn.nwpu.edu.cn，跳转至以下页面，点击“下载客户端”。

2. 客户端安装完成后，桌面上会创建如下快捷方式，双击即可。

得到以下页面

3. 输入图片中的网址，西工大的为https://vpn.nwpu.edu.cnµ,其他高校应该在自己学校官网可以查到对应的vpn地址。点击。跳转至以下页面：

4. 输入用户名及密码，点击登录即可。（西工大的用户名密码即为登录翱翔门户的用户名密码，其他高校可到自家官网查询要求）登陆成功，右下角会显示登陆成功的提示信息。

5. 获取资源
   3.5.1双击桌面Easy Connect 快捷方式即可得到校内资源的访问。

6. FTP资源
   和在校内一样，在我的电脑的地址栏里输入对应得ftp地址，就可以成功跳转。

glance内存分析工具使用

glances 是一款用于 Linux、BSD 的开源命令行系统监视工具，它使用 Python 语言开发，能够监视 CPU、负载、内存、磁盘 I/O、网络流量、文件系统、系统温度等信息。本文介绍 glances 的使用方法和技巧，帮助 Linux 系统管理员了解掌握服务器性能。

前言

glances 可以为 Unix 和 Linux 性能专家提供监视和分析性能数据的功能，其中包括：

• CPU 使用率
• 内存使用情况
• 内核统计信息和运行队列信息
• 磁盘 I/O 速度、传输和读/写比率
• 文件系统中的可用空间
• 磁盘适配器
• 网络 I/O 速度、传输和读/写比率
• 页面空间和页面速度
• 消耗资源最多的进程
• 计算机信息和系统资源

glances 工具可以在用户的终端上实时显示重要的系统信息，并动态地对其进行更新。这个高效的工具可以工作于任何终端屏幕。另外它并不会消耗大量的 CPU 资源，通常低于百分之二。glances 在屏幕上对数据进行显示，并且每隔两秒钟对其进行更新。您也可以自己将这个时间间隔更改为更长或更短的数值。glances 工具还可以将相同的数据捕获到一个文件，便于以后对报告进行分析和绘制图形。输出文件可以是电子表格的格式 (.csv) 或者 html 格式。

两种方法安装 glances

通 常可以有两种方法安装 glances。第一种是通过编译源代码的方式，这种方法比较复杂另外可能会遇到软件包依赖性问题。还有一种是使用特定的软件包管理工具来安装 glances，这种方法比较简单。本文使用后者，需要说明的是在 CentOS 特定的软件包管理工具来安装。glances 要首先配置 EPEL repo，然后使用 pip 工具安装 glances。

pip 软件包简介

通 常 Linux 系统管理员有两种方式来安装一个 Python 的软件包：一种是通过系统的包管理工具（如 apt-get）从系统的软件仓库里安装，一种是通过 Python 自己的包管理工具（如 easy_install 或者 pip）从 Python Cheese Shop 中下载安装。笔者推荐使用 pip。pip 是一个可以代替 easy_install 的安装和管理 Python 软件包的工具，是一个安装 Python 库很方便的工具，功能类似 YUM。注意 CentOS 和 Fedora 下安装 Python-pip 后，关键字不是 pip 而是 pip-Python。

首先配置 EPEL repo

如 果既想获得 RHEL 的高质量、高性能、高可靠性，又需要方便易用（关键是免费）的软件包更新功能，那么 Fedora Project 推出的 EPEL（Extra Packages for Enterprise Linux ，http://fedoraproject.org/wiki/EPEL）正好适合你。它是由 Fedora 社区打造，为 RHEL 及衍生发行版如 CentOS、Scientific Linux 等提供高质量软件包的项目。装上了 EPEL，就像在 Fedora 上一样，可以通过 yum install package-name，随意安装软件。安装使用 EPEL 非常简单：

1
2
3
4
5
6
7
8
9
10

#wget http://ftp.riken.jp/Linux/fedora/epel/RPM-GPG-KEY-EPEL-6
#rpm --import RPM-GPG-KEY-EPEL-6
#rm -f RPM-GPG-KEY-EPEL-6
#vi /etc/yum.repos.d/epel.repo
# create new
[epel]
name=EPEL RPM Repository for Red Hat Enterprise Linux
baseurl=http://ftp.riken.jp/Linux/fedora/epel/6/$basearch/
gpgcheck=1
enabled=0

使用 pip 安装 glances

这里介绍一下安装过程：首先使用 YUM 安装 pip 工具，然后使用 pip 工具安装 glances 和用来显示系统温度的相关软件。

1
2

#yum --enablerepo=epel install Python Python-pip Python-devel gcc
# pip-Python install glances

安装 lm_sensors 软件

lm_sensors 的软件可以帮助我们来监控主板、CPU 的工作电压、风扇转速、温度等数据。这些数据我们通常在主板的 BIOS 也可以看到。当我们可以在机器运行的时候通过 lm_sensors 随时来监测着 CPU 的温度变化，可以预防呵保护因为 CPU 过热而会烧掉。lm_sensors 软件监测到的数据可以被 glances 调用并且显示 。

1
2

#yum install lm_sensor
# pip-Python install PySensors

glances 使用方法

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

glances 是一个命令行工具包括如下命令选项：
-b：显示网络连接速度 Byte/ 秒
-B @IP|host ：绑定服务器端 IP 地址或者主机名称
-c @IP|host：连接 glances 服务器端
-C file：设置配置文件默认是 /etc/glances/glances.conf
-d：关闭磁盘 I/O 模块
-e：显示传感器温度
-f file：设置输出文件（格式是 HTML 或者 CSV）
-m：关闭挂载的磁盘模块
-n：关闭网络模块
-p PORT：设置运行端口默认是 61209
-P password：设置客户端 / 服务器密码
-s：设置 glances 运行模式为服务器
-t sec：设置屏幕刷新的时间间隔，单位为秒，默认值为 2 秒，数值许可范围：1~32767
-h : 显示帮助信息
-v : 显示版本信息

glances 工作界面如图 1
图 1.glances 工作界面

glances 工作界面的说明 :

在图 1 的上部是 CPU 、Load（负载）、Mem（内存使用）、 Swap（交换分区）的使用情况。在图 1 的中上部是网络接口、Processes（进程）的使用情况。通常包括如下字段：

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

VIRT: 虚拟内存大小
RES: 进程占用的物理内存值
%CPU：该进程占用的 CPU 使用率

%MEM：该进程占用的物理内存和总内存的百分比

PID: 进程 ID 号
USER: 进程所有者的用户名
TIME+: 该进程启动后占用的总的 CPU 时间
IO_R 和 IO_W: 进程的读写 I/O 速率
NAME: 进程名称
NI: 进程优先级
S: 进程状态，其中 S 表示休眠，R 表示正在运行，Z 表示僵死状态。

在图 1 的中下部是传感器检测到的 CPU 温度。 在图 1 的下部是磁盘 I/O 的使用情况。 另外 glances 可以使用交互式的方式运行该工具，用户可以使用如下快捷键：

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

h ： 显示帮助信息
q ： 离开程序退出
c ：按照 CPU 实时负载对系统进程进行排序
m ：按照内存使用状况对系统进程排序
i：按照 I/O 使用状况对系统进程排序
p： 按照进程名称排序
d ： 显示磁盘读写状况
w ： 删除日志文件
l ：显示日志
s： 显示传感器信息
f ： 显示系统信息
1 ：轮流显示每个 CPU 内核的使用情况（次选项仅仅使用在多核 CPU 系统）

glances 的高级应用

glances 的结果输出方法

让 glances 输出 HTML 格式文件，首先安装相关软件包

1
2

# pip-Python install Jinja2
# glances -o HTML -f /var/www/html

下面可以使用 Firefox 浏览器输入网址: http://localhost/glances.html，结果如图 2。
图 2.输出 HTML 格式文件

[

输出 csv 格式

该文件采用逗号分隔值（CSV）的格式，并且可以将其直接导入到电子表格中。

1

# glances -o CSV -f /home/cjh/glances.csv

下面使用 libreoffice 的 calc 工具打开 csv 格式文件（如图 3）

1

#libreoffice --calc %U /tmp/glances.csv

图 3.使用 libreoffice 的 calc 工具打开 csv 格式文件

glances 服务器 / 客户端工作方式

glances 支持服务器/客户端工作方式，可以实现远程监控。首先假设

服务器 IP 地址：10.0.2.14

客户端 IP 地址：10.0.2.15

确保二者都已经安装好 glances 软件包。

首先在服务器端启动；

1
2

# glances -s -B 10.0.2.15
glances server is running on 10.0.2.15:61209

可以看到 glances 使用的端口号是 61209，所以用户需要确保防火墙打开这个端口。

下面在客户端使用如下命令连接服务器如图 4：

1

# glances -c 10.0.2.15

图 4.客户端连接服务器

[

注意图 4 的左下角显示“Connected to 10.0.2.15”>表示客户端已经连接服务器成功。

通过 glances 输出颜色了解系统性能
图 5.是 glances 的一个输出界面

绿色表示性能良好，无需做任何额外工作；（此时 CPU 使用率、磁盘空间使用率和内存使用率低于 50%，系统负载低于 0.7）。

蓝色表示系统性能有一些小问题，用户应当开始关注系统性能；（此时 CPU 使用率、磁盘空间使用率和内存使用率在 50%-70% 之间，系统负载在 0.7-1 之间）。

品红表示性能报警，应当采取措施比如备份数据；（此时 CPU 使用率、磁盘空间使用率和内存使用率在 70%-90% 之间，，系统负载在 1-5 之间）。

红色表示性能问题严重，可能宕机；（此时 CPU 使用率、磁盘空间使用率和内存使用率在大于 90%，系统负载大于 5）。

命令行的艺术

• 前言
• 基础
• 日常使用
• 文件及数据处理
• 系统调试
• 单行脚本
• 冷门但有用
• 仅限 OS X 系统
• 仅限 Windows 系统
• 更多资源
• 免责声明

熟练使用命令行是一种常常被忽视，或被认为难以掌握的技能，但实际上，它会提高你作为工程师的灵活性以及生产力。本文是一份我在 Linux 上工作时，发现的一些命令行使用技巧的摘要。有些技巧非常基础，而另一些则相当复杂，甚至晦涩难懂。这篇文章并不长，但当你能够熟练掌握这里列出的所有技巧时，你就学会了很多关于命令行的东西了。

这篇文章是许多作者和译者共同的成果。这里的部分内容首次出现于 Quora，但已经迁移到了 Github，并由众多高手做出了许多改进。如果你在本文中发现了错误或者存在可以改善的地方，请贡献你的一份力量。

前言

涵盖范围：

• 这篇文章不仅能帮助刚接触命令行的新手，而且对具有经验的人也大有裨益。本文致力于做到覆盖面广（涉及所有重要的内容），具体（给出具体的最常用的例子），以及简洁（避免冗余的内容，或是可以在其他地方轻松查到的细枝末节）。在特定应用场景下，本文的内容属于基本功或者能帮助您节约大量的时间。
• 本文主要为 Linux 所写，但在仅限 OS X 系统章节和仅限 Windows 系统章节中也包含有对应操作系统的内容。除去这两个章节外，其它的内容大部分均可在其他类 Unix 系统或 OS X，甚至 Cygwin 中得到应用。
• 本文主要关注于交互式 Bash，但也有很多技巧可以应用于其他 shell 和 Bash 脚本当中。
• 除去“标准的”Unix 命令，本文还包括了一些依赖于特定软件包的命令（前提是它们具有足够的价值）。

注意事项：

• 为了能在一页内展示尽量多的东西，一些具体的信息可以在引用的页面中找到。我们相信机智的你知道如何使用 Google 或者其他搜索引擎来查阅到更多的详细信息。文中部分命令需要您使用 apt-get，yum，dnf，pacman，pip 或 brew（以及其它合适的包管理器）来安装依赖的程序。
• 遇到问题的话，请尝试使用 Explainshell 去获取相关命令、参数、管道等内容的解释。

基础

• 学习 Bash 的基础知识。具体地，在命令行中输入 man bash 并至少全文浏览一遍; 它理解起来很简单并且不冗长。其他的 shell 可能很好用，但 Bash 的功能已经足够强大并且到几乎总是可用的（ 如果你只学习 zsh，fish 或其他的 shell 的话，在你自己的设备上会显得很方便，但过度依赖这些功能会给您带来不便，例如当你需要在服务器上工作时）。

• 熟悉至少一个基于文本的编辑器。通常而言 Vim （vi） 会是你最好的选择，毕竟在终端中编辑文本时 Vim 是最好用的工具（甚至大部分情况下 Vim 要比 Emacs、大型 IDE 或是炫酷的编辑器更好用）。

• 学会如何使用 man 命令去阅读文档。学会使用 apropos 去查找文档。知道有些命令并不对应可执行文件，而是在 Bash 内置好的，此时可以使用 help 和 help -d 命令获取帮助信息。你可以用 type 命令 来判断这个命令到底是可执行文件、shell 内置命令还是别名。

• 学会使用 > 和 < 来重定向输出和输入，学会使用 | 来重定向管道。明白 > 会覆盖了输出文件而 >> 是在文件末添加。了解标准输出 stdout 和标准错误 stderr。

• 学会使用通配符 * （或许再算上 ? 和 […]） 和引用以及引用中 ' 和 " 的区别（后文中有一些具体的例子）。

• 熟悉 Bash 中的任务管理工具：&，ctrl-z，ctrl-c，jobs，fg，bg，kill 等。

• 学会使用 ssh 进行远程命令行登录，最好知道如何使用 ssh-agent，ssh-add 等命令来实现基础的无密码认证登录。

• 学会基本的文件管理工具：ls 和 ls -l （了解 ls -l 中每一列代表的意义），less，head，tail 和 tail -f （甚至 less +F），ln 和 ln -s （了解硬链接与软链接的区别），chown，chmod，du （硬盘使用情况概述：du -hs *）。 关于文件系统的管理，学习 df，mount，fdisk，mkfs，lsblk。知道 inode 是什么（与 ls -i 和 df -i 等命令相关）。

• 学习基本的网络管理工具：ip 或 ifconfig，dig。

• 学习并使用一种版本控制管理系统，例如 git。

• 熟悉正则表达式，学会使用 grep／egrep，它们的参数中 -i，-o，-v，-A，-B 和 -C 这些是很常用并值得认真学习的。

• 学会使用 apt-get，yum，dnf 或 pacman （具体使用哪个取决于你使用的 Linux 发行版）来查找和安装软件包。并确保你的环境中有 pip 来安装基于 Python 的命令行工具 （接下来提到的部分程序使用 pip 来安装会很方便）。

日常使用

• 在 Bash 中，可以通过按 Tab 键实现自动补全参数，使用 ctrl-r 搜索命令行历史记录（按下按键之后，输入关键字便可以搜索，重复按下 ctrl-r 会向后查找匹配项，按下 Enter 键会执行当前匹配的命令，而按下右方向键会将匹配项放入当前行中，不会直接执行，以便做出修改）。

• 在 Bash 中，可以按下 ctrl-w 删除你键入的最后一个单词，ctrl-u 可以删除行内光标所在位置之前的内容，alt-b 和 alt-f 可以以单词为单位移动光标，ctrl-a 可以将光标移至行首，ctrl-e 可以将光标移至行尾，ctrl-k 可以删除光标至行尾的所有内容，ctrl-l 可以清屏。键入 man readline 可以查看 Bash 中的默认快捷键。内容有很多，例如 alt-. 循环地移向前一个参数，而 alt-* 可以展开通配符。

• 你喜欢的话，可以执行 set -o vi 来使用 vi 风格的快捷键，而执行 set -o emacs 可以把它改回来。

• 为了便于编辑长命令，在设置你的默认编辑器后（例如 export EDITOR=vim），ctrl-x ctrl-e 会打开一个编辑器来编辑当前输入的命令。在 vi 风格下快捷键则是 escape-v。

• 键入 history 查看命令行历史记录，再用 !n（n 是命令编号）就可以再次执行。其中有许多缩写，最有用的大概就是 !$， 它用于指代上次键入的参数，而 !! 可以指代上次键入的命令了（参考 man 页面中的“HISTORY EXPANSION”）。不过这些功能，你也可以通过快捷键 ctrl-r 和 alt-. 来实现。

• cd 命令可以切换工作路径，输入 cd ~ 可以进入 home 目录。要访问你的 home 目录中的文件，可以使用前缀 ~（例如 ~/.bashrc）。在 sh 脚本里则用环境变量 $HOME 指代 home 目录的路径。

• 回到前一个工作路径：cd -。

• 如果你输入命令的时候中途改了主意，按下 alt-# 在行首添加 # 把它当做注释再按下回车执行（或者依次按下 ctrl-a， **#**， enter）。这样做的话，之后借助命令行历史记录，你可以很方便恢复你刚才输入到一半的命令。

• 使用 xargs （ 或 parallel）。他们非常给力。注意到你可以控制每行参数个数（-L）和最大并行数（-P）。如果你不确定它们是否会按你想的那样工作，先使用 xargs echo 查看一下。此外，使用 -I{} 会很方便。例如：

  1 2	find . -name '*.py' | xargs grep some_function cat hosts | xargs -I{} ssh root@{} hostname

• pstree -p 以一种优雅的方式展示进程树。

• 使用 pgrep 和 pkill 根据名字查找进程或发送信号（-f 参数通常有用）。

• 了解你可以发往进程的信号的种类。比如，使用 kill -STOP [pid] 停止一个进程。使用 man 7 signal 查看详细列表。

• 使用 nohup 或 disown 使一个后台进程持续运行。

• 使用 netstat -lntp 或 ss -plat 检查哪些进程在监听端口（默认是检查 TCP 端口; 添加参数 -u 则检查 UDP 端口）或者 lsof -iTCP -sTCP:LISTEN -P -n (这也可以在 OS X 上运行)。

• lsof 来查看开启的套接字和文件。

• 使用 uptime 或 w 来查看系统已经运行多长时间。

• 使用 alias 来创建常用命令的快捷形式。例如：alias ll='ls -latr' 创建了一个新的命令别名 ll。

• 可以把别名、shell 选项和常用函数保存在 ~/.bashrc，具体看下这篇文章。这样做的话你就可以在所有 shell 会话中使用你的设定。

• 把环境变量的设定以及登陆时要执行的命令保存在 ~/.bash_profile。而对于从图形界面启动的 shell 和 cron 启动的 shell，则需要单独配置文件。

• 要想在几台电脑中同步你的配置文件（例如 .bashrc 和 .bash_profile），可以借助 Git。

• 当变量和文件名中包含空格的时候要格外小心。Bash 变量要用引号括起来，比如 "$FOO"。尽量使用 -0 或 -print0 选项以便用 NULL 来分隔文件名，例如 locate -0 pattern | xargs -0 ls -al 或 find / -print0 -type d | xargs -0 ls -al。如果 for 循环中循环访问的文件名含有空字符（空格、tab 等字符），只需用 IFS=$'\n' 把内部字段分隔符设为换行符。

• 在 Bash 脚本中，使用 set -x 去调试输出（或者使用它的变体 set -v，它会记录原始输入，包括多余的参数和注释）。尽可能地使用严格模式：使用 set -e 令脚本在发生错误时退出而不是继续运行；使用 set -u 来检查是否使用了未赋值的变量；试试 set -o pipefail，它可以监测管道中的错误。当牵扯到很多脚本时，使用 trap 来检测 ERR 和 EXIT。一个好的习惯是在脚本文件开头这样写，这会使它能够检测一些错误，并在错误发生时中断程序并输出信息：

  1 2	set -euo pipefail trap "echo 'error: Script failed: see failed command above'" ERR

• 在 Bash 脚本中，子 shell（使用括号 (...)）是一种组织参数的便捷方式。一个常见的例子是临时地移动工作路径，代码如下：

  1 2 3

  # do something in current dir (cd /some/other/dir && other-command) # continue in original dir

• 在 Bash 中，变量有许多的扩展方式。${name:?error message} 用于检查变量是否存在。此外，当 Bash 脚本只需要一个参数时，可以使用这样的代码 input_file=${1:?usage: $0 input_file}。在变量为空时使用默认值：${name:-default}。如果你要在之前的例子中再加一个（可选的）参数，可以使用类似这样的代码 output_file=${2:-logfile}，如果省略了 $2，它的值就为空，于是 output_file 就会被设为 logfile。数学表达式：i=$(( (i + 1) % 5 ))。序列：{1..10}。截断字符串：${var%suffix} 和 ${var#prefix}。例如，假设 var=foo.pdf，那么 echo ${var%.pdf}.txt 将输出 foo.txt。

• 使用括号扩展（{…}）来减少输入相似文本，并自动化文本组合。这在某些情况下会很有用，例如 mv foo.{txt,pdf} some-dir（同时移动两个文件），cp somefile{,.bak}（会被扩展成 cp somefile somefile.bak）或者 mkdir -p test-{a,b,c}/subtest-{1,2,3}（会被扩展成所有可能的组合，并创建一个目录树）。

• 通过使用 <(some command) 可以将输出视为文件。例如，对比本地文件 /etc/hosts 和一个远程文件：

  1	diff /etc/hosts <(ssh somehost cat /etc/hosts)

• 编写脚本时，你可能会想要把代码都放在大括号里。缺少右括号的话，代码就会因为语法错误而无法执行。如果你的脚本是要放在网上分享供他人使用的，这样的写法就体现出它的好处了，因为这样可以防止下载不完全代码被执行。

  1 2 3

  { # 在这里写代码 }

• 了解 Bash 中的“here documents”，例如 cat <<EOF ...。

• 在 Bash 中，同时重定向标准输出和标准错误：some-command >logfile 2>&1 或者 some-command &>logfile。通常，为了保证命令不会在标准输入里残留一个未关闭的文件句柄捆绑在你当前所在的终端上，在命令后添加 </dev/null 是一个好习惯。

• 使用 man ascii 查看具有十六进制和十进制值的ASCII表。man unicode，man utf-8，以及 man latin1 有助于你去了解通用的编码信息。

• 使用 screen 或 tmux 来使用多份屏幕，当你在使用 ssh 时（保存 session 信息）将尤为有用。而 byobu 可以为它们提供更多的信息和易用的管理工具。另一个轻量级的 session 持久化解决方案是 dtach。

• ssh 中，了解如何使用 -L 或 -D（偶尔需要用 -R）开启隧道是非常有用的，比如当你需要从一台远程服务器上访问 web 页面。

• 对 ssh 设置做一些小优化可能是很有用的，例如这个 ~/.ssh/config 文件包含了防止特定网络环境下连接断开、压缩数据、多通道等选项：

  1 2 3 4 5 6 7

  TCPKeepAlive=yes ServerAliveInterval=15 ServerAliveCountMax=6 Compression=yes ControlMaster auto ControlPath /tmp/%r@%h:%p ControlPersist yes

• 一些其他的关于 ssh 的选项是与安全相关的，应当小心翼翼的使用。例如你应当只能在可信任的网络中启用 StrictHostKeyChecking=no，ForwardAgent=yes。

• 考虑使用 mosh 作为 ssh 的替代品，它使用 UDP 协议。它可以避免连接被中断并且对带宽需求更小，但它需要在服务端做相应的配置。

• 获取八进制形式的文件访问权限（修改系统设置时通常需要，但 ls 的功能不那么好用并且通常会搞砸），可以使用类似如下的代码：

  1	stat -c '%A %a %n' /etc/timezone

• 使用 percol 或者 fzf 可以交互式地从另一个命令输出中选取值。

• 使用 fpp（PathPicker）可以与基于另一个命令(例如 git）输出的文件交互。

• 将 web 服务器上当前目录下所有的文件（以及子目录）暴露给你所处网络的所有用户，使用：
  python -m SimpleHTTPServer 7777 （使用端口 7777 和 Python 2）或python -m http.server 7777 （使用端口 7777 和 Python 3）。

• 以其他用户的身份执行命令，使用 sudo。默认以 root 用户的身份执行；使用 -u 来指定其他用户。使用 -i 来以该用户登录（需要输入_你自己的_密码）。

• 将 shell 切换为其他用户，使用 su username 或者 sudo - username。加入 - 会使得切换后的环境与使用该用户登录后的环境相同。省略用户名则默认为 root。切换到哪个用户，就需要输入_哪个用户的_密码。

• 了解命令行的 128K 限制。使用通配符匹配大量文件名时，常会遇到“Argument list too long”的错误信息。（这种情况下换用 find 或 xargs 通常可以解决。）

• 当你需要一个基本的计算器时，可以使用 python 解释器（当然你要用 python 的时候也是这样）。例如：

  1 2

  >>> 2+3 5

文件及数据处理

• 在当前目录下通过文件名查找一个文件，使用类似于这样的命令：find . -iname '*something*'。在所有路径下通过文件名查找文件，使用 locate something （但注意到 updatedb 可能没有对最近新建的文件建立索引，所以你可能无法定位到这些未被索引的文件）。

• 使用 ag 在源代码或数据文件里检索（grep -r 同样可以做到，但相比之下 ag 更加先进）。

• 将 HTML 转为文本：lynx -dump -stdin。

• Markdown，HTML，以及所有文档格式之间的转换，试试 pandoc。

• 当你要处理棘手的 XML 时候，xmlstarlet 算是上古时代流传下来的神器。

• 使用 jq 处理 JSON。

• 使用 shyaml 处理 YAML。

• 要处理 Excel 或 CSV 文件的话，csvkit 提供了 in2csv，csvcut，csvjoin，csvgrep 等方便易用的工具。

• 当你要处理 Amazon S3 相关的工作的时候，s3cmd 是一个很方便的工具而 s4cmd 的效率更高。Amazon 官方提供的 aws 以及 saws 是其他 AWS 相关工作的基础，值得学习。

• 了解如何使用 sort 和 uniq，包括 uniq 的 -u 参数和 -d 参数，具体内容在后文单行脚本节中。另外可以了解一下 comm。

• 了解如何使用 cut，paste 和 join 来更改文件。很多人都会使用 cut，但遗忘了 join。

• 了解如何运用 wc 去计算新行数（-l），字符数（-m），单词数（-w）以及字节数（-c）。

• 了解如何使用 tee 将标准输入复制到文件甚至标准输出，例如 ls -al | tee file.txt。

• 要进行一些复杂的计算，比如分组、逆序和一些其他的统计分析，可以考虑使用 datamash。

• 注意到语言设置（中文或英文等）对许多命令行工具有一些微妙的影响，比如排序的顺序和性能。大多数 Linux 的安装过程会将 LANG 或其他有关的变量设置为符合本地的设置。要意识到当你改变语言设置时，排序的结果可能会改变。明白国际化可能会使 sort 或其他命令运行效率下降许多倍。某些情况下（例如集合运算）你可以放心的使用 export LC_ALL=C 来忽略掉国际化并按照字节来判断顺序。

• 你可以单独指定某一条命令的环境，只需在调用时把环境变量设定放在命令的前面，例如 TZ=Pacific/Fiji date 可以获取斐济的时间。

• 了解如何使用 awk 和 sed 来进行简单的数据处理。 参阅 One-liners 获取示例。

• 替换一个或多个文件中出现的字符串：

  1	perl -pi.bak -e 's/old-string/new-string/g' my-files-*.txt

• 使用 repren 来批量重命名文件，或是在多个文件中搜索替换内容。（有些时候 rename 命令也可以批量重命名，但要注意，它在不同 Linux 发行版中的功能并不完全一样。）

  1 2 3 4 5 6

  # 将文件、目录和内容全部重命名 foo -> bar: repren --full --preserve-case --from foo --to bar . # 还原所有备份文件 whatever.bak -> whatever: repren --renames --from '(.*)\.bak' --to '\1' *.bak # 用 rename 实现上述功能（若可用）: rename 's/\.bak$//' *.bak

• 根据 man 页面的描述，rsync 是一个快速且非常灵活的文件复制工具。它闻名于设备之间的文件同步，但其实它在本地情况下也同样有用。在安全设置允许下，用 rsync 代替 scp 可以实现文件续传，而不用重新从头开始。它同时也是删除大量文件的最快方法之一：

  1	mkdir empty && rsync -r --delete empty/ some-dir && rmdir some-dir

• 若要在复制文件时获取当前进度，可使用 pv，pycp，progress，rsync --progress。若所执行的复制为block块拷贝，可以使用 dd status=progress。

• 使用 shuf 可以以行为单位来打乱文件的内容或从一个文件中随机选取多行。

• 了解 sort 的参数。显示数字时，使用 -n 或者 -h 来显示更易读的数（例如 du -h 的输出）。明白排序时关键字的工作原理（-t 和 -k）。例如，注意到你需要 -k1，1 来仅按第一个域来排序，而 -k1 意味着按整行排序。稳定排序（sort -s）在某些情况下很有用。例如，以第二个域为主关键字，第一个域为次关键字进行排序，你可以使用 sort -k1，1 | sort -s -k2，2。

• 如果你想在 Bash 命令行中写 tab 制表符，按下 ctrl-v [Tab] 或键入 $'\t' （后者可能更好，因为你可以复制粘贴它）。

• 标准的源代码对比及合并工具是 diff 和 patch。使用 diffstat 查看变更总览数据。注意到 diff -r 对整个文件夹有效。使用 diff -r tree1 tree2 | diffstat 查看变更的统计数据。vimdiff 用于比对并编辑文件。

• 对于二进制文件，使用 hd，hexdump 或者 xxd 使其以十六进制显示，使用 bvi，hexedit 或者 biew 来进行二进制编辑。

• 同样对于二进制文件，strings（包括 grep 等工具）可以帮助在二进制文件中查找特定比特。

• 制作二进制差分文件（Delta 压缩），使用 xdelta3。

• 使用 iconv 更改文本编码。需要更高级的功能，可以使用 uconv，它支持一些高级的 Unicode 功能。例如，这条命令移除了所有重音符号：

  1	uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt

• 拆分文件可以使用 split（按大小拆分）和 csplit（按模式拆分）。

• 操作日期和时间表达式，可以用 dateutils 中的 dateadd、datediff、strptime 等工具。

• 使用 zless、zmore、zcat 和 zgrep 对压缩过的文件进行操作。

• 文件属性可以通过 chattr 进行设置，它比文件权限更加底层。例如，为了保护文件不被意外删除，可以使用不可修改标记：sudo chattr +i /critical/directory/or/file

• 使用 getfacl 和 setfacl 以保存和恢复文件权限。例如：

  1 2	getfacl -R /some/path > permissions.txt setfacl --restore=permissions.txt

• 为了高效地创建空文件，请使用 truncate（创建稀疏文件），fallocate（用于 ext4，xfs，btrf 和 ocfs2 文件系统），xfs_mkfile（适用于几乎所有的文件系统，包含在 xfsprogs 包中），mkfile（用于类 Unix 操作系统，比如 Solaris 和 Mac OS）。

系统调试

• curl 和 curl -I 可以被轻松地应用于 web 调试中，它们的好兄弟 wget 也是如此，或者也可以试试更潮的 httpie。

• 获取 CPU 和硬盘的使用状态，通常使用使用 top（htop 更佳），iostat 和 iotop。而 iostat -mxz 15 可以让你获悉 CPU 和每个硬盘分区的基本信息和性能表现。

• 使用 netstat 和 ss 查看网络连接的细节。

• dstat 在你想要对系统的现状有一个粗略的认识时是非常有用的。然而若要对系统有一个深度的总体认识，使用 glances，它会在一个终端窗口中向你提供一些系统级的数据。

• 若要了解内存状态，运行并理解 free 和 vmstat 的输出。值得留意的是“cached”的值，它指的是 Linux 内核用来作为文件缓存的内存大小，而与空闲内存无关。

• Java 系统调试则是一件截然不同的事，一个可以用于 Oracle 的 JVM 或其他 JVM 上的调试的技巧是你可以运行 kill -3 <pid> 同时一个完整的栈轨迹和堆概述（包括 GC 的细节）会被保存到标准错误或是日志文件。JDK 中的 jps，jstat，jstack，jmap 很有用。SJK tools 更高级。

• 使用 mtr 去跟踪路由，用于确定网络问题。

• 用 ncdu 来查看磁盘使用情况，它比寻常的命令，如 du -sh *，更节省时间。

• 查找正在使用带宽的套接字连接或进程，使用 iftop 或 nethogs。

• ab 工具（Apache 中自带）可以简单粗暴地检查 web 服务器的性能。对于更复杂的负载测试，使用 siege。

• wireshark，tshark 和 ngrep 可用于复杂的网络调试。

• 了解 strace 和 ltrace。这俩工具在你的程序运行失败、挂起甚至崩溃，而你却不知道为什么或你想对性能有个总体的认识的时候是非常有用的。注意 profile 参数（-c）和附加到一个运行的进程参数 （-p）。

• 了解使用 ldd 来检查共享库。但是永远不要在不信任的文件上运行。

• 了解如何运用 gdb 连接到一个运行着的进程并获取它的堆栈轨迹。

• 学会使用 /proc。它在调试正在出现的问题的时候有时会效果惊人。比如：/proc/cpuinfo，/proc/meminfo，/proc/cmdline，/proc/xxx/cwd，/proc/xxx/exe，/proc/xxx/fd/，/proc/xxx/smaps（这里的 xxx 表示进程的 id 或 pid）。

• 当调试一些之前出现的问题的时候，sar 非常有用。它展示了 cpu、内存以及网络等的历史数据。

• 关于更深层次的系统分析以及性能分析，看看 stap（SystemTap），perf，以及sysdig。

• 查看你当前使用的系统，使用 uname，uname -a（Unix／kernel 信息）或者 lsb_release -a（Linux 发行版信息）。

• 无论什么东西工作得很欢乐（可能是硬件或驱动问题）时可以试试 dmesg。

• 如果你删除了一个文件，但通过 du 发现没有释放预期的磁盘空间，请检查文件是否被进程占用：
  lsof | grep deleted | grep "filename-of-my-big-file"

单行脚本

一些命令组合的例子：

• 当你需要对文本文件做集合交、并、差运算时，sort 和 uniq 会是你的好帮手。具体例子请参照代码后面的，此处假设 a 与 b 是两内容不同的文件。这种方式效率很高，并且在小文件和上 G 的文件上都能运用（注意尽管在 /tmp 在一个小的根分区上时你可能需要 -T 参数，但是实际上 sort 并不被内存大小约束），参阅前文中关于 LC_ALL 和 sort 的 -u 参数的部分。

  1 2 3

  sort a b | uniq > c # c 是 a 并 b sort a b | uniq -d > c # c 是 a 交 b sort a b b | uniq -u > c # c 是 a - b

• 使用 grep . *（每行都会附上文件名）或者 head -100 *（每个文件有一个标题）来阅读检查目录下所有文件的内容。这在检查一个充满配置文件的目录（如 /sys、/proc、/etc）时特别好用。

• 计算文本文件第三列中所有数的和（可能比同等作用的 Python 代码快三倍且代码量少三倍）：

  1	awk '{ x += $3 } END { print x }' myfile

• 如果你想在文件树上查看大小/日期，这可能看起来像递归版的 ls -l 但比 ls -lR 更易于理解：

  1	find . -type f -ls

• 假设你有一个类似于 web 服务器日志文件的文本文件，并且一个确定的值只会出现在某些行上，假设一个 acct_id 参数在 URI 中。如果你想计算出每个 acct_id 值有多少次请求，使用如下代码：

  1	egrep -o 'acct_id=[0-9]+' access.log | cut -d= -f2 | sort | uniq -c | sort -rn

• 要持续监测文件改动，可以使用 watch，例如检查某个文件夹中文件的改变，可以用 watch -d -n 2 'ls -rtlh | tail'；或者在排查 WiFi 设置故障时要监测网络设置的更改，可以用 watch -d -n 2 ifconfig。

• 运行这个函数从这篇文档中随机获取一条技巧（解析 Markdown 文件并抽取项目）：

  1 2 3 4 5 6 7 8

  function taocl() { curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README-zh.md| pandoc -f markdown -t html | iconv -f 'utf-8' -t 'unicode' | xmlstarlet fo --html --dropdtd | xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" | xmlstarlet unesc | fmt -80 }

冷门但有用

• expr：计算表达式或正则匹配

• m4：简单的宏处理器

• yes：多次打印字符串

• cal：漂亮的日历

• env：执行一个命令（脚本文件中很有用）

• printenv：打印环境变量（调试时或在写脚本文件时很有用）

• look：查找以特定字符串开头的单词或行

• cut，paste 和 join：数据修改

• fmt：格式化文本段落

• pr：将文本格式化成页／列形式

• fold：包裹文本中的几行

• column：将文本格式化成多个对齐、定宽的列或表格

• expand 和 unexpand：制表符与空格之间转换

• nl：添加行号

• seq：打印数字

• bc：计算器

• factor：分解因数

• gpg：加密并签名文件

• toe：terminfo 入口列表

• nc：网络调试及数据传输

• socat：套接字代理，与 netcat 类似

• slurm：网络流量可视化

• dd：文件或设备间传输数据

• file：确定文件类型

• tree：以树的形式显示路径和文件，类似于递归的 ls

• stat：文件信息

• time：执行命令，并计算执行时间

• timeout：在指定时长范围内执行命令，并在规定时间结束后停止进程

• lockfile：使文件只能通过 rm -f 移除

• logrotate： 切换、压缩以及发送日志文件

• watch：重复运行同一个命令，展示结果并／或高亮有更改的部分

• when-changed：当检测到文件更改时执行指定命令。参阅 inotifywait 和 entr。

• tac：反向输出文件

• shuf：文件中随机选取几行

• comm：一行一行的比较排序过的文件

• strings：从二进制文件中抽取文本

• tr：转换字母

• iconv 或 uconv：文本编码转换

• split 和 csplit：分割文件

• sponge：在写入前读取所有输入，在读取文件后再向同一文件写入时比较有用，例如 grep -v something some-file | sponge some-file

• units：将一种计量单位转换为另一种等效的计量单位（参阅 /usr/share/units/definitions.units）

• apg：随机生成密码

• xz：高比例的文件压缩

• ldd：动态库信息

• nm：提取 obj 文件中的符号

• ab 或 wrk：web 服务器性能分析

• strace：调试系统调用

• mtr：更好的网络调试跟踪工具

• cssh：可视化的并发 shell

• rsync：通过 ssh 或本地文件系统同步文件和文件夹

• wireshark 和 tshark：抓包和网络调试工具

• ngrep：网络层的 grep

• host 和 dig：DNS 查找

• lsof：列出当前系统打开文件的工具以及查看端口信息

• dstat：系统状态查看

• glances：高层次的多子系统总览

• iostat：硬盘使用状态

• mpstat： CPU 使用状态

• vmstat： 内存使用状态

• htop：top 的加强版

• last：登入记录

• w：查看处于登录状态的用户

• id：用户/组 ID 信息

• sar：系统历史数据

• iftop 或 nethogs：套接字及进程的网络利用情况

• ss：套接字数据

• dmesg：引导及系统错误信息

• sysctl： 在内核运行时动态地查看和修改内核的运行参数

• hdparm：SATA/ATA 磁盘更改及性能分析

• lsblk：列出块设备信息：以树形展示你的磁盘以及磁盘分区信息

• lshw，lscpu，lspci，lsusb 和 dmidecode：查看硬件信息，包括 CPU、BIOS、RAID、显卡、USB设备等

• lsmod 和 modinfo：列出内核模块，并显示其细节

• fortune，ddate 和 sl：额，这主要取决于你是否认为蒸汽火车和莫名其妙的名人名言是否“有用”

仅限 OS X 系统

以下是仅限于 OS X 系统的技巧。

• 用 brew （Homebrew）或者 port （MacPorts）进行包管理。这些可以用来在 OS X 系统上安装以上的大多数命令。

• 用 pbcopy 复制任何命令的输出到桌面应用，用 pbpaste 粘贴输入。

• 若要在 OS X 终端中将 Option 键视为 alt 键（例如在上面介绍的 alt-b、alt-f 等命令中用到），打开 偏好设置 -> 描述文件 -> 键盘 并勾选“使用 Option 键作为 Meta 键”。

• 用 open 或者 open -a /Applications/Whatever.app 使用桌面应用打开文件。

• Spotlight：用 mdfind 搜索文件，用 mdls 列出元数据（例如照片的 EXIF 信息）。

• 注意 OS X 系统是基于 BSD UNIX 的，许多命令（例如 ps，ls，tail，awk，sed）都和 Linux 中有微妙的不同（ Linux 很大程度上受到了 System V-style Unix 和 GNU 工具影响）。你可以通过标题为 “BSD General Commands Manual” 的 man 页面发现这些不同。在有些情况下 GNU 版本的命令也可能被安装（例如 gawk 和 gsed 对应 GNU 中的 awk 和 sed ）。如果要写跨平台的 Bash 脚本，避免使用这些命令（例如，考虑 Python 或者 perl ）或者经过仔细的测试。

• 用 sw_vers 获取 OS X 的版本信息。

仅限 Windows 系统

以下是仅限于 Windows 系统的技巧。

在 Winodws 下获取 Unix 工具

• 可以安装 Cygwin 允许你在 Microsoft Windows 中体验 Unix shell 的威力。这样的话，本文中介绍的大多数内容都将适用。

• 在 Windows 10 上，你可以使用 Bash on Ubuntu on Windows，它提供了一个熟悉的 Bash 环境，包含了不少 Unix 命令行工具。好处是它允许 Linux 上编写的程序在 Windows 上运行，而另一方面，Windows 上编写的程序却无法在 Bash 命令行中运行。

• 如果你在 Windows 上主要想用 GNU 开发者工具（例如 GCC），可以考虑 MinGW 以及它的 MSYS 包，这个包提供了例如 bash，gawk，make 和 grep 的工具。MSYS 并不包含所有可以与 Cygwin 媲美的特性。当制作 Unix 工具的原生 Windows 端口时 MinGW 将特别地有用。

• 另一个在 Windows 下实现接近 Unix 环境外观效果的选项是 Cash。注意在此环境下只有很少的 Unix 命令和命令行可用。

实用 Windows 命令行工具

• 可以使用 wmic 在命令行环境下给大部分 Windows 系统管理任务编写脚本以及执行这些任务。

• Windows 实用的原生命令行网络工具包括 ping，ipconfig，tracert，和 netstat。

• 可以使用 Rundll32 命令来实现许多有用的 Windows 任务 。

Cygwin 技巧

• 通过 Cygwin 的包管理器来安装额外的 Unix 程序。

• 使用 mintty 作为你的命令行窗口。

• 要访问 Windows 剪贴板，可以通过 /dev/clipboard。

• 运行 cygstart 以通过默认程序打开一个文件。

• 要访问 Windows 注册表，可以使用 regtool。

• 注意 Windows 驱动器路径 C:\ 在 Cygwin 中用 /cygdrive/c 代表，而 Cygwin 的 / 代表 Windows 中的 C:\cygwin。要转换 Cygwin 和 Windows 风格的路径可以用 cygpath。这在需要调用 Windows 程序的脚本里很有用。

• 学会使用 wmic，你就可以从命令行执行大多数 Windows 系统管理任务，并编成脚本。

• 要在 Windows 下获得 Unix 的界面和体验，另一个办法是使用 Cash。需要注意的是，这个环境支持的 Unix 命令和命令行参数非常少。

• 要在 Windows 上获取 GNU 开发者工具（比如 GCC）的另一个办法是使用 MinGW 以及它的 MSYS 软件包，该软件包提供了 bash、gawk、make、grep 等工具。然而 MSYS 提供的功能没有 Cygwin 完善。MinGW 在创建 Unix 工具的 Windows 原生移植方面非常有用。

更多资源

• awesome-shell：一份精心组织的命令行工具及资源的列表。
• awesome-osx-command-line：一份针对 OS X 命令行的更深入的指南。
• Strict mode：为了编写更好的脚本文件。
• shellcheck：一个静态 shell 脚本分析工具，本质上是 bash／sh／zsh 的 lint。
• Filenames and Pathnames in Shell：有关如何在 shell 脚本里正确处理文件名的细枝末节。
• Data Science at the Command Line：用于数据科学的一些命令和工具，摘自同名书籍。

免责声明

除去特别小的工作，你编写的代码应当方便他人阅读。能力往往伴随着责任，你 有能力 在 Bash 中玩一些奇技淫巧并不意味着你应该去做！;)

授权条款

本文使用授权协议 Creative Commons Attribution-ShareAlike 4.0 International License。

手把手教你黑白群晖NAS安装破解版ROON音乐播放器1.6

什么是Roon？

roon不能说是一个播放软件，它是一个系统，由Roon Server为核心构建的，Roon Server本身不存储任何音乐文件，你也不需要把任何的音乐文件存储到它里面，他可以读取你本地的任何共享文件夹里的音乐文件，然后从他庞大的数据库中，帮你归类音乐文件，只要是信息齐全的，它没什么不认识的。

然后，重点来了。他可以通过IPAD、手机、PC这些设备，来控制你的其他设备播放你本地的别的设备里的音乐，并且可以接入你的家庭智能系统。

然后你可以通过手机APP，平板电脑和普通电脑去管理你的Roon，并且输出到任何接入这个Roon平台的音频设备，也就是说他可以实现局域网内多平台操控和多房间系统播放。

硬件要求：
1：有一台群晖
2：CPU最好是I5或者I7级别，官方这么说的，因为有的计算需要CPU强劲一些，实测呢，蜗牛也能跑，如果你不搞升频什么的。
3：一块SSD，Roon安装在这块SSD里，比较好。速度真的快很多，要不恶心死你。我用的一块240还是256的INTEL的SSD，而且计划这块SSD只跑Roon。
当然，你也可以装在你的机械硬盘里，如果你不太在乎速度，或者你没那么多DSD音乐的话，实测这也不是必须的。

安装准备：
1：群晖开启Root权限（怎么开启我就不介绍了，网上教程太多了）
2：Winscp
3：最好有梯子，否则安装的你想哭

安装1.7版本的Roon官方套件

我们在群晖安装Roon Server时，由于涉及到程序自启动以及环境变量的配置问题，一般都选择运行官方的安装脚本方式进行安装。
roon官方的有关于群晖安装的链接：https://roononnas.org/de/roon-auf-nas/
按照链接下载安装文件：RoonServer_Synology_x86_64_2018-03-07.spk
然后到群晖后台去手动安装插件!

这里会有第一个坑。因为即使本地安装，他也需要连接服务器，不知道为什么，如果你没梯子，速度因地方而异了。我是开了梯子，顺利安装，非常快。这里打开你的梯子，并且让群晖可以走梯子。你有耐心慢慢等也是可以的，有人慢慢等也装上了。

到这里。第一部分结束，安装好了最新的1.7的Roon Server，但是现在老毛子只破解了1.6的，我们现在得替换文件。

版本文件替换

1.6文件下载：

链接: https://pan.baidu.com/s/1NiRZCHdrHXisZyE2wTLKBA 密码: j05p

1：进入套件中心，停用，上面绿色的已启动会变成停用。

2：打开你的群晖的SSH那些，控制面板–终端机和SNMP1，两个打钩。

3：解压缩你刚才下载的RoonServer那个压缩包。

4：运行WINSCP。第一个是SCP模式，然后HOSTNAME填写你的群晖的IP。端口如果你没改的话是22，usernama填root，后面password，就是你的root账号的密码了。

5：连接进去以后，找到你的RoonServer套件所在的位置。
我的是/volume7/@appstore/RoonServer/RoonServer。找到这个目录，然后左边本地找到你刚才解压缩的那个roonserver1.6下面的roonserver文件夹。你会发现左右两边的文件是一样的。这个时候我们覆盖他就好了。
怎么覆盖？左边的一起框柱，然后往右边啦过去。

这里会问你是不是要overwrite，就是问你是不是覆盖，选yes to all 就是是的全部。

自此覆盖全部结束，到这还没全结束，我们只是降级了，现在我们要破解了。

破解服务器端

相关文件：

链接: https://pan.baidu.com/s/1f5Kg2XSi4sAF9ygmu07pSA 密码: uw01

1：修改群晖的HOST文件
SSH修改方式很好，但是怕有的同学不会，咱们弄点简单的。打开刚才那个WINSCP软件，进入根目录下，找ETC目录，然后往下翻，找到hosts文件，拖到左边去，下载下来，软件不要关。

2：找到下载下来的hosts文件，双击，用写字板打开，当然用notepod更好。
最后加上两行

1
2

127.0.0.1 accounts5.roonlabs.com
127.0.0.1 updates.roonlabs.com

保存，然后从WINSCP软件里面，找到修改好的文件，再拖会群晖里面就好了。会提示你是不是覆盖，覆盖掉就好了。这样RoonServer就没办法升级和验证了。

3：修改电脑的HOSTS文件

进入 C:/Windows/System32/drivers/etc目录

把hosts文件COPY到桌面，然后记事本打开，加两行：

1
2

127.0.0.1 accounts5.roonlabs.com
127.0.0.1 updates.roonlabs.com

保存，然后覆盖回 C:/Windows/System32/drivers/etc目录。会提示你拒绝访问，要管理员权限，继续。

覆盖完成，准备工作就好了。

4：开始正式破解
这里面我们需要找一个注册文件
所以我们需要安装RoonServer服务器端的PC版，找到roon.rar文件，解压缩，得到一个文件夹和两个文件，我为了方便，新建了一个ROON目录，在C盘，把文件都放进去了。

RoonKeyMaker是破解文件，RoonInstaller64是播放软件，我们现在要用的是RoonServerInstaller64.exe，双击运行RoonServerInstaller64.exe。这里没什么讲究的，反正你一会会卸载他，如图按顺序即可。

然后你要注意你电脑的右下角，多了一个图标，是ROONSERVER的。显示是ROON。这个就是服务器端开始运行了。不用管他了。
运行CMD，调出命令行。

进入里的ROON破解文件的目录，如果你跟我的一样，按顺序输入

1
2

cd\
cd roon\RoonKeyMaker\rkm_win

进入目录(注意不要输入错，你可以直接复制我上面的命令运行）

然后输入

1

rkm_win -i rs

会跳出Enter your name,包括后面的。你可以随便输，不过这个后面你运行软件的时候会这么显示。

看到successfully我们知道成功了。（如果是PC端安装server的同学，这里你就破解成功了。右下角那个下图标，右键，quit，关闭一下，然后桌边的roonserver,重新启动一下就好了）
然后我们去找KEY去吧。看下面的图，找到如图文件，复制出来。
C:/Users/用户名/AppData/Local/RoonServer/Database/Core

还是得用WINSCP，把文件复制过来即可。

这里有一个提示，开始我们找的那个目录是APPSTONE下满这个目录不一样了，是你最早新建的那个目录，我的目录是 /volume7/RoonServer/RoonServer/Database/Core，你不是一定是volume7，根据你自己的情况，把文件拖过去，自此，RoonServer,安装破解成功。

安装播放控制端

找到开始那个roon压缩包的解压缩文件夹。
1：运行RoonInstaller64.exe安装播放控制端。安装没什么好说的了。

2：ROON就运行了。这时候我们什么都不要动。不管他，也别关软件，一定不要关软件，一定不要关软件，一定不要关软件，一定不要关软件，一定不要关软件，一定不要关软件。

3：破解PC的播放端
首先运行CMD，调出命令行
然后依次输入

1
2
3

cd \
cd roon\RoonKeyMaker\rkm_win
rkm_win -i r

看清楚了。这次是r不是rs了,这两个命令一个是破解服务器端，一个是破解播放端的。

4：关闭电脑上的Roon软件，然后重新运行。因为破解了啊。要重新运行一下。这个时候再重开软件哦
然后左下角选择语言。

选择你喜欢的语言，比如马来语什么的，然后会提示你语言改了。现在重启。

5：这边，因为破解了。说一堆什么的，不管他，但是我们还是要谢谢一下。选择不，谢谢！

然后，这边我同意！

6：连接你的服务器吧

自此安装全部完成。

emby-server媒体库硬链接.md

现在emby和plex等媒体ggi库对于刮削的命名要求很高，而PT下载后我们却很难将下载的媒体资源添加到影音库中，因为要保持源文件名进行保种，而复制一份文件的话，又很占硬盘空间，造成浪费。
在这种情况下，使用Linux连接就能便捷得一石二鸟。

软链接和硬链接

软连接可以便捷地创立整个文件夹的连接，但软连接类似快捷方式，删除源文件后，连接就会失效。
这种情况下，如果你删除PT保种的文件，在媒体库中整理好的资源也会失效。
相比起来，硬链接更加方便，在创立连接后，即便删除了源文件，只要没有删除所有的硬链接文件，硬链接仍然有效。
但Linux的硬链接却有一个小小的缺点：为了避免递归问题，硬链接只能创建单个文件的连接，而无法连接整个文件夹。

linux硬链接脚本

Windows下有一些好用的硬链接工具，但在Linux系统下，却没有找到类似的工具，于是我就就从零搞起，网上东抄抄西抄抄，自己写了个简单的批量硬链接脚本，进行对文件夹的硬链接，在我的openmediavault系统(基于debian)下测试了几周，还没出过问题。
还没有在别的系统上测试过，但理论上适用于所有Linux系统，包括群晖、铁骑马、威联通、openmediavault、unas等等。

使用教程

1. 编辑两个bash脚本文件hardlink.bash和2.bash，复制到Linux下的/usr/local/bin/文件夹中。
2. 使用cd命令切换到想要让硬链接文件存在的文件夹，如test。
3. 以root账户或具有root权限的账户执行：sudo bash hardlink.bash [你的PT下载影音资源所在的目录]

** 注：root权限下不再需要输入sudo，链接文件和源文件必须处于同一个硬盘之下，不能跨硬盘执行硬链接操作。**
如此一来，在test这个文件夹下，就出现了你想要硬链接的文件夹下的所有子文件夹和文件。
对链接文件进行修改文件名，删除操作，均不会影响源文件，仍然能pt保种，但修改链接文件内容，会造成源文件内容改变，同时，对于大部分的程序来说，硬链接文件和源文件是相同的。
如果感觉每次都需要输入很烦，可以创建一个计划任务，可以让系统自动创建硬链接。

hardlink.bash

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

#!/bin/bash
PRE_IFS=$IFS
IFS=$'\n'
distdir=$1
echo $distdir
newdir=`basename $distdir`
mkdir $newdir
cd $newdir
filename=$(ls $distdir)
currentdir=`pwd`
mod=$currentdir
echo $currentdir
for file in $filename
do
    echo $file
    if [ -f $distdir/$file ]
    then
        ln $distdir/$file $currentdir/$file
    fi
    if [ -d $distdir/$file ]
    then
        cd $currentdir
        mkdir $currentdir/$file
        cd $currentdir/$file
        bash /usr/local/bin/2.bash $distdir/$file
    fi
done
# 任务执行完毕，把IFS还原回默认值
chmod -R 777 $mod
IFS=$PRE_IFS

2.bash

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

#!/bin/bash
PRE_IFS=$IFS
IFS=$'\n'
currentdir=`pwd`
echo $currentdir
distdir=$1
echo $distdir
filename=$(ls $distdir)
for file in $filename
do
    echo $file
    if [ -f $distdir/$file ]
    then
        ln $distdir/$file $currentdir/$file
    fi
    if [ -d $distdir/$file ]
    then
        cd $currentdir
        mkdir $currentdir/$file
        cd $currentdir/$file
        bash /usr/local/bin/${0##*/} $distdir/$file
    fi
done
# 任务执行完毕，把IFS还原回默认值
IFS=$PRE_IFS

从 Spring Boot 2.x 开始 Lettuce 已取代 Jedis 成为首选 Redis 的客户端。当然 Spring Boot 2.x 仍然支持 Jedis，并且你可以任意切换客户端。

Lettuce

Lettuce 是一个可伸缩的线程安全的 Redis 客户端，支持同步、异步和响应式模式。多个线程可以共享一个连接实例，而不必担心多线程并发问题。它基于优秀 Netty NIO 框架构建，支持 Redis 的高级功能，如 Sentinel、集群、流水线、自动重新连接和 Redis 数据模型

Jedis 实现通过直接连接的 redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个 Jedis 实例增加物理连接。

Lettuce 的连接是基于 Netty 的，连接实例 (StatefulRedisConnection) 可以在多个线程间并发访问，因为 StatefulRedisConnection 是线程安全的，所以一个连接实例 (StatefulRedisConnection) 就可以满足多线程环境下的并发访问，当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。 　　　　　　　

Spring Boot 2.0 集成 redis

一般需要4步

1. 引入依赖
2. 配置 redis
3. 自定义 RedisTemplate (推荐)
4. 自定义 redis 操作类 (推荐)

引入依赖

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

<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- lettuce pool 缓存连接池 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

<!--jackson-->
<!--<dependency>-->
<!--    <groupId>com.fasterxml.jackson.core</groupId>-->
<!--    <artifactId>jackson-databind</artifactId>-->
<!--</dependency>-->

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.67</version>
</dependency>

• 如果用的是 lettuce 客户端，需要引入 commons-pool2 连接池。
• 如果想用 json 序列化 redis 的 value 值，需要引入 jackson

配置 redis

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

# redis 服务端相关配置
# 服务器地址
spring.redis.host=localhost
# 端口号
spring.redis.port=6379
# 密码，默认为 null
spring.redis.password=
# 使用的数据库，默认选择下标为0的数据库
spring.redis.database=0
# 客户端超时时间,默认是2000ms
spring.redis.timeout=2000ms


## jedis 客户端配置(从 Spring Boot 2.x 开始，不再推荐使用 jedis 客户端)
## 建立连接最大等待时间，默认1ms，超出该时间会抛异常。设为-1表示无限等待，直到分配成功。
#spring.redis.jedis.pool.max-wait=1ms
## 最大连连接数，默认为8，负值表示没有限制
#spring.redis.jedis.pool.max-active=8
## 最大空闲连接数,默认8。负值表示没有限制
#spring.redis.jedis.pool.max-idle=8
## 最小空闲连接数,默认0。
#spring.redis.jedis.pool.min-idle=0


# lettuce 客户端配置(从 Spring Boot 2.x 开始，推荐使用 lettuce 客户端)
# 建立连接最大等待时间，默认1ms，超出该时间会抛异常。设为-1表示无限等待，直到分配成功。
spring.redis.lettuce.pool.max-wait=1ms
# 最大连连接数，默认为8，负值表示没有限制
spring.redis.lettuce.pool.max-active=8
# 最大空闲连接数,默认8。负值表示没有限制
spring.redis.lettuce.pool.max-idle=8
# 最小空闲连接数,默认0。
spring.redis.lettuce.pool.min-idle=0
# 设置关闭连接的超时时间
spring.redis.lettuce.shutdown-timeout=100ms

自定义 RedisTemplate

RedisTemplate 是 spring 为我们提供的 redis 操作类，通过它我们可以完成大部分 redis 操作。

只要我们引入了 redis 依赖，并将 redis 的连接信息配置正确，springboot 就会根据我们的配置会给我们生成默认 RedisTemplate。

但是默认生成的 RedisTemplate 有两个地方不是很符合日常开发中的使用习惯

1. 默认生成的 RedisTemplate<K, V> 接收的key和value为泛型，经常需要类型转换，直接使用不是很方便
2. 默认生成的 RedisTemplate 序列化时，使用的是 JdkSerializationRedisSerializer ，存储到 redis 中后，内容为二进制字节，不利于查看原始内容

对于第一个问题，一般习惯将 RedisTemplate<K, V> 改为 RedisTemplate<String, Object>，即接收的 key 为 String 类型,接收的 value 为 Object 类型 对于第二个问题,一般会把数据序列化为 json 格式，然后存储到 redis 中，序列化成 json 格式还有一个好处就是跨语言，其他语言也可以读取你存储在 redis 中的内容

为了实现上面两个目的，我们需要自定义自己的 RedisTemplate。

如下，创建一个 config 类，在里面配置 自定义的 RedisTemplate

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

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    
    @Bean
    RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 配置 json 序列化器 - Jackson2JsonRedisSerializer
        Jackson2JsonRedisSerializer<Object> jacksonSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper()
                // 扩展序列化器，增加对 java.time.* 包中时间类的序列化、反序列化支持
                .registerModule(new ParameterNamesModule())
                .registerModule(new Jdk8Module())
                .registerModule(new JavaTimeModule());
        jacksonSerializer.setObjectMapper(objectMapper);

        // 创建并配置自定义 RedisTemplateRedisOperator
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 将 key 序列化成字符串
        template.setKeySerializer(new StringRedisSerializer());
        // 将 hash 的 key 序列化成字符串
        template.setHashKeySerializer(new StringRedisSerializer());
        // 将 value 序列化成 json
        template.setValueSerializer(jacksonSerializer);
        // 将 hash 的 value 序列化成 json
        template.setHashValueSerializer(jacksonSerializer);
        // 设置连接器
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }

}

自定义 Redis 操作类

虽然 RedisTemplate 已经对 redis 的操作进行了一定程度的封装，但是直接使用还是有些不方便，实际开发中，一般会对 RedisTemplate 做近一步封装，形成一个简单、方便使用的Redis 操作类。

当然你也可以选择不封装，看个人喜好。

具体的封装类参考基于 RedisTemplate 自定义 Redis 操作类。

Spring Cache

Spring Cache 是 Spring 为缓存场景提供的一套解决方案。通过使用 @CachePut、@CacheEvict、@Cacheable等注解实现对缓存的，存储、查询、删除等操作

当我们引入了 spring-boot-starter-data-redis 后，只要在带有@Configuration类上使用 @EnableCaching 注解 Spring Cache 就会被“激活”。

Spring Cache 会为我们配置默认的缓存管理器和key生成器，但是缓存管理器对缓存的序列化和key生成器生成的key，不易阅读。建议自定义缓存管理器和key生成器

如果用不上 Spring Cache ，可以不用管。

1

注意：Spring Cache 并不是只能使用 Redis 作为缓存容器，其他例如 MemCache 等缓存中间件，都支持。

配置 Spring Cache

1
2
3
4
5

## spring cache 配置
# 使用的缓存的类型
spring.cache.type=redis
# 通过 spring cache 注解添加的缓存 的到期时间，单位秒(这是一个自定义属性)
cache.expireTime=60

最重要的就是指定使用的缓存的类型
另外是一个自定义的变量，后面配置缓存管理器会用到

配置缓存管理器和 key 生成器

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

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;

@Configuration
// 开启 Spring Cache
@EnableCaching
public class CacheConfig extends CachingConfigurerSupport {

    @Value("${cache.expireTime}")
    // 缓存超时时间
    private int cacheExpireTime;

    /**
     * 配置@Cacheable、@CacheEvict等注解在没有指定Key的情况下，key生成策略
     * 该配置作用于缓存管理器管理的所有缓存
     * 最终生成的key 为 cache类注解指定的cacheNames::类名:方法名#参数值1,参数值2...
     *
     * @return
     */
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuffer sb = new StringBuffer();
                sb.append(target.getClass().getName());
                sb.append(":");
                sb.append(method.getName());
                sb.append("#");
                for (Object obj : params) {
                    sb.append(obj.toString());
                    sb.append(",");
                }
                return sb.substring(0, sb.length() - 1);
            }
        };
    }


    /**
     * 配置缓存管理器
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        // 配置 json 序列化器 - Jackson2JsonRedisSerializer
        Jackson2JsonRedisSerializer<Object> jacksonSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSerializer.setObjectMapper(objectMapper);

        //关键点，spring cache 的注解使用的序列化都从这来，没有这个配置的话使用的jdk自己的序列化，实际上不影响使用，只是打印出来不适合人眼识别
        RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                // 将 key 序列化成字符串
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 将 value 序列化成 json
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jacksonSerializer))//value序列化方式
                // 设置缓存过期时间，单位秒
                .entryTtl(Duration.ofSeconds(cacheExpireTime))
                // 不缓存空值
                .disableCachingNullValues();

        return RedisCacheManager.builder(factory)
                .cacheDefaults(cacheConfig)
                .build();
    }
}

总结

网上 Spring Boot 集成 redis 的教程大多都是，将 redis 和 spring cache 一块配置，很容易让人产生误解。

其实 redis 和 spring cache 是两个不同的东西，所以，上面的教程我特意分为了两个配置文件。

你可以只使用 redis 而不使用 spring cache，也可以反过来。

那为什么两者经常放在一起去讨论呢？
原因在于两者也有一定的联系

站在 reids 的角度看，spring cache 提供了一种便捷的操作 reids 的途径，为缓存场景提供了优秀的解决方案。

站在 spring cache 的角度看， reids 提供了一种缓存容器，可以把缓存放在 reids 中。

缓存管理器对 reids 的操作也是通过 redisTemplate 实现的。

renren-fast开发文档3.0最新版

版权说明

本文档为付费文档，版权归人人开源（renren.io）所有，并保留一切权利，本文档及其描述的内容受有关法律的版权保护，对本文档以任何形式的非法复制、泄露或散布到网络提供下载，都将导致相应的法律责任。

免责声明

本文档仅提供阶段性信息，所含内容可根据项目的实际情况随时更新，以人人开源社区公告为准。如因文档使用不当造成的直接或间接损失，人人开源不承担任何责任。

文档更新

本文档由人人开源于 2019 年 03 月 01 日最后修订。

第 1 章 项目介绍

人人权限系统是一套轻量级的权限系统，主要包括用户管理、角色管理、部门管理、菜单管理、定时任务、 参数管理、字典管理、文件上传、登录日志、操作日志、异常日志、文章管理、APP模块等功能。其中，还拥有多数据源、数据权限、国际化支持、Redis缓存动态开启与关闭、统一异常处理等技术特点。

1.1 项目描述

1.2 项目特点

1.3 数据交互

1.4 开发环境搭建

1.5 获取帮助

1.1 项目描述

renren-fast是一套轻量级的权限系统，主要包括用户管理、角色管理、菜单管理、定时任务、文件上传、系 统日志、APP模块等功能。其中，还拥有多数据源、Redis缓存动态开启与关闭、统一异常处理等技术特 点。

1.2 项目特点

• renren-fast采用SpringBoot 2.1、MyBatis、Shiro框架，开发的一套权限系统，极低门槛，拿来即用。设
  计之初，就非常注重安全性，为企业系统保驾护航，让一切都变得如此简单。
• 灵活的权限控制，可控制到页面或按钮，满足绝大部分的权限需求
• 完善的 XSS 防范及脚本过滤，彻底杜绝 XSS 攻击
• 支持MySQL、Oracle、SQL Server、PostgreSQL等主流数据库

推荐使用阿里云服务器部署项目，免费领取阿里云优惠券，请点击【免费领取】

1.3 数据交互

• 一般情况下，web项目都是通过session进行认证，每次请求数据时，都会把jsessionid放在cookie中，以便与服务端保持会话
• 本项目是前后端分离的，通过token进行认证（登录时，生成唯一的token凭证），每次请求数据时，都会把token放在header中，服务端解析token，并确定用户身份及用户权限，数据通过json交互
• 数据交互流程，如下所示：

1.4 开发环境搭建

1.4.1 软件需求

• JDK 1.8+
• Maven 3.0+
• MySQL 5.5+
• Oracle 11g+
• SQL Server 2012+
• PostgreSQL 9.4+

1.4.2 下载源码

• 通过 git ，下载renren-fast源码，如下：

1

git clone https://gitee.com/renrenio/renren-fast.git

1.4.3 IDEA 开发工具

• IDEA打开项目， File -> Open 如下图：

1.4.4 Eclipse 开发工具

• Eclipse导入项目，如下图：

1.4.5 创建数据库

• 创建数据库 renren_fast ，数据库编码为UTF-8

1
2

CREATE
DATABASE renren_fast CHARACTER SET utf8 COLLATE utf8_general_ci;

• 执行 db/mysql.sql 文件，初始化数据（默认支持MySQL）

1.4.6 修改配置文件

• 修改 application-dev.yml ，更新MySQL账号和密码
• 运行 io.renren.RenrenApplication.java 的 main 方法，则可启动项目
• Swagger路径：http://localhost:8080/renren-fast/swagger/index.html
• Swagger注解路径：http://localhost:8080/renren-fast/swagger-ui.html

1.4.7 前端部署

renren-fast-vue基于vue、element-ui构建开发，实现renren-fast后台管理前端功能，提供一套更优的前端解决方案。 欢迎star或fork前端Git库，方便日后寻找，及二次开发

• 开发环境，需要安装node8.x最新版

1
2
3
4
5
6

# 克隆项目
git clone https://gitee.com/renrenio/renren-fast-vue.git
# 安装依赖
npm install --registry=https://registry.npm.taobao.org
# 启动服务
npm run dev

• 生产环境，打包并把dist目录文件，部署到Nginx里

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

#构建生产环境(默认)
npm run build
# 构建测试环境
npm run build --qa
# 构建验收环境
npm run build --uat
# 构建生产环境
npm run build --prod
# 安装Nginx，并配置Nginx
server {
		listen 80;
		server_name localhost;
		location / {
				root E:\\renren-fast-vue;
				index index.html index.htm;
		}
}
# 启动Nginx后，访问如下路径即可
http://localhost

• 登录的账号密码：admin/admin

1.5 获取帮助

• 后端地址：https://gitee.com/renrenio/renren-fast

• 前端地址：https://github.com/renrenio/renren-fast-vue

• 代码生成器：https://gitee.com/renrenio/renren-generator

• 官方社区：https://www.renren.io/community

• 如需寻求帮助、项目建议、技术讨论等，请移步到官方社区，我会在第一时间进行解答或回复 如需关注项目最新动态，请Watch、Star项目，同时也是对项目最好的支持

第 2 章 数据库支持

2.1 MySQL 数据库支持

2.2 Oracle 数据库支持

2.3 SQL Server 数据库支持

2.4 PostgreSQL 数据库支持

2.1 MySQL 数据库支持

1. 修改数据库配置信息，开发环境的配置文件在application-dev.yml，如下所示：

1
2
3
4
5
6
7

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/renren_fast?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false
      username: root
      password: 123456

2. 执行db/mysql.sql，创建表及初始化数据，再启动项目即可

2.2 Oracle 数据库支持

1. 修改数据库配置信息，开发环境的配置文件在application-dev.yml，如下所示：

1
2
3
4
5
6
7

spring:
  datasource:
    druid:
    driver-class-name: oracle.jdbc.OracleDriver
    url: jdbc:oracle:thin:@192.168.10.10:1521:renren
    username: renren_fast
    password: 123456

2. 执行db/oracle.sql，创建表及初始化数据，再启动项目即可

2.3 SQL Server 数据库支持

1. 修改数据库配置信息，开发环境的配置文件在application-dev.yml，如下所示：

1
2
3
4
5
6
7

spring:
  datasource:
    druid:
    driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
    url: jdbc:sqlserver://192.168.10.10:1433;DatabaseName=renren_fast
    username: sa
    password: 123456

2. 执行db/sqlserver.sql，创建表及初始化数据，再启动项目即可

2.4 PostgreSQL 数据库支持

1. 修改数据库配置信息，开发环境的配置文件在application-dev.yml，如下所示：

1
2
3
4
5
6
7

spring:
  datasource:
    druid:
    driver-class-name: org.postgresql.Driver
    url: jdbc:postgresql://192.168.10.10:5432/renren_fast
    username: renren
    password: 123456

2. 修改quartz配置信息，quartz配置文件 ScheduleConfig.java ，打开注释，如下所示：

1
2
3

//PostgreSQL数据库，需要打开此注释
prop.put("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.PostgreSQLD
elegate");

3. 执行db/postgresql.sql，创建表及初始化数据，再启动项目即可

第 3 章 多数据源支持

3.1 多数据源配置

3.2 多数据源使用

3.3 源码讲解

3.1 多数据源配置

多数据源的应用场景，主要针对跨多个数据库实例的情况，如果是同实例中的多个数据库，则没必要使用多数据源。

1
2
3

#下面演示单实例，多数据库的使用情况
select * from db.table;
#其中，db为数据库名，table为数据库表名

• 配置多数据源，如果是开发环境，则修改 application-dev.xml ，如下所示

多数据源的配置

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

dynamic:
  datasource:
    slave1:
      driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
      url: jdbc:sqlserver://192.168.10.10:1433;DatabaseName=renren_fast
      username: sa
      password: 123456
      slave2:
        driver-class-name: org.postgresql.Driver
        url: jdbc:postgresql://192.168.10.10:5432/renren_fast
        username: postgres
        password: 123456

3.2 多数据源使用

多数据源的使用，只需在Service类、方法上添加@DataSource(“”)注解即可，比如在类上添加了 @DataSource(“userDB”)注解，则表示该Service方法里的所有CURD，都会在 userDB 数据源里执行。

1. 多数据源注解使用规则
   • 支持在Service类或方法上，添加多数据源的注解@DataSource
   • 在Service类上添加了@DataSource注解，则该类下的所有方法，都会使用@DataSource标注的数据源
   • 在Service类、方法上都添加了@DataSource注解，则方法上的注解会覆盖Service类上的注解
2. 编写DynamicDataSourceTestService.java，测试多数据源及事物

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

package io.renren.service;

import io.renren.commons.dynamic.datasource.annotation.DataSource;
import io.renren.dao.SysUserDao;
import io.renren.entity.SysUserEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 测试多数据源
 *
 * @author Mark sunlightcs@gmail.com
 */
@Service
//@DataSource("slave1") 多数据源全局配置
public class DynamicDataSourceTestService {
    @Autowired
    private SysUserDao sysUserDao;

    @Transactional
    public void updateUser(Long id) {
        SysUserEntity user = new SysUserEntity();
        user.setUserId(id);
        user.setMobile("13500000000");
        sysUserDao.updateById(user);
    }

    @Transactional
    @DataSource("slave1")
    public void updateUserBySlave1(Long id) {
        SysUserEntity user = new SysUserEntity();
        user.setUserId(id);
        user.setMobile("13500000001");
        sysUserDao.updateById(user);
    }

    @DataSource("slave2")
    @Transactional
    public void updateUserBySlave2(Long id) {
        SysUserEntity user = new SysUserEntity();
        user.setUserId(id);
        user.setMobile("13500000002");
        sysUserDao.updateById(user);
        //测试事物
        int i = 1 / 0;
    }
}

3. 运行测试类DynamicDataSourceTest.java，即可测试多数据源及事物是生效的

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

package io.renren.service;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * 多数据源测试
 *
 * @author Mark sunlightcs@gmail.com
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class DynamicDataSourceTest {
    @Autowired
    private DynamicDataSourceTestService dynamicDataSourceTestService;

    @Test
    public void test() {
        Long id = 1L;
        dynamicDataSourceTestService.updateUser(id);
        dynamicDataSourceTestService.updateUserBySlave1(id);
        dynamicDataSourceTestService.updateUserBySlave2(id);
    }
}

3. 其中， @DataSource(“slave1”) 、 @DataSource(“slave2”) 里的 slave1 、 slave2 值，是在application- dev.xml里配置的，如下所示：

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

dynamic:
  datasource:
    slave1:
      driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
      url: jdbc:sqlserver://localhost:1433;DatabaseName=renren_security
      username: sa
      password: 123456
    slave2:
      driver-class-name: org.postgresql.Driver
      url: jdbc:postgresql://localhost:5432/renren_security
      username: renren
      password: 123456

3.3 源码讲解

1. 定义多数据源注解类@DataSource，使用多数据源时，只需在Service方法上添加@DataSource注解即可

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

import java.lang.annotation.*;

/**
 * 多数据源注解
 *
 * @author Mark sunlightcs@gmail.com
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource {
    String value() default "";
}

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

/**
 * 多数据源属性
 *
 * @author Mark sunlightcs@gmail.com
 */
public class DataSourceProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    /**
     * Druid默认参数
     */
    private int initialSize = 2;
    private int maxActive = 10;
    private int minIdle = -1;
    private long maxWait = 60 * 1000L;
    private long timeBetweenEvictionRunsMillis = 60 * 1000L;
    private long minEvictableIdleTimeMillis = 1000L * 60L * 30L;
    private long maxEvictableIdleTimeMillis = 1000L * 60L * 60L * 7;
    private String validationQuery = "select 1";
    private int validationQueryTimeout = -1;
    private boolean testOnBorrow = false;
    private boolean testOnReturn = false;
    private boolean testWhileIdle = true;
    private boolean poolPreparedStatements = false;
    private int maxOpenPreparedStatements = -1;
    private boolean sharePreparedStatements = false;
    private String filters = "stat,wall";

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getInitialSize() {
        return initialSize;
    }

    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }

    public int getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }

    public int getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }

    public long getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(long maxWait) {
        this.maxWait = maxWait;
    }

    public long getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }

    public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis =
                timeBetweenEvictionRunsMillis;
    }

    public long getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }

    public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis =
                minEvictableIdleTimeMillis;
    }

    public long getMaxEvictableIdleTimeMillis() {
        return maxEvictableIdleTimeMillis;
    }

    public void setMaxEvictableIdleTimeMillis(long maxEvictableIdleTimeMillis) {
        this.maxEvictableIdleTimeMillis =
                maxEvictableIdleTimeMillis;
    }

    public String getValidationQuery() {
        return validationQuery;
    }

    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }

    public int getValidationQueryTimeout() {
        return validationQueryTimeout;
    }

    public void setValidationQueryTimeout(int validationQueryTimeout) {
        this.validationQueryTimeout =
                validationQueryTimeout;
    }

    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public boolean isPoolPreparedStatements() {
        return poolPreparedStatements;
    }

    public void setPoolPreparedStatements(boolean poolPreparedStatements) {
        this.poolPreparedStatements =
                poolPreparedStatements;
    }

    public int getMaxOpenPreparedStatements() {
        return maxOpenPreparedStatements;
    }

    public void setMaxOpenPreparedStatements(int maxOpenPreparedStatements) {
        this.maxOpenPreparedStatements =
                maxOpenPreparedStatements;
    }

    public boolean isSharePreparedStatements() {
        return sharePreparedStatements;
    }

    public void setSharePreparedStatements(boolean sharePreparedStatements) {
        this.sharePreparedStatements =
                sharePreparedStatements;
    }

    public String getFilters() {
        return filters;
    }

    public void setFilters(String filters) {
        this.filters = filters;
    }
}

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

import org.springframework.boot.context.properties.ConfigurationProperties;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 多数据源属性
 *
 * @author Mark sunlightcs@gmail.com
 */
@ConfigurationProperties(prefix = "dynamic")
public class DynamicDataSourceProperties {
    private Map<String, DataSourceProperties> datasource = new LinkedHashMap<>();

    public Map<String, DataSourceProperties> getDatasource() {
        return datasource;
    }

    public void setDatasource(Map<String, DataSourceProperties> datasource) {
        this.datasource = datasource;
    }
}

3. 扩展Spring的AbstractRoutingDataSource抽象类，
   AbstractRoutingDataSource中的抽象方法determineCurrentLookupKey是实现多数据源的核心，并对该方法进行Override，如下所示：

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

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 多数据源
 *
 * @author Mark sunlightcs@gmail.com
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicContextHolder.peek();
    }
}

4. 数据源上下

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

/**
 * 多数据源上下文
 *
 * @author Mark sunlightcs@gmail.com
 */
public class DynamicContextHolder {
    @SuppressWarnings("unchecked")
    private static final ThreadLocal<Deque<String>> CONTEXT_HOLDER = new ThreadLocal() {
        @Override
        protected Object initialValue() {
            return new ArrayDeque();
        }
    };

    /**
     * 获得当前线程数据源
     *
     * @return 数据源名称
     */
    public static String peek() {
        return CONTEXT_HOLDER.get().peek();
    }

    /**
     * 设置当前线程数据源
     *
     * @param dataSource 数据源名称
     */
    public static void push(String dataSource) {
        CONTEXT_HOLDER.get().push(dataSource);
    }

    /**
     * 清空当前线程数据源
     */
    public static void poll() {
        Deque<String> deque = CONTEXT_HOLDER.get();
        deque.poll();
        if (deque.isEmpty()) {
            CONTEXT_HOLDER.remove();
        }
    }
}

5. 配置多数据源，如下所示：

1
2
3

return druidDataSource;
}
}

5. @DataSource注解的切面处理类，动态切换的核心代码

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

import com.alibaba.druid.pool.DruidDataSource;
import io.renren.commons.dynamic.datasource.properties.DataSourceProperties;
import io.renren.commons.dynamic.datasource.properties.DynamicDataSourceProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * 配置多数据源
 *
 * @author Mark sunlightcs@gmail.com
 */
@Configuration
@EnableConfigurationProperties(DynamicDataSourceProperties.class)
public class DynamicDataSourceConfig {
    @Autowired
    private DynamicDataSourceProperties properties;

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }
//因为DynamicDataSource是继承与AbstractRoutingDataSource，而AbstractRoutingDataSource又是继
    承于AbstractDataSource，AbstractDataSource实现了统一的DataSource接口，
    所以DynamicDataSource也可
            以当做DataSource使用

    @Bean
    public DynamicDataSource dynamicDataSource(DataSourceProperties dataSourceProperties) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(getDynamicDataSource());
        //默认数据源
        DruidDataSource defaultDataSource = DynamicDataSourceFactory.buildDruidDataSource(dat
                aSourceProperties);
        dynamicDataSource.setDefaultTargetDataSource(defaultDataSource);
        return dynamicDataSource;
    }

    private Map<Object, Object> getDynamicDataSource() {
        Map<Object, Object> targetDataSources = new HashMap<>();
        properties.getDatasource().forEach((k, v) -> {
            DruidDataSource druidDataSource = DynamicDataSourceFactory.buildDruidDataSource(v
            );
            targetDataSources.put(k, druidDataSource);
        });
        return targetDataSources;
    }
}

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

import com.alibaba.druid.pool.DruidDataSource;
import io.renren.commons.dynamic.datasource.properties.DataSourceProperties;

import java.sql.SQLException;

/**
 * DruidDataSource
 *
 * @author Mark sunlightcs@gmail.com
 */
public class DynamicDataSourceFactory {
    public static DruidDataSource buildDruidDataSource(DataSourceProperties properties) {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(properties.getDriverClassName());
        druidDataSource.setUrl(properties.getUrl());
        druidDataSource.setUsername(properties.getUsername());
        druidDataSource.setPassword(properties.getPassword());
        druidDataSource.setInitialSize(properties.getInitialSize());
        druidDataSource.setMaxActive(properties.getMaxActive());
        druidDataSource.setMinIdle(properties.getMinIdle());
        druidDataSource.setMaxWait(properties.getMaxWait());
        druidDataSource.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRun
                sMillis());
        druidDataSource.setMinEvictableIdleTimeMillis(properties.getMinEvictableIdleTimeMilli
                s());
        druidDataSource.setMaxEvictableIdleTimeMillis(properties.getMaxEvictableIdleTimeMilli
                s());
        druidDataSource.setValidationQuery(properties.getValidationQuery());
        druidDataSource.setValidationQueryTimeout(properties.getValidationQueryTimeout());
        druidDataSource.setTestOnBorrow(properties.isTestOnBorrow());
        druidDataSource.setTestOnReturn(properties.isTestOnReturn());
        druidDataSource.setPoolPreparedStatements(properties.isPoolPreparedStatements());
        druidDataSource.setMaxOpenPreparedStatements(properties.getMaxOpenPreparedStatements(
        ));
        druidDataSource.setSharePreparedStatements(properties.isSharePreparedStatements());
        try {
            druidDataSource.setFilters(properties.getFilters());
            druidDataSource.init();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return druidDataSource;
    }
}

5. @DataSource注解的切面处理类，动态切换的核心代码

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

import io.renren.commons.dynamic.datasource.annotation.DataSource;
import io.renren.commons.dynamic.datasource.config.DynamicContextHolder;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 多数据源，切面处理类
 *
 * @author Mark sunlightcs@gmail.com
 */
@Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class DataSourceAspect {
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("@annotation(io.renren.commons.dynamic.datasource.annotation.DataSource) " +
            "|| @within(io.renren.commons.dynamic.datasource.annotation.DataSource)")
    public void dataSourcePointCut() {
    }

    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Class targetClass = point.getTarget().getClass();
        Method method = signature.getMethod();
        DataSource targetDataSource = (DataSource) targetClass.getAnnotation(DataSource.class);
        DataSource methodDataSource = method.getAnnotation(DataSource.class);
        if (targetDataSource != null || methodDataSource != null) {
            String value;
            if (methodDataSource != null) {
                value = methodDataSource.value();
            } else {
                value = targetDataSource.value();
            }
            DynamicContextHolder.push(value);
            logger.debug("set datasource is {}", value);
        }
        try {
            return point.proceed();
        } finally {
            DynamicContextHolder.poll();
            logger.debug("clean datasource");
        }
    }
}