Jimmysc.github.io

Window

2017-02-02T00:00:00+00:00

</script>

Baby

2015-07-15T00:00:00+00:00

绘本

小熊宝宝绘本

作者：佐佐木洋子年龄：1-3岁星级：摘要：和小熊一起学生活必备知识，比如上厕所、刷牙、打招呼

我要大蜥蜴

作者：凯伦·考芙曼·欧洛夫年龄：3-6 星级：摘要：描写的是一个想养大蜥蜴的聪明男孩如何通过书信说服妈妈的故事，无独有偶，她智慧的妈妈同样精通沟通艺术，在一来二往的简短信件交流中，两个人都达到了目的，男孩子如愿得到了宠物蜥蜴，妈妈则借以让孩子的行为习惯做出了改进

大嘴狗

作者：安娜·玛尔年龄：3-6 星级：摘要：1个嘴巴很大而极为善良、内秀的狗，因为长相奇特而不受欢迎，直到他遇到一个热爱动物的小男孩，才有个一个家，只是小男孩的妈妈不肯接受，直到他用自己的才华打动了她……真是像极了世间的人际交往，当我们不可免俗地以貌取人时，也许就失去了像大嘴狗这样的朋友吧，所幸的是，还有一个群体，比我们更善于发现世间的美丽—–那就是孩子

学会爱自己

作者：珊蒂•克雷文年龄：7-10 星级：摘要：《学会爱自己:不要随便摸我+不要随便亲我+不要随便跟陌生人走(套装共3册)》是一套主题特别的图画书，对那些即将离开父母的视线、进入校园学习的孩子们来说，这是一套非常有帮助的教科书

全景式图画书-开车触发系列

作者：间濑直方(日) 年龄：3-6 星级：摘要：有趣的交通工具绘本，日本总销售量达105万册。其中多册入选日本图书馆协会选定图书、日本全国学校图书馆协议会选定图书、日本儿童书研究会选定图书）图书风景非常优美，每一页都有饱满的场景，各式的车和人物。同样也设计了阅读的各式小机关，大大激发了阅读兴趣。

大象小不点

作者：莫泽尔对象：3-6岁星级：摘要：小不点是一只“迷你”大象，出生没多久就和象群走散了。他从来没见过自己的爸爸妈妈，也不知道自己是谁。为了寻找家人，小不点不畏艰难，开始了一场充满挑战的冒险之旅…… 　　奥地利儿童文学奖荣誉奖得主莫泽尔创作的这一系列“大象小不点”的故事，涵盖了孩子心灵成长的各个阶段，小不点每邂逅一位朋友，就向着独立和更明确的自我认知迈出重要的一步。它教给孩子：孤单的时候不要慌张，失望的时候不要沮丧，困难的时候不要放弃。　　读“大象小不点”的故事，不仅能让孩子和小不点一同上路去冒险，感受这特别的心灵成长之旅，同时也是提醒家长们，孩子的身上蕴藏着无限力量，要相信他们，放手让他们自己去做决定，为以后的人生打下基础。

小兔汤姆

作者：玛丽•阿利娜•巴文对象：3-6岁星级：摘要：今天晚上睡觉前，汤姆有很多东西要准备。因为，明天全班要去游泳池游泳啦……去游泳前应该准备的东西、游泳的时候要做的各种各样的事情，那些要记住的、要小心的、滑稽好笑的，哪怕游泳池的更衣室会有一股特有的味道这样的事情，大大小小有用没用的，都罗罗唆唆地在《小兔汤姆系列礼品装(套装21册)》里记下来了。

儿童情绪管理

作者：特蕾西•莫洛尼对象：3-6岁星级：摘要：一套3-6岁幼儿情绪的生动写照，通过小兔子的形像表达了这个年龄段幼儿所面临的各种各样的情绪情境。画面精致美观，色彩非常具有感染性。生动的烘托了主题。也告诉家长不要忽略及小视幼儿成长期中各种情绪的表现。要重视他们的情感要求并做出正确的辅导，与孩子共同成长。《儿童情绪管理图画书1》丛书归纳了幼儿成长比较有代表性的六种情绪状态。非常适合亲子共读。图书内芯画面采用击凸工艺，可以让孩子触摸感知。封面采用新颖的植表工艺，手感与众不同，是一套感观及内容俱佳的低幼读物。

斯凯瑞金色童书-第1辑

作者：理查德•斯凯瑞对象：3-6岁星级：摘要：《忙忙碌碌镇》中，温和的动物居民们过着快乐而忙碌的生活。作者通过一个充满童话色彩的小镇，介绍了日常生活的方方面面，比如农场的工作、消防员救火，坐火车旅行、修建一条新路、树木的利用等。书中涉及到了各种各样的职业，涵盖的信息非常丰富，对孩子了解社会生活有着良好的引导作用。同时，妙趣横生的故事情节，大量隐藏着的图画信息，可以让孩子长时间地投入阅读和观察，从新的发现中获得快乐的体验。作为一本启蒙读物，《斯凯瑞金色童书(第1辑)(套装全4册)》并非孤立地介绍各项工作的内容，而是将密切相关的工作联缀成为一个整体，比如，从收割小麦到加工面粉，再到面包的制作，整个过程是怎样有序进行的。幽默的故事倡导着一种协同合作的工作精神

斯凯瑞金色童书-第1辑我的第一本书

作者：理查德•斯凯瑞对象：3-6岁星级：摘要：以小屁孩儿一家人的日常生活为线索，串联起做家务、在学校、做游戏、买东西、看医生等生活主题。孩子可以从书中学到字母、形状、颜色、数字、行为习惯、身体部位等相关知识

不一样的卡梅拉

作者：克利斯提昂•约里波瓦对象：3-6岁星级：5 摘要：“生活中肯定还有比睡觉更好玩的事情！”大小卡梅拉们一直都抱有这样的信念。他们执著地追求那些种群中认为不可想象的事情。去看大海、去摘星星、去追回逃逸的太阳……一路上处处坎坷、历经艰难，但总是逢凶化吉、化险为夷。最后还能收获超乎想象的回报和异乎寻常的果实。我们可以把卡梅拉当作一种象征，一种成长路上必不可少的“伴侣”。读不一样的卡梅拉，成就与众不同的你！

小幸运儿和大艺术家系列

