/ on archive

Mon, 01 Jan 0001 00:00:00 +0000

Intro(RIFF) #

摘自：维基百科

资源交换文件格式（英语： Resource Interchange File Format，缩写为 RIFF），又译资源互换文件格式，是一种文件格式（meta-format）标准，把资料存储在被标记的区块（tagged chunks）中。它是在 1991 年时，由 Microsoft 和 IBM 提出。它是 Electronic Arts 在 1985 提出的 Interchange File Format（IFF）的翻版。这两种标准的唯一不同处是在多比特整数的存储方式。 RIFF 使用的是小端序，这是 IBM PC 使用的处理器 80x86 所使用的格式，而 IFF 存储整数的方式是使用大端序，这是 Amiga 和 Apple Macintosh 电脑使用的处理器，68k，可处理的整数类型。

Microsoft在 AVI，WAV，以及接下来要介绍的 ANI 这些的文件格式中，都使用 RIFF 的格式当成它们的基础。
- 结构组成 #
  
  通用 trunk 结构
  RIFF 文件完全由各种chunk块组成，truck 是可以嵌套的，可以类比文件系统中的文件夹和文件。所有的chunk都有下面的格式：
  1. ID(4B)，比如 'RIFF'，'LIST'，'anhi' 等 ASCII 码，字符不够四个 ASCII，则用空格补全，比如'fmt ','seq '。
  2. SIZE(4B)，当前 chunk 无符号的整形值，尺寸不包括它自身占用的字节数和 ID 的四个字节。
  3. DATA(*)，当前块包含的数据，长度就是上一个 SIZE(4B) 对应的值。
  4. 一个填充字节，（可选值）如果当前 chunk 的数据不是偶数的话，会存在这个。例如综合图例中的 ID 为 ‘IART’ 的 truck 后面就有一个填充字节。

Mon, 01 Jan 0001 00:00:00 +0000

简介 #

grep(global regular expression print):
grep 主要用来查找，过滤，grep家族总共有三个：grep，egrep，fgrep。egrep = grep -E 扩展的正则表达式。

1、基本的正则表达式（Basic Regular Expression 又叫 Basic RegEx 简称 BREs）
2、扩展的正则表达式（Extended Regular Expression 又叫 Extended RegEx 简称 EREs）
3、Perl 的正则表达式（Perl Regular Expression 又叫 Perl RegEx 简称 PREs）

***********************************************************
 grep 默认 BREs, -E EREs, -P PREs
 egrep 默认 EREs, -P PREs
 sed 默认 BREs,-r EREs
 awk 默认 EREs
***********************************************************

常用选项 #

# -E : 开启扩展的正则表达式
# -i : 忽略大小写（ignore case）
# -v : 反向选择（invert）
# -n : 显示行号
# -o : 只显示匹配到的内容
# -w : 被匹配的文本只能是单词，不是某一部分，`like` 不会匹配liker
# -c : 显示匹配到多少行，与-cv使用表示反向匹配行数
# --color : 将匹配到的内容以颜色高亮显示
# -A n : 显示字符所在行及其后n行，after
# -B n : 显示字符所在行及其前n行，before
# -C n : 显示字符前后n行，context

grep "root" /etc/passwd
grep -n "root" /etc/passwd
grep -cv "root" /etc/passwd
grep -o "root" /etc/passwd
grep -A 2 "core id" /proc/cpuinfo

模式部分 #

1. 直接输入要匹配的字符串，可以使用fgrep(fast grep)代替来提高查找速度
2. 使用基本正则表达式
 * 匹配字符
 . :任意字符
 [abc] : 表示匹配一个字符，这个字符必须是abc中的一个。
 [^123] : 匹配一个除了123以外的字符
 [a-zA-Z] : 等价于[[:alpha:]]
 [0-9] : 等价于[[:digit:]]
 [a-zA-Z0-9] : 等价于 [[:alnum:]]
 tab,space : 等价于 [[:space:]]
 [A-Z] : [[:upper:]]
 [a-z] : [[:lower:]]
 标点符号 : [[:punct:]]
 
 # grep "hello." demo.c
 # grep "hello[[:upper:]]" demo.c
 # grep "hello[^[:upper:]][[:digit:]]" demo.c
 # grep "hell[a-z]" demo.c
 # grep "hell[a-z][[:punct:]]" demo.c
 
 * 匹配次数：
 \{m,n\} : 至少m,至多n次
 \? : 0 或 1 次
 * : 任意次
 
 # grep "/.*sh" /etc/passwd
 # grep "/.\{0,2\}sh" /etc/passwd
 # grep -w ".\{0,2\}sh" /etc/passwd
 
 * 位置锚定:
 ^ : 锚定行首
 $ : 锚定行尾： `^$`用于匹配空白行（没有空格）
 \b 或 \< : 单词词首
 \b 或 \> : 单词词尾
 \B : 与\b 相反 `beer/B` 不是以beer结尾
 
 # grep "h" /etc/passwd
 # grep "h$" /etc/passwd
 # grep "\<sh" /etc/passwd
 # grep "\Bsh\b" /etc/passwd
 
 * 分组及引用：
 \(string\) : 将string作为一个整体方便后面引用
 \n : 第几个引用，0表示本记录，从1开始
 
 # grep "^\(.\{1\}\).*\1$" /etc/passwd
 # grep "^\([[:alpha:]]\).*\1$" /etc/passwd

 * 分组后不引用 (?:), 参考Reference
 
 * 零宽断言：
 (?=pattern) 正向先行断言（正前瞻）
 (?<=pattern) 正向后行断言（正后顾）
 (?!pattern) 负向先行断言（负前瞻）
 (?<!=pattern)负向后行断言（负后顾）
 
 # 我爱祖国，我是祖国的花朵
 # 祖国(?=的花朵)
 # (?<=我爱)祖国
 # 祖国(?!的花朵)
 # (?<!我爱)祖国

3. 扩展正则表达式(-E | egrep)
 `?` `+` `|` `()` `{}`

外链 #

3.1 rubular.com外链 #

3.2 RegEx 学习记录 #

3.2.1正则匹配同时包含两个字符，不分先后顺序,https://rubular.com/r/C8klIhBII08CXN
^(?=.*?test)(?=.*?bash).*$
 以下下列子可能有助于理解:如果需要匹配字符，需要定界。
 ^(?=.*?test)(?=.*?bash).{9,}$
 ^(?=.*?test).{0,}(?=bash)
 ^(?=.*test)(?=.*bash)
 ^(?=.*test)(?=.*bash).{2}


3.2.2 正则不过滤但深色显示
cat abcdef | grep "content\|$"

3.2.3 网址之后一部分，或者没有网址的方式 (https://rubular.com/r/sXLihPuKPpJrCI)
/(^.*\/|^)(.*)$/

Reference #

OBJECT ORIENTED

Mon, 01 Jan 0001 00:00:00 +0000

对象结构 #
- 对象头 #
  - Mark Word #
    
    Mark Word(标记字)，用于存储自身运行时的数据例如GC标志位、哈希码、锁状态等信息。Mark Word 的位长度为 JVM 的一个 Word 大小，也就是说 32 位 JVM 的 Mark word 为 32 位，64 位 JVM 为 64 位。Mark Word 的位长度不会受到 Oop 对象指针压缩选项的影响。
    
    结构信息：
    Java 内置锁的涉及到很多重要信息，并且是存放于对象头的 Mark Word 字段中。
    
    Java 内置锁的状态总共有四种，级别由低到高依次为:无锁、偏向锁、轻量级锁、重量级锁。为了让 Mark word 字段存储更多的信息，JVM 将 Mark word 的最低两个位设置为 Java 内置锁状态位。
    
    其实在 JDK 1.6 之前，Java 内置锁还是一个重量级锁，是一个效率比较低下的锁，在 JDK 1.6 之后，JVM 为了提高锁的获取与释放效率，对 synchronized 的实现进行了优化，引入了偏向锁、轻量级锁的实现，从此以后 Java 内置锁的状态就有了四种(无锁、偏向锁、轻量级锁、重量级锁)，并且四种状态会随着竞争的情况逐渐升级，而且是不可逆的过程，即不可降级，也就是说只能进行锁升级(从低级别到高级别)。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(ANI | Animated cursors | 动画光标) #

摘自：维基百科

.ANI 文件格式是 Microsoft Windows 操作系统上用于动画鼠标光标的图形文件格式，该格式基于 Microsoft 资源交换文件格式，该格式用作存储动画的单个帧（标准Windows图标）的容器。
- 数据结构验证 #
Reference #
- https://en.wikipedia.org/wiki/ANI_(file_format)
- https://www.daubnet.com/en/file-format-ani
- https://sample-files-online.com/samples/ani [测试文件-ani样例文件]
- https://codesandbox.io/p/sandbox/open-ani-online-v6g3j [online load and show ani file]

Mon, 01 Jan 0001 00:00:00 +0000

awk (Alfred Aho 、Peter Weinberger 和 Brian Kernighan):
样式扫描和处理语言，它允许您创建简短的程序。读取输入文件，为数据排序，处理数据，对输入执行计算以及生成报表等。其中语法方面有借鉴C语言。

一.语法格式： #

awk 'pattern{action[;action..]}' {filenames}
 
原理：
 调用awk时，依次对文件中匹配的每一行做后面的action，每一对pattern+action用分号[;]隔开。
注意：
 如果一个'' 中没有pattern，默认所有行。action 必须{}包起来
 如果一个'' 中没有action，默认打印本行。
 如果什么都没有，只有'',不做任何处理。
 print,printf:
 print 输出后加一个ORS，而printf标准输出，想换行得加'\n',而这个换行不受awk的ORS控制。

二.常用选项： #

[option]
 -F fs or --field-separator fs :指定输入文件拆分符，是一个字符串或正则，如-F:
 -v var=value or --asign var=value :赋值一个用户变量
 -f scripfile or --file scriptfile :从脚本文件中读取awk命令。
 -mf nnn and -mr nnn :对nnn值设置内在限制，-mf选项限制分配给nnn的最大块数目；-mr选项限制记录的最大数目。这两个功能是Bell实验室版awk的扩展功能，在标准awk中不适用。
 -W compact or --compat, -W traditional or --traditional :在兼容模式下运行awk。所以gawk的行为和标准的awk完全一样，所有的awk扩展都被忽略。
 -W copyleft or --copyleft, -W copyright or --copyright :打印简短的版权信息。
 -W help or --help, -W usage or --usage :打印全部awk选项和每个选项的简短说明。
 -W lint or --lint :打印不能向传统unix平台移植的结构的警告。
 -W lint-old or --lint-old :打印关于不能向传统unix平台移植的结构的警告。
 -W posix :打开兼容模式。但有以下限制，不识别：/x、函数关键字、func、换码序列以及当fs是一个空格时，将新行作为一个域分隔符；操作符**和**=不能代替^和^=；fflush无效。
 -W re-interval or --re-inerval :允许间隔正则表达式的使用，参考(grep中的Posix字符类)，如括号表达式[[:alpha:]]。
 -W source program-text or --source program-text :使用program-text作为源代码，可与-f命令混用。
 -W version or --version :打印bug报告信息的版本。

三. 使用案例： #

1）简单样例 #

# echo 'hello this' | awk '' > 默认不做处理
# echo 'hello this' | awk '/hello/' >打印hello this
# echo 'hello this' | awk '{print $0}' >打印hello this

# cat test.txt | awk '{if(NR>=20 && NR<=30) print $0}' > 打印20～30行内容

>test.txt
I am Poe,my qq is 1234567
# cat test.txt | awk -F '[ ,]+' '{print $3" "$7' >Poe 1234567

2）BEGIN，END模块 #

# cat /etc/passwd | awk '{count++;print $0;}END{print "count is",count}' >统计/etc/passwd的账户人数
# ll | awk '{size=size+$5}END{print "size is",size/1024,"K"}' >统计某个文件夹下总字节数

3）awk运算符 #

# awk 'BEGIN{a=5;a+=5;print a}' >5,赋值运算符
# awk 'BEGIN{a=1;b=2;print (a>2&&b>1,a=1||b>1)}' >0 1 ,逻辑运算符
# awk 'BEGIN{a="100testaa";if(a~/100/)print "OK"}' >OK,正则运算符
# awk 'BEGIN{a="100testaa"} a~/100/ {print "OK"}' >等待用户输入
# awk 'BEGIN{a="11";if(a>=9){print "ok"}}' >无输出,关系运算符
# awk 'BEGIN{a=11;if(a>=9){print "ok"}}' >ok
# awk 'BEGIN{a;if(a>=b){print "ok"}}' >ok
# awk 'BEGIN{a="b";print a++,++a}' >0 2,算数运算符
# awk 'BEGIN{a="20b4";print a++,++a}' >20 22
# awk 'BEGIN{a="b";print a=="b"?"ok":"err"}' >ok,三目运算符
# awk 'BEGIN{a="b";print a=="c"?"ok":"err"}' >err

4）常用awk内置变量 #

$0 当前记录
$1~$n 当前记录的第n个字段
FS 输入字段分隔符，默认空格
RS 输入记录分隔符，默认换行符
NF 当前记录书中的字段个数
NR 行号，从1开始
OFS 输出字段分隔符，默认空格
ORS 输出记录分隔符，默认换行符

>tab.txt
ww CC IDD

# cat tab.txt | awk 'BEGIN{FS="\t+"}{print $1,$2,$3}' >ww CC IDD
# cat space.txt | awk -F [[:space:]+] '{print $1,$2,$3,$4,$5}'
# cat hello.txt | awk -F [" ":]+ '{print $1,$2,$3}'
# cat hello.txt | awk -F ":" 'NF==8{print $0}' hello.txt
# ifconfig eth0 | awk -F [" ":]+ 'NR==2{print $4}'

>record.txt
Jimmy the Weasel
100 Pleasant Drive
San Francisco,CA 123456

Big Tony
200 Incognito Ave.
Suburbia,WA 64890

>awk.txt
#!/bin/awk
BEGIN {
 FS="\n"
 RS=""
}
{
 print $1","$2","$3
}

# awk -f awk.txt recode.txt 
>Jimmy the Weasel,100 Pleasant Drive,San Francisco,CA 123456
>Big Tony,200 Incognito Ave.,Suburbia,WA 64890

5）awk正则 #

# cat /etc/passwd | awk '/root/{print $0}'
# cat /etc/passwd | awk -F: '$5~/root/{print $0}'
# cat /etc/passwd | awk -F: '$1=="root"{print $0}'

6）awk的C语言特性（if,循环和数组） #

-----------------------------
{
 if(){
 if(){
 ...
 }else{
 ...
 }
 }elseif(){
 ...
 }else{
 ...
 }
}
-----------------------------
{
 count=1 do{
 ...
 if(){
 break;
 }
 } while()
}
-----------------------------
for(x=1;x<=4;x++){
 ...
 if(){
 continue;
 }
}
-----------------------------
awk中的数组是关联数组，数字索引也会转变为字符串索引，是无序的，有序的得通过下标获得
-----------------------------
{
 cities[1]="beijing"
 cities[2]="shanghai"
 cities[“three”]="guangzhou"
 for( c in cities){
 print cities[c]
 }
 print cities["three"]; //也可以
}
# netstat -an|awk '/^tcp/{++s[$NF]}END{for(a in s)print a,s[a]}' 
>LISTEN 9
>ESTABLISHED 4

7）常用字符串函数 #

#替换
# awk 'BEGIN{info="this is a test2010test!";gsub(/[0-9]+/,"!",info);print info}' >this is a test!test!

#查找
# awk 'BEGIN{info="this is a test2010test!";print index(info,"test")?"ok":"no found";}' >ok

#匹配查找
# awk 'BEGIN{info="this is a test2010test!";print match(info,/[0-9]+/)?"ok":"no found";}' >ok

#截取
# awk 'BEGIN{info="this is a test2010test!";print substr(info,4,10);}' >s is a tes

#分割
# awk 'BEGIN{info="this is a test";split(info,tA," ");print length(tA);for(k in tA){print k,tA[k];}}'
>4
>4 test
>1 this
>2 is
>3 a

#length(),blength(),tolower(),toupper()...等

四.参考： #

Mon, 01 Jan 0001 00:00:00 +0000

sed (Stream Editor): #

文本流编辑，是一个"非交互式的"面向字符流的编辑器。能同时处理多个文件多行内容，可以不对源文件改动，把整个文件输入到屏幕，可以把只匹配到模式的内容输出到屏幕上。还可以对源文件改动，但是不会在屏幕上返回结果。

[root@12302 ~]# sed --version
sed (GNU sed) 4.2.2
Copyright (C) 2012 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Written by Jay Fenlason, Tom Lord, Ken Pizzini,
and Paolo Bonzini.
GNU sed home page: <http://www.gnu.org/software/sed/>.
General help using GNU software: <http://www.gnu.org/gethelp/>.
E-mail bug reports to: <bug-sed@gnu.org>.
Be sure to include the word ``sed'' somewhere in the ``Subject:'' field.

一.语法格式： #

# If no -e, --expression, -f, or --file option is given, then the first non-option argument is taken as the sed script to interpret. 
# All remaining arguments are names of input files; if no input files are specified, then the standard input is read.
sed [OPTION]... {script-only-if-no-other-script} [input-file]...

二.常用选项： #

option	describe
-n, –quiet, –silent	suppress automatic printing of pattern space
-e script, –expression=script	add the script to the commands to be executed
-r, –regexp-extended	use extended regular expressions in the script.
-f script-file, –file=script-file	add the contents of script-file to the commands to be executed
–follow-symlinks	follow symlinks when processing in place
-i[SUFFIX], –in-place[=SUFFIX]	edit files in place (makes backup if SUFFIX supplied)
-c, –copy	use copy instead of rename when shuffling files in -i mode
-s, –separate	consider files as separate rather than as a single continuous long stream.
-z, –null-data	separate lines by NUL characters
–version	output version information and exit
…	…

三.地址匹配： #

Sed commands can be given with no addresses, in which case the command will be executed for all input lines; with one address, in which case the command will only be executed for input lines which match that address; or with two addresses, in which case the command will be executed for all input lines which match the inclusive range of lines starting from the first address and continuing to the second address. Three things to note about address ranges: the syntax is addr1,addr2 (i.e., the addresses are separated by a comma); the line which addr1 matched will always be accepted, even if addr2 selects an earlier line; and if addr2 is a regexp, it will not be tested against the line that addr1 matched.
After the address (or address-range), and before the command, a ! may be inserted, which specifies that the command shall only be executed if the address (or address-range) does not match.

Mon, 01 Jan 0001 00:00:00 +0000

Intro(CURL| client url) #

SYNTAX #

# 1、直接访问默认是get
curl http://www.example.com 
# 2、-i,--include 打印响应头
curl http://www.example.com -i 
# 3、-I,--head 大写的只会打印响应头信息
curl http://www.example.com -I
# 3、-v,--verbose 详细信息
curl http://www.example.com -v
# 4、-d,--date 请求数据 配合-X(请求方式)
curl http://www.example.com -X post -d "username=xhsgg&pwd=123456"
# 5、-b,--cookie 附带cookie信息
curl http://www.example.com -b "JSESSIONID=************;time=***"
# 6、-H,--header 请求头消息，可以携带多个请求头
curl http://www.example.com -H "Content-Type:application/json"
# 7、-F,--form 表单的内容，可以上传文件
curl http://www.example.com -F "file=@_path_"

# 8、-L,--location 参数会让 http 请求跟随服务器的重定向，默认不跟随。
curl -L -i http://www.wtfu.site

# 9、-k,参数跳过 ssl/tls 证书检测
curl -k https://www.example.com

# 10、-x, 指定请求代理
curl -x socks5h://127.0.0.1:7890 https://yifen.996.buzz/gengxin
curl -x socks://127.0.0.1:7890 https://wtfu.site
curl -x 127.0.0.1:7890 https://yifen.996.buzz/gengxin
curl -x http://127.0.0.1:7890 https://webget.yfjc.xyz/api/v1/client/subscribe
curl -x https://127.0.0.1:10126 https://music.163.com/\#/song\?id\=1397021895
curl -x https://127.0.0.1:7890 -I https://wtfu.site

# 11、-X, 指定请求方法
curl -X POST https://www.example.com

# 12、-o,-O 保存文件
curl -o example.html https://www.example.com ==> example.html
curl -O https://www.example.com/foo/bar.html ==> bar.html

# 13 -T,--upload-file <file>
gpg --export 425B8CB8073AAC1EB005E4E648E1F1185160B400 | curl -T - https://keys.openpgp.org

# 使用curl 实现 telnet .追加超时时间是因为，有的服务器有安全策略阻止，会一直等待链接超时，效果跟端口开放相差无几，造成误解。
curl --connect-timeout 1 telnet://wtfu.site:30000

样例 #
- 1.ajax提交new from #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(wget) #

响应内容到标准输出 #

wget -q -O - -A 'Accept: application/xml' http://localhost:8080/test/helloxml
Reference #
- https://blog.csdn.net/geekooler/article/details/100853072

Mon, 01 Jan 0001 00:00:00 +0000

简介 #

1.介绍 #

Nginx (engine x) 是一个高性能的HTTP和反向代理web服务器，同时也提供了IMAP/POP3/SMTP服务,支持FastCGI,SSL,Virtual Host,URL Rewrite,Gzip等功能。
2.功能 #
- 反向代理
- 负载均衡
- 静态服务器
- 邮箱服务器

3.负载均衡方式 #

name	explain	feature
轮询	默认方式
weight	权重方式	根据权重分发请求,权重大的分配到请求的概率大
ip_hash	ip 分配	根据客户端请求的IP地址计算hash值，根据hash值来分发请求, 同一个IP发起的请求, 会发转发到同一个服务器上
url_hash	url 分配	根据客户端请求url的hash值，来分发请求, 同一个url请求, 会发转发到同一个服务器上
fair	智能响应	优先把请求分发给处理请求时间短的服务器
least_conn	最少连接	哪个服务器当前处理的连接少, 请求优先转发到这台服务器

编译安装 #

Tip
官方源码下载 1.16.1 、 1.26.2。
（可选）编译用的 openssl 源码库，主要为了支持 TLSv1.3。

Attention
切换完依赖的 openssl 库后记得重启服务器，要不然可能会存在配置的 TLSv1.3 的功能，即使通过-s reload但依然死活不生效，误以为配置出问题了。

Mon, 01 Jan 0001 00:00:00 +0000

基本命令 #
- BASE #
  
  提交镜像
  docker commit -a "xhsgg12302@gmail.com" -m "with requirements.txt" 44f357ee68bc eli/anaconda3:v1.0
  标签镜像
  docker tag bad7184c3c60 gitlab.pixdaddy.com:5050/library/eclipse-temurin:17.0.2_8-jre-3.8.18-python-alpine3.17-with-pip-deps
  加载镜像
  docker build -t me/venvs:v1.0 -f DK-venv .
  docker save me/venvs:v1.0 -o ./venvs.tar 、 docker save me/venvs:v1.0 > ./venvs.tar
  docker load -i /path/tmp/docker-build.tar
  删除容器
  docker ps -qa | xargs -n 1 docker rm -f
  
  这将列出所有没有被任何标签或容器引用的镜像。这些镜像通常被称为悬空镜像，因为它们没有被命名或引用，而且也没有被垃圾回收机制删除。
  https://docs.docker.com/engine/reference/commandline/images/#filter
  docker image ls -f "dangling=true"
  删除所有没有被标记或容器引用的悬空镜像
  docker image prune
  查找标记为 NONE 的镜像。运行以下命令：
  docker images | grep '<none>' | awk '{print $3}'
  删除标记为 NONE 的镜像。使用以下命令删除这些镜像：
  docker rmi $(docker images | grep '<none>' | awk '{print $3}')
  
  启动时去除基础镜像的entryponit 或者在Dockerfile中写入 ENTRYPOINT []
  docker run -d --entrypoint='' ff3b94479b5d /bin/sh -c "npm i; xvfb-run --server-args='-screen 0 1280x800x24 -ac -nolisten tcp -dpi 96 +extension RANDR' npm run dev"
  
  docker 不使用缓存构建镜像
  docker build -t **:1.0 --no-cache -f Dockerfile .
  docker 清理构建缓存
  docker builder prune、或者更深层次的docker system prune -a
  
  docker 进入内核查看 MacOSX 本地挂载卷 /var/lib/docker/volume
  docker run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh

Mon, 01 Jan 0001 00:00:00 +0000

代理设置 #

Note

有些时候需要搞明白代理如何生效，以致 clone、fetch 等远程操作纵享丝滑。
参考文档： http.proxy 、 Configure Git to use a proxy

http.proxy
	Override the HTTP proxy, normally configured using the http_proxy, https_proxy, and all_proxy environment variables (see curl(1)). In addition to the syntax understood by curl, it is possible to specify a proxy string with a user name but no password, in which case git will attempt to acquire one in the same way it does for other credentials. See gitcredentials[7] for more information. The syntax thus is [protocol://][user[:password]@]proxyhost[:port][/path]. This can be overridden on a per-remote basis; see remote.<name>.proxy
	【译：】可以通过`http.proxy`覆写 curl 可识别的环境变量：http_proxy, https_proxy, all_proxy 等。
	除了 curl 可识别的语法之外，还可以给代理字符串指定用户名，不需要密码，git 会通过`凭据管理`自动获取密码填充。语法形如：[protocol://][user[:password]@]proxyhost[:port][/path]

http.<url>.proxy
	给某个 URL 单独配置代理。

# 【添加代理】
git config --global http.proxy http://proxyUsername:proxyPassword@proxy.server.com:port
git config --global http.https://domain.com.proxy http://proxyUsername:proxyPassword@proxy.server.com:port

# 【删除代理】
git config --global --unset http.proxy
git config --global --unset http.https://domain.com.proxy

凭据管理 #
- 1.基本操作 #
  
  Caution

Mon, 01 Jan 0001 00:00:00 +0000

array

Mon, 01 Jan 0001 00:00:00 +0000

graph

Mon, 01 Jan 0001 00:00:00 +0000

Intro(CYCLE-LINKED | 环形链表检测) #
- 题目描述 #
  
  给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。若环不存在，请返回 null。如下：
  
  graph LR; A[3] --> B[2]; B --> C[0]; C --> D[-4]; D --> B; style B fill:#6f9,stroke:#333,stroke-width:4px;
  
  graph LR; A[3] --> B[2]; B --> C[0]; C --> D[-4]; D --> E[NULL];
  
  Attention
  在力扣题目面试题 02.08. 环路检测中，根据官方题解中第二种使用 快慢指针 的方式，可以求得环形链表的环点。
  但是有点费解的是，官方直接在首次相遇后推算出公式 $a=c+(n−1)(b+c)$，然后莫名其妙就判定如果此时使用pre和slow指针最终会在环点相遇。
  
  对于我来理解的话，跨度有点大了。经大佬视频的解释，慢慢理解了。
  
  大概就是：只有在第一次快慢指针相遇后，才能的出公式 $a=c+(n−1)(b+c)$，其他时间这个公式不一定成立。而且对于公式中的 n 来说，必定 >= 1，不存在 0 即（快指针还没跑一圈呢，就和慢指针相遇了）的情况。在得出公式后，我们可以知道，在首次相遇后这个时间点，会存在 $a = c + x圈 $ 这种关系。其中 a 和 c 只是距离问题，和快慢没关系了。所以在 首次相遇 情况下，可以理解为两个人从 a 开头和 c 开头，均速往环点走，一定会在环点相遇，无非是第二个人从 c 点多可能走几圈而已。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(REVERSE-LINKED-LIST | 反转链表) #
- 题目描述 #
  
  给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。如下：
  
  graph LR; A[1] --> B[2]; B --> C[3]; C --> D[4]; D --> E[5]; E --> F[NULL];
  
  graph RL; E[5] --> D[4]; D --> C[3]; C --> B[2]; B --> A[1]; A[1] --> F[NULL];
  
  Attention
  在力扣题目 206. 反转链表、剑指 Offer 24. 反转链表中，根据官方题解可知有迭代和递归的方式。
  
  对于递归的方式暂时先不记录。只对迭代通过图形的方式加深印象。

Mon, 01 Jan 0001 00:00:00 +0000

binary search #

implement #

import org.junit.Assert;
import org.junit.Test;

public class BinarySearch {

 @Test
 public void testBinarySearch(){
 int[] arr = new int[]{4,8,10, 16,18,20,50,100};

 Assert.assertEquals("", binarySearch(arr, 0, arr.length - 1, 4), 0);
 Assert.assertEquals("", binarySearch(arr, 0, arr.length - 1, 16), 3);
 Assert.assertEquals("", binarySearch(arr, 0, arr.length - 1, 100), 7);
 Assert.assertEquals("", binarySearch(arr, 0, arr.length - 1, 12302), -1);
 }

 private static int binarySearch(int[] arr, int left, int right, int key) {
 if(left > right) { return -1;}

 int mid = (left + right) / 2;
 int midKey = arr[mid];

 if(key > midKey){ return binarySearch(arr, mid + 1, right, key); }

 // right = mid - 1 才对，不然会发生 StackOverflowError, 比如： Assert.assertEquals("", binarySearch(arr, 0, arr.length - 1, 2), -1);
 // if(key < midKey){ return binarySearch(arr, left, mid, key); }
 if(key < midKey){ return binarySearch(arr, left, mid - 1, key); }
 return mid;
 }
}

Reference #

https://www.bilibili.com/video/BV1E4411H73v?p=82&vd_source=550a4dc4b2a914c0681a14307bbe8cbe

Mon, 01 Jan 0001 00:00:00 +0000

bubble #

visualization #

implement #

import java.util.Arrays;

public class BubbleSort{
 public static void sort(int[] raw){
 for (int i = 1; i < raw.length ; i++) {
 for (int j = 0; j < raw.length - i ; j++) {
 if(raw[j] > raw[j+1])
 switchNumberByTemp(raw,j,j+1);
 }
 }
 }

 public static void switchNumberByTemp(int[] raw,int x, int y){
 int temp = raw[x];
 raw[x] = raw[y];
 raw[y] = temp;
 }

 public static void main(String[] args){
 int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
 sort(arr);
 System.out.println(Arrays.toString(arr));
 }
}

Reference #

https://www.runoob.com/w3cnote/bubble-sort.html

Mon, 01 Jan 0001 00:00:00 +0000

insertion #

visualization #

implement #

import java.util.Arrays;

public class InsertionSort{
 public static void sort(int[] raw){
 for (int i = 1; i < raw.length; i++) {
 int preIndex = i - 1;
 int currentValue = raw[i];
 while(preIndex >= 0 && currentValue < raw[preIndex]){
 // 覆盖循环
 raw[preIndex + 1] = raw[preIndex];
 preIndex--;
 }
 raw[preIndex + 1] = currentValue;
 }
 }

 public static void main(String[] args){
 int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
 sort(arr);
 System.out.println(Arrays.toString(arr));
 }
}

def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex-=1
        arr[preIndex+1] = current
    return arr

Reference #

https://www.runoob.com/w3cnote/selection-sort.html

Mon, 01 Jan 0001 00:00:00 +0000

selection #

visualization #

implement #

import java.util.Arrays;

public class SelectionSort{
 public static void sort(int[] raw){
 for (int i = 0; i < raw.length - 1 ; i++) {
 int temp = i;
 for (int j = i + 1; j < raw.length ; j++) {
 if(raw[temp] > raw[j])
 temp = j;
 }
 switchNumberByXor(raw,i,temp);
 }
 }

 public static void switchNumberByXor(int[] raw, int x, int y ){
 if(raw[x] == raw[y]) return;
 raw[x] = raw[x] ^ raw[y];
 raw[y] = raw[x] ^ raw[y];
 raw[x] = raw[x] ^ raw[y];
 }

 public static void main(String[] args){
 int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
 sort(arr);
 System.out.println(Arrays.toString(arr));
 }
}

Reference #

https://www.runoob.com/w3cnote/selection-sort.html

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Stack) #

1. 栈的英文（stack)
2. 栈是一个先入先出（FILO-First In Last Out)的有序列表
3. 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，成为栈顶（top)，另一端为固定的一端，称为栈底（bottom）。
4. 根据栈的定义可知，最先放入栈中的元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(BinaryTree) #
- 二叉树 #
  - 定义 #
    
    二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2i-1个结点；深度为k的二叉树至多有2k-1个结点；对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1。
  - 性质 #
    
    1). 在非空二叉树中，第i层的结点总数不超过2i-1, i>=1;
    2) 深度为h的二叉树最多有2h-1个结点(h>=1)，最少有h个结点;
    3). 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;
    4). 具有n个结点的完全二叉树的深度为log2(n+1);
    5). 有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：
        若I为结点编号则如果I>1，则其父结点的编号为I/2；
        如果2I<=N，则其左儿子（即左子树的根结点）的编号为2I；若2I>N，则无左儿子；
        如果2I+1<=N，则其右儿子的结点编号为2I+1；若2I+1>N，则无右儿子。
    6). 给定N个节点，能构成h(N)种不同的二叉树，其中h(N)为卡特兰数的第N项，h(n)=C(2*n, n)/(n+1)。
    7). 设有i个枝点，I为所有枝点的道路长度总和，J为叶的道路长度总和J=I+2i。
- 满二叉树 #
  - 定义 #
    
    除最后一层无任何子节点外，每一层上的所有结点都有两个子结点。也可以这样理解，除叶子结点外的所有结点均有两个子结点。节点数达到最大值，所有叶子结点必须在同一层上。
  - 性质 #
    
    1) 一颗树深度为h，最大层数为k，深度与最大层数相同，k=h;
    2). 叶子数为2h;
    3). 第k层的结点数是：2k-1;
    4). 总结点数是：2k-1，且总节点数一定是奇数。
- 完全二叉树 #
  - 定义 #
    
    若设二叉树的深度为h，除第 h 层外，其它各层 (1～(h-1)层) 的结点数都达到最大个数，第h层所有的结点都连续集中在最左边，这就是完全二叉树。
    
    完全二叉树是效率很高的数据结构，堆是一种完全二叉树或者近似完全二叉树，所以效率极高，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才能优化，二叉排序树的效率也要借助平衡性来提高，而平衡性基于完全二叉树。
- 示例 #
- 线索化二叉树 #
  
  wiki: 在计算机科学中，线索二叉树（或称引线二叉树）是添加了直接指向节点的前驱和后继的指针的二叉树。
  
  图解与代码 #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(AVL) #

平衡二叉树又称AVL树。它可以是一颗空树，或者具有以下性质的二叉排序树：它的左子树和右子树的高度之差(平衡因子)的绝对值不超过1且它的左子树和右子树都是一颗平衡二叉树。因此它也被称为高度平衡树。
查找、插入和删除在平均和最坏情况下的时间复杂度都是 ${\color{red}O(\log_2 N)}$。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。
AVL 树得名于它的发明者 G. M. Adelson-Velsky 和 Evgenii Landis，他们在1962年的论文《An algorithm for the organization of information》中公开了这一数据结构。
- 来源 #
  
  为什么需要AVL：二叉搜索树一定程度上可以提高搜索效率，但是当原序列有序时，例如序列 A = {1，2，3，4，5，6}，构造二叉搜索树如下图。依据此序列构造的二叉搜索树为右斜树，同时二叉树退化成单链表，搜索效率降低为 ${\color{red}O(N)}$。
  
  在此二叉搜索树中查找元素 6 需要查找 6 次。
  二叉搜索树的查找效率取决于树的高度，因此保持树的高度最小，即可保证树的查找效率。同样的序列 A，将其改为图右的方式存储，查找元素 6 时只需比较 3 次，查找效率提升一倍。
  
  可以看出当节点数目一定，保持树的左右两端保持平衡，树的查找效率最高。这种左右子树的高度相差不超过 1 的树为平衡二叉树。
- 定义 #
  
  简称平衡二叉树。由前苏联的数学家 Adelse-Velskil 和 Landis 在 1962 年提出的高度平衡的二叉树，根据科学家的英文名也称为 AVL 树
  
  示例AVL.
  
  反示例AVL.
- 性质 #
  
  1. 可以是空树。
  2. 假如不是空树，任何一个结点的左子树与右子树都是平衡二叉树，并且高度之差的绝对值不超过 1。
- 平衡因子 #
  
  某节点的左子树与右子树的高度(深度)差即为该节点的平衡因子（BF,Balance Factor），平衡二叉树中不存在平衡因子大于 1 的节点。在一棵平衡二叉树中，节点的平衡因子只能取 0 、1 或者 -1 ，分别对应着左右子树等高，左子树比较高，右子树比较高。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Red-Black) #
- 定义 #
- 示例 #
- 性质 #
  1. 每个节点非黑即红。
  2. 根节点是黑色的。
  3. 每个NULL叶结点是黑色的[示例没画出来]。
  4. 如果一个节点是红色的，那么它的两个子节点都是黑色的。
  5. 从任一节点到叶子节点的所有路径上都包含相同数目的黑色节点(黑高相同)
- 来源 #
- 平衡因子 #
- 平衡 #

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(汇编语言(第4版)王爽-阅读笔记) #

9.1 复制指令(8BC3)到指定位置 #

有如下程序段,添写两条指令,使该程序在运行中将。处的一条指令复制到s0处。

;
assume cs:codesg
codesg segment
 s: mov ax, bx ; mov ax,bx的机器码占两个字节
 mov si, offset s
 mov di, offset s0
 ...
 ...
 s0: nop ; nop 的机器码占一个字节
 nop
codesg ends
end s

;
assume cs:codesg
codesg segment
 s: mov ax, bx
 mov si, offset s
 mov di, offset s0
 mov ax, cs:[si]
 mov cs:[di], ax
 s0: nop
 nop
codesg ends
end s

section .text
 global _start

_start:
 mov ax, 2h
 mov bx, 3h
 times 3 add ax,bx

 mov ax, 4c00h
 int 21h

section .data
 msg db 'Hello, world!$'

9.2 利用jcxz指令查找内存中的内容 #

补全程序,利用 jcxz 指令，实现在内存2000H 段中查找第一个值为0的字节,找到后,将它的偏移地址存储在 dx 中。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Varint-encoding) #
- 定义描述 #
  
  varint 类似于 utf-8，varchar等长度不定。顾名思义，属于变长的 int。对于一个 int 类型的数据来说，一般都为四个字节(固长)。所以变长的话就是将固定的四个字节中浪费的那部分去掉，比如对于整形 2 来说对应的二进制为 $00000000\space00000000\space00000000\space{\color{red}00000010}$ 前面的三个字节都为0，而且完全可以使用一个字节表示，此处对于整数2 来说，前三个字节就是浪费。所以出现了varint。使用少量字节来表示整数。使用定义型的方式描述就是：采用不定长的字节来编码或序列化一个整数。
- 编码过程 #
  
  Note
  将一个 int 型的数据二进制表示，从后至前，依次取 7 位，与 varint 特性 msb 占 1 位组成一个字节，直到无效字节(也就是前面全是零)，然后将这些字节按照小端字节序排列。形成一个新的数字，这个过程中会丢弃浪费字节，达到压缩的目的。
  
  varint msb 最高有效位为 1 表示后面都得字节属于当前值，为 0 表示当前字节是最后一部分。用来区分 varint 值边界。
  
  对于负数来说，编码过程并没有什么区别，只是因为负数最高位一直为 1，所以不存在浪费，也就是 vaint 对于负数压缩无效，字节不减反增。原本 -2 可以使用 8 个字节表示，但最终用使用了 10 个字节。所以在 ProtoBuf 中一般只处理无符号 64bit 值，签名如：func EncodeVarint(v uint64) []byte {}。所以我们此处传入的 -2 其实是当一个无符号正值处理的，负数的 varint 编码没有意义，我们应当避免直接对负值进行 varint 编码。而是先进行 zigzag 编码映射后在进行 varint处理。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(ZigZag-encoding) #
- 定义描述 #
  
  正如 varint 编码中所述，它对于负数来说显得手足无措，心有余而力不足。zigzag 编码 就是用来弥补 varint 的缺陷的。它会将负数映射成正值（但是不需要额外的映射表），比如：(0 = 0, -1 = 1, 1 = 2, -2 = 3, 2 = 4, -3 = 5, 3 = 6 ...)，从而能够使用 varint 继续编码。zigzag 编码的大致原理就是采用异或操作，将阻碍压缩的 1 进行消除。
  
  没有特别说明的都已 32 bit 进行阐述。
  
  异或操作
  异或运算(XOR | ^)，相同为 0，不同为 1。并且异或操作有如下特性：
  1). 任何数（0，1）与 1 进行异或的结果相当于取反，比如 0 ^ 1 = 1, 1 ^ 1 = 0。
  2). 任何数（0，1）与 0 进行异或的结果相当于不变，比如 0 ^ 0 = 0, 1 ^ 0 = 1。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Complement) #
- 重新认识计算机中的数字表示 #
  
  主要以一个字节，8比特位进行分析
  首先要知道计算机中的数字表示有空间限制，比如 java 中 byte 类型就用一个字节(8 bit)表示，而 int 得用 4byte（32 bit）。而且 java 默认都是有符号的，也即第一个比特位表示符号，一个byte 类型的变量可表示的值就是 $00000000$ - $11111111$。
  
  还有一点至关重要，就是进位后的值超出 8 位后会截断。比如 $11111111 + 1 = 1{\hspace{0.5em}}00000000 ==截断==> 00000000 $，要不然就没法循环了，跟钟表一样，到极限得归位。
  
  至于这些值表示的实际意义，可以在下面慢慢进行分析。（先不用考虑补码）
  1).: 首先分析正数，总共 8 位，一个符号位占一个[0],剩下的 7 位表示值的话就就是 $00000000$ - $01111111$ 表示数值 0 到 127，这个毋庸置疑的。
  2).: 不管一个负数怎么表示，都应该符合我们的理性认知。比如 -1 + 1 的值肯定是 0 的。
  3).: 现在有了正数值比如 1 ($00000001$)，加一操作后肯定等于 0。也即 $00000001$ + $8(*) = 00000000$
  4).: 目前只有让 $8(*)$ 这个未知值在加完后整体位溢出，被截断，才能达到加完一个值后更小。
  5).: 所以此处的 $8(*)$ 二进制表示应该是 $11111111$，加完 $00000001$ 后得到 $1{\hspace{0.5em}}00000000$，截断，然后正好等于 $00000000$。
  6).: 所以才让这个二进制 $11111111$ 表示的 -1。
  
  7).: 其他情况依次了类推，重要的是理解截断才能循环。再举个例子（-128）。
  8).: 已知上述得出的 -1$(11111111)$，和127$(01111111)$，所以 -128 $8(*)$ + 127 $01111111$ = -1 $11111111$
  9).: 后面的值在二进制表示上要比被加数大，所以这次不用截断，给 $8(*)$ 值设为 $10000000$ 即可。也就是 -128 = $10000000$
  
  为了更好的理解数据的分布，可以画一个圆来表示，方便记忆。范围: $[{\color{red}-(2^{8*size-1})}$ , ${\color{red}(2^{8*size-1})-1}]$，size = 1 时：[-128, 127].

Mon, 01 Jan 0001 00:00:00 +0000

Intro(ENDIANNESS | 字节序 | 端序 | 尾序) #

参考 wiki，记录这个是因为老是记不住，天天查，所以已自己比较容易记忆的方式将其记录下来，动手过一遍，避免胡翻乱找。

字节序分为大端（Big）和小端（Little）
高位低地址，低位高地址被称为大端序（Big ），参考下图可以理解为 顺序放置。
低位低地址，高位高地址被称为小端序（Little），参考下图可以理解为 逆序放置。

大小端序出现的背景：
计算机都是从低位往高位读取字节数据，而且方便处理，所以出现了小端序。但是小端序不符合人类的阅读习惯，且除了计算机内部之外，其他场合几乎都是大端字节序，比如网络传输一般采用大端序，也被称为 网络字节序，或 网络序。有 Berkeley套接字定义了一组转换函数，用于 16 和 32 位整数在网络序和本机字节序之间的转换。htonl(Host to Network Long(4Byte))，htons(Host to Network Short(2Byte))用于本机序转换到网络序；ntohl，ntohs用于网络序转换到本机序。
- 检测处理器字节序 #
  
  Note
  使用 C 语言程序即可验证：定义一个整形值int num = 1 = 0x 0000 0000 0000 0001;，然后强转成字符指针，取第一个字符（1 Byte）判断是否为 0，(小端逆序放置为 1，大端为 0)。
  编辑如下代码为 endian.c
  编译运行：gcc endian.c -o endian && ./endian
```
#include <stdio.h>

int main(){
 unsigned int num = 1;
 char *ptr = (char*) &num;

 if (*ptr) printf("Little\n");
 else printf("Big\n");

 return 0;
}
```
Reference #
- https://zh.wikipedia.org/wiki/%E5%AD%97%E8%8A%82%E5%BA%8F

Mon, 01 Jan 0001 00:00:00 +0000

CMAKE 💯 #

基础 #
- 简介 #
gcc
gcc是用来编译c文件的编译器。简单来说就是给他输入一个（或几个）c文件，它可以输出一个可执行文件。当你的程序只有一个源文件时，直接就可以用gcc命令编译它。但是当你的程序包含很多个源文件时，用gcc命令逐个去编译时，容易混乱而且工作量大。

make
因此出现了make工具。它本身没有编译和链接功能。但是它可以按照Makefile文件中的命令调用gcc来编译工程。有了make，我们就不用一个一个文件去编译，只要把他们的编译指令都写在Makefile中，然后make就可以一键完成。

cmake
为了进一步简化Makefile的书写，出现了cmake。cmake根据CMakeLists.txt文件生成项目的makefile，而且写法也大大简化。总的来说，CMake，make，gcc组成一个工具链，让我们在构建项目时只需要编写源文件以及CmakeLists.txt即可。它的流程如下：

graph LR A(编写CMakeLists.txt)-->B((Cmake)) B-->C(Makefile等配置文件) C-->D((make)) D-->F((gcc)) E(源文件)-->F F-->G(可执行程序)
- 基本规则 #
  1. 变量 #
  使用${}方式取值，变量名区分大小写（指令名不区分大小写）
  定义一个变量可以用SET指令：
```
SET(valname main.c src1.c src2.c)
```
  这条语句就是定一个一个名字叫valname的变量，它的值是main.c src1.c src2.c;相当于是valname=main.c src1.c src2.c
  系统预定义的变量
  
  在我们使用PROJECT指令指定工程名后，CMake会自动生成两个变量;可以在 CMakeCache.txt 中看到定义。
  - ${pname}_BINARY_DIR: 可执行程序目录，比如step1_BINARY_DIR,其实就是执行cmake命令时的当前目录，比如在build/外部编译，那么它就是build的绝对路径
  - ${pname}_SOURCE_DIR: 源文件目录，比如step1_SOURCE_DIR,就是主CmakeLists.txt所在的绝对路径。
  我们可以使用他们。同时系统还会帮我们预定义两个与工程名无关的变量，他们的内容与上述两个变量相同，但是好处是变量名不会因为工程名改变而改变，因此推荐使用：
  - PROJECT_BINARY_DIR : 可执行程序目录
  - PROJECT_SOURCE_DIR : 源文件目录
  1. 指令 #
  指令就是CMake里的函数。它的名称不区分大小写，调用的格式如下: * 指令名（参数1，参数2，参数3）参数之间用空格或者分号隔开。如果参数中包含括号，可以使用双引号将参数分开，如下所示：
```
SET(val fu n.c) # 指令会认为是'fu n.c'是两个参数
SET(val "fu n.c") # 使用双引号避免错误
```
  1. 使用 #
  CMake命令用于生成中间文件，使用时要传入CmakeLists.txt文件所在的目录。如果在主目录下直接生成配置文件，内部构建，这样做的坏处是使代码文件与中间文件相互混淆，因此最好的做法时外部构件。
  如下所示：在主目录下

Mon, 01 Jan 0001 00:00:00 +0000

Linux共享库，静态库，动态链接库 #

介绍 #

程序函数库可分为3种类型：静态函数库（static libraries）、共享函数库（shared libraries）、动态加载函数库（dynamically loaded libraries):
1. 静态函数库，是在程序执行前就加入到目标程序中去了；
2. 动态函数库同共享函数库是一个东西（在linux上叫共享对象库，文件后缀是.so ，windows上叫动态加载函数库，文件后缀是.dll）
- linux中明明系统的共享库的规则

代码实现 #

libhello.c

/* libhello.c - demonstrate library use. */
#include <stdio.h>

void hello(void) {
 printf("Hello, library world.\n");
}

libhello.h

/* libhello.h - demonstrate library use. */

void hello(void);

demo_use.c

Mon, 01 Jan 0001 00:00:00 +0000

Gradle入门到实战 #

Groovy语言的学习 #

学习Geadle我们需要先来学习一下Groovy，很多同学估计听说过Groovy语言，有的也许没听说过，其实我们每天在配置Gradle的时候就是在跟Groovy接触了。Groovy是一门jvm语言，最终编译成class文件然后在jvm上执行，Java语言的特性Groovy都支持，我们可以混写Java和Groovy，就是在同一文件中可以混写，注意，这里与Java和Kotlin可不一样，Java和Kotlin是可以互相调用，而不能在同一文件混写。

Groovy的优势是什么呢？Groovy增强了Java的很多功能。比如解析xml文件，文件读写等，Groovy只需要几行代码就能搞定，而如果用Java则需要几十行代码，简单说就是使用Groovy实现某些功能比Java要少些很多代码。

好了，说了那么多"废话"，下面就具体来了解一下Groovy语言，我们只需要了解其中核心的一些使用就可以了，没必要完全了解，作为一门语言Groovy也算比较复杂的，但是我们学习Groovy是为了编写Gradle插件那就只需要了解其核心部分就可以了，其实从我的经验来说学习Groovy更多是为了写更少的代码来实现一些功能，否则我直接用Java写不就完了。
- 1.Groovy的变量和方法声明 #
  - Groovy使用def来声明变量，声明变量可以不加类型，运行的时候可以自动推断出变量类型，并且声明语句可以不加分号结尾，如下：
```
def i = 10
def str = "hello groovy"
def d = 1.25
```
  - def同样用来定义函数，Groovy中函数返回值可以是无类型的：
```
def showName(){
 "wang lei" //最后一行执行结果默认作为函数返回值，可以不加return
}
```
  - 如果我们指定了函数的返回值类型，那么可以不加def关键字：
```
//定义函数
String showName(){
 "wang lei" //最后一行执行结果默认作为函数返回值
}
```
- 2.Groovy的字符串 #
  
  Groovy中字符串分为三种，我们一个个来看。

Mon, 01 Jan 0001 00:00:00 +0000

目录结构 #

Gradle uses two main directories to perform and manage its work: the Gradle User Home directory and the Project Root directory. 参考
初始化脚本 #

在项目构建之前进行初始化。参考
- 基本用法 #
  
  初始化脚本（又名init 脚本）与 Gradle 中的其他脚本类似。但是，这些脚本是在构建开始之前运行的。
  以下是几种可能的用途：
  - 设置企业范围的配置，例如在哪里可以找到自定义插件。
  - 根据当前环境设置属性，例如开发人员的计算机与持续集成服务器。
  - 提供构建所需的有关用户的个人信息，例如存储库或数据库身份验证凭据。
  - 定义特定于计算机的详细信息，例如 JDK 的安装位置。
  - 注册构建监听器。希望监听 Gradle 事件的外部工具可能会发现这很有用。
  - 注册构建记录器。您可以自定义 Gradle 如何记录它生成的事件。
  初始化脚本的一个主要限制是它们无法访问buildSrc项目中的类。
- 使用初始化脚本 #
  
  使用 init 脚本有多种方法：
  如果找到多个 init 脚本，它们都将按照下面指定的顺序执行。
  给定目录中的脚本按字母顺序执行。例如，工具可以在命令行上指定一个 init 脚本，并在主目录中指定另一个 init 脚本来定义环境。这两个脚本都会在 Gradle 执行时运行。
  - 在命令行上指定一个文件。命令行选项后面是-I,--init-script 的路径。(命令行选项可以出现多次，每次都会添加另一个初始化脚本。如果命令行上指定的任何文件不存在，构建将失败。)
  - init.gradle将一个名为（或init.gradle.ktsKotlin）的文件放入该目录中。$GRADLE_USER_HOME/
  - .gradle将以（或.init.gradle.ktsKotlin）结尾的文件放入目录中。$GRADLE_USER_HOME/init.d/
  - .gradle将以（或.init.gradle.ktsKotlin）结尾的文件放入Gradle 发行版的目录中。$GRADLE_HOME/init.d/
- 编写初始化脚本 #
  
  与 Gradle 构建脚本一样，init 脚本是 Groovy 或 Kotlin 脚本。每个 init 脚本都有一个与其关联的 Gradle实例。初始化脚本中的任何属性引用和方法调用都将委托给此Gradle实例。
  每个 init 脚本还实现 Script接口。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(make) #
- demo #
  # makefile 对空格相当挑剔，必须是制表符 # https://stackoverflow.com/questions/24145650/makefile6-missing-separator-stop OBJS = main.o tool1.o tool2.o CC = gcc CFLAGS += -c -Wall -g mytool: $(OBJS) $(CC) $^ -o $@ %.o: %.c $(CC) $^ $(CFLAGS) -o $@ .PHONY: clean clean: # 禁用回显使用@，或者在外部 make -s clean # https://stackoverflow.com/questions/9967105/suppress-echo-of-command-invocation-in-makefile @$(RM) *.o mytool -r
  - https://github.com/junegunn/fzf/blob/master/Makefile
- Spec #
  - rule #
    
    Makefile文件由一系列的规则(rules)组成。每条规则的形式如下：
    <target> : <prerequisites>
    [tab][commands]
    
    上面第一行冒号前面的部分，叫做"目标"（target），冒号后面的部分叫做"前置条件"（prerequisites）；第二行必须由一个tab键起首，后面跟着"命令"（commands）。
    “目标"是必需的，不可省略；“前置条件"和"命令"都是可选的，但是两者之中必须至少存在一个。每条规则就明确两件事：构建目标的前置条件是什么，以及如何构建。举例如下：
    
    a.txt: b.txt c.txt
    cat b.txt c.txt > a.txt

Mon, 01 Jan 0001 00:00:00 +0000

MAVEN分享 #

今天这次分享的主要就是maven构建工具使用的一些经验，和大家起分享，交流一下。也是为了日后能够更加灵活的使用。内容中也包括我原来对maven存在的误解和疑问的一些答疑。以交流学习，整理归纳为主。

Tips #
1. 运行mvn compile 会执行 clean 吗? 运行 package 会执行 compile吗?
2. optional,provided 区别?
3. 既然maven有自带的依赖仲裁机制，为什么还会出现依赖冲突?
4. mvn 依赖可以定义的位置及加载顺序，远程仓库定义的位置及加载顺序。mirrorOf实际意义?

介绍（一笔带过） #

maven 是继 ant 之后apache开源的软件构建工具，由绑定在生命周期上的插件辅助完成构建任务，主要的
功能包括解决依赖，集成测试，编译项目，定制化资源打包发布等。
介绍，下载地址，使用方式。

settings.xml 介绍 #

<localRepository>
<pluginGroups>
 配置插件的groupId。为的是单独执行插件的时候，可以简单调用。
 1，全路径执行。2，如何配置省略执行，3，自带的没有配置，为什么可以省略执行 4,prefix
<proxies>
<servers> 将pluginGroups中默认的标签解释一下
<mirrors>
 <mirror>
 <mirrorOf>
<profile> -- 属性压制

POM.xml介绍 #

<relativePath/>
 查找parent路径优先级； 指定的位置 > 本地仓库 > 远程仓库 
 1,当为空标签得时候，默认从本地仓库查找没有的话再从远程，
 2,不写得时候这个值默认为 ../pom.xml，也就是他上级路径得pom.xml.

<properties>
<dependencyManagement>
<dependencies>
 <dependency>
 <scope>
 <type>
 <classifier>
<build>
 <filters>
 <filter>
 <resource>
 <filtering>true|false
 <plugins>

properties 引用的各种形式，${},@@ #

https://maven.apache.org/pom.html#properties

resources 过滤或加载顺序
1,基本使用。
2，属性优先级

maven特性 #

生命周期，
继承与聚合，，
https://maven.apache.org/pom.html#a-final-note-on-inheritance-v-aggregation
 继承通过申明<parent>标签来定义。
依赖机制

问题答疑 #

1, 运行mvn compile 会执行 clean吗？运行package 会执行 compile吗？
 不会，因为查看文档发现 compile 阶段 跟 clean 阶段不属于同一个声明周期【分组】。
 或者执行命令也可发现在compile命令下，不会调用clean相关插件。

2, optional ,provided 区别，
 optional 表示可选依赖传递，可以理解为默认排除
 provided 表示依赖必选，但是使用方提供，

3，既然maven有自带的依赖仲裁机制，为什么还会出现依赖冲突？


4，mvn 依赖可以在哪些地方定义？最终生效的是那部分？
 1, <dependency> , <repository> 的定义是有顺序的。
 <dependency source> like repository,mirror,<profile>
 pom.dependency > profile.dependency > parent

 2,远程仓库定义
 settings > pom.profile > pom.repository

Mon, 01 Jan 0001 00:00:00 +0000

multiple containers in single pod #

apiVersion: apps/v1
kind: Deployment
metadata:
 labels:
 spring-boot: "true"
 app: multiple-pod-test
 provider: jkube
 version: 1.0.5-SNAPSHOT
 group: com.metaleap.framework
 name: multiple-pod-test
spec:
 replicas: 1
 revisionHistoryLimit: 2
 selector:
 matchLabels:
 app: multiple-pod-test
 provider: jkube
 group: com.metaleap.framework
 strategy:
 rollingUpdate:
 maxSurge: 5
 maxUnavailable: 0
 type: RollingUpdate
 template:
 metadata:
 labels:
 spring-boot: "true"
 app: multiple-pod-test
 provider: jkube
 version: 1.0.5-SNAPSHOT
 group: com.metaleap.framework
 spec:
 containers:
 - env:
 - name: SPRING_PROFILES_ACTIVE
 valueFrom:
 configMapKeyRef:
 name: base
 key: SPRING_PROFILES_ACTIVE
 - name: APPLICATION_NAME
 value: ${project.artifactId}
 - name: TZ
 value: Asia/Shanghai
 - name: KUBERNETES_NAMESPACE
 valueFrom:
 fieldRef:
 fieldPath: metadata.namespace
 - name: HOSTNAME
 valueFrom:
 fieldRef:
 fieldPath: metadata.name
 image: gitlab.pixdaddy.com:5050/magic/backend/magic-brush/magic-brush-app:1.0.1-SNAPSHOT
 imagePullPolicy: IfNotPresent
 lifecycle:
 postStart:
 exec:
 command:
 - sh
 - -c
 - |
 if netstat -nltp | grep ":80 "; then
 echo 'check port use netstat';
 exit 0;
 else
 echo 'not ready';
 exit 14;
 fi
 name: my-sqldb
 ports:
 - containerPort: 8090
 name: http
 protocol: TCP
 securityContext:
 privileged: false

 - env:
 - name: sqlhostname
 value: sql-test-pod
 - name: HOSTNAME
 valueFrom:
 fieldRef:
 fieldPath: metadata.name
 image: nginx
 ports:
 - containerPort: 80
 name: http
 protocol: TCP
 imagePullPolicy: IfNotPresent
 name: python-utils
 livenessProbe:
 httpGet:
 path: /
 port: 80
 initialDelaySeconds: 20
 periodSeconds: 9
 timeoutSeconds: 10
 readinessProbe:
 httpGet:
 path: /
 port: 80
 initialDelaySeconds: 25
 periodSeconds: 9
 timeoutSeconds: 10

 dnsConfig:
 options:
 - name: single-request-reopen
 - name: ndots
 value: "2"
 imagePullSecrets:
 - name: registry-key

Mon, 01 Jan 0001 00:00:00 +0000

虚拟机准备 #

# virtualbox 下载；https://download.virtualbox.org/virtualbox/7.0.6/VirtualBox-7.0.6-155176-OSX.dmg
# centos min : http://mirrors.aliyun.com/centos/7.9.2009/isos/x86_64/CentOS-7-x86_64-Minimal-2009.iso?spm=a2c6h.25603864.0.0.60196aeaRSRcS0
# k8s-master (bridge)(192.168.1.20)
# k8s-node01 (bridge)(192.168.1.31)
# k8s-node02 (bridge)(192.168.1.32)

系统初始化 #

# 设置系统主机名以及 Host文件的相互解析
hostnamectl set-hostname k8s-master01

# 安装依赖包
yum install -y conntrack ntpdate ntp ipvsadm ipset jq iptables curl sysstat libseccomp wget vim net-tools git

# 设置防火墙为 Iptables 并设置空规则
systemctl stop firewalld && systemctl disable firewalld 
yum -y install iptables-services && systemctl start iptables && systemctl enable iptables && iptables -F && service iptables save

# 关闭SELINUX
swapoff -a && sed -i '/ swap /s/^\(.*\)$/#\1/g' /etc/fstab && setenforce 0 && sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

# 调整内核参数，对于K8S
cat > kubernetes.conf <<EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
net.ipv4.tcp_tw_recycle=0
vm.swappiness=0 #禁止使用swap空间，只有当系统OOM时才允许使用它 
vm.overcommit_memory=1 # 不检查物理内存是否够用
vm.panic_on_oom=0 # 开启 OOM
fs.inotify.max_user_instances=8192
fs.inotify.max_user_watches=1048576
fs.file-max=52706963
fs.nr_open=52706963
net.ipv6.conf.all.disable_ipv6=1
net.netfilter.nf_conntrack_max=2310720
EOF
cp kubernetes.conf /etc/sysctl.d/kubernetes.conf
sysctl -p /etc/sysctl.d/kubernetes.conf # sysctl: cannot stat /proc/sys/net/bridge/bridge-nf-call-iptables: 没有那个文件或目录 ----》 modprobe br_netfilter

# 调整系统时区
#设置系统时区为中国/上海
timedatectl set-timezone Asia/Shanghai
# 将当前的UTC时间写入硬件时钟
timedatectl set-local-rtc 0
# 重启依赖于系统时间的服务
systemctl restart rsyslog
systemctl restart crond

#关闭系统不需要服务
systemctl stop postfix && systemctl disable postfix

# 设置 rsyslogd 和 systemd journald
mkdir /var/log/journal # 持久化保存日志的目录
mkdir /etc/systemd/journald.conf.d
cat > /etc/systemd/journald.conf.d/99-prophet.conf <<EOF
[Journal]
#持久化保存到磁盘
Storage=persistent
#压缩历史日志
Compress=yes
SyncIntervalSec=5m
RateLimitInterval=30s
RateLimitBurst=1000
#最大占用空间10G
SystemMaxUse=10G
#单日志文件最大200M
SystemMaxFileSize=200M
#日志保存时间2周
MaxRetentionSec=2week 
#不将日志转发到 syslog 
ForwardToSyslog=no
EOF
systemctl restart systemd-journald

# 升级系统内核为4.44
# CentOS 7.x系统自带的3.10.x内核存在一些Bugs，导致运行的Docker、Kubernetes不稳定，例如：rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
 # 方式一：最新的
 rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
 yum --enablerepo=elrepo-kernel install -y kernel-lt

 # 方式二：google 下载rpm包进行安装
 wget https://linux.cc.iitk.ac.in/mirror/centos/elrepo/kernel/el7/x86_64/RPMS/kernel-lt-4.4.213-1.el7.elrepo.x86_64.rpm
 yum install kernel-lt-4.4.213-1.el7.elrepo.x86_64.rpm

 # 查看已经安装的内核
 1： awk -F\' '$1=="menuentry " {print i++ " : " $2}' /etc/grub2.cfg
 2： # 安装完成后检查 /boot/grub2/grub.cfg 中对应内核menuentry中是否包含initrd16配置，如果没有，再安装一次！
#设置开机从新内核启动
# grub2-set-default 'CentOS Linux (4.4.189-1.el7.elrepo.x86_64) 7 (Core)'
grub2-set-default 'CentOS Linux (4.4.213-1.el7.elrepo.x86_64) 7 (Core)'

部署安装-kubeadm #

# kube-proxy开启ipvs的前置条件
modprobe br_netfilter
cat > /etc/sysconfig/modules/ipvs.modules <<EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr 
modprobe -- ip_vs_sh 
modprobe -- nf_conntrack_ipv4
EOF
chmod 755 /etc/sysconfig/modules/ipvs.modules && bash /etc/sysconfig/modules/ipvs.modules && lsmod | grep -e ip_vs -e nf_conntrack_ipv4

# 安装 Docker软件
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum update -y && yum install -y docker-ce
## 创建/etc/docker目录 
mkdir /etc/docker
#配置daemon.
cat > /etc/docker/daemon.json <<EOF
{
 "exec-opts":["native.cgroupdriver=systemd"],
 "registry-mirrors": ["https://ud6340vz.mirror.aliyuncs.com"],
 "log-driver":"json-file",
 "log-opts":{
 "max-size":"100m"
 }
}
EOF
mkdir -p /etc/systemd/system/docker.service.d
# 重启docker服务
systemctl daemon-reload && systemctl restart docker && systemctl enable docker

# 安装Kubeadm（主从配置）
cat > /etc/yum.repos.d/kubernetes.repo <<EOF 
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
http://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
yum -y install kubeadm-1.15.1 kubectl-1.15.1 kubelet-1.15.1
systemctl enable kubelet.service

# 初始化主节点 另外一种初始化方式参见（https://k8s.easydoc.net/docs/dRiQjyTY/28366845/6GiNOzyZ/nd7yOvdY）
kubeadm config print init-defaults > kubeadm-config.yaml
kubeadm init --config=kubeadm-config.yaml --experimental-upload-certs | tee kubeadm-init.log
kubeadm init --pod-network-cidr=10.244.0.0/16 --image-repository=registry.aliyuncs.com/google_containers
# 忘记了重新获取：
kubeadm token create --print-join-command
# 加入主节点以及其余工作节点
# 执行安装日志中的加入命令即可
# 部署网络
# kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml（这个文件对于当前集群好像不适用）
# NotReady （https://stackoverflow.com/questions/52675934/network-plugin-is-not-ready-cni-config-uninitialized）
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/62e44c867a2846fefb68bd5f178daf4da3095ccb/Documentation/kube-flannel.yml # NotReady （https://stackoverflow.com/questions/52675934/network-plugin-is-not-ready-cni-config-uninitialized）
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/62e44c867a2846fefb68bd5f178daf4da3095ccb/Documentation/kube-flannel.yml

# 重置k8s集群
sudo kubeadm reset && rm -rf /var/lib/cni/ && sudo rm -rf /var/lib/cni/ && systemctl daemon-reload && systemctl restart kubelet &&
sudo iptables -F && sudo iptables -t nat -F && sudo iptables -t mangle -F && sudo iptables -X

# 主节点继续执行
mkdir -p $HOME/.kube && sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config && sudo chown $(id -u):$(id -g) $HOME/.kube/config
# 子节点也需要重置(方法同上)
# rm -f /etc/kubernetes/kubelet.conf /etc/kubernetes/bootstrap-kubelet.conf /etc/kubernetes/pki/ca.crt && systemctl restart kubelet

# 容器二进制可执行插件
wget https://github.com/containernetworking/plugins/releases/download/v0.8.6/cni-plugins-linux-amd64-v0.8.6.tgz # 注意这个必须在子节点也安装，立竿见影。（捣鼓好一会）

# 查看当前集群配置
kubeadm config view

集群面板-dashboard #

# 安装dashboard
wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.4.0/aio/deploy/recommended.yaml
# 修改service type: NodePort，不指定端口的随机分配 通过svc 查看
# seccompProfile 规范出错了注释即可
# 通过token进行登录
# 创建账户
kubectl create serviceaccount dashboard-admin -n kube-system
kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
# 通过下面命令查看token
kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')

# 或者使用如下的yaml文件创建
# kubectl apply -f kube-admin.yaml
# kubectl -n kubernetes-dashboard create token admin-user[对于v1.15不适用]
kubectl -n kubernetes-dashboard get secret
kubectl -n kubernetes-dashboard describe secret admin-user-token-dxj54

apiVersion: v1
kind: ServiceAccount
metadata:
 name: admin-user
 namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
 name: admin-user
roleRef:
 apiGroup: rbac.authorization.k8s.io
 kind: ClusterRole
 name: cluster-admin
subjects:
- kind: ServiceAccount
 name: admin-user
 namespace: kubernetes-dashboard

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

minikube #

# 1.Installation
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64
sudo install minikube-darwin-amd64 /usr/local/bin/minikube

# 2.Start your cluster
minikube start

# 3.Interact with your cluster
kubectl get po -A # or: minikube kubectl -- get po -A

# bring-up dashboard
minikube dashboard

krew #

# 1.Make sure that git is installed.

# 2.Run this command to download and install krew:
(
 set -x; cd "$(mktemp -d)" &&
 OS="$(uname | tr '[:upper:]' '[:lower:]')" &&
 ARCH="$(uname -m | sed -e 's/x86_64/amd64/' -e 's/\(arm\)\(64\)\?.*/\1\2/' -e 's/aarch64$/arm64/')" &&
 KREW="krew-${OS}_${ARCH}" &&
 curl -fsSLO "https://github.com/kubernetes-sigs/krew/releases/latest/download/${KREW}.tar.gz" &&
 tar zxvf "${KREW}.tar.gz" &&
 ./"${KREW}" install krew
)

# 3.Add the $HOME/.krew/bin directory to your PATH environment variable. To do this, update your .bashrc or .zshrc file and append the following line:
# and restart your shell.
export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH" 

# 4.Run kubectl krew to check the installation.

node-shell #

kubectl krew install node-shell

Mon, 01 Jan 0001 00:00:00 +0000

基础概念 #

各个组件 #

name	explain
APISERVER	所有服务访问统一入口
CrontrollerManager	维持副本期望数目
Scheduler	负责介绍任务，选择合适的节点进行分配任务
ETCD	键值对数据库储存K8S集群所有重要信息（持久化）
Kubelet	直接跟容器引擎交互实现容器的生命周期管理
Kube-proxy	负责写入规则至 IPTABLES、IPVS 实现服务映射访问的
COREDNS	可以为集群中的SVC创建一个域名IP的对应关系解析
DASHBOARD	给 K8S 集群提供一个 B/S 结构访问体系
INGRESS CONTROLLER	官方只能实现四层代理，INGRESS 可以实现七层代理
FEDERATION	提供一个可以跨集群中心多K8S统一管理功能
PROMETHEUS	提供K8S集群的监控能力
ELK	提供 K8S 集群日志统一分析介入平台

POD #

K8S 中包装的最小单位，一个POD（容器组）中可以包含多个容器，用来表示可迁移的lamp，类似于Docker的多层镜像。同一个POD中容器可以直接共享pause共享的网络站或者挂载卷。

自主式管理POD #
POD 死亡后没办法继续启动。

控制器管理的POD #

name	explain
ReplicationControlelr(RC)	用来确保容器应用的副本数始终保持在用户定义的副本数，如果容器有异常退出，会自动创建新的POD来代替；而异常多出来的容器也会自动回收，新版本中建议使用ReplicaSet 来替代 ReplicationController
ReplicaSet(RS）	与上一个没有本质区别，但是这个支持集合式的 selector
Deployment	虽然ReplicaSet可以独立使用，但一般还是建议使用Deployment来自动管理ReplicaSet,这样就无需担心跟其他机制的不兼容问题（比如ReplicaSet不支持 rolling-update ，但 Deployment支持）
HorizontalPodAutoScale(HPA)	也是控制RS,根据CPU使用率自动平衡扩展，收缩，可定义最大，最小副本数
StatefulSet(SS)	主要解决有状态服务问题，包括的场景有：稳定的持久化存储，稳定的网络标志，有序部署，有序收缩
DaemonSet()	可以理解为跟node绑定的一些后台运行的POD，跟随节点进行创建和删除。
Job	负责批处理任务，即仅执行一次的任务.相比于script优点有，封装在POD中可判断是否正常退出，可以重新执行。而且可以设定认为成功的次数。
CronJob	带有cron 定时任务的JOB

网络通信方式 #

扁平化的网络空间

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Bridge) #
Reference #

Mon, 01 Jan 0001 00:00:00 +0000

bridge网络 #

目前的理解是

1. 容器中的eth0接口通过veth pair 连接到docker0 网桥。
2. docker0网桥创建的时候会自动生成一个网络接口并附有172.17.0.1的ip，参考
3. docker0 与 eth0 之间没有直接的关联，而是通过 ip_forward/ docker-proxy 等技术进行转发的。参考文档，有以下片段。
Looking at the diagram, the interface docker0 has a connection to the eth0 interface, this gives the ability to our containers to send pings to other machines on the internet. But in reality, this connection is made using a Linux firewall named “Iptables”.

参考资料 one #
参考资料 two #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(HTTP) #
- 分块传输编码 #
  
  Response Header 中存在 Transfer-Encoding: chunked的话，就是分块传输，数据需要按照格式解码。[ 参考]
  
  应用场景：使用 socket 发送 http/https 请求的时候会返回数据报文，需要自己解析。比如：
  1. 模拟 vless客户端发送 wss + https 请求: 先与vless服务器创建一个通过tls加密的websocket隧道连接。
  2. 发送command(ipaddr, port) + 握手消息到websocket服务器，并与目标服务器建立连接并且发送Client Hello[一般情况下是这个]，后续让BC库完成握手。
  3. 读取 tls[BC.TlsClientProtocol]解密后的报文，此时需要注意可能存在分块传输如下图。
- 响应头大小写 #
  
  (参考 rfc | 7540) 在 http2 中，响应头的 key 必须为小写，其他的视为畸形的，但是在 http1.1 中大小写不敏感。
  
  使用 curl 验证即可，一般浏览器应该会自动转化，比如 chrome 即使小写也会转化成首字母大写。
  下列命令查看响应头区别：curl -I --http1.1 https://wtfu.site，curl -I --http2 https://wtfu.site
Reference #
- https://en.wikipedia.org/wiki/Chunked_transfer_encoding
- https://www.runoob.com/http/http-tutorial.html

Mon, 01 Jan 0001 00:00:00 +0000

Intro(网络栈) #

直接往网卡发送数据 #

通过对网络模型以及 tcp/ip 协议栈的了解，是可以不通过协议栈处理而使用系统调用直接往网卡上面发送数据的。示例如下：（在 linux 上面的实验，macosx 因为限制原因，修改不了 MAC source address，但是 Linux 完全没有问题。）

抓包命令sudo tcpdump -i eth0 arp -w nic.pcap， nic.pcap file download

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/if_packet.h>
#include <net/ethernet.h>

int main() {
 int sockfd;
 struct ifreq if_idx;
 struct sockaddr_ll socket_address;
 char sendbuf[1024];
 unsigned char src_mac[6] = {0x00, 0x0c, 0x29, 0x7b, 0x3e, 0x1f}; // 本机 MAC 地址
 unsigned char dst_mac[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; // 广播 MAC 地址
 unsigned char *data = "Hello Ethernet!";
 int data_len = strlen(data);

 // 创建 Packet Socket
 if ((sockfd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL))) == -1) {
 perror("socket");
 exit(EXIT_FAILURE);
 }

 // 获取网络接口索引
 memset(&if_idx, 0, sizeof(struct ifreq));
 strncpy(if_idx.ifr_name, "eth0", IFNAMSIZ - 1);
 if (ioctl(sockfd, SIOCGIFINDEX, &if_idx) < 0) {
 perror("SIOCGIFINDEX");
 close(sockfd);
 exit(EXIT_FAILURE);
 }

 // 填充以太网帧头
 struct ethhdr *eh = (struct ethhdr *)sendbuf;
 memcpy(eh->h_dest, dst_mac, 6); // 设置目标 MAC 地址
 memcpy(eh->h_source, src_mac, 6); // 设置源 MAC 地址
 eh->h_proto = htons(ETH_P_ARP); // 设置协议类型（这里假设是 ARP）

 // 填充数据部分
 memcpy(sendbuf + sizeof(struct ethhdr), data, data_len);

 // 设置目标地址
 memset(&socket_address, 0, sizeof(struct sockaddr_ll));
 socket_address.sll_family = AF_PACKET;
 socket_address.sll_protocol = htons(ETH_P_ARP);
 socket_address.sll_ifindex = if_idx.ifr_ifindex;
 socket_address.sll_halen = ETH_ALEN;
 memcpy(socket_address.sll_addr, dst_mac, 6);

 // 发送数据包
 if (sendto(sockfd, sendbuf, sizeof(struct ethhdr) + data_len, 0,
 (struct sockaddr *)&socket_address, sizeof(struct sockaddr_ll)) < 0) {
 perror("sendto");
 close(sockfd);
 exit(EXIT_FAILURE);
 }

 printf("Data sent successfully!\n");
 close(sockfd);
 return 0;
}

网络堆栈 #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(PROXY) #
Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(SOCKET) #

socket 是网络架构中程序与操作系统网络协议栈进行交互的接口API。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口。
linux数据结构定义、 C demo

作为服务端，先创建一个socket，返回fd，然后与地址(ip+port)进行绑定，监听，然后接收
作为客户端，先创建一个socket，返回fd，然后与地址(serv ad)进行连接，发送
- 系统调用 #
  - socket() #
    
    原型：int socket(int domain, int type, int protocol); 例如：socketfd = socket(AF_INET, SOCK_STREAM, 0); 【man2】
    用来创建一个socket，并且返回引用的文件描述符fd。
  - bind() #
    
    原型：int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); 例如：bind(socketfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); 【man2】
    分配一个地址给socket。
  - listen() #
    
    原型：int listen(int sockfd, int backlog); 例如：listen(listenfd, 10); 【man2】
    listen函数将 socket 文件描述符标记为被动 socket,也就是服务端的socket，执行完之后，文件描述符处于监听状态。使用accept获取客户端连接。backlog 定义 socket允许待处理的客户端连接的队列长度。全连接和半连接会使用到这个值(和内核版本有关)
  - connect() #
    
    原型：int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen); 例如：if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) 【man2】
    客户端应用使用connect命令在本地socket和远程socket上建立连接。TCP只能调用一次进行三次握手，多次会报错。UPD的话可以调用多次改变关联的socket，好像只是注册一下对端地址【IBM connect】【UDP之connect】

Mon, 01 Jan 0001 00:00:00 +0000

Intro(SSH) #
- SSH登录 #
  - 准备步骤 #
    1. 生成公私匙: ssh-keygen -t rsa -b 4096 -C 12302@example.com
    2. 复制公匙到主机:cat ~/.ssh/id_virmach_ras.pub | ssh root@107.174.101.187 "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"
    - ssh-copy-id使用 #
      
      (ssh-copy-id) 是一个可执行的脚本文件，可以把本地的ssh公钥文件安装到远程主机对应的账户下。也就是将你的公共密钥填充到一个远程机器上的authorized_keys文件中。如果远程机器上存在authorizedkeys文件，且authorizedkeys有内容，则ssh-copy-id 可以将待传公钥追加到authorizedkeys文件里。它也能够改变远程用户名的权限，如~/.ssh和~/.ssh/authorized_keys删除其写的权限，所以一般/.ssh给予700，/.ssh/authorized_keys给予600权限。
      
      查看帮助：ssh-copy-id -h
      复制命令：ssh-copy-id [-i [identity_file]] [user@]machine
  - 登录原理 #
    
    Warning
    1). 发送登录请求到远程主机，identity文件中包含一些信息。
    2). 远程服务器利用这个账户下的公匙随机生成字符串然后发送给对方。
    3). 对方利用私匙将字符串解密后发送给远程服务器。
    4). 远程服务器验证通过后，准许对方登录。
- SSH隧道 #
  
  SSH 除了登录服务器，还有一大用途，就是作为加密通信的中介，充当两台服务器之间的通信加密跳板，使得原本不加密的通信变成加密通信。这个功能称为端口转发（port forwarding），又称 SSH 隧道（tunnel）。
  
  端口转发有两个主要作用：
  （1）将不加密的数据放在 SSH 安全连接里面传输，使得原本不安全的网络服务增加了安全性，比如通过端口转发访问 Telnet、FTP 等明文服务，数据传输就都会加密。
  （2）作为数据通信的加密跳板，绕过网络防火墙。
  端口转发有三种使用方法：动态转发，本地转发，远程转发。下面逐一介绍。

Mon, 01 Jan 0001 00:00:00 +0000

tcp flag #

图例 #

IP 报头（最小20Byte,最大 15[1111] * 32 / 8, 可填充 40Byte ）：首部长度的单位为 4Byte.
TCP 报头(20Byte)

标志位解释 #

SYN：同步序列编号（Synchronize Sequence Numbers）

是TCP/IP建立连接时使用的握手信号。在客户机和服务器之间建立正常的TCP网络连接时，客户机首先发出一个SYN消息，服务器使用SYN+ACK应答表示接收到了这个消息，最后客户机再以ACK消息响应。这样在客户机和服务器之间才能建立起可靠的TCP连接，数据才可以在客户机和服务器之间传递。
ACK (Acknowledge character）

ACK (Acknowledge character）即是确认字符，在数据通信中，接收站发给发送站的一种传输类控制字符。表示发来的数据已确认接收无误。在TCP/IP协议中，如果接收方成功的接收到数据，那么会回复一个ACK数据。通常ACK信号有自己固定的格式,长度大小,由接收方回复给发送方。
RST

产生RST场景或者导致“Connection reset by peer”场景？
- 当尝试和未开放的服务器端口建立tcp连接时，服务器tcp将会直接向客户端发送reset报文；
- 双方之前已经正常建立了通信通道，也可能进行过了交互，当某一方在交互的过程中发生了异常，如崩溃等，异常的一方会向对端发送reset报文，通知对方将连接关闭；
- 当收到TCP报文，但是发现该报文不是已建立的TCP连接列表可处理的，则其直接向对端发送reset报文；
- ack报文丢失，并且超出一定的重传次数或时间后，会主动向对端发送reset报文释放该TCP连接；

socket_keepalive理解 #

前言 #

1. net.ipv4.tcp_keepalive_intvl = 75 （发送探测包的周期，前提是当前连接一直没有数据交互，才会以该频率进行发送探测包，如果中途有数据交互，则会重新计时tcp_keepalive_time，到达规定时间没有数据交互，才会重新以该频率发送探测包）
2. net.ipv4.tcp_keepalive_probes = 9 （探测失败的重试次数，发送探测包达次数限制对方依旧没有回应，则关闭自己这端的连接）
3. net.ipv4.tcp_keepalive_time = 7200 （空闲多长时间，则发送探测包）
响应结果 #

1. 正常ack，继续保持连接；
2. 对方响应rst信号，双方重新连接。
3. 对方无响应。

Mon, 01 Jan 0001 00:00:00 +0000

tun/tap #

tun/tap 设备是操作系统内核中的虚拟网络设备，是用软件模拟的网络设备，提供与硬件网络设备完全相同的功能。主要用于用户空间和内核空间传递报文。

tun/tap 设备与物理网卡的区别，如图所示: #

对于硬件网络设备而言，一端连接的是物理网络，一端连接的是网络协议栈。
对于 tun/tap 设备而言，一端连接的是应用程序（通过字符设备文件 /net/dev/tun），一端连接的是网络协议栈。

工作原理 #

从下图可以更直观的看出 tun/tap 设备和物理设备的区别：虽然它们的一端都是连着网络协议栈，但是物理网卡另一端连接的是物理网络，而 tun/tap 设备另一端连接的是一个应用层程序，这样协议栈发送给 tun/tap 的数据包就可以被这个应用程序读取到，此时这个应用程序可以对数据包进行一些自定义的修改(比如封装成 UDP)，然后又通过网络协议栈发送出去——其实这就是目前大多数“代理”的工作原理。(Tun/tap 设备提供的虚拟网卡驱动，从tcp/ip协议栈的角度而言，它与真实网卡驱动并没有区别。)

工作模式 #

tun/tap 有两种模式，tun 模式与 tap 模式。tun 设备与 tap 设备工作方式完全相同，区别在于：

Tun 设备是三层设备，从 /dev/net/tun 字符设备上读取的是 IP 数据包，写入的也只能是 IP 数据包，因此不能进行二层操作，如发送 ARP 请求和以太网广播。
Tap 设备是二层设备，处理的是二层 MAC 层数据帧，从 /dev/net/tun 字符设备上读取的是 MAC 层数据帧，写入的也只能是 MAC 层数据帧。从这点来看， Tap 虚拟设备和真实的物理网卡的能力更接近，可以与物理网卡做 bridge。

注意事项

无论是 tun 还是 tap 设备，都是通过 open/dev/net/tun 这个字符设备文件，通过 ioctl 系统调用在内核创建新的 tun、tap 设备，创建的设备并不会以文件的形式出现在 /dev/ 下，可以在 sys/class/net/ 下看到对应的网络接口 tunx 或者 tapx。
设备 /dev/net/tun 必须以 read/write 的方式打开。该设备也被称为克隆设备，它是创建任何 tun/tap 虚拟接口的起点。
open 系统调用执行的时候，VFS 会为这次 open 分配一个独立的内核态 file 结构，也就是说，每次打开执行时，内核为此次打开分配的 file 结构实例不同，代表不同的字符设备。

应用的数据收发过程 #

数据发送：应用进程 A open/dev/net/tun 字符设备，通过 ioctl 调用创建虚拟接口 tunx 或者 tapx, ioctl 调用返回表示对应 tunx 或者 tapx 设备的文件描述符 fd ，应用 A 通过这个文件描述符 fd 写入格式化的数据，数据通过虚拟网卡驱动到达协议栈，对于协议栈来说，这个数据就像从真实网卡接收的一样。
数据接收：当网络协议栈发送数据到虚拟接口 tunx 或者 tapx 时，应用进程 A 通过上述创建的设备文件描述符 fd，从中读取接口发送的数据，然后进行处理。

设备创建 #

# 创建 tun/tap 设备
ip tuntap add dev tap0 mod tap # 创建 tap
ip tuntap add dev tun0 mod tun # 创建 tun
 
# 删除tun/tap设备
ip tuntap del dev tap0 mod tap # 删除 tap
ip tuntap del dev tun0 mod tun # 删除 tun
 
# 设置 ip 地址，up 设备
ip address add dev tap0 10.0.1.5/24
ip link set dev tap0 up

设备驱动 #

Tun/tap 驱动程序中包含两个部分，一部分是字符设备驱动，还有一部分是网卡驱动。

Mon, 01 Jan 0001 00:00:00 +0000

Reference #

https://blog.csdn.net/a745233700/article/details/90230490

Mon, 01 Jan 0001 00:00:00 +0000

Intro(EXT2-FS) #
- 注意 #
  
  Caution
  a).: 上述的图例是模拟 1M 的 ext2 文件系统，采用 block = 1024B ,inode size = 128B，进行划分的。
  b).: 转换成数值的时候是小端读取。比如 [80 00 00 00] ==int=> 0x00000080 = 0x80 = 128。
  c).: bitmap 采用的是 (MSB)10001001(LSB)，参考 block-bitmap 中的部分描述、以及 wiki，比如 10000111，指的是第1，2，3，8个，不是1，6，7，8。
- 准备 #
  
  在 Ubuntu-22.04 上准备两个文件系统，一个干净的 fs1m，一个需要写入数据作对比 fs1m-with-data。 fs1m 备份下载、 fs1m-with-data 备份下载
  创建一个1M的文件：dd if=/dev/zero of=fs1m count=256 bs=4K
  格式化文件系统：mke2fs -b 1024 -I 128 fs1m
  查看格式化后的信息：dumpe2fs fs1m
  
  复制 fs1m 到 fs1m-with-data
  挂载：mount -o loop fs1m-with-data /mnt
  进入目录并写入数据：cd /mnt && mkdir 12302 && cd 12302 && echo 'something' > Hello.java
  卸载：umount /mnt
  
  使用 xxd 查看十六进制信息：xxd -a -u -g1 -s 1024 -l 16 fs1m //使用*代替连续00，大写字母输出，一个字节分割，offset=1024, len=16。

Mon, 01 Jan 0001 00:00:00 +0000

配置Linux开机自启动 #

方式一，(rc.local)启动说明 #

脚本位置

/etc/rc.local -> /etc/rc.d/rc.local

脚本内容

 #!/bin/bash
 # THIS FILE IS ADDED FOR COMPATIBILITY PURPOSES
 #
 # It is highly advisable to create own systemd services or udev rules
 # to run scripts during boot instead of using this file.
 #
 # In contrast to previous versions due to parallel execution during boot
 # this script will NOT be run after all other services.
 #
 # Please note that you must run 'chmod +x /etc/rc.d/rc.local' to ensure
 # that this script will be executed during boot.

 touch /var/lock/subsys/local


 # nexus(maven personal server)
 # https://download.sonatype.com/nexus/oss/nexus-2.14.10-01-bundle.tar.gz
 su elizabeth -c "/home/elizabeth/nexus/nexus-2.14.10-01/bin/runself"

 # tomcat launch by self
 su elizabeth -c "/home/elizabeth/tomcat-8/apache-tomcat-8.0.53/bin/runself"

 # frp(forNAT)
 su elizabeth -c "/home/elizabeth/frp/frp_0.20.0_linux_amd64/frp_0.20.0_linux_amd64/runself"

 #su elizabeth -c "nohup /home/elizabeth/frp/frp_0.20.0_linux_amd64/frp_0.20.0_linux_amd64/frps -c frps.ini >frps.log 2>&1 &"


 # redis into end to ensure boot successfully
 /home/elizabeth/redis-4/redis-4.0.11/src/redis-server

 exit 0

nexus(runself)

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Linux免密登录) #

参考： SSH登录
Reference #
1. SSH登录

Mon, 01 Jan 0001 00:00:00 +0000

AUTO #

使用密码自动登录

/usr/local/bin/ssh #

# 先安装 sshpass 
brew install hudochenkov/sshpass/sshpass

#!/bin/zsh

host=$1
#password=`awk "/#Password/ && inhost { print \\\$2 } /Host/ { inhost=0 } /Host $host/ { inhost=1 }" ~/.ssh/config`
password=`awk "/#Password/ && inhost { print \\\$2 } /Host / { inhost = 0 } /Host $host/ { inhost=1 }" ~/.ssh/config`

if [[ -z "$password" ]]; then
 /usr/bin/ssh $*
else
 sshpass -p $password /usr/bin/ssh $*
fi

Host local
 HostName 127.0.0.1
 User root
 Port 23

Host rein
 HostName 47.98.226.149
 User rein
 Port 13322
 IdentityFile ~/.ssh/rein_id
 #Password 1***********0

Host meta
 HostName 10.28.4.2
 User root
 Port 22
 IdentityFile ~/.ssh/meta-just.pem

Host msb1v1
 HostName m.meishubao.com
 User wtf
 Port 2220
 #Password ********!
 # ProxyCommand sshpass -p *******! ssh -t -p %p %r@%h

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Automator #

DEMO #

# 在 macOS 上实现到某个时间点自动关闭某个软件，可以使用 AppleScript 脚本结合定时任务来实现。以下是一种可能的实现方式：
# 1.打开 "Script Editor" 应用程序：在 Launchpad 或者应用程序文件夹中找到 "Script Editor" 应用程序并打开。
# 2.编写 AppleScript 脚本：在 "Script Editor" 中编写一个 AppleScript 脚本，用于关闭指定的软件。例如，假设要关闭 Safari 浏览器，脚本内容如下：
tell application "Safari"
 quit
end tell
# 3.保存脚本：将脚本保存为可执行文件。选择 "File" -> "Export..."，选择 "File Format" 为 "Application"，然后保存到你喜欢的位置，例如桌面上。
# 4.创建定时任务：打开 "Automator" 应用程序，选择 "New Document"，然后选择 "Calendar Alarm"。
# 5.添加操作步骤：在右侧的操作库中，搜索并添加 "Run AppleScript" 操作步骤。
# 6.编写 AppleScript 代码：在 "Run AppleScript" 步骤中，将以下代码替换为你保存的脚本文件的路径：
do shell script "open /path/to/your/script.app"
# 7.保存这个automator.设定保存选项

Mon, 01 Jan 0001 00:00:00 +0000

brew #

切换版本 #

Note
brew unlink node@18
brew link --overwrite --force node@14

安装软件 #

gdb example

# ref from: https://stackoverflow.com/questions/62785290/installing-previous-versions-of-a-formula-with-brew-extract

# TAP=... # <org>/<repo>, for example "my-org/homebrew-old"
# MODULE=... # name of module you want to install, e.g. "hugo"
# VERS=... # version of $MODULE you want to install, e.g., "0.80.0"

brew tap-new 12302/gdb
# 在最新的仓库中提取原来的版本到新建的tap.
brew extract --version 13.1 gdb 12302/gdb
# 运行安装命令（其实这个时候已经可以通过 brew search gdb 搜索到需要安装版本的软件了）
brew install 12302/gdb/gdb@13.1

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Burp-Suite-Pro) #

抓包软件
- 下载 #
  
  组合包：Burp_Suite_Pro_v1.7.31_Loader_Keygen.zip 包括注册机jar包和官方的jar包
  也就是当前这个使用的是官方的，而不是修改过的。
  
  单独注册机下载：burp-loader-keygen.jar。需要注意注册机有的有后门，可以参考：恶意软件逆向：burpsuite 序列号器后门分析
  
  官方下载地址: https://portswigger.net/burp/releases/professional-1-7-31
  单独应用下载：burpsuite_pro_v1.7.31.jar。
  可以通过shasum -a 256 burpsuite_pro_v1.7.31.jar，md5 burpsuite_pro_v1.7.31.jar查看当前包的sha256和md5与官方进行对比。
- 激活 #
  
  placeholder
- 制作APP #
  
  使用如下命令制作 Mac APP,参考： Automator中的burp-suite-pro
  JDK1.8启动命令 java -Xbootclasspath/p:/path/burp-loader-keygen.jar -jar /path/burpsuite_pro_v1.7.31.jar

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(CleanMyMacX) #

电脑清理软件
- 下载 #
  
  CleanMyMac_v4_15_0_macOS.dmg

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

launchctl #

简单解释，launchd是一套统一的开源服务管理框架，它用于启动、停止以及管理后台程序、应用程序、进程和脚本。launchd是macOS第一个启动的进程，该进程的PID为1，整个系统的其他进程都是它创建的。

1). 当launchd启动后，它会扫描/System/Library/LaunchDaemons和/Library/LaunchDaemons中的plist文件并加载他们；
2). 当输入密码登录系统后，launchd会扫描/System/Library/LaunchdAgents、/Library/LaunchAgents、~/Library/LaunchAgents这三个目录中的plist文件并加载它们。每个plist文件都是一个任务，加载不代表立即运行，只有设置了RunAtLoad为true或keepAlive为true时，才会加载并同时启动这些任务。

name	ope
帮助	`launchctl help`
列出所有由launchd管理的进程	`launchctl list`
加载	`launchctl load ~/Library/LaunchAgents/docs.wtfu.site.plist`
卸载	`launchctl unload ~/Library/LaunchAgents/docs.wtfu.site.plist`
启动 (luanchctl start `<Label>`)	`launchctl start dos.wtfu.site`
关闭	`launchctl stop dos.wtfu.site`

restart #

摘自 How to start/stop/restart launchd services from the command line?
Just in case if you are looking for launchctl reload, you can define shell function in your ~/.bashrc/.zshrc as I did:
Command execution looks like -> lctl reload <your-plist-name>.plist

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Middle) #
- 下载 #
  
  因为 IDEA 中的 debug 相关功能的设置，比如 breakponits-enabled。里面提及到如果修改点击断点的默认行为，则会使用到 拖动到断点到编辑区域或者点击鼠标中间的按钮。使用触摸板的话就只能模拟了。
  经查，有个叫 middle的软件，可以实现类似功能。但是收费，所以找破解版。如下下载：
  
  下载来源： Middle 1.8.8 破解版 – 触控板辅助和增强应用
  下载地址： Middle 1.8.8 Crked - Digit77.com.dmg。（后期不知道会不会失效）。
- 激活 #
  
  Attention
  如果出现文件无法打开或者损坏的情况，本机是 Sequoia 15，到隐私安全中设置允许任何来源就行。安装完之后在设置回去就行。
  
  备注指令：sudo spctl --master-disable
Reference #
- https://www.digit77.com/apps/middle.html
- https://www.digit77.com/solutions/mac-apps-cant-be-opened.html

Mon, 01 Jan 0001 00:00:00 +0000

Parallels Desktop(PD) #
- 下载 #
  
  ParallelsDesktop-19.1.0-54729.dmg
  Parallels Desktop Activation Tool 4.0.0 [MacKed].dmg
- 激活 #
  
  Warning
  
  1). 打开激活工具，如图，直接双击就能启动激活工具，无需把工具移动到应用程序目录。当然，移动到应用程序目录后再打开也是没问题的。
  2). 运行激活工具后，点击弹出窗口的安装补丁按钮，输入密码即可。
  3). 激活之后再次打开pd，会报“请移动到废纸篓”，只需要打开访达，点击侧边栏的应用程序,找到pd，右键打开即可。（只有激活后第一次打开需要如此操作）
- windows镜像 #
  
  Warning
  
  官方下载页面：https://www.microsoft.com/zh-cn/software-download/windows10ISO
  ~~Win10_22H2_Chinese_Simplified_x64v1.iso~~
  
  MSDN
  Windows 10 (business editions), version 1909 (updated Jan 2020) (x64) - DVD (Chinese-Simplified)
  Windows 10 (Multiple Editions) (x64) - DVD (Chinese-Simplified)
  Windows 7 Ultimate (x64) - DVD (Chinese-Simplified)
  Windows 7 Professional (x64) - DVD (Chinese-Simplified)
  Windows 7 Enterprise (x64) - DVD (Chinese-Simplified)
  Windows 11 (business editions), version 23H2 (updated April 2024) (x64) - DVD (Chinese-Simplified)
  ed2k
  bt

Mon, 01 Jan 0001 00:00:00 +0000

viscosity #

多vpn链接软件，和 TunnelBlick属于同一类软件

下载 #

https://www.digit77.com/macapps/viscosity/#download-explan
https://pan.baidu.com/disk/main#/index?category=all&path=%2FMAC

激活 #

# 激活步骤：
	之前激活过的一般情况下只要激活没失效就无需再次激活！

	1.	Viscosity 运行后，提示安装帮助工具（Viscosity Helper Tool Installation），点击「Install」，输入电脑密码安装。（没有此步骤请跳过）
	2.	弹出登录界面，点击『Continue without account』蓝色文字（没有此步的话请跳过）
	3.	点击任务栏的(桌面右上角)「一个圆圈和一把锁的图标」，再点击「设置」，再点击「关于」，然后点击「注册」，输入以下激活码，点击提交即可。
	4.	激活成功，尽情享用吧。
	因某些代理软件会接管系统的 Hosts 导致 Hosts 屏蔽官方验证失效，从而导致使用过程中激活失效，遇到这种情况的请安装防火墙软件，禁止此应用的传入即可！

	激活码：(1.9,1.10 通用)
	Black Flag
	random@user.com
	VM1U-QY3G41-XN5IYG-WIOCN2-RX7ZDS-UCHA4Y

	Viscosity for mac注册码：
	The Shark
	deep@sea.com
	VM1U-JKJRW4-2NSXY4-G25K7Q-AU6LCU-I56CL4

导入TunnelBlick配置 #

# 从Tunnelblick 导入配置
~/Library/Application Support/Tunnelblick

Reference #

https://www.sparklabs.com/viscosity/
https://www.digit77.com/macapps/viscosity/#download-explan (多版本 1.9,1.10居多。[mac 13.3.1 (22E261)], 用1.10好使。)
https://pan.baidu.com/disk/main#/index?category=all&path=%2FMAC

Mon, 01 Jan 0001 00:00:00 +0000

VMware fusion pro #

下载 #

VMware-Fusion-13.5.1-23298085_universal.dmg

激活 #

#任选其一激活即可
4A4RR-813DK-M81A9-4U35H-06KND
NZ4RR-FTK5H-H81C1-Q30QH-1V2LA ✅
4C21U-2KK9Q-M8130-4V2QH-CF810
MC60H-DWHD5-H80U9-6V85M-8280D
HF200-0W05K-089X8-4R1EK-032J0
JU090-6039P-08409-8J0QH-2YR7F
4Y09U-AJK97-089Z0-A3054-83KLA
ZF3R0-FHED2-M80TY-8QYGC-NPKYF
YF390-0HF8P-M81RQ-2DXQE-M2UT6
ZF71R-DMX85-08DQY-8YMNC-PPHV8

密码 #

Note

TPM 模块相关密码：qSscu5b3D2+YMOA9
windows11镜像 #

Warning

下载页面：https://www.microsoft.com/software-download/windows11
~~Win11_23H2_English_x64v2.iso~~

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

hello command

Mon, 01 Jan 0001 00:00:00 +0000

命令记录 #

#!/bin/bash
# 首例打印数字权限
ls -l | awk 'NR>1{cmd="stat --printf \"%a\t\" "$9;system(cmd) ;print $0}'

#!/bin/bash
# 批量删除统一后缀文件
find . -name "*.txt" -type f -delete

#!/bin/bash
# 文件最好用""包起来，另外"使用\转义
# 批量文件重命名
ls -l | awk 'NR>1{origin=substr($0,57);now=substr($0,105);cmd="mv " "\"" origin "\"" " " "\"" now "\"";system(cmd);}'
# awk 制定截取字符
ls -l | grep '小鱼儿' | awk '{origin=substr($0,index($0,$9),match($0,/\.mp3/));now="_1_"origin;cmd="mv " "\""origin"\"" " " "\""now"\"";print cmd}'

#!/bin/bash
# curl 返回状态码
curl https://www.baidu.com -I -m 10 -o /dev/null -s -w "%{http_code}\n"

#!/bin/bash
# 删除100分钟内刚猜解压的文件夹及文件，注意这次包含当前目录，需要排除 [.]
find . \( -path "./WEB-INF" -prune -o -cmin -100 \) ! -path './.DS_Store' -ok rm -rf {} \;

#!/bin/bash
# curl ftp 上传
curl -u wang: -T /Users/stevenobelia/Downloads/temporary-download/阳光电影www.ygdy8.com.拆弹专家2.HD.1080p.国语中字.mkv/阳光电影www.ygdy8.com.拆弹专家2.HD.1080p.国语中 字.mkv ftp://192.168.2.2:2121/Download/

#!/bin/bash
# xargs 连接多个命令
echo 'obase=10;ibase=16;00020000' | bc | xargs -I % bash -c 'echo "%/2014/2014" | bc '

#!/bin/bash
# 将当前目录下的文件移动到当前目录新建目录中
ls ./ | grep -v 'docs' | xargs -n 1 -I {} mv {} docs

#!bin/bash
# 批量修改问价后缀
rename 's/\.jpg$/.webp/' *.jpg

批量转换 webm 到gif
find webps/ -type f -name "*.webp" -print0 | xargs -0 -I{} sh -c 'ffmpeg -y -loglevel quiet -i "{}" -pix_fmt rgb24 "webps-gif/$(basename {}).gif"'

Mon, 01 Jan 0001 00:00:00 +0000

Shell环境 #

Shell 变成跟JavaScript，php编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。Linux下面的shell很多，常见的又：

检查是否存在某个文件的命令：
# test命令检测
test -e ./shizi.jpg && echo 'found' || echo "not"

# [] 方括号检测 *括号内前后都有空格
[ -f ./shizi.jpg ] && echo 'found' || echo 'not'

名称	路径
Bourne Shell	`/usr/bin/sh 或者 /bin/sh`
Bourne Again Shell	`/bin/bash`
C Shell	`/usr/bin/csh`
K Shell	`/usr/bin/ksh`
Shell for Root	`/sbin/sh`
……	`……`

#!后面跟解释器路径

#!/bin/sh #!/sbin/sh #!/bin/bash

Shell变量 #

定义变量 #

定义变量时，变量名不加美元符号（$) ，而且变量之间不能有空格。

Mon, 01 Jan 0001 00:00:00 +0000

Clion 安装 GDB 工具 #

brew安装 gdb@13.1

# 结合`brew安装 gdb@13.1`, clion 不支持13.2
# PermissionsDarwin相关操作导入证书，一般不用重启。
# 添加gbd启动初始化脚本
echo 'set startup-with-shell off' >> ~/.gdbinit

# 重要的一点，使用GDB 得关闭 mac sip: 不然会一直hangs住
# 查看：csrutil status， 关闭：csrutil disable
# 结合图片进行gdb debug

make -v
# GNU Make 3.81
# This program built for i386-apple-darwin11.3.0
gcc -v 
# Apple clang version 14.0.3 (clang-1403.0.22.14.1)
g++ -v 
# Apple clang version 14.0.3 (clang-1403.0.22.14.1)

Mon, 01 Jan 0001 00:00:00 +0000

Intro(GoLand) #
- 断点不生效 #
  
  GoLand(2023.2.6) 中使用了最新版的 go(go1.23.2 darwin/amd64) 环境，但是由于工具自带的插件中的 dlv 版本为 1.21.0 ，导致 debug 的时候出现下述错误，以致断点不生效:
  WARNING: undefined behavior - version of Delve is too old for Go version 1.23.2 (maximum supported version 1.21) 。
  
  根据类似问题 Issues-GO-14287 中提到修复步骤，使用如下命令进行解决：
  Install dlv binary with go install github.com/go-delve/delve/cmd/dlv@latest
  Set the dlv.path=<path_to_dlv_executable> under Help > Edit Custom Properties, 比如：dlv.path=/Users/stevenobelia/.go/bin/dlv
  Restart GoLand
  
  备注信息
  export GOPATH=/Users/stevenobelia/.go
  设置了GOPTAH环境变量后，dlv二进制文件会存放在$GOPATH/bin里面。
  
  /Users/stevenobelia/.go/bin/dlv version 查看刚安装的 dlv 版本
  /Applications/GoLand.app/Contents/plugins/go-plugin/lib/dlv/mac/dlv version 查看 GoLand 自带的 dlv 版本

Mon, 01 Jan 0001 00:00:00 +0000

插件 #

column1	column2	column3
Lombok	Maven Helper	Mybaits Log Plugin
Translation	Find bugs	RestfulToolkit
.ignore	Alibaba Java Coding Guidelines	jclasslib bytecode viewer
Codota	Material Theme UI	SequenceDiagram
StickyScroll

配置 #
- 生成serialVersionUID #
  
  参考:
  File -> Settings -> Editor -> Inspections -> JVM Languages : Find serialization class without 'serialVersionUID' and check it.
  Back to the editor, clicks on the class name, ALT + ENTER (Windows), it will prompts the Add serialVersionUID field option.A new serialVersionUID is auto-generated.

Mon, 01 Jan 0001 00:00:00 +0000

Intro(RubyMine) #
- SDK警告阻止⚠️ #
  
  IDE中使用了最新版的 ruby sdk(ruby-3.3.1-p55) 环境，但是由于项目中使用的配置Gemfile.lock中使用BUNDLED WITH \n 2.1.4版本的bundle，导致每次运行都会出现红色的警告信息。
  
  根据 issues-5234 中提到的bundle版本2.3.4，使用命令/usr/local/opt/ruby/bin/gem install bundler -v 2.3.4安装，然后修改Gemfile.lock文件中的BUNDLE WITH版本即可解决。
  
  备注指令
  /usr/local/opt/ruby/bin/gem pristine --all --no-extensions
Reference #
- https://github.com/rubygems/rubygems/issues/5234

Mon, 01 Jan 0001 00:00:00 +0000

Intro(ADB) #
- PUSH #
  
  push moive to android:
  adb push /path/FILENAME.mp4 /sdcard/
- SYSTEMPROP(getprop) #
  
  通过 magisk设置系统属性，然后根据文章操作：setprop service.adb.tcp.port 5555:可以让手机中的adbd开放指定的tcp端口，方便连接调试。
  
  Caution
  1). 一直开放tcp端口也有分险，需要注意。
  2). 直接在/system/build.prop文件中编辑不生效(如果对/system分区没有写权限的话)。需要借助 magisk 模块中的system.prop。
- ADB添加系统证书的方法 #
  
  【 Docs|参见】

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(BC | basic calculator) #
- 保留位数 #
  
  echo 'scale=3; 10 / 3' | bc
  echo 'scale=5; 820 / (480 + 90)' | bc
- 指数/对数计算 #
  
  Note
  echo '2 ^ 3' | bc
  echo 'log(8,2)' | bc -l
- 异或 #
  
  echo 'ibase=16;obase=10;bxor(1,2)' | bc -l ==> 3
- 进制转换 #
  
  Caution
  1).: 特别需要注意 ibase，obase，以及值之间的联系，不然会出现意想不到的结果。如下图：参见
  简而言之，就是在进制转换的时候，不管ibase、obase哪一个在前，都要以前面使用的进制为主，对后面的值以前面的进制进行转换。举例如下：
  在2到八进制中，可以写成ibase=2;obase=1000;，或者obase=8;ibase=2;，对于第一个，（2，1000），1000 为二进制的值 8，第二个（8，2），2 为八进制中的值 2
  
  2).: 十六进制中的字母需要大写。小写就是: (standard_in) 1: syntax error。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(find) #

syntax #

# 1，在home目录下查找txt 结尾或者 sh 结尾的文件
find /home -name "*.txt" -o -name "*.sh"
# 2，查找路径，文件名中包含 lib 的文件
find /home -path "*lib*"
# 3，表达式匹配
find /home -regex ".*(\.txt | \.sh)$"
# 4，否定参数
find /home ! -name "*.txt"
# 5，文件类型
find /home -type [f普通文件 | l符号连接 | d 目录 | c 字符设备| b块设备 | s套接字 | p Fifo]
# 6，目录深度搜索
find /home -maxdepth 3
# 7，文件大小
find /home -size [+10k | -10k | 10K]
# 8，过滤权限拒绝的文件
find /home [-perm 777 | -user tom | -group git]
# 9，exec | ok
find /home -size 10k -[exec | ok] ls -l {} \;

样例 #
1. find / -name "*.jar" -a -path "*jetbrains*" 2>/dev/null

Mon, 01 Jan 0001 00:00:00 +0000

Linux 防火墙 #

iptables-services #

服务操作 #

index	content
安装	`yum install iptables-services`
配置	`vim /etc/sysconfig/iptables`
永久保存	`service iptables save`
状态	`systemctl status iptables`
启动	`systemctl status start`
停止	`systemctl status stop`
重启	`systemctl status restart`
关闭自启服务	`chkconfig iptables off`
开启自启服务	`chkconfig iptables on`

格式（-t没有默认filter） #

iptables [-t 表名] 操作选项 [链名] [条件] [-j 控制类型]

样例 #
```
# 地址转发与伪装:
# 先进行如下的配置
# 1.1.1.200 1.1.1.100(eth1) 172.25.254.72
# server虚拟机 172.25.254.233(eth0) 真机
# desktop虚拟机 
# 源地址地址转发（SNAT）：伪装
iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 172.25.254.233

# 目的地地址转发（DNAT）：转发
# desktop中设置:
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 22 -j DNAT --to-dest 1.1.1.200:22
```
- iptables -X -F -Z ：重置防火墙
- iptables -nL INPUT
- iptables -P INPUT DROP ：修改INPUT链默认策略，默认所有链都是[ACCEPT]
- iptables -t filter -I INPUT -p tcp --dport 80 -j DROP
- iptables -D INPUT -p tcp --dport 80 -j DROP
- iptables -D INPUT -p tcp -s 42.89.72.49 --dport 80 -j REJECT
- cat blacklist.ip | xargs -I % sudo iptables -t filter -A INPUT -s % -j DROP
- iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 80 -j ACCEP
- iptables -I INPUT -i eth0 -p tcp --tcp-flags SYN,RST,ACK SYN -j DROP
- iptables -t filter -A INPUT -p icmp -j REJECT
- iptables -I INPUT -p icmp --icmp-type 8 -j DROP :我们可以ping别人,但是别人不能ping我们,[OUTPUT|0]相反
- iptables -t nat -A POSTROUTING -s 192.168.100.0/24 -o ens33 -j SNAT --to-source 192.168.200.10

注意事项 #

1. iptables可以使用扩展bai模块来进行数据包du的匹配，zhi语法就是 -m modaole_name, 所以
-m tcp 的意思是使用zhuan tcp 扩展模块shu的功能 (tcp扩展模块提供权了 --dport, --tcp-flags, --sync等功能）
其实只用 -p tcp 了话， iptables也会默认的使用 -m tcp 来调用 tcp模块提供的功能。
但是 -p tcp 和 -m tcp是两个不同层面的东西，一个是说当前规则作用于 tcp 协议包，而后一是说明要使用iptables的tcp模块的功能 (--dport 等)

1. DROP,REJECT 第一个直接丢弃，需要等待客户端链接超时，而REJECT会返回一个关闭连接信息。响应快点。

2. 使用nat 时注意修改内核参数 `echo "net.ipv4.ip_forward=1" >> /usr/lib/sysctl.d/50-default.conf`(重启) 
或者直接 `echo 1 > /proc/sys/net/ipv4/ip_forward` 使用`sysctl -a | grep ip_forward` 查看修改后的属性

firewalld #

OMITTED #

Reference #

linux中的防火墙的基本设置—firewlld、iptables

Mon, 01 Jan 0001 00:00:00 +0000

Intro(GnuPG) #
- 基本概念 #
  
  Tip
  Key 管理是 GPG 的核心功能，GPG Key 不能简单的理解为非对称加密的 Private Key / Public Key / Key Pair。GPG Key 由如下信息组成：
  
  Key ID: 该 GPG Key 的唯一标识，值为主公钥的指纹，支持多种格式(Fingerprint, Long key ID, Short key ID)，更多参见：What is a OpenPGP/GnuPG key ID?。
  UID: 1 个或多个，每个 UID 由 name、email、comment 组成，email 和 comment 可以为空。
  Expire: 过期时间，可以为永久。
  多个具有不同用途的非对称加密算法中的 Key 的集合。
  
  key 分类参见下表

Mon, 01 Jan 0001 00:00:00 +0000

hashcat 简单使用 #

https://github.com/hashcat/hashcat.git

rar crack #

# 提取hash值，注意裁剪文件名
rar2john 9.rar > example0.hash
# output:
# $rar5$16$8345875512857bc69f0a8059ffce0166$15$7880153df518399181c9e2df158b7249$8$f627000464e14963
# 使用hashcat撞库
hashcat -a 3 -m 13000 -O -1 '?d?l' -D 1,2 -d 3,5 example0.hash '?l?l?l123'
# 自定义字符集
hashcat -a 3 -m 13000 -1 '?d?l' -D 1,2 -d 3,5 example0.hash '?1?1?1?1?1?1'
# hashcat.potfile
# /Users/stevenobelia/.local/share/hashcat/hashcat.potfile
# 查看破解记录
hashcat --show example0.hash

注意： #

安装john-ripper后需要链接rar2john https://superuser.com/questions/1652553/john-the-ripper-zip2john-command-not-found-mac/1670026 创建软链

Mon, 01 Jan 0001 00:00:00 +0000

Intro(keytool | Java 平台证书工具) #
Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Nmap | 参考指南) #

拿来主义：Nmap (“Network Mapper(网络映射器)”) 是一款开放源代码的网络探测和安全审核的工具。它的设计目标是快速地扫描大型网络，当然用它扫描单个主机也没有问题。Nmap以新颖的方式使用原始IP报文来发现网络上有哪些主机，那些主机提供什么服务(应用程序名和版本)，那些服务运行在什么操作系统(包括版本信息)，它们使用什么类型的报文过滤器/防火墙，以及一堆其它功能。虽然Nmap通常用于安全审核，许多系统管理员和网络管理员也用它来做一些日常的工作，比如查看整个网络的信息，管理服务升级计划，以及监视主机和服务的运行。

example:
nmap -v -A scanme.nmap.org
nmap -v -sP 192.168.0.0/16 10.0.0.0/8
nmap -v -iR 10000 -P0 -p 80

端口状态 #

state	explain
open	意味着目标机器上的应用程序正在该端口监听连接/报文
close	端口没有应用程序在它上面监听
filtered	意味着防火墙，过滤器或者其它网络障碍阻止了该端口被访问 open/close \| filtered :有可能开放/关闭或者被过滤，拦截等。比如对于`open \| filtered`来说，如果发送的报文有返回的时候认为是 close 的，那没返回的话就无法确定到底是被过滤了，还是真的 open。也既文档中的开放端口不响应的意思。UDP，IP协议， FIN，Null，和Xmas扫描可能把端口归入此类。`close \| filtered` 同理，它只可能出现在IPID Idle扫描中。
unfiltered	Nmap 根据目前的探测无法确定它们是关闭还是开放（极少出现的情况吧）

主机发现 #
扫描方式 #
服务探测 #
选项样例 #

Reference #
- https://nmap.org/man/zh/index.html

Options #

option	expalin
–packet-trace	打印数据包
–traceroute	路由追踪

Principle #

Examples #

References #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(OPENSSL) #
- 证书类型 #
  
  暂时记录一个 x509 ( rfc， wiki)。这种格式一般广泛应用于Web浏览器和服务器之间的SSL/TLS加密通信。
  对于这种证书的编码格式有 der, pem(privvaccy-enhanced mail) 等。且可以认为 pem 是 der 二进制的一种 base64编码。可以如下验证：
  
  1. 下载网站证书并写入到文件：（不是直接下载，而是在 https 握手过程中会携带证书数据，openssl 会在这个过程中打印出来，然后我们用工具提取即可）
  1.1. openssl s_client -connect wtfu.site:443 > pubkey.pem (运行可能会卡住，CTRL+c 终止就行)
  查看 pubkey.pem 内容：删除-----BEGIN CERTIFICATE-----和-----END CERTIFICATE-----之外多余的内容。
  1.2. 或者一步到位：openssl s_client -connect wtfu.site:443 </dev/null 2>/dev/null | sed -n '/BEGIN CERTIFICATE/,/END CERTIFICATE/p' > pubkey.pem
  
  2. 转换：pem -> der，将除了第一行和最后一行的内容进行 base64 解码，然后写入文件sed '1d;$d' pubkey.pem | base64 -d > pubkey.der
  3. 提取 pem 证书中的公匙并显示相关信息：openssl x509 -in pubkey.pem -pubkey -noout | openssl ec -pubin -text -noout
  4. 提取 der 证书中的公匙并显示相关信息：openssl x509 -in pubkey.der -pubkey -noout | openssl ec -pubin -text -noout
  
  或者也可以通过 asn1在线解析查看 pubkey.der 文件是否正确（DER 本质上是 ASN.1 结构类型的）。
  
  另外可以计算 sha-256 指纹(对应 chrome 浏览器证书基本信息中的值)，包括证书和公匙
  证书：cat pubkey.der | shasum -a 256，或者 grep -v ^- pubkey.pem | base64 -d | shasum -a 256。
  公匙：openssl x509 -in <pubkey.der | pubkey.pem> -pubkey -noout | grep -v ^- | base64 -d | shasum -a 256。

Mon, 01 Jan 0001 00:00:00 +0000

hello

Mon, 01 Jan 0001 00:00:00 +0000

用于参数转换，与不支持管道输入的命令搭配使用，比如 ls.

Options #

options	explain
-a	file 从文件中读入作为stdin
-e flag	注意，有的时候可能为-E，flag必须是一个以空格分隔的标志，当分析到含有flag这个标志的时候就停止
-p	每当执行一个argument的时候会询问用户
-n num	表示命令在执行的时候一次用几个参数，默认是所有
-t	表示先打印命令，再执行
-i \| -I	参数占位符，{}，%，等都可以使用
-s
-r no-run-if-empty
-L num
-d delim	默认的xargs的分隔符是回车，argument的分隔符是空格。这里修改的是xargs的分隔符
-x exit	主要配合 -s使用
-P	修改最大进程数，可以并发执行

CATION #

cat > file <<EOF
a b c d e
f g h i j k
l m n o p q r
s t u v
w x y z
EOF

cat file | xargs -L 2 -I {} echo '{}' # 这个命令中 -L 和 -I 指令冲突。所以不会出现预期效果，可以多加一个xargs使用,比如下面
cat file | xargs -L 2 | xargs -I {} echo '{}' # 多加后出现的效果。

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(xxd) #

vscode ➜ /workspaces/c_learning/multi-elf (master) $ xxd --help
Usage:
 xxd [options] [infile [outfile]]
 or
 xxd -r [-s [-]offset] [-c cols] [-ps] [infile [outfile]]
Options:
 -a toggle autoskip: A single '*' replaces nul-lines. Default off.
 -b binary digit dump (incompatible with -ps,-i). Default hex.
 -C capitalize variable names in C include file style (-i).
 -c cols format <cols> octets per line. Default 16 (-i: 12, -ps: 30).
 -E show characters in EBCDIC. Default ASCII.
 -e little-endian dump (incompatible with -ps,-i,-r).
 -g bytes number of octets per group in normal output. Default 2 (-e: 4).
 -h print this summary.
 -i output in C include file style.
 -l len stop after <len> octets.
 -n name set the variable name used in C include output (-i).
 -o off add <off> to the displayed file position.
 -ps output in postscript plain hexdump style.
 -r reverse operation: convert (or patch) hexdump into binary.
 -r -s off revert with <off> added to file positions found in hexdump.
 -d show offset in decimal instead of hex.
 -s [+][-]seek start at <seek> bytes abs. (or +: rel.) infile offset.
 -u use upper case hex letters.
 -R when colorize the output; <when> can be 'always', 'auto' or 'never'. Default: 'auto'.
 -v show version: "xxd 2023-10-25 by Juergen Weigert et al.".

Mon, 01 Jan 0001 00:00:00 +0000

# 1、语法
netsh interface ip set|show interface|address|dnsservers
netsh interface set|add|show interface

# 2、实践

netsh interface ip show interface
netsh interface ip set address name="本地连接" source=static|dhcp 192.168.0.192 255.255.255.0 192.168.0.1
netsh interface ip set dnsservers name="本地连接" source=static addr = 1.2.4.8 primary
netsh interface ip add dnsservers name="本地连接"  114.114.114.114 index=2
netsh interface set interface [admin=] enabled|disabled [connect=] connected|disconnected [newname=] xhs12302 

# 3、路由表
route print
route delete [traget]
route add [-p] 0.0.0.0 mask 0.0.0.0 192.168.1.1 metric 2 if 2

Mon, 01 Jan 0001 00:00:00 +0000

Intro(ByteCode) #

Hello.class

参考
JDK8 JVM虚拟机实现规范 Chapter 4. The class File Format，包括常量池数据结构
JDK8 JVM虚拟机实现规范 Chapter 6. The Java Virtual Machine Instruction Set

工具：
进制转换echo 'ibase=16;12'| bc
十六进制转utf-8echo -n "6E756D" | xxd -r -p | iconv -f utf-8

下面为java源代码和class字节码。编译使用-g参数，会包含 LocalVariableTable 。

用vim打开class文件vim -b Hello.class。[不加-b会在末尾追加0x0A多一个字节]
并且使用xxd工具查看:%!xxd -u;

右边为使用javap -v Hello.class工具输出的字节码信息。

public class Hello { 
 private int num;
 public int foo() {
 return num;
 } 
}

00000000: CAFE BABE 0000 0034 0013 0A00 0400 0F09 .......4........
00000010: 0003 0010 0700 1107 0012 0100 036E 756D .............num
00000020: 0100 0149 0100 063C 696E 6974 3E01 0003 ...I...<init>...
00000030: 2829 5601 0004 436F 6465 0100 0F4C 696E ()V...Code...Lin
00000040: 654E 756D 6265 7254 6162 6C65 0100 0366 eNumberTable...f
00000050: 6F6F 0100 0328 2949 0100 0A53 6F75 7263 oo...()I...Sourc
00000060: 6546 696C 6501 000A 4865 6C6C 6F2E 6A61 eFile...Hello.ja
00000070: 7661 0C00 0700 080C 0005 0006 0100 0548 va.............H
00000080: 656C 6C6F 0100 106A 6176 612F 6C61 6E67 ello...java/lang
00000090: 2F4F 626A 6563 7400 2100 0300 0400 0000 /Object.!.......
000000a0: 0100 0200 0500 0600 0000 0200 0100 0700 ................
000000b0: 0800 0100 0900 0000 1D00 0100 0100 0000 ................
000000c0: 052A B700 01B1 0000 0001 000A 0000 0006 .*..............
000000d0: 0001 0000 0001 0001 000B 000C 0001 0009 ................
000000e0: 0000 001D 0001 0001 0000 0005 2AB4 0002 ............*...
000000f0: AC00 0000 0100 0A00 0000 0600 0100 0000 ................
00000100: 0400 0100 0D00 0000 0200 0E ...........

Classfile /path/to/bytecode/Hello.class
Last modified 2024-3-6; size 267 bytes
MD5 checksum 4792914d35d8b3a70c01ee4fd462f512
Compiled from "Hello.java"
public class Hello
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #4.#15 // java/lang/Object."<init>":()V
#2 = Fieldref #3.#16 // Hello.num:I
#3 = Class #17 // Hello
#4 = Class #18 // java/lang/Object
#5 = Utf8 num
#6 = Utf8 I
#7 = Utf8 <init>
#8 = Utf8 ()V
#9 = Utf8 Code
#10 = Utf8 LineNumberTable
#11 = Utf8 foo
#12 = Utf8 ()I
#13 = Utf8 SourceFile
#14 = Utf8 Hello.java
#15 = NameAndType #7:#8 // "<init>":()V
#16 = NameAndType #5:#6 // num:I
#17 = Utf8 Hello
#18 = Utf8 java/lang/Object
{
public Hello();
 descriptor: ()V
 flags: ACC_PUBLIC
 Code:
 stack=1, locals=1, args_size=1
 0: aload_0
 1: invokespecial #1 // Method java/lang/Object."<init>":()V
 4: return
 LineNumberTable:
 line 1: 0

public int foo();
 descriptor: ()I
 flags: ACC_PUBLIC
 Code:
 stack=1, locals=1, args_size=1
 0: aload_0
 1: getfield #2 // Field num:I
 4: ireturn
 LineNumberTable:
 line 4: 0
}
SourceFile: "Hello.java"

文件定义 #

Java字节码类文件（.class）是Java编译器编译Java源文件（.java）产生的“目标文件”。它是一种8位字节的二进制流文件，各个数据项按顺序紧密的从前向后排列，相邻的项之间没有间隙，这样可以使得class文件非常紧凑，体积轻巧，可以被JVM快速的加载至内存，并且占据较少的内存空间（方便于网络的传输）。

Java源文件在被Java编译器编译之后，每个类（或者接口）都单独占据一个class文件，并且类中的所有信息都会在class文件中有相应的描述，由于class文件很灵活，它甚至比Java源文件有着更强的描述能力。

class文件中的信息是一项一项排列的，每项数据都有它的固定长度，有的占一个字节，有的占两个字节，还有的占四个字节或8个字节。数据项的不同长度分别用
u1, u2, u4, u8表示，分别表示一种数据项在class文件中占据1个字节， 2个字节， 4个字节，8个字节。可以把u1, u2, u3, u4看做class文件数据项的“类型” 。

Mon, 01 Jan 0001 00:00:00 +0000

Intro #

原理 #

实现 #

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.AlgorithmParameters;
import java.security.SecureRandom;
import java.security.Security;
import java.util.Base64;

public class AES {

 //加密方式
 private static final String ALGORITHM = "AES";
 //数据填充方式
 private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS7Padding";
 /**
 * 默认编码
 */
 private static final String CHARSET = "utf-8";

 //避免重复new生成多个BouncyCastleProvider对象，因为GC回收不了，会造成内存溢出
 //只在第一次调用decrypt()方法时才new 对象
 public static boolean initialized = false;

 static { Security.addProvider(new BouncyCastleProvider());}

 public static byte[] generateKey() throws Exception {
 KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
 SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG", "SUN");
 secureRandom.setSeed((CIPHER_ALGORITHM + "NEW_BRUSH").getBytes());
 keyGenerator.init(256, secureRandom);//要生成多少位，只需要修改这里即可128, 192或256
 SecretKey originalKey = keyGenerator.generateKey();
 return originalKey.getEncoded();
 }

 public static AlgorithmParameters generateIV(byte[] iv) throws Exception {
 AlgorithmParameters params = AlgorithmParameters.getInstance("AES");
 params.init(new IvParameterSpec(iv));
 return params;
 }

 /**
 * 加密
 */
 public static String encrypt(String content, byte[] key, byte[] iv) {
 try {
 byte[] originalContent = content.getBytes(CHARSET);
 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
 SecretKeySpec skeySpec = new SecretKeySpec(key, ALGORITHM);
 cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(iv));
 byte[] encrypted = cipher.doFinal(originalContent);
 return Base64.getEncoder().encodeToString(encrypted);
 } catch (Exception e) {
 throw new RuntimeException(e);
 }
 }

 /**
 * AES解密
 * 填充模式AES/CBC/PKCS7Padding
 * 解密模式128
 * @return 目标密文
 */
 public static String decrypt(String content, byte[] key, byte[] iv) {
 try {
 byte[] originalContent = Base64.getDecoder().decode(content);
 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
 SecretKey sKeySpec = new SecretKeySpec(key, ALGORITHM);
 cipher.init(Cipher.DECRYPT_MODE, sKeySpec, generateIV(iv));// 初始化
 byte[] result = cipher.doFinal(originalContent);
 return new String(result,CHARSET);
 } catch (Exception e) {
 throw new RuntimeException(e);
 }
 }
}

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro #

原理 #

实现 #

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.AlgorithmParameters;
import java.security.Key;
import java.util.Base64;

public class DES {

 /**
 * 偏移变量，固定占8位字节
 */
 private final static String IV_PARAMETER = "12345678";
 /**
 * 密钥算法
 */
 private static final String ALGORITHM = "DES";
 /**
 * 加密/解密算法-工作模式-填充模式
 */
 private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
 /**
 * 默认编码
 */
 private static final String CHARSET = "utf-8";

 /**
 * 生成key
 *
 * @param key
 * @return
 * @throws Exception
 */
 private static SecretKey generateKey(String key) throws Exception {
 DESKeySpec dks = new DESKeySpec(key.getBytes(CHARSET));
 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
 return keyFactory.generateSecret(dks);
 }

 public static AlgorithmParameters generateIV(byte[] iv) throws Exception {
 AlgorithmParameters params = AlgorithmParameters.getInstance(ALGORITHM);
 params.init(new IvParameterSpec(iv));
 return params;
 }

 /**
 * DES加密字符串
 *
 * @param key 加密密码，长度不能够小于8位
 * @param data 待加密字符串
 * @return 加密后内容
 */
 public static String encrypt(String data, byte[] key, byte[] iv) {
 if (key == null || key.length < 8) {
 throw new RuntimeException("加密失败，key不能小于8位");
 }
 if (data == null)
 return null;
 try {
 SecretKey secretKey = generateKey(new String(key));
 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
 IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
 cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
 byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));
 return new String(Base64.getEncoder().encode(bytes));

 } catch (Exception e) { e.printStackTrace(); return data;}
 }

 /**
 * DES解密字符串
 *
 * @param key 解密密码，长度不能够小于8位
 * @param data 待解密字符串
 * @return 解密后内容
 */
 public static String decrypt(String data, byte[] key, byte[] iv) {
 if (key== null || key.length < 8) {
 throw new RuntimeException("加密失败，key不能小于8位");
 }
 if (data == null)
 return null;
 try {
 SecretKey secretKey = generateKey(new String(key));
 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
 IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
 cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
 return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
 } catch (Exception e) { e.printStackTrace(); return data;}
 }
}

Reference #

https://blog.csdn.net/gs12software/article/details/83899389

Mon, 01 Jan 0001 00:00:00 +0000

Intro(RSA) #
- 前情提要 #
  - 欧拉函数 #
    
    欧拉函数 $\varphi(n)$ 是小于等于 n 的正整数中与 n 互质的数的数目。
    例如：$\varphi(8) = 4$，因为 1，3，5 和 7 均与 8 互质。
    
    有如下性质：
    1. 欧拉函数是积性函数，即是说若 m,n 互质，则 $\varphi(m*n) = \varphi(m) * \varphi(n)$。
    2. 如果 n 为质数，则 $\varphi(n) = n - 1$。
  - 同余 #
    
    对某两个整数 a b，若它们除以正整数 m 所得的余数相等，则称 a b 对于模 m 同余，也就是说，存在整数 k 使得 $a - b = km$，则称 a,b 对于 m 来说是同余的，一般记作 $a \equiv b \pmod{m}$。
    比如 $26 - 14 = 12 = 1 * 12$
    记作 $26 \equiv 14 \pmod{12}$

Mon, 01 Jan 0001 00:00:00 +0000

debugger #

参数解释 #

index	explain
-Xdebug	启用调试特性
-Xrunjdwp	在目标 VM 中加载 JDWP 实现。它通过传输和 JDWP 协议与独立的调试器应用程序通信。从 Java V5 开始，您可以使用 -agentlib:jdwp 选项，而不是 -Xdebug 和 -Xrunjdwp。
-Djava.compiler=NONE	禁止 JIT 编译器的加载
transport	传输方式，有 socket 和 shared memory 两种，我们通常使用 socket（套接字）传输，但是在 Windows 平台上也可以使用shared memory（共享内存）传输。
server（y/n）	VM 是否需要作为调试服务器执行
address	调试服务器的端口号，客户端用来连接服务器的端口号
suspend（y/n）	值是 y 或者 n，若为 y，启动时候自己程序的 VM 将会暂停（挂起），直到客户端进行连接，若为 n，自己程序的 VM 不会挂起

参数样例 #

Command line arguments for remote JVM.

JDK版本	(attach mode)启动追加命令[参考下图]	(listen mode)启动追加命令
JDK9 or later	-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:8800	-agentlib:jdwp=transport=dt_socket,server=n,address=localhost:8800,suspend=y
JDK 5-8	-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8800	-agentlib:jdwp=transport=dt_socket,server=n,address=localhost:8800,suspend=y
JDK 1.4.x	-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8800	-Xdebug -Xrunjdwp:transport=dt_socket,server=n,address=localhost:8800,suspend=y
JDK 1.3.x or earliar	-Xnoagent -Djava.compiler=NONE -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8800	-Xnoagent -Djava.compiler=NONE -Xdebug -Xrunjdwp:transport=dt_socket,server=n,address=localhost:8800,suspend=y

Mon, 01 Jan 0001 00:00:00 +0000

单例模式 #

描述 #

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {
 //获取唯一可用的对象
 SingleObject object = SingleObject.getInstance();
 //显示消息
 object.showMessage();
 }
}

public class Singleton { 
 private Singleton (){}
 private static Singleton instance; 
 public static /*synchronized*/ Singleton getInstance() { 
 if (instance == null) { 
 instance = new Singleton(); 
 } 
 return instance; 
 } 
}

public class Singleton { 
 private Singleton (){}
 private static Singleton instance = new Singleton();
 public static Singleton getInstance() {
 return instance;
 }
}

public class Singleton { 
 private Singleton (){}
 private volatile static Singleton singleton; 
 public static Singleton getSingleton() { 
 if (singleton == null) { 
 synchronized (Singleton.class) { 
 if (singleton == null) { 
 singleton = new Singleton(); 
 } 
 } 
 } 
 return singleton; 
 }
}

public class Singleton { 
 private Singleton (){}
 private static class SingletonHolder { 
 private static final Singleton INSTANCE = new Singleton(); 
 } 
 public static final Singleton getInstance() { 
 return SingletonHolder.INSTANCE; 
 } 
}

public enum Singleton { 
 INSTANCE; 
 public void whateverMethod() { 
 } 
}

Reference #
- https://www.runoob.com/design-pattern/singleton-pattern.html

Mon, 01 Jan 0001 00:00:00 +0000

工厂模式 #

描述 #

工厂模式提供了一种创建对象的方式，而无需指定要创建的具体类。

工厂模式属于创建型模式，它在创建对象时提供了一种封装机制，将实际创建对象的代码与使用代码分离。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {

 ShapeFactory shapeFactory = new ShapeFactory();

 Shape shape1 = shapeFactory.getShape("CIRCLE");
 shape1.draw();

 Shape shape2 = shapeFactory.getShape("RECTANGLE");
 shape2.draw();

 Shape shape3 = shapeFactory.getShape("SQUARE");
 shape3.draw();
 }
}

public class ShapeFactory {

 //使用 getShape 方法获取形状类型的对象
 public Shape getShape(String shapeType){
 if(shapeType == null){ return null; }

 if(shapeType.equalsIgnoreCase("CIRCLE")){
 return new Circle();
 } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
 return new Rectangle();
 } else if(shapeType.equalsIgnoreCase("SQUARE")){
 return new Square();
 }
 return null;
 }
}

public interface Shape {
 void draw();
}

public class Circle implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Circle::draw() method.");
 }
}

public class Rectangle implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Rectangle::draw() method.");
 }
}

public class Square implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Square::draw() method.");
}

Mon, 01 Jan 0001 00:00:00 +0000

抽象工厂模式 #

描述 #

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {
 //获取形状工厂
 AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");

 // 会出现NPE
 // Color color = shapeFactory.getColor("everything");
 Shape shape1 = shapeFactory.getShape("CIRCLE");
 shape1.draw();

 //获取颜色工厂
 AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");

 Color color1 = colorFactory.getColor("RED");
 color1.fill();
 }
}

public class FactoryProducer {
 public static AbstractFactory getFactory(String choice){
 if(choice.equalsIgnoreCase("SHAPE")){
 return new ShapeFactory();
 } else if(choice.equalsIgnoreCase("COLOR")){
 return new ColorFactory();
 }
 return null;
 }
}

public abstract class AbstractFactory {

 public abstract Color getColor(String color);

 public abstract Shape getShape(String shape);

}

public class ShapeFactory extends AbstractFactory {

 //使用 getShape 方法获取形状类型的对象
 public Shape getShape(String shapeType){
 if(shapeType == null){ return null; }
 if(shapeType.equalsIgnoreCase("CIRCLE")){
 return new Circle();
 } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
 return new Rectangle();
 } else if(shapeType.equalsIgnoreCase("SQUARE")){
 return new Square();
 }
 return null;
 }

 @Override
 public Color getColor(String color) {
 return null;
 }
}

public interface Shape {
 void draw();
}

public class Circle implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Circle::draw() method.");
 }
}

public class Rectangle implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Rectangle::draw() method.");
 }
}

public class Square implements Shape {
 @Override
 public void draw() {
 System.out.println("Inside Square::draw() method.");
}

public class ColorFactory extends AbstractFactory {
 @Override
 public Shape getShape(String shapeType){
 return null;
 }

 @Override
 public Color getColor(String color) {
 if(color == null){ return null; }

 if(color.equalsIgnoreCase("RED")){
 return new Red();
 } else if(color.equalsIgnoreCase("GREEN")){
 return new Green();
 } else if(color.equalsIgnoreCase("BLUE")){
 return new Blue();
 }
 return null;
 }
}

public interface Color {
 void fill();
}

public class Blue implements Color {
 @Override
 public void fill() {
 System.out.println("Inside Blue::fill() method.");
 }
}

public class Green implements Color {
 @Override
 public void fill() {
 System.out.println("Inside Green::fill() method.");
 }
}

public class Red implements Color {
 @Override
 public void fill() {
 System.out.println("Inside Red::fill() method.");
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

适配器模式 #

描述 #

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。

我们通过下面的实例来演示适配器模式的使用。其中，音频播放器设备只能播放 mp3 文件，通过使用一个更高级的音频播放器来播放 vlc 和 mp4 文件。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {

 AudioPlayer audioPlayer = new AudioPlayer();

 audioPlayer.play("mp3", "beyond the horizon.mp3");
 audioPlayer.play("mp4", "alone.mp4");
 audioPlayer.play("vlc", "far far away.vlc");
 audioPlayer.play("avi", "mind me.avi");
 }
}

public class AudioPlayer implements MediaPlayer {
 MediaAdapter mediaAdapter;

 @Override
 public void play(String audioType, String fileName) {

 //播放 mp3 音乐文件的内置支持
 if(audioType.equalsIgnoreCase("mp3")){
 System.out.println("Playing mp3 file. Name: "+ fileName);
 }
 //mediaAdapter 提供了播放其他文件格式的支持
 else if(audioType.equalsIgnoreCase("vlc")
 || audioType.equalsIgnoreCase("mp4")){
 mediaAdapter = new MediaAdapter(audioType);
 mediaAdapter.play(audioType, fileName);
 }
 else{
 System.out.println("Invalid media. "+
 audioType + " format not supported");
 }
 }
}

public interface MediaPlayer {
 public void play(String audioType, String fileName);
}

public class MediaAdapter implements MediaPlayer {

 AdvancedMediaPlayer advancedMusicPlayer;

 public MediaAdapter(String audioType){
 if(audioType.equalsIgnoreCase("vlc") ){
 advancedMusicPlayer = new VlcPlayer();
 } else if (audioType.equalsIgnoreCase("mp4")){
 advancedMusicPlayer = new Mp4Player();
 }
 }

 @Override
 public void play(String audioType, String fileName) {
 if(audioType.equalsIgnoreCase("vlc")){
 advancedMusicPlayer.playVlc(fileName);
 }else if(audioType.equalsIgnoreCase("mp4")){
 advancedMusicPlayer.playMp4(fileName);
 }
 }
}

public class Mp4Player implements AdvancedMediaPlayer{

 @Override
 public void playVlc(String fileName) {
 //什么也不做
 }

 @Override
 public void playMp4(String fileName) {
 System.out.println("Playing mp4 file. Name: "+ fileName);
 }
}

public class VlcPlayer implements AdvancedMediaPlayer{
 @Override
 public void playVlc(String fileName) {
 System.out.println("Playing vlc file. Name: "+ fileName);
 }

 @Override
 public void playMp4(String fileName) {
 //什么也不做
 }
}

public interface AdvancedMediaPlayer {
 public void playVlc(String fileName);
 public void playMp4(String fileName);
}

Mon, 01 Jan 0001 00:00:00 +0000

责任链模式 #

描述 #

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

我们创建抽象类 AbstractLogger，带有详细的日志记录级别。然后我们创建三种类型的记录器，都扩展了 AbstractLogger。每个记录器消息的级别是否属于自己的级别，如果是则相应地打印出来，否则将不打印并把消息传给下一个记录器。
UML #

代码实现 #

public class Main {
 private static AbstractLogger getChainOfLoggers(){

 AbstractLogger debugLogger = new DebugLogger(AbstractLogger.DEBUG);
 AbstractLogger infoLogger = new InfoLogger(AbstractLogger.INFO);
 AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);

 debugLogger.setNextLogger(infoLogger);
 infoLogger.setNextLogger(errorLogger);

 return debugLogger;
 }

 public static void main(String[] args) {
 AbstractLogger loggerChain = getChainOfLoggers();

 loggerChain.logMessage(AbstractLogger.DEBUG, "This is a debug level information.");

 loggerChain.logMessage(AbstractLogger.INFO, "This is an info level information.");

 loggerChain.logMessage(AbstractLogger.ERROR, "This is an error level information.");
 }
}

public abstract class AbstractLogger {
 public static int DEBUG = 1;
 public static int INFO = 2;
 public static int ERROR = 3;

 protected int level;

 //责任链中的下一个元素
 protected AbstractLogger nextLogger;

 public void setNextLogger(AbstractLogger nextLogger){
 this.nextLogger = nextLogger;
 }

 public void logMessage(int level, String message){
 if(this.level >= level){
 write(message);
 }
 if(nextLogger != null){
 nextLogger.logMessage(level, message);
 }else{ System.out.println();}
 }

 abstract protected void write(String message);
}

public class DebugLogger extends AbstractLogger {

 public DebugLogger(int level){
 this.level = level;
 }

 @Override
 protected void write(String message) {
 System.out.println("Debug::Logger: " + message);
 }
}

public class InfoLogger extends AbstractLogger {

 public InfoLogger(int level){
 this.level = level;
 }

 @Override
 protected void write(String message) {
 System.out.println("Info::Logger: " + message);
 }
}

public class ErrorLogger extends AbstractLogger {

 public ErrorLogger(int level){
 this.level = level;
 }

 @Override
 protected void write(String message) {
 System.out.println("Error::Logger: " + message);
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

策略模式 #

描述 #

在策略模式（Strategy Pattern）中一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式定义了一系列算法或策略，并将每个算法封装在独立的类中，使得它们可以互相替换。通过使用策略模式，可以在运行时根据需要选择不同的算法，而不需要修改客户端代码。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

我们将创建一个定义活动的 Strategy 接口和实现了 Strategy 接口的实体策略类。Context 是一个使用了某种策略的类。StrategyPatternDemo，我们的演示类使用 Context 和策略对象来演示 Context 在它所配置或使用的策略改变时的行为变化。
UML #

代码实现 #

public class Main {

 public static void main(String[] args) {

 Context context = new Context(new OperationAdd());
 System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

 context = new Context(new OperationSubtract());
 System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

 context = new Context(new OperationMultiply());
 System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
 }
}

public class Context {
 private Strategy strategy;

 public Context(Strategy strategy){
 this.strategy = strategy;
 }

 public int executeStrategy(int num1, int num2){
 return strategy.doOperation(num1, num2);
 }
}

public interface Strategy {
 public int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy{
 @Override
 public int doOperation(int num1, int num2) {
 return num1 + num2;
 }
}

public class OperationSubtract implements Strategy{
 @Override
 public int doOperation(int num1, int num2) {
 return num1 - num2;
 }
}

public class OperationMultiply implements Strategy{
 @Override
 public int doOperation(int num1, int num2) {
 return num1 * num2;
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

模板模式 #

描述 #

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {

 Game game = new Cricket();
 game.play();

 game = new Football();
 game.play();
 }
}

public abstract class Game {
 abstract void initialize();
 abstract void startPlay();
 abstract void endPlay();
 //模板
 public final void play(){
 //初始化游戏
 initialize();
 //开始游戏
 startPlay();
 //结束游戏
 endPlay();
 }
}

public class Cricket extends Game {

 @Override
 void endPlay() {
 System.out.println("Cricket Game Finished!");
 }

 @Override
 void initialize() {
 System.out.println("Cricket Game Initialized! Start playing.");
 }

 @Override
 void startPlay() {
 System.out.println("Cricket Game Started. Enjoy the game!");
 }
}

public class Football extends Game {

 @Override
 void endPlay() {
 System.out.println("Football Game Finished!");
 }

 @Override
 void initialize() {
 System.out.println("Football Game Initialized! Start playing.");
 }

 @Override
 void startPlay() {
 System.out.println("Football Game Started. Enjoy the game!");
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

访问者模式 #

描述 #

在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。

访问模式可以有变形，比如有些写法中被访问的是抽象类，而另外的是接口实现。

ASM里面就用到了访问者模式来处理字节码信息。
UML #

代码实现 #

public class Main {
 public static void main(String[] args) {

 List<Staff> staffs = new ArrayList<>();
 staffs.add(new Manager("经理-A"));
 staffs.add(new Manager("经理-B"));
 staffs.add(new Engineer("工程师-A"));
 staffs.add(new Engineer("工程师-B"));
 staffs.add(new Engineer("工程师-C"));
 staffs.add(new Engineer("工程师-D"));

 CEOVisitor ceoVisitor = new CEOVisitor();
 for (Staff staff : staffs) {
 staff.accept(ceoVisitor);
 }

 System.out.println();

 CTOVisitor ctoVisitor = new CTOVisitor();
 for (Staff staff : staffs) {
 staff.accept(ctoVisitor);
 }
 }
}

active(访问) #

public interface Visitor {
 void visit(Engineer engineer);
 void visit(Manager manager);
}

public class CEOVisitor implements Visitor {

 @Override
 public void visit(Engineer engineer) {
 System.out.println("CEO -visit-> 工程师: " + engineer.name + ", KPI: " + engineer.kpi);
 }

 @Override
 public void visit(Manager manager) {
 System.out.println("CEO -visit-> 经理: " + manager.name + ", KPI: " + manager.kpi +
 ", 新产品数量: " + manager.getProducts());
 }
}

public class CTOVisitor implements Visitor {

 @Override
 public void visit(Engineer engineer) {
 System.out.println("CTO -visit-> 工程师: " + engineer.name + ", 代码行数: " + engineer.getCodeLines());
 }

 @Override
 public void visit(Manager manager) {
 System.out.println("CTO -visit-> 经理: " + manager.name + ", 产品数量: " + manager.getProducts());
 }
}

passive(被访问) #

public abstract class Staff {

 public String name;
 public int kpi;// 员工KPI

 public Staff(String name) {
 this.name = name;
 kpi = new Random().nextInt(10);
 }
 // 核心方法，接受Visitor的访问
 public abstract void accept(Visitor visitor);
}

public class Engineer extends Staff {

 public Engineer(String name) {
 super(name);
 }

 @Override
 public void accept(Visitor visitor) {
 visitor.visit(this);
 }
 // 工程师一年的代码数量
 public int getCodeLines() {
 return new Random().nextInt(10 * 10000);
 }
}

public class Manager extends Staff {

 public Manager(String name) {
 super(name);
 }

 @Override
 public void accept(Visitor visitor) {
 visitor.visit(this);
 }

 // 一年做的产品数量
 public int getProducts() {
 return new Random().nextInt(10);
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

Intro(JavaAgent) #

通过实现agent类中的premain方法将自定义的类转换器注册到JVM中，从而实现类加载之前对字节码进行处理。本次实验中对类未进行处理，而是在加载类之前打印输出。
完整代码可参考

代码实现 #

package agent;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;

public class MyAgent {
 public static void premain(String args, Instrumentation instrumentation){
 ClassFileTransformer classFileTransformer = new MyTransfor();
 instrumentation.addTransformer(classFileTransformer);
 }
}

package agent;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;

public class MyTransfor implements ClassFileTransformer {
 @Override
 public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {

 /*_12302_2019-07-26_<此处可以静态代理>*/
 System.out.println("from: " + className + "--> hello agent!");

 /*_12302_2019-07-26_<return null 并不表示将要加载的类清空,而是不往其中添加任何东西>*/
 return null;
 }
}

package demo;

public class TestMain {
 public static void main(String[] args) {
 System.out.println("this is _base.base.demo.TestMain.main(),and nothing else");
 }
}

构建及运行 #

使用maven-assembly-plugin插件进行构建的。在assembly.xml配置中排除主类包，并在pom.xmlassembly插件配置中定义了生成META-INF/MANIFEST.MF文件且包含Premain-Class: agent.MyAgent 属性。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(JavaStrace) #

一个java程序的运行全过程解析。

右上java源代码，右下常量池，左下为Code方法块。

{
 public _jvm.classPrase.Student(int, java.lang.String, java.lang.String);
 descriptor: (ILjava/lang/String;Ljava/lang/String;)V
 flags: ACC_PUBLIC
 Code:
 stack=3, locals=4, args_size=4
 0: aload_0
 1: iload_1
 2: aload_2
 3: invokespecial #1 // Method _jvm/classPrase/Person."<init>":(ILjava/lang/String;)V
 6: aload_0
 7: aload_3
 8: putfield #2 // Field sid:Ljava/lang/String;
 11: return
 LineNumberTable:
 line 19: 0
 line 20: 6
 line 21: 11

 public void run();
 descriptor: ()V
 flags: ACC_PUBLIC
 Code:
 stack=2, locals=1, args_size=1
 0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
 3: ldc #4 // String run()...
 5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
 8: return
 LineNumberTable:
 line 23: 0
 line 24: 8

 public int study(int, int);
 descriptor: (II)I
 flags: ACC_PUBLIC
 Code:
 stack=3, locals=5, args_size=3
 0: bipush 10
 2: istore_3
 3: bipush 20
 5: istore 4
 7: iload_1
 8: iload_2
 9: iload_3
 10: imul
 11: iadd
 12: iload 4
 14: isub
 15: ireturn
 LineNumberTable:
 line 26: 0
 line 27: 3
 line 28: 7

 public static int getCnt();
 descriptor: ()I
 flags: ACC_PUBLIC, ACC_STATIC
 Code:
 stack=1, locals=0, args_size=0
 0: getstatic #6 // Field cnt:I
 3: ireturn
 LineNumberTable:
 line 31: 0

 public static void main(java.lang.String[]);
 descriptor: ([Ljava/lang/String;)V
 flags: ACC_PUBLIC, ACC_STATIC
 Code:
 stack=5, locals=2, args_size=1
 0: new #7 // class _jvm/classPrase/Student
 3: dup
 4: bipush 23
 6: ldc #8 // String dqrcsc
 8: ldc #9 // String 20150723
 10: invokespecial #10 // Method "<init>":(ILjava/lang/String;Ljava/lang/String;)V
 13: astore_1
 14: aload_1
 15: iconst_5
 16: bipush 6
 18: invokevirtual #11 // Method study:(II)I
 21: pop
 22: invokestatic #12 // Method getCnt:()I
 25: pop
 26: aload_1
 27: invokevirtual #13 // Method run:()V
 30: return
 LineNumberTable:
 line 34: 0
 line 35: 14
 line 36: 22
 line 37: 26
 line 38: 30

 static {};
 descriptor: ()V
 flags: ACC_STATIC
 Code:
 stack=2, locals=0, args_size=0
 0: iconst_5
 1: putstatic #6 // Field cnt:I
 4: getstatic #6 // Field cnt:I
 7: iconst_1
 8: iadd
 9: putstatic #6 // Field cnt:I
 12: return
 LineNumberTable:
 line 13: 0
 line 15: 4
 line 16: 12
}

package _jvm.classPrase;

/**
 *
 * Copyright https://wtfu.site Inc. All Rights Reserved.
 *
 * @date 2024/3/8
 * @since 1.0
 * @author 12302
 *
 */
public class Student extends Person implements IStudyable {
 private static int cnt=5;
 static{
 cnt++;
 }
 private String sid;
 public Student(int age, String name, String sid){
 super(age,name);
 this.sid = sid;
 }
 public void run(){
 System.out.println("run()...");
 }
 public int study(int a, int b){
 int c = 10;
 int d = 20;
 return a+b*c-d;
 }
 public static int getCnt(){
 return cnt;
 }
 public static void main(String[] args){
 Student s = new Student(23,"dqrcsc","20150723");
 s.study(5,6);
 Student.getCnt();
 s.run();
 }
}
class Person {
 private String name;
 private int age;
 public Person(int age, String name){
 this.age = age;
 this.name = name;
 }
 public void run(){}
}
interface IStudyable {
 public int study(int a, int b);
}

Constant pool:
 #1 = Methodref #14.#35 // _jvm/classPrase/Person."<init>":(ILjava/lang/String;)V
 #2 = Fieldref #7.#36 // _jvm/classPrase/Student.sid:Ljava/lang/String;
 #3 = Fieldref #37.#38 // java/lang/System.out:Ljava/io/PrintStream;
 #4 = String #39 // run()...
 #5 = Methodref #40.#41 // java/io/PrintStream.println:(Ljava/lang/String;)V
 #6 = Fieldref #7.#42 // _jvm/classPrase/Student.cnt:I
 #7 = Class #43 // _jvm/classPrase/Student
 #8 = String #44 // dqrcsc
 #9 = String #45 // 20150723
 #10 = Methodref #7.#46 // _jvm/classPrase/Student."<init>":(ILjava/lang/String;Ljava/lang/String;)V
 #11 = Methodref #7.#47 // _jvm/classPrase/Student.study:(II)I
 #12 = Methodref #7.#48 // _jvm/classPrase/Student.getCnt:()I
 #13 = Methodref #7.#49 // _jvm/classPrase/Student.run:()V
 #14 = Class #50 // _jvm/classPrase/Person
 #15 = Class #51 // _jvm/classPrase/IStudyable
 #16 = Utf8 cnt
 #17 = Utf8 I
 #18 = Utf8 sid
 #19 = Utf8 Ljava/lang/String;
 #20 = Utf8 <init>
 #21 = Utf8 (ILjava/lang/String;Ljava/lang/String;)V
 #22 = Utf8 Code
 #23 = Utf8 LineNumberTable
 #24 = Utf8 run
 #25 = Utf8 ()V
 #26 = Utf8 study
 #27 = Utf8 (II)I
 #28 = Utf8 getCnt
 #29 = Utf8 ()I
 #30 = Utf8 main
 #31 = Utf8 ([Ljava/lang/String;)V
 #32 = Utf8 <clinit>
 #33 = Utf8 SourceFile
 #34 = Utf8 Student.java
 #35 = NameAndType #20:#52 // "<init>":(ILjava/lang/String;)V
 #36 = NameAndType #18:#19 // sid:Ljava/lang/String;
 #37 = Class #53 // java/lang/System
 #38 = NameAndType #54:#55 // out:Ljava/io/PrintStream;
 #39 = Utf8 run()...
 #40 = Class #56 // java/io/PrintStream
 #41 = NameAndType #57:#58 // println:(Ljava/lang/String;)V
 #42 = NameAndType #16:#17 // cnt:I
 #43 = Utf8 _jvm/classPrase/Student
 #44 = Utf8 dqrcsc
 #45 = Utf8 20150723
 #46 = NameAndType #20:#21 // "<init>":(ILjava/lang/String;Ljava/lang/String;)V
 #47 = NameAndType #26:#27 // study:(II)I
 #48 = NameAndType #28:#29 // getCnt:()I
 #49 = NameAndType #24:#25 // run:()V
 #50 = Utf8 _jvm/classPrase/Person
 #51 = Utf8 _jvm/classPrase/IStudyable
 #52 = Utf8 (ILjava/lang/String;)V
 #53 = Utf8 java/lang/System
 #54 = Utf8 out
 #55 = Utf8 Ljava/io/PrintStream;
 #56 = Utf8 java/io/PrintStream
 #57 = Utf8 println
 #58 = Utf8 (Ljava/lang/String;)V

虚拟机栈 #

JVM中通过java栈，保存方法调用运行的相关信息，每当调用一个方法，会根据该方法的在字节码中的信息为该方法创建栈帧，不同的方法，其栈帧的大小有所不同。栈帧中的内存空间还可以分为3块，分别存放不同的数据：

1). 局部变量表：存放该方法调用者所传入的参数，及在该方法的方法体中创建的局部变量。
2). 操作数栈：用于存放操作数及计算的中间结果等。
3). 其他栈帧信息：如返回地址、当前方法的引用等。

只有当前正在运行的方法的栈帧位于栈顶，当前方法返回，则当前方法对应的栈帧出栈，当前方法的调用者的栈帧变为栈顶；当前方法的方法体中若是调用了其他方法，则为被调用的方法创建栈帧，并将其压入栈顶。
注意：局部变量表及操作数栈的最大深度在编译期间就已经确定了，存储在该方法字节码的Code属性中。

Mon, 01 Jan 0001 00:00:00 +0000

编译JDK #

build #

# 下载xcodeapp[(~7G), OS version [13.3.1 (22E261)]
wget -c https://download.developer.apple.com/Developer_Tools/Xcode_14.3.1/Xcode_14.3.1.xip
# 切换xcode 到xcodeapp
sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
sudo xcodebuild -license

# 配置
# disable-warnings-as-errors选项是禁止把warning 当成error
# --with-debug-level=slowdebug。用来设置编译的级别，可选值为release、fastdebug、slowde-bug，越往后进行的优化措施就越少，带的调试信息就越多。默认值为release。slowdebug 含有最丰富的调试信息，没有这些信息，很多执行可能被优化掉，我们单步执行时，可能看不到一些变量的值。所以最好指定slowdebug 为编译级别。
# with-jvm-variants 编译特定模式的HotSpot虚拟机，可选值：server、client、minimal、core、zero、custom
# configure 命令承担了依赖项检查、参数配置和构建输出目录结构等多项职责，如果编译过程中需要的工具链或者依赖项有缺失，命令执行后会得到明确的提示，并给出该依赖的安装命令。
bash configure --disable-warnings-as-errors --with-debug-level=slowdebug --with-jvm-variants=server
# 编译
make images

# 生成compile_commands.json文件
make compile-commands

loaded to clion #
debug #

使用lldb debug的时候会出现 Signal: SIGSEGV (signal SIGSEGV) ,目前切换到gdb断点不生效，未解决。
可以参考添加下列代码解决。如果是gdb的话，参考

Mon, 01 Jan 0001 00:00:00 +0000

Intro(HSDB) #

-XX:-UseCompressedOopsoops: ordinary object pointer，普通对象指针压缩，例如Object o = new Object();其中o就是个指向new Object()对象的指针，o在指针压缩前占用8个字节，在指针压缩后占用4个字节。
-XX:-UseCompressedClassPointers压缩Klass Pointer，压缩前8个字节，压缩后4个字节。

sudo java -cp $JAVA_HOME/lib/sa-jdi.jar sun.jvm.hotspot.HSDB
Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(jvisualvm) #
- OQL控制台
  
  使用样例
  select s from java.lang.String s where s.toString().contains("hello")
  select s from java.lang.String s where s.toString().equals("12")
  select s from java.lang.String s where /^\d+$/.test(s.toString())
  select i from java.lang.Integer i where i.value > 12302
Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro(StringTable | 打印 JVM StringTable) #

将虚拟机中的 StringTable 里面的字符全部打印出来，有两种方式，1：通过 jcmd 命令，2：借助 sun 下 hotspot 中的相关工具类编码。

jcmd 方式 #

Note

jcmd 里面有个命令是VM.stringtable，可以查看 VM 里面的 stringtable，jdk 9以下好像没有这个命令参考，会抛出：”java.lang.IllegalArgumentException: Unknown diagnostic command“错误，所以可以使用 jdk9 去诊断。

package _base.str.test;

public class StringTest {
 public static void main(String[] args) {
 String str2 = new String("str")+new String("01"); // 创建string对象 0x02912。
 str2.intern(); // jdk1.7及以下。 str2.intern()如果常量池中没有的话，会创建 str2 0x02912。 . 所以 str2.intern() == str2
 String str1 = "str01"; // 现在常量池中有了，直接返回引用 0x02912。
 System.out.println(str2==str1); // 所以相等

 String str3 = new String("hel") + new String("lo");

 String str4 = new String("he") + new String("llo");

 String str3Tmp = str3.intern();
 String str4Tmp = str4.intern();
 System.out.println(str3.equals(str4));

 keepRunning();
 System.out.println();
 }

 public static void keepRunning(){
 Thread thread = Thread.currentThread();
 synchronized (thread){
 try {
 thread.wait();
 } catch (InterruptedException e) { e.printStackTrace(); }
 }
 }
}

可以使用 idea 中的 JDK 1.8 环境编译，然后运行使用 jdk9。
再运行：/Library/Java/JavaVirtualMachines/jdk-9.0.4.jdk/Contents/Home/bin/java -cp /Users/stevenobelia/Documents/project_idea_test/idea-test-project/_0_base-learning/target/classes _base.str.test.StringTest

Mon, 01 Jan 0001 00:00:00 +0000

example #

1. 编写NativeLibrary.h #

#include <string>

namespace NativeLibrary {
 class NativeClass {
 public:
 const std::string& get_property() { return property; }
 void set_property(const std::string& property) { this->property = property; }
 std::string property;
 };
}

2. 编写NativeLibrary.java #

import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

@Platform(include="NativeLibrary.h")
@Namespace("NativeLibrary")
public class NativeLibrary {
 public static class NativeClass extends Pointer {
 static { Loader.load(); }
 public NativeClass() { allocate(); }
 private native void allocate();

 // to call the getter and setter functions 
 public native @StdString String get_property(); public native void set_property(String property);

 // to access the member variable directly
 public native @StdString String property(); public native void property(String property);
 }

 public static void main(String[] args) {
 // Pointer objects allocated in Java get deallocated once they become unreachable,
 // but C++ destructors can still be called in a timely fashion with Pointer.deallocate()
 NativeClass l = new NativeClass();
 l.set_property("Hello World!");
 System.out.println(l.property());
 }
}

3. 执行 #

$ java -jar javacpp-1.5.9.jar NativeLibrary.java -exec

4. 记录 #

Mon, 01 Jan 0001 00:00:00 +0000

example #

1. 导入需要的依赖包 #

<!-- https://mvnrepository.com/artifact/net.java.dev.jna/jna -->
<dependency>
 <groupId>net.java.dev.jna</groupId>
 <artifactId>jna</artifactId>
 <version>5.13.0</version>
</dependency>

2. 编写代码 #

The following program loads the local C standard library implementation and uses it to call the printf function.
Note: The following code is portable and works the same on Windows and POSIX (Linux / Unix / macOS) platforms.

Mon, 01 Jan 0001 00:00:00 +0000

example #

1. 写一段包含C方法实现的java代码 #

// Save as HelloJNI.java
public class HelloJNI{
 static {
 // Load native library hello.dll (Windows) or libhello.so (Unixes) at runtime
 // This library contains a native method called sayHello()
 System.loadLibrary("hello");
 }
 // Declare an instance native method sayHello() which receives no parameter and returns void
 private native void sayHello();
 public static void main(String[] args){
 // Create an instance and invoke the native method
 new HelloJNI().sayHello();
 }
}

The static initializer invokes System.loadLibrary() to load the native library “hello” (which contains a native method called sayHello()) during the class loading. It will be mapped to “hello.dll” in Windows; or “libhello.so” in Unixes/Mac OS X. This library shall be included in Java’s library path (kept in Java system variable java.library.path). You could include the library into Java’s library path via VM argument -Djava.library.path=/path/to/lib. The program will throw a UnsatisfiedLinkError if the library cannot be found in runtime.

Mon, 01 Jan 0001 00:00:00 +0000

AQS 内部结构 #

内部类Node节点代码

代码示例

static final class Node {
 /** Marker to indicate a node is waiting in shared mode */
 static final Node SHARED = new Node();
 /** Marker to indicate a node is waiting in exclusive mode */
 static final Node EXCLUSIVE = null;

 /** waitStatus value to indicate thread has cancelled */
 static final int CANCELLED = 1;
 /** waitStatus value to indicate successor's thread needs unparking */
 static final int SIGNAL = -1;
 /** waitStatus value to indicate thread is waiting on condition */
 static final int CONDITION = -2;
 /**
 * waitStatus value to indicate the next acquireShared should
 * unconditionally propagate
 */
 static final int PROPAGATE = -3;

 /**
 * Status field, taking on only the values:
 * SIGNAL: The successor of this node is (or will soon be)
 * blocked (via park), so the current node must
 * unpark its successor when it releases or
 * cancels. To avoid races, acquire methods must
 * first indicate they need a signal,
 * then retry the atomic acquire, and then,
 * on failure, block.
 * CANCELLED: This node is cancelled due to timeout or interrupt.
 * Nodes never leave this state. In particular,
 * a thread with cancelled node never again blocks.
 * CONDITION: This node is currently on a condition queue.
 * It will not be used as a sync queue node
 * until transferred, at which time the status
 * will be set to 0. (Use of this value here has
 * nothing to do with the other uses of the
 * field, but simplifies mechanics.)
 * PROPAGATE: A releaseShared should be propagated to other
 * nodes. This is set (for head node only) in
 * doReleaseShared to ensure propagation
 * continues, even if other operations have
 * since intervened.
 * 0: None of the above
 *
 * The values are arranged numerically to simplify use.
 * Non-negative values mean that a node doesn't need to
 * signal. So, most code doesn't need to check for particular
 * values, just for sign.
 *
 * The field is initialized to 0 for normal sync nodes, and
 * CONDITION for condition nodes. It is modified using CAS
 * (or when possible, unconditional volatile writes).
 */
 volatile int waitStatus;

 /**
 * Link to predecessor node that current node/thread relies on
 * for checking waitStatus. Assigned during enqueuing, and nulled
 * out (for sake of GC) only upon dequeuing. Also, upon
 * cancellation of a predecessor, we short-circuit while
 * finding a non-cancelled one, which will always exist
 * because the head node is never cancelled: A node becomes
 * head only as a result of successful acquire. A
 * cancelled thread never succeeds in acquiring, and a thread only
 * cancels itself, not any other node.
 */
 volatile Node prev;

 /**
 * Link to the successor node that the current node/thread
 * unparks upon release. Assigned during enqueuing, adjusted
 * when bypassing cancelled predecessors, and nulled out (for
 * sake of GC) when dequeued. The enq operation does not
 * assign next field of a predecessor until after attachment,
 * so seeing a null next field does not necessarily mean that
 * node is at end of queue. However, if a next field appears
 * to be null, we can scan prev's from the tail to
 * double-check. The next field of cancelled nodes is set to
 * point to the node itself instead of null, to make life
 * easier for isOnSyncQueue.
 */
 volatile Node next;

 /**
 * The thread that enqueued this node. Initialized on
 * construction and nulled out after use.
 */
 volatile Thread thread;

 /**
 * Link to next node waiting on condition, or the special
 * value SHARED. Because condition queues are accessed only
 * when holding in exclusive mode, we just need a simple
 * linked queue to hold nodes while they are waiting on
 * conditions. They are then transferred to the queue to
 * re-acquire. And because conditions can only be exclusive,
 * we save a field by using special value to indicate shared
 * mode.
 */
 Node nextWaiter;

 /**
 * Returns true if node is waiting in shared mode.
 */
 final boolean isShared() {
 return nextWaiter == SHARED;
 }

 /**
 * Returns previous node, or throws NullPointerException if null.
 * Use when predecessor cannot be null. The null check could
 * be elided, but is present to help the VM.
 *
 * @return the predecessor of this node
 */
 final Node predecessor() throws NullPointerException {
 Node p = prev;
 if (p == null)
 throw new NullPointerException();
 else
 return p;
 }

 Node() { // Used to establish initial head or SHARED marker
 }

 Node(Thread thread, Node mode) { // Used by addWaiter
 this.nextWaiter = mode;
 this.thread = thread;
 }

 Node(Thread thread, int waitStatus) { // Used by Condition
 this.waitStatus = waitStatus;
 this.thread = thread;
 }
}

整体结构图

Mon, 01 Jan 0001 00:00:00 +0000

Intro(HashMap) #

hello hashmap
- 构造器 #
```
public HashMap(int initialCapacity, float loadFactor) {
 if (initialCapacity < 0)
 throw new IllegalArgumentException("Illegal initial capacity: " +
 initialCapacity);
 if (initialCapacity > MAXIMUM_CAPACITY)
 initialCapacity = MAXIMUM_CAPACITY;
 if (loadFactor <= 0 || Float.isNaN(loadFactor))
 throw new IllegalArgumentException("Illegal load factor: " +
 loadFactor);
 this.loadFactor = loadFactor;
 this.threshold = tableSizeFor(initialCapacity);
}

/**
 * Constructs an empty <tt>HashMap</tt> with the specified initial
 * capacity and the default load factor (0.75).
 *
 * @param initialCapacity the initial capacity.
 * @throws IllegalArgumentException if the initial capacity is negative.
 */
public HashMap(int initialCapacity) {
 this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * Constructs an empty <tt>HashMap</tt> with the default initial capacity
 * (16) and the default load factor (0.75).
 */
public HashMap() {
 this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
```
- 初始容量 #
  
  实际是求取一个整形数值的最接近 ${\color{red}2^{n}}$ 的值。
  
  可以通过以下方法获取：
  $2^{0} < x <= 2^{1}-1$ $\hspace{5em} [00000000\quad00000000\quad00000000\quad0000000{\color{red}1}] - [00000000\quad00000000\quad00000000\quad0000000{\color{red}1}]$
  $2^{1} < x <= 2^{2}-1$ $\hspace{5em} [00000000\quad00000000\quad00000000\quad000000{\color{red}10}] - [00000000\quad00000000\quad00000000\quad000000{\color{red}11}]$
  $2^{2} < x <= 2^{3}-1$ $\hspace{5em} [00000000\quad00000000\quad00000000\quad00000{\color{red}100}] - [00000000\quad00000000\quad00000000\quad00000{\color{red}111}]$
  $2^{3} < x <= 2^{4}-1$ $\hspace{5em} [00000000\quad00000000\quad00000000\quad0000{\color{red}1000}] - [00000000\quad00000000\quad00000000\quad0000{\color{red}1111}]$
  $2^{4} < x <= 2^{5}-1$ $\hspace{5em} [00000000\quad00000000\quad00000000\quad000{\color{red}10000}] - [00000000\quad00000000\quad00000000\quad000{\color{red}11111}]$
  $\hspace{2.5em}\vdots$
  $2^{28} < x <= 2^{29}-1$ $\hspace{4.3em} [000{\color{red}10000\quad00000000\quad00000000\quad00000000}] - [000{\color{red}11111\quad11111111\quad11111111\quad11111111}]$
  $2^{29} < x <= 2^{30}-1$ $\hspace{4.3em} [00{\color{red}100000\quad00000000\quad00000000\quad00000000}] - [00{\color{red}111111\quad11111111\quad11111111\quad11111111}]$
  $2^{30} < x <= 2^{31}-1$ $\hspace{4.3em} [0{\color{red}1000000\quad00000000\quad00000000\quad00000000}] - [0{\color{red}1111111\quad11111111\quad11111111\quad11111111}]$

Mon, 01 Jan 0001 00:00:00 +0000

java 中异常返回时机 #

example #

// finally语句在return语句执行之后return返回之前执行的
public int exp1(){
 int b = 20;
 try {
 System.out.println("try block");
 return b += 80;
 }
 catch (Exception e) {
 System.out.println("catch block");
 }
 finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 }
 return b;
}

output:
try block
finally block
b>25, b = 100
100

// finally块中的return语句会覆盖try块中的return返回
public int exp2() {
 int b = 20;
 try {
 System.out.println("try block");
 return b += 80;
 } catch (Exception e) {
 System.out.println("catch block");
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 return 200;
 }
 // return b;
}

output:
try block
finally block
b>25, b = 100
200

// 如果finally语句中没有return语句覆盖返回值，那么原来的返回值可能因为finally里的修改而改变也可能不变
public int exp3() {
 int b = 20;
 try {
 System.out.println("try block");
 return b += 80;
 } catch (Exception e) {
 System.out.println("catch block");
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 b = 150;
 }
 return 2000;
}

output:
try block
finally block
b>25, b = 100
100

public Map<String, String> exp3_1() {
 Map<String, String> map = new HashMap();
 map.put("KEY", "INIT");
 try {
 map.put("KEY", "TRY");
 return map;
 }
 catch (Exception e) {
 map.put("KEY", "CATCH");
 }
 finally {
 map.put("KEY", "FINALLY");
 map = null;
 }
 return map;
}

output:
FINALLY

// try块里的return语句在异常的情况下不会被执行(参考中的例子有错误)
public int exp4() {
 int b = 20;
 try {
 System.out.println("try block");
 b = b / 0;
 return b += 80;
 } catch (Exception e) {
 b += 15;
 System.out.println("catch block");
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 b += 50;
 }
 return 204;
}

output:
try block
catch block
finally block
b>25, b = 35
204

// 当发生异常后，catch中的return执行情况与未发生异常时try中return的执行情况完全一样
public int exp5() {
 int b = 20;
 try {
 System.out.println("try block");
 b = b /0;
 return b += 80;
 } catch (Exception e) {
 System.out.println("catch block");
 return b += 15;
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 b += 50;
 }
 //return b;
}

output:
try block
catch block
finally block
b>25, b = 35
35

// catch中的return先计算然后传值到finally中最后finally直接返回，也符合情况1。
public int exp6() {
 int b = 20;
 try {
 System.out.println("try block");
 b = b /0;
 return b += 80;
 } catch (Exception e) {
 System.out.println("catch block");
 return b += 15;
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 return b += 50;
 }
 //return b;
}

output:
try block
catch block
finally block
b>25, b = 35
85

字节码查看异常执行顺序 #

reference #

Mon, 01 Jan 0001 00:00:00 +0000

IO 简介 #

IO指以内存为中心，外部到内存为input，内存到外部为output
按方向分为输入流和输出流.按传输单位分为字节流和字符流。按形态分为原始流及缓冲流。
IO流的本质是数据传输，并且流是单向的。

获取文件的几种方式 #

@Test
public void getFile(){
 // 1，直接获取项目路径下的文件
 File file = new File("pom.xml");
 // 2，获取resources里面的文件
 File file1 = new File("src/main/resources/log4j.properties");

 // 3，类加载器加载文件方式1,多一个resolveName()方法，用来追加包名。而类加载器直接在加载类的根目录加载。
 URL resource = this.getClass().getResource("../res/yqgz.cer");
 // 4，类加载器加载文件方式2
 URL resource1 = this.getClass().getClassLoader().getResource("_base/io/res/yqgz.cer");
}

字节流 #

InputStream #

FileInputStream

@Test
public void demoWithoutTryWithResource(){
 // URL resource = this.getClass().getClassLoader().getResource("../../yqgz.cer");
 // File file = new File(resource.toURI());
 URL resource = this.getClass().getResource("../../res/yqgz.cer");
 File file = new File(resource.getFile());
 InputStream ins = null;
 ByteArrayOutputStream byteArrayOutputStream;
 try {
 System.out.println(file.isFile() ? file.length() : 0);
 ins = new FileInputStream(file);
 byteArrayOutputStream = new ByteArrayOutputStream();
 byte[] data = new byte[1024];
 int len = 0;
 while((len = ins.read(data)) != -1){
 byteArrayOutputStream.write(data, 0, len);
 }
 System.out.println(byteArrayOutputStream.toByteArray().length);
 } catch (Exception e) {
 e.printStackTrace();
 } finally {
 if(ins != null){
 try {
 ins.close();
 } catch (IOException e) {
 throw new RuntimeException(e);
 }
 }
 // 或者直接关闭，异常包括空指针。省略if空判断。
 // try {
 // ins.close();
 // } catch (Exception e) {
 // throw new RuntimeException(e);
 // }
 }
}

@Test
public void demoWithTryWithResource(){
 URL resource = this.getClass().getResource("../../res/yqgz.cer");
 File file = new File(resource.getFile());
 try (InputStream ins = new FileInputStream(file)){
 // file.length() 与后面读取到的字节数一致。都是1583
 System.out.println(file.isFile() ? file.length() : 0);
 byte[] data = new byte[1024 * 2];
 int count = ins.read(data);
 System.out.println(count);
 } catch (Exception e) {
 e.printStackTrace();
 }
}

FilterInputStream

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Scalable IO in Java) #
1. Scalable network services
2. Event-driven processing
3. Reactor pattern
  1. Basic version
  2. Multithreaded versions
  3. Other variants
4. Walkthrough of java.nio nonblocking IO APIs
- Network Services #
  
  Web services, Distributed Objects, etc. Most have same basic structure:
  Read request ➠ Decode request ➠ Process service ➠ Encode reply ➠ Send reply
  " But differ in nature and cost of each step XML parsing, File transfer, Web page generation, computational services, …

Mon, 01 Jan 0001 00:00:00 +0000

Intro(ZERO COPY) #

Caution
下述零拷贝内容翻译自 Efficient data transfer through zero copy
- 概览 #
  
  许多 Web 应用程序提供大量的就静态内容，这相当于从从磁盘读取数据并将完全相同的数据写回响应的 socket。此活动似乎只需要相对较少的 CPU 活动，但是在某种程度上是低效的。内核从磁盘读取数据，并将其跨越内核用户边界推送到应用程序，然后再跨越一次推送到需要被写的 socket。实际上，应用程序充当一个低效的中介，将数据从磁盘文件传输到 socket。
  
  每一次数据从用户内核空间移动的时候，必须被复制，这会消耗 CPU 循环和内存带宽。幸运的是，你可以通过一个叫 ZERO COPY 零拷贝 的技术减少这些复制。使用零拷贝的应用程序请求内核直接将数据从磁盘文件复制到 socket，而不需要经过应用程序。零拷贝极大的提高了应用程序的性能和减少了用户内核空间上下文切换的次数。
  
  Java 类库通过java.nio.channels.FileChannel中的transferTo()方法在 Linux 和 Unix 系统上支持零拷贝。你可以使用transferTo()方法直接传输数据从被调用的 channel 到另外一个可写的 channel，而不需要数据流经应用程序。这篇文章首先演示了通过传统复制进行简单文件传输所带来的开销，然后展示了使用transferTo()的零拷贝技术如何获得更好地性能。
- 数据传输：传统方式 #
  
  思考一种场景：从文件中读取数据并通过网络将数据传输到另一个程序。（此场景描述了许多服务器应用程序的行为，包括提供静态内容的 Web 应用程序，FTP 服务器，邮件服务器等。）该操作的核心在清单1 中的两个调用中。或者下载完整的样例代码
  
  清单1，拷贝字节从文件到socket #
```
File.read(fileDesc, buf, len);
Socket.send(socket, buf, len);
```
  虽然清单1 在概念上很简单，但在内部，拷贝操作需要在用户模式和内核模式之间进行四个上下文切换，并在操作完成之前将数据复制四次。
  下图显示了数据在内部移动从一个文件到 socket

Mon, 01 Jan 0001 00:00:00 +0000

Intro(PROPERTIES) #
- System.properties() #
  
  在System类中有 initProperties(Properties props); native 方法。在C代码 GetJavaProperties(env);中会获取到一些props。这个方法的实现在 java_props_md.c中。在 626 行setProxyProperties(&sprops); 会进行系统代理的设置。继续调用到 java_props_maxosx.c中。主要会使用 macosx SDK 中的 SCDynamicStoreCopyProxies(_:) 【函数调用 C Demo】，获取当前系统中的网络代理设置。需要注意与环境变量进行区分。
- Prop对unicode编码的处理 #
  
  在查看 Spring国际化(i18n) 和 ResourceBundle 相关的代码的时候，发现都会用到Properties类相关的处理。而且对于 unicode 的处理都是由这个类去自动处理的。所以跟踪了相关代码，对这部分做一个记录。
  
  大概的原理是：
  1). 在 java.util.Properties#load0 读取每一行，通过=、: 分割每一个key和value。在最后对key和value分别进行转换。
  2). 调用 java.util.Properties#loadConvert 进行转换操作。转换过程：碰见\u将后面的四位使用算法转换成十进制数字，当成一个char类型的字符。在原来的数组上面进行覆盖。
  
  相关算法如下图：
  
  Caution
  比如将\u4f60转成字符char20320. 过程如下：
  
  第一个字符'4'，进到循环后，执行(value << 4) + aChar - '0'; 此时 value = 0，左移四位还是0 ，再加上字符'4'表示的整型值 4 (正好是当前字符'4'与'0'字符的差值) 最后value = 0100;
  第二个字符'f'，进来后执行(value << 4) + 10 + aChar - 'a'; 此时将上一步得到的value 左移四位，得到0100 0000 然后与实际值('f'表示的整型值 15 1111)想加，即得到0100 1111。
  依此类推：最终得到的value = 0100 1111 0110 0000 = 20320。

Mon, 01 Jan 0001 00:00:00 +0000

TCP #
UDP #
InetAddress #
- 流程解析 #
  
  根据域名实例化一个InetAddress对象的流程解析。
  比如：InetAddress byName = InetAddress.getByName("wtfu.site");。如果是域名的话，会涉及到系统调用getaddrinfo.里面包括DNS解析。
  
  1. getAllByName(String host, InetAddress reqAddr)
  2. 不属于ip地址的话，会继续进入到getAllByName0()
  3. addresses = getAddressesFromNameService(host, reqAddr);
  4. addresses = nameService.lookupAllHostAddr(host);
  5. impl.lookupAllHostAddr(host); // impl为Inet6AddressImpl类型，且lookupAllHostAddr为native方法。
  6. 定位到c源码后如下：可以看到关键的getaddrinfo系统调用。
```
//src/java.base/unix/native/libnet/Inet6AddressImpl.c
JNIEXPORT jobjectArray JNICALL
Java_java_net_Inet6AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this,
 jstring host, jint characteristics) {
 error = getaddrinfo(hostname, NULL, &hints, &res);
}
```
- 测试系统调用流程 #
  1. 编写样例代码

Mon, 01 Jan 0001 00:00:00 +0000

Intro(String) #

内存布局 #

intern() #

String.intern()方法表示获取一个字符串对象的值在常量池中的引用。如果常量池中存在，则直接返回引用。如果不存在，常量池创建并返回引用。

不同jdk版本创建并返回引用是有区别的：
JDK1.6，不存在则在永久代字符串常量池创建等值字符串，
JDK1.6之后，在堆区字符串常量池创建的是堆中String obj的引用。参考1，参考2

另外字符串常量池的实现是 C++ 中的hashtable。

String s = new String("ABC") 这行单纯代码层面来说，只创建一个对象。如果包含类加载的过程，有可能会创建两个，一个在常量池中，一个在堆里面。堆里面的引用常量池中的value。参考

不要使用JUnit之类的工具测试intern方法，有可能会有误差，详细解释查看case3

/**
 * Returns a canonical representation for the string object.
 * <p>
 * A pool of strings, initially empty, is maintained privately by the
 * class {@code String}.
 * <p>
 * When the intern method is invoked, if the pool already contains a
 * string equal to this {@code String} object as determined by
 * the {@link #equals(Object)} method, then the string from the pool is
 * returned. Otherwise, this {@code String} object is added to the
 * pool and a reference to this {@code String} object is returned.
 * <p>
 * It follows that for any two strings {@code s} and {@code t},
 * {@code s.intern() == t.intern()} is {@code true}
 * if and only if {@code s.equals(t)} is {@code true}.
 * <p>
 * All literal strings and string-valued constant expressions are
 * interned. String literals are defined in section 3.10.5 of the
 * <cite>The Java&trade; Language Specification</cite>.
 *
 * @return a string that has the same contents as this string, but is
 * guaranteed to be from a pool of unique strings.
 */
public native String intern();

测试 #

// source: https://blog.csdn.net/tyyking/article/details/82496901
String str2 = new String("str") + new String("01");
str2.intern(); 
String str1 = "str01";
System.out.println(str2 == str1);

// 上述代码在JDK1.6及以后版本表现不同。假设str2的地址为`String@725`
// 1.6 调用`str2.intern()`会在永久代字符串常量池中复制等值字符串String@825，然后返回引用String@825。给str1赋值的时候发现字符串常量池有'str01'，则将引用String@825给str1。
// >1.6 调用`str2.intern()`会在堆区字符串常量池中放置对象str2的引用String@725，然后返回引用String@725。给str1赋值的时候发现字符串常量池有'str01'，则将引用String@725给str1。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(THREAD POOL) #

ThreadPoolExecutor.java

线程池解决了两个不同的问题:
1). 在执行大量异步任务时，由于减少了每个任务的调用开销，它们通常提供改进的性能;
2). 在执行一组任务时，它们提供了一种绑定和管理资源(包括线程)的方法。每个ThreadPoolExecutor还维护一些基本统计信息，例如已完成任务的数量。

核心和最大线程数：
线程池会根据核心线程数和最大线程数自动调节池中的线程数量。当一个任务提交的时候，如果少于核心线程数的线程正在运行，则一个新的线程被创建用来处理当前的任务请求（即使其它线程空闲）。如果运行的线程数在核心线程和最大线程之间，则优先队列任务，如果队列满了，就创建线程。

队列(BlockingQueue)：
队列用来传输和持有提交的任务，它的使用和线程池中的线程数互相作用。有以下几点：
a). 小于核心线程数的线程正在运行，则创建新线程。
b). 大于核心线程数，则入队列
c). 入队列不成功(满了)，但是小于最大线程数，则创建新线程。
d). 其他情况(队列满了且达到最大线程数)，则拒绝执行。

对于队列的选择，一般有三种情况：
SynchronousQueue：这个阻塞队列的特性是，每插入一个元素，必须消费之后才可以继续插入。而且可以支持公平和非公平选择，用于对等待的生产者和消费者线程进行排序。所以使用这种队列，如果在生产速度大于消费速度，则通过queue.offer()方法放不进去，只能创建新线程进行处理了。所以线程数可能无限增长。

LinkedBlockingQueue：偏无界队列（Integer.MAX_VALUE）
ArrayBlockingQueue：有边界

钩子方法：beforeExecute(Thread, Runnable) 、afterExecute(Runnable, Throwable)

按需加载：prestartCoreThread(启动一个核心线程)、prestartAllCoreThreads(启动所有核心线程)
- 属性 #
  
  ctl 是一个原子整数类型，里面主要体现两个属性：workerCount: 有效的线程数量、runState: 是否运行，关闭等状态。
  为了将这两个属性放在一个数字里面控制，我们限制了workerCount的值为 ${\color{blue}(2^{29} - 1 )}$(大约5亿个线程)，而不是 ${\color{blue} (2^{31} - 1)}$(大约20亿)
  
  workerCount：允许开始执行的线程数。因为一些原因，这个值可能和实际存活的线程数暂时不一致，比如：当要求线程池创建线程的时候失败了，或者在terminated之前退出线程依旧在执行任务。
  
  runState：线程池状态
  RUNNING: 可以接受新的任务并且处理队列中的任务
  SHUTDOWN: 不接受新的任务但是会处理队列中的任务
  STOP: 不接受新的任务，不处理队列中的任务，并且给中断正在执行的线程
  TIDYING: 所有任务都已种植，workerCount 为零，转换到 TIDYING 状态的线程将执行terminated()钩子方法。
  TERMINATED: terminated()钩子方法执行完毕。
  
  为了允许有序比较，这些值之间的数字顺序很重要。runState单调地随时间增加，但不需要达到每个状态。转换过程：
  
  Caution

Mon, 01 Jan 0001 00:00:00 +0000

comming soon…

redis_lock #

zookeeper_lock #

Mon, 01 Jan 0001 00:00:00 +0000

comming soon…

1 #

2 #

Mon, 01 Jan 0001 00:00:00 +0000

comming soon…

1 #

2 #

3 #

Mon, 01 Jan 0001 00:00:00 +0000

2PC(两阶段提交方案/XA方案) #

TCC(Try Confirm Cancel) #

本地消息表 #

可靠消息最终一致性方案 #

最大努力通知方案 #

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

comming soon…

Mon, 01 Jan 0001 00:00:00 +0000

JUL(java util logging) #

配置模板 #

vim $(dirname $(which java))/../jre/lib/logging.properties
vim ``dirname $(which java)``/../jre/lib/logging.properties

############################################################
# Default Logging Configuration File
#
# You can use a different file by specifying a filename
# with the java.util.logging.config.file system property.
# For example java -Djava.util.logging.config.file=myfile
############################################################

############################################################
# Global properties
############################################################

# "handlers" specifies a comma separated list of log Handler
# classes. These handlers will be installed during VM startup.
# Note that these classes must be on the system classpath.
# By default we only configure a ConsoleHandler, which will only
# show messages at the INFO and above levels.
handlers= java.util.logging.ConsoleHandler

# To also add the FileHandler, use the following line instead.
#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler

# Default global logging level.
# This specifies which kinds of events are logged across
# all loggers. For any given facility this global level
# can be overriden by a facility specific level
# Note that the ConsoleHandler also has a separate level
# setting to limit messages printed to the console.
.level= INFO

############################################################
# Handler specific properties.
# Describes specific configuration info for Handlers.
############################################################

# default file output is in user's home directory.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# Limit the message that are printed on the console to INFO and above.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# Example to customize the SimpleFormatter output format
# to print one-line log message like this:
# <level>: <log message> [<date/time>]
#
# java.util.logging.SimpleFormatter.format=%4$s: %5$s [%1$tc]%n

############################################################
# Facility specific properties.
# Provides extra control for each logger.
############################################################
com.xyz.foo.level = SEVERE

使用 #

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

引入消息队列后如何保证高可用性 #

持久化、事务、签收、以及带复制的 Leavel DB + zookeeper 主从集群搭建

异步投递 Async send #

对于一个慢消费者，使用同步有可能造成堵塞，消息消费较慢时适合用异步发送消息 activemq 支持同步异步发送的消息，默认异步。当你设定同步发送的方式和未使用事务的情况下发持久化消息，这时是同步的。如果没有使用事务，且发送的是持久化消息，每次发送都会阻塞一个生产者直到 broker 发回一个确认，这样做保证了消息的安全送达，但是会阻塞客户端，造成很大延时。在高性能要求下，可以使用异步提高producer 的性能。但会消耗较多的client 端内存，也不能完全保证消息发送成功。在 useAsyncSend = true 情况下容忍消息丢失通过回调感知消息正常到达。

延迟投递和定时投递 #

ActiveMQ 的消息重试机制 #

超过6次标记为有毒消息，broker将消息放入死信队列

如何保证消息不被重复消费，幂等性的问题 #

如果消息是做数据库的插入操作，给这个消息一个唯一的主键，那么就算出现重复消费的情况，就会导致主键冲突，避免数据库出现脏数据。如果不是，可以用redis 等的第三方服务，给消息一个全局 id ，只要消费过的消息，将 id ，message 以 K-V 形式写入 redis ，那消费者开始消费前，先去 redis 中查询有没消费的记录即可。

Reference #

https://note.youdao.com/web/#/file/WEB1277b8f2da90c224c2c7a6a3175b2ea5/note/54AA1E33A4AE4AC9BA77EAA4384370B4/

Mon, 01 Jan 0001 00:00:00 +0000

hello kafka

Mon, 01 Jan 0001 00:00:00 +0000

Intro(MyBatis | underlying) #
- 要点 #
  
  Attention
  1. mapper 接口定义的语句怎么生成的? configuration解析后会生成一个 MappedStatement{id:""}. 并且将ID 和 ms 放入 configuration 中的 mappedStatements 中。
  2. 执行顺序是什么样的？
  3. 缓存是如何处理的？
  4. 拦截器原理。
- Mapper接口的实现 #
  
  通过MapperRegistry里面的 map 类型的 knowMappers 根据 type 获取到 MapperProxyFactory ,进而调用return mapperProxyFactory.newInstance(sqlSession);返回一个 mapper 接口代理对象。
  上述代理对象中使用的 InvocationHandler 叫 MapperProxy，里面 invoke() 的实现是将方法包装成一个MapperMethod mm 存放在MapperMethodInvoker mmi 里面，并会进行缓存，然后调用 mmi 里面的 invoke，进而执行到 mm.execute()方法，内部通过执行器拿到结果返回。
- 拦截器实现 #
  
  插件文档
  
  对于拦截器来说，主要在以下接口工作：Executor，ParameterHandler，ResultSetHandler，StatementHandler。
  
  涉及的主要类有，实现了 JDK 代理中 InvocationHandler 的 Plugin，以及 Interceptor接口。
  
  大致调用流程：
  1. 创建对象：executor = new CachingExecutor(executor);
  2. 将所有拦截器进行插件化：executor = (Executor) interceptorChain.pluginAll(executor);内部实现如下：
  2.1. 在 Plugin 代码中第 13 行，将 executor 对象，以及拦截器对象进行包装。如果拦截器注解签名方法中需要拦截的类在目标对象上的话，返回代理对象。如果不是，则返回target就行。
  2.2. 返回的代理对象是实现了目标对象上面的接口，此处也就是 executor，所以可以强转。
  2.3. 因为在 InterceptorChain 第六行循环中，需要注意第一次循环后返回的target可能是代理对象，下一次循环中可能返回代理对象 去代理 代理对象的情况。如下图：
  
  3. 使用对象：内部的执行流程可以画图表示，涉及 JDK 代理。
  如果在外部调用刚才插件化的代理对象的话，则首先调用到 invoke() 方法中，然后根据签名map 判断是否当前方法是拦截器需要拦截的方法，根据判断结果选择是进入拦截器拦截方法 intercept(Invocation invocation)，还是直接调用目标对象（此处的目标对象有可能是还是一个代理对象）。

Mon, 01 Jan 0001 00:00:00 +0000

hello

1、主从复制 https://www.cnblogs.com/gl-developer/p/6170423.html

2、读写分离 https://blog.csdn.net/liu976180578/article/details/77684583

3，分库分表 https://blog.csdn.net/trigl/article/details/50968079

4，多数据源

Mon, 01 Jan 0001 00:00:00 +0000

分析工具 #

通过工具进行分析，结合书中的概念学习innodb存储引擎。

.frm 解析工具如下：
dbsake(a(s)wiss-(a)rmy-(k)nif(e) for MySQL), github
mysqlfrm, download archive, mysql-utilities pdf
frm-parser

.ibd 解析工具有：
innodb-java-reader
innodb_ruby
- frm-parser #
  
  Note
  开源仓库
  使用frm解析工具对/tmp/mysql/demos/record_format_demo.frm ,进行分析，解析结果如下。
  
  Caution
  1). 对代码稍作修改，使用cmake构建，修改文件位置为绝对路径，show_tables(),show_db()函数中的文件位置也需要改变。
- dbsake #
  
  Note
  参考官方文档进行安装测试。自定义安装位置,比如：cd /usr/local/bin
  curl -s get.dbsake.net > dbsake
  chmod u+x dbsake
  dbsake -?
- mysql-utilities #
  
  Note

Mon, 01 Jan 0001 00:00:00 +0000

BIN目录可执行文件 #

查看目录 #

# tree -L 3 /usr/local/opt/mysql@5.7/bin/

/usr/local/opt/mysql@5.7/bin/
├── innochecksum
├── mysql
├── mysql.server -> ../support-files/mysql.server
├── mysql_client_test
├── mysql_client_test_embedded
├── mysql_install_db
├── mysql_plugin
├── mysql_secure_installation
├── mysql_upgrade
├── mysqladmin
├── mysqlbinlog
├── mysqld
├── mysqld_multi
├── mysqld_safe
├── mysqldump
├── mysqldumpslow
├── mysqlshow
├── mysqltest
└── ...

启动Mysql服务器程序 #

Unix里启动服务器程序 #
- mysqld
mysqld这个可执行文件代表mysql服务器程序，运行这个可执行文件就可以直接启动一个服务进程，但是这个命令不常用，一般会结合其他脚本使用。比如下面这个。
- mysqld_safe
mysqld_safe是一个可执行脚本，它会嫁接调用mysqld。而且还顺带启动了一个监控进程。这个监控进程会在服务器挂了的时候重新启动它。另外，使用脚本启动的时候，它会将服务器的出错信息和其他诊断信息重新定向到某个文件中，产生错误日志，这样可以方便我们找出发生错误的原因。

Mon, 01 Jan 0001 00:00:00 +0000

hello

Mon, 01 Jan 0001 00:00:00 +0000

字符集和比较规则简介 #

字符集简介 #

我们知道在计算机中只能存储二进制数据，那该怎么存储字符串呢？当然是建立字符与二进制数据的映射关系了，建立这个关系最起码要搞清楚两件事儿：

你要把哪些字符映射成二进制数据？（也就是界定清楚字符范围）
怎么映射？将一个字符映射成二进制数据的过程叫编码，将一个二进制数据映射到一个字符的过程叫解码

人们抽象出一个字符集的概念来描述某个字符范围的编码规则。比方说我们来自定义一个名称为 xiaohaizi的字符集，它包括的字符范围和编码规则如下：

包含的字符’a’、‘b’、‘A’、‘B’
编码的规则如下：

采用一个字节编码一个字符的形式，字符和字节的映射关系如下： ‘a’ -> 00000001 (十六进制：0x01) ‘b’ -> 00000010 (十六进制：0x02) ‘A’ -> 00000011 (十六进制：0x03) ‘B’ -> 00000100 (十六进制：0x04)

有了xiaohaizi 字符集，我们就可以用二进制形式表示一些字符串了，下边是一些字符串用 xiaohaizi字符编码后的二进制表示:

'bA' -> 0000001000000011 (十六进制：0x0203)
'baB' -> 000000100000000100000100 (十六进制：0x020104)
'cd' -> 无法表示，字符集xiaohaizi不包含字符'c'和'd'

比较规则简介 #

在我们确定了 xiaohaizi 字符集表示字符的范围以及编码规则后，怎么比较两个字符的大小呢？最容易想到的就是直接比较这两个字符对应的二进制编码的大小，比方说字符 ‘a’ 的编码为 0x01 ，字符 ‘b’ 的编码为 0x02 ，所以 ‘a’ 小于 ‘b’ ，这种简单的比较规则也可以被称为二进制比较规则，英文名为binary collation 。二进制比较规则是简单，但有时候并不符合现实需求，比如在很多场合对于英文字符我们都是不区分大小写的，也就是说 ‘a’ 和 ‘A’ 是相等的，在这种场合下就不能简单粗暴的使用二进制比较规则了，这时候我们可以这样指定比较规则：

Mon, 01 Jan 0001 00:00:00 +0000

准备工作 #

Comment
到现在为止， MySQL 对于我们来说还是一个黑盒，我们只负责使用客户端发送请求并等待服务器返回结果，表中的数据到底存到了哪里？以什么格式存放的？ MySQL 是以什么方式来访问的这些数据？我们前边唠叨请求处理过程的时候提到过， MySQL 服务器上负责对表中数据的读取和写入工作的部分是 存储引擎 ，而服务器又支持不同类型的存储引擎，比如 InnoDB 、 MyISAM 、 Memory 啥的，不同的存储引擎一般是由不同的人为实现不同的特性而开发的，真实数据在不同存储引擎中存放的格式一般是不同的，甚至有的存储引擎比如 Memory 都不用磁盘来存储数据，也就是说关闭服务器后表中的数据就消失了。由于 InnoDB 是 MySQL 默认的存储引擎，也是我们最常用到的存储引擎，我们也没有那么多时间去把各个存储引擎的内部实现都看一遍，所以本集要唠叨的是使用 InnoDB 作为存储引擎的数据存储结构。
InnoDB架构 #

Attention
https://dev.mysql.com/doc/refman/5.7/en/innodb-architecture.html
InnoDB页简介 #

InnoDB 是一个将表中的数据存储到磁盘上的存储引擎，所以即使关机后重启我们的数据还是存在的。而真正处理数据的过程是发生在内存中的，所以需要把磁盘中的数据加载到内存中，如果是处理写入或修改请求的话，还需要把内存中的内容刷新到磁盘上。而我们知道读写磁盘的速度非常慢，和内存读写差了几个数量级，所以当我们想从表中获取某些记录时， InnoDB 存储引擎需要一条一条的把记录从磁盘上读出来么？不，那样会慢死，InnoDB 采取的方式是：将数据划分为若干个页，以页作为磁盘和内存之间交互的基本单位，InnoDB中页的大小一般为 16KB: show variables like 'innodb_page_size'; 也就是在一般情况下，一次最少从磁盘中读取16KB的内容到内存中，一次最少把内存中的16KB内容刷新到磁盘中。
InnoDB行格式 #

我们平时是以记录为单位来向表中插入数据的，这些记录在磁盘上的存放方式(ROW_FORMAT)也被称为 行格式 或者 记录格式 。设计 InnoDB 存储引擎的大叔们到现在为止设计了4种不同类型的行格式，分别是:
Compact 、 Redundant(MySQL5.0 之前用的一种行格式) 、Dynamic 和 Compressed 行格式。
随着时间的推移，他们可能会设计出更多的行格式，但是不管怎么变，在原理上大体都是相同的。

Mon, 01 Jan 0001 00:00:00 +0000

不同类型的页简介 #

前边我们简单提了一下页的概念，它是 InnoDB 管理存储空间的基本单位，一个页的大小一般是 16KB 。InnoDB 为了不同的目的而设计了许多种不同类型的页，比如存放表空间头部信息的页，存放Insert Buffer信息的页，存放INODE 信息的页，存放undo 日志信息的页等等等等。当然了，如果我说的这些名词你一个都没有听过，就当我放了个屁吧～不过这没有一毛钱关系，我们今儿个也不准备说这些类型的页，我们聚焦的是那些存放我们表中记录的那种类型的页，官方称这种存放记录的页为 索引（ INDEX ）页 ，鉴于我们还没有了解过索引是个什么东西，而这些表中的记录就是我们日常口中所称的数据，所以目前还是叫这种存放记录的页为 数据页 吧。
数据页结构的快速预览 #

数据页代表的这块 16KB 大小的存储空间可以被划分为多个部分，不同部分有不同的功能，各个部分如图所示：

从图中可以看出，一个 InnoDB 数据页的存储空间大致被划分成了 7 个部分，有的部分占用的字节数是确定的，有的部分占用的字节数是不确定的。下边我们用表格的方式来大致描述一下这7个部分都存储一些啥内容（快速的瞅一眼就行了，后边会详细唠叨的）：
记录在页中的存储 #

在页的7个组成部分中，我们自己存储的记录会按照我们指定的 行格式 存储到 User Records 部分。但是在一开始生成页的时候，其实并没有 User Records 这个部分，每当我们插入一条记录，都会从 Free Space 部分，也就是尚未使用的存储空间中申请一个记录大小的空间划分到 User Records 部分，当 Free Space 部分的空间全部被 User Records 部分替代掉之后，也就意味着这个页使用完了，如果还有新的记录插入的话，就需要去申请新的页了，这个过程的图示如下：

Warning

Mon, 01 Jan 0001 00:00:00 +0000

前情提要 #

prerequirement
前边我们详细唠叨了 InnoDB 数据页的 7 个组成部分，知道了各个数据页可以组成一个 双向链表 ，而每个数据页中的记录会按照主键值从小到大的顺序组成一个 单向链表 ，每个数据页都会为存储在它里边儿的记录生成一个页目录，在单页中通过主键查找某条记录的时候可以 页目录(page-directory) 中使用二分法快速定位到对应的槽，然后再遍历该槽对应分组中的记录即可快速找到指定的记录（如果你对这段话有一丁点儿疑惑，那么接下来的部分不适合你，返回去看一下数据页结构吧）。页和记录的关系示意图如下：

其中页a、页b、页c … 页n 这些页可以不在物理结构上相连，只要通过双向链表相关联即可。
没有索引的查找 #

本集的主题是索引，在正式介绍索引之前，我们需要了解一下没有索引的时候是怎么查找记录的。为了方便大家理解，我们下边先只唠叨搜索条件为对某个列精确匹配的情况，所谓精确匹配，就是搜索条件中用等于 = 连接起的表达式，比如这样：
SELECT [列名列表] FROM 表名 WHERE 列名 = xxx;
- 在一个页中的查找 #
  
  Note
  假设目前表中的记录比较少，所有的记录都可以被存放到一个页中，在查找记录的时候可以根据搜索条件的不同分为两种情况：
  1. 以主键为搜索条件: 这个查找过程我们已经很熟悉了，可以在页目录中使用二分法快速定位到对应的槽，然后再遍历该槽对应分组中的记录即可快速找到指定的记录。
  2. 以其他列作为搜索条件: 对非主键列的查找的过程可就不这么幸运了，因为在数据页中并没有对非主键列建立所谓的页目录，所以我们无法通过二分法快速定位相应的槽。这种情况下只能从最小记录开始依次遍历单链表中的每条记录，然后对比每条记录是不是符合搜索条件。很显然，这种查找的效率是非常低的。
- 在很多页中查找 #
  
  Note

Mon, 01 Jan 0001 00:00:00 +0000

书接上文 #

prerequirement
我们前边详细、详细又详细的唠叨了 InnoDB 存储引擎的 B+ 树索引，我们必须熟悉下边这些结论：
1). 每个索引都对应一棵 B+ 树，B+ 树分为好多层，最下边一层是叶子节点，其余的是内节点。所有用户记录都存储在 B+ 树的叶子节点，所有目录项记录都存储在内节点。
2). InnoDB 存储引擎会自动为主键（如果没有它会自动帮我们添加）建立聚簇索引，聚簇索引的叶子节点包含完整的用户记录。
3). 我们可以为自己感兴趣的列建立二级索引，二级索引的叶子节点包含的用户记录由索引列+主键组成，所以如果想通过二级索引来查找完整的用户记录的话，需要通过回表操作，也就是在通过二级索引找到主键值之后再到聚簇索引中查找完整的用户记录。
4). B+ 树中每层节点都是按照索引列值从小到大的顺序排序而组成了双向链表，而且每个页内的记录（不论是用户记录还是目录项记录）都是按照索引列的值从小到大的顺序而形成了一个单链表。如果是联合索引的话，则页面和记录先按照联合索引前边的列排序，如果该列值相同，再按照联合索引后边的列排序。
5). 通过索引查找记录是从 B+ 树的根节点开始，一层一层向下搜索。由于每个页面都按照索引列的值建立了 Page Directory（页目录），所以在这些页面中的查找非常快。

如果你读上边的几点结论有些任何一点点疑惑的话，那下边的内容不适合你，回过头先去看前边的内容去。
索引的代价 #

Tip
在熟悉了 B+ 树索引原理之后，本篇文章的主题是唠叨如何更好的使用索引，虽然索引是个好东西，可不能乱建，在介绍如何更好的使用索引之前先要了解一下使用这玩意儿的代价，它在空间和时间上都会拖后腿：
空间上的代价：这个是显而易见的，每建立一个索引都要为它建立一棵 B+ 树，每一棵 B+ 树的每一个节点都是一个数据页，一个页默认会占用 16KB 的存储空间，一棵很大的 B+ 树由许多数据页组成，那可是很大的一片存储空间呢。
时间上的代价：每次对表中的数据进行增、删、改操作时，都需要去修改各个 B+ 树索引。而且我们讲过， B+ 树每层节点都是按照索引列的值从小到大的顺序排序而组成了双向链表。不论是叶子节点中的记录，还是内节点中的记录（也就是不论是用户记录还是目录项记录）都是按照索引列的值从小到大的顺序而形成了一个单向链表。而增、删、改操作可能会对节点和记录的排序造成破坏，所以存储引擎需要额外的时间进行一些记录移位，页面分裂、页面回收啥的操作来维护好节点和记录的排序。如果我们建了许多索引，每个索引对应的 B+ 树都要进行相关的维护操作，这还能不给性能拖后腿么？

所以说，一个表上索引建的越多，就会占用越多的存储空间，在增删改记录的时候性能就越差。为了能建立又好又少的索引，我们先得学学这些索引在哪些条件下起作用的。

Mon, 01 Jan 0001 00:00:00 +0000

数据库和文件系统的关系 #

我们知道像 InnoDB 、 MyISAM 这样的存储引擎都是把表存储在磁盘上的，而操作系统用来管理磁盘的那个东东又被称为 文件系统 ，所以用专业一点的话来表述就是：像 InnoDB 、 MyISAM 这样的存储引擎都是把表存储在文件系统上的。当我们想读取数据的时候，这些存储引擎会从文件系统中把数据读出来返回给我们，当我们想写入数据的时候，这些存储引擎会把这些数据又写回文件系统。本章就是要唠叨一下 InnoDB 和 MyISAM 这两个存储引擎的数据如何在文件系统中存储的。
MySQL数据目录 #

MySQL服务器程序在启动时会到文件系统的某个目录下加载一些文件，之后在运行过程中产生的数据也都会存储到这个目录下的某些文件中，这个目录就称为数据目录，我们下边就要详细唠唠这个目录下具体都有哪些重要的东西。
- 数据目录和安装目录的区别 #
  
  Caution
  我们之前只接触过 MySQL 的安装目录（在安装 MySQL 的时候我们可以自己指定），我们重点强调过这个安装目录下非常重要的 bin 目录，它里边存储了许多关于控制客户端程序和服务器程序的命令（许多可执行文件，比如 mysql ， mysqld ， mysqld_safe 等等等等好几十个）。而数据目录是用来存储 MySQL 在运行过程中产生的数据，一定要和本章要讨论的安装目录区别开！一定要区分开！一定要区分开！一定要区分开！
- 如何确定MySQL中的数据目录 #
  
  Tip
  那说了半天，到底 MySQL 把数据都存到哪个路径下呢？其实数据目录对应着一个系统变量 datadir ，我们在使用客户端与服务器建立连接之后查看这个系统变量的值就可以了：
  show variables like 'datadir';
  
  从结果中可以看出，在我的计算机上MySQL 的数据目录就是/data/mysql/，你用你的计算机试试呗～

Mon, 01 Jan 0001 00:00:00 +0000

书接上文 #

prerequirement
通过前边儿的内容大家知道，表空间是一个抽象的概念，对于系统表空间来说，对应着文件系统中一个或多个实际文件；对于每个独立表空间来说，对应着文件系统中一个名为表名.ibd 的实际文件。大家可以把表空间想象成被切分为许许多多个页的池子，当我们想为某个表插入一条记录的时候，就从池子中捞出一个对应的页来把数据写进去。本章内容会深入到表空间的各个细节中，带领大家在 InnoDB 存储结构的池子中畅游。由于本章中将会涉及比较多的概念，虽然这些概念都不难，但是却相互依赖，所以奉劝大家在看的时候：不要跳着看! 不要跳着看! 不要跳着看!

回忆一些旧知识 #

页面类型 #

再一次强调，InnoDB是以页为单位管理存储空间的，我们的聚簇索引（也就是完整的表数据）和其他的二级索引都是以 B+ 树的形式保存到表空间的，而 B+ 树的节点就是数据页。我们前边说过，这个数据页的类型名其实是： FIL_PAGE_INDEX ，除了这种存放索引数据的页面类型之外，InnoDB也为了不同的目的设计了若干种不同类型的页面，为了唤醒大家的记忆，我们再一次把各种常用的页面类型提出来：

因为页面类型前边都有个 FIL_PAGE 或者 FIL_PAGE_TYPE 的前缀，为简便起见我们后边唠叨页面类型的时候就把这些前缀省略掉了，比方说 FIL_PAGE_TYPE_ALLOCATED 类型称为 ALLOCATED 类型， FIL_PAGE_INDEX 类型称为INDEX 类型。

类型名称	十六进制	描述
FIL_PAGE_TYPE_ALLOCATED	0x0000	最新分配，还没使用
FIL_PAGE_UNDO_LOG	0x0002	Undo日志页
FIL_PAGE_INODE	0x0003	段信息节点
FIL_PAGE_IBUF_FREE_LIST	0x0004	Insert Buffer空闲列表
FIL_PAGE_IBUF_BITMAP	0x0005	Insert Buffer位图
FIL_PAGE_TYPE_SYS	0x0006	系统页
FIL_PAGE_TYPE_TRX_SYS	0x0007	事务系统数据
FIL_PAGE_TYPE_FSP_HDR	0x0008	表空间头部信息
FIL_PAGE_TYPE_XDES	0x0009	扩展描述页
FIL_PAGE_TYPE_BLOB	0x000A	BLOB页
FIL_PAGE_INDEX	0x45BF	索引页，也就是我们所说的数据页

页面通用部分 #

我们前边说过数据页，也就是 INDEX 类型的页由7个部分组成，其中的两个部分是所有类型的页面都通用的。当然我不能寄希望于你把我说的话都记住，所以在这里重新强调一遍，任何类型的页面都有下边这种通用的结构：

从上图中可以看出，任何类型的页都会包含这两个部分：
1). File Header ：记录页面的一些通用信息
2). File Trailer ：校验页是否完整，保证从内存到磁盘刷新时内容的一致性。

对于 File Trailer 我们不再做过多强调，全部忘记了的话可以到将数据页的那一章回顾一下。我们这里再强调一遍 File Header 的各个组成部分：

Mon, 01 Jan 0001 00:00:00 +0000

开场序言 #

Note
对于我们这些 MySQL 的使用者来说， MySQL 其实就是一个软件，平时用的最多的就是查询功能。DBA 时不时丢过来一些慢查询语句让优化，我们如果连查询是怎么执行的都不清楚还优化个毛线，所以是时候掌握真正的技术了。我们在第一章的时候就曾说过， MySQL Server 有一个称为 查询优化器 的模块，一条查询语句进行语法解析之后就会被交给查询优化器来进行优化，优化的结果就是生成一个所谓的 执行计划 ，这个执行计划表明了应该使用哪些索引进行查询，表之间的连接顺序是啥样的，最后会按照执行计划中的步骤调用存储引擎提供的方法来真正的执行查询，并将查询结果返回给用户。不过查询优化这个主题有点儿大，在学会跑之前还得先学会走，所以本章先来瞅瞅 MySQL 怎么执行单表查询（就是 FROM 子句后边只有一个表，最简单的那种查询～）。不过需要强调的一点是，在学习本章前务必看过前边关于记录结构、数据页结构以及索引的部分，如果你不能保证这些东西已经完全掌握，那么本章不适合你。

为了故事的顺利发展，我们先得建个如下的表：
我们为这个 single_table 表建立了1个聚簇索引和4个二级索引，分别是：
1. 为 id 列建立的聚簇索引。
2. 为 key1 列建立的 idx_key1 二级索引。
3. 为 key2 列建立的 idx_key2 二级索引，而且该索引是唯一二级索引。
4. 为 key3 列建立的 idx_key3 二级索引。
5. 为 key_part1 、 key_part2 、 key_part3 列建立的 idx_key_part 二级索引，这也是一个联合索引。

然后我们需要为这个表插入10000行记录，除 id 列外其余的列都插入随机值就好了，具体的插入语句我就不写了，自己写个程序插入吧（id列是自增主键列，不需要我们手动插入）。
```
CREATE TABLE single_table (
 id INT NOT NULL AUTO_INCREMENT,
 key1 VARCHAR(100),
 key2 INT,
 key3 VARCHAR(100),
 key_part1 VARCHAR(100),
 key_part2 VARCHAR(100),
 key_part3 VARCHAR(100),
 common_field VARCHAR(100),
 PRIMARY KEY (id),
 KEY idx_key1 (key1),
 UNIQUE KEY idx_key2 (key2),
 KEY idx_key3 (key3),
 KEY idx_key_part(key_part1, key_part2, key_part3)
) Engine=InnoDB CHARSET=utf8;
```
访问方法（access method）的概念 #

想必各位都用过高德地图来查找到某个地方的路线吧（此处没有为高德地图打广告的意思，他们没给我钱，大家用百度地图也可以啊），如果我们搜西安钟楼到大雁塔之间的路线的话，地图软件会给出n种路线供我们选择，如果我们实在闲的没事儿干并且足够有钱的话，还可以用南辕北辙的方式绕地球一圈到达目的地。也就是说，不论采用哪一种方式，我们最终的目标就是到达大雁塔这个地方。回到 MySQL 中来，我们平时所写的那些查询语句本质上只是一种声明式的语法，只是告诉 MySQL 我们要获取的数据符合哪些规则，至于 MySQL 背地里是怎么把查询结果搞出来的那是 MySQL 自己的事儿。对于单个表的查询来说，设计MySQL的大叔把查询的执行方式大致分为下边两种：
使用全表扫描进行查询: 这种执行方式很好理解，就是把表的每一行记录都扫一遍嘛，把符合搜索条件的记录加入到结果集就完了。不管是啥查询都可以使用这种方式执行，当然，这种也是最笨的执行方式。
使用索引进行查询: 因为直接使用全表扫描的方式执行查询要遍历好多记录，所以代价可能太大了。如果查询语句中的搜索条件可以使用到某个索引，那直接使用索引来执行查询可能会加快查询执行的时间。使用索引来执行查询的方式五花八门，又可以细分为许多种类：
1. 针对主键或唯一二级索引的等值查询
2. 针对普通二级索引的等值查询
3. 针对索引列的范围查询
4. 直接扫描整个索引

设计 MySQL 的大叔把 MySQL 执行查询语句的方式称之为 访问方法 或者 访问类型 。同一个查询语句可能可以使用多种不同的访问方法来执行，虽然最后的查询结果都是一样的，但是执行的时间可能差老鼻子远了，就像是从钟楼到大雁塔，你可以坐火箭去，也可以坐飞机去，当然也可以坐乌龟去。下边细细道来各种访问方法的具体内容。

Mon, 01 Jan 0001 00:00:00 +0000

开场序言 #

Caution
搞数据库一个避不开的概念就是 Join ，翻译成中文就是连接。相信很多小伙伴在初学连接的时候有些一脸懵逼，理解了连接的语义之后又可能不明白各个表中的记录到底是怎么连起来的，以至于在使用的时候常常陷入下边两种误区：
误区一：业务至上，管他三七二十一，再复杂的查询也用在一个连接语句中搞定。
误区二：敬而远之，上次 DBA 那给报过来的慢查询就是因为使用了连接导致的，以后再也不敢用了。
所以本章就来扒一扒连接的原理。考虑到一部分小伙伴可能忘了连接是个啥或者压根儿就不知道，为了节省他们百度或者看其他书的宝贵时间以及为了我的书凑字数，我们先来介绍一下 MySQL 中支持的一些连接语法。
连接简介 #
- 连接的本质 #
```
create schema multi_table_join collate utf8mb4_general_ci;
use multi_table_join;

CREATE TABLE t1 (m1 int, n1 char(1));
CREATE TABLE t2 (m2 int, n2 char(1));
INSERT INTO t1 VALUES(1, 'a'), (2, 'b'), (3, 'c');
INSERT INTO t2 VALUES(2, 'b'), (3, 'c'), (4, 'd');
```
  为了故事的顺利发展，我们先建立两个简单的表并给它们填充一点数据：
  
  我们成功建立了 t1 、 t2 两个表，这两个表都有两个列，一个是 INT 类型的，一个是 CHAR(1) 类型的，填充好数据的两个表长这样：
  
  连接的本质就是把各个连接表中的记录都取出来依次匹配的组合加入结果集并返回给用户。所以我们把 t1 和 t2 两个表连接起来的过程如下左所示：
  
  这个过程看起来就是把 t1 表的记录和 t2 的记录连起来组成新的更大的记录，所以这个查询过程称之为 连接查询。连接查询的结果集中包含一个表中的每一条记录与另一个表中的每一条记录相互匹配的组合，像这样的结果集就可以称之为 笛卡尔积。因为表 t1 中有3条记录，表 t2 中也有3条记录，所以这两个表连接之后的笛卡尔积就有 3×3=9 行记录。在 MySQL 中，连接查询的语法也很随意，只要在 FROM 语句后边跟多个表名就好了，比如我们把 t1 表和 t2 表连接起来的查询语句可以写成如上右那样。

Mon, 01 Jan 0001 00:00:00 +0000

什么是成本 #

我们之前老说 MySQL 执行一个查询可以有不同的执行方案，它会选择其中成本最低，或者说代价最低的那种方案去真正的执行查询。不过我们之前对成本的描述是非常模糊的，其实在 MySQL 中一条查询语句的执行成本是由下边这两个方面组成的：
1.: I/O 成本
我们的表经常使用的 MyISAM 、 InnoDB 存储引擎都是将数据和索引都存储到磁盘上的，当我们想查询表中的记录时，需要先把数据或者索引加载到内存中然后再操作。这个从磁盘到内存这个加载的过程损耗的时间称之为 I/O 成本。

2.: CPU 成本
读取以及检测记录是否满足对应的搜索条件、对结果集进行排序等这些操作损耗的时间称之为 CPU 成本。对于 InnoDB 存储引擎来说，页是磁盘和内存之间交互的基本单位，设计 MySQL 的大叔规定读取一个页面花费的成本默认是 1.0 ，读取以及检测一条记录是否符合搜索条件的成本默认是 0.2 。 1.0 、 0.2 这些数字称之为成本常数，这两个成本常数我们最常用到，其余的成本常数我们后边再说哈。

小贴士
需要注意的是，不管读取记录时需不需要检测是否满足搜索条件，其成本都算是0.2。
单表查询的成本 #
- 准备工作 #
  
  Note
  为了故事的顺利发展，我们还得把之前用到的 single_table 表搬来，怕大家忘了这个表长啥样，再给大家抄一遍如下：
  还是假设这个表里边儿有 10000 条记录，除 id 列外其余的列都插入随机值。下边正式开始我们的表演。
  
  为了方便我们使用 python 进行插入。
  安装依赖 pip install faker pymysql。
  编写代码如下执行 python single_table_faker.py

Mon, 01 Jan 0001 00:00:00 +0000

开场序言 #

Caution
我们前边唠叨查询成本的时候经常用到一些统计数据，比如通过 SHOW TABLE STATUS 可以看到关于表的统计数据，通过 SHOW INDEX 可以看到关于索引的统计数据，那么这些统计数据是怎么来的呢？它们是以什么方式收集的呢？本章将聚焦于 InnoDB 存储引擎的统计数据收集策略，看完本章大家就会明白为啥前边老说 InnoDB 的统计信息是不精确的估计值了（言下之意就是我们不打算介绍 MyISAM 存储引擎统计数据的收集和存储方式，有想了解的同学自己个儿看看文档哈）。
两种不同的统计数据存储方式 #
基于磁盘的永久性统计数据 #
- innodb_table_stats #
  - n_rows统计项的收集 #
  - clustered_index_size和sum_of_other_index_sizes统计项的收集 #
- innodb_index_stats #
- 定期更新统计数据 #
- 手动更新 innodb_table_stats 和 innodb_index_stats 表 #
基于内存的非永久性统计数据 #
innodb_stats_method的使用 #
总结 #

Mon, 01 Jan 0001 00:00:00 +0000

开场序言 #

Caution
大家别忘了 MySQL 本质上是一个软件，设计 MySQL 的大叔并不能要求使用这个软件的人个个都是数据库高高手，就像我写这本书的时候并不能要求各位在学之前就会了里边儿的知识。(吐槽一下：都会了的人谁还看呢，难道是为了精神上受感化？)
也就是说我们无法避免某些同学写一些执行起来十分耗费性能的语句。即使是这样，设计 MySQL 的大叔还是依据一些规则，竭尽全力的把这个很糟糕的语句转换成某种可以比较高效执行的形式，这个过程也可以被称作 查询重写 （就是人家觉得你写的语句不好，自己再重写一遍）。本章详细唠叨一下一些比较重要的重写规则。
条件化简 #
- 移除不必要的括号 #
- 常量传递（constant_propagation） #
- 等值传递（equality_propagation） #
- 移除没用的条件（trivial_condition_removal） #
- 表达式计算 #
- HAVING子句和WHERE子句的合并 #
- 常量表检测 #
外连接消除 #
子查询优化 #
- 子查询语法 #
  - 按返回的结果集区分子查询 #
  - 按与外层查询关系来区分子查询 #
  - 子查询在布尔表达式中的使用 #
  - 子查询语法注意事项 #
- 子查询在MySQL中是怎么执行的 #
  - 小白们眼中子查询的执行方式 #
  - 标量子查询、行子查询的执行方式 #
  - IN子查询优化 #
  - ANY/ALL子查询优化 #
  - [NOT] EXISTS子查询的执行 #
  - 对于派生表的优化 #

Mon, 01 Jan 0001 00:00:00 +0000

开场序言 #

Caution

一条查询语句在经过 MySQL 查询优化器的各种基于成本和规则的优化会后生成一个所谓的执行计划，这个执行计划展示了接下来具体执行查询的方式，比如多表连接的顺序是什么，对于每个表采用什么访问方法来具体执行查询等等。设计 MySQL 的大叔贴心的为我们提供了 EXPLAIN 语句 来帮助我们查看某个查询语句的具体执行计划，本章的内容就是为了帮助大家看懂 EXPLAIN 语句的各个输出项都是干嘛使的，从而可以有针对性的提升我们查询语句的性能。

如果我们想看看某个查询的执行计划的话，可以在具体的查询语句前边加一个 EXPLAIN ，就像这样：EXPLAIN SELECT 1;

然后这输出的一大坨东西就是所谓的 执行计划 ，我的任务就是带领大家看懂这一大坨东西里边的每个列都是干啥用的，以及在这个执行计划的辅助下，我们应该怎样改进自己的查询语句以使查询执行起来更高效。其实除了以 SELECT 开头的查询语句，其余的 DELETE 、 INSERT 、 REPLACE 以及 UPDATE 语句前边都可以加上 EXPLAIN 这个词儿，用来查看这些语句的执行计划，不过我们这里对 SELECT 语句更感兴趣，所以后边只会以 SELECT 语句为例来描述 EXPLAIN 语句的用法。为了让大家先有一个感性的认识，我们把 EXPLAIN 语句输出的各个列的作用先大致罗列如下左：

需要注意的是，大家如果看不懂上边输出列含义，那是正常的，千万不要纠结～。我在这里把它们都列出来只是为了描述一个轮廓，让大家有一个大致的印象，下边会细细道来，等会儿说完了不信你不会～为了故事的顺利发展，我们还是要请出我们前边已经用了n遍的 single_table 表，为了防止大家忘了，再把它的结构描述一遍如下右：

我们仍然假设有两个和 single_table 表构造一模一样的 s1 、 s2 表，而且这两个表里边儿有10000条记录，除id列外其余的列都插入随机值。为了让大家有比较好的阅读体验，我们下边并不准备严格按照 EXPLAIN 输出列的顺序来介绍这些列分别是干嘛的，大家注意一下就好了。

列名	描述
id	在一个大的查询语句中每个 SELECT 关键字都对应一个唯一的 id
select_type	SELECT 关键字对应的那个查询的类型
table	表名
partitions	匹配的分区信息
type	针对单表的访问方法
possible_keys	可能用到的索引
key	实际上使用的索引
key_len	实际使用到的索引长度
ref	当使用索引列等值查询时，与索引列进行等值匹配的对象信息
rows	预估的需要读取的记录条数
filtered	某个表经过搜索条件过滤后剩余记录条数的百分比
Extra	一些额外的信息

CREATE TABLE single_table (
 id INT NOT NULL AUTO_INCREMENT,
 key1 VARCHAR(100),
 key2 INT,
 key3 VARCHAR(100),
 key_part1 VARCHAR(100),
 key_part2 VARCHAR(100),
 key_part3 VARCHAR(100),
 common_field VARCHAR(100),
 PRIMARY KEY (id),
 KEY idx_key1 (key1),
 UNIQUE KEY idx_key2 (key2),
 KEY idx_key3 (key3),
 KEY idx_key_part(key_part1, key_part2, key_part3)
) Engine=InnoDB CHARSET=utf8;
CREATE TABLE s1 LIKE single_table; insert into s1 select * from single_table; CREATE TABLE s2 LIKE single_table; insert into s2 select * from single_table;

// CREATE TABLE s1 AS SELECT * FROM single_table;

// 完整复制
-- 第一步：创建表结构
-- CREATE TABLE new_table LIKE original_table;
-- 第二步：复制数据
-- INSERT INTO new_table SELECT * FROM original_table;

执行计划输出中各列详解 #
- table #
  
  不论我们的查询语句有多复杂，里边儿包含了多少个表，到最后也是需要对每个表进行单表访问的，所以设计 MySQL 的大叔规定 EXPLAIN 语句输出的每条记录都对应着某个单表的访问方法，该条记录的 table 列代表着该表的表名。所以我们看一条比较简单的查询语句：EXPLAIN SELECT * FROM s1;
  
  这个查询语句只涉及对 s1 表的单表查询，所以 EXPLAIN 输出中只有一条记录，其中的 table 列的值是 s1 ，表明这条记录是用来说明对 s1 表的单表访问方法的。
  下边我们看一下一个连接查询的执行计划：EXPLAIN SELECT * FROM s1 INNER JOIN s2;
  
  可以看到这个连接查询的执行计划中有两条记录，这两条记录的 table 列分别是 s1 和 s2 ，这两条记录用来分别说明对 s1 表和 s2 表的访问方法是什么。

Mon, 01 Jan 0001 00:00:00 +0000

执行计划输出中各列详解 #

本章紧接着上一节的内容，继续唠叨 EXPLAIN 语句输出的各个列的意思。
- Extra #
  
  Note
  顾名思义， Extra 列是用来说明一些额外信息的，我们可以通过这些额外信息来更准确的理解 MySQL 到底将如何执行给定的查询语句。 MySQL 提供的额外信息有好几十个，我们就不一个一个介绍了（都介绍了感觉我们的文章就跟文档差不多了～），所以我们只挑一些平时常见的或者比较重要的额外信息介绍给大家哈。
  - No tables used #
    
    Tip
    当查询语句的没有 FROM 子句时将会提示该额外信息，比如：
    EXPLAIN SELECT 1;
  - Impossible WHERE #
    
    Tip
    查询语句的 WHERE 子句永远为 FALSE 时将会提示该额外信息，比方说：
    EXPLAIN SELECT * FROM s1 WHERE 1 != 1;
  - No matching min/max row #
    
    Tip

Mon, 01 Jan 0001 00:00:00 +0000

一镜到底 #

对于 MySQL 5.6 以及之前的版本来说，查询优化器就像是一个黑盒子一样，你只能通过 EXPLAIN 语句查看到最后优化器决定使用的执行计划，却无法知道它为什么做这个决策。这对于一部分喜欢刨根问底的小伙伴来说简直是灾难：“我就觉得使用其他的执行方案比 EXPLAIN 输出的这种方案强，凭什么优化器做的决定和我想的不一样呢？”

在 MySQL 5.6 以及之后的版本中，设计 MySQL 的大叔贴心的为这部分小伙伴提出了一个 optimizer trace 的功能，这个功能可以让我们方便的查看优化器生成执行计划的整个过程，这个功能的开启与关闭由 系统变量 optimizer_trace 决定，我们看一下：SHOW VARIABLES LIKE 'optimizer_trace';

可以看到 enabled 值为 off ，表明这个功能默认是关闭的。

小贴士
one_line 的值是控制输出格式的，如果为 on 那么所有输出都将在一行中展示，不适合人阅读，所以我们就保持其默认值为 off 吧。

如果想打开这个功能，必须首先把 enabled 的值改为 on ，就像这样：
SET optimizer_trace="enabled=on";

然后我们就可以输入我们想要查看优化过程的查询语句，当该查询语句执行完成后，就可以到 information_schema 数据库下的 OPTIMIZER_TRACE 表 中查看完整的优化过程。这个 OPTIMIZER_TRACE 表有4个列，分别是：
1. QUERY ：表示我们的查询语句。
2. TRACE ：表示优化过程的JSON格式文本。
3. MISSING_BYTES_BEYOND_MAX_MEM_SIZE ：由于优化过程可能会输出很多，如果超过某个限制时，多余的文本将不会被显示，这个字段展示了被忽略的文本字节数
4. INSUFFICIENT_PRIVILEGES ：表示是否没有权限查看优化过程，默认值是0，只有某些特殊情况下才会是 1 ，我们暂时不关心这个字段的值。
完整的使用 optimizer trace 功能的步骤总结如下：

Mon, 01 Jan 0001 00:00:00 +0000

缓存的重要性 #

通过前边的唠叨我们知道，对于使用 InnoDB 作为存储引擎的表来说，不管是用于存储用户数据的索引（包括聚簇索引和二级索引），还是各种系统数据，都是以页的形式存放在 表空间 中的，而所谓的 表空间 只不过是 InnoDB 对文件系统上一个或几个实际文件的抽象，也就是说我们的数据说到底还是存储在磁盘上的。但是各位也都知道，磁盘的速度慢的跟乌龟一样，怎么能配得上“快如风，疾如电”的 CPU 呢？所以 InnoDB 存储引擎在处理客户端的请求时，当需要访问某个页的数据时，就会把完整的页的数据全部加载到内存中，也就是说即使我们只需要访问一个页的一条记录，那也需要先把整个页的数据加载到内存中。将整个页加载到内存中后就可以进行读写访问了，在进行完读写访问之后并不着急把该页对应的内存空间释放掉，而是将其缓存起来，这样将来有请求再次访问该页面时，就可以省去磁盘 IO 的开销了。
InnoDB的Buffer Pool #
- 啥是个Buffer Pool #
  
  Note
  设计 InnoDB 的大叔为了缓存磁盘中的页，在 MySQL 服务器启动的时候就向操作系统申请了一片连续的内存，他们给这片内存起了个名，叫做 Buffer Pool （中文名是缓冲池）。那它有多大呢？这个其实看我们机器的配置，如果你是土豪，你有 512G 内存，你分配个几百 G 作为 Buffer Pool 也可以啊，当然你要是没那么有钱，设置小点也行呀～默认情况下 Buffer Pool 只有 128M 大小。当然如果你嫌弃这个 128M 太大或者太小，可以在启动服务器的时候配置 innodb_buffer_pool_size 参数的值，它表示 Buffer Pool 的大小，就像这样：
  
  其中， 268435456 的单位是字节，也就是我指定 Buffer Pool 的大小为 256M 。需要注意的是， Buffer Pool 也不能太小，最小值为 5M (当小于该值时会自动设置成 5M )。

Mon, 01 Jan 0001 00:00:00 +0000

事务的起源 #

对于大部分程序员来说，他们的任务就是把现实世界的业务场景映射到数据库世界。比如银行为了存储人们的账户信息会建立一个 account 表：

狗哥和猫爷是一对好基友，他们都到银行开一个账户，他们在现实世界中拥有的资产就会体现在数据库世界的 account 表中。比如现在狗哥有 11 元，猫爷只有 2 元，那么现实中的这个情况映射到数据库的 account 表就是这样：
```
CREATE TABLE account (
 id INT NOT NULL AUTO_INCREMENT COMMENT '自增id',
 name VARCHAR(100) COMMENT '客户名称',
 balance INT COMMENT '余额',
 PRIMARY KEY (id)
) Engine=InnoDB CHARSET=utf8;

-- 插入数据
INSERT INTO `account` (`id`, `name`, `balance`) VALUES (1,'狗哥',11),(2,'猫爷',2);
```
在某个特定的时刻，狗哥猫爷这些家伙在银行所拥有的资产是一个特定的值，这些特定的值也可以被描述为账户在这个特定的时刻现实世界的一个状态。随着时间的流逝，狗哥和猫爷可能陆续进行向账户中存钱、取钱或者向别人转账等操作，这样他们账户中的余额就可能发生变动，每一个操作都相当于现实世界中账户的一次状态转换。数据库世界作为现实世界的一个映射，自然也要进行相应的变动。不变不知道，一变吓一跳，现实世界中一些看似很简单的状态转换，映射到数据库世界却不是那么容易的。比方说有一次猫爷在赌场赌博输了钱，急忙打电话给狗哥要借10块钱，不然那些看场子的就会把自己剁了。现实世界中的狗哥走向了ATM机，输入了猫爷的账号以及10元的转账金额，然后按下确认，狗哥就拔卡走人了。对于数据库世界来说，相当于执行了下边这两条语句：
```
UPDATE account SET balance = balance - 10 WHERE id = 1;
UPDATE account SET balance = balance + 10 WHERE id = 2;
```
但是这里头有个问题，上述两条语句只执行了一条时忽然服务器断电了咋办？把狗哥的钱扣了，但是没给猫爷转过去，那猫爷还是逃脱不了被砍死的噩运～即使对于单独的一条语句，我们前边唠叨 Buffer Pool 时也说过，在对某个页面进行读写访问时，都会先把这个页面加载到 Buffer Pool 中，之后如果修改了某个页面，也不会立即把修改同步到磁盘，而只是把这个修改了的页面加到 Buffer Pool 的 flush链表中，在之后的某个时间点才会刷新到磁盘。如果在将修改过的页刷新到磁盘之前系统崩溃了那岂不是猫爷还是要被砍死？或者在刷新磁盘的过程中（只刷新部分数据到磁盘上）系统奔溃了猫爷也会被砍死？怎么才能保证让可怜的猫爷不被砍死呢？其实再仔细想想，我们只是想让某些数据库操作符合现实世界中状态转换的规则而已，设计数据库的大叔们仔细盘算了盘算，现实世界中状态转换的规则有好几条，待我们慢慢道来。

Mon, 01 Jan 0001 00:00:00 +0000

事先说明 #

本文以及接下来的几篇文章将会频繁的使用到我们前边唠叨的 InnoDB 记录行格式、页面格式、索引原理、表空间的组成等各种基础知识，如果大家对这些东西理解的不透彻，那么阅读下边的文字可能会有些吃力，为保证您的阅读体验，请确保自己已经掌握了我前边唠叨的这些知识。
redo日志是个啥 #

我们知道 InnoDB 存储引擎是以页为单位来管理存储空间的，我们进行的增删改查操作其实本质上都是在访问页面（包括读页面、写页面、创建新页面等操作）。我们前边唠叨 Buffer Pool 的时候说过，在真正访问页面之前，需要把在磁盘上的页缓存到内存中的 Buffer Pool 之后才可以访问。但是在唠叨事务的时候又强调过一个称之为持久性的特性，就是说对于一个已经提交的事务，在事务提交后即使系统发生了崩溃，这个事务对数据库中所做的更改也不能丢失。但是如果我们只在内存的 Buffer Pool 中修改了页面，假设在事务提交后突然发生了某个故障，导致内存中的数据都失效了，那么这个已经提交了的事务对数据库中所做的更改也就跟着丢失了，这是我们所不能忍受的（想想ATM机已经提示狗哥转账成功，但之后由于服务器出现故障，重启之后猫爷发现自己没收到钱，猫爷就被砍死了）。那么如何保证这个持久性呢？一个很简单的做法就是在事务提交完成之前把该事务所修改的所有页面都刷新到磁盘，但是这个简单粗暴的做法有些问题：
刷新一个完整的数据页太浪费了：有时候我们仅仅修改了某个页面中的一个字节，但是我们知道在 InnoDB 中是以页为单位来进行磁盘IO的，也就是说我们在该事务提交时不得不将一个完整的页面从内存中刷新到磁盘，我们又知道一个页面默认是16KB大小，只修改一个字节就要刷新16KB的数据到磁盘上显然是太浪费了。
随机IO刷起来比较慢：一个事务可能包含很多语句，即使是一条语句也可能修改许多页面，倒霉催的是该事务修改的这些页面可能并不相邻，这就意味着在将某个事务修改的 Buffer Pool 中的页面刷新到磁盘时，需要进行很多的随机IO，随机IO比顺序IO要慢，尤其对于传统的机械硬盘来说。

咋办呢？再次回到我们的初心：我们只是想让已经提交了的事务对数据库中数据所做的修改永久生效，即使后来系统崩溃，在重启后也能把这种修改恢复出来。所以我们其实没有必要在每次事务提交时就把该事务在内存中修改过的全部页面刷新到磁盘，只需要把修改了哪些东西记录一下就好，比方说某个事务将系统表空间中的第100 号页面中偏移量为1000处的那个字节的值 1 改成 2 我们只需要记录一下：
将第0号表空间的100号页面的偏移量为1000处的值更新为 2。

这样我们在事务提交时，把上述内容刷新到磁盘中，即使之后系统崩溃了，重启之后只要按照上述内容所记录的步骤重新更新一下数据页，那么该事务对数据库中所做的修改又可以被恢复出来，也就意味着满足持久性的要求。因为在系统奔溃重启时需要按照上述内容所记录的步骤重新更新数据页，所以上述内容也被称之为 重做日志 ，英文名为 redo log ，我们也可以土洋结合，称之为 redo日志 。与在事务提交时将所有修改过的内存中的页面刷新到磁盘中相比，只将该事务执行过程中产生的 redo 日志刷新到磁盘的好处如下：
redo 日志占用的空间非常小：存储表空间ID、页号、偏移量以及需要更新的值所需的存储空间是很小的，关于 redo 日志的格式我们稍后会详细唠叨，现在只要知道一条 redo 日志占用的空间不是很大就好了。
redo 日志是顺序写入磁盘的：在执行事务的过程中，每执行一条语句，就可能产生若干条 redo 日志，这些日志是按照产生的顺序写入磁盘的，也就是使用顺序IO。
redo日志格式 #

通过上边的内容我们知道， redo 日志本质上只是记录了一下事务对数据库做了哪些修改。设计 InnoDB 的大叔们针对事务对数据库的不同修改场景定义了多种类型的 redo 日志，但是绝大部分类型的 redo 日志都有下边这种通用的结构：

各个部分的详细释义如下：
type ：该条 redo 日志的类型。（在 MySQL 5.7.21 这个版本中，设计 InnoDB 的大叔一共为 redo 日志设计了53种不同的类型，稍后会详细介绍不同类型的 redo 日志。)
space ID ：表空间ID。
page number ：页号。
data ：该条 redo 日志的具体内容。

Mon, 01 Jan 0001 00:00:00 +0000

redo日志文件 #
- redo日志刷盘时机 #
  
  我们前边说 mtr 运行过程中产生的一组 redo 日志在 mtr 结束时会被复制到 log buffer 中，可是这些日志总在内存里呆着也不是个办法，在一些情况下它们会被刷新到磁盘里，比如：
  - log buffer 空间不足时
    
    log buffer 的大小是有限的（通过系统变量 innodb_log_buffer_size 指定），如果不停的往这个有限大小的 log buffer 里塞入日志，很快它就会被填满。设计 InnoDB 的大叔认为如果当前写入 log buffer 的redo 日志量已经占满了 log buffer 总容量的大约一半左右，就需要把这些日志刷新到磁盘上。
  - 事务提交时
    
    我们前边说过之所以使用 redo 日志主要是因为它占用的空间少，还是顺序写，在事务提交时可以不把修改过的 Buffer Pool 页面刷新到磁盘，但是为了保证持久性，必须要把修改这些页面对应的 redo 日志刷新到磁盘。
  - 后台线程不停的刷刷刷
    
    后台有一个线程，大约每秒都会刷新一次 log buffer 中的 redo 日志到磁盘。
  - 正常关闭服务器时
    
    做所谓的 checkpoint 时（我们现在没介绍过 checkpoint 的概念，稍后会仔细唠叨，稍安勿躁）
  - 其他的一些情况…
- redo日志文件组 #
  
  MySQL 的数据目录（使用 SHOW VARIABLES LIKE ‘datadir’ 查看）下默认有两个名为 ib_logfile0 和 ib_logfile1 的文件， log buffer 中的日志默认情况下就是刷新到这两个磁盘文件中。如果我们对默认的 redo 日志文件不满意，可以通过下边几个启动参数来调节：

Mon, 01 Jan 0001 00:00:00 +0000

事务回滚的需求 #

我们说过事务需要保证原子性，也就是事务中的操作要么全部完成，要么什么也不做。但是偏偏有时候事务执行到一半会出现一些情况，比如：
1. 情况一：事务执行过程中可能遇到各种错误，比如服务器本身的错误，操作系统错误，甚至是突然断电导致的错误。
2. 情况二：程序员可以在事务执行过程中手动输入 ROLLBACK 语句结束当前的事务的执行。
这两种情况都会导致事务执行到一半就结束，但是事务执行过程中可能已经修改了很多东西，为了保证事务的原子性，我们需要把东西改回原先的样子，这个过程就称之为回滚（英文名： rollback ），这样就可以造成一个假象：这个事务看起来什么都没做，所以符合原子性要求。

小时候我非常痴迷于象棋，总是想找厉害的大人下棋，赢棋是不可能赢棋的，这辈子都不可能赢棋的，又不想认输，只能偷偷的悔棋才能勉强玩的下去。悔棋就是一种非常典型的回滚操作，比如棋子往前走两步，悔棋对应的操作就是向后走两步；比如棋子往左走一步，悔棋对应的操作就是向右走一步。数据库中的回滚跟悔棋差不多，你插入了一条记录，回滚操作对应的就是把这条记录删除掉；你更新了一条记录，回滚操作对应的就是把该记录更新为旧值；你删除了一条记录，回滚操作对应的自然就是把该记录再插进去。说的貌似很简单的样子[手动偷笑😏]。

从上边的描述中我们已经能隐约感觉到，每当我们要对一条记录做改动时（这里的改动可以指 INSERT 、DELETE 、 UPDATE ），都需要留一手 —— 把回滚时所需的东西都给记下来。比方说：
- 你插入一条记录时，至少要把这条记录的主键值记下来，之后回滚的时候只需要把这个主键值对应的记录删掉就好了。
- 你删除了一条记录，至少要把这条记录中的内容都记下来，这样之后回滚时再把由这些内容组成的记录插入到表中就好了。
- 你修改了一条记录，至少要把修改这条记录前的旧值都记录下来，这样之后回滚时再把这条记录更新为旧值就好了。
设计数据库的大叔把这些为了回滚而记录的这些东东称之为撤销日志，英文名为 undo log ，我们也可以土洋结合，称之为 undo日志。这里需要注意的一点是，由于查询操作（ SELECT ）并不会修改任何用户记录，所以在查询操作执行时，并不需要记录相应的 undo日志。在真实的 InnoDB 中， undo日志其实并不像我们上边所说的那么简单，不同类型的操作产生的 undo日志的格式也是不同的，不过先暂时把这些容易让人脑子糊的具体细节放一放，我们先回过头来看看事务id 是个神马玩意儿。
事务id #
- 给事务分配id的时机 #
  
  我们前边在唠叨事务简介时说过，一个事务可以是一个只读事务，或者是一个读写事务：

Mon, 01 Jan 0001 00:00:00 +0000

书接上文 #

prerequirement
上一章我们主要唠叨了为什么需要 undo日志 ，以及 INSERT 、 DELETE 、 UPDATE 这些会对数据做改动的语句都会产生什么类型的 undo日志，还有不同类型的 undo日志的具体格式是什么。本章会继续唠叨这些 undo日志会被具体写到什么地方，以及在写入过程中需要注意的一些问题。
通用链表结构 #

在写入 undo日志的过程中会使用到多个链表，很多链表都有同样的节点结构，如图所示：

在某个表空间内，我们可以通过一个页的页号和在页内的偏移量来唯一定位一个节点的位置，这两个信息也就相当于指向这个节点的一个指针。所以：
- Pre Node Page Number 和 Pre Node Offset 的组合就是指向前一个节点的指针
- Next Node Page Number 和 Next Node Offset 的组合就是指向后一个节点的指针。
整个 List Node 占用 12 个字节的存储空间。

为了更好的管理链表，设计 InnoDB 的大叔还提出了一个基节点的结构，里边存储了这个链表的头节点、尾节点以及链表长度信息，基节点的结构示意图如下：

其中：
- List Length 表明该链表一共有多少节点。
- First Node Page Number 和 First Node Offset 的组合就是指向链表头节点的指针。
- Last Node Page Number 和 Last Node Offset 的组合就是指向链表尾节点的指针。
整个 List Base Node 占用 16 个字节的存储空间。

Mon, 01 Jan 0001 00:00:00 +0000

事前准备 #

为了故事的顺利发展，我们需要创建一个表：

CREATE TABLE hero (
 number INT,
 name VARCHAR(100),
 country varchar(100),
 PRIMARY KEY (number)
) Engine=InnoDB CHARSET=utf8;

-- 然后向这个表里插入一条数据：
INSERT INTO hero VALUES(1, '刘备', '蜀');

-- 现在表里的数据就是这样的：
mysql> SELECT * FROM hero;
+--------+--------+---------+
| number | name | country |
+--------+--------+---------+
| 1 | 刘备 | 蜀 |
+--------+--------+---------+
1 row in set (0.00 sec)

Mon, 01 Jan 0001 00:00:00 +0000

解决并发事务带来问题的两种基本方式 #

上一章唠叨了事务并发执行时可能带来的各种问题，并发事务访问相同记录的情况大致可以划分为3种：
1. 读-读情况：即并发事务相继读取相同的记录。
  
  读取操作本身不会对记录有一毛钱影响，并不会引起什么问题，所以允许这种情况的发生。
2. 写-写情况：即并发事务相继对相同的记录做出改动。
  
  我们前边说过，在这种情况下会发生脏写的问题，任何一种隔离级别都不允许这种问题的发生。所以在多个未提交事务相继对一条记录做改动时，需要让它们排队执行，这个排队的过程其实是通过锁来实现的。这个所谓的锁其实是一个内存中的结构，在事务执行前本来是没有锁的，也就是说一开始是没有锁结构和记录进行关联的，如图所示：
  
  当一个事务想对这条记录做改动时，首先会看看内存中有没有与这条记录关联的锁结构，当没有的时候就会在内存中生成一个锁结构与之关联。比方说事务 T1 要对这条记录做改动，就需要生成一个锁结构与之关联：
  
  其实在锁结构里有很多信息，不过为了简化理解，我们现在只把两个比较重要的属性拿了出来：
  - trx信息：代表这个锁结构是哪个事务生成的。
  - is_waiting ：代表当前事务是否在等待。
  如图所示，当事务 T1 改动了这条记录后，就生成了一个锁结构与该记录关联，因为之前没有别的事务为这条记录加锁，所以 is_waiting 属性就是 false ，我们把这个场景就称之为获取锁成功，或者加锁成功，然后就可以继续执行操作了。
  
  在事务 T1 提交之前，另一个事务 T2 也想对该记录做改动，那么先去看看有没有锁结构与这条记录关联，发现有一个锁结构与之关联后，然后也生成了一个锁结构与这条记录关联，不过锁结构的is_waiting 属性值为 true ，表示当前事务需要等待，我们把这个场景就称之为获取锁失败，或者加锁失败，或者没有成功的获取到锁，画个图表示就是这样：
  
  在事务 T1 提交之后，就会把该事务生成的锁结构释放掉，然后看看还有没有别的事务在等待获取锁，发现了事务 T2 还在等待获取锁，所以把事务 T2 对应的锁结构的 is_waiting 属性设置为 false ，然后把该事务对应的线程唤醒，让它继续执行，此时事务 T2 就算获取到锁了。效果图就是这样：

Mon, 01 Jan 0001 00:00:00 +0000

感谢 #

我不生产知识，只是知识的搬运工。写作本小册的时间主要用在了两个方面：
搞清楚事情的本质是什么。这个过程就是研究源码、书籍和资料。

如何把我已经知道的知识表达出来。这个过程就是我不停的在地上走过来走过去，梳理知识结构，斟酌用词用句，不停的将已经写好的文章推倒重来，只是想给大家一个不错的用户体验。

这两个方面用的时间基本上是一半一半吧，在搞清楚事情的本质是什么阶段，除了直接阅读 MySQL 的源码之外，查看参考资料也是一种比较偷懒的学习方式。本书只是 MySQL 进阶的一个入门，想了解更多关于 MySQL 的知识，大家可以从下边这些资料里找点灵感。
- 一些链接 #
  - MySQL官方文档： https://dev.mysql.com/doc/refman/5.7/en/
    
    MySQL 官方文档是写作本书时参考最多的一个资料。说实话，文档写的非常通俗易懂，唯一的缺点就是太长了，导致大家看的时候无从下手。
  - MySQL Internals Manual： https://dev.mysql.com/doc/internals/en/
    
    介绍MySQL如何实现各种功能的文档，写的比较好，但是太少了，有很多章节直接跳过了。
  - 何登成的github： https://github.com/hedengcheng/tech
    
    登博的博客非常好，对事务、优化这讨论的细节也非常多，不过由于大多是PPT结构，字太少，对上下文不清楚的同学可能会一脸懵逼。
  - orczhou的博客： http://www.orczhou.com/
  - Jeremy Cole的博客： https://blog.jcole.us/innodb/
    
    Jeremy Cole大神不仅写作了 innodb_ruby 这个非常棒的解析 InnoDB 存储结构的工具，还对这些存储结构写了一系列的博客，在我几乎要放弃深入研究表空间结构的时候，是他老人家的博客把我又从深渊里拉了回来。
  - 那海蓝蓝（李海翔）的博客： https://blog.csdn.net/fly2nn
  - taobao月报： http://mysql.taobao.org/monthly/
    
    因为MySQL的源码非常多，经常让大家无从下手，而taobao月报就是一个非常好的源码阅读指南。
    
    Note
    吐槽一下，这个taobao月报也只能当作源码阅读指南看，如果真的不看源码光看月报，那只能当作天书看，十有八九被绕进去出不来了。
  - MySQL Server Blog： http://mysqlserverteam.com/
    
    MySQL team的博客，一手资料，在我不知道看什么的时候给了很多启示。
  - mysql_lover的博客： https://blog.csdn.net/mysql_lover/
  - Jørgen’s point of view： https://jorgenloland.blogspot.com/
  - mariadb的关于查询优化的文档： https://mariadb.com/kb/en/library/query-optimizations/
    
    不得不说mariadb的文档相比MySQL的来说就非常有艺术性了（里边儿有很多漂亮的插图），我很怀疑 MySQL 文档是程序员直接写的，mariadb的文档是产品经理写的。当我们想研究某个功能的原理，在MySQL 文档干巴巴的说明中找不到头脑时，可以参考一下 mariadb 娓娓道来的风格。
  - Reconstructing Data Manipulation Queries from Redo Logs： https://www.sba-research.org/wpcontent/uploads/publications/WSDF2012_InnoDB.pdf
  - 关于InnoDB事务的一个PPT： https://mariadb.org/wp-content/uploads/2018/02/Deep-Dive_-InnoDBTransactions-and-Write-Paths.pdf
  - 非官方优化文档： http://www.unofficialmysqlguide.com/optimizer-trace.html
    
    这个文档非常好，非常非常好～

Mon, 01 Jan 0001 00:00:00 +0000

压缩包安装 #

准备

# 下载MySQL5.6.49
$ wget -c https://cdn.mysql.com/archives/mysql-5.6/mysql-5.6.49-linux-glibc2.12-x86_64.tar.gz
# 检查是否安装过mysql,如果有先卸载, 
# 用yum -y remove删除,如果有多个,一个一个执行,卸载不掉的用 rpm -ev
$ rpm -qa|grep -i mysql
# 删除所有mysql的文件夹
$ find / -name mysql|xargs rm -rf
# 卸载系统自带的Mariadb
$ rpm -qa|grep mariadb
$ rpm -ev --nodeps mariadb-libs-5.5.68-1.el7.x86_64
# 创建my.cnf 文件,或者使用原有的进行拷贝
$ cp /usr/local/mysql/support-files/my-default.cnf /etc/my.cnf
# 创建mysql用户组并且创建一个用户名为mysql的用户并加入mysql用户组
$ groupadd mysql && useradd -g mysql mysql
# 创建数据目录或者使用原有的数据目录
$ mkdir data && mv data mysql-5.6.49/
# 移动安装文件夹到 /usr/local/ 并且重命名
$ mv mysql-5.6.49-linux-glibc2.12-x86_64 mysql-5.6.49 && mv mysql-5.6.49 /usr/local/
# 设置目录所属组和用户
$ chown -R mysql:mysql mysql-5.6.49/

正式安装

# 初始化
./scripts/mysql_install_db --user=mysql --basedir=/usr/local/mysql-5.6.49 --datadir=/usr/local/mysql-5.6.49/mysql_data/mysql --explicit_defaults_for_timestamp
# 自启动
$ cp ./support-files/mysql.server /etc/rc.d/init.d/mysqld
$ chmod +x /etc/rc.d/init.d/mysqld
$ chkconfig --add mysqld
$ chkconfig --list mysqld
$ service mysqld start
# 关闭防火墙
$ systemctl status firewalld
$ systemctl stop firewalld

测试及后续

# 以root账户登录mysql,默认是没有密码的
$ bin/mysql -uroot -p
# 修改密码
$ use mysql;
$ update user set password=password('12345678') where user='mysql' and host='localhost';
# 设置远程登录
$ GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'password' WITH GRANT OPTION;
$ FLUSH PRIVILEGES;

注意事项

[1] 通过 systemctl 或者 service 启动mysql服务的时候，是通过调用 bin/mysqld_safe 作为守护进程去启动 bin/mysqld 进程来启动服务。
[2] bin/mysqld 通过 bin/mysqld --help --verbose 可以查看启动配置参数。其中my.cnf配置文件的查找过程就在输出中可以看见。

# omitted

配置环境

Mon, 01 Jan 0001 00:00:00 +0000

数据库相关概念 #

DDL(Data Definition Language) #

数据库定义语言 statements are used to define the database structure or schema. DDL是SQL语言的四大功能之一。用于定义数据库的三级结构，包括外模式、概念模式、内模式及其相互之间的映像，定义数据的完整性、安全控制等约束DDL不需要commit. CREATE、ALTER、DROP、TRUNCATE、COMMENT、RENAME。
DML(Data Manipulation Language) #

数据操纵语言statements are used for managing data within schema objects. 由DBMS提供，用于让用户或程序员使用，实现对数据库中数据的操作。DML分成交互型DML和嵌入型DML两类。依据语言的级别，DML又可分成过程性DML和非过程性DML两种。需要commit. INSERT、UPDATE、DELETE、MERGE、CALL、EXPLAIN PLAN、LOCK TABLE。
DQL(Data Query Language) #

数据查询语言 SELECT、
DCL(Data Control Language) #

数据库控制语言授权，角色控制等。GRANT 授权、REVOKE 取消授权
TCL(Transaction Control Language) #

事务控制语言。SAVEPOINT 设置保存点、ROLLBACK 回滚、SET TRANSACTION

Reference #

https://www.cnblogs.com/henryhappier/archive/2010/07/05/1771295.html

Mon, 01 Jan 0001 00:00:00 +0000

函数 #

For server side help, type ‘help contents’

mysql> help contents
You asked for help about help category: "Contents"
For more information, type 'help <item>', where <item> is one of the following
categories:
 Account Management
 Administration
 Compound Statements
 Contents
 Data Definition
 Data Manipulation
 Data Types
 Functions
 Geographic Features
 Help Metadata
 Language Structure
 Plugins
 Procedures
 Storage Engines
 Table Maintenance
 Transactions
 User-Defined Functions
 Utility

mysql> help Functions
You asked for help about help category: "Functions"
For more information, type 'help <item>', where <item> is one of the following
categories:
 Bit Functions
 Comparison Operators
 Control Flow Functions
 Date and Time Functions
 Encryption Functions
 GROUP BY Functions and Modifiers
 Information Functions
 Locking Functions
 Logical Operators
 Miscellaneous Functions
 Numeric Functions
 Spatial Functions
 String Functions

常见函数 #
单行函数 #
字符函数 #
数学函数 #
日期函数 #
其他函数 #

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

DQL语言的学习 #
- 1.基础查询 #
  
  语法：select 查询列表 from 表名;
  
  特点：
  1，查询列表可以是：表中的字段，常量值，表达式，函数
  2，查询的结果是一个虚拟的表格
  
  1.查询表中的单个字段
  select last_name from employees limit 10;
  
  2.查询表中的多个字段
  select last_name, salary, email from employees limit 10;
  
  3.查询表中的所有字段
  select * from employees limit 10;
  
  4.查询常量值
  select 100;,select 'john';
  
  5.查询表达式
  select 100%98;
  
  6.查询函数
  select version();
  
  7.起别名
  ① 便于理解，② 如果查询字段有重名，使用别名可以区分开来，③ 别名中有特殊字符使用引号扩起来
  select 100%98 as 结果;
  select last_name as 姓,first_name as 名 from employees limit 10;
  
  8.去重
  # case: 查询员工表中涉及到的所有的部门编号
  select distinct department_id from employees;
  
  9.+号的作用 ① 仅仅只有一个功能，运算符
  select 100 + 90; 连个操作数都为数值型，则做加法运算
  select '123' + 90; 213 其中一个为字符型，可以转换，做加法运算
  select 'john' + 90 90 转换失败，则将字符型数值转换成 0 再做加法。
  select null + 10; NULL 只要有一方为NULL, 则结果肯定为NULL。
  所以下面字符串连接得使用concat函数
  case: 查询员工名和姓连接成一个字段，并显示为姓名
  select concat(last_name,first_name) as 姓名 from employees limit 10;

Mon, 01 Jan 0001 00:00:00 +0000

DML语言的学习 #

Mon, 01 Jan 0001 00:00:00 +0000

DDL语言的学习 #

1.库和表的管理 #
2.常见数据类型介绍 #

3.常见约束 #

含义：一种限制，用于限制表中的数据，为了保证表中数据的准确和可靠性

分类：六大约束：
①: NOT NULL：非空，用于保证该字段的值不能为空。
②: DEFAULT：默认，用于保证该字段有默认值。
③: PRIMARY KEY：主键，用于保证该字段的值具有唯一性，并且非空。
④: UNIQUE：唯一，用于保证该字段的值具有唯一性，可以为空。
⑤: CHECK：检查约束【mysql中不支持】
⑥: FOREIGN KEY：外键，用于限制两个表的关系，用于保证该字段的值必须来自于主表的关联列的值。在从表中添加外键约束，用于引用主表中的某列的值。

添加约束的时机：
a). 创建表时：
b). 修改表时：

约束的添加分类：
1). 列级约束：六大约束语法上都支持，但是外键约束没有效果
2). 表级约束：除了非空，默认，其他都支持
通用写法：其他列级，外键表级

测试约束用到的数据库 #

drop database students;
create database students character set utf8;
use students;

-- 创建外键引用的主表
drop table if exists major;
create table major(
 id int primary key,
 majorName varchar(20)
);
insert into major values (1, 'java'),(2, 'h5');
select * from major;

创建表时添加约束 #

添加列级约束 #

# 1.1 添加列级约束
drop table if exists stu_info;
create table stu_info(
 id int primary key, # 主键
 stuName varchar(20) not null, # 非空
 gender char(1) check ( gender = '男' or gender = '女'), # 检查
 seat int unique, # 唯一
 age int default 18, # 默认
 majorId int references major(id) # 外键(列级没效果)
);
desc stu_info;
show index from stu_info;
insert into stu_info values (1,'john', '男', null, 19, 1);
insert into stu_info values (2,'lily', '男', null, 19, 2);
select * from stu_info;

添加表级约束 #

# 1.2添加表级约束
drop table if exists stu_info;
create table stu_info(
 id int,
 stuName varchar(20) not null,
 gender char(1),
 seat int,
 age int default 18,
 majorId int,

 constraint pk primary key(id), # 主键
 constraint uq unique (seat), # 唯一
 constraint ck check ( gender = '男' or gender = '女' ), # 检查
 constraint fk_stu_info_major foreign key (majorId) references major(id) # 外键
);

主键和唯一对比 #

	保证唯一性	是否允许为空	一个表中可以有多个	是否允许组合（联合）
主键	✅	❌	至多有1个主键	✅ 【primary key(id,name)】
唯一	✅	✅ (可以有多个NULL)	可以有多个唯一字段	✅ 【unique(seat, seat2】

外键的特点 #

Note

Mon, 01 Jan 0001 00:00:00 +0000

Intro(TCL) #
Reference #
- delete 和 truncate在事务中的区别

Mon, 01 Jan 0001 00:00:00 +0000

Intro(VIEW) #

含义：虚拟表，和普通表一样使用
mysql5.1版本出现的新特性是通过表动态生成的数据，行和列的数据来自定义视图的查询中使用的表，并且实在使用视图时动态生成的，只保存了sql逻辑，不保存查询结果

好处：
1).: 重用sql语句
2).: 简化复杂的sql操作，不必知道它的查询细节
3).: 保护数据，提高安全性

应用场景：
1).: 多个地方用到了同样的查询结果
2).: 该查询结果使用的sql语句较复杂
- 示例 #
```
create view my_v1
as 
select stuname, majorname from stu_info s inner join major m on s.majorId = m.id;
```
case1: 查询姓张的学生名和专业名
select stuname,majorname from stu_info s inner join major m on s.majorId = m.id where s.stuname like '张%';
create view v1 as select stuname, majorname from stu_info s inner join major m on s.majorId = m.id;
select * from v1 where stuname like '张%';

Mon, 01 Jan 0001 00:00:00 +0000

Intro(VARIABLES) #

变量分类：
【系统变量 [全局变量 | 会话变量] 】
【用户自定义变量 [用户变量 | 局部变量]】：
- 系统变量 #
  
  说明：
  变量由系统提供的，不是用户定义的，属于服务器层面
  
  使用语法：
  case1：查看所有的系统变量: <br>`show global|session variables;` <br><br>case2：查看满足条件的部分系统变量:
  show global|session variables like '%char%';
  
  case3：查看指定的某个系统变量的值: ``
  select @@global|session.变量名;
  
  case4：为某个变量赋值:
  set global|session 系统变量名 = 值;
  set @@global|session .系统变量名 = 值;
  
  Caution
  如果是全局级别，则需要加global，如果是会话级别，则需要加session，如果不写，则默认session
  - 全局变量 #
    
    Note
    作用域：服务器每次启动将会为所有的全局变量赋初始值，针对于所有的会话（连接）有效，但不能跨重启。可通过配置文件进行重启生效
    
    使用语法：
    case1：查看所有的系统变量:
    show global variables;
    
    case2：查看满足条件的部分系统变量:
    show global variables like '%char%';
    
    case3：查看指定的某个系统变量的值:
    select @@global.autocommit;
    ~~select @@tx_isolation;~~
    
    case4：为某个变量赋值:
    set global autocommit = 1;，set @@global.autocommit = 0;

Mon, 01 Jan 0001 00:00:00 +0000

Intro(PROCEDURE) #

类似于java中的方法，MySQL 5.0 版本开始支持存储过程。
含义：一组预先编译好的sql语句的集合，理解成批处理语句。

好处：
1). 提高代码的重用性
2). 简化操作
3). 减少编译次数并且减少了和数据库服务器的连接次数，提高了效率。
- 创建语法 #
```
create procedure 存储过程名称(参数列表)
begin
 存储过程题（一组合法的sql语句）
end
```
  Note
  注意：
  1). 参数列表包含三部分（参数模式，参数名，参数类型），例如：IN stuname varchar(20)
  参数模式：
  in: 该参数可以作为输入，也就是该参数需要调用方传入值
  out: 该参数可以作为输出，也就是该参数可以作为返回值
  inout: 该参数既可以作为输入又可以作为输出，也就是该参数既需要传入值，又可以返回值
  
  2). 如果存储过程体仅仅只有一句话，begin end可以省略,存储过程体中的每条sql语句的结尾要求必须加分号。存储过程的结尾可以使用 delimiter重新设置。语法：delimiter 结束标记
  delimiter $
- 调用语法 #
  
  call 存储过程(实参列表);
  - 1.空参列表 #
    
    case1：插入到admin表中五条记录
    使用下面代码创建存储过程，
    然后使用语句call myp1();进行调用
```
delimiter $
create procedure myp1()
begin
 insert into admin(username, `password`) values('john1', '0000'), ('lily', '0000'), ('rose', '0000'), ('jack', '0000'), ('tom', '0000');
end $
```
  - 2.(IN)模式列表 #
    
    case1：创建存储过程实现根据女神名，查询对应的男神信息
    使用下面代码创建存储过程，
    然后使用语句call myp2('小昭');进行调用，控制台会展示返回值。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(FLOW CONTROL) #

简单介绍：
顺序结构：程序从上至下依次执行
分支结构：程序从两条或多条路径中选择一条去执行
循环结构：程序在满足一定条件的基础上，重复执行一段代码
- 分支结构 #
  - IF函数 #
    
    功能：实现简单的双分支
    
    语法：if(表达式1，返回值2，返回值3)
    如果表达式1成立，则if使用返回值2，否则使用返回值3.
    
    应用：任何地方
  - CASE函数 #
    特点：
    1). 可以作为表达式，嵌套在其他语句中使用，可以放在任何地方，begin end 中或begin end外面。可以作为单独的语句去使用，只能放在 begin end 中。
    2). 如果when中的值满足或条件成立，则执行对应的then后面的语句，并且结束case，如果都不满足，则执行else中的语句或值
    3). else可以省略，如果else省略了，并且所有when条件都不满足，则返回NULL。
    Note
    情况一：类似于java中的switch语句，一般用作实现等值判断
    
    case 变量|表达式|字段 when 要判断的值 then 返回的值1或语句1; when 要判断的值 then 返回的值1或语句1; ... else 返回的值n或语句n; end case;
    Note

Mon, 01 Jan 0001 00:00:00 +0000

HEAD #

表注释查询 #

-- oracle
select * from user_tab_comments where comments like '%危险%';

-- mysql
SELECT COLUMN_NAME,column_comment FROM INFORMATION_SCHEMA.Columns
WHERE table_name='表名' AND table_schema='数据库名'

父子路径 #

-- 宁夏，银川，金凤，良田镇
SELECT T2.*
FROM (
 SELECT
 @r AS _code,
 (SELECT @r := sgd_father_url FROM stats_gov_data WHERE sgd_source_url = _code) AS v2,
 @l := @l + 1 AS lvl
 FROM
 stats_gov_data h , (SELECT @r := '2020/64/01/06/640106100.html',@l :=0) vars
 WHERE @r <> '2020/index.html'

) T1
LEFT JOIN stats_gov_data T2 ON T1._code = T2.sgd_source_url
order by T1.lvl desc;

-- 甘肃省-天水市-武山县
SELECT T2.*
FROM (
 SELECT 
 @r AS _code, 
 (SELECT @r := raa_father_code FROM `rsp_administrative_area` WHERE raa_code = _code) AS v2, 
 @l := @l + 1 AS lvl 
 FROM 
 rsp_administrative_area h , (SELECT @r := '620524',@l :=0) vars 
 WHERE @r is not null) T1 
left JOIN rsp_administrative_area T2 
ON T1._code = T2.raa_code
order by T1.lvl desc;

-- 所有子节点，包括父节点
SELECT * FROM (

 SELECT t1.*,
 IF(FIND_IN_SET(rgp_father_id, @pids) > 0 OR rgp_id = 1, @pids := CONCAT(@pids, ',', rgp_id), '0') AS ischild
 FROM (
 SELECT * FROM rsp_grid_position AS t 
 -- WHERE t.rgp_id = '01' 
 ORDER BY t.rgp_id ASC
 ) t1,
 (SELECT @pids := 1 ) t2 
) t3 
WHERE ischild != '0'

时间处理 #

SELECT
 MONTH( "2019-03-11 13:24:51" ),
 YEAR ( "2019-03-11 13:24:51" ),
 DAY ( "2019-03-11 13:24:51" ),
 HOUR ( "2019-03-11 13:24:51" ),
 MINUTE ( "2019-03-11 13:24:51" ),
 SECOND ( "2019-03-11 13:24:51" );

SELECT now(), EXTRACT( DAY_SECOND FROM now( ) );

select unix_timestamp();
select from_unixtime(1683993600000 / 1000);
select curdate(), curtime(), date(now());
select EXTRACT(YEAR_MONTH FROM now()); -- MICROSECOND、SECOND、MINUTE、HOUR、DAY、WEEK、MONTH、QUARTER、YEAR、SECOND_MICROSECOND、MINUTE_MICROSECOND、MINUTE_SECOND、HOUR_MICROSECOND、HOUR_SECOND、HOUR_MINUTE、DAY_MICROSECOND、DAY_SECOND、DAY_MINUTE、DAY_HOUR、YEAR_MONTH
-- DATE_ADD(date,INTERVAL expr type)

select TIME_TO_SEC('00:06:53');
select str_to_date('2018-07-03 18:06:53', '%Y-%m-%d %H:%i:%s');
select date_format(now(), '%Y-%m-%d %H:%i:%s' );
select timediff('2018-07-03 19:13:21', '2018-07-03 18:06:53');

Mon, 01 Jan 0001 00:00:00 +0000

MySQL数据库设计规范___MSB___ #
1. 规范背景与目的 #
  
  MySQL数据库与 Oracle、 SQL Server 等数据库相比，有其内核上的优势与劣势。我们在使用MySQL数据库的时候需要遵循一定规范，扬长避短。本规范旨在帮助或指导RD、QA、OP等技术人员做出适合线上业务的数据库设计。在数据库变更和处理流程、数据库表设计、SQL编写等方面予以规范，从而为公司业务系统稳定、健康地运行提供保障。
2. 设计规范 #
  - 2.1 数据库设计 #
    
    以下所有规范会按照**【高危】、【强制】、【建议】**三个级别进行标注，遵守优先级从高到低。
    对于不满足【高危】和【强制】两个级别的设计，DBA会强制打回要求修改。
    - 2.1.1 库名 #
      1. 【强制】库的名称必须控制在32个字符以内，相关模块的表名与表名之间尽量提现join的关系，如user表和user_login表。
      2. 【强制】库的名称格式：业务系统名称_子系统名，同一模块使用的表名尽量使用统一前缀。
      3. 【强制】一般分库名称命名格式是库通配名_编号，编号从0开始递增，比如wenda_001以时间进行分库的名称格式是“库通配名_时间”
      4. 【强制】创建数据库时必须显式指定字符集，并且字符集只能是utf8或者utf8mb4。创建数据库SQL举例：create database db1 default character set utf8mb4;。
    - 2.1.2 表结构 #
      1. 【强制】表和列的名称必须控制在32个字符以内，表名只能使用字母、数字和下划线，一律小写。
      2. 【强制】表名要求模块名强相关，如师资系统采用”sz”作为前缀，渠道系统采用”qd”作为前缀等。
      3. 【强制】创建表时必须显式指定字符集为utf8或utf8mb4。
      4. 【强制】创建表时必须显式指定表存储引擎类型，如无特殊需求，一律为InnoDB。当需要使用除InnoDB/MyISAM/Memory以外的存储引擎时，必须通过DBA审核才能在生产环境中使用。因为Innodb表支持事务、行锁、宕机恢复、MVCC等关系型数据库重要特性，为业界使用最多的MySQL存储引擎。而这是其他大多数存储引擎不具备的，因此首推InnoDB。
      5. 【强制】建表必须有comment
      6. 【建议】建表时关于主键：(1)强制要求主键为id，类型为int或bigint，且为auto_increment标识表里每一行主体的字段不要设为主键，建议设为其他字段如user_id，order_id等，并建立unique key索引（可参考cdb.teacher表设计）。因为如果设为主键且主键值为随机插入，则会导致innodb内部page分裂和大量随机I/O，性能下降。
      7. 【建议】核心表（如用户表，金钱相关的表）必须有行数据的创建时间字段create_time和最后更新时间字段update_time，便于查问题。
      8. 【建议】表中所有字段必须都是NOT NULL属性，业务可以根据需要定义DEFAULT值。因为使用NULL值会存在每一行都会占用额外存储空间、数据迁移容易出错、聚合函数计算结果偏差等问题。
      9. 【建议】建议对表里的blob、text等大字段，垂直拆分到其他表里，仅在需要读这些对象的时候才去select。
      10. 【建议】反范式设计：把经常需要join查询的字段，在其他表里冗余一份。如user_name属性在user_account，user_login_log等表里冗余一份，减少join查询。
      11. 【强制】中间表用于保留中间结果集，名称必须以tmp_开头。备份表用于备份或抓取源表快照，名称必须以bak_开头。中间表和备份表定期清理。
      12. 【强制】对于超过100W行的大表进行alter table，必须经过DBA审核，并在业务低峰期执行。因为alter table会产生表锁，期间阻塞对于该表的所有写入，对于业务可能会产生极大影响。
    - 2.1.3 列数据类型优化 #
      1. 【建议】表中的自增列（auto_increment属性），快速增长的表推荐使用bigint类型。因为无符号int存储范围为-2147483648~2147483647（大约21亿左右），溢出后会导致报错。
      2. 【建议】业务中选择性很少的状态status、类型type等字段推荐使用tinytint或者smallint类型节省存储空间。
      3. 【建议】业务中IP地址字段推荐使用int类型，不推荐用char(15)。因为int只占4字节，可以用如下函数相互转换，而char(15)占用至少15字节。一旦表数据行数到了1亿，那么要多用1.1G存储空间。 SQL：select inet_aton('192.168.2.12'); select inet_ntoa(3232236044); PHP: ip2long(‘192.168.2.12’); long2ip(3530427185);
      4. 【建议】不推荐使用enum，set。因为它们浪费空间，且枚举值写死了，变更不方便。推荐使用tinyint或smallint。
      5. 【建议】不推荐使用blob，text等类型。它们都比较浪费硬盘和内存空间。在加载表数据时，会读取大字段到内存里从而浪费内存空间，影响系统性能。建议和PM、RD沟通，是否真的需要这么大字段。Innodb中当一行记录超过8098字节时，会将该记录中选取最长的一个字段将其768字节放在原始page里，该字段余下内容放在overflow-page里。不幸的是在compact行格式下，原始page和overflow-page都会加载。
      6. 【强制】存储金钱的字段，强制用decimal，禁止使用浮点型来存储金钱
      7. 【建议】文本数据尽量用varchar存储。因为varchar是变长存储，比char更省空间。MySQL server层规定一行所有文本最多存65535字节，因此在utf8字符集下最多存21844个字符，超过会自动转换为mediumtext字段。而text在utf8字符集下最多存21844个字符，mediumtext最多存2^24/3个字符，longtext最多存2^32个字符。一般建议用varchar类型，字符数不要超过2700。
      8. 【建议】时间类型尽量选取datetime类型，timestamp在不同的时区访问会有时区转换。更为高阶的方法，选用int来存储时间，使用SQL函数unix_timestamp()和from_unixtime()来进行转换。
    - 2.1.4 索引设计 #
      1. 【强制】InnoDB表必须主键为`id int/bigint auto_increment``,且主键值禁止被更新。
      2. 【建议】主键的名称以“pk_”开头，唯一键以“uniq_”开头，普通索引以“idx_”开头，一律使用小写格式，以表名/字段的名称或缩写作为后缀。
      3. 【强制】InnoDB和MyISAM存储引擎表，索引类型必须为BTREE；MEMORY表可以根据需要选择HASH或者BTREE类型索引。
      4. 【强制】单个索引中每个索引记录的长度不能超过64KB。
      5. 【建议】单个表上的索引个数不能超过16个。
      6. 【建议】在建立索引时，多考虑建立联合索引，并把区分度最高的字段放在最前面。如列userid的区分度可由select count(distinct userid)计算出来。
      7. 【建议】在多表join的SQL里，保证被驱动表的连接列上有索引，这样join执行效率最高。
      8. 【建议】建表或加索引时，保证表里互相不存在冗余索引。对于MySQL来说，如果表里已经存在key(a,b)，则key(a)为冗余索引，需要删除。
    - 2.1.5 分库分表、分区表 #
      1. 【强制】分区表的分区字段（partition-key）必须有索引，或者是组合索引的首列。
      2. 【强制】单个分区表中的分区（包括子分区）个数不能超过1024。
      3. 【强制】上线前RD或者DBA必须指定分区表的创建、清理策略。
      4. 【强制】访问分区表的SQL必须包含分区键。
      5. 【建议】单个分区文件不超过2G，总大小不超过50G。建议总分区数不超过20个。
      6. 【强制】对于分区表执行alter table操作，必须在业务低峰期执行。
      7. 【强制】采用分库策略的，库的数量不能超过1024
      8. 【强制】采用分表策略的，表的数量不能超过4096
      9. 【建议】单个分表不超过500W行，ibd文件大小不超过2G，这样才能让数据分布式变得性能更佳。
      10. 【建议】水平分表尽量用取模方式，日志、报表类数据建议采用日期进行分表。
    - 2.1.6 字符集 #
      1. 【强制】数据库本身库、表、列所有字符集必须保持一致，为utf8或utf8mb4,不要在表中给字段单独指定字符集。
      2. 【强制】前端程序字符集或者环境变量中的字符集，与数据库、表的字符集必须一致，统一为utf8mb4。
    - 2.1.7 程序层DAO设计建议 #
      1. 【建议】新的代码不要用model，推荐使用手动拼SQL+绑定变量传入参数的方式。因为model虽然可以使用面向对象的方式操作db，但是其使用不当很容易造成生成的SQL非常复杂，且model层自己做的强制类型转换性能较差，最终导致数据库性能下降。
      2. 【建议】前端程序连接MySQL或者redis，必须要有连接超时和失败重连机制，且失败重试必须有间隔时间。
      3. 【建议】前端程序报错里尽量能够提示MySQL或redis原生态的报错信息，便于排查错误。
      4. 【建议】对于有连接池的前端程序，必须根据业务需要配置初始、最小、最大连接数，超时时间以及连接回收机制，否则会耗尽数据库连接资源，造成线上事故。
      5. 【建议】对于log或history类型的表，随时间增长容易越来越大，因此上线前RD或者DBA必须建立表数据清理或归档方案。
      6. 【建议】在应用程序设计阶段，RD必须考虑并规避数据库中主从延迟对于业务的影响。尽量避免从库短时延迟（20秒以内）对业务造成影响，建议强制一致性的读开启事务走主库，或更新后过一段时间再去读从库。
      7. 【建议】多个并发业务逻辑访问同一块数据（innodb表）时，会在数据库端产生行锁甚至表锁导致并发下降，因此建议更新类SQL尽量基于主键去更新。
      8. 【建议】业务逻辑之间加锁顺序尽量保持一致，否则会导致死锁。
      9. 【建议】对于单表读写比大于10:1的数据行或单个列，可以将热点数据放在缓存里（如mecache或redis），加快访问速度，降低MySQL压力。
    - 2.1.8 一个规范的建表语句示例 #
      CREATE TABLE user ( id bigint NOT NULL AUTO_INCREMENT, user_id bigint NOT NULL DEFAULT 0 COMMENT '用户id', username varchar(64) NOT NULL DEFAULT '' COMMENT '真实姓名', email varchar(64) NOT NULL DEFAULT '' COMMENT '用户邮箱', nickname varchar(64) NOT NULL DEFAULT '' COMMENT '昵称', birthday date NOT NULL DEFAULT '1001-01-01' COMMENT '生日', sex tinyint NOT NULL DEFAULT 0 COMMENT '性别 0-男 1-女', short_introduce varchar(128) NOT NULL DEFAULT '' COMMENT '一句话介绍自己，最多128个汉字', user_resume varchar(256) NOT NULL DEFAULT '' COMMENT '用户提交的简历存放地址', create_time datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '用户记录创建的时间', update_time datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '用户资料修改的时间', user_review_status tinyint NOT NULL DEFAULT 4 COMMENT '用户资料审核状态，1为通过，2为审核中，3为未通过，4为还未提交审核', PRIMARY KEY (id), UNIQUE KEY uniq_user_id (user_id), KEY idx_username(username), KEY idx_create_time(create_time) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='网站用户基本信息';
  - 2.2 SQL编写 #
    - 2.2.1 DML语句 #
      1. 【强制】SELECT语句必须指定具体字段名称，禁止写成*。因为select *会将不该读的数据也从MySQL里读出来，造成网卡压力。且表字段一旦更新，但model层没有来得及更新的话，系统会报错。
      2. 【强制】insert语句指定具体字段名称，不要写成insert into t1 values(…)，道理同上。
      3. 【建议】insert into…values(XX),(XX),(XX)…。这里XX的值不要超过5000个。值过多虽然上线很很快，但会引起主从同步延迟。
      4. 【建议】SELECT语句不要使用UNION，推荐使用UNION ALL，并且UNION子句个数限制在5个以内。因为union all不需要去重，节省数据库资源，提高性能。
      5. 【建议】in值列表限制在200以内。例如select… where userid in(….200个以内…)，这么做是为了减少底层扫描，减轻数据库压力从而加速查询。
      6. 【建议】事务里批量更新数据需要控制数量，进行必要的sleep，做到少量多次。
      7. 【强制】事务涉及的表必须全部是innodb表。否则一旦失败不会全部回滚，且易造成主从库同步终端。
      8. 【强制】写入和事务发往主库，只读SQL发往从库。
      9. 【强制】除静态表或小表（100行以内），DML语句必须有where条件，且使用索引查找。
      10. 【强制】生产环境禁止使用hint，如sql_no_cache，force index，ignore key，straight join等。因为hint是用来强制SQL按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的，因此我们要相信MySQL优化器！
      11. 【强制】where条件里等号左右字段类型必须一致，否则无法利用索引。
      12. 【建议】SELECT|UPDATE|DELETE|REPLACE要有WHERE子句，且WHERE子句的条件必需使用索引查找。
      13. 【强制】生产数据库中强烈不推荐大表上发生全表扫描，但对于100行以下的静态表可以全表扫描。查询数据量不要超过表行数的25%，否则不会利用索引。
      14. 【强制】WHERE 子句中禁止只使用全模糊的LIKE条件进行查找，必须有其他等值或范围查询条件，否则无法利用索引。
      15. 【建议】索引列不要使用函数或表达式，否则无法利用索引。如where length(name)='Admin'或where user_id+2=10023。
      16. 【建议】减少使用or语句，可将or语句优化为union，然后在各个where条件上建立索引。如where a=1 or b=2优化为where a=1… union …where b=2, key(a),key(b)。
      17. 【建议】分页查询，当limit起点较高时，可先用过滤条件进行过滤。如select a,b,c from t1 limit 10000,20;优化为: select a,b,c from t1 where id>10000 limit 20;。
    - 2.2.2 多表连接 #
      1. 【强制】禁止跨db的join语句。因为这样可以减少模块间耦合，为数据库拆分奠定坚实基础。
      2. 【强制】禁止在业务的更新类SQL语句中使用join，比如update t1 join t2…。
      3. 【建议】不建议使用子查询，建议将子查询SQL拆开结合程序多次查询，或使用join来代替子查询。
      4. 【建议】线上环境，多表join不要超过3个表。
      5. 【建议】多表连接查询推荐使用别名，且SELECT列表中要用别名引用字段，数据库.表格式，如select a from db1.table1 alias1 where …。
      6. 【建议】在多表join中，尽量选取结果集较小的表作为驱动表，来join其他表。
    - 2.2.3 事务 #
      1. 【建议】事务中INSERT|UPDATE|DELETE|REPLACE语句操作的行数控制在2000以内，以及WHERE子句中IN列表的传参个数控制在500以内。
      2. 【建议】批量操作数据时，需要控制事务处理间隔时间，进行必要的sleep，一般建议值5-10秒。
      3. 【建议】对于有auto_increment属性字段的表的插入操作，并发需要控制在200以内。
      4. 【强制】程序设计必须考虑“数据库事务隔离级别”带来的影响，包括脏读、不可重复读和幻读。线上建议事务隔离级别为repeatable-read。
      5. 【建议】事务里包含SQL不超过5个（支付业务除外）。因为过长的事务会导致锁数据较久，MySQL内部缓存、连接消耗过多等雪崩问题。
      6. 【建议】事务里更新语句尽量基于主键或unique key，如update … where id=XX; 否则会产生间隙锁，内部扩大锁定范围，导致系统性能下降，产生死锁。
      7. 【建议】尽量把一些典型外部调用移出事务，如调用webservice，访问文件存储等，从而避免事务过长。
      8. 【建议】对于MySQL主从延迟严格敏感的select语句，请开启事务强制访问主库。
    - 2.2.4 排序和分组 #
      1. 【建议】减少使用order by，和业务沟通能不排序就不排序，或将排序放到程序端去做。order by、group by、distinct这些语句较为耗费CPU，数据库的CPU资源是极其宝贵的。
      2. 【建议】order by、group by、distinct这些SQL尽量利用索引直接检索出排序好的数据。如where a=1 order by可以利用key(a,b)。
      3. 【建议】包含了order by、group by、distinct这些查询的语句，where条件过滤出来的结果集请保持在1000行以内，否则SQL会很慢。
    - 2.2.5 线上禁止使用的SQL语句 #
      1. 【高危】禁用update|delete t1 … where a=XX limit XX; 这种带limit的更新语句。因为会导致主从不一致，导致数据错乱。建议加上order by PK。
      2. 【高危】禁止使用关联子查询，如update t1 set … where name in(select name from user where…); 效率极其低下。
      3. 【强制】禁用procedure、function、trigger、views、event、外键约束。因为他们消耗数据库资源，降低数据库实例可扩展性。推荐都在程序端实现。
      4. 【强制】禁用insert into …on duplicate key update… 在高并发环境下，会造成主从不一致。
      5. 【强制】禁止联表更新语句，如update t1,t2 where t1.id=t2.id…。
Reference #

© Archery (v1.7.9)

Mon, 01 Jan 0001 00:00:00 +0000

Netty编码流程 #

写一个简单的http server

public class TestServer {
 public static void main(String[] args) {
 EventLoopGroup bossGroup = new NioEventLoopGroup();
 EventLoopGroup wordGroup = new NioEventLoopGroup();

 ServerBootstrap serverBootstrap = new ServerBootstrap();

 try {
 serverBootstrap.group(bossGroup,wordGroup)
 .channel(NioServerSocketChannel.class)
 
 // channel初始化器
 .childHandler(new ChannelInitializer<SocketChannel>() {
 @Override
 protected void initChannel(SocketChannel socketChannel) throws Exception {
 ChannelPipeline pipeline = socketChannel.pipeline();
 pipeline.addLast("httpServerCodec",new HttpServerCodec());
 
 // 在pipeline中加入自定义的解码器 handler
 pipeline.addLast("httpServerContent", new SimpleChannelInboundHandler<HttpObject>() {
 @Override
 protected void channelRead0(ChannelHandlerContext channelHandlerContext, HttpObject msg) throws Exception {
 /* 
 另外有一个 LastHttpContent 类型的 EMPTY_LAST_CONTENT 对象
 来源：HttpServerCodec 中 inboundHandler 为 HttpServerRequestDecoder ==> HttpObjectDecoder
 channelRead 的时候会进行解码，追加两个对象；
 out.add(message);
 out.add(LastHttpContent.EMPTY_LAST_CONTENT);
 所以追加if判断
 */
 if(msg instanceof HttpRequest){
 ByteBuf byteBuf = Unpooled.copiedBuffer("hello world", CharsetUtil.UTF_8);
 FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,HttpResponseStatus.OK,byteBuf);
 response.headers().set(HttpHeaderNames.CONTENT_TYPE,"text/plain");
 response.headers().set(HttpHeaderNames.CONTENT_LENGTH,byteBuf.readableBytes());
 response.headers().set(HttpHeaderNames.SERVER,"X-eli");

 channelHandlerContext.writeAndFlush(response);
 }
 }
 });
 }
 });
 ChannelFuture channelFuture = serverBootstrap.bind(13308).sync();
 channelFuture.channel().closeFuture().sync();
 }catch (Exception e){
 e.printStackTrace();
 }finally {
 bossGroup.shutdownGracefully();
 wordGroup.shutdownGracefully();
 }
 }
}

Reference #

https://www.bilibili.com/video/BV1c4411J7Ty?p=5

Mon, 01 Jan 0001 00:00:00 +0000

Netty 是什么 #

Netty 是一个基于 NIO的client-server(客户端服务器)框架，使用它可以快速简单地开发网络应用程序。
它极大地简化并优化了 TCP 和 UDP套接字服务器等网络编程,并且性能以及安全性等很多方面甚至都要更好。
支持多种协议如 FTP，SMTP，HTTP 以及各种二进制和基于文本的传统协议。

优点 #

placeholder
- 统一的 API，支持多种传输类型，阻塞和非阻塞的。
- 简单而强大的线程模型。
- 自带编解码器解决 TCP 粘包/拆包问题。
- 自带各种协议栈。
- 真正的无连接数据包套接字支持。
- 比直接使用 Java 核心 API 有更高的吞吐量、更低的延迟、更低的资源消耗和更少的内存复制。
- 安全性不错，有完整的 SSL/TLS 以及 StartTLS 支持。
- 社区活跃
- 成熟稳定，经历了大型项目的使用和考验，而且很多开源项目都使用到了 Netty，比如我们经常接触的 Dubbo、RocketMQ 等等。

应用场景 #

placeholder
- 作为 RPC 框架的网络通信工具
- 实现一个自己的 HTTP 服务器
- 实现一个即时通讯系统
- 实现消息推送系统

知识点 #

placeholder
- netty 核心组件有哪些？分别有什么作用
- EventloopGroup了解么？和Eventloop有什么关系？
- BootStrap和ServerBootStrap了解么？
- NioEventLoopGroup 默认的构造函数会起多少线程？
- Netty 线程模型了解吗？
- netty 服务端和客户端的启动过过程了解吗？
- netty 长链接和心跳机制？
- netty 零拷贝？
- netty中空轮询BUG

Reference #

https://gee.cs.oswego.edu/dl/cpjslides/nio.pdf

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Install) #

压缩包安装 #

配置环境

# 启动服务器
$ docker run -d -p 6379:6379 --name redis-6.2.8 redis:6.2.8 redis-server --save 60 1 --loglevel warning

# 使用自定义的配置文件
$ docker run -d -p 6379:6379 -v /myredis/conf:/usr/local/etc/redis --name redis-6.2.8 redis:6.2.8 redis-server /usr/local/etc/redis/redis.conf

测试

# 使用redis容器内部客户端进行访问
$ docker run -it --rm --network host redis:6.2.8 redis-cli -h 127.0.0.1

Mon, 01 Jan 0001 00:00:00 +0000

NoSql数据库的四大分类 #

表格视图 #

分类	Example举例	典型应用场景	数据模型	优点	缺点
键值(key-value)	Tokyo,Cabinet/Tyrant,Redis,Voldemort,Oracle BDB	内容缓存，主要用于处理大量数据的高访问负载，也用于一些日志系统等	key指向value的键值对，通常用hashtable来实现	查找速度快	数据无结构化，通常只被当作字符串或者二进制数据
列存储数据库	Cassandra，HBase,Riak	分布式的文件系统	以列簇式存储，将同一列数据存放在一起	查找速度快，可扩展性强，更容易进行分布式扩展	功能相对局限
文档型数据库	CouchDB，MongoDb	web应用（与Key-value类似，value是结构化的，不同的是数据库能够了解Value的内容）	key-value对应的键值对，value为结构化数据	数据结构要求不严格，表结构可变，不需要向关系型数据库一样预先定义表结构	查询性能不高，而且缺乏统一的查询语法
图形数据库	Neo4j,InfoGrid,Infinite Graph	社交网络，推荐系统等，专注于构建关系图谱	图结构	利用图层结构相关算法，比如最短路径寻址等	很多时候需要对整个图做计算才能得出需要的信息

分布式数据库中的CAP原理CAP+BASE #

传统的acid分别是什么 #
- A（Atomicity）原子性
原子性很容易理解，也就是说事务里的所有操作要么全部完成，要么不做，事务成功的条件是事务里的所有操作都成功，只要有一个操作失败，整个事务就是失败的，需要回滚。比如银行转账，从A向B转100元，分为两个步骤，1）从A账户减100，2）在B账户加100。
- C（Consistency）一致性
数据库要一直处于一致的状态，事务的运行不会改变数据库原本的一致性约束
- I（Isolation）隔离性
所谓的隔离性是指并发的事务之间不会互相影响，如果一个事务要访问的数据正在被另一个事务修改，只要另外一个事务未提交，它所访问的数据就不受未提交事务的影响，比如有个事务要完成A——》B转账100元，只要事务还没提交（未完成）的情况下，B查询自己的账户余额，是看不到新增加的100元的
- D（Durability）持久性
持久性是指一旦事务提交后，它所做的修改将会永久的保存在数据库上，即使宕机也不会丢失。
CAP #
- C（Consistency）强一致性
Consistency 中文叫做"一致性"。意思是，写操作之后的读操作，必须返回该值。举例来说，某条记录是 v0，用户向 G1 发起一个写操作，将其改为 v1。接下来，用户的读操作就会得到 v1。这就叫一致性。问题是，用户有可能向 G2 发起读操作，由于 G2 的值没有发生变化，因此返回的是 v0。G1 和 G2 读操作的结果不一致，这就不满足一致性了。为了让 G2 也能变为 v1，就要在 G1 写操作的时候，让 G1 向 G2 发送一条消息，要求 G2 也改成 v1。

Mon, 01 Jan 0001 00:00:00 +0000

hello brpc

Mon, 01 Jan 0001 00:00:00 +0000

hello dubbo

Mon, 01 Jan 0001 00:00:00 +0000

hello gRpc

Mon, 01 Jan 0001 00:00:00 +0000

hello avro

Mon, 01 Jan 0001 00:00:00 +0000

hello fst

Mon, 01 Jan 0001 00:00:00 +0000

hello hession

Mon, 01 Jan 0001 00:00:00 +0000

hello jdk build in

Mon, 01 Jan 0001 00:00:00 +0000

hello json or xml

Mon, 01 Jan 0001 00:00:00 +0000

hello kryo

Mon, 01 Jan 0001 00:00:00 +0000

hello protobuf

Mon, 01 Jan 0001 00:00:00 +0000

hello thrift

Mon, 01 Jan 0001 00:00:00 +0000

启动流程 #

流程图 #

伪代码 #

main方法启动： SpringApplication.run(SpringbootApplication.class, args);
new SpringApplication(sources).run();

SpringApplication#init构造器中的初始化过程

private void initialize(Object[] sources) {
 if (sources != null && sources.length > 0) {
 this.sources.addAll(Arrays.asList(sources));
 }
 this.webEnvironment = deduceWebEnvironment();
 setInitializers((Collection) getSpringFactoriesInstances(
 ApplicationContextInitializer.class));
 setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
 this.mainApplicationClass = deduceMainApplicationClass();
}

SpringApplication#run

public ConfigurableApplicationContext run(String... args) {
 StopWatch stopWatch = new StopWatch();
 stopWatch.start();
 ConfigurableApplicationContext context = null;
 FailureAnalyzers analyzers = null;
 configureHeadlessProperty();
 SpringApplicationRunListeners listeners = getRunListeners(args);
 listeners.starting();
 try {
 ApplicationArguments applicationArguments = new DefaultApplicationArguments(
 args);
 ConfigurableEnvironment environment = prepareEnvironment(listeners,
 applicationArguments);
 Banner printedBanner = printBanner(environment);
 context = createApplicationContext();
 analyzers = new FailureAnalyzers(context);
 prepareContext(context, environment, listeners, applicationArguments,
 printedBanner);
 refreshContext(context);
 afterRefresh(context, applicationArguments);
 listeners.finished(context, null);
 stopWatch.stop();
 if (this.logStartupInfo) {
 new StartupInfoLogger(this.mainApplicationClass)
 .logStarted(getApplicationLog(), stopWatch);
 }
 return context;
 }
 catch (Throwable ex) {
 handleRunFailure(context, listeners, analyzers, ex);
 throw new IllegalStateException(ex);
 }
}

自动装配 #

Reference #

https://blog.csdn.net/weixin_44947701/article/details/124055713

Mon, 01 Jan 0001 00:00:00 +0000

comming soon…

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Startup Process) #

spring.version = 4.3.7.RELEASE

Tip
1.) ApplicationContext继承了BeanFactory接口，在内部实现中采用委托的方式调用正真的beanfactory.
- 解析流程 #
  
  1). 以ClassPathXmlApplicationContext为例，新建一个应用上下文：new ClassPathXmlApplicationContext("_framework/spring/res/factory-bean.xml");
  
  2). 紧接着通过super(parent)调用父类构造器，一直往上传，直到AbstractApplicationContext,调用自己无参构造器this();后，使用setParent(parent);设置父属性。
  在this()内部获取一个PathMatchingResourcePatternResolver().
  
  3). 然后是设置配置文件位置setConfigLocations(configLocations);,对于每一个配置文件，都会通过getEnvironment()获取环境变量StandardEnvironment对象解决(~~配置文件~~)配置文件路径中的占位符。
  
  4). 接下来进入主题AbstractApplicationContext#refresh();
  - refresh() #
    - 01). prepareRefresh() #
      
      对于刷新这个上下文做准备。记录启动时间，关闭状态，激活状态。
      以及留给子类去初始化propertySource的方法initPropertySources();，
      获取环境并校验通过ConfigurablePropertyResolver#setRequiredProperties设置的必需属性，委托给 AbstractPropertyResolver 去执行校验。
      另外准备一个保存应用事件的set容器。
    - 02). obtainFreshBeanFactory() #
      
      获取一个新的bean工厂。
      
      protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;由子类去处理。
      
      通过createBeanFactory()方法new一个 DefaultListableBeanFactory bean工厂
      
      customizeBeanFactory(beanFactory);根据需要设置bean定义覆盖和循环引用的标志。
      - 02.1). loadBeanDefinitions #
        
        loadBeanDefinitions(beanFactory);加载bean定义，是抽象类AbstractRefreshableApplicationContext中定义的方法，由子类AbstractXmlApplicationContext去实现。
        
        创建beanDefinitionReader，传递benafactory给父类AbstractBeanDefinitionReader初始化 resourceLoader 和 environment 属性。但是在后续步骤中，使用了applicationContext的环境覆盖了自己刚才初始化的，包括ResourceLoader也一样。并且在reader对象中保存当前beanfactory，方便后续进行操作。
        
        initBeanDefinitionReader(beanDefinitionReader) ，初始化reader属性，比如设置validate=true.
        loadBeanDefinitions(beanDefinitionReader) ，使用reader从配置文件中加载beandefinitions到beanfactory中。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(FactoryBean) #

spring.version = 4.3.7.RELEASE

准备编码 #

// 创建普通bean
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Tool {

 private int id;

}

// 创建工厂
@Data
public class ToolFactory implements FactoryBean<Tool> {

 private int factoryId;

 private int toolId;

 @Override
 public Tool getObject() throws Exception {
 return new Tool(toolId);
 }

 @Override
 public Class<?> getObjectType() {
 return Tool.class;
 }

 @Override
 public boolean isSingleton() {
 return false;
 }
}

<!-- factory-bean.xml -->

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 <!-- FactoryBean work process -->
 <bean id="toolFB" class="_framework.spring.factory_bean.beans.ToolFactory">
 <property name="factoryId" value="9090" />
 <property name="toolId" value="2" />
 </bean>

</beans>

public class SpringFactoryBeanTest {

 public static void main(String[] args) {

 ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("_framework/spring/res/factory-bean.xml");
 ToolFactory fb = applicationContext.getBean("&toolFB", ToolFactory.class);
 Tool tool1 = applicationContext.getBean(Tool.class);
 Tool tool2 = applicationContext.getBean(Tool.class);
 System.out.println();
 applicationContext.destroy();

 }

}

解析流程 #

1). 初始化bean对象：在refresh()里面通过obtainFreshBeanFactory()方法创建扫描到beanDefinition的顶级工厂。然后通过方法finishBeanFactoryInitialization(beanFactory);实例化所有非懒加载的所有单例bean,此处就包含这个工厂bean对象。

Mon, 01 Jan 0001 00:00:00 +0000

spring 是什么 #

Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。

spring 优点 #

低入侵，减少代码耦合，支持一些通用任务（鉴权，日志，事务等）的集中管理，对其他一些框架提供集成支持

spring IOC 理解 #

IOC

IOC(Inversion of control. 控制反转)，将bean对象的控制权交由spring去管理。其中包括bean对象的创建与销毁，bean对象之间的依赖关系等。简单来讲，就是对象不用我们去new了，而是框架帮我们使用反射的方式去创建。用户只需要在使用的时候注入即可。
DI

DI (dependency inject ,依赖注入)，程序运行期间如果发现对象需要依赖其他的对象。就会通过反射的方式自动处理依赖关系。反射的功能就是在程序运行期间动态的生成对象，执行对象的方法，改变对象的属性等功能。

spring AOP 理解 #

AOP 面向切面编程。作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。编程中使用cglib和jdk两种动态代理来实现。

BeanFactory 和 ApplicationContext区别 #

MessageSource

用于消息资源国际化
ResourcePatternResolver

在上一篇中我们介绍了Resource接口，它的出现是为了解决spring方便访问各种配置信息。但Resource接口有一个问题，就是如果我们要访问同一个路径下的所有符合条件的配置，如果用Resource接口则会比较麻烦，因为它不支持通配符方式的文件读取，所以要将读取的配置文件名称全部写出来才可以。 spring为了解决这个问题，于是新定义了一个新接口，并实现了该接口特有的特性，也就是支持类似 Ant风格的通配符
ApplicationEventPublisher

时间发布器
EnvironmentCapable

提供环境处理能力，getEnvironment()返回的 Environment 不可配置。所以在ConfigurableApplicationContext重新定义getEnvironment()并缩小签名以返回一个ConfigurableEnvironment。在此之前环境对象是只读的。

spring 容器启动流程 #

启动流程

代码示例

@Override
public void refresh() throws BeansException, IllegalStateException {
 synchronized (this.startupShutdownMonitor) {
 // Prepare this context for refreshing.
 // 准备这个上下文以便刷新，设置它的启动日期和活动标志，并执行PropertySource属性源的任何初始化。
 prepareRefresh();

 // Tell the subclass to refresh the internal bean factory.
 // DefaultListableBeanFactory beanFactory = createBeanFactory();
 // beanFactory.setSerializationId(getId());
 // customizeBeanFactory(beanFactory);
 // loadBeanDefinitions(beanFactory);
 // 如果开启包扫描，会默认加载6个bd,(根据环境不同，可能数量有变，比如还可能有EJB的) 参见下图
 // class org.springframework.context.annotation.ConfigurationClassPostProcessor
 // class org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
 // class org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor
 // class org.springframework.context.annotation.CommonAnnotationBeanPostProcessor
 // CommonAnnotationBeanPostProcessor 是根据 jsr250 加载的。
 // private static final boolean jsr250Present = ClassUtils.isPresent("javax.annotation.Resource", AnnotationConfigUtils.class.getClassLoader());
 // class org.springframework.context.event.DefaultEventListenerFactory
 // class org.springframework.context.event.EventListenerMethodProcessor
 // return beanFactory;
 // 一般来说ApplicationContext自己没有实现BeanFactory相关方法，而是委托给自己刚才实例化的属性 beanFactory 来实现BeanFactory效果的。
 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

 // Prepare the bean factory for use in this context.
 // 初始化 beanFactory 相关属性。
 prepareBeanFactory(beanFactory);

 try {
 // Allows post-processing of the bean factory in context subclasses.
 // 让子类继续处理 beanFactory 增加或修改属性。比如WebApplicationContext
 // beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
 // beanFactory.ignoreDependencyInterface(ServletContextAware.class);
 // beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
 // WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
 // WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
 postProcessBeanFactory(beanFactory);

 // Invoke factory processors registered as beans in the context.
 // 调用在上下文中已注册为bean的工厂处理器，来增加或修改属性。
 // 比如ConfigurationClassPostProcessor。创建了一个org.springframework.context.annotation.internalConfigurationAnnotationProcessor对象。
 // 且给beanFactory的属性：beanPostProcessors 增加了一个 ImportAwareBeanPostProcessor。

 // 1027追加注释 
 // 内部逻辑先找 实现了BeanDefinitionRegistryPostProcessor接口的 实例化然后按顺序进行接口调用。因为这个接口继承自BeanFactoryPostProcessor.所以还会对这个接口也进行调用。
 // 然后是其余的BeanFactoryPostProcessor 这个接口 实例化后再按照顺序进行接口调用
 invokeBeanFactoryPostProcessors(beanFactory);

 // Register bean processors that intercept bean creation.
 // 向容器中实例化BeanPostProcessor，并追加到beacFactory的属性：beanPostProcessors中。

 // 1027追加注释 
 // 和上面调用一样，不过这次找的是BeanPostProcessor接口，另外会追加属性 到 beanPostProcessors中。因为这个接口的功能是对Bean的创建进行拦截处理实例用的。而不是修改beanDefinition用的。
 registerBeanPostProcessors(beanFactory);

 // Initialize message source for this context.
 initMessageSource();

 // Initialize event multicaster for this context.
 initApplicationEventMulticaster();

 // Initialize other special beans in specific context subclasses.
 // 对于EmbedWebApplicationContext 调用 createEmbeddedServletContainer();
 onRefresh();

 // Check for listener beans and register them.
 registerListeners();

 // Instantiate all remaining (non-lazy-init) singletons.
 finishBeanFactoryInitialization(beanFactory);

 // Last step: publish corresponding event.
 finishRefresh();
 }
 // ...
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

springmvc 执行流程 #

过滤器 #

拦截器 #

数据绑定 #

消息转换器 #

异常处理 #

注解ExceptionHandler

注解ExceptionHandler作用对象为方法，最简单的使用方法就是放在controller文件中，详细的注解定义不再介绍。如果项目中有多个controller文件，通常可以在baseController中实现ExceptionHandler的异常处理，而各个contoller继承basecontroller从而达到统一异常处理的目的。因为比较常见，简单代码如下：
单个controller处理
```
@ExceptionHandler(Exception.class)
@ResponseBody
public String exceptionHandler(Exception ex){
 return this.getClass().getSimpleName() + ": " + ex.getMessage();
} 
```
注解ControllerAdvice

这里虽说是ControllerAdvice注解，其实是其与ExceptionHandler的组合使用。在上文中可以看到，单独使用@ExceptionHandler时，其必须在一个Controller中，然而当其与ControllerAdvice组合使用时就完全没有了这个限制。换句话说，二者的组合达到的全局的异常捕获处理。

*** 注解ControllerAdvice 等级低于第一个。而且第一个只处理当前Controller。顺序为 @ExceptionHandler,@ControllerAdvice,HandlerExceptionResolver
全局异常处理
```
@ControllerAdvice
public class ExceptionHandlerAdvice {
 //也可以出现 自定义Exception，和其他Exception
 @ExceptionHandler(Exception.class)
 @ResponseBody
 public String exceptionHandler(Exception ex){
 return this.getClass().getSimpleName() + ": " + ex.getMessage();
 }
} 
```
实现HandlerExceptionResolver接口

Mon, 01 Jan 0001 00:00:00 +0000

Intro(TOMCAT-CORE) #

tomcat.version = 8.5.35
offical git repo | tag = 3.5.35 learning git repo
tomcat-8.5-doc
download 8.5.35
- 概念解释 #
- 整体架构 #
  
  Connector（【coyote】处理socket连接，负责网络字节流）
  Container（【Catalina】加载servlet处理具体请求）
  
  https://stackoverflow.com/questions/32985051/what-are-the-tomcat-component-what-is-catalina-and-coyote
- 启动流程 #
  
  先是初始化
  BootStrap->Calaline->Server->Service
  BootStrap->Calaline->Server->Service->[Engine->Host->Context]
  BootStrap->Calaline->Server->Service->[Executor]
  BootStrap->Calaline->Server->Service->[ProtocalHandler]
  然后调用start启动整个tomcat
- I/O模型和协议 #
  
  BIO，NIO，AIO（NIO2），APR
  HTTP/1.1，HTTP/2，AJP（用于和apache服务器集成用来处理静态资源）
- Jasper引擎 #
  
  index.jsp -> jspServlet(找到文件) -> 渲染成servlet.class-> 加载调用
- Context #
  
  官方不建议直接在server.xml中配置，因为，server.xml文件只会在tomcat重新的时候重新加载。
  1. In an individual file at /META-INF/context.xml inside the application files
  2. In individual files (with a “.xml” extension) in the $CATALINA_BASE/conf/[enginename]/[hostname]/ directory
  3. Inside a Host element in the main conf/server.xml.
- 安全 #
  
  1). 删除webapp下面的管理页面和其他项目
  2). 禁用server-user.xml里面的权限或者直接删除
  3). 修改tomcat默认关机指令，或者禁用
  4). 配置错误页面。

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Zookeeper) #

压缩包安装 #

配置环境

# 启动服务器
$ docker run -d -p 2181:2182 --name zookeeper-3.6.3 zookeeper:3.6.3

# 使用自定义的配置文件
$ docker run -d -p 2181:2182 -v $(pwd)/zoo.cfg:/conf/zoo.cfg --restart always --name zookeeper-3.6.3 zookeeper:3.6.3

测试

# 使用redis容器内部客户端进行访问
$ docker run -it --rm --network host zookeeper:3.6.3 zkCli.sh -server 127.0.0.1[:2181]

Mon, 01 Jan 0001 00:00:00 +0000

ZK 简介 #

zab协议

description

ZK 实现原理 #

ZK 常用命令 #

command	function
help	显示所有命令操作
ls path [watch]	使用ls 命令来查看当前znode中所包含的内容
ls2 path [watch]	查看当前节点数据，并能看到更新次数等数据
create	普通创建 -s 含有序列，-e 临时（重启或者超时消失）
get path [watch]	获得节点值
set	设置节点具体值
stat	查看节点状态
delete	删除节点
rmr	递归删除节点

ZK stat 结构 #

show	explain
cZxid = 0x20000000e	create 创建znode更改的事务ID
ctime = Thu Aug 04 09: 33:08 UTC 2022	create znode 创建时间
mZxid = 0x20000000e	modify 修改znode更改的事务ID
mtime = Thu Aug 04 09:33:08 UTC 2022	modify 修改时间
pZxid = 0x20000000e	p…. 添加或删除子节点的znode更改事务ID
cversion = 0	表示对此znode子节点进行更改的次数
dataVersion = 0	表示对此znode数据的更改次数
aclVersion = 0	表示对此znode的ACL进行更改的次数
ephemeralOwner = 0x0	ephemeral类型？znode 所有者session Id : 0
dataLength = 11	znode 数据字段长度
numChildren = 0	znode 的子节点的数量

ZK 应用 #

共享锁
- explain
description

Mon, 01 Jan 0001 00:00:00 +0000

Intro(FRIDA) #

APK 加固信息
通过MT文件管理器 -> 安装包提取(左侧菜单) -> 选择应用，查看加固状态
```
# app-demo
site.example.framework

# 哔哩哔哩
tv.danmaku.bili

# 个人所得税
cn.gov.tax.its

# 交管12302
com.tmri.app.main
```
command

frida -D 192.168.1.200:5544 -l agent/frida_multiple_unpinning.js -f com.tmri.app.main -F
frida -U -f com.example.seccon2015.rock_paper_scissors -l _agent.js
frida --debug --runtime=v8 -U -f com.example.seccon2015.rock_paper_scissors -l _agent.js
frida -D local -l _lesson/function.js -n hello
frida-ps -D 192.168.1.200:5544 -a
frida-ps -D local | grep hello

adb shell pm path

Mon, 01 Jan 0001 00:00:00 +0000

Intro(ImHex | 十六进制编辑器) #

一个瑞士小孩哥使用 C++23 写的开源 十六进制编辑器，主要包括十六进制预览（Hex editor），单多字节数据编码（data inspector）,基于节点的预处理器（data processor）,书签列表（Bookmarks），一些其他内置工具，数据分析和图表可视统计，使用向导，在线商店，其中包括各路大神写的（类库，magic文件，编码集等）。
当然，最主要，也是最核心的就是下面需要单独介绍的模式语言（暂且这么翻译）。

使用场景：
针对某个实例文件，结合模式语言，展现结构列表，可视化二进制数据。比如分析 java 字节码， RIFF,ANI 文件格式分析，或者分析 ext2 文件系统等。

当前使用版本 v1.37.4
优点的话：开源，看不惯的话可以改。马上快 50K 的星标了，你想想。
缺点目前来说的话，就是，macosx 上面一不小心就闪退了，window上面保存项目文件，不知道死哪儿去了。数据处理器不能复用，另外模式语言部分的文档缺少示例，api 文档定义跟开玩笑一样。

软件使用官方文档。
开源仓库地址。
ImHex Pattern language #

ImHex 的精髓所在。简单的理解，就是通过模式编辑器（Pattern editor），通过编程的方式将二进制文件按照内存地址解析成对应的模式(变量)，并通过 Pattern Data 视图窗口将数据展示出来，可以自定义展示数据格式，颜色等，数据布局，格式分布一目了然。类比于 Java POJO中的 toString()。参考文档

如果有main函数会直接调用。
- 前期准备 #
```
4D 5A 90 00 03 00 00 00 04 00 00 00 FF 01 00 00 B8 00 00 00 00 00 06 00 40 00 00 00 00 00 1A 41 00 00 20 00 40 00 21 00 1A 2D 44 54 FB 21 09 40 00 00 00 05 00 80 C3 8D 00 01 02 00 00 00 00 00 54 C9 A7 0A F5 A0 A5 0B 52 69 63 68 F4 A0 A5 0B 00 01 02 68 65 6C 6C 6F 00 69 51 44 75 2E 00 00 00 00 00 00 02 94 5F 00 00 00 00 00 00 00 00 00
```
  准备一份分析用的二进制数据

Mon, 01 Jan 0001 00:00:00 +0000

Intro( 2024款 280TSI 手动先锋版) #
- 确认 #
  1. 有没有现车，颜色有哪些？几月份生产的？合格证？
  2. 可不可以代办【异地临牌】，多长时间？（如果缴纳订金自己去办理）。
  3. 全国联保【平安，人保】？保险（交强险，三者险，车损险，驾乘险【几十】，医保外用药【100+】）
- 流程 #
  - 先去看车，有没有现车，合格证（确保当天可以提车）
  - 砍价，
  - 签购车合同， 0. 车辆品牌，型号，配置，外观内饰颜色, 生产日期，
    1. 签订合同价格明细(裸车价，保险，上牌，购置税）
    2. 购车合同必须注明是新车，不要（展车，库存车，试驾车，有损车等）
    3. 注明提车日期（逾期未交车，定金全额退款，或者延迟赔付，现金补偿）
    4. 定金/订金？
    5. 谈好的赠品/随车工具,
    6. 备注除了以上费用外，无任何其他费用。
  - ~~订金（全额退款）？~~
  - 验车，
    - 生产日期
      - 车辆铭牌（车架号，挡风玻璃下方也有）
      - 轮胎日期（四个数字，周数+年数，五个轮胎生产日期一般不要过早于汽车生产日期）
      - 玻璃日期（数字代表年份，点代表月份，点前七减，点后13减。比如1...1代表21年，点后就是13-3=10，就是21年10月份）
      - 发动机
      - 电瓶
    - 外观
      - 漆面（是否有划痕，漆面是否完整，有没有坑洼，检查前后挡风，天窗，车窗是否有细微的裂痕）
      - 轮胎（是否有鼓包）
      - 前后雨刮器（前后雨刮是否正常运行，喷水是否正常）
      - 车门（开关车门是否有异响，连接处是否严丝合缝）
      - 底盘（抬高底盘观察是否有磕碰，漏油）
      - 前挡风玻璃（没有国家安全玻璃认证标志的话可能换过）
      - 保险杠（有无明显变形，损坏，有误校正，重新补漆的痕迹）
      - 后备箱（查看密合度，是否异响）
    - 车内
      - 仪表盘（一般总公里数 <= 50，检查胎压是否正常）
      - 坐椅（坐椅是否有损坏，划痕，调节是否顺畅，安全带回弹）
      - 中控屏（开机是否流畅，会不会卡顿，车机功能使用是否正常）
      - 天窗（开关是否正常，出现异响）
      - 空调（制冷，暖气，出风是否正常）
      - 车灯（远近光灯，前后雾灯，到车灯，报警闪光灯，示廓灯，刹车灯是否正常）
      - 后备箱（开关是否正常，配件是否齐全（三脚架，反光背心，备胎，换台工具，千斤顶，灭火器）
      - 启动（开车检测一键启动，驻车系统，刹车油门是否正常）
      - 发动机（刹车油，冷却液，玻璃水，机油是否在正常刻度）
      - 排气管（手摸内壁是否严重发黑）
      - PDI 检测单（查看各项标准是否全部合格，重点看启动电池电压是否达标）
      - 导航（确认车辆的导航已经激活并且可以使用）
      - 各个接口（检查收音机，USB，HDMI,AUX，蓝牙，音响系统是否正常使用）。
    - 正常行驶（离合，油门，刹车，挂挡）
  - 交钱,
  - 办理异地临牌。
  - 提车必拿 #
    - ~~车辆登记证书（大本，绿本）~~，
    - 车钥匙两把，
    - 车辆行驶证，车辆合格证，车辆一致性证书，
    - 保单，
    - 购车合同，
    - 四联发票（个人三联[购车发票，注册登记，抵扣]），三包凭证，首保卡，保养手册，车辆说明书等
    - 赠品（写入合同）【油卡，保养卡（包含工时），延保，[行车记录仪，倒车影像，玻璃膜，脚垫]】
    - 随车工具【三脚架，反光背心，备胎，换台工具，千斤顶，灭火器k】
  - 后续： #
    1. 本地上牌
    2. 12123 备案非本人机动车
    3. 自己收拾（记录仪，脚垫，玻璃膜，手机支架，座垫，装饰，香薰）
    4. …
- 备注： #
  1. 现金优惠，综合优惠？
  2. 贷款买车和全款买车哪个更合适？
  3. 防止保修手册被扣留，厂家400电话/12315
- 砍价 #
  1. 贷款（今天带着全款来的，如果价格合适，贷款并不是不能考虑）
  2. 转了好几家店了，您报一个最低的实在价格，随时可以刷卡买车。
  3. xx 费用就不要有了，如果非要有，你这个价格还得再优惠，
  4. 贷款价格和利息有点不认可。
  5. 你要是能聊，就找老板谈谈，聊不了，今天就到这儿了。
  6. 不要问我多少钱，我说5w, 你也肯定不卖呀，对不对，你说多少钱，还能聊，就再帮我争取一下。
  7. 给个可以买的价格，要不你就找领导请示一下，别一口咬死了，
  8. 今天过来不是看车，是买车，你想卖车，我想买车，价格合适就成一单。
  9. 现在这个价格还是有点高。
  10. 今天一个人来的，身份证都带来了，价格诚意，立马付款提车。
- 回合 #
  1. 你这个价格不太诚意，我都转了好几家了，你要是有诚意，我就在这儿谈，你要是没诚意，我就再考虑考虑。
  2. 现在这个价格是降了，但是没有降到我想要的情况，你要觉得行，你就申请申请，要是不不行，那我就撤了。
Reference #
- https://www.autohome.com.cn/spec/67292#pvareaid=3454492
- https://jiage.autohome.com.cn/price/carlist/p-67292-2-0-0-0-610100-1-0#pvareaid=2094106

Mon, 01 Jan 0001 00:00:00 +0000

Intro(Maddy | 自建个人邮箱) #

下载: maddy-0.8.1-x86_64-linux-musl.tar.zst

证书操作可参考 DOCS | acme自动化管理证书
颁发证书：acme.sh --issue --dns dns_tencent -d mail.wtfu.site -d mta-sts.wtfu.site --keylength 2048
创建目录：mkdir -p /usr/local/nginx/conf/certificate/mail
安装到 nginx 里面，稍后为 MTA-STS 提供验证。acme.sh --install-cert -d mail.wtfu.site --fullchain-file /usr/local/nginx/conf/certificate/mail/full_chain.pem --key-file /usr/local/nginx/conf/certificate/mail/private.key --reloadcmd "/usr/local/nginx/sbin/nginx -s reload"

魔法前摇 #

需要注意：
1. 使用 maddy 发送非本域邮件的话，必须使用 25 端口转发，根据 PR:767 中说明是 RFC 中的标准吧，配置文件中target.remote部分并没有可以配置可选端口的选项。所以，如果你的 VPS 厂商封锁 TCP 25端口的出口流量的话，你的自建邮箱服务器给其他邮件服务器（gmail，outlook，126之类的）就 gg 了。很不幸，此次使用的是阿里的机器，然后根据搜索说是可以解封，但是发现申请后没毛用，【安全管控｜25端口解封】处仍然是红色的审核未通过，此时距离发送邮件就遥不可及了。但是好在可以使用其他端口委托到 SMPT 中继服务器，继续满足我们对高潮的期待。
邮箱服务器形态 #
配置文件参悟 #

DNS记录 #

用于	主机记录	记录类型	记录值
基本记录	mail.wtfu.site	A	47.94.20.18
	smtp.wtfu.site	CNAME	mail.wtfu.site
	wtfu.site	MX	mail.wtfu.site
SPF	mail.wtfu.site	TXT	v=spf1 mx ~all
DKIM	default._domainkey.wtfu.site	TXT	v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyDAs34 …
DMARC	_dmarc.wtfu.site	TXT	v=DMARC1; p=quarantine; ruf=mailto:xhsgg12302@126.com
MTA-STS	_mta-sts.wtfu.site	TXT	v=STSv1; id=1
	_smtp._tls.wtfu.site 【TLS-RPT】	TXT	v=TLSRPTv1;rua=mailto:xhsgg12302@126.com
	mta-sts.wtfu.site	A	47.94.20.18

SMTP中继服务器使用 #
邮箱评分 #
SMTP端口选择 #

SSL/TLS和STARTTLS：
通常情况下：（SSL和TSL）放在一起都表示传输层安全加密，除了特别的协议版本指定之外，他们没有任何区别。一般工作在465端口，表示这个端口的流量必须加密。
另外一个是（STARTTLS）通常情况下在端口587发挥作用。表示可以支持 ssl/tls 加密，也可以不加密，以普通方式进行。在 RFC/3207 中有命令 STARTTLS 定义，稍后演示一下。
还有一个最为熟知的端口25，现在一般不允许在此处提交邮件，只针对中继服务（MTA）转发使用。（maddy 默认不让在这个端口提交邮件，但是不影响它使用 25 端口接收其他 MTA 发过来的邮件）

其他协议 IMAP，POP3 加密端口
IMAP 使用 143 端口，经过 SSL/TLS 加密的 IMAPS 协议使用 993 端口。
POP3 使用 110 端口，经过 SSL/TLS 加密的 POP3S 协议使用 995 端口。

参考： which-smtp-port-understanding-ports-25-465-587

Mon, 01 Jan 0001 00:00:00 +0000

Intro(RIME | SQUIRREL | 自定义输入法) #

Caution
因为需要输入法配置灵活度高，所以找到开源的鼠须管，基于中州韵输入法引擎的一个 macosx 端实现。详细介绍(自序、历史、概念、项目构成、开发计划)
另外本文主要针对 【朙月拼音】 和 【小鹤双拼】 等方案进行配置，当然其他方案也可以局部参考。

贴一些使用过程中的感受：
1. 好用是真好用，但是学习成本是真 TM 高。如果只是想简单使用，默认配置基本够用。如果想打造成满心欢喜的神兵利器，还是需要时间滋养的。可以循序渐进。
2. 官方的概念多且杂，但是还又不能不看，建议有个全局了解。这样碰见其他人分享的配置文件，也能看个大概，汲取精华，去其糟粕。因为外部资料更是一搜一大堆。
3. 因为这东西大概在 11 年左右出来的，出道早，以至于滋生出各式各样的输入法编码，完备方案等，不懂大概运行流程及配置关系只会懵逼树下懵逼果，偷鸡的话只能祈求上天保佑好使了。
- 下载安装 #
  
  下载页面， macOS 鼠须管 1.0.2 pkg 安装包(属于将引擎中州韵代码作为 git 子模块，编译成动态链接库供鼠须管使用)
  
  macOS 编译指南
   鼠鬚管 Wiki
  
  重新部署：参考
  /Library/Input\ Methods/Squirrel.app/Contents/MacOS/Squirrel --reload
  control + option + .
- 配置 #
  - 配置文件位置 #
    
    Warning
    应运程序的安装位置: /Library/Input\ Methods/Squirrel.app/Contents
    程序附带的共享配置: /Library/Input\ Methods/Squirrel.app/Contents/SharedSupport/
    用户自定义覆写目录: ~/Library/Rime/
    
    配置文件目录及文件分布参考 (RimeWithSchemata / Rime 中的數據文件分佈及作用)
    配置文件的 YAML 升级语法参考 (Configuration / Rime 配置文件)
    对于定制选项可参考 (CustomizationGuide / 定製指南)

Mon, 01 Jan 0001 00:00:00 +0000

Wechat-emoji #

content	content	content	content	content	content	content	content	content	content
`/微笑` `[微笑]` `/::)`	`/撇嘴` `[撇嘴]` `/::~`	`/色` `[色]` `/::B`	`/发呆` `[发呆]` `/::\|`	`/得意` `[得意]` `/:8-)`	`/流泪` `[流泪]` `/::<`	`/害羞` `[害羞]` `/::$`	`/闭嘴` `[闭嘴]` `/::X`	`/睡` `[睡]` `/::Z`	`/大哭` `[大哭]` `/::'(`
`/尴尬` `[尴尬]` `/::-\|`	`/发怒` `[发怒]` `/::@`	`/调皮` `[调皮]` `/::P`	`/呲牙` `[呲牙]` `/::D`	`/惊讶` `[惊讶]` `/::O`	`/难过` `[难过]` `/::(`	`/冷汗` `[囧]` `/:--b`	`/抓狂` `[抓狂]` `/::Q`	`/吐` `[吐]` `/::T`	`/偷笑` `[偷笑]` `/:,@P`
`/愉快` `[愉快]` `/:,@-D`	`/白眼` `[白眼]` `/::d`	`/傲慢` `[傲慢]` `/:,@o`	`/困` `[困]` `/:\|-)`	`/惊恐` `[惊恐]` `/::!`	`/憨笑` `[憨笑]` `/::>`	`/悠闲` `[悠闲]` `/::,@`	`/咒骂` `[咒骂]` `/::-S`	`/疑问` `[疑问]` `/:?`	`/嘘` `[嘘]` `/:,@x`
`/晕` `[晕]` `/:,@@`	`/衰` `[衰]` `/:,@!`	`/骷髅` `[骷髅]` `/:!!!`	`/敲打` `[敲打]` `/:xx`	`/再见` `[再见]` `/:bye`	`/擦汗` `[擦汗]` `/:wipe`	`/抠鼻` `[抠鼻]` `/:dig`	`/鼓掌` `[鼓掌]` `/:handclap`	`/坏笑` `[坏笑]` `/:B-)`	`/右哼哼` `[右哼哼]` `/:@>`
`/鄙视` `[鄙视]` `/:>-\|`	`/委屈` `[委屈]` `/:P-(`	`/快哭了` `[快哭了]`	`/阴险` `[阴险]` `/:X-)`	`/亲亲` `[亲亲]` `/::*`	`/可怜` `[可怜]` `/:8*`	`/笑脸` `[笑脸]`	`/生病` `[生病]`	`/脸红` `[脸红]`	`/破涕为笑` `[破涕为笑]`
`/恐惧` `[恐惧]`	`/失望` `[失望]`	`/无语` `[无语]`	`/嘿哈` `[嘿哈]`	`/捂脸` `[捂脸]`	`/奸笑` `[奸笑]`	`/机智` `[机智]`	`/皱眉` `[皱眉]`	`/耶` `[耶]`	`/吃瓜` `[吃瓜]`
`/加油` `[加油]`	`/汗` `[汗]`	`/天啊` `[天啊]`	`/Emm` `[Emm]`	`/社会社会` `[社会社会]`	`/旺柴` `[旺柴]`	`/好的` `[好的]`	`/打脸` `[打脸]`	`/哇` `[哇]`	`/翻白眼` `[翻白眼]`
`/666` `[666]`	`/让我看看` `[让我看看]`	`/叹气` `[叹气]`	`/苦涩` `[苦涩]`	`/裂开` `[裂开]`	`/嘴唇` `[嘴唇]` `/:showlove`	`/爱心` `[爱心]` `/:heart`	`/心碎` `[心碎]` `/:break`	`/拥抱` `[拥抱]` `/:hug`	`/强` `[强]` `/:strong`
`/弱` `[弱]` `/:weak`	`/握手` `[握手]` `/:share`	`/胜利` `[胜利]` `/:v`	`/抱拳` `[抱拳]` `/:@)`	`/勾引` `[勾引]` `/:jj`	`/拳头` `[拳头]` `/:@@`	`/OK` `[OK]` `/:ok`	`/合十` `[合十]`	`/啤酒` `[啤酒]` `/:beer`	`/咖啡` `[咖啡]` `/:coffee`

缺失的部分表情 #

文本代码段

/:,@f 奋斗
/:cake 蛋糕
/:gift 礼物
/:rose 玫瑰
/:kiss 献吻
/:love 爱情
/:lvu 爱你
/::-O 哈欠
/:no NO
/::L 流汗
/::8 疯了
/:pd 菜刀
/:pig 猪头
/:fade 凋谢
/:li 闪电
/:bome 炸弹
/:kn 刀
/:shit 便便
/::+ 酷
/:turn 回头
/:ladybug 瓢虫
/:#-0 激动
/:kotow 磕头
/:@x 吓
/:&-( 糗大了
/:<@ 左哼哼
/:bad 差劲
/:shake 发抖
/:moon 月亮
/::g 饥饿
/:eat 吃饭
/:sun 太阳
/:hiphot 街舞
/:footb 足球
/:oo 乒乓
/:basketb 篮球
/:jump 跳跳
/:circle 转圈
/:skip 跳绳
/:<& 左太极
/:&> 右太极
/:<L> 飞吻
/:oY 投降
/:<W> 西瓜
/:<O> 怄火

Baidu输入法个性短语导入 #

微信表情快捷输入文本导入(注意文本编码【UTF-16】)

[微信分组]
weixiao=1,[微笑]
piezui=1,[撇嘴]
se=1,[色]
fadai=1,[发呆]
deyi=1,[得意]
liulei=1,[流泪]
haixiu=1,[害羞]
bizui=1,[闭嘴]
shui=1,[睡]
daku=1,[大哭]

ganga=1,[尴尬]
fanu=1,[发怒]
tiaopi=1,[调皮]
ciya=1,[呲牙]
jingya=1,[惊讶]
nanguo=1,[难过]
jiong=1,[囧]
zhuakuang=1,[抓狂]
tu=1,[吐]
touxiao=1,[偷笑]

yukuai=1,[愉快]
baiyan=1,[白眼]
aoman=1,[傲慢]
kun=1,[困]
jingkong=1,[惊恐]
hanxiao=1,[憨笑]
youxian=1,[悠闲]
zhouma=1,[咒骂]
yiwen=1,[疑问]
xu=1,[嘘]

yun=1,[晕]
shuai=1,[衰]
kulou=1,[骷髅]
qiaoda=1,[敲打]
zaijian=1,[再见]
cahan=1,[擦汗]
koubi=1,[抠鼻]
guzhang=1,[鼓掌]
huaixiao=1,[坏笑]
youhengheng=1,[右哼哼]

bishi=1,[鄙视]
weiqu=1,[委屈]
kuaikule=1,[快哭了]
yinxian=1,[阴险]
qinqin=1,[亲亲]
kelian=1,[可怜]
xiaolian=1,[笑脸]
shengbing=1,[生病]
lianhong=1,[脸红]
potiweixiao=1,[破涕为笑]

kongju=1,[恐惧]
shiwang=1,[失望]
wuyu=1,[无语]
heiha=1,[嘿哈]
wulian=1,[捂脸]
jianxiao=1,[奸笑]
jizhi=1,[机智]
zhoumei=1,[皱眉]
ye=1,[耶]
chigua=1,[吃瓜]

jiayou=1,[加油]
han=1,[汗]
tiana=1,[天啊]
emm=1,[Emm]
shehuishehui=1,[社会社会]
wangchai=1,[旺柴]
haode=1,[好的]
dalian=1,[打脸]
wa=1,[哇]
fanbaiyan=1,[翻白眼]

liu=1,[666]
rangwokankan=1,[让我看看]
tanqi=1,[叹气]
kuse=1,[苦涩]
liekai=1,[裂开]
zuichun=1,[嘴唇]
aixin=1,[爱心]
xinsui=1,[心碎]
yongbao=1,[拥抱]
qiang=1,[强]

ruo=1,[弱]
woshou=1,[握手]
shengli=1,[胜利]
baoquan=1,[抱拳]
gouyin=1,[勾引]
quantou=1,[拳头]
ok=1,[OK]
heshi=1,[合十]
pijiu=1,[啤酒]
cafei=1,[咖啡]

Reference #
- https://blog.51cto.com/u_14191/7995989
- https://blog.csdn.net/llhwin2010/article/details/12675761

Mon, 01 Jan 0001 00:00:00 +0000

Intro(UNblock Netease Music) #

解锁网易云变灰歌曲，

docker run -d --restart=always \
 -v /root/UNMCertificates/server.crt:/app/server.crt \
 -v /root/UNMCertificates/server.key:/app/server.key \
 -p 14163:14163 -p 14126:14126 --name UNM pan93412/unblock-netease-music-enhanced -t hello:world -p 14163:14126 -o kugou kuwo bilibili

Reference #
- https://github.com/UnblockNeteaseMusic/server

Mon, 01 Jan 0001 00:00:00 +0000

线上项目碰到过什么问题 #

项目中复杂的业务逻辑 #

数据量,访问量多大 #

Mon, 01 Jan 0001 00:00:00 +0000

自我介绍中的亮点 #

面试官你好，我叫xxx，2018毕业于xxx软件工程专业。今天面试的岗位是Java软件开发。
在校时期领先突破单片机点灯实验。利用暑假自学汇编。参考JAVA学习课本独立完成学习管理系统开发，博客获得高赞。
参与工作后，
曾经，
在日常工作中，除了编写相应的模块代码和bug修复以外.
还能够优化系统结构或者处理逻辑等。 曾经将网关白名单鉴权部分利用多线程技术效率提高百分之45%左右。
自己除了日常工作中的Java编码外，还喜欢学习嵌入式，汇编，网络通信等知识。
以上就是我的自我介绍。

最大的优缺点(求职优势) #

自我评价 #

工作积极主动，工作效率高，责任心强，注重细节，追求完美
能及时进行思考和总结，对相关知识进行沉淀与分享
喜欢钻研技术，学习源码，经常利用业余时间进行学习
有较强自我管理能力和时间管理能力
喜欢跑步，爬山，打球，为人乐观大方，遇事沉着冷静

为什么选择我们公司 #

我十分看好贵公司所在的行业，也感觉贵公司十分重视人才，而且这项工作很适合我，相信自己一定能做好。
我花费了很长时间考虑各种职业的可能性。我认为这方面的工作最适合我，原因是这项工作要求的许多技能都是我擅长的。
示范：因为我的专业以及过往的经历与贵公司的这个岗位很匹配，同时我也很认可贵公司的发展理念，同时这个岗位也与我的个人的职业规划相匹配，所以我对贵公司有所期待。
示范：我选择公司其实也比较谨慎。希望下一家公司稳定靠谱。而贵公司近年来一直稳健发展。也逐步成为行业标杆。所以我期望有机会加入。

总结：
- 专业经历与职位匹配度
- 个人规划与发展理念匹配
- 选择公司的态度（谨慎）与公司发展状态（稳定）。
了解公司的情况
- 公司的综合信誉
- 关键领导者的声誉
- 公司产品，服务的赞赏
- 公司理念与价值观
- 公司对员工的管理理念及奖惩制度。

职业规划 #

分析因素
- 个人性格，兴趣，能力分析
- 目标行业的发展前景
- 根据自身做出时间方案
短期目标
- 尽快熟悉公司的发展业务与后端架构布局
- 补充项目中用到技术的一些盲点
中期目标
- 主动解决工作碰到的问题以及业务拓展
- 向架构师看齐,希望能够带领团队，为单位做出更大的贡献，获得双赢。
长期目标
- 梳理知识点，形成知识体系，持续输出，包括笔记，博客，产品等。

离职原因 #

对岗位及行业的理解 #

怎么看待加班 #

你有什么要问我的 #

从刚才的面试状态来说，我要胜任这份工作，还有哪些需要补充的？
目前在做的项目或者使用的一些框架
公司的有没有什么晋升机制？

福利待遇 #

五险一金
每月工资构成（底薪，绩效，年终奖，餐补，交通补等等）
12个月的基本工资+季度奖金+年终奖等等
涨薪机制（一年有几次考核晋升调薪机会，KPI考核，期权等）。
加班，出差补助
报道需求（证明，体检）【事先准备】

谈薪技巧 #

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

网页下载需要修改的部分 #

1. <body data-page="/Users/mac/Downloads/REPORT/README.md" class="sticky ready" style="">

 ==> <body data-page="/Users/mac/Downloads/REPORT/README.md" class="sticky ready close" style="">

2. body.close .content {
 left: 200px;
 }

3. body:not(.ready) {
 # overflow: hidden;
 }

# vus.css
# body.close .content{left:0}
# body:not(.ready){overflow:hidden}
find . -type f -name 'vue.css' -exec sed -i '' \
 -e 's/body\.close \.content{left:0}/body\.close \.content{left:200px}/g' \
 -e 's/body:not(\.ready){overflow:hidden}/body:not(\.ready){\/*overflow:hidden*\/}/g' \
 {} +

# *.html
find . -type f -name '*.html' -exec sed -i '' \
 -e 's/class=".*sticky.*" /class="sticky close" /g' \
 -e 's/<a href="https:\/\/github\.com\/xhsgg12302\/knownledges.*<\/a>//g' \
 -e 's/<a style="text-decoration: underline;.*Edit on github<\/a>//g' {} +

Mon, 01 Jan 0001 00:00:00 +0000

render everything

TLS-RECORD-CONSOLE-OUTPUT

Mon, 01 Jan 0001 00:00:00 +0000

wireshark capture package: instance-tls-ssl.pcapng，use filter：ip.addr == 47.94.20.18 && tcp.port == 443

/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/bin/java -agentlib:jdwp=transport=dt_socket,address=127.0.0.1:64185,suspend=y,server=n -javaagent:/Users/stevenobelia/Library/Caches/JetBrains/IntelliJIdea2023.2/captureAgent/debugger-agent.jar -Dfile.encoding=UTF-8 -classpath /Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/charsets.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/deploy.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/cldrdata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/dnsns.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/jaccess.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/jfxrt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/localedata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/nashorn.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunec.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunjce_provider.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunpkcs11.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/zipfs.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/javaws.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jce.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jfr.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jfxswt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jsse.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/management-agent.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/plugin.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/resources.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/rt.jar:/Users/stevenobelia/Documents/project_idea_test/idea-test-project/_4_springmvc/target/classes:/Users/stevenobelia/Documents/_maven_repo/javax/servlet/javax.servlet-api/3.0.1/javax.servlet-api-3.0.1.jar:/Users/stevenobelia/Documents/_maven_repo/javax/servlet/jstl/1.2/jstl-1.2.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-core/4.3.30.RELEASE/spring-core-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/commons-logging/commons-logging/1.2/commons-logging-1.2.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-web/4.3.30.RELEASE/spring-web-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-beans/4.3.30.RELEASE/spring-beans-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-context/4.3.30.RELEASE/spring-context-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-oxm/4.3.30.RELEASE/spring-oxm-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-tx/4.3.30.RELEASE/spring-tx-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-jdbc/4.3.30.RELEASE/spring-jdbc-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-webmvc/4.3.30.RELEASE/spring-webmvc-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-expression/4.3.30.RELEASE/spring-expression-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-aop/4.3.30.RELEASE/spring-aop-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-context-support/4.3.30.RELEASE/spring-context-support-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/springframework/spring-test/4.3.30.RELEASE/spring-test-4.3.30.RELEASE.jar:/Users/stevenobelia/Documents/_maven_repo/org/mybatis/mybatis/3.5.5/mybatis-3.5.5.jar:/Users/stevenobelia/Documents/_maven_repo/org/mybatis/mybatis-spring/2.0.5/mybatis-spring-2.0.5.jar:/Users/stevenobelia/Documents/_maven_repo/mysql/mysql-connector-java/5.1.42/mysql-connector-java-5.1.42.jar:/Users/stevenobelia/Documents/_maven_repo/com/zaxxer/HikariCP/4.0.3/HikariCP-4.0.3.jar:/Users/stevenobelia/Documents/_maven_repo/jstl/jstl/1.2/jstl-1.2.jar:/Users/stevenobelia/Documents/_maven_repo/log4j/log4j/1.2.17/log4j-1.2.17.jar:/Users/stevenobelia/Documents/_maven_repo/com/alibaba/fastjson/1.2.25.sec10/fastjson-1.2.25.sec10.jar:/Users/stevenobelia/Documents/_maven_repo/org/slf4j/slf4j-api/1.7.7/slf4j-api-1.7.7.jar:/Users/stevenobelia/Documents/_maven_repo/org/slf4j/slf4j-log4j12/1.7.7/slf4j-log4j12-1.7.7.jar:/Users/stevenobelia/Documents/_maven_repo/com/fasterxml/jackson/core/jackson-databind/2.9.5/jackson-databind-2.9.5.jar:/Users/stevenobelia/Documents/_maven_repo/com/fasterxml/jackson/core/jackson-annotations/2.14.2/jackson-annotations-2.14.2.jar:/Users/stevenobelia/Documents/_maven_repo/com/fasterxml/jackson/core/jackson-core/2.14.2/jackson-core-2.14.2.jar:/Users/stevenobelia/Documents/_maven_repo/commons-fileupload/commons-fileupload/1.3.3/commons-fileupload-1.3.3.jar:/Users/stevenobelia/Documents/_maven_repo/commons-io/commons-io/2.4/commons-io-2.4.jar:/Users/stevenobelia/Documents/_maven_repo/commons-codec/commons-codec/1.9/commons-codec-1.9.jar:/Users/stevenobelia/Documents/_maven_repo/org/apache/commons/commons-lang3/3.0/commons-lang3-3.0.jar:/Users/stevenobelia/Documents/_maven_repo/javax/annotation/jsr250-api/1.0/jsr250-api-1.0.jar:/Users/stevenobelia/Documents/_maven_repo/org/apache/poi/poi-ooxml/3.17/poi-ooxml-3.17.jar:/Users/stevenobelia/Documents/_maven_repo/org/apache/poi/poi-ooxml-schemas/3.17/poi-ooxml-schemas-3.17.jar:/Users/stevenobelia/Documents/_maven_repo/org/apache/xmlbeans/xmlbeans/2.6.0/xmlbeans-2.6.0.jar:/Users/stevenobelia/Documents/_maven_repo/stax/stax-api/1.0.1/stax-api-1.0.1.jar:/Users/stevenobelia/Documents/_maven_repo/com/github/virtuald/curvesapi/1.04/curvesapi-1.04.jar:/Users/stevenobelia/Documents/_maven_repo/org/apache/poi/poi/3.14/poi-3.14.jar:/Users/stevenobelia/Documents/_maven_repo/org/apache/commons/commons-collections4/4.1/commons-collections4-4.1.jar:/Users/stevenobelia/Documents/_maven_repo/net/sourceforge/jexcelapi/jxl/2.6.12/jxl-2.6.12.jar:/Users/stevenobelia/Documents/_maven_repo/org/projectlombok/lombok/1.16.22/lombok-1.16.22.jar:/Users/stevenobelia/Documents/_maven_repo/org/apache/httpcomponents/httpclient/4.5.14/httpclient-4.5.14.jar:/Users/stevenobelia/Documents/_maven_repo/org/apache/httpcomponents/httpcore/4.4.16/httpcore-4.4.16.jar:/Users/stevenobelia/Documents/_maven_repo/com/fasterxml/jackson/dataformat/jackson-dataformat-yaml/2.14.2/jackson-dataformat-yaml-2.14.2.jar:/Users/stevenobelia/Documents/_maven_repo/org/yaml/snakeyaml/1.33/snakeyaml-1.33.jar:/Users/stevenobelia/Documents/_maven_repo/org/java-websocket/Java-WebSocket/1.5.3/Java-WebSocket-1.5.3.jar:/Users/stevenobelia/Documents/_maven_repo/org/bouncycastle/bcprov-jdk15to18/1.78/bcprov-jdk15to18-1.78.jar:/Users/stevenobelia/Documents/_maven_repo/org/bouncycastle/bctls-debug-jdk15to18/1.78/bctls-debug-jdk15to18-1.78.jar:/Users/stevenobelia/Documents/_maven_repo/org/bouncycastle/bcutil-jdk15to18/1.78/bcutil-jdk15to18-1.78.jar:/Users/stevenobelia/Documents/_maven_repo/org/junit/jupiter/junit-jupiter/5.11.4/junit-jupiter-5.11.4.jar:/Users/stevenobelia/Documents/_maven_repo/org/junit/jupiter/junit-jupiter-api/5.11.4/junit-jupiter-api-5.11.4.jar:/Users/stevenobelia/Documents/_maven_repo/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar:/Users/stevenobelia/Documents/_maven_repo/org/junit/platform/junit-platform-commons/1.11.4/junit-platform-commons-1.11.4.jar:/Users/stevenobelia/Documents/_maven_repo/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar:/Users/stevenobelia/Documents/_maven_repo/org/junit/jupiter/junit-jupiter-params/5.11.4/junit-jupiter-params-5.11.4.jar:/Users/stevenobelia/Documents/_maven_repo/org/junit/jupiter/junit-jupiter-engine/5.11.4/junit-jupiter-engine-5.11.4.jar:/Users/stevenobelia/Documents/_maven_repo/org/junit/platform/junit-platform-engine/1.11.4/junit-platform-engine-1.11.4.jar:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar site.wtfu.framework.utils.TLSTest
Connected to the target VM, address: '127.0.0.1:64185', transport: 'socket'
16 03 01 00 fd 01 00 00 f9 03 03 e3 e5 0a 0c c0 
f1 f7 49 4c 14 89 45 9c 28 05 39 fa b4 e9 ce 08 
77 f0 94 1f 44 4e 05 34 d6 4b c0 20 e0 76 16 70 
7f ac e1 53 5f 39 77 f3 98 b3 ff 2a 19 b6 76 08 
3e 23 15 d2 10 78 c5 a8 c1 2a 65 3a 00 1e 13 03 
13 01 cc a9 c0 2b c0 23 c0 09 cc a8 c0 2f c0 27 
c0 13 cc aa 00 9e 00 67 00 33 00 ff 01 00 00 92 
00 17 00 00 00 16 00 00 00 2b 00 05 04 03 04 03 
03 00 0a 00 10 00 0e 00 1d 00 1e 00 17 00 18 01 
00 01 01 01 02 00 33 00 26 00 24 00 1d 00 20 20 
87 73 67 9a 1e 19 0a 9c 9e 04 b8 1d 49 60 6f a1 
2e 6c 12 f0 f6 19 03 24 99 0c 77 11 ec 04 60 00 
05 00 05 01 00 00 00 00 00 0d 00 30 00 2e 08 07 
08 08 04 03 05 03 06 03 08 04 08 05 08 06 08 09 
08 0a 08 0b 04 01 05 01 06 01 04 02 05 02 06 02 
03 03 03 01 03 02 02 03 02 01 02 02 00 0b 00 02 
01 00
void
16 03 03 00 59 02 00 00 55 03 03 52 f6 1e a4 6d 
79 2e 2b 1b 94 70 d7 eb 21 5d 42 ed 4b a3 44 88 
45 f2 b8 c1 4b 63 8f 28 5b e9 fe 20 0a 0e a0 a9 
e9 88 4d 2d 07 c1 54 db 76 d3 9c e0 97 48 eb af 
7e 54 ee 51 d1 bb 61 39 7a 80 53 d0 c0 2b 00 00 
0d ff 01 00 01 00 00 0b 00 04 03 00 01 02
void
16 03 03 0b 77 0b 00 0b 73 00 0b 70 00 04 07 30 
82 04 03 30 82 03 88 a0 03 02 01 02 02 10 4f c9 
72 15 bf 60 1b 22 25 62 0a 35 37 a8 57 73 30 0a 
06 08 2a 86 48 ce 3d 04 03 03 30 4b 31 0b 30 09 
06 03 55 04 06 13 02 41 54 31 10 30 0e 06 03 55 
04 0a 13 07 5a 65 72 6f 53 53 4c 31 2a 30 28 06 
03 55 04 03 13 21 5a 65 72 6f 53 53 4c 20 45 43 
43 20 44 6f 6d 61 69 6e 20 53 65 63 75 72 65 20 
53 69 74 65 20 43 41 30 1e 17 0d 32 34 31 32 32 
32 30 30 30 30 30 30 5a 17 0d 32 35 30 33 32 32 
32 33 35 39 35 39 5a 30 14 31 12 30 10 06 03 55 
04 03 13 09 77 74 66 75 2e 73 69 74 65 30 59 30 
13 06 07 2a 86 48 ce 3d 02 01 06 08 2a 86 48 ce 
3d 03 01 07 03 42 00 04 4a cd f6 13 8a a1 45 4b 
a1 b2 29 2f 8c 31 06 2a 7f 03 7f e0 cd be 38 9b 
c3 85 02 0e 08 13 fb 14 31 8c 52 9c 12 31 76 dd 
be bf 92 7a 7d 66 66 79 df 2e 90 18 2b 58 62 67 
51 57 82 5a 6c eb 11 56 a3 82 02 83 30 82 02 7f 
30 1f 06 03 55 1d 23 04 18 30 16 80 14 0f 6b e6 
4b ce 39 47 ae f6 7e 90 1e 79 f0 30 91 92 c8 5f 
a3 30 1d 06 03 55 1d 0e 04 16 04 14 ee f5 a9 f7 
35 a7 22 36 8c b5 58 f4 03 78 2e 98 bd e6 fe c2 
30 0e 06 03 55 1d 0f 01 01 ff 04 04 03 02 07 80 
30 0c 06 03 55 1d 13 01 01 ff 04 02 30 00 30 1d 
06 03 55 1d 25 04 16 30 14 06 08 2b 06 01 05 05 
07 03 01 06 08 2b 06 01 05 05 07 03 02 30 49 06 
03 55 1d 20 04 42 30 40 30 34 06 0b 2b 06 01 04 
01 b2 31 01 02 02 4e 30 25 30 23 06 08 2b 06 01 
05 05 07 02 01 16 17 68 74 74 70 73 3a 2f 2f 73 
65 63 74 69 67 6f 2e 63 6f 6d 2f 43 50 53 30 08 
06 06 67 81 0c 01 02 01 30 81 88 06 08 2b 06 01 
05 05 07 01 01 04 7c 30 7a 30 4b 06 08 2b 06 01 
05 05 07 30 02 86 3f 68 74 74 70 3a 2f 2f 7a 65 
72 6f 73 73 6c 2e 63 72 74 2e 73 65 63 74 69 67 
6f 2e 63 6f 6d 2f 5a 65 72 6f 53 53 4c 45 43 43 
44 6f 6d 61 69 6e 53 65 63 75 72 65 53 69 74 65 
43 41 2e 63 72 74 30 2b 06 08 2b 06 01 05 05 07 
30 01 86 1f 68 74 74 70 3a 2f 2f 7a 65 72 6f 73 
73 6c 2e 6f 63 73 70 2e 73 65 63 74 69 67 6f 2e 
63 6f 6d 30 82 01 05 06 0a 2b 06 01 04 01 d6 79 
02 04 02 04 81 f6 04 81 f3 00 f1 00 77 00 cf 11 
56 ee d5 2e 7c af f3 87 5b d9 69 2e 9b e9 1a 71 
67 4a b0 17 ec ac 01 d2 5b 77 ce cc 3b 08 00 00 
01 93 ec be 8a c5 00 00 04 03 00 48 30 46 02 21 
00 ba 14 89 4c d4 a6 bf d5 8e 18 3b 10 63 54 35 
3e 16 3a f1 b0 1d e3 49 20 a0 7f 36 e0 44 30 e7 
e1 02 21 00 a8 dc 88 b6 51 32 6b 67 1e 60 d9 3a 
8b 2e f1 f9 1c f1 ff 18 8d c5 3f f7 9b cc 4b d4 
28 db 5c 13 00 76 00 cc fb 0f 6a 85 71 09 65 fe 
95 9b 53 ce e9 b2 7c 22 e9 85 5c 0d 97 8d b6 a9 
7e 54 c0 fe 4c 0d b0 00 00 01 93 ec be 8a 8f 00 
00 04 03 00 47 30 45 02 20 1b ff 93 39 6b c9 87 
b7 00 d6 45 63 66 92 b3 60 a0 4f 85 86 d5 1a 7a 
4d 4d 40 30 d8 9e 7a 21 df 02 21 00 fa b6 ae 47 
eb 9f c3 a7 f7 e1 87 3c 28 aa a3 47 88 81 af 36 
ff 1d 16 3e f1 3a 6c 5f 90 cb e3 e1 30 21 06 03 
55 1d 11 04 1a 30 18 82 09 77 74 66 75 2e 73 69 
74 65 82 0b 2a 2e 77 74 66 75 2e 73 69 74 65 30 
0a 06 08 2a 86 48 ce 3d 04 03 03 03 69 00 30 66 
02 31 00 f9 31 c9 8c 2e 6b f5 ca d4 ad dd 19 87 
27 1f d8 bd 32 ea 6c 99 6c 2e d6 c7 87 1c 02 f1 
33 40 68 3a 1a 03 cd 65 10 ae 68 63 85 2e 30 80 
22 da 47 02 31 00 b6 93 15 5e 96 75 ce 12 4e c0 
c7 14 79 2b 0a 63 ed 00 42 3a a3 82 0a 68 29 d2 
90 2a a8 59 c7 56 df 33 53 6f 59 0e 30 ec a0 81 
42 65 83 a4 09 68 00 03 89 30 82 03 85 30 82 03 
0c a0 03 02 01 02 02 10 23 b7 6d e3 c1 bb 2b 1a 
51 96 1e 08 ea b7 64 e8 30 0a 06 08 2a 86 48 ce 
3d 04 03 03 30 81 88 31 0b 30 09 06 03 55 04 06 
13 02 55 53 31 13 30 11 06 03 55 04 08 13 0a 4e 
65 77 20 4a 65 72 73 65 79 31 14 30 12 06 03 55 
04 07 13 0b 4a 65 72 73 65 79 20 43 69 74 79 31 
1e 30 1c 06 03 55 04 0a 13 15 54 68 65 20 55 53 
45 52 54 52 55 53 54 20 4e 65 74 77 6f 72 6b 31 
2e 30 2c 06 03 55 04 03 13 25 55 53 45 52 54 72 
75 73 74 20 45 43 43 20 43 65 72 74 69 66 69 63 
61 74 69 6f 6e 20 41 75 74 68 6f 72 69 74 79 30 
1e 17 0d 32 30 30 31 33 30 30 30 30 30 30 30 5a 
17 0d 33 30 30 31 32 39 32 33 35 39 35 39 5a 30 
4b 31 0b 30 09 06 03 55 04 06 13 02 41 54 31 10 
30 0e 06 03 55 04 0a 13 07 5a 65 72 6f 53 53 4c 
31 2a 30 28 06 03 55 04 03 13 21 5a 65 72 6f 53 
53 4c 20 45 43 43 20 44 6f 6d 61 69 6e 20 53 65 
63 75 72 65 20 53 69 74 65 20 43 41 30 76 30 10 
06 07 2a 86 48 ce 3d 02 01 06 05 2b 81 04 00 22 
03 62 00 04 36 41 61 17 2b 53 25 ed aa ca 94 e4 
d6 da 48 57 ef 50 ba 84 64 82 d7 bb 05 1b d6 1f 
06 24 f6 a5 33 9d 8c e7 f1 0b 55 68 63 82 30 10 
5f 8d 65 ec aa a8 af 97 ca b5 86 ce 30 01 89 74 
de e3 4e 5e 01 6e ee 26 7b cc 53 fa 23 a4 f7 44 
1d 3e 4d 1e 5f 66 a6 ad 85 f6 f2 e3 bc 8e 09 98 
80 24 8e 20 a3 82 01 75 30 82 01 71 30 1f 06 03 
55 1d 23 04 18 30 16 80 14 3a e1 09 86 d4 cf 19 
c2 96 76 74 49 76 dc e0 35 c6 63 63 9a 30 1d 06 
03 55 1d 0e 04 16 04 14 0f 6b e6 4b ce 39 47 ae 
f6 7e 90 1e 79 f0 30 91 92 c8 5f a3 30 0e 06 03 
55 1d 0f 01 01 ff 04 04 03 02 01 86 30 12 06 03 
55 1d 13 01 01 ff 04 08 30 06 01 01 ff 02 01 00 
30 1d 06 03 55 1d 25 04 16 30 14 06 08 2b 06 01 
05 05 07 03 01 06 08 2b 06 01 05 05 07 03 02 30 
22 06 03 55 1d 20 04 1b 30 19 30 0d 06 0b 2b 06 
01 04 01 b2 31 01 02 02 4e 30 08 06 06 67 81 0c 
01 02 01 30 50 06 03 55 1d 1f 04 49 30 47 30 45 
a0 43 a0 41 86 3f 68 74 74 70 3a 2f 2f 63 72 6c 
2e 75 73 65 72 74 72 75 73 74 2e 63 6f 6d 2f 55 
53 45 52 54 72 75 73 74 45 43 43 43 65 72 74 69 
66 69 63 61 74 69 6f 6e 41 75 74 68 6f 72 69 74 
79 2e 63 72 6c 30 76 06 08 2b 06 01 05 05 07 01 
01 04 6a 30 68 30 3f 06 08 2b 06 01 05 05 07 30 
02 86 33 68 74 74 70 3a 2f 2f 63 72 74 2e 75 73 
65 72 74 72 75 73 74 2e 63 6f 6d 2f 55 53 45 52 
54 72 75 73 74 45 43 43 41 64 64 54 72 75 73 74 
43 41 2e 63 72 74 30 25 06 08 2b 06 01 05 05 07 
30 01 86 19 68 74 74 70 3a 2f 2f 6f 63 73 70 2e 
75 73 65 72 74 72 75 73 74 2e 63 6f 6d 30 0a 06 
08 2a 86 48 ce 3d 04 03 03 03 67 00 30 64 02 30 
24 70 54 0f 01 c9 40 dd c8 54 d9 6d 54 ca c8 08 
ca 98 43 74 d8 3f f4 d7 a9 5f 6d f2 61 b9 70 0a 
26 1b 63 30 a8 8b 31 9c bf 77 ec 67 b0 7f a5 88 
02 30 25 ad ab a4 b0 ee 8d 52 e0 dd 0d 7c 9d df 
7d 1d ae e2 5c 64 9c 74 f8 7e 63 e5 c1 4e 60 16 
86 b0 a7 5e 19 6e ec 08 c6 91 d8 fb 03 14 a1 a5 
95 ab 00 03 d7 30 82 03 d3 30 82 02 bb a0 03 02 
01 02 02 10 56 67 1d 04 ea 4f 99 4c 6f 10 81 47 
59 d2 75 94 30 0d 06 09 2a 86 48 86 f7 0d 01 01 
0c 05 00 30 7b 31 0b 30 09 06 03 55 04 06 13 02 
47 42 31 1b 30 19 06 03 55 04 08 0c 12 47 72 65 
61 74 65 72 20 4d 61 6e 63 68 65 73 74 65 72 31 
10 30 0e 06 03 55 04 07 0c 07 53 61 6c 66 6f 72 
64 31 1a 30 18 06 03 55 04 0a 0c 11 43 6f 6d 6f 
64 6f 20 43 41 20 4c 69 6d 69 74 65 64 31 21 30 
1f 06 03 55 04 03 0c 18 41 41 41 20 43 65 72 74 
69 66 69 63 61 74 65 20 53 65 72 76 69 63 65 73 
30 1e 17 0d 31 39 30 33 31 32 30 30 30 30 30 30 
5a 17 0d 32 38 31 32 33 31 32 33 35 39 35 39 5a 
30 81 88 31 0b 30 09 06 03 55 04 06 13 02 55 53 
31 13 30 11 06 03 55 04 08 13 0a 4e 65 77 20 4a 
65 72 73 65 79 31 14 30 12 06 03 55 04 07 13 0b 
4a 65 72 73 65 79 20 43 69 74 79 31 1e 30 1c 06 
03 55 04 0a 13 15 54 68 65 20 55 53 45 52 54 52 
55 53 54 20 4e 65 74 77 6f 72 6b 31 2e 30 2c 06 
03 55 04 03 13 25 55 53 45 52 54 72 75 73 74 20 
45 43 43 20 43 65 72 74 69 66 69 63 61 74 69 6f 
6e 20 41 75 74 68 6f 72 69 74 79 30 76 30 10 06 
07 2a 86 48 ce 3d 02 01 06 05 2b 81 04 00 22 03 
62 00 04 1a ac 54 5a a9 f9 68 23 e7 7a d5 24 6f 
53 c6 5a d8 4b ab c6 d5 b6 d1 e6 73 71 ae dd 9c 
d6 0c 61 fd db a0 89 03 b8 05 14 ec 57 ce ee 5d 
3f e2 21 b3 ce f7 d4 8a 79 e0 a3 83 7e 2d 97 d0 
61 c4 f1 99 dc 25 91 63 ab 7f 30 a3 b4 70 e2 c7 
a1 33 9c f3 bf 2e 5c 53 b1 5f b3 7d 32 7f 8a 34 
e3 79 79 a3 81 f2 30 81 ef 30 1f 06 03 55 1d 23 
04 18 30 16 80 14 a0 11 0a 23 3e 96 f1 07 ec e2 
af 29 ef 82 a5 7f d0 30 a4 b4 30 1d 06 03 55 1d 
0e 04 16 04 14 3a e1 09 86 d4 cf 19 c2 96 76 74 
49 76 dc e0 35 c6 63 63 9a 30 0e 06 03 55 1d 0f 
01 01 ff 04 04 03 02 01 86 30 0f 06 03 55 1d 13 
01 01 ff 04 05 30 03 01 01 ff 30 11 06 03 55 1d 
20 04 0a 30 08 30 06 06 04 55 1d 20 00 30 43 06 
03 55 1d 1f 04 3c 30 3a 30 38 a0 36 a0 34 86 32 
68 74 74 70 3a 2f 2f 63 72 6c 2e 63 6f 6d 6f 64 
6f 63 61 2e 63 6f 6d 2f 41 41 41 43 65 72 74 69 
66 69 63 61 74 65 53 65 72 76 69 63 65 73 2e 63 
72 6c 30 34 06 08 2b 06 01 05 05 07 01 01 04 28 
30 26 30 24 06 08 2b 06 01 05 05 07 30 01 86 18 
68 74 74 70 3a 2f 2f 6f 63 73 70 2e 63 6f 6d 6f 
64 6f 63 61 2e 63 6f 6d 30 0d 06 09 2a 86 48 86 
f7 0d 01 01 0c 05 00 03 82 01 01 00 19 ec eb 9d 
89 2c 20 0b 04 80 1d 18 de 42 99 72 99 16 32 bd 
0e 9c 75 5b 2c 15 e2 29 40 6d ee ff 72 db db ab 
90 1f 8c 95 f2 8a 3d 08 72 42 89 50 07 e2 39 15 
6c 01 87 d9 16 1a f5 c0 75 2b c5 e6 56 11 07 df 
d8 98 bc 7c 9f 19 39 df 8b ca 00 64 73 bc 46 10 
9b 93 23 8d be 16 c3 2e 08 82 9c 86 33 74 76 3b 
28 4c 8d 03 42 85 b3 e2 b2 23 42 d5 1f 7a 75 6a 
1a d1 7c aa 67 21 c4 33 3a 39 6d 53 c9 a2 ed 62 
22 a8 bb e2 55 6c 99 6c 43 6b 91 97 d1 0c 0b 93 
02 1d d2 bc 69 77 49 e6 1b 4d f7 bf 14 78 03 b0 
a6 ba 0b b4 e1 85 7f 2f dc 42 3b ad 74 01 48 de 
d6 6c e1 19 98 09 5e 0a b3 67 47 fe 1c e0 d5 c1 
28 ef 4a 8b 44 31 26 04 37 8d 89 74 36 2e ef a5 
22 0f 83 74 49 92 c7 f7 10 c2 0c 29 fb b7 bd ba 
7f e3 5f d5 9f f2 a9 f4 74 d5 b8 e1 b3 b0 81 e4 
e1 a5 63 a3 cc ea 04 78 90 6e bf f7
void
16 03 03 00 94 0c 00 00 90 03 00 17 41 04 cf 1f 
1d 3c 13 27 b0 bf d5 0d f9 55 9e b2 c2 e5 f7 ad 
ed db db 34 03 37 6e d2 e9 b1 ae 93 a0 b1 33 87 
5d 9b 90 d9 71 ee df ea 19 d3 b9 da 74 bf 60 f3 
39 4c 37 5d dc 75 82 68 fe a3 9d 7e c1 a4 06 03 
00 47 30 45 02 21 00 de ed 7f a8 fd 3c d8 e0 d5 
f2 e0 cf 22 eb a8 48 c6 a8 11 4a 65 30 7a 9e c6 
8d fa 22 a2 a5 b0 e5 02 20 11 2d 77 5a 4b 27 a0 
b6 0a 00 c0 e0 f5 ca 53 ba 57 66 40 76 79 26 c3 
40 c0 fc 46 d4 97 74 87 44
void
publicKey: 04 cf 1f 1d 3c 13 27 b0 bf d5 0d f9 55 9e b2 c2 e5 f7 ad ed db db 34 03 37 6e d2 e9 b1 ae 93 a0 b1 33 87 5d 9b 90 d9 71 ee df ea 19 d3 b9 da 74 bf 60 f3 39 4c 37 5d dc 75 82 68 fe a3 9d 7e c1 a4 
16 03 03 00 04 0e 00 00 00
void
big: 41421376590410550347532242163556460089898812947798573278257512740784871055544
16 03 03 00 46 10 00 00 42 41 04 8e 74 54 c4 02 
9d a0 63 1d 72 d2 ee 25 74 2d 59 82 6f 1b 85 51 
65 38 c8 e7 4a 3e af 4c bc fa 83 cc c5 6c f5 c2 
93 1a 51 34 ac 2e 60 13 0d 17 23 35 d7 2e c2 01 
2e 1e a5 47 f5 60 40 ab 94 b1 ef
void
label: "master secret", seed: e3 e5 0a 0c c0 f1 f7 49 4c 14 89 45 9c 28 05 39 fa b4 e9 ce 08 77 f0 94 1f 44 4e 05 34 d6 4b c0 52 f6 1e a4 6d 79 2e 2b 1b 94 70 d7 eb 21 5d 42 ed 4b a3 44 88 45 f2 b8 c1 4b 63 8f 28 5b e9 fe 
14 03 03 00 01 01
void
label: "client finished", seed: b3 a8 af 07 33 51 f0 44 c8 28 eb f2 50 86 cd 65 5d 76 6f 75 8d 39 08 dc 58 b2 4a 32 29 32 92 69 
16 03 03 00 28 00 00 00 00 00 00 00 00 04 c1 4c 
a1 7a c3 ed ad 20 45 0a 2c 32 08 b2 db 6c 79 76 
d8 5b 3d ae 76 ff 1e 28 6e 4e 12 56 8e 
void
14 03 03 00 01 01
void
16 03 03 00 28 84 ef 8c ec 32 b4 9f d9 a5 e6 04 
70 54 90 69 44 14 84 ce ad d3 03 e0 eb 66 36 3e 
01 28 88 6e d7 5c ed f6 80 58 e6 6d a4
void
clientRandom: e3 e5 0a 0c c0 f1 f7 49 4c 14 89 45 9c 28 05 39 fa b4 e9 ce 08 77 f0 94 1f 44 4e 05 34 d6 4b c0 
serverRandom: 52 f6 1e a4 6d 79 2e 2b 1b 94 70 d7 eb 21 5d 42 ed 4b a3 44 88 45 f2 b8 c1 4b 63 8f 28 5b e9 fe 
cipherText: 16 03 03 00 28 84 ef 8c ec 32 b4 9f d9 a5 e6 04 70 54 90 69 44 14 84 ce ad d3 03 e0 eb 66 36 3e 01 28 88 6e d7 5c ed f6 80 58 e6 6d a4 
label: "server finished", seed: db a1 5c c2 bb 4e 60 58 30 16 00 7b 0a a0 9f 34 61 20 06 ca 74 68 d2 31 9d 18 c9 9d 21 82 c5 18 
17 03 03 00 fa 00 00 00 00 00 00 00 01 5b 2e c7 
61 b1 bb 92 38 2c a9 d0 7e 65 2b 6f 7a 95 71 5d 
28 bf f2 0a 14 d7 12 17 15 8f e5 ea 39 e9 aa 22 
f4 47 b8 26 48 9b e8 4e 41 1f 16 3b e4 03 c5 b6 
0b 9e 4d 9b a8 22 25 55 65 30 b7 52 a1 a3 d4 45 
5b 66 87 ae 9d 7d c6 c2 2c c4 d1 a1 a1 06 ee 46 
89 42 cd 52 27 9e 8b ca 57 d7 b7 74 38 5e cb 79 
cc af 89 31 06 b9 f4 c6 37 dd d2 bd ba 52 e1 32 
a5 2e c1 5f 64 42 97 f7 f2 f2 62 3e 04 e8 ed 69 
e0 a2 23 1e 9a 7d 5b dc 0b 4f b9 fa 46 19 90 9e 
05 eb 93 c7 57 b6 ee 50 bb 87 ba e7 bb 1f dc 27 
b0 68 ff 50 9f fd 51 78 39 97 72 f1 c8 ce b7 78 
c7 fa 51 d7 04 d7 98 cb 4d f2 1f 80 5c 0c a1 62 
a9 b0 95 a4 7a 27 b1 0f 20 ab 34 30 6c 2a f4 be 
53 14 d0 e7 b0 4c 6a bb 89 89 41 d3 db 59 06 ca 
2a 37 ca 46 de 19 08 e9 14 a9 ab 32 d2 0d 12
void
17 03 03 0a 04 84 ef 8c ec 32 b4 9f da 96 81 de 
e1 95 e3 1c 13 dc cf 70 da d2 f9 30 c6 70 49 47 
f1 78 eb b6 eb 7e ba c7 7b 22 3a 18 6b 2e 29 fe 
f8 d6 46 62 21 89 d8 84 05 a5 29 28 23 bc a8 05 
2b 0f 77 95 bb e2 ba 20 14 c5 5d 89 5d 11 c2 df 
5d 46 f0 4d 38 5e 2c ca 1f 46 4f 05 4e 8d 6d f8 
7a 0a 30 22 78 49 08 3f 40 bd e6 52 99 39 19 7d 
59 8c 19 3c 9f b4 f5 0f 68 e7 51 00 47 71 4a 12 
a2 97 35 8e e9 12 65 01 88 17 7e fd 85 c1 e6 f1 
0f ca bf 0d 08 88 8c b9 d4 c4 5f 4b 18 bf ba 26 
f6 15 84 92 df be e5 83 15 d7 3b 6c 92 d7 66 e5 
a6 ad 42 77 0d eb 24 f2 21 fb 60 04 c4 a5 ab 8e 
7b df 2f c9 74 a3 83 a5 29 bd b6 c3 e4 d7 d1 e9 
b3 78 91 af c3 00 1a 0f 3a 61 19 ce 2a 9b 43 1e 
d1 f7 02 6c 93 90 46 0a 8b 6c 96 37 56 6d dd 3d 
3b a0 68 ad 30 e6 f4 3b 02 b5 05 73 8b a9 4b 3f 
2e 0d 26 e2 f4 be ad 30 9a 52 83 73 65 b4 b2 e8 
6b b2 0d 66 ba dd 58 8d 5c 2e 34 13 e0 52 0b 91 
66 dd ed 30 2c b9 9e 7a 14 4b 52 06 8d 3f bd 01 
72 dc b2 68 0d 83 64 c4 00 01 12 b4 34 4a c4 bd 
15 eb e6 1c 62 ec 92 e5 ea 5b 6f d6 94 1f 89 6b 
c7 37 82 ad 28 2f 33 ff ac 63 13 47 e8 81 fb 4e 
6c ac 27 d5 f1 7c 0a 23 20 4d 15 77 7f 70 dd 4d 
e4 f3 18 6c b6 42 00 4f 5c 97 11 9b 4a 5d 46 90 
c4 53 d4 1c 57 94 b9 ba 06 2d 53 ab f9 b8 f7 bf 
4f 60 4d 28 f7 6e e1 be 83 e1 36 2f 61 65 d3 31 
67 90 1f e0 ae 84 92 e8 d5 26 74 fc 15 82 37 cf 
33 ed 86 df 7c e7 12 a9 c1 48 b3 53 23 e5 55 0d 
50 7f 2b 9a 65 dd eb 40 1c 2a 1f b0 fa 44 97 49 
99 cb a9 f0 f6 cd 95 1e a8 f3 b9 4b 2e 6a 09 cd 
03 90 ec 04 a9 b7 6d ba 20 fe 38 cc e5 a6 cc e6 
b2 62 f3 fb 2f 00 ae 9d 59 cb 9a 31 2c 74 5e e0 
35 47 58 d8 68 25 9d fd 32 51 9a 82 a4 66 32 df 
6b fa 4f e7 40 a3 31 6f cd ee 23 e5 fe 14 41 06 
e2 cb b9 3a c3 85 c7 fa d7 aa dd e1 3a b9 5c 46 
0d 17 9b e2 21 5a 3c b6 8f 97 a2 a6 5d 4f 8e 4a 
b0 3d 50 66 04 0f 9a 42 f0 42 bc 79 0f 0b 68 d6 
a3 36 dd 36 f4 06 7d f9 51 69 18 5d 13 2f 6a 54 
b5 8c f0 ee 0d 86 67 f5 85 54 51 30 06 48 5b f6 
f9 e5 e1 d8 4a 45 f2 75 da 17 69 60 c2 c4 09 36 
0d 76 9c 3e 30 0d ce ed 1c 55 aa d1 d0 c8 62 6f 
18 41 cf f9 0c 49 df 19 15 a5 c5 25 57 5d f0 2f 
14 86 e3 37 49 46 a3 01 5e c0 58 38 d6 20 70 4a 
36 67 2c 5b d3 26 cf ed 46 12 d1 3e 83 a8 69 57 
0e b0 8e f9 87 2e 69 dd fe e9 88 22 fb eb 74 0f 
a3 4a 3e 39 f5 cb b2 42 32 b8 3d b0 8e 72 3a 87 
7f 79 ec 51 24 7e 34 7c a5 e3 e7 22 b0 05 bd 62 
f8 75 da 28 0a 55 16 78 f2 ed 06 e1 5d d8 6e 56 
2b 88 78 93 2d fd 4d da 8e 59 eb b6 f4 12 86 d9 
c3 f6 7b 85 56 05 01 5d 1d ac 35 1a 4b 41 91 b6 
aa 79 00 90 a7 47 0c 1c 9e 82 b6 43 f2 30 29 19 
1b b4 72 e2 61 b9 24 77 1e 53 47 57 7d cf e3 4e 
97 ae f2 88 01 5e 7a 8d 55 1f 7a a3 06 a7 4f 0c 
56 72 c9 5b b1 41 73 5a 38 c0 fb 16 a3 d8 f8 da 
e3 fc a4 e3 91 4e ab 5a 94 1b 5a 02 69 d3 11 e9 
06 e0 95 1a 21 bd 3c f5 ef ec e2 f3 ed be 5d b0 
0d a7 49 7b 5c 66 4d e6 4d 2f 89 52 b9 d2 3c 2f 
c1 ec 26 73 8d 52 c5 d7 20 49 c9 57 3f f8 f2 da 
d5 46 13 a1 30 a1 24 60 27 cb 95 ab 7f 15 1c 6c
void
9b 98 0c a8 80 ce 9b 17 06 3b 3d 6e c2 24 0b e3 
29 36 b0 41 df 6b 94 97 8f e4 be e8 d8 5b fb 99 
f8 01 e8 c8 9b fd 6e fd 67 74 74 02 27 9e dc c4 
52 a8 18 dc 83 25 19 5e 34 5d e1 33 d9 55 cb 39 
10 78 66 5a 88 65 44 de 11 3b 38 d2 94 42 26 4b 
4e 64 c7 17 5a 62 f3 e8 83 46 37 15 01 94 f5 21 
3e 81 03 17 05 7d fd ef 33 b6 2c 55 66 6a c2 36 
a2 5b 7f 12 78 0a fb e1 a1 8f a1 7c 2a c9 19 cc 
bc 39 a5 e5 27 b6 e2 1c 2f 8e af fc 71 17 09 1b 
1d 26 e5 ac ff 27 09 d7 20 16 43 42 8e 9e 4c f5 
bb 2e 4f 57 bc 41 79 a1 93 d5 ca f5 23 36 56 82 
7d 02 b5 0b af ef 35 d1 5a d0 f3 8a 92 8b 83 55 
8d 0e e4 77 78 45 5a 57 01 19 a5 e5 d3 46 1b 06 
e8 4a 18 ce 63 6e e9 4d 90 19 a1 6a 3e 86 d2 60 
4f 45 84 56 a5 fd f4 b4 ef 55 cf 6e d3 08 40 a6 
08 c7 2d e1 fe bd 25 0c 13 0f 08 4a ff d9 3d 92 
e5 db 9d 22 53 5d e2 8a c5 65 74 14 f2 ff 81 54 
04 2b bd 49 ee 02 ed 5c 64 35 f3 bb aa 50 8d a6 
a9 5b ae 4b 93 82 ce a5 87 c2 65 4c c3 ab 05 f0 
3d 4d 75 b7 ad d4 68 de b2 94 88 07 ce 31 ac 20 
0e 97 41 e1 d4 89 af b9 e5 92 3c ce 56 e3 f5 c6 
c8 f5 4f b7 94 db cc 30 f0 30 f1 49 4a 15 03 6d 
bc 64 85 6e 95 82 14 c1 5b 6c d7 43 81 f3 da b0 
e1 6b a5 e3 59 5d 4e 41 38 7d d5 9a aa cb ef 12 
8d 97 88 90 03 d3 92 91 90 96 7b 02 00 6a cc c3 
01 f9 c1 fe 2c 8d a7 49 0b c3 7f 16 77 45 4b 9f 
3d 5d f5 96 f6 94 3e f1 65 0b 33 90 f9 f0 6a ef 
c9 2b 9c 8c 92 53 e2 c9 26 30 6e fc fa b7 df 70 
38 ee b9 02 16 5e d5 69 97 25 a1 ae a4 19 9f f8 
93 31 85 7e 2b 78 29 b7 a0 fb f3 b9 15 71 59 ca 
e1 b5 6d 61 b9 df 8d 93 35 6d 25 ff ba 80 e1 b9 
d0 32 b3 4a 08 7f 4f 1f 83 49 f3 61 59 59 18 7d 
40 b2 f8 97 44 61 fa d9 a3 9f d5 d6 41 64 ee ef 
22 3d f7 ba b6 47 a2 65 8f 50 7b d1 83 59 c0 51 
0e 38 06 d5 03 17 d2 87 0c 38 bd 72 b3 1b 16 33 
ca 41 91 d7 1f 73 bd 4a 88 d4 f7 58 1f 92 24 a5 
80 51 ea 97 3c c9 67 3e 42 1d 70 4f 58 f2 e3 1b 
49 e0 67 12 c4 35 37 3e 22 cc 3a 90 2d ea 23 4c 
39 57 8f fb e8 6e 9c df bb c3 38 ae b5 e5 e5 ee 
18 d0 b6 c5 c7 e0 a6 ad 5c 9e f7 59 ce 53 71 eb 
fe 09 c2 3b 39 fc d2 8d f8 bb 5c 37 c9 61 e3 94 
3a de 42 85 b7 7b ca e8 c9 06 29 f8 e1 41 12 d5 
1a 63 24 75 66 ee cf a2 bf 22 ae 55 33 49 4c 43 
fa a1 1c a1 5b cb fb 0a 4d 07 cd d8 c2 16 e1 35 
23 af a8 96 c6 a7 8d fc f6 c3 1b 85 70 2e ae 56 
d4 6a af 1a 96 eb cd ac 25 5d c4 a3 00 fd 1b 8c 
29 75 75 68 eb d6 2d 15 45 98 90 75 31 24 ac ec 
87 70 34 ee 23 eb 15 3c 54 dd 8f ff 34 74 81 ae 
ea c6 19 45 6c 9a 88 0f 43 b0 f9 9c 4a 13 cc 6f 
56 f1 f5 b7 c9 16 47 1d 54 f5 99 95 ba ac 5e c4 
02 7e fd a2 66 76 92 fe 5b 06 63 cb b9 29 14 f2 
2c 70 58 36 89 a8 84 af 60 aa 41 a0 21 84 d0 43 
b7 1b f5 eb 3a 43 8f f9 c2 ec 6b 76 94 5b 7f e9 
17 e7 7f 9d c8 19 28 c6 fe a1 7f 84 49 31 45 68 
2f cc fc 0e a1 85 ef 79 e7 0f f5 65 b6 65 45 59 
af 5b 3b 27 0f bf e6 5b 75 63 35 c5 03 e6 51 57 
81 48 00 f9 b5 4f dd 0b 1e 41 45 ef 90 c4 4e 26 
b4 15 c8 fc e2 60 be b9 a7 2f e5 73 06 0c d7 56 
f2 e8 fc 70 64 e0 2e be 62 df a9 14 a1 ab 3d f8 
dc 93 d8 32 77 d7 38 1d 6e ae ce 29 92 d9 90 9b 
cb cd 6c 5c 57 ce 91 05 16 72 64 5b 6a 9a 54 3b 
eb 42 8c b8 6e 6d ac 74 5c b0 c0 4c b6 f8 61 f1 
a2 c5 aa b3 ed 6b e9 76 e1 9a c1 b8 70 43 d3 b9 
8a 5e 0a c2 a6 f1 39 7d d9 fe 46 a0 17 56 f1 49 
5d ed f9 2e 8e a1 56 4c fc a9 39 7c 95 a6 77 e2 
e0 7c db ea a2 be ff 14 f7 04 ea 23 cf 6a 8a 02 
18 bf 40 ce 2d de e4 b0 34 90 d4 c3 c3 15 bf 7b 
e7 03 de f7 5a d8 8f 27 5c 5f b8 37 c1 f9 54 22 
39 52 e7 e9 78 a3 df ce 98 96 7a a4 ea 8b 62 28 
00 25 3b 2c ce 1a 68 ae 46 1d 6c a1 f2 9c 16 29 
91 05 18 3e ab fb a3 d4 fd d0 ed e0 54 5e c1 13 
65 2b 59 ee 4f 6f bc 37 75 ff ab 1b 63 5e 7c fa 
f7 3b 91 46 ae 0c f5 5f f8 5f 43 5a 2c f4 82 b5 
1d 10 ae 59 92 f9 fc 61 86 06 ec d1 43 18 c2 8e 
be fd 9a 41 2f 81 58 d4 c9 8a 49 43 2a 81 f5 d9 
92 e9 b2 dd 23 5d 94 fb 7b 29 b3 7b cc 49 57 8d 
26 63 1d 15 9d f7 12 87 df 7d c4 4c 0d fd 29 81 
79 0b e0 9a c0 0b 27 93 ca d1 02 d0 ba 37 e1 67 
53 dd 6c 1d b5 bd 99 11 c5 1a 84 06 6a 08 82 c8 
fc 2b 92 fb b7 c3 dc 4a 4a eb 29 04 b4 42 1c 8f 
4d a2 39 41 a7 d3 d6 ad c0 71 f3 ba c3 ad 00 0b 
a5 c7 60 6a 1a 5d 87 a3 80 5c 08 97 7a 04 4c 13 
f5 6b 0c a4 90 78 fa 1d b6 d5 df 4c c3 27 a4 a9 
ae a3 a8 db 37 cd 0e b0 ba a3 6f 7d 7f 40 b4 fc 
c3 35 59 ef 4e b7 dc 27 32 79 0a 30 e4 a4 58 f2 
47 d7 f8 38 24 d1 41 41 53 de c8 ff f2 65 ff 1a 
f7 88 17 f3 59 84 4d 2d 5b ad 7d 3e d6 c2 c2 e7 
5f 4e f5 d5 da 56 e5 1c a4 30 6a f7 60 5d 51 ff 
4e ec 0d f7 60 5a 69 53 0e 63 d7 f8 af b7 e2 81 
37 99 0a 4f 1f a5 9b fc ff 6a 11 dc 2b 1f f2 4e 
06 e2 2d 53 b7 0f 65 9a 9c 6a 52 e1 7c 13 af 56 
7b 50 f4 16 37 f2 67 12 a4 54 11 48 3a cd 9f bb 
d6 4f eb da d4 1c b9 47 db 2c 7e 3b 85 e3 77 03 
aa 12 e8 af 4f 5f df e5 da 5a c9 53 14 2c 86 ed 
02 5e 9c e3 77 f6 bf 18 ad 25 51 47 75 73 72 85 
c6 0a 45 bf 2a 14 2c d8 07 5d 9f e6 e4 e2 6f 2c 
5c e0 84 4f 50 16 6c 23 75 87 63 d9 2f 43 22 ef 
31 2a c1 f9 be ce c3 54 64 5d 3c d7 71 06 9d 5f 
85 b0 c2 26 87 dc 3f 33 f9 e5 5e 6c d3 7b 07 cd 
41 35 80 ab 5c 6a 97 ec a1 c6 60 23 6d 3d c4 c3 
f2 ea b2 59 fd 5b 38 b8 9d aa 24 bf 32 b0 fd 3f 
e6 c3 94 29 05 98 5c f7 39
Unable to evaluate the expression "String temp = "clientRandom: " + TLSTest.bytesToHex(this.cryptoParams.getSecurityParametersHandshake().clientRandom) + "\nserverRandom: " + TLSTest.bytesToHex(this.cryptoParams.getSecurityParametersHandshake().serverRandom) + "\ncipherText: " + TLSTest.bytesToHex(ciphertext);" : java.lang.NullPointerException
HTTP/1.1 200 OK
Server: X_12302.eli
Date: Mon, 30 Dec 2024 00:08:02 GMT
Content-Type: text/html
Content-Length: 2239
Last-Modified: Tue, 08 Oct 2024 01:41:47 GMT
Connection: close
Vary: Accept-Encoding
ETag: "67048ddb-8bf"
Strict-Transport-Security: max-age=15552000
Accept-Ranges: bytes

15 03 03 00 1a 84 ef 8c ec 32 b4 9f db a9 11 e8 
3f 18 d6 fe 11 34 13 20 11 ce a3 c8 ca 1f 77
void
Unable to evaluate the expression "String temp = "clientRandom: " + TLSTest.bytesToHex(this.cryptoParams.getSecurityParametersHandshake().clientRandom) + "\nserverRandom: " + TLSTest.bytesToHex(this.cryptoParams.getSecurityParametersHandshake().serverRandom) + "\ncipherText: " + TLSTest.bytesToHex(ciphertext);" : java.lang.NullPointerException
15 03 03 00 1a 00 00 00 00 00 00 00 02 3a f7 82 
f2 00 2e 34 39 8a 72 77 2b c0 bb aa 34 65 a9
void
<!doctypehtml><html lang="en"><meta charset="UTF-8"><title>index</title><style>body{margin:0;padding:0;overflow:hidden;position:relative;display:flex;justify-content:center;align-items:center;height:150vh;background:#eee8ee;font-size:12px;font-family:Arial,sans-serif}canvas{position:absolute;bottom:0;left:0;z-index:-1}#bottom_layer{visibility:hidden;width:3000px;position:fixed;z-index:302;bottom:0;left:0;height:65px;padding-top:1px;zoom:1;margin:0;line-height:39px}#bottom_layer .s-bottom-layer-content{margin:0 17px;text-align:center}#bottom_layer .lh{display:inline-block;margin-right:14px}#bottom_layer .text-color{color:#979e87}#bottom_layer a{font-size:12px;text-decoration:none}</style><canvas id="waveCanvas"></canvas><div id="bottom_layer"style="visibility:visible;width:100%"><div class="s-bottom-layer-content"><p class="lh"><a class="text-color"href="//wtfu.site"target="_self">关于首页</a><p class="lh"><a class="text-color"href="https://wtfu.site"target="_self">About Site</a><p class="lh"><a class="text-color"href="https://beian.mps.gov.cn/#/query/webSearch?code=11011402053698"rel="noreferrer"target="_blank"><img src="https://beian.mps.gov.cn/img/logo01.dd7ff50e.png"class="w-full"style="width:12px;padding-right:3px;vertical-align:-2px"> 京公网安备11011402053698</a><p class="lh"><a class="text-color"href="https://beian.miit.gov.cn"target="_blank">陇ICP备2020004323号</a><p class="lh"><span class="text-color">© Copyright 2000-2023 12302, Inc. and Contributors</span><p class="lh"><span class="text-color">Created using OpenAI</span></div></div><script>let i=document.getElementById("waveCanvas"),n=i.getContext("2d"),h=(i.width=window.innerWidth,i.height=window.innerHeight,{yOffset:100,amplitude:50,wavelength:.03,frequency:.01,phase:0,speed:.1});window.addEventListener("resize",()=>{i.width=window.innerWidth,i.height=window.innerHeight}),function e(){n.clearRect(0,0,i.width,i.height),n.fillStyle="rgba(255, 255, 255, 0.5)",n.beginPath();for(let e=0;e<i.width;e+=10){var t=h.yOffset+Math.sin(e*h.wavelength+h.phase)*h.amplitude*Math.sin(h.frequency*e+h.phase);n.lineTo(e,t)}n.lineTo(i.width,i.height),n.lineTo(0,i.height),n.closePath(),n.fill(),h.phase+=h.speed,requestAnimationFrame(e)}()</script>
Disconnected from the target VM, address: '127.0.0.1:64185', transport: 'socket'

Process finished with exit code 0

/ on archive

Intro(RIFF) #

结构组成 #

简介 #

常用选项 #

模式部分 #

外链 #

3.1 rubular.com外链 #

3.2 RegEx 学习记录 #

Reference #

OBJECT ORIENTED

对象结构 #

对象头 #

Mark Word #

Intro(ANI | Animated cursors | 动画光标) #

数据结构验证 #

Reference #

一.语法格式： #

二.常用选项： #

三. 使用案例： #

1）简单样例 #

2）BEGIN，END模块 #

3）awk运算符 #

4）常用awk内置变量 #

5）awk正则 #

6）awk的C语言特性（if,循环和数组） #

7）常用字符串函数 #

四.参考： #

sed (Stream Editor): #

一.语法格式： #

二.常用选项： #

三.地址匹配： #

Intro(CURL| client url) #

SYNTAX #

样例 #

1.ajax提交new from #

Intro(wget) #

响应内容到标准输出 #

Reference #

简介 #

1.介绍 #

2.功能 #

3.负载均衡方式 #

编译安装 #

基本命令 #

BASE #

代理设置 #

凭据管理 #

1.基本操作 #

Intro(CYCLE-LINKED | 环形链表检测) #

题目描述 #

Intro(REVERSE-LINKED-LIST | 反转链表) #

题目描述 #

binary search #

implement #

Reference #

bubble #

visualization #

implement #

Reference #

insertion #

visualization #

implement #

Reference #

selection #

visualization #

implement #

Reference #

Intro(Stack) #

Reference #

Intro(BinaryTree) #

二叉树 #

定义 #

性质 #

满二叉树 #

定义 #

性质 #

完全二叉树 #

定义 #

示例 #