0%

由于经常在服务器上运行程序,本地不可能一直和服务器保持连接,而且如果本地和服务器的连接断开,在服务器上运行的程序将会终止,为了,查找了一些网络资料,发现screen 会话命令可以保持本地和服务器断开后,程序继续在服务器上运行,并且运行结束后,输出最后的结果。

一、背景

系统管理员经常需要SSH 或者telent 远程登录到Linux 服务器,经常运行一些需要很长时间才能完成的任务,比如系统备份、ftp 传输等等。通常情况下我们都是为每一个这样的任务开一个远程终端窗口,因为它们执行的时间太长了。必须等待它们执行完毕,在此期间不能关掉窗口或者断开连接,否则这个任务就会被杀掉,一切半途而废了。

二、简介

GNU Screen是一款由GNU计划开发的用于命令行终端切换的自由软件。用户可以通过该软件同时连接多个本地或远程的命令行会话,并在其间自由切换。

GNU Screen可以看作是窗口管理器的命令行界面版本。它提供了统一的管理多个会话的界面和相应的功能。

会话恢复

只要Screen本身没有终止,在其内部运行的会话都可以恢复。这一点对于远程登录的用户特别有用——即使网络连接中断,用户也不会失去对已经打开的命令行会话的控制。只要再次登录到主机上执行screen -r就可以恢复会话的运行。同样在暂时离开的时候,也可以执行分离命令detach,在保证里面的程序正常运行的情况下让Screen挂起(切换到后台)。这一点和图形界面下的VNC很相似。

多窗口

在Screen环境下,所有的会话都独立的运行,并拥有各自的编号、输入、输出和窗口缓存。用户可以通过快捷键在不同的窗口下切换,并可以自由的重定向各个窗口的输入和输出。Screen实现了基本的文本操作,如复制粘贴等;还提供了类似滚动条的功能,可以查看窗口状况的历史记录。窗口还可以被分区和命名,还可以监视后台窗口的活动。

会话共享

Screen可以让一个或多个用户从不同终端多次登录一个会话,并共享会话的所有特性(比如可以看到完全相同的输出)。它同时提供了窗口访问权限的机制,可以对窗口进行密码保护。

GNU's Screen 官方站点:http://www.gnu.org/software/screen/

三、语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# screen [-AmRvx -ls -wipe][-d <作业名称>][-h <行数>][-r <作业名称>][-s ][-S <作业名称>]

参数说明

-A  将所有的视窗都调整为目前终端机的大小。
-d <作业名称>  将指定的screen作业离线。
-h <行数>  指定视窗的缓冲区行数。
-m  即使目前已在作业中的screen作业,仍强制建立新的screen作业。
-r <作业名称>  恢复离线的screen作业。
-R  先试图恢复离线的作业。若找不到离线的作业,即建立新的screen作业。
-s  指定建立新视窗时,所要执行的shell。
-S <作业名称>  指定screen作业的名称。
-v  显示版本信息。
-x  恢复之前离线的screen作业。
-ls或--list  显示目前所有的screen作业。
-wipe  检查目前所有的screen作业,并删除已经无法使用的screen作业。

四、常用screen参数

1
2
3
4
5
screen -S yourname -> 新建一个叫yourname的session
screen -ls(或者screen -list) -> 列出当前所有的session
screen -r yourname -> 回到yourname这个session
screen -d yourname -> 远程detach某个session
screen -d -r yourname -> 结束当前session并回到yourname这个session

在每个screen session 下,所有命令都以 ctrl+a(C-a) 开始。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
C-a ? -> 显示所有键绑定信息
C-a c -> 创建一个新的运行shell的窗口并切换到该窗口
C-a n -> Next,切换到下一个 window
C-a p -> Previous,切换到前一个 window
C-a 0..9 -> 切换到第 0..9 个 window
Ctrl+a [Space] -> 由视窗0循序切换到视窗9
C-a C-a -> 在两个最近使用的 window 间切换
C-a x -> 锁住当前的 window,需用用户密码解锁
C-a d -> detach,暂时离开当前session,将目前的 screen session (可能含有多个 windows) 丢到后台执行,并会回到还没进 screen 时的状态,此时在 screen session 里,每个 window 内运行的 process (无论是前台/后台)都在继续执行,即使 logout 也不影响。
C-a z -> 把当前session放到后台执行,用 shell 的 fg 命令则可回去。
C-a w -> 显示所有窗口列表
C-a t -> Time,显示当前时间,和系统的 load
C-a k -> kill window,强行关闭当前的 window
C-a [ -> 进入 copy mode,在 copy mode 下可以回滚、搜索、复制就像用使用 vi 一样
C-b Backward,PageUp
C-f Forward,PageDown
H(大写) High,将光标移至左上角
L Low,将光标移至左下角
0 移到行首
$ 行末
w forward one word,以字为单位往前移
b backward one word,以字为单位往后移
Space 第一次按为标记区起点,第二次按为终点
Esc 结束 copy mode
C-a ] -> Paste,把刚刚在 copy mode 选定的内容贴上

五、使用 screen

5.1 安装screen

流行的Linux发行版(例如Red Hat Enterprise Linux)通常会自带screen实用程序,如果没有的话,可以从GNU screen的官方网站下载。

1
2
3
4
[root@TS-DEV ~]# yum install screen
[root@TS-DEV ~]# rpm -qa|grep screen
screen-4.0.3-4.el5
[root@TS-DEV ~]#

5.2 创建一个新的窗口

安装完成后,直接敲命令screen就可以启动它。但是这样启动的screen会话没有名字,实践上推荐为每个screen会话取一个名字,方便分辨:

1
[root@TS-DEV ~]# screen -S david

screen启动后,会创建第一个窗口,也就是窗口No. 0,并在其中打开一个系统默认的shell,一般都会是bash。所以你敲入命令screen之后,会立刻又返回到命令提示符,仿佛什么也没有发生似的,其实你已经进入Screen的世界了。当然,也可以在screen命令之后加入你喜欢的参数,使之直接打开你指定的程序,例如:

1
[root@TS-DEV ~]# screen vi david.txt

screen创建一个执行vi david.txt的单窗口会话,退出vi 将退出该窗口/会话。

查看自己的会话,可以使用命令:

1
screen -ls  # or: screen -list

显示如下: alt 其中:12865是ID,即进程的ID,如果为session命名的话,紧跟ID后'.'的后面应该是session的名字,以后连接可以使用ID或者自己命名的名字。

5.3 查看窗口和窗口名称

打开多个窗口后,可以使用快捷键C-a w列出当前所有窗口。如果使用文本终端,这个列表会列在屏幕左下角,如果使用X环境下的终端模拟器,这个列表会列在标题栏里。窗口列表的样子一般是这样:

1
0$ bash  1-$ bash  2*$ bash

这个例子中我开启了三个窗口,其中*号表示当前位于窗口2,-号表示上一次切换窗口时位于窗口1。

Screen默认会为窗口命名为编号和窗口中运行程序名的组合,上面的例子中窗口都是默认名字。练习了上面查看窗口的方法,你可能就希望各个窗口可以有不同的名字以方便区分了。可以使用快捷键C-a A来为当前窗口重命名,按下快捷键后,Screen会允许你为当前窗口输入新的名字,回车确认。

5.4 会话分离与恢复

你可以不中断screen窗口中程序的运行而暂时断开(detach)screen会话,并在随后时间重新连接(attach)该会话,重新控制各窗口中运行的程序。例如,我们打开一个screen窗口编辑/tmp/david.txt文件:

1
[root@TS-DEV ~]# screen vi /tmp/david.txt

之后我们想暂时退出做点别的事情,比如出去散散步,那么在screen窗口键入C-a d,Screen会给出detached提示:

或者使用

1
screen -d  <session ID 或者 名字>