作者：英-安荷特年龄：3-6 星级：5 摘要：六个孩子，非常幸运地分别与世界上最伟大的六位艺术家结识。他们有些是大艺术家的学徒，有些是大艺术家好友的孩子，有些与大艺术家只是偶然邂逅。大艺术家高涨的创作激情、天赋的灵感、勇往直前的生活态度以及充满哲理的话语，让孩子们感受到空前的激励和指引，一些孩子的命运甚至彻底改变，长大后成为了卓有成就的伟大人物。而孩子们天真、稚朴、充满灵性的一举一动，也成为大艺术家们的灵感之源。

金色童年

作者：安徒生年龄：3-6岁星级：5 摘要：囊括了安徒生童话中最为著名的篇章：描绘社会底层劳动人民的《实火柴的小女孩》；讽刺皇帝昏庸无能和朝臣们阿谀奉承的《皇帝的新装》；表达真挚情感、宣扬牺牲精神的《海的女儿》……这些经典的童话故事,带给大、小朋友们最愉悦的阅读享受，引领大、小朋友们走进真、善、美的童话世界，给大、小朋友们的记忆深处增添绚丽多姿且浓墨重彩的一笔！

和爸爸一起去探索

作者：威廉·霍顿(英) 年龄：3-6 星级：摘要：一对父子驱车来到远处的森林里，在河边空旷的露营地上搭建好帐篷。搬运食物的黄腰蜾蠃、正在羽化的蜻蜓、“用餐”中的飞蛾、獾和松鼠的脚印……图鉴水准的动静态动植物手绘，融入真实自然的场景，还有野外生活所需的物品、真实的野炊过程等，都让读者仿佛置身其中

做最好的自己

作者：陈梦敏年龄：3-6 星级：摘要：这是一套塑造孩子良好性格和健全人格，开发孩子情绪智力、帮助孩子心灵成长的图画书。围绕10个最重要的性格主题，在优美的文字、精美的画面和童趣故事的徜徉熏陶中，教孩子学会自信与乐观，避免自卑与消极；学会勇敢与坚持，避免胆怯与退缩；学会尊重与宽容，避免武断与狭隘；学会自立，避免凡事依赖；学会合作，避免自高自大；学会时间管理，避免拖沓懒散；学会自我控制，避免急躁任性……

学会管自己

作者：陈梦敏年龄：3-6 星级：摘要：这套童话语言优美，故事精彩，想象奇特，并配有大量精美手绘插图，是基础阅读和文学启蒙的上选。该书系统地归纳了孩子从幼儿园大班到小学中低年级这段时间里会面临的主要问题，帮助学龄前和小学低年级学生在独立品格、学习能力、社会适应三方面应对小学新环境，让孩子顺利完成对外部环境变化的适应和自我角色的转变，在富有文学性的故事中，引导孩子学会认真不马虎，学会勤快不拖延，不找借口不搪塞，坚持自我不盲从，发现优点不自卑，学会坚持不放弃

我能行

作者：高尔基年龄：3-8 星级：摘要：专为提升3-8岁儿童情商素质而精心设计，通过孩子最熟悉的生活情境和生活细节，启发孩子认同自我、管理自我、建立责任感，引导孩子学会尊重、包容、分享、合作，鼓励孩子培养创造力、领导力、乐观精神，帮助孩子安全渡过叛逆期，培养受用一生的好情商

Tcp:udp

2015-05-12T00:00:00+00:00

TCP（Transmission Control Protocol，传输控制协议）

面向连接的协议：正式发送数据前，必须与对方建立连接，采用三次握手来完成连接的建立，比如主机A向主机B拷贝文件

1.主机A向主机B发送【连接请求】的数据包：“我想给你发文件，可以吗？”

2.主机B向主机A发送【同意和要求同步】的数据包：“可以，你什么时候发？”

3.主机A向主机B发送【确认同步】的数据包：“现在就发，你接着吧？”
保证数据传输可靠性：采用“重新发送”和“ACK”来保证数据传输的可靠性

1.发送者等待一段时间，如果没有收到当前发送数据包的ACK确认信息，发送方会重新发送数据包

2.若网络拥塞，重新发送将导致发送的数据包重复，接收方可以使用数据包的序号判定是否重复并丢弃
网络流量：TCP协议采用三次握手的方式，实际上主机A发送数据包给主机B，到主机B完全收到数据包后，消耗的网络流量=数据包大小+三次握手的开销

UDP（User Data Protocol，用户数据报协议）

面向非连接的协议：不与对方建立连接，直接把数据包发送过去
特性：通信效率高，可靠性不如TCP

Spring

2015-05-12T00:00:00+00:00

1.spring了解开始

Index

2015-05-12T00:00:00+00:00

Dns

2015-05-12T00:00:00+00:00

DNS名词

Bind（Berkeley Internet Name Domain）：搭建DNS服务的软件
DNS（Domain Name System）：域名系统
Hostname：主机名
FQDN（Fully Qualified Domain Name）：完整主机名称（主机名+域名），可以准确表示出主机的位置
NameServer（NS)：DNS服务器
A(Adress)：位址
Zone：每个需要解析的Domain(eg. www.baidu.com)

Hostname和Domain Name

<src=”https://github.com/jimmysc/jimmysc.github.io/raw/master/images/dns/HostnameAndDomainName.png” width = “300” height = “200” alt=”图片名称” align=center />

DNS出现

不同主机之间的数据包传送，需要知道双方的IP地址
IP地址的格式：32bits的IPV4和128bits的IPV6，实在是无法记忆
/ets/hosts局限性：IP的变更或域名的增加无法自动将所有Client端的hosts全部更新

DNS结构

树状目录架构(阶层架构)，将主机名称的管理分配在不同层级的DNS服务器中，采购分层管理，所以每部DNS服务器存储的内容不会太多，修改IP也相对容易
顶层 root(.):跟域
第2层特殊领域:com(公司、企业)；gov（政府）；org（组织，机构）；net（网络，通讯）；edu（教育）；mil（军事）；cn（中国）；tw（台湾）；jp（日本）

DNS查询

协议：优先UDP协议，异常时TCP协议, port 53

DNS追踪（Dig trace）

DNS解析追踪

eg. dig +trace www.baidu.com

DNS架构：master/slave架构

实现容灾方案，不会因为DNS挂掉后，导致无法找到目标主机
master/salve都是同事提供查询服务，没有查询优先权的设定
master修改资料库后，并加大资料库序号，重启DNS服务，会主动告知slave更新
salve也可以主动check资料库序号，来决定是否更新

DNS根服务器

总共13个DNS根服务器，其中唯一的一台主根服务器和9个副根服务器均设在美国(Inter-NIC，负责美国及其他地区)，另外3个副根服务器分别设在欧洲的瑞典、荷兰(RIPE-NIC，负责欧洲地区)和亚洲的日本(APNIC ，负责亚太地区)
13个DNS根服务器指的是逻辑上，并非物理上的服务器个数
所有根服务器均由美国政府授权的互联网域名与号码分配机构ICANN统一管理，负责全球互联网域名根服务器、域名体系和IP地址等的管理
所有root DNS坐标： root坐标网址

DNS攻击

1.DNS劫持

在特定的网络（该网络可能是有预谋的网络环境）范围内劫持域名解析的请求，返回错误的IP或不返回IP

2.DNS欺骗

通过串改DNS服务器中域名和IP映射关系，返回假的目标IP地址，导致用户实际访问的是攻击者的IP地址

3.DNS缓存投毒

通过污染DNS Cache，用虚假的IP地址信息替换Cache中主机记录的真实IP地址信息来制造破坏

什么情况下导致域名对应的IP查找不到？

目标DNS服务器挂掉
目标DNS服务器中的A记录不存在

如何让自己的主机名称对应IP、且其他电脑可以查询到？

上层DNS授权查询权，让你自己设定DNS服务器
请上层DNS服务器帮你设定主机和IP对应

为什么建立中国自己的根DNS刻不容缓?

2013年7月6日，上海联通DNS设备发生故障，导致2G、3G的手机用户无法上网
2013年8月25日，.CN根域名服务器全线故障
2014年1月21日，国内通用顶级根域名服务器解析出现异常，部分国内用户无法访问.com等域名网站。据初步统计，全国有2/3的网站访问受到影响。故障发生后，中国用户在访问时，都会被跳转到一个IP地址（65.49.2.178），而这个地址指向的是位于美国北卡罗来纳州卡里镇的一家公司

Mvn

2015-05-05T00:00:00+00:00

在多模块Maven项目中，反应堆（Reactor）是一个包含了所有需要构建模块的抽象概念，对于Maven用户来说，主要关心的是两点：

哪些模块会被包含到反应堆中？反应堆中所有模块的构建顺序是什么？

例如有这样的一个多模块项目:

plexus-security包含了8个子模块，其中security-realms还包括了更进一层的两个子模块。运行mvn clean install可以看到这样的输出：

Java代码收藏代码 [INFO] Scanning for projects…
[INFO] ————————————————————————
[INFO] Reactor Build Order:
[INFO]
[INFO] Plexus Security Aggregator
[INFO] Security: Parent
[INFO] Security: Model
[INFO] Security: XML Model
[INFO] Security: Configuration
[INFO] Security: System
[INFO] Security: Realms Parent
[INFO] Plexus XML Realm
[INFO] Security: REST API
[INFO] Plexus URL Realm
[INFO] Security Legacy Adapter
[INFO]
[INFO] ————————————————————————

在默认情况下，Maven会根据多模块配置构建所有的模块，Maven还会根据模块间的依赖关系自动计算构建顺序，以确保被依赖的模块会先得以构建。值得一提的是，在这种情形下，Maven会将父模块看成是其子模块的依赖，因此该例中Security Parent会较先得以构建。

一般来说，我们要么构建整个项目，要么构建单个模块，但是有些时候，我们会想要仅仅构建这个完整的反应堆中的某些模块，换句话说，我们会需要裁剪反应堆。例如说，我对模块security-configuration做了一些更改，而我知道在完整反应堆顺序中，security-model-xml和security-model在其之前，不会依赖它，因此就没必要构建他们。我们只需要构建security-configuration及其之后的项目。

Maven提供了很多命令行选项让我们自定义反应堆，输入mvn -h可以看到这样一些选项：

Java代码收藏代码 Options:
-am,–also-make If project list is specified, also
build projects required by the
list
-amd,–also-make-dependents If project list is specified, also
-pl,–projects Build specified reactor projects instead of all projects. A project can be specified by [groupId]:artifactId or by its relative path. -rf,--resume-from Resume reactor from specified project

–resume-from 表示从该模块恢复，也就是说选择从哪里开始构建，等于剪掉了完整反应堆的前面一部分。例如我运行 mvn clean install -rf security-configuration/ ，就会得到这样的一个反应堆：

Java代码收藏代码 [INFO] ————————————————————————
[INFO] Reactor Build Order:
[INFO]
[INFO] Security: Configuration
[INFO] Security: System
[INFO] Security: Realms Parent
[INFO] Plexus XML Realm
[INFO] Security: REST API
[INFO] Plexus URL Realm
[INFO] Security Legacy Adapter
[INFO]
[INFO] ————————————————————————

与完整反应堆相比，前面的四个模块不见了，只保留了security-system及其之后的模块。

–projects 表示手动选择需要构建的项目，项目间以逗号分隔。例如我运行 mvn clean install -pl security-configuration/,security-realms/security-xml-realm/，会得到如下反应堆：

Java代码收藏代码 [INFO] ————————————————————————
[INFO] Reactor Build Order:
[INFO]
[INFO] Security: Configuration
[INFO] Plexus XML Realm
[INFO]
[INFO] ————————————————————————

–also-make 的前提是–projects参数，表示同时构建所列模块依赖的其他模块。例如我运行 mvn clean install -pl security-model-xml/ -am，会得到如下反应堆：

Java代码收藏代码 [INFO] ————————————————————————
[INFO] Reactor Build Order:
[INFO]
[INFO] Security: Parent
[INFO] Security: Model
[INFO] Security: XML Model
[INFO]
[INFO] ————————————————————————

这里security-model-xml依赖于security-model，而security-parent是security-model-xml的父项目，因此这两个模块都会得以构建。

–also-make-dependents 的前提是–projects参数，表示同时构建那些依赖于所列模块的模块。例如我运行 mvn clean install -pl security-model-xml/ -amd，会得到如下反应堆：

Java代码收藏代码 [INFO] ————————————————————————
[INFO] Reactor Build Order:
[INFO]
[INFO] Security: XML Model
[INFO] Plexus XML Realm
[INFO] Security: REST API
[INFO] Plexus URL Realm
[INFO] Security Legacy Adapter
[INFO]
[INFO] ————————————————————————

除了security-model-xml本身，所有其他依赖于该模块的模块也会被加入到反应堆中。

除此之外，在-pl、-am或者-pl、-amd的基础上，还能应用-rf参数，紧接着上面的例子，再加上参数-rf -rf security-rest-api/，如：mvn clean install -pl security-model-xml/ -amd -rf security-rest-api/，便可以得到如下的反应堆：

Java代码收藏代码 [INFO] ————————————————————————
[INFO] Reactor Build Order:
[INFO]
[INFO] Security: REST API
[INFO] Plexus URL Realm
[INFO] Security Legacy Adapter
[INFO]
[INFO] ————————————————————————