如果本地用的Shell出现“卡顿”,自己关闭了这个窗口,但是重新连接时,发现状态为“Attached”,不能连接。这时,你也可以使用上面的命令,先中断会话,再重新连接。

暂时中断会话 alt 半个小时之后回来了,找到该screen会话:

1
[root@TS-DEV ~]# screen -ls

alt 重新连接会话:

1
[root@TS-DEV ~]# screen -r 12865

一切都在。

当然,如果你在另一台机器上没有分离一个Screen会话,就无从恢复会话了。

这时可以使用下面命令强制将这个会话从它所在的终端分离,转移到新的终端上来: alt

5.5 清除dead 会话

如果由于某种原因其中一个会话死掉了(例如人为杀掉该会话),这时screen -list会显示该会话为dead状态。使用screen -wipe命令清除该会话: alt

5.6 关闭或杀死窗口

正常情况下,当你退出一个窗口中最后一个程序(通常是bash)后,这个窗口就关闭了。另一个关闭窗口的方法是使用C-a k,这个快捷键杀死当前的窗口,同时也将杀死这个窗口中正在运行的进程。

如果一个Screen会话中最后一个窗口被关闭了,那么整个Screen会话也就退出了,screen进程会被终止。

除了依次退出/杀死当前Screen会话中所有窗口这种方法之外,还可以使用快捷键C-a :,然后输入quit命令退出Screen会话。需要注意的是,这样退出会杀死所有窗口并退出其中运行的所有程序。其实C-a :这个快捷键允许用户直接输入的命令有很多,包括分屏可以输入split等,这也是实现Screen功能的一个途径,不过个人认为还是快捷键比较方便些。

六、screen 高级应用

6.1 会话共享

还有一种比较好玩的会话恢复,可以实现会话共享。假设你在和朋友在不同地点以相同用户登录一台机器,然后你创建一个screen会话,你朋友可以在他的终端上命令:

1
[root@TS-DEV ~]# screen -x

这个命令会将你朋友的终端Attach到你的Screen会话上,并且你的终端不会被Detach。这样你就可以和朋友共享同一个会话了,如果你们当前又处于同一个窗口,那就相当于坐在同一个显示器前面,你的操作会同步演示给你朋友,你朋友的操作也会同步演示给你。当然,如果你们切换到这个会话的不同窗口中去,那还是可以分别进行不同的操作的。

6.2 会话锁定与解锁

Screen允许使用快捷键C-a s锁定会话。锁定以后,再进行任何输入屏幕都不会再有反应了。但是要注意虽然屏幕上看不到反应,但你的输入都会被Screen中的进程接收到。快捷键C-a q可以解锁一个会话。

也可以使用C-a x锁定会话,不同的是这样锁定之后,会话会被Screen所属用户的密码保护,需要输入密码才能继续访问这个会话。

6.3 发送命令到screen会话

在Screen会话之外,可以通过screen命令操作一个Screen会话,这也为使用Screen作为脚本程序增加了便利。关于Screen在脚本中的应用超出了入门的范围,这里只看一个例子,体会一下在会话之外对Screen的操作:

[root@TS-DEV ~]# screen -S sandy -X screen ping www.baidu.com

这个命令在一个叫做sandy的screen会话中创建一个新窗口,并在其中运行ping命令。

6.4 屏幕分割

现在显示器那么大,将一个屏幕分割成不同区域显示不同的Screen窗口显然是个很酷的事情。可以使用快捷键C-a S将显示器水平分割,Screen 4.00.03版本以后,也支持垂直分屏,快捷键是C-a |。分屏以后,可以使用C-a 在各个区块间切换,每一区块上都可以创建窗口并在其中运行进程。

可以用C-a X快捷键关闭当前焦点所在的屏幕区块,也可以用C-a Q关闭除当前区块之外其他的所有区块。关闭的区块中的窗口并不会关闭,还可以通过窗口切换找到它。 alt

6.5 C/P模式和操作

screen的另一个很强大的功能就是可以在不同窗口之间进行复制粘贴了。使用快捷键C-a 或者C-a [可以进入copy/paste模式,这个模式下可以像在vi中一样移动光标,并可以使用空格键设置标记。其实在这个模式下有很多类似vi的操作,譬如使用/进行搜索,使用y快速标记一行,使用w快速标记一个单词等。关于C/P模式下的高级操作,其文档的这一部分有比较详细的说明。

一般情况下,可以移动光标到指定位置,按下空格设置一个开头标记,然后移动光标到结尾位置,按下空格设置第二个标记,同时会将两个标记之间的部分储存在copy/paste buffer中,并退出copy/paste模式。在正常模式下,可以使用快捷键C-a ]将储存在buffer中的内容粘贴到当前窗口。 alt

6.6 更多screen功能

同大多数UNIX程序一样,GNU Screen提供了丰富强大的定制功能。你可以在Screen的默认两级配置文件/etc/screenrc和$HOME/.screenrc中指定更多,例如设定screen选项,定制绑定键,设定screen会话自启动窗口,启用多用户模式,定制用户访问权限控制等等。如果你愿意的话,也可以自己指定screen配置文件。

以多用户功能为例,screen默认是以单用户模式运行的,你需要在配置文件中指定multiuser on 来打开多用户模式,通过acl*(acladd,acldel,aclchg...)命令,你可以灵活配置其他用户访问你的screen会话。更多配置文件内容请参考screen的man页。

Shadowsocks作为现在一种很流行的穿墙工具,以其轻量级、速度感人等优点深受广大网友热捧。与VP_N相比,他就像一把锋利的”瑞士军刀”,不用受制于“系统全局代理”模式的困扰,控制更加便捷,基于Socks5安全加密协议,防止GF*W通过分析流量特征从而干扰的问题。而又不像GoAgent这种集中式爬墙模式,一般不会出现全局封锁等现象。不管你是因为什么原因喜欢上Shadowsocks,我相信她一定有给你带来好的体验的方面。

在Shadowsocks里面,系统代理模式有两种,一种是“系统代理模式”,另一种是“PAC代理模式”,通常情况下我们会选择后者,今天这里给大家解析一下PAC模式的原理以及如何修改PAC文件、user-rule文件实现自动代理,希望大家可以通过本文更的“科学上网”。

什么是PAC

代理自动配置(英语:Proxy auto-config,简称PAC)是一种网页浏览器技术,用于定义浏览器该如何自动选择适当的代理服务器来访问一个网址。

一个PAC文件包含一个JavaScript形式的函数“FindProxyForURL(url, host)”。这个函数返回一个包含一个或多个访问规则的字符串。用户代理根据这些规则适用一个特定的代理其或者直接访问。当一个代理服务器无法响应的时候,多个访问规则提供了其他的后备访问方法。浏览器在访问其他页面以前,首先访问这个PAC文件。PAC文件中的URL可能是手工配置的,也可能是是通过网页的网络代理自发现协议(Web Proxy Autodiscovery Protocol)自动配置的。

上面是从维基百科摘录的关于PAC的解释,我做了一个简单的图片解释什么是PAC: alt

简单的讲,PAC就是一种配置,它能让你的浏览器智能判断哪些网站走代理,哪些不需要走代理。用过Shadowsocks的朋友应该会知道, shadowsocks.exe 同级目录下有一个 pac.txt 文件,这正是我们本文刚刚所说的pac配置文件。 alt 打开 pac.txt 文件,可以看到如下内容 alt 可以看到pac配置文件是用的JavaScript语法,里面有一个变量 rules ,是一个JSon数组格式的数据类型,数组里面存放的是各种URL的通配符,那么在pac模式下,如果当访问符合这个数组里面任意一个URL通配符的网址时,系统会走代理,反之直连。比如图中pac配置,如果访问 http://www.cloudflare.com/index.php 时,会走代理,而访问百度、新浪等国内网站则会选择直连方式。

PAC的优势