这个反应堆表示：计算所有security-model-xml及依赖于它的模块，在次基础上，从security-rest-api模块开始构建。

在开发过程中，灵活应用上述4个参数，可以帮助我们跳过那些无须构建的项目模块，从而加速构建，当项目庞大，模块特别多的时候，这种效果就异常明显。

Idea

2015-05-05T00:00:00+00:00

格式化

alt + command + L

补全或去除import

ctrl + alt + o

查找Class

command + o

查找资源文件

command + shift + o

删除单行

command + delete

导入Class

alt + enter

重命名

shift + F6

进入代码内部

command + b

返回上一个鼠标焦点

alt + command + 左右箭头

切换window

command + ~

最大化

 command + shift + F12

当前类的方法

command + F12

打开类的继承关系

control + H

进入到方法的实现

command+alt+B

override method

ctrl + o

implement method

ctrl + i

import class

ctrl + shitf + o

delete import class

ctrl + alt + o

查找当前类中的代码

ctrl + G

查找类的引用

alt + F7

get/set方法

command + N

Idea 生成serialVersionUID的方法

1、setting->Inspections->Serialization issues，将serialzable class without "serialVersionUID"打上勾；
2、将光标放到类名上，按atl＋enter键，就会提示生成serialVersionUID了。

上下移动代码

alt + shift + up/down

复制一行代码

command + d

显示Class的方法

command + F12

搜索

command + shift + F

搜索Java类的引用

alt + F7

程序员书单

2014-11-19T00:00:00+00:00

语法

Think in Java
Effective Java
代码大全

原理

深入Java虚拟机

设计模式

重构改善既有代码的设计
Head First设计模式

Web

Http权威指南

框架类

Spring + Ibatis

架构类

企业应用架构

SQL

高性能MySql

集成工具

Maven实战

口水书

大型网站技术架构

操作系统

Vim学习

2014-11-11T00:00:00+00:00

学习思路

学习Vim需要不断学习和强化，逐步实践，从4个阶段进行学习

基础篇

中级篇

高级篇

杀手篇

1.基础篇

命令行中敲vim，默认进入normal模式

i		插入模式，按ESC回到normal模式
x		删除当前光标所在的一个字符
dd		删除当前光标所在的整行，并把删除的行放在剪贴板里
p		粘贴剪贴板中的内容
:wq		存盘+退出
hjkl	光标移动的方向 (←↓↑→).
:help <command>	查看命令的帮助信息

2.中级篇

选择插入

在VIM编辑的时候，会碰到：在后面一行插入、在前面一行插入、删除当前光标所在位置开始到下个单词之间的部分
o	在当前行后面插入一行，同时变成INSERT模式
O	在当前行前面插入一行，同时变成INSERT模式
cw	替换当前光标所在位置开始到下一个单词之间整个单词，但是不会删除光标之前单词的部分
a	在当前光标后插入 eg. abc 光标在b位置，选择a，会在b之后插入
i	在当前光标前插入 eg. abc 光标在b位置，选择i，会在b之前插入

移动光标

0	数字0移动到行首
^	移动到本行行首，且行首不是blank字符，比如括号中得内容(  abc   efg)，^移动到a位置
$	移动到行尾
g_	移动到本行行尾，切行尾不是blank的字符，比如括号中得内容(  abc   efg   )，g_移动到g位置

拷贝和粘贴
p	粘贴
yy	拷贝当前行

updo/redo
u	撤销

保存/打开文件

:q!	不保存，退出
ZZ	不保存，退出
wq	保存并退出
:w	存盘
:saveas	<path/file>	保存到新文件
:x	保存并退出

3.高级篇

###命令重复执行

.	:表示重复上次命令，eg.	 上次的命令是dd，输入.在执行一次dd，在输入.又执行一次dd
N<command>	:表示执行N次命令，eg.	2dd表示执行2次dd，2p表示执行2次粘贴
3.	:表示重复3次上次的命令

###光标快速移动

NG	表示移动到第几行，比如4G，表示移动到第4行
gg	表示移动到第1行
G	表示移动到最后一行
e	移动到下一个单词的末尾,单词是默认方式分隔 abc-def-bac
w	移动到下一个单词的开头，单词是默认方式分隔
E	移动到下一个单词的末尾，单词采用blank分隔
W	移动到下一个单词的开头，单词采用blank分隔
*	匹配当前光标所在位置的单词，并移动到下一个
#	匹配当前光标所在位置的单词，并移动到上一个

###组合命令

0y$	表示从行头到行尾的拷贝
ye	表示从当前位置拷贝到单词的末尾
gU	将当前行变大写
gu	将当前行变小写
v	可视化选择,可以先按v，然后移动箭头，根据可视化选择的情况进行命令的执行

4.杀手篇

Awk

2014-10-20T00:00:00+00:00

awk命令

是一种编程语言，用于linux/unix下的文本和数据处理，数据来源于标准输入，一个或多个文件，其他命令的输出。

处理流程：逐行扫描文件，从第一行到最后一行，寻找匹配的行，并在该行做你想做的事；如果没有指定action，则直接输出；如果没有指定pattern，则所有行被处理。

使用语法

awk '{pattern action}' input-file(s)}

使用方式

1.命令方式
	awk [-F fs] 'commands' input-file(s)
2.脚本方式
	#!/bin/awk
3.文件方式
	awk -f awk-script-file input-file

小试牛刀

/etc/passwd的数据内容格式
nobody:*:-2:-2:Unprivileged User:/var/empty:/usr/bin/false
root:*:0:0:System Administrator:/var/root:/bin/sh
daemon:*:1:1:System Services:/var/root:/usr/bin/false
_uucp:*:4:4:Unix to Unix Copy Protocol:/var/spool/uucp:/usr/sbin/uucico
_taskgated:*:13:13:Task Gate Daemon:/var/empty:/usr/bin/false
_networkd:*:24:24:Network Services:/var/networkd:/usr/bin/false
_installassistant:*:25:25:Install Assistant:/var/empty:/usr/bin/false

1.统计所有的账号列表($0,$1....的意思)
	awk -F ':'  '{print $1}' /etc/passwd
	
2.统计账号的个数(内置变量)
	awk -F ':' '{count++;} END{print "user account size is ",count}' /etc/passwd	
	
3.去重后的账号列表
	awk -F ':' ''
		
4.统计/etc/passwd文件名，行号(printf使用)
	 awk  -F ':'  '{printf("filename:%s,linenumber:%s,columns:%s,linecontent:%s\n",FILENAME,NR,NF,$0)}' /etc/passwd
	
5.输出账号的序号(数组，for循环的使用)
	awk -F ':' 'BEGIN{count = 0;} {account[count]=$1;count++;} END{for(i=0 ;i<count;i++) print i, account[i]}' /etc/passwd

6.统计某个文件夹下文件大于1M
	ls -l |awk '{if ($5 > 1024*1024) {print $9" "$5/1024/1024, "M"}}' 
	ls -l /home/admin/work |awk '{if ($5 > 1024*1024) {print $9" "$5/1024/1024, "M"}}'

内置变量

$0 当前行
$1...$n	当前记录的第N个字段，字段间由FS分隔
ARGC	命令行参数个数
AGRV	命令行参数排序
EVRIRON	
FILENAME	awk浏览的文件名
FNR	当前记录数，各个文件自己的行号
FS	输入域分隔符,默认空格或tab
NF	当前记录中的字段个数，也就是列数
NR	已读出的记录数，就是行号，从1开始，如果有多个文件，不断累加
OFS	输出的字段分隔符，默认空格
ORS	输出记录分隔符，默认换行 awk -F ":" ' END {print ORS}' /etc/passwd
RS	输入的记录分隔符，默认换行 awk -F ":" ' END {print RS}' /etc/passwd
NF	浏览记录的域个数 awk -F ":" ' END {print NF}' /etc/passwd

过滤记录

<	awk -F ":" '{if($3 < 1) print $1}' /etc/passwd
<=	awk -F ":" '{if($3 <= 1) print $1}' /etc/passwd
>	awk -F ":" '{if($3 > 1) print $1}' /etc/passwd
>=	awk -F ":" '{if($3 >= 1) print $1}' /etc/passwd
!=	awk -F ":" '{if($3 != 1) print $1}' /etc/passwd
==	awk -F ":" '{if($3 == 1) print $1}' /etc/passwd
~	awk -F ":" '{if($1~/root/) print $1}' /etc/passwd
!~	awk -F ":" '{if($1!~/root/) print $1}' /etc/passwd
&&	awk -F ":" '{if($3 > 2 && $3 != 4) print $1 , $3}' /etc/passwd
||	awk -F ":" '{if($3 > 2 || $3 == 4) print $1 , $3}' /etc/passwd

字符串匹配

匹配/etc/passwd中第1列是root的行及内容

awk -F ":"  '$1 ~ /root/ {print NR, $0}' /etc/passed
12 root:*:0:0:System Administrator:/var/root:/bin/sh
62 _cvmsroot:*:212:212:CVMS Root:/var/empty:/usr/bin/false

匹配/etc/passwd行中包含root的行及内容

awk '/root/ {print NR,$0}' /etc/passwd
12 root:*:0:0:System Administrator:/var/root:/bin/sh
13 daemon:*:1:1:System Services:/var/root:/usr/bin/false
62 _cvmsroot:*:212:212:CVMS Root:/var/empty:/usr/bin/false

拆分文件

相同的列归类到一个文件中

ps aux | awk 'NR !=1{print > $1}'
17926830 -rw-r--r--   1 jimmy  staff    128 11  4 23:37 _appleevents
17926826 -rw-r--r--   1 jimmy  staff     98 11  4 23:37 _coreaudiod
17926831 -rw-r--r--   1 jimmy  staff    100 11  4 23:37 _locationd
17926834 -rw-r--r--   1 jimmy  staff    101 11  4 23:37 _mdnsresponder
17926828 -rw-r--r--   1 jimmy  staff    100 11  4 23:37 _netbios
17926833 -rw-r--r--   1 jimmy  staff     99 11  4 23:37 _networkd
17926829 -rw-r--r--   1 jimmy  staff    446 11  4 23:37 _spotlight
17926832 -rw-r--r--   1 jimmy  staff    172 11  4 23:37 _usbmuxd
17926825 -rw-r--r--   1 jimmy  staff    199 11  4 23:37 _windowserver
17926824 -rw-r--r--   1 jimmy  staff  49272 11  4 23:37 jimmy
17926827 -rw-r--r--   1 jimmy  staff   7158 11  4 23:37 root

将过滤的内容输出到指定的文件中

ps aux | awk 'NR !=1{print $1 > "a.txt"}'
jimmy
jimmy
jimmy
jimmy
jimmy
jimmy

统计

遍历每个文件的行数

for i in `ll |awk '{print $10}'` ; do wc -l $i ; done  > file-line-count.txt

统计总文件大小

awk -F "mailSize" '{print $2}' * | awk -F "\"" '{print $3}' | awk -F "\\" '{sum+=$1} END {print sum/1024/1024/1024}'

统计每个文件的大小

for i in `ll |awk '{print $10}'` ;  do echo $i; awk -F "mailSize" '{print $2}' $i | awk -F "\"" '{print $3}' | awk -F "\\" '{sum+=$1} END {print FILENAME, sum/1024/1024}' ; done > size.txt

统计文件超过10M，20M的个数

awk -F "mailSize" '{print $2}' * | awk -F "\"" '{print $3}' | awk -F "\\" '{sum+=$1} END {print sum/1024/1024/1024}'

awk -F "mailSize" '{print $2}' * |awk -F "\"" '{print $3}' |awk -F "\\" '{if($1 > 20971520) sum+=1} END {print sum}'

按文件大小进行排序

ls -lR | awk '{if($5 > 0) print $5/1024/1024,"M",$9}' |sort  -nr

环境变量

使用脚本

Blog

2014-10-20T00:00:00+00:00

2014-11-12

Jvmtoolstudy

2014-09-30T00:00:00+00:00

jstat

用处: 实时统计GC的时间，次数等，帮助识别应用是否存在频繁创建对象，但是未及时释放，导致频繁的GC。

jstat -help
jstat -options
jstat -snap <pid>
jstat -<option> [-t] [-h<lines>] <pid> [<mill second> [<count>]]

jmap

用处: 用于dump堆内存进行分析，或者dump出堆内存中的对象明细，分析目前堆中对象占用的情况

jmap -help
jmap -dump
jmap -histo

top

用处: 实时显示linux中处理器的使用情况，内核管理的任务，及CPU，内存的使用率

10进制转成16进制方法：

 echo 'ibase=10;obase=16;3845' | bc

jstack

打印进程当前时刻的线程栈，可以分析是否发生了死锁，当前所有线程空忙情况，忙于做什么任务，同时可以定位消耗CPU的线程此时此刻的任务情况

1.线程处理慢

1.1 运行测试