PAC自动代理属于智能判断模式,相比全局代理,它的优点有:

  • 不影响国内网站的访问速度,防止无意义的绕路
  • 节省Shadowsocks服务的流量,节省服务器资源
  • 控制方便

PAC文件及user-rule文件的语法规则

那么,当一个网站被墙,如何添加到PAC里面让其能够正常访问呢?在Shadowsocks里面,可以有如下两个方式:

1. 添加到 pac.txt 文件中

编辑 pac.txt 文件,模仿里面的一些URL通配符,再添加一个,例如"||ip138.com", ,注意不要忘记了 , 半角逗号,那么意思就是所有 ip138.com域名下的网址都将走Shadowsocks代理,打开ip138可以看到IP已经变成Shadowsocks所用的国外代理了 alt

2. 添加到 user-rule.txt 文件中

编辑 user-rule.txt 文件,这里和 pac.txt 文件语法不完全相同,user-rule文件中,每一行表示一个URL通配符,但是通配符语法类似。例如添加一行||ip138.com^ ,然后记得右键小飞机-PAC-从GFWList更新本地PAC,打开ip138可以看到IP已经变成Shadowsocks所用的国外代理了 alt 注意末尾不要忘记 ^ 符号,意思是要么在这个符号的地方结束,要么后面跟着?,/等符号。

语法

自定义代理规则的设置语法与GFWlist相同,语法规则如下:

  • 通配符支持。比如 .example.com/ 实际书写时可省略 * , 如.example.com/ , 和 .example.com/ 效果一样
  • 正则表达式支持。以 \ 开始和结束, 如 [\w]+://example.com\
  • 例外规则 @@ ,如 @@.example.com/ 满足 @@ 后规则的地址不使用代理
  • 匹配地址开始和结尾 | ,如 |http://example.com 、 example.com| 分别表示以 http://example.com 开始和以 example.com 结束的地址
  • || 标记,如 ||example.com 则 http://example.comhttps://example.comftp://example.com 等地址均满足条件
  • 注释 ! 。 如 !我是注释

更多user-rule.txt语法规则,可以参考AdBlockPlus过滤规则https://adblockplus.org/en/filter-cheatsheet

对于经常使用Git的朋友来说,.gitignore配置一定不会陌生。废话不说多了,接下来就来说说这个.gitignore的使用。

首先要强调一点,这个文件的完整文件名就是".gitignore",注意最前面有个“.”。 一般来说每个Git项目中都需要一个“.gitignore”文件,这个文件的作用就是告诉Git哪些文件不需要添加到版本管理中。实际项目中,很多文件都是不需要版本管理的,比如Python的.pyc文件和一些包含密码的配置文件等等。这个文件的内容是一些规则,Git会根据这些规则来判断是否将文件添加到版本控制中。

下面我们看看常用的规则:

1
2
3
1)/mtk/        过滤整个文件夹
2)*.zip 过滤所有.zip文件
3)/mtk/do.c 过滤某个具体文件

很简单吧,被过滤掉的文件就不会出现在git仓库中(gitlab或github)了,当然本地库中还有,只是push的时候不会上传。 需要注意的是,gitignore还可以指定要将哪些文件添加到版本管理中:

1
2
1)!*.zip
2)!/mtk/one.txt

唯一的区别就是规则开头多了一个感叹号,Git会将满足这类规则的文件添加到版本管理中。 为什么要有两种规则呢?想象一个场景:假如我们只需要管理/mtk/目录中的one.txt文件,这个目录中的其他文件都不需要管理,那么我们就需要使用:

1
2
1)/mtk/
2)!/mtk/one.txt

假设我们只有过滤规则,而没有添加规则,那么我们就需要把/mtk/目录下除了one.txt以外的所有文件都写出来!

最后需要强调的一点是,如果你不慎在创建.gitignore文件之前就push了项目,那么即使你在.gitignore文件中写入新的过滤规则,这些规则也不会起作用,Git仍然会对所有文件进行版本管理。 简单来说,出现这种问题的原因就是Git已经开始管理这些文件了,所以你无法再通过过滤规则过滤它们。因此一定要养成在项目开始就创建.gitignore文件的习惯,否则一旦push,处理起来会非常麻烦。

.gitignore配置文件用于配置不需要加入版本管理的文件,配置好该文件可以为版本管理带来很大的便利,以下是对于配置.gitignore的一些心得记录: 1)配置语法:

1
2
3
4
5
以斜杠“/”开头表示目录;
以星号“*”通配多个字符;
以问号“?”通配单个字符
以方括号“[]”包含单个字符的匹配列表;
以叹号“!”表示不忽略(跟踪)匹配到的文件或目录;

此外,git 对于 .ignore 配置文件是按行从上到下进行规则匹配的,意味着如果前面的规则匹配的范围更大,则后面的规则将不会生效;

2)示例说明 a)规则:

1
fd1/*

说明:忽略目录 fd1 下的全部内容;注意,不管是根目录下的 /fd1/ 目录,还是某个子目录 /child/fd1/ 目录,都会被忽略; b)规则:

1
/fd1/*

说明:忽略根目录下的 /fd1/ 目录的全部内容; c)规则:

1
2
3
4
/*
!.gitignore
!/fw/bin/
!/fw/sf/

说明:忽略全部内容,但是不忽略 .gitignore 文件、根目录下的 /fw/bin/ 和 /fw/sf/ 目录;

Git忽略规则及.gitignore规则不生效的解决办法

在git中如果想忽略掉某个文件,不让这个文件提交到版本库中,可以使用修改根目录中 .gitignore 文件的方法(如无,则需自己手工建立此文件)。这个文件每一行保存了一个匹配的规则例如:

1
2
3
4
5
6
# 此为注释 – 将被 Git 忽略
*.a # 忽略所有 .a 结尾的文件
!lib.a # 但 lib.a 除外
/TODO # 仅仅忽略项目根目录下的 TODO 文件,不包括 subdir/TODO
build/ # 忽略 build/ 目录下的所有文件
doc/*.txt # 会忽略 doc/notes.txt 但不包括 doc/server/arch.txt

规则很简单,不做过多解释,但是有时候在项目开发过程中,突然心血来潮想把某些目录或文件加入忽略规则,按照上述方法定义后发现并未生效,原因是.gitignore只能忽略那些原来没有被track的文件,如果某些文件已经被纳入了版本管理中,则修改.gitignore是无效的。那么解决方法就是先把本地缓存删除(改变成未track状态),然后再提交:

1
2
3
git rm -r --cached .
git add .
git commit -m 'update .gitignore'

注意: 不要误解了 .gitignore 文件的用途,该文件只能作用于 Untracked Files,也就是那些从来没有被 Git 记录过的文件(自添加以后,从未 add 及 commit 过的文件)。 如果文件曾经被 Git 记录过,那么.gitignore 就对它们完全无效。

1
2
3
环境:
服务器 CentOS 7.2 + git(version 1.8.3.1)
客户端 随意

① 安装 Git

Linux 做为服务器端系统,Windows 作为客户端系统,分别安装 Git

服务器端:

1
#yum install -y git

安装完后,查看 Git 版本

1
2
[root@localhost ~]# git --version
git version 1.8.3.1

客户端:

自行下载并安装,安装完之后,查看 Git 版本

1
2
$ git --version
git version 2.8.4.windows.1

② 服务器端创建 git 用户,用来管理 Git 服务,并为 git 用户设置密码

1
2
3
4
[root@localhost home]# id git
id: git:无此用户
[root@localhost home]# useradd git
[root@localhost home]# passwd git

③ 服务器端创建 Git 仓库

设置 /home/git/test.git 为 Git 仓库

然后把 Git 仓库的 owner 修改为 git

1
2
3
4
[root@localhost git]# mkdir -p test.git
[root@localhost git]# git init --bare test.git
Initialized empty Git repository in /home/git/test.git/
[root@localhost git]# chown -R git:git test.git/

④ 服务器端 Git 打开 RSA 认证

进入 /etc/ssh 目录,编辑 sshd_config,打开以下三个配置的注释:

1
2
3
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

保存并重启 sshd 服务:

1
[root@localhost ssh]# server sshd restart

由 AuthorizedKeysFile 得知公钥的存放路径是 .ssh/authorized_keys,实际上是 $Home/.ssh/authorized_keys,由于管理 Git 服务的用户是 git,所以实际存放公钥的路径是 /home/git/.ssh/authorized_keys

在 /home/git/ 下创建目录 .ssh

1
2
3
4
5
[root@localhost git]# pwd
/home/git
[root@localhost git]# mkdir .ssh
[root@localhost git]# ls -a
. .. .bash_logout .bash_profile .bashrc .gnome2 .mozilla .ssh

然后把 .ssh 文件夹的 owner 修改为 git

1
2
3
4
5
6
7
8
9
10
11
[root@localhost git]# chown -R git:git .ssh
[root@localhost git]# ll -a
总用量 32
drwx------. 5 git git 4096 8月 28 20:04 .
drwxr-xr-x. 8 root root 4096 8月 28 19:32 ..
-rw-r--r--. 1 git git 18 10月 16 2014 .bash_logout
-rw-r--r--. 1 git git 176 10月 16 2014 .bash_profile
-rw-r--r--. 1 git git 124 10月 16 2014 .bashrc
drwxr-xr-x. 2 git git 4096 11月 12 2010 .gnome2
drwxr-xr-x. 4 git git 4096 5月 8 12:22 .mozilla
drwxr-xr-x. 2 git git 4096 8月 28 20:08 .ssh

⑤ 将客户端公钥导入服务器端 /home/git/.ssh/authorized_keys 文件

1
[root@localhost git]# cat 公钥 >> .ssh/authorized_keys

也可以使用Vim编辑

⑥ 禁止 git 用户 ssh 登录服务器

之前在服务器端创建的 git 用户不允许 ssh 登录服务器

编辑 /etc/passwd

找到:

1
git:x:502:504::/home/git:/bin/bash

修改为

1
git:x:502:504::/home/git:/bin/git-shell

此时 git 用户可以正常通过 ssh 使用 git,但无法通过 ssh 登录系统。

完成

通过以上操作,就实现了使用git自建服务器存放单用户仓库的全部流程;其中,开启RSA不是必需的,使用秘钥一样可以的.

克隆示例

1
2
3
git clone git@{ip/域名:端口}:/home/git/test.git
或使用相对路径
git clone git@{ip/域名:端口}:test.git

网上流传的Mac改plist文件,Windows改ini文件,经过本人测试发现在Charles4.2上均无法解决问题;

最终使用该方法解决,大家可以参考下咯~~~:

进入 菜单栏 - Tools - Rewrite :

如图所示

1. 打开重写机制

2. 添加新的规则(名称随意)

3. 编辑新规则

4. 添加规则匹配目标

5. 添加插入/替换具体规则

添加规则匹配目标

如图所示

添加插入/替换具体规则

1
2
为匹配的响应添加Header:
Content-Type : application/json;charset=UTF-8

如图所示

以上.

一、概述

  在JAVA的util包中有两个所有集合的父接口Collection和Map,它们的父子关系:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
+Collection (接口 这个接口extends自Iterable接口)
├+List (接口 代表有序,可重复的集合。列表)
│├ ArreyList (Class 数组,随机访问,没有同步,线程不安全)
│├ Vector (Class 数组 同步 线程全)
│├ LinkedList (Class 链表 插入删除 没有同步 线程不安全)
│└ Stack (Class)
└+Set(接口 不能含重复的元素。仅接收一次并做内部排序,集)
├ HashSet (Class)
├ LinkedHashSet (Class)
└ TreeSet (Class)

+Map (接口)
└+Map(接口 映射集合)
├ HashMap (Class 不同步,线程不安全。除了不同和允许使用null 键值之外,与Hashtable大致相同)
├ Hashtable (Class 同步 ,线程安全 。不允许实施null 键值)
├ +SortedMap 接口
│ ├ TreeMap (Class)
└ WeakHashMap (Class)

  集合框架图: 集合框架图

  以下对众多接口和类的简单说明:首先不能不先说一下数组(Array)

1
2
3
4
5
6
7
8
1、效率高,但容量固定且无法动态改变。array还有一个缺点是,无法判断其中实际存有多少元素,length只是告诉我们array的容量。
2、Java中有一个Arrays类,专门用来操作array。
arrays中拥有一组static函数,
equals():比较两个array是否相等。array拥有相同元素个数,且所有对应元素两两相等。
fill():将值填入array中。
sort():用来对array进行排序。
binarySearch():在排好序的array中寻找元素。
System.arraycopy():array的复制。

二、数组和集合的区别:

  1. 数组是大小固定的,并且同一个数组只能存放类型一样的数据(基本类型/引用类型)
  2. JAVA集合可以存储和操作数目不固定的一组数据。
  3. 若程序时不知道究竟需要多少对象,需要在空间不足时自动扩增容量,则需要使用容器类库,array不适用。

三、Set/Map/List的区别

  首先,都是集合接口

1
2
3
Set     其中的值不允许重复,无序的数据结构 
List 其中的值允许重复,因为其为有序的数据结构
Map 成对的数据结构,健值必须具有唯一性(键不能同,否则值替换)

List

  按对象进入的顺序保存对象,不做排序或编辑操作。

Set

  对每个对象只接受一次,并使用自己内部的排序方法(通常,你只关心某个元素是否属于Set,而不关心它的顺序--否则应该使用List)。

Map

  同样对每个元素保存一份,但这是基于"键"的,Map也有内置的排序,因而不关心元素添加的顺序。如果添加元素的顺序对你很重要,应该使用 LinkedHashSet或者LinkedHashMap.

1
2
3
HashTable 和 HashMap 是 Map 的实现类 
HashTable 是线程安全的,不能存储 null 值
HashMap 不是线程安全的,可以存储 null 值

四、 List接口:有序可重复的集合

  实际上有两种List: 一种是基本的ArrayList,其优点在于随机访问元素,另一种是更强大的LinkedList,它并不是为快速随机访问设计的,而是具有一套更通用的方法。

  List : 次序是List最重要的特点:它保证维护元素特定的顺序。List为Collection添加了许多方法,使得能够向List中间插入与移除元素(这只推荐LinkedList使用。)一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。

1. ArrayList

  1. ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。
  2. size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
  3. 每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法 并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
  4. 和LinkedList一样,ArrayList也是非同步的(unsynchronized)。
  5. 由数组实现的List。允许对元素进行快速随机访问,但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList,而不是用来插入和移除元素。因为那比LinkedList开销要大很多。

2. Vector

  Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。

3. LinkedList

  LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在 LinkedList的首部或尾部。如下列方法:addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。

  注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:

1
List list = Collections.synchronizedList(new LinkedList(...));

4. Stack

  Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

用法:

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

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TestList {
public static void main(String dd[]) {
// new了一个存储list
List l = new ArrayList();
// 因为Collection framework只能存储对象所以new封装类
l.add(new Integer(1));
l.add(new Integer(2));
l.add(new Integer(3));
l.add(new Integer(4));

Iterator it = l.iterator();
//使用 迭代器(Iterator):
// hasNext是取值取的是当前值.他的运算过程是判断下个是否有值如果有继续.
while (it.hasNext()) {
System.out.println("iterator:Element in list is : " + it.next());
}
//用for循环和get()方法:
for (int i = 0; i < l.size(); i++) {
System.out.println("for:Element in list is : " + l.get(i));
}
}
}

LinkedList:

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

import java.util.Iterator;
import java.util.LinkedList;

public class TestLinkedList {
public static void main(String arg[]) {
LinkedList ll = new LinkedList();// 声明LinkedList并实例化
// 使用add()方法添加元素
ll.add("a");
ll.add("b");
ll.add("c");
// 使用Iterator迭代器遍历出集合的元素并打印
Iterator it = ll.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
System.out.println("------------------");
// 向链表头和尾分别添加x和z
ll.addFirst("z");
ll.addLast("x");
// 遍历查看添加后的结果
for (Iterator i = ll.iterator(); i.hasNext();) {
System.out.println(i.next());
}
}
}

ArrayList和LinkedList的区别。

  1. ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
  2. 对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
  3. 对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。

如果熟悉数据结构的同学,就会一下明白,ArrayList就是线性表的顺序表示,LinkedList就是线性表的链表表示。

五、 Set接口:代表无序,不可重复的集合

  Set具有与Collection完全一样的接口,因此没有任何额外的功能,不像前面有两个不同的List。实际上Set就是Collection,只是行为不同。(这是继承与多态思想的典型应用:表现不同的行为。)Set不保存重复的元素(至于如何判断元素相同则较为负责)

  Set : 存入Set的每个元素都必须是唯一的,因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。

1. HashSet

  为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。

2. TreeSet

  保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。

3. LinkedHashSet

  具有HashSet的查询速度,且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时,结果会按元素插入的次序显示。

用法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Set set=new HashSet();  
String s1=new String("hello");
String s2=s1;
String s3=new String("world");
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size());//打印集合中对象的数目 为 2。
Set 的 add()方法是如何判断对象是否已经存放在集合中?
boolean isExists=false;
Iterator iterator=set.iterator();
while(it.hasNext()) {
String oldStr=it.next();
if(newStr.equals(oldStr)){
isExists=true;
}
}

六、 Map接口:映射

  Map没有继承Collection接口, Map 提供 key 到 value 的映射,你可以通过“键”查找“值”。一个 Map 中不能包含相同的 key ,每个 key 只能映射一个 value 。 Map 接口提供3种集合的视图, Map 的内容可以被当作一组 key 集合,一组 value 集合,或者一组 key-value 映射。

  方法 put(Object key, Object value) 添加一个“值” ( 想要得东西 ) 和与“值”相关联的“键” (key) ( 使用它来查找 ) 。方法get(Object key) 返回与给定“键”相关联的“值”。可以用 containsKey() 和 containsValue() 测试 Map 中是否包含某个“键”或“值”。 标准的 Java 类库中包含了几种不同的 Map : HashMap, TreeMap, LinkedHashMap, WeakHashMap, IdentityHashMap 。它们都有同样的基本接口 Map ,但是行为、效率、排序策略、保存对象的生命周期和判定“键”等价的策略等各不相同。

  Map 同样对每个元素保存一份,但这是基于"键"的, Map 也有内置的排序,因而不关心元素添加的顺序。如果添加元素的顺序对你很重要,应该使用 LinkedHashSet 或者 LinkedHashMap.

  执行效率是 Map 的一个大问题。看看 get() 要做哪些事,就会明白为什么在 ArrayList 中搜索“键”是相当慢的。而这正是 HashMap 提高速度的地方。 HashMap 使用了特殊的值,称为“散列码” (hash code) ,来取代对键的缓慢搜索。“散列码”是“相对唯一”用以代表对象的int值,它是通过将该对象的某些信息进行转换而生成的(在下面总结二:需要的注意的地方有更进一步探讨)。所有 Java 对象都能产生散列码,因为 hashCode() 是定义在基类 Object 中的方法 。 HashMap 就是使用对象的 hashCode() 进行快速查询的。此方法能够显著提高性能。

1.Hashtable

  Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。Hashtable是同步的。添加数据使用 put(key, value) ,取出数据使用get(key),这两个基本操作的时间开销为常数。

  Hashtable 通过初始化容量 (initial capacity) 和负载因子 (load factor) 两个参数调整性能。通常缺省的 load factor0.75 较好地实现了时间和空间的均衡。增大 load factor 可以节省空间但相应的查找时间将增大,这会影响像 get 和 put 这样的操作。

使用 Hashtable 的简单示例如下,将 1,2,3 放到 Hashtable 中,他们的 key 分别是 ”one” , ”two” , ”three” :

1
2
3
4
Hashtable numbers =new Hashtable();
numbers.put("one", new Integer(1));
numbers.put("two", new Integer(2));
numbers.put("three", new Integer(3));

要取出一个数,比如 2 ,用相应的 key :

1
2
Integer n = (Integer)numbers.get("two");
System.out.println("two=" + n);

   由于作为 key 的对象将通过计算其散列函数来确定与之对应的 value 的位置,因此任何作为 key 的对象都必须实现 hashCode 方法和 equals 方法。 hashCode 方法和 equals 方法继承自根类 Object ,如果你用自定义的类当作 key 的话,要相当小心,按照散列函数的定义,如果两个对象相同,即 obj1.equals(obj2)=true,则它们的 hashCode 必须相同,但如果两个对象不同,则它们的 hashCode 不一定不同,如果两个不同对象的 hashCode 相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的 hashCode() 方法,能加快哈希表的操作。

  如果相同的对象有不同的 hashCode ,对哈希表的操作会出现意想不到的结果(期待的 get 方法返回null),要避免这种问题,只需要牢记一条:要同时复写 equals 方法和 hashCode 方法,而不要只写其中一个。

  Hashtable 是同步的。

2.HashMap

  HashMap和Hashtable类似,也是基于hash散列表的实现。不同之处在于 HashMap是非同步的,并且允许null,即null value和null key。,但是将HashMap视为Collection时 (values()方法可返回Collection),其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能相当重要的话,不要 将HashMap的初始化容量设得过高,或者load factor过低。

   LinkedHashMap 类:类似于 HashMap ,但是迭代遍历它时,取得“键值对”的顺序是其插入次序,或者是最近最少使用 (LRU) 的次序。只比 HashMap 慢一点。而在迭代访问时发而更快,因为它使用链表维护内部次序。

3.WeakHashMap

  WeakHashMap是一种改进的HashMap,它是为解决特殊问题设计的,它对key实行“弱引用”,如果一个key不再被外部所引用,那么该key可以被GC回收。

4.TreeMap

  基于红黑树数据结构的实现。查看“键”或“键值对”时,它们会被排序 ( 次序由 Comparabel 或 Comparator 决定 ) 。 TreeMap 的特点在于,你得到的结果是经过排序的。 TreeMap 是唯一的带有 subMap() 方法的 Map ,它可以返回一个子树。

5.IdentifyHashMap

  使用 == 代替 equals() 对“键”作比较的 hash map 。专为解决特殊问题而设计。

用法:

1
2
3
4
5
6
7
8
1 添加,删除操作:
Object put(Object key, Object value): 向集合中加入元素
Object remove(Object key): 删除与KEY相关的元素
void putAll(Map t): 将来自特定映像的所有元素添加给该映像
void clear(): 从映像中删除所有映射

2 查询操作:
Object get(Object key): 获得与关键字key相关的值

  Map集合中的键对象不允许重复,也就说,任意两个键对象通过equals()方法比较的结果都是false.但是可以将任意多个键独享映射到同一个值对象上。

七、 如何选择

1、容器类和Array的区别、择取

  1. 容器类仅能持有对象引用(指向对象的指针),而不是将对象信息copy一份至数列某位置。
  2. 一旦将对象置入容器内,便损失了该对象的型别信息。

2、综合区别与选取

  1. 在各种Lists中,最好的做法是以ArrayList作为缺省选择。当插入、删除频繁时,使用LinkedList();Vector总是比ArrayList慢,所以要尽量避免使用。
  2. 在各种Sets中,HashSet通常优于HashTree(插入、查找)。只有当需要产生一个经过排序的序列,才用TreeSet。HashTree存在的唯一理由:能够维护其内元素的排序状态。
  3. 在各种Maps中,HashMap用于快速查找。
  4. 当元素个数固定,用Array,因为Array效率是最高的。

结论:最常用的是ArrayList,HashSet,HashMap,Array。而且,我们也会发现一个规律,用TreeXXX都是排序的。

八、注意

1、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。 2、Set和Collection拥有一模一样的接口。 3、List,可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个,get(0)...。(add/get) 4、一般使用ArrayList。用LinkedList构造堆栈stack、队列queue。 5、Map用 put(k,v) / get(k),还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。HashMap会利用对象的hashCode来快速找到key。

  • hashing 哈希码就是将对象的信息经过一些转变形成一个独一无二的int值,这个值存储在一个array中。我们都知道所有存储结构中,array查找速度是最快的。所以,可以加速查找。发生碰撞时,让array指向多个values。即,数组每个位置上又生成一个梿表。

6、Map中元素,可以将key序列、value序列单独抽取出来。 使用keySet()抽取key序列,将map中的所有keys生成一个Set。 使用values()抽取value序列,将map中的所有values生成一个Collection。 为什么一个生成Set,一个生成Collection?那是因为,key总是独一无二的,value允许重复。

概要:UTF-8的一个特别的好处是它与ISO- 8859-1完全兼容,可以表示世界上所有的字符,汉字通常用3个字节来表示。GB2312的code page是CP20936。GBK的code page是CP936 。GB18030支持的字符数更多。GB2312、GBK、GB18030均为双字节。
这是一篇程序员写给程序员的趣味读物。所谓趣味是指可以比较轻松地了解一些原来不清

楚的概念,增进知识,类似于打RPG游戏的升级。整理这篇文章的动机是两个问题:

  • 问题一: 使用Windows记事本的“另存为”,可以在GBK、Unicode、Unicode big endian和UTF-8这 几种编码方式间相互转换。同样是txt文件,Windows是怎样识别编码方式的呢?
    我很早前就发现Unicode、Unicode big endian和UTF-8编码的txt文件的开头会多出几个字 节,分别是FF、FE(Unicode),FE、FF(Unicode big endian),EF、BB、BF(UTF-8)。 但这些标记是基于什么标准呢?

  • 问题二: 最近在网上看到一个ConvertUTF.c,实现了UTF-32、UTF-16和UTF-8这三种编码方式的相互 转换。对于Unicode(UCS2)、GBK、UTF-8这些编码方式,我原来就了解。但这个程序让我有 些糊涂,想不起来UTF-16和UCS2有什么关系。
    查了查相关资料,总算将这些问题弄清楚了,顺带也了解了一些Unicode的细节。作者写成一篇文章,送给有过类似疑问的朋友。本文在写作时尽量做到通俗易懂,但要求读者知道 什么是字节,什么是十六进制。

0、big endian和little endian

big endian和little endian是CPU处理多字节数的不同方式。例如“汉”字的Unicode编码 是6C49。那么写到文件里时,究竟是将6C写在前面,还是将49写在前面?如果将6C写在前 面,就是big endian。如果将49写在前面,就是little endian。
“endian”这个词出自《格列佛游记》。小人国的内战就源于吃鸡蛋时是究竟从大头(Big -Endian)敲开还是从小头(Little-Endian)敲开,由此曾发生过六次叛乱,一个皇帝送了命 ,另一个丢了王位。
我们一般将endian翻译成“字节序”,将big endian和little endian称作“大尾”和“小 尾”。

1、字符编码、内码,顺带介绍汉字编码

字符必须编码后才能被计算机处理。计算机使用的缺省编码方式就是计算机的内码。早期 的计算机使用7位的ASCII编码,为了处理汉字,程序员设计了用于简体中文的GB2312和用 于繁体中文的big5。
GB2312(1980年)一共收录了7445个字符,包括6763个汉字和682个其它符号。汉字区的内码 范围高字节从B0-F7,低字节从A1-FE,占用的码位是7294=6768。其中有5个空位是D7FA- D7FE。
GB2312支持的汉字太少。1995年的汉字扩展规范GBK1.0收录了21886个符号,它分为汉字区 和图形符号区。汉字区包括 21003个字符。2000年的GB18030是取代GBK1.0的正式国家标准 。该标准收录了27484个汉字,同时还收录了藏文、蒙文、维吾尔文等主要的少数民族文字 。现在的PC平台必须支持GB18030,对嵌入式产品暂不作要求。所以手机、MP3一般只支持 GB2312。
从ASCII、GB2312、GBK到GB18030,这些编码方法是向下兼容的,即同一个字符在这些方案 中总是有相同的编码,后面的标准支持更多的字符。在这些编码中,英文和中文可以统一 地处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼,GB2312、GBK 到 GB18030都属于双字节字符集 (DBCS)。
有的中文Windows的缺省内码还是GBK,可以通过GB18030升级包升级到GB18030。不过GB18 030相对GBK增加的字符,普通人是很难用到的,通常我们还是用GBK指代中文Windows内码 。
这里还有一些细节:
GB2312的原文还是区位码,从区位码到内码,需要在高字节和低字节上分别加上A0。
在DBCS中,GB内码的存储格式始终是big endian,即高位在前。
GB2312的两个字节的最高位都是1。但符合这个条件的码位只有128
128=16384个。所以GB K和GB18030的低字节最高位都可能不是1。不过这不影响DBCS字符流的解析:在读取DBCS字 符流时,只要遇到高位为1的字节,就可以将下两个字节作为一个双字节编码,而不用管低 字节的高位是什么。

2、Unicode、UCS和UTF

前面提到从ASCII、GB2312、GBK到GB18030的编码方法是向下兼容的。而Unicode只与ASCI I兼容(更准确地说,是与ISO-8859-1兼容),与GB码不兼容。例如“汉”字的Unicode编 码是6C49,而GB码是BABA。
Unicode也是一种字符编码方法,不过它是由国际组织设计,可以容纳全世界所有语言文字 的编码方案。Unicode的学名是 "Universal Multiple-Octet Coded Character Set",简 称为UCS。UCS可以看作是"Unicode Character Set"的缩写。
根据维基百科全书( http://zh.wikipedia.org/wiki/ )的记载:历史上存在两个试图独立 设计Unicode的组织,即国际标准化组织(ISO)和一个软件制造商的协会(unicode.org) 。ISO开发了ISO 10646项目,Unicode协会开发了Unicode项目。
在1991年前后,双方都认识到世界不需要两个不兼容的字符集。于是它们开始合并双方的 工作成果,并为创立一个单一编码表而协同工作。从Unicode2.0开始,Unicode项目采用了 与ISO 10646-1相同的字库和字码。
目前两个项目仍都存在,并独立地公布各自的标准。Unicode协会现在的最新版本是2005年 的Unicode 4.1.0。ISO的最新标准是ISO 10646-3:2003。
UCS只是规定如何编码,并没有规定如何传输、保存这个编码。例如“汉”字的UCS编码是 6C49,我可以用4个ascii数字来传输、保存这个编码;也可以用utf-8编码:3个连续的字节 E6 B1 89来表示它。关键在于通信双方都要认可。UTF-8、UTF-7、UTF-16都是被广泛接受 的方案。UTF-8的一个特别的好处是它与ISO- 8859-1完全兼容。UTF是“UCS Transformat ion Format”的缩写。
IETF的RFC2781和RFC3629以RFC的一贯风格,清晰、明快又不失严谨地描述了UTF-16和UTF -8的编码方法。我总是记不得IETF是Internet Engineering Task Force的缩写。但IETF负 责维护的RFC是Internet上一切规范的基础。

2.1、内码和code page

目前Windows的内核已经采用Unicode编码,这样在内核上可以支持全世界所有的语言文字 。但是由于现有的大量程序和文档都采用了某种特定语言的编码,例如GBK,Windows不可 能不支持现有的编码,而全部改用Unicode。
Windows使用代码页(code page)来适应各个国家和地区。code page可以被理解为前面提到 的内码。GBK对应的code page是CP936。
微软也为GB18030定义了code page:CP54936。但是由于GB18030有一部分4字节编码,而W indows的代码页只支持单字节和双字节编码,所以这个code page是无法真正使用的。

3、UCS-2、UCS-4、BMP

UCS有两种格式:UCS-2和UCS-4。顾名思义,UCS-2就是用两个字节编码,UCS-4就是用4个 字节(实际上只用了31位,最高位必须为0)编码。下面让我们做一些简单的数学游戏:
UCS-2有2^16=65536个码位,UCS-4有2^31=2147483648个码位。
UCS-4根据最高位为0的最高字节分成2^7=128个group。每个group再根据次高字节分为256 个plane。每个 plane根据第3个字节分为256行(rows),每行包含256个cells。当然同一行 的cells只是最后一个字节不同,其余都相同。
group 0的plane 0被称作Basic Multilingual Plane, 即BMP。或者说UCS-4中,高两个字 节为0的码位被称作BMP。
将UCS-4的BMP去掉前面的两个零字节就得到了UCS-2。在UCS-2的两个字节前加上两个零字 节,就得到了UCS-4的BMP。而目前的UCS-4规范中还没有任何字符被分配在BMP之外。

4、UTF编码

UTF-8就是以8位为单元对UCS进行编码。从UCS-2到UTF-8的编码方式如下:
UCS-2编码(16进制) UTF-8 字节流(二进制) 0000 - 007F 0xxxxxxx 0080 - 07FF 110xxx xx 10xxxxxx 0800 - FFFF 1110xxxx 10xxxxxx 10xxxxxx

例如“汉”字的Unicode编码是6C49。6C49在0800-FFFF之间,所以肯定要用3字节模板了: 1110xxxx 10xxxxxx 10xxxxxx。将6C49写成二进制是:0110 110001 001001,用这个比特 流依次代替模板中的x,得到:11100110 10110001 10001001,即E6 B1 89。
读者可以用记事本测试一下我们的编码是否正确。需要注意,UltraEdit在打开utf-8编码 的文本文件时会自动转换为UTF-16,可能产生混淆。你可以在设置中关掉这个选项。更好 的工具是Hex Workshop。
UTF-16以16位为单元对UCS进行编码。对于小于0x10000的UCS码,UTF-16编码就等于UCS码 对应的16位无符号整数。对于不小于0x10000的UCS码,定义了一个算法。不过由于实际使 用的UCS2,或者UCS4的BMP必然小于0x10000,所以就目前而言,可以认为UTF-16和UCS-2基 本相同。但UCS-2只是一个编码方案,UTF-16却要用于实际的传输,所以就不得不考虑字节 序的问题。

5、UTF的字节序和BOM

UTF-8以字节为编码单元,没有字节序的问题。UTF-16以两个字节为编码单元,在解释一个 UTF-16文本前,首先要弄清楚每个编码单元的字节序。例如“奎”的Unicode编码是594E, “乙”的Unicode编码是4E59。如果我们收到UTF-16字节流“594E”,那么这是“奎” 还 是“乙”?
Unicode规范中推荐的标记字节顺序的方法是BOM。BOM不是“Bill Of Material”的BOM表 ,而是Byte Order Mark。BOM是一个有点小聪明的想法:
在UCS编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符,它的编码是FEFF。而FFFE 在UCS中是不存在的字符,所以不应该出现在实际传输中。UCS规范建议我们在传输字节流 前,先传输字符"ZERO WIDTH NO-BREAK SPACE"。
这样如果接收者收到FEFF,就表明这个字节流是Big-Endian的;如果收到FFFE,就表明这 个字节流是Little-Endian的。因此字符"ZERO WIDTH NO-BREAK SPACE"又被称作BOM。
UTF-8不需要BOM来表明字节顺序,但可以用BOM来表明编码方式。字符"ZERO WIDTH NO-BR EAK SPACE"的UTF-8编码是EF BB BF(读者可以用我们前面介绍的编码方法验证一下)。所 以如果接收者收到以EF BB BF开头的字节流,就知道这是UTF-8编码了。
Windows就是使用BOM来标记文本文件的编码方式的。

6、进一步的参考资料

本文主要参考的资料是 "Short overview of ISO-IEC 10646 and Unicode" ( http://ww w.nada.kth.se/i18n/ucs/unicode-iso10646-oview.html )。
我还找了两篇看上去不错的资料,不过因为我开始的疑问都找到了答案,所以就没有看:
"Understanding Unicode A general introduction to the Unicode Standard" ( http: //scripts.sil.org/cms/scripts/page.php?site_id=nrsi&item_id=IWS-Chapter04a ) " Character set encoding basics Understanding character set encodings and legacy encodings" ( http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&item_id =IWS-Chapter03 ) 我写过UTF-8、UCS-2、GBK相互转换的软件包,包括使用Windows API和 不使用Windows API的版本。以后有时间的话,我会整理一下放到我的个人主页上( http: //fmddlmyy.home4u.china.com )。
附录1 再说说区位码、GB2312、内码和代码页
有的朋友对文章中这句话还有疑问: “GB2312的原文还是区位码,从区位码到内码,需要 在高字节和低字节上分别加上A0。”
我再详细解释一下:
“GB2312的原文”是指国家1980年的一个标准《中华人民共和国国家标准 信息交换用汉字 编码字符集 基本集 GB 2312-80》。这个标准用两个数来编码汉字和中文符号。第一个数 称为“区”,第二个数称为“位”。所以也称为区位码。1-9区是中文符号,16-55 区是一 级汉字,56-87区是二级汉字。现在Windows也还有区位输入法,例如输入1601得到“啊” 。
内码是指操作系统内部的字符编码。早期操作系统的内码是与语言相关的.现在的Windows 在内部统一使用Unicode,然后用代码页适应各种语言,“内码”的概念就比较模糊了。微 软一般将缺省代码页指定的编码说成是内码,在特殊的场合也会说自己的内码是Unicode, 例如在 GB18030问题的处理上。
所谓代码页(code page)就是针对一种语言文字的字符编码。例如GBK的code page是CP936 ,BIG5的code page是CP950,GB2312的code page是CP20936。
Windows中有缺省代码页的概念,即缺省用什么编码来解释字符。例如Windows的记事本打 开了一个文本文件,里面的内容是字节流:BA、BA、D7、D6。Windows应该去怎么解释它呢 ?
是按照Unicode编码解释、还是按照GBK解释、还是按照BIG5解释,还是按照ISO8859-1去解 释?如果按GBK去解释,就会得到“汉字”两个字。按照其它编码解释,可能找不到对应的 字符,也可能找到错误的字符。所谓“错误”是指与文本作者的本意不符,这时就产生了 乱码。
答案是Windows按照当前的缺省代码页去解释文本文件里的字节流。缺省代码页可以通过控 制面板的区域选项设置。记事本的另存为中有一项ANSI,其实就是按照缺省代码页的编码 方法保存。
Windows的内码是Unicode,它在技术上可以同时支持多个代码页。只要文件能说明自己使 用什么编码,用户又安装了对应的代码页,Windows就能正确显示,例如在HTML文件中就可 以指定charset。
有的HTML文件作者,特别是英文作者,认为世界上所有人都使用英文,在文件中不指定ch arset。如果他使用了0x80-0xff之间的字符,中文Windows又按照缺省的GBK去解释,就会 出现乱码。这时只要在这个html文件中加上指定charset的语句,例如:如果原作者使用的 代码页和ISO8859-1兼容,就不会出现乱码了。
再说区位码,啊的区位码是1601,写成16进制是0x10,0x01。这和计算机广泛使用的ASCII 编码冲突。为了兼容00-7f的 ASCII编码,我们在区位码的高、低字节上分别加上A0。这样 “啊”的编码就成为B0A1。我们将加过两个A0的编码也称为GB2312编码,虽然 GB2312的原 文根本没提到这一点。

http://blog.csdn.net/yuzhiqiang_1993/article/details/78366985

AndroidStudio3.0 正式版已经出来了,相比2.x的版本,编译速度提高了不少。
当我们使用AS3.0新建项目时会发现,默认的依赖由之前的compile更改为implementation了。

下面我们来看看他们之前的差异:

首先是2.x版本的依赖方式:

alt

再来看看3.0的:

alt

可以看到在Android studio3.0中,compile依赖关系已被弃用,被implementation和api替代,provided被compile only替代,apk被runtime only替代,剩下的看名字就知道了。

我们先来看看implementation和api的区别:

api

跟2.x版本的 compile完全相同

implementation

只能在内部使用此模块,比如我在一个libiary中使用implementation依赖了gson库,然后我的主项目依赖了libiary,那么,我的主项目就无法访问gson库中的方法。这样的好处是编译速度会加快,推荐使用implementation的方式去依赖,如果你需要提供给外部访问,那么就使用api依赖即可

还不熟悉2.x版本依赖的可以看看下面的说明,括号里对应的是3.0版本的依赖方式。

compile(api)

这种是我们最常用的方式,使用该方式依赖的库将会**参与编译和打包**。
当我们依赖一些第三方的库时,可能会遇到com.android.support冲突的问题,就是因为开发者使用的compile依赖的com.android.support包,而他所依赖的包与我们本地所依赖的com.android.support包版本不一样,所以就会报All com.android.support libraries must use the exact same version specification (mixing versions can lead to runtime crashes这个错误。

解决办法可以看这篇博客:com.android.support冲突的解决办法

provided(compileOnly)

只在编译时有效,不会参与打包。 可以在自己的moudle中使用该方式依赖一些比如com.android.support,gson这些使用者常用的库,避免冲突。

apk(runtimeOnly)

只在生成apk的时候参与打包,编译时不会参与,很少用。

testCompile(testImplementation)

testCompile 只在单元测试代码的编译以及最终打包测试apk时有效。

debugCompile(debugImplementation)

debugCompile 只在debug模式的编译和最终的debug apk打包时有效

releaseCompile(releaseImplementation)

releaseCompile 仅仅针对Release 模式的编译和最终的Release apk打包。

简介

top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器。top是一个动态显示过程,即可以通过用户按键来不断刷新当前状态.如果在前台执行该命令,它将独占前台,直到用户终止该程序为止.比较准确的说,top命令提供了实时的对系统处理器的状态监视.它将显示系统中CPU最“敏感”的任务列表.该命令可以按CPU使用.内存使用和执行时间对任务进行排序;而且该命令的很多特性都可以通过交互式命令或者在个人定制文件中进行设定。

常在linux系统下玩,这是必须掌握的命令之一;
下面详细说说这个命令:

敲入top进入:

top - 09:14:56 up 264 days, 20:56,  1 user,  load average: 0.02, 0.04, 0.00
Tasks:  87 total,   1 running,  86 sleeping,   0 stopped,   0 zombie
Cpu(s):  0.0%us,  0.2%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.2%st
Mem:    377672k total,   322332k used,    55340k free,    32592k buffers
Swap:   397308k total,    67192k used,   330116k free,    71900k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                        
    1 root      20   0  2856  656  388 S  0.0  0.2   0:49.40 init                                            
    2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd                                        
    3 root      20   0     0    0    0 S  0.0  0.0   7:15.20 ksoftirqd/0                                     
    4 root      RT   0     0    0    0 S  0.0  0.0   0:00.00 migration/0

第一行

09:14:56 : 系统当前时间
264 days, 20:56 : 系统开机到现在经过了多少时间
1 users : 当前2用户在线
load average: 0.02, 0.04, 0.00: 系统1分钟、5分钟、15分钟的CPU负载信息

第二行

Tasks:任务;
87 total:很好理解,就是当前有87个任务,也就是87个进程。
1 running:1个进程正在运行
86 sleeping:86个进程睡眠
0 stopped:停止的进程数
0 zombie:僵死的进程数

第三行

Cpu(s):表示这一行显示CPU总体信息
0.0%us:用户态进程占用CPU时间百分比,不包含renice值为负的任务占用的CPU的时间。
0.7%sy:内核占用CPU时间百分比
0.0%ni:改变过优先级的进程占用CPU的百分比
99.3%id:空闲CPU时间百分比
0.0%wa:等待I/O的CPU时间百分比
0.0%hi:CPU硬中断时间百分比
0.0%si:CPU软中断时间百分比
注:这里显示数据是所有cpu的平均值,如果想看每一个cpu的处理情况,按1即可;折叠,再次按1;

第四行

Men:内存的意思
8175320kk total:物理内存总量
8058868k used:使用的物理内存量
116452k free:空闲的物理内存量
283084k buffers:用作内核缓存的物理内存量

第五行

Swap:交换空间
6881272k total:交换区总量
4010444k used:使用的交换区量
2870828k free:空闲的交换区量
4336992k cached:缓冲交换区总量

进程信息

再下面就是进程信息:

PID:进程的ID
USER:进程所有者
PR:进程的优先级别,越小越优先被执行
NInice:值
VIRT:进程占用的虚拟内存
RES:进程占用的物理内存
SHR:进程使用的共享内存
S:进程的状态。S表示休眠,R表示正在运行,Z表示僵死状态,N表示该进程优先值为负数
%CPU:进程占用CPU的使用率
%MEM:进程使用的物理内存和总内存的百分比
TIME+:该进程启动后占用的总的CPU时间,即占用CPU使用时间的累加值。
COMMAND:进程启动命令名称

top命令交互操作指令

下面列出一些常用的 top命令操作指令

q:退出top命令
<Space>:立即刷新
s:设置刷新时间间隔
c:显示命令完全模式
t::显示或隐藏进程和CPU状态信息
m:显示或隐藏内存状态信息
l:显示或隐藏uptime信息
f:增加或减少进程显示标志
S:累计模式,会把已完成或退出的子进程占用的CPU时间累计到父进程的MITE+
P:按%CPU使用率排行
T:按MITE+排行
M:按%MEM排行
u:指定显示用户进程
r:修改进程renice值
kkill:进程
i:只显示正在运行的进程
W:保存对top的设置到文件~/.toprc,下次启动将自动调用toprc文件的设置。
h:帮助命令。
q:退出

注:强调一下,使用频率最高的是P、T、M,因为通常使用top,我们就想看看是哪些进程最耗cpu资源、占用的内存最多;
注:通过”shift + >”或”shift + <”可以向右或左改变排序列
如果只需要查看内存:可用free命令。只查看uptime信息(第一行),可用uptime命令;

nginx默认是不允许列出整个目录的。如何开启Nginx的目录文件列表功能?

打开nginx.conf文件,在location server 或 http段中加入 autoindex on; 另外两个参数最好也加上去: autoindex_exact_size on; 显示出文件的确切大小,单位是bytes。 改为off后,显示出文件的大概大小,单位是kB或者MB或者GB autoindex_localtime on; 默认为off,显示的文件时间为GMT时间。 改为on后,显示的文件时间为文件的服务器时间

配置Nginx目录列表的方法详细参照: http://wiki.nginx.org/NginxChsHttpAutoindexModule

配置示例:

1
2
3
4
5
6
location /upload {
autoindex on;
autoindex_exact_size on;
autoindex_localtime on;
alias /usr/local/upload;
}