1.运行BusyThreadTest
2.jps
3.jstack -l <pid>

1.2 线程内容

"BusyThread-99" prio=5 tid=0x00007fd2d2839000 nid=0x11603 waiting on condition [0x000000011e4d7000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
	at java.lang.Thread.sleep(Native Method)
	at com.jimmysc.thread.busy.BusyThread1.readFileFormRemote(BusyThread1.java:18)
	at com.jimmysc.thread.busy.BusyThread1.run(BusyThread1.java:13)
	at java.lang.Thread.run(Thread.java:744)

   Locked ownable synchronizers:
	- None

"BusyThread-98" prio=5 tid=0x00007fd2d2838000 nid=0x11403 waiting on condition [0x000000011e3d4000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
	at java.lang.Thread.sleep(Native Method)
	at com.jimmysc.thread.busy.BusyThread1.readFileFormRemote(BusyThread1.java:18)
	at com.jimmysc.thread.busy.BusyThread1.run(BusyThread1.java:13)
	at java.lang.Thread.run(Thread.java:744)

1.3 运行结果

所有的线程都在执行com.jimmysc.thread.busy.BusyThread1.readFileFormRemote(BusyThread1.java:18)
说明该方法处理速度过慢，这种情况下会整个应用的线程逐步被耗光，导致应用的处理能力急剧下降

2.死锁发生

2.1 运行测试

1.运行ThreadDeadLockTest
2.JPS
3.jstack -l <pid>

2.2 线程内容

"Thread-0" prio=5 tid=0x00007f94f3832000 nid=0x5003 waiting for monitor entry [0x000000011972f000]
java.lang.Thread.State: BLOCKED (on object monitor)
at com.jimmysc.thread.deadlock.Thread1.run(Thread1.java:19)
- waiting to lock <0x00000007d57a7008> (a java.lang.Class for com.jimmysc.thread.deadlock.ThreadLock2)
- locked <0x00000007d5655148> (a java.lang.Class for com.jimmysc.thread.deadlock.ThreadLock1)
at java.lang.Thread.run(Thread.java:744)

Locked ownable synchronizers:
- None
线程有3部分信息
1.线程的状态：waiting for monitor entry
2.线程的调用栈：
3.线程当前锁住的资源：locked <0x00000007d5655148> (a java.lang.Class for com.jimmysc.thread.deadlock.ThreadLock1)

2.3 线程状态

1.runnable
	表示线程具备运行条件等待操作系统调度，或正在运行中
2.waiting on condition
	表示线程等待某个条件的发生：比如sleep、网络空闲等
3.Waiting for monitor entry 和 in Object.wait() 
	Monitor是java中实现线程之间互斥和协作的主要手段，它可以看成是对象或class的锁，每个对象都有，但只有一个Monitor，下图描述Monitor，线程及线程状态的转换图

任何时刻，每个 Monitor只能被 “Active Thread”拥有。其它线程都是 “Waiting Thread”，分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”，在 “Wait Set”中等待的线程状态是 “in Object.wait()”
当执行到synchronized块的代码时（临界区），线程进入Entry Set队列中，若此时Monitor不被其他线程占用，并且Entry Set中没有其他线程，则当前线程会成为Monitor的Owner，执行synchronized中的代码，否则会一直在Entry Set等待；如果线程调用wait方法，则线程进入Wait Set等待，除非线程调用了对象的notify() 或 notifyAll()，Wait Set中的线程才有机会去竞争Monitor，但最终只有一个线程获得Monitor

2.4 运行结果

	"Thread-1" prio=5 tid=0x00007f94f3832800 nid=0x5203 waiting for monitor entry [0x0000000119832000]
   java.lang.Thread.State: BLOCKED (on object monitor)
	at com.jimmysc.thread.deadlock.Thread2.run(Thread2.java:19)
	- waiting to lock <0x00000007d5655148> (a java.lang.Class for com.jimmysc.thread.deadlock.ThreadLock1)
	- locked <0x00000007d57a7008> (a java.lang.Class for com.jimmysc.thread.deadlock.ThreadLock2)
	at java.lang.Thread.run(Thread.java:744)

   Locked ownable synchronizers:
	- None

"Thread-0" prio=5 tid=0x00007f94f3832000 nid=0x5003 waiting for monitor entry [0x000000011972f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
	at com.jimmysc.thread.deadlock.Thread1.run(Thread1.java:19)
	- waiting to lock <0x00000007d57a7008> (a java.lang.Class for com.jimmysc.thread.deadlock.ThreadLock2)
	- locked <0x00000007d5655148> (a java.lang.Class for com.jimmysc.thread.deadlock.ThreadLock1)
	at java.lang.Thread.run(Thread.java:744)

   Locked ownable synchronizers:
	- None	

1).Thread-1和Thread-0的线程状态都是waiting for monitor entry，表示都是在Entry Set队列中，都在等待拿到Monitor，多执行几次jstack -l <pid> 线程栈的信息都一样，说明无法拿到monitor；
2).线程栈的提示信息显示BLOCKED，同时Thread-0在waiting to lock <0x00000007d57a7008> ；Thread-0又locked <0x00000007d5655148> ，Thread-1在waiting to lock <0x00000007d5655148>，locked <0x00000007d57a7008>，都锁住对方需要的锁，同时又等待对方释放锁，造成了死锁

tsar

http://tsar.taobao.org/

Jekyll Introduction

2011-12-29T00:00:00+00:00

This Jekyll introduction will outline specifically what Jekyll is and why you would want to use it. Directly following the intro we’ll learn exactly how Jekyll does what it does.

Overview

What is Jekyll?

Jekyll is a parsing engine bundled as a ruby gem used to build static websites from dynamic components such as templates, partials, liquid code, markdown, etc. Jekyll is known as “a simple, blog aware, static site generator”.

Examples

This website is created with Jekyll. Other Jekyll websites.

What does Jekyll Do?

Jekyll is a ruby gem you install on your local system. Once there you can call jekyll --server on a directory and provided that directory is setup in a way jekyll expects, it will do magic stuff like parse markdown/textile files, compute categories, tags, permalinks, and construct your pages from layout templates and partials.

Once parsed, Jekyll stores the result in a self-contained static _site folder. The intention here is that you can serve all contents in this folder statically from a plain static web-server.

You can think of Jekyll as a normalish dynamic blog but rather than parsing content, templates, and tags on each request, Jekyll does this once beforehand and caches the entire website in a folder for serving statically.

Jekyll is Not Blogging Software

Jekyll is a parsing engine.

Jekyll does not come with any content nor does it have any templates or design elements. This is a common source of confusion when getting started. Jekyll does not come with anything you actually use or see on your website - you have to make it.

Why Should I Care?

Jekyll is very minimalistic and very efficient. The most important thing to realize about Jekyll is that it creates a static representation of your website requiring only a static web-server. Traditional dynamic blogs like Wordpress require a database and server-side code. Heavily trafficked dynamic blogs must employ a caching layer that ultimately performs the same job Jekyll sets out to do; serve static content.

Therefore if you like to keep things simple and you prefer the command-line over an admin panel UI then give Jekyll a try.

Developers like Jekyll because we can write content like we write code:

Ability to write content in markdown or textile in your favorite text-editor.
Ability to write and preview your content via localhost.
No internet connection required.
Ability to publish via git.
Ability to host your blog on a static web-server.
Ability to host freely on GitHub Pages.
No database required.

How Jekyll Works

The following is a complete but concise outline of exactly how Jekyll works.

Be aware that core concepts are introduced in rapid succession without code examples. This information is not intended to specifically teach you how to do anything, rather it is intended to give you the full picture relative to what is going on in Jekyll-world.

Learning these core concepts should help you avoid common frustrations and ultimately help you better understand the code examples contained throughout Jekyll-Bootstrap.

Initial Setup

After installing jekyll you’ll need to format your website directory in a way jekyll expects. Jekyll-bootstrap conveniently provides the base directory format.

The Jekyll Application Base Format

Jekyll expects your website directory to be laid out like so:

.
|-- _config.yml
|-- _includes
|-- _layouts
|   |-- default.html
|   |-- post.html
|-- _posts
|   |-- 2011-10-25-open-source-is-good.markdown
|   |-- 2011-04-26-hello-world.markdown
|-- _site
|-- index.html
|-- assets
    |-- css
        |-- style.css
    |-- javascripts

_config.yml Stores configuration data.
_includes This folder is for partial views.
_layouts This folder is for the main templates your content will be inserted into. You can have different layouts for different pages or page sections.
_posts This folder contains your dynamic content/posts. the naming format is required to be @YEAR-MONTH-DATE-title.MARKUP@.
_site This is where the generated site will be placed once Jekyll is done transforming it.
assets This folder is not part of the standard jekyll structure. The assets folder represents any generic folder you happen to create in your root directory. Directories and files not properly formatted for jekyll will be left untouched for you to serve normally.

Jekyll Configuration

Jekyll supports various configuration options that are fully outlined here: (https://github.com/mojombo/jekyll/wiki/Configuration)

Content in Jekyll

Content in Jekyll is either a post or a page. These content “objects” get inserted into one or more templates to build the final output for its respective static-page.

Posts and Pages

Both posts and pages should be written in markdown, textile, or HTML and may also contain Liquid templating syntax. Both posts and pages can have meta-data assigned on a per-page basis such as title, url path, as well as arbitrary custom meta-data.

Working With Posts

Creating a Post Posts are created by properly formatting a file and placing it the _posts folder.

Formatting A post must have a valid filename in the form YEAR-MONTH-DATE-title.MARKUP and be placed in the _posts directory. If the data format is invalid Jekyll will not recognize the file as a post. The date and title are automatically parsed from the filename of the post file. Additionally, each file must have YAML Front-Matter prepended to its content. YAML Front-Matter is a valid YAML syntax specifying meta-data for the given file.

Order Ordering is an important part of Jekyll but it is hard to specify a custom ordering strategy. Only reverse chronological and chronological ordering is supported in Jekyll.

Since the date is hard-coded into the filename format, to change the order, you must change the dates in the filenames.

Tags Posts can have tags associated with them as part of their meta-data. Tags may be placed on posts by providing them in the post’s YAML front matter. You have access to the post-specific tags in the templates. These tags also get added to the sitewide collection.

Categories Posts may be categorized by providing one or more categories in the YAML front matter. Categories offer more significance over tags in that they can be reflected in the URL path to the given post. Note categories in Jekyll work in a specific way. If you define more than one category you are defining a category hierarchy “set”. Example:

---
title :  Hello World
categories : [lessons, beginner]
---

This defines the category hierarchy “lessons/beginner”. Note this is one category node in Jekyll. You won’t find “lessons” and “beginner” as two separate categories unless you define them elsewhere as singular categories.

Working With Pages

Creating a Page Pages are created by properly formatting a file and placing it anywhere in the root directory or subdirectories that do not start with an underscore.

Formatting In order to register as a Jekyll page the file must contain YAML Front-Matter. Registering a page means 1) that Jekyll will process the page and 2) that the page object will be available in the site.pages array for inclusion into your templates.

Categories and Tags Pages do not compute categories nor tags so defining them will have no effect.

Sub-Directories If pages are defined in sub-directories, the path to the page will be reflected in the url. Example:

.
|-- people
    |-- bob
        |-- essay.html

This page will be available at http://yourdomain.com/people/bob/essay.html

Recommended Pages

index.html You will always want to define the root index.html page as this will display on your root URL.
404.html Create a root 404.html page and GitHub Pages will serve it as your 404 response.
sitemap.html Generating a sitemap is good practice for SEO.
about.html A nice about page is easy to do and gives the human perspective to your website.

Templates in Jekyll

Templates are used to contain a page’s or post’s content. All templates have access to a global site object variable: site as well as a page object variable: page. The site variable holds all accessible content and metadata relative to the site. The page variable holds accessible data for the given page or post being rendered at that point.

Create a Template Templates are created by properly formatting a file and placing it in the _layouts directory.

Formatting Templates should be coded in HTML and contain YAML Front Matter. All templates can contain Liquid code to work with your site’s data.

Rending Page/Post Content in a Template There is a special variable in all templates named : content. The content variable holds the page/post content including any sub-template content previously defined. Render the content variable wherever you want your main content to be injected into your template:

...
<body>
  <div id="sidebar"> ... </div>
  <div id="main">
    {{content}}
  </div>
</body>
...

Sub-Templates

Sub-templates are exactly templates with the only difference being they define another “root” layout/template within their YAML Front Matter. This essentially means a template will render inside of another template.

Includes

In Jekyll you can define include files by placing them in the _includes folder. Includes are NOT templates, rather they are just code snippets that get included into templates. In this way, you can treat the code inside includes as if it was native to the parent template.

Any valid template code may be used in includes.

Using Liquid for Templating

Templating is perhaps the most confusing and frustrating part of Jekyll. This is mainly due to the fact that Jekyll templates must use the Liquid Templating Language.

What is Liquid?

Liquid is a secure templating language developed by Shopify. Liquid is designed for end-users to be able to execute logic within template files without imposing any security risk on the hosting server.

Jekyll uses Liquid to generate the post content within the final page layout structure and as the primary interface for working with your site and post/page data.

Why Do We Have to Use Liquid?

GitHub uses Jekyll to power GitHub Pages. GitHub cannot afford to run arbitrary code on their servers so they lock developers down via Liquid.

Liquid is Not Programmer-Friendly.

The short story is liquid is not real code and its not intended to execute real code. The point being you can’t do jackshit in liquid that hasn’t been allowed explicitly by the implementation. What’s more you can only access data-structures that have been explicitly passed to the template.

In Jekyll’s case it is not possible to alter what is passed to Liquid without hacking the gem or running custom plugins. Both of which cannot be supported by GitHub Pages.

As a programmer - this is very frustrating.

But rather than look a gift horse in the mouth we are going to suck it up and view it as an opportunity to work around limitations and adopt client-side solutions when possible.

Aside My personal stance is to not invest time trying to hack liquid. It’s really unnecessary from a programmer’s perspective. That is to say if you have the ability to run custom plugins (i.e. run arbitrary ruby code) you are better off sticking with ruby. Toward that end I’ve built Mustache-with-Jekyll

Static Assets

Static assets are any file in the root or non-underscored subfolders that are not pages. That is they have no valid YAML Front Matter and are thus not treated as Jekyll Pages.

Static assets should be used for images, css, and javascript files.

How Jekyll Parses Files

Remember Jekyll is a processing engine. There are two main types of parsing in Jekyll.

Content parsing. This is done with textile or markdown.
Template parsing. This is done with the liquid templating language.

And thus there are two main types of file formats needed for this parsing.

Post and Page files. All content in Jekyll is either a post or a page so valid posts and pages are parsed with markdown or textile.
Template files. These files go in _layouts folder and contain your blogs templates. They should be made in HTML with the help of Liquid syntax. Since include files are simply injected into templates they are essentially parsed as if they were native to the template.

Arbitrary files and folders. Files that are not valid pages are treated as static content and pass through Jekyll untouched and reside on your blog in the exact structure and format they originally existed in.

Formatting Files for Parsing.

We’ve outlined the need for valid formatting using YAML Front Matter. Templates, posts, and pages all need to provide valid YAML Front Matter even if the Matter is empty. This is the only way Jekyll knows you want the file processed.

YAML Front Matter must be prepended to the top of template/post/page files:

---
layout: post
category : pages
tags : [how-to, jekyll]
---

... contents ...

Three hyphens on a new line start the Front-Matter block and three hyphens on a new line end the block. The data inside the block must be valid YAML.

Configuration parameters for YAML Front-Matter is outlined here: A comprehensive explanation of YAML Front Matter

Defining Layouts for Posts and Templates Parsing.

The layout parameter in the YAML Front Matter defines the template file for which the given post or template should be injected into. If a template file specifies its own layout, it is effectively being used as a sub-template. That is to say loading a post file into a template file that refers to another template file with work in the way you’d expect; as a nested sub-template.

How Jekyll Generates the Final Static Files.

Ultimately, Jekyll’s job is to generate a static representation of your website. The following is an outline of how that’s done:

Jekyll collects data. Jekyll scans the posts directory and collects all posts files as post objects. It then scans the layout assets and collects those and finally scans other directories in search of pages.
Jekyll computes data. Jekyll takes these objects, computes metadata (permalinks, tags, categories, titles, dates) from them and constructs one big site object that holds all the posts, pages, layouts, and respective metadata. At this stage your site is one big computed ruby object.
Jekyll liquifies posts and templates. Next jekyll loops through each post file and converts (through markdown or textile) and liquifies the post inside of its respective layout(s). Once the post is parsed and liquified inside the the proper layout structure, the layout itself is “liquified”. Liquification is defined as follows: Jekyll initiates a Liquid template, and passes a simpler hash representation of the ruby site object as well as a simpler hash representation of the ruby post object. These simplified data structures are what you have access to in the templates.
Jekyll generates output. Finally the liquid templates are “rendered”, thereby processing any liquid syntax provided in the templates and saving the final, static representation of the file.

Notes. Because Jekyll computes the entire site in one fell swoop, each template is given access to a global site hash that contains useful data. It is this data that you’ll iterate through and format using the Liquid tags and filters in order to render it onto a given page.

Remember, in Jekyll you are an end-user. Your API has only two components:

The manner in which you setup your directory.
The liquid syntax and variables passed into the liquid templates.

All the data objects available to you in the templates via Liquid are outlined in the API Section of Jekyll-Bootstrap. You can also read the original documentation here: https://github.com/mojombo/jekyll/wiki/Template-Data

Conclusion

I hope this paints a clearer picture of what Jekyll is doing and why it works the way it does. As noted, our main programming constraint is the fact that our API is limited to what is accessible via Liquid and Liquid only.

Jekyll-bootstrap is intended to provide helper methods and strategies aimed at making it more intuitive and easier to work with Jekyll =)

Thank you for reading this far.

Next Steps

Please take a look at or jump right into Usage if you’d like.

Jimmysc.github.io

Window

Baby

绘本

Tcp:udp

TCP（Transmission Control Protocol，传输控制协议）

UDP（User Data Protocol，用户数据报协议）

Spring

Index

安全

技能

架构

DB

工具使用

网络

Dns

DNS名词

Hostname和Domain Name

DNS出现

DNS结构

DNS查询

DNS追踪（Dig trace）

DNS架构：master/slave架构

DNS根服务器

DNS攻击

1.DNS劫持

2.DNS欺骗

3.DNS缓存投毒

什么情况下导致域名对应的IP查找不到？

如何让自己的主机名称对应IP、且其他电脑可以查询到？

为什么建立中国自己的根DNS刻不容缓?

Mvn

Idea

格式化

补全或去除import

查找Class

查找资源文件

删除单行

导入Class

重命名

进入代码内部

返回上一个鼠标焦点

切换window

最大化

当前类的方法

打开类的继承关系

进入到方法的实现

override method

implement method

import class

delete import class

查找当前类中的代码

查找类的引用

get/set方法

Idea 生成serialVersionUID的方法

上下移动代码

复制一行代码

显示Class的方法

搜索

搜索Java类的引用

程序员书单

语法

原理

设计模式

Web

框架类

架构类

SQL

集成工具

口水书

操作系统

Vim学习

学习思路

1.基础篇

2.中级篇

选择插入

移动光标

拷贝和粘贴

updo/redo

保存/打开文件