diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..29f81d8
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..a3bd137
--- /dev/null
+++ b/README.md
@@ -0,0 +1,205 @@
+# 路漫漫其修远兮,吾将上下而求索
+
+> 
+>
+> 舒适的环境总让人感觉很满足，殊不知它却是毒药。
+>
+> 
+
+## c语言
+
+1. [c语言入门](./c语言/c语言入门.md)
+
+## java
+
+### 文档
+
+1. [CountDownLatch](./java/countdownlatch.md)
+2. [future获取异步计算结果](./java/future获取异步计算结果.md)
+3. [html元素解析工具jsoup](./java/html元素解析工具jsoup.md)
+4. [httpclient](./java/httpclient.md)
+5. [java persistence api](./java/java_persistence_api.md)
+6. [java spi机制](./java/java_spi机制.md)
+7. [javaagent](./java/javaagent.md)
+8. [javassist使用指南](./java/javassist使用指南.md)
+9. [java逃逸分析](./java/java逃逸分析.md)
+10. [ReadWriteLock引发的假死](./java/ReadWriteLock引发的假死.md)
+11. [一张图看懂java集合框架](./java/一张图看懂java集合框架.md)
+12. [使用命令编译打包](./java/使用命令编译打包.md)
+13. [动态代理](./java/动态代理.md)
+14. [多次删除不掉文件](./java/多次删除不掉文件.md)
+15. [多线程之间的管道流](./java/多线程之间的管道流.md)
+16. [正则表达式分组](./java/正则表达式分组.md)
+17. [正则表达式替换匹配的文本](./java/正则表达式替换匹配的文本.md)
+18. [正则表达式规则大全](./java/正则表达式规则大全.md)
+19. [正则表达式贪婪和懒惰匹配](./java/正则表达式贪婪和懒惰匹配.md)
+20. [类加载器](./java/类加载器.md)
+21. [维护多个数据库连接](./java/维护多个数据库连接.md)
+22. [获取数据库元数据](./java/获取数据库元数据.md)
+23. [获取程序工作路径](./java/获取程序工作路径.md)
+24. [裁剪图片](./java/裁剪图片.md)
+25. [计算身份证校验码](./java/计算身份证校验码.md)
+26. [运行时编译](./java/运行时编译.md)
+27. [远程debug](./java/远程debug.md)
+
+### 代码片
+
+1. [Jackson转换JSON工具](./java/代码片/jackson转换json工具.md)
+2. [java8日期之间的转换](./java/代码片/java8日期之间的转换.md)
+3. [SVN基础操作](./java/代码片/SVN基础操作.md)
+4. [zip文件操作](./java/代码片/zip文件操作.md)
+6. [复制文件或文件夹](./java/代码片/复制文件或文件夹.md)
+7. [手动分析调试json](./java/代码片/手动分析调试json.md)
+8. [操作maven](./java/代码片/操作maven.md)
+9. [数字转中文](./java/代码片/数字转中文.md)
+10. [数字转英文](./java/代码片/数字转英文.md)
+10. [文件操作工具类](./java/代码片/文件操作工具类.md)
+11. [脚本调用](./java/代码片/脚本调用.md)
+12. [获取文件创建时间](./java/代码片/获取文件创建时间.md)
+
+## java web
+
+1. [下载文件](./javaweb/下载文件.md)
+2. [跨域访问](./javaweb/跨域访问.md)
+3. [转发与重定向](./javaweb/转发与重定向.md)
+
+## spring boot
+
+入门
+
+1. [1_入门](./springboot/入门/1_入门.md)
+2. [2_配置](./springboot/入门/2_配置.md)
+3. [3_日志](./springboot/入门/3_日志.md)
+4. [4_web](./springboot/入门/4_web.md)
+5. [5_docker](./springboot/入门/5_docker.md)
+6. [6_数据访问](./springboot/入门/6_数据访问.md)
+7. [7_启动配置原理](./springboot/入门/7_启动配置原理.md)
+8. [8_自定义starter](./springboot/入门/8_自定义starter.md)
+
+**解决方案**
+
+1. [上传大文件报错](./springboot/上传大文件报错.md)
+2. [修改JSON转换器](./springboot/修改JSON转换器.md)
+3. [排除预定义的Configuration](./springboot/排除预定义的Configuration.md)
+4. [自定义conditional](./springboot/自定义conditional.md)
+5. [自定义filter](./springboot/自定义filter.md)
+6. [运行时指定外部配置文件](./springboot/运行时指定外部配置文件.md)
+7. [静态资源映射](./springboot/静态资源映射.md)
+
+## spring framework
+
+1. [aop](./springframework/aop.md)
+2. [beanpostprocessor](./springframework/beanpostprocessor.md)
+3. [jms](./springframework/jms.md)
+4. [单元测试及事务](./springframework/单元测试及事务.md)
+5. [运行时注册bean](./springframework/运行时注册bean.md)
+
+## 日志
+
+### logback
+
+1. [logback](./日志/logback/logback.md)
+2. [logback设置控制台颜色](./日志/logback/logback设置控制台颜色.md)
+
+## lua
+
+1. [搭建开发环境](./lua/搭建开发环境.md)
+
+## js
+
+1. [jquery属性操作](./js/jquery属性操作.md)
+2. [jquery获取非form标签的value](./js/jquery获取非form标签的value.md)
+3. [使用FormData上传文件](./js/使用FormData上传文件.md)
+4. [定时器](./js/定时器.md)
+5. [触发事件](./js/触发事件.md)
+
+## vuejs
+
+1. [vue入门](./vuejs/vue入门.md)
+
+## 数据库
+
+1. [mysql存储过程](./数据库/mysql存储过程.md)
+2. [mysql异常](./数据库/mysql异常.md)
+3. [mysql清档](./数据库/mysql清档.md)
+4. [sql基础](./数据库/sql基础.md)
+5. [url添加时区](./数据库/url添加时区.md)
+
+## 计算机基础
+
+1. [原码、反码、补码](./计算机基础/原码、反码、补码.md)
+2. [有符号右移>>无符号右移>>>](./计算机基础/有符号右移与无符号右移.md)
+3. [进制转换](./计算机基础/进制转换.md)
+
+## linux
+
+1. [centos7安装mysql5.6](./linux/centos7安装mysql5.6.md)
+2. [centos扩大swap分区](./linux/centos扩大swap分区.md)
+3. [centos搭建consul集群](./linux/centos搭建consul集群.md)
+4. [centos搭建redis集群](./linux/centos搭建redis集群.md)
+5. [centos搭建shadowsocks](./linux/centos搭建shadowsocks.md)
+6. [centos设置网络代理](./linux/centos设置网络代理.md)
+7. [goflyway访问外网](./linux/goflyway访问外网.md)
+8. [nginx转发规则](./linux/nginx转发规则.md)
+9. [screen命令](./linux/screen命令.md)
+10. [source命令](./linux/source命令.md)
+11. [查看占用端口的进程](./linux/查看占用端口的进程.md)
+12. [虚拟机设置静态ip](./linux/虚拟机设置静态ip.md)
+
+## windows
+
+2. [安装ubuntu子系统](./windows/安装ubuntu子系统.md)
+3. [查看占用端口的进程](./windows/查看占用端口的进程.md)
+
+## 开发工具
+
+### git
+
+1. [使用文档](./开发工具/git/使用文档.md)
+2. [修改文件名大小写](./开发工具/git/修改文件名大小写.md)
+3. [只拉取最新版本的代码](./开发工具/git/只拉取最新版本的代码.md)
+4. [清空提交记录](./开发工具/git/清空提交记录.md)
+
+### idea
+
+1. [单个文件超限制](./开发工具/idea/单个文件超限制.md)
+2. [安装eclipse格式化插件](./开发工具/idea/安装eclipse格式化插件.md)
+3. [快捷键](./开发工具/idea/快捷键.md)
+4. [提升运行及编译速度](./开发工具/idea/提升运行及编译速度.md)
+5. [正则替换文本](./开发工具/idea/正则替换文本.md)
+6. [社区版安装tomcat](./开发工具/idea/社区版安装tomcat.md)
+7. [编译项目时内存溢出](./开发工具/idea/编译项目时内存溢出.md)
+8. [自动导入内部类](./开发工具/idea/自动导入内部类.md)
+
+### maven
+
+1. [idea中包offline_mode错误](./开发工具/maven/idea中包offline_mode错误.md)
+2. [idea控制台中文乱码](./开发工具/maven/idea控制台中文乱码.md)
+3. [jar打包插件](./开发工具/maven/jar打包插件.md)
+4. [maven](./开发工具/maven/maven.md)
+5. [maven配置文件](./开发工具/maven/maven配置文件.md)
+6. [下载jar包](./开发工具/maven/下载jar包.md)
+7. [依赖war包项目](./开发工具/maven/依赖war包项目.md)
+8. [原生插件一览表](./开发工具/maven/原生插件一览表.md)
+9. [安装本地jar包到仓库](./开发工具/maven/安装本地jar包到仓库.md)
+10. [打包文件名添加时间戳](./开发工具/maven/打包文件名添加时间戳.md)
+11. [打包时跳过测试](./开发工具/maven/打包时跳过测试.md)
+12. [无法识别java下的配置文件](./开发工具/maven/无法识别java下的配置文件.md)
+13. [统一管理版本号](./开发工具/maven/统一管理版本号.md)
+14. [编码GBK的不可映射字符](./开发工具/maven/编码GBK的不可映射字符.md)
+15. [编译时无法识别com.sun包](./开发工具/maven/编译时无法识别com.sun包.md)
+16. [配置阿里私服镜像](./开发工具/maven/配置阿里私服镜像.md)
+
+### svn
+
+1. [clean提示先前的操作未结束](./开发工具/svn/clean提示先前的操作未结束.md)
+
+## 服务器
+
+1. [idea控制台中文乱码](./服务器/tomcat/idea控制台中文乱码.md)
+
+## chrome
+
+1. [switchyomega](./chrome/switchyomega.md)
+2. [打包扩展程序](./chrome/打包扩展程序.md)
+
diff --git a/_config.yml b/_config.yml
new file mode 100644
index 0000000..c419263
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1 @@
+theme: jekyll-theme-cayman
\ No newline at end of file
diff --git a/chrome/images/001/001.png b/chrome/images/001/001.png
new file mode 100644
index 0000000..3bed2ad
Binary files /dev/null and b/chrome/images/001/001.png differ
diff --git a/chrome/images/001/002.png b/chrome/images/001/002.png
new file mode 100644
index 0000000..30d1ab2
Binary files /dev/null and b/chrome/images/001/002.png differ
diff --git a/chrome/images/002/001.png b/chrome/images/002/001.png
new file mode 100644
index 0000000..9c0c9d4
Binary files /dev/null and b/chrome/images/002/001.png differ
diff --git a/chrome/images/002/002.png b/chrome/images/002/002.png
new file mode 100644
index 0000000..09e04b0
Binary files /dev/null and b/chrome/images/002/002.png differ
diff --git a/chrome/images/002/003.png b/chrome/images/002/003.png
new file mode 100644
index 0000000..9d5b8c5
Binary files /dev/null and b/chrome/images/002/003.png differ
diff --git a/chrome/switchyomega.md b/chrome/switchyomega.md
new file mode 100644
index 0000000..1cce63d
--- /dev/null
+++ b/chrome/switchyomega.md
@@ -0,0 +1,24 @@
+# SwitchyOmega
+
+**SwitchyOmega**是一个代理设置工具，用于管理不同域名使用不同代理服务器
+
+## 新增代理配置
+
+![添加配置](./images/002/002.png)
+
+点击左侧的**新建情景模式**，输入名称后点击**创建**按钮。
+
+点击左侧刚刚创建的情景名称。配置如下信息，并点击**应用选项**：
+
+![情景配置](./images/002/003.png)
+
+## 配置GFW列表
+
+![自动代理页面](./images/002/001.png)
+
+在**SwitchyOmega**管理页面选择**auto switch**，下拉到**规则列表设置**，选择**AutoProxy**，并将`https://raw.githubusercontent.com/gfwlist/gfwlist/master/gfwlist.txt`填入**规则列表网址**，然后选择**立即更新情景场景**。
+
+将上方匹配规则列表设置为刚刚新建的**情景模式**
+
+点击左侧**应用选项**。
+
diff --git "a/chrome/\346\211\223\345\214\205\346\211\251\345\261\225\347\250\213\345\272\217.md" "b/chrome/\346\211\223\345\214\205\346\211\251\345\261\225\347\250\213\345\272\217.md"
new file mode 100644
index 0000000..5732bb3
--- /dev/null
+++ "b/chrome/\346\211\223\345\214\205\346\211\251\345\261\225\347\250\213\345\272\217.md"
@@ -0,0 +1,34 @@
+## 1. 打开扩展文件安装目录
+
+资源管理器中打开下面的目录：
+
+```
+C:\Users\用户名\AppData\Local\Google\Chrome\User Data\Default\Extensions
+```
+
+该目录下存放着所有的插件，文件夹的名称就是插件的ID。
+
+## 2. 打开chrome扩展程序管理页面
+
+选择chrome工具栏最右侧的 三个点(.)，选择更多工具 > 扩展程序。
+
+启用扩展程序左侧的 **开发者模式**
+
+![扩展程序管理页面](./images/001/001.png)
+
+该页面中显示了扩展程序的ID以及版本号。
+
+## 3.打包
+
+点击扩展程序管理页面的 **打包扩展程序**
+
+![打包扩展程序](./images/001/002.png)
+
+**扩展程序根目录**选择刚才资源管理器中打开路径的 + ID + 版本号，如：
+
+```
+C:\Users\用户\AppData\Local\Google\Chrome\User Data\Default\Extensions\cfhdojbkjhnklbpkdaibdccddilifddb\3.5.2_0
+```
+
+最后点击打包扩展程序，chrome会提示插件以及秘钥打包的位置。
+
diff --git "a/c\350\257\255\350\250\200/c\350\257\255\350\250\200\345\205\245\351\227\250.md" "b/c\350\257\255\350\250\200/c\350\257\255\350\250\200\345\205\245\351\227\250.md"
new file mode 100644
index 0000000..62f9555
--- /dev/null
+++ "b/c\350\257\255\350\250\200/c\350\257\255\350\250\200\345\205\245\351\227\250.md"
@@ -0,0 +1,113 @@
+### 第一个C语言程序
+
+```c
+# include <stdio.h> 	// 引入头文件
+int main(void) {		// 函数
+    int number = 10;	// 变量声明及赋值
+    printf("当前的number是%d\n", number);	// 输出语句
+    return 0;			// 函数返回
+}
+```
+
+### 基本数据类型
+
+C语言的基本数据类型为：整型、字符型、实数型。这些类型按其在计算机中的存储方式可被分为两个系列，即整数(integer)类型和浮点数(floating-point)类型。 
+这三种类型之下分别是：short、int、long、char、float、double 这六个关键字再加上两个符号说明符signed和unsigned就基本表示了C语言的最常用的数据类型。 
+下面列出了在32位操作系统下 常见编译器下的数据类型大小及表示的数据范围：
+
+| 类型名称       | 占字节数 | 其他叫法           | 表示的数据范围                 |
+| -------------- | -------- | ------------------ | ------------------------------ |
+| char           | 1        | signed char        | -128 ~ 127                     |
+| unsigned char  | 1        | none               | 0 ~ 255                        |
+| int            | 4        | signed int         | -2,147,483,648 ~ 2,147,483,647 |
+| unsigned int   | 4        | unsigned           | 0 ~ 4,294,967,295              |
+| short          | 2        | short int          | -32,768 ~ 32,767               |
+| unsigned short | 2        | unsigned short int | 0 ~ 65,535                     |
+| long           | 4        | long int           | -2,147,483,648 ~ 2,147,483,647 |
+| unsigned long  | 4        | unsigned long      | 0 ~ 4,294,967,295              |
+| float          | 4        | none               | 3.4E +/- 38 (7 digits)         |
+| double         | 8        | none               | 1.7E +/- 308 (15 digits)       |
+| long double    | 10       | none               | 1.2E +/- 4932 (19 digits)      |
+
+
+
+### 关键字
+
+| C语言中的32个关键字 |        |          |          |
+| ------------------- | ------ | -------- | -------- |
+| auto                | double | int      | struct   |
+| break               | else   | long     | switch   |
+| case                | enum   | register | typedef  |
+| char                | extern | return   | union    |
+| const               | float  | short    | unsigned |
+| continue            | for    | signed   | void     |
+| default             | goto   | sizeof   | volatile |
+| do                  | if     | static   | while    |
+
+
+
+### 基本输入输出函数
+
+#### 字符输出函数putchar
+
+putchar函数是字符输出函数，其功能是在终端（显示器）输出单个字符。其一般调用形式为： 
+putchar(字符变量); 
+例: 
+
+```c
+`putchar``(‘A’); ``/*输出大写字母A */``putchar``(x);  ``/*输出字符变量x的值*/``putchar``(‘\n’); ``/*换行*/`
+```
+
+#### 字符输入函数getchar
+
+getchar函数的功能是接收用户从键盘上输入的一个字符。其一般调用形式为： 
+getchar(); 
+getchar会以返回值的形式返回接收到的字符.通常的用法如下: 
+
+```c
+`char` `c;  ``/*定义字符变量c*/``c=``getchar``(); ``/*将读取的字符赋值给字符变量c*/`
+```
+
+#### 格式化输出函数printf
+
+printf函数叫做格式输出函数，其功能是按照用户指定的格式，把指定的数据输出到屏幕上
+
+printf函数的格式为: 
+
+printf(“格式控制字符串”,输出表项);   
+
+常用的输出格式及含义如下:
+
+| 格式字符 |                                                    |
+| -------- | -------------------------------------------------- |
+| d , i    | 以十进制形式输出有符号整数(正数不输出符号)         |
+| O        | 以八进制形式输出无符号整数(不输出前缀0)            |
+| x        | 以十六进制形式输出无符号整数(不输出前缀0x)         |
+| U        | 以十进制形式输出无符号整数                         |
+| f        | 以小数形式输出单、双精度类型实数                   |
+| e        | 以指数形式输出单、双精度实数                       |
+| g        | 以%f或%e中较短输出宽度的一种格式输出单、双精度实数 |
+| C        | 输出单个字符                                       |
+| S        | 输出字符串                                         |
+
+#### 格式化输入函数scanf
+
+scanf函数称为格式输入函数，即按照格式字符串的格式，从键盘上把数据输入到指定的变量之中。Scanf函数的调用的一般形式为： 
+scanf(“格式控制字符串”，输入项地址列表); 
+其中，格式控制字符串的作用与printf函数相同，但不能显示非格式字符串，也就是不能显示提示字符串。地址表项中的地址给出各变量的地址，地址是由地址运算符”&”后跟变量名组成的。 
+Scanf 函数中格式字符串的构成与printf函数基本相同，但使用时有几点不同. 
+(1) 格式说明符中，可以指定数据的宽度，但不能指定数据的精度。例： 
+
+```c
+`float` `a；``scanf``(“%10f”，&a);  ``//正确``scanf``(“%10.2f”,&a); ``//错误`
+```
+
+(2) 输入long类型数据时必须使用%ld，输入double数据必须使用%lf或%le。 
+(3) 附加格式说明符”*”使对应的输入数据不赋给相应的变量。 
+
+*修饰符在scanf中()的用法：
+*在scanf()中提供截然不同的服务，当把它放在%和说明符字母之间时，它使函数跳过相应的输入项目。
+
+关于scanf()的返回值
+scanf() 函数返回成功读入的项目的个数。如果它没有读取任何项目(比如它期望接收一个数字而您却输入的一个非数字字符时就会发生这种情况),scanf()返回0。 
+当它检测到“文件末尾”(end of file)时，它返回EOF(EOF在是文件stdio.h中的定义好的一个特殊值，一般，#define指令将EOF的值定义为-1)。
\ No newline at end of file
diff --git "a/java/ReadWriteLock\345\274\225\345\217\221\347\232\204\345\201\207\346\255\273.md" "b/java/ReadWriteLock\345\274\225\345\217\221\347\232\204\345\201\207\346\255\273.md"
new file mode 100644
index 0000000..3356091
--- /dev/null
+++ "b/java/ReadWriteLock\345\274\225\345\217\221\347\232\204\345\201\207\346\255\273.md"
@@ -0,0 +1,42 @@
+## 一个有趣的Java多线程"bug": ReadWriteLock引发的"假死"
+
+### 摘要
+
+在一个Java多线程服务里, 发现有reader和writer线程竞争同一个ReentrantReadWriteLock却双双被卡住. 乍一看, 大概率是因为该服务的多线程实现有bug而导致了死锁. 然而经过排查源码后却没有发现该服务的实现上的问题. 最后发现事故的真相是一场"假死". 而其罪魁祸首是JDK的ReentrantReadWriteLock默认实现里的一个"坑".
+
+### 问题背景及描述
+
+简化一下我们遇到问题: 假设有一个分布式文件系统, 其master节点提供文件系统的元数据(metadata)服务来管理该文件系统中所有的目录和文件. 该文件系统的元数据服务有一个线程池通过RPC来响应不同用户的请求, 并通过为每个目录/文件维护一个ReentrantReadWriteLock(使用默认方式创建)来协同线程保证consistency.
+
+此时我们有三个不同的用户各自通过RPC对master节点发起请求:
+
+1. 客户端A请求对目录"/foo/"下的所有文件以及子目录递归检查和校验. 这个请求会请求"/foo/"对应的读锁, 且当"/foo/"目录下文件过多时耗时会很长;
+2. 客户端B请求删除文件"/foo/bar". 这个请求会竞争目录"/foo/"的写锁(因为"bar"是"/foo/" inode里的一个child);
+3. 客户端C请求列出目录"/foo/"底下的文件. 该请求会竞争"/foo/"的读锁.
+
+问题表现为客户端A运行的时候, B和C均发生了"卡死"而无法继续. 因为A仅仅是要求拿到"/foo/"的读锁, B由于竞争写锁需要等待A完成还可以理解, 但是C在这里也是要求读锁并不能继续, 令人非常疑惑.
+
+### ReentrantReadWriteLock: 皮一下很开心
+
+最后发现B和C对应的服务端读写线程均发生"卡死"其实是ReentrantReadWriteLock在默认的unfair policy下的一个合法行为. 这里我们先解释一下, 什么是ReentrantReadWriteLock的fair以及unfair policy:
+
+- fair policy: 在这种模式下, ReentrantReadWriteLock会尽量按照锁请求的时间顺序来决定锁竞争结果. 这样的用意是在锁竞争激烈的时候, 保证写锁的竞争线程总有机会拿到锁而不是永远被读锁的竞争线程排斥.
+- unfair policy: 在这种模式下, 由一系列的启发函数来决定锁竞争的结果, 而并不是依赖锁请求的顺序. 请注意, 这是ReentrantReadWriteLock默认的模式.
+
+在我们的情况下, ReentrantReadWriteLock已经是使用unfair policy创建了, 但却依然发生请求读锁的客户端C卡死, 这又是为什么呢?
+
+原来在unfair policy的启发函数中有一条规定, 当lock已经被读锁占用, 且锁竞争队列里排第一的是写锁请求的时候, 其他的读锁请求并不能以为是读锁就"插队"抢锁. 这个用意和fair policy一样, 为了防止写锁请求一直不能被轮巡到. 换言之, 所谓的unfair也并非完全效率第一, 而是一定程度上还是在兼顾fairness (参见 [ReadWriteLock: writeLock request blocks future readLock despite policy unfair](https://link.zhihu.com/?target=https%3A//bugs.openjdk.java.net/browse/JDK-6893626))
+
+回到我们的场景: 客户端A成功的使用了读锁霸占住了"/foo/"对应的ReentrantReadWriteLock后并"超长待机"一直霸占, 请求写锁的客户端B排到了队列的头一名, 在unfair policy的作用下, 客户端C无法插队也一直被B的写锁请求抑制. 最后造成的假象就是, 没有线程可以继续工作, 形同"服务器卡死". 但实际上当A在工作了10分钟完成之后, B和C也分别顺利结束.
+
+### 总结
+
+通过对这个问题的排查, 确定了服务的多线程实现并没有问题, 出现的问题是对fairness了解不足. 如果要解决这个问题, 可以考虑以下几种方法:
+
+1. 绕过"lock()"里的启发函数, 转而使用使用"tryLock()"和"while"循环来手动实现一个正真unfair的ReentrantReadWriteLock.
+2. 通过业务逻辑层面的修改防止master的文件系统服务端为了响应一个请求而占用锁时间过长, 哪怕这是读锁.
+3. 转用非JDK实现或者自己实现一个ReentrantReadWriteLock, 可以自定义各种启发函数来平衡线程间的公平和效率.
+
+### 引用
+
+[一个有趣的Java多线程"bug": ReadWriteLock引发的"假死"](https://zhuanlan.zhihu.com/p/34672421)
\ No newline at end of file
diff --git a/java/countdownlatch.md b/java/countdownlatch.md
new file mode 100644
index 0000000..4d61c3d
--- /dev/null
+++ b/java/countdownlatch.md
@@ -0,0 +1,97 @@
+## CountDownLatch
+
+### 解释
+
+`CountDownLatch` 是 `java.util.concurrent`包中的一个工具类，用于线程计数。
+
+它提供了一种同步的功能，允许一个或多个线程等待其他一系列在其他线程的操作完成后，继续执行当前线程。
+
+并且，该对象是不可重用的，对象内存储的状态值一旦被减少为“0”，就无法再次重新设置。
+
+
+
+### 入门demo
+
+```java
+    public static void main(String[] args) throws InterruptedException {
+        int num = 3;	// 创建的线程数量
+        CountDownLatch countDownLatch = new CountDownLatch(num);
+        for (int i = 0; i < num; i++) {
+            new Thread(new Worker(countDownLatch)).start();
+        }
+        countDownLatch.await(); // 等待所有线程执行完毕，再向下执行
+        System.out.println("主线程执行完毕");
+    }
+
+    static class Worker implements Runnable {
+        private CountDownLatch countDownLatch;
+        public Worker(CountDownLatch countDownLatch) {
+            this.countDownLatch = countDownLatch;
+        }
+        @Override
+        public void run() {
+            System.out.println(Thread.currentThread().getName() + "正在执行...");
+            countDownLatch.countDown(); // 通知count执行完毕
+        }
+    }
+```
+
+上面的程序定义了一个`num`变量用于指定`CountDownLatch`的`await()`方法等待的线程数量。
+
+初始化一个`CountDownLatch`对象，并将该对象传入子线程中。子线程中通过调用`CountDownLatch`的`countDown()`方法来通知`CountDownLatch`当前线程执行完毕，由`CountDownLatch`对象进行计数。
+
+主线程通过调用`CountDownLatch`的`await()`方法等待线程计数等于指定的线程数量。当两者相等时，唤醒主线程继续执行。
+
+程序输出如下：
+
+```
+Thread-1正在执行...
+Thread-2正在执行...
+Thread-0正在执行...
+主线程执行完毕
+```
+
+
+
+### 源码解析
+
+#### 原理
+
+`CountDownLatch`通过使用线程锁的方式，对线程进行计数。
+
+#### 内部锁
+
+```java
+private static final class Sync extends AbstractQueuedSynchronizer {}
+```
+
+上述对象是`CountDownLatch`内部的锁实现类。
+
+该类中通过设置父类的`state`状态值变量，并重写`tryAcquireShared`和`tryReleaseShared`对此状态进行修改。`tryAcquireShared`方法通过检查状态值是否为`0`尝试获取共享锁，`tryReleaseShared`释放锁的同时修改状态值，释放成功后对状态值进行`-1`操作。
+
+#### 构造器
+
+```java
+public CountDownLatch(int count) {}
+```
+
+`CountDownLatch`仅提供了上面一个构造器，用于指定监听计数的线程数量。
+
+#### await()
+
+```java
+public void await() throws InterruptedException {}
+public boolean await(long timeout, TimeUnit unit)
+        throws InterruptedException {}
+```
+
+该方法用于获取共享锁，内部通过调用`Sync`对象的`tryAcquireShared`获取锁，但是该方法会检测锁的状态值，只有状态值为`0`，也就是所有的监听线程都执行完毕后，锁才能正常获取到，否则，调用该方法的线程进行阻塞。
+
+#### countDown()
+
+```java
+public void countDown() {}
+```
+
+`countDown()`方法通过释放锁的操作来修改状态值，每调用一次，状态值就减少1，知道状态值减少为`0`时，通知调用`await()`方法的线程再次进行锁获取操作。
+
diff --git "a/java/future\350\216\267\345\217\226\345\274\202\346\255\245\350\256\241\347\256\227\347\273\223\346\236\234.md" "b/java/future\350\216\267\345\217\226\345\274\202\346\255\245\350\256\241\347\256\227\347\273\223\346\236\234.md"
new file mode 100644
index 0000000..4097198
--- /dev/null
+++ "b/java/future\350\216\267\345\217\226\345\274\202\346\255\245\350\256\241\347\256\227\347\273\223\346\236\234.md"
@@ -0,0 +1,239 @@
+## Future
+
+所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在 Java 语言中，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不需要等待计算结果。但调用者仍需要取线程的计算结果。
+
+JDK5新增了Future接口，用于描述一个异步计算的结果。
+
+### Callable、Runnable
+
+`Callable`和`Runnable`都是线程执行接口，两者的区别是：是否可以获取返回值。
+
+`Runnable`接口的定义为：
+
+```java
+public interface Runnable {
+    public abstract void run();
+}
+```
+
+`Callable`接口的定义为：
+
+```java
+public interface Callable<V> {
+    V call() throws Exception;
+}
+```
+
+可以看出Callable存在一个泛型V，并且call()方法返回的就是该泛型类型。
+
+### Future
+
+`Future`对当前执行的线程进行了封装，可以检测当前线程的状态，以及打断线程，获取线程结果等。
+
+`Future`接口的定位为：
+
+```java
+public interface Future<V> {
+    boolean cancel(boolean mayInterruptIfRunning);
+    boolean isCancelled();
+    boolean isDone();
+    V get() throws InterruptedException, ExecutionException;
+    V get(long timeout, TimeUnit unit)
+        throws InterruptedException, ExecutionException, TimeoutException;
+}
+```
+
+调用`get()`方法时，当前线程会被阻塞，知道该`Future`对象的线程执行完毕或被打断时才被唤醒继续执行。
+
+### FutureTask
+
+`FutureTask`是`Future`接口的实现类，同时`FutureTask`实现了`Future`和`Runnable`接口，也就说明`FutureTask`同时拥有了这两个接口的特性，即可以作为线程方法执行， 也可以获取返回结果。
+
+`FutureTask`定义：
+
+```java
+public interface RunnableFuture<V> extends Runnable, Future<V> {
+    void run();
+}
+public class FutureTask<V> implements RunnableFuture<V>{}
+```
+
+`FutureTask`需要接受`Runnable`或`Callable`接口的实现类来操作任务。它提供了一下两种构造器：
+
+```java
+public FutureTask(Callable<V> callable) {
+}
+public FutureTask(Runnable runnable, V result) {
+}
+```
+
+### 使用方式
+
+`Runnable`、`Callable`必须和`ExecuteService`配合使用才能获取到返回结果，而`FutureTask`既可以和`ExecuteService`配合使用，也可以和`Thread`类配合使用，但有一点需要注意，**`FutureTask`对象是无法被重用的**。
+
+### 案例
+
+**MyCallable.java**
+
+```java
+public class MyCallable implements Callable<String> {
+
+    @Override
+    public String call() throws Exception {
+        System.out.println(Thread.currentThread().getName() + "--执行");
+        Thread.sleep(3000);
+        return Thread.currentThread().getName() + "--get string text";
+    }
+}
+```
+
+**CallableMain.java**
+
+```java
+public class CallableMain {
+
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        // 创建线程池
+        ExecutorService executorService = Executors.newCachedThreadPool();
+
+        // 创建callable对象
+        MyCallable task = new MyCallable();
+
+        System.out.println("使用callable + future");
+        Future<String> future = executorService.submit(task);
+        System.out.println(future.get());
+
+        System.out.println();
+        System.out.println("使用callable + futureTask + ThreadPool 执行开始");
+        FutureTask futureTask = new FutureTask<>(task);
+        executorService.submit(futureTask);
+        System.out.println(futureTask.get());
+        System.out.println("使用callable + futureTask + ThreadPool 执行完成");
+
+        System.out.println();
+        System.out.println("使用callable + futureTask + Thread");
+        // 构建一个新的 FutureTask
+        FutureTask futureTask1 = new FutureTask<>(task);
+        Thread thread = new Thread(futureTask1);
+        thread.setName("new Thread");
+        thread.start();
+        System.out.println(futureTask1.get());
+
+        // 销毁线程池
+        executorService.shutdown();
+    }
+
+}
+```
+
+**结果输出**
+
+```
+使用callable + future
+pool-1-thread-1--执行
+pool-1-thread-1--get string text
+
+使用callable + futureTask + ThreadPool 执行开始
+pool-1-thread-1--执行
+pool-1-thread-1--get string text
+使用callable + futureTask + ThreadPool 执行完成
+
+使用callable + futureTask + Thread
+new Thread--执行
+new Thread--get string text
+```
+
+
+
+## CompletableFuture
+
+虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果。
+
+在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。
+
+它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作。
+
+### Future 接口的局限性
+
+Future接口可以构建异步应用，但依然有其局限性。它很难直接表述多个Future 结果之间的依赖性。实际开发中，我们经常需要达成以下目的：
+
+1. 将多个异步计算的结果合并成一个
+2. 等待Future集合中的所有任务都完成
+3. Future完成事件（即，任务完成以后触发执行动作）
+4. 。。。
+
+### CompletionStage
+
+- CompletionStage代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段
+- 一个阶段的计算执行可以是一个Function，Consumer或者Runnable。比如：stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println())
+- 一个阶段的执行可能是被单个阶段的完成触发，也可能是由多个阶段一起触发
+
+### 函数
+
+`Async`后缀存在的区别在于，如果调用`Async`结尾的方法，则会将当前函数放入线程池内执行，否则使用当前任务的线程继续执行。
+
+函数共分为如下几类：
+
+1. `CompletableFuture`对象创建函数
+2. 数据处理函数，无返回，仅对传入的数据进行处理(值拷贝，非指针传递，修改该值并不会影响下面的操作)
+3. 数据处理函数，有返回，且返回类型不限制
+4. 多个`CompletionStage`交叉函数
+5. `Future`固定的方法
+
+| 函数名                                        | 解释                                                         |
+| --------------------------------------------- | ------------------------------------------------------------ |
+| static CompletableFuture\<Void> runAsync      | 无返回创建CompletableFuture对象，可接收线程池                |
+| static \<U> CompletableFuture\<U> supplyAsync | 有返回创建CompletableFuture对象，可接收线程池                |
+| whenComplete                                  | 当CompletableFuture的计算结果完成，执行特定的Action。        |
+| exceptionally                                 | 当CompletableFuture抛出异常的时，执行特定的Action。          |
+| thenApply                                     | 当一个线程依赖另一个线程时，可以使用 thenApply 方法来把这两个线程串行化。 |
+| handle                                        | handle 是执行任务完成时对结果的处理。handle 方法和 thenApply 方法处理方式基本一样。不同的是 handle 是在任务完成后再执行，还可以处理异常的任务。thenApply 只可以执行正常的任务，任务出现异常则不执行 thenApply 方法。 |
+| thenAccept                                    | 接收任务的处理结果，并消费处理，无返回结果。                 |
+| thenRun                                       | 跟 thenAccept 方法不一样的是，不关心任务的处理结果。只要上面的任务执行完成，就开始执行 thenRun。 |
+| thenCombine                                   | thenCombine 会把 两个 CompletionStage 的任务都执行完成后，把两个任务的结果一块交给 thenCombine 来处理。 |
+| thenAcceptBoth                                | 当两个CompletionStage都执行完成后，把结果一块交给thenAcceptBoth来进行消耗 |
+| applyToEither                                 | 两个CompletionStage，使用最先执行完成的CompletionStage的结果进行下一步的转化操作。 |
+| acceptEither                                  | 两个CompletionStage，使用最先执行完成的CompletionStage的结果进行下一步的消费操作。 |
+| runAfterEither                                | 两个CompletionStage，任何一个完成了都会执行下一步的操作（Runnable） |
+| runAfterBoth                                  | 两个CompletionStage，都完成了计算才会执行下一步的操作（Runnable） |
+| thenCompose                                   | thenCompose 方法允许你对两个 CompletionStage 进行流水线操作，第一个操作完成时，将其结果作为参数传递给第二个操作。 |
+
+### 案例
+
+```java
+public class CompletableFutureMain {
+
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        CompletableFuture<Integer> future1 = CompletableFuture
+                // 创建对象
+                .supplyAsync(() -> new Random().nextInt(10))
+                // 接受上一步的参数并处理
+                .thenApply(integer -> integer + ":2")
+                // 接受上一步的参数并处理，同时可以处理异常
+                .handle((str, ex) -> Integer.parseInt(str.split(":")[1]));
+
+        CompletableFuture<Integer> future2 = CompletableFuture
+                .supplyAsync(() -> new Random().nextInt(20))
+                // 上一步处理完成对参数进行处理
+                .whenComplete((integer, throwable) -> {
+                    // 这里的处理并不会影响下面的处理
+                    if (throwable == null) {
+                        integer = 0;
+                    }
+                })
+                // 上一步执行完成执行下一步
+                .thenApply(integer -> integer += 50)
+                // 合并两个future
+                .thenCombine(future1, (i1, i2) -> {
+                    System.out.println(i1);
+                    System.out.println(i2);
+                    return i1 + i2;
+                });
+
+        System.out.println("程序最终结果：" + future2.get());
+
+    }
+
+}
+```
+
diff --git "a/java/html\345\205\203\347\264\240\350\247\243\346\236\220\345\267\245\345\205\267jsoup.md" "b/java/html\345\205\203\347\264\240\350\247\243\346\236\220\345\267\245\345\205\267jsoup.md"
new file mode 100644
index 0000000..5a80ffb
--- /dev/null
+++ "b/java/html\345\205\203\347\264\240\350\247\243\346\236\220\345\267\245\345\205\267jsoup.md"
@@ -0,0 +1,501 @@
+# Jsoup 简介
+
+ jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。
+
+## 输入
+
+### 解析一个html字符串
+
+#### 存在问题
+
+来自用户输入，一个文件或一个网站的HTML字符串，你可能需要对它进行解析并取其内容，或校验其格式是否完整，或想修改它。怎么办？jsonu能够帮你轻松解决这些问题
+
+#### 解决方法
+
+使用静态`Jsoup.parse(String html)` 方法或 `Jsoup.parse(String html, String baseUri)`示例代码：
+
+```java
+String html = "<html><head><title>First parse</title></head>"
+  + "<body><p>Parsed HTML into a doc.</p></body></html>";
+Document doc = Jsoup.parse(html);
+```
+
+#### 描述
+
+`parse(String html, String baseUri)` 这方法能够将输入的HTML解析为一个新的文档 (Document），参数 baseUri 是用来将相对 URL 转成绝对URL，并指定从哪个网站获取文档。如这个方法不适用，你可以使用 `parse(String html)` 方法来解析成HTML字符串如上面的示例。.
+
+只要解析的不是空字符串，就能返回一个结构合理的文档，其中包含(至少) 一个head和一个body元素。
+
+一旦拥有了一个Document，你就可以使用Document中适当的方法或它父类 `Element`和`Node`中的方法来取得相关数据。
+
+
+
+### 解析一个body片段
+
+#### 问题
+
+假如你有一个HTML片断 (比如. 一个 `div` 包含一对 `p` 标签; 一个不完整的HTML文档) 想对它进行解析。这个HTML片断可以是用户提交的一条评论或在一个CMS页面中编辑body部分。
+
+#### 办法
+
+使用`Jsoup.parseBodyFragment(String html)`方法.
+
+```
+String html = "<div><p>Lorem ipsum.</p>";
+Document doc = Jsoup.parseBodyFragment(html);
+Element body = doc.body();
+```
+
+#### 说明
+
+`parseBodyFragment` 方法创建一个空壳的文档，并插入解析过的HTML到`body`元素中。假如你使用正常的 `Jsoup.parse(String html)` 方法，通常你也可以得到相同的结果，但是明确将用户输入作为 body片段处理，以确保用户所提供的任何糟糕的HTML都将被解析成body元素。
+
+`Document.body()` 方法能够取得文档body元素的所有子元素，与 `doc.getElementsByTag("body")`相同。
+
+#### 保证安全Stay safe
+
+假如你可以让用户输入HTML内容，那么要小心避免跨站脚本攻击。利用基于 `Whitelist` 的清除器和 `clean(String bodyHtml, Whitelist whitelist)`方法来清除用户输入的恶意内容。
+
+
+
+### 从一个URL加载一个Document
+
+#### 存在问题
+
+你需要从一个网站获取和解析一个HTML文档，并查找其中的相关数据。你可以使用下面解决方法：
+
+#### 解决方法
+
+使用 `Jsoup.connect(String url)`方法:
+
+```java
+Document doc = Jsoup.connect("http://example.com/").get();
+String title = doc.title();
+```
+
+#### 说明
+
+`connect(String url)` 方法创建一个新的 `Connection`, 和 `get()` 取得和解析一个HTML文件。如果从该URL获取HTML时发生错误，便会抛出 IOException，应适当处理。
+
+`Connection` 接口还提供一个方法链来解决特殊请求，具体如下：
+
+```java
+Document doc = Jsoup.connect("http://example.com")
+  .data("query", "Java")
+  .userAgent("Mozilla")
+  .cookie("auth", "token")
+  .timeout(3000)
+  .post();
+```
+
+这个方法只支持Web URLs (`http`和`https` 协议); 假如你需要从一个文件加载，可以使用 `parse(File in, String charsetName)` 代替。
+
+
+
+### 从一个文件加载一个文档
+
+#### 问题
+
+在本机硬盘上有一个HTML文件，需要对它进行解析从中抽取数据或进行修改。
+
+#### 办法
+
+可以使用静态 `Jsoup.parse(File in, String charsetName, String baseUri)` 方法：
+
+```
+File input = new File("/tmp/input.html");
+Document doc = Jsoup.parse(input, "UTF-8", "http://example.com/");
+```
+
+#### 说明
+
+`parse(File in, String charsetName, String baseUri)` 这个方法用来加载和解析一个HTML文件。如在加载文件的时候发生错误，将抛出IOException，应作适当处理。
+
+`baseUri` 参数用于解决文件中URLs是相对路径的问题。如果不需要可以传入一个空的字符串。
+
+另外还有一个方法`parse(File in, String charsetName)` ，它使用文件的路径做为 `baseUri`。 这个方法适用于如果被解析文件位于网站的本地文件系统，且相关链接也指向该文件系统。
+
+
+
+## 数据抽取
+
+### 使用DOM方法来遍历一个文档
+
+#### 问题
+
+你有一个HTML文档要从中提取数据，并了解这个HTML文档的结构。
+
+#### 方法
+
+将HTML解析成一个`Document`之后，就可以使用类似于DOM的方法进行操作。示例代码：
+
+```java
+File input = new File("/tmp/input.html");
+Document doc = Jsoup.parse(input, "UTF-8", "http://example.com/");
+
+Element content = doc.getElementById("content");
+Elements links = content.getElementsByTag("a");
+for (Element link : links) {
+  String linkHref = link.attr("href");
+  String linkText = link.text();
+}
+```
+
+#### 说明
+
+Elements这个对象提供了一系列类似于DOM的方法来查找元素，抽取并处理其中的数据。具体如下：
+
+#### 查找元素
+
+- `getElementById(String id)`
+- `getElementsByTag(String tag)`
+- `getElementsByClass(String className)`
+- `getElementsByAttribute(String key)` (and related methods)
+- Element siblings: `siblingElements()`, `firstElementSibling()`, `lastElementSibling()`;`nextElementSibling()`, `previousElementSibling()`
+- Graph: `parent()`, `children()`, `child(int index)`
+
+#### 元素数据
+
+- `attr(String key)`获取属性`attr(String key, String value)`设置属性
+- `attributes()`获取所有属性
+- `id()`, `className()` and `classNames()`
+- `text()`获取文本内容`text(String value)` 设置文本内容
+- `html()`获取元素内HTML`html(String value)`设置元素内的HTML内容
+- `outerHtml()`获取元素外HTML内容
+- `data()`获取数据内容（例如：script和style标签)
+- `tag()` and `tagName()`
+
+#### 操作HTML和文本
+
+- `append(String html)`, `prepend(String html)`
+- `appendText(String text)`, `prependText(String text)`
+- `appendElement(String tagName)`, `prependElement(String tagName)`
+- `html(String value)`
+
+
+
+### 使用选择器语法来查找元素
+
+#### 问题
+
+你想使用类似于CSS或jQuery的语法来查找和操作元素。
+
+#### 方法
+
+可以使用`Element.select(String selector)` 和 `Elements.select(String selector)` 方法实现：
+
+```java
+File input = new File("/tmp/input.html");
+Document doc = Jsoup.parse(input, "UTF-8", "http://example.com/");
+
+Elements links = doc.select("a[href]"); //带有href属性的a元素
+Elements pngs = doc.select("img[src$=.png]"); //扩展名为.png的图片
+
+Element masthead = doc.select("div.masthead").first(); //class等于masthead的div标签
+
+Elements resultLinks = doc.select("h3.r > a"); //在h3元素之后的a元素
+```
+
+#### 说明
+
+jsoup elements对象支持类似于[CSS](http://www.w3.org/TR/2009/PR-css3-selectors-20091215/) (或[jquery](http://jquery.com/))的选择器语法，来实现非常强大和灵活的查找功能。.
+
+这个`select` 方法在`Document`, `Element`,或`Elements`对象中都可以使用。且是上下文相关的，因此可实现指定元素的过滤，或者链式选择访问。
+
+Select方法将返回一个`Elements`集合，并提供一组方法来抽取和处理结果。
+
+#### Selector选择器概述
+
+- `tagname`: 通过标签查找元素，比如：`a`
+- `ns|tag`: 通过标签在命名空间查找元素，比如：可以用 `fb|name` 语法来查找 `<fb:name>` 元素
+- `#id`: 通过ID查找元素，比如：`#logo`
+- `.class`: 通过class名称查找元素，比如：`.masthead`
+- `[attribute]`: 利用属性查找元素，比如：`[href]`
+- `[^attr]`: 利用属性名前缀来查找元素，比如：可以用`[^data-]` 来查找带有HTML5 Dataset属性的元素
+- `[attr=value]`: 利用属性值来查找元素，比如：`[width=500]`
+- `[attr^=value]`, `[attr$=value]`, `[attr*=value]`: 利用匹配属性值开头、结尾或包含属性值来查找元素，比如：`[href*=/path/]`
+- `[attr~=regex]`: 利用属性值匹配正则表达式来查找元素，比如： `img[src~=(?i)\.(png|jpe?g)]`
+- `*`: 这个符号将匹配所有元素
+
+#### Selector选择器组合使用
+
+- `el#id`: 元素+ID，比如： `div#logo`
+- `el.class`: 元素+class，比如： `div.masthead`
+- `el[attr]`: 元素+class，比如： `a[href]`
+- 任意组合，比如：`a[href].highlight`
+- `ancestor child`: 查找某个元素下子元素，比如：可以用`.body p` 查找在"body"元素下的所有 `p`元素
+- `parent > child`: 查找某个父元素下的直接子元素，比如：可以用`div.content > p` 查找 `p` 元素，也可以用`body > *` 查找body标签下所有直接子元素
+- `siblingA + siblingB`: 查找在A元素之前第一个同级元素B，比如：`div.head + div`
+- `siblingA ~ siblingX`: 查找A元素之前的同级X元素，比如：`h1 ~ p`
+- `el, el, el`:多个选择器组合，查找匹配任一选择器的唯一元素，例如：`div.masthead, div.logo`
+
+#### 伪选择器selectors
+
+- `:lt(n)`: 查找哪些元素的同级索引值（它的位置在DOM树中是相对于它的父节点）小于n，比如：`td:lt(3)` 表示小于三列的元素
+- `:gt(n)`:查找哪些元素的同级索引值大于`n``，比如`： `div p:gt(2)`表示哪些div中有包含2个以上的p元素
+- `:eq(n)`: 查找哪些元素的同级索引值与`n`相等，比如：`form input:eq(1)`表示包含一个input标签的Form元素
+- `:has(seletor)`: 查找匹配选择器包含元素的元素，比如：`div:has(p)`表示哪些div包含了p元素
+- `:not(selector)`: 查找与选择器不匹配的元素，比如： `div:not(.logo)` 表示不包含 class=logo 元素的所有 div 列表
+- `:contains(text)`: 查找包含给定文本的元素，搜索不区分大不写，比如： `p:contains(jsoup)`
+- `:containsOwn(text)`: 查找直接包含给定文本的元素
+- `:matches(regex)`: 查找哪些元素的文本匹配指定的正则表达式，比如：`div:matches((?i)login)`
+- `:matchesOwn(regex)`: 查找自身包含文本匹配指定正则表达式的元素
+- 注意：上述伪选择器索引是从0开始的，也就是说第一个元素索引值为0，第二个元素index为1等
+
+可以查看`Selector` API参考来了解更详细的内容
+
+
+
+### 从元素抽取属性，文本和HTML
+
+#### 问题
+
+在解析获得一个Document实例对象，并查找到一些元素之后，你希望取得在这些元素中的数据。
+
+#### 方法
+
+- 要取得一个属性的值，可以使用`Node.attr(String key)` 方法
+- 对于一个元素中的文本，可以使用`Element.text()`方法
+- 对于要取得元素或属性中的HTML内容，可以使用`Element.html()`, 或 `Node.outerHtml()`方法
+
+#### 示例：
+
+```java
+String html = "<p>An <a href='http://example.com/'><b>example</b></a> link.</p>";
+Document doc = Jsoup.parse(html);//解析HTML字符串返回一个Document实现
+Element link = doc.select("a").first();//查找第一个a元素
+
+String text = doc.body().text(); // "An example link"//取得字符串中的文本
+String linkHref = link.attr("href"); // "http://example.com/"//取得链接地址
+String linkText = link.text(); // "example""//取得链接地址中的文本
+
+String linkOuterH = link.outerHtml(); 
+    // "<a href="http://example.com"><b>example</b></a>"
+String linkInnerH = link.html(); // "<b>example</b>"//取得链接内的html内容
+```
+
+#### 说明
+
+上述方法是元素数据访问的核心办法。此外还其它一些方法可以使用：
+
+- `Element.id()`
+- `Element.tagName()`
+- `Element.className()` and `Element.hasClass(String className)`
+
+这些访问器方法都有相应的setter方法来更改数据.
+
+### 处理URLs
+
+#### 问题
+
+你有一个包含相对URLs路径的HTML文档，需要将这些相对路径转换成绝对路径的URLs。
+
+#### 方法
+
+1. 在你解析文档时确保有指定`base URI`，然后
+2. 使用 `abs:` 属性前缀来取得包含`base URI`的绝对路径。代码如下： 
+
+```
+Document doc = Jsoup.connect("http://www.open-open.com").get();
+
+Element link = doc.select("a").first();
+String relHref = link.attr("href"); // == "/"
+String absHref = link.attr("abs:href"); // "http://www.open-open.com/"
+```
+
+#### 说明
+
+在HTML元素中，URLs经常写成相对于文档位置的相对路径： `<a href="/download">...</a>`. 当你使用 `Node.attr(String key)` 方法来取得a元素的href属性时，它将直接返回在HTML源码中指定定的值。
+
+假如你需要取得一个绝对路径，需要在属性名前加 `abs:` 前缀。这样就可以返回包含根路径的URL地址`attr("abs:href")`
+
+因此，在解析HTML文档时，定义base URI非常重要。
+
+如果你不想使用`abs:` 前缀，还有一个方法能够实现同样的功能 `Node.absUrl(String key)`。
+
+
+
+## 数据修改
+
+### 设置属性的值
+
+#### 问题
+
+在你解析一个Document之后可能想修改其中的某些属性值，然后再保存到磁盘或都输出到前台页面。
+
+#### 方法
+
+可以使用属性设置方法 `Element.attr(String key, String value)`, 和 `Elements.attr(String key, String value)`.
+
+假如你需要修改一个元素的 `class` 属性，可以使用 `Element.addClass(String className)` 和 `Element.removeClass(String className)` 方法。
+
+`Elements` 提供了批量操作元素属性和class的方法，比如：要为div中的每一个a元素都添加一个`rel="nofollow"` 可以使用如下方法：
+
+```java
+doc.select("div.comments a").attr("rel", "nofollow");
+```
+
+#### 说明
+
+与`Element`中的其它方法一样，`attr` 方法也是返回当 `Element` (或在使用选择器是返回 `Elements` 集合)。这样能够很方便使用方法连用的书写方式。比如：
+
+```java
+doc.select("div.masthead").attr("title", "jsoup").addClass("round-box");
+```
+
+### 设置一个元素的HTML内容
+
+#### 问题
+
+你需要一个元素中的HTML内容
+
+#### 方法
+
+可以使用`Element`中的HTML设置方法具体如下：
+
+```java
+Element div = doc.select("div").first(); // <div></div>
+div.html("<p>lorem ipsum</p>"); // <div><p>lorem ipsum</p></div>
+div.prepend("<p>First</p>");//在div前添加html内容
+div.append("<p>Last</p>");//在div之后添加html内容
+// 添完后的结果: <div><p>First</p><p>lorem ipsum</p><p>Last</p></div>
+
+Element span = doc.select("span").first(); // <span>One</span>
+span.wrap("<li><a href='http://example.com/'></a></li>");
+// 添完后的结果: <li><a href="http://example.com"><span>One</span></a></li>
+```
+
+#### 说明
+
+- `Element.html(String html)` 这个方法将先清除元素中的HTML内容，然后用传入的HTML代替。
+- `Element.prepend(String first)` 和 `Element.append(String last)` 方法用于在分别在元素内部HTML的前面和后面添加HTML内容
+- `Element.wrap(String around)` 对元素包裹一个外部HTML内容。
+
+### 设置元素的文本内容
+
+#### 问题
+
+你需要修改一个HTML文档中的文本内容
+
+#### 方法
+
+可以使用`Element`的设置方法：:
+
+```java
+Element div = doc.select("div").first(); // <div></div>
+div.text("five > four"); // <div>five &gt; four</div>
+div.prepend("First ");
+div.append(" Last");
+// now: <div>First five &gt; four Last</div>
+```
+
+#### 说明
+
+文本设置方法与设置元素的html方法一样：
+
+- `Element.text(String text)` 将清除一个元素中的内部HTML内容，然后提供的文本进行代替
+- `Element.prepend(String first)` 和 `Element.append(String last)` 将分别在元素的内部html前后添加文本节点。
+
+对于传入的文本如果含有像 `<`, `>` 等这样的字符，将以文本处理，而非HTML。
+
+
+
+## HTML 清理
+
+### 消除不受信任的HTML (来防止XSS攻击)
+
+#### 问题
+
+在做网站的时候，经常会提供用户评论的功能。有些不怀好意的用户，会搞一些脚本到评论内容中，而这些脚本可能会破坏整个页面的行为，更严重的是获取一些机要信息，此时需要清理该HTML，以避免跨站脚本[cross-site scripting](http://en.wikipedia.org/wiki/Cross-site_scripting)攻击（XSS）。
+
+#### 方法
+
+使用jsoup HTML `Cleaner` 方法进行清除，但需要指定一个可配置的 `Whitelist`。
+
+```java
+String unsafe = 
+  "<p><a href='http://example.com/' onclick='stealCookies()'>Link</a></p>";
+String safe = Jsoup.clean(unsafe, Whitelist.basic());
+// now: <p><a href="http://example.com/" rel="nofollow">Link</a></p>
+```
+
+#### 说明
+
+XSS又叫CSS (Cross Site Script) ，跨站脚本攻击。它指的是恶意攻击者往Web页面里插入恶意html代码，当用户浏览该页之时，嵌入其中Web里面的html代码会被执行，从而达到恶意攻击用户的特殊目的。XSS属于被动式的攻击，因为其被动且不好利用，所以许多人常忽略其危害性。所以我们经常只让用户输入纯文本的内容，但这样用户体验就比较差了。
+
+一个更好的解决方法就是使用一个富文本编辑器WYSIWYG如[CKEditor](http://ckeditor.com/) 和 [TinyMCE](http://tinymce.moxiecode.com/)。这些可以输出HTML并能够让用户可视化编辑。虽然他们可以在客户端进行校验，但是这样还不够安全，需要在服务器端进行校验并清除有害的HTML代码，这样才能确保输入到你网站的HTML是安全的。否则，攻击者能够绕过客户端的Javascript验证，并注入不安全的HMTL直接进入您的网站。
+
+jsoup的whitelist清理器能够在服务器端对用户输入的HTML进行过滤，只输出一些安全的标签和属性。
+
+jsoup提供了一系列的`Whitelist`基本配置，能够满足大多数要求；但如有必要，也可以进行修改，不过要小心。
+
+这个cleaner非常好用不仅可以避免XSS攻击，还可以限制用户可以输入的标签范围。
+
+
+
+## 程序实例：获取所有链接
+
+```java
+package org.jsoup.examples;
+
+import org.jsoup.Jsoup;
+import org.jsoup.helper.Validate;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+
+import java.io.IOException;
+
+/**
+ * Example program to list links from a URL.
+ */
+public class ListLinks {
+    public static void main(String[] args) throws IOException {
+        Validate.isTrue(args.length == 1, "usage: supply url to fetch");
+        String url = args[0];
+        print("Fetching %s...", url);
+
+        Document doc = Jsoup.connect(url).get();
+        Elements links = doc.select("a[href]");
+        Elements media = doc.select("[src]");
+        Elements imports = doc.select("link[href]");
+
+        print("\nMedia: (%d)", media.size());
+        for (Element src : media) {
+            if (src.tagName().equals("img"))
+                print(" * %s: <%s> %sx%s (%s)",
+                        src.tagName(), src.attr("abs:src"), src.attr("width"), src.attr("height"),
+                        trim(src.attr("alt"), 20));
+            else
+                print(" * %s: <%s>", src.tagName(), src.attr("abs:src"));
+        }
+
+        print("\nImports: (%d)", imports.size());
+        for (Element link : imports) {
+            print(" * %s <%s> (%s)", link.tagName(),link.attr("abs:href"), link.attr("rel"));
+        }
+
+        print("\nLinks: (%d)", links.size());
+        for (Element link : links) {
+            print(" * a: <%s>  (%s)", link.attr("abs:href"), trim(link.text(), 35));
+        }
+    }
+
+    private static void print(String msg, Object... args) {
+        System.out.println(String.format(msg, args));
+    }
+
+    private static String trim(String s, int width) {
+        if (s.length() > width)
+            return s.substring(0, width-1) + ".";
+        else
+            return s;
+    }
+}
+```
+
+
+
+## 引用
+
+[jsonp入门教程](https://www.open-open.com/jsoup/parsing-a-document.htm)
\ No newline at end of file
diff --git a/java/httpclient.md b/java/httpclient.md
new file mode 100644
index 0000000..b9cef6b
--- /dev/null
+++ b/java/httpclient.md
@@ -0,0 +1,130 @@
+## 引入pom
+
+```xml
+<dependency>
+    <groupId>org.apache.httpcomponents</groupId>
+    <artifactId>httpclient</artifactId>
+    <version>4.2</version>
+</dependency>
+```
+
+## 编写HttpClient发送请求的步骤
+
+1. 创建HttpClient对象
+2. 创建Http[HttpMethod]具体发送http方式对象
+3. 设置http方法对象
+4. 使用HttpClient执行http方法对象
+5. 接受HttpClient方法返回值
+
+## 案例
+
+### 处理url
+
+```java
+    /**
+     * 构造请求 url
+     * @param url 源url 
+     * @param param 键值对参数
+     * @return 带参数的url
+     */
+    private static String buildUrl(String url, Map<String, String> param) {
+        if (url == null || "".equals(url = url.trim())) {
+            throw new IllegalArgumentException("Http request url must not null");
+        }
+        StringBuilder requestUrl = new StringBuilder(url);
+        if (param != null && param.size() > 0) {
+            boolean first = true;
+            for (Map.Entry<String, String> entry : param.entrySet()) {
+                if (first) {
+                    // 不存在 ? 添加一个
+                    if (!url.contains("?")) {
+                        requestUrl.append("?");
+                    }
+                    if (url.contains("&") && url.indexOf("&") < url.length() - 1) {
+                        requestUrl.append("&");
+                    }
+                    first = !first;
+                } else {
+                    requestUrl.append("&");
+                }
+                requestUrl.append(entry.getKey()).append("=").append(entry.getValue());
+            }
+        }
+        return requestUrl.toString();
+    }
+```
+
+### get 请求
+
+```java
+    /**
+     * 发送get请求
+     * @param url 请求地址
+     * @param headers 头部信息
+     * @param params 请求参数
+     * @return 返回值
+     */
+    public static String get(String url, Map<String, String> headers, Map<String, String> params) {
+        String result = null;
+        // http 客户端
+        HttpClient httpClient = new DefaultHttpClient();
+        try {
+            // 执行get请求
+            HttpGet httpGet = new HttpGet(buildUrl(url, params));
+            if (headers != null && headers.size() > 0) {
+                headers.forEach(httpGet::setHeader);
+            }
+            HttpResponse response = httpClient.execute(httpGet);
+            HttpEntity httpEntity = response.getEntity();
+            if (httpEntity != null) {
+                result = EntityUtils.toString(httpEntity);
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        } finally {
+            httpClient.getConnectionManager().shutdown();
+        }
+        return result;
+    }
+```
+
+### post 请求
+
+```java
+    /**
+     * 发送get请求
+     * @param url 请求地址
+     * @param headers 头部信息
+     * @param params 请求参数 (普通的键值对参数)
+     * @param body 内容体，可以是任何字符串形式
+     * @return 返回值
+     */
+    public static String post(String url, Map<String, String> headers, Map<String, String> params, String body) {
+        String result = null;
+        // http 客户端
+        HttpClient httpClient = new DefaultHttpClient();
+        try {
+            HttpPost httpPost = new HttpPost(buildUrl(url, params));
+            if (headers != null && headers.size() > 0) {
+                headers.forEach(httpPost::setHeader);
+            }
+            if (body != null && !"".equals(body.trim())) {
+                HttpEntity httpEntity = new StringEntity(body, Charset.forName("UTF-8"));
+                httpPost.setEntity(httpEntity);
+            }
+
+            HttpResponse response = httpClient.execute(httpPost);
+            HttpEntity httpEntity = response.getEntity();
+            if (httpEntity != null) {
+                result = EntityUtils.toString(httpEntity);
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        } finally {
+            httpClient.getConnectionManager().shutdown();
+        }
+
+        return result;
+    }
+```
+
diff --git a/java/images/001/001.png b/java/images/001/001.png
new file mode 100644
index 0000000..ee0105a
Binary files /dev/null and b/java/images/001/001.png differ
diff --git "a/java/images/002/java\351\233\206\345\220\210\346\241\206\346\236\266.jpg" "b/java/images/002/java\351\233\206\345\220\210\346\241\206\346\236\266.jpg"
new file mode 100644
index 0000000..5ca9e6f
Binary files /dev/null and "b/java/images/002/java\351\233\206\345\220\210\346\241\206\346\236\266.jpg" differ
diff --git a/java/images/003/1570773224689.png b/java/images/003/1570773224689.png
new file mode 100644
index 0000000..36b0820
Binary files /dev/null and b/java/images/003/1570773224689.png differ
diff --git a/java/java_persistence_api.md b/java/java_persistence_api.md
new file mode 100644
index 0000000..118ef96
--- /dev/null
+++ b/java/java_persistence_api.md
@@ -0,0 +1,599 @@
+## Entities
+
+**标准的实体类的要求**
+
+* 必须被 `javax.persistence.Entity`注解修饰
+* 实体类必须是 `public`或者`protect` 的， 必须得有一个无参的构造器，当然，它可以有其他的构造器。
+* 必须不能为`final`修饰，没有方法或实体常量必须被声明为`final`.
+* 如果实体需要被远程调用或传输，必须实现`Serializable`接口。
+* 实体类可以扩展非实体类和实体类。非实体类可以扩展实体类。
+* 实体的属性必须被声明为`private`、`protect`或`package-privare`，并且只能通过实体类的方法访问。客户端必须通过访问者或业务方法访问实体的状态。 
+
+**实体持久化字段和属性的类型**
+
+- Java 基本数据类型
+- `java.lang.String`
+- 其他可被序列化的类：
+  - Java 基本数据类型的包装类
+  - `java.math.BigInteger`
+  - `java.math.BigDecimal`
+  - `java.util.Date`
+  - `java.util.Calendar`
+  - `java.sql.Date`
+  - `java.sql.Time`
+  - `java.sql.TimeStamp`
+  - 用户定义的可序列化的类型
+  - `byte[]`
+  - `Byte[]`
+  - `char[]`
+  - `Character[]`
+- 枚举类型
+- 其他实体和/或实体的集合
+- 内部类
+
+**持久化字段**
+
+如果一个字段没有注解`javax.persitence.Transient`或者没有被标注为`transient`,那么这个字段将会被持久化到数据库。
+
+**实体中的主键**
+
+每个实体都有一个唯一的对象标识。
+
+简单的主键可以使用`javax.persitence.Id`注解来表明这个字段是一个主键。
+
+复合主键必须对应于单个持久属性或字段，或者对应于一组单个持久性属性或字段。必须在主键类中定义组合主键 。复合主键可以使用`javax.persistence.EmbeddedId`和`javax.persistence.IdClass`注解来表明。 
+
+复合主键的类型必须是下面的几种类型
+
+* java 基本数据类型
+* java 基本数据类型的包装类
+* `java.lang.String`
+* `java.util.Date`
+* `java.sql.Date`
+
+主键必须是一个整形，而不能是浮点型。
+
+**主键类的要求**
+
+* 访问修饰符必须是`public`
+* 如果使用基于属性的访问，则主键类的属性必须是`public`或`protect`的。
+* 必须可以被序列化（实现`Serializable`接口）
+*  必须表示复合主键并将其映射到实体类的多个字段或属性，或者必须将其表示并映射为可嵌入类。 
+* 如果类映射到实体类的多个字段或属性，则主键类中主键字段或属性的名称和类型必须与实体类的名称和类型匹配。 
+
+```java
+public final class LineItemKey implements Serializable {
+    public Integer orderId;
+    public int itemId;
+
+    public LineItemKey() {}
+
+    public LineItemKey(Integer orderId, int itemId) {
+        this.orderId = orderId;
+        this.itemId = itemId;
+    }
+
+    public boolean equals(Object otherOb) {
+        if (this == otherOb) {
+            return true;
+        }
+        if (!(otherOb instanceof LineItemKey)) {
+            return false;
+        }
+        LineItemKey other = (LineItemKey) otherOb;
+        return (
+                    (orderId==null?other.orderId==null:orderId.equals
+                    (other.orderId)
+                    )
+                    &&
+                    (itemId == other.itemId)
+                );
+    }
+
+    public int hashCode() {
+        return (
+                    (orderId==null?0:orderId.hashCode())
+                    ^
+                    ((int) itemId)
+                );
+    }
+
+    public String toString() {
+        return "" + orderId + "-" + itemId;
+    }
+}
+```
+
+**实体之间的关系**
+
+* One-to-one：一对一的关系使用`javax.persistence.OneToOne`注解来声明持久化字段或属性
+* One-to-many：一对多的关系使用`javax.persistence.OneToMany`来声明持久化字段或属性
+* Many-to-one：多对一的关系使用`javax.persistence.ManyToOne`来声明持久化字段或属性
+* Many-to-many：多对多的关系使用`javax.persistence.ManyToMany`来声明持久化字段或属性
+
+**实体关系之间的方向**
+
+实体之间的关系可以是双向的，也可以是单向的。
+
+**双向关系**
+
+在一个双向关系中，每一个实体都有一个字段来映射其他的实体。
+
+双向关联的关系必须有如下规则：
+
+* 双向关系的反面必须通过使用`@OneToOne`，`@ OneToMany`或`@ManyToMany`注释的`mappedBy`元素来引用其拥有方。 `mappedBy`元素指定作为关系所有者的实体中的属性或字段。 
+* 多对一的关系中，多的一次不能使用`mappedBy`。因为多的一方始终是关系的拥有方。
+* 对于一对一的双向关系，拥有方对应于包含相应外键的一侧。
+* 对于多对多双向关系，任何一方都可能是拥有方。 
+
+**级联删除关系**
+
+使用关系的实体通常依赖于关系中另一个实体的存在， 如果一方删除，也另一方也应该删除，这种方式叫做"级联删除"。
+
+使用`@OneToOne`和`@OneToMany`关系的`cascade = REMOVE`元素规范指定级联删除关系 
+
+```java
+@OneToMany(cascade=REMOVE, mappedBy="customer")
+public Set<Order> getOrders() { return orders; }
+```
+
+**抽象实体**
+
+```java
+@Entity
+public abstract class Employee {
+    @Id
+    protected Integer employeeId;
+    ...
+}
+@Entity
+public class FullTimeEmployee extends Employee {
+    protected Integer salary;
+    ...
+}
+@Entity
+public class PartTimeEmployee extends Employee {
+    protected Float hourlyWage;
+}
+```
+
+**映射超类**
+
+通过使用`javax.persistence.MappedSuperclass`注解对类进行装饰来指定映射的超类。 
+
+```java
+@MappedSuperclass
+public class Employee {
+    @Id
+    protected Integer employeeId;
+    ...
+}
+@Entity
+public class FullTimeEmployee extends Employee {
+    protected Integer salary;
+    ...
+}
+@Entity
+public class PartTimeEmployee extends Employee {
+    protected Float hourlyWage;
+    ...
+}
+```
+
+
+
+## EntityManger
+
+**获取EntityManger**
+
+```java
+@PersistenceContext
+EntityManager em;
+```
+
+**获取EntityMangerFactory**
+
+```java
+@PersistenceUnit
+EntityManagerFactory emf;
+```
+
+我们可以从`EntityMangerFactory`中通过调用`createEntityManger`方法获取`EntityManger`
+
+```java
+EntityManager em = emf.createEntityManager();
+```
+
+**使用EntityManger从`data store`中通过主键查询实体
+
+```java
+@PersistenceContext
+EntityManager em;
+public void enterOrder(int custID, Order newOrder) {
+    Customer cust = em.find(Customer.class, custID);
+    cust.getOrders().add(newOrder);
+    newOrder.setCustomer(cust);
+}
+```
+
+**Entity的声明周期**
+
+Entity 的声明周期有 `new`（新实体）, `managed`（被管理）, `detached`（分离）, `removed`（被移除）四种状态
+
+* `new`没有持久化标识(主键)，和持久化上下文(persistence context)没有关联
+* `managed`有持久化标识，且和持久化上下文有关联。
+* `detached` 有持久化标识，并且当前不与持久性上下文相关联。 
+* `removed`有持久化标识，与持久性上下文关联，并计划从数据存储中删除。
+
+**持久化实体(保存)**
+
+通过调用`persist`方法或通过在关系注释中设置了`cascade = PERSIST`或`cascade = ALL`元素的相关实体调用的级联持久操作，新实体实例变为托管和持久化 。如果实体已经是被管理的实例，则会忽略`persist`操作。如果`persist`的方法被 `removed`状态的实体调用，则该实体将会从`removed`状态转变为`managed`状态。如果实体为`detached`状态，则`persist`将会抛出`IllegalArgumentException `, 并且事务的提交会失败。
+
+```java
+@PersistenceContext
+EntityManager em;
+...
+public LineItem createLineItem(Order order, Product product,
+        int quantity) {
+    LineItem li = new LineItem(order, product, quantity);
+    order.getLineItems().add(li);
+    em.persist(li);
+    return li;
+}
+```
+
+`persist`（持久化）操作将传播到实体中所有的关系注解(OneToMany等)，如果关系注解中的`cascade`  属性被设置为`ALL`或者`PERSIST`。则其注解的对象也会被持久化到数据库。
+
+```java
+@OneToMany(cascade=ALL, mappedBy="order")
+public Collection<LineItem> getLineItems() {
+    return lineItems;
+}
+```
+
+**删除 Entity 实例（删除）**
+
+`managed`(被管理得)实例通过调用`remove`方法删除，并且如果被删除的实例中的关系注解的`cascade`属性被设置为`ALL`或`REMOVE`，则对应的对象也会被删除。如果删除的对象是一个新的实体，则删除操作将会被忽略。如果删除的是一个`detached`对象，则会抛出`IllegalArgumentException `，且事务提交也会失败。如果删除的是一个已被删除的实体，则操作将被忽略。当事务提交或者执行`flush`操作时，数据将会从数据库中删除。
+
+```java
+public void removeOrder(Integer orderId) {
+    try {
+        Order order = em.find(Order.class, orderId);
+        em.remove(order);
+    }...
+```
+
+**创建查询语句**
+
+`EntityManager.createQuery `和`EntityManager.createNamedQuery `被用来使用`JPA`查询语言从数据库查询数据。
+
+* `createQuery `被用来创建动态查询
+
+```java
+public List findWithName(String name) {
+return em.createQuery(
+    "SELECT c FROM Customer c WHERE c.name LIKE :custName")
+    .setParameter("custName", name)
+    .setMaxResults(10)
+    .getResultList();
+}
+```
+
+* `createNamedQuery `被用来创建静态查询，通过使用`javax.persistence.NamedQuery `注解在实体类上声明，该注解中的`name`元素指定了该静态查询语句的名称。`query`  元素指定了查询的语句。
+
+```java
+@NamedQuery(
+    name="findAllCustomersWithName",
+    query="SELECT c FROM Customer c WHERE c.name LIKE :custName"
+)
+```
+
+```java
+@PersistenceContext
+public EntityManager em;
+...
+customers = em.createNamedQuery("findAllCustomersWithName")
+    .setParameter("custName", "Smith")
+    .getResultList();
+```
+
+**查询语句中的参数**
+
+命名参数在查询中使用（:）作为前缀，它会被`javax.persistence.Query.setParameter(String name, Object value) `方法绑定
+
+```java
+public List findWithName(String name) {
+    Query query = em.createQuery("SELECT c FROM Customer c WHERE c.name LIKE :custName");
+    query.setParameter("custName", name);
+    return query.getResultList();
+}
+```
+
+也可以使用参数下标的形式对参数进行赋值
+
+```java
+public List findWithName(String name) {
+    return em.createQuery(
+        “SELECT c FROM Customer c WHERE c.name LIKE ?1”)
+        .setParameter(1, name)
+        .getResultList();
+}
+```
+
+**持久化单元(配置文件)**
+
+持久性单元定义由应用程序中的EntityManager实例管理的所有实体类的集合。这组实体类表示单个数据存储中包含的数据。 
+
+持久性单元由persistence.xml配置文件定义，META-INF目录包含persistence.xml的JAR文件或目录称为持久性单元的根，持久性单元的范围由持久性单元的根确定。
+
+```xml
+<persistence>
+    <persistence-unit name="OrderManagement">
+        <description>
+            This unit manages orders and customers.
+            It does not rely on any vendor-specific features and can
+            therefore be deployed to any persistence provider.
+        </description>
+        <jta-data-source>jdbc/MyOrderDB</jta-data-source>
+        <jar-file>MyOrderApp.jar</jar-file>
+        <class>com.widgets.Order</class>
+        <class>com.widgets.Customer</class>
+    </persistence-unit>
+</persistence>
+```
+
+
+
+## JPA 在WEB 中的应用
+
+**定义持久化单元**
+
+持久化单元被定义在`persistence.xml`文件中，其中包含了以下内容：
+
+*  `persistence` 元素，用于标识描述符验证的模式，并包含`persistence-unit`元素。 
+* `persistence-unit` 元素定义了持久化单元的名称和事务类型
+* `description` 可选
+* `jta-data-source` 它指定JTA数据源的全局JNDI名称。 
+
+`jta-data-source` 元素指示实体管理器参与的事务是JTA事务，这意味着事务由容器管理。 也可以使用`resource-local`来管理事务，这是由应用程序本身提供的事务。
+
+资源本地实体管理器不能参与全局事务。此外，Web容器不会回滚由编写不良的应用程序留下的待处理事务。 
+
+**创建持久化实体**
+
+```java
+@Entity
+@Table(name="WEB_BOOKSTORE_BOOKS")
+public class Book implements Serializable {
+	
+    @Id
+    private String bookId;
+    private String title;
+	... //getter and setter
+}
+```
+
+**通过EntityManager访问数据**
+
+```java
+public final class ContextListener implements SerlvetContextListener {
+...
+@PersistenceUnit
+private EntityManagerFactory emf;
+
+public void contextInitialized(ServletContexEvent event) {
+    context = event.getServletContext();
+    ...
+    try {
+        BookDBAO bookDB = new BookDBAO(emf);
+        context.setAttribute("bookDB", bookDB);
+    } catch (Exception ex) {
+        System.out.println(
+            "Couldn’t create bookstore database bean: "
+                 + ex.getMessage());
+    }
+}
+}
+```
+
+`BookDBAO`源码如下
+
+```java
+private EntityManager em;
+
+public BookDBAO (EntityManagerFactory emf) throws Exception {
+    em = emf.getEntityManager();
+    ...
+}
+```
+
+也可以使用下面的方式在 `DAO` 中直接获取 `EntityManager`
+
+```java
+public class BookDBAO {
+
+    @PersistenceContext
+    private EntityManager em;
+...
+```
+
+我们可以通过`EntityManager`内提供的方法执行`CRUD`操作
+
+**事务**
+
+```java
+@Resource
+UserTransaction utx;
+...
+try {
+    utx.begin();
+    bookDBAO.buyBooks(cart);
+    utx.commit();
+} catch (Exception ex) {
+    try {
+        utx.rollback();
+    } catch (Exception exe) {
+        System.out.println("Rollback failed: "+exe.getMessage());
+}
+...
+```
+
+
+
+## JAVA 持久化查询语言
+
+**基本查询语句**
+
+```sql
+SELECT p FROM Player p
+```
+
+`FROM` 元素后面跟的不再试 SQL 语言中的表名，而是JAVA 中的实体名称。
+
+**去重**
+
+```sql
+SELECT DISTINCT
+ p
+FROM Player p
+WHERE p.position = ?1
+```
+
+**命名参数**
+
+```sql
+SELECT DISTINCT p
+FROM Player p
+WHERE p.position = :position AND p.name = :name
+```
+
+**关联查询**
+
+***一对多 或 多对多***
+
+```sql
+SELECT DISTINCT p
+FROM Player p, IN(p.teams) t
+```
+
+也可以使用 `JOIN` 操作符
+
+```sql
+SELECT DISTINCT p
+FROM Player p JOIN p.teams t
+
+-- 也可以重写为：
+SELECT DISTINCT p
+FROM Player p
+WHERE p.team IS NOT EMPTY
+```
+
+***一对一***
+
+```sql
+SELECT t
+ FROM Team t JOIN t.league l
+ WHERE l.sport = ’soccer’ OR l.sport =’football’
+```
+
+***整合使用***
+
+```sql
+SELECT DISTINCT p
+FROM Player p, IN (p.teams) AS t
+WHERE t.city = :city
+```
+
+***遍历多条关系***
+
+```sql
+SELECT DISTINCT p
+FROM Player p, IN (p.teams) t
+WHERE t.league = :league
+```
+
+***通过关联对象的属性查询***
+
+```sql
+SELECT DISTINCT p
+FROM Player p, IN (p.teams) t
+WHERE t.league.sport = :sport
+```
+
+***LIKE 查询***
+
+```sql
+SELECT p
+ FROM Player p
+ WHERE p.name LIKE ’Mich%’
+```
+
+***IS NULL***
+
+```sql
+SELECT t
+ FROM Team t
+ WHERE t.league IS NULL
+```
+
+***IS EMPTY***
+
+```SQL
+SELECT p
+FROM Player p
+WHERE p.teams IS EMPTY
+```
+
+***BETWEEN***
+
+```SQL
+SELECT DISTINCT p
+FROM Player p
+WHERE p.salary BETWEEN :lowerSalary AND :higherSalary
+```
+
+***比较***
+
+```sql
+SELECT DISTINCT p1
+FROM Player p1, Player p2
+WHERE p1.salary > p2.salary AND p2.name = :name
+```
+
+***更新***
+
+```sql
+UPDATE Player p
+SET p.status = ’inactive’
+WHERE p.lastPlayed < :inactiveThresholdDate
+```
+
+***删除***
+
+```sql
+DELETE
+FROM Player p
+WHERE p.status = ’inactive’
+AND p.teams IS EMPTY
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/java/java_spi\346\234\272\345\210\266.md" "b/java/java_spi\346\234\272\345\210\266.md"
new file mode 100644
index 0000000..3f8c74c
--- /dev/null
+++ "b/java/java_spi\346\234\272\345\210\266.md"
@@ -0,0 +1,100 @@
+### 什么是SPI
+
+SPI的全名为：Service Provider Interface，这个东西是针对厂商或者插件的，在java.util.ServiceLoad的文档中有详细的介绍。
+
+简单来说，我们的系统中抽象的各个模块，往往有很多不同的实现方案，比如日志模块的方案，jdbc模块的方案等。我们一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。
+
+
+
+### Java SPI机制
+
+Java SPI提供了为某个接口寻找服务实现的的机制，有点类似于IOC的思想，就是将装配的控制权移交到程序之外，在模块化设计中这个机制尤为重要。
+
+
+
+### 约定
+
+当服务的提供者提供了服务接口的一种实现后，在**jar**包的**META-INF/services/**目录里同时创建一个服务接口命名的文件。该文件里就是实现服务接口的具体实现类。
+
+而当外部程序装配这个模块时，就能通过该配置文件找到具体的实现类名，并装载实例化，完成模块的注入。
+
+基于这样一个约定就能很好的找到服务接口的实现类，而不需要在代码里指定。jdk提供服务实现查找的一个工具类为**java.util.ServiceLoad**。
+
+
+
+### 代码实现SPI
+
+#### 定义抽象接口
+
+首先需要定义一个抽象接口，用于将功能分离。具体实现由各个厂商负责。
+
+```java
+package com.demo.inter;
+
+public interface Service {
+
+    void say();
+}
+```
+
+#### 定义实现接口的类
+
+实现类用于实现抽象接口中的具体方法，为服务提供功能需要。
+
+```java
+package com.demo.a.impl;
+
+import com.demo.inter.Service;
+
+public class ServiceImpl implements Service {
+    @Override
+    public void say() {
+        System.out.println("I am A");
+    }
+}
+```
+
+#### 定义配置文件
+
+在基于MAVEN搭建的Java工程中，需要将 **META-INF/services/** 建立在 **resources** 目录下。
+
+在 **resources** 目录下创建  **META-INF/services/** 目录，并在  **META-INF/services/** 目录下建立 **com.demo.inter.Service** 文件。
+
+**com.demo.inter.Service** 文件中填写具体的实现类，如下：
+
+```java
+com.demo.a.impl.ServiceImpl
+```
+
+#### 定义测试类
+
+```java
+package com.demo;
+
+import com.demo.inter.Service;
+import java.util.Iterator;
+import java.util.ServiceLoader;
+
+public class Main {
+
+    public static void main(String[] args) {
+        // 使用ServiceLoad加载 META-INF/services/com.demo.inter.Service 文件下的内容
+        ServiceLoader<Service> services = ServiceLoader.load(Service.class);
+        // 获取所有的实现类
+        Iterator<Service> iterator = services.iterator();
+        if (iterator.hasNext()) {
+            // META-INF/services/com.demo.inter.Service 文件中配置的实现类
+            Service service = iterator.next();
+            service.say();
+        }
+    }
+}
+
+```
+
+运行代码后输出：
+
+```java
+I am A
+```
+
diff --git a/java/javaagent.md b/java/javaagent.md
new file mode 100644
index 0000000..50c70aa
--- /dev/null
+++ b/java/javaagent.md
@@ -0,0 +1,529 @@
+##  Instrumentation 简介
+
+利用 Java 代码，即 java.lang.instrument 做动态 Instrumentation 是 Java SE 5 的新特性，它把 Java 的 instrument 功能从本地代码中解放出来，使之可以用 Java 代码的方式解决问题。使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。有了这样的功能，开发者就可以实现更为灵活的运行时虚拟机监控和 Java 类操作了，这样的特性实际上提供了一种虚拟机级别支持的 AOP 实现方式，使得开发者无需对 JDK 做任何升级和改动，就可以实现某些 AOP 的功能了。
+
+在 Java SE 6 里面，instrumentation 包被赋予了更强大的功能：启动后的 instrument、本地代码（native code）instrument，以及动态改变 classpath 等等。这些改变，意味着 Java 具有了更强的动态控制、解释能力，它使得 Java 语言变得更加灵活多变。
+
+在 Java SE6 里面，最大的改变使运行时的 Instrumentation 成为可能。在 Java SE 5 中，Instrument 要求在运行前利用命令行参数或者系统参数来设置代理类，在实际的运行之中，虚拟机在初始化之时（在绝大多数的 Java 类库被载入之前），instrumentation 的设置已经启动，并在虚拟机中设置了回调函数，检测特定类的加载情况，并完成实际工作。但是在实际的很多的情况下，我们没有办法在虚拟机启动之时就为其设定代理，这样实际上限制了 instrument 的应用。而 Java SE 6 的新特性改变了这种情况，通过 Java Tool API 中的 attach 方式，我们可以很方便地在运行过程中动态地设置加载代理类，以达到 instrumentation 的目的。
+
+另外，对 native 的 Instrumentation 也是 Java SE 6 的一个崭新的功能，这使以前无法完成的功能 —— 对 native 接口的 instrumentation 可以在 Java SE 6 中，通过一个或者一系列的 prefix 添加而得以完成。
+
+最后，Java SE 6 里的 Instrumentation 也增加了动态添加 class path 的功能。所有这些新的功能，都使得 instrument 包的功能更加丰富，从而使 Java 语言本身更加强大。
+
+ 
+
+ 
+
+## Instrumentation 的基本功能和用法
+
+“java.lang.instrument”包的具体实现，依赖于 JVMTI。JVMTI（Java Virtual Machine Tool Interface）是一套由 Java 虚拟机提供的，为 JVM 相关的工具提供的本地编程接口集合。JVMTI 是从 Java SE 5 开始引入，整合和取代了以前使用的 Java Virtual Machine Profiler Interface (JVMPI) 和 the Java Virtual Machine Debug Interface (JVMDI)，而在 Java SE 6 中，JVMPI 和 JVMDI 已经消失了。JVMTI 提供了一套”代理”程序机制，可以支持第三方工具程序以代理的方式连接和访问 JVM，并利用 JVMTI 提供的丰富的编程接口，完成很多跟 JVM 相关的功能。事实上，java.lang.instrument 包的实现，也就是基于这种机制的：在 Instrumentation 的实现当中，存在一个 JVMTI 的代理程序，通过调用 JVMTI 当中 Java 类相关的函数来完成 Java 类的动态操作。除开 Instrumentation 功能外，JVMTI 还在虚拟机内存管理，线程控制，方法和变量操作等等方面提供了大量有价值的函数。关于 JVMTI 的详细信息，请参考 Java SE 6 文档（请参见 [参考资源](http://www.ibm.com/developerworks/cn/java/j-lo-jse61/#resources)）当中的介绍。
+
+Instrumentation 的最大作用，就是类定义动态改变和操作。在 Java SE 5 及其后续版本当中，开发者可以在一个普通 Java 程序（带有 main 函数的 Java 类）运行时，通过 `– javaagent`参数指定一个特定的 jar 文件（包含 Instrumentation 代理）来启动 Instrumentation 的代理程序。
+
+在 Java SE 5 当中，开发者可以让 Instrumentation 代理在 main 函数运行前执行。简要说来就是如下几个步骤：
+
+1. **编写** **premain** **函数**
+
+编写一个 Java 类，包含如下两个方法当中的任何一个
+
+```
+public static void premain(String agentArgs, Instrumentation inst);  [1]
+public static void premain(String agentArgs); [2]
+```
+
+其中，[1] 的优先级比 [2] 高，将会被优先执行（[1] 和 [2] 同时存在时，[2] 被忽略）。
+
+在这个 premain 函数中，开发者可以进行对类的各种操作。
+
+agentArgs 是 premain 函数得到的程序参数，随同 “`– javaagent`”一起传入。与 main 函数不同的是，这个参数是一个字符串而不是一个字符串数组，如果程序参数有多个，程序将自行解析这个字符串。
+
+Inst 是一个 java.lang.instrument.Instrumentation 的实例，由 JVM 自动传入。java.lang.instrument.Instrumentation 是 instrument 包中定义的一个接口，也是这个包的核心部分，集中了其中几乎所有的功能方法，例如类定义的转换和操作等等。
+
+1. **jar** **文件打包**
+
+将这个 Java 类打包成一个 jar 文件，并在其中的 manifest 属性当中加入” Premain-Class”来指定步骤 1 当中编写的那个带有 premain 的 Java 类。（可能还需要指定其他属性以开启更多功能）
+
+1. **运行**
+
+用如下方式运行带有 Instrumentation 的 Java 程序：
+
+```
+ java -javaagent:jar 文件的位置 [= 传入 premain 的参数 ]
+```
+
+对 Java 类文件的操作，可以理解为对一个 byte 数组的操作（将类文件的二进制字节流读入一个 byte 数组）。开发者可以在“ClassFileTransformer”的 transform 方法当中得到，操作并最终返回一个类的定义（一个 byte 数组）。这方面，Apache 的 BCEL 开源项目提供了强有力的支持，读者可以在参考文章“[Java SE 5 特性 Instrumentation 实践](http://www.ibm.com/developerworks/cn/java/j-lo-instrumentation/)”中看到一个 BCEL 和 Instrumentation 结合的例子。具体的字节码操作并非本文的重点，所以，本文中所举的例子，只是采用简单的类文件替换的方式来演示 Instrumentation 的使用。
+
+下面，我们通过简单的举例，来说明 Instrumentation 的基本使用方法。
+
+首先，我们有一个简单的类，TransClass， 可以通过一个静态方法返回一个整数 1。
+
+```
+ public class TransClass { 
+          public int getNumber() { 
+          return 1; 
+    } 
+ }
+```
+
+我们运行如下类，可以得到输出 ”1“。
+
+```
+ public class TestMainInJar { 
+    public static void main(String[] args) { 
+        System.out.println(new TransClass().getNumber()); 
+    } 
+ }
+```
+
+然后，我们将 TransClass 的 getNumber 方法改成如下 :
+
+```
+ public int getNumber() { 
+        return 2; 
+ }
+```
+
+再将这个返回 2 的 Java 文件编译成类文件，为了区别开原有的返回 1 的类，我们将返回 2 的这个类文件命名为 TransClass2.class.2。
+
+接下来，我们建立一个 Transformer 类：
+
+```
+ import java.io.File; 
+ import java.io.FileInputStream; 
+ import java.io.IOException; 
+ import java.io.InputStream; 
+ import java.lang.instrument.ClassFileTransformer; 
+ import java.lang.instrument.IllegalClassFormatException; 
+ import java.security.ProtectionDomain; 
+ 
+ class Transformer implements ClassFileTransformer { 
+ 
+    public static final String classNumberReturns2 = "TransClass.class.2"; 
+ 
+    public static byte[] getBytesFromFile(String fileName) { 
+        try { 
+            // precondition 
+            File file = new File(fileName); 
+            InputStream is = new FileInputStream(file); 
+            long length = file.length(); 
+            byte[] bytes = new byte[(int) length]; 
+ 
+            // Read in the bytes 
+            int offset = 0; 
+            int numRead = 0; 
+            while (offset <bytes.length 
+                    && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) { 
+                offset += numRead; 
+            } 
+ 
+            if (offset < bytes.length) { 
+                throw new IOException("Could not completely read file "
+                        + file.getName()); 
+            } 
+            is.close(); 
+            return bytes; 
+        } catch (Exception e) { 
+            System.out.println("error occurs in _ClassTransformer!"
+                    + e.getClass().getName()); 
+            return null; 
+        } 
+    } 
+ 
+   /**
+    * 参数： 
+    * loader - 定义要转换的类加载器；如果是引导加载器，则为 null 
+    * className - 完全限定类内部形式的类名称和 The Java Virtual Machine Specification 中定义的接口名称。例如，"java/util/List"。 
+    * classBeingRedefined - 如果是被重定义或重转换触发，则为重定义或重转换的类；如果是类加载，则为 null 
+    * protectionDomain - 要定义或重定义的类的保护域 
+    * classfileBuffer - 类文件格式的输入字节缓冲区（不得修改） 
+    * 返回： 
+    * 一个格式良好的类文件缓冲区（转换的结果），如果未执行转换,则返回 null。 
+    * 抛出： 
+    * IllegalClassFormatException - 如果输入不表示一个格式良好的类文件 
+    */
+    public byte[] transform(ClassLoader l, String className, Class<?> c, 
+            ProtectionDomain pd, byte[] b) throws IllegalClassFormatException { 
+        if (!className.equals("TransClass")) { 
+            return null; 
+        } 
+        return getBytesFromFile(classNumberReturns2); 
+ 
+    } 
+ }
+```
+
+这个类实现了 ClassFileTransformer 接口。其中，getBytesFromFile 方法根据文件名读入二进制字符流，而 ClassFileTransformer 当中规定的 transform 方法则完成了类定义的替换转换。
+
+最后，我们建立一个 Premain 类，写入 Instrumentation 的代理方法 premain：
+
+```
+ public class Premain { 
+    public static void premain(String agentArgs， Instrumentation inst) 
+            throws ClassNotFoundException， UnmodifiableClassException { 
+        inst.addTransformer(new Transformer()); 
+    } 
+ }
+```
+
+可以看出，addTransformer 方法并没有指明要转换哪个类。转换发生在 premain 函数执行之后，main 函数执行之前，这时每装载一个类，transform 方法就会执行一次，看看是否需要转换，所以，在 transform（Transformer 类中）方法中，程序用 className.equals("TransClass") 来判断当前的类是否需要转换。
+
+代码完成后，我们将他们打包为 TestInstrument1.jar。返回 1 的那个 TransClass 的类文件保留在 jar 包中，而返回 2 的那个 TransClass.class.2 则放到 jar 的外面。在 manifest 里面加入如下属性来指定 premain 所在的类：
+
+```
+ Manifest-Version: 1.0 
+ Premain-Class: Premain
+```
+
+在运行这个程序的时候，如果我们用普通方式运行这个 jar 中的 main 函数，可以得到输出“1”。如果用下列方式运行 :
+
+```
+ java – javaagent:TestInstrument1.jar – cp TestInstrument1.jar TestMainInJar
+```
+
+则会得到输出“2”。
+
+当然，程序运行的 main 函数不一定要放在 premain 所在的这个 jar 文件里面，这里只是为了例子程序打包的方便而放在一起的。
+
+除开用 addTransformer 的方式，Instrumentation 当中还有另外一个方法“redefineClasses”来实现 premain 当中指定的转换。用法类似，如下：
+
+```
+ public class Premain { 
+    public static void premain(String agentArgs， Instrumentation inst) 
+            throws ClassNotFoundException， UnmodifiableClassException { 
+        ClassDefinition def = new ClassDefinition(TransClass.class， Transformer 
+                .getBytesFromFile(Transformer.classNumberReturns2)); 
+        inst.redefineClasses(new ClassDefinition[] { def }); 
+        System.out.println("success"); 
+    } 
+ }
+```
+
+redefineClasses 的功能比较强大，可以批量转换很多类。
+
+ 
+
+ 
+
+##  Java SE 6 的新特性：虚拟机启动后的动态 instrument
+
+在 Java SE 5 当中，开发者只能在 premain 当中施展想象力，所作的 Instrumentation 也仅限与 main 函数执行前，这样的方式存在一定的局限性。
+
+在 Java SE 5 的基础上，Java SE 6 针对这种状况做出了改进，开发者可以在 main 函数开始执行以后，再启动自己的 Instrumentation 程序。
+
+在 Java SE 6 的 Instrumentation 当中，有一个跟 premain“并驾齐驱”的“agentmain”方法，可以在 main 函数开始运行之后再运行。
+
+跟 premain 函数一样， 开发者可以编写一个含有“agentmain”函数的 Java 类：
+
+```
+ public static void agentmain (String agentArgs, Instrumentation inst);                  [1] 
+ public static void agentmain (String agentArgs);                      [2]
+```
+
+同样，[1] 的优先级比 [2] 高，将会被优先执行。
+
+跟 premain 函数一样，开发者可以在 agentmain 中进行对类的各种操作。其中的 agentArgs 和 Inst 的用法跟 premain 相同。
+
+与“Premain-Class”类似，开发者必须在 manifest 文件里面设置“Agent-Class”来指定包含 agentmain 函数的类。
+
+可是，跟 premain 不同的是，agentmain 需要在 main 函数开始运行后才启动，这样的时机应该如何确定呢，这样的功能又如何实现呢？
+
+在 Java SE 6 文档当中，开发者也许无法在 java.lang.instrument 包相关的文档部分看到明确的介绍，更加无法看到具体的应用 agnetmain 的例子。不过，在 Java SE 6 的新特性里面，有一个不太起眼的地方，揭示了 agentmain 的用法。这就是 Java SE 6 当中提供的 Attach API。
+
+Attach API 不是 Java 的标准 API，而是 Sun 公司提供的一套扩展 API，用来向目标 JVM ”附着”（Attach）代理工具程序的。有了它，开发者可以方便的监控一个 JVM，运行一个外加的代理程序。
+
+Attach API 很简单，只有 2 个主要的类，都在 com.sun.tools.attach 包里面： VirtualMachine 代表一个 Java 虚拟机，也就是程序需要监控的目标虚拟机，提供了 JVM 枚举，Attach 动作和 Detach 动作（Attach 动作的相反行为，从 JVM 上面解除一个代理）等等 ; VirtualMachineDescriptor 则是一个描述虚拟机的容器类，配合 VirtualMachine 类完成各种功能。
+
+为了简单起见，我们举例简化如下：依然用类文件替换的方式，将一个返回 1 的函数替换成返回 2 的函数，Attach API 写在一个线程里面，用睡眠等待的方式，每隔半秒时间检查一次所有的 Java 虚拟机，当发现有新的虚拟机出现的时候，就调用 attach 函数，随后再按照 Attach API 文档里面所说的方式装载 Jar 文件。等到 5 秒钟的时候，attach 程序自动结束。而在 main 函数里面，程序每隔半秒钟输出一次返回值（显示出返回值从 1 变成 2）。
+
+TransClass 类和 Transformer 类的代码不变，参看上一节介绍。 含有 main 函数的 TestMainInJar 代码为：
+
+```
+ public class TestMainInJar { 
+    public static void main(String[] args) throws InterruptedException { 
+        System.out.println(new TransClass().getNumber()); 
+        int count = 0; 
+        while (true) { 
+            Thread.sleep(500); 
+            count++; 
+            int number = new TransClass().getNumber(); 
+            System.out.println(number); 
+            if (3 == number || count >= 10) { 
+                break; 
+            } 
+        } 
+    } 
+ }
+```
+
+含有 agentmain 的 AgentMain 类的代码为：
+
+```
+ import java.lang.instrument.ClassDefinition; 
+ import java.lang.instrument.Instrumentation; 
+ import java.lang.instrument.UnmodifiableClassException; 
+ 
+ public class AgentMain { 
+    public static void agentmain(String agentArgs, Instrumentation inst) 
+            throws ClassNotFoundException, UnmodifiableClassException, 
+            InterruptedException { 
+        inst.addTransformer(new Transformer (), true); 
+        inst.retransformClasses(TransClass.class); 
+        System.out.println("Agent Main Done"); 
+    } 
+ }
+```
+
+其中，retransformClasses 是 Java SE 6 里面的新方法，它跟 redefineClasses 一样，可以批量转换类定义，多用于 agentmain 场合。
+
+Jar 文件跟 Premain 那个例子里面的 Jar 文件差不多，也是把 main 和 agentmain 的类，TransClass，Transformer 等类放在一起，打包为“TestInstrument1.jar”，而 Jar 文件当中的 Manifest 文件为 :
+
+```
+ Manifest-Version: 1.0 
+ Agent-Class: AgentMain
+```
+
+另外，为了运行 Attach API，我们可以再写一个控制程序来模拟监控过程：（代码片段）
+
+```
+ import com.sun.tools.attach.VirtualMachine; 
+ import com.sun.tools.attach.VirtualMachineDescriptor; 
+……
+ // 一个运行 Attach API 的线程子类
+ static class AttachThread extends Thread { 
+        
+ private final List<VirtualMachineDescriptor> listBefore; 
+ 
+        private final String jar; 
+ 
+        AttachThread(String attachJar, List<VirtualMachineDescriptor> vms) { 
+            listBefore = vms;  // 记录程序启动时的 VM 集合
+            jar = attachJar; 
+        } 
+ 
+        public void run() { 
+            VirtualMachine vm = null; 
+            List<VirtualMachineDescriptor> listAfter = null; 
+            try { 
+                int count = 0; 
+                while (true) { 
+                    listAfter = VirtualMachine.list(); 
+                    for (VirtualMachineDescriptor vmd : listAfter) { 
+                        if (!listBefore.contains(vmd)) { 
+ // 如果 VM 有增加，我们就认为是被监控的 VM 启动了
+ // 这时，我们开始监控这个 VM 
+                            vm = VirtualMachine.attach(vmd); 
+                            break; 
+                        } 
+                    } 
+                    Thread.sleep(500); 
+                    count++; 
+                    if (null != vm || count >= 10) { 
+                        break; 
+                    } 
+                } 
+                vm.loadAgent(jar); 
+                vm.detach(); 
+            } catch (Exception e) { 
+                 ignore 
+            } 
+        } 
+    } 
+……
+ public static void main(String[] args) throws InterruptedException {   
+     new AttachThread("TestInstrument1.jar", VirtualMachine.list()).start(); 
+ 
+ }
+```
+
+运行时，可以首先运行上面这个启动新线程的 main 函数，然后，在 5 秒钟内（仅仅简单模拟 JVM 的监控过程）运行如下命令启动测试 Jar 文件 :
+
+```
+ java – javaagent:TestInstrument2.jar – cp TestInstrument2.jar TestMainInJar
+```
+
+如果时间掌握得不太差的话，程序首先会在屏幕上打出 1，这是改动前的类的输出，然后会打出一些 2，这个表示 agentmain 已经被 Attach API 成功附着到 JVM 上，代理程序生效了，当然，还可以看到“Agent Main Done”字样的输出。
+
+以上例子仅仅只是简单示例，简单说明这个特性而已。真实的例子往往比较复杂，而且可能运行在分布式环境的多个 JVM 之中。
+
+ 
+
+## Java SE 6 新特性：本地方法的 Instrumentation
+
+在 1.5 版本的 instumentation 里，并没有对 Java 本地方法（Native Method）的处理方式，而且在 Java 标准的 JVMTI 之下，并没有办法改变 method signature， 这就使替换本地方法非常地困难。一个比较直接而简单的想法是，在启动时替换本地代码所在的动态链接库 —— 但是这样，本质上是一种静态的替换，而不是动态的 Instrumentation。而且，这样可能需要编译较大数量的动态链接库 —— 比如，我们有三个本地函数，假设每一个都需要一个替换，而在不同的应用之下，可能需要不同的组合，那么如果我们把三个函数都编译在同一个动态链接库之中，最多我们需要 8 个不同的动态链接库来满足需要。当然，我们也可以独立地编译之，那样也需要 6 个动态链接库——无论如何，这种繁琐的方式是不可接受的。
+
+在 Java SE 6 中，新的 Native Instrumentation 提出了一个新的 native code 的解析方式，作为原有的 native method 的解析方式的一个补充，来很好地解决了一些问题。这就是在新版本的 java.lang.instrument 包里，我们拥有了对 native 代码的 instrument 方式 —— 设置 prefix。
+
+假设我们有了一个 native 函数，名字叫 nativeMethod，在运行中过程中，我们需要将它指向另外一个函数（需要注意的是，在当前标准的 JVMTI 之下，除了 native 函数名，其他的 signature 需要一致）。比如我们的 Java 代码是：
+
+```
+ package nativeTester; 
+ class nativePrefixTester{ 
+         …
+          native int nativeMethod(int input); 
+         …
+ }
+```
+
+那么我们已经实现的本地代码是 :
+
+```
+ jint Java_nativeTester_nativeMethod(jclass thiz, jobject thisObj, jint input);
+```
+
+现在我们需要在调用这个函数时，使之指向另外一个函数。那么按照 J2SE 的做法，我们可以按他的命名方式，加上一个 prefix 作为新的函数名。比如，我们以 "another_" 作为 prefix，那么我们新的函数是 :
+
+```
+ jint Java_nativeTester_another_nativePrefixTester(jclass thiz, jobject thisObj, 
+ jint input);
+```
+
+然后将之编入动态链接库之中。
+
+现在我们已经有了新的本地函数，接下来就是做 instrument 的设置。正如以上所说的，我们可以使用 premain 方式，在虚拟机启动之时就载入 premain 完成 instrument 代理设置。也可以使用 agentmain 方式，去 attach 虚拟机来启动代理。而设置 native 函数的也是相当简单的 :
+
+```
+ premain(){  // 或者也可以在 agentmain 里
+…
+ if (!isNativeMethodPrefixSupported()){ 
+                  return; // 如果无法设置，则返回
+ } 
+ setNativeMethodPrefix(transformer,"another_"); // 设置 native 函数的 prefix，注意这个下划线必须由用户自己规定
+…
+ }
+```
+
+在这里要注意两个问题。一是不是在任何的情况下都是可以设置 native 函数的 prefix 的。首先，我们要注意到 agent 包之中的 Manifest 所设定的特性 :
+
+```
+ Can-Set-Native-Method-Prefix
+```
+
+要注意，这一个参数都可以影响是否可以设置 native prefix，而且，在默认的设置之中，这个参数是 false 的，我们需要将之设置成 true（顺便说一句，对 Manifest 之中的属性来说都是大小写无关的，当然，如果给一个不是“true”的值，就会被当作 false 值处理）。
+
+当然，我们还需要确认虚拟机本身是否支持 setNativePrefix。在 Java API 里，Instrumentation 类提供了一个函数 isNativePrefix，通过这个函数我们可以知道该功能是否可以实行。
+
+二是我们可以为每一个 ClassTransformer 加上它自己的 nativeprefix；同时，每一个 ClassTransformer 都可以为同一个 class 做 transform，因此对于一个 Class 来说，一个 native 函数可能有不同的 prefix，因此对这个函数来说，它可能也有好几种解析方式。
+
+在 Java SE 6 当中，Native prefix 的解释方式如下：对于某一个 package 内的一个 class 当中的一个 native method 来说，首先，假设我们对这个函数的 transformer 设置了 native 的 prefix“another”，它将这个函数接口解释成 :
+
+由 Java 的函数接口
+
+```
+ native void method()
+```
+
+和上述 prefix"another"，去寻找本地代码中的函数
+
+```
+ void Java_package_class_another_method(jclass theClass, jobject thiz);  
+ // 请注意 prefix 在函数名中出现的位置！
+```
+
+一旦可以找到，那么调用这个函数，整个解析过程就结束了；如果没有找到，那么虚拟机将会做进一步的解析工作。我们将利用 Java native 接口最基本的解析方式 , 去找本地代码中的函数 :
+
+```
+ void Java_package_class_method(jclass theClass, jobject thiz);
+```
+
+如果找到，则执行之。否则，因为没有任何一个合适的解析方式，于是宣告这个过程失败。
+
+那么如果有多个 transformer，同时每一个都有自己的 prefix，又该如何解析呢？事实上，虚拟机是按 transformer 被加入到的 Instrumentation 之中的次序去解析的（还记得我们最基本的 addTransformer 方法吗？）。
+
+假设我们有三个 transformer 要被加入进来，他们的次序和相对应的 prefix 分别为：transformer1 和“prefix1_”，transformer2 和 “prefix2_”，transformer3 和 “prefix3_”。那么，虚拟机会首先做的就是将接口解析为 :
+
+```
+ native void prefix1_prefix2_prefix3_native_method()
+```
+
+然后去找它相对应的 native 代码。
+
+但是如果第二个 transformer（transformer2）没有设定 prefix，那么很简单，我们得到的解析是：
+
+```
+ native void prefix1_prefix3_native_method()
+```
+
+这个方式简单而自然。
+
+当然，对于多个 prefix 的情况，我们还要注意一些复杂的情况。比如，假设我们有一个 native 函数接口是：
+
+```
+ native void native_method()
+```
+
+然后我们为它设置了两个 prefix，比如 "wrapped_" 和 "wrapped2_"，那么，我们得到的是什么呢？是
+
+```
+ void Java_package_class_wrapped_wrapped2_method(jclass theClass, jobject thiz); 
+ // 这个函数名正确吗？
+```
+
+吗？答案是否定的，因为事实上，对 Java 中 native 函数的接口到 native 中的映射，有一系列的规定，因此可能有一些特殊的字符要被代入。而实际中，这个函数的正确的函数名是：
+
+```
+ void Java_package_class_wrapped_1wrapped2_1method(jclass theClass, jobject thiz); 
+ // 只有这个函数名会被找到
+```
+
+很有趣不是吗？因此如果我们要做类似的工作，一个很好的建议是首先在 Java 中写一个带 prefix 的 native 接口，用 javah 工具生成一个 c 的 header-file，看看它实际解析得到的函数名是什么，这样我们就可以避免一些不必要的麻烦。
+
+另外一个事实是，与我们的想像不同，对于两个或者两个以上的 prefix，虚拟机并不做更多的解析；它不会试图去掉某一个 prefix，再来组装函数接口。它做且仅作两次解析。
+
+总之，新的 native 的 prefix-instrumentation 的方式，改变了以前 Java 中 native 代码无法动态改变的缺点。在当前，利用 JNI 来写 native 代码也是 Java 应用中非常重要的一个环节，因此它的动态化意味着整个 Java 都可以动态改变了 —— 现在我们的代码可以利用加上 prefix 来动态改变 native 函数的指向，正如上面所说的，如果找不到，虚拟机还会去尝试做标准的解析，这让我们拥有了动态地替换 native 代码的方式，我们可以将许多带不同 prefix 的函数编译在一个动态链接库之中，而通过 instrument 包的功能，让 native 函数和 Java 函数一样动态改变、动态替换。
+
+当然，现在的 native 的 instrumentation 还有一些限制条件，比如，不同的 transformer 会有自己的 native prefix，就是说，每一个 transformer 会负责他所替换的所有类而不是特定类的 prefix —— 因此这个粒度可能不够精确。
+
+ 
+
+## Java SE 6 新特性：BootClassPath / SystemClassPath 的动态增补
+
+我们知道，通过设置系统参数或者通过虚拟机启动参数，我们可以设置一个虚拟机运行时的 boot class 加载路径（-Xbootclasspath）和 system class（-cp）加载路径。当然，我们在运行之后无法替换它。然而，我们也许有时候要需要把某些 jar 加载到 bootclasspath 之中，而我们无法应用上述两个方法；或者我们需要在虚拟机启动之后来加载某些 jar 进入 bootclasspath。在 Java SE 6 之中，我们可以做到这一点了。
+
+实现这几点很简单，首先，我们依然需要确认虚拟机已经支持这个功能，然后在 premain/agantmain 之中加上需要的 classpath。我们可以在我们的 Transformer 里使用 appendToBootstrapClassLoaderSearch/appendToSystemClassLoaderSearch 来完成这个任务。
+
+同时我们可以注意到，在 agent 的 manifest 里加入 Boot-Class-Path 其实一样可以在动态地载入 agent 的同时加入自己的 boot class 路径，当然，在 Java code 中它可以更加动态方便和智能地完成 —— 我们可以很方便地加入判断和选择成分。
+
+在这里我们也需要注意几点。首先，我们加入到 classpath 的 jar 文件中不应当带有任何和系统的 instrumentation 有关的系统同名类，不然，一切都陷入不可预料之中 —— 这不是一个工程师想要得到的结果，不是吗？
+
+其次，我们要注意到虚拟机的 ClassLoader 的工作方式，它会记载解析结果。比如，我们曾经要求读入某个类 someclass，但是失败了，ClassLoader 会记得这一点。即使我们在后面动态地加入了某一个 jar，含有这个类，ClassLoader 依然会认为我们无法解析这个类，与上次出错的相同的错误会被报告。
+
+再次我们知道在 Java 语言中有一个系统参数“java.class.path”，这个 property 里面记录了我们当前的 classpath，但是，我们使用这两个函数，虽然真正地改变了实际的 classpath，却不会对这个 property 本身产生任何影响。
+
+在公开的 JavaDoc 中我们可以发现一个很有意思的事情，Sun 的设计师们告诉我们，这个功能事实上依赖于 ClassLoader 的 appendtoClassPathForInstrumentation 方法 —— 这是一个非公开的函数，因此我们不建议直接（使用反射等方式）使用它，事实上，instrument 包里的这两个函数已经可以很好的解决我们的问题了。
+
+ 
+
+从以上的介绍我们可以得出结论，在 Java SE 6 里面，instrumentation 包新增的功能 —— 虚拟机启动后的动态 instrument、本地代码（native code）instrumentation，以及动态添加 classpath 等等，使得 Java 具有了更强的动态控制、解释能力，从而让 Java 语言变得更加灵活多变。
+
+这些能力，从某种意义上开始改变 Java 语言本身。在过去很长的一段时间内，动态 脚本语言的大量涌现和快速发展，对整个软件业和网络业提高生产率起到了非常重要的作用。在这种背景之下，Java 也正在慢慢地作出改变。而 Instrument 的新功能和 Script 平台（本系列的后面一篇中将介绍到这一点）的出现，则大大强化了语言的动态化和与动态语言融合，它是 Java 的发展的值得考量的新趋势。
+
+## MANIFEST.MF属性
+
+为代理JAR文件定义了以下清单属性：
+
+> - `Premain-Class`
+>
+> 在JVM启动时指定代理程序时，此属性指定代理程序类。也就是说，包含该`premain`方法的类。在JVM启动时指定代理程序时，此属性是必需的。如果该属性不存在，则JVM将中止。注意：这是类名，而不是文件名或路径。
+>
+> - `Agent-Class`
+>
+> 如果实现支持在VM启动后的某个时间启动代理的机制，则此属性指定代理类。也就是说，包含该`agentmain`方法的类。此属性是必需的，如果不存在，则不会启动代理。注意：这是类名，而不是文件名或路径。
+>
+> - `Boot-Class-Path`
+>
+> 引导类加载器要搜索的路径列表。路径表示目录或库（在许多平台上通常称为JAR或zip库）。在定位类的平台特定机制失败之后，引导类加载器搜索这些路径。按列出的顺序搜索路径。列表中的路径由一个或多个空格分隔。路径采用分层URI的路径组件的语法。如果它以斜杠字符（'/'）开头，则该路径是绝对的，否则它是相对的。根据代理JAR文件的绝对路径解析相对路径。格式错误且不存在的路径将被忽略。在VM启动后的某个时间启动代理程序时，将忽略不代表JAR文件的路径。此属性是可选的。在VM启动后的某个时间启动代理程序时，将忽略不代表JAR文件的路径。此属性是可选的。
+>
+> - `Can-Redefine-Classes`
+>
+> 布尔（`true`或`false`）。是否能够重新定义此代理所需的类。此属性是可选的，默认为`false`。
+>
+> - `Can-Retransform-Classes`
+>
+> 布尔（`true`或`false`）。是否能够重新转换此代理所需的类。此属性是可选的，默认为`false`。
+>
+> - `Can-Set-Native-Method-Prefix`
+>
+> 布尔（`true`或`false`）。是否能够设置此代理所需的本机方法前缀。此属性是可选的，默认为`false`。
+
+代理JAR文件可以 在清单中同时包含`Premain-Class`和`Agent-Class`属性。使用该`-javaagent`选项在命令行上启动代理程序时，该`Premain-Class`属性指定代理程序类的名称，并`Agent-Class`忽略该属性。同样，如果代理在VM启动后的某个时间启动，则该`Agent-Class`属性指定代理类的名称（`Premain-Class`忽略属性的值）。
+
diff --git "a/java/javassist\344\275\277\347\224\250\346\214\207\345\215\227.md" "b/java/javassist\344\275\277\347\224\250\346\214\207\345\215\227.md"
new file mode 100644
index 0000000..ec09307
--- /dev/null
+++ "b/java/javassist\344\275\277\347\224\250\346\214\207\345\215\227.md"
@@ -0,0 +1,1516 @@
+## 1. 读写字节码
+
+我们知道 Java 字节码以二进制的形式存储在 class 文件中，每一个 class 文件包含一个 Java 类或接口。Javaassist 就是一个用来处理 Java 字节码的类库。
+
+在 Javassist 中，类 `Javaassit.CtClass` 表示 class 文件。一个 GtClass (编译时类）对象可以处理一个 class 文件，下面是一个简单的例子：
+
+```java
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("test.Rectangle");
+cc.setSuperclass(pool.get("test.Point"));
+cc.writeFile();
+```
+
+这段代码首先获取一个 ClassPool 对象。ClassPool 是 CtClass 对象的容器。它按需读取类文件来构造 CtClass 对象，并且保存 CtClass 对象以便以后使用。
+
+为了修改类的定义，首先需要使用 ClassPool.get() 方法来从 ClassPool 中获得一个 CtClass 对象。上面的代码中，我们从 ClassPool 中获得了代表 test.Rectangle 类的 CtClass 对象的引用，并将其赋值给变量 cc。使用 getDefault() 方法获取的 ClassPool 对象使用的是默认系统的类搜索路径。
+
+从实现的角度来看，ClassPool 是一个存储 CtClass 的 Hash 表，类的名称作为 Hash 表的 key。ClassPool 的 get() 函数用于从 Hash 表中查找 key 对应的 CtClass 对象。如果没有找到，get() 函数会创建并返回一个新的 CtClass 对象，这个新对象会保存在 Hash 表中。
+
+从 ClassPool 中获取的 CtClass 是可以被修改的（稍后会讨论细节）。
+
+在上面的例子中，test.Rectangle 的父类被设置为 test.Point。调用 writeFile() 后，这项修改会被写入原始类文件。writeFile() 会将 CtClass 对象转换成类文件并写到本地磁盘。也可以使用 toBytecode() 函数来获取修改过的字节码：
+
+```java
+byte[] b = cc.toBytecode();
+```
+
+你也可以通过 toClass() 函数直接将 CtClass 转换成 Class 对象:
+
+```java
+Class clazz = cc.toClass();
+```
+
+toClass() 请求当前线程的 ClassLoader 加载 CtClass 所代表的类文件。它返回此类文件的 java.lang.Class 对象，更多细节，请参考[下面的章节](https://github.com/jboss-javassist/javassist/wiki/Tutorial-1#toclass)。
+
+定义新类
+
+使用 ClassPool 的 makeClass() 方法可以定义一个新类。
+
+```java
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.makeClass("Point");
+```
+
+这段代码定义了一个空的 Point 类。Point 类的成员方法可以通过 CtNewMethod 类的工厂方法来创建，然后使用 CtClass 的 addMethod() 方法将其添加到 Point 中。
+
+使用 ClassPool 中的 makeInterface() 方法可以创建新接口。接口中的方法可以使用 CtNewMethod 的 abstractMethod() 方法创建。
+
+将类冻结
+
+如果一个 CtClass 对象通过 writeFile(), toClass(), toBytecode() 被转换成一个类文件，此 CtClass 对象会被冻结起来，不允许再修改。因为一个类只能被 JVM 加载一次。
+
+但是，一个冷冻的 CtClass 也可以被解冻，例如：
+
+```java
+CtClasss cc = ...;
+    :
+cc.writeFile();
+cc.defrost();
+cc.setSuperclass(...);    // 因为类已经被解冻，所以这里可以调用成功
+```
+
+调用 defrost() 之后，此 CtClass 对象又可以被修改了。
+
+如果 ClassPool.doPruning 被设置为 true，Javassist 在冻结 CtClass 时，会修剪 CtClass 的数据结构。为了减少内存的消耗，修剪操作会丢弃 CtClass 对象中不必要的属性。例如，Code_attribute 结构会被丢弃。一个 CtClass 对象被修改之后，方法的字节码是不可访问的，但是方法名称、方法签名、注解信息可以被访问。修剪过的 CtClass 对象不能再次被解冻。ClassPool.doPruning 的默认值为 false。
+
+stopPruning() 可以用来驳回修剪操作。
+
+```java
+CtClasss cc = ...;
+cc.stopPruning(true);
+    :
+cc.writeFile(); // 转换成一个 class 文件
+// cc is not pruned.
+```
+
+这个 CtClass 没有被修剪，所以在 writeFile() 之后，可以被解冻。
+
+**注意**：调试的时候，你可能临时需要停止修剪和冻结，然后保存一个修改过的类文件到磁盘，debugWriteFile() 方法正是为此准备的。它停止修剪，然后写类文件，然后解冻并再次打开修剪（如果开始时修养是打开的）。
+
+类搜索路径
+
+通过 ClassPool.getDefault() 获取的 ClassPool 使用 JVM 的类搜索路径。如果程序运行在 JBoss 或者 Tomcat 等 Web 服务器上，ClassPool 可能无法找到用户的类，因为 Web 服务器使用多个类加载器作为系统类加载器。在这种情况下，ClassPool 必须添加额外的类搜索路径。
+
+下面的例子中，pool 代表一个 ClassPool 对象：
+
+```java
+pool.insertClassPath(new ClassClassPath(this.getClass()));
+```
+
+上面的语句将 this 指向的类添加到 pool 的类加载路径中。你可以使用任意 Class 对象来代替 this.getClass()，从而将 Class 对象添加到类加载路径中。
+
+也可以注册一个目录作为类搜索路径。下面的例子将 /usr/local/javalib 添加到类搜索路径中：
+
+```java
+ClassPool pool = ClassPool.getDefault();
+pool.insertClassPath("/usr/local/javalib");
+```
+
+类搜索路径不但可以是目录，还可以是 URL ：
+
+```java
+ClassPool pool = ClassPool.getDefault();
+ClassPath cp = new URLClassPath("www.javassist.org", 80, "/java/", "org.javassist.");
+pool.insertClassPath(cp);
+```
+
+上述代码将 [http://www.javassist.org:80/java/](http://www.javassist.org/java/) 添加到类搜索路径。并且这个URL只能搜索 `org.javassist` 包里面的类。例如，为了加载 `org.javassist.test.Main`，它的类文件会从获取 [http://www.javassist.org:80/java/org/javassist/test/Main.class](http://www.javassist.org/java/org/javassist/test/Main.class) 获取。
+
+此外，也可以直接传递一个 byte 数组给 ClassPool 来构造一个 CtClass 对象，完成这项操作，需要使用 ByteArrayPath 类。示例：
+
+```java
+ClassPool cp = ClassPool.getDefault();
+byte[] b = a byte array;
+String name = class name;
+cp.insertClassPath(new ByteArrayClassPath(name, b));
+CtClass cc = cp.get(name);
+```
+
+示例中的 CtClass 对象表示 b 代表的 class 文件。将对应的类名传递给 ClassPool 的 get() 方法，就可以从 ByteArrayClassPath 中读取到对应的类文件。
+
+如果你不知道类的全名，可以使用 makeClass() 方法：
+
+```java
+ClassPool cp = ClassPool.getDefault();
+InputStream ins = an input stream for reading a class file;
+CtClass cc = cp.makeClass(ins);
+```
+
+makeClass() 返回从给定输入流构造的 CtClass 对象。 你可以使用 makeClass() 将类文件提供给 ClassPool 对象。如果搜索路径包含大的 jar 文件，这可能会提高性能。由于 ClassPool 对象按需读取类文件，它可能会重复搜索整个 jar 文件中的每个类文件。 makeClass() 可以用于优化此搜索。由 makeClass() 构造的 CtClass 保存在 ClassPool 对象中，从而使得类文件不会再被读取。
+
+用户可以通过实现 ClassPath 接口来扩展类加载路径，然后调用 ClassPool 的 insertClassPath() 方法将路径添加进来。这种技术主要用于将非标准资源添加到类搜索路径中。
+
+## 2. ClassPool
+
+ClassPool 是 CtClass 对象的容器。因为编译器在编译引用 CtClass 代表的 Java 类的源代码时，可能会引用 CtClass 对象，所以一旦一个 CtClass 被创建，它就被保存在 ClassPool 中.
+
+例如，一个 CtClass 类代表 Point 类，并给 CtClass 添加 getter() 方法。然后，程序尝试编译一段代码，代码中包含了 Point 的 getter() 调用，然后将这段代码添加了另一个类 Line 中，如果代表 Point 的 CtClass 丢失，编译器就无法编译 Line 中的 Point.getter() 方法。注：原来的 Point 类中无 getter() 方法。因此，为了能够正确编译这个方法调用，ClassPool 必须在程序执行期间包含所有的 CtClass 实例。
+
+避免内存溢出
+
+如果 CtClass 对象的数量变得非常大（这种情况很少发生，因为 Javassist 试图以各种方式减少内存消耗），ClassPool 可能会导致巨大的内存消耗。 为了避免此问题，可以从 ClassPool 中显式删除不必要的 CtClass 对象。 如果对 CtClass 对象调用 detach()，那么该 CtClass 对象将被从 ClassPool 中删除。 例如：
+
+```java
+CtClass cc = ... ;
+cc.writeFile();
+cc.detach();
+```
+
+在调用 detach() 之后，就不能调用这个 CtClass 对象的任何方法了。但是如果你调用 ClassPool 的 get() 方法，ClassPool 会再次读取这个类文件，创建一个新的 CtClass 对象。
+
+另一个办法是用新的 ClassPool 替换旧的 ClassPool，并将旧的 ClassPool 丢弃。 如果旧的 ClassPool 被垃圾回收掉，那么包含在 ClassPool 中的 CtClass 对象也会被回收。要创建一个新的 ClassPool，参见以下代码：
+
+```java
+ClassPool cp = new ClassPool(true);
+// if needed, append an extra search path by appendClassPath()
+```
+
+这段代码创建了一个 ClassPool 对象，它的行为与 ClassPool.getDefault() 类似。 请注意，ClassPool.getDefault() 是为了方便而提供的单例工厂方法，它保留了一个`ClassPool`的单例并重用它。getDefault() 返回的 ClassPool 对象并没有特殊之处。
+
+**注意**：new ClassPool(true) 构造一个 ClassPool 对象，并附加了系统搜索路径。
+调用此构造函数等效于以下代码：
+
+```java
+ClassPool cp = new ClassPool();
+cp.appendSystemPath();  // or append another path by appendClassPath()
+```
+
+级联的 ClassPools
+
+如果程序正在 Web 应用程序服务器上运行，则可能需要创建多个 ClassPool 实例; 应为每一个 ClassLoader 创建一个 ClassPool 的实例。 程序应该通过 ClassPool 的构造函数，而不是调用 getDefault() 来创建一个 ClassPool 对象。
+多个 ClassPool 对象可以像 java.lang.ClassLoader 一样级联。 例如，
+
+```java
+ClassPool parent = ClassPool.getDefault();
+ClassPool child = new ClassPool(parent);
+child.insertClassPath("./classes");
+```
+
+如果调用 child.get()，子 ClassPool 首先委托给父 ClassPool。如果父 ClassPool 找不到类文件，那么子 ClassPool 会尝试在 ./classes 目录下查找类文件。
+
+如果 child.childFirstLookup 返回 true，那么子类 ClassPool 会在委托给父 ClassPool 之前尝试查找类文件。 例如：
+
+```java
+ClassPool parent = ClassPool.getDefault();
+ClassPool child = new ClassPool(parent);
+child.appendSystemPath();         // the same class path as the default one.
+child.childFirstLookup = true;    // changes the behavior of the child.
+```
+
+拷贝一个已经存在的类来定义一个新的类
+
+```java
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+cc.setName("Pair");
+```
+
+这个程序首先获得类 Point 的 CtClass 对象。然后它调用 setName() 将这个 CtClass 对象的名称设置为 Pair。在这个调用之后，这个 CtClass 对象所代表的类的名称 Point 被修改为 Pair。类定义的其他部分不会改变。
+
+**注意**：CtClass 中的 setName() 改变了 ClassPool 中的记录。从实现的角度来看，一个 ClassPool 对象是一个 CtClass 对象的哈希表。setName() 更改了与哈希表中的 CtClass 对象相关联的 Key。Key 从原始类名更改为新类名。
+
+因此，如果后续在 ClassPool 对象上再次调用 get("Point")，则它不会返回变量 cc 所指的 CtClass 对象。 而是再次读取类文件 Point.class，并为类 Point 构造一个新的 CtClass 对象。 因为与 Point 相关联的 CtClass 对象不再存在。示例：
+
+```java
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+CtClass cc1 = pool.get("Point");   // cc1 is identical to cc.
+cc.setName("Pair");
+CtClass cc2 = pool.get("Pair");    // cc2 is identical to cc.
+CtClass cc3 = pool.get("Point");   // cc3 is not identical to cc.
+```
+
+cc1 和 cc2 指向 CtClass 的同一个实例，而 cc3 不是。 注意，在执行 cc.setName("Pair") 之后，cc 和 cc1 引用的 CtClass 对象都表示 Pair 类。
+
+ClassPool 对象用于维护类和 CtClass 对象之间的一对一映射关系。 为了保证程序的一致性，Javassist 不允许用两个不同的 CtClass 对象来表示同一个类，除非创建了两个独立的 ClassPool。
+
+如果你有两个 ClassPool 对象，那么你可以从每个 ClassPool 中，获取一个表示相同类文件的不同的 CtClass 对象。 你可以修改这些 CtClass 对象来生成不同版本的类。
+
+通过重命名冻结的类来生成新的类
+
+一旦一个 CtClass 对象被 writeFile() 或 toBytecode() 转换为一个类文件，Javassist 会拒绝对该 CtClass 对象的进一步修改。因此，在表示 Point 类的 CtClass 对象被转换为类文件之后，你不能将 Pair 类定义为 Point 的副本，因为在 Point 上执行 setName() 会被拒绝。 以下代码段是错误的：
+
+```java
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+cc.writeFile();
+cc.setName("Pair");    // wrong since writeFile() has been called.
+```
+
+为了避免这种限制，你应该在 ClassPool 中调用 getAndRename() 方法。 例如：
+
+```java
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+cc.writeFile();
+CtClass cc2 = pool.getAndRename("Point", "Pair");
+```
+
+如果调用 getAndRename()，ClassPool 首先读取 Point.class 来创建一个新的表示 Point 类的 CtClass 对象。 而且，它会在这个 CtClass 被记录到哈希表之前，将 CtClass 对象重命名为 Pair。因此，getAndRename() 可以在表示 Point 类的 CtClass 对象上调用 writeFile() 或 toBytecode() 后执行。
+
+## 3. 类加载器 (Class Loader)
+
+如果事先知道要修改哪些类，修改类的最简单方法如下：
+
+1. 调用 ClassPool.get() 获取 CtClass 对象，
+2. 修改 CtClass
+3. 调用 CtClass 对象的 writeFile() 或者 toBytecode() 获得修改过的类文件。
+
+如果在加载时，可以确定是否要修改某个类，用户必须使 Javassist 与类加载器协作，以便在加载时修改字节码。用户可以定义自己的类加载器，也可以使用 Javassist 提供的类加载器。
+
+### 3.1 CtClass.toClass()
+
+CtClass 的 toClass() 方法请求当前线程的上下文类加载器，加载 CtClass 对象所表示的类。要调用此方法，调用者必须具有相关的权限; 否则，可能会抛出 SecurityException。示例：
+
+```java
+public class Hello {
+    public void say() {
+        System.out.println("Hello");
+    }
+}
+
+public class Test {
+    public static void main(String[] args) throws Exception {
+        ClassPool cp = ClassPool.getDefault();
+        CtClass cc = cp.get("Hello");
+        CtMethod m = cc.getDeclaredMethod("say");
+        m.insertBefore("{ System.out.println(\"Hello.say():\"); }");
+        Class c = cc.toClass();
+        Hello h = (Hello)c.newInstance();
+        h.say();
+    }
+}
+```
+
+Test.main() 在 Hello 中的 say() 方法体中插入一个 println()。然后它构造一个修改过的 Hello 类的实例，并在该实例上调用 say() 。
+**注意**：上面的程序要正常运行，Hello 类在调用 toClass() 之前不能被加载。 如果 JVM 在 toClass() 调用之前加载了原始的 Hello 类，后续加载修改的 Hello 类将会失败（LinkageError 抛出）。
+例如，如果 Test 中的 main() 是这样的：
+
+```java
+public static void main(String[] args) throws Exception {
+    Hello orig = new Hello();
+    ClassPool cp = ClassPool.getDefault();
+    CtClass cc = cp.get("Hello");
+        :
+}
+```
+
+那么，原始的 Hello 类在 main 的第一行被加载，toClass() 调用会抛出一个异常，因为类加载器不能同时加载两个不同版本的 Hello 类。
+
+如果程序在某些应用程序服务器（如JBoss和Tomcat）上运行，toClass() 使用的上下文类加载器可能是不合适的。在这种情况下，你会看到一个意想不到的 ClassCastException。为了避免这个异常，必须给 toClass() 指定一个合适的类加载器。 例如，如果 'bean' 是你的会话 bean 对象，那么下面的代码：
+
+```java
+CtClass cc = ...;
+Class c = cc.toClass(bean.getClass().getClassLoader());
+```
+
+可以工作。你应该给 toClass() 传递加载了你的程序的类加载器（上例中，`bean`对象的类）。
+
+toClass() 是为了简便而提供的方法。如果你需要更复杂的功能，你应该编写自己的类加载器。
+
+### 3.2 Java的类加载机制
+
+在Java中，多个类加载器可以共存，每个类加载器创建自己的名称空间。不同的类加载器可以加载具有相同类名的不同类文件。加载的两个类被视为不同的类。此功能使我们能够在单个 JVM 上运行多个应用程序，即使这些程序包含具有相同名称的不同的类。
+
+**注意**：JVM 不允许动态重新加载类。一旦类加载器加载了一个类，它不能在运行时重新加载该类的修改版本。因此，在JVM 加载类之后，你不能更改类的定义。但是，JPDA（Java平台调试器架构）提供有限的重新加载类的能力。参见[3.6节](https://blog.csdn.net/21aspnet/article/details/81671777#hotswap)。
+
+如果相同的类文件由两个不同的类加载器加载，则 JVM 会创建两个具有相同名称和定义的不同的类。由于两个类不相同，一个类的实例不能被分配给另一个类的变量。两个类之间的转换操作将失败并抛出一个 ClassCastException。
+例如，下面的代码会抛出异常：
+
+```java
+MyClassLoader myLoader = new MyClassLoader();
+Class clazz = myLoader.loadClass("Box");
+Object obj = clazz.newInstance();
+Box b = (Box)obj;    // this always throws ClassCastException.
+```
+
+Box 类由两个类加载器加载。假设类加载器 CL 加载包含此代码片段的类。因为这段代码引用了 MyClassLoader，Class，Object 和 Box，CL 也加载这些类（除非它委托给另一个类加载器）。 因此，变量 b 的类型是 CL 加载的 Box 类。 另一方面， myLoader 也加载了 Box class。 对象 obj 是由 myLoader 加载的 Box 类的一个实例。 因此，最后一个语句总是抛出 ClassCastException ，因为 obj 的类是一个不同的 Box 类的类型，而不是用作变量 b 的类型。
+
+多个类加载器形成一个树型结构。 除引导类加载器之外的每个类加载器，都有一个父类加载器，它通常加载该子类加载器的类。 因为加载类的请求可以沿类加载器的这个层次委派，所以即使你没有请求加载一个类，它也可能被加载。因此，已经请求加载类 C 的类加载器可以不同于实际加载类 C 的加载器。为了区分，我们将前加载器称为 C 的发起者，将后加载器称为 C 的实际加载器 。
+
+此外，如果请求加载类 C（C的发起者）的类加载器 CL 委托给父类加载器 PL，则类加载器 CL 不会加载类 C 引用的任何类。因为 CL 不是那些类的发起者。 相反，父类加载器 PL 成为它们的启动器，并且加载它们。
+
+请参考下面的例子来理解：
+
+```java
+public class Point {    // loaded by PL
+    private int x, y;
+    public int getX() { return x; }
+        :
+}
+
+public class Box {      // the initiator is L but the real loader is PL
+    private Point upperLeft, size;
+    public int getBaseX() { return upperLeft.x; }
+        :
+}
+
+public class Window {    // loaded by a class loader L
+    private Box box;
+    public int getBaseX() { return box.getBaseX(); }
+}
+```
+
+假设一个类 Window 由类加载器 L 加载。Window 的启动器和实际加载器都是 L。由于 Window 的定义引用了 Box，JVM 将请求 L 加载 Box。 这里，假设 L 将该任务委托给父类加载器 PL。Box 的启动器是 L，但真正的加载器是 PL。 在这种情况下，Point 的启动器不是 L 而是 PL，因为它与 Box 的实际加载器相同。 因此，Point 不会被 L 加载。
+
+接下来，看一个稍微修改过的例子：
+
+```java
+public class Point {
+    private int x, y;
+    public int getX() { return x; }
+        :
+}
+
+public class Box {      // the initiator is L but the real loader is PL
+    private Point upperLeft, size;
+    public Point getSize() { return size; }
+        :
+}
+
+public class Window {    // loaded by a class loader L
+    private Box box;
+    public boolean widthIs(int w) {
+        Point p = box.getSize();
+        return w == p.getX();
+    }
+}
+```
+
+现在，Window 的定义也引用了 Point。 在这种情况下，如果请求加载 Point，类加载器 L 也必须委托给 PL。 **你必须避免有两个类加载器两次加载同一个类**。两个加载器之一必须委托给另一个。
+
+当 Point 加载时，如果 L 不委托给 PL，widthIs() 就会抛出一个 ClassCastException 异常。因为 Box 的实际加载器是 PL，在 Box 中引用的 Point 也由 PL 加载。 getSize() 的结果值是由 PL 加载的 Point，widthIs() 中的变量 p 是由 L 加载的 Point。JVM 认为它们是不同的类型，因此它会抛出类型不匹配的异常。
+
+这种设计有点不方便，但也是必须的。
+
+```java
+Point p = box.getSize();
+```
+
+如果上面的语句没有抛出异常，那么 Window 的程序员可以破坏 Point 对象的封装。 例如，字段 x 在 PL 中加载的 Point 中是私有的。 然而，如果 L 加载具有以下定义的 Point，则 Window 类可以直接访问 x 的值：
+
+```java
+public class Point {
+    public int x, y;    // not private
+    public int getX() { return x; }
+        :
+}
+```
+
+有关 Java 类加载器的更多详细信息，可以参看以下文章：
+
+> Sheng Liang 和 Gilad Bracha，“Dynamic Class Loading in the Java Virtual Machine”，* ACM OOPSLA'98 *，pp.36-44,1998。
+
+### 3.3 使用 javassist.Loader
+
+Javassit 提供一个类加载器 javassist.Loader。它使用 javassist.ClassPool 对象来读取类文件。
+例如，javassist.Loader 可以用于加载用 Javassist 修改过的类。
+
+```java
+import javassist.*;
+import test.Rectangle;
+
+public class Main {
+  public static void main(String[] args) throws Throwable {
+     ClassPool pool = ClassPool.getDefault();
+     Loader cl = new Loader(pool);
+     CtClass ct = pool.get("test.Rectangle");
+     ct.setSuperclass(pool.get("test.Point"));
+     Class c = cl.loadClass("test.Rectangle");
+     Object rect = c.newInstance();
+         :
+  }
+}
+```
+
+这个程序将 test.Rectangle 的超类设置为 test.Point。然后再加载修改的类，并创建新的 test.Rectangle 类的实例。
+
+如果用户希望在加载时按需修改类，则可以向 javassist.Loader 添加事件监听器。当类加载器加载类时会通知监听器。事件监听器类必须实现以下接口：
+
+```java
+public interface Translator {
+    public void start(ClassPool pool)
+        throws NotFoundException, CannotCompileException;
+    public void onLoad(ClassPool pool, String classname)
+        throws NotFoundException, CannotCompileException;
+}
+```
+
+当事件监听器通过 addTranslator() 添加到 javassist.Loader 对象时，start() 方法会被调用。在 javassist.Loader 加载类之前，会调用 onLoad() 方法。可以在 onLoad() 方法中修改被加载的类的定义。
+
+例如，下面的事件监听器在类加载之前，将所有类更改为 public 类。
+
+```java
+public class MyTranslator implements Translator {
+    void start(ClassPool pool) throws NotFoundException, CannotCompileException {}
+    void onLoad(ClassPool pool, String classname) throws NotFoundException, CannotCompileException {
+        CtClass cc = pool.get(classname);
+        cc.setModifiers(Modifier.PUBLIC);
+    }
+}
+```
+
+注意，onLoad() 不必调用 toBytecode() 或 writeFile()，因为 javassist.Loader 会调用这些方法来获取类文件。
+
+要使用 MyTranslator 对象运行一个应用程序类 MyApp，主类代码如下：
+
+```java
+import javassist.*;
+
+public class Main2 {
+  public static void main(String[] args) throws Throwable {
+     Translator t = new MyTranslator();
+     ClassPool pool = ClassPool.getDefault();
+     Loader cl = new Loader();
+     cl.addTranslator(pool, t);
+     cl.run("MyApp", args);
+  }
+}
+```
+
+执行下面的命令来运行程序：
+
+```shell
+% java Main2 arg1 arg2...
+```
+
+类 MyApp 和其他应用程序类会被 MyTranslator 监听。
+
+注意，MyApp 不能访问 loader 类，如 Main2，MyTranslator 和 ClassPool，因为它们是由不同的加载器加载的。 应用程序类由 javassist.Loader 加载，而加载器类（例如 Main2）由默认的 Java 类加载器加载。
+
+javassist.Loader 以不同的顺序从 java.lang.ClassLoader 中搜索类。ClassLoader 首先将加载操作委托给父类加载器，只有当父类加载器无法找到它们时才尝试自己加载类。另一方面，javassist.Loader 尝试在委托给父类加载器之前加载类。它仅在以下情况下进行委派：
+
+1. 在 ClassPool 对象上调用 get() 找不到这个类；
+2. 这些类已经通过 delegateLoadingOf() 来指定由父类加载器加载。
+
+此搜索顺序允许 Javassist 加载修改过的类。但是，如果找不到修改的类，它将委托父类加载器来加载。一旦一个类被父类加载器加载，那个类中引用的其他类也将被父类加载器加载，因此它们是没有被修改的。 回想一下，C 类引用的所有类都由 C 的实际加载器加载的。如果你的程序无法加载修改的类，你应该确保所有使用该类的类都是由 javassist 加载的。
+
+### 3.4 自定义类加载器
+
+下面看一个简单的带 Javassist 的类加载器：
+
+```java
+import javassist.*;
+
+public class SampleLoader extends ClassLoader {
+    /* Call MyApp.main(). */
+    public static void main(String[] args) throws Throwable {
+        SampleLoader s = new SampleLoader();
+        Class c = s.loadClass("MyApp");
+        c.getDeclaredMethod("main", new Class[] { String[].class })
+         .invoke(null, new Object[] { args });
+    }
+
+    private ClassPool pool;
+
+    public SampleLoader() throws NotFoundException {
+        pool = new ClassPool();
+        pool.insertClassPath("./class"); // MyApp.class must be there.
+    }
+    /* 
+     * Finds a specified class.
+     * The bytecode for that class can be modified.
+     */
+    protected Class findClass(String name) throws ClassNotFoundException {
+        try {
+            CtClass cc = pool.get(name);
+            // *modify the CtClass object here*
+            byte[] b = cc.toBytecode();
+            return defineClass(name, b, 0, b.length);
+        } catch (NotFoundException e) {
+            throw new ClassNotFoundException();
+        } catch (IOException e) {
+            throw new ClassNotFoundException();
+        } catch (CannotCompileException e) {
+            throw new ClassNotFoundException();
+        }
+    }
+}
+```
+
+MyApp 类是一个应用程序。 要执行此程序，首先将类文件放在 ./class 目录下，它不能包含在类搜索路径中。 否则，MyApp.class 将由默认系统类加载器加载，它是 SampleLoader 的父加载器。目录名 ./class 由构造函数中的 insertClassPath() 指定。然后运行：
+
+```shell
+% java SampleLoader
+```
+
+类加载器会加载类 MyApp (./class/MyApp.class)，并使用命令行参数调用 MyApp.main()。
+
+这是使用 Javassist 的最简单的方法。 但是，如果你编写一个更复杂的类加载器，你可能需要更详细地了解 Java 的类加载机制。 例如，上面的程序将 MyApp 类放在与 SampleLoader 类不同的命名空间中，因为这两个类由不同的类装载器加载。 因此，MyApp 类不能直接访问类 SampleLoader。
+
+### 3.5 修改系统的类
+
+像 java.lang.String 这样的系统类只能被系统类加载器加载。因此，上面的 SampleLoader 或 javassist.Loader 在加载时不能修改系统类。系统类必须被静态地修改。下面的程序向 java.lang.String 添加一个新字段 hiddenValue：
+
+```java
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("java.lang.String");
+CtField f = new CtField(CtClass.intType, "hiddenValue", cc);
+f.setModifiers(Modifier.PUBLIC);
+cc.addField(f);
+cc.writeFile(".");
+```
+
+这段程序生成一个新文件 ./java/lang/String.class
+
+可以使用 MyApp 这样测试修改过的 String 类：
+
+```shell
+% java -Xbootclasspath/p:. MyApp arg1 arg2...
+```
+
+MyApp 的定义如下：
+
+```java
+public class MyApp {
+    public static void main(String[] args) throws Exception {
+        System.out.println(String.class.getField("hiddenValue").getName());
+    }
+}
+```
+
+如果修改过的 String 类被加载，MyApp 会打印出 hiddenValue。
+
+**注意**：如果应用使用此技术来覆盖 rt.jar 中的系统类，那么部署这个应用会违反 Java 2 运行时二进制代码许可协议。
+
+### 3.6 在运行时重新加载类
+
+如果 JVM 在启用 JPDA（Java平台调试器体系结构）的情况下启动，那么类可以被动态地重新加载。在 JVM 加载类之后，旧版本的类可以被卸载，新版本可以再次重新加载。也就是说，该类的定义可以在运行时动态被修改。然而，新的类定义必须与旧的类定义有些兼容。JVM 不允许两个版本之间的模式更改。它们必须具有相同的方法和字段。
+
+Javassist 提供了一个方便的类，用于在运行时重新加载类。更多相关信息，请参阅javassist.tools.HotSwapper 的 API 文档。
+
+## 4. 自省和自定制 (Introspection and customization)
+
+CtClass 提供了自省的方法。Javassist 的自省能力与 Java 反射 API 兼容。 CtClass 提供了 getName()，getSuperclass()，getMethods() 等方法来获取类的信息，也提供了修改类定义的方法（添加字段，添加构造函数、添加方法），同时也可以对方法体的语句进行检测。
+
+方法由 CtMethod 对象表示。CtMethod 提供了几个函数来修改方法的定义。
+**注意**，如果一个方法继承自一个超类，那么表示继承方法的 CtMethod 对象，同样也表示该超类中声明的方法。
+
+例如，如果类 Point 声明方法 move() ， Point 的子类 ColorPoint 不覆盖 move() ，那么在 Point 中声明的 move 和 ColorPoint 的 move 具有相同的 CtMethod。 如果由这个 CtMethod 对象表示的方法定义被修改，那么修改将反映在这两种方法上。 如果你只想修改 ColorPoint 中的 move() 方法，你首先必须在 Point 中加入 CtMethod 对象的副本 move() 。CtMethod 对象的副本可以通过 CtNewMethod.copy() 获得。
+
+Javassist 不允许删除方法或字段，但它允许更改名称。所以，如果一个方法是没有必要的，可以通过调用 CtMethod 的 setName() 和 setModifiers() 中将其改为一个私有方法。
+
+Javassist 不允许向现有方法添加额外的参数。你可以通过新建一个方法达到同样的效果。 例如，如果你想为一个方法添加一个额外的 int 参数 newZ 到 Point 类，
+
+```java
+void move(int newX, int newY) { x = newX; y = newY; }
+```
+
+你可以添加一个这样的方法到 Point 类：
+
+```java
+void move(int newX, int newY, int newZ) {
+    // do what you want with newZ.
+    move(newX, newY);
+}
+```
+
+Javassist 还提供了用于直接编辑原始类文件的低级API。
+例如，CtClass 中的 getClassFile() 返回一个表示类文件的 ClassFile 对象。CtMethod 的 getMethodInfo() 方法返回一个 MethodInfo 对象，表示类文件中的 method_info 结构。 低级API使用 Java 虚拟机规范中的词汇表。 用户必须具有类文件和字节码的知识。有关更多详细信息，请参考 [javassist.bytecode 包](https://link.jianshu.com/?t=tutorial3.html#intro)。
+
+由 Javassist 修改的类文件只有在使用以 $ 开头的特殊标识符时才需要 javassist.runtime 包来提供运行时支持。接下来的内容会讨论这些特殊标识符。在没有这些特殊标识符的情况下，在运行时修改类文件不需要 javassist.runtime 包或任何其他 Javassist 包。有关更多详细信息，请参阅 javassist.runtime 包的API文档。
+
+### 4.1 在方法体的开始/结尾处添加代码
+
+CtMethod 和 CtConstructor 提供了 insertBefore()，insertAfter() 和 addCatch() 方法。 它们可以将用 Java 编写的代码片段插入到现有方法中。Javassist 包括一个用于处理源代码的简单编译器，它接收用 Java 编写的源代码，并将其编译成 Java 字节码，并内联方法体中。
+
+也可以按行号来插入代码段（如果行号表包含在类文件中）。向 CtMethod 和 CtConstructor 中的 insertAt() 方法提供源代码和原始类定义中的源文件的行号，就可以将编译后的代码插入到指定行号位置。
+
+方法 insertBefore() ，insertAfter()，addCatch() 和 insertAt() 接收一个表示语句或语句块的 String 对象。一个语句是一个单一的控制结构，比如 if 和 while 或者以分号结尾的表达式。语句块是一组用大括号 {} 包围的语句。因此，以下每行都是有效语句或块的示例：
+
+```java
+System.out.println("Hello");
+{ System.out.println("Hello"); }
+if (i < 0) { i = -i; }
+```
+
+语句和语句块可以引用字段和方法。如果使用 -g 选项（在类文件中包含局部变量属性）编译该方法，则它们还可以引用方法的参数。 否则，它们必须通过特殊变量 $0，$1，$2，... 来访问方法参数，下面会讨论。不允许访问在方法中声明的局部变量，尽管在块中声明一个新的局部变量是允许的。但是，insertAt() 允许语句和块访问局部变量，前提是这些变量在指定的行号处可用，并且目标方法是使用 -g 选项编译的。
+
+传递给方法 insertBefore() ，insertAfter() ，addCatch() 和 insertAt() 的 String 对象是由Javassist 的编译器编译的。 由于编译器支持语言扩展，以 $ 开头的几个标识符有特殊的含义：
+
+| 符号                  | 含义                                            |
+| :-------------------- | :---------------------------------------------- |
+| `$0`, `$1`, `$2`, ... | `this` and 方法的参数                           |
+| `$args`               | 方法参数数组.它的类型为 `Object[]`              |
+| `$$`                  | 所有实参。例如, `m($$)` 等价于 `m($1,$2,`...`)` |
+| `$cflow(`...`)`       | `cflow` 变量                                    |
+| `$r`                  | 返回结果的类型，用于强制类型转换                |
+| `$w`                  | 包装器类型，用于强制类型转换                    |
+| `$_`                  | 返回值                                          |
+| `$sig`                | 类型为 java.lang.Class 的参数类型数组           |
+| `$type`               | 一个 java.lang.Class 对象，表示返回值类型       |
+| `$class`              | 一个 java.lang.Class 对象，表示当前正在修改的类 |
+
+$0, $1, $2, ...
+
+传递给目标方法的参数使用 $1，$2，... 访问，而不是原始的参数名称。 $1 表示第一个参数，$2 表示第二个参数，以此类推。 这些变量的类型与参数类型相同。 $0 等价于 `this` 指针。 如果方法是静态的，则 $0 不可用。
+
+下面有一些使用这些特殊变量的例子。假设一个类 Point:
+
+```java
+class Point {
+    int x, y;
+    void move(int dx, int dy) { x += dx; y += dy; }
+}
+```
+
+要在调用方法 move() 时打印 dx 和 dy 的值，请执行以下程序：
+
+```java
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+CtMethod m = cc.getDeclaredMethod("move");
+m.insertBefore("{ System.out.println($1); System.out.println($2); }");
+cc.writeFile();
+```
+
+请注意，传递给 insertBefore() 的源文本是用大括号 {} 括起来的。insertBefore() 只接受单个语句或用大括号括起来的语句块。
+
+修改后的类 Point 的定义是这样的：
+
+```java
+class Point {
+    int x, y;
+    void move(int dx, int dy) {
+        { System.out.println(dx); System.out.println(dy); }
+        x += dx; y += dy;
+    }
+}
+```
+
+`$1` and `$2` are replaced with `dx` and `dy`, respectively.
+`$1`, `$2`, `$3` ... are updatable. If a new value is assigend to one of those variables, then the value of the parameter represented by that variable is also updated.
+
+$1 和 $2 分别替换为 dx 和 dy。
+$1，$2，$3 ...是可更新的。如果这些变量被赋予新值，则由该变量表示的参数的值也将被更新。
+
+$args
+
+变量 $args 表示所有参数的数组。该变量的类型是 Object 类的数组。如果参数类型是原始类型（如 int），则该参数值将转换为包装器对象（如java.lang.Integer）以存储在 $args 中。 因此，如果第一个参数的类型是不是原始类型，那么 $args[0] 等于 $1。注意 $args[0] 不等于 $0，因为 $0 表示 `this`。
+
+如果 Object 的数组被分配给 $args，那么该数组的每个元素都被分配给每个参数。如果参数类型是基本类型，则相应元素的类型必须是包装类型。 在将值分配给参数之前，必须将该值从包装器类型转换为基本类型。
+
+$$
+
+变量 $$ 是所有参数列表的缩写，用逗号分隔。 例如，如果方法 move() 的有 3 个参数，则
+
+```
+move($1, $2, $3)
+```
+
+如果 move() 不带任何参数，则 move（
+
+）等同于move()。）等同于move()。
+
+可以与其他方法一起使用。 如果你写一个表达式：
+
+```
+exMove($$, context)
+```
+
+这个表达式等价于
+
+```
+exMove($1, $2, $3, context)
+```
+
+注意，$$ 开启了通用符号方法调用，它通常与稍后要介绍的 $proceed 一起使用。
+
+$cflow
+
+$ cflow表示 控制流。此只读变量返回特定方法的递归调用的深度。
+
+假设下面所示的方法由CtMethod对象cm表示：
+
+```java
+int fact(int n) {
+    if (n <= 1)
+        return n;
+    else
+        return n * fact(n - 1);
+}
+```
+
+要使用 $cflow，首先声明使用 $cflow 监视方法 fact() 的调用：
+
+```java
+CtMethod cm = ...;
+cm.useCflow("fact");
+```
+
+useCflow() 的参数是 $cflow 变量的标识符。任何有效的 Java 名称都可以用作标识符。标识符还可以包括 `.` ，例如，“my.Test.fact”是有效的标识符。
+
+然后，$cflow(fact) 表示由 cm 指定的方法的递归调用深度。$cflow(fact) 的值在方法第一次调用时为 0，而当方法在方法中递归调用时为 1。 例如，
+
+```java
+cm.insertBefore("if ($cflow(fact) == 0)"
+              + "    System.out.println(\"fact \" + $1);");
+```
+
+翻译方法fact()，以便它显示参数。因为检查了 $cflow(fact) 的值，所以如果在 fact() 中递归调用，则方法 fact() 不会显示参数。
+
+$cflow 的值是当前线程的最顶层堆栈帧下与 cm 相关联的堆栈帧数。 $cflow 也可以不在 cm 方法中访问。
+
+$r
+
+$r 表示方法的结果类型（返回类型）。它用在 cast 表达式中作 cast 转换类型。 下面是一个典型的用法：
+
+```java
+Object result = ... ;
+$_ = ($r)result;
+```
+
+如果结果类型是原始类型，则 ($r) 遵循特殊语义。 首先，如果 cast 表达式的操作数是原始类型，($r) 作为普通转换运算符。 另一方面，如果操作数是包装类型，($r) 将从包装类型转换为结果类型。 例如，如果结果类型是 int，那么 ($r) 将从 java.lang.Integer 转换为 int。
+
+如果结果类型为void，那么 ($r) 不转换类型; 它什么也不做。 但是，如果操作数是对 void 方法的调用，则 ($r) 将导致 null。 例如，如果结果类型是 void，而 foo() 是一个 void 方法，那么
+
+```
+$_ = ($r)foo();
+```
+
+是一个正确的表达式。
+
+cast 运算符 ($r) 在 return 语句中也很有用。 即使结果类型是 void，下面的 return 语句也是有效的：
+
+```
+return ($r)result;
+```
+
+这里，result是局部变量。 因为指定了 ($r)，所以结果值被丢弃。此返回语句被等价于:
+
+```
+return;
+```
+
+$w
+
+$w 表示包装类型。它用在 cast 表达式中作 cast 转换类型。($w) 把基本类型转换为包装类型。 以下代码是一个示例：
+
+```
+Integer i = ($w)5;
+```
+
+包装后的类型取决于 ($w) 后面表达式的类型。如果表达式的类型为 double，则包装器类型为 java.lang.Double。
+
+If the type of the expression following `($w)` is not a primitive type, then `($w)` does nothing.
+如果下面的表达式 ($w) 的类型不是原始类型，那么($w) 什么也不做。
+
+$_
+
+CtMethod 中的 insertAfter() 和 CtConstructor 在方法的末尾插入编译的代码。传递给insertAfter() 的语句中，不但可以使用特殊符号如 $0，$1。也可以使用 $_ 来表示方法的结果值。
+该变量的类型是方法的结果类型（返回类型）。如果结果类型为 void，那么 $_ 的类型为Object，$_ 的值为 null。
+虽然由 insertAfter() 插入的编译代码通常在方法返回之前执行，但是当方法抛出异常时，它也可以执行。要在抛出异常时执行它，insertAfter() 的第二个参数 asFinally 必须为true。
+如果抛出异常，由 insertAfter() 插入的编译代码将作为 finally 子句执行。$_ 的值 0 或 null。在编译代码的执行终止后，最初抛出的异常被重新抛出给调用者。注意，$_ 的值不会被抛给调用者，它将被丢弃。
+
+$sig
+
+$sig 的值是一个 java.lang.Class 对象的数组，表示声明的形式参数类型。
+
+$type
+
+$type 的值是一个 java.lang.Class 对象，表示结果值的类型。 如果这是一个构造函数，此变量返回 Void.class。
+
+$class
+
+$class 的值是一个 java.lang.Class 对象，表示编辑的方法所在的类。 即表示 $0 的类型。
+
+addCatch()
+
+addCatch() 插入方法体抛出异常时执行的代码，控制权会返回给调用者。 在插入的源代码中，异常用 $e 表示。
+
+例如：
+
+```java
+CtMethod m = ...;
+CtClass etype = ClassPool.getDefault().get("java.io.IOException");
+m.addCatch("{ System.out.println($e); throw $e; }", etype);
+```
+
+转换成对应的 java 代码如下：
+
+```java
+try {
+    // the original method body
+} catch (java.io.IOException e) {
+    System.out.println(e);
+    throw e;
+}
+```
+
+请注意，插入的代码片段必须以 throw 或 return 语句结束。
+
+### 4.2 修改方法体
+
+CtMethod 和 CtConstructor 提供 setBody() 来替换整个方法体。他将新的源代码编译成 Java 字节码，并用它替换原方法体。 如果给定的源文本为 null，则替换后的方法体仅包含返回语句，返回零或空值，除非结果类型为 void。
+
+在传递给 setBody() 的源代码中，以 $ 开头的标识符具有特殊含义：
+
+| 符号                  | 含义                                            |
+| :-------------------- | :---------------------------------------------- |
+| `$0`, `$1`, `$2`, ... | `this` and 方法的参数                           |
+| `$args`               | 方法参数数组.它的类型为 `Object[]`              |
+| `$$`                  | 所有实参。例如, `m($$)` 等价于 `m($1,$2,`...`)` |
+| `$cflow(`...`)`       | `cflow` 变量                                    |
+| `$r`                  | 返回结果的类型，用于强制类型转换                |
+| `$w`                  | 包装器类型，用于强制类型转换                    |
+| `$sig`                | 类型为 java.lang.Class 的参数类型数组           |
+| `$type`               | 一个 java.lang.Class 对象，表示返回值类型       |
+| `$class`              | 一个 java.lang.Class 对象，表示当前正在修改的类 |
+
+注意 $_ 不可用。
+
+替换表达式
+
+Javassist 只允许修改方法体中包含的表达式。javassist.expr.ExprEditor 是一个用于替换方法体中的表达式的类。用户可以定义 ExprEditor 的子类来指定修改表达式的方式。
+
+要运行 ExprEditor 对象，用户必须在 CtMethod 或 CtClass 中调用 instrument()。
+例如，
+
+```java
+CtMethod cm = ... ;
+cm.instrument(
+    new ExprEditor() {
+        public void edit(MethodCall m) throws CannotCompileException {
+            if (m.getClassName().equals("Point")
+                          && m.getMethodName().equals("move"))
+                m.replace("{ $1 = 0; $_ = $proceed($$); }");
+        }
+    });
+```
+
+上述代码，搜索由 cm 表示的方法体，并用使用下面的代码替换 Point 中的 move()调用：
+
+```
+{ $1 = 0; $_ = $proceed($$); }
+```
+
+因此 move() 的第一个参数总是0。注意，替换的代码不是一个表达式，而是一个语句或块。 它不能是或包含 try-catch 语句。
+
+方法 instrument() 搜索方法体。 如果它找到一个表达式，如方法调用、字段访问和对象创建，那么它调用给定的 ExprEditor 对象上的 edit() 方法。 edit() 的参数表示找到的表达式。 edit() 可以检查和替换该表达式。
+
+调用 edit() 参数的 replace() 方法可以将表达式替换为我们给定的语句。如果给定的语句是空块，即执行replace("{}")，则将表达式删除。如果要在表达式之前或之后插入语句（或块），则应该将类似以下的代码传递给 replace()：
+
+```
+{ *before-statements;*
+  $_ = $proceed($$);
+  *after-statements;* }
+```
+
+无论表达式是方法调用、字段访问还是对象创建或其他。
+
+如果表达式是读操作，第二个语句应该是：
+
+```
+$_ = $proceed();
+```
+
+如果表达式是写操作，则第二个语句应该是：
+
+```
+$proceed($$);
+```
+
+如果由 instrument() 搜索的方法是使用 -g 选项（类文件包含一个局部变量属性）编译的，目标表达式中可用的局部变量，也可以传递给 replace() 的源代码中使用。
+
+javassist.expr.MethodCall
+
+MethodCall 表示方法调用。MethodCall 的 replace() 方法用于替换方法调用，它接收表示替换语句或块的源代码。和 insertBefore() 方法一样，传递给 replace 的源代码中，以 $ 开头的标识符具有特殊的含义。
+
+| 符号          | 含义                                                         |
+| :------------ | :----------------------------------------------------------- |
+| `$0`          | 方法调用的目标对象。它不等于 this，它代表了调用者。 如果方法是静态的，则 $0 为 null |
+| `$1`, `$2` .. | 方法的参数                                                   |
+| `$_`          | 方法调用的结果                                               |
+| `$r`          | 返回结果的类型，用于强制类型转换                             |
+| `$class`      | 一个 java.lang.Class 对象，表示当前正在修改的类              |
+| `$sig`        | 类型为 java.lang.Class 的参数类型数组                        |
+| `$type`       | 一个 java.lang.Class 对象，表示返回值类型                    |
+| `$class`      | 一个 java.lang.Class 对象，表示当前正在修改的类              |
+| `$proceed`    | 调用表达式中方法的名称                                       |
+
+这里的方法调用意味着由 MethodCall 对象表示的方法。
+
+其他标识符如 $w，$args 和 $$ 也可用。
+
+除非方法调用的返回类型为 void，否则返回值必须在源代码中赋给 $_，$_ 的类型是表达式的结果类型。如果结果类型为 void，那么 $_ 的类型为Object，并且分配给 $_ 的值将被忽略。
+
+$proceed 不是字符串值，而是特殊的语法。 它后面必须跟一个由括号括起来的参数列表。
+
+javassist.expr.ConstructorCall
+
+ConstructorCall 表示构造函数调用，例如包含在构造函数中的 this() 和 super()。ConstructorCall 中的方法 replace() 可以使用语句或代码块来代替构造函数。它接收表示替换语句或块的源代码。和 insertBefore() 方法一样，传递给 replace 的源代码中，以 $ 开头的标识符具有特殊的含义。
+
+| 符号            | 含义                                            |
+| :-------------- | :---------------------------------------------- |
+| `$0`            | 构造调用的目标对象。它等于 this                 |
+| `$1`, `$2`, ... | 构造函数的参数                                  |
+| `$class`        | 一个 java.lang.Class 对象，表示当前正在修改的类 |
+| `$sig`          | 类型为 java.lang.Class 的参数类型数组           |
+| `$proceed`      | 调用表达式中构造函数的名称                      |
+
+这里的构造函数调用是由 ConstructorCall 对象表示的。
+
+其他标识符如 $w，$args 和 $$ 也可用。
+
+由于任何构造函数必须调用超类的构造函数或同一类的另一个构造函数，所以替换语句必须包含构造函数调用，通常是对 $proceed() 的调用。
+
+$proceed 不是字符串值，而是特殊的语法。 它后面必须跟一个由括号括起来的参数列表。
+
+javassist.expr.FieldAccess
+
+FieldAccess 对象表示字段访问。 如果找到对应的字段访问操作，ExprEditor 中的 edit() 方法将接收到一个 FieldAccess 对象。FieldAccess 中的 replace() 方法接收替源代码来替换字段访问。
+
+在源代码中，以 $ 开头的标识符具有特殊含义：
+
+| 符号       | 含义                                                         |
+| :--------- | :----------------------------------------------------------- |
+| `$0`       | 表达式访问的字段。它不等于 this。this 表示调用表达式所在方法的对象。如果字段是静态的，则 $0 为 null |
+| `$1`       | 如果表达式是写操作，则写的值将保存在 $1 中。否则 $1 不可用   |
+| `$_`       | 如果表达式是读操作，则结果值保存在 $1 中，否则将舍弃存储在 $_ 中的值 |
+| `$r`       | 如果表达式是读操作，则 $r 读取结果的类型。 否则 $r 为 void   |
+| `$class`   | 一个 java.lang.Class 对象，表示字段所在的类                  |
+| `$type`    | 一个 java.lang.Class 对象，表示字段的类型                    |
+| `$proceed` | 执行原始字段访问的虚拟方法的名称                             |
+
+其他标识符如 $w，$args 和 $$ 也可用。
+如果表达式是读操作，则必须在源文本中将值分配给 $。 $的类型是字段的类型。
+
+javassist.expr.NewExpr
+
+NewExpr 表示使用 new 运算符（不包括数组创建）创建对象的表达式。 如果发现创建对象的操作，NewEditor 中的 edit() 方法将接收到一个 NewExpr 对象。NewExpr 中的 replace() 方法接收替源代码来替换字段访问。
+
+在源文本中，以 $ 开头的标识符具有特殊含义：
+
+| 符号       | 含义                                            |
+| :--------- | :---------------------------------------------- |
+| `$0`       | null                                            |
+| `$1`       | 构造函数的参数                                  |
+| `$_`       | 创建对象的返回值。一个新的对象存储在 $_ 中      |
+| `$r`       | 所创建的对象的类型                              |
+| `$sig`     | 类型为 java.lang.Class 的参数类型数组           |
+| `$type`    | 一个 java.lang.Class 对象，表示创建的对象的类型 |
+| `$proceed` | 执行对象创建虚拟方法的名称                      |
+
+其他标识符如 $w，$args 和 $$ 也可用。
+
+javassist.expr.NewArray
+
+NewArray 表示使用 new 运算符创建数组。如果发现数组创建的操作，ExprEditor 中的 edit() 方法一个 NewArray 对象。NewArray 中的 replace() 方法可以使用源代码来替换数组创建操作。
+
+在源文本中，以$开头的标识符具有特殊含义：
+
+| 符号       | 含义                                            |
+| :--------- | :---------------------------------------------- |
+| `$0`       | null                                            |
+| `$1`, `$1` | 每一维的大小                                    |
+| `$_`       | 创建数组的返回值。一个新的数组对象存储在 $_ 中  |
+| `$r`       | 所创建的数组的类型                              |
+| `$type`    | 一个 java.lang.Class 对象，表示创建的数组的类型 |
+| `$proceed` | 执行数组创建虚拟方法的名称                      |
+
+其他标识符如 $w，$args 和 $$ 也可用。
+例如，如果按下面的方式创建数组：
+
+```
+String[][] s = new String[3][4];
+```
+
+那么 $1 和 $2 的值分别是 3 和 4。 $3 不可用。
+
+例如，如果按下面的方式创建数组：
+
+```
+String[][] s = new String[3][];
+```
+
+那么 $1 的值为 3，但 $2 不可用。
+
+javassist.expr.Instanceof
+
+一个 InstanceOf 对象表示一个 instanceof 表达式。 如果找到 instanceof 表达式，则ExprEditor 中的 edit() 方法接收此对象。Instanceof 中的 replace() 方法可以使用源代码来替换 instanceof 表达式。
+
+在源文本中，以$开头的标识符具有特殊含义：
+
+| 符号       | 含义                                                         |
+| :--------- | :----------------------------------------------------------- |
+| `$0`       | null                                                         |
+| `$1`       | instanceof 运算符左侧的值                                    |
+| `$_`       | 表达式的返回值。类型为 boolean                               |
+| `$r`       | instanceof 运算符右侧的值                                    |
+| `$type`    | 一个 java.lang.Class 对象，表示 instanceof 运算符右侧的类型  |
+| `$proceed` | 执行 instanceof 表达式的虚拟方法的名称。它需要一个参数（类型是 java.lang.Object）。如果参数类型和 instanceof 表达式右侧的类型一致，则返回 true。否则返回 false。 |
+
+其他标识符如 $w，$args 和 $$ 也可用。
+
+javassist.expr.Cast
+
+Cast 表示 cast 表达式。如果找到 cast 表达式，ExprEditor 中的 edit() 方法会接收到一个 Cast 对象。 Cast 的 replace() 方法可以接收源代码来替换替换 �cast 表达式。
+
+在源文本中，以$开头的标识符具有特殊含义：
+
+| 符号       | 含义                                                         |
+| :--------- | :----------------------------------------------------------- |
+| `$0`       | null                                                         |
+| `$1`       | 显示类型转换的目标类型（？）                                 |
+| `$_`       | 表达式的结果值。$_ 的类型和被括号括起来的类型相同（？）      |
+| `$r`       | 转换之后的类型，即被括号括起来的类型（？）                   |
+| `$type`    | 一个 java.lang.Class 对象，和 $r 的类型相同                  |
+| `$proceed` | 执行类型转换的虚拟方法的名称。它需要一个参数（类型是 java.lang.Object）。并在类型转换完成后返回它 |
+
+其他标识符如 $w，$args 和 $$ 也可用。
+
+javassist.expr.Handler
+
+Handler 对象表示 try-catch 语句的 catch 子句。 如果找到 catch，ExprEditor 中的 edit() 方法会接收此对象。 Handler 中的 insertBefore() 方法会将收到的源代码插入到 catch 子句的开头。
+
+在源文本中，以$开头的标识符具有意义：
+
+| 符号    | 含义                                                   |
+| :------ | :----------------------------------------------------- |
+| `$1`    | catch 分支获得的异常对象                               |
+| `$r`    | catch 分支获得的异常对象的类型，用于强制类型转换       |
+| `$w`    | 包装类型，用于强制类型转换                             |
+| `$type` | 一个 java.lang.Class 对象，表示 catch 捕获的异常的类型 |
+
+如果一个新的异常分配给 $1，它将作为捕获的异常传递给原始的 catch 子句。
+
+### 4.3 添加新方法和字段
+
+添加新方法
+
+Javassist 可以创建新的方法和构造函数。CtNewMethod 和 CtNewConstructor 提供了几个工厂方法来创建 CtMethod 或 CtConstructor 对象。make() 方法可以通过源代码来CtMethod 或 CtConstructor 对象。
+
+例如：
+
+```java
+CtClass point = ClassPool.getDefault().get("Point");
+CtMethod m = CtNewMethod.make(
+                 "public int xmove(int dx) { x += dx; }",
+                 point);
+point.addMethod(m);
+```
+
+上面的代码向类 Point 添加了一个公共方法 xmove()。在这个例子中，x 是类 Point 的一个int 字段。
+
+传递给 make() 和 setBody() 的源文本可以包括以 $ 开头的标识符 ($_ 除外)。 如果目标对象和目标方法名也被传递给 make() 方法，源文本中也可以包括 $proceed。
+
+例如：
+
+```java
+CtClass point = ClassPool.getDefault().get("Point");
+CtMethod m = CtNewMethod.make(
+                 "public int ymove(int dy) { $proceed(0, dy); }",
+                 point, "this", "move");
+```
+
+这个程序创建一个 ymove() 方法，定义如下：
+
+```
+public int ymove(int dy) { this.move(0, dy); }
+```
+
+注意，$proceed 已经被替换为 this.move。
+
+Javassist 还提供了另一种添加新方法的方式。 你可以先创建一个抽象方法，然后给它一个方法体：
+
+```java
+CtClass cc = ... ;
+CtMethod m = new CtMethod(CtClass.intType, "move",
+                          new CtClass[] { CtClass.intType }, cc);
+cc.addMethod(m);
+m.setBody("{ x += $1; }");
+cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);
+```
+
+因为 Javassist 在类中添加了的方法是抽象的，所以在调用 setBody() 之后，必须将类显式地改回非抽象类。
+
+相互递归的方法 (Mutual recursive methods)
+
+Javassist 不能这种方法：如果它调用另一个方法，而另一个方法没有被添加到一个类（Javassist可以编译一个以递归方式调用的方法）。如果要向类添加相互递归方法，需要使用如下的技巧。假设你想要将方法 m() 和 n() 添加到由 cc 表示的类中：
+
+```java
+CtClass cc = ... ;
+CtMethod m = CtNewMethod.make("public abstract int m(int i);", cc);
+CtMethod n = CtNewMethod.make("public abstract int n(int i);", cc);
+cc.addMethod(m);
+cc.addMethod(n);
+m.setBody("{ return ($1 <= 0) ? 1 : (n($1 - 1) * $1); }");
+n.setBody("{ return m($1); }");
+cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);
+```
+
+你必须先创建两个抽象方法，并将它们添加到类中。然后设置它们的方法体，即使方法体包括互相递归的调用。 最后，必须将类更改为非抽象类。
+
+添加一个字段
+
+Javassist 还允许用户创建一个新字段。
+
+```java
+CtClass point = ClassPool.getDefault().get("Point");
+CtField f = new CtField(CtClass.intType, "z", point);
+point.addField(f);
+```
+
+该程序向类 Point 添加一个名为 z 的字段。
+如果必须指定添加字段的初始值，那么上面的程序必须修改为：
+
+```java
+CtClass point = ClassPool.getDefault().get("Point");
+CtField f = new CtField(CtClass.intType, "z", point);
+point.addField(f, "0");  // initial value is 0
+```
+
+现在，方法 addField() 接收两个参数，第二个参数表示计算初始值的表达式。这个表达式可以是任意 Java 表达式，只要其结果与字段的类型匹配。 请注意，表达式不以分号结尾。
+
+此外，上述代码可以重写为更简单代码：
+
+```java
+CtClass point = ClassPool.getDefault().get("Point");
+CtField f = CtField.make("public int z = 0;", point);
+point.addField(f);
+```
+
+删除成员
+
+要删除字段或方法，请在 CtClass 的 removeField() 或 removeMethod() 方法。 一个CtConstructor 可以通过 CtClass 的 removeConstructor() 删除。
+
+### 4.4 注解 (Annotations)
+
+CtClass，CtMethod，CtField 和 CtConstructor 提供 getAnnotations() 方法，用于读取注解。 它返回一个注解类型的对象。
+
+例如，假设有以下注解：
+
+```java
+public @interface Author {
+    String name();
+    int year();
+}
+```
+
+下面是使用注解的代码：
+
+```java
+@Author(name="Chiba", year=2005)
+public class Point {
+    int x, y;
+}
+```
+
+然后，可以使用 getAnnotations() 获取注解的值。 它返回一个包含注解类型对象的数组。
+
+```java
+CtClass cc = ClassPool.getDefault().get("Point");
+Object[] all = cc.getAnnotations();
+Author a = (Author)all[0];
+String name = a.name();
+int year = a.year();
+System.out.println("name: " + name + ", year: " + year);
+```
+
+这段代码输出：
+
+```
+name: Chiba, year: 2005
+```
+
+由于 Point 的注解只有 @Author，所以数组的长度是 1，all[0] 是一个 Author 对象。 注解成员值可以通过调用Author对象的 name() 和 year() 来获取。
+
+要使用 getAnnotations()，注释类型（如 Author）必须包含在当前类路径中。它们也必须也可以从 ClassPool 对象访问。如果未找到注释类型的类文件，Javassist 将无法获取该注释类型的成员的默认值。
+
+### 4.5 运行时支持类
+
+在大多数情况下，使用 Javassist 修改类不需要运行 Javassist。 但是，Javassist 编译器生成的某些字节码需要运行时支持类，这些类位于 javassist.runtime 包中（有关详细信息，请阅读该包的API文档）。请注意，javassist.runtime 是修改的类时唯一可能需要使用的包。 修改类的运行时不会再使用其他的 Javassist 类。
+
+### 4.6 导入（Import）
+
+源代码中的所有类名都必须是完整的（必须包含包名，java.lang 除外）。例如，Javassist 编译器可以解析 Object 以及 java.lang.Object。
+
+要告诉编译器在解析类名时搜索其他包，请在 ClassPool中 调用 importPackage()。 例如，
+
+```java
+ClassPool pool = ClassPool.getDefault();
+pool.importPackage("java.awt");
+CtClass cc = pool.makeClass("Test");
+CtField f = CtField.make("public Point p;", cc);
+cc.addField(f);
+```
+
+第二行导入了 java.awt 包。 因此，第三行不会抛出异常。 编译器可以将 Point 识别为java.awt.Point。
+
+注意 importPackage() 不会影响 ClassPool 中的 get() 方法。只有编译器才考虑导入包。 get() 的参数必须是完整类名。
+
+### 4.7 限制 (Limitations)
+
+在目前实现中，Javassist 中包含的 Java 编译器有一些限制：
+
+- J2SE 5.0 引入的新语法（包括枚举和泛型）不受支持。注释由 Javassist 的低级 API 支持。 参见 javassist.bytecode.annotation 包（以及 CtClass 和 CtBehavior 中的� getAnnotations()）。对泛型只提供部分支持。更多信息，请参阅后面的部分；
+- 初始化数组时，只有一维数组可以用大括号加逗号分隔元素的形式初始化，多维数组还不支持；
+- 编译器不能编译包含内部类和匿名类的源代码。 但是，Javassist 可以读取和修改内部/匿名类的类文件；
+- 不支持带标记的 continue 和 break 语句；
+- 编译器没有正确实现 Java 方法调度算法。编译器可能会混淆在类中定义的重载方法（方法名称相同，查参数列表不同）。例如：
+
+```java
+class A {} 
+
+class B extends A {} 
+
+class C extends B {} 
+
+class X { 
+    void foo(A a) { .. } 
+    void foo(B b) { .. } 
+}
+```
+
+如果编译的表达式是 `x.foo(new C())`，其中 `x` 是 `X` 的实例，编译器将产生对 `foo(A)` 的调用，尽管编译器可以正确地编译 `foo((B) new C())` 。
+
+- 建议使用 # 作为类名和静态方法或字段名之间的分隔符。 例如，在常规 Java 中，
+
+```
+javassist.CtClass.intType.getName()
+```
+
+在 javassist.CtClass 中的静态字段 intType 指示的对象上调用一个方法 getName()。 在Javassist 中，用户也可以写上面的表达式，但是建议写成这样：
+
+```
+javassist.CtClass#intType.getName()
+```
+
+使编译器可以快速解析表达式。
+
+## 5. 字节码操作
+
+Javassist 还提供了用于直接编辑类文件的低级级 API。 使用此 API之前，你需要详细了解Java 字节码和类文件格式，因为它允许你对类文件进行任意修改。
+
+如果你只想生成一个简单的类文件，使用`javassist.bytecode.ClassFileWriter`就足够了。 它比`javassist.bytecode.ClassFile`更快而且更小。
+
+### 获取 ClassFile 对象
+
+javassist.bytecode.ClassFile 对象表示类文件。要获得这个对象，应该调用 CtClass 中的 getClassFile() 方法。
+你也可以直接从类文件构造 javassist.bytecode.ClassFile 对象。 例如：
+
+```java
+BufferedInputStream fin
+    = new BufferedInputStream(new FileInputStream("Point.class"));
+ClassFile cf = new ClassFile(new DataInputStream(fin));
+```
+
+这代码段从 Point.class 创建一个 ClassFile 对象。
+ClassFile 对象可以写回类文件。ClassFile 的 write() 将类文件的内容写入给定的 DataOutputStream。
+
+### 5.2 添加和删除成员
+
+ClassFile 提供了 addField()，addMethod() 和 addAttribute()，来向类添加字段、方法和类文件属性。
+
+注意，FieldInfo，MethodInfo 和 AttributeInfo 对象包括到 ConstPool（常量池表）对象的链接。 ConstPool 对象必须对 ClassFile 对象和添加到该 ClassFile 对象的 FieldInfo（或MethodInfo 等）对象是通用的。 换句话说，FieldInfo（或MethodInfo等）对象不能在不同的ClassFile 对象之间共享。
+
+要从 ClassFile 对象中删除字段或方法，必须首先获取包含该类的所有字段的 java.util.List 对象。 getFields() 和 getMethods() 返回列表。可以通过在List对象上调用 remove() 来删除字段或方法。可以以类似的方式去除属性。在 FieldInfo 或 MethodInfo 中调用 getAttributes() 以获取属性列表，并从列表中删除一个。
+
+### 5.3 遍历方法体
+
+使用 CodeIterator 可以检查方法体中的每个字节码指令，要获得 CodeIterator 对象，参考以下代码：
+
+```java
+ClassFile cf = ... ;
+MethodInfo minfo = cf.getMethod("move");    // we assume move is not overloaded.
+CodeAttribute ca = minfo.getCodeAttribute();
+CodeIterator ci = ca.iterator();
+```
+
+CodeIterator 对象允许你逐个访问每个字节码指令。下面展示了一部分 CodeIterator 中声明的方法：
+
+- void begin（）
+  移动到第一条指令。
+- void move（int index）
+  移动到指定位置的指令。
+- boolean hasNext（）
+  是否有下一条指定
+- int next（）
+  返回下一条指令的索引。注意，它不返回下一条指令的操作码。
+- int byteAt（int index）
+  返回索引处的无符号8位整数。
+- int u16bitAt（int index）
+  返回索引处的无符号16位整数。
+- int write（byte [] code，int index）
+  在索引处写入字节数组。
+- void insert（int index，byte [] code）
+  在索引处插入字节数组。自动调整分支偏移量。
+
+以下代码段打印了方法体中所有的指令：
+
+```java
+CodeIterator ci = ... ;
+while (ci.hasNext()) {
+    int index = ci.next();
+    int op = ci.byteAt(index);
+    System.out.println(Mnemonic.OPCODE[op]);
+}
+```
+
+### 5.4 生成字节码序列
+
+`Bytecode` 对象表示字节码指令序列。它是一个可扩展的字节码数组。
+以下是示例代码段：
+
+```java
+ConstPool cp = ...;    // constant pool table
+Bytecode b = new Bytecode(cp, 1, 0);
+b.addIconst(3);
+b.addReturn(CtClass.intType);
+CodeAttribute ca = b.toCodeAttribute();
+```
+
+这段代码产生以下序列的代码属性：
+
+```
+iconst_3
+ireturn
+```
+
+您还可以通过调用 Bytecode 中的 get() 方法来获取包含此序列的字节数组。获得的数组可以插入另一个代码属性。
+Bytecode 提供了许多方法来添加特定的指令，例如使用 addOpcode() 添加一个 8 位操作码，使用 addIndex() 用于添加一个索引。每个操作码的值定义在 Opcode 接口中。
+addOpcode() 和添加特定指令的方法，将自动维持最大堆栈深度，除非控制流没有分支。可以通过调用 Bytecode 的 getMaxStack() 方法来获得这个深度。它也反映在从 Bytecode对象构造的 CodeAttribute 对象上。要重新计算方法体的最大堆栈深度，可以调用 CodeAttribute 的 computeMaxStack() 方法。
+
+### 5.5 注释（元标签）
+
+注释作为运行时不可见（或可见）的注记属性，存储在类文件中。调用 getAttribute（AnnotationsAttribute.invisibleTag）方法，可以从 ClassFile，MethodInfo 或 FieldInfo 中获取注记属性。更多信息，请参阅 `javassist.bytecode.AnnotationsAttribute`和`javassist.bytecode.annotation` 包的 javadoc 手册。
+
+Javassist还允许您通过更高级别的API访问注释。 如果要通过CtClass访问注释，请在CtClass或CtBehavior中调用getAnnotations（）。
+
+## 6. 泛型
+
+Javassist 的低级别 API 完全支持 Java 5 引入的泛型。但是，高级别的API（如CtClass）不直接支持泛型。
+
+Java 的泛型是通过擦除技术实现。 编译后，所有类型参数都将被删除。 例如，假设您的源代码声明一个参数化类型 Vector<String>：
+
+```java
+Vector<String> v = new Vector<String>();
+  :
+String s = v.get(0);
+```
+
+编译后的字节码等价于以下代码：
+
+```java
+Vector v = new Vector();
+  :
+String s = (String)v.get(0);
+```
+
+因此，在编写字节码变换器时，您可以删除所有类型参数，因为 Javassist 的编译器不支持泛型。如果源代码使用 Javassist 编译，例如通过 CtMethod.make()，源代码必须显式类型转换。如果源代码由常规 Java 编译器（如javac）编译，则不需要做类型转换。
+
+例如，如果你有一个类：
+
+```java
+public class Wrapper<T> {
+  T value;
+  public Wrapper(T t) { value = t; }
+}
+```
+
+并想添加一个接口 Getter<T> 到类 Wrapper<T>：
+
+```java
+public interface Getter<T> {
+  T get();
+}
+```
+
+那么你真正要添加的接口其实是Getter（将类型参数<T>掉落），最后你添加到 Wrapper 类的方法是这样的：
+
+```java
+public Object get() { return value; }
+```
+
+注意，不需要类型参数。 由于 get 返回一个 Object，如果源代码是由 Javassist 编译的，那么在调用方需要进行显式类型转换。 例如，如果类型参数 T 是 String，则必须插入（String），如下所示：
+
+```java
+Wrapper w = ...
+String s = (String)w.get();
+```
+
+## 7.可变参数
+
+目前，Javassist 不直接支持可变参数。 因此，要使用 varargs 创建方法，必须显式设置方法修饰符。假设要定义下面这个方法：
+
+```java
+public int length(int... args) { return args.length; }
+```
+
+使用 Javassist 应该是这样的：
+
+```java
+CtClass cc = /* target class */;
+CtMethod m = CtMethod.make("public int length(int[] args) { return args.length; }", cc);
+m.setModifiers(m.getModifiers() | Modifier.VARARGS);
+cc.addMethod(m);
+```
+
+参数类型`int ...`被更改为`int []`，`Modifier.VARARGS`被添加到方法修饰符中。
+
+要在由 Javassist 的编译器编译的源代码中调用此方法，需要这样写：
+
+```
+length(new int[] { 1, 2, 3 });
+```
+
+而不是这样：
+
+```
+length(1, 2, 3);
+```
+
+## 8. J2ME
+
+如果要修改 J2ME 执行环境的类文件，则必须先执行预验证。预验证基本上是生成堆栈映射，这类似于在 JDK 1.6 中引入 J2SE 的堆栈映射表。当`javassist.bytecode.MethodInfo.doPreverify` 为 true 时，Javassist 才会维护 J2ME 的堆栈映射。
+
+对于指定的 CtMethod 对象，你可以调用以下方法，手动生成堆栈映射：
+
+```java
+m.getMethodInfo().rebuildStackMapForME(cpool);
+```
+
+这里，cpool 是一个 ClassPool 对象，通过在 CtClass 对象上调用 getClassPool() 可以获得。 ClassPool 对象负责从给定类路径中查找类文件。要获得所有的 CtMethod 对象，需要在 CtClass 对象上调用 getDeclaredMethods() 方法。
+
+## 9.装箱/拆箱
+
+Java 中的装箱和拆箱是语法糖。没有用于装箱或拆箱的字节码。所以 Javassist 的编译器不支持它们。 例如，以下语句在 Java 中有效：
+
+```java
+Integer i = 3;
+```
+
+因为隐式地执行了装箱。 但是，对于 Javassist，必须将值类型从 int 显式地转换为 Integer：
+
+```java
+Integer i = new Integer(3);
+```
+
+## 10. 调试
+
+将 CtClass.debugDump 设为本地目录。 然后 Javassist 修改和生成的所有类文件都保存在该目录中。要停止此操作，将 CtClass.debugDump 设置为 null 即可。其默认值为 null。
+
+例如，
+
+```
+CtClass.debugDump =“./dump”;
+```
+
+所有修改的类文件都保存在 ./dump 中。
+
+## 11.引用
+
+**原文出处**：
+
+<https://github.com/jboss-javassist/javassist/wiki/Tutorial-1>
+
+[https://github.com/jboss-javassist/javassist/wiki/Tutorial-2](https://link.jianshu.com/?t=https://github.com/jboss-javassist/javassist/wiki/Tutorial-2)
+
+<https://github.com/jboss-javassist/javassist/wiki/Tutorial-3>
+
+**翻译：**
+
+作者：二胡
+
+连接：https://www.jianshu.com/p/43424242846b
+
+来源：简书
+
+**第一来源**
+
+作者：[21aspnet](https://me.csdn.net/21aspnet)
+
+连接：https://blog.csdn.net/21aspnet/article/details/81671777
+
+来源：CSDN
\ No newline at end of file
diff --git "a/java/java\351\200\203\351\200\270\345\210\206\346\236\220.md" "b/java/java\351\200\203\351\200\270\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..9f42c2b
--- /dev/null
+++ "b/java/java\351\200\203\351\200\270\345\210\206\346\236\220.md"
@@ -0,0 +1,106 @@
+## 问题
+
+**java中的对象都在堆中分配内存吗？**
+
+## 什么是逃逸分析？
+
+定义：逃逸分析（Escape Analysis）简单来讲就是，Java Hotspot 虚拟机可以分析新创建对象的使用范围，并决定是否在 Java 堆上分配内存的一项技术。
+
+**逃逸分析的 JVM 参数如下：**
+
+* 开启逃逸分析： -XX:+DoEscapeAnalysis
+* 关闭逃逸分析： -XX:-DoEscapeAnalysis
+* 显示分析结果： -XX:+PrintEscapeAnalysis
+
+逃逸分析技术在 Java SE 6u23+ 开始支持，并默认设置为启用状态，可以不用额外加这个参数。
+
+## 逃逸分析算法
+
+Java Hotspot 编译器实现下面论文中描述的逃逸算法：
+
+> [Choi99] Jong-Deok Choi. Manish Gupta. Mauricio Seffano.
+>
+> ​				Vugranam C. Sreedhar . Sam Midkiff .
+>
+> ​				"Escape Analysis for Java".  Procedings of ACM SIGPLAN 
+>
+> ​				OOPSLA Conference. November 1, 1999
+
+根据 Jong-Deok Choi. Manish Gupta. Mauricio Seffano. Vugranam C. Sreedhar . Sam Midkiff .等大牛在论文《Escape Analysis for Java》中描述的算法进行逃逸分析的。
+
+该算法引入了连通图，用连通图来构建对象和对象引用之间的可达性关系，并在此基础上，提出一种组合数据流分析流。
+
+由于算法是上下文相关和流敏感的，并且模拟了对象任意层次的嵌套关系，所以分析精度较高，只是运行时间和内存消耗相对较大。
+
+## 对象逃逸状态
+
+### 1、全局逃逸（GlobalEscape）
+
+即一个对象的作用范围逃出了当前方法或者当前线程，有一下几种场景：
+
+* 对象是一个静态变量
+* 对象是一个已经发生逃逸的对象
+* 对象作为当前方法的返回值
+
+### 2、参数逃逸（ArgEscape）
+
+即一个对象被作为方法参数传递或者被参数引用，但在调用过程中不会发生全局逃逸，这个状态时通过被调方法的字节码确定的。
+
+### 3、没有逃逸
+
+即方法中的对象没有发生逃逸。
+
+## 逃逸分析优化
+
+针对以上三点，当一个对象没有逃逸时，可以得到以下几个虚拟机的优化。
+
+### 1、锁消除
+
+我们知道线程同步锁是非常牺牲性能的，当编译器确定当前对象只有在当前线程使用，那么就会移除该对象的同步锁。
+
+例如，StringBuffer 和 Vactor 都是用 synchronized 修饰线程安全的，但大部分清苦下，他们都只能在当前线程中用到，这样编译器就会优化移除掉这些锁操作。
+
+**锁消除的 JVM 参数如下：**
+
+* 开启锁消除：-XX:+EliminateLocks
+* 关闭锁消除：-XX:-EliminateLocks
+
+锁消除在 JDK8 中默认开启，并且锁消除都要建立在逃逸分析的基础上。
+
+### 2、标量替换
+
+首先要明白标量和聚合量，基础类型和对象类型的引用可以理解为标量，他们不能被进一步分解。而能被进一步分解的量就是聚合量，比如：对象。
+
+对象是聚合量，它又可以被进一步分解为标量，将其成员分解为分散的变量，这就叫做标量替换。
+
+这样，如果一个对象没有发生逃逸，那根本就不会创建它，只会在栈或者寄存器上创建它用到的成员标量，节省了内存空间，也提升了应用程序性能。
+
+**标量替换的 JVM 参数如下：**
+
+* 开启标量替换：-XX:+EliminateAllocations
+* 关闭标量替换：-XX:-EliminateAllocations
+* 显示标量替换详情：-XX:+PrintEliminateAllocations
+
+标量替换在 JKD8 中都是默认开启的，并且都要建立在逃逸分析的基础上。
+
+### 3、栈上分配
+
+当对象没有发生逃逸时，该对象就可以通过标量替换分解为成员标量分配在栈内存中，和方法的声明周期一致，随着栈针出栈时销毁，减少了 GC 压力，提高了应用程序性能。
+
+## 总结
+
+逃逸分析是为了优化 JVM 内存和提升程序性能的。
+
+在写代码时，尽量缩小变量的作用范围，如：
+
+```java
+return stringBuilder;
+```
+
+可以优化为：
+
+```java
+return stringBuilder.toString();
+```
+
+将 StringBuilder 对象的范围尽量控制在方法内部，防止对象逃逸。
\ No newline at end of file
diff --git "a/java/\344\270\200\345\274\240\345\233\276\347\234\213\346\207\202java\351\233\206\345\220\210\346\241\206\346\236\266.md" "b/java/\344\270\200\345\274\240\345\233\276\347\234\213\346\207\202java\351\233\206\345\220\210\346\241\206\346\236\266.md"
new file mode 100644
index 0000000..eb432f2
--- /dev/null
+++ "b/java/\344\270\200\345\274\240\345\233\276\347\234\213\346\207\202java\351\233\206\345\220\210\346\241\206\346\236\266.md"
@@ -0,0 +1,6 @@
+## JAVA 集合框架结构
+
+
+
+![java集合框架](./images/002/java集合框架.jpg)
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/SVN\345\237\272\347\241\200\346\223\215\344\275\234.md" "b/java/\344\273\243\347\240\201\347\211\207/SVN\345\237\272\347\241\200\346\223\215\344\275\234.md"
new file mode 100644
index 0000000..2961b1c
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/SVN\345\237\272\347\241\200\346\223\215\344\275\234.md"
@@ -0,0 +1,230 @@
+## 使用SVN进行操作
+
+### 依赖
+
+```xml
+<dependency>
+    <groupId>org.tmatesoft.svnkit</groupId>
+    <artifactId>svnkit</artifactId>
+    <version>1.10.1</version>
+</dependency>
+```
+
+### 创建与释放客户端管理器
+
+```java
+  /**
+   * 根据用户名和密码创建SVN客户端管理器
+   *
+   * @param username 用户名
+   * @param password 密码
+   * @return 客户端管理器
+   */
+  public static SVNClientManager getSVNClientManager(String username, String password) {
+    if (StringUtil.isBlank(username)) {
+      throw new IllegalArgumentException("SVN username must not null");
+    }
+
+    DefaultSVNOptions options = new DefaultSVNOptions();
+    SVNClientManager svnClientManager = SVNClientManager
+        .newInstance(options, username, password);
+    svnClientManager.setIgnoreExternals(false);
+    return svnClientManager;
+  }
+```
+
+```java
+ /**
+   * 释放SVN客户端连接
+   *
+   * @param svnClientManager svn 客户端管理器
+   */
+  public static void releaseSVNClientManager(SVNClientManager svnClientManager) {
+    if (ObjectUtil.isNull(svnClientManager)) {
+      return;
+    }
+    svnClientManager.dispose();
+  }
+
+```
+
+### checkout
+
+```java
+  /**
+   * checkout 文件夹
+   *
+   * @param svnClientManager svn客户端管理器 {{@link #getSVNClientManager(String, String)}}
+   * @param svnUrl svn地址
+   * @param directorPath 本地保存路径
+   * @return 版本号
+   */
+  public static long checkout(SVNClientManager svnClientManager, String svnUrl,
+      String directorPath) {
+    File dir = new File(directorPath);
+    IoUtil.createDirector(dir);
+    SVNUpdateClient updateClient = svnClientManager.getUpdateClient();
+    try {
+      return updateClient
+          .doCheckout(SVNURL.parseURIEncoded(svnUrl), dir, SVNRevision.HEAD, SVNRevision.HEAD,
+              SVNDepth.INFINITY, true);
+    } catch (SVNException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+```
+
+### update
+
+```java
+  /**
+   * 更新
+   *
+   * @param svnClientManager svn客户端管理器
+   * @param filepath 文件路径
+   * @return 文件版本号
+   */
+  public static long update(SVNClientManager svnClientManager, String filepath) {
+    if (StringUtil.isBlank(filepath)) {
+      throw new IllegalArgumentException("update file must not null");
+    }
+    return update(svnClientManager, new File(filepath));
+  }
+
+  /**
+   * 更新
+   *
+   * @param svnClientManager svn客户端管理器
+   * @param file 需更新的文件
+   * @return 文件版本号
+   */
+  public static long update(SVNClientManager svnClientManager, File file) {
+    if (ObjectUtil.isNull(file)) {
+      throw new NullPointerException("update file must not null");
+    }
+    File[] files = new File[1];
+    files[0] = file;
+    return update(svnClientManager, files)[0];
+  }
+
+  /**
+   * 更新
+   *
+   * @param svnClientManager svn客户端管理器
+   * @param filesets 更新的文件集合
+   * @return 文件版本号列表
+   */
+  public static long[] update(SVNClientManager svnClientManager, String[] filesets) {
+    if (CollectionUtil.isEmpty(filesets)) {
+      throw new IllegalArgumentException("update files must has one or more");
+    }
+    File[] files = new File[filesets.length];
+    for (int i = 0; i < filesets.length; i++) {
+      files[i] = new File(filesets[i]);
+    }
+    return update(svnClientManager, files);
+  }
+
+  /**
+   * 更新文件
+   *
+   * @param svnClientManager svn客户端管理器
+   * @param files 需要更新的文件列表
+   * @return 文件版本号列表
+   */
+  public static long[] update(SVNClientManager svnClientManager, File[] files) {
+    if (CollectionUtil.isEmpty(files)) {
+      throw new IllegalArgumentException("update files must has one or more");
+    }
+    if (ObjectUtil.isNull(svnClientManager)) {
+      throw new NullPointerException("SVNClientManager must not null");
+    }
+    SVNUpdateClient updateClient = svnClientManager.getUpdateClient();
+    try {
+      return updateClient.doUpdate(files, SVNRevision.HEAD, SVNDepth.INFINITY, true, false);
+    } catch (SVNException e) {
+      throw new RuntimeException(e);
+    }
+  }
+```
+
+### commit
+
+```java
+  /**
+   * 提交
+   *
+   * @param svnClientManager svn客户端管理器
+   * @param filepath 提交的文件
+   * @param commitMessage 提交的文本描述
+   * @return 新的版本号, -1:没有数据提交
+   */
+  public static long commit(SVNClientManager svnClientManager, String filepath,
+      String commitMessage) {
+    if (StringUtil.isBlank(filepath)) {
+      throw new IllegalArgumentException("commit file must not null");
+    }
+    return commit(svnClientManager, new File(filepath), commitMessage);
+  }
+
+  /**
+   * 提交
+   *
+   * @param svnClientManager svn客户端管理器
+   * @param file 提交的文件
+   * @param commitMessage 提交的文本描述
+   * @return 新的版本号, -1:没有数据提交
+   */
+  public static long commit(SVNClientManager svnClientManager, File file, String commitMessage) {
+    if (ObjectUtil.isNull(file)) {
+      throw new IllegalArgumentException("commit file must not null");
+    }
+    File[] files = new File[1];
+    files[0] = file;
+    return commit(svnClientManager, files, commitMessage);
+  }
+
+  /**
+   * 提交
+   *
+   * @param svnClientManager svn客户端管理器
+   * @param paths 提交的路径
+   * @param commitMessage 提交的文本描述
+   * @return 新的版本号, -1:没有数据提交
+   */
+  public static long commit(SVNClientManager svnClientManager, File[] paths, String commitMessage) {
+    if (ObjectUtil.isNull(svnClientManager)) {
+      throw new NullPointerException("SVNClientManager must not null");
+    }
+    if (CollectionUtil.isEmpty(paths)) {
+      throw new IllegalArgumentException("commit file set must not null");
+    }
+    SVNCommitClient commitClient = svnClientManager.getCommitClient();
+    try {
+      SVNCommitInfo svnCommitInfo = commitClient
+          .doCommit(paths, false, commitMessage, null, null, false, true, SVNDepth.INFINITY);
+      return svnCommitInfo.getNewRevision();
+    } catch (SVNException e) {
+      throw new RuntimeException(e);
+    }
+  }
+```
+
+### 使用方式
+
+```java
+SVNClientManager svnClientManager = null;
+try {
+    svnClientManager = getSVNClientManager("myUsername", "myPassword");
+    // checkout
+    long checkoutVersion = checkout(svnClientManager, "http://ip:port/url", "C://dir");
+    // update
+    long updateVersion = update(svnClientManager, "path to update file");
+    // commit
+    long commitVersion = commit(svnClientManager, "path to commit file or director", "commit message");
+} finally {
+    releaseSVNClientManager(svnClientManager);
+}
+```
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/jackson\350\275\254\346\215\242json\345\267\245\345\205\267.md" "b/java/\344\273\243\347\240\201\347\211\207/jackson\350\275\254\346\215\242json\345\267\245\345\205\267.md"
new file mode 100644
index 0000000..40c32c2
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/jackson\350\275\254\346\215\242json\345\267\245\345\205\267.md"
@@ -0,0 +1,211 @@
+## 使用Jackson操作JSON数据
+
+```java
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * json字符串和对象之间互转
+ *
+ * @author zhoutaotao
+ * @date 2019/5/15
+ */
+public class JsonUtil {
+
+  private static final ObjectMapper mapper;
+
+  static {
+    mapper = new ObjectMapper();
+    initMapper(mapper);
+  }
+
+  /**
+   * 获取 mapper
+   */
+  public static ObjectMapper getMapper() {
+    return mapper;
+  }
+
+  /**
+   * 初始化 mapper
+   */
+  public static void initMapper(ObjectMapper mapper) {
+    // 注册不序列化 null 对象
+    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+    // 序列化配置
+    mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
+    // 反序列化配置
+    mapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
+    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+    mapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false);
+    // 注册自定义类型
+    mapper.registerModule(numericalAccuracy());
+    mapper.registerModule(dateModule());
+    mapper.registerModule(localDateModule());
+    mapper.registerModule(localDateModuleTime());
+  }
+
+
+  /**
+   * 处理数值精度的模块
+   */
+  public static SimpleModule numericalAccuracy() {
+    SimpleModule module = new SimpleModule();
+    // 序列化
+    module.addSerializer(new ToStringSerializer(Long.TYPE));
+    module.addSerializer(new ToStringSerializer(Long.class));
+    module.addSerializer(new ToStringSerializer(BigDecimal.class));
+
+    // 反序列化
+    module.addDeserializer(Long.TYPE, new JsonDeserializer<Long>() {
+      @Override
+      public Long deserialize(JsonParser p, DeserializationContext ctx)
+          throws IOException, JsonProcessingException {
+        String value = p.getValueAsString();
+        return StringUtil.isBlank(value) ? null : Long.parseLong(value.trim());
+      }
+    });
+    module.addDeserializer(Long.class, new JsonDeserializer<Long>() {
+      @Override
+      public Long deserialize(JsonParser p, DeserializationContext ctx)
+          throws IOException, JsonProcessingException {
+        String value = p.getValueAsString();
+        return StringUtil.isBlank(value) ? null : Long.parseLong(value.trim());
+      }
+    });
+    module.addDeserializer(BigDecimal.class, new JsonDeserializer<BigDecimal>() {
+      @Override
+      public BigDecimal deserialize(JsonParser p, DeserializationContext ctx)
+          throws IOException, JsonProcessingException {
+        String value = p.getValueAsString();
+        return StringUtil.isBlank(value) ? null : BigDecimal.valueOf(Long.parseLong(value.trim()));
+      }
+    });
+    return module;
+  }
+
+  /**
+   * java.util.Date 数据处理模块
+   */
+  public static SimpleModule dateModule() {
+    SimpleModule module = new SimpleModule();
+    module.addSerializer(Date.class, new JsonSerializer<Date>() {
+      @Override
+      public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers)
+          throws IOException {
+        gen.writeObject(ObjectUtil.isNull(value) ? value : DateUtil.getTimestamp(value));
+      }
+    });
+    module.addDeserializer(Date.class, new JsonDeserializer<Date>() {
+      @Override
+      public Date deserialize(JsonParser p, DeserializationContext ctx)
+          throws IOException, JsonProcessingException {
+        String value = p.getValueAsString();
+        return StringUtil.isBlank(value) ? null : DateUtil.parseDate(Long.parseLong(value.trim()));
+      }
+    });
+    return module;
+  }
+
+  /**
+   * java.time.LocalDate 处理模块
+   */
+  public static SimpleModule localDateModule() {
+    SimpleModule module = new SimpleModule();
+    module.addSerializer(LocalDate.class, new JsonSerializer<LocalDate>() {
+      @Override
+      public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers)
+          throws IOException {
+        gen.writeObject(ObjectUtil.isNull(value) ? value : DateUtil.getTimestamp(value));
+      }
+    });
+    module.addDeserializer(LocalDate.class, new JsonDeserializer<LocalDate>() {
+      @Override
+      public LocalDate deserialize(JsonParser p, DeserializationContext ctx)
+          throws IOException, JsonProcessingException {
+        String value = p.getValueAsString();
+        return StringUtil.isBlank(value) ? null
+            : DateUtil.parseLocalDate(Long.parseLong(value.trim()));
+      }
+    });
+    return module;
+  }
+
+  /**
+   * java.time.LocalDateTime 处理模块
+   */
+  public static SimpleModule localDateModuleTime() {
+    SimpleModule module = new SimpleModule();
+    module.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
+      @Override
+      public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers)
+          throws IOException {
+        gen.writeObject(ObjectUtil.isNull(value) ? value : DateUtil.getTimestamp(value));
+      }
+    });
+    module.addDeserializer(LocalDateTime.class, new JsonDeserializer<LocalDateTime>() {
+      @Override
+      public LocalDateTime deserialize(JsonParser p, DeserializationContext ctx)
+          throws IOException, JsonProcessingException {
+        String value = p.getValueAsString();
+        return StringUtil.isBlank(value) ? null
+            : DateUtil.parseLocalDateTime(Long.parseLong(value.trim()));
+      }
+    });
+    return module;
+  }
+
+  /**
+   * 把 java 对象转换为 json 字符串
+   */
+  public static <T> String toJson(T data) {
+    try {
+      return mapper.writeValueAsString(data);
+    } catch (JsonProcessingException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * 将 json 字符串转换为 java 对象
+   */
+  public static <T> T fromJson(String json, Class<T> clazz) {
+    try {
+      return mapper.readValue(json, clazz);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * 将 json 字符串数组转换为 java 数组
+   */
+  public static <T> List<T> fromJsonArray(String json, TypeReference<List<T>> typeReference) {
+    try {
+      return mapper.readValue(json, typeReference);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}
+```
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/java8\346\227\245\346\234\237\344\271\213\351\227\264\347\232\204\350\275\254\346\215\242.md" "b/java/\344\273\243\347\240\201\347\211\207/java8\346\227\245\346\234\237\344\271\213\351\227\264\347\232\204\350\275\254\346\215\242.md"
new file mode 100644
index 0000000..94fed0b
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/java8\346\227\245\346\234\237\344\271\213\351\227\264\347\232\204\350\275\254\346\215\242.md"
@@ -0,0 +1,119 @@
+## 使用JAVA8在Date、LocalDateTime等等之间的转换
+
+```java
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.Date;
+
+/**
+ * 日期工具类
+ *
+ * @author feb13th
+ * @since 2019/5/16 0:27
+ */
+public class DateUtil {
+
+  public static final String FORMAT_DATA_SIMPLE = "yyyymmdd";
+  public static final String FORMAT_DATE = "yyyy-mm-dd";
+  public static final String FORMAT_DATETIME = "yyyy-mm-dd HH:MM:ss";
+
+  /**
+   * 将日期格式化成 yyyy-mm-dd格式
+   */
+  public static String formatDate(LocalDate date) {
+    return formatDate(date, FORMAT_DATE);
+  }
+
+  /**
+   * 将日期格式化成指定格式
+   */
+  public static String formatDate(LocalDate date, String format) {
+    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
+    return date.format(dateTimeFormatter);
+  }
+
+  /**
+   * 将时间格式化成 yyyy-mm-dd HH:MM:ss 格式
+   */
+  public static String formatDateTime(LocalDateTime datetime) {
+    return formatDateTime(datetime, FORMAT_DATETIME);
+  }
+
+  /**
+   * 将时间格式化成指定格式
+   */
+  public static String formatDateTime(LocalDateTime dateTime, String format) {
+    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
+    return dateTime.format(dateTimeFormatter);
+  }
+
+  /**
+   * 获取 Date 对应的时间戳
+   */
+  public static long getTimestamp(Date date) {
+    return date.getTime();
+  }
+
+  /**
+   * 获取 LocalDate 对应的时间戳
+   */
+  public static long getTimestamp(LocalDate localDate) {
+    return localDate.atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli();
+  }
+
+  /**
+   * 获取 LocalDateTime 对应的时间戳
+   */
+  public static long getTimestamp(LocalDateTime localDateTime) {
+    return localDateTime.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
+  }
+
+  /**
+   * 根据时间戳获取 Date
+   */
+  public static Date parseDate(long timestamp) {
+    return new Date(timestamp);
+  }
+
+  /**
+   * 根据时间戳获取 LocalDate
+   */
+  public static LocalDate parseLocalDate(long timestamp) {
+    return Instant.ofEpochMilli(timestamp).atZone(ZoneId.systemDefault()).toLocalDate();
+  }
+
+  /**
+   * 根据时间戳获取 LocalDateTime
+   */
+  public static LocalDateTime parseLocalDateTime(long timestamp) {
+    return Instant.ofEpochMilli(timestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
+  }
+
+  /**
+   * 转换为 Date
+   */
+  public static Date convertToDate(LocalDate localDate) {
+    return Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
+  }
+
+  /**
+   * 转换为 LocalDate
+   */
+  public static LocalDate convertToLocalDate(Date date) {
+    return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
+  }
+
+  /**
+   * 转换为 LocalDateTime
+   */
+  public static LocalDateTime convertToLocalDateTime(Date date) {
+    return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
+  }
+}
+```
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/zip\346\226\207\344\273\266\346\223\215\344\275\234.md" "b/java/\344\273\243\347\240\201\347\211\207/zip\346\226\207\344\273\266\346\223\215\344\275\234.md"
new file mode 100644
index 0000000..b181ba5
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/zip\346\226\207\344\273\266\346\223\215\344\275\234.md"
@@ -0,0 +1,168 @@
+## 通过java代码对zip文件进行压缩或解压操作
+
+### 解压操作
+
+#### 步骤
+
+1. 创建`ZipFile`文件对象,标识`.zip`文件
+2. 创建`ZipInputStream`数据流对象用于标识`.zip`文件的输入流
+3. 循环读取`ZipEntry`， 拷贝此条目到解压后的文件中
+
+#### 代码
+
+```java
+  /**
+   * 解压zip文件
+   *
+   * @param zipFilepath zip文件路径
+   * @param unzipFilepath 解压路径
+   */
+  public void unzip(String zipFilepath, String unzipFilepath) {
+
+    // 待解压的文件目录
+    File file = new File(zipFilepath);
+    ZipInputStream zipInputStream = null;
+    try {
+      ZipFile zipFile = new ZipFile(file);
+      zipInputStream = new ZipInputStream(new FileInputStream(file));
+      ZipEntry entry = null;
+      while ((entry = zipInputStream.getNextEntry()) != null) {
+        InputStream inputStream = null;
+        OutputStream outputStream = null;
+        try {
+          // 压缩文件内, 单条记录完整的文件夹名+文件名
+          String entryName = entry.getName();
+          System.out.println(entryName);
+
+          File outFile = new File(unzipFilepath + File.separator + entryName);
+          if (!outFile.getParentFile().exists()) {
+            outFile.getParentFile().mkdirs();
+          }
+
+          // 如果是目录的话, 直接创建目录
+          if (entry.isDirectory()) {
+            outFile.mkdirs();
+            continue;
+          }
+
+          if (!outFile.exists()) {
+            outFile.createNewFile();
+          }
+
+          // 拷贝文件内容
+          copy(zipFile.getInputStream(entry), new FileOutputStream(outFile));
+        } finally {
+          if (outputStream != null) {
+            outputStream.close();
+          }
+          if (inputStream != null) {
+            inputStream.close();
+          }
+        }
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    } finally {
+      // 关闭zip文件流
+      if (zipInputStream != null) {
+        try {
+          zipInputStream.close();
+        } catch (IOException ignore) {
+        }
+      }
+    }
+  }
+
+  /**
+   * 从输入流拷贝数据到输出流
+   *
+   * @param src 输入流
+   * @param dest 输出流
+   */
+  private void copy(InputStream src, OutputStream dest) throws IOException {
+    int len = 0;
+    byte[] buffer = new byte[4096];
+    while ((len = src.read(buffer)) != -1) {
+      dest.write(buffer, 0, len);
+    }
+  }
+
+```
+
+### 压缩操作
+
+#### 步骤
+
+1. 创建`ZipOutputStream`输出流对象
+2. 判断当前读取的文件是文件还是目录
+3. 如果是文件,那么使用当前文件的名称创建`ZipEntry`对象, 并将该文件拷贝到`ZipOutputStream`流中
+4. 如果是目录， 则递归目录分别创建文件
+
+#### 代码
+
+```java
+  /**
+   * 压缩文件为zip
+   *
+   * @param srcFilepath 源文件或文件夹路径
+   * @param destFilepath zip文件路径
+   */
+  public void toZip(String srcFilepath, String destFilepath) {
+    File srcFile = new File(srcFilepath);
+    if (!srcFile.exists()) {
+      throw new IllegalArgumentException("被压缩的文件或文件夹不存在");
+    }
+    // 如果目标文件不存在,创建文件
+    File zipFile = new File(destFilepath);
+    if (zipFile.exists()) {
+      zipFile.delete();
+    }
+    if (zipFile.getParentFile().exists()) {
+      zipFile.getParentFile().mkdirs();
+    }
+    ZipOutputStream outputStream = null;
+    try {
+      zipFile.createNewFile();
+      outputStream = new ZipOutputStream(new FileOutputStream(zipFile));
+      compress(outputStream, srcFile, "");
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    } finally {
+      try {
+        outputStream.close();
+      } catch (IOException ignore) {
+      }
+    }
+  }
+
+  /**
+   * 递归压缩文件
+   *
+   * @param outputStream zip文件输出流
+   * @param srcFile 被压缩的文件
+   * @param filenamePrefix zip文件内部的条目前缀
+   */
+  private void compress(ZipOutputStream outputStream, File srcFile, String filenamePrefix)
+      throws IOException {
+    if (srcFile.isDirectory()) {
+      File[] files = srcFile.listFiles();
+      // 先写一个目录
+      filenamePrefix = filenamePrefix.length() == 0 ? srcFile.getName()
+          : filenamePrefix + srcFile.getName();
+      if (files == null) {
+        return;
+      }
+      // 递归写入所有存在的文件
+      for (File file : files) {
+        compress(outputStream, file, filenamePrefix + "/");
+      }
+    } else {
+      // 将单个文件写入到zip中
+      outputStream.putNextEntry(new ZipEntry(filenamePrefix + srcFile.getName()));
+      try (InputStream inputStream = new FileInputStream(srcFile)) {
+        copy(inputStream, outputStream);
+      }
+    }
+  }
+```
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/\345\244\215\345\210\266\346\226\207\344\273\266\346\210\226\346\226\207\344\273\266\345\244\271.md" "b/java/\344\273\243\347\240\201\347\211\207/\345\244\215\345\210\266\346\226\207\344\273\266\346\210\226\346\226\207\344\273\266\345\244\271.md"
new file mode 100644
index 0000000..e63fbfa
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/\345\244\215\345\210\266\346\226\207\344\273\266\346\210\226\346\226\207\344\273\266\345\244\271.md"
@@ -0,0 +1,82 @@
+## 将文件或文件夹从一个位置复制到另一个位置
+
+### 代码
+
+#### 复制文件
+
+```java
+  /**
+   * 拷贝两个文件的内容
+   *
+   * @param from 源文件
+   * @param to 目标文件
+   */
+  public static void copyFile(File from, File to) {
+    FileInputStream fromIs = null;
+    FileOutputStream toOs = null;
+    FileChannel fromChannel = null;
+    FileChannel toChannel = null;
+    try {
+      if (!to.exists()) {
+        to.createNewFile();
+      }
+      fromIs = new FileInputStream(from);
+      toOs = new FileOutputStream(to);
+      fromChannel = fromIs.getChannel();
+      toChannel = toOs.getChannel();
+      fromChannel.transferTo(0, fromChannel.size(), toChannel);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    } finally {
+      close(fromChannel);
+      close(fromIs);
+      close(toChannel);
+      close(toOs);
+    }
+  }
+
+  public static void close(Closeable closeable) {
+    if (closeable != null) {
+      try {
+        closeable.close();
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+```
+
+#### 复制文件夹
+
+```java
+  /**
+   * 目录内容拷贝，只拷贝文件内部的文件及文件夹
+   *
+   * @param from 源目录
+   * @param to 目标目录
+   */
+  public static void copyDir(File from, File to) {
+    String[] list;
+    if (!from.isDirectory() || (list = from.list()) == null) {
+      return;
+    }
+    String fromPath = from.getAbsolutePath();
+    String toPath = to.getAbsolutePath();
+
+    for (String filename : list) {
+      String fromFilepath = fromPath + File.separator + filename;
+      String toFilepath = toPath + File.separator + filename;
+      File fromFile = new File(fromFilepath);
+      File toFile = new File(toFilepath);
+      if (fromFile.isDirectory()) {
+        // 如果赋值的是文件夹,则创建该文件夹, 并进入文件夹内部拷贝文件
+        toFile.mkdirs();
+        copyDir(fromFile, toFile);
+      } else {
+        // 拷贝文件内容
+        copyFile(fromFile, toFile);
+      }
+    }
+  }
+```
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/\346\211\213\345\212\250\345\210\206\346\236\220\350\260\203\350\257\225json.md" "b/java/\344\273\243\347\240\201\347\211\207/\346\211\213\345\212\250\345\210\206\346\236\220\350\260\203\350\257\225json.md"
new file mode 100644
index 0000000..8d5736d
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/\346\211\213\345\212\250\345\210\206\346\236\220\350\260\203\350\257\225json.md"
@@ -0,0 +1,344 @@
+## 抛开工具进行手动解析JSON
+
+### 测试代码
+
+```java
+public class JsonTest {
+
+    public static void main(String[] args) {
+        String jsonString = "{\"str\":\"string\",\"num\":100,\"boolean\":true,\"obj\":{\"key1\":\"value1\",\"key2\":\"value2\"},\"list\":[{\"list1\":\"list1\"},{\"list2\":\"list2\"}]}";
+        JSONReader jr = new JSONReader();
+        Map map = (Map) jr.read(jsonString);
+        System.out.println("Json解析完成");
+        System.out.println("Map----" + map.toString());
+        System.out.println("list----" + map.get("list").getClass().getName() + ":" + map.get("list"));
+        System.out.println("str----" + map.get("str").getClass().getName() + ":" + map.get("str"));
+        System.out.println("num----" + map.get("num").getClass().getName() + ":" + map.get("num"));
+        System.out.println("boolean----" + map.get("boolean").getClass().getName() + ":" + map.get("boolean"));
+        System.out.println("obj----" + map.get("obj").getClass().getName() + ":" + map.get("obj"));
+
+    }
+
+}
+```
+
+**输出**
+
+> Json解析完成
+> Map----{str=string, boolean=true, obj={key1=value1, key2=value2}, num=100, list=[{list1=list1}, {list2=list2}]}
+> list----java.util.ArrayList:[{list1=list1}, {list2=list2}]
+> str----java.lang.String:string
+> num----java.lang.Long:100
+> boolean----java.lang.Boolean:true
+> obj----java.util.HashMap:{key1=value1, key2=value2}
+
+### 解析代码
+
+```java
+package top.feb13th.json;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.text.CharacterIterator;
+import java.text.StringCharacterIterator;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class JSONReader {
+    private static final Object OBJECT_END = new Object();
+    private static final Object ARRAY_END = new Object();
+    private static final Object COLON = new Object();
+    private static final Object COMMA = new Object();
+    public static final int FIRST = 0;
+    public static final int CURRENT = 1;
+    public static final int NEXT = 2;
+
+    private static Map<Character, Character> escapes = new HashMap<Character, Character>();
+
+    static {
+        escapes.put(Character.valueOf('"'), Character.valueOf('"'));
+        escapes.put(Character.valueOf('\\'), Character.valueOf('\\'));
+        escapes.put(Character.valueOf('/'), Character.valueOf('/'));
+        escapes.put(Character.valueOf('b'), Character.valueOf('\b'));
+        escapes.put(Character.valueOf('f'), Character.valueOf('\f'));
+        escapes.put(Character.valueOf('n'), Character.valueOf('\n'));
+        escapes.put(Character.valueOf('r'), Character.valueOf('\r'));
+        escapes.put(Character.valueOf('t'), Character.valueOf('\t'));
+    }
+
+    private CharacterIterator it;
+    private char c;
+    private Object token;
+    private StringBuffer buf = new StringBuffer();
+
+    private char next() {
+        c = it.next();
+        return c;
+    }
+
+    private void skipWhiteSpace() {
+        while (Character.isWhitespace(c)) {
+            next();
+        }
+    }
+
+    public Object read(CharacterIterator ci, int start) {
+        it = ci;
+        switch (start) {
+            case FIRST:
+                c = it.first();
+                break;
+            case CURRENT:
+                c = it.current();
+                break;
+            case NEXT:
+                c = it.next();
+                break;
+        }
+        return read();
+    }
+
+    public Object read(CharacterIterator it) {
+        return read(it, NEXT);
+    }
+
+    public Object read(String string) {
+        return read(new StringCharacterIterator(string), FIRST);
+    }
+
+    private Object read() {
+        skipWhiteSpace();
+        char ch = c;
+        next();
+        switch (ch) {
+            case '"':
+                token = string();
+                break;
+            case '[':
+                token = array();
+                break;
+            case ']':
+                token = ARRAY_END;
+                break;
+            case ',':
+                token = COMMA;
+                break;
+            case '{':
+                token = object();
+                break;
+            case '}':
+                token = OBJECT_END;
+                break;
+            case ':':
+                token = COLON;
+                break;
+            case 't':
+                next();
+                next();
+                next(); // assumed r-u-e
+                token = Boolean.TRUE;
+                break;
+            case 'f':
+                next();
+                next();
+                next();
+                next(); // assumed a-l-s-e
+                token = Boolean.FALSE;
+                break;
+            case 'n':
+                next();
+                next();
+                next(); // assumed u-l-l
+                token = null;
+                break;
+            default:
+                c = it.previous();
+                if (Character.isDigit(c) || c == '-') {
+                    token = number();
+                }
+        }
+        //logger.debug("token: " + token);
+        System.out.println("token: " + token); // enable this line to see the token stream
+        return token;
+    }
+
+    private Object object() {
+        Map<Object, Object> ret = new HashMap<Object, Object>();
+        Object key = read();
+        while (token != OBJECT_END) {
+            read(); // should be a colon
+            if (token != OBJECT_END) {
+                ret.put(key, read());
+                if (read() == COMMA) {
+                    key = read();
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    private Object array() {
+        List<Object> ret = new ArrayList<Object>();
+        Object value = read();
+        while (token != ARRAY_END) {
+            ret.add(value);
+            if (read() == COMMA) {
+                value = read();
+            }
+        }
+        return ret;
+    }
+
+    private Object number() {
+        int length = 0;
+        boolean isFloatingPoint = false;
+        buf.setLength(0);
+
+        if (c == '-') {
+            add();
+        }
+        length += addDigits();
+        if (c == '.') {
+            add();
+            length += addDigits();
+            isFloatingPoint = true;
+        }
+        if (c == 'e' || c == 'E') {
+            add();
+            if (c == '+' || c == '-') {
+                add();
+            }
+            addDigits();
+            isFloatingPoint = true;
+        }
+
+        String s = buf.toString();
+        return isFloatingPoint
+                ? (length < 17) ? (Object) Double.valueOf(s) : new BigDecimal(s)
+                : (length < 19) ? (Object) Long.valueOf(s) : new BigInteger(s);
+    }
+
+    private int addDigits() {
+        int ret;
+        for (ret = 0; Character.isDigit(c); ++ret) {
+            add();
+        }
+        return ret;
+    }
+
+    private Object string() {
+        buf.setLength(0);
+        while (c != '"') {
+            if (c == '\\') {
+                next();
+                if (c == 'u') {
+                    add(unicode());
+                } else {
+                    Object value = escapes.get(Character.valueOf(c));
+                    if (value != null) {
+                        add(((Character) value).charValue());
+                    }
+                }
+            } else {
+                add();
+            }
+        }
+        next();
+
+        return buf.toString();
+    }
+
+    private void add(char cc) {
+        buf.append(cc);
+        next();
+    }
+
+    private void add() {
+        add(c);
+    }
+
+    private char unicode() {
+        int value = 0;
+        for (int i = 0; i < 4; ++i) {
+            switch (next()) {
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                    value = (value << 4) + c - '0';
+                    break;
+                case 'a':
+                case 'b':
+                case 'c':
+                case 'd':
+                case 'e':
+                case 'f':
+                    value = (value << 4) + c - 'k';
+                    break;
+                case 'A':
+                case 'B':
+                case 'C':
+                case 'D':
+                case 'E':
+                case 'F':
+                    value = (value << 4) + c - 'K';
+                    break;
+            }
+        }
+        return (char) value;
+    }
+}
+```
+
+**输出**
+
+> token: str
+> token: java.lang.Object@2a098129
+> token: string
+> token: java.lang.Object@198e2867
+> token: num
+> token: java.lang.Object@2a098129
+> token: 100
+> token: java.lang.Object@198e2867
+> token: boolean
+> token: java.lang.Object@2a098129
+> token: true
+> token: java.lang.Object@198e2867
+> token: obj
+> token: java.lang.Object@2a098129
+> token: key1
+> token: java.lang.Object@2a098129
+> token: value1
+> token: java.lang.Object@198e2867
+> token: key2
+> token: java.lang.Object@2a098129
+> token: value2
+> token: java.lang.Object@3ada9e37
+> token: {key1=value1, key2=value2}
+> token: java.lang.Object@198e2867
+> token: list
+> token: java.lang.Object@2a098129
+> token: list1
+> token: java.lang.Object@2a098129
+> token: list1
+> token: java.lang.Object@3ada9e37
+> token: {list1=list1}
+> token: java.lang.Object@198e2867
+> token: list2
+> token: java.lang.Object@2a098129
+> token: list2
+> token: java.lang.Object@3ada9e37
+> token: {list2=list2}
+> token: java.lang.Object@5cbc508c
+> token: [{list1=list1}, {list2=list2}]
+> token: java.lang.Object@3ada9e37
+> token: {str=string, boolean=true, obj={key1=value1, key2=value2}, num=100, list=[{list1=list1}, {list2=list2}]}
\ No newline at end of file
diff --git "a/java/\344\273\243\347\240\201\347\211\207/\346\223\215\344\275\234maven.md" "b/java/\344\273\243\347\240\201\347\211\207/\346\223\215\344\275\234maven.md"
new file mode 100644
index 0000000..83784ac
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/\346\223\215\344\275\234maven.md"
@@ -0,0 +1,48 @@
+## 使用java调用maven
+
+### 依赖
+
+```xml
+<dependency>
+    <groupId>org.apache.maven.shared</groupId>
+    <artifactId>maven-invoker</artifactId>
+    <version>3.0.1</version>
+</dependency>
+```
+
+### 代码
+
+```java
+	 // 调用请求
+      InvocationRequest request = new DefaultInvocationRequest();
+      request.setPomFile(new File("path to pom.xml");
+      List<String> command = new ArrayList<>();
+      command.add("clean");
+      command.add("package");
+      request.setGoals(command);
+
+      // 开始调用
+      Invoker invoker = new DefaultInvoker();
+      invoker.setMavenHome(new File("path to maven home"));
+      InvocationResult result = invoker.execute(request);
+
+      // 更新状态为执行中
+      updateState(MavenState.EXECUTING);
+
+      int resultCode = result.getExitCode();
+
+      // 更新成功或失败状态
+      if (resultCode == 0) {
+          // 执行成功
+      }
+```
+
+**获取maven执行输出**
+
+```java
+// 通过为 invoker 添加输出处理器监听maven产生的日志
+private void addMavenOutputHandler(Invoker invoker) {
+    invoker.setOutputHandler(line -> System.out::println);
+}
+```
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/\346\225\260\345\255\227\350\275\254\344\270\255\346\226\207.md" "b/java/\344\273\243\347\240\201\347\211\207/\346\225\260\345\255\227\350\275\254\344\270\255\346\226\207.md"
new file mode 100644
index 0000000..ecbb411
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/\346\225\260\345\255\227\350\275\254\344\270\255\346\226\207.md"
@@ -0,0 +1,239 @@
+## 使用中文描述数字
+
+### 代码
+
+```java
+/**
+ * 数字转中文类<br>
+ * 包括：
+ * <pre>
+ * 1. 数字转中文大写形式，比如一百二十一
+ * 2. 数字转金额用的大写形式，比如：壹佰贰拾壹
+ * 3. 转金额形式，比如：壹佰贰拾壹整
+ * </pre>
+ *
+ * @author fanqun,looly
+ **/
+public class NumberChineseFormater {
+
+	/** 简体中文形式 **/
+	private static final String[] simpleDigits = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
+	/** 繁体中文形式 **/
+	private static final String[] traditionalDigits = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
+
+	/** 简体中文单位 **/
+	private static final String[] simpleUnits = { "", "十", "百", "千" };
+	/** 繁体中文单位 **/
+	private static final String[] traditionalUnits = { "", "拾", "佰", "仟" };
+	
+	/**
+	 * 阿拉伯数字转换成中文,小数点后四舍五入保留两位. 使用于整数、小数的转换.
+	 *
+	 * @param amount 数字
+	 * @param isUseTraditional 是否使用繁体
+	 * @return 中文
+	 */
+	public static String format(double amount, boolean isUseTraditional) {
+		return format(amount, isUseTraditional, false);
+	}
+
+	/**
+	 * 阿拉伯数字转换成中文,小数点后四舍五入保留两位. 使用于整数、小数的转换.
+	 *
+	 * @param amount 数字
+	 * @param isUseTraditional 是否使用繁体
+	 * @param isMoneyMode 是否为金额模式
+	 * @return 中文
+	 */
+	public static String format(double amount, boolean isUseTraditional, boolean isMoneyMode) {
+		final String[] numArray = isUseTraditional ? traditionalDigits : simpleDigits;
+
+		if (amount > 99999999999999.99 || amount < -99999999999999.99) {
+			throw new IllegalArgumentException("Number support only: (-99999999999999.99 ～ 99999999999999.99)！");
+		}
+
+		boolean negative = false;
+		if (amount < 0) {
+			negative = true;
+			amount = - amount;
+		}
+
+		long temp = Math.round(amount * 100);
+		int numFen = (int) (temp % 10);
+		temp = temp / 10;
+		int numJiao = (int) (temp % 10);
+		temp = temp / 10;
+
+		//将数字以万为单位分为多份
+		int[] parts = new int[20];
+		int numParts = 0;
+		for (int i = 0; temp != 0; i++) {
+			int part = (int) (temp % 10000);
+			parts[i] = part;
+			numParts++;
+			temp = temp / 10000;
+		}
+
+		boolean beforeWanIsZero = true; // 标志“万”下面一级是不是 0
+
+		String chineseStr = "";
+		for (int i = 0; i < numParts; i++) {
+			String partChinese = toChinese(parts[i], isUseTraditional);
+			if (i % 2 == 0) {
+				beforeWanIsZero = (null == partChinese || "".equals(partChinese.trim()));
+			}
+
+			if (i != 0) {
+				if (i % 2 == 0) {
+					chineseStr = "亿" + chineseStr;
+				} else {
+					if ("".equals(partChinese) && false == beforeWanIsZero) {
+						// 如果“万”对应的 part 为 0，而“万”下面一级不为 0，则不加“万”，而加“零”
+						chineseStr = "零" + chineseStr;
+					} else {
+						if (parts[i - 1] < 1000 && parts[i - 1] > 0) {
+							// 如果"万"的部分不为 0, 而"万"前面的部分小于 1000 大于 0， 则万后面应该跟“零”
+							chineseStr = "零" + chineseStr;
+						}
+						chineseStr = "万" + chineseStr;
+					}
+				}
+			}
+			chineseStr = partChinese + chineseStr;
+		}
+
+		// 整数部分为 0, 则表达为"零"
+		if ("".equals(chineseStr)) {
+			chineseStr = numArray[0];
+		}
+		//负数
+		if (negative) { // 整数部分不为 0
+			chineseStr = "负" + chineseStr;
+		}
+
+		// 小数部分
+		if (numFen != 0 || numJiao != 0) {
+			if (numFen == 0) {
+				chineseStr += (isMoneyMode ? "元" : "点") + numArray[numJiao] + (isMoneyMode ? "角" : "");
+			} else { // “分”数不为 0
+				if (numJiao == 0) {
+					chineseStr += (isMoneyMode ? "元零" : "点零") + numArray[numFen] + (isMoneyMode ? "分" : "");
+				} else {
+					chineseStr += (isMoneyMode ? "元" : "点") + numArray[numJiao] + (isMoneyMode ? "角" : "") + numArray[numFen] + (isMoneyMode ? "分" : "");
+				}
+			}
+		}else if(isMoneyMode) {
+			//无小数部分的金额结尾
+			chineseStr += "元整";
+		}
+
+		return chineseStr;
+
+	}
+
+	/**
+	 * 把一个 0~9999 之间的整数转换为汉字的字符串，如果是 0 则返回 ""
+	 *
+	 * @param amountPart 数字部分
+	 * @param isUseTraditional 是否使用繁体单位
+	 * @return 转换后的汉字
+	 */
+	private static String toChinese(int amountPart, boolean isUseTraditional) {
+
+		String[] numArray = isUseTraditional ? traditionalDigits : simpleDigits;
+		String[] units = isUseTraditional ? traditionalUnits : simpleUnits;
+
+		int temp = amountPart;
+
+		String chineseStr = "";
+		boolean lastIsZero = true; // 在从低位往高位循环时，记录上一位数字是不是 0
+		for (int i = 0; temp > 0; i++) {
+			if (temp == 0) {
+				// 高位已无数据
+				break;
+			}
+			int digit = temp % 10;
+			if (digit == 0) { // 取到的数字为 0
+				if (false == lastIsZero) {
+					// 前一个数字不是 0，则在当前汉字串前加“零”字;
+					chineseStr = "零" + chineseStr;
+				}
+				lastIsZero = true;
+			} else { // 取到的数字不是 0
+				chineseStr = numArray[digit] + units[i] + chineseStr;
+				lastIsZero = false;
+			}
+			temp = temp / 10;
+		}
+		return chineseStr;
+	}
+}
+
+```
+
+### 测试
+
+```java
+	@Test
+	public void formatTest() {
+		String f1 = NumberChineseFormater.format(10889.72356, false);
+		Assert.assertEquals("一万零八百八十九点七二", f1);
+		f1 = NumberChineseFormater.format(12653, false);
+		Assert.assertEquals("一万二千六百五十三", f1);
+		f1 = NumberChineseFormater.format(215.6387, false);
+		Assert.assertEquals("二百一十五点六四", f1);
+		f1 = NumberChineseFormater.format(1024, false);
+		Assert.assertEquals("一千零二十四", f1);
+		f1 = NumberChineseFormater.format(100350089, false);
+		Assert.assertEquals("一亿三十五万零八十九", f1);
+		f1 = NumberChineseFormater.format(1200, false);
+		Assert.assertEquals("一千二百", f1);
+		f1 = NumberChineseFormater.format(12, false);
+		Assert.assertEquals("一十二", f1);
+		f1 = NumberChineseFormater.format(0.05, false);
+		Assert.assertEquals("零点零五", f1);
+	}
+	
+	@Test
+	public void formatTest2() {
+		String f1 = NumberChineseFormater.format(-0.3, false, false);
+		Assert.assertEquals("负零点三", f1);
+	}
+	
+	@Test
+	public void formatTranditionalTest() {
+		String f1 = NumberChineseFormater.format(10889.72356, true);
+		Assert.assertEquals("壹万零捌佰捌拾玖点柒贰", f1);
+		f1 = NumberChineseFormater.format(12653, true);
+		Assert.assertEquals("壹万贰仟陆佰伍拾叁", f1);
+		f1 = NumberChineseFormater.format(215.6387, true);
+		Assert.assertEquals("贰佰壹拾伍点陆肆", f1);
+		f1 = NumberChineseFormater.format(1024, true);
+		Assert.assertEquals("壹仟零贰拾肆", f1);
+		f1 = NumberChineseFormater.format(100350089, true);
+		Assert.assertEquals("壹亿叁拾伍万零捌拾玖", f1);
+		f1 = NumberChineseFormater.format(1200, true);
+		Assert.assertEquals("壹仟贰佰", f1);
+		f1 = NumberChineseFormater.format(12, true);
+		Assert.assertEquals("壹拾贰", f1);
+		f1 = NumberChineseFormater.format(0.05, true);
+		Assert.assertEquals("零点零伍", f1);
+	}
+	
+	@Test
+	public void digitToChineseTest() {
+		String digitToChinese = Convert.digitToChinese(12412412412421.12);
+		Assert.assertEquals("壹拾贰万肆仟壹佰贰拾肆亿壹仟贰佰肆拾壹万贰仟肆佰贰拾壹元壹角贰分", digitToChinese);
+		
+		String digitToChinese2 = Convert.digitToChinese(12412412412421D);
+		Assert.assertEquals("壹拾贰万肆仟壹佰贰拾肆亿壹仟贰佰肆拾壹万贰仟肆佰贰拾壹元整", digitToChinese2);
+		
+		String digitToChinese3 = Convert.digitToChinese(2421.02);
+		Assert.assertEquals("贰仟肆佰贰拾壹元零贰分", digitToChinese3);
+	}
+```
+
+## 引用
+
+[Hutool NumberChineseFormater](https://github.com/looly/hutool/blob/v4-master/hutool-core/src/main/java/cn/hutool/core/convert/NumberChineseFormater.java)
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/\346\225\260\345\255\227\350\275\254\350\213\261\346\226\207.md" "b/java/\344\273\243\347\240\201\347\211\207/\346\225\260\345\255\227\350\275\254\350\213\261\346\226\207.md"
new file mode 100644
index 0000000..38e83dd
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/\346\225\260\345\255\227\350\275\254\350\213\261\346\226\207.md"
@@ -0,0 +1,176 @@
+## 使用英文描述数字
+
+### 代码
+
+```java
+/**
+ * 将浮点数类型的number转换成英语的表达方式 <br>
+ * 参考博客：http://blog.csdn.net/eric_sunah/article/details/8713226
+ * 
+ * @author Looly
+ * @since 3.0.9
+ * @see <a href=
+ *      "http://blog.csdn.net/eric_sunah/article/details/8713226">http://blog.csdn.net/eric_sunah/article/details/8713226</a>
+ */
+public class NumberWordFormater {
+
+	private static final String[] NUMBER = new String[] { "", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN",
+			"EIGHT", "NINE" };
+	private static final String[] NUMBER_TEEN = new String[] { "TEN", "ELEVEN", "TWELEVE", "THIRTEEN", "FOURTEEN",
+			"FIFTEEN", "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN" };
+	private static final String[] NUMBER_TEN = new String[] { "TEN", "TWENTY", "THIRTY", "FORTY", "FIFTY", "SIXTY",
+			"SEVENTY", "EIGHTY", "NINETY" };
+	private static final String[] NUMBER_MORE = new String[] { "", "THOUSAND", "MILLION", "BILLION" };
+
+	/**
+	 * 将阿拉伯数字转为英文表达式
+	 * 
+	 * @param x
+	 *            阿拉伯数字，可以为{@link Number}对象，也可以是普通对象，最后会使用字符串方式处理
+	 * @return 英文表达式
+	 */
+	public static String format(Object x) {
+		if (x != null) {
+			return format(x.toString());
+		} else {
+			return "";
+		}
+	}
+
+	/**
+	 * 将阿拉伯数字转为英文表达式
+	 * 
+	 * @param x
+	 *            阿拉伯数字字符串
+	 * @return 英文表达式
+	 */
+	private static String format(String x) {
+		int z = x.indexOf("."); // 取小数点位置
+		String lstr = "", rstr = "";
+		if (z > -1) { // 看是否有小数，如果有，则分别取左边和右边
+			lstr = x.substring(0, z);
+			rstr = x.substring(z + 1);
+		} else {
+			// 否则就是全部
+			lstr = x;
+		}
+
+		String lstrrev = reverse(lstr); // 对左边的字串取反
+		String[] a = new String[5]; // 定义5个字串变量来存放解析出来的叁位一组的字串
+
+		switch (lstrrev.length() % 3) {
+		case 1:
+			lstrrev += "00";
+			break;
+		case 2:
+			lstrrev += "0";
+			break;
+		}
+		String lm = ""; // 用来存放转换後的整数部分
+		for (int i = 0; i < lstrrev.length() / 3; i++) {
+			a[i] = reverse(lstrrev.substring(3 * i, 3 * i + 3)); // 截取第一个叁位
+			if (!a[i].equals("000")) { // 用来避免这种情况：1000000 = one million
+										// thousand only
+				if (i != 0) {
+					lm = transThree(a[i]) + " " + parseMore(String.valueOf(i)) + " " + lm; // 加:
+																							// thousand、million、billion
+				} else {
+					lm = transThree(a[i]); // 防止i=0时， 在多加两个空格.
+				}
+			} else {
+				lm += transThree(a[i]);
+			}
+		}
+
+		String xs = ""; // 用来存放转换後小数部分
+		if (z > -1) {
+			xs = "AND CENTS " + transTwo(rstr) + " "; // 小数部分存在时转换小数
+		}
+
+		return lm.trim() + " " + xs + "ONLY";
+	}
+
+	private static String reverse(String substring) {
+		char[] chars = substring.toCharArray();
+		int len = chars.length - 1;
+		for (int i = 0; i < chars.length / 2; i++) {
+			char tmp = chars[i];
+			chars[i] = chars[len];
+			chars[len] = tmp;
+			len--;
+		}
+
+		return new String(chars);
+	}
+
+	private static String parseFirst(String s) {
+		return NUMBER[Integer.parseInt(s.substring(s.length() - 1))];
+	}
+
+	private static String parseTeen(String s) {
+		return NUMBER_TEEN[Integer.parseInt(s) - 10];
+	}
+
+	private static String parseTen(String s) {
+		return NUMBER_TEN[Integer.parseInt(s.substring(0, 1)) - 1];
+	}
+
+	private static String parseMore(String s) {
+		return NUMBER_MORE[Integer.parseInt(s)];
+	}
+
+	// 两位
+	private static String transTwo(String s) {
+		String value = "";
+		// 判断位数
+		if (s.length() > 2) {
+			s = s.substring(0, 2);
+		} else if (s.length() < 2) {
+			s = "0" + s;
+		}
+
+		if (s.startsWith("0")) {// 07 - seven 是否小於10
+			value = parseFirst(s);
+		} else if (s.startsWith("1")) {// 17 seventeen 是否在10和20之间
+			value = parseTeen(s);
+		} else if (s.endsWith("0")) {// 是否在10与100之间的能被10整除的数
+			value = parseTen(s);
+		} else {
+			value = parseTen(s) + " " + parseFirst(s);
+		}
+		return value;
+	}
+
+	// 制作叁位的数
+	// s.length = 3
+	private static String transThree(String s) {
+		String value = "";
+		if (s.startsWith("0")) {// 是否小於100
+			value = transTwo(s.substring(1));
+		} else if (s.substring(1).equals("00")) {// 是否被100整除
+			value = parseFirst(s.substring(0, 1)) + " HUNDRED";
+		} else {
+			value = parseFirst(s.substring(0, 1)) + " HUNDRED AND " + transTwo(s.substring(1));
+		}
+		return value;
+	}
+}
+```
+
+### 测试
+
+```java
+	@Test
+	public void formatTest() {
+		String format = NumberWordFormater.format(100.23);
+		Assert.assertEquals("ONE HUNDRED AND CENTS TWENTY THREE ONLY", format);
+		
+		String format2 = NumberWordFormater.format("2100.00");
+		Assert.assertEquals("TWO THOUSAND ONE HUNDRED AND CENTS  ONLY", format2);
+	}
+```
+
+### 引用
+
+[Hutool NumberWordFormater](https://github.com/looly/hutool/blob/v4-master/hutool-core/src/main/java/cn/hutool/core/convert/NumberWordFormater.java)
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/\346\226\207\344\273\266\346\223\215\344\275\234\345\267\245\345\205\267\347\261\273.md" "b/java/\344\273\243\347\240\201\347\211\207/\346\226\207\344\273\266\346\223\215\344\275\234\345\267\245\345\205\267\347\261\273.md"
new file mode 100644
index 0000000..9f7cc7e
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/\346\226\207\344\273\266\346\223\215\344\275\234\345\267\245\345\205\267\347\261\273.md"
@@ -0,0 +1,294 @@
+## 文件操作工具类
+
+### 代码
+
+```java
+package top.feb13th.deploy.util;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.StringJoiner;
+
+/**
+ * 输入输出工具类
+ *
+ * @author zhoutaotao
+ * @date 2019/9/24 16:26
+ */
+public class IoUtil {
+
+  /**
+   * 获取系统临时目录
+   *
+   * @param dirs 在临时目录后额外增加的文件名称
+   * @return 系统临时目录
+   */
+  public static String getTmpdir(String... dirs) {
+    String tmpdir = System.getProperty("java.io.tmpdir");
+    StringJoiner joiner = new StringJoiner(File.separator);
+    joiner.add(tmpdir);
+    for (String dir : dirs) {
+      joiner.add(dir);
+    }
+    return joiner.toString();
+  }
+
+  /**
+   * 获取应用程序的运行路径
+   *
+   * @param dirs 子目录
+   * @return 应用程序运行目录 + 子目录
+   */
+  public static String getAppDir(String... dirs) {
+    // 获取当前程序的运行路径
+    String location = IoUtil.class.getProtectionDomain().getCodeSource().getLocation()
+        .getFile();
+    if (location.startsWith("file:")) {
+      location = location.substring(5);
+    }
+    if (location.contains(".jar")) {
+      location = location.substring(0, location.indexOf(".jar"));
+      File file = new File(location);
+      location = file.getParent();
+    }
+    File file = new File(location);
+    if (file.isFile()) {
+      // 如果当前是执行的jar文件, 获取jar文件的所在目录
+      location = file.getParent();
+    }
+    return appendPath(location, dirs);
+  }
+
+  /**
+   * 拼接路径
+   *
+   * @param prefix 前缀
+   * @param paths 路径列表
+   * @return 路径
+   */
+  public static String appendPath(String prefix, String... paths) {
+    if (StringUtil.isBlank(prefix)) {
+      return null;
+    }
+    StringJoiner joiner = new StringJoiner(File.separator);
+    joiner.add(prefix);
+    for (String path : paths) {
+      joiner.add(path);
+    }
+    return joiner.toString();
+  }
+
+  /**
+   * 删除文件
+   *
+   * @param dirPath 文件路径
+   */
+  public static void delete(String dirPath) {
+    // 文件路径为空时, 直接返回
+    if (StringUtil.isBlank(dirPath)) {
+      return;
+    }
+    File dirFile = new File(dirPath);
+    String[] list = dirFile.list();
+    if (list != null && list.length > 0) {
+      for (String filename : list) {
+        String newFilePath = dirPath + File.separator + filename;
+        File file = new File(newFilePath);
+        if (file.isDirectory()) {
+          delete(newFilePath);
+        }
+        file.delete();
+      }
+    }
+    if (dirFile.exists()) {
+      dirFile.delete();
+    }
+  }
+
+  /**
+   * 目录内容拷贝，只拷贝文件内部的文件及文件夹
+   *
+   * @param from 源目录
+   * @param to 目标目录
+   */
+  public static void copyDir(File from, File to) {
+    String[] list;
+    if (!from.isDirectory() || (list = from.list()) == null) {
+      return;
+    }
+    String fromPath = from.getAbsolutePath();
+    String toPath = to.getAbsolutePath();
+
+    for (String filename : list) {
+      String fromFilepath = fromPath + File.separator + filename;
+      String toFilepath = toPath + File.separator + filename;
+      File fromFile = new File(fromFilepath);
+      File toFile = new File(toFilepath);
+      if (fromFile.isDirectory()) {
+        // 如果赋值的是文件夹,则创建该文件夹, 并进入文件夹内部拷贝文件
+        toFile.mkdirs();
+        copyDir(fromFile, toFile);
+      } else {
+        // 拷贝文件内容
+        copyFile(fromFile, toFile);
+      }
+    }
+  }
+
+  /**
+   * 拷贝两个文件的内容
+   *
+   * @param from 源文件
+   * @param to 目标文件
+   */
+  public static void copyFile(File from, File to) {
+    FileInputStream fromIs = null;
+    FileOutputStream toOs = null;
+    FileChannel fromChannel = null;
+    FileChannel toChannel = null;
+    try {
+      if (!to.exists()) {
+        createFile(to);
+      }
+      fromIs = new FileInputStream(from);
+      toOs = new FileOutputStream(to);
+      fromChannel = fromIs.getChannel();
+      toChannel = toOs.getChannel();
+      fromChannel.transferTo(0, fromChannel.size(), toChannel);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    } finally {
+      close(fromChannel);
+      close(fromIs);
+      close(toChannel);
+      close(toOs);
+    }
+  }
+
+  public static void close(Closeable closeable) {
+    if (closeable != null) {
+      try {
+        closeable.close();
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  /**
+   * 从指定文件中读取字符串
+   *
+   * @param filepath 文件路径
+   * @return 如果文件不存在则返回null, 否则返回文件字符串内容
+   */
+  public static String readString(String filepath) {
+    Path path = Paths.get(new File(filepath).toURI());
+    if (!Files.exists(path)) {
+      return null;
+    }
+    try {
+      return Files.readAllLines(path, StandardCharsets.UTF_8).stream().reduce("", String::concat);
+    } catch (IOException e) {
+      return null;
+    }
+  }
+
+  /**
+   * 向文件中写入content
+   *
+   * @param filepath 文件路径
+   * @param content 文件内容字符串
+   */
+  public static void writeString(String filepath, String... content) {
+    try {
+      Path path = Paths.get(new File(filepath).toURI());
+      Files.deleteIfExists(path);
+      Path parent = path.getParent();
+      if (!Files.exists(parent)) {
+        Files.createDirectories(parent);
+      }
+      Files.createFile(path);
+      Files.write(path, Arrays.asList(content), StandardCharsets.UTF_8);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * 创建新文件, 如果存在则删除重新创建
+   *
+   * @param filepath 文件路径
+   */
+  public static void createFile(String filepath) {
+    if (StringUtil.isBlank(filepath)) {
+      throw new NullPointerException("filepath must not empty");
+    }
+    createFile(new File(filepath));
+  }
+
+  /**
+   * 创建新文件, 如果存在则删除重新创建
+   *
+   * @param file 文件
+   */
+  public static void createFile(File file) {
+    if (ObjectUtil.isNull(file)) {
+      throw new NullPointerException("core must not null");
+    }
+    try {
+      Path path = Paths.get(file.toURI());
+      Files.deleteIfExists(path);
+      Path parent = path.getParent();
+      if (!Files.exists(parent)) {
+        Files.createDirectories(parent);
+      }
+      Files.createFile(path);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * 创建目录
+   *
+   * @param directorPath 目录路径
+   */
+  public static void createDirector(String directorPath) {
+    if (StringUtil.isBlank(directorPath)) {
+      throw new NullPointerException("director path must not empty");
+    }
+    createDirector(new File(directorPath));
+  }
+
+  /**
+   * 创建目录
+   *
+   * @param file 目录
+   */
+  public static void createDirector(File file) {
+    if (ObjectUtil.isNull(file)) {
+      throw new NullPointerException("director core must not null");
+    }
+    try {
+      Path path = Paths.get(file.toURI());
+      if (!Files.exists(path)) {
+        Files.createDirectories(path);
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+}
+
+```
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/\350\204\232\346\234\254\350\260\203\347\224\250.md" "b/java/\344\273\243\347\240\201\347\211\207/\350\204\232\346\234\254\350\260\203\347\224\250.md"
new file mode 100644
index 0000000..b9b270e
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/\350\204\232\346\234\254\350\260\203\347\224\250.md"
@@ -0,0 +1,22 @@
+## 调用服务器本地脚本
+
+### 代码
+
+```java
+  public static String exec(String command) {
+    StringBuilder sb = new StringBuilder();
+    try {
+      Process exec = Runtime.getRuntime().exec(command);
+      exec.waitFor();
+      BufferedReader br = new BufferedReader(new InputStreamReader(exec.getInputStream()));
+      String tmp = null;
+      while ((tmp = br.readLine()) != null) {
+        sb.append(tmp);
+      }
+    } catch (IOException | InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+    return sb.toString();
+  }
+```
+
diff --git "a/java/\344\273\243\347\240\201\347\211\207/\350\216\267\345\217\226\346\226\207\344\273\266\345\210\233\345\273\272\346\227\266\351\227\264.md" "b/java/\344\273\243\347\240\201\347\211\207/\350\216\267\345\217\226\346\226\207\344\273\266\345\210\233\345\273\272\346\227\266\351\227\264.md"
new file mode 100644
index 0000000..ab40f13
--- /dev/null
+++ "b/java/\344\273\243\347\240\201\347\211\207/\350\216\267\345\217\226\346\226\207\344\273\266\345\210\233\345\273\272\346\227\266\351\227\264.md"
@@ -0,0 +1,25 @@
+## 获取文件的创建时间
+
+### 代码
+
+由于linux下不能获取文件的创建时间，并且java中没有对应获取文件创建时间的api，只有获取修改时间的api,所以如果想在windows下获取创建时间可以这样（适用于windows和linux，linux下获取的是访问时间即修改时间，windows下获取的是创建时间）：
+
+```java
+private Long getFileCreateTime(String filePath){
+    File file = new File(filePath);
+    try {
+        Path path= Paths.get(filePath);
+        BasicFileAttributeView basicview= Files.getFileAttributeView(path, BasicFileAttributeView.class, LinkOption.NOFOLLOW_LINKS );
+        BasicFileAttributes attr = basicview.readAttributes();
+        return attr.creationTime().toMillis();
+    } catch (Exception e) {
+        e.printStackTrace();
+        return file.lastModified();
+    }
+}
+```
+
+### 引用
+
+[java获取文件的创建时间](https://blog.csdn.net/qingfengmuzhu1993/article/details/84238731)
+
diff --git "a/java/\344\275\277\347\224\250\345\221\275\344\273\244\347\274\226\350\257\221\346\211\223\345\214\205.md" "b/java/\344\275\277\347\224\250\345\221\275\344\273\244\347\274\226\350\257\221\346\211\223\345\214\205.md"
new file mode 100644
index 0000000..12e25ea
--- /dev/null
+++ "b/java/\344\275\277\347\224\250\345\221\275\344\273\244\347\274\226\350\257\221\346\211\223\345\214\205.md"
@@ -0,0 +1,177 @@
+## 目录准备
+
+1. 创建项目根目录 `project`
+2. 创建源码目录`project/src`
+3. 创建编译文件后的文件目录`project/classes`
+4. 创建`lib`库目录`project/lib`
+
+## 编译
+
+### 不依赖任何类库
+
+1、在`project/src`目录下创建`com/feb13th/demo1`文件夹及其子文件夹。
+
+2、在`demo1`文件夹下创建`HelloWorld.java`文件。
+
+`package`用于指定当前文件的包名，如果当前文件在根目录（本项目中是`src`目录），那么可以省略`package`一行。
+
+`import`用于引入其他在项目中可能用到的文件。格式为`包名.文件名`(文件名需去除**.java**后缀)。
+
+`HelloWorld.java`
+
+```java
+package com.feb13th.demo1;
+
+import com.feb13th.demo1.util.MyTools;
+
+public class HelloWorld {
+	public static void main(String[] args) {
+		System.out.println("Hello World!!");
+		System.out.println(new MyTools().getTime());
+	}
+}
+```
+
+3、在`demo1`文件夹下创建`util`文件夹用于存在`MyTools.java`文件。
+
+`MyTools.java`
+
+```java
+package com.feb13th.demo1.util;
+
+import java.util.Date;
+
+public class MyTools {
+	public String getTime() {
+		return new Date().toString();
+	}
+}
+```
+
+4、在`project`文件夹下执行如下命令编译：
+
+```shell
+javac -d .\classes .\src\com\feb13th\demo1\HelloWorld.java .\src\com\feb13th\demo1\util\MyTools.java
+```
+
+目录分隔符根据操作系统划分，windows为**\\**， linux为**/**
+
+**-d** 用于指定文件编译后的输出目录。
+
+后面跟的两项为我们要编译的**java**源文件。如果在同一个目录下存在多个需要编译的源文件，可以使用匹配符***.java**，如`.\src\com\feb13th\demo1\*.java`。
+
+**注： ** ***.java**只能匹配与单个文件夹，对其子文件无效。
+
+### 依赖类库
+
+将依赖的类库文件放入`lib`目录下。如`lib\fastjson-1.2.58.jar`
+
+1、修改`HelloWorld.java`
+
+```java
+package com.feb13th.demo1;
+
+import com.feb13th.demo1.util.MyTools;
+import com.alibaba.fastjson.JSONObject;
+
+public class HelloWorld {
+	public static void main(String[] args) {
+		System.out.println("Hello World!!");
+		System.out.println(new MyTools().getTime());
+		JSONObject obj = new JSONObject();
+		obj.put("1", "one");
+		obj.put("2", "two");
+		System.out.println(obj.toJSONString());
+	}
+}
+```
+
+导入`fastjson`对象，并使用该对象生成`json`字符串。
+
+2、使用`-classpath`指定类库文件
+
+```shell
+javac -d .\classes -classpath .\lib\fastjson-1.2.58.jar .\src\com\feb13th\demo1\HelloWorld.java .\src\com\feb13th\demo1\util\MyTools.java
+```
+
+**-classpath** 用于指定代码编译时使用类库的位置，多个类库可以使用分隔符进行分割，windows使用 **;** ，linux使用 **:** 
+
+
+
+## 运行
+
+`java`指令用于运行**java**程序
+
+### 运行未依赖类库的程序
+
+执行`java`指令需要在编译文件的根目录
+
+```shell
+java com.feb13th.demo1.HelloWorld
+```
+
+语法为：`java  main函数所在的文件`
+
+### 运行依赖类库的程序
+
+切换到`project`目录。执行如下脚本
+
+```shell
+java -classpath ./classes/;./lib/fastjson-1.2.58.jar;./dependency/* com.feb13th.demo1.HelloWorld
+```
+
+**-classpath** 用于指定可执行文件的位置。
+
+`./classes`：刚刚编译的class文件目录
+
+`./lib/fastjson-1.2.58.jar`：程序中依赖的类库。
+
+`./dependency/*`：存放jar的文件夹，当我们有很多jar的时候，一个个指定classpath无疑费时费力，那么我们可以将所有的jar存放到一个目录中，使用通配符进行指定classpath。
+
+多个classpath之间使用分隔符进行分割，windows使用 **;** ，linux使用 **:** 
+
+**注：** 指定jar包时，不能通过匹配符进行匹配。例如`spring-*.jar`
+
+
+
+## 打包
+
+1、拷贝`lib`目录到`classes`目录下
+
+2、编写`MANIFEST.MF`文件。
+
+```
+Manifest-Version: 1.0
+Created-By: 1.8.0_71 (Oracle Corporation)
+Main-Class: com.feb13th.demo1.HelloWorld
+Class-Path: lib/fastjson-1.2.58.jar
+
+
+```
+
+该文件最后必须**保留两个空行**。**：**(冒号)后面必须跟一个空格。
+
+**Manifest-Version**：指定版本号（可选）
+
+**Created-By**：构建的JDK版本（可选）
+
+**Main-Class**：main方法所有在类，如果指定必须唯一。
+
+**Class-Path**：jar包中访问第三方类库的路径，和本地jar包的存储路径不是一个东西。多个类库之间使用 **空格** 分割。如果没有依赖第三方库可以不指定。
+
+3、切换到`project`目录，执行打包脚本
+
+```shell
+jar -cvfm my.jar ./MANIFEST.MF -C ./classes .
+```
+
+**-C** 用于指定目录并包含该目录下的文件， **.** (点)用于匹配当前文件夹下的所有文件。
+
+4、运行jar
+
+```shell
+java -jar my.jar
+```
+
+也可以指定**-classpath**
+
diff --git "a/java/\345\212\250\346\200\201\344\273\243\347\220\206.md" "b/java/\345\212\250\346\200\201\344\273\243\347\220\206.md"
new file mode 100644
index 0000000..38a2a0e
--- /dev/null
+++ "b/java/\345\212\250\346\200\201\344\273\243\347\220\206.md"
@@ -0,0 +1,312 @@
+# Java核心技术点之动态代理
+
+​    本篇博文会从代理的概念出发，介绍Java中动态代理技术的使用，并进一步探索它的实现原理。由于个人水平有限，叙述中难免出现不清晰或是不准确的地方，希望大家可以指正，谢谢大家：）
+
+# 一、概述
+
+## 1. 什么是代理
+
+​    我们大家都知道微商代理，简单地说就是代替厂家卖商品，厂家“委托”代理为其销售商品。关于微商代理，首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁，也就是说，“委托者”对我们来说是不可见的；其次，微商代理主要以朋友圈的人为目标客户，这就相当于为厂家做了一次对客户群体的“过滤”。我们把微商代理和厂家进一步抽象，前者可抽象为代理类，后者可抽象为委托类（被代理类）。通过使用代理，通常有两个优点，并且能够分别与我们提到的微商代理的两个特点对应起来：
+
+- 优点一：可以隐藏委托类的实现；
+- 优点二：可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理。
+
+##  
+
+## 2. 静态代理
+
+​     若代理类在程序运行前就已经存在，那么这种代理方式被成为**静态代理**，这种情况下的代理类通常都是我们在Java代码中定义的。 通常情况下，**静态代理中的代理类和委托类会实现同一接口或是派生自相同的父类。**下面我们用Vendor类代表生产厂家，BusinessAgent类代表微商代理，来介绍下静态代理的简单实现，委托类和代理类都实现了Sell接口，Sell接口的定义如下：
+
+```java
+public interface Sell {
+    void sell();
+    void ad();
+}
+```
+
+ 
+
+​    Vendor类的定义如下：
+
+```
+public class Vendor implements Sell {
+    public void sell() {
+        System.out.println("In sell method");
+    }
+    public void ad() {
+        System,out.println("ad method")
+    }
+}
+```
+
+ 
+
+​    代理类BusinessAgent的定义如下：
+
+```java
+ 1 public class BusinessAgent implements Sell {
+ 2     private Vendor mVendor;
+ 3   
+ 4     public BusinessAgent(Vendor vendor) {
+ 5         mVendor = vendor;
+ 6     }
+ 7    
+ 8     public void sell() { mVendor.sell(); }
+ 9     public void ad() { mVendor.ad(); }
+10 }
+```
+
+​    从BusinessAgent类的定义我们可以了解到，静态代理可以通过聚合来实现，让代理类持有一个委托类的引用即可。
+
+​    下面我们考虑一下这个需求：给Vendor类增加一个过滤功能，只卖货给大学生。通过静态代理，我们无需修改Vendor类的代码就可以实现，只需在BusinessAgent类中的sell方法中添加一个判断即可如下所示：
+
+```java
+public class BusinessAgent implements Sell {
+    ...
+    public void sell() {
+        if (isCollegeStudent()) {
+            vendor.sell();
+        }
+    }
+    ...
+}
+```
+
+​    这对应着我们上面提到的使用代理的第二个优点：可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理。静态代理的局限在于运行前必须编写好代理类，下面我们重点来介绍下运行时生成代理类的动态代理方式。
+
+ 
+
+# 二、动态代理
+
+## 1. 什么是动态代理
+
+​    代理类在程序运行时创建的代理方式被成为**动态代理。**也就是说，这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理，**动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。**这么说比较抽象，下面我们结合一个实例来介绍一下动态代理的这个优势是怎么体现的。
+
+​    现在，假设我们要实现这样一个需求：在执行委托类中的方法之前输出“before”，在执行完毕后输出“after”。我们还是以上面例子中的Vendor类作为委托类，BusinessAgent类作为代理类来进行介绍。首先我们来使用静态代理来实现这一需求，相关代码如下：
+
+```java
+public class BusinessAgent implements Sell {
+    private Vendor mVendor;
+    
+    public BusinessAgent(Vendor vendor) {
+        this.mVendor = vendor;
+    }
+
+    public void sell() {
+        System.out.println("before");
+        mVendor.sell();
+        System.out.println("after");
+    }
+
+    public void ad() {
+        System.out.println("before");
+        mVendor.ad();
+        System.out.println("after");
+    }
+}
+```
+
+​     从以上代码中我们可以了解到，通过静态代理实现我们的需求需要我们在每个方法中都添加相应的逻辑，这里只存在两个方法所以工作量还不算大，假如Sell接口中包含上百个方法呢？这时候使用静态代理就会编写许多冗余代码。通过使用动态代理，我们可以做一个“统一指示”，从而对所有代理类的方法进行统一处理，而不用逐一修改每个方法。下面我们来具体介绍下如何使用动态代理方式实现我们的需求。
+
+##  
+
+## 2. 使用动态代理
+
+### （1）InvocationHandler接口
+
+​    在使用动态代理时，我们需要定义一个位于代理类与委托类之间的中介类，这个中介类被要求实现InvocationHandler接口，这个接口的定义如下：
+
+```java
+public interface InvocationHandler {
+    Object invoke(Object proxy, Method method, Object[] args);
+}
+```
+
+​    从InvocationHandler这个名称我们就可以知道，实现了这个接口的中介类用做“调用处理器”。当我们调用代理类对象的方法时，这个“调用”会转送到invoke方法中，代理类对象作为proxy参数传入，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。这样一来，我们对代理类中的所有方法的调用都会变为对invoke的调用，这样我们可以在invoke方法中添加统一的处理逻辑（也可以根据method参数对不同的代理类方法做不同的处理）。因此我们只需在中介类的invoke方法实现中输出“before”，然后调用委托类的invoke方法，再输出“after”。下面我们来一步一步具体实现它。
+
+###  
+
+### （2）委托类的定义
+
+​    动态代理方式下，要求委托类必须实现某个接口，这里我们实现的是Sell接口。委托类Vendor类的定义如下：
+
+```java
+public class Vendor implements Sell {
+    public void sell() {
+        System.out.println("In sell method");
+    }
+    public void ad() {
+        System,out.println("ad method")
+    }
+}
+```
+
+ 
+
+### （3）中介类
+
+​    上面我们提到过，中介类必须实现InvocationHandler接口，作为调用处理器”拦截“对代理类方法的调用。中介类的定义如下：
+
+```java
+public class DynamicProxy implements InvocationHandler {
+    private Object obj; //obj为委托类对象；
+    
+    public DynamicProxy(Object obj) {
+        this.obj = obj;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        System.out.println("before");
+        Object result = method.invoke(obj, args);
+        System.out.println("after");
+        return result;
+    }
+}
+```
+
+​     从以上代码中我们可以看到，中介类持有一个委托类对象引用，在invoke方法中调用了委托类对象的相应方法（第11行），看到这里是不是觉得似曾相识？通过聚合方式持有委托类对象引用，把外部对invoke的调用最终都转为对委托类对象的调用。这不就是我们上面介绍的静态代理的一种实现方式吗？实际上，中介类与委托类构成了静态代理关系，在这个关系中，中介类是代理类，委托类就是委托类；
+
+代理类与中介类也构成一个静态代理关系，在这个关系中，中介类是委托类，代理类是代理类。也就是说，动态代理关系由两组静态代理关系组成，这就是动态代理的原理。下面我们来介绍一下如何”指示“以动态生成代理类。
+
+ 
+
+### （4）动态生成代理类
+
+​    动态生成代理类的相关代码如下：
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        //创建中介类实例
+        DynamicProxy  inter = new DynamicProxy(new Vendor());
+        //加上这句将会产生一个$Proxy0.class文件，这个文件即为动态生成的代理类文件
+        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 
+        //获取代理类实例sell
+        Sell sell = (Sell)(Proxy.newProxyInstance(Sell.class.getClassLoader(),
+        new Class[] {Sell.class}, inter));
+        //通过代理类对象调用代理类方法，实际上会转到invoke方法调用
+        sell.sell();
+        sell.ad();
+    }
+}
+```
+
+​    在以上代码中，我们调用Proxy类的newProxyInstance方法来获取一个代理类实例。这个代理类实现了我们指定的接口并且会把方法调用分发到指定的调用处理器。这个方法的声明如下：
+
+```java
+public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
+```
+
+ 方法的三个参数含义分别如下：
+
+- loader：定义了代理类的ClassLoder；
+
+- interfaces：代理类实现的接口列表
+
+- h：调用处理器，也就是我们上面定义的实现了InvocationHandler接口的类实例
+
+  
+
+​       上面我们已经简单提到过动态代理的原理，这里再简单的总结下：首先通过newProxyInstance方法获取代理类实例，而后我们便可以通过这个代理类实例调用代理类的方法，对代理类的方法的调用实际上都会调用中介类（调用处理器）的invoke方法，在invoke方法中我们调用委托类的相应方法，并且可以添加自己的处理逻辑。下面我们来看一下生成的代理类的代码究竟是怎样的。
+
+## 3. 动态代理类的源码分析
+
+​    通过运行Main，我们会得到一个名为“$Proxy”的class文件，这个文件即为动态生成的代理类，我们通过反编译来查看下这个代理类的源代码：
+
+```java
+package com.sun.proxy;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.UndeclaredThrowableException;
+
+public final class $Proxy0 extends Proxy implements Sell {
+    //这5个Method对象分别代表equals()、toString()、ad()、sell()、hashCode()方法
+    private static Method m1;
+    private static Method m2;
+    private static Method m4;
+    private static Method m3;
+    private static Method m0;
+    
+    //构造方法接收一个InvocationHandler对象为参数，这个对象就是代理类的“直接委托类”（真正的委托类可以看做代理类的“间接委托类”）
+    public $Proxy0(InvocationHandler var1) throws  {
+        super（var1);
+    }
+
+    //对equals方法的调用实际上转为对super.h.invoke方法的调用，父类中的h即为我们在构造方法中传入的InvocationHandler对象，以下的toString()、sell()、ad()、hashCode()等方法同理
+    public final boolean equals(Object var1) throws  {
+        try {
+            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
+        } catch (RuntimeException | Error var3) {
+            throw var3;
+        } catch (Throwable var4) {
+            throw new UndeclaredThrowableException(var4);
+        }
+    }
+
+    public final String toString() throws  {
+        try {
+            return (String)super.h.invoke(this, m2, (Object[])null);
+        } catch (RuntimeException | Error var2) {
+            throw var2;
+        } catch (Throwable var3) {
+            throw new UndeclaredThrowableException(var3);
+        }
+    }
+
+    public final void ad() throws  {
+        try {
+            super.h.invoke(this, m4, (Object[])null);
+        } catch (RuntimeException | Error var2) {
+            throw var2;
+        } catch (Throwable var3) {
+            throw new UndeclaredThrowableException(var3);
+        }
+    }
+
+    public final void sell() throws  {
+        try {
+            super.h.invoke(this, m3, (Object[])null);
+        } catch (RuntimeException | Error var2) {
+            throw var2;
+        } catch (Throwable var3) {
+            throw new UndeclaredThrowableException(var3);
+        }
+    }
+
+    public final int hashCode() throws  {
+        try {
+            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
+        } catch (RuntimeException | Error var2) {
+            throw var2;
+        } catch (Throwable var3) {
+            throw new UndeclaredThrowableException(var3);
+        }
+    }
+    
+    //这里完成Method对象的初始化（通过反射在运行时获得Method对象）
+    static {
+        try {
+            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
+            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
+            m4 = Class.forName("Sell").getMethod("ad", new Class[0]);
+            m3 = Class.forName("Sell").getMethod("sell", new Class[0]);
+            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
+        } catch (NoSuchMethodException var2) {
+            throw new NoSuchMethodError(var2.getMessage());
+        } catch (ClassNotFoundException var3) {
+            throw new NoClassDefFoundError(var3.getMessage());
+        }
+    }
+}
+```
+
+​     我们可以看到，以上代码的逻辑十分简单，我们在注释中也做出了相关的说明。
+
+​    现在，我们已经了解了动态代理的使用，也搞清楚了它的实现原理，更进一步的话我们可以去了解动态代理类的生成过程，只需要去阅读newProxyInstance方法的源码即可，这个方法的逻辑也没有复杂的地方，这里就不展开了。
+
+# 三、引用
+
+[Java核心技术点之动态代理](https://www.cnblogs.com/absfree/p/5392639.html)
\ No newline at end of file
diff --git "a/java/\345\244\232\346\254\241\345\210\240\351\231\244\344\270\215\346\216\211\346\226\207\344\273\266.md" "b/java/\345\244\232\346\254\241\345\210\240\351\231\244\344\270\215\346\216\211\346\226\207\344\273\266.md"
new file mode 100644
index 0000000..76c4b37
--- /dev/null
+++ "b/java/\345\244\232\346\254\241\345\210\240\351\231\244\344\270\215\346\216\211\346\226\207\344\273\266.md"
@@ -0,0 +1,11 @@
+### 原因
+
+被删除的文件任然被虚拟机占用，导致文件删除不掉。
+
+最大的原因是因为将文件打开为流的位置没有被关闭导致的。
+
+### 解决方案
+
+1、找出文件被使用为流的位置，将文件流关闭
+
+2、多次进行删除文件，通过使用`System.gc()`进行内存回收，从而释放内存。（不推荐，会导致频繁gc）
\ No newline at end of file
diff --git "a/java/\345\244\232\347\272\277\347\250\213\344\271\213\351\227\264\347\232\204\347\256\241\351\201\223\346\265\201.md" "b/java/\345\244\232\347\272\277\347\250\213\344\271\213\351\227\264\347\232\204\347\256\241\351\201\223\346\265\201.md"
new file mode 100644
index 0000000..59c790d
--- /dev/null
+++ "b/java/\345\244\232\347\272\277\347\250\213\344\271\213\351\227\264\347\232\204\347\256\241\351\201\223\346\265\201.md"
@@ -0,0 +1,59 @@
+### 管道输入/输出流
+
+管道输入/输出流和普通的文件输入/输出流或网络输入/输出流不同之处在于， 它主要用于线程之间的数据传输，而传输的媒介为内存。
+
+管道输入/输出流主要包括了有如下两类实现：
+
+**面向字节的管道流：**
+
+* PipedOutputStream
+* PipedInputStream
+
+**面向字符的管道流：**
+
+* PipedReader
+* PipedWriter
+
+对于**Piped**类型的流，必须先要进行绑定，也就是调用**connect()**方法，如果没有将输入/输出流绑定起来，对于该流的访问将会抛出异常。
+
+
+
+#### DEMO
+
+```java
+public class Piped {
+    public static void main(String[] args) {
+        PipedWriter out = new PipedWriter();
+        PipedReader in = new PipedReader();
+        // 将输出流和输入流进行连接，否则在使用时会抛出异常
+        out.connect(in);
+        Thread t = new Thread(new Print(in), "PrintThread");
+        t.start();
+        int receive = 0;
+        try {
+            while((receive = System.in.read()) != -1) {
+                out.write(receive);
+            }
+        } finally {
+            out.close();
+        }
+    }
+    
+    static class Print implements Runnable {
+        private PipedReader in;
+        public Print(PipedReader in) {
+            this.in = in;
+        }
+        public void run() {
+            int receive = 0;
+            try {
+                while((receive = in.read()) != -1) {
+                    System.out.println((char) receive);
+                }
+            } catch (IOException ex){
+            }
+        }
+    }
+}
+```
+
diff --git "a/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\345\210\206\347\273\204.md" "b/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\345\210\206\347\273\204.md"
new file mode 100644
index 0000000..2a9eb62
--- /dev/null
+++ "b/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\345\210\206\347\273\204.md"
@@ -0,0 +1,113 @@
+### 分组
+
+在正则表达式中使用`()`进行分组。`()`中匹配到的规则为一组。
+
+在`JAVA`中，默认分组`0`为整个表达式。其余子分组下标从`1`开始。
+
+
+
+### 分组嵌套下标规则
+
+在多个分组嵌套的正则表达式中。下标的计算规则为：从左到右，从外到内，遇内则进。
+
+比如我们有这样一种正则表达式`((()())())()`。为了更直观的表达式，换下符号：`{[()()][]}{}`。
+
+这是三层嵌套结果。那么下标和分组的对对应关系如下：
+
+| 下标 | 分组符号     |
+| ---- | ------------ |
+| 0    | {\[\(\)\()][]}{} |
+| 1 | 左边的{} |
+| 2 | 左边的[] |
+| 3 | 左边的() |
+| 4 | 右边的() |
+| 5 | 右边的[] |
+| 6 | 右边的{} |
+
+
+
+### JAVA 代码实现。
+
+#### 一层分组
+
+```java
+    /**
+     * 分组获取
+     * @param regex 正则表达式
+     * @param input 输入
+     */
+    public static void group(String regex, String input) {
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(input);
+        while (matcher.find()) {
+            String group = matcher.group();
+            String chines = matcher.group(1);
+            String math = matcher.group(2);
+            String english = matcher.group(3);
+            System.out.println(group);
+            System.out.println(chines);
+            System.out.println(math);
+            System.out.println(english);
+        }
+
+    }
+
+    public static void main(String[] args) {
+        String regex = "语文:(\\d+), 数学:(\\d+), 英语:(\\d+)";
+        String input = "小明在这次考试的成绩为：语文:100, 数学:99, 英语:88";
+        group(regex, input);
+    }
+```
+
+代码执行结果为：
+
+```
+语文:100, 数学:99, 英语:88
+100
+99
+88
+```
+
+#### 多层分组
+
+```java
+    /**
+     * 分组获取
+     * @param regex 正则表达式
+     * @param input 输入
+     */
+    public static void group(String regex, String input) {
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(input);
+        while (matcher.find()) {
+            String group = matcher.group();
+            String group1 = matcher.group(1);
+            String group2 = matcher.group(2);
+            String group3 = matcher.group(3);
+            String group4 = matcher.group(4);
+            System.out.println(group);
+            System.out.println(group1);
+            System.out.println(group2);
+            System.out.println(group3);
+            System.out.println(group4);
+        }
+
+    }
+
+    public static void main(String[] args) {
+        String regex = "a(a(e)?(e)?+b)(cc)+";
+        String input = "aaebcc";
+        group(regex, input);
+    }
+```
+
+代码执行结果：
+
+```
+aaebcc
+aeb
+e
+null
+cc
+```
+
diff --git "a/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\346\233\277\346\215\242\345\214\271\351\205\215\347\232\204\346\226\207\346\234\254.md" "b/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\346\233\277\346\215\242\345\214\271\351\205\215\347\232\204\346\226\207\346\234\254.md"
new file mode 100644
index 0000000..6021d0a
--- /dev/null
+++ "b/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\346\233\277\346\215\242\345\214\271\351\205\215\347\232\204\346\226\207\346\234\254.md"
@@ -0,0 +1,64 @@
+### 方法
+
+`Matcher`提供了`replaceAll`和`appendReplacement`方法用于替换字符串。
+
+`replaceAll`用于将所有匹配到的字符替换为单一的字符串。
+
+`appendReplacement`可以为每一个匹配的字符指定唯一的字符串，字符串内容不受限。
+
+**注： ** `appendReplacement`替换后必须使用`appendTail`将剩余的字符收集完整。否则会从最后一次匹配到的字符后截断。
+
+
+
+### JAVA 实现
+
+```java
+    /**
+     * 替换字符
+     * @param regex 正则表达式
+     * @param input 输入
+     * @param replaceStr 用于替换的字符
+     */
+    public static void replace(String regex, String input, String replaceStr) {
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(input);
+
+        System.out.println("replaceAll : 用于将所有匹配的字符替换为指定的字符串");
+        String replaceAll = matcher.replaceAll(replaceStr);
+        System.out.println("replaceAll : " + replaceAll);
+
+        // 重置匹配器，用于测试下面的方法
+        matcher.reset();
+
+        System.out.println("appendReplacement : 用于替换当前匹配到的字符");
+        StringBuffer sb = new StringBuffer();
+        int i = 0;
+        while (matcher.find()) {
+            // 将匹配之前的字符串复制到sb,再将匹配结果替换为: replaceChar，并追加到sb
+            matcher.appendReplacement(sb, replaceStr + ++i);
+        }
+        System.out.println("appendReplacement : " + sb);
+        // 收集剩余的字符
+        matcher.appendTail(sb);
+        System.out.println("appendReplacement : " + sb);
+
+    }
+
+    public static void main(String[] args) {
+        String regex = "\\{.*?}";
+        String input = "this is {} text {} text";
+        String replaceStr = "a";
+        replace(regex, input, replaceStr);
+    }
+```
+
+代码输出结果：
+
+```
+replaceAll : 用于将所有匹配的字符替换为指定的字符串
+replaceAll : this is a text a text
+appendReplacement : 用于替换当前匹配到的字符
+appendReplacement : this is a1 text a2
+appendReplacement : this is a1 text a2 text
+```
+
diff --git "a/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\350\247\204\345\210\231\345\244\247\345\205\250.md" "b/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\350\247\204\345\210\231\345\244\247\345\205\250.md"
new file mode 100644
index 0000000..16225f5
--- /dev/null
+++ "b/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\350\247\204\345\210\231\345\244\247\345\205\250.md"
@@ -0,0 +1,93 @@
+## 常用正则表达式
+
+```
+匹配中文字符的正则表达式： [u4e00-u9fa5]   
+评注：匹配中文还真是个头疼的事，有了这个表达式就好办了 
+匹配双字节字符(包括汉字在内)：[^x00-xff] 
+评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1） 
+匹配空白行的正则表达式：ns*r 
+评注：可以用来删除空白行 
+匹配HTML标记的正则表达式：<(S*?)[^>]*>.*?|<.*? /> 
+评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力 
+匹配首尾空白字符的正则表达式：^s*|s*$ 
+评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式 
+匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)* 
+评注：表单验证时很实用 
+匹配网址URL的正则表达式：[a-zA-z]+://[^s]* 
+评注：网上流传的版本功能很有限，上面这个基本可以满足需求 
+匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 
+评注：表单验证时很实用 
+匹配国内电话号码：d{3}-d{8}|d{4}-d{7} 
+评注：匹配形式如 0511-4405222 或 021-87888822 
+匹配腾讯QQ号：[1-9][0-9]{4,} 
+评注：腾讯QQ号从10000开始 
+匹配中国邮政编码：[1-9]d{5}(?!d) 
+评注：中国邮政编码为6位数字 
+匹配身份证：d{15}|d{18} 
+评注：中国的身份证为15位或18位 
+匹配ip地址：d+.d+.d+.d+ 
+评注：提取ip地址时有用 
+货币格式：
+(?=(?!^)(?:\d{3})+(?:\.|$))(\d{3}(\.\d+$)?)
+匹配特定数字： 
+^[1-9]d*$　 　 //匹配正整数 
+^-[1-9]d*$ 　 //匹配负整数 
+^-?[1-9]d*$　　 //匹配整数 
+^[1-9]d*|0$　 //匹配非负整数（正整数 + 0） 
+^-[1-9]d*|0$　　 //匹配非正整数（负整数 + 0） 
+^[1-9]d*.d*|0.d*[1-9]d*$　　 //匹配正浮点数 
+^-([1-9]d*.d*|0.d*[1-9]d*)$　 //匹配负浮点数 
+^-?([1-9]d*.d*|0.d*[1-9]d*|0?.0+|0)$　 //匹配浮点数 
+^[1-9]d*.d*|0.d*[1-9]d*|0?.0+|0$　　 //匹配非负浮点数（正浮点数 + 0） 
+^(-([1-9]d*.d*|0.d*[1-9]d*))|0?.0+|0$　　//匹配非正浮点数（负浮点数 + 0） 
+评注：处理大量数据时有用，具体应用时注意修正 
+匹配特定字符串： 
+^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串 
+^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串 
+^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串 
+^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串 
+^w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串 
+在使用RegularExpressionValidator验证控件时的验证功能及其验证表达式介绍如下: 
+只能输入数字：“^[0-9]*$” 
+只能输入n位的数字：“^d{n}$” 
+只能输入至少n位数字：“^d{n,}$” 
+只能输入m-n位的数字：“^d{m,n}$” 
+只能输入零和非零开头的数字：“^(0|[1-9][0-9]*)$” 
+只能输入有两位小数的正实数：“^[0-9]+(.[0-9]{2})?$” 
+只能输入有1-3位小数的正实数：“^[0-9]+(.[0-9]{1,3})?$” 
+只能输入非零的正整数：“^+?[1-9][0-9]*$” 
+只能输入非零的负整数：“^-[1-9][0-9]*$” 
+只能输入长度为3的字符：“^.{3}$” 
+只能输入由26个英文字母组成的字符串：“^[A-Za-z]+$” 
+只能输入由26个大写英文字母组成的字符串：“^[A-Z]+$” 
+只能输入由26个小写英文字母组成的字符串：“^[a-z]+$” 
+只能输入由数字和26个英文字母组成的字符串：“^[A-Za-z0-9]+$” 
+只能输入由数字、26个英文字母或者下划线组成的字符串：“^w+$” 
+验证用户密码:“^[a-zA-Z]w{5,17}$”正确格式为：以字母开头，长度在6-18之间， 
+只能包含字符、数字和下划线。 
+验证是否含有^%&'',;=?$"等字符：“[^%&'',;=?$x22]+” 
+只能输入汉字：“^[u4e00-u9fa5],{0,}$” 
+验证Email地址：“^w+[-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$” 
+验证InternetURL：“^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$” 
+验证电话号码：“^((d{3,4})|d{3,4}-)?d{7,8}$” 
+正确格式为：“XXXX-XXXXXXX”，“XXXX-XXXXXXXX”，“XXX-XXXXXXX”， 
+“XXX-XXXXXXXX”，“XXXXXXX”，“XXXXXXXX”。 
+验证身份证号（15位或18位数字）：“^d{15}|d{}18$” 
+验证一年的12个月：“^(0?[1-9]|1[0-2])$”正确格式为：“01”-“09”和“1”“12” 
+验证一个月的31天：“^((0?[1-9])|((1|2)[0-9])|30|31)$” 
+正确格式为：“01”“09”和“1”“31”。 
+匹配中文字符的正则表达式： [u4e00-u9fa5] 
+匹配双字节字符(包括汉字在内)：[^x00-xff] 
+匹配空行的正则表达式：n[s| ]*r 
+匹配HTML标记的正则表达式：/<(.*)>.*|<(.*) />/ 
+匹配首尾空格的正则表达式：(^s*)|(s*$) 
+匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)* 
+匹配网址URL的正则表达式：http://([w-]+.)+[w-]+(/[w- ./?%&=]*)? 
+```
+
+
+
+## 参考
+
+[常用正则表达式大全！（例如：匹配中文、匹配html）](https://www.cnblogs.com/wenmaoyu/archive/2011/07/21/2113124.html)
+
diff --git "a/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\350\264\252\345\251\252\345\222\214\346\207\222\346\203\260\345\214\271\351\205\215.md" "b/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\350\264\252\345\251\252\345\222\214\346\207\222\346\203\260\345\214\271\351\205\215.md"
new file mode 100644
index 0000000..2adb7f5
--- /dev/null
+++ "b/java/\346\255\243\345\210\231\350\241\250\350\276\276\345\274\217\350\264\252\345\251\252\345\222\214\346\207\222\346\203\260\345\214\271\351\205\215.md"
@@ -0,0 +1,70 @@
+### 贪婪匹配、懒惰匹配
+
+`贪恋匹配`对应的是`懒惰匹配`。
+
+`贪恋匹配`指的是在满足`正则表达式`的规则的前提下，尽可能的匹配尽可能多的字符，并且只匹配一次。
+
+`懒惰匹配`则和`贪婪匹配`相反。它会尽可能少的匹配字符。可能会匹配到多个。
+
+例如我们想要匹配这个规则：`a.*b`， 匹配的字符串为`aababa`。
+
+贪恋匹配会匹配到：`aabaab`，匹配到的最长的字符串。
+
+懒惰匹配则会匹配到：`aab`、`ab`，尽可能的匹配了最短的字符，切匹配到了多个。
+
+
+
+### 贪婪和懒惰匹配转换
+
+贪婪匹配和懒惰匹配影响的是正则表达式`限定符`的匹配结果。
+
+在限定符后面加`?`，则为懒惰匹配，否则为贪婪匹配。
+
+**懒惰限定符**
+
+| 代码/语法 | 说明          |
+| --------- | ------------- |
+| *?        | 重复任意次    |
+| +?        | 重复1次或更多 |
+| ?？       | 重复0次或1次  |
+| {m, n}?   | 重复n到m次    |
+| {m,}?     | 重复m次以上   |
+
+
+
+### JAVA 实现
+
+```java
+    public static void match(String regex, String input) {
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(input);
+        while (matcher.find()) {
+            String m = matcher.group();
+            System.out.println(m);
+        }
+    }
+
+    public static void main(String[] args) {
+        String desc = "{}this is a test{}";
+        System.out.println("贪婪匹配：");
+        String greedy = "\\{.*}";
+        match(greedy, desc);
+        // 分割线
+        System.out.println("================分割线=================");
+        System.out.println("懒惰匹配：");
+        String lazy = "\\{.*?}";
+        match(lazy, desc);
+    }
+```
+
+以上代码执行结果：
+
+```
+贪婪匹配：
+{}this is a test{}
+================分割线=================
+懒惰匹配：
+{}
+{}
+```
+
diff --git "a/java/\347\261\273\345\212\240\350\275\275\345\231\250.md" "b/java/\347\261\273\345\212\240\350\275\275\345\231\250.md"
new file mode 100644
index 0000000..8aad6ce
--- /dev/null
+++ "b/java/\347\261\273\345\212\240\350\275\275\345\231\250.md"
@@ -0,0 +1,115 @@
+## JAVA类装载方式
+
+1. 隐式装载， 程序在运行过程中当碰到通过new 等方式生成对象时，隐式调用类装载器加载对应的类到jvm中。 
+2.  显式装载， 通过class.forname()等方法，显式加载需要的类。
+
+## 系统类加载器
+
+**Bootstrp loader** Bootstrp加载器是用C++语言写的，它是在Java虚拟机启动后初始化的，它主要负责加载%JAVA_HOME%/jre/lib,-Xbootclasspath参数指定的路径以及%JAVA_HOME%/jre/classes中的类。
+
+**ExtClassLoader**  Bootstrp loader加载ExtClassLoader,并且将ExtClassLoader的父加载器设置为Bootstrp loader.ExtClassLoader是用Java写的，具体来说就是 sun.misc.Launcher$ExtClassLoader，ExtClassLoader主要加载%JAVA_HOME%/jre/lib/ext，此路径下的所有classes目录以及java.ext.dirs系统变量指定的路径中类库。
+
+**AppClassLoader** Bootstrp loader加载完ExtClassLoader后，就会加载AppClassLoader,并且将AppClassLoader的父加载器指定为 ExtClassLoader。AppClassLoader也是用Java写成的，它的实现类是 sun.misc.Launcher$AppClassLoader，另外我们知道ClassLoader中有个getSystemClassLoader方法,此方法返回的正是AppclassLoader.AppClassLoader主要负责加载classpath所指定的位置的类或者是jar文档，它也是Java程序默认的类加载器。
+
+**类加载器继承关系**
+
+![类加载器继承关系](./images/001/001.png)
+
+## 工作原理
+
+java的类加载器采用了**委托模型机制**，这个机制简单来讲，就是类装载器有载入类的需求时，会先请示其Parent使用其搜索路径帮忙载入，如果Parent 找不到,那么才由自己依照自己的搜索路径搜索类。
+
+加载class文件的步骤如下：
+
+1、装载：查找和导入Class文件 
+
+2、链接：其中解析步骤是可以选择的 （a）检查：检查载入的class文件数据的正确性 （b）准备：给类的静态变量分配存储空间 （c）解析：将符号引用转成直接引用 
+
+3、初始化：对静态变量，静态代码块执行初始化工作
+
+## 自定义类加载器
+
+定义自已的类加载器分为两步：
+
+1.  继承java.lang.ClassLoader
+2.  重写父类的findClass方法
+
+## 线程上下文加载器
+
+线程上下文类加载器（context class loader）是从 JDK 1.2 开始引入的。类 java.lang.Thread中的方法 getContextClassLoader()和 setContextClassLoader(ClassLoader cl)用来获取和设置线程的上下文类加载器。如果没有通过 setContextClassLoader(ClassLoader cl)方法进行设置的话，线程将继承其父线程的上下文类加载器。Java 应用运行的初始线程的上下文类加载器是系统类加载器。在线程中运行的代码可以通过此类加载器来加载类和资源。
+
+
+
+## 实现自定义的类加载器
+
+**CustomClassLoader.java**
+
+```java
+public class CustomClassLoader extends ClassLoader {
+
+    public CustomClassLoader(ClassLoader parent) {
+        super(parent);
+    }
+
+    @Override
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        byte[] date = getClassDate(name);
+        if (date != null) {
+            return defineClass(name, date, 0, date.length);
+        }
+        throw new ClassNotFoundException();
+    }
+
+    private byte[] getClassDate(String className) {
+        String filename = className.replaceAll("\\.", File.separator).concat(".class");
+        try (InputStream in = new FileInputStream(filename);
+             ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
+            byte[] buffer = new byte[1024];
+            int len = 0;
+            while ((len = in.read(buffer)) != -1) {
+                bos.write(buffer, 0, len);
+            }
+            return bos.toByteArray();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}
+```
+
+**Main.java**
+
+```java
+public class Main {
+
+    public static void main(String[] args) {
+
+        // 获取当前的类加载器
+        ClassLoader currentClassLoader = Main.class.getClassLoader();
+        // 新建类加载器
+        ClassLoader customClassLoader = new CustomClassLoader(currentClassLoader);
+        // 设置当前线程使用自定义的类加载器
+        Thread.currentThread().setContextClassLoader(customClassLoader);
+
+        // 查看子线程的类加载器
+        new Thread(new Runner()).start();
+    }
+}
+
+class Runner implements Runnable {
+
+    @Override
+    public void run() {
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+        System.out.println(classLoader);
+    }
+}
+```
+
+**输出**
+
+```
+com.classload.CustomClassLoader@60cb300b
+```
+
diff --git "a/java/\347\273\264\346\212\244\345\244\232\344\270\252\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245.md" "b/java/\347\273\264\346\212\244\345\244\232\344\270\252\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245.md"
new file mode 100644
index 0000000..3195c44
--- /dev/null
+++ "b/java/\347\273\264\346\212\244\345\244\232\344\270\252\346\225\260\346\215\256\345\272\223\350\277\236\346\216\245.md"
@@ -0,0 +1,239 @@
+## java 多数据库连接维护
+
+### 1.DriverManager维护了一个驱动列表
+
+以我们熟悉的MysqlDriver来举例：
+
+```java
+package com.mysql.jdbc;
+
+import java.sql.SQLException;
+public class Driver extends NonRegisteringDriver implements java.sql.Driver {
+    //
+    // Register ourselves with the DriverManager
+    //
+    static {
+        try {
+            java.sql.DriverManager.registerDriver(new Driver());
+        } catch (SQLException E) {
+            throw new RuntimeException("Can't register driver!");
+        }
+    }
+
+    public Driver() throws SQLException {
+        // Required for Class.forName().newInstance()
+    }
+}
+```
+
+在我们执行如下语句的时候，static块的内容会被执行，于是com.mysql.jdbc.Driver就成功的把自己给注册到DriverManager的驱动列表里面去了。
+
+```java
+Class.forName("com.mysql.jdbc.Driver");
+```
+
+来看看DriverManager的注册实现：
+
+```java
+private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
+public static synchronized void registerDriver(java.sql.Driver driver,
+            DriverAction da)
+        throws SQLException {
+
+        /* Register the driver if it has not already been added to our list */
+        if(driver != null) {
+            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
+        } else {
+            // This is for compatibility with the original DriverManager
+            throw new NullPointerException();
+        }
+
+        println("registerDriver: " + driver);
+
+    }
+```
+
+代码的意思就是如果当前的Driver不存在就添加，否则就啥也不执行。
+
+于是在DriverManager这个类里面就有了我们Mysql的驱动类了。
+
+对于Oracle也是一样的，被加载的驱动都需要在被加载的时候，在static块中，自动把自己给注册到DriverManager中。
+
+于是我们明白DriverManager就是维护了一个数据库的驱动列表，而且这个列表中同类型的数据库连接只有一份，比如我们系统里面即用到了mysql也用到了oracle那么我们的DriverManager里面只维护了2种类型的数据库驱动，不论我们实际上用了多个mysql数据库，驱动都是一样的。
+
+### 2.获取逻辑由具体驱动自己实现
+看看DriverManager是如何获取数据库连接的：
+
+第一步：构造用户信息
+
+```java
+ @CallerSensitive
+    public static Connection getConnection(String url,
+        String user, String password) throws SQLException {
+        java.util.Properties info = new java.util.Properties();
+
+        if (user != null) {
+            info.put("user", user);
+        }
+        if (password != null) {
+            info.put("password", password);
+        }
+
+        return (getConnection(url, info, Reflection.getCallerClass()));
+    }
+```
+
+第二步：获取连接
+
+```java
+//  Worker method called by the public getConnection() methods.
+    private static Connection getConnection(
+        String url, java.util.Properties info, Class<?> caller) throws SQLException {
+        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
+        // 线程同步，防止并发出问题
+        synchronized(DriverManager.class) {
+            // synchronize loading of the correct classloader.
+            if (callerCL == null) {
+                callerCL = Thread.currentThread().getContextClassLoader();
+            }
+        }
+			
+        if(url == null) {
+            throw new SQLException("The url cannot be null", "08001");
+        }
+
+        println("DriverManager.getConnection(\"" + url + "\")");
+
+       SQLException reason = null;
+				// 循环当前的数据库驱动来获取数据库连接
+        for(DriverInfo aDriver : registeredDrivers) {
+            // If the caller does not have permission to load the driver then
+            // skip it.
+            if(isDriverAllowed(aDriver.driver, callerCL)) {
+                try {
+                    println("    trying " + aDriver.driver.getClass().getName());
+                    // 这个地方由具体的数据库驱动自己来实现
+                    Connection con = aDriver.driver.connect(url, info);
+                    if (con != null) {
+                        // Success!
+                        println("getConnection returning " + aDriver.driver.getClass().getName());
+                        return (con);
+                    }
+                } catch (SQLException ex) {
+                    if (reason == null) {
+                        reason = ex;
+                    }
+                }
+
+            } else {
+                println("    skipping: " + aDriver.getClass().getName());
+            }
+
+        }
+
+        // if we got here nobody could connect.
+        if (reason != null)    {
+            println("getConnection failed: " + reason);
+            throw reason;
+        }
+
+        println("getConnection: no suitable driver found for "+ url);
+        throw new SQLException("No suitable driver found for "+ url, "08001");
+    }
+```
+
+对于上面的代码，我们不需要全部关注，只需要知道，连接的获取过程是**通过循环已有的驱动，然后由每个驱动自己来完成的**。我们来看看mysql的驱动实现：
+
+```java
+ public java.sql.Connection connect(String url, Properties info) throws SQLException {
+        if (url == null) {
+            throw SQLError.createSQLException(Messages.getString("NonRegisteringDriver.1"), SQLError.SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE, null);
+        }
+				// 首先判断当前的url是不是负载均衡的url，如果是走负载均衡的获取逻辑
+        if (StringUtils.startsWithIgnoreCase(url, LOADBALANCE_URL_PREFIX)) {
+            return connectLoadBalanced(url, info);
+        } else if (StringUtils.startsWithIgnoreCase(url, REPLICATION_URL_PREFIX)) {
+            return connectReplicationConnection(url, info);
+        }
+
+        Properties props = null;
+				// 这个地方会判断当前url是不是属于mysql连接的前缀，不是就return
+        if ((props = parseURL(url, info)) == null) {
+            return null;
+        }
+
+        if (!"1".equals(props.getProperty(NUM_HOSTS_PROPERTY_KEY))) {
+            return connectFailover(url, info);
+        }
+				// 总之经过了一系列的判断我们的程序开始真正的去拿我们要的连接了
+        try {
+            Connection newConn = com.mysql.jdbc.ConnectionImpl.getInstance(host(props), port(props), props, database(props), url);
+
+            return newConn;
+        } catch (SQLException sqlEx) {
+            // Don't wrap SQLExceptions, throw
+            // them un-changed.
+            throw sqlEx;
+        } catch (Exception ex) {
+            SQLException sqlEx = SQLError.createSQLException(
+                    Messages.getString("NonRegisteringDriver.17") + ex.toString() + Messages.getString("NonRegisteringDriver.18"),
+                    SQLError.SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE, null);
+
+            sqlEx.initCause(ex);
+
+            throw sqlEx;
+        }
+    }
+```
+
+我们看看parseURL方法实现：
+
+```java
+private static final String URL_PREFIX = "jdbc:mysql://";
+@SuppressWarnings("deprecation")
+    public Properties parseURL(String url, Properties defaults) throws java.sql.SQLException {
+        Properties urlProps = (defaults != null) ? new Properties(defaults) : new Properties();
+
+        if (url == null) {
+            return null;
+        }
+// 判断当前的url是不是以"jdbc:mysql://";开始
+        if (!StringUtils.startsWithIgnoreCase(url, URL_PREFIX) && !StringUtils.startsWithIgnoreCase(url, MXJ_URL_PREFIX)
+                && !StringUtils.startsWithIgnoreCase(url, LOADBALANCE_URL_PREFIX) && !StringUtils.startsWithIgnoreCase(url, REPLICATION_URL_PREFIX)) {
+
+            return null;
+        }
+
+       ...还有一大堆逻辑
+
+        return urlProps;
+    }
+```
+
+对于不同的数据库，因为使用的连接url不一样，比如mysql的连接格式如下
+
+```java
+jdbc:mysql://localhost:3306/test?characterEncoding=utf-8
+```
+
+而oracle的连接字符串如下：
+
+```java
+jdbc:oracle:thin:@127.0.0.1:1521:news
+```
+
+sql server的连接字符串如下：
+
+```java
+jdbc:sqlserver://localhost:1434;DataBaseName=testdatabase
+```
+
+所以通过连接字符串的前缀不同可以区分出当前的驱动是不是目标驱动，如果不是，DriverManager接着循环下一个驱动来尝试获取连接。这样就可以通过DriverManager通过url来获取不同类型数据库的连接了。到此我们发现其实DriverManager维护的只是驱动而已，我们要获取那种类型数据库的连接，以及获取那个数据库连接还是取决于我们自己，因为获取数据库连接的时候，连接信息是我们自己指定的。
+
+### 3.如何维护多个数据库连接
+从上面的分析我们知道了，我们获取数据库的连接就是提供连接的url，用户名，密码就可以获取一个相应数据库的连接了，而如果要维护多个数据库连接，不就是提供多套url，用户名和密码吗？而如果你想手动的来把这些连接管理起来也很简单，其实就是如何管理多套数据库连接信息而已。
+
+### 4.引用
+
+[java 多数据库连接维护示例](https://blog.csdn.net/tengdazhang770960436/article/details/98223427)
+
diff --git "a/java/\350\216\267\345\217\226\346\225\260\346\215\256\345\272\223\345\205\203\346\225\260\346\215\256.md" "b/java/\350\216\267\345\217\226\346\225\260\346\215\256\345\272\223\345\205\203\346\225\260\346\215\256.md"
new file mode 100644
index 0000000..bc72285
--- /dev/null
+++ "b/java/\350\216\267\345\217\226\346\225\260\346\215\256\345\272\223\345\205\203\346\225\260\346\215\256.md"
@@ -0,0 +1,122 @@
+## 获取数据库元数据
+
+### 1. 代码
+
+```java
+ import java.sql.Connection;
+ import java.sql.DatabaseMetaData;
+ import java.sql.DriverManager;
+ import java.sql.ResultSet;
+ import java.sql.ResultSetMetaData;
+ import java.sql.Statement;
+ import java.sql.Types;
+ import java.util.ArrayList;
+ import java.util.HashMap;
+ import java.util.Iterator;
+ import java.util.List;
+ import java.util.Map;
+ import java.util.AbstractMap.SimpleEntry;
+ import java.util.Map.Entry;
+ public class TestDbMetaData {
+ 	@SuppressWarnings("unchecked")
+ 	public static void main(String[] args) throws Exception {
+ 		String dburl = "jdbc:mysql://127.0.0.1:3306/fhadmin";
+ 		String dbuser = "root";
+ 		String dbpwd = "root";
+ 		Class.forName("com.mysql.jdbc.Driver");
+ 		List<String> tableName = new ArrayList<String>();
+ 		Map<String, List<Entry<String, String>>> tables = new HashMap<String, List<Entry<String, String>>>();
+ 		Connection con = DriverManager.getConnection(dburl, dbuser, dbpwd);
+        // 获取整个数据库的元数据
+ 		DatabaseMetaData metaDb = con.getMetaData();
+ 		ResultSet rsTableName = metaDb.getTables(null, null, null, new String[] { "table" });
+ 		while (rsTableName.next()) {
+ 			String tmpTableName = rsTableName.getString("table_name");
+ 			tableName.add(tmpTableName);
+ 			String sql = "select * from " + tmpTableName;
+ 			Statement st = con.createStatement();
+ 			ResultSet rsColumName = st.executeQuery(sql);
+            // 获取查询语句对应的元数据
+ 			ResultSetMetaData metaRs = rsColumName.getMetaData();
+ 			List<Entry<String, String>> colums = new ArrayList<Entry<String, String>>();
+ 			for (int i = 1; i <= metaRs.getColumnCount(); i++) {
+         		System.out.print( metaRs.getColumnName(i)+","+metaRs.getColumnClassName(i).substring(metaRs.getColumnClassName(i).lastIndexOf(".") + 1));
+				System.out.println(",是否为空："+metaRs.isNullable(i));//0 不能为空   1可以为空
+    			//System.out.println(metaRs.getColumnLabel(i));
+    			//System.out.println(metaRs.getColumnDisplaySize(i));
+				String columName = metaRs.getColumnName(i);
+				// 某列类型的精确度(类型的长度)
+                int precision = metaRs.getPrecision(i);
+                // 小数点后的位数 
+                int scale = metaRs.getScale(i);
+                // 是否自动递增 
+                boolean isAutoInctement = metaRs.isAutoIncrement(i);
+				String aa= metaRs.getColumnTypeName(i);
+				String columType = "";
+				switch (metaRs.getColumnType(i)) {
+					case Types.CHAR:
+					columType = "String";
+					break;
+					case Types.BIGINT:
+					columType = "int";
+					break;
+					case Types.DATE:
+					columType = "Date";
+					break;
+					case Types.DECIMAL:
+					columType = "int";
+					break;
+					case Types.INTEGER:
+					columType = "int";
+					break;
+					case Types.NCHAR:
+					columType = "String";
+					break;
+					case Types.NUMERIC:
+					columType = "int";
+					break;
+					case Types.NVARCHAR:
+					columType = "String";
+					break;
+					case Types.SMALLINT:
+					columType = "int";
+					break;
+					case Types.TIME:
+					columType = "Date";
+					break;
+					case Types.TINYINT:
+					columType = "int";
+					break;
+					case Types.TIMESTAMP:
+					columType = "Date";
+					break;
+					case Types.VARCHAR:
+					columType = "String";
+					break;
+					default:
+					throw new Exception("数据类型不支持，orm映射异常");
+				}
+				Entry<String, String> entry = new SimpleEntry(columName, columType);
+				colums.add(entry);
+				}
+			tables.put(tmpTableName, colums);
+		}
+
+
+		Iterator<Entry<String, List<Entry<String, String>>>> iter = tables.entrySet().iterator();
+		while (iter.hasNext()) {
+			Entry<String, List<Entry<String, String>>> entry = iter.next();
+			System.out.println("表名：" + entry.getKey());
+			for (int i = 0; i < entry.getValue().size(); i++) {
+				System.out.print(entry.getValue().get(i).getKey() + " " + entry.getValue().get(i).getValue());
+			}
+			System.out.println();
+		}
+		System.out.println("complete...");
+	}
+}
+```
+
+### 2. 引用
+
+[java获取mysql表结构](https://blog.csdn.net/jacke121/article/details/54835491)
\ No newline at end of file
diff --git "a/java/\350\216\267\345\217\226\347\250\213\345\272\217\345\267\245\344\275\234\350\267\257\345\276\204.md" "b/java/\350\216\267\345\217\226\347\250\213\345\272\217\345\267\245\344\275\234\350\267\257\345\276\204.md"
new file mode 100644
index 0000000..9c1dcbc
--- /dev/null
+++ "b/java/\350\216\267\345\217\226\347\250\213\345\272\217\345\267\245\344\275\234\350\267\257\345\276\204.md"
@@ -0,0 +1,19 @@
+## 获取应用程序当前的工作路径
+
+以前用于获取当前类路径下的文件的方式：
+
+```java
+URL resource = getClass().getClassLoader().getResource("");
+// or
+URL resource = Thread.currentThread().getContextClassLoader().getResource("");
+```
+
+**限制: **该方式只能在java文件未被打包的情况下才能正常使用，如果使用jar执行该文件，则会返回null。
+
+假设我们有一个`app.jar`文件，我们使用`java -jar app.jar`，若我们想在`app.jar`获取此文件所在的路径，那么使用上述的两种方式都是无效的，返回的`URL`对象都是null，为了解决这种文件，可以使用下面的方式：
+
+```java
+URL url = getClass().getProtectionDomain().getCodeSource().getLocation();
+```
+
+这种方式会获取到`app.jar`文件在系统上的绝对路径。
\ No newline at end of file
diff --git "a/java/\350\243\201\345\211\252\345\233\276\347\211\207.md" "b/java/\350\243\201\345\211\252\345\233\276\347\211\207.md"
new file mode 100644
index 0000000..5de21df
--- /dev/null
+++ "b/java/\350\243\201\345\211\252\345\233\276\347\211\207.md"
@@ -0,0 +1,42 @@
+### 主要思路
+
+使用`ImageReader`类，通过设置矩阵的方式进行裁剪。
+
+### 代码
+
+```java
+/**
+ * 将原始图片居中裁剪为正方形
+ */
+public static void cutSquareImage(String src, String dest) {
+    InputStream secInputSteam = null;
+    try {
+        secInputSteam = new FileInputStream(src);
+        // 获取图片读取器
+        ImageReader reader = ImageIO.getImageReadersByFormatName("jpeg").next();
+        // 读取原始图片
+        ImageInputStream imageInputStream = ImageIO.createImageInputStream(secInputSteam);
+        // 将原始图片信息设置到读取器内
+        reader.setInput(imageInputStream, true);
+        // 获取长宽，取正方形的边长
+        int imageIndex = 0;
+        int height = reader.getHeight(imageIndex);
+        int width = reader.getWidth(imageIndex);
+        // 边长
+        int side = Math.min(width, height);
+        // 绘制一个正方形，使读取器读取正方形指定的范围
+        Rectangle rectangle = new Rectangle((width - side) / 2, (height - side) / 2, side, side);
+        ImageReadParam param = reader.getDefaultReadParam();
+        param.setSourceRegion(rectangle);
+        // 输出图片
+        BufferedImage bufferedImage = reader.read(imageIndex, param);
+        File destFile = IoUtil.createFile(dest);
+        ImageIO.write(bufferedImage, "jpeg", destFile);
+    } catch (IOException e) {
+        throw ExceptionUtil.unchecked(e);
+    } finally {
+        IoUtil.close(secInputSteam);
+    }
+}
+```
+
diff --git "a/java/\350\256\241\347\256\227\350\272\253\344\273\275\350\257\201\346\240\241\351\252\214\347\240\201.md" "b/java/\350\256\241\347\256\227\350\272\253\344\273\275\350\257\201\346\240\241\351\252\214\347\240\201.md"
new file mode 100644
index 0000000..562b10f
--- /dev/null
+++ "b/java/\350\256\241\347\256\227\350\272\253\344\273\275\350\257\201\346\240\241\351\252\214\347\240\201.md"
@@ -0,0 +1,55 @@
+## 计算校验码
+
+**身份证号与权重的对应表**
+
+| 号码 | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    | 9    | 10   | 11   | 12   | 13   | 14   | 15   | 16   | 17   | 18     |
+| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ------ |
+| 权重 | 7    | 9    | 10   | 5    | 8    | 4    | 2    | 1    | 6    | 3    | 7    | 9    | 10   | 5    | 8    | 4    | 2    | 校验码 |
+
+**余数与校验码对应表**
+
+| 余数   | 0    | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    | 9    | 10   |
+| ------ | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
+| 校验码 | 1    | 0    | X    | 9    | 8    | 7    | 6    | 5    | 4    | 3    | 2    |
+
+**计算公式**
+
+1. 身份证每一位号码与其对应的权重，使用当前位上的**数字**和对应的**权重** **相乘**，并将十七位计算的数字**求和**。
+2. 将第一步**求和的结果**，除以 **11**，**取余**。
+3. 参照**余数与校验码对照表**获取真实的校验码。
+4. 将计算的**校验码**对用户输入的第**十八**位进行对比，一致则身份证号正确。
+
+## 代码
+
+```java
+public class IDCardValidate {
+
+    // 每一位号码的权重
+    private static final int[] WEIGHT = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
+    // 最后一位身份证号码
+    private static final String[] VALICATION_NUMBER = { "1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2" };
+
+    /**
+     * 计算身份证最后一位校验码
+     * @param idCard
+     * @return null:获取校验码错误
+     */
+    public static String computeValidationCode(String idCard) {
+        String[] idNums;
+        if (idCard == null || "".equalsIgnoreCase(idCard.trim()) || (idNums = idCard.split("")).length != 18) {
+            return null;
+        }
+        // 第一步，计算每一位身份证号和对应数字的总和
+        int sum = 0;
+        for (int i = 0; i < WEIGHT.length; i++) {
+            sum += (Integer.parseInt(idNums[i]) * WEIGHT[i]);
+        }
+        // 计算最后一位校验数字的下标
+        int index = sum % 11;
+        // 计算最后一位字符
+        return VALICATION_NUMBER[index];
+    }
+
+}
+```
+
diff --git "a/java/\350\277\220\350\241\214\346\227\266\347\274\226\350\257\221.md" "b/java/\350\277\220\350\241\214\346\227\266\347\274\226\350\257\221.md"
new file mode 100644
index 0000000..3d996af
--- /dev/null
+++ "b/java/\350\277\220\350\241\214\346\227\266\347\274\226\350\257\221.md"
@@ -0,0 +1,157 @@
+## 技术前提
+
+请完整阅读`java使用命令编译打包`文档后再继续阅读。
+
+关键组件介绍:
+
+- JavaCompiler  - 表示java编译器, run方法执行编译操作. 或者可以先生成编译任务(CompilationTask), 然后与调用任务的call方法执行
+- JavaFileObject  - 表示一个java源文件对象
+- JavaFileManager - Java源文件管理类, 管理一系列JavaFileObject
+- Diagnostic  - 表示一个诊断信息
+- DiagnosticListener - 诊断信息监听器, 编译过程触发. 生成编译task(`JavaCompiler#getTask()`)或获取FileManager(`JavaCompiler#getStandardFileManager()`)时需要传递DiagnosticListener以便收集诊断信息
+
+
+
+## 编译本地源文件并输出到本地
+
+读取本地的`.java`文件，动态编译为`.class`文件后保存在磁盘上。
+
+**第一种方式**
+
+```java
+public static void main(String[] args) {
+    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+    // 输入流、输出流、错误流、javac参数
+    int result = compiler.run(null, null, null, "/path/to/source");
+    if (result != 0) {
+    System.out.println("编译失败");
+    }
+}
+```
+
+通过以上的方式，默认编译的文件和源文件存在同一目录下。可以通过`-d`参数指定编译输出位置。
+
+**第二种方式**
+
+```java
+public static void main(String[] args) {
+    // 获取java编译器
+    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+    // 获取文件管理器
+    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
+    // 定义要编译的源文件
+    File file = new File("F:\\javalearning\\src\\com\\feb13th\\demo1\\HelloWorld.java");
+    //通过源文件获取到要编译的Java类源码迭代器，包括所有内部类，其中每个类都是一个 JavaFileObject，也被称为一个汇编单元
+    Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjects(file);
+    // options -d 指定编译后的文件位置， -classpath 指定依赖
+    Iterable<String> options = Arrays.asList(
+        "-d", "F:\\javalearning\\classes",
+        "-classpath", "F:\\javalearning\\classes;F:\\javalearning\\lib\\fastjson-1.2.58.jar");
+    // 生成编译任务
+    JavaCompiler.CompilationTask task = compiler.getTask(null,
+                                                         fileManager, 
+                                                         null, 
+                                                         options, 
+                                                         null, 
+                                                         compilationUnits);
+    // 执行编译任务
+    Boolean success = task.call();
+    if (success) {
+        System.out.println("编译成功");
+    } else {
+        System.out.println("编译失败");
+    }
+}
+```
+
+
+
+## 编译内存中的源码并写入内存
+
+编译内存中的源码需要自定义`JavaFileObject`以及`JavaFileManager`。下面的例子中实现了读取内存中的java源码，并将编译后的结果字节码保存在map中。
+
+如果只需要读取内存中的源码，将**（1）**修改为上一节中对应的代码即可。
+
+如果只需要将编译后的字节码保存在内存中，将**（2）**修改为上一节对应的代码即可。
+
+**注：** （1）（2）都有两处需要修改。
+
+```java
+public static void main(String[] args) {
+    // 获取java编译器
+    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+    // 获取文件管理器
+    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
+    String className = "com.feb13th.HelloWorld";
+    String code = "package com.feb13th;" +
+        "public class HelloWorld { " +
+        "   public static void main(String[] args) { " +
+        "       System.out.println(\"HelloWorld!!\");" +
+        "   }" +
+        "}";
+    // （1） 自定义JavaFileObject实现读取内存中的源文件
+    JavaFileObject javaFileObject = new SimpleJavaFileObject(
+        // 创建 uri, com/feb13th/HelloWorld.java
+        URI.create(className.replaceAll("\\.", "/") + JavaFileObject.Kind.SOURCE.extension),
+        JavaFileObject.Kind.SOURCE) {
+        @Override
+        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
+            return code;
+        }
+    };
+
+    // 自定义用于存储字节码的map
+    Map<String, byte[]> bytes = new HashMap<>();
+    // （2） 自定义JavaFileManager实现将编译后的字节码存储在内存中
+    JavaFileManager javaFileManager = new ForwardingJavaFileManager<JavaFileManager>(fileManager) {
+        @Override
+        public JavaFileObject getJavaFileForOutput(Location location,
+                                                   String className,
+                                                   JavaFileObject.Kind kind,
+                                                   FileObject sibling) throws IOException {
+            if (kind == JavaFileObject.Kind.CLASS) {
+                return new SimpleJavaFileObject(
+                    URI.create(className + JavaFileObject.Kind.CLASS.extension),
+                    JavaFileObject.Kind.CLASS) {
+                    @Override
+                    public OutputStream openOutputStream() throws IOException {
+                        return new FilterOutputStream(new ByteArrayOutputStream()) {
+                            @Override
+                            public void close() throws IOException {
+                                out.close();
+                                ByteArrayOutputStream bos = (ByteArrayOutputStream) out;
+                                bytes.put(className, bos.toByteArray());
+                            }
+                        };
+                    }
+                };
+            }
+            return super.getJavaFileForOutput(location, className, kind, sibling);
+        }
+    };
+
+    // 生成编译任务
+    JavaCompiler.CompilationTask task = compiler.getTask(null,
+                                                         javaFileManager, //（2）
+                                                         null,
+                                                         null, //（1）
+                                                         null,
+                                                         Arrays.asList(javaFileObject));
+    // 执行编译任务
+    Boolean success = task.call();
+    if (success) {
+        System.out.println("编译成功");
+    } else {
+        System.out.println("编译失败");
+    }
+
+    // 查看map中有没有存储字节码
+    bytes.forEach((k, v) -> {
+        System.out.println(k);
+        System.out.println(v.length);
+    });
+}
+```
+
+
+
diff --git "a/java/\350\277\234\347\250\213debug.md" "b/java/\350\277\234\347\250\213debug.md"
new file mode 100644
index 0000000..3ed80e5
--- /dev/null
+++ "b/java/\350\277\234\347\250\213debug.md"
@@ -0,0 +1,75 @@
+## 远程debug调试java代码
+
+日常环境和预发环境遇到问题时，可以用远程调试的方法本地打断点，在本地调试。生产环境由于网络隔离和系统稳定性考虑，不能进行远程代码调试。
+
+整体过程是通过修改远程服务JAVA_OPTS参数，然后本地通过Eclipse或IDEA等工具调试。
+
+### 理论
+
+JPDA（Java Platform Debugger Architecture）是Java平台调试体系结构的缩写。由3个规范组成，分别是JVMTI(JVM Tool Interface)，JDWP(Java Debug Wire Protocol)，JDI(Java Debug Interface) 。
+
+* 1.JVMTI定义了虚拟机应该提供的调试服务，包括调试信息（Information譬如栈信息）、调试行为（Action譬如客户端设置一个断点）和通知（Notification譬如到达某个断点时通知客户端），该接口由虚拟机实现者提供实现，并结合在虚拟机中
+* 2.JDWP定义调试服务和调试器之间的通信，包括定义调试信息格式和调试请求机制
+* 3.JDI在语言的高层次上定义了调试者可以使用的调试接口以能方便地与远程的调试服务进行交互，Java语言实现，调试器实现者可直接使用该接口访问虚拟机调试服务。 java调试工具jdb，就是sun公司提供的JDI实现。eclipse IDE，它的两个插件org.eclipse.jdt.debug.ui和org.eclipse.jdt.debug与其强大的调试功能密切相关，其中前者是eclipse调试工具界面的实现，而后者则是JDI的一个完整实现。
+
+### 远程调试
+
+远程调试分为主动连接调试，和被动连接调试。
+
+> 主动连接调试：服务端配置监控端口，本地IDE连接远程监听端口进行调试，一般调试问题用这种方式。
+>
+> 被动连接调试：本地IDE监听某端口，等待远程连接本地端口。一般用于远程服务启动不了，启动时连接到本地调试分析。
+
+### 主动连接调试
+
+首先需要远程服务配置启动脚本:
+
+```shell
+JAVA_OPTS="$JAVA_OPTS -Xdebug 
+-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000"
+```
+
+如果是启动jar包，指令：
+
+```shell
+java -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000 -jar test.jar
+```
+
+| 命令      | 解释                                                         |
+| --------- | ------------------------------------------------------------ |
+| -Xdebug   | 通知JVM工作在DEBUG模式下                                     |
+| -Xrunjdwp | 通知JVM使用(java debug wire protocol)来运行调试环境          |
+| transport | 监听Socket端口连接方式                                       |
+| server    | =y表示当前是调试服务端，=n表示当前是调试客户端               |
+| suspend   | =n表示启动时不中断（如果启动时中断，一般用于调试启动不了的问题） |
+| address   | =8000表示本地监听8000端口                                    |
+
+### 被动连接
+
+首先需要远程服务配置启动脚本:
+
+```shell
+JAVA_OPTS="$JAVA_OPTS -Xdebug 
+-Xrunjdwp:transport=dt_socket,address=127.0.0.1:8000,suspend=y"
+```
+
+如果是启动jar包，指令：
+
+```shell
+java -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000 -jar test.jar
+```
+
+参数含义和主动连接调试一样，只是这里suspend=y表示启动时就中断，需要连接本地IDE调试启动。address=ip:port，ip需要修改为本地的对外IP。
+
+这样远程项目启动时就连接到本地，方便调试项目启动不了的问题。
+
+### IDEA远程debug
+
+![1570773224689](./images/003/1570773224689.png)
+
+添加Remote配置，在右侧的`Configuration`窗口中配置具体内容。
+
+如果是主动连接调试，`Debugger mode`选择`Attach to remote JVM`。
+
+如果是被动连接调试，`Debugger mode`选择`Listen to remote JVM`。
+
diff --git "a/javaweb/\344\270\213\350\275\275\346\226\207\344\273\266.md" "b/javaweb/\344\270\213\350\275\275\346\226\207\344\273\266.md"
new file mode 100644
index 0000000..193b85c
--- /dev/null
+++ "b/javaweb/\344\270\213\350\275\275\346\226\207\344\273\266.md"
@@ -0,0 +1,43 @@
+## 下载文件
+
+**思路：**
+
+1. 设置返回的内容格式为二进制
+2. 设置下载后的文件名称
+3. 读取文件流并写出Response的输出流
+4. 关闭文件输入流
+
+```java
+  /**
+   * 下载文件
+   *
+   * @param filepath 下载文件的路径
+   * @param filename 下载后文件的名称
+   */
+  public static void download(HttpServletResponse response, String filepath, String filename) {
+    InputStream inputStream = null;
+    try {
+      // 设置返回类型为二进制
+      response.setHeader("content-type", "application/octet-stream");
+      response.setContentType("application/octet-stream");
+      // 设置下载后的文件名称
+      response.setHeader("Content-Disposition",
+          "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
+      // 写出二进制数据
+      OutputStream outputStream = response.getOutputStream();
+      inputStream = new FileInputStream(new File(filepath));
+      int len;
+      byte[] data = new byte[1024];
+      while ((len = inputStream.read(data)) != -1) {
+        outputStream.write(data, 0, len);
+      }
+      outputStream.flush();
+
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    } finally {
+      IoUtil.close(inputStream);
+    }
+  }
+```
+
diff --git "a/javaweb/\350\267\250\345\237\237\350\256\277\351\227\256.md" "b/javaweb/\350\267\250\345\237\237\350\256\277\351\227\256.md"
new file mode 100644
index 0000000..e15e691
--- /dev/null
+++ "b/javaweb/\350\267\250\345\237\237\350\256\277\351\227\256.md"
@@ -0,0 +1,65 @@
+### 为什么要解决跨域访问？
+
+在`http`请求中，默认只能在同一个域中进行访问，如果访问不同的域，则会被认为是非法操作，浏览器会提示`No 'Access-Control-Allow-Origin'`错误。
+
+**注： ** 所谓 `域` 就是网址名称。如`https://www.baidu.com`，它的域就是`baidu.com`。如果我在`baidu.com`下面想访问`google.com`下面的资源，这就叫跨域。
+
+
+
+### 怎么解决跨域？
+
+#### 前端使用 JSONP 的方式请求
+
+前端可以通过使用`jsonp`执行跨域请求。这里不多做解释。
+
+#### 服务器通过对响应进行配置
+
+`java`服务器可以对所有的请求进行拦截，通过设置`response`对象的`header`实现跨域。
+
+**`response`需要设置的header和值的对应关系**
+
+| header 名                    | header 值                                                    |
+| ---------------------------- | ------------------------------------------------------------ |
+| Access-Control-Allow-Origin  | *                                                            |
+| Access-Control-Allow-Methods | POST, GET, DELETE, OPTIONS, DELETE, PUT                      |
+| Access-Control-Allow-Headers | Content-Type, x-requested-with, X-Custom-Header, HaiYi-Access-Token |
+
+### 代码
+
+```java
+import javax.servlet.*;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * 允许跨域过滤器
+ *
+ * @author zhoutaotao
+ * @date 2019/5/31
+ */
+public class AllowOriginFilter implements Filter {
+
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+
+    }
+
+    @Override
+    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
+        HttpServletRequest request = (HttpServletRequest) servletRequest;
+        HttpServletResponse response = (HttpServletResponse) servletResponse;
+
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("Access-Control-Allow-Methods", "POST, GET, DELETE, OPTIONS, DELETE, PUT");
+        response.setHeader("Access-Control-Allow-Headers", "Content-Type, x-requested-with, X-Custom-Header, HaiYi-Access-Token");
+        chain.doFilter(request, response);
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+}
+```
+
diff --git "a/javaweb/\350\275\254\345\217\221\344\270\216\351\207\215\345\256\232\345\220\221.md" "b/javaweb/\350\275\254\345\217\221\344\270\216\351\207\215\345\256\232\345\220\221.md"
new file mode 100644
index 0000000..a52b605
--- /dev/null
+++ "b/javaweb/\350\275\254\345\217\221\344\270\216\351\207\215\345\256\232\345\220\221.md"
@@ -0,0 +1,42 @@
+## 转发
+
+```java
+request.getRequestDispatcher("success.jsp").forward(request,response);
+```
+
+> 在服务器组件收到用户请求后。经过它的处理后有传递给了另一个组件。不修改用户的请求码。各组件处理完之后在返回给用户
+
+**请求流程**
+
+用户请求 ---> 服务器 ---> 组件1 ---> 组件2 ---> 服务器 ---> 用户
+
+> 转发时，用户的请求不会改变，只能服务器内部组件之间进行跳转，同时，多个组件之间共享一个**request**对象，所以说转发是可以传值的，但也仅限于`request`范围
+
+
+
+## 重定向
+
+```java
+response.sendRedirect("http://domain/success.jsp");
+```
+
+> 在服务器组件收到用户请求后。经过处理修改用户请求。在返回给用户。这样用户再次使用这个请求就会被动的使用新的请求了。
+
+**请求流程**
+
+用户请求 ---> 服务器 ---> 组件 ---> 服务器 ---> 用户 ---> 新的请求
+
+> 重定向使用两次客户端请求操作。效率相较于转发较低。由于是多次请求，所以请求之间不会共享`request`对象，所以说重定向是无法传值的，但是可以通过在`url`中增加参数进行传递。
+>
+> 如：`response.sendRedirect("http://domain/success.jsp?name=user");`
+
+
+
+## 转发与重定向的区别
+
+1. 转发使用的是`request.getRequestDispatcher()`方法;重定向使用的是`response.sendRedirect()`;
+2. 转发：浏览器URL的地址栏不变。重定向：浏览器URL的地址栏改变；
+3. 转发是服务器行为，重定向是客户端行为；
+4. 转发是浏览器只做了一次访问请求。重定向是浏览器做了至少两次的访问请求；
+5. 转发2次跳转之间传输的信息不会丢失，重定向2次跳转之间传输的信息会丢失（request范围）。
+
diff --git "a/js/jquery\345\261\236\346\200\247\346\223\215\344\275\234.md" "b/js/jquery\345\261\236\346\200\247\346\223\215\344\275\234.md"
new file mode 100644
index 0000000..1078785
--- /dev/null
+++ "b/js/jquery\345\261\236\346\200\247\346\223\215\344\275\234.md"
@@ -0,0 +1,12 @@
+## 获取属性
+
+obj.attr('disabled');
+
+## 添加属性
+
+obj.attr('disabled', 'disabled');
+
+## 移除属性
+
+obj.removeAttr('disabled');
+
diff --git "a/js/jquery\350\216\267\345\217\226\351\235\236form\346\240\207\347\255\276\347\232\204value.md" "b/js/jquery\350\216\267\345\217\226\351\235\236form\346\240\207\347\255\276\347\232\204value.md"
new file mode 100644
index 0000000..d0c6226
--- /dev/null
+++ "b/js/jquery\350\216\267\345\217\226\351\235\236form\346\240\207\347\255\276\347\232\204value.md"
@@ -0,0 +1,29 @@
+## jquery 获取\<li>标签的value值
+
+对于普通标签来说，可以使用jquery的`val()`方法获取属性，如：
+
+```html
+<input name="username" value="myname"/>
+```
+
+```js
+var myname = $('input').val();
+```
+
+而对于`<li>`标签来说，如果value存放的不是数字，使用`val()`方法是无法获取到真正的值的， 如：
+
+```html
+<ul>
+    <li value="myname">username</li>
+</ul>
+```
+
+```js
+var zero = $('li').val();	// 获取不到,结果为0
+var myname = $('li').attr('value');	// 可以正确获取到myname值
+```
+
+**原因：**
+
+HTML的li标签的value属性存在一下规定：规定列表项目为数字，所以它的value只能是数字。
+
diff --git "a/js/\344\275\277\347\224\250FormData\344\270\212\344\274\240\346\226\207\344\273\266.md" "b/js/\344\275\277\347\224\250FormData\344\270\212\344\274\240\346\226\207\344\273\266.md"
new file mode 100644
index 0000000..90d44bd
--- /dev/null
+++ "b/js/\344\275\277\347\224\250FormData\344\270\212\344\274\240\346\226\207\344\273\266.md"
@@ -0,0 +1,72 @@
+## 使用FormData上传文件
+
+### form标签上传文件
+
+```html
+<form action="上传文件的后端api接口" enctype="multipart/form-data">
+    <!-- 上传额外的参数 -->
+    <input type="text" name="filename"/>
+    <!-- 上传的文件 -->
+    <input type="file" name="file"/>
+    <input type="submit" value="提交"/>
+</form>
+```
+
+使用常规的form表单方式可以实现文件上传，但是当用户点击提交按钮时，页面也会跟随着跳转，用户体验很差。
+
+### FromData异步上传
+
+`FormData`是js提供的用于手动组装from表单的数据，为form数据的提交提供了更加灵活的方式。
+
+#### 初始化FromData
+
+```html
+<form id="myfrom" enctype="multipart/form-data">
+    <!-- 上传额外的参数 -->
+    <input type="text" name="filename"/>
+    <!-- 上传的文件 -->
+    <input id="id_file" type="file" name="file"/>
+</form>
+```
+
+```js
+// 获取form表单对象
+var formObj = document.getElementById('myform');
+// 通过form表单构造FromData对象
+var formData = new FormData(formObj);
+```
+
+#### 添加属性
+
+```js
+// 获取文件
+var file = $('#id_file')[0].files[0];
+// 文件名
+var filename = file.name;
+// 直接构建FormData
+var formData = new FormData();
+// 添加上传的文件
+formData.append('file', file);
+// 添加其他属性
+formData.append('serverId', 'myServerId');
+```
+
+### 使用jquery上传
+
+```js
+$.ajax({
+    url: '后端提供的上传url',
+    data: formData,   // 使用上面构建好的FromData对象
+    type: 'post',
+    cache: false,	// 上传文件不需要缓存
+    processData: false,	// 用于对data参数进行序列化，必须为false
+    contentType: false,	// 必须为false
+    success: function(data) {
+        // 处理成功后的回调函数
+    },
+    error: function(data) {
+        // 处理失败后的回调函数
+    }
+})
+```
+
diff --git "a/js/\345\256\232\346\227\266\345\231\250.md" "b/js/\345\256\232\346\227\266\345\231\250.md"
new file mode 100644
index 0000000..11db017
--- /dev/null
+++ "b/js/\345\256\232\346\227\266\345\231\250.md"
@@ -0,0 +1,40 @@
+## JS 定时器
+
+### setTimeout
+
+设置一个定时器，在定时器到期后执行一次函数或代码段
+
+```js
+var timeoutId = setTimeout(func[,delay, param1, param2...]);
+var timeoutId = setTimeout(code[,delay]);
+```
+
+> * timeoutId: 定时器id
+> * func: 延迟执行的函数
+> * code: 延迟后执行的代码字符串, 不推荐使用
+> * delay: 延迟时间(单位：毫秒)，默认0
+> * param1: 向延迟函数传递的参数
+
+```js
+clearTimeout(timeoutId);	// 清除定时器
+```
+
+### setInterval
+
+以固定的时间间隔重复一个函数或代码段
+
+```js
+var intervalId = setInterval(func[,delay, param1, param2...]);
+var intervalId = setInterval(code[,delay]);
+```
+
+> - intervalId: 定时器id
+> - func: 延迟执行的函数
+> - code: 延迟后执行的代码字符串, 不推荐使用
+> - delay: 延迟时间(单位：毫秒)，默认0
+> - param1: 向延迟函数传递的参数
+
+```js
+clearInterval(intervalId);	// 清除定时器
+```
+
diff --git "a/js/\350\247\246\345\217\221\344\272\213\344\273\266.md" "b/js/\350\247\246\345\217\221\344\272\213\344\273\266.md"
new file mode 100644
index 0000000..bb593c2
--- /dev/null
+++ "b/js/\350\247\246\345\217\221\344\272\213\344\273\266.md"
@@ -0,0 +1,26 @@
+## 添加事件监听器
+
+在**文件上传**的业务中，我们不免会遇到由于原生的文件上传按钮太丑导致需要自定位上传按钮的情形。
+
+在该需求中，我们可以通过一个绘制好的按钮或其他标签的点击事件来实现，通过监听该标签的点击事件，动态的调用文件上传按钮的点击事件。
+
+**HTML**
+
+```html
+<form class="form-inline my-2 my-lg-0">
+          <button id="header_select_file" class="form-control form-control-file mr-sm-2">选择文件...</button>
+          <input id="header_file" type="file" class="form-control form-control-file mr-sm-2" style="display: none"> <!-- 隐藏真实的文件上传按钮 -->
+          <button id="header_file_upload" class="btn btn-outline-success my-2 my-sm-0">上传文件</button>
+        </form>
+```
+
+**JS**
+
+```js
+// 动态将按钮的点击事件替换为文件上传框的点击事件
+document.querySelector('#header_select_file').addEventListener('click',
+      function () {
+        document.querySelector('#header_file').click();
+      });
+```
+
diff --git "a/linux/centos7\345\256\211\350\243\205mysql5.6.md" "b/linux/centos7\345\256\211\350\243\205mysql5.6.md"
new file mode 100644
index 0000000..f24d8b5
--- /dev/null
+++ "b/linux/centos7\345\256\211\350\243\205mysql5.6.md"
@@ -0,0 +1,262 @@
+### 环境准备
+
+| 环境   | 版本 |
+| ------ | ---- |
+| centos | 7    |
+| mysql  | 5.7  |
+
+### 必要工具
+
+[MySQL yum源5.7](https://cdn.mysql.com//Downloads/MySQL-5.7/mysql-community-server-5.7.26-1.el7.x86_64.rpm)
+
+### 开始安装
+
+#### 下载mysql yum源
+
+执行如下命令下载mysql rpm 官网源：
+
+```shell
+ wget https://cdn.mysql.com//Downloads/MySQL-5.7/mysql-community-server-5.7.26-1.el7.x86_64.rpm
+#### 输出
+--2019-05-08 03:25:45--  https://cdn.mysql.com//Downloads/MySQL-5.7/mysql-community-server-5.7.26-1.el7.x86_64.rpm
+Resolving cdn.mysql.com (cdn.mysql.com)... 23.209.176.104
+Connecting to cdn.mysql.com (cdn.mysql.com)|23.209.176.104|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 173541272 (166M) [application/x-redhat-package-manager]
+Saving to: ‘mysql-community-server-5.7.26-1.el7.x86_64.rpm’
+100%[=================================================================>] 173,541,272 99.1MB/s   in 1.7s   
+2019-05-08 03:25:46 (99.1 MB/s) - ‘mysql-community-server-5.7.26-1.el7.x86_64.rpm’ saved [173541272/173541272]
+```
+
+下载完成后会在当前目录下出现名字为：`mysql-community-server-5.7.26-1.el7.x86_64.rpm`的文件。
+
+#### 安装yum源
+
+通过`yum`命令安装mysql源
+
+```shell
+yum localinstall mysql-community-server-5.7.26-1.el7.x86_64.rpm
+### 输出
+Loaded plugins: fastestmirror
+Examining mysql-community-server-5.7.26-1.el7.x86_64.rpm: mysql-community-server-5.7.26-1.el7.x86_64
+Marking mysql-community-server-5.7.26-1.el7.x86_64.rpm to be installed
+Resolving Dependencies
+--> Running transaction check
+---> Package mysql-community-server.x86_64 0:5.7.26-1.el7 will be installed
+--> Processing Dependency: mysql-community-common(x86-64) = 5.7.26-1.el7 for package: mysql-community-server-5.7.26-1.el7.x86_64
+...
+```
+
+#### 查看当前源启用的mysql版本
+
+```shell
+yum repolist all | grep mysql
+### 输出
+mysql-connectors-community/x86_64 MySQL Connectors Community   enabled:      108
+mysql-connectors-community-source MySQL Connectors Community - disabled
+mysql-tools-community/x86_64      MySQL Tools Community        enabled:       90
+mysql-tools-community-source      MySQL Tools Community - Sour disabled
+mysql55-community/x86_64          MySQL 5.5 Community Server   disabled
+mysql55-community-source          MySQL 5.5 Community Server - disabled
+mysql56-community/x86_64          MySQL 5.6 Community Server   enabled:      463
+mysql56-community-source          MySQL 5.6 Community Server - disabled
+mysql57-community-dmr/x86_64      MySQL 5.7 Community Server D disabled
+mysql57-community-dmr-source      MySQL 5.7 Community Server D disabled
+```
+
+倒数第二列**disable**表示直接通过**yum**进行安装时，会直接忽略对应的项目。**enable**则恰恰相反。
+
+**通过命令启用或禁止源**
+
+```shell
+yum-config-manager --disable mysql56-community  # 禁用 mysql56-community
+yum-config-manager --enable mysql56-community  # 启用 mysql56-community
+```
+
+**通过配置文件启用或禁止源**
+
+`vim /etc/yum.repos.d/mysql-community.repo`
+
+*enabled*为**1**时，表示启用该源。为**0**则表示禁用该源。
+
+```properties
+...
+# Enable to use MySQL 5.5
+[mysql55-community]
+name=MySQL 5.5 Community Server
+baseurl=http://repo.mysql.com/yum/mysql-5.5-community/el/7/$basearch/
+enabled=0
+gpgcheck=1
+gpgkey=file:/etc/pki/rpm-gpg/RPM-GPG-KEY-mysql
+
+# Enable to use MySQL 5.6
+[mysql56-community]
+name=MySQL 5.6 Community Server
+baseurl=http://repo.mysql.com/yum/mysql-5.6-community/el/7/$basearch/
+enabled=1
+gpgcheck=1
+gpgkey=file:/etc/pki/rpm-gpg/RPM-GPG-KEY-mysql
+...
+```
+
+#### 安装mysql服务
+
+通过`yum`安装mysql server
+
+```shell
+yum install mysql-community-server
+### 输出
+Loaded plugins: fastestmirror
+mysql-connectors-community                                           | 2.5 kB  00:00:00
+mysql-tools-community                                                | 2.5 kB  00:00:00
+mysql56-community                                                    | 2.5 kB  00:00:00
+...
+
+Dependencies Resolved
+=========================================================================================
+ Package				Arch	Version			Repository			Size
+=========================================================================================
+Installing:
+ mysql-community-server	x86_64	5.6.44-2.el7	mysql56-community	60 M
+
+Transaction Summary
+=======================================================================================
+Install  1 Package
+
+Total download size: 60 M
+Installed size: 252 M
+Is this ok [y/d/N]: y  # 这里需要确认一下
+Downloading packages:
+mysql-community-server-5.6.44-2.el7.x86_64.rpm                                      |  60 MB  00:00:01     
+...
+Installed:
+  mysql-community-server.x86_64 0:5.6.44-2.el7          
+Complete!
+```
+
+### 使用mysql
+
+#### 启动和查看mysql服务状态
+
+```shell
+# 启动mysql服务
+systemctl start mysqld
+# 查看mysql状态
+systemctl status mysqld
+### 输出
+● mysqld.service - MySQL Community Server
+   Loaded: loaded (/usr/lib/systemd/system/mysqld.service; enabled; vendor preset: disabled)
+   Active: active (running) since Wed 2019-05-08 03:34:08 EDT; 8s ago
+  Process: 2694 ExecStartPost=/usr/bin/mysql-systemd-start post (code=exited, status=0/SUCCESS)
+  Process: 2634 ExecStartPre=/usr/bin/mysql-systemd-start pre (code=exited, status=0/SUCCESS)
+ Main PID: 2693 (mysqld_safe)
+...
+```
+
+**Active: active (running)**表示当前服务正在运行。
+
+#### 修改密码
+
+**mysqladmin**可以修改root用户的密码。语法为：`mysqladmin -u用户名 -p原密码 password 新密码`。
+
+由于mysql5.6安装完成后默认密码为空，所有我们可以使用下面的命令来将root用户的密码修改为root
+
+```shell
+mysqladmin -u root password root
+```
+
+#### 修改mysql的配置
+
+配置文件的路径为：`/etc/my.conf`
+
+查看数据库的编码格式
+
+```sql
+mysql> show variables like '%char%';
++--------------------------+----------------------------+
+| Variable_name            | Value                      |
++--------------------------+----------------------------+
+| character_set_client     | utf8                       |
+| character_set_connection | utf8                       |
+| character_set_database   | utf8                       |
+| character_set_filesystem | binary                     |
+| character_set_results    | utf8                       |
+| character_set_server     | utf8                       |
+| character_set_system     | utf8                       |
+| character_sets_dir       | /usr/share/mysql/charsets/ |
++--------------------------+----------------------------+
+8 rows in set (0.01 sec)
+```
+
+修改默认的编码格式，在配置文件中增加如下内容
+
+```properties
+[client]
+default-character-set=utf8
+
+[mysqld]
+default-storage-engine=INNODB
+character-set-server=utf8
+collation-server=utf8_general_ci
+```
+
+修改指定表的编码格式
+
+```sql
+alter table tableName character set utf8;
+```
+
+### mysql 核心参数
+
+#### cpu优化
+
+| 参数                      | 参数功能                                                     | 取值范围 | 经验值                 |
+| ------------------------- | ------------------------------------------------------------ | -------- | ---------------------- |
+| innodb_thread_concurrency | 并发执行的线程的数量（同时干活的线程的数量），保护系统不被hang住 | 0-1000   | 一般要求是cpu核数的4倍 |
+
+#### 内存优化
+
+| 参数                           | 参数功能                                             | 取值范围                                                     | 经验值                                                       |
+| ------------------------------ | ---------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| innodb_buffer_pool_size        | 缓存innodb表和索引数据的内存池大小                   | <=5.7.4：非动态全局；>=5.7.5：动态全局；64位：默认128M，最小5M，最大2^64-1 | 一般设置内存的50%~80%，根据实际内存大小设置，如果内存不是很大，可以考虑50~70%，如果内存很大，可以考虑到70%~80%，如果总是产生Innodb_buffer_pool_wait_free，说明buffer_pool设置过小 |
+| tmpdir                         | 存放临时文件和临时表目录，可以设置多个路径用：分隔   | 全局参数，非动态，更改需要重启数据库                         | 单独挂载，对读写要求很高，放在高性能盘，独立分区             |
+| innodb_buffer_pool_instances   | buffer_pool被分成多少实例                            | 非动态，全局；                                               | 8个或者16个，根据实际buffer pool大小设置，如果实例数量过小，会导致latch争用 |
+| innodb_max_dirty_pages_pct     | buffer pool中最大脏页占比                            | 百分比                                                       | 75%~90%，如果io能力足够强，例如使用了闪卡，可以将这个参数调小；该参数设置越小，写入压力越大。 |
+| innodb_max_dirty_pages_pct_lwm | 预刷新脏页比例，可以有效控制脏页比例达到最大脏页占比 | 动态，全局；<5.7.4：默认0，范围0~99；>=5.7.5：默认0，范围0~99.99 | 70，控制脏页比率，防止达到脏页最大占比                       |
+
+#### io优化
+
+| 参数                           | 参数功能                                                   | 取值范围                                                     | 经验值                                                       |
+| ------------------------------ | ---------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| innodb_io_capacity             | 设定了后台任务执行的io量的上限                             | 动态，全局；64位：默认200，最小100，最大2^64-1               | 每秒后台进程处理IO数据的上限，一般为IO QPS总能力的75%        |
+| innodb_io_capacity_max         | 在紧急情况下，innodbio容量上限的最大值，2000是初始默认值。 | 动态，全局；unix-64位：默认是2000，最小100，最大2^32-1       | 根据innodb_io_capacity的2倍进行设置                          |
+| innodb_log_files_in_group      | redo日志的组数，即logfile的数量                            | 非动态，全局；默认2个，范围2~100                             | 一般设置5组                                                  |
+| innodb_log_file_size           | 每个logfile的大小                                          | \<=5.7.10:默认50M，最小1M，最大512G/innodb_log_files_in_group；>=5.7.11：默认50M，最小4M，最大512G/innodb_log_files_in_group | 一般设置2G，每20~30分钟切换一次redo比较合适， 案例：业务人员反映晚上9:10-9:15有大量交易放弃，交易失败，让dba看看这个时间段数据库的性能情况，dba发现这个时间段有redo切换，buffer写入明显增加（写入抖动），TPS明显降低（事务提交了降低），怀疑redo文件过小，组数过少，脏数据写入速度慢。 解决方案：增加redo数量和大小，加大脏数据的写入力度，需要重启数据库 |
+| innodb_flush_method            | 采用O_DIRECT方式写入的时候绕过文件系统缓存，直接写入磁盘   | 非动态，全局；默认NULL，有效值：fsync、O_DSYNC、littlesync、nosync、O_DIRECT、O_DIRECT_NO_FSYNC | =O_DIRECT                                                    |
+| innodb_max_dirty_pages_pct     | buffer pool中最大脏页占比                                  |                                                              | 75%~90%，如果io能力足够强，例如使用了闪卡，可以将这个参数调小；该参数设置越小，写入压力越大。 |
+| innodb_max_dirty_pages_pct_lwm | 预刷新脏页比例，可以有效控制脏页比例达到最大脏页占比       | 动态，全局；<5.7.4：默认0，范围0~99；>=5.7.5：默认0，范围0~99.99 | 70，，当脏块达到70%的时候，触发网磁盘写，控制脏页比率，防止达到脏页最大占比 |
+| innodb_flush_neighbors         | 是否关闭邻接页刷新                                         | 0关闭,1不关闭                                                | 一般关闭邻接页刷新                                           |
+
+#### 连接优化
+| 参数                 | 参数功能                                                     | 取值范围                                  | 经验值                                                 |
+| -------------------- | ------------------------------------------------------------ | ----------------------------------------- | ------------------------------------------------------ |
+| max_connections      | 允许客户端并发连接数量                                       | 动态，全局；默认151，最小1，最大10000     | 1024，一般不要超过2000                                 |
+| max_user_connections | 任何一个mysql用户允许最大并发连接数                          | 动态，全局和会话；默认0，范围0~4294967295 | 256                                                    |
+| table_open_cache     | 打开表缓存，跟表数量没关系1000个连接上来，都需要访问A表，那么会打开1000个表，打开1000个表是指mysql创建1000个这个表的对象，连接直接访问表对象 | 动态，全局；默认                          | 4096 ，监控opened_tables值，如果很大，说明该值设置小了 |
+| thread_cache_size    | 线程缓存                                                     |                                           | 512                                                    |
+| wait_timeout         | app应用连接mysql进行操作完毕后，空闲断开的时间，单位秒       |                                           | 120                                                    |
+
+#### 数据一致性优化
+
+```innodb_flush_log_at_trx_commit=1``
+
+0，不管有没有提交，每秒钟都写到binlog日志里
+1，每次提交事务，都会把log buffer的内容写到磁盘里去，对日志文件做到磁盘刷新，安全最好
+2，每次提交事务，都写到操作系统缓存，由OS刷新到磁盘，性能最好
+
+```sync_binlog=1```
+
+0，事务提交后，mysql不做fsync之类的刷盘，由文件系统来决定什么落盘
+n，多少次提交，每n次提交持久化磁盘
+生产设为1
+
diff --git "a/linux/centos\346\211\251\345\244\247swap\345\210\206\345\214\272.md" "b/linux/centos\346\211\251\345\244\247swap\345\210\206\345\214\272.md"
new file mode 100644
index 0000000..f84c774
--- /dev/null
+++ "b/linux/centos\346\211\251\345\244\247swap\345\210\206\345\214\272.md"
@@ -0,0 +1,64 @@
+### 前言
+
+linux下扩大系统swap分区有两种方法，一种是重新建立swap分区，一种是增加swap分区。
+
+**注：**必须拥有`root`权限，并且不小心会破坏硬盘数据（做好备份），建议增加swap分区。
+
+
+
+#### 方法一：新建swap分区
+
+1、以root身份进入系统，输入下面命令停止交换分区
+
+```sh
+# swapoff -a
+```
+
+2、用 `fdisk` 命令加swap分区的盘符，（例如：`# fdisk /dev/sdb`）剔除swap分区，输入 `d` 删除swap分区，然后再 `n` 添加分区（添加时硬盘必须要有可用空间），然后再用 `t` 将新添的分区`id` 改为 `82`（linux swap类型），最后用 `w` 将操作实际写入硬盘。
+
+3、格式化swap分区，`sdb2`盘符要使用 `p` 命令显示的实际分区设备名
+
+```sh
+# mkswap /dev/sdb2
+```
+
+4、启动新的swap分区
+
+```sh
+swapon /dev/sdb2
+```
+
+5、配置开机启动swap分区，在 `/etc/fstab` 文件内最后添加一行
+
+```
+/dev/sdb2 swap swap defaults 0 0
+```
+
+
+
+#### 方法二：增加swap分区
+
+1、创建交换分区的文件，增加1G大小的交换分区，命令如下，其中count等于要增加的块大小
+
+```sh
+# dd if=/dev/zero of /home/swapfile bs=1M count=1024
+```
+
+2、设置交换分区文件，建立swap的文件系统
+
+```sh
+# mkswap /home/swapfile
+```
+
+3、立即启用交换分区文件
+
+```sh
+# swapon /home/swapfile
+```
+
+4、配置开机启动swap分区，在 `/etc/fstab` 文件内最后添加一行
+
+```
+/home/swapfile swap swap defaults 0 0
+```
+
diff --git "a/linux/centos\346\220\255\345\273\272consul\351\233\206\347\276\244.md" "b/linux/centos\346\220\255\345\273\272consul\351\233\206\347\276\244.md"
new file mode 100644
index 0000000..e87b9f9
--- /dev/null
+++ "b/linux/centos\346\220\255\345\273\272consul\351\233\206\347\276\244.md"
@@ -0,0 +1,621 @@
+### 准备
+
+#### 下载
+
+下载地址`https://www.consul.io/downloads.html`
+
+#### 安装
+
+- 解压`unzip consule-consul_1.2.2_linux_amd64.zip`
+- 拷贝 `cp ./consule /usr/bin`
+
+### 命令（cli）
+
+#### 帮助
+
+`consul command -h`
+
+#### API选项
+
+- `-ca-file=<value>`- 与Consul通信时用于TLS的CA文件的路径。这也可以通过`CONSUL_CACERT`环境变量指定。
+- `-ca-path=<value>` - 与Consul通信时用于TLS的CA证书目录的路径。这也可以通过`CONSUL_CAPATH`环境变量指定。
+- `-client-cert=<value>`- verify_incoming启用时用于TLS的客户端证书文件的路径 。这也可以通过CONSUL_CLIENT_CERT 环境变量指定。
+- `-client-key=<value>`- verify_incoming启用时用于TLS的客户机密钥文件的路径 。这也可以通过CONSUL_CLIENT_KEY 环境变量指定。
+- `-http-addr=<addr>` - 具有端口的Consul代理的地址。这可以是IP地址或DNS地址，但必须包含端口。这也可以通过`CONSUL_HTTP_ADDR`环境变量指定。在Consul 0.8及更高版本中，默认值为[http://127.0.0.1:8500](http://127.0.0.1:8500/)，可以选择使用https。也可以通过设置环境变量将方案设置为HTTPS `CONSUL_HTTP_SSL=true`。
+- `-tls-server-name=<value>` - 通过TLS连接时用作SNI主机的服务器名称。这也可以通过`CONSUL_TLS_SERVER_NAME` 环境变量指定。
+- `-token=<value>`- 在请求中使用的ACL令牌。这也可以通过`CONSUL_HTTP_TOKEN`环境变量指定。如果未指定，则查询将默认为HTTP地址处的Consul代理的令牌。
+- `-datacenter=<name>` - 要查询的数据中心的名称。如果未指定，则查询将默认为HTTP地址处的Consul代理的数据中心。
+
+- `-stale` - 允许任何Consul服务器（非领导者）响应此请求。这允许更低的延迟和更高的吞吐量，但可能导致过时的数据。此选项对非读取操作没有影响。默认值为false。
+
+#### 代理人(agent)
+
+该`consul agent`命令是Consul的核心：它运行代理，执行维护成员资格信息，运行检查，公布服务，处理查询等重要任务。 
+
+`console agent -dev`
+
+#### 目录(category)
+
+| 命令                                     | 解释                       |
+| ---------------------------------------- | -------------------------- |
+| consul category datacenters              | 列出多有的数据中心         |
+| consul category nodes                    | 列出所有的节点             |
+| console category nodes -service=redis    | 列出提供特定服务的所有节点 |
+| consul category services                 | 列出所有服务               |
+| consul category services -node=worker-01 | 列出节点上的所有服务       |
+
+##### 数据中心
+
+用法： `consul catalog datacenters [options]`
+
+##### 节点
+
+用法： `consul catalog nodes [options]` 
+
+目录列表节点选项
+
+- `-detailed`- 输出有关节点的详细信息，包括其地址和元数据。
+- `-near=<string>` - 节点名称，用于根据从该节点估计的往返时间按升序对节点列表进行排序。传递`"_agent"`将使用此代理的节点进行排序。
+- `-node-meta=<key=value>` - 使用给定键=值对过滤节点的元数据。可以多次指定该标志以过滤多个元数据源。
+- `-service=<id or name>` - 过滤节点的服务ID或名称。仅返回提供给定服务的节点。
+
+##### 服务
+
+用法： `consul catalog services [options]` 
+
+目录列表节点选项
+
+- `-node=<id or name>`- `id or name`列出服务的节点。
+- `-node-meta=<key=value>`- 使用给定`key=value`对过滤节点的元数据 。如果指定，则仅返回在与给定元数据匹配的节点上运行的服务。可以多次指定该标志以过滤多个元数据源。
+- `-tags` - 将每个服务的标签显示为每个服务条目旁边的逗号分隔列表。
+
+#### 链接(connect)
+
+##### 证书颁发机构(CA)
+
+**get-config**
+
+此命令显示当前的CA配置。 
+
+用法： `consul connect ca get-config [options]` 
+
+**set-config**
+
+修改当前的CA配置。如果这导致使用新的根证书，则将触发[根循环](https://www.consul.io/docs/connect/ca.html#root-certificate-rotation)过程。
+
+用法： `consul connect ca set-config [options]`
+
+命令选项
+
+- `-config-file`- （必需）指定用于新配置的JSON格式的文件。
+
+##### 代理（proxy）
+
+用法： `consul connect proxy [options]` 
+
+代理选项
+
+- `-service` - 此代理表示的服务的名称。此服务不需要实际存在于Consul目录中，但需要正确的ACL权限（`service:write`）。
+- `-upstream`- 支持连接的上游服务。格式应为'name：addr'，例如'db：8181'。这将使端口8181上的“db”可用。当与端口8181建立常规TCP连接时，代理将服务发现“db”并建立一个标识为`-service`值的Connect mTLS连接。该标志可以重复多次。
+- `-listen` - 用于侦听代理服务的入站连接的地址。必须使用-service和-service-addr指定。如果未指定，则不启动入站侦听器。
+- `-service-addr` - 代理的本地服务的地址。必需的 `-listen`。
+- `-register` - 向当地Consul代理自行注册，使该代理在目录中作为Connect-capable服务提供。这只适用于`-listen`。
+- `-register-id`- `-register`设置为消除服务ID歧义时服务的可选ID后缀。默认情况下，服务ID为“-proxy”，其中`<service>`是`-service`的值。
+- `-log-level`- 指定日志级别。
+- `-pprof-addr`- 通过pprof启用调试。提供host：port（或只是'：port'）可以在该地址上分析HTTP端点。
+- `-proxy-id` - 本地代理上的代理ID。这仅适用于测试托管代理模式。
+
+例子
+
+下面的示例显示如何启动本地代理以建立表示前端服务的“db”的出站连接。一旦运行，任何创建到指定端口（8181）的TCP连接的进程将建立与标识为“前端”的“db”的相互TLS连接。
+
+```
+$ consul connect proxy -service frontend -upstream db:8181
+```
+
+下一个示例启动一个本地代理，该代理也接受端口8443上的入站连接，授权连接，然后将其代理到端口8080：
+
+```
+$ consul connect proxy \
+    -service frontend \
+    -service-addr 127.0.0.1:8080 \
+    -listen ':8443'
+```
+
+#### 加入(join)
+
+该`join`命令告知Consul代理加入现有集群。新的Consul代理必须与群集中的至少一个现有成员连接才能加入现有群集。在加入该一个成员之后，八卦层接管，在集群中传播更新的成员资格状态。
+
+如果您未加入现有群集，则该代理程序是其自己的隔离群集的一部分。其他节点可以加入它。
+
+代理可以多次加入其他代理而不会出现问题。如果已经是集群一部分的节点加入另一个节点，则两个节点的集群将成为一个集群。
+
+用法： `consul join [options] address ...` 
+
+命令选项
+
+- `-wan` - 对于以服务器模式运行的代理，代理将尝试加入WAN群集中的其他服务器集群。这用于在多个数据中心之间形成桥梁。
+
+#### KV
+
+该`kv`命令用于通过命令行与Consul的KV存储进行交互。它公开了用于从商店插入，更新，读取和删除的顶级命令。 
+
+用法： `consul kv <subcommand>` 
+
+##### 删除（delete）
+
+用法： `consul kv delete [options] KEY_OR_PREFIX` 
+
+KV删除选项
+
+- `-cas` - 执行检查和设置操作。指定此值还需要设置-modify-index标志。默认值为false。
+- `-modify-index=<int>` - 表示密钥的ModifyIndex的无符号整数。这与-cas标志结合使用。
+- `-recurse` - 递归删除路径中的所有键。默认值为false。
+
+例子
+
+要删除KV存储中名为“redis / config / connections”的键的值，请执行以下操作： 
+
+`consul kv delete redis/config/connections`
+
+如果密钥不存在，则命令不会出错，并返回成功消息
+
+要仅删除自给定索引后尚未修改的密钥，请指定`-cas`和`-modify-index`标记：
+
+```
+$ consul kv get -detailed redis/config/connections | grep ModifyIndex
+ModifyIndex      456
+
+$ consul kv delete -cas -modify-index=123 redis/config/connections
+Error! Did not delete key redis/config/connections: CAS failed
+
+$ consul kv delete -cas -modify-index=456 redis/config/connections
+Success! Deleted key: redis/config/connections
+```
+
+要以递归方式删除以给定前缀开头的所有键，请指定 `-recurse`标志：
+
+```
+$ consul kv delete -recurse redis/
+Success! Deleted keys with prefix: redis/
+```
+
+**尾随斜杠**在递归删除操作中**很重要**，因为Consul会对提供的前缀执行贪婪匹配。如果你使用“foo”作为键，这将递归删除任何以这些字母开头的键，例如“foo”，“food”和“football”，而不仅仅是“foo”。要确保删除文件夹，请始终使用尾部斜杠。
+
+将`-cas`选项组合在一起无效`-recurse`，因为您在单个操作中删除前缀下的多个键：
+
+```
+$ consul kv delete -cas -recurse redis/
+Cannot specify both -cas and -recurse!
+```
+
+##### 导出（export）
+
+该`kv export`命令用于从Consul的KV存储中检索给定前缀的KV对，并将JSON表示写入stdout。这可以与命令“consul kv import”一起使用，以在Consul集群之间移动整个树。 
+
+用法： `consul kv export [PREFIX]` 
+
+例子
+
+要在键值存储中的“vault /”处导出树：
+
+```
+$ consul kv export vault/
+# JSON output
+```
+
+##### 取值（get）
+
+用法： `consul kv get [options] [KEY_OR_PREFIX]` 
+
+KV获取选项
+
+- `-base64` - Base 64对值进行编码。默认值为false。
+- `-detailed` - 除了值之外，还提供有关密钥的其他元数据，例如ModifyIndex和可能已在密钥上设置的任何标志。默认值为false。
+- `-keys` - 列出以给定前缀开头但不是其值的键。如果您只需要键名本身，这将特别有用。此选项通常与-separator选项结合使用。默认值为false。
+- `-recurse` - 递归查看前缀为给定路径的所有键。默认值为false。
+- `-separator=<string>` - 用作键之间分隔符的字符串。默认值为“/”，但只有在与-keys标志配对时才考虑此选项。
+
+例子
+
+要仅列出以指定前缀开头的键，请使用“-keys”选项。这样性能更高，并且有效载荷更小：
+
+```
+$ consul kv get -keys redis/config/
+redis/config/connections
+redis/config/cpu
+redis/config/memory
+```
+
+默认情况下，该`-keys`操作使用“/”分隔符，这意味着它不会递归到该分隔符之外。您可以通过设置选择不同的分隔符 `-separator="<string>"`。
+
+```
+$ consul kv get -keys -separator="c" redis
+redis/c
+```
+
+或者，您可以通过将分隔符设置为空字符串来完全禁用分隔符：
+
+```
+$ consul kv get -keys -separator="" redis
+redis/config/connections
+redis/config/cpu
+redis/config/memory
+```
+
+要列出根目录下的所有密钥，只需省略prefix参数：
+
+```
+$ consul kv get -keys
+memcached/
+redis/
+```
+
+##### 导入(import)
+
+该`kv import`命令用于从`kv export`命令生成的JSON表示中导入KV对。 
+
+用法： `consul kv import [DATA]` 
+
+例子
+
+要从文件导入，请在文件名前加上`@`：
+
+```
+$ consul kv import @values.json
+# Output
+```
+
+要从stdin导入，请`-`用作数据参数：
+
+```
+$ cat values.json | consul kv import -
+# Output
+```
+
+您也可以直接传递JSON，但必须小心shell转义：
+
+```
+$ consul kv import "$(cat values.json)"
+# Output
+```
+
+##### 存值 （put）
+
+该`kv put`命令将数据写入KV存储中的给定路径。 
+
+用法： `consul kv put [options] KEY [DATA]` 
+
+选项
+
+- `-acquire` - 获得钥匙锁。如果密钥不存在，则此操作将创建密钥并获取锁定。会话必须已存在并通过-session标志指定。默认值为false。
+- `-base64` - 将数据视为基数为64的编码。默认值为false。
+- `-cas` - 执行检查和设置操作。指定此值还需要设置-modify-index标志。默认值为false。
+- `-flags=<int>`- 要分配给此KV对的无符号整数值。Consul不会读取此值，因此客户端可以使用此值但对其用例有意义。默认值为0（无标志）。
+- `-modify-index=<int>` - 表示密钥的ModifyIndex的无符号整数。这与-cas标志结合使用。
+- `-release`- 放弃给定路径上钥匙的锁定。这需要设置-session标志。密钥必须由会话保存才能解锁。默认值为false。
+- `-session=<string>` - 用户定义的此会话标识符为字符串。这通常与-acquire和-release操作一起使用来构建强大的锁定，但它可以在任何键上设置。默认值为空（无会话）。
+
+例子
+
+对于更长或更敏感的值，可以通过在`@`符号前面添加前缀来读取文件：
+
+```
+$ consul kv put redis/config/password @password.txt
+Success! Data written to: redis/config/connections
+```
+
+或者通过指定`-`符号从stdin读取值：
+
+```
+$ echo "5" | consul kv put redis/config/password -
+Success! Data written to: redis/config/connections
+
+$ consul kv put redis/config/password -
+5
+<CTRL+D>
+Success! Data written to: redis/config/connections
+```
+
+要创建或调整锁定，请使用`-acquire`和`-session`标志。会话必须已存在（此命令不会创建或管理它）：
+
+```
+$ consul kv put -acquire -session=abc123 redis/lock/update
+Success! Lock acquired on: redis/lock/update
+```
+
+完成后，释放锁：
+
+```
+$ consul kv put -release -session=acb123 redis/lock/update
+Success! Lock released on: redis/lock/update
+```
+
+### 代理(agent)
+
+使用该`consul agent`命令启动代理程序。此命令阻止，永久运行或直到被告知退出。agent命令有很多种`configuration options`，但大多数都有合理的默认值。
+
+运行时`consul agent`，您应该看到与此类似的输出：
+
+```
+$ consul agent -data-dir=/tmp/consul
+==> Starting Consul agent...
+==> Consul agent running!
+       Node name: 'Armons-MacBook-Air'
+      Datacenter: 'dc1'
+          Server: false (bootstrap: false)
+     Client Addr: 127.0.0.1 (HTTP: 8500, DNS: 8600)
+    Cluster Addr: 192.168.1.43 (LAN: 8301, WAN: 8302)
+
+==> Log data will now stream in as it occurs:
+
+    [INFO] serf: EventMemberJoin: Armons-MacBook-Air.local 192.168.1.43
+...
+```
+
+`consul agent`输出有几条重要信息：
+
+- **节点名称**：这是代理的唯一名称。默认情况下，这是计算机的主机名，但您可以使用该`-node`标志对其进行自定义 。
+- **数据中心**：这是代理配置为运行的数据中心。Consul为多个数据中心提供一流的支持; 但是，要高效工作，必须将每个节点配置为报告其数据中心。该`-datacenter`标志可用于设置数据中心。对于单DC配置，代理将默认为“dc1”。
+- **服务器**：这表示代理是在服务器还是客户端模式下运行。服务器节点具有参与共识仲裁，存储群集状态和处理查询的额外负担。另外，服务器可以处于“引导”模式。多个服务器无法处于引导模式，因为这会使群集处于不一致状态。
+- **客户端地址**：这是用于代理的客户端接口的地址。这包括HTTP和DNS接口的端口。默认情况下，这仅绑定到localhost。如果更改此地址或端口，则必须`-http-addr` 在运行命令时指定，`consul members`以指示如何联系代理。其他应用程序也可以使用HTTP地址和端口 来控制Consul。
+- **Cluster Addr**：这是用于群集中Consul代理之间通信的端口和端口集。并非群集中的所有Consul代理都必须使用相同的端口，但所有其他节点都**必须**可以访问此地址。
+
+当在运行`systemd`在Linux上，领事通知发送systemd `READY=1`到`$NOTIFY_SOCKET`当LAN连接已经完成。为此，必须设置`join`或`retry_join`选项，并且必须设置服务定义文件`Type=notify`。
+
+#### 命令行配置
+
+- `-advertise` - 广告地址用于将我们通告的地址更改为群集中的其他节点。默认情况下，`-bind`通告地址。但是，在某些情况下，可能存在无法绑定的可路由地址。此标志允许闲聊不同的地址以支持此功能。如果此地址不可路由，则该节点将处于恒定的振荡状态，因为其他节点将不可路由性视为故障。
+- `-advertise-wan` - 广告WAN地址用于将我们通告的地址更改为通过WAN加入的服务器节点。当与`translate_wan_addrs`配置选项结合使用时，也可以在客户端代理上设置此选项。默认情况下，`-advertise`通告地址。但是，在某些情况下，所有数据中心的所有成员都不能位于同一物理或虚拟网络上，尤其是混合云和私有数据中心的混合设置。此标志使服务器节点通过公共网络为WAN进行闲聊，同时使用专用VLAN互相闲聊及其客户端代理，并且如果远程数据中心是远程数据中心，则允许从远程数据中心访问此地址时访问客户端代理。配置了`translate_wan_addrs`。
+- `-bootstrap` - 此标志用于控制服务器是否处于“引导”模式。重要的是，在此模式下，*每个*数据中心只能运行一台服务器。从技术上讲，允许自举模式的服务器作为Raft领导者自行选举。重要的是只有一个节点处于这种模式; 否则，无法保证一致性，因为多个节点能够自我选择。在引导群集后，建议不要使用此标志。
+- `-bootstrap-expect` - 此标志提供数据中心中预期的服务器数。不应提供此值，或者该值必须与群集中的其他服务器一致。提供后，Consul将等待指定数量的服务器可用，然后引导群集。这允许自动选择初始领导者。这不能与传统`-bootstrap`标志一起使用。此标志需要`-server`模式。
+- `-bind` - 应绑定到内部群集通信的地址。这是群集中所有其他节点都应该可以访问的IP地址。默认情况下，这是“0.0.0.0”，这意味着Consul将绑定到本地计算机上的所有地址，并将 第一个可用的私有IPv4地址通告给群集的其余部分。如果有**多个私有IPv4地址**可用，Consul将在启动时退出并显示错误。如果指定“[::]”，Consul将 通告第一个可用的公共IPv6地址。如果有**多个**可用的**公共IPv6地址**，Consul将在启动时退出并显示错误。Consul同时使用TCP和UDP以及相同的端口。如果您有防火墙，请务必同时允许这两种协议。
+- `-serf-wan-bind` - 应该绑定到Serf WAN八卦通信的地址。默认情况下，该值遵循与`-bind`相同的规则，如果未指定，`-bind`则使用该选项。
+- `-serf-lan-bind` - 应该绑定到Serf LAN八卦通信的地址。这是群集中所有其他LAN节点都应该可以访问的IP地址。默认情况下，该值遵循与`-bind`命令行标志相同的规则，如果未指定，`-bind`则使用该选项。
+- `-client`- Consul将绑定客户端接口的地址，包括HTTP和DNS服务器。默认情况下，这是“127.0.0.1”，仅允许环回连接。
+- `-config-file` - 要加载的配置文件。有关此文件格式的更多信息，请阅读“ 配置文件”部分。可以多次指定此选项以加载多个配置文件。如果多次指定，则稍后加载的配置文件将与先前加载的配置文件合并。在配置合并期间，单值键（string，int，bool）将简单地替换它们的值，而列表类型将被附加在一起。
+- `-config-dir` - 要加载的配置文件的目录。Consul将使用后缀“.json”或“.hcl”加载此目录中的所有文件。加载顺序是按字母顺序排列的，并且使用与上述`config-file`选项相同的合并例程 。可以多次指定此选项以加载多个目录。未加载config目录的子目录。有关配置文件格式的详细信息，请参阅“配置文件”部分。
+- `-config-format`- 要加载的配置文件的格式。通常，Consul会从“.json”或“.hcl”扩展名中检测配置文件的格式。将此选项设置为“json”或“hcl”会强制Consul解释具有或不具有扩展名的任何文件，以便以该格式进行解释。
+- `-data-dir` - 此标志为代理程序存储状态提供数据目录。这是所有代理商都需要的。该目录在重新启动后应该是持久的。这对于在服务器模式下运行的代理尤其重要，因为它们必须能够持久化群集状态。此外，该目录必须支持使用文件系统锁定，这意味着某些类型的已安装文件夹（例如VirtualBox共享文件夹）可能不适合。**注意：**服务器代理和非服务器代理都可以在此目录中的状态中存储ACL令牌，因此读访问可以授予对服务器上的任何令牌以及非服务器上的服务注册期间使用的任何令牌的访问权限。在基于Unix的平台上，文件使用0600权限编写，因此您应确保只有受信任的进程才能与Consul作为同一用户执行。在Windows上，您应确保该目录具有适当的权限，因为这些权限将被继承。
+- `-datacenter` - 此标志控制代理程序运行的数据中心。如果未提供，则默认为“dc1”。Consul拥有对多个数据中心的一流支持，但它依赖于正确的配置。同一数据中心中的节点应位于单个LAN上。
+- `-dev`- 启用开发服务器模式。这对于快速启动Consul代理并关闭所有持久性选项非常有用，可以启用内存服务器，该服务器可用于快速原型设计或针对API进行开发。在此模式下， Connect已启用，默认情况下将在启动时创建新的根CA证书。此模式**不适**用于生产用途，因为它不会将任何数据写入磁盘。
+- `-disable-host-node-id` - 将此设置为true将阻止Consul使用来自主机的信息生成确定性节点ID，而是生成将保留在数据目录中的随机节点ID。在同一主机上运行多个Consul代理进行测试时，这非常有用。在版本0.8.5之前的Consul中默认为false，在0.8.5及更高版本中默认为true，因此您必须选择加入基于主机的ID。使用<https://github.com/shirou/gopsutil/tree/master/host>生成基于主机的ID ，这是与HashiCorp的[Nomad](https://www.nomadproject.io/)共享的 ，因此如果您选择使用基于主机的ID，那么Consul和Nomad将使用信息在主机上自动在两个系统中分配相同的ID。
+- `-disable-keyring-file` - 如果设置，密钥环将不会持久保存到文件中。关机时任何已安装的密钥都将丢失，`-encrypt`启动时只有给定的 密钥可用。默认为false。
+- `-dns-port` - 要侦听的DNS端口。这将覆盖默认端口8600.这在Consul 0.7及更高版本中可用。
+- `-domain` - 默认情况下，Consul在“consul”中响应DNS查询。域。此标志可用于更改该域。假定此域中的所有查询都由Consul处理，不会以递归方式解析。
+- `-enable-script-checks`这可以控制是否在此代理上启用了执行脚本的运行状况检查，默认为`false`运营商必须选择允许这些检查。如果启用，建议还启用ACL以控制允许哪些用户注册新检查以执行脚本。这是在Consul 0.9.0中添加的。
+- `-encrypt` - 指定用于加密Consul网络流量的密钥。该密钥必须是16字节的Base64编码。创建加密密钥的最简单方法是使用 `consul keygen`。群集中的所有节点必须共享相同的加密密钥才能进行通信。提供的密钥将自动持久保存到数据目录，并在重新启动代理时自动加载。这意味着要加密Consul的八卦协议，只需在每个代理的初始启动序列上提供一次该选项。如果在使用加密密钥初始化Consul之后提供，则忽略提供的密钥并显示警告。
+- `-hcl` - HCL配置片段。此HCL配置片段将附加到配置中，并允许在命令行上指定配置文件的所有选项。可以多次指定此选项。这是在Consul 1.0中添加的。
+- `-http-port`- 要监听的HTTP API端口。这将覆盖默认端口8500.将Consul部署到通过环境传输HTTP端口的环境（例如CloudFoundry等PaaS）时，此选项非常有用，允许您通过Procfile直接设置端口。
+- `-join` - 启动时加入的另一个代理的地址。可以多次指定，以指定要加入的多个代理。如果Consul无法加入任何指定的地址，则代理启动将失败。默认情况下，代理在启动时不会加入任何节点。请注意，`retry_join`在自动执行Consul群集部署时，使用 可能更适合帮助缓解节点启动竞争条件。
+
+- `-retry-join`- 类似`-join`但允许在第一次尝试失败时重试连接。这对于您知道地址最终可用的情况很有用。该列表可以包含IPv4，IPv6或DNS地址。如果Consul在非默认的Serf LAN端口上运行，则必须同时指定。IPv6必须使用“括号”语法。如果给出了多个值，则会按列出的顺序尝试和重试它们，直到第一个成功为止。这里有些例子：
+
+  ```
+  # Using a DNS entry
+  $ consul agent -retry-join "consul.domain.internal"
+  ```
+
+  ```
+  # Using IPv4
+  $ consul agent -retry-join "10.0.4.67"
+  ```
+
+  ```
+  # Using IPv6
+  $ consul agent -retry-join "[::1]:8301"
+  ```
+
+#### 配置文件
+
+示例配置文件
+
+```
+{
+  "datacenter": "east-aws",
+  "data_dir": "/opt/consul",
+  "log_level": "INFO",
+  "node_name": "foobar",
+  "server": true,
+  "watches": [
+    {
+        "type": "checks",
+        "handler": "/usr/bin/health-check-handler.sh"
+    }
+  ],
+  "telemetry": {
+     "statsite_address": "127.0.0.1:2180"
+  }
+}
+```
+
+示例配置文件，带有TLS
+
+```
+{
+  "datacenter": "east-aws",
+  "data_dir": "/opt/consul",
+  "log_level": "INFO",
+  "node_name": "foobar",
+  "server": true,
+  "addresses": {
+    "https": "0.0.0.0"
+  },
+  "ports": {
+    "https": 8080
+  },
+  "key_file": "/etc/pki/tls/private/my.key",
+  "cert_file": "/etc/pki/tls/certs/my.crt",
+  "ca_file": "/etc/pki/tls/certs/ca-bundle.crt"
+}
+```
+
+特别参见`ports`设置的使用：
+
+```
+"ports": {
+  "https": 8080
+}
+```
+
+除非为`https`端口分配了端口号，否则Consul不会为HTTP API启用TLS `> 0`。
+
+#### 服务定义
+
+服务发现的主要目标之一是提供可用服务的目录。为此，代理提供了一种简单的服务定义格式来声明服务的可用性，并可能将其与运行状况检查相关联。如果运行状况检查与服务关联，则将其视为应用程序级别。服务在配置文件中定义，或在运行时通过HTTP接口添加。 
+
+要配置服务，请将服务定义作为`-config-file`代理提供给代理，或将其置于`-config-dir`代理中。该文件必须以Consul加载的`.json`或`.hcl`扩展名结尾。可以通过向`SIGHUP`代理发送更新检查定义。或者，可以使用HTTP API动态注册服务。 
+
+服务定义是一种如下所示的配置。此示例显示了所有可能的字段，但请注意，只需要几个字段。
+
+```
+{
+  "service": {
+    "name": "redis",
+    "tags": ["primary"],
+    "address": "",
+    "meta": {
+      "meta": "for my service"
+    },
+    "port": 8000,
+    "enable_tag_override": false,
+    "checks": [
+      {
+        "args": ["/usr/local/bin/check_redis.py"],
+        "interval": "10s"
+      }
+    ],
+    "kind": "connect-proxy",
+    "proxy_destination": "redis",
+    "connect": {
+      "native": false,
+      "proxy": {
+        "command": [],
+        "config": {}
+      }
+    }
+  }
+}
+```
+
+服务定义必须包括`name`和可任选地提供 `id`，`tags`，`address`，`port`，`check`，`meta`和`enable_tag_override`。如果没有提供，`id`则设置为`name`。要求所有服务每个节点都有唯一的ID，因此如果名称可能存在冲突，则应提供唯一ID。
+
+
+
+可以使用`services`配置文件中的复数键一次提供多个服务定义 。
+
+```
+{
+  "services": [
+    {
+      "id": "red0",
+      "name": "redis",
+      "tags": [
+        "primary"
+      ],
+      "address": "",
+      "port": 6000,
+      "checks": [
+        {
+          "args": ["/bin/check_redis", "-p", "6000"],
+          "interval": "5s",
+          "ttl": "20s"
+        }
+      ]
+    },
+    {
+      "id": "red1",
+      "name": "redis",
+      "tags": [
+        "delayed",
+        "secondary"
+      ],
+      "address": "",
+      "port": 7000,
+      "checks": [
+        {
+          "args": ["/bin/check_redis", "-p", "7000"],
+          "interval": "30s",
+          "ttl": "60s"
+        }
+      ]
+    },
+    ...
+  ]
+}
+```
+
+
+
+#### 检查定义
+
+代理的主要角色之一是管理系统级和应用程序级运行状况检查。如果运行状况检查与服务关联，则将其视为应用程序级别。如果未与服务关联，则检查将监视整个节点的运行状况。
+
+检查在配置文件中定义，或在运行时通过HTTP接口添加。通过HTTP接口创建的检查将与该节点保持一致。
+
+脚本检查：
+
+```
+{
+  "check": {
+    "id": "mem-util",
+    "name": "Memory utilization",
+    "args": ["/usr/local/bin/check_mem.py", "-limit", "256MB"],
+    "interval": "10s",
+    "timeout": "1s"
+  }
+}
+```
+
+HTTP检查：
+
+```
+{
+  "check": {
+    "id": "api",
+    "name": "HTTP API on port 5000",
+    "http": "https://localhost:5000/health",
+    "tls_skip_verify": false,
+    "method": "POST",
+    "header": {"x-foo":["bar", "baz"]},
+    "interval": "10s",
+    "timeout": "1s"
+  }
+}
+```
+
+本地服务的别名检查：
+
+```
+{
+  "check": {
+    "id": "web-alias",
+    "alias_service": "web"
+  }
+}
+```
+
+
+
+### 集群搭建
+
+服务端
+
+```
+consul agent -server -bootstrap-expect=1 \
+    -data-dir=/tmp/consul -node=agent-one -bind=172.20.20.10 \
+    -enable-script-checks=true -config-dir=/etc/consul.d
+```
+
+客户端
+
+```
+consul agent -data-dir=/tmp/consul -node=agent-two \
+    -bind=172.20.20.11 -enable-script-checks=true -config-dir=/etc/consul.d
+```
+
+服务端调用 `join`将节点加入集群
+
+```
+consul join 172.20.20.11
+```
\ No newline at end of file
diff --git "a/linux/centos\346\220\255\345\273\272redis\351\233\206\347\276\244.md" "b/linux/centos\346\220\255\345\273\272redis\351\233\206\347\276\244.md"
new file mode 100644
index 0000000..19dda93
--- /dev/null
+++ "b/linux/centos\346\220\255\345\273\272redis\351\233\206\347\276\244.md"
@@ -0,0 +1,512 @@
+### 软件
+
+```
+centos-release-7-5.1804.1.el7.centos.x86_64
+Redis server v=4.0.11
+ruby 2.5.0p0 (2017-12-25 revision 61468) [x86_64-linux]
+gem 2.7.3
+```
+
+### 系统准备
+
+系统必要更新
+
+```shell
+# yum -y update 
+# yum -y upgrade
+```
+
+安装 gcc 、gcc-c++、openssl-devel
+
+```shell
+# yum install -y gcc gcc-c++ openssl-devel
+```
+
+关闭防火墙
+
+```shell
+# systemctl stop firewalld.service
+```
+
+### 安装 Ruby 及 RubyGems
+
+查看当前安装的 Ruby 及 Gems
+
+```shell
+# ruby -v
+# gem -v
+```
+
+如果出现版本号，则说明当前环境已安装过，可以跳过安装
+
+若版本太低，删除原有 Ruby
+
+```shell
+# yum remove ruby ruby-devel
+```
+
+下载需要安装的 Ruby 版本：http://cache.ruby-lang.org/pub/ruby/ 
+
+下载完成后利用 FTP 传入 Centos 机器，也可以使用如下命令下载
+
+```shell
+# wget http://cache.ruby-lang.org/pub/ruby/ruby-2.5.0.tar.gz
+```
+
+开始安装
+
+```shell
+# tar zxvf ruby-2.5.0.tar.gz
+# cd ruby-2.5.0
+# ./configure
+# make && make install
+```
+
+#### 配置 zlib 
+
+```shell
+# cd ruby-2.5.0/ext/zlib
+# ruby ./extconf.rb
+# vim Makefile 
+```
+
+更改 Makefile 中的配置
+
+```shell
+ zlib.o: $(top_srcdir)/include/ruby.h  
+ 改成   
+ zlib.o: ../../include/ruby.h
+ // 退出 vim 并保存
+ # make && make install
+```
+
+
+
+#### 配置 openssl
+
+```shell
+# cd ruby-2.5.0/ext/openssl
+# ruby ./extconf.rb
+# vim Makefile 
+```
+
+更改 Makefile 中的配置
+
+```shell
+将所有的  $(top_srcdir)
+替换为： ../..
+vim 快捷命令  :1,$s/$(top_srcdir)/..\/..
+ // 退出 vim 并保存
+# make && make install
+```
+
+安装 zlib-devel (当时忘记了这一步是否执行完全了)
+`yum install zlib-devel && rvm reinstall 2.5.1`
+
+这里提示-bash: rvm: command not found，
+然后执行 `curl -L get.rvm.io | bash -s stable`，报错为gpg: Can't check signature: No public key，
+然后执行 `gpg2 --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3`，再执行`curl -L get.rvm.io | bash -s stable`，到这里rvm安装成功！
+
+```shell
+# gpg2 --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3
+# yum install zlib-devel && rvm reinstall 2.5.1
+```
+
+更新 RubyGems 和 Bundler (可选)
+
+```shell
+# gem update --system
+# gem install bundler
+```
+
+更新老版本安装的 RubyGems
+
+```shell
+# gem update
+```
+
+安装 redis 插件
+
+```shell
+# gem install redis
+```
+
+### 安装 Redis
+
+#### 安装 Redis
+
+下载，解压，编译安装
+
+```shell
+cd /opt
+# wget http://download.redis.io/releases/redis-4.0.1.tar.gz
+# tar xzf redis-4.0.1.tar.gz
+# cd redis-4.0.1
+# make
+```
+
+如果因为上次编译失败，有残留的文件
+
+```shell
+# make distclean
+```
+
+#### 创建节点
+
+1.首先在 192.168.252.101机器上 /opt/redis-4.0.1目录下创建 `redis-cluster` 目录
+
+```shell
+# mkdir /opt/redis-4.0.1/redis-cluster
+```
+
+2.在 `redis-cluster` 目录下，创建名为`7000、7001、7002`的目录
+
+```shell
+# cd /opt/redis-4.0.1/redis-cluster
+# mkdir 7000 7001 7002
+```
+
+3.分别修改这三个配置文件，把如下`redis.conf 配置`内容粘贴进去
+
+```shell
+# vi 7000/redis.conf
+# vi 7001/redis.conf
+# vi 7002/redis.conf
+```
+
+redis.conf 配置
+
+```properties
+port 7000
+bind 192.168.252.101
+daemonize yes
+pidfile /var/run/redis_7000.pid
+cluster-enabled yes
+cluster-config-file nodes_7000.conf
+cluster-node-timeout 10100
+appendonly yes
+```
+
+redis.conf 配置说明
+
+```properties
+#端口7000,7001,7002
+port 7000
+
+#默认ip为127.0.0.1，需要改为其他节点机器可访问的ip，否则创建集群时无法访问对应的端口，无法创建集群
+bind 192.168.252.101
+
+#redis后台运行
+daemonize yes
+
+#pidfile文件对应7000，7001，7002
+pidfile /var/run/redis_7000.pid
+
+#开启集群，把注释#去掉
+cluster-enabled yes
+
+#集群的配置，配置文件首次启动自动生成 7000，7001，7002          
+cluster-config-file nodes_7000.conf
+
+#请求超时，默认15秒，可自行设置 
+cluster-node-timeout 10100    
+        
+#aof日志开启，有需要就开启，它会每次写操作都记录一条日志
+appendonly yes
+```
+
+接着在另外两台机器上(192.168.252.102，192.168.252.103)重复以上三步，只是把目录改为7003、7004、7005、7006、7007、7008对应的配置文件也按照这个规则修改即可
+
+启动集群
+
+```shell
+#第一台机器上执行 3个节点
+# for((i=0;i<=2;i++)); do /opt/redis-4.0.1/src/redis-server /opt/redis-4.0.1/redis-cluster/700$i/redis.conf; done
+
+#第二台机器上执行 3个节点
+# for((i=3;i<=5;i++)); do /opt/redis-4.0.1/src/redis-server /opt/redis-4.0.1/redis-cluster/700$i/redis.conf; done
+
+#第三台机器上执行 3个节点 
+# for((i=6;i<=8;i++)); do /opt/redis-4.0.1/src/redis-server /opt/redis-4.0.1/redis-cluster/700$i/redis.conf; done
+```
+
+#### 检查服务
+
+检查各 Redis 各个节点启动情况
+
+```shell
+# ps -ef | grep redis           //redis是否启动成功
+# netstat -tnlp | grep redis    //监听redis端口
+```
+
+#### 创建集群
+
+**注意：在任意一台上运行** 不要在每台机器上都运行，一台就够了
+
+Redis 官方提供了 `redis-trib.rb` 这个工具，就在解压目录的 src 目录中
+
+```shell
+# /opt/redis-4.0.1/src/redis-trib.rb create --replicas 1 192.168.252.101:7000192.168.252.101:7001 192.168.252.101:7002 192.168.252.102:7003 192.168.252.102:7004192.168.252.102:7005 192.168.252.103:7006 192.168.252.103:7007 192.168.252.103:7008
+```
+
+出现以下内容
+
+```
+[root@localhost redis-cluster]# /opt/redis-4.0.1/src/redis-trib.rb create --replicas 1 192.168.252.101:7000 192.168.252.101:7001 192.168.252.101:7002 192.168.252.102:7003 192.168.252.102:7004 192.168.252.102:7005 192.168.252.103:7006 192.168.252.103:7007 192.168.252.103:7008
+>>> Creating cluster
+>>> Performing hash slots allocation on 9 nodes...
+Using 4 masters:
+192.168.252.101:7000
+192.168.252.102:7003
+192.168.252.103:7006
+192.168.252.101:7001
+Adding replica 192.168.252.102:7004 to 192.168.252.101:7000
+Adding replica 192.168.252.103:7007 to 192.168.252.102:7003
+Adding replica 192.168.252.101:7002 to 192.168.252.103:7006
+Adding replica 192.168.252.102:7005 to 192.168.252.101:7001
+Adding replica 192.168.252.103:7008 to 192.168.252.101:7000
+M: 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf 192.168.252.101:7000
+   slots:0-4095 (4096 slots) master
+M: 44c81c15b01d992cb9ede4ad35477ec853d70723 192.168.252.101:7001
+   slots:12288-16383 (4096 slots) master
+S: 38f03c27af39723e1828eb62d1775c4b6e2c3638 192.168.252.101:7002
+   replicates f1abb62a8c9b448ea14db421bdfe3f1d8075189c
+M: 987965baf505a9aa43e50e46c76189c51a8f17ec 192.168.252.102:7003
+   slots:4096-8191 (4096 slots) master
+S: 6555292fed9c5d52fcf5b983c441aff6f96923d5 192.168.252.102:7004
+   replicates 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf
+S: 2b5ba254a0405d4efde4c459867b15176f79244a 192.168.252.102:7005
+   replicates 44c81c15b01d992cb9ede4ad35477ec853d70723
+M: f1abb62a8c9b448ea14db421bdfe3f1d8075189c 192.168.252.103:7006
+   slots:8192-12287 (4096 slots) master
+S: eb4067373d36d8a8df07951f92794e67a6aac022 192.168.252.103:7007
+   replicates 987965baf505a9aa43e50e46c76189c51a8f17ec
+S: 2919e041dd3d1daf176d6800dcd262f4e727f366 192.168.252.103:7008
+   replicates 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf
+Can I set the above configuration? (type 'yes' to accept): yes
+```
+
+**输入 yes**
+
+```
+>>> Nodes configuration updated
+>>> Assign a different config epoch to each node
+>>> Sending CLUSTER MEET messages to join the cluster
+Waiting for the cluster to join.........
+>>> Performing Cluster Check (using node 192.168.252.101:7000)
+M: 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf 192.168.252.101:7000
+   slots:0-4095 (4096 slots) master
+   2 additional replica(s)
+S: 6555292fed9c5d52fcf5b983c441aff6f96923d5 192.168.252.102:7004
+   slots: (0 slots) slave
+   replicates 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf
+M: 44c81c15b01d992cb9ede4ad35477ec853d70723 192.168.252.101:7001
+   slots:12288-16383 (4096 slots) master
+   1 additional replica(s)
+S: 2919e041dd3d1daf176d6800dcd262f4e727f366 192.168.252.103:7008
+   slots: (0 slots) slave
+   replicates 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf
+M: f1abb62a8c9b448ea14db421bdfe3f1d8075189c 192.168.252.103:7006
+   slots:8192-12287 (4096 slots) master
+   1 additional replica(s)
+S: eb4067373d36d8a8df07951f92794e67a6aac022 192.168.252.103:7007
+   slots: (0 slots) slave
+   replicates 987965baf505a9aa43e50e46c76189c51a8f17ec
+S: 38f03c27af39723e1828eb62d1775c4b6e2c3638 192.168.252.101:7002
+   slots: (0 slots) slave
+   replicates f1abb62a8c9b448ea14db421bdfe3f1d8075189c
+S: 2b5ba254a0405d4efde4c459867b15176f79244a 192.168.252.102:7005
+   slots: (0 slots) slave
+   replicates 44c81c15b01d992cb9ede4ad35477ec853d70723
+M: 987965baf505a9aa43e50e46c76189c51a8f17ec 192.168.252.102:7003
+   slots:4096-8191 (4096 slots) master
+   1 additional replica(s)
+[OK] All nodes agree about slots configuration.
+>>> Check for open slots...
+>>> Check slots coverage...
+[OK] All 16384 slots covered.
+```
+
+#### 关闭集群
+
+这样也可以，推荐
+
+```shell
+# pkill redis
+```
+
+循环节点逐个关闭
+
+```shell
+# for((i=0;i<=2;i++)); do /opt/redis-4.0.1/src/redis-cli -c -h 192.168.252.101 -p 700$i shutdown; done
+
+# for((i=3;i<=5;i++)); do /opt/redis-4.0.1/src/redis-cli -c -h 192.168.252.102 -p 700$i shutdown; done
+
+# for((i=6;i<=8;i++)); do /opt/redis-4.0.1/src/redis-cli -c -h 192.168.252.103 -p 700$i shutdown; done
+```
+
+#### 集群验证
+
+参数 -C 可连接到集群，因为 redis.conf 将 bind 改为了ip地址，所以 -h 参数不可以省略，-p 参数为端口号
+
+- **我们在192.168.252.101机器redis 7000 的节点set 一个key**
+
+```
+$ /opt/redis-4.0.1/src/redis-cli -h 192.168.252.101 -c -p 7000
+192.168.252.101:7000> set name www.ymq.io
+-> Redirected to slot [5798] located at 192.168.252.102:7003
+OK
+192.168.252.102:7003> get name
+"www.ymq.io"
+192.168.252.102:7003>
+```
+
+发现redis set name 之后重定向到192.168.252.102机器 redis 7003 这个节点
+
+- **我们在192.168.252.103机器redis 7008 的节点get一个key**
+
+```
+[root@localhost redis-cluster]# /opt/redis-4.0.1/src/redis-cli -h 192.168.252.103 -c -p 7008
+192.168.252.103:7008> get name
+-> Redirected to slot [5798] located at 192.168.252.102:7003
+"www.ymq.io"
+192.168.252.102:7003> 
+```
+
+发现redis get name 重定向到192.168.252.102机器 redis 7003 这个节点
+
+> 如果您看到这样的现象，说明集群已经是可用的了
+
+#### 检查集群状态
+
+```
+$ /opt/redis-4.0.1/src/redis-trib.rb check 192.168.252.101:7000
+```
+
+```
+>>> Performing Cluster Check (using node 192.168.252.101:7000)
+M: 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf 192.168.252.101:7000
+   slots:0-4095 (4096 slots) master
+   2 additional replica(s)
+S: 6555292fed9c5d52fcf5b983c441aff6f96923d5 192.168.252.102:7004
+   slots: (0 slots) slave
+   replicates 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf
+M: 44c81c15b01d992cb9ede4ad35477ec853d70723 192.168.252.101:7001
+   slots:12288-16383 (4096 slots) master
+   1 additional replica(s)
+S: 2919e041dd3d1daf176d6800dcd262f4e727f366 192.168.252.103:7008
+   slots: (0 slots) slave
+   replicates 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf
+M: f1abb62a8c9b448ea14db421bdfe3f1d8075189c 192.168.252.103:7006
+   slots:8192-12287 (4096 slots) master
+   1 additional replica(s)
+S: eb4067373d36d8a8df07951f92794e67a6aac022 192.168.252.103:7007
+   slots: (0 slots) slave
+   replicates 987965baf505a9aa43e50e46c76189c51a8f17ec
+S: 38f03c27af39723e1828eb62d1775c4b6e2c3638 192.168.252.101:7002
+   slots: (0 slots) slave
+   replicates f1abb62a8c9b448ea14db421bdfe3f1d8075189c
+S: 2b5ba254a0405d4efde4c459867b15176f79244a 192.168.252.102:7005
+   slots: (0 slots) slave
+   replicates 44c81c15b01d992cb9ede4ad35477ec853d70723
+M: 987965baf505a9aa43e50e46c76189c51a8f17ec 192.168.252.102:7003
+   slots:4096-8191 (4096 slots) master
+   1 additional replica(s)
+[OK] All nodes agree about slots configuration.
+>>> Check for open slots...
+>>> Check slots coverage...
+[OK] All 16384 slots covered.
+```
+
+#### 列出集群节点
+
+列出集群当前已知的所有节点（node），以及这些节点的相关信息
+
+```shell
+# /opt/redis-4.0.1/src/redis-cli -h 192.168.252.101 -c -p 7000
+
+192.168.252.101:7000> cluster nodes
+```
+
+```
+6555292fed9c5d52fcf5b983c441aff6f96923d5 192.168.252.102:7004@17004 slave 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf 0 1502815268317 5 connected
+44c81c15b01d992cb9ede4ad35477ec853d70723 192.168.252.101:7001@17001 master - 0 1502815268000 2 connected 12288-16383
+2919e041dd3d1daf176d6800dcd262f4e727f366 192.168.252.103:7008@17008 slave 7c622ac191edd40dd61d9b79b27f6f69d02a5bbf 0 1502815269000 9 connected
+7c622ac191edd40dd61d9b79b27f6f69d02a5bbf 192.168.252.101:7000@17000 myself,master - 0 1502815269000 1 connected 0-4095
+f1abb62a8c9b448ea14db421bdfe3f1d8075189c 192.168.252.103:7006@17006 master - 0 1502815269000 7 connected 8192-12287
+eb4067373d36d8a8df07951f92794e67a6aac022 192.168.252.103:7007@17007 slave 987965baf505a9aa43e50e46c76189c51a8f17ec 0 1502815267000 8 connected
+38f03c27af39723e1828eb62d1775c4b6e2c3638 192.168.252.101:7002@17002 slave f1abb62a8c9b448ea14db421bdfe3f1d8075189c 0 1502815269327 7 connected
+2b5ba254a0405d4efde4c459867b15176f79244a 192.168.252.102:7005@17005 slave 44c81c15b01d992cb9ede4ad35477ec853d70723 0 1502815270336 6 connected
+987965baf505a9aa43e50e46c76189c51a8f17ec 192.168.252.102:7003@17003 master - 0 1502815271345 4 connected 4096-8191
+192.168.252.101:7000> 
+```
+
+打印集群信息
+
+```
+# 192.168.252.101:7000> cluster info
+```
+
+```
+cluster_state:ok
+cluster_slots_assigned:16384
+cluster_slots_ok:16384
+cluster_slots_pfail:0
+cluster_slots_fail:0
+cluster_known_nodes:9
+cluster_size:4
+cluster_current_epoch:9
+cluster_my_epoch:1
+cluster_stats_messages_ping_sent:485
+cluster_stats_messages_pong_sent:485
+cluster_stats_messages_sent:970
+cluster_stats_messages_ping_received:477
+cluster_stats_messages_pong_received:485
+cluster_stats_messages_meet_received:8
+cluster_stats_messages_received:970
+192.168.252.101:7000> 
+```
+
+### 集群命令
+
+#### 语法格式
+
+```
+redis-cli -c -p port
+```
+
+#### 集群
+
+```
+cluster info ：打印集群的信息
+cluster nodes ：列出集群当前已知的所有节点（ node），以及这些节点的相关信息。
+```
+
+#### 节点
+
+```
+cluster meet <ip> <port> ：将 ip 和 port 所指定的节点添加到集群当中，让它成为集群的一份子。
+cluster forget <node_id> ：从集群中移除 node_id 指定的节点。
+cluster replicate <node_id> ：将当前节点设置为 node_id 指定的节点的从节点。
+cluster saveconfig ：将节点的配置文件保存到硬盘里面。
+```
+
+#### 槽(slot)
+
+```
+cluster addslots <slot> [slot ...] ：将一个或多个槽（ slot）指派（ assign）给当前节点。
+cluster delslots <slot> [slot ...] ：移除一个或多个槽对当前节点的指派。
+cluster flushslots ：移除指派给当前节点的所有槽，让当前节点变成一个没有指派任何槽的节点。
+cluster setslot <slot> node <node_id> ：将槽 slot 指派给 node_id 指定的节点，如果槽已经指派给另一个节点，那么先让另一个节点删除该槽>，然后再进行指派。
+cluster setslot <slot> migrating <node_id> ：将本节点的槽 slot 迁移到 node_id 指定的节点中。
+cluster setslot <slot> importing <node_id> ：从 node_id 指定的节点中导入槽 slot 到本节点。
+cluster setslot <slot> stable ：取消对槽 slot 的导入（ import）或者迁移（ migrate）。
+```
+
+#### 键
+
+```
+cluster keyslot <key> ：计算键 key 应该被放置在哪个槽上。
+cluster countkeysinslot <slot> ：返回槽 slot 目前包含的键值对数量。
+cluster getkeysinslot <slot> <count> ：返回 count 个 slot 槽中的键 。
+```
\ No newline at end of file
diff --git "a/linux/centos\346\220\255\345\273\272shadowsocks.md" "b/linux/centos\346\220\255\345\273\272shadowsocks.md"
new file mode 100644
index 0000000..33917fc
--- /dev/null
+++ "b/linux/centos\346\220\255\345\273\272shadowsocks.md"
@@ -0,0 +1,152 @@
+#### 安装shadowsocks
+
+1、下载安装脚本
+
+`wget --no-check-certificate -O shadowsocks-all.sh https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-all.sh`
+
+下载按成后会在当前下载目录中出现`shadowsocks-all.sh`文件，如果下载不到可以使用`./software/shadowsocks-all.sh`
+
+![下载脚本](./images/ss_1_01.jpg)
+
+2、为脚本赋予执行权限
+
+`chmod +x shadowsocks-all.sh`
+
+![添加执行权限](./images/ss_1_02.jpg)
+
+3、执行脚本
+
+`./shadowsocks-all.sh 2>&1 | tee shadowsocks-all.log`
+
+![执行脚本](./images/ss_1_03.jpg)
+
+4、出现以上画面后输入1，或者直接回车，下面会提示你输入你的SS SERVER的密码，和端口。不输入就是默认。跑完命令后会出来你的SS客户端的信息。
+
+![设置ss密码](./images/ss_1_04.jpg)
+
+![设置端口](./images/ss_1_05.jpg)
+
+5、输入完成ss的密码和端口号之后，进行回车：
+
+![选择协议](./images/ss_1_06.jpg)
+
+6、特别注意，由于iPhone端的的wingy目前只支持到**cfb**，所以我们选择**aes-256-cfb**，即**7** ，回车：
+
+![选择协议](./images/ss_1_07.jpg)
+
+7、这一步按回车继续，然后需要几分钟的安装过程，请耐心等待出现下面的画面：
+
+![选择协议](./images/ss_1_08.jpg)
+
+8、当我们看到*Congratulations, Shadowsocks-Python server install completed!*时，则证明我们已经成功安装了ss。请立即将这些信息复制下来加以保存，我们就会用到这几个比较重要的信息：主机服务器IP地址、端口号、密码和加密方式。上面的命令全部回车执行后，如果没有报错，即为执行成功，出现确认提示的时候，输入 y 后，回车即可。
+
+#### Shadowsocks设备终端下载地址
+
+[Windows版下载地址](https://github.com/shadowsocks/shadowsocks-windows/releases)
+
+[Android版下载地址](<https://github.com/shadowsocks/shadowsocks-android/releases>)
+
+[Mac版下载地址](<https://github.com/yangfeicheung/Shadowsocks-X/releases/>)
+
+**iphone**因存在限制，国内用户无法在App Store搜到，可以使用如下代替
+
+[Kite Ass Proxy](<https://itunes.apple.com/cn/app/kite-ss-proxy/id1346595633?mt=8>)
+
+[FirstWingy](<https://itunes.apple.com/cn/app/firstwingy/id1316416848?mt=8>)
+
+[SuperWingy](<https://itunes.apple.com/cn/app/superwingy/id1290093815?mt=8>)
+
+#### 优化Shadowsocks性能
+
+1、增加系统文件描述符，编辑`/etc/security/limits.conf`，新增如下两行，*不要忘记。
+
+```
+* soft nofile 51200
+* hard nofile 51200
+```
+
+2、配置`/etc/sysctl.d/local.conf`
+
+```properties
+# max open files
+fs.file-max = 1024000
+# max read buffer
+net.core.rmem_max = 67108864
+# max write buffer
+net.core.wmem_max = 67108864
+# default read buffer
+net.core.rmem_default = 65536
+# default write buffer
+net.core.wmem_default = 65536
+# max processor input queue
+net.core.netdev_max_backlog = 4096
+# max backlog
+net.core.somaxconn = 4096
+
+# resist SYN flood attacks
+net.ipv4.tcp_syncookies = 1
+# reuse timewait sockets when safe
+net.ipv4.tcp_tw_reuse = 1
+# turn off fast timewait sockets recycling
+net.ipv4.tcp_tw_recycle = 0
+# short FIN timeout
+net.ipv4.tcp_fin_timeout = 30
+# short keepalive time
+net.ipv4.tcp_keepalive_time = 1200
+# outbound port range
+net.ipv4.ip_local_port_range = 10000 65000
+# max SYN backlog
+net.ipv4.tcp_max_syn_backlog = 4096
+# max timewait sockets held by system simultaneously
+net.ipv4.tcp_max_tw_buckets = 5000
+# TCP receive buffer
+net.ipv4.tcp_rmem = 4096 87380 67108864
+# TCP write buffer
+net.ipv4.tcp_wmem = 4096 65536 67108864
+# turn on path MTU discovery
+net.ipv4.tcp_mtu_probing = 1
+
+# for high-latency network
+net.ipv4.tcp_congestion_control = hybla
+# forward ivp4
+net.ipv4.ip_forward = 1
+```
+
+2、使配置生效
+
+```sh
+sysctl --system
+```
+
+#### 配置多用户
+
+修改`/etc/shadowsocks.json`
+
+```json
+{
+ 	"server":"本机外网IP",
+	"local_address": "127.0.0.1",
+	"local_port":1080,
+	"port_password": {
+  	    "端口1": "密码1",
+        "端口2": "密码2"
+	},
+ 	"timeout":300,
+	"method":"aes-256-cfb",
+ 	"fast_open": false
+}
+
+```
+
+#### 启动、停止
+
+1. 建议使用后端启动
+   - 前端启动：`ssserver -c /etc/shadowsocks.json`；
+   - 后端启动：`ssserver -c /etc/shadowsocks.json -d start`；
+   - 停止：`ssserver -c /etc/shadowsocks.json -d stop`；
+   - 重启(修改配置要重启才生效)：`ssserver -c /etc/shadowsocks.json -d restart`
+2. 设置开机启动
+   1. 在终端输入`vi /etc/rc.local`，
+   2. 把里面最后的带有ssserver的一大段默认的代码删除掉，
+   3. 再把`ssserver -c /etc/shadowsocks.json -d start`加进去，
+   4. 按`wq`保存退出。
\ No newline at end of file
diff --git "a/linux/centos\350\256\276\347\275\256\347\275\221\347\273\234\344\273\243\347\220\206.md" "b/linux/centos\350\256\276\347\275\256\347\275\221\347\273\234\344\273\243\347\220\206.md"
new file mode 100644
index 0000000..3d43cb8
--- /dev/null
+++ "b/linux/centos\350\256\276\347\275\256\347\275\221\347\273\234\344\273\243\347\220\206.md"
@@ -0,0 +1,24 @@
+## CentOS配置网络代理
+
+### 涉及的环境变量
+
+| 环境变量    | 描述                                                         | 值示例                                                       |
+| ----------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| http_proxy  | 为http变量设置代理；默认不填开头以http协议传输               | 10.0.0.51:8080 user:pass@10.0.0.10:8080 socks4://10.0.0.51:1080 socks5://192.168.1.1:1080 |
+| https_proxy | 为https变量设置代理；                                        | 同上                                                         |
+| ftp_proxy   | 为ftp变量设置代理；                                          | 同上                                                         |
+| all_proxy   | 全部变量设置代理，设置了这个时候上面的不用设置               | 同上                                                         |
+| no_proxy    | 无需代理的主机或域名； 可以使用通配符； 多个时使用“,”号分隔； | \*.aiezu.com,10.\*.\*.\*,192.168.\*.\*, *.local,localhost,127.0.0.1 |
+
+### 修改文件
+
+`/etc/profile`
+
+```shell
+export proxy="http://ip:1080" # 这里修改为指定协议的格式
+export http_proxy=$proxy
+export https_proxy=$proxy
+export ftp_proxy=$proxy
+export no_proxy="localhost, 127.0.0.1, ::1"
+```
+
diff --git "a/linux/goflyway\350\256\277\351\227\256\345\244\226\347\275\221.md" "b/linux/goflyway\350\256\277\351\227\256\345\244\226\347\275\221.md"
new file mode 100644
index 0000000..83eacdb
--- /dev/null
+++ "b/linux/goflyway\350\256\277\351\227\256\345\244\226\347\275\221.md"
@@ -0,0 +1,164 @@
+# GoFlyWay + CDN 
+
+通过使用 GoFlyWay + CDN 的方式实现外网访问。
+
+**优点**
+
+* 隐藏个人VPN真实IP
+* 被墙的IP也可以通过这种方式救活
+
+## 前提准备
+
+* VPS 一台
+* centos7系统
+* 个人域名一个
+
+## namesilo
+
+如果已有个人域名，可以跳过这一步。
+
+### 注册账号
+
+使用浏览器访问[namesilo官网](<https://www.namesilo.com/>)，点击**Create New Account**按钮。
+
+![创建账户](./images/goflyway_1/001.png)
+
+完成**创建账户的上半部分**，部分英文解释如图：
+
+![创建账户](./images/goflyway_1/002.png)
+
+完成**创建账户的下半部分**，部分英文解释如图：
+
+![创建账户](./images/goflyway_1/003.png)
+
+页面拉倒最下方，输入验证码，同意协议后，点击**CREATE MY NEW ACCOUNT**进行注册。
+
+### 购买域名
+
+注册完成后通过首页第一步中**Create New Account**左边的**log in**登录。
+
+登录成功后按下图的**顺序点击**
+
+![创建账户](./images/goflyway_1/004.png)
+
+点击**register**【1】，在输入框中输入自己打算购买的域名【2】，点击**SEARCH**按钮【3】会弹出输入框下面的结果【4】，选择域名后缀【5】，点击**REGISTER CHECKED DOMAINS**。选择域名的过程完成。
+
+弹出购物车页面，确认个人购买信息后点击**CONTINUE**按钮。
+
+![创建账户](./images/goflyway_1/005.png)
+
+确认完成后会跳转付款页面，国内就选择支付宝，同时填写支付宝注册时的邮箱，如果没有，则填一个正在使用的邮箱，点击**GO**按钮后会进入支付宝的付款页面。扫码支付就可以了。
+
+![创建账户](./images/goflyway_1/006.png)
+
+**支付成功后，等待完成可能需要几个小时的时间，如果超过两个小时未收到订单成功的邮件，请联系在线客服**
+
+
+
+## cloudflare
+
+### 注册账号
+
+访问[cloudflare登录页面](https://dash.cloudflare.com/login)，点击**Sign up**按钮进行注册。根据网站流程进行注册账号。
+
+注册成功后，cloudflare会要求输入网站地址，如下，输入刚才购买的域名。
+
+![创建账户](./images/goflyway_1/007.png)
+
+输入完成后点击**add site**按钮，然后选择套餐，选择免费版就可以。确认方案后，Cloudflare会扫描该域名当前的DNS记录，你可以保留、添加或者删除：
+
+![创建账户](./images/goflyway_1/008.png)
+
+我们在上图的红色框中输入name和ip地址，点击**Add Record**。之后点击**Continue**就是修改**NS**了。
+
+### 配置NameServer
+
+配置**NS**需要回到**namesilo**官网。选择**Manager My Domain**【1】，并在购买的域名前打勾【2】，点击**change name servers**【3】
+
+![创建账户](./images/goflyway_1/009.png)
+
+namesilo会有三个默认的nameservers，将其删除，替换成cloudflare提供了地址，点击**COMMIT**按钮即可。首次解析域名可能需要一点时间，可以等待邮件通知。
+
+![创建账户](./images/goflyway_1/010.png)
+
+
+
+## 安装GoFlyWay服务端
+
+通过命令行工具连接主机后，执行如下命令，或者使用[离线脚本](./software/goflyway.sh)
+
+```shell
+wget -N --no-check-certificate https://raw.githubusercontent.com/ToyoDAdoubi/doubi/master/goflyway.sh && chmod +x goflyway.sh && bash goflyway.sh
+```
+
+之后输入1即可进行安装，其中**端口选择80**，HTTP伪装填写
+
+http://kernel.ubuntu.com/~kernel-ppa/mainline/
+
+**密码必须设置为：   ?c域名:端口号**
+
+例如：购买的域名为 testd.top，在cloudflare中解析的名字为 fly， 那么我们的密码应该为 :`?cfly.testd.top:80`。这样设置密码是为了安卓客户端使用。
+
+![创建账户](./images/goflyway_1/011.png)
+
+## 安装客户端
+
+### windows
+
+访问[下载GoFlyWay Tools](http://yun.iiwl.cc/s/ivmmqekw)
+
+**功能简介**：
+支持 多服务器管理
+支持 直连模式、PAC模式、全局模式
+支持 生成/导入 分享链接功能（分享链接格式）
+支持 HTTP、KCP、CDN、WebSocket 传输协议
+支持 账号自检
+支持 开机启动
+等等
+和酸酸乳shadowsocks差不多一样的。
+其他不介绍，放图和教程就行。
+
+![创建账户](./images/goflyway_1/012.png)
+
+打开之后就差不多是这样，我这个是导入了配置界面。
+其中协议一般是http，因为此节点被墙，使用了伪装，所以选择cdn。
+
+**配置**
+
+1.最简单的方法就是导入分享链接，上面仔细看就行
+2.点击浏览，选择相应位数的文件
+
+![创建账户](./images/goflyway_1/013.png)
+
+### android
+
+访问[GoFlyWay release下载apk](https://github.com/coyove/goflyway/releases)
+
+由于该apk是使用shadowsocks进行修改的，所以手机上如果安装可shadowsocks，需要先将其卸载后再安装。
+
+打开 Goflyway 安卓客户端后，可以看到一个默认的账号，因为 Goflyway 安卓客户端是基于 Shadowsocks 安卓客户端修改而来的，所以此处的默认账户实际上是 Shadowsocks 安卓客户端自带的 SS 账号，删除该账号。
+
+点击右上角的+号，选择手动配置
+
+![创建账户](./images/goflyway_1/014.png)
+
+然后依次填写 服务器、远程端口、密码 这三项即可。
+
+![创建账户](./images/goflyway_1/015.png)
+
+在该页的配置中，可以启用**分应用VPN**指定使用VPN的应用程序。
+
+
+
+## 参考
+
+[域名解析教程：Cloudflare解析与DNSPod解析](https://blog.csdn.net/wf632856695/article/details/86689607)
+
+[IP被墙怎么办？利用Goflyway+CDN救活你的被墙IP！](https://www.xiaobaidaxue.com/operation/288.html)
+
+[GoFlyway全解+让被墙IP继续“上班”](https://www.lsland.cn/Technical/453.html)
+
+[GoFlyway 基础教程Android 客户端使用方法](https://doubibackup.com/wlqx27bd.html)
+
+[GoFlyWay github 托管地址](https://github.com/coyove/goflyway)
+
diff --git a/linux/images/goflyway_1/001.png b/linux/images/goflyway_1/001.png
new file mode 100644
index 0000000..87367ed
Binary files /dev/null and b/linux/images/goflyway_1/001.png differ
diff --git a/linux/images/goflyway_1/002.png b/linux/images/goflyway_1/002.png
new file mode 100644
index 0000000..6823d1a
Binary files /dev/null and b/linux/images/goflyway_1/002.png differ
diff --git a/linux/images/goflyway_1/003.png b/linux/images/goflyway_1/003.png
new file mode 100644
index 0000000..ebc1ac8
Binary files /dev/null and b/linux/images/goflyway_1/003.png differ
diff --git a/linux/images/goflyway_1/004.png b/linux/images/goflyway_1/004.png
new file mode 100644
index 0000000..bc98529
Binary files /dev/null and b/linux/images/goflyway_1/004.png differ
diff --git a/linux/images/goflyway_1/005.png b/linux/images/goflyway_1/005.png
new file mode 100644
index 0000000..36ac0cf
Binary files /dev/null and b/linux/images/goflyway_1/005.png differ
diff --git a/linux/images/goflyway_1/006.png b/linux/images/goflyway_1/006.png
new file mode 100644
index 0000000..db208d0
Binary files /dev/null and b/linux/images/goflyway_1/006.png differ
diff --git a/linux/images/goflyway_1/007.png b/linux/images/goflyway_1/007.png
new file mode 100644
index 0000000..3b6d219
Binary files /dev/null and b/linux/images/goflyway_1/007.png differ
diff --git a/linux/images/goflyway_1/008.png b/linux/images/goflyway_1/008.png
new file mode 100644
index 0000000..2e3b1e8
Binary files /dev/null and b/linux/images/goflyway_1/008.png differ
diff --git a/linux/images/goflyway_1/009.png b/linux/images/goflyway_1/009.png
new file mode 100644
index 0000000..01c511d
Binary files /dev/null and b/linux/images/goflyway_1/009.png differ
diff --git a/linux/images/goflyway_1/010.png b/linux/images/goflyway_1/010.png
new file mode 100644
index 0000000..3e91a46
Binary files /dev/null and b/linux/images/goflyway_1/010.png differ
diff --git a/linux/images/goflyway_1/011.png b/linux/images/goflyway_1/011.png
new file mode 100644
index 0000000..45e5a96
Binary files /dev/null and b/linux/images/goflyway_1/011.png differ
diff --git a/linux/images/goflyway_1/012.png b/linux/images/goflyway_1/012.png
new file mode 100644
index 0000000..aac52d4
Binary files /dev/null and b/linux/images/goflyway_1/012.png differ
diff --git a/linux/images/goflyway_1/013.png b/linux/images/goflyway_1/013.png
new file mode 100644
index 0000000..77dcda6
Binary files /dev/null and b/linux/images/goflyway_1/013.png differ
diff --git a/linux/images/goflyway_1/014.png b/linux/images/goflyway_1/014.png
new file mode 100644
index 0000000..7eced08
Binary files /dev/null and b/linux/images/goflyway_1/014.png differ
diff --git a/linux/images/goflyway_1/015.png b/linux/images/goflyway_1/015.png
new file mode 100644
index 0000000..e51f86f
Binary files /dev/null and b/linux/images/goflyway_1/015.png differ
diff --git a/linux/images/ss_1_01.jpg b/linux/images/ss_1_01.jpg
new file mode 100644
index 0000000..4ce9cfe
Binary files /dev/null and b/linux/images/ss_1_01.jpg differ
diff --git a/linux/images/ss_1_02.jpg b/linux/images/ss_1_02.jpg
new file mode 100644
index 0000000..9720136
Binary files /dev/null and b/linux/images/ss_1_02.jpg differ
diff --git a/linux/images/ss_1_03.jpg b/linux/images/ss_1_03.jpg
new file mode 100644
index 0000000..c542096
Binary files /dev/null and b/linux/images/ss_1_03.jpg differ
diff --git a/linux/images/ss_1_04.jpg b/linux/images/ss_1_04.jpg
new file mode 100644
index 0000000..c1f0c56
Binary files /dev/null and b/linux/images/ss_1_04.jpg differ
diff --git a/linux/images/ss_1_05.jpg b/linux/images/ss_1_05.jpg
new file mode 100644
index 0000000..6f93188
Binary files /dev/null and b/linux/images/ss_1_05.jpg differ
diff --git a/linux/images/ss_1_06.jpg b/linux/images/ss_1_06.jpg
new file mode 100644
index 0000000..23cd3ab
Binary files /dev/null and b/linux/images/ss_1_06.jpg differ
diff --git a/linux/images/ss_1_07.jpg b/linux/images/ss_1_07.jpg
new file mode 100644
index 0000000..3b99407
Binary files /dev/null and b/linux/images/ss_1_07.jpg differ
diff --git a/linux/images/ss_1_08.jpg b/linux/images/ss_1_08.jpg
new file mode 100644
index 0000000..815b8b6
Binary files /dev/null and b/linux/images/ss_1_08.jpg differ
diff --git "a/linux/nginx\350\275\254\345\217\221\350\247\204\345\210\231.md" "b/linux/nginx\350\275\254\345\217\221\350\247\204\345\210\231.md"
new file mode 100644
index 0000000..bc30724
--- /dev/null
+++ "b/linux/nginx\350\275\254\345\217\221\350\247\204\345\210\231.md"
@@ -0,0 +1,36 @@
+### nginx 正则规则
+
+以=开头表示精确匹配
+如 A 中只匹配根目录结尾的请求，后面不能带任何字符串。
+^~ 开头表示uri以某个常规字符串开头，不是正则匹配
+~ 开头表示区分大小写的正则匹配;
+~* 开头表示不区分大小写的正则匹配
+/ 通用匹配, 如果没有其它匹配,任何请求都会匹配到
+
+### 匹配顺序
+  (location =) > (location 完整路径) > (location ^~) > (location ~) > (location ~*) > (location 部分路径) > (location /)
+
+### 案例
+
+```
+	# 配置反向代理
+	location / {
+	   		rewrite '^/download/([\s\S]*)' /assetes/$1;
+	        proxy_pass http://127.0.0.1:8080;
+	        root html;
+	        index index.html index.htm;
+	}
+	
+	# 将所有以 /assetes开头的资源转发到 /opt/res/assetes/目录下
+	location ^~ /assetes/ {
+	     root   /opt/res/;
+	     autoindex on;
+	}
+	
+	# 静态资源(网页静态资源使用)
+	# 忽略大小写，并且匹配后面的正则
+	location ~* \.(htm|html|gif|jpg|jpeg|png|css|js|icon)$ {
+	        root  /opt/res/web/;
+	    autoindex off;
+	}
+```
\ No newline at end of file
diff --git "a/linux/screen\345\221\275\344\273\244.md" "b/linux/screen\345\221\275\344\273\244.md"
new file mode 100644
index 0000000..7f2963a
--- /dev/null
+++ "b/linux/screen\345\221\275\344\273\244.md"
@@ -0,0 +1,37 @@
+## screen命令
+
+### 创建会话
+
+```shell
+screen -S 会话名称
+或者
+screen -R 会话名称
+```
+
+### 查看会话列表
+
+```shell
+screen -ls
+```
+
+### 恢复会话
+
+```shell
+screen -r 会话名称
+或
+screen -R 会话名称
+```
+
+**恢复失败时：**
+
+```shell
+screen -d 会话名称
+screen -r 会话名称
+```
+
+### 删除会话
+
+```shell
+screen -S 会话名称 -X quit
+```
+
diff --git a/linux/software/goflyway.sh b/linux/software/goflyway.sh
new file mode 100644
index 0000000..d320f1f
--- /dev/null
+++ b/linux/software/goflyway.sh
@@ -0,0 +1,688 @@
+#!/usr/bin/env bash
+PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
+export PATH
+
+#=================================================
+#	System Required: CentOS/Debian/Ubuntu
+#	Description: GoFlyway
+#	Version: 1.0.11
+#	Author: Toyo
+#	Blog: https://doub.io/goflyway-jc2/
+#=================================================
+
+sh_ver="1.0.11"
+filepath=$(cd "$(dirname "$0")"; pwd)
+file_1=$(echo -e "${filepath}"|awk -F "$0" '{print $1}')
+Folder="/usr/local/goflyway"
+File="/usr/local/goflyway/goflyway"
+CONF="/usr/local/goflyway/goflyway.conf"
+Now_ver_File="/usr/local/goflyway/ver.txt"
+Log_File="/usr/local/goflyway/goflyway.log"
+Crontab_file="/usr/bin/crontab"
+
+Green_font_prefix="\033[32m" && Red_font_prefix="\033[31m" && Green_background_prefix="\033[42;37m" && Red_background_prefix="\033[41;37m" && Font_color_suffix="\033[0m"
+Info="${Green_font_prefix}[信息]${Font_color_suffix}"
+Error="${Red_font_prefix}[错误]${Font_color_suffix}"
+Tip="${Green_font_prefix}[注意]${Font_color_suffix}"
+
+check_root(){
+	[[ $EUID != 0 ]] && echo -e "${Error} 当前非ROOT账号(或没有ROOT权限)，无法继续操作，请更换ROOT账号或使用 ${Green_background_prefix}sudo su${Font_color_suffix} 命令获取临时ROOT权限（执行后可能会提示输入当前账号的密码）。" && exit 1
+}
+#检查系统
+check_sys(){
+	if [[ -f /etc/redhat-release ]]; then
+		release="centos"
+	elif cat /etc/issue | grep -q -E -i "debian"; then
+		release="debian"
+	elif cat /etc/issue | grep -q -E -i "ubuntu"; then
+		release="ubuntu"
+	elif cat /etc/issue | grep -q -E -i "centos|red hat|redhat"; then
+		release="centos"
+	elif cat /proc/version | grep -q -E -i "debian"; then
+		release="debian"
+	elif cat /proc/version | grep -q -E -i "ubuntu"; then
+		release="ubuntu"
+	elif cat /proc/version | grep -q -E -i "centos|red hat|redhat"; then
+		release="centos"
+    fi
+	bit=`uname -m`
+}
+check_installed_status(){
+	[[ ! -e ${File} ]] && echo -e "${Error} GoFlyway 没有安装，请检查 !" && exit 1
+}
+check_crontab_installed_status(){
+	if [[ ! -e ${Crontab_file} ]]; then
+		echo -e "${Error} Crontab 没有安装，开始安装..."
+		if [[ ${release} == "centos" ]]; then
+			yum install crond -y
+		else
+			apt-get install cron -y
+		fi
+		if [[ ! -e ${Crontab_file} ]]; then
+			echo -e "${Error} Crontab 安装失败，请检查！" && exit 1
+		else
+			echo -e "${Info} Crontab 安装成功！"
+		fi
+	fi
+}
+check_pid(){
+	PID=$(ps -ef| grep "goflyway"| grep -v grep| grep -v "goflyway.sh"| grep -v "init.d"| grep -v "service"| awk '{print $2}')
+}
+check_new_ver(){
+	new_ver=$(wget --no-check-certificate -qO- -t1 -T3 https://api.github.com/repos/coyove/goflyway/releases| grep "tag_name"|grep -v "caddy"| head -n 1| awk -F ":" '{print $2}'| sed 's/\"//g;s/,//g;s/ //g')
+	if [[ -z ${new_ver} ]]; then
+		echo -e "${Error} GoFlyway 最新版本获取失败，请手动获取最新版本号[ https://github.com/coyove/goflyway/releases ]"
+		read -e -p "请输入版本号 [ 格式如 1.3.0a ] :" new_ver
+		[[ -z "${new_ver}" ]] && echo "取消..." && exit 1
+	else
+		echo -e "${Info} 检测到 GoFlyway 最新版本为 [ ${new_ver} ]"
+	fi
+}
+check_ver_comparison(){
+	now_ver=$(cat ${Now_ver_File})
+	[[ -z ${now_ver} ]] && echo "${new_ver}" > ${Now_ver_File}
+	if [[ ${now_ver} != ${new_ver} ]]; then
+		echo -e "${Info} 发现 GoFlyway 已有新版本 [ ${new_ver} ]，当前版本 [ ${now_ver} ]"
+		read -e -p "是否更新 ? [Y/n] :" yn
+		[[ -z "${yn}" ]] && yn="y"
+		if [[ $yn == [Yy] ]]; then
+			check_pid
+			[[ ! -z $PID ]] && kill -9 ${PID}
+			cp "${CONF}" "/tmp/goflyway.conf"
+			rm -rf ${Folder}
+			mkdir ${Folder}
+			Download_goflyway
+			mv "/tmp/goflyway.conf" "${CONF}"
+			Start_goflyway
+		fi
+	else
+		echo -e "${Info} 当前 GoFlyway 已是最新版本 [ ${new_ver} ]" && exit 1
+	fi
+}
+Download_goflyway(){
+	cd ${Folder}
+	if [[ ${bit} == "x86_64" ]]; then
+		wget --no-check-certificate -N "https://github.com/coyove/goflyway/releases/download/${new_ver}/goflyway_linux_amd64.tar.gz"
+		mv goflyway_linux_amd64.tar.gz goflyway_linux.tar.gz
+	else
+		wget --no-check-certificate -N "https://github.com/coyove/goflyway/releases/download/${new_ver}/goflyway_linux_386.tar.gz"
+		mv goflyway_linux_386.tar.gz goflyway_linux.tar.gz
+	fi
+	[[ ! -e "goflyway_linux.tar.gz" ]] && echo -e "${Error} GoFlyway 下载失败 !" && exit 1
+	tar -xzf goflyway_linux.tar.gz
+	[[ ! -e "goflyway" ]] && echo -e "${Error} GoFlyway 解压失败 !" && rm -f goflyway_linux.tar.gz && exit 1
+	rm -f goflyway_linux.tar.gz
+	chmod +x goflyway
+	./goflyway -gen-ca
+	echo "${new_ver}" > ${Now_ver_File}
+}
+Service_goflyway(){
+	if [[ ${release} = "centos" ]]; then
+		if ! wget --no-check-certificate https://raw.githubusercontent.com/ToyoDAdoubi/doubi/master/service/goflyway_centos -O /etc/init.d/goflyway; then
+			echo -e "${Error} GoFlyway 服务管理脚本下载失败 !" && exit 1
+		fi
+		chmod +x /etc/init.d/goflyway
+		chkconfig --add goflyway
+		chkconfig goflyway on
+	else
+		if ! wget --no-check-certificate https://raw.githubusercontent.com/ToyoDAdoubi/doubi/master/service/goflyway_debian -O /etc/init.d/goflyway; then
+			echo -e "${Error} GoFlyway 服务管理脚本下载失败 !" && exit 1
+		fi
+		chmod +x /etc/init.d/goflyway
+		update-rc.d -f goflyway defaults
+	fi
+	echo -e "${Info} GoFlyway 服务管理脚本下载完成 !"
+}
+Installation_dependency(){
+	mkdir ${Folder}
+}
+Write_config(){
+	cat > ${CONF}<<-EOF
+port=${new_port}
+passwd=${new_passwd}
+protocol=${new_protocol}
+proxy_pass=${new_proxy_pass}
+EOF
+}
+Read_config(){
+	[[ ! -e ${CONF} ]] && echo -e "${Error} GoFlyway 配置文件不存在 !" && exit 1
+	port=$(cat ${CONF}|grep "port"|awk -F "=" '{print $NF}')
+	passwd=$(cat ${CONF}|grep "passwd"|awk -F "=" '{print $NF}')
+	proxy_pass=$(cat ${CONF}|grep "proxy_pass"|awk -F "=" '{print $NF}')
+	protocol=$(cat ${CONF}|grep "protocol"|awk -F "=" '{print $NF}')
+	if [[ -z "${protocol}" ]]; then
+		protocol="http"
+		new_protocol="http"
+		new_port="${port}"
+		new_passwd="${passwd}"
+		new_proxy_pass="${proxy_pass}"
+		Write_config
+	fi
+}
+Set_port(){
+	while true
+		do
+		echo -e "请输入 GoFlyway 监听端口 [1-65535]（如果要伪装或者套CDN，那么只能使用端口：80 8080 8880 2052 2082 2086 2095）"
+		read -e -p "(默认: 8880):" new_port
+		[[ -z "${new_port}" ]] && new_port="8880"
+		echo $((${new_port}+0)) &>/dev/null
+		if [[ $? -eq 0 ]]; then
+			if [[ ${new_port} -ge 1 ]] && [[ ${new_port} -le 65535 ]]; then
+				echo && echo "========================"
+				echo -e "	端口 : ${Red_background_prefix} ${new_port} ${Font_color_suffix}"
+				echo "========================" && echo
+				break
+			else
+				echo "输入错误, 请输入正确的端口。"
+			fi
+		else
+			echo "输入错误, 请输入正确的端口。"
+		fi
+		done
+}
+Set_passwd(){
+	echo "请输入 GoFlyway 密码"
+	read -e -p "(默认: doub.io):" new_passwd
+	[[ -z "${new_passwd}" ]] && new_passwd="doub.io"
+	echo && echo "========================"
+	echo -e "	密码 : ${Red_background_prefix} ${new_passwd} ${Font_color_suffix}"
+	echo "========================" && echo
+}
+Set_proxy_pass(){
+	echo "请输入 GoFlyway 要伪装的网站(反向代理，只支持 HTTP:// 网站)"
+	read -e -p "(默认不伪装):" new_proxy_pass
+	if [[ ! -z ${new_proxy_pass} ]]; then
+		echo && echo "========================"
+		echo -e "	伪装 : ${Red_background_prefix} ${new_proxy_pass} ${Font_color_suffix}"
+		echo "========================" && echo
+	fi
+}
+Set_protocol(){
+	echo -e "请选择 GoFlyway 传输协议
+	
+ ${Green_font_prefix}1.${Font_color_suffix} HTTP (默认，要使用 CDN、WebSocket 则必须选择 HTTP 协议)
+ ${Green_font_prefix}2.${Font_color_suffix} KCP  (将 TCP 数据转为 KCP，并通过UDP方式传输，可复活被TCP阻断的IP)
+ ${Tip} 如果使用 KCP 协议，那么将不能使用 CDN、WebSocket。另外，部分地区对海外的UDP链接会QOS限速，这可能导致 KCP 协议速度不理想。" && echo
+	read -e -p "(默认: 1. HTTP):" new_protocol
+	[[ -z "${new_protocol}" ]] && new_protocol="3"
+	if [[ ${new_protocol} == "1" ]]; then
+		new_protocol="http"
+	elif [[ ${new_protocol} == "2" ]]; then
+		new_protocol="kcp"
+	else
+		new_protocol="http"
+	fi
+	echo && echo "========================"
+	echo -e "	协议 : ${Red_background_prefix} ${new_protocol^^} ${Font_color_suffix}"
+	echo "========================" && echo
+}
+Set_conf(){
+	Set_port
+	Set_passwd
+	Set_protocol
+	Set_proxy_pass
+}
+Modify_port(){
+	Read_config
+	Set_port
+	new_passwd="${passwd}"
+	new_proxy_pass="${proxy_pass}"
+	new_protocol="${protocol}"
+	Del_iptables
+	Write_config
+	Add_iptables
+	Save_iptables
+	Restart_goflyway
+}
+Modify_passwd(){
+	Read_config
+	Set_passwd
+	new_port="${port}"
+	new_proxy_pass="${proxy_pass}"
+	new_protocol="${protocol}"
+	Write_config
+	Restart_goflyway
+}
+Modify_proxy_pass(){
+	Read_config
+	Set_proxy_pass
+	new_port="${port}"
+	new_passwd="${passwd}"
+	new_protocol="${protocol}"
+	Write_config
+	Restart_goflyway
+}
+Modify_protocol(){
+	Read_config
+	Set_protocol
+	new_port="${port}"
+	new_passwd="${passwd}"
+	new_proxy_pass="${proxy_pass}"
+	Write_config
+	Restart_goflyway
+}
+Modify_all(){
+	Read_config
+	Set_conf
+	Del_iptables
+	Write_config
+	Add_iptables
+	Save_iptables
+	Restart_goflyway
+}
+Set_goflyway(){
+	check_installed_status
+	echo && echo -e "你要做什么？
+ ${Green_font_prefix}1.${Font_color_suffix}  修改 端口配置
+ ${Green_font_prefix}2.${Font_color_suffix}  修改 密码配置
+ ${Green_font_prefix}3.${Font_color_suffix}  修改 传输协议
+ ${Green_font_prefix}4.${Font_color_suffix}  修改 伪装配置(反向代理)
+ ${Green_font_prefix}5.${Font_color_suffix}  修改 全部配置
+————————————————
+ ${Green_font_prefix}6.${Font_color_suffix}  监控 运行状态
+ 
+ ${Tip} 用户的端口是不能重复的，密码可以重复 !" && echo
+	read -e -p "(默认: 取消):" gf_modify
+	[[ -z "${gf_modify}" ]] && echo "已取消..." && exit 1
+	if [[ ${gf_modify} == "1" ]]; then
+		Modify_port
+	elif [[ ${gf_modify} == "2" ]]; then
+		Modify_passwd
+	elif [[ ${gf_modify} == "3" ]]; then
+		Modify_protocol
+	elif [[ ${gf_modify} == "4" ]]; then
+		Modify_proxy_pass
+	elif [[ ${gf_modify} == "5" ]]; then
+		Modify_all
+	elif [[ ${gf_modify} == "6" ]]; then
+		Set_crontab_monitor_goflyway
+	else
+		echo -e "${Error} 请输入正确的数字(1-6)" && exit 1
+	fi
+}
+Install_goflyway(){
+	check_root
+	[[ -e ${File} ]] && echo -e "${Error} 检测到 GoFlyway 已安装 !" && exit 1
+	echo -e "${Info} 开始设置 用户配置..."
+	Set_conf
+	echo -e "${Info} 开始安装/配置 依赖..."
+	Installation_dependency
+	echo -e "${Info} 开始检测最新版本..."
+	check_new_ver
+	echo -e "${Info} 开始下载/安装..."
+	Download_goflyway
+	echo -e "${Info} 开始下载/安装 服务脚本(init)..."
+	Service_goflyway
+	echo -e "${Info} 开始写入 配置文件..."
+	Write_config
+	echo -e "${Info} 开始设置 iptables防火墙..."
+	Set_iptables
+	echo -e "${Info} 开始添加 iptables防火墙规则..."
+	Add_iptables
+	echo -e "${Info} 开始保存 iptables防火墙规则..."
+	Save_iptables
+	echo -e "${Info} 所有步骤 安装完毕，开始启动..."
+	Start_goflyway
+}
+Start_goflyway(){
+	check_installed_status
+	check_pid
+	[[ ! -z ${PID} ]] && echo -e "${Error} GoFlyway 正在运行，请检查 !" && exit 1
+	/etc/init.d/goflyway start
+	sleep 1s
+	check_pid
+	[[ ! -z ${PID} ]] && View_goflyway
+}
+Stop_goflyway(){
+	check_installed_status
+	check_pid
+	[[ -z ${PID} ]] && echo -e "${Error} GoFlyway 没有运行，请检查 !" && exit 1
+	/etc/init.d/goflyway stop
+}
+Restart_goflyway(){
+	check_installed_status
+	check_pid
+	[[ ! -z ${PID} ]] && /etc/init.d/goflyway stop
+	/etc/init.d/goflyway start
+	sleep 1s
+	check_pid
+	[[ ! -z ${PID} ]] && View_goflyway
+}
+Update_goflyway(){
+	check_installed_status
+	check_new_ver
+	check_ver_comparison
+}
+Uninstall_goflyway(){
+	check_installed_status
+	echo "确定要卸载 GoFlyway ? (y/N)"
+	echo
+	read -e -p "(默认: n):" unyn
+	[[ -z ${unyn} ]] && unyn="n"
+	if [[ ${unyn} == [Yy] ]]; then
+		check_pid
+		[[ ! -z $PID ]] && kill -9 ${PID}
+		Read_config
+		Del_iptables
+		Save_iptables
+		rm -rf ${Folder}
+		if [[ ${release} = "centos" ]]; then
+			chkconfig --del goflyway
+		else
+			update-rc.d -f goflyway remove
+		fi
+		rm -rf /etc/init.d/goflyway
+		echo && echo "GoFlyway 卸载完成 !" && echo
+	else
+		echo && echo "卸载已取消..." && echo
+	fi
+}
+View_goflyway(){
+	check_installed_status
+	Read_config
+	ip=$(wget -qO- -t1 -T2 ipinfo.io/ip)
+	if [[ -z "${ip}" ]]; then
+		ip=$(wget -qO- -t1 -T2 api.ip.sb/ip)
+		if [[ -z "${ip}" ]]; then
+			ip=$(wget -qO- -t1 -T2 members.3322.org/dyndns/getip)
+			if [[ -z "${ip}" ]]; then
+				ip="VPS_IP"
+			fi
+		fi
+	fi
+	[[ -z ${proxy_pass} ]] && proxy_pass="无"
+	link_qr
+	clear && echo "————————————————" && echo
+	echo -e " GoFlyway 信息 :" && echo
+	echo -e " 地址\t: ${Green_font_prefix}${ip}${Font_color_suffix}"
+	echo -e " 端口\t: ${Green_font_prefix}${port}${Font_color_suffix}"
+	echo -e " 密码\t: ${Green_font_prefix}${passwd}${Font_color_suffix}"
+	echo -e " 协议\t: ${Green_font_prefix}${protocol^^}${Font_color_suffix}"
+	echo -e " 伪装\t: ${Green_font_prefix}${proxy_pass}${Font_color_suffix}"
+	echo -e "${link}"
+	echo -e "${Tip} 链接仅适用于Windows系统的 Goflyway Tools 客户端（https://doub.io/dbrj-11/）。"
+	echo && echo "————————————————"
+}
+urlsafe_base64(){
+	date=$(echo -n "$1"|base64|sed ':a;N;s/\n//g;ta'|sed 's/=//g;s/+/-/g;s/\//_/g')
+	echo -e "${date}"
+}
+link_qr(){
+	PWDbase64=$(urlsafe_base64 "${passwd}")
+	base64=$(urlsafe_base64 "${ip}:${port}@${PWDbase64}:${protocol}")
+	url="goflyway://${base64}"
+	QRcode="http://doub.pw/qr/qr.php?text=${url}"
+	link=" 链接\t: ${Red_font_prefix}${url}${Font_color_suffix} \n 二维码 : ${Red_font_prefix}${QRcode}${Font_color_suffix} \n "
+}
+View_Log(){
+	check_installed_status
+	[[ ! -e ${Log_File} ]] && echo -e "${Error} GoFlyway 日志文件不存在 !" && exit 1
+	echo && echo -e "${Tip} 按 ${Red_font_prefix}Ctrl+C${Font_color_suffix} 终止查看日志" && echo -e "如果需要查看完整日志内容，请用 ${Red_font_prefix}cat ${Log_File}${Font_color_suffix} 命令。" && echo
+	tail -f ${Log_File}
+}
+# 显示 连接信息
+debian_View_user_connection_info(){
+	format_1=$1
+	Read_config
+	user_port=${port}
+	user_IP_1=$(netstat -anp |grep 'ESTABLISHED' |grep 'goflyway' |grep 'tcp6' |grep ":${user_port} " |awk '{print $5}' |awk -F ":" '{print $1}' |sort -u |grep -E -o "([0-9]{1,3}[\.]){3}[0-9]{1,3}")
+	if [[ -z ${user_IP_1} ]]; then
+		user_IP_total="0"
+		echo -e "端口: ${Green_font_prefix}"${user_port}"${Font_color_suffix}\t 链接IP总数: ${Green_font_prefix}"${user_IP_total}"${Font_color_suffix}\t 当前链接IP: "
+	else
+		user_IP_total=`echo -e "${user_IP_1}"|wc -l`
+		if [[ ${format_1} == "IP_address" ]]; then
+			echo -e "端口: ${Green_font_prefix}"${user_port}"${Font_color_suffix}\t 链接IP总数: ${Green_font_prefix}"${user_IP_total}"${Font_color_suffix}\t 当前链接IP: "
+			get_IP_address
+			echo
+		else
+			user_IP=$(echo -e "\n${user_IP_1}")
+			echo -e "端口: ${Green_font_prefix}"${user_port}"${Font_color_suffix}\t 链接IP总数: ${Green_font_prefix}"${user_IP_total}"${Font_color_suffix}\t 当前链接IP: ${Green_font_prefix}${user_IP}${Font_color_suffix}\n"
+		fi
+	fi
+	user_IP=""
+}
+centos_View_user_connection_info(){
+	format_1=$1
+	Read_config
+	user_port=${port}
+	user_IP_1=`netstat -anp |grep 'ESTABLISHED' |grep 'goflyway' |grep 'tcp' |grep ":${user_port} "|grep '::ffff:' |awk '{print $5}' |awk -F ":" '{print $4}' |sort -u |grep -E -o "([0-9]{1,3}[\.]){3}[0-9]{1,3}"`
+	if [[ -z ${user_IP_1} ]]; then
+		user_IP_total="0"
+		echo -e "端口: ${Green_font_prefix}"${user_port}"${Font_color_suffix}\t 链接IP总数: ${Green_font_prefix}"${user_IP_total}"${Font_color_suffix}\t 当前链接IP: "
+	else
+		user_IP_total=`echo -e "${user_IP_1}"|wc -l`
+		if [[ ${format_1} == "IP_address" ]]; then
+			echo -e "端口: ${Green_font_prefix}"${user_port}"${Font_color_suffix}\t 链接IP总数: ${Green_font_prefix}"${user_IP_total}"${Font_color_suffix}\t 当前链接IP: "
+			get_IP_address
+			echo
+		else
+			user_IP=$(echo -e "\n${user_IP_1}")
+			echo -e "端口: ${Green_font_prefix}"${user_port}"${Font_color_suffix}\t 链接IP总数: ${Green_font_prefix}"${user_IP_total}"${Font_color_suffix}\t 当前链接IP: ${Green_font_prefix}${user_IP}${Font_color_suffix}\n"
+		fi
+	fi
+	user_IP=""
+}
+View_user_connection_info(){
+	check_installed_status
+	echo && echo -e "请选择要显示的格式：
+ ${Green_font_prefix}1.${Font_color_suffix} 显示 IP 格式
+ ${Green_font_prefix}2.${Font_color_suffix} 显示 IP+IP归属地 格式" && echo
+	read -e -p "(默认: 1):" goflyway_connection_info
+	[[ -z "${goflyway_connection_info}" ]] && goflyway_connection_info="1"
+	if [[ "${goflyway_connection_info}" == "1" ]]; then
+		View_user_connection_info_1 ""
+	elif [[ "${goflyway_connection_info}" == "2" ]]; then
+		echo -e "${Tip} 检测IP归属地(ipip.net)，如果IP较多，可能时间会比较长..."
+		View_user_connection_info_1 "IP_address"
+	else
+		echo -e "${Error} 请输入正确的数字(1-2)" && exit 1
+	fi
+}
+View_user_connection_info_1(){
+	format=$1
+	if [[ ${release} = "centos" ]]; then
+		cat /etc/redhat-release |grep 7\..*|grep -i centos>/dev/null
+		if [[ $? = 0 ]]; then
+			debian_View_user_connection_info "$format"
+		else
+			centos_View_user_connection_info "$format"
+		fi
+	else
+		debian_View_user_connection_info "$format"
+	fi
+}
+get_IP_address(){
+	#echo "user_IP_1=${user_IP_1}"
+	if [[ ! -z ${user_IP_1} ]]; then
+	#echo "user_IP_total=${user_IP_total}"
+		for((integer_1 = ${user_IP_total}; integer_1 >= 1; integer_1--))
+		do
+			IP=$(echo "${user_IP_1}" |sed -n "$integer_1"p)
+			#echo "IP=${IP}"
+			IP_address=$(wget -qO- -t1 -T2 http://freeapi.ipip.net/${IP}|sed 's/\"//g;s/,//g;s/\[//g;s/\]//g')
+			#echo "IP_address=${IP_address}"
+			#user_IP="${user_IP}\n${IP}(${IP_address})"
+			echo -e "${Green_font_prefix}${IP}${Font_color_suffix} (${IP_address})"
+			#echo "user_IP=${user_IP}"
+			sleep 1s
+		done
+	fi
+}
+Set_crontab_monitor_goflyway(){
+	check_crontab_installed_status
+	crontab_monitor_goflyway_status=$(crontab -l|grep "goflyway.sh monitor")
+	if [[ -z "${crontab_monitor_goflyway_status}" ]]; then
+		echo && echo -e "当前监控模式: ${Green_font_prefix}未开启${Font_color_suffix}" && echo
+		echo -e "确定要开启 ${Green_font_prefix}Goflyway 服务端运行状态监控${Font_color_suffix} 功能吗？(当进程关闭则自动启动 Goflyway 服务端)[Y/n]"
+		read -e -p "(默认: y):" crontab_monitor_goflyway_status_ny
+		[[ -z "${crontab_monitor_goflyway_status_ny}" ]] && crontab_monitor_goflyway_status_ny="y"
+		if [[ ${crontab_monitor_goflyway_status_ny} == [Yy] ]]; then
+			crontab_monitor_goflyway_cron_start
+		else
+			echo && echo "	已取消..." && echo
+		fi
+	else
+		echo && echo -e "当前监控模式: ${Green_font_prefix}已开启${Font_color_suffix}" && echo
+		echo -e "确定要关闭 ${Green_font_prefix}Goflyway 服务端运行状态监控${Font_color_suffix} 功能吗？(当进程关闭则自动启动 Goflyway 服务端)[y/N]"
+		read -e -p "(默认: n):" crontab_monitor_goflyway_status_ny
+		[[ -z "${crontab_monitor_goflyway_status_ny}" ]] && crontab_monitor_goflyway_status_ny="n"
+		if [[ ${crontab_monitor_goflyway_status_ny} == [Yy] ]]; then
+			crontab_monitor_goflyway_cron_stop
+		else
+			echo && echo "	已取消..." && echo
+		fi
+	fi
+}
+crontab_monitor_goflyway_cron_start(){
+	crontab -l > "$file_1/crontab.bak"
+	sed -i "/goflyway.sh monitor/d" "$file_1/crontab.bak"
+	echo -e "\n* * * * * /bin/bash $file_1/goflyway.sh monitor" >> "$file_1/crontab.bak"
+	crontab "$file_1/crontab.bak"
+	rm -r "$file_1/crontab.bak"
+	cron_config=$(crontab -l | grep "goflyway.sh monitor")
+	if [[ -z ${cron_config} ]]; then
+		echo -e "${Error} Goflyway 服务端运行状态监控功能 启动失败 !" && exit 1
+	else
+		echo -e "${Info} Goflyway 服务端运行状态监控功能 启动成功 !"
+	fi
+}
+crontab_monitor_goflyway_cron_stop(){
+	crontab -l > "$file_1/crontab.bak"
+	sed -i "/goflyway.sh monitor/d" "$file_1/crontab.bak"
+	crontab "$file_1/crontab.bak"
+	rm -r "$file_1/crontab.bak"
+	cron_config=$(crontab -l | grep "goflyway.sh monitor")
+	if [[ ! -z ${cron_config} ]]; then
+		echo -e "${Error} Goflyway 服务端运行状态监控功能 停止失败 !" && exit 1
+	else
+		echo -e "${Info} Goflyway 服务端运行状态监控功能 停止成功 !"
+	fi
+}
+crontab_monitor_goflyway(){
+	check_installed_status
+	check_pid
+	echo "${PID}"
+	if [[ -z ${PID} ]]; then
+		echo -e "${Error} [$(date "+%Y-%m-%d %H:%M:%S %u %Z")] 检测到 Goflyway服务端 未运行 , 开始启动..." | tee -a ${Log_File}
+		/etc/init.d/goflyway start
+		sleep 1s
+		check_pid
+		if [[ -z ${PID} ]]; then
+			echo -e "${Error} [$(date "+%Y-%m-%d %H:%M:%S %u %Z")] Goflyway服务端 启动失败..." | tee -a ${Log_File}
+		else
+			echo -e "${Info} [$(date "+%Y-%m-%d %H:%M:%S %u %Z")] Goflyway服务端 启动成功..." | tee -a ${Log_File}
+		fi
+	else
+		echo -e "${Info} [$(date "+%Y-%m-%d %H:%M:%S %u %Z")] Goflyway服务端 进程运行正常..." | tee -a ${Log_File}
+	fi
+}
+Add_iptables(){
+	iptables -I INPUT -m state --state NEW -m tcp -p tcp --dport ${new_port} -j ACCEPT
+	iptables -I INPUT -m state --state NEW -m udp -p udp --dport ${new_port} -j ACCEPT
+}
+Del_iptables(){
+	iptables -D INPUT -m state --state NEW -m tcp -p tcp --dport ${port} -j ACCEPT
+	iptables -D INPUT -m state --state NEW -m udp -p udp --dport ${port} -j ACCEPT
+}
+Save_iptables(){
+	if [[ ${release} == "centos" ]]; then
+		service iptables save
+	else
+		iptables-save > /etc/iptables.up.rules
+	fi
+}
+Set_iptables(){
+	if [[ ${release} == "centos" ]]; then
+		service iptables save
+		chkconfig --level 2345 iptables on
+	else
+		iptables-save > /etc/iptables.up.rules
+		echo -e '#!/bin/bash\n/sbin/iptables-restore < /etc/iptables.up.rules' > /etc/network/if-pre-up.d/iptables
+		chmod +x /etc/network/if-pre-up.d/iptables
+	fi
+}
+Update_Shell(){
+	sh_new_ver=$(wget --no-check-certificate -qO- -t1 -T3 "https://raw.githubusercontent.com/ToyoDAdoubi/doubi/master/goflyway.sh"|grep 'sh_ver="'|awk -F "=" '{print $NF}'|sed 's/\"//g'|head -1) && sh_new_type="github"
+	[[ -z ${sh_new_ver} ]] && echo -e "${Error} 无法链接到 Github !" && exit 0
+	if [[ -e "/etc/init.d/goflyway" ]]; then
+		rm -rf /etc/init.d/goflyway
+		Service_goflyway
+	fi
+	wget -N --no-check-certificate "https://raw.githubusercontent.com/ToyoDAdoubi/doubi/master/goflyway.sh" && chmod +x goflyway.sh
+	echo -e "脚本已更新为最新版本[ ${sh_new_ver} ] !(注意：因为更新方式为直接覆盖当前运行的脚本，所以可能下面会提示一些报错，无视即可)" && exit 0
+}
+check_sys
+action=$1
+if [[ "${action}" == "monitor" ]]; then
+	crontab_monitor_goflyway
+else
+echo && echo -e "  GoFlyway 一键管理脚本 ${Red_font_prefix}[v${sh_ver}]${Font_color_suffix}
+  -- Toyo | doub.io/goflyway-jc2 --
+  
+ ${Green_font_prefix} 0.${Font_color_suffix} 升级脚本
+————————————
+ ${Green_font_prefix} 1.${Font_color_suffix} 安装 GoFlyway
+ ${Green_font_prefix} 2.${Font_color_suffix} 升级 GoFlyway
+ ${Green_font_prefix} 3.${Font_color_suffix} 卸载 GoFlyway
+————————————
+ ${Green_font_prefix} 4.${Font_color_suffix} 启动 GoFlyway
+ ${Green_font_prefix} 5.${Font_color_suffix} 停止 GoFlyway
+ ${Green_font_prefix} 6.${Font_color_suffix} 重启 GoFlyway
+————————————
+ ${Green_font_prefix} 7.${Font_color_suffix} 设置 账号配置
+ ${Green_font_prefix} 8.${Font_color_suffix} 查看 账号信息
+ ${Green_font_prefix} 9.${Font_color_suffix} 查看 日志信息
+ ${Green_font_prefix}10.${Font_color_suffix} 查看 链接信息
+————————————" && echo
+if [[ -e ${File} ]]; then
+	check_pid
+	if [[ ! -z "${PID}" ]]; then
+		echo -e " 当前状态: ${Green_font_prefix}已安装${Font_color_suffix} 并 ${Green_font_prefix}已启动${Font_color_suffix}"
+	else
+		echo -e " 当前状态: ${Green_font_prefix}已安装${Font_color_suffix} 但 ${Red_font_prefix}未启动${Font_color_suffix}"
+	fi
+else
+	echo -e " 当前状态: ${Red_font_prefix}未安装${Font_color_suffix}"
+fi
+echo
+read -e -p " 请输入数字 [0-10]:" num
+case "$num" in
+	0)
+	Update_Shell
+	;;
+	1)
+	Install_goflyway
+	;;
+	2)
+	Update_goflyway
+	;;
+	3)
+	Uninstall_goflyway
+	;;
+	4)
+	Start_goflyway
+	;;
+	5)
+	Stop_goflyway
+	;;
+	6)
+	Restart_goflyway
+	;;
+	7)
+	Set_goflyway
+	;;
+	8)
+	View_goflyway
+	;;
+	9)
+	View_Log
+	;;
+	10)
+	View_user_connection_info
+	;;
+	*)
+	echo "请输入正确数字 [0-10]"
+	;;
+esac
+fi
\ No newline at end of file
diff --git a/linux/software/shadowsocks-all.sh b/linux/software/shadowsocks-all.sh
new file mode 100644
index 0000000..3a7adc6
--- /dev/null
+++ b/linux/software/shadowsocks-all.sh
@@ -0,0 +1,1383 @@
+#!/usr/bin/env bash
+PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
+export PATH
+#
+# Auto install Shadowsocks Server (all version)
+#
+# Copyright (C) 2016-2019 Teddysun <i@teddysun.com>
+#
+# System Required:  CentOS 6+, Debian7+, Ubuntu12+
+#
+# Reference URL:
+# https://github.com/shadowsocks/shadowsocks
+# https://github.com/shadowsocks/shadowsocks-go
+# https://github.com/shadowsocks/shadowsocks-libev
+# https://github.com/shadowsocks/shadowsocks-windows
+# https://github.com/shadowsocksr-rm/shadowsocksr
+# https://github.com/shadowsocksrr/shadowsocksr
+# https://github.com/shadowsocksrr/shadowsocksr-csharp
+#
+# Thanks:
+# @clowwindy  <https://twitter.com/clowwindy>
+# @breakwa11  <https://twitter.com/breakwa11>
+# @cyfdecyf   <https://twitter.com/cyfdecyf>
+# @madeye     <https://github.com/madeye>
+# @linusyang  <https://github.com/linusyang>
+# @Akkariiin  <https://github.com/Akkariiin>
+# 
+# Intro:  https://teddysun.com/486.html
+
+red='\033[0;31m'
+green='\033[0;32m'
+yellow='\033[0;33m'
+plain='\033[0m'
+
+[[ $EUID -ne 0 ]] && echo -e "[${red}Error${plain}] This script must be run as root!" && exit 1
+
+cur_dir=$( pwd )
+software=(Shadowsocks-Python ShadowsocksR Shadowsocks-Go Shadowsocks-libev)
+
+libsodium_file="libsodium-1.0.17"
+libsodium_url="https://github.com/jedisct1/libsodium/releases/download/1.0.17/libsodium-1.0.17.tar.gz"
+
+mbedtls_file="mbedtls-2.16.0"
+mbedtls_url="https://tls.mbed.org/download/mbedtls-2.16.0-gpl.tgz"
+
+shadowsocks_python_file="shadowsocks-master"
+shadowsocks_python_url="https://github.com/shadowsocks/shadowsocks/archive/master.zip"
+shadowsocks_python_init="/etc/init.d/shadowsocks-python"
+shadowsocks_python_config="/etc/shadowsocks-python/config.json"
+shadowsocks_python_centos="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks"
+shadowsocks_python_debian="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-debian"
+
+shadowsocks_r_file="shadowsocksr-3.2.2"
+shadowsocks_r_url="https://github.com/shadowsocksrr/shadowsocksr/archive/3.2.2.tar.gz"
+shadowsocks_r_init="/etc/init.d/shadowsocks-r"
+shadowsocks_r_config="/etc/shadowsocks-r/config.json"
+shadowsocks_r_centos="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocksR"
+shadowsocks_r_debian="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocksR-debian"
+
+shadowsocks_go_file_64="shadowsocks-server-linux64-1.2.2"
+shadowsocks_go_url_64="https://dl.lamp.sh/shadowsocks/shadowsocks-server-linux64-1.2.2.gz"
+shadowsocks_go_file_32="shadowsocks-server-linux32-1.2.2"
+shadowsocks_go_url_32="https://dl.lamp.sh/shadowsocks/shadowsocks-server-linux32-1.2.2.gz"
+shadowsocks_go_init="/etc/init.d/shadowsocks-go"
+shadowsocks_go_config="/etc/shadowsocks-go/config.json"
+shadowsocks_go_centos="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-go"
+shadowsocks_go_debian="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-go-debian"
+
+shadowsocks_libev_init="/etc/init.d/shadowsocks-libev"
+shadowsocks_libev_config="/etc/shadowsocks-libev/config.json"
+shadowsocks_libev_centos="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-libev"
+shadowsocks_libev_debian="https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks-libev-debian"
+
+# Stream Ciphers
+common_ciphers=(
+aes-256-gcm
+aes-192-gcm
+aes-128-gcm
+aes-256-ctr
+aes-192-ctr
+aes-128-ctr
+aes-256-cfb
+aes-192-cfb
+aes-128-cfb
+camellia-128-cfb
+camellia-192-cfb
+camellia-256-cfb
+xchacha20-ietf-poly1305
+chacha20-ietf-poly1305
+chacha20-ietf
+chacha20
+salsa20
+rc4-md5
+)
+go_ciphers=(
+aes-256-cfb
+aes-192-cfb
+aes-128-cfb
+aes-256-ctr
+aes-192-ctr
+aes-128-ctr
+chacha20-ietf
+chacha20
+salsa20
+rc4-md5
+)
+r_ciphers=(
+none
+aes-256-cfb
+aes-192-cfb
+aes-128-cfb
+aes-256-cfb8
+aes-192-cfb8
+aes-128-cfb8
+aes-256-ctr
+aes-192-ctr
+aes-128-ctr
+chacha20-ietf
+chacha20
+salsa20
+xchacha20
+xsalsa20
+rc4-md5
+)
+# Reference URL:
+# https://github.com/shadowsocksr-rm/shadowsocks-rss/blob/master/ssr.md
+# https://github.com/shadowsocksrr/shadowsocksr/commit/a3cf0254508992b7126ab1151df0c2f10bf82680
+# Protocol
+protocols=(
+origin
+verify_deflate
+auth_sha1_v4
+auth_sha1_v4_compatible
+auth_aes128_md5
+auth_aes128_sha1
+auth_chain_a
+auth_chain_b
+auth_chain_c
+auth_chain_d
+auth_chain_e
+auth_chain_f
+)
+# obfs
+obfs=(
+plain
+http_simple
+http_simple_compatible
+http_post
+http_post_compatible
+tls1.2_ticket_auth
+tls1.2_ticket_auth_compatible
+tls1.2_ticket_fastauth
+tls1.2_ticket_fastauth_compatible
+)
+# libev obfuscating
+obfs_libev=(http tls)
+# initialization parameter
+libev_obfs=""
+
+disable_selinux(){
+    if [ -s /etc/selinux/config ] && grep 'SELINUX=enforcing' /etc/selinux/config; then
+        sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config
+        setenforce 0
+    fi
+}
+
+check_sys(){
+    local checkType=$1
+    local value=$2
+
+    local release=''
+    local systemPackage=''
+
+    if [[ -f /etc/redhat-release ]]; then
+        release="centos"
+        systemPackage="yum"
+    elif grep -Eqi "debian|raspbian" /etc/issue; then
+        release="debian"
+        systemPackage="apt"
+    elif grep -Eqi "ubuntu" /etc/issue; then
+        release="ubuntu"
+        systemPackage="apt"
+    elif grep -Eqi "centos|red hat|redhat" /etc/issue; then
+        release="centos"
+        systemPackage="yum"
+    elif grep -Eqi "debian|raspbian" /proc/version; then
+        release="debian"
+        systemPackage="apt"
+    elif grep -Eqi "ubuntu" /proc/version; then
+        release="ubuntu"
+        systemPackage="apt"
+    elif grep -Eqi "centos|red hat|redhat" /proc/version; then
+        release="centos"
+        systemPackage="yum"
+    fi
+
+    if [[ "${checkType}" == "sysRelease" ]]; then
+        if [ "${value}" == "${release}" ]; then
+            return 0
+        else
+            return 1
+        fi
+    elif [[ "${checkType}" == "packageManager" ]]; then
+        if [ "${value}" == "${systemPackage}" ]; then
+            return 0
+        else
+            return 1
+        fi
+    fi
+}
+
+version_ge(){
+    test "$(echo "$@" | tr " " "\n" | sort -rV | head -n 1)" == "$1"
+}
+
+version_gt(){
+    test "$(echo "$@" | tr " " "\n" | sort -V | head -n 1)" != "$1"
+}
+
+check_kernel_version(){
+    local kernel_version=$(uname -r | cut -d- -f1)
+    if version_gt ${kernel_version} 3.7.0; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+check_kernel_headers(){
+    if check_sys packageManager yum; then
+        if rpm -qa | grep -q headers-$(uname -r); then
+            return 0
+        else
+            return 1
+        fi
+    elif check_sys packageManager apt; then
+        if dpkg -s linux-headers-$(uname -r) > /dev/null 2>&1; then
+            return 0
+        else
+            return 1
+        fi
+    fi
+    return 1
+}
+
+getversion(){
+    if [[ -s /etc/redhat-release ]]; then
+        grep -oE  "[0-9.]+" /etc/redhat-release
+    else
+        grep -oE  "[0-9.]+" /etc/issue
+    fi
+}
+
+centosversion(){
+    if check_sys sysRelease centos; then
+        local code=$1
+        local version="$(getversion)"
+        local main_ver=${version%%.*}
+        if [ "$main_ver" == "$code" ]; then
+            return 0
+        else
+            return 1
+        fi
+    else
+        return 1
+    fi
+}
+
+autoconf_version(){
+    if [ ! "$(command -v autoconf)" ]; then
+        echo -e "[${green}Info${plain}] Starting install package autoconf"
+        if check_sys packageManager yum; then
+            yum install -y autoconf > /dev/null 2>&1 || echo -e "[${red}Error:${plain}] Failed to install autoconf"
+        elif check_sys packageManager apt; then
+            apt-get -y update > /dev/null 2>&1
+            apt-get -y install autoconf > /dev/null 2>&1 || echo -e "[${red}Error:${plain}] Failed to install autoconf"
+        fi
+    fi
+    local autoconf_ver=$(autoconf --version | grep autoconf | grep -oE "[0-9.]+")
+    if version_ge ${autoconf_ver} 2.67; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+get_ip(){
+    local IP=$( ip addr | egrep -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | egrep -v "^192\.168|^172\.1[6-9]\.|^172\.2[0-9]\.|^172\.3[0-2]\.|^10\.|^127\.|^255\.|^0\." | head -n 1 )
+    [ -z ${IP} ] && IP=$( wget -qO- -t1 -T2 ipv4.icanhazip.com )
+    [ -z ${IP} ] && IP=$( wget -qO- -t1 -T2 ipinfo.io/ip )
+    echo ${IP}
+}
+
+get_ipv6(){
+    local ipv6=$(wget -qO- -t1 -T2 ipv6.icanhazip.com)
+    [ -z ${ipv6} ] && return 1 || return 0
+}
+
+get_libev_ver(){
+    libev_ver=$(wget --no-check-certificate -qO- https://api.github.com/repos/shadowsocks/shadowsocks-libev/releases/latest | grep 'tag_name' | cut -d\" -f4)
+    [ -z ${libev_ver} ] && echo -e "[${red}Error${plain}] Get shadowsocks-libev latest version failed" && exit 1
+}
+
+get_opsy(){
+    [ -f /etc/redhat-release ] && awk '{print ($1,$3~/^[0-9]/?$3:$4)}' /etc/redhat-release && return
+    [ -f /etc/os-release ] && awk -F'[= "]' '/PRETTY_NAME/{print $3,$4,$5}' /etc/os-release && return
+    [ -f /etc/lsb-release ] && awk -F'[="]+' '/DESCRIPTION/{print $2}' /etc/lsb-release && return
+}
+
+is_64bit(){
+    if [ `getconf WORD_BIT` = '32' ] && [ `getconf LONG_BIT` = '64' ] ; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+debianversion(){
+    if check_sys sysRelease debian;then
+        local version=$( get_opsy )
+        local code=${1}
+        local main_ver=$( echo ${version} | sed 's/[^0-9]//g')
+        if [ "${main_ver}" == "${code}" ];then
+            return 0
+        else
+            return 1
+        fi
+    else
+        return 1
+    fi
+}
+
+download(){
+    local filename=$(basename $1)
+    if [ -f ${1} ]; then
+        echo "${filename} [found]"
+    else
+        echo "${filename} not found, download now..."
+        wget --no-check-certificate -c -t3 -T60 -O ${1} ${2}
+        if [ $? -ne 0 ]; then
+            echo -e "[${red}Error${plain}] Download ${filename} failed."
+            exit 1
+        fi
+    fi
+}
+
+download_files(){
+    cd ${cur_dir}
+
+    if   [ "${selected}" == "1" ]; then
+        download "${shadowsocks_python_file}.zip" "${shadowsocks_python_url}"
+        if check_sys packageManager yum; then
+            download "${shadowsocks_python_init}" "${shadowsocks_python_centos}"
+        elif check_sys packageManager apt; then
+            download "${shadowsocks_python_init}" "${shadowsocks_python_debian}"
+        fi
+    elif [ "${selected}" == "2" ]; then
+        download "${shadowsocks_r_file}.tar.gz" "${shadowsocks_r_url}"
+        if check_sys packageManager yum; then
+            download "${shadowsocks_r_init}" "${shadowsocks_r_centos}"
+        elif check_sys packageManager apt; then
+            download "${shadowsocks_r_init}" "${shadowsocks_r_debian}"
+        fi
+    elif [ "${selected}" == "3" ]; then
+        if is_64bit; then
+            download "${shadowsocks_go_file_64}.gz" "${shadowsocks_go_url_64}"
+        else
+            download "${shadowsocks_go_file_32}.gz" "${shadowsocks_go_url_32}"
+        fi
+        if check_sys packageManager yum; then
+            download "${shadowsocks_go_init}" "${shadowsocks_go_centos}"
+        elif check_sys packageManager apt; then
+            download "${shadowsocks_go_init}" "${shadowsocks_go_debian}"
+        fi
+    elif [ "${selected}" == "4" ]; then
+        get_libev_ver
+        shadowsocks_libev_file="shadowsocks-libev-$(echo ${libev_ver} | sed -e 's/^[a-zA-Z]//g')"
+        shadowsocks_libev_url="https://github.com/shadowsocks/shadowsocks-libev/releases/download/${libev_ver}/${shadowsocks_libev_file}.tar.gz"
+
+        download "${shadowsocks_libev_file}.tar.gz" "${shadowsocks_libev_url}"
+        if check_sys packageManager yum; then
+            download "${shadowsocks_libev_init}" "${shadowsocks_libev_centos}"
+        elif check_sys packageManager apt; then
+            download "${shadowsocks_libev_init}" "${shadowsocks_libev_debian}"
+        fi
+    fi
+
+}
+
+get_char(){
+    SAVEDSTTY=$(stty -g)
+    stty -echo
+    stty cbreak
+    dd if=/dev/tty bs=1 count=1 2> /dev/null
+    stty -raw
+    stty echo
+    stty $SAVEDSTTY
+}
+
+error_detect_depends(){
+    local command=$1
+    local depend=`echo "${command}" | awk '{print $4}'`
+    echo -e "[${green}Info${plain}] Starting to install package ${depend}"
+    ${command} > /dev/null 2>&1
+    if [ $? -ne 0 ]; then
+        echo -e "[${red}Error${plain}] Failed to install ${red}${depend}${plain}"
+        echo "Please visit: https://teddysun.com/486.html and contact."
+        exit 1
+    fi
+}
+
+config_firewall(){
+    if centosversion 6; then
+        /etc/init.d/iptables status > /dev/null 2>&1
+        if [ $? -eq 0 ]; then
+            iptables -L -n | grep -i ${shadowsocksport} > /dev/null 2>&1
+            if [ $? -ne 0 ]; then
+                iptables -I INPUT -m state --state NEW -m tcp -p tcp --dport ${shadowsocksport} -j ACCEPT
+                iptables -I INPUT -m state --state NEW -m udp -p udp --dport ${shadowsocksport} -j ACCEPT
+                /etc/init.d/iptables save
+                /etc/init.d/iptables restart
+            else
+                echo -e "[${green}Info${plain}] port ${green}${shadowsocksport}${plain} already be enabled."
+            fi
+        else
+            echo -e "[${yellow}Warning${plain}] iptables looks like not running or not installed, please enable port ${shadowsocksport} manually if necessary."
+        fi
+    elif centosversion 7; then
+        systemctl status firewalld > /dev/null 2>&1
+        if [ $? -eq 0 ]; then
+            default_zone=$(firewall-cmd --get-default-zone)
+            firewall-cmd --permanent --zone=${default_zone} --add-port=${shadowsocksport}/tcp
+            firewall-cmd --permanent --zone=${default_zone} --add-port=${shadowsocksport}/udp
+            firewall-cmd --reload
+        else
+            echo -e "[${yellow}Warning${plain}] firewalld looks like not running or not installed, please enable port ${shadowsocksport} manually if necessary."
+        fi
+    fi
+}
+
+config_shadowsocks(){
+
+if check_kernel_version && check_kernel_headers; then
+    fast_open="true"
+else
+    fast_open="false"
+fi
+
+if   [ "${selected}" == "1" ]; then
+    if [ ! -d "$(dirname ${shadowsocks_python_config})" ]; then
+        mkdir -p $(dirname ${shadowsocks_python_config})
+    fi
+    cat > ${shadowsocks_python_config}<<-EOF
+{
+    "server":"0.0.0.0",
+    "server_port":${shadowsocksport},
+    "local_address":"127.0.0.1",
+    "local_port":1080,
+    "password":"${shadowsockspwd}",
+    "timeout":300,
+    "method":"${shadowsockscipher}",
+    "fast_open":${fast_open}
+}
+EOF
+elif [ "${selected}" == "2" ]; then
+    if [ ! -d "$(dirname ${shadowsocks_r_config})" ]; then
+        mkdir -p $(dirname ${shadowsocks_r_config})
+    fi
+    cat > ${shadowsocks_r_config}<<-EOF
+{
+    "server":"0.0.0.0",
+    "server_ipv6":"::",
+    "server_port":${shadowsocksport},
+    "local_address":"127.0.0.1",
+    "local_port":1080,
+    "password":"${shadowsockspwd}",
+    "timeout":120,
+    "method":"${shadowsockscipher}",
+    "protocol":"${shadowsockprotocol}",
+    "protocol_param":"",
+    "obfs":"${shadowsockobfs}",
+    "obfs_param":"",
+    "redirect":"",
+    "dns_ipv6":false,
+    "fast_open":${fast_open},
+    "workers":1
+}
+EOF
+elif [ "${selected}" == "3" ]; then
+    if [ ! -d "$(dirname ${shadowsocks_go_config})" ]; then
+        mkdir -p $(dirname ${shadowsocks_go_config})
+    fi
+    cat > ${shadowsocks_go_config}<<-EOF
+{
+    "server":"0.0.0.0",
+    "server_port":${shadowsocksport},
+    "local_port":1080,
+    "password":"${shadowsockspwd}",
+    "method":"${shadowsockscipher}",
+    "timeout":300
+}
+EOF
+elif [ "${selected}" == "4" ]; then
+    local server_value="\"0.0.0.0\""
+    if get_ipv6; then
+        server_value="[\"[::0]\",\"0.0.0.0\"]"
+    fi
+
+    if [ ! -d "$(dirname ${shadowsocks_libev_config})" ]; then
+        mkdir -p $(dirname ${shadowsocks_libev_config})
+    fi
+
+    if [ "${libev_obfs}" == "y" ] || [ "${libev_obfs}" == "Y" ]; then
+        cat > ${shadowsocks_libev_config}<<-EOF
+{
+    "server":${server_value},
+    "server_port":${shadowsocksport},
+    "password":"${shadowsockspwd}",
+    "timeout":300,
+    "user":"nobody",
+    "method":"${shadowsockscipher}",
+    "fast_open":${fast_open},
+    "nameserver":"8.8.8.8",
+    "mode":"tcp_and_udp",
+    "plugin":"obfs-server",
+    "plugin_opts":"obfs=${shadowsocklibev_obfs}"
+}
+EOF
+    else
+        cat > ${shadowsocks_libev_config}<<-EOF
+{
+    "server":${server_value},
+    "server_port":${shadowsocksport},
+    "password":"${shadowsockspwd}",
+    "timeout":300,
+    "user":"nobody",
+    "method":"${shadowsockscipher}",
+    "fast_open":${fast_open},
+    "nameserver":"8.8.8.8",
+    "mode":"tcp_and_udp"
+}
+EOF
+    fi
+
+fi
+}
+
+install_dependencies(){
+    if check_sys packageManager yum; then
+        echo -e "[${green}Info${plain}] Checking the EPEL repository..."
+        if [ ! -f /etc/yum.repos.d/epel.repo ]; then
+            yum install -y epel-release > /dev/null 2>&1
+        fi
+        [ ! -f /etc/yum.repos.d/epel.repo ] && echo -e "[${red}Error${plain}] Install EPEL repository failed, please check it." && exit 1
+        [ ! "$(command -v yum-config-manager)" ] && yum install -y yum-utils > /dev/null 2>&1
+        [ x"$(yum-config-manager epel | grep -w enabled | awk '{print $3}')" != x"True" ] && yum-config-manager --enable epel > /dev/null 2>&1
+        echo -e "[${green}Info${plain}] Checking the EPEL repository complete..."
+
+        yum_depends=(
+            unzip gzip openssl openssl-devel gcc python python-devel python-setuptools pcre pcre-devel libtool libevent
+            autoconf automake make curl curl-devel zlib-devel perl perl-devel cpio expat-devel gettext-devel
+            libev-devel c-ares-devel git qrencode
+        )
+        for depend in ${yum_depends[@]}; do
+            error_detect_depends "yum -y install ${depend}"
+        done
+    elif check_sys packageManager apt; then
+        apt_depends=(
+            gettext build-essential unzip gzip python python-dev python-setuptools curl openssl libssl-dev
+            autoconf automake libtool gcc make perl cpio libpcre3 libpcre3-dev zlib1g-dev libev-dev libc-ares-dev git qrencode
+        )
+
+        apt-get -y update
+        for depend in ${apt_depends[@]}; do
+            error_detect_depends "apt-get -y install ${depend}"
+        done
+    fi
+}
+
+install_check(){
+    if check_sys packageManager yum || check_sys packageManager apt; then
+        if centosversion 5; then
+            return 1
+        fi
+        return 0
+    else
+        return 1
+    fi
+}
+
+install_select(){
+    if ! install_check; then
+        echo -e "[${red}Error${plain}] Your OS is not supported to run it!"
+        echo "Please change to CentOS 6+/Debian 7+/Ubuntu 12+ and try again."
+        exit 1
+    fi
+
+    clear
+    while true
+    do
+    echo  "Which Shadowsocks server you'd select:"
+    for ((i=1;i<=${#software[@]};i++ )); do
+        hint="${software[$i-1]}"
+        echo -e "${green}${i}${plain}) ${hint}"
+    done
+    read -p "Please enter a number (Default ${software[0]}):" selected
+    [ -z "${selected}" ] && selected="1"
+    case "${selected}" in
+        1|2|3|4)
+        echo
+        echo "You choose = ${software[${selected}-1]}"
+        echo
+        break
+        ;;
+        *)
+        echo -e "[${red}Error${plain}] Please only enter a number [1-4]"
+        ;;
+    esac
+    done
+}
+
+install_prepare_password(){
+    echo "Please enter password for ${software[${selected}-1]}"
+    read -p "(Default password: teddysun.com):" shadowsockspwd
+    [ -z "${shadowsockspwd}" ] && shadowsockspwd="teddysun.com"
+    echo
+    echo "password = ${shadowsockspwd}"
+    echo
+}
+
+install_prepare_port() {
+    while true
+    do
+    dport=$(shuf -i 9000-19999 -n 1)
+    echo -e "Please enter a port for ${software[${selected}-1]} [1-65535]"
+    read -p "(Default port: ${dport}):" shadowsocksport
+    [ -z "${shadowsocksport}" ] && shadowsocksport=${dport}
+    expr ${shadowsocksport} + 1 &>/dev/null
+    if [ $? -eq 0 ]; then
+        if [ ${shadowsocksport} -ge 1 ] && [ ${shadowsocksport} -le 65535 ] && [ ${shadowsocksport:0:1} != 0 ]; then
+            echo
+            echo "port = ${shadowsocksport}"
+            echo
+            break
+        fi
+    fi
+    echo -e "[${red}Error${plain}] Please enter a correct number [1-65535]"
+    done
+}
+
+install_prepare_cipher(){
+    while true
+    do
+    echo -e "Please select stream cipher for ${software[${selected}-1]}:"
+
+    if   [[ "${selected}" == "1" || "${selected}" == "4" ]]; then
+        for ((i=1;i<=${#common_ciphers[@]};i++ )); do
+            hint="${common_ciphers[$i-1]}"
+            echo -e "${green}${i}${plain}) ${hint}"
+        done
+        read -p "Which cipher you'd select(Default: ${common_ciphers[0]}):" pick
+        [ -z "$pick" ] && pick=1
+        expr ${pick} + 1 &>/dev/null
+        if [ $? -ne 0 ]; then
+            echo -e "[${red}Error${plain}] Please enter a number"
+            continue
+        fi
+        if [[ "$pick" -lt 1 || "$pick" -gt ${#common_ciphers[@]} ]]; then
+            echo -e "[${red}Error${plain}] Please enter a number between 1 and ${#common_ciphers[@]}"
+            continue
+        fi
+        shadowsockscipher=${common_ciphers[$pick-1]}
+    elif [ "${selected}" == "2" ]; then
+        for ((i=1;i<=${#r_ciphers[@]};i++ )); do
+            hint="${r_ciphers[$i-1]}"
+            echo -e "${green}${i}${plain}) ${hint}"
+        done
+        read -p "Which cipher you'd select(Default: ${r_ciphers[1]}):" pick
+        [ -z "$pick" ] && pick=2
+        expr ${pick} + 1 &>/dev/null
+        if [ $? -ne 0 ]; then
+            echo -e "[${red}Error${plain}] Please enter a number"
+            continue
+        fi
+        if [[ "$pick" -lt 1 || "$pick" -gt ${#r_ciphers[@]} ]]; then
+            echo -e "[${red}Error${plain}] Please enter a number between 1 and ${#r_ciphers[@]}"
+            continue
+        fi
+        shadowsockscipher=${r_ciphers[$pick-1]}
+    elif [ "${selected}" == "3" ]; then
+        for ((i=1;i<=${#go_ciphers[@]};i++ )); do
+            hint="${go_ciphers[$i-1]}"
+            echo -e "${green}${i}${plain}) ${hint}"
+        done
+        read -p "Which cipher you'd select(Default: ${go_ciphers[0]}):" pick
+        [ -z "$pick" ] && pick=1
+        expr ${pick} + 1 &>/dev/null
+        if [ $? -ne 0 ]; then
+            echo -e "[${red}Error${plain}] Please enter a number"
+            continue
+        fi
+        if [[ "$pick" -lt 1 || "$pick" -gt ${#go_ciphers[@]} ]]; then
+            echo -e "[${red}Error${plain}] Please enter a number between 1 and ${#go_ciphers[@]}"
+            continue
+        fi
+        shadowsockscipher=${go_ciphers[$pick-1]}
+    fi
+
+    echo
+    echo "cipher = ${shadowsockscipher}"
+    echo
+    break
+    done
+}
+
+install_prepare_protocol(){
+    while true
+    do
+    echo -e "Please select protocol for ${software[${selected}-1]}:"
+    for ((i=1;i<=${#protocols[@]};i++ )); do
+        hint="${protocols[$i-1]}"
+        echo -e "${green}${i}${plain}) ${hint}"
+    done
+    read -p "Which protocol you'd select(Default: ${protocols[0]}):" protocol
+    [ -z "$protocol" ] && protocol=1
+    expr ${protocol} + 1 &>/dev/null
+    if [ $? -ne 0 ]; then
+        echo -e "[${red}Error${plain}] Please enter a number"
+        continue
+    fi
+    if [[ "$protocol" -lt 1 || "$protocol" -gt ${#protocols[@]} ]]; then
+        echo -e "[${red}Error${plain}] Please enter a number between 1 and ${#protocols[@]}"
+        continue
+    fi
+    shadowsockprotocol=${protocols[$protocol-1]}
+    echo
+    echo "protocol = ${shadowsockprotocol}"
+    echo
+    break
+    done
+}
+
+install_prepare_obfs(){
+    while true
+    do
+    echo -e "Please select obfs for ${software[${selected}-1]}:"
+    for ((i=1;i<=${#obfs[@]};i++ )); do
+        hint="${obfs[$i-1]}"
+        echo -e "${green}${i}${plain}) ${hint}"
+    done
+    read -p "Which obfs you'd select(Default: ${obfs[0]}):" r_obfs
+    [ -z "$r_obfs" ] && r_obfs=1
+    expr ${r_obfs} + 1 &>/dev/null
+    if [ $? -ne 0 ]; then
+        echo -e "[${red}Error${plain}] Please enter a number"
+        continue
+    fi
+    if [[ "$r_obfs" -lt 1 || "$r_obfs" -gt ${#obfs[@]} ]]; then
+        echo -e "[${red}Error${plain}] Please enter a number between 1 and ${#obfs[@]}"
+        continue
+    fi
+    shadowsockobfs=${obfs[$r_obfs-1]}
+    echo
+    echo "obfs = ${shadowsockobfs}"
+    echo
+    break
+    done
+}
+
+install_prepare_libev_obfs(){
+    if autoconf_version || centosversion 6; then
+        while true
+        do
+        echo -e "Do you want install simple-obfs for ${software[${selected}-1]}? [y/n]"
+        read -p "(default: n):" libev_obfs
+        [ -z "$libev_obfs" ] && libev_obfs=n
+        case "${libev_obfs}" in
+            y|Y|n|N)
+            echo
+            echo "You choose = ${libev_obfs}"
+            echo
+            break
+            ;;
+            *)
+            echo -e "[${red}Error${plain}] Please only enter [y/n]"
+            ;;
+        esac
+        done
+
+        if [ "${libev_obfs}" == "y" ] || [ "${libev_obfs}" == "Y" ]; then
+            while true
+            do
+            echo -e "Please select obfs for simple-obfs:"
+            for ((i=1;i<=${#obfs_libev[@]};i++ )); do
+                hint="${obfs_libev[$i-1]}"
+                echo -e "${green}${i}${plain}) ${hint}"
+            done
+            read -p "Which obfs you'd select(Default: ${obfs_libev[0]}):" r_libev_obfs
+            [ -z "$r_libev_obfs" ] && r_libev_obfs=1
+            expr ${r_libev_obfs} + 1 &>/dev/null
+            if [ $? -ne 0 ]; then
+                echo -e "[${red}Error${plain}] Please enter a number"
+                continue
+            fi
+            if [[ "$r_libev_obfs" -lt 1 || "$r_libev_obfs" -gt ${#obfs_libev[@]} ]]; then
+                echo -e "[${red}Error${plain}] Please enter a number between 1 and ${#obfs_libev[@]}"
+                continue
+            fi
+            shadowsocklibev_obfs=${obfs_libev[$r_libev_obfs-1]}
+            echo
+            echo "obfs = ${shadowsocklibev_obfs}"
+            echo
+            break
+            done
+        fi
+    else
+        echo -e "[${green}Info${plain}] autoconf version is less than 2.67, simple-obfs for ${software[${selected}-1]} installation has been skipped"
+    fi
+}
+
+install_prepare(){
+
+    if  [[ "${selected}" == "1" || "${selected}" == "3" || "${selected}" == "4" ]]; then
+        install_prepare_password
+        install_prepare_port
+        install_prepare_cipher
+        if [ "${selected}" == "4" ]; then
+            install_prepare_libev_obfs
+        fi
+    elif [ "${selected}" == "2" ]; then
+        install_prepare_password
+        install_prepare_port
+        install_prepare_cipher
+        install_prepare_protocol
+        install_prepare_obfs
+    fi
+
+    echo
+    echo "Press any key to start...or Press Ctrl+C to cancel"
+    char=`get_char`
+
+}
+
+install_libsodium(){
+    if [ ! -f /usr/lib/libsodium.a ]; then
+        cd ${cur_dir}
+        download "${libsodium_file}.tar.gz" "${libsodium_url}"
+        tar zxf ${libsodium_file}.tar.gz
+        cd ${libsodium_file}
+        ./configure --prefix=/usr && make && make install
+        if [ $? -ne 0 ]; then
+            echo -e "[${red}Error${plain}] ${libsodium_file} install failed."
+            install_cleanup
+            exit 1
+        fi
+    else
+        echo -e "[${green}Info${plain}] ${libsodium_file} already installed."
+    fi
+}
+
+install_mbedtls(){
+    if [ ! -f /usr/lib/libmbedtls.a ]; then
+        cd ${cur_dir}
+        download "${mbedtls_file}-gpl.tgz" "${mbedtls_url}"
+        tar xf ${mbedtls_file}-gpl.tgz
+        cd ${mbedtls_file}
+        make SHARED=1 CFLAGS=-fPIC
+        make DESTDIR=/usr install
+        if [ $? -ne 0 ]; then
+            echo -e "[${red}Error${plain}] ${mbedtls_file} install failed."
+            install_cleanup
+            exit 1
+        fi
+    else
+        echo -e "[${green}Info${plain}] ${mbedtls_file} already installed."
+    fi
+}
+
+install_shadowsocks_python(){
+    cd ${cur_dir}
+    unzip -q ${shadowsocks_python_file}.zip
+    if [ $? -ne 0 ];then
+        echo -e "[${red}Error${plain}] unzip ${shadowsocks_python_file}.zip failed, please check unzip command."
+        install_cleanup
+        exit 1
+    fi
+
+    cd ${shadowsocks_python_file}
+    python setup.py install --record /usr/local/shadowsocks_python.log
+
+    if [ -f /usr/bin/ssserver ] || [ -f /usr/local/bin/ssserver ]; then
+        chmod +x ${shadowsocks_python_init}
+        local service_name=$(basename ${shadowsocks_python_init})
+        if check_sys packageManager yum; then
+            chkconfig --add ${service_name}
+            chkconfig ${service_name} on
+        elif check_sys packageManager apt; then
+            update-rc.d -f ${service_name} defaults
+        fi
+    else
+        echo
+        echo -e "[${red}Error${plain}] ${software[0]} install failed."
+        echo "Please visit: https://teddysun.com/486.html and contact."
+        install_cleanup
+        exit 1
+    fi
+}
+
+install_shadowsocks_r(){
+    cd ${cur_dir}
+    tar zxf ${shadowsocks_r_file}.tar.gz
+    mv ${shadowsocks_r_file}/shadowsocks /usr/local/
+    if [ -f /usr/local/shadowsocks/server.py ]; then
+        chmod +x ${shadowsocks_r_init}
+        local service_name=$(basename ${shadowsocks_r_init})
+        if check_sys packageManager yum; then
+            chkconfig --add ${service_name}
+            chkconfig ${service_name} on
+        elif check_sys packageManager apt; then
+            update-rc.d -f ${service_name} defaults
+        fi
+    else
+        echo
+        echo -e "[${red}Error${plain}] ${software[1]} install failed."
+        echo "Please visit; https://teddysun.com/486.html and contact."
+        install_cleanup
+        exit 1
+    fi
+}
+
+install_shadowsocks_go(){
+    cd ${cur_dir}
+    if is_64bit; then
+        gzip -d ${shadowsocks_go_file_64}.gz
+        if [ $? -ne 0 ];then
+            echo -e "[${red}Error${plain}] Decompress ${shadowsocks_go_file_64}.gz failed."
+            install_cleanup
+            exit 1
+        fi
+        mv -f ${shadowsocks_go_file_64} /usr/bin/shadowsocks-server
+    else
+        gzip -d ${shadowsocks_go_file_32}.gz
+        if [ $? -ne 0 ];then
+            echo -e "[${red}Error${plain}] Decompress ${shadowsocks_go_file_32}.gz failed."
+            install_cleanup
+            exit 1
+        fi
+        mv -f ${shadowsocks_go_file_32} /usr/bin/shadowsocks-server
+    fi
+
+    if [ -f /usr/bin/shadowsocks-server ]; then
+        chmod +x /usr/bin/shadowsocks-server
+        chmod +x ${shadowsocks_go_init}
+
+        local service_name=$(basename ${shadowsocks_go_init})
+        if check_sys packageManager yum; then
+            chkconfig --add ${service_name}
+            chkconfig ${service_name} on
+        elif check_sys packageManager apt; then
+            update-rc.d -f ${service_name} defaults
+        fi
+    else
+        echo
+        echo -e "[${red}Error${plain}] ${software[2]} install failed."
+        echo "Please visit: https://teddysun.com/486.html and contact."
+        install_cleanup
+        exit 1
+    fi
+}
+
+install_shadowsocks_libev(){
+    cd ${cur_dir}
+    tar zxf ${shadowsocks_libev_file}.tar.gz
+    cd ${shadowsocks_libev_file}
+    ./configure --disable-documentation && make && make install
+    if [ $? -eq 0 ]; then
+        chmod +x ${shadowsocks_libev_init}
+        local service_name=$(basename ${shadowsocks_libev_init})
+        if check_sys packageManager yum; then
+            chkconfig --add ${service_name}
+            chkconfig ${service_name} on
+        elif check_sys packageManager apt; then
+            update-rc.d -f ${service_name} defaults
+        fi
+    else
+        echo
+        echo -e "[${red}Error${plain}] ${software[3]} install failed."
+        echo "Please visit: https://teddysun.com/486.html and contact."
+        install_cleanup
+        exit 1
+    fi
+}
+
+install_shadowsocks_libev_obfs(){
+    if [ "${libev_obfs}" == "y" ] || [ "${libev_obfs}" == "Y" ]; then
+        cd ${cur_dir}
+        git clone https://github.com/shadowsocks/simple-obfs.git
+        [ -d simple-obfs ] && cd simple-obfs || echo -e "[${red}Error:${plain}] Failed to git clone simple-obfs."
+        git submodule update --init --recursive
+        if centosversion 6; then
+            if [ ! "$(command -v autoconf268)" ]; then
+                echo -e "[${green}Info${plain}] Starting install autoconf268..."
+                yum install -y autoconf268 > /dev/null 2>&1 || echo -e "[${red}Error:${plain}] Failed to install autoconf268."
+            fi
+            # replace command autoreconf to autoreconf268
+            sed -i 's/autoreconf/autoreconf268/' autogen.sh
+            # replace #include <ev.h> to #include <libev/ev.h>
+            sed -i 's@^#include <ev.h>@#include <libev/ev.h>@' src/local.h
+            sed -i 's@^#include <ev.h>@#include <libev/ev.h>@' src/server.h
+        fi
+        ./autogen.sh
+        ./configure --disable-documentation
+        make
+        make install
+        if [ ! "$(command -v obfs-server)" ]; then
+            echo -e "[${red}Error${plain}] simple-obfs for ${software[${selected}-1]} install failed."
+            echo "Please visit: https://teddysun.com/486.html and contact."
+            install_cleanup
+            exit 1
+        fi
+        [ -f /usr/local/bin/obfs-server ] && ln -s /usr/local/bin/obfs-server /usr/bin
+    fi
+}
+
+install_completed_python(){
+    clear
+    ${shadowsocks_python_init} start
+    echo
+    echo -e "Congratulations, ${green}${software[0]}${plain} server install completed!"
+    echo -e "Your Server IP        : ${red} $(get_ip) ${plain}"
+    echo -e "Your Server Port      : ${red} ${shadowsocksport} ${plain}"
+    echo -e "Your Password         : ${red} ${shadowsockspwd} ${plain}"
+    echo -e "Your Encryption Method: ${red} ${shadowsockscipher} ${plain}"
+}
+
+install_completed_r(){
+    clear
+    ${shadowsocks_r_init} start
+    echo
+    echo -e "Congratulations, ${green}${software[1]}${plain} server install completed!"
+    echo -e "Your Server IP        : ${red} $(get_ip) ${plain}"
+    echo -e "Your Server Port      : ${red} ${shadowsocksport} ${plain}"
+    echo -e "Your Password         : ${red} ${shadowsockspwd} ${plain}"
+    echo -e "Your Protocol         : ${red} ${shadowsockprotocol} ${plain}"
+    echo -e "Your obfs             : ${red} ${shadowsockobfs} ${plain}"
+    echo -e "Your Encryption Method: ${red} ${shadowsockscipher} ${plain}"
+}
+
+install_completed_go(){
+    clear
+    ${shadowsocks_go_init} start
+    echo
+    echo -e "Congratulations, ${green}${software[2]}${plain} server install completed!"
+    echo -e "Your Server IP        : ${red} $(get_ip) ${plain}"
+    echo -e "Your Server Port      : ${red} ${shadowsocksport} ${plain}"
+    echo -e "Your Password         : ${red} ${shadowsockspwd} ${plain}"
+    echo -e "Your Encryption Method: ${red} ${shadowsockscipher} ${plain}"
+}
+
+install_completed_libev(){
+    clear
+    ldconfig
+    ${shadowsocks_libev_init} start
+    echo
+    echo -e "Congratulations, ${green}${software[3]}${plain} server install completed!"
+    echo -e "Your Server IP        : ${red} $(get_ip) ${plain}"
+    echo -e "Your Server Port      : ${red} ${shadowsocksport} ${plain}"
+    echo -e "Your Password         : ${red} ${shadowsockspwd} ${plain}"
+    if [ "$(command -v obfs-server)" ]; then
+    echo -e "Your obfs             : ${red} ${shadowsocklibev_obfs} ${plain}"
+    fi
+    echo -e "Your Encryption Method: ${red} ${shadowsockscipher} ${plain}"
+}
+
+qr_generate_python(){
+    if [ "$(command -v qrencode)" ]; then
+        local tmp=$(echo -n "${shadowsockscipher}:${shadowsockspwd}@$(get_ip):${shadowsocksport}" | base64 -w0)
+        local qr_code="ss://${tmp}"
+        echo
+        echo "Your QR Code: (For Shadowsocks Windows, OSX, Android and iOS clients)"
+        echo -e "${green} ${qr_code} ${plain}"
+        echo -n "${qr_code}" | qrencode -s8 -o ${cur_dir}/shadowsocks_python_qr.png
+        echo "Your QR Code has been saved as a PNG file path:"
+        echo -e "${green} ${cur_dir}/shadowsocks_python_qr.png ${plain}"
+    fi
+}
+
+qr_generate_r(){
+    if [ "$(command -v qrencode)" ]; then
+        local tmp1=$(echo -n "${shadowsockspwd}" | base64 -w0 | sed 's/=//g;s/\//_/g;s/+/-/g')
+        local tmp2=$(echo -n "$(get_ip):${shadowsocksport}:${shadowsockprotocol}:${shadowsockscipher}:${shadowsockobfs}:${tmp1}/?obfsparam=" | base64 -w0)
+        local qr_code="ssr://${tmp2}"
+        echo
+        echo "Your QR Code: (For ShadowsocksR Windows, Android clients only)"
+        echo -e "${green} ${qr_code} ${plain}"
+        echo -n "${qr_code}" | qrencode -s8 -o ${cur_dir}/shadowsocks_r_qr.png
+        echo "Your QR Code has been saved as a PNG file path:"
+        echo -e "${green} ${cur_dir}/shadowsocks_r_qr.png ${plain}"
+    fi
+}
+
+qr_generate_go(){
+    if [ "$(command -v qrencode)" ]; then
+        local tmp=$(echo -n "${shadowsockscipher}:${shadowsockspwd}@$(get_ip):${shadowsocksport}" | base64 -w0)
+        local qr_code="ss://${tmp}"
+        echo
+        echo "Your QR Code: (For Shadowsocks Windows, OSX, Android and iOS clients)"
+        echo -e "${green} ${qr_code} ${plain}"
+        echo -n "${qr_code}" | qrencode -s8 -o ${cur_dir}/shadowsocks_go_qr.png
+        echo "Your QR Code has been saved as a PNG file path:"
+        echo -e "${green} ${cur_dir}/shadowsocks_go_qr.png ${plain}"
+    fi
+}
+
+qr_generate_libev(){
+    if [ "$(command -v qrencode)" ]; then
+        local tmp=$(echo -n "${shadowsockscipher}:${shadowsockspwd}@$(get_ip):${shadowsocksport}" | base64 -w0)
+        local qr_code="ss://${tmp}"
+        echo
+        echo "Your QR Code: (For Shadowsocks Windows, OSX, Android and iOS clients)"
+        echo -e "${green} ${qr_code} ${plain}"
+        echo -n "${qr_code}" | qrencode -s8 -o ${cur_dir}/shadowsocks_libev_qr.png
+        echo "Your QR Code has been saved as a PNG file path:"
+        echo -e "${green} ${cur_dir}/shadowsocks_libev_qr.png ${plain}"
+    fi
+}
+
+install_main(){
+    install_libsodium
+    if ! ldconfig -p | grep -wq "/usr/lib"; then
+        echo "/usr/lib" > /etc/ld.so.conf.d/lib.conf
+    fi
+    ldconfig
+
+    if   [ "${selected}" == "1" ]; then
+        install_shadowsocks_python
+        install_completed_python
+        qr_generate_python
+    elif [ "${selected}" == "2" ]; then
+        install_shadowsocks_r
+        install_completed_r
+        qr_generate_r
+    elif [ "${selected}" == "3" ]; then
+        install_shadowsocks_go
+        install_completed_go
+        qr_generate_go
+    elif [ "${selected}" == "4" ]; then
+        install_mbedtls
+        install_shadowsocks_libev
+        install_shadowsocks_libev_obfs
+        install_completed_libev
+        qr_generate_libev
+    fi
+
+    echo
+    echo "Welcome to visit: https://teddysun.com/486.html"
+    echo "Enjoy it!"
+    echo
+}
+
+install_cleanup(){
+    cd ${cur_dir}
+    rm -rf simple-obfs
+    rm -rf ${libsodium_file} ${libsodium_file}.tar.gz
+    rm -rf ${mbedtls_file} ${mbedtls_file}-gpl.tgz
+    rm -rf ${shadowsocks_python_file} ${shadowsocks_python_file}.zip
+    rm -rf ${shadowsocks_r_file} ${shadowsocks_r_file}.tar.gz
+    rm -rf ${shadowsocks_go_file_64}.gz ${shadowsocks_go_file_32}.gz
+    rm -rf ${shadowsocks_libev_file} ${shadowsocks_libev_file}.tar.gz
+}
+
+install_shadowsocks(){
+    disable_selinux
+    install_select
+    install_prepare
+    install_dependencies
+    download_files
+    config_shadowsocks
+    if check_sys packageManager yum; then
+        config_firewall
+    fi
+    install_main
+    install_cleanup
+}
+
+uninstall_shadowsocks_python(){
+    printf "Are you sure uninstall ${red}${software[0]}${plain}? [y/n]\n"
+    read -p "(default: n):" answer
+    [ -z ${answer} ] && answer="n"
+    if [ "${answer}" == "y" ] || [ "${answer}" == "Y" ]; then
+        ${shadowsocks_python_init} status > /dev/null 2>&1
+        if [ $? -eq 0 ]; then
+            ${shadowsocks_python_init} stop
+        fi
+        local service_name=$(basename ${shadowsocks_python_init})
+        if check_sys packageManager yum; then
+            chkconfig --del ${service_name}
+        elif check_sys packageManager apt; then
+            update-rc.d -f ${service_name} remove
+        fi
+
+        rm -fr $(dirname ${shadowsocks_python_config})
+        rm -f ${shadowsocks_python_init}
+        rm -f /var/log/shadowsocks.log
+        if [ -f /usr/local/shadowsocks_python.log ]; then
+            cat /usr/local/shadowsocks_python.log | xargs rm -rf
+            rm -f /usr/local/shadowsocks_python.log
+        fi
+        echo -e "[${green}Info${plain}] ${software[0]} uninstall success"
+    else
+        echo
+        echo -e "[${green}Info${plain}] ${software[0]} uninstall cancelled, nothing to do..."
+        echo
+    fi
+}
+
+uninstall_shadowsocks_r(){
+    printf "Are you sure uninstall ${red}${software[1]}${plain}? [y/n]\n"
+    read -p "(default: n):" answer
+    [ -z ${answer} ] && answer="n"
+    if [ "${answer}" == "y" ] || [ "${answer}" == "Y" ]; then
+        ${shadowsocks_r_init} status > /dev/null 2>&1
+        if [ $? -eq 0 ]; then
+            ${shadowsocks_r_init} stop
+        fi
+        local service_name=$(basename ${shadowsocks_r_init})
+        if check_sys packageManager yum; then
+            chkconfig --del ${service_name}
+        elif check_sys packageManager apt; then
+            update-rc.d -f ${service_name} remove
+        fi
+        rm -fr $(dirname ${shadowsocks_r_config})
+        rm -f ${shadowsocks_r_init}
+        rm -f /var/log/shadowsocks.log
+        rm -fr /usr/local/shadowsocks
+        echo -e "[${green}Info${plain}] ${software[1]} uninstall success"
+    else
+        echo
+        echo -e "[${green}Info${plain}] ${software[1]} uninstall cancelled, nothing to do..."
+        echo
+    fi
+}
+
+uninstall_shadowsocks_go(){
+    printf "Are you sure uninstall ${red}${software[2]}${plain}? [y/n]\n"
+    read -p "(default: n):" answer
+    [ -z ${answer} ] && answer="n"
+    if [ "${answer}" == "y" ] || [ "${answer}" == "Y" ]; then
+        ${shadowsocks_go_init} status > /dev/null 2>&1
+        if [ $? -eq 0 ]; then
+            ${shadowsocks_go_init} stop
+        fi
+        local service_name=$(basename ${shadowsocks_go_init})
+        if check_sys packageManager yum; then
+            chkconfig --del ${service_name}
+        elif check_sys packageManager apt; then
+            update-rc.d -f ${service_name} remove
+        fi
+        rm -fr $(dirname ${shadowsocks_go_config})
+        rm -f ${shadowsocks_go_init}
+        rm -f /usr/bin/shadowsocks-server
+        echo -e "[${green}Info${plain}] ${software[2]} uninstall success"
+    else
+        echo
+        echo -e "[${green}Info${plain}] ${software[2]} uninstall cancelled, nothing to do..."
+        echo
+    fi
+}
+
+uninstall_shadowsocks_libev(){
+    printf "Are you sure uninstall ${red}${software[3]}${plain}? [y/n]\n"
+    read -p "(default: n):" answer
+    [ -z ${answer} ] && answer="n"
+    if [ "${answer}" == "y" ] || [ "${answer}" == "Y" ]; then
+        ${shadowsocks_libev_init} status > /dev/null 2>&1
+        if [ $? -eq 0 ]; then
+            ${shadowsocks_libev_init} stop
+        fi
+        local service_name=$(basename ${shadowsocks_libev_init})
+        if check_sys packageManager yum; then
+            chkconfig --del ${service_name}
+        elif check_sys packageManager apt; then
+            update-rc.d -f ${service_name} remove
+        fi
+        rm -fr $(dirname ${shadowsocks_libev_config})
+        rm -f /usr/local/bin/ss-local
+        rm -f /usr/local/bin/ss-tunnel
+        rm -f /usr/local/bin/ss-server
+        rm -f /usr/local/bin/ss-manager
+        rm -f /usr/local/bin/ss-redir
+        rm -f /usr/local/bin/ss-nat
+        rm -f /usr/local/bin/obfs-local
+        rm -f /usr/local/bin/obfs-server
+        rm -f /usr/local/lib/libshadowsocks-libev.a
+        rm -f /usr/local/lib/libshadowsocks-libev.la
+        rm -f /usr/local/include/shadowsocks.h
+        rm -f /usr/local/lib/pkgconfig/shadowsocks-libev.pc
+        rm -f /usr/local/share/man/man1/ss-local.1
+        rm -f /usr/local/share/man/man1/ss-tunnel.1
+        rm -f /usr/local/share/man/man1/ss-server.1
+        rm -f /usr/local/share/man/man1/ss-manager.1
+        rm -f /usr/local/share/man/man1/ss-redir.1
+        rm -f /usr/local/share/man/man1/ss-nat.1
+        rm -f /usr/local/share/man/man8/shadowsocks-libev.8
+        rm -fr /usr/local/share/doc/shadowsocks-libev
+        rm -f ${shadowsocks_libev_init}
+        echo -e "[${green}Info${plain}] ${software[3]} uninstall success"
+    else
+        echo
+        echo -e "[${green}Info${plain}] ${software[3]} uninstall cancelled, nothing to do..."
+        echo
+    fi
+}
+
+uninstall_shadowsocks(){
+    while true
+    do
+    echo  "Which Shadowsocks server you want to uninstall?"
+    for ((i=1;i<=${#software[@]};i++ )); do
+        hint="${software[$i-1]}"
+        echo -e "${green}${i}${plain}) ${hint}"
+    done
+    read -p "Please enter a number [1-4]:" un_select
+    case "${un_select}" in
+        1|2|3|4)
+        echo
+        echo "You choose = ${software[${un_select}-1]}"
+        echo
+        break
+        ;;
+        *)
+        echo -e "[${red}Error${plain}] Please only enter a number [1-4]"
+        ;;
+    esac
+    done
+
+    if   [ "${un_select}" == "1" ]; then
+        if [ -f ${shadowsocks_python_init} ]; then
+            uninstall_shadowsocks_python
+        else
+            echo -e "[${red}Error${plain}] ${software[${un_select}-1]} not installed, please check it and try again."
+            echo
+            exit 1
+        fi
+    elif [ "${un_select}" == "2" ]; then
+        if [ -f ${shadowsocks_r_init} ]; then
+            uninstall_shadowsocks_r
+        else
+            echo -e "[${red}Error${plain}] ${software[${un_select}-1]} not installed, please check it and try again."
+            echo
+            exit 1
+        fi
+    elif [ "${un_select}" == "3" ]; then
+        if [ -f ${shadowsocks_go_init} ]; then
+            uninstall_shadowsocks_go
+        else
+            echo -e "[${red}Error${plain}] ${software[${un_select}-1]} not installed, please check it and try again."
+            echo
+            exit 1
+        fi
+    elif [ "${un_select}" == "4" ]; then
+        if [ -f ${shadowsocks_libev_init} ]; then
+            uninstall_shadowsocks_libev
+        else
+            echo -e "[${red}Error${plain}] ${software[${un_select}-1]} not installed, please check it and try again."
+            echo
+            exit 1
+        fi
+    fi
+}
+
+# Initialization step
+action=$1
+[ -z $1 ] && action=install
+case "${action}" in
+    install|uninstall)
+        ${action}_shadowsocks
+        ;;
+    *)
+        echo "Arguments error! [${action}]"
+        echo "Usage: $(basename $0) [install|uninstall]"
+        ;;
+esac
diff --git "a/linux/source\345\221\275\344\273\244.md" "b/linux/source\345\221\275\344\273\244.md"
new file mode 100644
index 0000000..d452dcb
--- /dev/null
+++ "b/linux/source\345\221\275\344\273\244.md"
@@ -0,0 +1,29 @@
+## 定义
+
+source命令也称为“点命令”，也就是一个点符号（.）,是bash的内部命令。
+
+## 功能
+
+使Shell读入指定的Shell程序文件并依次执行文件中的所有语句 source命令通常用于重新执行刚修改的初始化文件，使之立即生效，而不必注销并重新登录。
+
+## 用法
+
+`source filename` 或` . filename`
+
+ source命令(从 C Shell 而来)是bash shell的内置命令;点命令(.)，就是个点符号(从Bourne Shell而来)是source的另一名称。
+
+
+
+## source filename 与 sh filename 及./filename执行脚本的区别在那里呢？
+
+1.当shell脚本具有可执行权限时，用sh filename与./filename执行脚本是没有区别得。./filename是因为当前目录没有在PATH中，所有"."是用来表示当前目录的。
+
+2.sh filename 重新建立一个子shell，在子shell中执行脚本里面的语句，该子shell继承父shell的环境变量，但子shell新建的、改变的变量不会被带回父shell，除非使用export。
+
+3.source filename：这个命令其实只是简单地读取脚本里面的语句依次在当前shell里面执行，没有建立新的子shell。那么脚本里面所有新建、改变变量的语句都会保存在当前shell里面。  
+
+
+
+## 引用
+
+[source命令](https://www.cnblogs.com/wqbin/p/10244063.html)
\ No newline at end of file
diff --git "a/linux/\346\237\245\347\234\213\345\215\240\347\224\250\347\253\257\345\217\243\347\232\204\350\277\233\347\250\213.md" "b/linux/\346\237\245\347\234\213\345\215\240\347\224\250\347\253\257\345\217\243\347\232\204\350\277\233\347\250\213.md"
new file mode 100644
index 0000000..069a74f
--- /dev/null
+++ "b/linux/\346\237\245\347\234\213\345\215\240\347\224\250\347\253\257\345\217\243\347\232\204\350\277\233\347\250\213.md"
@@ -0,0 +1,63 @@
+## 查看端口占用情况
+
+`lsof -i`：用于查看所有IPV4/6端口占用情况
+
+`lsof -i:port`：查看指定端口的占用情况
+
+```shell
+[root@yw ~]# lsof -i:80
+COMMAND  PID USER   FD   TYPE    DEVICE SIZE/OFF NODE NAME
+nginx   1124 root    9u  IPv4      8842      0t0  TCP *:http (LISTEN)
+nginx   1125 root    9u  IPv4      8842      0t0  TCP *:http (LISTEN)
+nginx   1126 root    9u  IPv4      8842      0t0  TCP *:http (LISTEN)
+nginx   1127 root    9u  IPv4      8842      0t0  TCP *:http (LISTEN)
+nginx   1128 root    9u  IPv4      8842      0t0  TCP *:http (LISTEN)
+java    9535 root  149u  IPv4 148223160      0t0  TCP 192.168.10.110:64885->192.168.10.110:http (CLOSE_WAIT)
+```
+
+**列名解释**
+
+>  COMMAND：进程名称
+>  PID：进程标示符
+>  USER：用户
+>  FD：文件描述符，应用程序通过文件描述符识别该文件，如cwd、txt等
+>  TYPE：文件类型，如DIR
+>  DEVICE：指定磁盘的名称
+>  SIZE/OFF：文件大小
+>  NODE：索引节点（文件在磁盘上的标识）
+>  NAME：打开文件的确切名称
+
+
+## 查看TCP、UDP的端口和进程情况
+
+`netstat -tunlp`用于显示tcp、udp的端口和进程等相关情况。
+
+> -t：（tcp）仅显示tcp相关选项
+>
+> -u：（udp）仅显示udp相关选项
+>
+> -n：拒绝显示别名，能显示数字的全部转换为数字
+>
+> -l：仅列出有在 Listen(监听) 的服务状态
+>
+> -p：显示建立相关链接的程序名
+
+```shell
+[root@yw ~]# netstat -tunlp
+Active Internet connections (only servers)
+Proto Recv-Q Send-Q Local Address   Foreign Address     State      PID/Program name   
+tcp        0      0 0.0.0.0:445       0.0.0.0:*        LISTEN      1179/smbd           
+tcp        0      0 0.0.0.0:8001      0.0.0.0:*        LISTEN      10600/java   
+```
+
+从上面的日志中可以看出端口号以及PID。
+
+`netstat -tunlp | grep 80`
+
+```shell
+[root@yw ~]# netstat -tunlp | grep 80      
+tcp        0      0 0.0.0.0:80        0.0.0.0:*        LISTEN      1124/nginx          
+```
+
+
+
diff --git "a/linux/\350\231\232\346\213\237\346\234\272\350\256\276\347\275\256\351\235\231\346\200\201ip.md" "b/linux/\350\231\232\346\213\237\346\234\272\350\256\276\347\275\256\351\235\231\346\200\201ip.md"
new file mode 100644
index 0000000..2536b13
--- /dev/null
+++ "b/linux/\350\231\232\346\213\237\346\234\272\350\256\276\347\275\256\351\235\231\346\200\201ip.md"
@@ -0,0 +1,66 @@
+## Linux虚拟机设置静态ip
+
+### 1、获取网关地址
+
+该文档中使用**VMware**创建linux虚拟机，所有我们的网关地址从**VMware**中进行获取。
+
+1. 打开VMware主界面
+2. 点击`编辑`->`虚拟网络编辑器`
+3. 单击`NAT 模式`后可以查看最下边一行为：子网IP和子网掩码
+4. 单击`NAT 设置`，查看或修改`网关 IP`
+
+该文档中`网关IP`使用192.168.73.2
+
+
+
+### 2、配置静态ip
+
+使用`ifconfig`命令查看当前虚拟机的网卡信息
+
+```
+ens33: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
+        inet 192.168.73.151  netmask 255.255.255.0  broadcast 192.168.73.255
+        inet6 fe80::e24c:de6e:faf9:312e  prefixlen 64  scopeid 0x20<link>
+        ether 00:0c:29:b8:66:21  txqueuelen 1000  (Ethernet)
+        RX packets 254  bytes 24518 (23.9 KiB)
+        RX errors 0  dropped 0  overruns 0  frame 0
+        TX packets 248  bytes 25016 (24.4 KiB)
+        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
+
+lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
+        inet 127.0.0.1  netmask 255.0.0.0
+        inet6 ::1  prefixlen 128  scopeid 0x10<host>
+        loop  txqueuelen 1000  (Local Loopback)
+        RX packets 0  bytes 0 (0.0 B)
+        RX errors 0  dropped 0  overruns 0  frame 0
+        TX packets 0  bytes 0 (0.0 B)
+        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
+```
+
+由上可知当前虚拟机的网卡为`ens33`
+
+使用`vim`修改`/etc/sysconfig/network-scripts/ifcfg-ens33`
+
+```
+ONBOOT="yes"
+BOOTPROTO="static"
+IPADDR="192.168.73.151"
+NETMASK="255.255.255.0"
+GATEWAY="192.168.73.2"
+```
+
+
+
+### 3、配置DNS
+
+修改`/etc/resolv.conf`
+
+```
+nameserver 192.168.73.2
+```
+
+
+
+### 4、 使配置生效
+
+重启主机或使用`service network restart`即可使配置生效。
\ No newline at end of file
diff --git "a/lua/\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203.md" "b/lua/\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203.md"
new file mode 100644
index 0000000..332f13b
--- /dev/null
+++ "b/lua/\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203.md"
@@ -0,0 +1,32 @@
+# 搭建Lua开发环境
+
+## 下载 Lua
+
+进入[lua官网](http://www.lua.org)下载windows办二进制包
+
+## 配置环境变量
+
+将下载的二进制包解压后放入文件夹中，如：`C:\Program Files\Lua`，同时将该路径配置到**path**环境变量中。
+
+
+
+## Sublime配置Lua环境
+
+1、打开sublime,选择`Tools -> Build System -> New Build System`
+
+2、在打开的文件中输入一下内容：
+
+```json
+{  
+    "cmd": ["lua","$file"],  
+    "file_regex":"^(...*?):([0-9]*):?([0-9]*)",  
+    "selector":"source.lua"  
+}  
+```
+
+并将该文件保存到`C:\Users\zh\AppData\Roaming\Sublime Text 3\Packages\User`目录下，名称为`WindowsLua.sublime-build`
+
+3、重启sublime，选择`Tools -> Build System -> WindowsLua`，lua环境完成
+
+4、使用**F7**或**F8**可以调试程序
+
diff --git a/springboot/images/springboot_1_01.png b/springboot/images/springboot_1_01.png
new file mode 100644
index 0000000..fd9e4fc
Binary files /dev/null and b/springboot/images/springboot_1_01.png differ
diff --git a/springboot/images/springboot_1_02.png b/springboot/images/springboot_1_02.png
new file mode 100644
index 0000000..cf2d09a
Binary files /dev/null and b/springboot/images/springboot_1_02.png differ
diff --git a/springboot/images/springboot_1_03.png b/springboot/images/springboot_1_03.png
new file mode 100644
index 0000000..6858d2d
Binary files /dev/null and b/springboot/images/springboot_1_03.png differ
diff --git a/springboot/images/springboot_2_01.png b/springboot/images/springboot_2_01.png
new file mode 100644
index 0000000..35791e4
Binary files /dev/null and b/springboot/images/springboot_2_01.png differ
diff --git a/springboot/images/springboot_3_01.png b/springboot/images/springboot_3_01.png
new file mode 100644
index 0000000..9c7d1b1
Binary files /dev/null and b/springboot/images/springboot_3_01.png differ
diff --git a/springboot/images/springboot_3_02.png b/springboot/images/springboot_3_02.png
new file mode 100644
index 0000000..46d1f6d
Binary files /dev/null and b/springboot/images/springboot_3_02.png differ
diff --git a/springboot/images/springboot_3_03.png b/springboot/images/springboot_3_03.png
new file mode 100644
index 0000000..b2e192a
Binary files /dev/null and b/springboot/images/springboot_3_03.png differ
diff --git a/springboot/images/springboot_3_04.png b/springboot/images/springboot_3_04.png
new file mode 100644
index 0000000..62ce96a
Binary files /dev/null and b/springboot/images/springboot_3_04.png differ
diff --git a/springboot/images/springboot_4_01.png b/springboot/images/springboot_4_01.png
new file mode 100644
index 0000000..24fb8cd
Binary files /dev/null and b/springboot/images/springboot_4_01.png differ
diff --git a/springboot/images/springboot_4_02.png b/springboot/images/springboot_4_02.png
new file mode 100644
index 0000000..93c077e
Binary files /dev/null and b/springboot/images/springboot_4_02.png differ
diff --git a/springboot/images/springboot_4_03.png b/springboot/images/springboot_4_03.png
new file mode 100644
index 0000000..57f0970
Binary files /dev/null and b/springboot/images/springboot_4_03.png differ
diff --git a/springboot/images/springboot_4_04.png b/springboot/images/springboot_4_04.png
new file mode 100644
index 0000000..35aa555
Binary files /dev/null and b/springboot/images/springboot_4_04.png differ
diff --git a/springboot/images/springboot_4_05.png b/springboot/images/springboot_4_05.png
new file mode 100644
index 0000000..de870b1
Binary files /dev/null and b/springboot/images/springboot_4_05.png differ
diff --git a/springboot/images/springboot_4_06.png b/springboot/images/springboot_4_06.png
new file mode 100644
index 0000000..71dc6cd
Binary files /dev/null and b/springboot/images/springboot_4_06.png differ
diff --git a/springboot/images/springboot_4_07.png b/springboot/images/springboot_4_07.png
new file mode 100644
index 0000000..95a55ef
Binary files /dev/null and b/springboot/images/springboot_4_07.png differ
diff --git a/springboot/images/springboot_4_08.png b/springboot/images/springboot_4_08.png
new file mode 100644
index 0000000..9b1b409
Binary files /dev/null and b/springboot/images/springboot_4_08.png differ
diff --git a/springboot/images/springboot_4_09.png b/springboot/images/springboot_4_09.png
new file mode 100644
index 0000000..8813c26
Binary files /dev/null and b/springboot/images/springboot_4_09.png differ
diff --git a/springboot/images/springboot_4_10.png b/springboot/images/springboot_4_10.png
new file mode 100644
index 0000000..368e33c
Binary files /dev/null and b/springboot/images/springboot_4_10.png differ
diff --git a/springboot/images/springboot_4_11.png b/springboot/images/springboot_4_11.png
new file mode 100644
index 0000000..e6fbf2c
Binary files /dev/null and b/springboot/images/springboot_4_11.png differ
diff --git a/springboot/images/springboot_4_12.png b/springboot/images/springboot_4_12.png
new file mode 100644
index 0000000..5ac2c5a
Binary files /dev/null and b/springboot/images/springboot_4_12.png differ
diff --git a/springboot/images/springboot_4_13.png b/springboot/images/springboot_4_13.png
new file mode 100644
index 0000000..bd44e3a
Binary files /dev/null and b/springboot/images/springboot_4_13.png differ
diff --git a/springboot/images/springboot_4_14.png b/springboot/images/springboot_4_14.png
new file mode 100644
index 0000000..9a234f5
Binary files /dev/null and b/springboot/images/springboot_4_14.png differ
diff --git a/springboot/images/springboot_4_15.png b/springboot/images/springboot_4_15.png
new file mode 100644
index 0000000..7d89211
Binary files /dev/null and b/springboot/images/springboot_4_15.png differ
diff --git a/springboot/images/springboot_5_01.png b/springboot/images/springboot_5_01.png
new file mode 100644
index 0000000..e06088a
Binary files /dev/null and b/springboot/images/springboot_5_01.png differ
diff --git a/springboot/images/springboot_5_02.png b/springboot/images/springboot_5_02.png
new file mode 100644
index 0000000..2c2d8e0
Binary files /dev/null and b/springboot/images/springboot_5_02.png differ
diff --git a/springboot/images/springboot_5_03.png b/springboot/images/springboot_5_03.png
new file mode 100644
index 0000000..8b1c5cd
Binary files /dev/null and b/springboot/images/springboot_5_03.png differ
diff --git a/springboot/images/springboot_6_01.png b/springboot/images/springboot_6_01.png
new file mode 100644
index 0000000..85a8e84
Binary files /dev/null and b/springboot/images/springboot_6_01.png differ
diff --git a/springboot/images/springboot_6_02.png b/springboot/images/springboot_6_02.png
new file mode 100644
index 0000000..62410d7
Binary files /dev/null and b/springboot/images/springboot_6_02.png differ
diff --git a/springboot/images/springboot_7_01.png b/springboot/images/springboot_7_01.png
new file mode 100644
index 0000000..d94c0a4
Binary files /dev/null and b/springboot/images/springboot_7_01.png differ
diff --git a/springboot/images/springboot_7_02.png b/springboot/images/springboot_7_02.png
new file mode 100644
index 0000000..fd7d0e6
Binary files /dev/null and b/springboot/images/springboot_7_02.png differ
diff --git "a/springboot/\344\270\212\344\274\240\345\244\247\346\226\207\344\273\266\346\212\245\351\224\231.md" "b/springboot/\344\270\212\344\274\240\345\244\247\346\226\207\344\273\266\346\212\245\351\224\231.md"
new file mode 100644
index 0000000..a2b9141
--- /dev/null
+++ "b/springboot/\344\270\212\344\274\240\345\244\247\346\226\207\344\273\266\346\212\245\351\224\231.md"
@@ -0,0 +1,16 @@
+### 原因
+
+SpringBoot 默认配置的上传文件的大小为1MB，超过配置的文件进行上传则会报错。并且SpringBoot2的配置不同于SpringBoot1, SpringBoot2已将上传文件从`http`转换为`servlet`的属性。
+
+### 解决方案
+
+在`application.yml`中配置如下两条配置
+
+```yaml
+spring:
+  servlet: 
+    multipart:
+      max-file-size: 10MB
+      max-request-size: 15MB
+```
+
diff --git "a/springboot/\344\277\256\346\224\271JSON\350\275\254\346\215\242\345\231\250.md" "b/springboot/\344\277\256\346\224\271JSON\350\275\254\346\215\242\345\231\250.md"
new file mode 100644
index 0000000..2caa463
--- /dev/null
+++ "b/springboot/\344\277\256\346\224\271JSON\350\275\254\346\215\242\345\231\250.md"
@@ -0,0 +1,26 @@
+## 修改预定义的JSON转换器
+
+ springboot2.x版本修改了以前设置转换器的方式
+
+### 原方式：
+
+通过实现`org.springframework.web.servlet.config.annotation.WebMvcConfigurer`接口，实现`configureMessageConverters(List<HttpMessageConverter<?>> converters)`方法后，将自定义的转换器添加到`converters`集合的最后面即可。
+
+### 现方式：
+
+现在需要提供一个`org.springframework.boot.autoconfigure.http.HttpMessageConverters`类的bean到spring容器中,用于将预定义的转换器集合替换掉才行。
+
+对比以前的方式，现在的方式更加灵活，spring也不需要从源转换器集合中寻找，直接使用用户提供的集合。
+
+实现方式
+
+```java
+  @Bean
+  public HttpMessageConverters httpMessageConverters() {
+    // 自定义json格式化
+    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(
+        JsonUtil.getMapper());
+    return new HttpMessageConverters(converter);
+  }
+```
+
diff --git "a/springboot/\345\205\245\351\227\250/1_\345\205\245\351\227\250.md" "b/springboot/\345\205\245\351\227\250/1_\345\205\245\351\227\250.md"
new file mode 100644
index 0000000..dfa624f
--- /dev/null
+++ "b/springboot/\345\205\245\351\227\250/1_\345\205\245\351\227\250.md"
@@ -0,0 +1,272 @@
+# 一、Spring Boot 入门
+
+## 1、Spring Boot 简介
+
+> 简化Spring应用开发的一个框架；
+>
+> 整个Spring技术栈的一个大整合；
+>
+> J2EE开发的一站式解决方案；
+
+## 2、微服务
+
+2014，martin fowler
+
+微服务：架构风格（服务微化）
+
+一个应用应该是一组小型服务；可以通过HTTP的方式进行互通；
+
+单体应用：ALL IN ONE
+
+微服务：每一个功能元素最终都是一个可独立替换和独立升级的软件单元；
+
+[详细参照微服务文档](https://martinfowler.com/articles/microservices.html#MicroservicesAndSoa)
+
+
+
+## 3、环境准备
+
+环境约束
+
+–jdk1.8：Spring Boot 推荐jdk1.7及以上；java version "1.8.0_112"
+
+–maven3.x：maven 3.3以上版本；Apache Maven 3.3.9
+
+–IntelliJIDEA2017：IntelliJ IDEA 2017.2.2 x64、STS
+
+–SpringBoot 1.5.9.RELEASE：1.5.9；
+
+
+
+### 1、MAVEN设置；
+
+给maven 的settings.xml配置文件的profiles标签添加
+
+```xml
+<profile>
+  <id>jdk-1.8</id>
+  <activation>
+    <activeByDefault>true</activeByDefault>
+    <jdk>1.8</jdk>
+  </activation>
+  <properties>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+ <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
+  </properties>
+</profile>
+```
+
+### 2、IDEA设置
+
+整合maven进来；
+
+![idea设置](images/springboot_1_01.png)
+
+![images/](images/springboot_1_02.png)
+
+## 4、Spring Boot HelloWorld
+
+一个功能：
+
+浏览器发送hello请求，服务器接受请求并处理，响应Hello World字符串；
+
+
+### 1、创建一个maven工程；（jar）
+
+### 2、导入spring boot相关的依赖
+
+```xml
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>1.5.9.RELEASE</version>
+    </parent>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+    </dependencies>
+```
+
+### 3、编写一个主程序；启动Spring Boot应用
+
+```java
+/**
+ *  @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
+ */
+@SpringBootApplication
+public class HelloWorldMainApplication {
+    public static void main(String[] args) {
+        // Spring应用启动起来
+        SpringApplication.run(HelloWorldMainApplication.class,args);
+    }
+}
+```
+
+### 4、编写相关的Controller、Service
+
+```java
+@Controller
+public class HelloController {
+    @ResponseBody
+    @RequestMapping("/hello")
+    public String hello(){
+        return "Hello World!";
+    }
+}
+
+```
+
+### 5、运行主程序测试
+
+### 6、简化部署
+
+```xml
+ <!-- 这个插件，可以将应用打包成一个可执行的jar包；-->
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+```
+
+将这个应用打成jar包，直接使用java -jar的命令进行执行；
+
+## 5、Hello World探究
+
+### 1、POM文件
+
+#### 1、父项目
+
+```xml
+<parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>1.5.9.RELEASE</version>
+</parent>
+
+他的父项目是
+<parent>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-dependencies</artifactId>
+  <version>1.5.9.RELEASE</version>
+  <relativePath>../../spring-boot-dependencies</relativePath>
+</parent>
+他来真正管理Spring Boot应用里面的所有依赖版本；
+
+```
+
+Spring Boot的版本仲裁中心；
+
+以后我们导入依赖默认是不需要写版本；（没有在dependencies里面管理的依赖自然需要声明版本号）
+
+#### 2、启动器
+
+```xml
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-web</artifactId>
+</dependency>
+```
+
+**spring-boot-starter**：
+
+spring-boot-starter：spring-boot场景启动器；帮我们导入了web模块正常运行所依赖的组件；
+
+Spring Boot将所有的功能场景都抽取出来，做成一个个的starters（启动器），只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器
+
+### 2、主程序类，主入口类
+
+```java
+/**
+ *  @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
+ */
+@SpringBootApplication
+public class HelloWorldMainApplication {
+    public static void main(String[] args) {
+        // Spring应用启动起来
+        SpringApplication.run(HelloWorldMainApplication.class,args);
+    }
+}
+
+```
+
+@**SpringBootApplication**:    Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；
+
+```java
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@SpringBootConfiguration
+@EnableAutoConfiguration
+@ComponentScan(excludeFilters = {
+      @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
+      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
+public @interface SpringBootApplication {
+```
+
+@**SpringBootConfiguration**:Spring Boot的配置类；
+
+标注在某个类上，表示这是一个Spring Boot的配置类；
+	
+@**Configuration**:配置类上来标注这个注解；
+	
+配置类 -----  配置文件；配置类也是容器中的一个组件；@Component
+
+@**EnableAutoConfiguration**：开启自动配置功能；
+
+以前我们需要配置的东西，Spring Boot帮我们自动配置；@**EnableAutoConfiguration**告诉SpringBoot开启自动配置功能；这样自动配置才能生效；
+
+```java
+@AutoConfigurationPackage
+@Import(EnableAutoConfigurationImportSelector.class)
+public @interface EnableAutoConfiguration {
+```
+
+@**AutoConfigurationPackage**：自动配置包
+
+@**Import**(AutoConfigurationPackages.Registrar.class)：
+
+Spring的底层注解@Import，给容器中导入一个组件；导入的组件由AutoConfigurationPackages.Registrar.class；
+
+==将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器；==
+
+@**Import**(EnableAutoConfigurationImportSelector.class)；
+	
+给容器中导入组件？
+	
+**EnableAutoConfigurationImportSelector**：导入哪些组件的选择器；
+	
+将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中；
+	
+会给容器中导入非常多的自动配置类（xxxAutoConfiguration）；就是给容器中导入这个场景需要的所有组件，并配置好这些组件；		![自动配置类](images/springboot_1_03.png)
+
+有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；
+
+SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader)；
+
+==Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作；==以前我们需要自己配置的东西，自动配置类都帮我们；
+
+J2EE的整体整合解决方案和自动配置都在spring-boot-autoconfigure-1.5.9.RELEASE.jar；
+
+## 6、使用Spring Initializer快速创建Spring Boot项目
+
+### 1、IDEA：使用 Spring Initializer快速创建项目
+
+IDE都支持使用Spring的项目创建向导快速创建一个Spring Boot项目；
+
+选择我们需要的模块；向导会联网创建Spring Boot项目；
+
+默认生成的Spring Boot项目；
+
+- 主程序已经生成好了，我们只需要我们自己的逻辑
+- resources文件夹中目录结构
+  - static：保存所有的静态资源； js css  images；
+  - templates：保存所有的模板页面；（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面）；可以使用模板引擎（freemarker、thymeleaf）；
+  - application.properties：Spring Boot应用的配置文件；可以修改一些默认设置；
\ No newline at end of file
diff --git "a/springboot/\345\205\245\351\227\250/2_\351\205\215\347\275\256.md" "b/springboot/\345\205\245\351\227\250/2_\351\205\215\347\275\256.md"
new file mode 100644
index 0000000..ff75170
--- /dev/null
+++ "b/springboot/\345\205\245\351\227\250/2_\351\205\215\347\275\256.md"
@@ -0,0 +1,580 @@
+# 二、配置文件
+
+## 1、配置文件
+
+SpringBoot使用一个全局的配置文件，配置文件名是固定的；
+
+• application.properties
+
+• application.yml
+
+
+配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好；
+
+YAML（YAML Ain't Markup Language）
+
+* YAML  A Markup Language：是一个标记语言
+
+* YAML   isn't Markup Language：不是一个标记语言；
+
+标记语言：
+
+以前的配置文件；大多都使用的是  **xxxx.xml**文件；
+	
+YAML：**以数据为中心**，比json、xml等更适合做配置文件；
+	
+**YAML**
+
+```yaml
+server:
+  port: 8081
+```
+
+**XML**：
+
+```xml
+<server>
+	<port>8081</port>
+</server>
+```
+
+## 2、YAML语法：
+
+### 1、基本语法
+
+k:(空格)v：表示一对键值对（空格必须有）；
+
+以**空格**的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的
+
+```yaml
+server:
+    port: 8081
+    path: /hello
+```
+
+属性和值也是大小写敏感；
+
+### 2、值的写法
+
+#### 字面量：普通的值（数字，字符串，布尔）
+
+k: v：字面直接来写；
+	
+字符串默认不用加上单引号或者双引号；
+	
+""：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思
+	
+name:   "zhangsan \n lisi"：输出；zhangsan 换行  lisi
+	
+''：单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据
+	
+name:   ‘zhangsan \n lisi’：输出；zhangsan \n  lisi
+
+
+#### 对象、Map（属性和值）（键值对）：
+
+k: v：在下一行来写对象的属性和值的关系；注意缩进
+	
+对象还是k: v的方式
+
+```yaml
+friends:
+		lastName: zhangsan
+		age: 20
+```
+
+行内写法：
+
+```yaml
+friends: {lastName: zhangsan,age: 18}
+```
+
+#### 数组（List、Set）：
+
+用- 值表示数组中的一个元素
+
+```yaml
+pets:
+ - cat
+ - dog
+ - pig
+```
+
+行内写法
+
+```yaml
+pets: [cat,dog,pig]
+```
+
+## 3、配置文件值注入
+
+配置文件
+
+```yaml
+person:
+    lastName: hello
+    age: 18
+    boss: false
+    birth: 2017/12/12
+    maps: {k1: v1,k2: 12}
+    lists:
+      - lisi
+      - zhaoliu
+    dog:
+      name: 小狗
+      age: 12
+```
+
+javaBean：
+
+```java
+/**
+ * 将配置文件中配置的每一个属性的值，映射到这个组件中
+ * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
+ *      prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
+ *
+ * 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
+ *
+ */
+@Component
+@ConfigurationProperties(prefix = "person")
+public class Person {
+
+    private String lastName;
+    private Integer age;
+    private Boolean boss;
+    private Date birth;
+
+    private Map<String,Object> maps;
+    private List<Object> lists;
+    private Dog dog;
+
+```
+
+我们可以导入配置文件处理器，以后编写配置就有提示了
+
+```xml
+<!--导入配置文件处理器，配置文件进行绑定就会有提示-->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-configuration-processor</artifactId>
+			<optional>true</optional>
+        </dependency>
+```
+
+#### 1、properties配置文件在idea中默认utf-8可能会乱码
+
+调整
+
+![idea配置乱码](images/springboot_2_01.png)
+
+#### 2、@Value获取值和@ConfigurationProperties获取值比较
+
+|                      | @ConfigurationProperties | @Value     |
+| -------------------- | ------------------------ | ---------- |
+| 功能                 | 批量注入配置文件中的属性 | 一个个指定 |
+| 松散绑定（松散语法） | 支持                     | 不支持     |
+| SpEL                 | 不支持                   | 支持       |
+| JSR303数据校验       | 支持                     | 不支持     |
+| 复杂类型封装         | 支持                     | 不支持     |
+
+配置文件yml还是properties他们都能获取到值；
+
+如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value；
+
+如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties；
+
+#### 3、配置文件注入值数据校验
+
+```java
+@Component
+@ConfigurationProperties(prefix = "person")
+@Validated
+public class Person {
+
+    /**
+     * <bean class="Person">
+     *      <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
+     * <bean/>
+     */
+     
+   //lastName必须是邮箱格式
+    @Email
+    //@Value("${person.last-name}")
+    private String lastName;
+    //@Value("#{11*2}")
+    private Integer age;
+    //@Value("true")
+    private Boolean boss;
+
+    private Date birth;
+    private Map<String,Object> maps;
+    private List<Object> lists;
+    private Dog dog;
+```
+
+#### 4、@PropertySource&@ImportResource&@Bean
+
+@**PropertySource**：加载指定的配置文件；
+
+```java
+/**
+ * 将配置文件中配置的每一个属性的值，映射到这个组件中
+ * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
+ *      prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
+ *
+ * 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
+ *  @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值；
+ *
+ */
+@PropertySource(value = {"classpath:person.properties"})
+@Component
+@ConfigurationProperties(prefix = "person")
+//@Validated
+public class Person {
+
+    /**
+     * <bean class="Person">
+     *      <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
+     * <bean/>
+     */
+
+   //lastName必须是邮箱格式
+   // @Email
+    //@Value("${person.last-name}")
+    private String lastName;
+    //@Value("#{11*2}")
+    private Integer age;
+    //@Value("true")
+    private Boolean boss;
+
+```
+
+@**ImportResource**：导入Spring的配置文件，让配置文件里面的内容生效；
+
+Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；
+
+想让Spring的配置文件生效，加载进来；@**ImportResource**标注在一个配置类上
+
+```java
+@ImportResource(locations = {"classpath:beans.xml"})
+导入Spring的配置文件让其生效
+```
+
+不来编写Spring的配置文件
+
+```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">
+
+    <bean id="helloService" class="com.atguigu.springboot.service.HelloService"></bean>
+</beans>
+```
+
+SpringBoot推荐给容器中添加组件的方式；推荐使用全注解的方式
+
+1、配置类**@Configuration**------>Spring配置文件
+
+2、使用**@Bean**给容器中添加组件
+
+```java
+/**
+ * @Configuration：指明当前类是一个配置类；就是来替代之前的Spring配置文件
+ *
+ * 在配置文件中用<bean><bean/>标签添加组件
+ *
+ */
+@Configuration
+public class MyAppConfig {
+
+    //将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
+    @Bean
+    public HelloService helloService02(){
+        System.out.println("配置类@Bean给容器中添加组件了...");
+        return new HelloService();
+    }
+}
+```
+
+##4、配置文件占位符
+
+### 1、随机数
+
+```java
+${random.value}、${random.int}、${random.long}
+${random.int(10)}、${random.int[1024,65536]}
+
+```
+
+### 2、占位符获取之前配置的值，如果没有可以是用:指定默认值
+
+```properties
+person.last-name=张三${random.uuid}
+person.age=${random.int}
+person.birth=2017/12/15
+person.boss=false
+person.maps.k1=v1
+person.maps.k2=14
+person.lists=a,b,c
+person.dog.name=${person.hello:hello}_dog
+person.dog.age=15
+```
+
+## 5、Profile
+
+### 1、多Profile文件
+
+我们在主配置文件编写的时候，文件名可以是   application-{profile}.properties/yml
+
+默认使用application.properties的配置；
+
+### 2、yml支持多文档块方式
+
+```yml
+
+server:
+  port: 8081
+spring:
+  profiles:
+    active: prod
+
+---
+server:
+  port: 8083
+spring:
+  profiles: dev
+
+
+---
+
+server:
+  port: 8084
+spring:
+  profiles: prod  #指定属于哪个环境
+```
+
+### 3、激活指定profile
+
+1、在配置文件中指定  spring.profiles.active=dev
+	
+2、命令行：
+	
+java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev；
+	
+可以直接在测试的时候，配置传入命令行参数
+	
+3、虚拟机参数；
+	
+-Dspring.profiles.active=dev
+
+## 6、配置文件加载位置
+
+springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件
+
+–file:./config/
+
+–file:./
+
+–classpath:/config/
+
+–classpath:/
+
+优先级由高到底，高优先级的配置会覆盖低优先级的配置；
+
+SpringBoot会从这四个位置全部加载主配置文件；**互补配置**；
+
+==我们还可以通过spring.config.location来改变默认的配置文件位置==
+
+**项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；**
+
+java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties
+
+## 7、外部配置加载顺序
+
+**==SpringBoot也可以从以下位置加载配置； 优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置==**
+
+**1.命令行参数**
+
+所有的配置都可以在命令行上进行指定
+
+java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087  --server.context-path=/abc
+
+多个配置用空格分开； --配置项=值
+
+2.来自java:comp/env的JNDI属性
+
+3.Java系统属性（System.getProperties()）
+
+4.操作系统环境变量
+
+5.RandomValuePropertySource配置的random.*属性值
+
+==**由jar包外向jar包内进行寻找；**==
+
+==**优先加载带profile**==
+
+**6.jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件**
+
+**7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件**
+
+==**再来加载不带profile**==
+
+**8.jar包外部的application.properties或application.yml(不带spring.profile)配置文件**
+
+**9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件**
+
+10.@Configuration注解类上的@PropertySource
+
+11.通过SpringApplication.setDefaultProperties指定的默认属性
+
+所有支持的配置加载来源；
+
+[参考官方文档](https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#boot-features-external-config)
+
+## 8、自动配置原理
+
+配置文件到底能写什么？怎么写？自动配置原理；
+
+[配置文件能配置的属性参照](https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#common-application-properties)
+
+### 1、**自动配置原理：**
+
+1）、SpringBoot启动的时候加载主配置类，开启了自动配置功能 ==@EnableAutoConfiguration==
+
+**2）、@EnableAutoConfiguration 作用：**
+
+- 利用EnableAutoConfigurationImportSelector给容器中导入一些组件？
+
+- 可以查看selectImports()方法的内容；
+
+- List<String> configurations = getCandidateConfigurations(annotationMetadata,      attributes);获取候选的配置
+
+```java
+    SpringFactoriesLoader.loadFactoryNames()
+    扫描所有jar包类路径下  META-INF/spring.factories
+    把扫描到的这些文件的内容包装成properties对象
+    从properties中获取到EnableAutoConfiguration.class类（类名）对应的值，然后把他们添加在容器中
+```
+
+**==将 类路径下  META-INF/spring.factories 里面配置的所有EnableAutoConfiguration的值加入到了容器中；==**
+
+```properties
+# Auto Configure
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
+...
+```
+
+每一个这样的  xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；
+
+3）、每一个自动配置类进行自动配置功能；
+
+4）、以**HttpEncodingAutoConfiguration（Http编码自动配置）**为例解释自动配置原理；
+
+```java
+@Configuration   //表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
+@EnableConfigurationProperties(HttpEncodingProperties.class)  //启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到ioc容器中
+
+@ConditionalOnWebApplication //Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；    判断当前应用是否是web应用，如果是，当前配置类生效
+
+@ConditionalOnClass(CharacterEncodingFilter.class)  //判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；
+
+@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)  //判断配置文件中是否存在某个配置  spring.http.encoding.enabled；如果不存在，判断也是成立的
+//即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
+public class HttpEncodingAutoConfiguration {
+  
+  	//他已经和SpringBoot的配置文件映射了
+  	private final HttpEncodingProperties properties;
+  
+   //只有一个有参构造器的情况下，参数的值就会从容器中拿
+  	public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
+		this.properties = properties;
+	}
+  
+    @Bean   //给容器中添加一个组件，这个组件的某些值需要从properties中获取
+	@ConditionalOnMissingBean(CharacterEncodingFilter.class) //判断容器没有这个组件？
+	public CharacterEncodingFilter characterEncodingFilter() {
+		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
+		filter.setEncoding(this.properties.getCharset().name());
+		filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
+		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
+		return filter;
+	}
+```
+
+根据当前不同的条件判断，决定这个配置类是否生效？
+
+一但这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
+
+5）、所有在配置文件中能配置的属性都是在xxxxProperties类中封装者‘；配置文件能配置什么就可以参照某个功能对应的这个属性类
+
+```java
+@ConfigurationProperties(prefix = "spring.http.encoding")  //从配置文件中获取指定的值和bean的属性进行绑定
+public class HttpEncodingProperties {
+
+   public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
+```
+
+**精髓：**
+
+**1）、SpringBoot启动会加载大量的自动配置类**
+	
+**2）、我们看我们需要的功能有没有SpringBoot默认写好的自动配置类；**
+	
+**3）、我们再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件有，我们就不需要再来配置了）**
+	
+**4）、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值；**
+
+xxxxAutoConfigurartion：自动配置类；
+
+给容器中添加组件
+
+xxxxProperties:封装配置文件中相关属性；
+
+### 2、细节
+
+#### 1、@Conditional派生注解（Spring注解版原生的@Conditional作用）
+
+作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效；
+
+| @Conditional扩展注解            | 作用（判断是否满足当前指定条件）                 |
+| ------------------------------- | ------------------------------------------------ |
+| @ConditionalOnJava              | 系统的java版本是否符合要求                       |
+| @ConditionalOnBean              | 容器中存在指定Bean；                             |
+| @ConditionalOnMissingBean       | 容器中不存在指定Bean；                           |
+| @ConditionalOnExpression        | 满足SpEL表达式指定                               |
+| @ConditionalOnClass             | 系统中有指定的类                                 |
+| @ConditionalOnMissingClass      | 系统中没有指定的类                               |
+| @ConditionalOnSingleCandidate   | 容器中只有一个指定的Bean，或者这个Bean是首选Bean |
+| @ConditionalOnProperty          | 系统中指定的属性是否有指定的值                   |
+| @ConditionalOnResource          | 类路径下是否存在指定资源文件                     |
+| @ConditionalOnWebApplication    | 当前是web环境                                    |
+| @ConditionalOnNotWebApplication | 当前不是web环境                                  |
+| @ConditionalOnJndi              | JNDI存在指定项                                   |
+
+**自动配置类必须在一定的条件下才能生效；**
+
+我们怎么知道哪些自动配置类生效；
+
+**==我们可以通过启用  debug=true属性；来让控制台打印自动配置报告==**，这样我们就可以很方便的知道哪些自动配置类生效；
+
+```java
+=========================
+AUTO-CONFIGURATION REPORT
+=========================
+
+Positive matches:（自动配置类启用的）
+-----------------
+
+   DispatcherServletAutoConfiguration matched:
+      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
+        
+Negative matches:（没有启动，没有匹配成功的自动配置类）
+-----------------
+
+   ActiveMQAutoConfiguration:
+      Did not match:
+         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
+```
\ No newline at end of file
diff --git "a/springboot/\345\205\245\351\227\250/3_\346\227\245\345\277\227.md" "b/springboot/\345\205\245\351\227\250/3_\346\227\245\345\277\227.md"
new file mode 100644
index 0000000..9dad6e7
--- /dev/null
+++ "b/springboot/\345\205\245\351\227\250/3_\346\227\245\345\277\227.md"
@@ -0,0 +1,300 @@
+# 三、日志
+
+## 1、日志框架
+
+ 小张；开发一个大型系统；
+
+		1、System.out.println("")；将关键数据打印在控制台；去掉？写在一个文件？
+	
+		2、框架来记录系统的一些运行时信息；日志框架 ；  zhanglogging.jar；
+	
+		3、高大上的几个功能？异步模式？自动归档？xxxx？  zhanglogging-good.jar？
+	
+		4、将以前框架卸下来？换上新的框架，重新修改之前相关的API；zhanglogging-prefect.jar；
+	
+		5、JDBC---数据库驱动；
+	
+			写了一个统一的接口层；日志门面（日志的一个抽象层）；logging-abstract.jar；
+	
+			给项目中导入具体的日志实现就行了；我们之前的日志框架都是实现的抽象层；
+
+**市面上的日志框架；**
+
+JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j....
+
+| 日志门面  （日志的抽象层）                                   | 日志实现                                             |
+| ------------------------------------------------------------ | ---------------------------------------------------- |
+| ~~JCL（Jakarta  Commons Logging）~~    SLF4j（Simple  Logging Facade for Java）    **~~jboss-logging~~** | Log4j  JUL（java.util.logging）  Log4j2  **Logback** |
+
+左边选一个门面（抽象层）、右边来选一个实现；
+
+日志门面：  SLF4J；
+
+日志实现：Logback；
+
+SpringBoot：底层是Spring框架，Spring框架默认是用JCL；‘
+
+	**==SpringBoot选用 SLF4j和logback；==**
+
+## 2、SLF4j使用
+
+### 1、如何在系统中使用SLF4j   https://www.slf4j.org
+
+以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法；
+
+给系统里面导入slf4j的jar和  logback的实现jar
+
+```java
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class HelloWorld {
+  public static void main(String[] args) {
+    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
+    logger.info("Hello World");
+  }
+}
+```
+
+图示；
+
+![images/concrete-bindings.png](images/springboot_3_01.png)
+
+每一个日志的实现框架都有自己的配置文件。使用slf4j以后，**配置文件还是做成日志实现框架自己本身的配置文件；**
+
+### 2、遗留问题
+
+a（slf4j+logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx
+
+统一日志记录，即使是别的框架和我一起统一使用slf4j进行输出？
+
+![](images/springboot_3_02.png)
+
+**如何让系统中所有的日志都统一到slf4j；**
+
+==1、将系统中其他日志框架先排除出去；==
+
+==2、用中间包来替换原有的日志框架；==
+
+==3、我们导入slf4j其他的实现==
+
+## 3、SpringBoot日志关系
+
+```xml
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter</artifactId>
+		</dependency>
+```
+
+SpringBoot使用它来做日志功能；
+
+```xml
+	<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-logging</artifactId>
+		</dependency>
+```
+
+底层依赖关系
+
+![](images/springboot_3_03.png)
+
+总结：
+
+	1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录
+	
+	2）、SpringBoot也把其他的日志都替换成了slf4j；
+	
+	3）、中间替换包？
+
+```java
+@SuppressWarnings("rawtypes")
+public abstract class LogFactory {
+
+    static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";
+
+    static LogFactory logFactory = new SLF4JLogFactory();
+```
+
+![](images/springboot_3_04.png)
+
+	4）、如果我们要引入其他框架？一定要把这个框架的默认日志依赖移除掉？
+	
+			Spring框架用的是commons-logging；
+
+```xml
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-core</artifactId>
+			<exclusions>
+				<exclusion>
+					<groupId>commons-logging</groupId>
+					<artifactId>commons-logging</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+```
+
+**==SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；==**
+
+## 4、日志使用；
+
+### 1、默认配置
+
+SpringBoot默认帮我们配置好了日志；
+
+```java
+	//记录器
+	Logger logger = LoggerFactory.getLogger(getClass());
+	@Test
+	public void contextLoads() {
+		//System.out.println();
+
+		//日志的级别；
+		//由低到高   trace<debug<info<warn<error
+		//可以调整输出的日志级别；日志就只会在这个级别以以后的高级别生效
+		logger.trace("这是trace日志...");
+		logger.debug("这是debug日志...");
+		//SpringBoot默认给我们使用的是info级别的，没有指定级别的就用SpringBoot默认规定的级别；root级别
+		logger.info("这是info日志...");
+		logger.warn("这是warn日志...");
+		logger.error("这是error日志...");
+	}
+```
+
+        日志输出格式：
+    		%d表示日期时间，
+    		%thread表示线程名，
+    		%-5level：级别从左显示5个字符宽度
+    		%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
+    		%msg：日志消息，
+    		%n是换行符
+        -->
+        %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
+SpringBoot修改日志的默认配置
+
+```properties
+logging.level.com.atguigu=trace
+
+#logging.path=
+# 不指定路径在当前项目下生成springboot.log日志
+# 可以指定完整的路径；
+#logging.file=G:/springboot.log
+
+# 在当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用 spring.log 作为默认文件
+logging.path=/spring/log
+
+#  在控制台输出的日志的格式
+logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n
+# 指定文件中日志输出的格式
+logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} ==== %msg%n
+```
+
+| logging.file | logging.path | Example  | Description                        |
+| ------------ | ------------ | -------- | ---------------------------------- |
+| (none)       | (none)       |          | 只在控制台输出                     |
+| 指定文件名   | (none)       | my.log   | 输出日志到my.log文件               |
+| (none)       | 指定目录     | /var/log | 输出到指定目录的 spring.log 文件中 |
+
+### 2、指定配置
+
+给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不使用他默认配置的了
+
+| Logging System          | Customization                                                |
+| ----------------------- | ------------------------------------------------------------ |
+| Logback                 | `logback-spring.xml`, `logback-spring.groovy`, `logback.xml` or `logback.groovy` |
+| Log4j2                  | `log4j2-spring.xml` or `log4j2.xml`                          |
+| JDK (Java Util Logging) | `logging.properties`                                         |
+
+logback.xml：直接就被日志框架识别了；
+
+**logback-spring.xml**：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot的高级Profile功能
+
+```xml
+<springProfile name="staging">
+    <!-- configuration to be enabled when the "staging" profile is active -->
+  	可以指定某段配置只在某个环境下生效
+</springProfile>
+
+```
+
+如：
+
+```xml
+<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
+        <!--
+        日志输出格式：
+			%d表示日期时间，
+			%thread表示线程名，
+			%-5level：级别从左显示5个字符宽度
+			%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
+			%msg：日志消息，
+			%n是换行符
+        -->
+        <layout class="ch.qos.logback.classic.PatternLayout">
+            <springProfile name="dev">
+                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
+            </springProfile>
+            <springProfile name="!dev">
+                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
+            </springProfile>
+        </layout>
+    </appender>
+```
+
+
+
+如果使用logback.xml作为日志配置文件，还要使用profile功能，会有以下错误
+
+ `no applicable action for [springProfile]`
+
+## 5、切换日志框架
+
+可以按照slf4j的日志适配图，进行相关的切换；
+
+slf4j+log4j的方式；
+
+```xml
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-web</artifactId>
+  <exclusions>
+    <exclusion>
+      <artifactId>logback-classic</artifactId>
+      <groupId>ch.qos.logback</groupId>
+    </exclusion>
+    <exclusion>
+      <artifactId>log4j-over-slf4j</artifactId>
+      <groupId>org.slf4j</groupId>
+    </exclusion>
+  </exclusions>
+</dependency>
+
+<dependency>
+  <groupId>org.slf4j</groupId>
+  <artifactId>slf4j-log4j12</artifactId>
+</dependency>
+
+```
+
+切换为log4j2
+
+```xml
+   <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+            <exclusions>
+                <exclusion>
+                    <artifactId>spring-boot-starter-logging</artifactId>
+                    <groupId>org.springframework.boot</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+    <dependency>
+         <groupId>org.springframework.boot</groupId>
+         <artifactId>spring-boot-starter-log4j2</artifactId>
+    </dependency>
+```
+
diff --git "a/springboot/\345\205\245\351\227\250/4_web.md" "b/springboot/\345\205\245\351\227\250/4_web.md"
new file mode 100644
index 0000000..987b9cd
--- /dev/null
+++ "b/springboot/\345\205\245\351\227\250/4_web.md"
@@ -0,0 +1,1846 @@
+# 四、Web开发
+
+## 1、简介
+
+使用SpringBoot；
+
+**1）、创建SpringBoot应用，选中我们需要的模块；**
+
+**2）、SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来**
+
+**3）、自己编写业务代码；**
+
+
+
+**自动配置原理？**
+
+这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？xxx
+
+```
+xxxxAutoConfiguration：帮我们给容器中自动配置组件；
+xxxxProperties:配置类来封装配置文件的内容；
+```
+
+## 2、SpringBoot对静态资源的映射规则；
+
+```java
+@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
+public class ResourceProperties implements ResourceLoaderAware {
+  //可以设置和静态资源有关的参数，缓存时间等
+```
+
+```java
+	WebMvcAuotConfiguration：
+		@Override
+		public void addResourceHandlers(ResourceHandlerRegistry registry) {
+			if (!this.resourceProperties.isAddMappings()) {
+				logger.debug("Default resource handling disabled");
+				return;
+			}
+			Integer cachePeriod = this.resourceProperties.getCachePeriod();
+			if (!registry.hasMappingForPattern("/webjars/**")) {
+				customizeResourceHandlerRegistration(
+						registry.addResourceHandler("/webjars/**")
+								.addResourceLocations(
+										"classpath:/META-INF/resources/webjars/")
+						.setCachePeriod(cachePeriod));
+			}
+			String staticPathPattern = this.mvcProperties.getStaticPathPattern();
+          	//静态资源文件夹映射
+			if (!registry.hasMappingForPattern(staticPathPattern)) {
+				customizeResourceHandlerRegistration(
+						registry.addResourceHandler(staticPathPattern)
+								.addResourceLocations(
+										this.resourceProperties.getStaticLocations())
+						.setCachePeriod(cachePeriod));
+			}
+		}
+
+        //配置欢迎页映射
+		@Bean
+		public WelcomePageHandlerMapping welcomePageHandlerMapping(
+				ResourceProperties resourceProperties) {
+			return new WelcomePageHandlerMapping(resourceProperties.getWelcomePage(),
+					this.mvcProperties.getStaticPathPattern());
+		}
+
+       //配置喜欢的图标
+		@Configuration
+		@ConditionalOnProperty(value = "spring.mvc.favicon.enabled", matchIfMissing = true)
+		public static class FaviconConfiguration {
+
+			private final ResourceProperties resourceProperties;
+
+			public FaviconConfiguration(ResourceProperties resourceProperties) {
+				this.resourceProperties = resourceProperties;
+			}
+
+			@Bean
+			public SimpleUrlHandlerMapping faviconHandlerMapping() {
+				SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
+				mapping.setOrder(Ordered.HIGHEST_PRECEDENCE + 1);
+              	//所有  **/favicon.ico 
+				mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
+						faviconRequestHandler()));
+				return mapping;
+			}
+
+			@Bean
+			public ResourceHttpRequestHandler faviconRequestHandler() {
+				ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
+				requestHandler
+						.setLocations(this.resourceProperties.getFaviconLocations());
+				return requestHandler;
+			}
+
+		}
+
+```
+
+==1）、所有 /webjars/** ，都去 classpath:/META-INF/resources/webjars/ 找资源；==
+
+	webjars：以jar包的方式引入静态资源；
+
+http://www.webjars.org/
+
+![](images/springboot_4_01.png)
+
+localhost:8080/webjars/jquery/3.3.1/jquery.js
+
+```xml
+<!--引入jquery-webjar-->在访问的时候只需要写webjars下面资源的名称即可
+		<dependency>
+			<groupId>org.webjars</groupId>
+			<artifactId>jquery</artifactId>
+			<version>3.3.1</version>
+		</dependency>
+```
+
+==2）、"/**" 访问当前项目的任何资源，都去（静态资源的文件夹）找映射==
+
+```
+"classpath:/META-INF/resources/", 
+"classpath:/resources/",
+"classpath:/static/", 
+"classpath:/public/" 
+"/"：当前项目的根路径
+```
+
+localhost:8080/abc ===  去静态资源文件夹里面找abc
+
+==3）、欢迎页； 静态资源文件夹下的所有index.html页面；被"/**"映射；==
+
+	localhost:8080/   找index页面
+
+==4）、所有的 **/favicon.ico  都是在静态资源文件下找；==
+
+
+
+## 3、模板引擎
+
+JSP、Velocity、Freemarker、Thymeleaf
+
+![](images/springboot_4_02.png)
+
+SpringBoot推荐的Thymeleaf；
+
+语法更简单，功能更强大；
+
+
+
+### 1、引入thymeleaf；
+
+```xml
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-thymeleaf</artifactId>
+          	2.1.6
+		</dependency>
+切换thymeleaf版本
+<properties>
+		<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
+		<!-- 布局功能的支持程序  thymeleaf3主程序  layout2以上版本 -->
+		<!-- thymeleaf2   layout1-->
+		<thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
+  </properties>
+```
+
+
+
+### 2、Thymeleaf使用
+
+```java
+@ConfigurationProperties(prefix = "spring.thymeleaf")
+public class ThymeleafProperties {
+
+	private static final Charset DEFAULT_ENCODING = Charset.forName("UTF-8");
+
+	private static final MimeType DEFAULT_CONTENT_TYPE = MimeType.valueOf("text/html");
+
+	public static final String DEFAULT_PREFIX = "classpath:/templates/";
+
+	public static final String DEFAULT_SUFFIX = ".html";
+  	//
+```
+
+只要我们把HTML页面放在classpath:/templates/，thymeleaf就能自动渲染；
+
+使用：
+
+1、导入thymeleaf的名称空间
+
+```xml
+<html lang="en" xmlns:th="http://www.thymeleaf.org">
+```
+
+2、使用thymeleaf语法；
+
+```html
+<!DOCTYPE html>
+<html lang="en" xmlns:th="http://www.thymeleaf.org">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+</head>
+<body>
+    <h1>成功！</h1>
+    <!--th:text 将div里面的文本内容设置为 -->
+    <div th:text="${hello}">这是显示欢迎信息</div>
+</body>
+</html>
+```
+
+### 3、语法规则
+
+1）、th:text；改变当前元素里面的文本内容；
+
+	th：任意html属性；来替换原生属性的值
+
+![](images/springboot_4_03.png)
+
+2）、表达式？
+
+```properties
+Simple expressions:（表达式语法）
+    Variable Expressions: ${...}：获取变量值；OGNL；
+    		1）、获取对象的属性、调用方法
+    		2）、使用内置的基本对象：
+    			#ctx : the context object.
+    			#vars: the context variables.
+                #locale : the context locale.
+                #request : (only in Web Contexts) the HttpServletRequest object.
+                #response : (only in Web Contexts) the HttpServletResponse object.
+                #session : (only in Web Contexts) the HttpSession object.
+                #servletContext : (only in Web Contexts) the ServletContext object.
+                
+                ${session.foo}
+            3）、内置的一些工具对象：
+#execInfo : information about the template being processed.
+#messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.
+#uris : methods for escaping parts of URLs/URIs
+#conversions : methods for executing the configured conversion service (if any).
+#dates : methods for java.util.Date objects: formatting, component extraction, etc.
+#calendars : analogous to #dates , but for java.util.Calendar objects.
+#numbers : methods for formatting numeric objects.
+#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
+#objects : methods for objects in general.
+#bools : methods for boolean evaluation.
+#arrays : methods for arrays.
+#lists : methods for lists.
+#sets : methods for sets.
+#maps : methods for maps.
+#aggregates : methods for creating aggregates on arrays or collections.
+#ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).
+
+    Selection Variable Expressions: *{...}：选择表达式：和${}在功能上是一样；
+    	补充：配合 th:object="${session.user}：
+   <div th:object="${session.user}">
+    <p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
+    <p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
+    <p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>
+    </div>
+    
+    Message Expressions: #{...}：获取国际化内容
+    Link URL Expressions: @{...}：定义URL；
+    		@{/order/process(execId=${execId},execType='FAST')}
+    Fragment Expressions: ~{...}：片段引用表达式
+    		<div th:insert="~{commons :: main}">...</div>
+    		
+Literals（字面量）
+      Text literals: 'one text' , 'Another one!' ,…
+      Number literals: 0 , 34 , 3.0 , 12.3 ,…
+      Boolean literals: true , false
+      Null literal: null
+      Literal tokens: one , sometext , main ,…
+Text operations:（文本操作）
+    String concatenation: +
+    Literal substitutions: |The name is ${name}|
+Arithmetic operations:（数学运算）
+    Binary operators: + , - , * , / , %
+    Minus sign (unary operator): -
+Boolean operations:（布尔运算）
+    Binary operators: and , or
+    Boolean negation (unary operator): ! , not
+Comparisons and equality:（比较运算）
+    Comparators: > , < , >= , <= ( gt , lt , ge , le )
+    Equality operators: == , != ( eq , ne )
+Conditional operators:条件运算（三元运算符）
+    If-then: (if) ? (then)
+    If-then-else: (if) ? (then) : (else)
+    Default: (value) ?: (defaultvalue)
+Special tokens:
+    No-Operation: _ 
+```
+
+## 4、SpringMVC自动配置
+
+https://docs.spring.io/spring-boot/docs/1.5.10.RELEASE/reference/htmlsingle/#boot-features-developing-web-applications
+
+### 1. Spring MVC auto-configuration
+
+Spring Boot 自动配置好了SpringMVC
+
+以下是SpringBoot对SpringMVC的默认配置:**==（WebMvcAutoConfiguration）==**
+
+- Inclusion of `ContentNegotiatingViewResolver` and `BeanNameViewResolver` beans.
+  - 自动配置了ViewResolver（视图解析器：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？））
+  - ContentNegotiatingViewResolver：组合所有的视图解析器的；
+  - ==如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其组合进来；==
+
+- Support for serving static resources, including support for WebJars (see below).静态资源文件夹路径,webjars
+
+- Static `index.html` support. 静态首页访问
+
+- Custom `Favicon` support (see below).  favicon.ico
+
+- 自动注册了 of `Converter`, `GenericConverter`, `Formatter` beans.
+
+  - Converter：转换器；  public String hello(User user)：类型转换使用Converter
+  - `Formatter`  格式化器；  2017.12.17===Date；
+
+```java
+		@Bean
+		@ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")//在文件中配置日期格式化的规则
+		public Formatter<Date> dateFormatter() {
+			return new DateFormatter(this.mvcProperties.getDateFormat());//日期格式化组件
+		}
+```
+
+	==自己添加的格式化器转换器，我们只需要放在容器中即可==
+
+- Support for `HttpMessageConverters` (see below).
+
+  - HttpMessageConverter：SpringMVC用来转换Http请求和响应的；User---Json；
+
+  - `HttpMessageConverters` 是从容器中确定；获取所有的HttpMessageConverter；
+
+    ==自己给容器中添加HttpMessageConverter，只需要将自己的组件注册容器中（@Bean,@Component）==
+
+- Automatic registration of `MessageCodesResolver` (see below).定义错误代码生成规则
+
+- Automatic use of a `ConfigurableWebBindingInitializer` bean (see below).
+
+  ==我们可以配置一个ConfigurableWebBindingInitializer来替换默认的；（添加到容器）==
+
+  ```
+  初始化WebDataBinder；
+  请求数据=====JavaBean；
+  ```
+
+**org.springframework.boot.autoconfigure.web：web的所有自动场景；**
+
+If you want to keep Spring Boot MVC features, and you just want to add additional [MVC configuration](https://docs.spring.io/spring/docs/4.3.14.RELEASE/spring-framework-reference/htmlsingle#mvc) (interceptors, formatters, view controllers etc.) you can add your own `@Configuration` class of type `WebMvcConfigurerAdapter`, but **without** `@EnableWebMvc`. If you wish to provide custom instances of `RequestMappingHandlerMapping`, `RequestMappingHandlerAdapter` or `ExceptionHandlerExceptionResolver` you can declare a `WebMvcRegistrationsAdapter` instance providing such components.
+
+If you want to take complete control of Spring MVC, you can add your own `@Configuration` annotated with `@EnableWebMvc`.
+
+### 2、扩展SpringMVC
+
+```xml
+    <mvc:view-controller path="/hello" view-name="success"/>
+    <mvc:interceptors>
+        <mvc:interceptor>
+            <mvc:mapping path="/hello"/>
+            <bean></bean>
+        </mvc:interceptor>
+    </mvc:interceptors>
+```
+
+**==编写一个配置类（@Configuration），是WebMvcConfigurerAdapter类型；不能标注@EnableWebMvc==**;
+
+既保留了所有的自动配置，也能用我们扩展的配置；
+
+```java
+//使用WebMvcConfigurerAdapter可以来扩展SpringMVC的功能
+@Configuration
+public class MyMvcConfig extends WebMvcConfigurerAdapter {
+
+    @Override
+    public void addViewControllers(ViewControllerRegistry registry) {
+       // super.addViewControllers(registry);
+        //浏览器发送 /atguigu 请求来到 success
+        registry.addViewController("/atguigu").setViewName("success");
+    }
+}
+```
+
+原理：
+
+	1）、WebMvcAutoConfiguration是SpringMVC的自动配置类
+	
+	2）、在做其他自动配置时会导入；@Import(**EnableWebMvcConfiguration**.class)
+
+```java
+    @Configuration
+	public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
+      private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
+
+	 //从容器中获取所有的WebMvcConfigurer
+      @Autowired(required = false)
+      public void setConfigurers(List<WebMvcConfigurer> configurers) {
+          if (!CollectionUtils.isEmpty(configurers)) {
+              this.configurers.addWebMvcConfigurers(configurers);
+            	//一个参考实现；将所有的WebMvcConfigurer相关配置都来一起调用；  
+            	@Override
+             // public void addViewControllers(ViewControllerRegistry registry) {
+              //    for (WebMvcConfigurer delegate : this.delegates) {
+               //       delegate.addViewControllers(registry);
+               //   }
+              }
+          }
+	}
+```
+
+	3）、容器中所有的WebMvcConfigurer都会一起起作用；
+	
+	4）、我们的配置类也会被调用；
+	
+	效果：SpringMVC的自动配置和我们的扩展配置都会起作用；
+
+### 3、全面接管SpringMVC；
+
+SpringBoot对SpringMVC的自动配置不需要了，所有都是我们自己配置；所有的SpringMVC的自动配置都失效了
+
+**我们需要在配置类中添加@EnableWebMvc即可；**
+
+```java
+//使用WebMvcConfigurerAdapter可以来扩展SpringMVC的功能
+@EnableWebMvc
+@Configuration
+public class MyMvcConfig extends WebMvcConfigurerAdapter {
+
+    @Override
+    public void addViewControllers(ViewControllerRegistry registry) {
+       // super.addViewControllers(registry);
+        //浏览器发送 /atguigu 请求来到 success
+        registry.addViewController("/atguigu").setViewName("success");
+    }
+}
+```
+
+原理：
+
+为什么@EnableWebMvc自动配置就失效了；
+
+1）@EnableWebMvc的核心
+
+```java
+@Import(DelegatingWebMvcConfiguration.class)
+public @interface EnableWebMvc {
+```
+
+2）、
+
+```java
+@Configuration
+public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
+```
+
+3）、
+
+```java
+@Configuration
+@ConditionalOnWebApplication
+@ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
+		WebMvcConfigurerAdapter.class })
+//容器中没有这个组件的时候，这个自动配置类才生效
+@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
+@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
+@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
+		ValidationAutoConfiguration.class })
+public class WebMvcAutoConfiguration {
+```
+
+4）、@EnableWebMvc将WebMvcConfigurationSupport组件导入进来；
+
+5）、导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能；
+
+
+
+## 5、如何修改SpringBoot的默认配置
+
+模式：
+
+	1）、SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（@Bean、@Component）如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以有多个（ViewResolver）将用户配置的和自己默认的组合起来；
+	
+	2）、在SpringBoot中会有非常多的xxxConfigurer帮助我们进行扩展配置
+	
+	3）、在SpringBoot中会有很多的xxxCustomizer帮助我们进行定制配置
+
+## 6、RestfulCRUD
+
+### 1）、默认访问首页
+
+```java
+
+//使用WebMvcConfigurerAdapter可以来扩展SpringMVC的功能
+//@EnableWebMvc   不要接管SpringMVC
+@Configuration
+public class MyMvcConfig extends WebMvcConfigurerAdapter {
+
+    @Override
+    public void addViewControllers(ViewControllerRegistry registry) {
+       // super.addViewControllers(registry);
+        //浏览器发送 /atguigu 请求来到 success
+        registry.addViewController("/atguigu").setViewName("success");
+    }
+
+    //所有的WebMvcConfigurerAdapter组件都会一起起作用
+    @Bean //将组件注册在容器
+    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
+        WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
+            @Override
+            public void addViewControllers(ViewControllerRegistry registry) {
+                registry.addViewController("/").setViewName("login");
+                registry.addViewController("/index.html").setViewName("login");
+            }
+        };
+        return adapter;
+    }
+}
+
+```
+
+### 2）、国际化
+
+**1）、编写国际化配置文件；**
+
+2）、使用ResourceBundleMessageSource管理国际化资源文件
+
+3）、在页面使用fmt:message取出国际化内容
+
+
+
+步骤：
+
+1）、编写国际化配置文件，抽取页面需要显示的国际化消息
+
+![](images/springboot_4_04.png)
+
+
+
+2）、SpringBoot自动配置好了管理国际化资源文件的组件；
+
+```java
+@ConfigurationProperties(prefix = "spring.messages")
+public class MessageSourceAutoConfiguration {
+    
+    /**
+	 * Comma-separated list of basenames (essentially a fully-qualified classpath
+	 * location), each following the ResourceBundle convention with relaxed support for
+	 * slash based locations. If it doesn't contain a package qualifier (such as
+	 * "org.mypackage"), it will be resolved from the classpath root.
+	 */
+	private String basename = "messages";  
+    //我们的配置文件可以直接放在类路径下叫messages.properties；
+    
+    @Bean
+	public MessageSource messageSource() {
+		ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
+		if (StringUtils.hasText(this.basename)) {
+            //设置国际化资源文件的基础名（去掉语言国家代码的）
+			messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(
+					StringUtils.trimAllWhitespace(this.basename)));
+		}
+		if (this.encoding != null) {
+			messageSource.setDefaultEncoding(this.encoding.name());
+		}
+		messageSource.setFallbackToSystemLocale(this.fallbackToSystemLocale);
+		messageSource.setCacheSeconds(this.cacheSeconds);
+		messageSource.setAlwaysUseMessageFormat(this.alwaysUseMessageFormat);
+		return messageSource;
+	}
+```
+
+
+
+3）、去页面获取国际化的值；
+
+![](images/springboot_4_05.png)
+
+
+
+```html
+<!DOCTYPE html>
+<html lang="en"  xmlns:th="http://www.thymeleaf.org">
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+		<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+		<meta name="description" content="">
+		<meta name="author" content="">
+		<title>Signin Template for Bootstrap</title>
+		<!-- Bootstrap core CSS -->
+		<link href="asserts/css/bootstrap.min.css" th:href="@{/webjars/bootstrap/4.0.0/css/bootstrap.css}" rel="stylesheet">
+		<!-- Custom styles for this template -->
+		<link href="asserts/css/signin.css" th:href="@{/asserts/css/signin.css}" rel="stylesheet">
+	</head>
+
+	<body class="text-center">
+		<form class="form-signin" action="dashboard.html">
+			<img class="mb-4" th:src="@{/asserts/img/bootstrap-solid.svg}" src="asserts/img/bootstrap-solid.svg" alt="" width="72" height="72">
+			<h1 class="h3 mb-3 font-weight-normal" th:text="#{login.tip}">Please sign in</h1>
+			<label class="sr-only" th:text="#{login.username}">Username</label>
+			<input type="text" class="form-control" placeholder="Username" th:placeholder="#{login.username}" required="" autofocus="">
+			<label class="sr-only" th:text="#{login.password}">Password</label>
+			<input type="password" class="form-control" placeholder="Password" th:placeholder="#{login.password}" required="">
+			<div class="checkbox mb-3">
+				<label>
+          		<input type="checkbox" value="remember-me"/> [[#{login.remember}]]
+        </label>
+			</div>
+			<button class="btn btn-lg btn-primary btn-block" type="submit" th:text="#{login.btn}">Sign in</button>
+			<p class="mt-5 mb-3 text-muted">© 2017-2018</p>
+			<a class="btn btn-sm">中文</a>
+			<a class="btn btn-sm">English</a>
+		</form>
+
+	</body>
+
+</html>
+```
+
+效果：根据浏览器语言设置的信息切换了国际化；
+
+原理：
+
+	国际化Locale（区域信息对象）；LocaleResolver（获取区域信息对象）；
+
+```java
+		@Bean
+		@ConditionalOnMissingBean
+		@ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
+		public LocaleResolver localeResolver() {
+			if (this.mvcProperties
+					.getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
+				return new FixedLocaleResolver(this.mvcProperties.getLocale());
+			}
+			AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
+			localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
+			return localeResolver;
+		}
+默认的就是根据请求头带来的区域信息获取Locale进行国际化
+```
+
+4）、点击链接切换国际化
+
+```java
+/**
+ * 可以在连接上携带区域信息
+ */
+public class MyLocaleResolver implements LocaleResolver {
+    
+    @Override
+    public Locale resolveLocale(HttpServletRequest request) {
+        String l = request.getParameter("l");
+        Locale locale = Locale.getDefault();
+        if(!StringUtils.isEmpty(l)){
+            String[] split = l.split("_");
+            locale = new Locale(split[0],split[1]);
+        }
+        return locale;
+    }
+
+    @Override
+    public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {
+
+    }
+}
+
+
+ @Bean
+    public LocaleResolver localeResolver(){
+        return new MyLocaleResolver();
+    }
+}
+
+
+```
+
+### 3）、登陆
+
+开发期间模板引擎页面修改以后，要实时生效
+
+1）、禁用模板引擎的缓存
+
+```
+# 禁用缓存
+spring.thymeleaf.cache=false 
+```
+
+2）、页面修改完成以后ctrl+f9：重新编译；
+
+登陆错误消息的显示
+
+```html
+<p style="color: red" th:text="${msg}" th:if="${not #strings.isEmpty(msg)}"></p>
+```
+
+
+
+### 4）、拦截器进行登陆检查
+
+拦截器
+
+```java
+
+/**
+ * 登陆检查，
+ */
+public class LoginHandlerInterceptor implements HandlerInterceptor {
+    //目标方法执行之前
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        Object user = request.getSession().getAttribute("loginUser");
+        if(user == null){
+            //未登陆，返回登陆页面
+            request.setAttribute("msg","没有权限请先登陆");
+            request.getRequestDispatcher("/index.html").forward(request,response);
+            return false;
+        }else{
+            //已登陆，放行请求
+            return true;
+        }
+
+    }
+
+    @Override
+    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
+
+    }
+
+    @Override
+    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
+
+    }
+}
+
+```
+
+
+
+注册拦截器
+
+```java
+  //所有的WebMvcConfigurerAdapter组件都会一起起作用
+    @Bean //将组件注册在容器
+    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
+        WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
+            @Override
+            public void addViewControllers(ViewControllerRegistry registry) {
+                registry.addViewController("/").setViewName("login");
+                registry.addViewController("/index.html").setViewName("login");
+                registry.addViewController("/main.html").setViewName("dashboard");
+            }
+
+            //注册拦截器
+            @Override
+            public void addInterceptors(InterceptorRegistry registry) {
+                //super.addInterceptors(registry);
+                //静态资源；  *.css , *.js
+                //SpringBoot已经做好了静态资源映射
+                registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**")
+                        .excludePathPatterns("/index.html","/","/user/login");
+            }
+        };
+        return adapter;
+    }
+```
+
+### 5）、CRUD-员工列表
+
+实验要求：
+
+1）、RestfulCRUD：CRUD满足Rest风格；
+
+URI：  /资源名称/资源标识       HTTP请求方式区分对资源CRUD操作
+
+|      | 普通CRUD（uri来区分操作） | RestfulCRUD       |
+| ---- | ------------------------- | ----------------- |
+| 查询 | getEmp                    | emp---GET         |
+| 添加 | addEmp?xxx                | emp---POST        |
+| 修改 | updateEmp?id=xxx&xxx=xx   | emp/{id}---PUT    |
+| 删除 | deleteEmp?id=1            | emp/{id}---DELETE |
+
+2）、实验的请求架构;
+
+| 实验功能                             | 请求URI | 请求方式 |
+| ------------------------------------ | ------- | -------- |
+| 查询所有员工                         | emps    | GET      |
+| 查询某个员工(来到修改页面)           | emp/1   | GET      |
+| 来到添加页面                         | emp     | GET      |
+| 添加员工                             | emp     | POST     |
+| 来到修改页面（查出员工进行信息回显） | emp/1   | GET      |
+| 修改员工                             | emp     | PUT      |
+| 删除员工                             | emp/1   | DELETE   |
+
+3）、员工列表：
+
+#### thymeleaf公共页面元素抽取
+
+```html
+1、抽取公共片段
+<div th:fragment="copy">
+&copy; 2011 The Good Thymes Virtual Grocery
+</div>
+
+2、引入公共片段
+<div th:insert="~{footer :: copy}"></div>
+~{templatename::selector}：模板名::选择器
+~{templatename::fragmentname}:模板名::片段名
+
+3、默认效果：
+insert的公共片段在div标签中
+如果使用th:insert等属性进行引入，可以不用写~{}：
+行内写法可以加上：[[~{}]];[(~{})]；
+```
+
+
+
+三种引入公共片段的th属性：
+
+**th:insert**：将公共片段整个插入到声明引入的元素中
+
+**th:replace**：将声明引入的元素替换为公共片段
+
+**th:include**：将被引入的片段的内容包含进这个标签中
+
+
+
+```html
+<footer th:fragment="copy">
+&copy; 2011 The Good Thymes Virtual Grocery
+</footer>
+
+引入方式
+<div th:insert="footer :: copy"></div>
+<div th:replace="footer :: copy"></div>
+<div th:include="footer :: copy"></div>
+
+效果
+<div>
+    <footer>
+    &copy; 2011 The Good Thymes Virtual Grocery
+    </footer>
+</div>
+
+<footer>
+&copy; 2011 The Good Thymes Virtual Grocery
+</footer>
+
+<div>
+&copy; 2011 The Good Thymes Virtual Grocery
+</div>
+```
+
+
+
+引入片段的时候传入参数： 
+
+```html
+
+<nav class="col-md-2 d-none d-md-block bg-light sidebar" id="sidebar">
+    <div class="sidebar-sticky">
+        <ul class="nav flex-column">
+            <li class="nav-item">
+                <a class="nav-link active"
+                   th:class="${activeUri=='main.html'?'nav-link active':'nav-link'}"
+                   href="#" th:href="@{/main.html}">
+                    <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-home">
+                        <path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path>
+                        <polyline points="9 22 9 12 15 12 15 22"></polyline>
+                    </svg>
+                    Dashboard <span class="sr-only">(current)</span>
+                </a>
+            </li>
+
+<!--引入侧边栏;传入参数-->
+<div th:replace="commons/bar::#sidebar(activeUri='emps')"></div>
+```
+
+### 6）、CRUD-员工添加
+
+添加页面
+
+```html
+<form>
+    <div class="form-group">
+        <label>LastName</label>
+        <input type="text" class="form-control" placeholder="zhangsan">
+    </div>
+    <div class="form-group">
+        <label>Email</label>
+        <input type="email" class="form-control" placeholder="zhangsan@atguigu.com">
+    </div>
+    <div class="form-group">
+        <label>Gender</label><br/>
+        <div class="form-check form-check-inline">
+            <input class="form-check-input" type="radio" name="gender"  value="1">
+            <label class="form-check-label">男</label>
+        </div>
+        <div class="form-check form-check-inline">
+            <input class="form-check-input" type="radio" name="gender"  value="0">
+            <label class="form-check-label">女</label>
+        </div>
+    </div>
+    <div class="form-group">
+        <label>department</label>
+        <select class="form-control">
+            <option>1</option>
+            <option>2</option>
+            <option>3</option>
+            <option>4</option>
+            <option>5</option>
+        </select>
+    </div>
+    <div class="form-group">
+        <label>Birth</label>
+        <input type="text" class="form-control" placeholder="zhangsan">
+    </div>
+    <button type="submit" class="btn btn-primary">添加</button>
+</form>
+```
+
+提交的数据格式不对：生日：日期；
+
+2017-12-12；2017/12/12；2017.12.12；
+
+日期的格式化；SpringMVC将页面提交的值需要转换为指定的类型;
+
+2017-12-12---Date； 类型转换，格式化;
+
+默认日期是按照/的方式；
+
+### 7）、CRUD-员工修改
+
+修改添加二合一表单
+
+```html
+<!--需要区分是员工修改还是添加；-->
+<form th:action="@{/emp}" method="post">
+    <!--发送put请求修改员工数据-->
+    <!--
+1、SpringMVC中配置HiddenHttpMethodFilter;（SpringBoot自动配置好的）
+2、页面创建一个post表单
+3、创建一个input项，name="_method";值就是我们指定的请求方式
+-->
+    <input type="hidden" name="_method" value="put" th:if="${emp!=null}"/>
+    <input type="hidden" name="id" th:if="${emp!=null}" th:value="${emp.id}">
+    <div class="form-group">
+        <label>LastName</label>
+        <input name="lastName" type="text" class="form-control" placeholder="zhangsan" th:value="${emp!=null}?${emp.lastName}">
+    </div>
+    <div class="form-group">
+        <label>Email</label>
+        <input name="email" type="email" class="form-control" placeholder="zhangsan@atguigu.com" th:value="${emp!=null}?${emp.email}">
+    </div>
+    <div class="form-group">
+        <label>Gender</label><br/>
+        <div class="form-check form-check-inline">
+            <input class="form-check-input" type="radio" name="gender" value="1" th:checked="${emp!=null}?${emp.gender==1}">
+            <label class="form-check-label">男</label>
+        </div>
+        <div class="form-check form-check-inline">
+            <input class="form-check-input" type="radio" name="gender" value="0" th:checked="${emp!=null}?${emp.gender==0}">
+            <label class="form-check-label">女</label>
+        </div>
+    </div>
+    <div class="form-group">
+        <label>department</label>
+        <!--提交的是部门的id-->
+        <select class="form-control" name="department.id">
+            <option th:selected="${emp!=null}?${dept.id == emp.department.id}" th:value="${dept.id}" th:each="dept:${depts}" th:text="${dept.departmentName}">1</option>
+        </select>
+    </div>
+    <div class="form-group">
+        <label>Birth</label>
+        <input name="birth" type="text" class="form-control" placeholder="zhangsan" th:value="${emp!=null}?${#dates.format(emp.birth, 'yyyy-MM-dd HH:mm')}">
+    </div>
+    <button type="submit" class="btn btn-primary" th:text="${emp!=null}?'修改':'添加'">添加</button>
+</form>
+```
+
+### 8）、CRUD-员工删除
+
+```html
+<tr th:each="emp:${emps}">
+    <td th:text="${emp.id}"></td>
+    <td>[[${emp.lastName}]]</td>
+    <td th:text="${emp.email}"></td>
+    <td th:text="${emp.gender}==0?'女':'男'"></td>
+    <td th:text="${emp.department.departmentName}"></td>
+    <td th:text="${#dates.format(emp.birth, 'yyyy-MM-dd HH:mm')}"></td>
+    <td>
+        <a class="btn btn-sm btn-primary" th:href="@{/emp/}+${emp.id}">编辑</a>
+        <button th:attr="del_uri=@{/emp/}+${emp.id}" class="btn btn-sm btn-danger deleteBtn">删除</button>
+    </td>
+</tr>
+
+
+<script>
+    $(".deleteBtn").click(function(){
+        //删除当前员工的
+        $("#deleteEmpForm").attr("action",$(this).attr("del_uri")).submit();
+        return false;
+    });
+</script>
+```
+
+
+
+## 7、错误处理机制
+
+### 1）、SpringBoot默认的错误处理机制
+
+默认效果：
+
+		1）、浏览器，返回一个默认的错误页面
+
+![](images/springboot_4_14.png)
+
+  浏览器发送请求的请求头：
+
+![](images/springboot_4_06.png)
+
+		2）、如果是其他客户端，默认响应一个json数据
+
+![](images/springboot_4_15.png)
+
+![](images/springboot_4_07.png)
+
+原理：
+
+	可以参照ErrorMvcAutoConfiguration；错误处理的自动配置；
+
+  	给容器中添加了以下组件
+
+	1、DefaultErrorAttributes：
+
+```java
+帮我们在页面共享信息；
+@Override
+	public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
+			boolean includeStackTrace) {
+		Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
+		errorAttributes.put("timestamp", new Date());
+		addStatus(errorAttributes, requestAttributes);
+		addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
+		addPath(errorAttributes, requestAttributes);
+		return errorAttributes;
+	}
+```
+
+
+
+	2、BasicErrorController：处理默认/error请求
+
+```java
+@Controller
+@RequestMapping("${server.error.path:${error.path:/error}}")
+public class BasicErrorController extends AbstractErrorController {
+    
+    @RequestMapping(produces = "text/html")//产生html类型的数据；浏览器发送的请求来到这个方法处理
+	public ModelAndView errorHtml(HttpServletRequest request,
+			HttpServletResponse response) {
+		HttpStatus status = getStatus(request);
+		Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
+				request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
+		response.setStatus(status.value());
+        
+        //去哪个页面作为错误页面；包含页面地址和页面内容
+		ModelAndView modelAndView = resolveErrorView(request, response, status, model);
+		return (modelAndView == null ? new ModelAndView("error", model) : modelAndView);
+	}
+
+	@RequestMapping
+	@ResponseBody    //产生json数据，其他客户端来到这个方法处理；
+	public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
+		Map<String, Object> body = getErrorAttributes(request,
+				isIncludeStackTrace(request, MediaType.ALL));
+		HttpStatus status = getStatus(request);
+		return new ResponseEntity<Map<String, Object>>(body, status);
+	}
+```
+
+
+
+	3、ErrorPageCustomizer：
+
+```java
+	@Value("${error.path:/error}")
+	private String path = "/error";  系统出现错误以后来到error请求进行处理；（web.xml注册的错误页面规则）
+```
+
+
+
+	4、DefaultErrorViewResolver：
+
+```java
+@Override
+	public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
+			Map<String, Object> model) {
+		ModelAndView modelAndView = resolve(String.valueOf(status), model);
+		if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
+			modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
+		}
+		return modelAndView;
+	}
+
+	private ModelAndView resolve(String viewName, Map<String, Object> model) {
+        //默认SpringBoot可以去找到一个页面？  error/404
+		String errorViewName = "error/" + viewName;
+        
+        //模板引擎可以解析这个页面地址就用模板引擎解析
+		TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
+				.getProvider(errorViewName, this.applicationContext);
+		if (provider != null) {
+            //模板引擎可用的情况下返回到errorViewName指定的视图地址
+			return new ModelAndView(errorViewName, model);
+		}
+        //模板引擎不可用，就在静态资源文件夹下找errorViewName对应的页面   error/404.html
+		return resolveResource(errorViewName, model);
+	}
+```
+
+
+
+	步骤：
+	
+		一但系统出现4xx或者5xx之类的错误；ErrorPageCustomizer就会生效（定制错误的响应规则）；就会来到/error请求；就会被**BasicErrorController**处理；
+	
+		1）响应页面；去哪个页面是由**DefaultErrorViewResolver**解析得到的；
+
+```java
+protected ModelAndView resolveErrorView(HttpServletRequest request,
+      HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
+    //所有的ErrorViewResolver得到ModelAndView
+   for (ErrorViewResolver resolver : this.errorViewResolvers) {
+      ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
+      if (modelAndView != null) {
+         return modelAndView;
+      }
+   }
+   return null;
+}
+```
+
+### 2）、如果定制错误响应：
+
+#### 	**1）、如何定制错误的页面；**
+
+			**1）、有模板引擎的情况下；error/状态码;** 【将错误页面命名为  错误状态码.html 放在模板引擎文件夹里面的 error文件夹下】，发生此状态码的错误就会来到  对应的页面；
+	
+			我们可以使用4xx和5xx作为错误页面的文件名来匹配这种类型的所有错误，精确优先（优先寻找精确的状态码.html）；		
+	
+			页面能获取的信息；
+	
+				timestamp：时间戳
+	
+				status：状态码
+	
+				error：错误提示
+	
+				exception：异常对象
+	
+				message：异常消息
+	
+				errors：JSR303数据校验的错误都在这里
+	
+			2）、没有模板引擎（模板引擎找不到这个错误页面），静态资源文件夹下找；
+	
+			3）、以上都没有错误页面，就是默认来到SpringBoot默认的错误提示页面；
+
+
+
+#### 	2）、如何定制错误的json数据；
+
+		1）、自定义异常处理&返回定制json数据；
+
+```java
+@ControllerAdvice
+public class MyExceptionHandler {
+
+    @ResponseBody
+    @ExceptionHandler(UserNotExistException.class)
+    public Map<String,Object> handleException(Exception e){
+        Map<String,Object> map = new HashMap<>();
+        map.put("code","user.notexist");
+        map.put("message",e.getMessage());
+        return map;
+    }
+}
+//没有自适应效果...
+```
+
+
+
+		2）、转发到/error进行自适应响应效果处理
+
+```java
+ @ExceptionHandler(UserNotExistException.class)
+    public String handleException(Exception e, HttpServletRequest request){
+        Map<String,Object> map = new HashMap<>();
+        //传入我们自己的错误状态码  4xx 5xx，否则就不会进入定制错误页面的解析流程
+        /**
+         * Integer statusCode = (Integer) request
+         .getAttribute("javax.servlet.error.status_code");
+         */
+        request.setAttribute("javax.servlet.error.status_code",500);
+        map.put("code","user.notexist");
+        map.put("message",e.getMessage());
+        //转发到/error
+        return "forward:/error";
+    }
+```
+
+#### 	3）、将我们的定制数据携带出去；
+
+出现错误以后，会来到/error请求，会被BasicErrorController处理，响应出去可以获取的数据是由getErrorAttributes得到的（是AbstractErrorController（ErrorController）规定的方法）；
+
+	1、完全来编写一个ErrorController的实现类【或者是编写AbstractErrorController的子类】，放在容器中；
+	
+	2、页面上能用的数据，或者是json返回能用的数据都是通过errorAttributes.getErrorAttributes得到；
+	
+			容器中DefaultErrorAttributes.getErrorAttributes()；默认进行数据处理的；
+
+自定义ErrorAttributes
+
+```java
+//给容器中加入我们自己定义的ErrorAttributes
+@Component
+public class MyErrorAttributes extends DefaultErrorAttributes {
+
+    @Override
+    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
+        Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);
+        map.put("company","atguigu");
+        return map;
+    }
+}
+```
+
+最终的效果：响应是自适应的，可以通过定制ErrorAttributes改变需要返回的内容，
+
+![](images/springboot_4_08.png)
+
+
+
+## 8、配置嵌入式Servlet容器
+
+SpringBoot默认使用Tomcat作为嵌入式的Servlet容器；
+
+![](images/springboot_4_09.png)
+
+
+
+问题？
+
+### 1）、如何定制和修改Servlet容器的相关配置；
+
+1、修改和server有关的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）；
+
+```properties
+server.port=8081
+server.context-path=/crud
+
+server.tomcat.uri-encoding=UTF-8
+
+//通用的Servlet容器设置
+server.xxx
+//Tomcat的设置
+server.tomcat.xxx
+```
+
+2、编写一个**EmbeddedServletContainerCustomizer**：嵌入式的Servlet容器的定制器；来修改Servlet容器的配置
+
+```java
+@Bean  //一定要将这个定制器加入到容器中
+public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
+    return new EmbeddedServletContainerCustomizer() {
+
+        //定制嵌入式的Servlet容器相关的规则
+        @Override
+        public void customize(ConfigurableEmbeddedServletContainer container) {
+            container.setPort(8083);
+        }
+    };
+}
+```
+
+### 2）、注册Servlet三大组件【Servlet、Filter、Listener】
+
+由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用，没有web.xml文件。
+
+注册三大组件用以下方式
+
+ServletRegistrationBean
+
+```java
+//注册三大组件
+@Bean
+public ServletRegistrationBean myServlet(){
+    ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
+    return registrationBean;
+}
+
+```
+
+FilterRegistrationBean
+
+```java
+@Bean
+public FilterRegistrationBean myFilter(){
+    FilterRegistrationBean registrationBean = new FilterRegistrationBean();
+    registrationBean.setFilter(new MyFilter());
+    registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
+    return registrationBean;
+}
+```
+
+ServletListenerRegistrationBean
+
+```java
+@Bean
+public ServletListenerRegistrationBean myListener(){
+    ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
+    return registrationBean;
+}
+```
+
+
+
+SpringBoot帮我们自动SpringMVC的时候，自动的注册SpringMVC的前端控制器；DIspatcherServlet；
+
+DispatcherServletAutoConfiguration中：
+
+```java
+@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
+@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
+public ServletRegistrationBean dispatcherServletRegistration(
+      DispatcherServlet dispatcherServlet) {
+   ServletRegistrationBean registration = new ServletRegistrationBean(
+         dispatcherServlet, this.serverProperties.getServletMapping());
+    //默认拦截： /  所有请求；包静态资源，但是不拦截jsp请求；   /*会拦截jsp
+    //可以通过server.servletPath来修改SpringMVC前端控制器默认拦截的请求路径
+    
+   registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
+   registration.setLoadOnStartup(
+         this.webMvcProperties.getServlet().getLoadOnStartup());
+   if (this.multipartConfig != null) {
+      registration.setMultipartConfig(this.multipartConfig);
+   }
+   return registration;
+}
+
+```
+
+2）、SpringBoot能不能支持其他的Servlet容器；
+
+### 3）、替换为其他嵌入式Servlet容器
+
+![](images/springboot_4_10.png)
+
+默认支持：
+
+Tomcat（默认使用）
+
+```xml
+<dependency>
+   <groupId>org.springframework.boot</groupId>
+   <artifactId>spring-boot-starter-web</artifactId>
+   引入web模块默认就是使用嵌入式的Tomcat作为Servlet容器；
+</dependency>
+```
+
+Jetty
+
+```xml
+<!-- 引入web模块 -->
+<dependency>
+   <groupId>org.springframework.boot</groupId>
+   <artifactId>spring-boot-starter-web</artifactId>
+   <exclusions>
+      <exclusion>
+         <artifactId>spring-boot-starter-tomcat</artifactId>
+         <groupId>org.springframework.boot</groupId>
+      </exclusion>
+   </exclusions>
+</dependency>
+
+<!--引入其他的Servlet容器-->
+<dependency>
+   <artifactId>spring-boot-starter-jetty</artifactId>
+   <groupId>org.springframework.boot</groupId>
+</dependency>
+```
+
+Undertow
+
+```xml
+<!-- 引入web模块 -->
+<dependency>
+   <groupId>org.springframework.boot</groupId>
+   <artifactId>spring-boot-starter-web</artifactId>
+   <exclusions>
+      <exclusion>
+         <artifactId>spring-boot-starter-tomcat</artifactId>
+         <groupId>org.springframework.boot</groupId>
+      </exclusion>
+   </exclusions>
+</dependency>
+
+<!--引入其他的Servlet容器-->
+<dependency>
+   <artifactId>spring-boot-starter-undertow</artifactId>
+   <groupId>org.springframework.boot</groupId>
+</dependency>
+```
+
+### 4）、嵌入式Servlet容器自动配置原理；
+
+EmbeddedServletContainerAutoConfiguration：嵌入式的Servlet容器自动配置？
+
+```java
+@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
+@Configuration
+@ConditionalOnWebApplication
+@Import(BeanPostProcessorsRegistrar.class)
+//导入BeanPostProcessorsRegistrar：Spring注解版；给容器中导入一些组件
+//导入了EmbeddedServletContainerCustomizerBeanPostProcessor：
+//后置处理器：bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作
+public class EmbeddedServletContainerAutoConfiguration {
+    
+    @Configuration
+	@ConditionalOnClass({ Servlet.class, Tomcat.class })//判断当前是否引入了Tomcat依赖；
+	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判断当前容器没有用户自己定义EmbeddedServletContainerFactory：嵌入式的Servlet容器工厂；作用：创建嵌入式的Servlet容器
+	public static class EmbeddedTomcat {
+
+		@Bean
+		public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
+			return new TomcatEmbeddedServletContainerFactory();
+		}
+
+	}
+    
+    /**
+	 * Nested configuration if Jetty is being used.
+	 */
+	@Configuration
+	@ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
+			WebAppContext.class })
+	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
+	public static class EmbeddedJetty {
+
+		@Bean
+		public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {
+			return new JettyEmbeddedServletContainerFactory();
+		}
+
+	}
+
+	/**
+	 * Nested configuration if Undertow is being used.
+	 */
+	@Configuration
+	@ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
+	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
+	public static class EmbeddedUndertow {
+
+		@Bean
+		public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {
+			return new UndertowEmbeddedServletContainerFactory();
+		}
+
+	}
+```
+
+1）、EmbeddedServletContainerFactory（嵌入式Servlet容器工厂）
+
+```java
+public interface EmbeddedServletContainerFactory {
+
+   //获取嵌入式的Servlet容器
+   EmbeddedServletContainer getEmbeddedServletContainer(
+         ServletContextInitializer... initializers);
+
+}
+```
+
+![](images/springboot_4_11.png)
+
+2）、EmbeddedServletContainer：（嵌入式的Servlet容器）
+
+![](images/springboot_4_12.png)
+
+3）、以**TomcatEmbeddedServletContainerFactory**为例
+
+```java
+@Override
+public EmbeddedServletContainer getEmbeddedServletContainer(
+      ServletContextInitializer... initializers) {
+    //创建一个Tomcat
+   Tomcat tomcat = new Tomcat();
+    
+    //配置Tomcat的基本环节
+   File baseDir = (this.baseDirectory != null ? this.baseDirectory
+         : createTempDir("tomcat"));
+   tomcat.setBaseDir(baseDir.getAbsolutePath());
+   Connector connector = new Connector(this.protocol);
+   tomcat.getService().addConnector(connector);
+   customizeConnector(connector);
+   tomcat.setConnector(connector);
+   tomcat.getHost().setAutoDeploy(false);
+   configureEngine(tomcat.getEngine());
+   for (Connector additionalConnector : this.additionalTomcatConnectors) {
+      tomcat.getService().addConnector(additionalConnector);
+   }
+   prepareContext(tomcat.getHost(), initializers);
+    
+    //将配置好的Tomcat传入进去，返回一个EmbeddedServletContainer；并且启动Tomcat服务器
+   return getTomcatEmbeddedServletContainer(tomcat);
+}
+```
+
+4）、我们对嵌入式容器的配置修改是怎么生效？
+
+```
+ServerProperties、EmbeddedServletContainerCustomizer
+```
+
+**EmbeddedServletContainerCustomizer**：定制器帮我们修改了Servlet容器的配置？
+
+怎么修改的原理？
+
+5）、容器中导入了**EmbeddedServletContainerCustomizerBeanPostProcessor**
+
+```java
+//初始化之前
+@Override
+public Object postProcessBeforeInitialization(Object bean, String beanName)
+      throws BeansException {
+    //如果当前初始化的是一个ConfigurableEmbeddedServletContainer类型的组件
+   if (bean instanceof ConfigurableEmbeddedServletContainer) {
+       //
+      postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
+   }
+   return bean;
+}
+
+private void postProcessBeforeInitialization(
+			ConfigurableEmbeddedServletContainer bean) {
+    //获取所有的定制器，调用每一个定制器的customize方法来给Servlet容器进行属性赋值；
+    for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
+        customizer.customize(bean);
+    }
+}
+
+private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
+    if (this.customizers == null) {
+        // Look up does not include the parent context
+        this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
+            this.beanFactory
+            //从容器中获取所有这葛类型的组件：EmbeddedServletContainerCustomizer
+            //定制Servlet容器，给容器中可以添加一个EmbeddedServletContainerCustomizer类型的组件
+            .getBeansOfType(EmbeddedServletContainerCustomizer.class,
+                            false, false)
+            .values());
+        Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
+        this.customizers = Collections.unmodifiableList(this.customizers);
+    }
+    return this.customizers;
+}
+
+ServerProperties也是定制器
+```
+
+步骤：
+
+1）、SpringBoot根据导入的依赖情况，给容器中添加相应的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】
+
+2）、容器中某个组件要创建对象就会惊动后置处理器；EmbeddedServletContainerCustomizerBeanPostProcessor；
+
+只要是嵌入式的Servlet容器工厂，后置处理器就工作；
+
+3）、后置处理器，从容器中获取所有的**EmbeddedServletContainerCustomizer**，调用定制器的定制方法
+
+###5）、嵌入式Servlet容器启动原理；
+
+什么时候创建嵌入式的Servlet容器工厂？什么时候获取嵌入式的Servlet容器并启动Tomcat；
+
+获取嵌入式的Servlet容器工厂：
+
+1）、SpringBoot应用启动运行run方法
+
+2）、refreshContext(context);SpringBoot刷新IOC容器【创建IOC容器对象，并初始化容器，创建容器中的每一个组件】；如果是web应用创建**AnnotationConfigEmbeddedWebApplicationContext**，否则：**AnnotationConfigApplicationContext**
+
+3）、refresh(context);**刷新刚才创建好的ioc容器；**
+
+```java
+public void refresh() throws BeansException, IllegalStateException {
+   synchronized (this.startupShutdownMonitor) {
+      // Prepare this context for refreshing.
+      prepareRefresh();
+
+      // Tell the subclass to refresh the internal bean factory.
+      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
+
+      // Prepare the bean factory for use in this context.
+      prepareBeanFactory(beanFactory);
+
+      try {
+         // Allows post-processing of the bean factory in context subclasses.
+         postProcessBeanFactory(beanFactory);
+
+         // Invoke factory processors registered as beans in the context.
+         invokeBeanFactoryPostProcessors(beanFactory);
+
+         // Register bean processors that intercept bean creation.
+         registerBeanPostProcessors(beanFactory);
+
+         // Initialize message source for this context.
+         initMessageSource();
+
+         // Initialize event multicaster for this context.
+         initApplicationEventMulticaster();
+
+         // Initialize other special beans in specific context subclasses.
+         onRefresh();
+
+         // Check for listener beans and register them.
+         registerListeners();
+
+         // Instantiate all remaining (non-lazy-init) singletons.
+         finishBeanFactoryInitialization(beanFactory);
+
+         // Last step: publish corresponding event.
+         finishRefresh();
+      }
+
+      catch (BeansException ex) {
+         if (logger.isWarnEnabled()) {
+            logger.warn("Exception encountered during context initialization - " +
+                  "cancelling refresh attempt: " + ex);
+         }
+
+         // Destroy already created singletons to avoid dangling resources.
+         destroyBeans();
+
+         // Reset 'active' flag.
+         cancelRefresh(ex);
+
+         // Propagate exception to caller.
+         throw ex;
+      }
+
+      finally {
+         // Reset common introspection caches in Spring's core, since we
+         // might not ever need metadata for singleton beans anymore...
+         resetCommonCaches();
+      }
+   }
+}
+```
+
+4）、  onRefresh(); web的ioc容器重写了onRefresh方法
+
+5）、webioc容器会创建嵌入式的Servlet容器；**createEmbeddedServletContainer**();
+
+**6）、获取嵌入式的Servlet容器工厂：**
+
+EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
+
+	从ioc容器中获取EmbeddedServletContainerFactory 组件；**TomcatEmbeddedServletContainerFactory**创建对象，后置处理器一看是这个对象，就获取所有的定制器来先定制Servlet容器的相关配置；
+
+7）、**使用容器工厂获取嵌入式的Servlet容器**：this.embeddedServletContainer = containerFactory      .getEmbeddedServletContainer(getSelfInitializer());
+
+8）、嵌入式的Servlet容器创建对象并启动Servlet容器；
+
+**先启动嵌入式的Servlet容器，再将ioc容器中剩下没有创建出的对象获取出来；**
+
+**==IOC容器启动创建嵌入式的Servlet容器==**
+
+
+
+## 9、使用外置的Servlet容器
+
+嵌入式Servlet容器：应用打成可执行的jar
+
+		优点：简单、便携；
+	
+		缺点：默认不支持JSP、优化定制比较复杂（使用定制器【ServerProperties、自定义EmbeddedServletContainerCustomizer】，自己编写嵌入式Servlet容器的创建工厂【EmbeddedServletContainerFactory】）；
+
+
+
+外置的Servlet容器：外面安装Tomcat---应用war包的方式打包；
+
+### 步骤
+
+1）、必须创建一个war项目；（利用idea创建好目录结构）
+
+2）、将嵌入式的Tomcat指定为provided；
+
+```xml
+<dependency>
+   <groupId>org.springframework.boot</groupId>
+   <artifactId>spring-boot-starter-tomcat</artifactId>
+   <scope>provided</scope>
+</dependency>
+```
+
+3）、必须编写一个**SpringBootServletInitializer**的子类，并调用configure方法
+
+```java
+public class ServletInitializer extends SpringBootServletInitializer {
+
+   @Override
+   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
+       //传入SpringBoot应用的主程序
+      return application.sources(SpringBoot04WebJspApplication.class);
+   }
+
+}
+```
+
+4）、启动服务器就可以使用；
+
+### 原理
+
+jar包：执行SpringBoot主类的main方法，启动ioc容器，创建嵌入式的Servlet容器；
+
+war包：启动服务器，**服务器启动SpringBoot应用**【SpringBootServletInitializer】，启动ioc容器；
+
+
+
+servlet3.0（Spring注解版）：
+
+8.2.4 Shared libraries / runtimes pluggability：
+
+规则：
+
+	1）、服务器启动（web应用启动）会创建当前web应用里面每一个jar包里面ServletContainerInitializer实例：
+	
+	2）、ServletContainerInitializer的实现放在jar包的META-INF/services文件夹下，有一个名为javax.servlet.ServletContainerInitializer的文件，内容就是ServletContainerInitializer的实现类的全类名
+	
+	3）、还可以使用@HandlesTypes，在应用启动的时候加载我们感兴趣的类；
+
+
+
+流程：
+
+1）、启动Tomcat
+
+2）、org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\META-INF\services\javax.servlet.ServletContainerInitializer：
+
+Spring的web模块里面有这个文件：**org.springframework.web.SpringServletContainerInitializer**
+
+3）、SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到onStartup方法的Set<Class<?>>；为这些WebApplicationInitializer类型的类创建实例；
+
+4）、每一个WebApplicationInitializer都调用自己的onStartup；
+
+![](images/springboot_4_13.png)
+
+5）、相当于我们的SpringBootServletInitializer的类会被创建对象，并执行onStartup方法
+
+6）、SpringBootServletInitializer实例执行onStartup的时候会createRootApplicationContext；创建容器
+
+```java
+protected WebApplicationContext createRootApplicationContext(
+      ServletContext servletContext) {
+    //1、创建SpringApplicationBuilder
+   SpringApplicationBuilder builder = createSpringApplicationBuilder();
+   StandardServletEnvironment environment = new StandardServletEnvironment();
+   environment.initPropertySources(servletContext, null);
+   builder.environment(environment);
+   builder.main(getClass());
+   ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
+   if (parent != null) {
+      this.logger.info("Root context already created (using as parent).");
+      servletContext.setAttribute(
+            WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
+      builder.initializers(new ParentContextApplicationContextInitializer(parent));
+   }
+   builder.initializers(
+         new ServletContextApplicationContextInitializer(servletContext));
+   builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
+    
+    //调用configure方法，子类重写了这个方法，将SpringBoot的主程序类传入了进来
+   builder = configure(builder);
+    
+    //使用builder创建一个Spring应用
+   SpringApplication application = builder.build();
+   if (application.getSources().isEmpty() && AnnotationUtils
+         .findAnnotation(getClass(), Configuration.class) != null) {
+      application.getSources().add(getClass());
+   }
+   Assert.state(!application.getSources().isEmpty(),
+         "No SpringApplication sources have been defined. Either override the "
+               + "configure method or add an @Configuration annotation");
+   // Ensure error pages are registered
+   if (this.registerErrorPageFilter) {
+      application.getSources().add(ErrorPageFilterConfiguration.class);
+   }
+    //启动Spring应用
+   return run(application);
+}
+```
+
+7）、Spring的应用就启动并且创建IOC容器
+
+```java
+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);
+       
+       //刷新IOC容器
+      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);
+   }
+}
+```
+
+**==启动Servlet容器，再启动SpringBoot应用==**
+
diff --git "a/springboot/\345\205\245\351\227\250/5_docker.md" "b/springboot/\345\205\245\351\227\250/5_docker.md"
new file mode 100644
index 0000000..ae692ab
--- /dev/null
+++ "b/springboot/\345\205\245\351\227\250/5_docker.md"
@@ -0,0 +1,208 @@
+# 五、Docker
+
+## 1、简介
+
+**Docker**是一个开源的应用容器引擎；是一个轻量级容器技术；
+
+Docker支持将软件编译成一个镜像；然后在镜像中各种软件做好配置，将镜像发布出去，其他使用者可以直接使用这个镜像；
+
+运行中的这个镜像称为容器，容器启动是非常快速的。
+
+![](images/springboot_5_01.png)
+
+
+
+![](images/springboot_5_02.png)
+
+## 2、核心概念
+
+docker主机(Host)：安装了Docker程序的机器（Docker直接安装在操作系统之上）；
+
+docker客户端(Client)：连接docker主机进行操作；
+
+docker仓库(Registry)：用来保存各种打包好的软件镜像；
+
+docker镜像(Images)：软件打包好的镜像；放在docker仓库中；
+
+docker容器(Container)：镜像启动后的实例称为一个容器；容器是独立运行的一个或一组应用
+
+![](images/springboot_5_03.png)
+
+使用Docker的步骤：
+
+1）、安装Docker
+
+2）、去Docker仓库找到这个软件对应的镜像；
+
+3）、使用Docker运行这个镜像，这个镜像就会生成一个Docker容器；
+
+4）、对容器的启动停止就是对软件的启动停止；
+
+## 3、安装Docker
+
+#### 1）、安装linux虚拟机
+
+	1）、VMWare、VirtualBox（安装）；
+	
+	2）、导入虚拟机文件centos7-atguigu.ova；
+	
+	3）、双击启动linux虚拟机;使用  root/ 123456登陆
+	
+	4）、使用客户端连接linux服务器进行命令操作；
+	
+	5）、设置虚拟机网络；
+	
+		桥接网络===选好网卡====接入网线；
+	
+	6）、设置好网络以后使用命令重启虚拟机的网络
+
+```shell
+service network restart
+```
+
+	7）、查看linux的ip地址
+
+```shell
+ip addr
+```
+
+	8）、使用客户端连接linux；
+
+#### 2）、在linux虚拟机上安装docker
+
+步骤：
+
+```shell
+1、检查内核版本，必须是3.10及以上
+uname -r
+2、安装docker
+yum install docker
+3、输入y确认安装
+4、启动docker
+[root@localhost ~]# systemctl start docker
+[root@localhost ~]# docker -v
+Docker version 1.12.6, build 3e8e77d/1.12.6
+5、开机启动docker
+[root@localhost ~]# systemctl enable docker
+Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
+6、停止docker
+systemctl stop docker
+```
+
+## 4、Docker常用命令&操作
+
+### 1）、镜像操作
+
+| 操作 | 命令                                            | 说明                                                     |
+| ---- | ----------------------------------------------- | -------------------------------------------------------- |
+| 检索 | docker  search 关键字  eg：docker  search redis | 我们经常去docker  hub上检索镜像的详细信息，如镜像的TAG。 |
+| 拉取 | docker pull 镜像名:tag                          | :tag是可选的，tag表示标签，多为软件的版本，默认是latest  |
+| 列表 | docker images                                   | 查看所有本地镜像                                         |
+| 删除 | docker rmi image-id                             | 删除指定的本地镜像                                       |
+
+https://hub.docker.com/
+
+### 2）、容器操作
+
+软件镜像（QQ安装程序）----运行镜像----产生一个容器（正在运行的软件，运行的QQ）；
+
+步骤：
+
+````shell
+1、搜索镜像
+[root@localhost ~]# docker search tomcat
+2、拉取镜像
+[root@localhost ~]# docker pull tomcat
+3、根据镜像启动容器
+docker run --name mytomcat -d tomcat:latest
+4、docker ps  
+查看运行中的容器
+5、 停止运行中的容器
+docker stop  容器的id
+6、查看所有的容器
+docker ps -a
+7、启动容器
+docker start 容器id
+8、删除一个容器
+ docker rm 容器id
+9、启动一个做了端口映射的tomcat
+[root@localhost ~]# docker run -d -p 8888:8080 tomcat
+-d：后台运行
+-p: 将主机的端口映射到容器的一个端口    主机端口:容器内部的端口
+
+10、为了演示简单关闭了linux的防火墙
+service firewalld status ；查看防火墙状态
+service firewalld stop：关闭防火墙
+11、查看容器的日志
+docker logs container-name/container-id
+
+更多命令参看
+https://docs.docker.com/engine/reference/commandline/docker/
+可以参考每一个镜像的文档
+
+````
+
+
+
+### 3）、安装MySQL示例
+
+```shell
+docker pull mysql
+```
+
+
+
+错误的启动
+
+```shell
+[root@localhost ~]# docker run --name mysql01 -d mysql
+42f09819908bb72dd99ae19e792e0a5d03c48638421fa64cce5f8ba0f40f5846
+
+mysql退出了
+[root@localhost ~]# docker ps -a
+CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                           PORTS               NAMES
+42f09819908b        mysql               "docker-entrypoint.sh"   34 seconds ago      Exited (1) 33 seconds ago                            mysql01
+538bde63e500        tomcat              "catalina.sh run"        About an hour ago   Exited (143) About an hour ago                       compassionate_
+goldstine
+c4f1ac60b3fc        tomcat              "catalina.sh run"        About an hour ago   Exited (143) About an hour ago                       lonely_fermi
+81ec743a5271        tomcat              "catalina.sh run"        About an hour ago   Exited (143) About an hour ago                       sick_ramanujan
+
+
+//错误日志
+[root@localhost ~]# docker logs 42f09819908b
+error: database is uninitialized and password option is not specified 
+  You need to specify one of MYSQL_ROOT_PASSWORD, MYSQL_ALLOW_EMPTY_PASSWORD and MYSQL_RANDOM_ROOT_PASSWORD；这个三个参数必须指定一个
+```
+
+正确的启动
+
+```shell
+[root@localhost ~]# docker run --name mysql01 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
+b874c56bec49fb43024b3805ab51e9097da779f2f572c22c695305dedd684c5f
+[root@localhost ~]# docker ps
+CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
+b874c56bec49        mysql               "docker-entrypoint.sh"   4 seconds ago       Up 3 seconds        3306/tcp            mysql01
+```
+
+做了端口映射
+
+```shell
+[root@localhost ~]# docker run -p 3306:3306 --name mysql02 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
+ad10e4bc5c6a0f61cbad43898de71d366117d120e39db651844c0e73863b9434
+[root@localhost ~]# docker ps
+CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
+ad10e4bc5c6a        mysql               "docker-entrypoint.sh"   4 seconds ago       Up 2 seconds        0.0.0.0:3306->3306/tcp   mysql02
+```
+
+
+
+几个其他的高级操作
+
+```
+docker run --name mysql03 -v /conf/mysql:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
+把主机的/conf/mysql文件夹挂载到 mysqldocker容器的/etc/mysql/conf.d文件夹里面
+改mysql的配置文件就只需要把mysql配置文件放在自定义的文件夹下（/conf/mysql）
+
+docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
+指定mysql的一些配置参数
+```
\ No newline at end of file
diff --git "a/springboot/\345\205\245\351\227\250/6_\346\225\260\346\215\256\350\256\277\351\227\256.md" "b/springboot/\345\205\245\351\227\250/6_\346\225\260\346\215\256\350\256\277\351\227\256.md"
new file mode 100644
index 0000000..7bee7ef
--- /dev/null
+++ "b/springboot/\345\205\245\351\227\250/6_\346\225\260\346\215\256\350\256\277\351\227\256.md"
@@ -0,0 +1,273 @@
+# 六、SpringBoot与数据访问
+
+## 1、JDBC
+
+```xml
+<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-jdbc</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>mysql</groupId>
+			<artifactId>mysql-connector-java</artifactId>
+			<scope>runtime</scope>
+		</dependency>
+```
+
+
+
+```yaml
+spring:
+  datasource:
+    username: root
+    password: 123456
+    url: jdbc:mysql://192.168.15.22:3306/jdbc
+    driver-class-name: com.mysql.jdbc.Driver
+```
+
+效果：
+
+	默认是用org.apache.tomcat.jdbc.pool.DataSource作为数据源；
+	
+	数据源的相关配置都在DataSourceProperties里面；
+
+自动配置原理：
+
+org.springframework.boot.autoconfigure.jdbc：
+
+1、参考DataSourceConfiguration，根据配置创建数据源，默认使用Tomcat连接池；可以使用spring.datasource.type指定自定义的数据源类型；
+
+2、SpringBoot默认可以支持；
+
+```
+org.apache.tomcat.jdbc.pool.DataSource、HikariDataSource、BasicDataSource、
+```
+
+3、自定义数据源类型
+
+```java
+/**
+ * Generic DataSource configuration.
+ */
+@ConditionalOnMissingBean(DataSource.class)
+@ConditionalOnProperty(name = "spring.datasource.type")
+static class Generic {
+
+   @Bean
+   public DataSource dataSource(DataSourceProperties properties) {
+       //使用DataSourceBuilder创建数据源，利用反射创建响应type的数据源，并且绑定相关属性
+      return properties.initializeDataSourceBuilder().build();
+   }
+
+}
+```
+
+4、**DataSourceInitializer：ApplicationListener**；
+
+	作用：
+	
+		1）、runSchemaScripts();运行建表语句；
+	
+		2）、runDataScripts();运行插入数据的sql语句；
+
+默认只需要将文件命名为：
+
+```properties
+schema-*.sql、data-*.sql
+默认规则：schema.sql，schema-all.sql；
+可以使用   
+	schema:
+      - classpath:department.sql
+      指定位置
+```
+
+5、操作数据库：自动配置了JdbcTemplate操作数据库
+
+## 2、整合Druid数据源
+
+```java
+导入druid数据源
+@Configuration
+public class DruidConfig {
+
+    @ConfigurationProperties(prefix = "spring.datasource")
+    @Bean
+    public DataSource druid(){
+       return  new DruidDataSource();
+    }
+
+    //配置Druid的监控
+    //1、配置一个管理后台的Servlet
+    @Bean
+    public ServletRegistrationBean statViewServlet(){
+        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
+        Map<String,String> initParams = new HashMap<>();
+
+        initParams.put("loginUsername","admin");
+        initParams.put("loginPassword","123456");
+        initParams.put("allow","");//默认就是允许所有访问
+        initParams.put("deny","192.168.15.21");
+
+        bean.setInitParameters(initParams);
+        return bean;
+    }
+
+
+    //2、配置一个web监控的filter
+    @Bean
+    public FilterRegistrationBean webStatFilter(){
+        FilterRegistrationBean bean = new FilterRegistrationBean();
+        bean.setFilter(new WebStatFilter());
+
+        Map<String,String> initParams = new HashMap<>();
+        initParams.put("exclusions","*.js,*.css,/druid/*");
+
+        bean.setInitParameters(initParams);
+
+        bean.setUrlPatterns(Arrays.asList("/*"));
+
+        return  bean;
+    }
+}
+
+```
+
+## 3、整合MyBatis
+
+```xml
+		<dependency>
+			<groupId>org.mybatis.spring.boot</groupId>
+			<artifactId>mybatis-spring-boot-starter</artifactId>
+			<version>1.3.1</version>
+		</dependency>
+```
+
+![](images/springboot_6_01.png)
+
+步骤：
+
+	1）、配置数据源相关属性（见上一节Druid）
+	
+	2）、给数据库建表
+	
+	3）、创建JavaBean
+
+### 	4）、注解版
+
+```java
+//指定这是一个操作数据库的mapper
+@Mapper
+public interface DepartmentMapper {
+
+    @Select("select * from department where id=#{id}")
+    public Department getDeptById(Integer id);
+
+    @Delete("delete from department where id=#{id}")
+    public int deleteDeptById(Integer id);
+
+    @Options(useGeneratedKeys = true,keyProperty = "id")
+    @Insert("insert into department(departmentName) values(#{departmentName})")
+    public int insertDept(Department department);
+
+    @Update("update department set departmentName=#{departmentName} where id=#{id}")
+    public int updateDept(Department department);
+}
+```
+
+问题：
+
+自定义MyBatis的配置规则；给容器中添加一个ConfigurationCustomizer；
+
+```java
+@org.springframework.context.annotation.Configuration
+public class MyBatisConfig {
+
+    @Bean
+    public ConfigurationCustomizer configurationCustomizer(){
+        return new ConfigurationCustomizer(){
+
+            @Override
+            public void customize(Configuration configuration) {
+                configuration.setMapUnderscoreToCamelCase(true);
+            }
+        };
+    }
+}
+```
+
+
+
+```java
+使用MapperScan批量扫描所有的Mapper接口；
+@MapperScan(value = "com.atguigu.springboot.mapper")
+@SpringBootApplication
+public class SpringBoot06DataMybatisApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(SpringBoot06DataMybatisApplication.class, args);
+	}
+}
+```
+
+### 5）、配置文件版
+
+```yaml
+mybatis:
+  config-location: classpath:mybatis/mybatis-config.xml 指定全局配置文件的位置
+  mapper-locations: classpath:mybatis/mapper/*.xml  指定sql映射文件的位置
+```
+
+更多使用参照
+
+http://www.mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/
+
+
+
+## 4、整合SpringData JPA
+
+### 1）、SpringData简介
+
+![](images/springboot_6_02.png)
+
+### 2）、整合SpringData JPA
+
+JPA:ORM（Object Relational Mapping）；
+
+1）、编写一个实体类（bean）和数据表进行映射，并且配置好映射关系；
+
+```java
+//使用JPA注解配置映射关系
+@Entity //告诉JPA这是一个实体类（和数据表映射的类）
+@Table(name = "tbl_user") //@Table来指定和哪个数据表对应;如果省略默认表名就是user；
+public class User {
+
+    @Id //这是一个主键
+    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
+    private Integer id;
+
+    @Column(name = "last_name",length = 50) //这是和数据表对应的一个列
+    private String lastName;
+    @Column //省略默认列名就是属性名
+    private String email;
+```
+
+2）、编写一个Dao接口来操作实体类对应的数据表（Repository）
+
+```java
+//继承JpaRepository来完成对数据库的操作
+public interface UserRepository extends JpaRepository<User,Integer> {
+}
+
+```
+
+3）、基本的配置JpaProperties
+
+```yaml
+spring:  
+ jpa:
+    hibernate:
+#     更新或者创建数据表结构
+      ddl-auto: update
+#    控制台显示SQL
+    show-sql: true
+```
\ No newline at end of file
diff --git "a/springboot/\345\205\245\351\227\250/7_\345\220\257\345\212\250\351\205\215\347\275\256\345\216\237\347\220\206.md" "b/springboot/\345\205\245\351\227\250/7_\345\220\257\345\212\250\351\205\215\347\275\256\345\216\237\347\220\206.md"
new file mode 100644
index 0000000..841d19b
--- /dev/null
+++ "b/springboot/\345\205\245\351\227\250/7_\345\220\257\345\212\250\351\205\215\347\275\256\345\216\237\347\220\206.md"
@@ -0,0 +1,201 @@
+# 七、启动配置原理
+
+几个重要的事件回调机制
+
+配置在META-INF/spring.factories
+
+**ApplicationContextInitializer**
+
+**SpringApplicationRunListener**
+
+
+
+只需要放在ioc容器中
+
+**ApplicationRunner**
+
+**CommandLineRunner**
+
+
+
+启动流程：
+
+## **1、创建SpringApplication对象**
+
+```java
+initialize(sources);
+private void initialize(Object[] sources) {
+    //保存主配置类
+    if (sources != null && sources.length > 0) {
+        this.sources.addAll(Arrays.asList(sources));
+    }
+    //判断当前是否一个web应用
+    this.webEnvironment = deduceWebEnvironment();
+    //从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来
+    setInitializers((Collection) getSpringFactoriesInstances(
+        ApplicationContextInitializer.class));
+    //从类路径下找到ETA-INF/spring.factories配置的所有ApplicationListener
+    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
+    //从多个配置类中找到有main方法的主配置类
+    this.mainApplicationClass = deduceMainApplicationClass();
+}
+```
+
+![](images/springboot_7_01.png)
+
+![](images/springboot_7_02.png)
+
+## 2、运行run方法
+
+```java
+public ConfigurableApplicationContext run(String... args) {
+   StopWatch stopWatch = new StopWatch();
+   stopWatch.start();
+   ConfigurableApplicationContext context = null;
+   FailureAnalyzers analyzers = null;
+   configureHeadlessProperty();
+    
+   //获取SpringApplicationRunListeners；从类路径下META-INF/spring.factories
+   SpringApplicationRunListeners listeners = getRunListeners(args);
+    //回调所有的获取SpringApplicationRunListener.starting()方法
+   listeners.starting();
+   try {
+       //封装命令行参数
+      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
+            args);
+      //准备环境
+      ConfigurableEnvironment environment = prepareEnvironment(listeners,
+            applicationArguments);
+       		//创建环境完成后回调SpringApplicationRunListener.environmentPrepared()；表示环境准备完成
+       
+      Banner printedBanner = printBanner(environment);
+       
+       //创建ApplicationContext；决定创建web的ioc还是普通的ioc
+      context = createApplicationContext();
+       
+      analyzers = new FailureAnalyzers(context);
+       //准备上下文环境;将environment保存到ioc中；而且applyInitializers()；
+       //applyInitializers()：回调之前保存的所有的ApplicationContextInitializer的initialize方法
+       //回调所有的SpringApplicationRunListener的contextPrepared()；
+       //
+      prepareContext(context, environment, listeners, applicationArguments,
+            printedBanner);
+       //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded（）；
+       
+       //s刷新容器；ioc容器初始化（如果是web应用还会创建嵌入式的Tomcat）；Spring注解版
+       //扫描，创建，加载所有组件的地方；（配置类，组件，自动配置）
+      refreshContext(context);
+       //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
+       //ApplicationRunner先回调，CommandLineRunner再回调
+      afterRefresh(context, applicationArguments);
+       //所有的SpringApplicationRunListener回调finished方法
+      listeners.finished(context, null);
+      stopWatch.stop();
+      if (this.logStartupInfo) {
+         new StartupInfoLogger(this.mainApplicationClass)
+               .logStarted(getApplicationLog(), stopWatch);
+      }
+       //整个SpringBoot应用启动完成以后返回启动的ioc容器；
+      return context;
+   }
+   catch (Throwable ex) {
+      handleRunFailure(context, listeners, analyzers, ex);
+      throw new IllegalStateException(ex);
+   }
+}
+```
+
+## 3、事件监听机制
+
+配置在META-INF/spring.factories
+
+**ApplicationContextInitializer**
+
+```java
+public class HelloApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
+    @Override
+    public void initialize(ConfigurableApplicationContext applicationContext) {
+        System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
+    }
+}
+
+```
+
+**SpringApplicationRunListener**
+
+```java
+public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {
+
+    //必须有的构造器
+    public HelloSpringApplicationRunListener(SpringApplication application, String[] args){
+
+    }
+
+    @Override
+    public void starting() {
+        System.out.println("SpringApplicationRunListener...starting...");
+    }
+
+    @Override
+    public void environmentPrepared(ConfigurableEnvironment environment) {
+        Object o = environment.getSystemProperties().get("os.name");
+        System.out.println("SpringApplicationRunListener...environmentPrepared.."+o);
+    }
+
+    @Override
+    public void contextPrepared(ConfigurableApplicationContext context) {
+        System.out.println("SpringApplicationRunListener...contextPrepared...");
+    }
+
+    @Override
+    public void contextLoaded(ConfigurableApplicationContext context) {
+        System.out.println("SpringApplicationRunListener...contextLoaded...");
+    }
+
+    @Override
+    public void finished(ConfigurableApplicationContext context, Throwable exception) {
+        System.out.println("SpringApplicationRunListener...finished...");
+    }
+}
+
+```
+
+配置（META-INF/spring.factories）
+
+```properties
+org.springframework.context.ApplicationContextInitializer=\
+com.atguigu.springboot.listener.HelloApplicationContextInitializer
+
+org.springframework.boot.SpringApplicationRunListener=\
+com.atguigu.springboot.listener.HelloSpringApplicationRunListener
+```
+
+
+
+只需要放在ioc容器中
+
+**ApplicationRunner**
+
+```java
+@Component
+public class HelloApplicationRunner implements ApplicationRunner {
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+        System.out.println("ApplicationRunner...run....");
+    }
+}
+```
+
+
+
+**CommandLineRunner**
+
+```java
+@Component
+public class HelloCommandLineRunner implements CommandLineRunner {
+    @Override
+    public void run(String... args) throws Exception {
+        System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
+    }
+}
+```
\ No newline at end of file
diff --git "a/springboot/\345\205\245\351\227\250/8_\350\207\252\345\256\232\344\271\211starter.md" "b/springboot/\345\205\245\351\227\250/8_\350\207\252\345\256\232\344\271\211starter.md"
new file mode 100644
index 0000000..1dba2e2
--- /dev/null
+++ "b/springboot/\345\205\245\351\227\250/8_\350\207\252\345\256\232\344\271\211starter.md"
@@ -0,0 +1,192 @@
+# 八、自定义starter
+
+starter：
+
+	1、这个场景需要使用到的依赖是什么？
+	2、如何编写自动配置
+
+```java
+@Configuration  //指定这个类是一个配置类
+@ConditionalOnXXX  //在指定条件成立的情况下自动配置类生效
+@AutoConfigureAfter  //指定自动配置类的顺序
+@Bean  //给容器中添加组件
+
+@ConfigurationPropertie结合相关xxxProperties类来绑定相关的配置
+@EnableConfigurationProperties //让xxxProperties生效加入到容器中
+
+自动配置类要能加载
+将需要启动就加载的自动配置类，配置在META-INF/spring.factories
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
+org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
+```
+
+	3、模式：
+
+启动器只用来做依赖导入；
+
+专门来写一个自动配置模块；
+
+启动器依赖自动配置；别人只需要引入启动器（starter）
+
+mybatis-spring-boot-starter；自定义启动器名-spring-boot-starter
+
+
+
+步骤：
+
+1）、启动器模块
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.atguigu.starter</groupId>
+    <artifactId>atguigu-spring-boot-starter</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <!--启动器-->
+    <dependencies>
+
+        <!--引入自动配置模块-->
+        <dependency>
+            <groupId>com.atguigu.starter</groupId>
+            <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+    </dependencies>
+
+</project>
+```
+
+2）、自动配置模块
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+   <modelVersion>4.0.0</modelVersion>
+
+   <groupId>com.atguigu.starter</groupId>
+   <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
+   <version>0.0.1-SNAPSHOT</version>
+   <packaging>jar</packaging>
+
+   <name>atguigu-spring-boot-starter-autoconfigurer</name>
+   <description>Demo project for Spring Boot</description>
+
+   <parent>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-parent</artifactId>
+      <version>1.5.10.RELEASE</version>
+      <relativePath/> <!-- lookup parent from repository -->
+   </parent>
+
+   <properties>
+      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+      <java.version>1.8</java.version>
+   </properties>
+
+   <dependencies>
+
+      <!--引入spring-boot-starter；所有starter的基本配置-->
+      <dependency>
+         <groupId>org.springframework.boot</groupId>
+         <artifactId>spring-boot-starter</artifactId>
+      </dependency>
+
+   </dependencies>
+
+
+
+</project>
+
+```
+
+
+
+```java
+package com.atguigu.starter;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties(prefix = "atguigu.hello")
+public class HelloProperties {
+
+    private String prefix;
+    private String suffix;
+
+    public String getPrefix() {
+        return prefix;
+    }
+
+    public void setPrefix(String prefix) {
+        this.prefix = prefix;
+    }
+
+    public String getSuffix() {
+        return suffix;
+    }
+
+    public void setSuffix(String suffix) {
+        this.suffix = suffix;
+    }
+}
+
+```
+
+```java
+package com.atguigu.starter;
+
+public class HelloService {
+
+    HelloProperties helloProperties;
+
+    public HelloProperties getHelloProperties() {
+        return helloProperties;
+    }
+
+    public void setHelloProperties(HelloProperties helloProperties) {
+        this.helloProperties = helloProperties;
+    }
+
+    public String sayHellAtguigu(String name){
+        return helloProperties.getPrefix()+"-" +name + helloProperties.getSuffix();
+    }
+}
+
+```
+
+```java
+package com.atguigu.starter;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConditionalOnWebApplication //web应用才生效
+@EnableConfigurationProperties(HelloProperties.class)
+public class HelloServiceAutoConfiguration {
+
+    @Autowired
+    HelloProperties helloProperties;
+    @Bean
+    public HelloService helloService(){
+        HelloService service = new HelloService();
+        service.setHelloProperties(helloProperties);
+        return service;
+    }
+}
+
+```
+
+# 更多SpringBoot整合示例
+
+https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples
\ No newline at end of file
diff --git "a/springboot/\346\216\222\351\231\244\351\242\204\345\256\232\344\271\211\347\232\204Configuration.md" "b/springboot/\346\216\222\351\231\244\351\242\204\345\256\232\344\271\211\347\232\204Configuration.md"
new file mode 100644
index 0000000..eadfa64
--- /dev/null
+++ "b/springboot/\346\216\222\351\231\244\351\242\204\345\256\232\344\271\211\347\232\204Configuration.md"
@@ -0,0 +1,63 @@
+## 排除预定义的Configuration
+
+**SpringBoot** 提供了大量的预配置项，但并不是所有的预配置项都符合我们的要求，那么我们就需要将预配置项从**SpringBoot**的生命周期中移除，主要实现有两种方式。
+
+### 通过注解排除自动配置项
+
+`org.springframework.boot.autoconfigure.SpringBootApplication`注解提供了`exclude`和`excludeName`属性对配置项进行移除
+
+`exclude`需要提供排除的Class，`excldeName`需要提供排除类的全类名。
+
+这种方式的优点是使用简单。
+
+### 通过自定义过滤器排除
+
+**SpringBoot**允许我们自己编写`Starter`来对不同的框架实现预配置。在编写`Starter`的同时，我们不能帮用户选择项目的启动类，也就是我们无法使用`org.springframework.boot.autoconfigure.SpringBootApplication`注解，那么基于注解排除预配置项就无法实现。
+
+如果我们自动以的`Starter`与`SpringBoot`提供的配置或者其他第三方的配置存在冲突的情况，那么我们就必须想办法将冲突项排除。
+
+**SpringBoot**给我们提供了`org.springframework.boot.autoconfigure.AutoConfigurationImportFilter`接口来过滤所有的自动配置项，我们只需要实现该接口，并按照**SpringBoot**的要求，将该类配置到`META-INF/spring.factories`中即可。
+
+**实现接口并对指定的配置项进行排除**
+
+```java
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import org.springframework.boot.autoconfigure.AutoConfigurationImportFilter;
+import org.springframework.boot.autoconfigure.AutoConfigurationMetadata;
+
+/**
+ * spring boot 默认提供的数据源自动配置排除过滤器
+ */
+public class AutoConfigurationSkipFilter implements
+    AutoConfigurationImportFilter {
+
+  // 所有需要跳过的自动配置项
+  private static final Set<String> SHOULD_SKIP = new HashSet<>(
+      // 初始化要排除的自动配置项的全类名
+  Collections.singletonList("org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration")
+  );
+
+  @Override
+  public boolean[] match(String[] autoConfigurationClasses,
+      AutoConfigurationMetadata autoConfigurationMetadata) {
+    boolean[] matches = new boolean[autoConfigurationClasses.length];
+    for (int i = 0; i < matches.length; i++) {
+      // 对所有需要排除的配置项的match设置为false
+      matches[i] = !SHOULD_SKIP.contains(autoConfigurationClasses[i]);
+    }
+    return matches;
+  }
+}
+
+```
+
+**META-INF/spring.factories**
+
+```properties
+org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
+  mypackage.AutoConfigurationSkipFilter
+```
+
+如果存在多个**ImportFilter**接口的实现，可以使用`,`分隔
\ No newline at end of file
diff --git "a/springboot/\350\207\252\345\256\232\344\271\211conditional.md" "b/springboot/\350\207\252\345\256\232\344\271\211conditional.md"
new file mode 100644
index 0000000..be24e39
--- /dev/null
+++ "b/springboot/\350\207\252\345\256\232\344\271\211conditional.md"
@@ -0,0 +1,144 @@
+### 什么是Conditional
+
+`condition` 是`spring`提供的一个特性，用于在初始化对象时对初始化条件进行检测，满足条件的对象才予以创建。
+
+`SpringBoot`提供了`ConditionalOnBean`、`ConditionalOnClass`、`ConditionalOnProperty`等。分别用于不同的场景下对`bean`对象的创建行为进行限制。
+
+
+
+### 如何自定义Conditional
+
+#### 1、创建自定义的注解
+
+```java
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Conditional(MyCondition.class)
+public @interface MyConditionAnnotation {
+    String value() default "";
+}
+```
+
+通过创建自定义的注解，并且使用`Conditional`注解在我们自定义的注解上面。`Conditional`需要传递一个实现了`org.springframework.context.annotation.Condition`的类。`spring`会通过调用该实现类的`matches`方法来判断是否要创建对象。
+
+#### 2、创建`Condition`的实现类。
+
+在`SpringBoot`中，我们可以通过继承`org.springframework.boot.autoconfigure.condition.SpringBootCondition`类，并重写`getMatchOutcome`方法进行实现。
+
+`getMatchOutcome`需要返回一个`ConditionOutcome`对象，我们可以通过`new ConditionOutcome(bool,desc)`来创建该对象，构造器中需要接受两个参数，第一个为当前匹配是否成功，第二个为描述。当我们检测到当前环境满足Bean的初始化条件，就需要将第一个参数设为`true`。
+
+**创建匹配类**
+
+```java
+public class MyCondition extends SpringBootCondition {
+    @Override
+    public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
+        // 处理逻辑
+        return new ConditionOutcome(true, "");
+    }
+}
+```
+
+#### 3、注意事项
+
+1、在匹配类中可能无法自动注入bean
+
+由于`Conditional`用于标注当前环境是否满足`bean`的创建条件，所以通过`context.getBeanFactory().getBean("name")`可能无法获取到希望的对象，因为这里查询的对象可能还没有被初始化。
+
+2、不能通过自动注入配置的类来获取配置参数值。
+
+就如上面解释的。在匹配类被调用时，对象可能没有被初始化，所以当我们直接访问配置类时，可能获取不到正确的配置。
+
+解决方式是使用`PropertyResolver`进行获取指定属性。
+
+```java
+PropertyResolver resolver = context.getEnvironment();
+String property = resolver.getProperty("属性名");
+```
+
+
+
+### 完整案例
+
+#### 自定义注解
+
+```java
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Conditional(OnEnvironmentConditional.class)
+public @interface ConditionalOnEnvironment {
+
+    /**
+     * 当前条件支持的环境列表
+     */
+    Environment[] value() default Environment.PRODUCT;
+
+}
+```
+
+#### 可能会用到的枚举
+
+```java
+public enum Environment {
+    /**
+     * 开发环境
+     */
+    DEVELOP,
+    /**
+     * 测试环境
+     */
+    TEST,
+    /**
+     * 生产环境
+     */
+    PRODUCT
+}
+```
+
+#### 编写匹配条件类
+
+```java
+public class OnEnvironmentConditional extends SpringBootCondition {
+
+    @Override
+    public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
+        PropertyResolver resolver = context.getEnvironment();
+        String property = resolver.getProperty("business.environment", Environment.PRODUCT.name());
+        Environment environment = Environment.valueOf(property.toUpperCase());
+        if (metadata.isAnnotated(ConditionalOnEnvironment.class.getName())) {
+            Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(ConditionalOnEnvironment.class.getName());
+            Environment[] envs = (Environment[]) annotationAttributes.get("value");
+            List<Environment> envList = Arrays.asList(envs);
+            if (envList.contains(environment)) {
+                return new ConditionOutcome(true, "环境检查通过");
+            }
+            return new ConditionOutcome(false, "环境检查未通过");
+        }
+        return new ConditionOutcome(true, "no ConditionalOnEnvironment marked");
+    }
+}
+```
+
+#### 使用方式
+
+```java
+@Bean
+@ConditionalOnEnvironment({Environment.DEVELOP, Environment.TEST})
+public FilterRegistrationBean<AllowOriginFilter> allowOriginFilter() {
+    FilterRegistrationBean<AllowOriginFilter> bean = new FilterRegistrationBean<>();
+    bean.setFilter(new AllowOriginFilter());
+    bean.addUrlPatterns("/*");
+    bean.setName("AllowOriginFilter");
+    bean.setOrder(1);
+    return bean;
+}
+```
+
+#### 配置文件
+
+```properties
+business.environment = develop
+```
+
diff --git "a/springboot/\350\207\252\345\256\232\344\271\211filter.md" "b/springboot/\350\207\252\345\256\232\344\271\211filter.md"
new file mode 100644
index 0000000..488c752
--- /dev/null
+++ "b/springboot/\350\207\252\345\256\232\344\271\211filter.md"
@@ -0,0 +1,60 @@
+### 什么是Filter
+
+`Filter`属于`Servlet`规范内的组件，用于过滤请求。
+
+其运行原理类似于AOP，可以在请求前后执行部分逻辑。
+
+
+
+### 如何自定义Filter
+
+#### 编写Filter类
+
+```java
+public class MyFilter implements javax.servlet.Filter {
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+    }
+
+    @Override
+    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
+		// 请求处理之前
+        chain.doFilter(request, response);
+        // 请求处理之后
+    }
+
+    @Override
+    public void destroy() {
+    }
+}
+```
+
+#### 注册Filter
+
+在普通的`JAVA WEB`项目中可以在`web.xml`中进行注册过滤器，但是在`SpringBoot`项目中不存在`web.xml`配置文件。
+
+`Servlet3`提供了通过注解的方式注册Filter。也可以通过`SpringBoot`提供的方式注册Filter
+
+**Servlet 3 注解方式注册Filter**
+
+```java
+@javax.servlet.annotation.WebFilter(urlPatterns = "/*", filterName = "myFilter")
+public class MyFilter implements javax.servlet.Filter {}
+```
+
+**SpringBoot Bean 方式注册Filter**
+
+通过在`Spring IOC`中注册`FilterRegistrationBean`就可以自动注册过滤器。
+
+```java
+@Bean
+public FilterRegistrationBean<MyFilter> myFilter() {
+    FilterRegistrationBean<MyFilter> bean = new FilterRegistrationBean<>();
+    bean.setFilter(new MyFilter());
+    bean.addUrlPatterns("/*");
+    bean.setName("myFilter");
+    bean.setOrder(1);
+    return bean;
+}
+```
+
diff --git "a/springboot/\350\277\220\350\241\214\346\227\266\346\214\207\345\256\232\345\244\226\351\203\250\351\205\215\347\275\256\346\226\207\344\273\266.md" "b/springboot/\350\277\220\350\241\214\346\227\266\346\214\207\345\256\232\345\244\226\351\203\250\351\205\215\347\275\256\346\226\207\344\273\266.md"
new file mode 100644
index 0000000..d0b6b62
--- /dev/null
+++ "b/springboot/\350\277\220\350\241\214\346\227\266\346\214\207\345\256\232\345\244\226\351\203\250\351\205\215\347\275\256\346\226\207\344\273\266.md"
@@ -0,0 +1,12 @@
+#### 原因
+
+spring boot 默认会使用当前项目下的application.yml文件，但是，该文件在打包是直接被包含在jar包内，对于后面的修改会产生问题
+
+#### 解决方案
+
+执行`java`命令时指定配置文件
+
+```sh
+java -jar jar文件路径 --spring.config.location=配置文件路径
+```
+
diff --git "a/springboot/\351\235\231\346\200\201\350\265\204\346\272\220\346\230\240\345\260\204.md" "b/springboot/\351\235\231\346\200\201\350\265\204\346\272\220\346\230\240\345\260\204.md"
new file mode 100644
index 0000000..55ace06
--- /dev/null
+++ "b/springboot/\351\235\231\346\200\201\350\265\204\346\272\220\346\230\240\345\260\204.md"
@@ -0,0 +1,26 @@
+## SpringBoot映射本地静态资源
+
+### 逻辑
+
+1. 实现`org.springframework.web.servlet.config.annotation.WebMvcConfigurer`接口
+2. 重写`void addResourceHandlers(ResourceHandlerRegistry registry)`方法
+3. 添加资源映射
+
+### 代码
+
+```java
+public class DeployServerApplication implements WebMvcConfigurer {
+  @Override
+  public void addResourceHandlers(ResourceHandlerRegistry registry) {
+    // 配置静态资源映射
+    registry.addResourceHandler("/**/*.html", "/**/*.css", "/**/*.js")
+        // 资源字符串支持标准的java url格式,分别为 classpath: 或 file:
+        .addResourceLocations("classpath:/static/");
+    registry.addResourceHandler("swagger-ui.html")
+        .addResourceLocations("classpath:/META-INF/resources/");
+    registry.addResourceHandler("/webjars/**")
+        .addResourceLocations("classpath:/META-INF/resources/webjars/");
+  }
+}
+```
+
diff --git a/springframework/aop.md b/springframework/aop.md
new file mode 100644
index 0000000..c50ccf5
--- /dev/null
+++ b/springframework/aop.md
@@ -0,0 +1,280 @@
+## 切面表达式
+
+在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点"。
+
+例如定义切入点表达式  **execution (\* com.sample.service.impl..\*.\*(..))**
+
+**execution()**是最常用的切点函数，其语法如下所示：
+
+ 整个表达式可以分为五个部分：
+
+1. **execution()**: 表达式主体。
+2. 第一个*****号：表示返回类型，*****号表示所有的类型。
+3. 包名：表示需要拦截的包名，后面的两个句点(**..**)表示当前包和当前包的所有子包
+4. 第二个*****号：表示类名，*****号表示所有的类。
+5. ***(..)**:最后这个星号表示方法名，*****号表示所有的方法，后面括号里面表示方法的参数，两个句点表示任何参数。
+
+### excution() 
+
+**表示满足某一匹配模式的所有目标类方法连接点。**
+
+#### 语法
+
+execution(<修饰符模式>? **<返回类型模式> <方法名模式>(<参数模式>)** <异常模式>?)  除了返回类型模式、方法名模式和参数模式外，其它项都是可选的
+
+#### 特殊符号
+
+*****：表示匹配任意的值
+
+**..**：表示匹配任意的数量且不限制类型
+
+**+**：表示匹配指定的类及其子类
+
+#### 例子
+
+1. **execution(public * com.feb13th..*(..))**：匹配 `com.feb13th`包下的所有`public`方法。方法参数不限，返回值不限，方法名不限。
+2. **execution(* com.feb13th.Enter+.*(..))**：匹配`Enter`接口及其所有实现类的方法。即使不存在`Enter`中的方法也会被切面。方法参数不限，返回值类型不限，方法修饰符不限。方法名不限。
+3. **execution(* com.feb13th..*(String, *))**：匹配`com.feb13th`包下，方法第一个参数为`String`类型的方法。方法返回值不限，修饰符不限，方法名不限。
+4. **execution(* com.feb13th..*(Object+))**：匹配`com.feb13th`包下的所有方法第一个入参为`Object`及其子类的方法。方法返回值不限，修饰符不限，方法名不限。
+
+
+
+### @annotation()
+
+**表示标注了特定注解的目标方法连接点**
+
+#### 语法
+
+@annotation(注解)
+
+#### 例子
+
+**@annotation(com.feb13th.Enter)**：匹配所有标注了`com.feb13th.Enter`注解的方法。
+
+
+
+### args()
+
+**通过判别目标类方法运行时入参对象的类型定义指定连接点**
+
+#### 语法
+
+args(类名..)
+
+#### 例子
+
+**args(com.feb13th.Enter)**：匹配所有入参有且仅有一个类型和`com.feb13th.Enter`匹配的方法。
+
+
+
+### @args()
+
+**通过判别目标方法的运行时入参对象的类是否标注特定注解来指定连接点**
+
+#### 语法
+
+@args(注解)
+
+#### 例子
+
+**@args(com.feb13th.Enter)**：匹配有且仅有一个入参，且入参对象的类标注了`com.feb13th.Enter`注解的方法。
+
+
+
+### within()
+
+**表示特定域下的所有连接点**
+
+#### 语法
+
+within(类名匹配串)
+
+#### 例子
+
+1. **within(com.feb13th.*)**：匹配`com.feb13th`包下的所有方法
+2. **within(com.feb13th.service.*Service)**：匹配`com.feb13th.service`包下所有以`Service`结尾的类中的方法。
+
+
+
+### @within()
+
+**假如目标类按类型匹配于某个类A，且类A标注了特定注解，则目标类的所有连接点匹配这个切点。**
+
+#### 语法
+
+@within(类型注解类名)
+
+#### 例子
+
+**@within(com.feb13th.Enter)**：假如一个类标注了`com.feb13th.Enter`注解，那么该类及其子类的所有方法都会有切面。
+
+
+
+### target()
+
+**假如目标类按类型匹配于指定类，则目标类的所有连接点匹配这个切点**
+
+#### 语法
+
+target(类名)
+
+#### 例子
+
+**target(com.feb13th.Enter)**：匹配`com.feb13th.Enter`类及其子类中所有的方法。
+
+
+
+### @target()
+
+**目标类标注了特定注解，则目标类所有连接点匹配该切点**
+
+#### 语法
+
+@target(类型注解类名)
+
+#### 例子
+
+**@target(com.feb13th.Enter)**：匹配所有标注了`com.feb13th.Enter`类中的所有方法。不包括其子类。
+
+
+
+## 组合多个表达式
+
+在多个表达式中可以使用**”&&“** 、 **”||“** 、**”！“**  连接多个表达式。
+
+
+
+## Spring 切面通知类型
+
+| 注解            | 通知                       |
+| --------------- | -------------------------- |
+| @Before         | 在方法调用之前执行         |
+| @After          | 在方法返回或抛出异常后执行 |
+| @Around         | 环绕通知                   |
+| @AfterReturning | 目标方法返回后调用         |
+| @AfterThrowing  | 方法抛出异常后执行         |
+
+
+
+## Spring 中使用 AOP
+
+### 启用AOP
+
+启用AOP特性可以在`xml`文件中配置或使用注解开启。
+
+**使用XML配置**
+
+```xml
+<!-- 支持注解 -->
+<context:annotation-config />
+<context:component-scan base-package="com.feb13th"/>
+<!-- 配置 aop  -->
+<aop:aspectj-autoproxy/>
+```
+
+**使用注解配置**
+
+```java
+@Configuration
+@EnableAspectJAutoProxy
+@ComponentScan(basePackages = "com.feb13th")
+public class Test {
+    public static void main(String[] args) {
+        ApplicationContext applicationContext = new AnnotationConfigApplicationContext();
+    }
+}
+```
+
+### 编写切面类
+
+切面类需使用`Aspect`注解进行标注，具体看下面：
+
+```java
+@Aspect
+@Component
+public class MyAspect {
+
+    // 自定义的切入点
+    @Pointcut("execution(* android..*(..))")
+    public void pointCut() {}
+
+    // 方法执行前执行
+    @Before("pointCut()")
+    public void before(){}
+
+    // 方法执行后执行
+    @After("pointCut()")
+    public void after(){}
+
+    // 环绕执行方法, proceed()方法用于调用被切面的方法
+    @Around("pointCut()")
+    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+        return joinPoint.proceed();
+    }
+
+    // 方法返回后调用
+    @AfterReturning("pointCut()")
+    public void afterReturning() {}
+
+    // 方法抛出异常后调用
+    @AfterThrowing("pointCut()")
+    public void afterThrowing() {}
+}
+```
+
+
+
+## 常见问题
+
+### 获取方法信息
+
+```java
+    @Around("pointCut()")
+    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+        Signature signature = joinPoint.getSignature();
+        if (!(signature instanceof MethodSignature)) {
+            return joinPoint.proceed();
+        }
+        // 只有当前切入点为方法时，才能获取到方法信息
+        MethodSignature methodSignature = (MethodSignature) signature;
+        Method method = methodSignature.getMethod();
+        // ...
+
+        return joinPoint.proceed();
+    }
+```
+
+### 获取入参信息
+
+```java
+@Around("pointCut()")
+    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+        // 所有的入参值，可能会存在 null
+        Object[] args = joinPoint.getArgs();
+        Signature signature = joinPoint.getSignature();
+        // 方法名
+        String name = signature.getName();
+        // ...
+
+        return joinPoint.proceed();
+    }
+```
+
+### 出现灵异事件，重启后解决
+
+方法正常执行时没问题，方方法抛出错误时，程序不会根据原预定的逻辑执行。
+
+出现这种情况一般是由于操作了共享变量导致的。
+
+正常逻辑中会对共享变量进行修改，但是当程序出错时，对共享变量的修改的代码无法被执行。所有导致了这种灵时间。
+
+解决方案就是将一定要执行的代码写在`finally`块中。
+
+
+
+
+
+
+
+
+
diff --git a/springframework/beanpostprocessor.md b/springframework/beanpostprocessor.md
new file mode 100644
index 0000000..65764d3
--- /dev/null
+++ b/springframework/beanpostprocessor.md
@@ -0,0 +1,107 @@
+## BeanPostProcessor
+
+`BeanPostProcessor`是Spring提供的`bean`通过`反射`初始化对象后进行调用的接口。
+
+## 作用
+
+通过实现`BeanPostProcessor`接口，并将实现类交由`spring`管理，我们可以实现在`bean`创建完成时，手动的处理一些事情，如获取指定的方法、注解、属性等等。
+
+## 使用
+
+创建`JAVA`类并实现`BeanPostProcessor`接口。同时在类上标注`@Component`。
+
+```java
+@Component
+public class BeanPostProcessor implements BeanPostProcessor {
+    @Override
+    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+        return bean;
+    }
+
+    @Override
+    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+        return bean;
+    }
+```
+
+**postProcessBeforeInitialization**
+
+对象创建完成，但并未初始化时进行调用。
+
+**postProcessAfterInitialization**
+
+对象创建完成，且已被成功的初始化，当前对象为直接可用的对象。
+
+
+
+## 遇到的问题
+
+### BeanPostProcessor中处理的方法，反射调用后切面失效
+
+`BeanPostProcessor`处理的对象是未经过切面代理的。也就是说，在`BeanPostProcessor`中获取到的`bean`实例，并不能正确的相应Spring AOP功能。
+
+**解决方案**：
+
+可以使用`曲线救国`的方式，在`BeanPostProcessor`处理逻辑中，仅存储`beanName`和`methodName`，在使用的位置使用`ApplicationContext`通过`beanName`获取bean，从而解决问题。
+
+#### 案例
+
+**处理bean**
+
+```java
+@Component
+public class AndroidBeanPostProcessor implements BeanPostProcessor {
+
+    // 入口方法集合
+    private static volatile List<AndroidMethodWrap> enterMethodList = Collections.synchronizedList(new ArrayList<>());
+
+    @Override
+    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+        Method[] methods = bean.getClass().getMethods();
+        Arrays.stream(methods).forEach(method -> {
+            AndroidEnter androidEnter = method.getAnnotation(AndroidEnter.class);
+            if (androidEnter != null) {
+                AndroidMethodWrap wrap = new AndroidMethodWrap();
+                wrap.setBean(beanName);
+                wrap.setMethod(method.getName());
+                wrap.setMethodArgs(method.getParameterTypes());
+                wrap.setSendHeader(androidEnter.sendHeader());
+                int repeat = androidEnter.repeat();
+                if (repeat < 1) {
+                    throw new IllegalArgumentException("Repeat in AndroidEnter must be great than 0");
+                }
+                wrap.setRepeat(repeat);
+                enterMethodList.add(wrap);
+            }
+        });
+        return bean;
+    }
+
+    @Override
+    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {return bean;}
+
+    public static List<AndroidMethodWrap> getEnterMethodList() {
+        return enterMethodList;}
+}
+```
+
+**反射调用bean的方法**
+
+```java
+List<AndroidMethodWrap> enterMethodList = AndroidBeanPostProcessor.getEnterMethodList();
+enterMethodList.forEach(wrap -> {
+    try {
+        String beanName = wrap.getBean();
+        // 获取新的bean
+        Object bean = AndroidSpringContextContainer.getBean(beanName);
+        String methodName = wrap.getMethod();
+        Class<?>[] methodArgs = wrap.getMethodArgs();
+        Method method = bean.getClass().getMethod(methodName, methodArgs);
+        Object[] objs = new Object[methodArgs.length];
+        method.invoke(bean, objs);
+    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+        throw new RuntimeException(e);
+    }
+});
+```
+
diff --git a/springframework/jms.md b/springframework/jms.md
new file mode 100644
index 0000000..4cf95cf
--- /dev/null
+++ b/springframework/jms.md
@@ -0,0 +1,193 @@
+## 类结构
+
+* >  JmsAccessor 实现 InitializingBean 
+  >
+  > -- 实现 afterPropertiesSet 方法，对当前ConnectionFactory 进行了非空判断
+  >
+  > 
+  >
+  > 拥有ConnectionFactory 对象及创建 session 的两个属性
+  >
+  > -- sessionTransacted
+  >
+  > -- sessionAcknowledgeMode
+  >
+  >  
+  >
+  > 创建Connection
+  >
+  > 创建 Session
+  >
+  > 
+
+* > ```java
+  > public abstract class JmsDestinationAccessor extends JmsAccessor
+  > ```
+  >
+  > JmsDestinationAccessor 集成 JmsAccessor
+  >
+  > 持有两个消息接收超时时间设置参数
+  >
+  > 持有 DestinationResolver 对象
+  >
+  > 持有 是否是订阅模式的参数 pubSubDomain = false
+  >
+  >  
+  >
+  > 方法 
+  >
+  > ```java
+  > // 通过调用 DestinationResolver  对象的方法创建 destination 对象
+  > Destination resolveDestinationName(Session session, String destinationName) 
+  > ```
+  >
+  >  ```java
+  > // 接收消息
+  > Message receiveFromConsumer(MessageConsumer consumer, long timeout) 
+  >     
+  > // 通过对超时时间的判断，调用不同的接收方法：
+  > if (timeout > 0) {
+  >     return consumer.receive(timeout);
+  > }
+  > else if (timeout < 0) {
+  >     return consumer.receiveNoWait();
+  > }
+  > else {
+  >     return consumer.receive();
+  > }
+  >  ```
+
+* > ```java
+  > public abstract class AbstractJmsListeningContainer extends JmsDestinationAccessor implements BeanNameAware, DisposableBean, SmartLifecycle
+  > ```
+  >
+  >  所有需要实现 JMS 链接的容器的公共基类。
+  >
+  > 提供了最基本的生命周期管理，主要管理 shared JMS Connection 。
+  >
+  > 子类通过实现 `sharedConnectionEnabled()`、`doInitialize()`、`doShutdown()`这三个模板方法来接入声明周期。
+  >
+  > 
+  >
+  > 属性：
+  >
+  > ```java
+  > private String clientId;
+  > private boolean autoStartup = true;
+  > private int phase = Integer.MAX_VALUE;
+  > private String beanName;
+  > private Connection sharedConnection;
+  > private boolean sharedConnectionStarted = false;
+  > protected final Object sharedConnectionMonitor = new Object();
+  > private boolean active = false;
+  > private boolean running = false;
+  > private final List<Object> pausedTasks = new LinkedList<Object>();
+  > ```
+  >
+  >  钩子方法
+  >
+  > ```java
+  > protected void validateConfiguration() {
+  > }
+  > 
+  > void initialize() {
+  >     synchronized (this.lifecycleMonitor) {
+  >         this.active = true;
+  >         // 唤醒所有该声明周期管理的线程
+  >         this.lifecycleMonitor.notifyAll();
+  >     }
+  > }
+  > 
+  > void doInitialize()
+  > boolean sharedConnectionEnabled()
+  > void doShutdown()
+  > ```
+
+* >  ```java
+  >  public abstract class AbstractMessageListenerContainer extends AbstractJmsListeningContainer implements MessageListenerContainer
+  >  ```
+  >
+  >  属性：
+  >
+  >  ```java
+  >  private volatile Object destination;
+  >  private volatile String messageSelector;
+  >  private volatile Object messageListener;
+  >  
+  >  private boolean subscriptionDurable = false;
+  >  private boolean subscriptionShared = false;
+  >  
+  >  private String subscriptionName;
+  >  
+  >  private Boolean replyPubSubDomain;
+  >  private boolean pubSubNoLocal = false;
+  >  
+  >  private MessageConverter messageConverter;
+  >  private ExceptionListener exceptionListener;
+  >  private ErrorHandler errorHandler;
+  >  
+  >  private boolean exposeListenerSession = true;
+  >  private boolean acceptMessagesWhileStopping = false;
+  >  ```
+  >
+
+* >  ```java
+  >  public abstract class AbstractPollingMessageListenerContainer extends AbstractMessageListenerContainer
+  >  ```
+  >
+  >  轮询的监听器实现类。为 consumer 提供支持，提供可选事务管理。
+  >
+  >  属性：
+  >
+  >  ```java
+  >  public static final long DEFAULT_RECEIVE_TIMEOUT = 1000;
+  >  
+  >  private final MessageListenerContainerResourceFactory transactionalResourceFactory = new MessageListenerContainerResourceFactory();
+  >  
+  >  private boolean sessionTransactedCalled = false;
+  >  
+  >  private PlatformTransactionManager transactionManager;
+  >  
+  >  private DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
+  >  
+  >  private long receiveTimeout = DEFAULT_RECEIVE_TIMEOUT;
+  >  ```
+
+* > public class DefaultMessageListenerContainer extends AbstractPollingMessageListenerContainer
+  >
+  > 定义了5个缓存等级
+  >
+  > 属性
+  >
+  > ```java
+  > private Executor taskExecutor;
+  > private BackOff backOff = new FixedBackOff(DEFAULT_RECOVERY_INTERVAL, Long.MAX_VALUE);
+  > 
+  > private int cacheLevel = CACHE_AUTO;
+  > private int concurrentConsumers = 1;
+  > private int maxConcurrentConsumers = 1;
+  > private int maxMessagesPerTask = Integer.MIN_VALUE;
+  > private int idleConsumerLimit = 1;
+  > private int idleTaskExecutionLimit = 1;
+  > 
+  > private final Set<AsyncMessageListenerInvoker> scheduledInvokers = new HashSet<AsyncMessageListenerInvoker>();
+  > 
+  > private int activeInvokerCount = 0;
+  > private int registeredWithDestination = 0;
+  > 
+  > private volatile boolean recovering = false;
+  > private volatile boolean interrupted = false;
+  > 
+  > private Runnable stopCallback;
+  > private Object currentRecoveryMarker = new Object();
+  > private final Object recoveryMonitor = new Object();	
+  > ```
+  >
+  >  
+  >
+  > 
+
+
+
+
+
diff --git "a/springframework/\345\215\225\345\205\203\346\265\213\350\257\225\345\217\212\344\272\213\345\212\241.md" "b/springframework/\345\215\225\345\205\203\346\265\213\350\257\225\345\217\212\344\272\213\345\212\241.md"
new file mode 100644
index 0000000..3e5995c
--- /dev/null
+++ "b/springframework/\345\215\225\345\205\203\346\265\213\350\257\225\345\217\212\344\272\213\345\212\241.md"
@@ -0,0 +1,198 @@
+### 如何使用Spring单元测试
+
+在测试类上使用`@RunWith`和`ContextConfiguration`进行修饰，指定Spring的配置文件即可使用单元测试
+
+```java
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
+public class TestClass {
+    @Test
+    public void test1() {}
+}
+```
+
+
+
+### 如何在单元测试中支持事务
+
+#### 如何使用事务
+
+在spring单元测试中，默认不支持事务，如果需要单元测试类支持事务，则需要继承`AbstractTransactionalJUnit4SpringContextTests`类，同时需要在配置文件中配置事务管理器。
+
+xml配置：
+
+```xml
+<bean id="transactionManager"
+    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
+    <property name="dataSource" ref="dataSource" />
+</bean>
+```
+
+单元测试代码：
+
+```java
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
+public class TestClass extends AbstractTransactionalJUnit4SpringContextTests {
+    @Test
+    public void test1() {}
+}
+```
+
+#### 为什么单元测试通过了，但是数据库的数据没有改变？
+
+因为在spring单元测试中，默认会在方法的开始之前开启事务，当方法执行成功或失败以后回滚事务。
+
+所有我们在单元测试方法中修改的数据可以在同一个方法中查询到，但是并不会体现在数据库上面。
+
+#### 如何使单元测试的事务提交
+
+在`AbstractTransactionalJUnit4SpringContextTests`的源码中有下面一段：
+
+```java
+ * @see org.springframework.test.annotation.Commit
+ * @see org.springframework.test.annotation.Rollback
+```
+
+我们查看`Commit`和`Rollback`注解的源码注释可以给出解释：
+
+```java
+Commit:
+	 * {@code @Commit} is a test annotation that is used to indicate that a
+ 	 * <em>test-managed transaction</em> should be <em>committed</em> after
+ 	 * the test method has completed.
+Rollback:
+	 * {@code @Rollback} is a test annotation that is used to indicate whether
+	 * a <em>test-managed transaction</em> should be <em>rolled back</em> after
+	 * the test method has completed.
+```
+
+上面是Spring官方给出的解释，简单的说就是，当在测试类或测试方法上标注`@Commit`或者`@Rollback`时，就会决定当前的事务是提交还是回滚。
+
+看到这里，我们的解决方案就出来了，只需要在我们的测试类或者测试方法上标注`@Commit`或者`@Rollback(false)`就可以实现事务的提交。
+
+
+
+### 事务源码解析
+
+#### spring 在哪里进行检测注解的？
+
+Spring单元测试实现事务管理主要类为`TransactionalTestExecutionListener`。
+
+Spring在当前类中进行开启事务，同时检测事务是否需要回滚。在该类中开始事务的方法为`beforeTestMethod`方法。
+
+```java
+public class TransactionalTestExecutionListener extends AbstractTestExecutionListener {
+    //...
+    public void beforeTestMethod(final TestContext testContext) throws Exception {
+    	// ...
+        if (tm != null) {
+            // 在此创建一个事务上下文，用于管理事务的提交或回滚
+			txContext = new TransactionContext(testContext, tm, transactionAttribute, isRollback(testContext));
+			runBeforeTransactionMethods(testContext);	// 运行事务之前的代码
+			txContext.startTransaction();	// 开启事务
+			TransactionContextHolder.setCurrentTransactionContext(txContext);
+		}
+        // ...
+    }
+    // ...
+}
+```
+
+从上面的代码可以看出，Spring创建了一个`TransactionContext`用于管理事务的声明周期。同时在该方法中开启事务，并将事务绑定到当前单元测试的上下文上。
+
+同时可以注意到`isRollback()`方法，Spring通过该方法检测单元测试类或方法上是否存在`Rollback`注解。
+
+```java
+// 检测是否需要回滚
+protected final boolean isRollback(TestContext testContext) throws Exception {
+    	// 检测回滚测试是否是默认项
+		boolean rollback = isDefaultRollback(testContext);
+    	// 获取类或方法上的注解
+		Rollback rollbackAnnotation =
+				AnnotatedElementUtils.findMergedAnnotation(testContext.getTestMethod(), Rollback.class);
+		if (rollbackAnnotation != null) {
+            // 获取到覆盖默认策略
+			boolean rollbackOverride = rollbackAnnotation.value();
+			rollback = rollbackOverride;
+		}
+		return rollback;
+	}
+}
+
+// 检测是否是默认的回滚策略
+protected final boolean isDefaultRollback(TestContext testContext) throws Exception {
+		Class<?> testClass = testContext.getTestClass();
+    	// 获取类或方法上的Rollback注解
+		Rollback rollback = AnnotatedElementUtils.findMergedAnnotation(testClass, Rollback.class);
+		boolean rollbackPresent = (rollback != null);
+		// ...
+		if (rollbackPresent) {
+            // Rollback 注解存在则返回注解内的 value 值
+			boolean defaultRollback = rollback.value();
+			return defaultRollback;
+		}
+
+		// else
+		return txConfigAttributes.isDefaultRollback();
+	}
+```
+
+`isRollback()`方法中首先检测事务回滚策略是否是默认策略。然后再次检测单元测试类或方法上是否存在`Rollback`注解，如果有注解，则覆盖默认的回滚策略。
+
+
+
+#### spring在哪里进行事务的提交或回滚？
+
+通过上面的注解检测阶段我们看到了一段代码：
+
+`txContext = new TransactionContext(testContext, tm, transactionAttribute, isRollback(testContext));`
+
+由此我们可以确定，事务的管理应该就是在当前类中进行管理的。下面我们看下当前调用的构造器：
+
+```java
+TransactionContext(TestContext testContext,
+                   PlatformTransactionManager transactionManager,
+					TransactionDefinition transactionDefinition, boolean defaultRollback) {
+	this.testContext = testContext;
+	this.transactionManager = transactionManager;
+	this.transactionDefinition = transactionDefinition;
+	this.defaultRollback = defaultRollback;
+	this.flaggedForRollback = defaultRollback;
+}
+```
+
+对比构造器的调用和声明，可以看出检测`Rollback`注解获取到的值，在构造器中被赋值给`flaggedForRollback`属性。通过跟踪`flaggedForRollback`属性，在`endTransaction()`方法中可以看到如下代码：
+
+```java
+void endTransaction() {
+    if (this.flaggedForRollback) {
+        this.transactionManager.rollback(this.transactionStatus);
+    }
+    else {
+        this.transactionManager.commit(this.transactionStatus);
+    }
+}
+```
+
+至此，也就可以很容易的看出，为什么`Rollback`注解可以控制事务的提交或者回滚了。
+
+#### Commit怎么没有被使用？
+
+在前面的源码解析中检测和获取的注解值都是`Rollback`，那`Commit`就没有作用了吗？
+
+带着这个疑问，我们可以看下`Commit`注解的声明：
+
+```java
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Rollback(false)
+public @interface Commit {
+}
+```
+
+看到源码豁然开朗，原来`Commit`只是一个标记注解，它最主要的作用就是承载`@Rollback(false)`。
+
+这样在注解搜索阶段就可以通过获取类或方法上的所有注解，同时获取注解的注解，也就是说，spring通过检测类或者方法上的所有注解，同时检测获取到的注解有没有被`Rollback`注解进行修饰。通过这种方法，在注解检测阶段就不需要分别对这两类注解分别进行解析。
\ No newline at end of file
diff --git "a/springframework/\350\277\220\350\241\214\346\227\266\346\263\250\345\206\214bean.md" "b/springframework/\350\277\220\350\241\214\346\227\266\346\263\250\345\206\214bean.md"
new file mode 100644
index 0000000..130c05c
--- /dev/null
+++ "b/springframework/\350\277\220\350\241\214\346\227\266\346\263\250\345\206\214bean.md"
@@ -0,0 +1,61 @@
+## 运行时移除bean
+
+```java
+    /**
+     * 动态移除 bean
+     *
+     * @param context spring context
+     * @param clazz   被移除的 bean 类型
+     */
+    public void removeBeanFromIoc(ApplicationContext context, Class<?> clazz) {
+        // 转型 ApplicationContext
+        ConfigurableApplicationContext applicationContext = (ConfigurableApplicationContext) context;
+        // 获取 bean 工厂
+        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getBeanFactory();
+        // 获取 bean 名称
+        String[] beanNames = applicationContext.getBeanNamesForType(clazz);
+        if (beanNames != null) {
+            // 根据名称移除 bean
+            Arrays.stream(beanNames).forEach(beanFactory::removeBeanDefinition);
+        }
+    }
+```
+
+## 运行时注册bean
+
+```java
+    /**
+     * 动态注册bean到ioc
+     *
+     * @param context  spring context
+     * @param beanName 新注册的bean名称
+     * @param clazz    bean类型
+     */
+    public void registerBean2IOC(ApplicationContext context, String beanName, Class<?> clazz) {
+        // 转型 ApplicationContext
+        ConfigurableApplicationContext applicationContext = (ConfigurableApplicationContext) context;
+        // 获取 bean 工厂
+        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getBeanFactory();
+
+        // 定义bean
+        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
+        // 设置bean的属性值
+        beanDefinitionBuilder.addPropertyValue("属性名", "属性值");
+        beanDefinitionBuilder.addPropertyReference("属性名", "引用的bean名称");
+        // 注册到 ioc
+        beanFactory.registerBeanDefinition(beanName, beanDefinitionBuilder.getBeanDefinition());
+    }
+```
+
+## 缺陷
+
+通过这种方式注册的bean，只能通过`ApplicationContext.getBean(clazz)`获取的才是正确的bean，无法参与到`Autowired`这种注入。
+
+如果想通过这种方式实现bean对象的替换是不可行的。
+
+解决动态替换的方案有：
+
+* 动态注册bean后，反射源对象，将新注册的bean属性拷贝到源对象(不建议使用)
+* 使用 `java agent` 
+* 使用 `spring -loaded` 
+
diff --git "a/vuejs/vue\345\205\245\351\227\250.md" "b/vuejs/vue\345\205\245\351\227\250.md"
new file mode 100644
index 0000000..5404f4a
--- /dev/null
+++ "b/vuejs/vue\345\205\245\351\227\250.md"
@@ -0,0 +1,950 @@
+## 引入vue.js
+
+在`html`文件中添加：
+
+`<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>`
+
+## 声明式渲染
+
+声明式渲染是`vue`提供的一个动态改变页面属性的特性，通过页面属性和`js`属性的绑定，实现修改一方，另一方也动态更新的原则。
+
+## 插值
+
+### 文本
+
+可动态更新的文本
+
+```html
+<span>Message: {{ msg }}</span>
+```
+
+仅能执行一次的文本
+
+```html
+<span v-once>这个将不会改变: {{ msg }}</span>
+```
+
+### 原始 HTML
+
+在标签中插入 `html` 文本需要使用 `v-html` 指令
+
+```HTML
+<p>Using v-html directive: <span v-html="rawHtml"></span></p>
+```
+
+### 特性
+
+Mustache 语法不能作用在 HTML 特性上，遇到这种情况应该使用 `v-bind` 指令：
+
+```
+<div v-bind:id="dynamicId"></div>
+```
+
+对于布尔特性 (它们只要存在就意味着值为 `true`)，`v-bind` 工作起来略有不同，在这个例子中：
+
+```
+<button v-bind:disabled="isButtonDisabled">Button</button>
+```
+
+如果 `isButtonDisabled` 的值是 `null`、`undefined` 或 `false`，则 `disabled` 特性甚至不会被包含在渲染出来的 `<button>` 元素中。
+
+### 使用js表达式
+
+`vue`只允许访问一个全局变量，同时，`js`表达式只能是一行，不支持多行。
+
+
+
+## 指令
+
+指令是带有`v-`前缀的特殊特性。指令的值预期是**单个js表达式**
+
+`v-if`用于判断：
+
+```html
+<p v-if="seen">现在你看到我了</p>
+```
+
+`v-for`用于循环：
+
+```html
+ <li v-for="todo in todos">
+      {{ todo.text }}
+ </li>
+```
+
+### 参数
+
+一些指令能够接收一个“参数”，在指令名称之后以冒号表示。例如，`v-bind` 指令可以用于响应式地更新 HTML 特性：
+
+```html
+<a v-bind:href="url">...</a>
+```
+
+在这里 `href` 是参数，告知 `v-bind` 指令将该元素的 `href` 特性与表达式 `url` 的值绑定。
+
+另一个例子是 `v-on` 指令，它用于监听 DOM 事件：
+
+```html
+<a v-on:click="doSomething">...</a>
+```
+
+在这里参数是监听的事件名。我们也会更详细地讨论事件处理。
+
+### 动态参数
+
+用方括号括起来的参数叫做动态参数。
+
+```html
+<a v-bind:[attributeName]="url"> ... </a>
+```
+
+这里的 `attributeName` 会被作为一个 JavaScript 表达式进行动态求值，求得的值将会作为最终的参数来使用。例如，如果你的 Vue 实例有一个 `data` 属性 `attributeName`，其值为 `"href"`，那么这个绑定将等价于 `v-bind:href`。
+
+同样地，你可以使用动态参数为一个动态的事件名绑定处理函数：
+
+```
+<a v-on:[eventName]="doSomething"> ... </a>
+```
+
+同样地，当 `eventName` 的值为 `"focus"` 时，`v-on:[eventName]` 将等价于 `v-on:focus`。
+
+#### 对动态参数的值的约束
+
+动态参数预期会求出一个字符串，异常情况下值为 `null`。这个特殊的 `null` 值可以被显性地用于移除绑定。任何其它非字符串类型的值都将会触发一个警告。
+
+#### 对动态参数表达式的约束
+
+动态参数表达式有一些语法约束，因为某些字符，例如空格和引号，放在 HTML 特性名里是无效的。同样，在 DOM 中使用模板时你需要回避大写键名。
+
+### 修饰符
+
+修饰符 (modifier) 是以半角句号 `.` 指明的特殊后缀，用于指出一个指令应该以特殊方式绑定。例如，`.prevent` 修饰符告诉 `v-on` 指令对于触发的事件调用 `event.preventDefault()`：
+
+```html
+<form v-on:submit.prevent="onSubmit">...</form>
+```
+
+### 缩写
+
+`vue`为`v-bind`和`v-on`这两个常用指令提供了缩写。
+
+**`v-bind`缩写**
+
+```html
+<!-- 完整语法 -->
+<a v-bind:href="url">...</a>
+
+<!-- 缩写 -->
+<a :href="url">...</a>
+```
+
+**`v-on`缩写**
+
+```html
+<!-- 完整语法 -->
+<a v-on:click="doSomething">...</a>
+
+<!-- 缩写 -->
+<a @click="doSomething">...</a>
+```
+
+
+
+## 计算属性
+
+计算属性用于简化`{{}}`中频繁的使用复杂的表达式。计算属性和普通属性的使用方式一致。当`Vue`对象的`data`在计算属性内使用时，如果`data`内的数据发生变更，计算属性也会跟随着变化。
+
+```html
+<div id="example">
+  <p>Original message: "{{ message }}"</p>
+  <p>Computed reversed message: "{{ reversedMessage }}"</p>
+</div>
+```
+
+```js
+var vm = new Vue({
+  el: '#example',
+  data: {
+    message: 'Hello'
+  },
+  computed: {
+    // 计算属性的 getter
+    reversedMessage: function () {
+      // `this` 指向 vm 实例
+      return this.message.split('').reverse().join('')
+    }
+  }
+})
+```
+
+### 手动声明计算属性的 getter setter
+
+```js
+computed: {
+  fullName: {
+    // getter
+    get: function () {
+      return this.firstName + ' ' + this.lastName
+    },
+    // setter
+    set: function (newValue) {
+      var names = newValue.split(' ')
+      this.firstName = names[0]
+      this.lastName = names[names.length - 1]
+    }
+  }
+}
+```
+
+现在再运行 `vm.fullName = 'John Doe'` 时，setter 会被调用，`vm.firstName` 和 `vm.lastName` 也会相应地被更新。
+
+### 计算属性和方法的区别
+
+`计算属性`和`方法`都能达到属性计算的目的，但是`计算属性`是惰性求值的，也就是说，`计算属性`会做缓存，只有与`计算属性`关联的属性改变时，`计算属性`才会重新求值。而方法则是在每次调用时都会重新求值。
+
+## 方法
+
+```html
+<p>Reversed message: "{{ reversedMessage() }}"</p>
+```
+
+```js
+// 在组件中
+methods: {
+  reversedMessage: function () {
+    return this.message.split('').reverse().join('')
+  }
+}
+```
+
+
+
+## 侦听器
+
+Vue 提供了一种更通用的方式来观察和响应 Vue 实例上的数据变动：**侦听属性**。它被设计为用于监听属性的变化，从而执行必要的操作。
+
+```html
+<div id="demo">{{ fullName }}</div>
+```
+
+```js
+var vm = new Vue({
+  el: '#demo',
+  data: {
+    firstName: 'Foo',
+    lastName: 'Bar',
+    fullName: 'Foo Bar'
+  },
+  watch: {
+    firstName: function (val) {
+      this.fullName = val + ' ' + this.lastName
+    },
+    lastName: function (val) {
+      this.fullName = this.firstName + ' ' + val
+    }
+  }
+})
+```
+
+
+
+## Class 与 Style 绑定
+
+操作元素的 class 列表和内联样式是数据绑定的一个常见需求。因为它们都是属性，所以我们可以用 `v-bind` 处理它们：只需要通过表达式计算出字符串结果即可。不过，字符串拼接麻烦且易错。因此，在将 `v-bind` 用于 `class` 和 `style` 时，Vue.js 做了专门的增强。表达式结果的类型除了字符串之外，还可以是对象或数组。
+
+### 绑定 HTML Class
+
+#### 对象语法
+
+我们可以传给 `v-bind:class` 一个对象，以动态地切换 class：
+
+```html
+<div v-bind:class="{ active: isActive }"></div>
+```
+
+上面的语法表示 `active` 这个 class 存在与否将取决于数据属性 `isActive` 的 [truthiness](https://developer.mozilla.org/zh-CN/docs/Glossary/Truthy)。
+
+你可以在对象中传入更多属性来动态切换多个 class。此外，`v-bind:class` 指令也可以与普通的 class 属性共存。当有如下模板:
+
+```html
+<div
+  class="static"
+  v-bind:class="{ active: isActive, 'text-danger': hasError }"
+></div>
+```
+
+和如下 data：
+
+```js
+data: {
+  isActive: true,
+  hasError: false
+}
+```
+
+结果渲染为：
+
+```html
+<div class="static active"></div>
+```
+
+当 `isActive` 或者 `hasError` 变化时，class 列表将相应地更新。例如，如果 `hasError` 的值为 `true`，class 列表将变为 `"static active text-danger"`。
+
+绑定的数据对象不必内联定义在模板里：
+
+```html
+<div v-bind:class="classObject"></div>
+```
+
+```js
+data: {
+  classObject: {
+    active: true,
+    'text-danger': false
+  }
+}
+```
+
+渲染的结果和上面一样。我们也可以在这里绑定一个返回对象的计算属性。这是一个常用且强大的模式：
+
+```html
+<div v-bind:class="classObject"></div>
+```
+
+```js
+data: {
+  isActive: true,
+  error: null
+},
+computed: {
+  classObject: function () {
+    return {
+      active: this.isActive && !this.error,
+      'text-danger': this.error && this.error.type === 'fatal'
+    }
+  }
+}
+```
+
+#### 数组语法
+
+我们可以把一个数组传给 `v-bind:class`，以应用一个 class 列表：
+
+```html
+<div v-bind:class="[activeClass, errorClass]"></div>
+```
+
+```js
+data: {
+  activeClass: 'active',
+  errorClass: 'text-danger'
+}
+```
+
+渲染为：
+
+```html
+<div class="active text-danger"></div>
+```
+
+如果你也想根据条件切换列表中的 class，可以用三元表达式：
+
+```html
+<div v-bind:class="[isActive ? activeClass : '', errorClass]"></div>
+```
+
+这样写将始终添加 `errorClass`，但是只有在 `isActive` 是 truthy时才添加 `activeClass`。
+
+不过，当有多个条件 class 时这样写有些繁琐。所以在数组语法中也可以使用对象语法：
+
+```html
+<div v-bind:class="[{ active: isActive }, errorClass]"></div>
+```
+
+#### 用在组件上
+
+当在一个自定义组件上使用 `class` 属性时，这些类将被添加到该组件的根元素上面。这个元素上已经存在的类不会被覆盖。
+
+例如，如果你声明了这个组件：
+
+```js
+Vue.component('my-component', {
+  template: '<p class="foo bar">Hi</p>'
+})
+```
+
+然后在使用它的时候添加一些 class：
+
+```html
+<my-component class="baz boo"></my-component>
+```
+
+HTML 将被渲染为:
+
+```html
+<p class="foo bar baz boo">Hi</p>
+```
+
+对于带数据绑定 class 也同样适用：
+
+```html
+<my-component v-bind:class="{ active: isActive }"></my-component>
+```
+
+当 `isActive` 为 truthy[[1\]](https://cn.vuejs.org/v2/guide/class-and-style.html#footnote-1) 时，HTML 将被渲染成为：
+
+```html
+<p class="foo bar active">Hi</p>
+```
+
+### 绑定内联样式
+
+#### 对象语法
+
+`v-bind:style` 的对象语法十分直观——看着非常像 CSS，但其实是一个 JavaScript 对象。CSS 属性名可以用驼峰式 (camelCase) 或短横线分隔 (kebab-case，记得用引号括起来) 来命名：
+
+```html
+<div v-bind:style="{ color: activeColor, fontSize: fontSize + 'px' }"></div>
+```
+
+```js
+data: {
+  activeColor: 'red',
+  fontSize: 30
+}
+```
+
+直接绑定到一个样式对象通常更好，这会让模板更清晰：
+
+```html
+<div v-bind:style="styleObject"></div>
+```
+
+```js
+data: {
+  styleObject: {
+    color: 'red',
+    fontSize: '13px'
+  }
+}
+```
+
+同样的，对象语法常常结合返回对象的计算属性使用。
+
+#### 数组语法
+
+`v-bind:style` 的数组语法可以将多个样式对象应用到同一个元素上：
+
+```html
+<div v-bind:style="[baseStyles, overridingStyles]"></div>
+```
+
+#### 自动添加前缀
+
+当 `v-bind:style` 使用需要添加浏览器引擎前缀的 CSS 属性时，如 `transform`，Vue.js 会自动侦测并添加相应的前缀。
+
+#### 多重值
+
+可以为 `style` 绑定中的属性提供一个包含多个值的数组，常用于提供多个带前缀的值，例如：
+
+```html
+<div :style="{ display: ['-webkit-box', '-ms-flexbox', 'flex'] }"></div>
+```
+
+这样写只会渲染数组中最后一个被浏览器支持的值。在本例中，如果浏览器支持不带浏览器前缀的 flexbox，那么就只会渲染 `display: flex`。
+
+
+
+## 条件渲染
+
+### v-if
+
+`v-if` 指令用于条件性地渲染一块内容。这块内容只会在指令的表达式返回 truthy 值的时候被渲染。
+
+```html
+<h1 v-if="awesome">Vue is awesome!</h1>
+```
+
+也可以用 `v-else` 添加一个“else 块”：
+
+```html
+<h1 v-if="awesome">Vue is awesome!</h1>
+<h1 v-else>Oh no 😢</h1>
+```
+
+Vue也提供了`v-else-if`，这些判断表达式都可以引用在`template`上面。
+
+**注： **Vue会重用已有的元素而不是从头开始渲染，如果要禁止该特性，可以给标签添加`key`属性，提供一个唯一值。
+
+```html
+<template v-if="loginType === 'username'">
+  <label>Username</label>
+  <input placeholder="Enter your username" key="username-input">
+</template>
+<template v-else>
+  <label>Email</label>
+  <input placeholder="Enter your email address" key="email-input">
+</template>
+```
+
+### v-show
+
+另一个用于根据条件展示元素的选项是 `v-show` 指令。用法大致一样：
+
+```html
+<h1 v-show="ok">Hello!</h1>
+```
+
+不同的是带有 `v-show` 的元素始终会被渲染并保留在 DOM 中。`v-show` 只是简单地切换元素的 CSS 属性 `display`。
+
+**注：** `v-show` 不支持 `<template>` 元素，也不支持 `v-else`。
+
+### v-if  VS v-show
+
+`v-if` 是“真正”的条件渲染，因为它会确保在切换过程中条件块内的事件监听器和子组件适当地被销毁和重建。
+
+`v-if` 也是**惰性的**：如果在初始渲染时条件为假，则什么也不做——直到条件第一次变为真时，才会开始渲染条件块。
+
+相比之下，`v-show` 就简单得多——不管初始条件是什么，元素总是会被渲染，并且只是简单地基于 CSS 进行切换。
+
+一般来说，`v-if` 有更高的切换开销，而 `v-show` 有更高的初始渲染开销。因此，如果需要非常频繁地切换，则使用 `v-show` 较好；如果在运行时条件很少改变，则使用 `v-if` 较好。
+
+
+
+## 列表渲染
+
+### 应用在数组上
+
+`v-for`用于对列表进行渲染，`v-for` 指令需要使用 `item in items` 形式的特殊语法，`items` 是源数据数组并且 `item` 是数组元素迭代的别名。`v-for` 还支持一个可选的第二个参数为当前项的索引。
+
+```html
+<ul id="example-1">
+  <li v-for="item in items">
+    {{ item.message }}
+  </li>
+</ul>
+<ul id="example-2">
+  <li v-for="(item, index) in items">
+    {{ parentMessage }} - {{ index }} - {{ item.message }}
+  </li>
+</ul>
+```
+
+### 应用到对象上
+
+`v-for`应用在对象上，格式为`field in object`， `field`为对象的属性值。在该语法中，field可以提供三个参数，分别是 （属性值， 属性名， 索引）
+
+```html
+<div v-for="value in object">
+  {{ value }}
+</div>
+<div v-for="(value, name) in object">
+  {{ name }}: {{ value }}
+</div>
+<div v-for="(value, name, index) in object">
+  {{ index }}. {{ name }}: {{ value }}
+</div>
+```
+
+**注：** 在遍历对象时，是按 `Object.keys()` 的结果遍历，但是不能保证它的结果在不同的 JavaScript 引擎下是一致的。
+
+### 维护状态
+
+当 Vue.js 用 `v-for` 正在更新已渲染过的元素列表时，它默认用“就地复用”策略。如果数据项的顺序被改变，Vue 将不会移动 DOM 元素来匹配数据项的顺序， 而是简单复用此处每个元素，并且确保它在特定索引下显示已被渲染过的每个元素。
+
+为了给 Vue 一个提示，以便它能跟踪每个节点的身份，从而重用和重新排序现有元素，你需要为每项提供一个唯一 `key` 属性：
+
+```html
+<div v-for="item in items" v-bind:key="item.id">
+  <!-- 内容 -->
+</div>
+```
+
+### 数组更新检测
+
+#### 变异方法
+
+Vue 包含一组观察数组的变异方法，所以它们也将会触发视图更新。这些方法如下：
+
+- `push()`
+- `pop()`
+- `shift()`
+- `unshift()`
+- `splice()`
+- `sort()`
+- `reverse()`
+
+你打开控制台，然后用前面例子的 `items` 数组调用变异方法：`example1.items.push({ message: 'Baz' })` 。
+
+#### 替换数组
+
+变异方法 (mutation method)，顾名思义，会改变被这些方法调用的原始数组。相比之下，也有非变异 (non-mutating method) 方法，例如：`filter()`, `concat()` 和 `slice()` 。这些不会改变原始数组，但**总是返回一个新数组**。当使用非变异方法时，可以用新数组替换旧数组：
+
+```js
+example1.items = example1.items.filter(function (item) {
+  return item.message.match(/Foo/)
+})
+```
+
+你可能认为这将导致 Vue 丢弃现有 DOM 并重新渲染整个列表。幸运的是，事实并非如此。Vue 为了使得 DOM 元素得到最大范围的重用而实现了一些智能的、启发式的方法，所以用一个含有相同元素的数组去替换原来的数组是非常高效的操作。
+
+#### 注意事项
+
+由于 JavaScript 的限制，Vue 不能检测以下变动的数组：
+
+1. 当你利用索引直接设置一个项时，例如：`vm.items[indexOfItem] = newValue`
+2. 当你修改数组的长度时，例如：`vm.items.length = newLength`
+
+解决第一种情况：
+
+1. `Vue.set(vm.items, indexOfItem, newValue)`
+2. `vm.items.splice(indexOfItem, 1, newValue)`
+3. `vm.$set(vm.items, indexOfItem, newValue)`
+
+解决第二种情况：
+
+1. `vm.items.splice(newLength)`
+
+
+
+## 事件处理
+
+### 监听事件
+
+可以用 `v-on` 指令监听 DOM 事件，并在触发时运行一些 JavaScript 代码。
+
+然而许多事件处理逻辑会更为复杂，所以直接把 JavaScript 代码写在 `v-on` 指令中是不可行的。因此 `v-on` 还可以接收一个需要调用的方法名称。
+
+有时也需要在内联语句处理器中访问原始的 DOM 事件。可以用特殊变量 `$event` 把它传入方法：
+
+```html
+<button v-on:click="warn('Form cannot be submitted yet.', $event)">
+  Submit
+</button>
+```
+
+```js
+// ...
+methods: {
+  warn: function (message, event) {
+    // 现在我们可以访问原生事件对象
+    if (event) event.preventDefault()
+    alert(message)
+  }
+}
+```
+
+### 事件修饰符
+
+在事件处理程序中调用 `event.preventDefault()` 或 `event.stopPropagation()` 是非常常见的需求。尽管我们可以在方法中轻松实现这点，但更好的方式是：方法只有纯粹的数据逻辑，而不是去处理 DOM 事件细节。
+
+为了解决这个问题，Vue.js 为 `v-on` 提供了**事件修饰符**。之前提过，修饰符是由点开头的指令后缀来表示的。
+
+- `.stop`
+- `.prevent`
+- `.capture`
+- `.self`
+- `.once`
+- `.passive`
+
+```html
+<!-- 阻止单击事件继续传播 -->
+<a v-on:click.stop="doThis"></a>
+
+<!-- 提交事件不再重载页面 -->
+<form v-on:submit.prevent="onSubmit"></form>
+
+<!-- 修饰符可以串联 -->
+<a v-on:click.stop.prevent="doThat"></a>
+
+<!-- 只有修饰符 -->
+<form v-on:submit.prevent></form>
+
+<!-- 添加事件监听器时使用事件捕获模式 -->
+<!-- 即元素自身触发的事件先在此处理，然后才交由内部元素进行处理 -->
+<div v-on:click.capture="doThis">...</div>
+
+<!-- 只当在 event.target 是当前元素自身时触发处理函数 -->
+<!-- 即事件不是从内部元素触发的 -->
+<div v-on:click.self="doThat">...</div>
+
+<!-- 点击事件将只会触发一次 -->
+<a v-on:click.once="doThis"></a>
+
+<!-- 滚动事件的默认行为 (即滚动行为) 将会立即触发 -->
+<!-- 而不会等待 `onScroll` 完成  -->
+<!-- 这其中包含 `event.preventDefault()` 的情况 -->
+<div v-on:scroll.passive="onScroll">...</div>
+```
+
+**注：** 使用修饰符时，顺序很重要；相应的代码会以同样的顺序产生。因此，用 `v-on:click.prevent.self` 会阻止**所有的点击**，而 `v-on:click.self.prevent` 只会阻止对元素自身的点击。
+
+**注：** 不要把 `.passive` 和 `.prevent` 一起使用，因为 `.prevent` 将会被忽略，同时浏览器可能会向你展示一个警告。请记住，`.passive` 会告诉浏览器你*不*想阻止事件的默认行为。
+
+
+
+## 表单输入绑定
+
+### 基础用法
+
+`v-model`指令在表单`<input>`、`<textarea>`及`<select>`元素上创建双向数据绑定。它会根据控件类型自动选取正确的方法来更新元素。
+
+`v-model`会忽略所有表单元素的`value`、`checked`、`selected`特性的初始值而总是将Vue实例的数据作为数据来源。因此，应该通过JS在组件的`data`选项中声明初始值。
+
+`v-model`在内部为不同的输入元素使用不同的属性并抛出不同的事件：
+
+* text 和 textarea 元素使用 `value` 属性和 `input` 事件；
+* checkbox 和 radio 使用 `checked` 属性和 `change` 事件；
+* select 字段将 `value` 作为 prop 并将 `change` 作为事件。
+
+**注： ** `v-model` 和 `v-bind:value` 绑定的值一致。
+
+### 修饰符
+
+#### .lazy
+
+在默认情况下，`v-model` 在每次 `input` 事件触发后将输入框的值与数据进行同步 (除了[上述](https://cn.vuejs.org/v2/guide/forms.html#vmodel-ime-tip)输入法组合文字时)。你可以添加 `lazy` 修饰符，从而转变为使用 `change` 事件进行同步：
+
+```html
+<!-- 在“change”时而非“input”时更新 -->
+<input v-model.lazy="msg" >
+```
+
+#### .number
+
+如果想自动将用户的输入值转为数值类型，可以给 `v-model` 添加 `number` 修饰符：
+
+```html
+<input v-model.number="age" type="number">
+```
+
+这通常很有用，因为即使在 `type="number"` 时，HTML 输入元素的值也总会返回字符串。如果这个值无法被 `parseFloat()` 解析，则会返回原始的值。
+
+#### .trim
+
+如果要自动过滤用户输入的首尾空白字符，可以给 `v-model` 添加 `trim` 修饰符：
+
+```html
+<input v-model.trim="msg">
+```
+
+
+
+## 组件
+
+### 基本示例
+
+```js
+// 定义一个名为 button-counter 的新组件
+Vue.component('button-counter', {
+  data: function () {
+    return {
+      count: 0
+    }
+  },
+  template: '<button v-on:click="count++">You clicked me {{ count }} times.</button>'
+})
+```
+
+组件是可复用的Vue实例，且带有一个名字：在这个例子中是 `<button-counter>`。我们可以在一个通过 `new Vue` 创建的 Vue 根实例中，把这个组件作为自定义元素来使用：
+
+```html
+<div id="components-demo">
+  <button-counter></button-counter>
+</div>
+```
+
+```js
+new Vue({ el: '#components-demo' })
+```
+
+因为组件是可复用的 Vue 实例，所以它们与 `new Vue` 接收相同的选项，例如 `data`、`computed`、`watch`、`methods` 以及生命周期钩子等。仅有的例外是像 `el` 这样根实例特有的选项。
+
+### `data`必须是一个函数
+
+一个组件的`data`选项必须是一个函数，因此每个实例可以维护一份被返回对象的独立的拷贝。
+
+### 通过Prop向子组件传递数据
+
+子组件可以通过`props`选项将其包含在该组件可接受的prop列表中。
+
+```js
+Vue.component('blog-post', {
+  props: ['title'],
+  template: '<h3>{{ title }}</h3>'
+})
+```
+
+一个组件默认可以拥有任意数量的 prop，任何值都可以传递给任何 prop。
+
+```html
+<blog-post title="My journey with Vue"></blog-post>
+```
+
+我们可以使用`v-bind`来动态传递prop。也可通过`v-bind`直接传递对象。
+
+```html
+<blog-post
+  v-for="post in posts"
+  v-bind:key="post.id"
+  v-bind:title="post.title"
+></blog-post>
+```
+
+### 监听子组件事件
+
+子组件通过`v-on:事件类型="$emit('事件名')"`向父组件提交事件，父组件通过`v-on:事件名`绑定并处理事件。
+
+子组件：
+
+```html
+Vue.component('blog-post', {
+  props: ['post'],
+  template: `
+    <div class="blog-post">
+      <h3>{{ post.title }}</h3>
+      <button v-on:click="$emit('enlarge-text')">
+        Enlarge text
+      </button>
+      <div v-html="post.content"></div>
+    </div>
+  `
+})
+```
+
+父组件：
+
+```html
+<blog-post
+  ...
+  v-on:enlarge-text="postFontSize += 0.1"
+></blog-post>
+```
+
+```js
+new Vue({
+  el: '#blog-posts-events-demo',
+  data: {
+    posts: [/* ... */],
+    postFontSize: 1
+  }
+})
+```
+
+### 使用事件抛出一个值
+
+有的时候用一个事件来抛出一个特定的值是非常有用的。例如我们可能想让 `<blog-post>` 组件决定它的文本要放大多少。这时可以使用 `$emit` 的第二个参数来提供这个值：
+
+```html
+<button v-on:click="$emit('enlarge-text', 0.1)">
+  Enlarge text
+</button>
+```
+
+然后当在父级组件监听这个事件的时候，我们可以通过 `$event` 访问到被抛出的这个值：
+
+```html
+<blog-post
+  ...
+  v-on:enlarge-text="postFontSize += $event"
+></blog-post>
+```
+
+或者，如果这个事件处理函数是一个方法：
+
+```html
+<blog-post
+  ...
+  v-on:enlarge-text="onEnlargeText"
+></blog-post>
+```
+
+那么这个值将会作为第一个参数传入这个方法：
+
+```js
+methods: {
+  onEnlargeText: function (enlargeAmount) {
+    this.postFontSize += enlargeAmount
+  }
+}
+```
+
+### 在组件上使用 `v-model`
+
+自定义组件需要使用`$emit`提交事件，并提供组件的输入值。同时也需要为自定义组件绑定值。
+
+```js
+Vue.component('custom-input', {
+    props: ['value'],
+    template: `
+        <input
+        	v-bind:value="value"
+        	v-on:input="$emit('input', $event.target.value)"
+        >
+`
+})
+```
+
+使用自定义组件和使用原生组件一致。`v-model`既可以绑定`data`的属性，也可以绑定计算属性，但是不能绑定方法。
+
+```html
+<custom-input v-model="searchText"></custom-input>
+```
+
+```js
+var app = new Vue({
+    el: '#app',
+    data: {
+        text: '111'
+    },
+    computed: {
+        searchText: function(argument) {
+            return this.text;
+        }
+    }
+})
+```
+
+### 通过插槽分发内容
+
+和 HTML 元素一样，我们经常需要向一个组件传递内容，像这样：
+
+```html
+<alert-box>
+  Something bad happened.
+</alert-box>
+```
+
+可能会渲染出这样的东西：
+
+**Error!** Something bad happened.
+
+幸好，Vue 自定义的 `<slot>` 元素让这变得非常简单：
+
+```js
+Vue.component('alert-box', {
+  template: `
+    <div class="demo-alert-box">
+      <strong>Error!</strong>
+      <slot></slot>
+    </div>
+  `
+})
+```
+
+### 动态组件
+
+有的时候，在不同组件之间进行动态切换是非常有用的，比如在一个多标签的界面里。
+
+动态组件可以通过 Vue 的 `<component>` 元素加一个特殊的 `is` 特性来实现：
+
+```html
+<!-- 组件会在 `currentTabComponent` 改变时改变 -->
+<component v-bind:is="currentTabComponent"></component>
+```
+
+在上述示例中，`currentTabComponent` 可以包括
+
+- 已注册组件的名字，或
+- 一个组件的选项对象
+
diff --git "a/windows/\345\256\211\350\243\205ubuntu\345\255\220\347\263\273\347\273\237.md" "b/windows/\345\256\211\350\243\205ubuntu\345\255\220\347\263\273\347\273\237.md"
new file mode 100644
index 0000000..67ca86a
--- /dev/null
+++ "b/windows/\345\256\211\350\243\205ubuntu\345\255\220\347\263\273\347\273\237.md"
@@ -0,0 +1,112 @@
+## 启用WSL
+
+使用`WINDOWS + X`打开`Windows PowerShell(管理员)`，执行如下命令：
+
+```sh
+Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
+```
+
+执行完毕后按回车键重启。
+
+## 安装Ubuntu
+
+1、在开始菜单中找到`Windows Store`，搜索`Ubuntu`进行安装。
+
+2、打开开始菜单，点击刚刚安装的`Ubuntu`，系统会提示`Installing, this may take a few minutes..`
+
+3、等待安装，命令行中会提示输入用户名和密码，按要求填写。
+
+## 启动Ubuntu
+
+1、通过开始菜单按钮进行启动。
+
+2、命令行中输入`bash`或`wsl`登录子系统。
+
+## 挂载点
+
+`Ubuntu`子系统安装后默认挂载了`c`盘。位置在`/mnt`下面，进入该目录可以看到`C`盘的内容，但是需要通过`sudo`提权后才能查看。
+
+## XShell 连接子系统
+
+1、配置SSH服务，执行如下命令
+
+```shell
+sudo apt-get remove --purge openssh-server   ## 先删ssh
+sudo apt-get install openssh-server          ## 在安装ssh  
+
+sudo rm /etc/ssh/ssh_config                  ## 删配置文件，让ssh服务自己想办法链接
+sudo service ssh --full-restart
+```
+
+2、直接使用XShell通过IP进行登录即可。
+
+但是这种操作在子系统重启后就失效。设置永久生效的方法为将`sudo service ssh --full-restart`命令设置为脚本，系统每次重启后执行该脚本。
+
+**ssh.sh**
+
+```shell
+#!/bin/sh
+sudo service ssh --full-restart
+```
+
+赋予执行权限：
+
+```shell
+sudo chmod +x ssh.sh
+```
+
+使用如下命令执行脚本：
+
+```shell
+sh ssh.sh
+```
+
+## 配置国内镜像源
+
+1、访问[清华大学开源软件镜像站](<https://mirrors.tuna.tsinghua.edu.cn/help/ubuntu/>)，选择对应的Ubuntu版本，复制镜像，如：
+
+```shell
+# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
+deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic main restricted universe multiverse
+# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic main restricted universe multiverse
+deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-updates main restricted universe multiverse
+# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-updates main restricted universe multiverse
+deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-backports main restricted universe multiverse
+# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-backports main restricted universe multiverse
+deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-security main restricted universe multiverse
+# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-security main restricted universe multiverse
+
+# 预发布软件源，不建议启用
+# deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-proposed main restricted universe multiverse
+# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ bionic-proposed main restricted universe multiverse
+```
+
+2、备份`/etc/apt/sources.list`
+
+```shell
+sudo cp sources.list sources.list.bak
+```
+
+3、编辑`/etc/apt/sources.list`，将文件内的文本全部删除，并替换为刚才复制的文本，保存并退出。
+
+## Ubuntu apt相关命令
+
+| 命令                                         | 解释                                   |
+| -------------------------------------------- | -------------------------------------- |
+| sudo apt-get update                          | 更新源                                 |
+| sudo apt-get install \<package>              | 安装包                                 |
+| sudo apt-get remove \<package>               | 删除包                                 |
+| sudo apt-cache search \<package>             | 搜索软件包                             |
+| sudo apt-cache show \<package>               | 获取包的相关信息，如说明、大小、版本等 |
+| sudo apt-get install \<package> --reinstall  | 重新安装包                             |
+| sudo apt-get -f install                      | 修复安装                               |
+| sudo apt-get remove \<package> --purge       | 删除包，包括配置文件等                 |
+| sudo apt-get build-dep \<package>            | 安装相关的编译环境                     |
+| sudo apt-get upgrade                         | 更新已安装的包                         |
+| sudo apt-get dist-upgrade                    | 升级系统                               |
+| sudo apt-cache depends \<package>            | 了解使用该包依赖那些包                 |
+| sudo apt-cache rdepends \<package>           | 查看该包被哪些包依赖                   |
+| sudo apt-get source \<package>               | 下载该包的源代码                       |
+| sudo apt-get clean && sudo apt-get autoclean | 清理无用的包                           |
+| sudo apt-get check                           | 检查是否有损坏的依赖                   |
+
diff --git "a/windows/\346\237\245\347\234\213\345\215\240\347\224\250\347\253\257\345\217\243\347\232\204\350\277\233\347\250\213.md" "b/windows/\346\237\245\347\234\213\345\215\240\347\224\250\347\253\257\345\217\243\347\232\204\350\277\233\347\250\213.md"
new file mode 100644
index 0000000..3ba7635
--- /dev/null
+++ "b/windows/\346\237\245\347\234\213\345\215\240\347\224\250\347\253\257\345\217\243\347\232\204\350\277\233\347\250\213.md"
@@ -0,0 +1,33 @@
+## 查看占用端口的 PID
+
+打开命令行输入`netstat -ano  | findstr "端口号"`
+
+```
+协议		本地地址			外部地址		状态			PID
+TCP		0.0.0.0:查询端口号	0.0.0.0:0		LISTENING	pid号码
+```
+
+
+
+## 查看占用端口的进程
+
+命令行输入`tasklist | findstr "pid号码"`
+
+```
+进程名称	pid		....
+```
+
+
+
+## 根据PID终止进程
+
+打开任务管理器 -> 进程页面，
+
+点击查看 -> 选择列，在窗口中将PID勾上。
+
+在进程页面中查找指定的PID，如果找不到，将左下角的**显示所有用户的进程**打上勾。
+
+选中指定的PID，右键选择结束进程。
+
+或者在CMD命令中执行：`taskkill /f /t /im 进程名`
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/git/\344\275\277\347\224\250\346\226\207\346\241\243.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/git/\344\275\277\347\224\250\346\226\207\346\241\243.md"
new file mode 100644
index 0000000..9c76896
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/git/\344\275\277\347\224\250\346\226\207\346\241\243.md"
@@ -0,0 +1,641 @@
+### 一、创建版本库
+
+#### 1、本地仓库
+
+1、创建文件夹，使用该文件夹作为仓库根目录
+
+```shell
+$ mkdir repo #创建文件夹，名字为repo
+$ cd repo #进入repo目录
+$ pwd
+/home/power/root
+```
+
+2、通过`git init` 命令来初始化仓库
+
+```shell
+$ git init
+Initialized empty Git repository in /home/power/root
+```
+
+#### 2、远程仓库
+
+1）查看远程仓库信息
+
+```shell
+# 查看关联的远程仓库的名称
+git remote
+# 查看关联的远程仓库的详细信息
+git remote -v
+```
+
+2) 添加远程仓库的关键
+
+远程仓库的名称一般默认为 origin ，当然，你可以设置为其他的名称。
+
+通过 git clone 下载项目到本地时，项目文件夹中的 .git 目录就是版本库目录。
+
+.git 目录中的 config 文件中有远程仓库的关联配置。
+
+```shell
+# git_url 为你的远程仓库的 url，可采用 http 协议或 ssh（git） 协议
+git remote add origin <url>
+```
+
+3）删除远程仓库的关联
+
+```shell
+git remote remove <name>
+```
+
+4）修改远程仓库的关键
+
+方式一：
+
+```shell
+git remote set-url origin <newurl>
+```
+
+方式二： 先删除再添加
+
+```shell
+# 删除关联的远程仓库
+git remote remove <name>
+ 
+# 添加新的远程仓库关联
+git remote add <name> <url>
+```
+
+方式三：直接修改`.git`目录下的`config`配置文件
+
+### 二、提交文件
+
+1、在 `/home/power/root` 下创建 `test.txt` 文件，并输入一些文字
+
+```shell
+$ touch test.txt	# 创建test.txt文件
+$ vi test.txt		# 编辑test.txt文件，进入新窗口，按 i 进入插入模式，输入文本后按 ESC -> :wq
+$ cat test.txt		# 查看test.txt内容
+this is a new file 	# 这里test.txt内部的文字，直接在控制台输出
+$ pwd
+/home/power/root
+$ ls -a
+.git test.txt
+```
+
+2、使用 `git add <filename | . >` 文件添加到本地仓库
+
+```shell
+$ git add test.txt
+```
+
+完成，没有任何的输出。
+
+`git add filename` ：将指定的文件添加到仓库
+
+`git add .`： **.** （点）用来代替当前文件及其子文件添加到仓库。
+
+3、使用 `git commit -m <message>` 告诉 git 将使用 `git add ` 命令添加的内容提交到仓库
+
+```shell
+$ git commit -m "添加了新文件"
+[master ...]
+```
+
+`-m` 参数用于为本次提交添加评论，可以根据自己的情况添加更有意义的评论内容。
+
+**注：**
+
+`git add` 可以使用多次，多次提交仅需要使用一次 `git commit` 就可完成提交
+
+
+
+### 三、版本回退
+
+#### 1、快照、版本
+
+在 git 中，一次 `commit` 被称为一个快照(版本)，下面让我们多次修改文件并提交。
+
+版本1：添加了新文件
+
+```
+this is a new file
+```
+
+版本2：修改了文件
+
+```
+this is a update file
+```
+
+版本3：再次修改了文件
+
+```
+this is a file with update
+```
+
+#### 2、查看提交记录
+
+使用 `git log` 命令可以查看我们每次提交的ID、日期、提交人和评论。
+
+```shell
+$ git log
+commit ba26d28a0473efc9f4077aa4605057dd6c9248f2 (HEAD -> master) # ID
+Author: unknown <zhoutaotao@bojoy.net>	#提交人
+Date:   Fri May 10 10:30:32 2019 +0800	# 提交时间
+
+    再次修改了文件	#提交时添加的评论 
+
+commit 22844da5053b6516b3e8a52d0972f23b6ad53254
+Author: unknown <zhoutaotao@bojoy.net>
+Date:   Fri May 10 10:30:01 2019 +0800
+
+    修改了文件
+
+commit d4adfa45270384a698c8aea37425a73234218ba6
+Author: unknown <zhoutaotao@bojoy.net>
+Date:   Fri May 10 10:21:56 2019 +0800
+
+    添加了新文件
+```
+
+如果`git log` 命令执行后发现输出的内容过多，那么，我们可以通过添加 `--pretty=oneline` 来使得输出一行显示
+
+```shell
+$ git log --pretty=oneline
+ba26d28a0473efc9f4077aa4605057dd6c9248f2 (HEAD -> master) 再次修改了文件
+22844da5053b6516b3e8a52d0972f23b6ad53254 修改了文件
+d4adfa45270384a698c8aea37425a73234218ba6 添加了新文件
+```
+
+#### 3、回退版本
+
+在 git 中，用 `HEAD` 表示当前版本，也就是最新提交的ID为“ba26d28...”，上一个版本就是 `HEAD^`，上上个版本就是 `HEAD^^`，如果我们要会退到前100个版本，我们可以使用 `HEAD~100`。这种方式也进适用于最近的几个版本之间回退。
+
+`git reset`命令用来回退版本。
+
+```shell
+$ git reset --hard HEAD^
+HEAD is now at 22844da 修改了文件
+$ cat test.txt
+this is a update file	# 发现文件已经会退到第二版
+```
+
+如果我们回退版本时发现自己回退错了版本，那怎么办？先让 `git log`命令看看日志变化
+
+```shell
+$ git log --pretty=oneline
+22844da5053b6516b3e8a52d0972f23b6ad53254 (HEAD -> master) 修改了文件
+d4adfa45270384a698c8aea37425a73234218ba6 添加了新文件
+```
+
+从日志中可以发现，第三版提交的记录居然不存在了，我们想要回到第三版怎么办？
+
+`git reset --hard <id>` 可以帮助我们会退到第三版，前提是我们并没有关闭当前的命令行，可以从控制台的日志中找到第三版的ID。
+
+```shell
+$ git reset --hard ba26d28
+HEAD is now at ba26d28 再次修改了文件
+$ cat test.txt
+this is a file with update #第三版的文件内容又回来了
+```
+
+但是通过刚才的命令我们发现，第三版的ID是一长串内容，而我们只写了前几位，这样真的可以？答案是可以的。git 会通过给定的前几位去查找ID，如果查找的ID唯一，就正常执行命令。否则命令错误。
+
+但是，如果我们关闭了当前控制台窗口，没办法在窗口中找到提交记录的ID怎么办？
+
+总是会有办法的，我们可以使用 `git reflog` 查询到 git 指针的所有操作记录
+
+```shell
+$ git reflog
+ba26d28 (HEAD -> master) HEAD@{0}: reset: moving to ba26d28
+22844da HEAD@{1}: reset: moving to HEAD^
+ba26d28 (HEAD -> master) HEAD@{2}: commit: 再次修改了文件
+22844da HEAD@{3}: commit: 修改了文件
+d4adfa4 HEAD@{4}: commit (initial): 添加了新文件
+```
+
+这样，我们就可以找到指定的版本号了。
+
+#### 4、查看当前文件状态
+
+`git status`可以查看当前工作区文件的状态。
+
+```shell
+$ git status
+On branch master
+Changes not staged for commit:
+  (use "git add <file>..." to update what will be committed)
+  (use "git checkout -- <file>..." to discard changes in working directory)
+
+        modified:   test.txt
+
+no changes added to commit (use "git add" and/or "git commit -a")
+```
+
+#### 5、文件与版本库对比
+
+`git diff <id> -- <filename>`可以查看指定文件与版本库之间的差异
+
+```shell
+$ git diff d4adfa4 -- test.txt
+diff --git a/test.txt b/test.txt
+index 3b2aed8..d2a9c10 100644
+--- a/test.txt
++++ b/test.txt
+@@ -1 +1 @@
+-this is a new file
++this is a file with update
+```
+
+#### 6、撤销修改
+
+`git checkout -- <file>`可以将指定文件回退到最近一次 `git add` 或 `git commit`状态
+
+```shell
+$ git checkout -- test.txt
+$ git status
+On branch master
+nothing to commit, working tree clean
+```
+
+如果我们已经通过 `git add` 将文件添加到缓存区，但还没有执行 `git commit` 命令，我们可以使用 `git reset HEAD <file>` 将缓存区的内容撤销掉，重新放入工作区。再次通过 `git checkout -- <file>` 将文件回退。
+
+#### 7、删除文件
+
+`git rm <file>` 用于删除一个文件。如果一个文件已经被提交到版本库，那么你永远不用担心误删，但是要小心，你只能恢复文件到最新版本，你会丢失**最近一次提交后你修改的内容**。
+
+
+
+### 四、分支管理
+
+#### 1、创建分支
+
+首先，我们创建`dev`分支，然后切换到`dev`分支：
+
+```shell
+$ git checkout -b dev
+Switched to a new branch 'dev'
+```
+
+`git checkout`命令加上`-b`参数表示创建并切换，相当于以下两条命令：
+
+```shell
+$ git branch dev
+$ git checkout dev
+Switched to branch 'dev'
+```
+
+然后，用`git branch`命令查看当前分支：
+
+```shell
+$ git branch
+* dev
+  master
+```
+
+`git branch`命令会列出所有分支，当前分支前面会标一个`*`号。
+
+我们可以在当前分支上工作，工作完成后通过 `git commit`进行提交
+
+#### 2、合并分支
+
+现在，我们把`dev`分支的工作成果合并到`master`分支上：
+
+```
+$ git merge dev
+Updating d46f35e..b17d20e
+Fast-forward
+ readme.txt | 1 +
+ 1 file changed, 1 insertion(+)
+```
+
+`git merge`命令用于合并指定分支到当前分支。合并后，再查看readme.txt的内容，就可以看到，和`dev`分支的最新提交是完全一样的。
+
+注意到上面的`Fast-forward`信息，Git告诉我们，这次合并是“快进模式”，也就是直接把`master`指向`dev`的当前提交，所以合并速度非常快。
+
+用带参数的`git log`也可以看到分支的合并情况：
+
+```
+$ git log --graph --pretty=oneline --abbrev-commit
+*   cf810e4 (HEAD -> master) conflict fixed
+|\  
+| * 14096d0 (feature1) AND simple
+* | 5dc6824 & simple
+|/  
+```
+
+#### 3、删除分支
+
+合并完成后，就可以放心地删除`dev`分支了：
+
+```
+$ git branch -d dev
+Deleted branch dev (was b17d20e).
+```
+
+删除后，查看`branch`，就只剩下`master`分支了：
+
+```
+$ git branch
+* master
+```
+
+因为创建、合并和删除分支非常快，所以Git鼓励你使用分支完成某个任务，合并后再删掉分支，这和直接在`master`分支上工作效果是一样的，但过程更安全。
+
+**注：**如果要丢弃一个没有被合并过的分支，可以通过`git branch -D <name>`强行删除。
+
+#### 4、分支管理策略
+
+通常，合并分支时，如果可能，Git会用`Fast forward`模式，但这种模式下，删除分支后，会丢掉分支信息。
+
+如果要强制禁用`Fast forward`模式，Git就会在merge时生成一个新的commit，这样，从分支历史上就可以看出分支信息。
+
+下面我们实战一下`--no-ff`方式的`git merge`：
+
+首先，仍然创建并切换`dev`分支：
+
+```
+$ git checkout -b dev
+Switched to a new branch 'dev'
+```
+
+修改readme.txt文件，并提交一个新的commit：
+
+```
+$ git add readme.txt 
+$ git commit -m "add merge"
+[dev f52c633] add merge
+ 1 file changed, 1 insertion(+)
+```
+
+现在，我们切换回`master`：
+
+```
+$ git checkout master
+Switched to branch 'master'
+```
+
+准备合并`dev`分支，请注意`--no-ff`参数，表示禁用`Fast forward`：
+
+```
+$ git merge --no-ff -m "merge with no-ff" dev
+Merge made by the 'recursive' strategy.
+ readme.txt | 1 +
+ 1 file changed, 1 insertion(+)
+```
+
+因为本次合并要创建一个新的commit，所以加上`-m`参数，把commit描述写进去。
+
+合并后，我们用`git log`看看分支历史：
+
+```
+$ git log --graph --pretty=oneline --abbrev-commit
+*   e1e9c68 (HEAD -> master) merge with no-ff
+|\  
+| * f52c633 (dev) add merge
+|/  
+*   cf810e4 conflict fixed
+...
+```
+
+在实际开发中，我们应该按照几个基本原则进行分支管理：
+
+首先，`master`分支应该是非常稳定的，也就是仅用来发布新版本，平时不能在上面干活；
+
+那在哪干活呢？干活都在`dev`分支上，也就是说，`dev`分支是不稳定的，到某个时候，比如1.0版本发布时，再把`dev`分支合并到`master`上，在`master`分支发布1.0版本；
+
+你和你的小伙伴们每个人都在`dev`分支上干活，每个人都有自己的分支，时不时地往`dev`分支上合并就可以了。
+
+#### 5、隐藏工作细节
+
+`git stash` 可以把当前工作现场“储藏”起来，等以后恢复现场后继续工作
+
+```shell
+$ git stash
+Saved working directory and index state WIP on dev: f52c633 add merge
+```
+
+查看隐藏的工作空间
+
+```shell
+$ git stash list
+stash@{0}: WIP on dev: f52c633 add merge
+```
+
+工作现场还在，Git把stash内容存在某个地方了，但是需要恢复一下，有两个办法：
+
+一是用`git stash apply`恢复，但是恢复后，stash内容并不删除，你需要用`git stash drop`来删除；
+
+另一种方式是用`git stash pop`，恢复的同时把stash内容也删了：
+
+```shell
+$ git stash pop
+On branch dev
+Changes to be committed:
+  (use "git reset HEAD <file>..." to unstage)
+
+	new file:   hello.py
+
+Changes not staged for commit:
+  (use "git add <file>..." to update what will be committed)
+  (use "git checkout -- <file>..." to discard changes in working directory)
+
+	modified:   readme.txt
+
+Dropped refs/stash@{0} (5d677e2ee266f39ea296182fb2354265b91b3b2a)
+```
+
+你可以多次stash，恢复的时候，先用`git stash list`查看，然后恢复指定的stash，用命令：
+
+```shell
+$ git stash apply stash@{0}
+```
+
+#### 6、多人协作
+
+1.  首先用`git clone <path>`拉取分支
+2. 查看远程库信息`git remote -v`
+3. 试图用`git push origin <branch-name>`推送自己的修改；
+4. 如果推送失败，则因为远程分支比你的本地更新，需要先用`git pull`试图合并；
+5. 如果合并有冲突，则解决冲突，并在本地提交；
+6. 没有冲突或者解决掉冲突后，再用`git push origin <branch-name>`推送就能成功！
+
+如果`git pull`提示`no tracking information`，则说明本地分支和远程分支的链接关系没有创建，用命令`git branch --set-upstream-to <branch-name> origin/<branch-name>`。
+
+#### 7、美化提交线
+
+- rebase操作可以把本地未push的分叉提交历史整理成直线；
+- rebase的目的是使得我们在查看历史提交的变化时更容易，因为分叉的提交需要三方对比。
+
+```shell
+$ git rebase
+```
+
+#### 8、创建远程分支
+
+1) 新建本地分支
+
+```shell
+git checkout -b dev
+```
+
+2) 将本地分支推送到远程
+
+```shell
+git push origin dev:dev
+```
+
+前一个dev是本地分支的名称，后一个dev是远程分支的名称
+
+#### 9、删除远程分支
+
+方式一： 直接推送一个空分支到远程分支，相当于删除远程分支
+
+```shell
+git push origin :dev
+```
+
+方式二：指定`--delete`参数
+
+```shell
+git push origin --delete dev
+```
+
+
+
+### 五、标签管理
+
+发布一个版本时，我们通常先在版本库中打一个标签（tag），这样，就唯一确定了打标签时刻的版本。将来无论什么时候，取某个标签的版本，就是把那个打标签的时刻的历史版本取出来。所以，标签也是版本库的一个快照。
+
+Git的标签虽然是版本库的快照，但其实它就是指向某个commit的指针（跟分支很像对不对？但是分支可以移动，标签不能移动），所以，创建和删除标签都是瞬间完成的。
+
+tag就是一个让人容易记住的有意义的名字，它跟某个commit绑在一起。
+
+#### 1、创建标签
+
+- 命令`git tag <tagname>`用于新建一个标签，默认为`HEAD`，也可以指定一个commit id；
+- 命令`git tag -a <tagname> -m "blablabla..."`可以指定标签信息；
+- 命令`git tag`可以查看所有标签。
+
+#### 2、操作标签
+
+- 命令`git push origin <tagname>`可以推送一个本地标签；
+- 命令`git push origin --tags`可以推送全部未推送过的本地标签；
+- 命令`git tag -d <tagname>`可以删除一个本地标签；
+- 命令`git push origin :refs/tags/<tagname>`可以删除一个远程标签。
+
+
+
+### 六、自定义git
+
+* 配置邮箱：`git config --global user.email <mail>`
+* 配置用户名：`git config --global user.name <name>`
+* 配置控制台颜色：`git config --global color.ui true`
+
+#### 1、忽略特殊文件
+
+- 忽略某些文件时，需要编写`.gitignore`；
+- `.gitignore`文件本身要放到版本库里，并且可以对`.gitignore`做版本管理！
+- `git add -f <file>` 强制添加文件
+- `git check-ignore -v <file>` 检查配置文件错误，git会提示配置文件中的那条规则把指定文件排除了。
+
+#### 2、配置别名
+
+`git config --global alias.别名 命令`可以为命令配置别名。
+
+`--global`参数是全局参数，也就是这些命令在这台电脑的所有Git仓库下都有用。
+
+#### 3、配置文件
+
+配置Git的时候，加上`--global`是针对当前用户起作用的，如果不加，那只针对当前的仓库起作用。
+
+配置文件放哪了？每个仓库的Git配置文件都放在`.git/config`文件中：
+
+```
+$ cat .git/config 
+[core]
+    repositoryformatversion = 0
+    filemode = true
+    bare = false
+    logallrefupdates = true
+    ignorecase = true
+    precomposeunicode = true
+[remote "origin"]
+    url = git@github.com:michaelliao/learngit.git
+    fetch = +refs/heads/*:refs/remotes/origin/*
+[branch "master"]
+    remote = origin
+    merge = refs/heads/master
+[alias]
+    last = log -1
+```
+
+别名就在`[alias]`后面，要删除别名，直接把对应的行删掉即可。
+
+而当前用户的Git配置文件放在用户主目录下的一个隐藏文件`.gitconfig`中：
+
+```
+$ cat .gitconfig
+[alias]
+    co = checkout
+    ci = commit
+    br = branch
+    st = status
+[user]
+    name = Your Name
+    email = your@email.com
+```
+
+配置别名也可以直接修改这个文件，如果改错了，可以删掉文件重新通过命令配置。
+
+
+
+### 七、命令总结
+
+| 命令                                                       | 解释                                                         |
+| ---------------------------------------------------------- | ------------------------------------------------------------ |
+| `git init`                                                 | 初始化仓库                                                   |
+| `git add <file>`                                           | 添加文件到临时区                                             |
+| `git add -f <file>`                                        | 强制添加文件到临时区                                         |
+| `git commit -m <msg>`                                      | 提交文件到分支                                               |
+| `git reset --hard commit_id`                               | 恢复文件到指定版本                                           |
+| `git log --graph --pretty=oneline --abbrev-commit`         | 单行显示提交历史信息                                         |
+| `git reflog`                                               | 查看命令历史                                                 |
+| `git status`                                               | 查看工作区状态                                               |
+| `git rm <file>`                                            | 删除指定文件                                                 |
+| `git branch`                                               | 查看所有分支                                                 |
+| `git branch <name>`                                        | 创建分支                                                     |
+| `git checkout <name>`                                      | 切换分支                                                     |
+| `git checkout -b <name>`                                   | 创建 + 切换分支                                              |
+| `git merge <name>`                                         | 合并分支                                                     |
+| `git merge --no-ff -m <msg>`                               | 禁用快速合并并添加标签，分支历史看以看到分支信息             |
+| `git branch -d <name>`                                     | 删除分支                                                     |
+| `git branch -D <name>`                                     | 强制删除分支                                                 |
+| `git stash`                                                | 保存工作现场并隐藏                                           |
+| `git stash list`                                           | 查看隐藏的工作现场                                           |
+| `git stash apply`                                          | 恢复工作现场，stash内容不删除                                |
+| `git stash apply <stash@{0}>`                              | 恢复到指定的工作现场，stash内容不删除                        |
+| `git stash drop`                                           | 删除工作现场                                                 |
+| `git stash pop`                                            | 恢复工作现场，并删除stash内容                                |
+| `git stash pop <stash@{0}>`                                | 恢复到指定的工作现场，并删除stash内容                        |
+| `git remote -v`                                            | 查看远程库信息                                               |
+| `git push origin master`                                   | 将master分支推送到远程库                                     |
+| `git clone <path>`                                         | 从远程库克隆信息                                             |
+| `git pull <remote> <branch>`                               | 抓取远程的新提交                                             |
+| `git checkout -b branch-name origin/branch-name`           | 在本地床架和远程分支对应的分支，本地和远程分支的名称最好保持一致 |
+| `git branch --set-upstream branch-name origin/branch-name` | 建立本地分支和远程分支的关联                                 |
+| `git rebase`                                               | 合并分支提交线                                               |
+| `git tab <tagname> -m <msg> <commit-id>`                   | 新建标签，默认为 HEAD，也可以指定一个 commit-id              |
+| `git tag`                                                  | 查看所有标签                                                 |
+| `git show <tagname>`                                       | 查看标签信息                                                 |
+| `git tag -d <tagname>`                                     | 删除标签                                                     |
+| `git push origin <tagname>`                                | 推送标签到远程                                               |
+| `git push origin --tags`                                   | 一次性推送所有未推送的标签到远程                             |
+| `git push origin :refs/tags/<tagname>`                     | 删除远程标签，需要先删除本地标签                             |
+| `git config --global user.email <mail>`                    | 配置全局邮箱                                                 |
+| `git config --global user.name <name>`                     | 配置全局用户名                                               |
+| `git config --global color.ui true`                        | 显示控制台颜色                                               |
+| `git config alias.<aliasname> <commend>`                   | 为commend配置别名为aliasname，复合命令要使用单引号包裹       |
+| `git check-ignore -v <file>`                               | 检查配置文件错误                                             |
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/git/\344\277\256\346\224\271\346\226\207\344\273\266\345\220\215\345\244\247\345\260\217\345\206\231.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/git/\344\277\256\346\224\271\346\226\207\344\273\266\345\220\215\345\244\247\345\260\217\345\206\231.md"
new file mode 100644
index 0000000..9454e82
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/git/\344\277\256\346\224\271\346\226\207\344\273\266\345\220\215\345\244\247\345\260\217\345\206\231.md"
@@ -0,0 +1,34 @@
+### 问题
+
+当我们手动修改文件夹名称的大小写时，github上出现了两份文件，一份大写命名，一份小写命名。
+
+后来不如怎么`git add`、`git commit`都无法改变上面的情况。
+
+
+
+#### 原因
+
+* git 本身是对大小写不敏感的
+* mac和windows默认也是对文件名不区分大小写的
+
+所以，默认情况下如果你本地把文件夹小写修改为大写然后提交，会导致github上存在一份大写和一份小写的文件夹。
+
+
+
+### 如何正确的修改文件名大小写？
+
+修改文件名的操作在`git`中类似于`unix`操作系统的文件操作。
+
+`git`使用`git mv`命令用来重命名文件：
+
+`git mv old_filename new_filename`
+
+
+
+#### 处理已存在错误操作的情况
+
+如果修改名字时没有使用`git mv`命令，并且该文件也被`git push`到远程仓库了。那么就需要做下面几件事：
+
+1. 在github删除错误的分支
+2. 本地执行`git rm -r --cached .` （注意有个点）
+3. 然后重新`git add`、`git commit`、`git push`就可以了。
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/git/\345\217\252\346\213\211\345\217\226\346\234\200\346\226\260\347\211\210\346\234\254\347\232\204\344\273\243\347\240\201.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/git/\345\217\252\346\213\211\345\217\226\346\234\200\346\226\260\347\211\210\346\234\254\347\232\204\344\273\243\347\240\201.md"
new file mode 100644
index 0000000..a1e96fa
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/git/\345\217\252\346\213\211\345\217\226\346\234\200\346\226\260\347\211\210\346\234\254\347\232\204\344\273\243\347\240\201.md"
@@ -0,0 +1,22 @@
+## 原因
+
+项目内容过大，且提交次数太多时，如果整个进行`git clone`下载时间会很长
+
+## 解决方案
+
+**仅拉取最新的版本**
+
+> git clone --depth=1  url
+
+--depth可用于指定拉取最近的几次提交
+
+**存在的问题**
+
+**--depth** 拉取的只是默认分支，如果拉取其他分支可以使用如下命令：
+
+```shell
+$ git remote set-branches origin 'remote_branch_name'
+$ git fetch --depth 1 origin remote_branch_name
+$ git checkout remote_branch_name
+```
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/git/\346\270\205\347\251\272\346\217\220\344\272\244\350\256\260\345\275\225.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/git/\346\270\205\347\251\272\346\217\220\344\272\244\350\256\260\345\275\225.md"
new file mode 100644
index 0000000..4660218
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/git/\346\270\205\347\251\272\346\217\220\344\272\244\350\256\260\345\275\225.md"
@@ -0,0 +1,39 @@
+## 清空仓库中所有的提交记录
+
+1.切换到新的分支
+
+```undefined
+   git checkout --orphan latest_branch
+```
+
+1. 缓存所有文件（除了.gitignore中声名排除的）
+
+```csharp
+   git add -A
+```
+
+1. 提交跟踪过的文件（Commit the changes）
+
+```bash
+   git commit -am "commit message"
+```
+
+1. 删除master分支（Delete the branch）
+
+```undefined
+   git branch -D master
+```
+
+5.重命名当前分支为master（Rename the current branch to master）
+
+```undefined
+   git branch -m master
+```
+
+6.提交到远程master分支 （Finally, force update your repository）
+
+```undefined
+   git push -f origin master
+```
+
+来源: [git仓库删除所有提交历史记录，成为一个干净的新仓库](https://www.jianshu.com/p/0b986acd0064)
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\215\225\344\270\252\346\226\207\344\273\266\350\266\205\351\231\220\345\210\266.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\215\225\344\270\252\346\226\207\344\273\266\350\266\205\351\231\220\345\210\266.md"
new file mode 100644
index 0000000..b9b4b6c
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\215\225\344\270\252\346\226\207\344\273\266\350\266\205\351\231\220\345\210\266.md"
@@ -0,0 +1,15 @@
+#### 问题描述
+
+idea中单个`.java`文件过大，导致该文件无法被正常编译
+
+#### 问题原因
+
+由于使用了`protobuf`作为客户端与服务端的协议传输，单个`.proto`文件中定义了过多的消息协议，导致通过`protobuf.exe`编译后的文件超出了idea默认的文件大小限制，idea默认的文件大小限制为`2.5M`。
+
+#### 解决方案
+
+1. 点击工具栏`Help`按钮
+2.  `Help`按钮弹出框选择`Edit custom properties`
+3.  如果第一次修改idea的自定义属性，则会提示创建`idea.properties`文件，点击`create`即可 
+4. 在`idea.properties`文件中添加 `idea.max.intellisense.filesize=5000`
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\256\211\350\243\205eclipse\346\240\274\345\274\217\345\214\226\346\217\222\344\273\266.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\256\211\350\243\205eclipse\346\240\274\345\274\217\345\214\226\346\217\222\344\273\266.md"
new file mode 100644
index 0000000..1b239ad
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\256\211\350\243\205eclipse\346\240\274\345\274\217\345\214\226\346\217\222\344\273\266.md"
@@ -0,0 +1,23 @@
+### 前言
+
+在团队开发中，为了避免冲突，我们一般会采用统一的代码格式化工具，也会编写自己的`code-style`文件。如果团队中主力使用的是`eclipse`，并且`code-style`文件只有`eclipse`仅可使用的，那对于我们喜欢用`idea`的程序员来说，这种限制简直是灾难性的，试想一下，如果我们的代码格式化方式和同时的代码格式化方式不一样，那么当我们同事操作一个文件的时候，并且同时进行代码格式化与代码提交，那么提交后的代码冲突数量可想而知。为了解决这种问题，并兼容同事们使用`eclipse`编写的代码，我们就需要在`idea`中使用`eclipse`的`code-style`文件
+
+### 插件介绍
+
+`Eclipse Code Formate`插件是一个可以是用户在`idea`中使用`eclipse`的`code-style`文件的工具。
+
+### 安装
+
+通过`idea`的插件仓库搜索`Eclipse Code Formate`进行安装，安装完成后重启`idea`
+
+### 配置
+
+1. 选择`settings`-`Other Settings`选择`Eclipse Code Formate`
+2. 启用`Use the Eclipse formatter`
+3. `Eclipse Java Formatter config file`配置为`eclipse`的`code-style`文件在本地的路径
+4. `Import order`启动`From file`，并配置为`code-style`文件的本地路径
+
+### 使用及建议
+
+* 使用`Ctrl`+`Alt`+`L`格式化代码后，`Event Log`会出现`*.java formatted successfully by Eclipse code formatter`，说明插件设置成功。
+* 尽量格式化资源的代码，不要全局格式化。
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\277\253\346\215\267\351\224\256.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\277\253\346\215\267\351\224\256.md"
new file mode 100644
index 0000000..3b247c3
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\345\277\253\346\215\267\351\224\256.md"
@@ -0,0 +1,245 @@
+### 基础
+
+| 快捷键       | 操作结果                                                     |
+| ------------ | ------------------------------------------------------------ |
+| F2           | 跳转到下一个高亮错误或警告位置                               |
+| F3           | 在查找模式下,定位到下一个匹配处                              |
+| F4           | 编辑源                                                       |
+| F7           | 在Debug模式下,进入下一步,如果当前行断点是一个方法,则进入当前方法体内 |
+| F8           | 在Debug模式下,进入下一步,如果当前行断点是一个方法,则不进入当前方法体内 |
+| F9           | 在Debug模式下,恢复程序运行,但是如果该断点下面还有断点则停在下一个断点上 |
+| F11          | 添加书签                                                     |
+| F12          | 回到前一个工具窗口                                           |
+| Tab          | 缩进                                                         |
+| Esc          | 从工具窗口进入代码文件窗口                                   |
+| double shift | 弹出Search Everywhere弹出层                                  |
+
+### Ctrl 
+
+| 快捷键          | 操作结果                                                     |
+| --------------- | ------------------------------------------------------------ |
+| Ctrl+ F         | 在当前文件进行文本查找                                       |
+| Ctrl+ R         | 在当前文件进行文本替换                                       |
+| Ctrl+ Z         | 撤销                                                         |
+| Ctrl+ Y         | 删除光标所在行或删除选中的行                                 |
+| Ctrl+ X         | 剪切光标所在行或复制选择内容                                 |
+| Ctrl+ C         | 复制光标所在行或复制选择内容                                 |
+| Ctrl+ D         | 复制光标所在行或复制选择内容，并把复制内容插入光标位置下面   |
+| Ctrl+ W         | 递进式选择代码块。                                           |
+| Ctrl+ E         | 显示最近打开的文件记录列表                                   |
+| Ctrl+ N         | 根据输入的类名查找类文件                                     |
+| Ctrl+ G         | 在当前文件跳转到指定行数                                     |
+| Ctrl+ J         | 插入自定义动态代码模板                                       |
+| Ctrl+ P         | 方法参数提示显示                                             |
+| Ctrl+ Q         | 光标所在的变量/类名/方法名等上面，显示文档内容               |
+| Ctrl+ U         | 前往当前光标所在的方法的父类的方法/接口                      |
+| Ctrl+ B         | 进入光标所在的方法、变量的接口或是定义处，等效于Ctrl+左键单击 |
+| Ctrl+ K         | 版本控制提交项目，需要此项目有加入到版本控制才可用           |
+| Ctrl+ T         | 版本控制更新项目，需要此项目有加入到版本控制才可用           |
+| Ctrl+ H         | 显示当前类的层次结构                                         |
+| Ctrl+ O         | 选择可重写的方法                                             |
+| Ctrl+ I         | 选择可继承的方法                                             |
+| Ctrl+ +         | 展开代码                                                     |
+| Ctrl+ -         | 折叠代码                                                     |
+| Ctrl+ /         | 注释光标所在行代码                                           |
+| Ctrl+ [         | 移动光标到当前所在代码的花括号结束位置                       |
+| Ctrl+ ]         | 移动光标到当前所在代码的花括号结束位置                       |
+| Ctrl+ F1        | 在光标所在的错误代码处显示错误信息                           |
+| Ctrl+ F3        | 跳转到所选中词的下一个引用位置                               |
+| Ctrl+ F4        | 关闭当前编辑文件                                             |
+| Ctrl+ F8        | 在Debug模式下，设置光标当前行为断点，如果当前已经是断点则去掉断点 |
+| Ctrl+ F9        | 执行Make Project操作                                         |
+| Ctrl+ F12       | 弹出当前文件结构层，可以在弹出的层上面直接输入，进行筛选     |
+| Ctrl+ Tab       | 编辑窗口切换，如果在切换的过程中又加上delete，则是关闭对应选中的窗口 |
+| Ctrl+ End       | 调到文件尾                                                   |
+| Ctrl+ Home      | 调到文件头                                                   |
+| Ctrl+ Sapce     | 基础代码补全                                                 |
+| Ctrl+ delete    | 删除光标后面的单词或是中文句                                 |
+| Ctrl+ BackSpace | 删除光标前面的单词或是中文句                                 |
+
+### Alt
+
+| 快捷键       | 操作结果                                                     |
+| ------------ | ------------------------------------------------------------ |
+| Alt+ F7      | 查找指定对象的调用位置                                       |
+| Alt+ F8      | 在Debug的状态下，选中对象，弹出可输入计算表达式调试框，查看该输入内容的调试结果 |
+| Alt+ Home    | 定位/显示到当前文件的Navigation Bar                          |
+| Alt+ Enter   | 代码快速修复，不同代码提供不同的修复方案                     |
+| Alt+ Insert  | 代码自动生成，如生成对象的set/get方法，构造函数，toString()等 |
+| Alt+ ←\|→    | 移动到相邻的TAB                                              |
+| Alt+ ↑\|↓    | 在当前类的方法间移动                                         |
+| Alt+ 1,2,3.. | 打开或关闭当前的选项卡(一般显示在左右边缘)                   |
+
+### Shift
+
+| 快捷键              | 操作结果                                                     |
+| ------------------- | ------------------------------------------------------------ |
+| Shift+ F2           | 跳转到上一个高亮错误或警告位置                               |
+| Shift+ F3           | 在查找模式下，查找匹配上一个                                 |
+| Shift+ F4           | 在当前打开的文件，使用新Windows窗口打开，旧窗口保留          |
+| Shift+ F6           | 对文件、文件夹重命名                                         |
+| Shift+ F7           | 在Debug模式下，智能步入，断点所在行上有多个方法调用，会弹出进入哪个方法 |
+| Shift+ F8           | 在Debug模式下，跳出，表现出来的效果跟F9一样                  |
+| Shift+ F9           | 等效于点击工具栏的Debug按钮                                  |
+| Shift+ F10          | 等效于点击工具栏的Run按钮                                    |
+| Shift+ Tab          | 取消缩进                                                     |
+| Shift+ ESC          | 隐藏当前或最后一个激活的工具窗口                             |
+| Shift+ End          | 选中光标到当前行尾位置                                       |
+| Shift+ Home         | 选中光标到当前行头位置                                       |
+| Shift+ Enter        | 开始新一行，光标所在行下空一行，光标定位到新行位置           |
+| Shift+ 左键单击     | 在打开的文件名上按此快捷键，可以关闭当前打开文件             |
+| Shift+ 滚轮前后滚动 | 当前文件的横向滚动轴滚动                                     |
+
+### Ctrl + Alt
+
+| 快捷键             | 操作结果                                                     |
+| ------------------ | ------------------------------------------------------------ |
+| Ctrl+Alt+ L        | 格式化代码，可以对当前文件和整个包目录使用                   |
+| Ctrl+Alt+ O        | 优化导入的类,可以对当前文件和整个包目录使用                  |
+| Ctrl+Alt+ I        | 光标所在行或选中部分进行自动代码缩进,有点类似格式化          |
+| Ctrl+Alt+ J        | 弹出模版选择窗口,将选定的代码加入动态模版中                  |
+| Ctrl+Alt+ H        | 调出层次                                                     |
+| Ctrl+Alt+ B        | 在某个调用的方法名上使用会跳到具体的实现处,可以跳过接口      |
+| Ctrl+Alt+ C        | 重构-快速提取常量                                            |
+| Ctrl+Alt+ F        | 重构-快速提取成员变量                                        |
+| Ctrl+Alt+ V        | 重构-快速变量                                                |
+| Ctrl+Alt+ Y        | 同步,刷新                                                    |
+| Ctrl+Alt+ S        | 打开Intellij IDEA系统设置                                    |
+| Ctrl+Alt+ F7       | 显示使用的地方,寻找被该类或是变量被调用的地方,用弹出框的方式找出来 |
+| Ctrl+Alt+ F11      | 切换全屏模式                                                 |
+| Ctrl+Alt+ Enter    | 光标所在行上空出一行,光标定位到新行                          |
+| Ctrl+Alt+ Home     | 弹出跟当前文件有关联的文件弹出层                             |
+| Ctrl+Alt+ Space    | 类名自动换行                                                 |
+| Ctrl+Alt+ 左方向键 | 退回到上一个操作的地方                                       |
+| Ctrl+Alt+ 右方向键 | 前进到上一个操作的地方                                       |
+| Ctrl+Alt+ 前方向键 | 在查找模板下,跳到上一个查找的文件                            |
+| Ctrl+Alt+ 后方向键 | 在查找模板下,跳到下一个查找的文件                            |
+| Ctrl+Alt+ ]        | 在打开多个项目的情况下,切换下一个项目窗口                    |
+| Ctrl+Alt+ [        | 在打开多个项目的情况下,切换上一个项目窗口                    |
+
+### Ctrl + Shift
+
+| 快捷键                | 操作结果                                                     |
+| --------------------- | ------------------------------------------------------------ |
+| Ctrl+Shift+ F         | 根据输入内容查找整个项目或指定目录内文件                     |
+| Ctrl+Shift+ R         | 输入内容替换对应内容,范围为整个项目或指定目录内文件          |
+| Ctrl+Shift+ J         | 自动将下一行合并到当前行末尾                                 |
+| Ctrl+Shift+ Z         | 取消撤销                                                     |
+| Ctrl+Shift+ W         | 递进式取消选择代码块                                         |
+| Ctrl+Shift+ N         | 通过文件名定位/打开文件/目录，打开目录需要在输入的内容后面多加一个正斜杠 |
+| Ctrl+Shift+ U         | 对选中的代码进行大/小写轮流转换                              |
+| Ctrl+Shift+ T         | 对当前类生成单元测试类，如果已经存在的单元测试类则可以进行选择 |
+| Ctrl+Shift+ C         | 复制当前文件磁盘路径到剪贴板                                 |
+| Ctrl+Shift+ V         | 弹出缓存的最近拷贝的内容管理器弹出层                         |
+| Ctrl+Shift+ E         | 显示最近修改的文件列表的弹出层                               |
+| Ctrl+Shift+ H         | 显示方法层次结构                                             |
+| Ctrl+Shift+ B         | 跳转到类声明处                                               |
+| Ctrl+Shift+ I         | 快速查看光标所在的方法或类的定义                             |
+| Ctrl+Shift+ A         | 查找动作/设置                                                |
+| Ctrl+Shift+ /         | 代码块注释                                                   |
+| Ctrl+Shift+ F7        | 高亮显示所有该选中文本,按Esc高亮消失                         |
+| Ctrl+Shift+ F8        | 在Debug模式下，指定断点进入条件                              |
+| Ctrl+Shift+ F9        | 编译选中的文件/包/Module                                     |
+| Ctrl+Shift+ Space     | 智能代码提示                                                 |
+| Ctrl+Shift+ Enter     | 自动结束代码，行末自动添加分号                               |
+| Ctrl+Shift+ Backspace | 退回到上次修改的地方                                         |
+
+### Ctrl + Shift + Alt
+
+| 快捷键            | 操作结果   |
+| ----------------- | ---------- |
+| Ctrl+Shift+Alt+ V | 无格式黏贴 |
+
+---
+
+---
+
+---
+
+---
+
+---
+
+### 编写代码相关快捷键
+| 快捷键            | 操作结果                                                     |
+| ----------------- | ------------------------------------------------------------ |
+| Tab               | 缩进                                                         |
+| Ctrl+ Y           | 删除光标所在行或删除选中的行                                 |
+| Ctrl+ D           | 复制光标所在行或复制选择内容，并把复制内容插入光标位置下面   |
+| Ctrl+ W           | 递进式选择代码块。                                           |
+| Ctrl+ E           | 显示最近打开的文件记录列表                                   |
+| Ctrl+ P           | 方法参数提示显示                                             |
+| Ctrl+ O           | 选择可重写的方法                                             |
+| Ctrl+ I           | 选择可继承的方法                                             |
+| Ctrl+ F1          | 在光标所在的错误代码处显示错误信息                           |
+| Ctrl+ F4          | 关闭当前编辑文件                                             |
+| Ctrl+ Sapce       | 基础代码补全                                                 |
+| Alt+ Enter        | 代码快速修复，不同代码提供不同的修复方案                     |
+| Alt+ Insert       | 代码自动生成，如生成对象的set/get方法，构造函数，toString()等 |
+| Shift+ F2         | 跳转到上一个高亮错误或警告位置                               |
+| Shift+ F6         | 对文件、文件夹重命名                                         |
+| Shift+ Tab        | 取消缩进                                                     |
+| Shift+ Enter      | 开始新一行，光标所在行下空一行，光标定位到新行位置           |
+| Ctrl+Alt+ L       | 格式化代码，可以对当前文件和整个包目录使用                   |
+| Ctrl+Alt+ O       | 优化导入的类,可以对当前文件和整个包目录使用                  |
+| Ctrl+Shift+ U     | 对选中的代码进行大/小写轮流转换                              |
+| Ctrl+Shift+ /     | 代码块注释                                                   |
+| Ctrl+Shift+ Space | 智能代码提示                                                 |
+
+### 阅读代码相关快捷键
+
+| 快捷键        | 操作结果                                                     |
+| ------------- | ------------------------------------------------------------ |
+| double shift  | 弹出Search Everywhere弹出层                                  |
+| Ctrl+ N       | 根据输入的类名查找类文件                                     |
+| Ctrl+ G       | 在当前文件跳转到指定行数                                     |
+| Ctrl+ Q       | 光标所在的变量/类名/方法名等上面，显示文档内容               |
+| Ctrl+ U       | 前往当前光标所在的方法的父类的方法/接口                      |
+| Ctrl+ B       | 进入光标所在的方法、变量的接口或是定义处，等效于Ctrl+左键单击 |
+| Ctrl+ H       | 显示当前类的层次结构                                         |
+| Ctrl+ +       | 展开代码                                                     |
+| Ctrl+ -       | 折叠代码                                                     |
+| Ctrl+ F3      | 跳转到所选中词的下一个引用位置                               |
+| Ctrl+ F12     | 弹出当前文件结构层，可以在弹出的层上面直接输入，进行筛选     |
+| Alt+ ←\|→     | 移动到相邻的TAB                                              |
+| Alt+ ↑\|↓     | 在当前类的方法间移动                                         |
+| Shift+ F4     | 在当前打开的文件，使用新Windows窗口打开，旧窗口保留          |
+| Ctrl+Alt+ H   | 调出层次                                                     |
+| Ctrl+Alt+ B   | 在某个调用的方法名上使用会跳到具体的实现处,可以跳过接口      |
+| Ctrl+Shift+ H | 显示方法层次结构                                             |
+| Ctrl+Shift+ B | 跳转到类声明处                                               |
+| Ctrl+Shift+ I | 快速查看光标所在的方法或类的定义                             |
+
+### 重构代码相关快捷键
+| 快捷键      | 操作结果              |
+| ----------- | --------------------- |
+| Ctrl+Alt+ C | 重构-快速提取常量     |
+| Ctrl+Alt+ F | 重构-快速提取成员变量 |
+| Ctrl+Alt+ V | 重构-快速变量         |
+
+### debug相关快捷键
+| 快捷键         | 操作结果                                                     |
+| -------------- | ------------------------------------------------------------ |
+| F7             | 在Debug模式下,进入下一步,如果当前行断点是一个方法,则进入当前方法体内 |
+| F8             | 在Debug模式下,进入下一步,如果当前行断点是一个方法,则不进入当前方法体内 |
+| F9             | 在Debug模式下,恢复程序运行,但是如果该断点下面还有断点则停在下一个断点上 |
+| Ctrl+ F8       | 在Debug模式下，设置光标当前行为断点，如果当前已经是断点则去掉断点 |
+| Alt+ F8        | 在Debug的状态下，选中对象，弹出可输入计算表达式调试框，查看该输入内容的调试结果 |
+| Shift+ F7      | 在Debug模式下，智能步入，断点所在行上有多个方法调用，会弹出进入哪个方法 |
+| Shift+ F8      | 在Debug模式下，跳出，表现出来的效果跟F9一样                  |
+| Ctrl+Shift+ F8 | 在Debug模式下，指定断点进入条件                              |
+
+### 编译及运行相关快捷键
+| 快捷键         | 操作结果                    |
+| -------------- | --------------------------- |
+| Ctrl+ F9       | 执行Make Project操作        |
+| Shift+ F9      | 等效于点击工具栏的Debug按钮 |
+| Shift+ F10     | 等效于点击工具栏的Run按钮   |
+| Ctrl+Alt+ Y    | 同步,刷新                   |
+| Ctrl+Shift+ F9 | 编译选中的文件/包/Module    |
+
+### 版本控制相关快捷键
+| 快捷键  | 操作结果                                           |
+| ------- | -------------------------------------------------- |
+| Ctrl+ K | 版本控制提交项目，需要此项目有加入到版本控制才可用 |
+| Ctrl+ T | 版本控制更新项目，需要此项目有加入到版本控制才可用 |
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\346\217\220\345\215\207\350\277\220\350\241\214\345\217\212\347\274\226\350\257\221\351\200\237\345\272\246.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\346\217\220\345\215\207\350\277\220\350\241\214\345\217\212\347\274\226\350\257\221\351\200\237\345\272\246.md"
new file mode 100644
index 0000000..7107aab
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\346\217\220\345\215\207\350\277\220\350\241\214\345\217\212\347\274\226\350\257\221\351\200\237\345\272\246.md"
@@ -0,0 +1,55 @@
+## 提升idea运行速度
+
+`Help -> Edit Custom VM Option..`
+
+将默认值修改为如下配置：
+
+ ```properties
+-Xms1024m
+-Xmx4096m
+-server
+-XX:+UseParNewGC
+-XX:ReservedCodeCacheSize=1024m
+-XX:+UseConcMarkSweepGC
+-XX:SoftRefLRUPolicyMSPerMB=50
+-XX:MetaspaceSize=2048m
+-ea
+-Dsun.io.useCanonCaches=false
+-Djava.net.preferIPv4Stack=true
+-Djdk.http.auth.tunneling.disabledSchemes=""
+-XX:+HeapDumpOnOutOfMemoryError
+-XX:-OmitStackTraceInFastThrow
+ ```
+
+**参数解释：**
+
+**-Xms1024** 设置堆的初始内存
+
+**-Xmx** 设置堆的最大内存
+
+**-server** 设置控制GC的方式为服务器方式
+
+**-XX:+UseParNewGC** 使用并行收集算法
+
+**-XX:ReservedCodeCacheSize** 设置代码内存容量
+
+**-XX:MetaspaceSize** 设置永久代内存容量
+
+
+
+## 提升编译速度
+
+### 增加javac内存
+
+`File -> Settings -> Buld,Execution,Deployment -> Compiler`
+
+1. 勾选**Compile independent modules in parallel**
+2. **Build process head size** 根据系统内存，设置适当的大小
+
+
+
+### 增加maven内存
+
+`File -> Settings -> Buld,Execution,Deployment -> Maven -> Importing`
+
+1. **VM options for importer** 根据系统内存设置适当的值，如：-Xmx2048m
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\346\255\243\345\210\231\346\233\277\346\215\242\346\226\207\346\234\254.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\346\255\243\345\210\231\346\233\277\346\215\242\346\226\207\346\234\254.md"
new file mode 100644
index 0000000..ae4cd8a
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\346\255\243\345\210\231\346\233\277\346\215\242\346\226\207\346\234\254.md"
@@ -0,0 +1,39 @@
+## 原因
+
+在代码中出现了过多的三元运算符，并且每个三元运算符做的事情都一样， 如：
+
+ ```java
+int result = a == null ? 0 : a;
+ ```
+
+为了更加简化代码我们提供了一个额外的方法用于替换以上这种三元表达式：
+
+```java
+/**
+ * 当期望值为null时返回默认值
+ */
+public static <T> T getOrDefault(T expectValue, T defaultValue) {
+    return expectValue == null? defaultValue : expectValue;
+}
+```
+
+那么我们在代码中只需要调用该方法即可替换三元表达式：
+
+```java
+int result = getOrDefault(a, 0);
+```
+
+但是如果我们在几千行代码中一处一处进行修改，无疑是在搬砖，这个时候我们就需要通过文本替换的方式将符合规则的代码替换为指定的格式。
+
+## 使用正则表达式替换
+
+1. **IDEA**中通过 `Ctrl + R` 打开文本替换窗口，并在该窗口中选中 `Regex`标签。
+2. 在待替换文本框中输入正则表达式，如`(\w*) == null \? 0 : \w*`
+3. 在替换后的文本框中输入替换后的文本，如`getOrDefault($1, 0)`
+4. 点击**Replace all**即可完成替换。
+
+## 正则表达式分组
+
+在**IDEA**中通过`$index`进行获取分组，每个分组使用的符合和正则表达式中一样，都是使用小括号()。
+
+如果要获取整个表达式匹配的内容可以使用`$0`，如果要获取第一个分组则需要使用`$1`，以此类推。
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\347\244\276\345\214\272\347\211\210\345\256\211\350\243\205tomcat.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\347\244\276\345\214\272\347\211\210\345\256\211\350\243\205tomcat.md"
new file mode 100644
index 0000000..3b7d985
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\347\244\276\345\214\272\347\211\210\345\256\211\350\243\205tomcat.md"
@@ -0,0 +1,70 @@
+## idea社区版安装tomcat
+
+idea社区版中默认不存在`tomcat`的插件，如果我们项目中需要使用`tomcat`作为`web服务器`的话，则需要我们手动进行安装插件。
+
+在社区版中安装`tomcat`插件的方式有两种，一种是使用`smart tomcat`插件，另一种是使用`maven`的`tomcat8-maven-plugin`插件。
+
+### smart tomcat 安装方式
+
+#### 安装插件
+
+1. 通过`settings`的`plugins`仓库搜索`smart tomcat`进行安装，安装完成后重启idea
+2. 选择`run`按钮旁边的下拉框，点击`Edit Configurations`
+3. 弹出的`run/debug configurations`配置框中点击左上角的`+`号按钮。选择`Smart Tomcat`
+
+#### smart tomcat 配置文件
+
+| 名称          | 解释                                        |
+| ------------- | ------------------------------------------- |
+| Name          | 当前启动服务运行时名称                      |
+| Tomcat Server | 通过后面的`...`按钮选择本地tomcat的安装路径 |
+| Deployment    | `webapp`在项目中的路径                      |
+| Context Path  | 部署项目的上下文路径                        |
+| Server Port   | 服务器端口                                  |
+| AJP port      | 保持默认                                    |
+| Tomcat Port   | 保持默认                                    |
+| VM options    | JVM运行参数                                 |
+| Env options   | tomcat 运行环境参数                         |
+
+#### 启动
+
+选择`run`按钮旁边下拉框中刚刚配置的`Name`,使用`run`或`debug`进行运行。
+
+### maven配置运行tomcat
+
+#### 配置`pom.xml`
+
+```xml
+<build> 
+    <finalName>appName</finalName> 
+    <plugins> 
+      <plugin> 
+        <groupId>org.apache.tomcat.maven</groupId> 
+        <artifactId>tomcat7-maven-plugin</artifactId> 
+        <version>2.1</version> 
+        <configuration> 
+          <port>9090</port> 
+          <path>/</path> 
+          <uriEncoding>UTF-8</uriEncoding> 
+          <server>tomcat7</server> 
+        </configuration> 
+      </plugin> 
+    </plugins> 
+ </build> 
+```
+
+#### 配置运行方式
+
+1. 选择`run`按钮旁边的下拉框，点击`Edit Configurations`
+2. 弹出的`run/debug configurations`配置框中点击左上角的`+`号按钮。选择`Maven`
+
+#### maven `Paramters` 配置
+
+| 名称              | 解释        |
+| ----------------- | ----------- |
+| Working directory | 项目根目录  |
+| Command line      | tomcat7:run |
+
+#### 启动
+
+选择`run`按钮旁边下拉框中刚刚配置的`Name`,使用`run`或`debug`进行运行。
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\347\274\226\350\257\221\351\241\271\347\233\256\346\227\266\345\206\205\345\255\230\346\272\242\345\207\272.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\347\274\226\350\257\221\351\241\271\347\233\256\346\227\266\345\206\205\345\255\230\346\272\242\345\207\272.md"
new file mode 100644
index 0000000..988c396
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\347\274\226\350\257\221\351\241\271\347\233\256\346\227\266\345\206\205\345\255\230\346\272\242\345\207\272.md"
@@ -0,0 +1,17 @@
+## IDEA在编译大项目时内存溢出
+
+在对一个类文件达到6000个的项目进行`build`的时候，出现了以下异常：
+
+```
+Error:java: OutOfMemoryError: insufficient memory
+```
+
+### 原因分析
+
+根据异常可以看出是`java`在申请内存的时候，并且javac已完全由java进行重写，那么肯定是javac在编译的时候申请的内存超出了`-Xmx`配置的内存太小，从而导致了编译器出现内存溢出的情况。
+
+### 解决方案
+
+知道了问题的原因，那么我们只需要将编译器最大可申请的内存增加就可以解决这个问题。
+
+修改`File | Settings | Build, Execution, Deployment | Compiler `页面的`Build process head size (Mbytes)`为适当的大小即可解决问题
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\350\207\252\345\212\250\345\257\274\345\205\245\345\206\205\351\203\250\347\261\273.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\350\207\252\345\212\250\345\257\274\345\205\245\345\206\205\351\203\250\347\261\273.md"
new file mode 100644
index 0000000..83cf5fd
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\350\207\252\345\212\250\345\257\274\345\205\245\345\206\205\351\203\250\347\261\273.md"
@@ -0,0 +1,35 @@
+## 自动引入内部类
+
+idea默认不会自动导入内部类，如下面的类:
+
+```java
+public class User {
+    public static class Sex {
+        
+    }
+}
+```
+
+如果使用默认的方式会形成下面的代码：
+
+```java
+import package.User;
+
+User.Sex sex = new User.Sex();
+```
+
+但是这种情况非常不方便，我们需要的是下面的代码:
+
+```java
+import package.User.Sex;
+
+Sex sex = new Sex();
+```
+
+**实现方式**
+
+打开设置对话框路径`File | Settings | Editor | Code Style | Java`，
+
+选择该设置框的`Imports`页签
+
+选中`Inser imports from inner classes`
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/editor.xml" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/editor.xml"
new file mode 100644
index 0000000..927d999
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/editor.xml"
@@ -0,0 +1,6 @@
+<application>
+  <component name="DefaultFont">
+    <option name="FONT_SIZE" value="16" />
+    <option name="FONT_FAMILY" value="Consolas" />
+  </component>
+</application>
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/idea.properties" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/idea.properties"
new file mode 100644
index 0000000..1f70135
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/idea.properties"
@@ -0,0 +1,3 @@
+# custom IntelliJ IDEA properties
+
+idea.max.intellisense.filesize=5000
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-inspections.xml" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-inspections.xml"
new file mode 100644
index 0000000..8ddbfe3
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-inspections.xml"
@@ -0,0 +1,144 @@
+<profile version="1.0">
+  <option name="myName" value="My Code Inspections" />
+  <inspection_tool class="CheckNodeTest" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="CheckTagEmptyBody" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="Convert2Diamond" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="DanglingJavadoc" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="DuplicateThrows" enabled="true" level="INFORMATION" enabled_by_default="true" />
+  <inspection_tool class="DuplicatedCode" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
+  <inspection_tool class="Duplicates" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
+  <inspection_tool class="ELDeferredExpressionsInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="ELMethodSignatureInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="ELSpecValidationInJSP" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="ELValidationInJSP" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="EjbClassBasicInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbClassWarningsInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="EjbDomInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbEntityClassInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbEntityHomeInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbEntityInterfaceInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbEnvironmentInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbInterceptorInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbInterceptorWarningsInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="EjbInterfaceMethodInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbInterfaceSignatureInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbProhibitedPackageUsageInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="EjbQlInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbRemoteRequirementsInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbSessionHomeInterfaceInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="EjbStaticAccessInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="EjbThisExpressionInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="HardwiredNamespacePrefix" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="IgnoreResultOfCall" enabled="false" level="WARNING" enabled_by_default="false">
+    <option name="m_reportAllNonLibraryCalls" value="false" />
+    <option name="callCheckString" value="java.io.File,.*,java.io.InputStream,read|skip|available|markSupported,java.io.Reader,read|skip|ready|markSupported,java.lang.Boolean,.*,java.lang.Byte,.*,java.lang.Character,.*,java.lang.Double,.*,java.lang.Float,.*,java.lang.Integer,.*,java.lang.Long,.*,java.lang.Math,.*,java.lang.Object,equals|hashCode|toString,java.lang.Short,.*,java.lang.StrictMath,.*,java.lang.String,.*,java.lang.Thread,interrupted,java.math.BigInteger,.*,java.math.BigDecimal,.*,java.net.InetAddress,.*,java.net.URI,.*,java.util.Arrays,.*,java.util.List,of,java.util.Set,of,java.util.Map,of|ofEntries|entry,java.util.Collections,(?!addAll).*,java.util.UUID,.*,java.util.regex.Matcher,pattern|toMatchResult|start|end|group|groupCount|matches|find|lookingAt|quoteReplacement|replaceAll|replaceFirst|regionStart|regionEnd|hasTransparentBounds|hasAnchoringBounds|hitEnd|requireEnd,java.util.regex.Pattern,.*,java.util.stream.BaseStream,.*" />
+  </inspection_tool>
+  <inspection_tool class="ImplicitTypeConversion" enabled="false" level="WARNING" enabled_by_default="false">
+    <option name="BITS" value="1720" />
+    <option name="FLAG_EXPLICIT_CONVERSION" value="true" />
+    <option name="IGNORE_NODESET_TO_BOOLEAN_VIA_STRING" value="true" />
+  </inspection_tool>
+  <inspection_tool class="IndexZeroUsage" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="Java8ListSort" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaDoc" enabled="false" level="WARNING" enabled_by_default="false">
+    <option name="TOP_LEVEL_CLASS_OPTIONS">
+      <value>
+        <option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
+        <option name="REQUIRED_TAGS" value="" />
+      </value>
+    </option>
+    <option name="INNER_CLASS_OPTIONS">
+      <value>
+        <option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
+        <option name="REQUIRED_TAGS" value="" />
+      </value>
+    </option>
+    <option name="METHOD_OPTIONS">
+      <value>
+        <option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
+        <option name="REQUIRED_TAGS" value="@return@param@throws or @exception" />
+      </value>
+    </option>
+    <option name="FIELD_OPTIONS">
+      <value>
+        <option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
+        <option name="REQUIRED_TAGS" value="" />
+      </value>
+    </option>
+    <option name="IGNORE_DEPRECATED" value="false" />
+    <option name="IGNORE_JAVADOC_PERIOD" value="true" />
+    <option name="IGNORE_DUPLICATED_THROWS" value="false" />
+    <option name="IGNORE_POINT_TO_ITSELF" value="false" />
+    <option name="myAdditionalJavadocTags" value="" />
+  </inspection_tool>
+  <inspection_tool class="JavaFxColorRgb" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaFxDefaultTag" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaFxEventHandler" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaFxRedundantPropertyValue" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaFxResourcePropertyValue" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaFxUnresolvedFxIdReference" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaFxUnresolvedStyleClassReference" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaFxUnusedImports" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JavaeeApplicationDomInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaAttributeMemberSignatureInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaAttributeTypeInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaConfigDomFacetInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JpaDataSourceORMDomInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaDataSourceORMInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaDomInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaEntityListenerInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaEntityListenerWarningsInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JpaMissingIdInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaModelReferenceInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaORMDomInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaObjectClassSignatureInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaQlInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JpaQueryApiInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JspAbsolutePathInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="JspDirectiveInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JspPropertiesInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="JspTagBodyContent" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="ManagedBeanClassInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="MimeType" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="RedundantThrows" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
+  <inspection_tool class="RedundantTypeConversion" enabled="false" level="WARNING" enabled_by_default="false">
+    <option name="CHECK_ANY" value="false" />
+  </inspection_tool>
+  <inspection_tool class="ReferencesToClassesFromDefaultPackagesInJSPFile" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="SelfIncludingJspFiles" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="ServletWithoutMappingInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="SpringJavaAutowiredFieldsWarningInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="SpringJavaInjectionPointsAutowiringInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="SpringXmlModelInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="SwitchStatementWithTooFewBranches" enabled="false" level="WARNING" enabled_by_default="false">
+    <option name="m_limit" value="2" />
+  </inspection_tool>
+  <inspection_tool class="TaglibDomModelInspection" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="TryFinallyCanBeTryWithResources" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="UnhandledExceptionInJSP" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="UnusedAssignment" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+    <option name="REPORT_PREFIX_EXPRESSIONS" value="false" />
+    <option name="REPORT_POSTFIX_EXPRESSIONS" value="true" />
+    <option name="REPORT_REDUNDANT_INITIALIZER" value="true" />
+  </inspection_tool>
+  <inspection_tool class="UnusedReturnValue" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="WeakerAccess" enabled="false" level="WARNING" enabled_by_default="false">
+    <option name="SUGGEST_PACKAGE_LOCAL_FOR_MEMBERS" value="true" />
+    <option name="SUGGEST_PACKAGE_LOCAL_FOR_TOP_CLASSES" value="true" />
+    <option name="SUGGEST_PRIVATE_FOR_INNERS" value="false" />
+  </inspection_tool>
+  <inspection_tool class="WebProperties" enabled="false" level="ERROR" enabled_by_default="false" />
+  <inspection_tool class="WebWarnings" enabled="false" level="WARNING" enabled_by_default="false" />
+  <inspection_tool class="unused" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+    <option name="LOCAL_VARIABLE" value="true" />
+    <option name="FIELD" value="true" />
+    <option name="METHOD" value="true" />
+    <option name="CLASS" value="true" />
+    <option name="PARAMETER" value="true" />
+    <option name="REPORT_PARAMETER_FOR_PUBLIC_METHODS" value="true" />
+    <option name="ADD_MAINS_TO_ENTRIES" value="true" />
+    <option name="ADD_APPLET_TO_ENTRIES" value="true" />
+    <option name="ADD_SERVLET_TO_ENTRIES" value="true" />
+    <option name="ADD_NONJAVA_TO_ENTRIES" value="true" />
+  </inspection_tool>
+</profile>
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-scheme.icls" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-scheme.icls"
new file mode 100644
index 0000000..69a3ee7
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-scheme.icls"
@@ -0,0 +1,2734 @@
+<scheme name="My Code Scheme" version="142" parent_scheme="Darcula">
+  <option name="FONT_SCALE" value="1.0" />
+  <metaInfo>
+    <property name="created">2019-12-13T17:40:27</property>
+    <property name="ide">idea</property>
+    <property name="ideVersion">2019.2.4.0.0</property>
+    <property name="modified">2019-12-13T17:40:45</property>
+    <property name="originalScheme">My Code Scheme</property>
+  </metaInfo>
+  <option name="LINE_SPACING" value="1.2" />
+  <font>
+    <option name="EDITOR_FONT_NAME" value="Consolas" />
+    <option name="EDITOR_FONT_SIZE" value="18" />
+  </font>
+  <font>
+    <option name="EDITOR_FONT_NAME" value="Monospaced" />
+    <option name="EDITOR_FONT_SIZE" value="18" />
+  </font>
+  <console-font>
+    <option name="EDITOR_FONT_NAME" value="Consolas" />
+    <option name="EDITOR_FONT_SIZE" value="18" />
+  </console-font>
+  <console-font>
+    <option name="EDITOR_FONT_NAME" value="Monospaced" />
+    <option name="EDITOR_FONT_SIZE" value="18" />
+  </console-font>
+  <colors>
+    <option name="ADDED_LINES_COLOR" value="8f9d6a" />
+    <option name="ANNOTATIONS_COLOR" value="fffbf7" />
+    <option name="DELETED_LINES_COLOR" value="cf6a4c" />
+    <option name="DIFF_SEPARATORS_BACKGROUND" value="1e2a30" />
+    <option name="DIFF_SEPARATORS_TOP_BORDER" value="1b262b" />
+    <option name="DOCUMENTATION_COLOR" value="46484a" />
+    <option name="FILESTATUS_ADDED" value="8f9d6a" />
+    <option name="FILESTATUS_COPIED" value="8f9d6a" />
+    <option name="FILESTATUS_DELETED" value="a7a7a7" />
+    <option name="FILESTATUS_HIJACKED" value="47bc9b" />
+    <option name="FILESTATUS_IDEA_FILESTATUS_DELETED_FROM_FILE_SYSTEM" value="808080" />
+    <option name="FILESTATUS_IDEA_FILESTATUS_IGNORED" value="ab7967" />
+    <option name="FILESTATUS_IDEA_SVN_FILESTATUS_EXTERNAL" value="8f9d6a" />
+    <option name="FILESTATUS_IGNORE.PROJECT_VIEW.IGNORED" value="ab7967" />
+    <option name="FILESTATUS_MERGED" value="9b859d" />
+    <option name="FILESTATUS_MODIFIED" value="f9ee98" />
+    <option name="FILESTATUS_NOT_CHANGED_IMMEDIATE" value="f9ee98" />
+    <option name="FILESTATUS_NOT_CHANGED_RECURSIVE" value="f9ee98" />
+    <option name="FILESTATUS_OBSOLETE" value="a7a7a7" />
+    <option name="FILESTATUS_SUPPRESSED" value="5f5a60" />
+    <option name="FILESTATUS_SWITCHED" value="9b859d" />
+    <option name="FILESTATUS_UNKNOWN" value="f77669" />
+    <option name="FILESTATUS_addedOutside" value="8f9d6a" />
+    <option name="FILESTATUS_modifiedOutside" value="cf6a4c" />
+    <option name="FOLDED_TEXT_BORDER_COLOR" value="" />
+    <option name="INFORMATION_HINT" value="4b4d4d" />
+    <option name="LINE_NUMBERS_COLOR" value="5c6066" />
+    <option name="LINE_NUMBER_ON_CARET_ROW_COLOR" value="afafb0" />
+    <option name="METHOD_SEPARATORS_COLOR" value="464b52" />
+    <option name="MODIFIED_LINES_COLOR" value="47bc9b" />
+    <option name="MT_IGNORE.PROJECT_VIEW.IGNORED" value="ab7967" />
+    <option name="MT_SUPPRESSED" value="eeffff" />
+    <option name="NOT_CHANGED" value="8b9eb5" />
+    <option name="QUESTION_HINT" value="376c89" />
+    <option name="SELECTION_BACKGROUND" value="444773" />
+    <option name="SOFT_WRAP_SIGN_COLOR" value="464b52" />
+    <option name="TOOLTIP" value="" />
+    <option name="VCS_ANNOTATIONS_COLOR_1" value="5f5a60" />
+    <option name="VCS_ANNOTATIONS_COLOR_2" value="2b2e39" />
+    <option name="VCS_ANNOTATIONS_COLOR_3" value="37474f" />
+    <option name="VCS_ANNOTATIONS_COLOR_4" value="39adb5" />
+    <option name="VCS_ANNOTATIONS_COLOR_5" value="cf6a4c" />
+    <option name="WHITESPACES_MODIFIED_LINES_COLOR" value="5f5a60" />
+  </colors>
+  <attributes>
+    <option name="ABSTRACT_CLASS_NAME_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="ANNOTATION_ATTRIBUTE_NAME_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+      </value>
+    </option>
+    <option name="ANNOTATION_NAME_ATTRIBUTES" baseAttributes="DEFAULT_METADATA" />
+    <option name="BACKGROUND">
+      <value>
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="BASH.EXTERNAL_COMMAND">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="BASH.HERE_DOC_END" baseAttributes="DEFAULT_KEYWORD" />
+    <option name="BASH.HERE_DOC_START" baseAttributes="DEFAULT_KEYWORD" />
+    <option name="BASH.SHEBANG" baseAttributes="BASH.LINE_COMMENT" />
+    <option name="BNF_KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="1a1f29" />
+      </value>
+    </option>
+    <option name="BNF_NUMBER">
+      <value>
+        <option name="FOREGROUND" value="f36e3a" />
+      </value>
+    </option>
+    <option name="BREAKPOINT_ATTRIBUTES">
+      <value>
+        <option name="BACKGROUND" value="4b1515" />
+      </value>
+    </option>
+    <option name="BROWSEWORDATCARET">
+      <value>
+        <option name="FOREGROUND" value="9688" />
+        <option name="EFFECT_COLOR" value="9688" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="CLASS_REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="1a1f29" />
+      </value>
+    </option>
+    <option name="CODE_VISION_DEFAULT">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+      </value>
+    </option>
+    <option name="CODE_VISION_HOVERED">
+      <value>
+        <option name="FOREGROUND" value="42a5f5" />
+      </value>
+    </option>
+    <option name="COFFEESCRIPT.BAD_CHARACTER">
+      <value>
+        <option name="EFFECT_COLOR" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="COFFEESCRIPT.CLASS_NAME">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="COFFEESCRIPT.GLOBAL_VARIABLE" baseAttributes="JS.GLOBAL_VARIABLE" />
+    <option name="COFFEESCRIPT.JAVASCRIPT_CONTENT">
+      <value />
+    </option>
+    <option name="COFFEESCRIPT.JAVASCRIPT_ID">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="COFFEESCRIPT.THIS">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="CONDITIONALLY_NOT_COMPILED">
+      <value>
+        <option name="FOREGROUND" value="536c46" />
+      </value>
+    </option>
+    <option name="CONSOLE_BLACK_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="CONSOLE_CYAN_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="33cccc" />
+      </value>
+    </option>
+    <option name="CONSOLE_ERROR_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="CONSOLE_GREEN_BRIGHT_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="70ff70" />
+      </value>
+    </option>
+    <option name="CONSOLE_GREEN_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="7f00" />
+      </value>
+    </option>
+    <option name="CONSOLE_MAGENTA_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="ff70ff" />
+      </value>
+    </option>
+    <option name="CONSOLE_OUTPUT">
+      <value>
+        <option name="BACKGROUND" value="252b39" />
+      </value>
+    </option>
+    <option name="CONSOLE_RANGE_TO_EXECUTE">
+      <value />
+    </option>
+    <option name="CONSOLE_USER_INPUT">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="CONSOLE_WHITE_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="CONSOLE_YELLOW_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="cdcd00" />
+      </value>
+    </option>
+    <option name="CONSTRUCTOR_CALL_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="CSS.COLOR">
+      <value>
+        <option name="FOREGROUND" value="ffea7d" />
+      </value>
+    </option>
+    <option name="CSS.FUNCTION">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="CSS.HASH">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="CSS.IDENT">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="CSS.IMPORTANT" baseAttributes="DEFAULT_KEYWORD" />
+    <option name="CSS.KEYWORD" baseAttributes="DEFAULT_KEYWORD" />
+    <option name="CSS.PROPERTY_NAME">
+      <value>
+        <option name="FOREGROUND" value="afc4db" />
+      </value>
+    </option>
+    <option name="CSS.PROPERTY_VALUE">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="CSS.PSEUDO">
+      <value>
+        <option name="FOREGROUND" value="a9b7c6" />
+      </value>
+    </option>
+    <option name="CSS.TAG_NAME">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="CSS.URL" baseAttributes="HTML_ATTRIBUTE_VALUE" />
+    <option name="CTRL_CLICKABLE">
+      <value>
+        <option name="FOREGROUND" value="5294e2" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="CUSTOM_KEYWORD1_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="CUSTOM_KEYWORD2_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="CUSTOM_KEYWORD3_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="CUSTOM_KEYWORD4_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="CUSTOM_STRING_ATTRIBUTES" baseAttributes="DEFAULT_STRING" />
+    <option name="CUSTOM_VALID_STRING_ESCAPE_ATTRIBUTES" baseAttributes="DEFAULT_VALID_STRING_ESCAPE" />
+    <option name="Class" baseAttributes="" />
+    <option name="DEFAULT_ATTRIBUTE">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="DEFAULT_BLOCK_COMMENT">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+      </value>
+    </option>
+    <option name="DEFAULT_CLASS_NAME">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="DEFAULT_CLASS_REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="DEFAULT_CONSTANT">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="DEFAULT_DOC_COMMENT">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+      </value>
+    </option>
+    <option name="DEFAULT_DOC_COMMENT_TAG">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="DEFAULT_DOC_COMMENT_TAG_VALUE">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="DEFAULT_DOC_MARKUP">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+      </value>
+    </option>
+    <option name="DEFAULT_ENTITY">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="DEFAULT_FUNCTION_CALL">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="DEFAULT_FUNCTION_DECLARATION">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="DEFAULT_GLOBAL_VARIABLE">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="DEFAULT_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="c3d3de" />
+      </value>
+    </option>
+    <option name="DEFAULT_INSTANCE_FIELD">
+      <value>
+        <option name="FOREGROUND" value="ba68cc" />
+      </value>
+    </option>
+    <option name="DEFAULT_INSTANCE_METHOD">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="DEFAULT_INTERFACE_NAME">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="DEFAULT_INVALID_STRING_ESCAPE">
+      <value>
+        <option name="EFFECT_COLOR" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="DEFAULT_KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="DEFAULT_LABEL">
+      <value>
+        <option name="FOREGROUND" value="c3d3de" />
+      </value>
+    </option>
+    <option name="DEFAULT_LINE_COMMENT">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+      </value>
+    </option>
+    <option name="DEFAULT_LOCAL_VARIABLE">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="DEFAULT_METADATA">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="DEFAULT_NUMBER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="DEFAULT_OPERATION_SIGN">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="DEFAULT_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="DEFAULT_PREDEFINED_SYMBOL">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="DEFAULT_REASSIGNED_LOCAL_VARIABLE">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="DEFAULT_REASSIGNED_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="DEFAULT_STATIC_FIELD">
+      <value>
+        <option name="FOREGROUND" value="ba68cc" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="DEFAULT_STATIC_METHOD">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="DEFAULT_STRING">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="DEFAULT_TAG">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="DEFAULT_TEMPLATE_LANGUAGE_COLOR">
+      <value>
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="DEFAULT_VALID_STRING_ESCAPE">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="DELETED_TEXT_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="EFFECT_COLOR" value="c14360" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="DEPRECATED_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="6d7177" />
+        <option name="EFFECT_COLOR" value="9b703f" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="DIFF_CONFLICT">
+      <value>
+        <option name="BACKGROUND" value="5e3d18" />
+        <option name="ERROR_STRIPE_COLOR" value="b03435" />
+      </value>
+    </option>
+    <option name="DIFF_DELETED">
+      <value>
+        <option name="BACKGROUND" value="623128" />
+        <option name="ERROR_STRIPE_COLOR" value="656e76" />
+      </value>
+    </option>
+    <option name="DIFF_INSERTED">
+      <value>
+        <option name="BACKGROUND" value="4e573b" />
+        <option name="ERROR_STRIPE_COLOR" value="447152" />
+      </value>
+    </option>
+    <option name="DIFF_MODIFIED">
+      <value>
+        <option name="BACKGROUND" value="4a3c4c" />
+        <option name="ERROR_STRIPE_COLOR" value="43698d" />
+      </value>
+    </option>
+    <option name="ELIXIR_BIT">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="ENUM_CONST">
+      <value>
+        <option name="FOREGROUND" value="9373a5" />
+      </value>
+    </option>
+    <option name="EXECUTIONPOINT_ATTRIBUTES">
+      <value>
+        <option name="BACKGROUND" value="2e4677" />
+      </value>
+    </option>
+    <option name="FOLDED_TEXT_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="a9b7c6" />
+        <option name="BACKGROUND" value="393f4c" />
+      </value>
+    </option>
+    <option name="FOLLOWED_HYPERLINK_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="GO_FUNCTION_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="GO_METHOD_RECEIVER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="HAML_CLASS">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="HAML_COMMENT" baseAttributes="DEFAULT_DOC_COMMENT" />
+    <option name="HAML_FILTER" baseAttributes="DEFAULT_LABEL" />
+    <option name="HAML_ID" baseAttributes="DEFAULT_INSTANCE_FIELD" />
+    <option name="HAML_RUBY_CODE" baseAttributes="INJECTED_LANGUAGE_FRAGMENT" />
+    <option name="HAML_RUBY_START" baseAttributes="DEFAULT_KEYWORD" />
+    <option name="HAML_TAG" baseAttributes="TEXT" />
+    <option name="HAML_TAG_NAME">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="HAML_TEXT" baseAttributes="TEXT" />
+    <option name="HAML_XHTML">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="HTML_ATTRIBUTE_NAME" baseAttributes="DEFAULT_ATTRIBUTE" />
+    <option name="HTML_ATTRIBUTE_VALUE" baseAttributes="DEFAULT_STRING" />
+    <option name="HTML_CODE">
+      <value />
+    </option>
+    <option name="HTML_ENTITY_REFERENCE" baseAttributes="DEFAULT_ENTITY" />
+    <option name="HTML_TAG">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="HTML_TAG_NAME">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="HTTP_HEADER_FIELD_VALUE">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="HTTP_REQUEST_INPUT_FILE">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="HTTP_REQUEST_PARAMETER_NAME">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="HTTP_REQUEST_PARAMETER_VALUE">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="HYPERLINK_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="EFFECT_COLOR" value="7587a6" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="IDENTIFIER_UNDER_CARET_ATTRIBUTES">
+      <value>
+        <option name="BACKGROUND" value="344134" />
+        <option name="ERROR_STRIPE_COLOR" value="38613" />
+      </value>
+    </option>
+    <option name="IGNORE.BRACKET">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="IGNORE.COMMENT">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+      </value>
+    </option>
+    <option name="IGNORE.HEADER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="IGNORE.NEGATION">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="IGNORE.SECTION">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="IGNORE.SLASH">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="IGNORE.SYNTAX">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="IGNORE.VALUE">
+      <value />
+    </option>
+    <option name="IMPLICIT_ANONYMOUS_CLASS_PARAMETER_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="INACTIVE_HYPERLINK_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="808080" />
+        <option name="EFFECT_COLOR" value="808080" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="INFO_ATTRIBUTES">
+      <value>
+        <option name="EFFECT_COLOR" value="aeae80" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="INJECTED_LANGUAGE_FRAGMENT">
+      <value />
+    </option>
+    <option name="INLINE_PARAMETER_HINT_CURRENT">
+      <value>
+        <option name="FOREGROUND" value="7b8a99" />
+        <option name="BACKGROUND" value="393f4c" />
+      </value>
+    </option>
+    <option name="IVAR">
+      <value>
+        <option name="FOREGROUND" value="9373a5" />
+      </value>
+    </option>
+    <option name="JAVA.MODIFIER">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="JAVA.THIS_SUPER">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="JAVA_BRACES">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JAVA_BRACKETS">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JAVA_COMMA">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JAVA_DOT">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JAVA_KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="JAVA_OPERATION_SIGN">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JAVA_PARENTH">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JAVA_SEMICOLON">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JAVA_VALID_STRING_ESCAPE">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JFLEX_MACROS_REF">
+      <value>
+        <option name="FOREGROUND" value="1a1f29" />
+      </value>
+    </option>
+    <option name="JS.CONSOLE">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+      </value>
+    </option>
+    <option name="JS.DEBUGGER_STMT">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="JS.GLOBAL_FUNCTION" baseAttributes="DEFAULT_FUNCTION_DECLARATION" />
+    <option name="JS.GLOBAL_VARIABLE" baseAttributes="DEFAULT_GLOBAL_VARIABLE" />
+    <option name="JS.INSTANCE_MEMBER_FUNCTION" baseAttributes="DEFAULT_INSTANCE_METHOD" />
+    <option name="JS.LOCAL_VARIABLE" baseAttributes="DEFAULT_LOCAL_VARIABLE" />
+    <option name="JS.MODULE_KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="JS.NULL_UNDEFINED">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="JS.REGEXP" baseAttributes="DEFAULT_STRING" />
+    <option name="JS.THIS_SUPER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="JSON.KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="JSON.PROPERTY_KEY">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+      </value>
+    </option>
+    <option name="JSP_DIRECTIVE_NAME" baseAttributes="DEFAULT_KEYWORD" />
+    <option name="JSP_SCRIPTING_BACKGROUND">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="JUPYTER_SELECTED_CELL">
+      <value>
+        <option name="BACKGROUND" value="3e424d" />
+      </value>
+    </option>
+    <option name="KOTLIN_BACKING_FIELD_VARIABLE">
+      <value />
+    </option>
+    <option name="KOTLIN_CLOSURE_DEFAULT_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="KOTLIN_COLON">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="KOTLIN_DOUBLE_COLON">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="KOTLIN_DYNAMIC_FUNCTION_CALL">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="KOTLIN_DYNAMIC_PROPERTY_CALL">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="KOTLIN_EXCLEXCL">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="KOTLIN_IMPLICIT_EXHAUSTIVE_WHEN">
+      <value />
+    </option>
+    <option name="KOTLIN_MUTABLE_VARIABLE">
+      <value>
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="KOTLIN_NAMED_ARGUMENT">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="KOTLIN_PROPERTY_WITH_BACKING_FIELD">
+      <value />
+    </option>
+    <option name="KOTLIN_QUEST">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="KOTLIN_SMART_CAST_RECEIVER">
+      <value />
+    </option>
+    <option name="KOTLIN_SMART_CAST_VALUE">
+      <value />
+    </option>
+    <option name="KOTLIN_SMART_CONSTANT">
+      <value />
+    </option>
+    <option name="KOTLIN_VARIABLE_AS_FUNCTION">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="KOTLIN_VARIABLE_AS_FUNCTION_LIKE">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="LABEL">
+      <value>
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="LINE_NONE_COVERAGE">
+      <value>
+        <option name="FOREGROUND" value="715353" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="LOG_DEBUG_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+      </value>
+    </option>
+    <option name="LOG_ERROR_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="LOG_INFO_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="LOG_VERBOSE_OUTPUT">
+      <value />
+    </option>
+    <option name="LOG_WARNING_OUTPUT">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+      </value>
+    </option>
+    <option name="LUA_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="LUA_REGION_DESC">
+      <value>
+        <option name="FOREGROUND" value="5f5a60" />
+      </value>
+    </option>
+    <option name="LUA_SELF">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="LUA_STD_API">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MACRONAME">
+      <value>
+        <option name="FOREGROUND" value="908b25" />
+      </value>
+    </option>
+    <option name="MARKDOWN.AUTO_LINK">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="MARKDOWN.BULLET_LIST">
+      <value>
+        <option name="FOREGROUND" value="646877" />
+      </value>
+    </option>
+    <option name="MARKDOWN.EXPLICIT_LINK">
+      <value>
+        <option name="FOREGROUND" value="6dc2b8" />
+      </value>
+    </option>
+    <option name="MARKDOWN.HEADER_LEVEL_1">
+      <value>
+        <option name="FOREGROUND" value="63c0ee" />
+      </value>
+    </option>
+    <option name="MARKDOWN.HEADER_LEVEL_2">
+      <value>
+        <option name="FOREGROUND" value="63c0ee" />
+      </value>
+    </option>
+    <option name="MARKDOWN.HEADER_LEVEL_3">
+      <value>
+        <option name="FOREGROUND" value="63c0ee" />
+      </value>
+    </option>
+    <option name="MARKDOWN.HEADER_LEVEL_4">
+      <value>
+        <option name="FOREGROUND" value="63c0ee" />
+      </value>
+    </option>
+    <option name="MARKDOWN.HEADER_LEVEL_5">
+      <value>
+        <option name="FOREGROUND" value="63c0ee" />
+      </value>
+    </option>
+    <option name="MARKDOWN.IMAGE">
+      <value>
+        <option name="FOREGROUND" value="ff355b" />
+      </value>
+    </option>
+    <option name="MARKDOWN.MAIL_LINK">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="MARKDOWN.REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="ff355b" />
+      </value>
+    </option>
+    <option name="MARKDOWN.REFERENCE_IMAGE">
+      <value>
+        <option name="FOREGROUND" value="ff355b" />
+      </value>
+    </option>
+    <option name="MARKDOWN.REFERENCE_LINK">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="MARKDOWN.TEXT">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_AUTO_LINK">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_BLOCK_QUOTE">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_BLOCK_QUOTE_MARKER">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_BOLD">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_BOLD_MARKER">
+      <value>
+        <option name="FOREGROUND" value="5f5a60" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_CODE_BLOCK">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+      </value>
+    </option>
+    <option name="MARKDOWN_CODE_FENCE">
+      <value />
+    </option>
+    <option name="MARKDOWN_CODE_SPAN">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_CODE_SPAN_MARKER">
+      <value>
+        <option name="FOREGROUND" value="5f5a60" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_EXPLICIT_LINK">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="MARKDOWN_HEADER_LEVEL_1">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="MARKDOWN_HEADER_LEVEL_2">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="MARKDOWN_HEADER_LEVEL_3">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="EFFECT_TYPE" value="4" />
+      </value>
+    </option>
+    <option name="MARKDOWN_HEADER_LEVEL_4">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="EFFECT_TYPE" value="4" />
+      </value>
+    </option>
+    <option name="MARKDOWN_HEADER_LEVEL_5">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="EFFECT_TYPE" value="4" />
+      </value>
+    </option>
+    <option name="MARKDOWN_HEADER_LEVEL_6">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="EFFECT_TYPE" value="4" />
+      </value>
+    </option>
+    <option name="MARKDOWN_HEADER_MARKER">
+      <value>
+        <option name="FOREGROUND" value="5f5a60" />
+      </value>
+    </option>
+    <option name="MARKDOWN_HRULE">
+      <value>
+        <option name="FOREGROUND" value="5f5a60" />
+      </value>
+    </option>
+    <option name="MARKDOWN_IMAGE">
+      <value>
+        <option name="FOREGROUND" value="5f5a60" />
+      </value>
+    </option>
+    <option name="MARKDOWN_INLINE_HTML">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="MARKDOWN_ITALIC">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_ITALIC_MARKER">
+      <value>
+        <option name="FOREGROUND" value="5f5a60" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_LINK_DEFINITION">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="MARKDOWN_LINK_DESTINATION">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="MARKDOWN_LINK_LABEL">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_LINK_TEXT">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_LINK_TITLE">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+      </value>
+    </option>
+    <option name="MARKDOWN_LIST_MARKER">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.ABBREVIATED_TEXT">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.ABBREVIATION">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.ABBREVIATION_SHORT_TEXT">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.ANCHOR_ID">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.ATX_HEADER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.AUTO_LINK">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="EFFECT_COLOR" value="7587a6" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.BOLD">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.BOLD_TEXT_CODE_TEXT">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="644c67" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.BOLD_TEXT_ITALIC_TEXT_CODE_TEXT">
+      <value>
+        <option name="FOREGROUND" value="644c67" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.BULLET_LIST">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.CODE">
+      <value>
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.DEFINITION_MARKER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.DEFINITION_TERM">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.EMOJI_ID">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.EMOJI_MARKER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.FOOTNOTE">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.FOOTNOTE_ID">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.FOOTNOTE_REF">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.HEADER_TEXT">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="cda869" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.IMAGE_ALT_TEXT">
+      <value>
+        <option name="FOREGROUND" value="eeffe3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.IMAGE_LINK_REF_TITLE">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.ITALIC">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.ITALIC_MARKER">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.ITALIC_TEXT_CODE_TEXT">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.JEKYLL_TAG_NAME">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.JEKYLL_TAG_PARAMETERS">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.LINK_REF_TITLE">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.QUOTED_TEXT_ABBREVIATED_TEXT">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="BACKGROUND" value="2f343f" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.QUOTED_TEXT_HTML_ENTITY">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="BACKGROUND" value="2f343f" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.QUOTED_TEXT_SMARTS">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="BACKGROUND" value="2f343f" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.QUOTED_TEXT_SPECIAL_TEXT">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="BACKGROUND" value="2f343f" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.QUOTED_TEXT_SPECIAL_TEXT_MARKER">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="BACKGROUND" value="2f343f" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.SIM_TOC_TITLE">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.SMARTS">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.STRIKETHROUGH">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="644c67" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.STRIKETHROUGH_TEXT_BOLD_TEXT_CODE_TEXT">
+      <value>
+        <option name="FOREGROUND" value="644c67" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="866f89" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT_CODE_TEXT">
+      <value>
+        <option name="FOREGROUND" value="866f89" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.STRIKETHROUGH_TEXT_CODE_TEXT">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="644c67" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.STRIKETHROUGH_TEXT_ITALIC_TEXT_CODE_TEXT">
+      <value>
+        <option name="FOREGROUND" value="644c67" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.SUBSCRIPT">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.SUPERSCRIPT">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="4" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CAPTION">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CAPTION_MARKER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CEVEN">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+        <option name="BACKGROUND" value="393f4c" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CEVEN_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CEVEN_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CEVEN_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CEVEN_STRIKETHROUGH_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CEVEN_STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CEVEN_STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="756680" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CEVEN_STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CODD">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+        <option name="BACKGROUND" value="393f4c" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CODD_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CODD_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CODD_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CODD_STRIKETHROUGH_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CODD_STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CODD_STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="756680" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_REVEN_CODD_STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CEVEN">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CEVEN_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CEVEN_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CEVEN_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CEVEN_STRIKETHROUGH_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CEVEN_STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CEVEN_STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="756680" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CEVEN_STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CODD">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CODD_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CODD_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CODD_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CODD_STRIKETHROUGH_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CODD_STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CODD_STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="756680" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_CELL_RODD_CODD_STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CEVEN_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CEVEN_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CEVEN_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CEVEN_STRIKETHROUGH_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CEVEN_STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CEVEN_STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="756680" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CEVEN_STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CODD_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CODD_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CODD_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CODD_STRIKETHROUGH_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CODD_STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CODD_STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="756680" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_REVEN_CODD_STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="BACKGROUND" value="393f4c" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CEVEN_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CEVEN_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CEVEN_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CEVEN_STRIKETHROUGH_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CEVEN_STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CEVEN_STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="756680" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CEVEN_STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CODD_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CODD_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CODD_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CODD_STRIKETHROUGH_TEXT">
+      <value>
+        <option name="FOREGROUND" value="867891" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CODD_STRIKETHROUGH_TEXT_BOLD_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="1" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CODD_STRIKETHROUGH_TEXT_BOLD_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="756680" />
+        <option name="FONT_TYPE" value="3" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_HDR_CELL_RODD_CODD_STRIKETHROUGH_TEXT_ITALIC_TEXT">
+      <value>
+        <option name="FOREGROUND" value="5a4963" />
+        <option name="FONT_TYPE" value="2" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_ROW_EVEN">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_ROW_ODD">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TABLE_SEPARATOR">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TASK_DONE_ITEM_MARKER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TASK_ITEM_MARKER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TEXT">
+      <value>
+        <option name="FOREGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.TOC_OPTION">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.UNDERLINE">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="EFFECT_COLOR" value="9b859d" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.VERBATIM">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.VERBATIM_LANG">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="MARKDOWN_NAVIGATOR.VERBATIM_MARKER">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MARKDOWN_STRIKE_THROUGH">
+      <value>
+        <option name="EFFECT_COLOR" value="a2a2a2" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MARKDOWN_TABLE_SEPARATOR">
+      <value />
+    </option>
+    <option name="MARKED_FOR_REMOVAL_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="757677" />
+        <option name="EFFECT_COLOR" value="bc3f3c" />
+        <option name="EFFECT_TYPE" value="3" />
+      </value>
+    </option>
+    <option name="MATCHED_BRACE_ATTRIBUTES">
+      <value>
+        <option name="BACKGROUND" value="444773" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="MESSAGE_ARGUMENT">
+      <value>
+        <option name="FOREGROUND" value="c4b3a3" />
+      </value>
+    </option>
+    <option name="NG.EXPANSION_FORM">
+      <value>
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="NG.EXPRESSIONS">
+      <value>
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="NOT_TOP_FRAME_ATTRIBUTES">
+      <value>
+        <option name="BACKGROUND" value="d3dae3" />
+      </value>
+    </option>
+    <option name="OC.BADCHARACTER">
+      <value>
+        <option name="EFFECT_COLOR" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="OC.CLASS_REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="OC.CONDITIONALLY_NOT_COMPILED">
+      <value />
+    </option>
+    <option name="OC.CPP_KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="a7dbd8" />
+      </value>
+    </option>
+    <option name="OC.ENUM_CONST">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="OC.GENERIC_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="OC.INVALID_STRING_ESCAPE">
+      <value>
+        <option name="EFFECT_COLOR" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="OC.IVAR">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="OC.MACRONAME">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="OC.MACRO_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="OC.NAMESPACE_LIKE">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="OC.OVERLOADED_OPERATOR">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="OC.PROPERTY">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="OC.PROPERTY_ATTRIBUTE">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="OC.PROTOCOL_REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="OC.SELFSUPERTHIS">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="OC.STRUCT_FIELD">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="OC.STRUCT_LIKE">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="OC.TYPEDEF">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="OC.VALID_STRING_ESCAPE">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="PHP_ALIAS_REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+      </value>
+    </option>
+    <option name="PHP_CONCATENATION">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="PHP_SCRIPTING_BACKGROUND">
+      <value>
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="PHP_TAG">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="PROPERTIES.INVALID_STRING_ESCAPE" baseAttributes="DEFAULT_INVALID_STRING_ESCAPE" />
+    <option name="PROPERTIES.KEY" baseAttributes="DEFAULT_KEYWORD" />
+    <option name="PROPERTIES.KEY_VALUE_SEPARATOR" baseAttributes="DEFAULT_OPERATION_SIGN" />
+    <option name="PROPERTIES.VALID_STRING_ESCAPE" baseAttributes="DEFAULT_VALID_STRING_ESCAPE" />
+    <option name="PROTOCOL_REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="219598" />
+      </value>
+    </option>
+    <option name="PY.BUILTIN_NAME" baseAttributes="" />
+    <option name="PY.DECORATOR">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="PY.SELF_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="PY.STRING">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="RDOC_DIRECTIVE">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="RDOC_EMAIL">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="RDOC_HEADINGS">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="RDOC_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="RDOC_KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="RDOC_URL">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="EFFECT_COLOR" value="8f9d6a" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="REASSIGNED_LOCAL_VARIABLE_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="REASSIGNED_PARAMETER_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="REGEXP.BRACES">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="REGEXP.BRACKETS">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="REGEXP.CHAR_CLASS">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="REGEXP.ESC_CHARACTER">
+      <value />
+    </option>
+    <option name="REGEXP.META">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="REGEXP.PARENTHS">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="REGEXP.QUOTE_CHARACTER">
+      <value />
+    </option>
+    <option name="REGEXP.REDUNDANT_ESCAPE">
+      <value />
+    </option>
+    <option name="REST.FIXED">
+      <value>
+        <option name="BACKGROUND" value="252b39" />
+      </value>
+    </option>
+    <option name="REST.INLINE">
+      <value>
+        <option name="BACKGROUND" value="252b39" />
+      </value>
+    </option>
+    <option name="REST.INTERPRETED">
+      <value>
+        <option name="BACKGROUND" value="252b39" />
+      </value>
+    </option>
+    <option name="RHTML_EXPRESSION_END_ID">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="RHTML_EXPRESSION_START_ID">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="RHTML_SCRIPTING_BACKGROUND_ID">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="RHTML_SCRIPTLET_END_ID">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="RHTML_SCRIPTLET_START_ID">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="RUBY_CONSTANT_DECLARATION">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="RUBY_HEREDOC_CONTENT">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="RUBY_HEREDOC_ID">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_COMMENT">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_DIRECTIVE_NAME">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_ENTITY_REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_MVC_ACTION">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_MVC_AREA">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_MVC_CONTROLLER">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_MVC_VIEW">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_MVC_VIEW_COMPONENT">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_RAZOR_ATTRIBUTE_NAME">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_RAZOR_ATTRIBUTE_VALUE">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_RAZOR_CODE_BLOCK">
+      <value>
+        <option name="BACKGROUND" value="393f4c" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_RAZOR_COMMENT">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_RAZOR_ENTITY_REFERENCE">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_RAZOR_TAG_NAME">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_RUN_AT_ATTRIBUTE">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="ReSharper.ASP_NET_TAG_NAME">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="ReSharper.BRACE_OUTLINE">
+      <value />
+    </option>
+    <option name="ReSharper.CPP_DEPENDENT_NAME_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="ReSharper.CPP_DOXYGEN_COMMAND">
+      <value>
+        <option name="FOREGROUND" value="747c84" />
+      </value>
+    </option>
+    <option name="ReSharper.CPP_ENUM_ENUMERATOR_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="ReSharper.CPP_PREPROCESSOR_MACRO_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.CPP_STATIC_FIELD_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="ReSharper.CPP_STATIC_MEMBER_FUNCTION_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="ReSharper.DELEGATE_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.ENUM_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="ReSharper.EVENT_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.EXTENSION_METHOD_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+      </value>
+    </option>
+    <option name="ReSharper.FORMAT_STRING_ITEM">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="ReSharper.HINT">
+      <value>
+        <option name="EFFECT_COLOR" value="a7a7a7" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="ReSharper.MATCHED_FORMAT_STRING_ITEM">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="EFFECT_COLOR" value="cda869" />
+      </value>
+    </option>
+    <option name="ReSharper.MUTABLE_LOCAL_VARIABLE_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="eeffe3" />
+      </value>
+    </option>
+    <option name="ReSharper.NAMESPACE_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="ReSharper.OUTLINED_ENTITY">
+      <value />
+    </option>
+    <option name="ReSharper.ReSharper.Cg_PREPROCESSOR_LINE_CONTENT">
+      <value>
+        <option name="FOREGROUND" value="9b859d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="ReSharper.STATIC_CLASS_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="ReSharper.STRUCT_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+        <option name="EFFECT_COLOR" value="47bc9b" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="ReSharper.TYPE_PARAMETER_IDENTIFIER">
+      <value>
+        <option name="FOREGROUND" value="8f9d6a" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="SASS_COMMENT" baseAttributes="" />
+    <option name="SASS_MIXIN">
+      <value>
+        <option name="FOREGROUND" value="7587a6" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="SASS_VARIABLE" baseAttributes="" />
+    <option name="SLIM_INTERPOLATION">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="SLIM_TAG">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="SLIM_TAG_ATTR_KEY">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="SLIM_TAG_START">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="SMARTY_BACKGROUND">
+      <value>
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="SPEL.BACKGROUND">
+      <value>
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="STATIC_FINAL_FIELD_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="STATIC_METHOD_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="ffc66d" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="SUGGESTION">
+      <value>
+        <option name="EFFECT_COLOR" value="747c84" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="Scala Type Alias" baseAttributes="" />
+    <option name="Scala Type parameter" baseAttributes="" />
+    <option name="Static method access" baseAttributes="" />
+    <option name="TAPESTRY_COMPONENT_PARAMATER" baseAttributes="" />
+    <option name="TAPESTRY_COMPONENT_TAG" baseAttributes="" />
+    <option name="TS.PRIVATE_PUBLIC">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="FONT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="TS.TYPE_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="47bc9b" />
+      </value>
+    </option>
+    <option name="TWIG_BACKGROUND">
+      <value>
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="TYPEDEF">
+      <value>
+        <option name="FOREGROUND" value="c7c8f5" />
+      </value>
+    </option>
+    <option name="TYPE_PARAMETER_NAME_ATTRIBUTES">
+      <value>
+        <option name="FOREGROUND" value="cda869" />
+      </value>
+    </option>
+    <option name="TYPO">
+      <value>
+        <option name="EFFECT_COLOR" value="ffeb95" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="UNITY_EXPENSIVE_CAMERA_MAIN_USAGE">
+      <value>
+        <option name="EFFECT_COLOR" value="cf6a4c" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="UNITY_EXPENSIVE_METHOD_INVOCATION">
+      <value>
+        <option name="EFFECT_COLOR" value="7587a6" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="UNITY_EXPENSIVE_NULL_COMPARISON">
+      <value>
+        <option name="EFFECT_COLOR" value="cda869" />
+        <option name="EFFECT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="UNITY_PERFORMANCE_CRITICAL_LINE_MARKER">
+      <value>
+        <option name="EFFECT_COLOR" value="47bc9b" />
+        <option name="EFFECT_TYPE" value="4" />
+      </value>
+    </option>
+    <option name="VELOCITY_KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="a7dbd8" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="VELOCITY_NUMBER">
+      <value>
+        <option name="FOREGROUND" value="f36e3a" />
+      </value>
+    </option>
+    <option name="VELOCITY_SCRIPTING_BACKGROUND">
+      <value>
+        <option name="BACKGROUND" value="252b39" />
+      </value>
+    </option>
+    <option name="WRITE_IDENTIFIER_UNDER_CARET_ATTRIBUTES">
+      <value>
+        <option name="BACKGROUND" value="40332b" />
+        <option name="ERROR_STRIPE_COLOR" value="be687d" />
+      </value>
+    </option>
+    <option name="XML_ATTRIBUTE_NAME" baseAttributes="DEFAULT_ATTRIBUTE" />
+    <option name="XML_ENTITY_REFERENCE" baseAttributes="DEFAULT_ENTITY" />
+    <option name="XML_PROLOGUE" baseAttributes="TEXT" />
+    <option name="XML_TAG">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+      </value>
+    </option>
+    <option name="XML_TAG_DATA" baseAttributes="TEXT" />
+    <option name="XML_TAG_NAME">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="XPATH.KEYWORD">
+      <value>
+        <option name="FOREGROUND" value="a7dbd8" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="XPATH.NUMBER">
+      <value>
+        <option name="FOREGROUND" value="f25619" />
+      </value>
+    </option>
+    <option name="XPATH.STRING">
+      <value>
+        <option name="FOREGROUND" value="f36e3a" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+    <option name="XPATH.XPATH_NAME" baseAttributes="TEXT" />
+    <option name="XPATH.XPATH_VARIABLE" baseAttributes="DEFAULT_LOCAL_VARIABLE" />
+    <option name="YAML_SCALAR_KEY">
+      <value>
+        <option name="FOREGROUND" value="cf6a4c" />
+      </value>
+    </option>
+    <option name="YAML_SCALAR_LIST">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="YAML_SCALAR_VALUE">
+      <value>
+        <option name="FOREGROUND" value="a7a7a7" />
+        <option name="EFFECT_TYPE" value="5" />
+      </value>
+    </option>
+    <option name="org.rust.TYPE_PARAMETER">
+      <value>
+        <option name="FOREGROUND" value="f9ee98" />
+      </value>
+    </option>
+    <option name="org.rust.UNSAFE_CODE">
+      <value>
+        <option name="EFFECT_COLOR" value="a7a7a7" />
+        <option name="EFFECT_TYPE" value="2" />
+      </value>
+    </option>
+    <option name="osmorc.headerName">
+      <value>
+        <option name="FOREGROUND" value="a7dbd8" />
+        <option name="FONT_TYPE" value="1" />
+      </value>
+    </option>
+  </attributes>
+</scheme>
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-style.xml" "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-style.xml"
new file mode 100644
index 0000000..2e492a2
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/idea/\351\205\215\347\275\256\346\226\207\344\273\266/my-code-style.xml"
@@ -0,0 +1,259 @@
+<code_scheme name="My Code Style" version="173">
+  <option name="OTHER_INDENT_OPTIONS">
+    <value>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </value>
+  </option>
+  <option name="LINE_SEPARATOR" value="&#xA;"/>
+  <JSCodeStyleSettings version="0">
+    <option name="INDENT_CHAINED_CALLS" value="false"/>
+  </JSCodeStyleSettings>
+  <JavaCodeStyleSettings>
+    <option name="INSERT_INNER_CLASS_IMPORTS" value="true"/>
+    <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="6"/>
+    <option name="NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND" value="6"/>
+    <option name="PACKAGES_TO_USE_IMPORT_ON_DEMAND">
+      <value/>
+    </option>
+    <option name="IMPORT_LAYOUT_TABLE">
+      <value>
+        <package name="java" withSubpackages="true" static="false"/>
+        <emptyLine/>
+        <package name="javax" withSubpackages="true" static="false"/>
+        <emptyLine/>
+        <package name="org" withSubpackages="true" static="false"/>
+        <emptyLine/>
+        <package name="com" withSubpackages="true" static="false"/>
+        <emptyLine/>
+        <package name="top" withSubpackages="true" static="false"/>
+        <emptyLine/>
+        <package name="" withSubpackages="true" static="false"/>
+        <emptyLine/>
+        <package name="" withSubpackages="true" static="true"/>
+      </value>
+    </option>
+    <option name="JD_ALIGN_PARAM_COMMENTS" value="false"/>
+    <option name="JD_ALIGN_EXCEPTION_COMMENTS" value="false"/>
+    <option name="JD_DO_NOT_WRAP_ONE_LINE_COMMENTS" value="true"/>
+    <option name="JD_KEEP_EMPTY_PARAMETER" value="false"/>
+    <option name="JD_KEEP_EMPTY_EXCEPTION" value="false"/>
+    <option name="JD_KEEP_EMPTY_RETURN" value="false"/>
+    <option name="JD_PRESERVE_LINE_FEEDS" value="true"/>
+    <option name="JD_INDENT_ON_CONTINUATION" value="true"/>
+  </JavaCodeStyleSettings>
+  <Properties>
+    <option name="KEEP_BLANK_LINES" value="true"/>
+  </Properties>
+  <Python>
+    <option name="USE_CONTINUATION_INDENT_FOR_ARGUMENTS" value="true"/>
+  </Python>
+  <TypeScriptCodeStyleSettings version="0">
+    <option name="INDENT_CHAINED_CALLS" value="false"/>
+  </TypeScriptCodeStyleSettings>
+  <XML>
+    <option name="XML_ALIGN_ATTRIBUTES" value="false"/>
+    <option name="XML_LEGACY_SETTINGS_IMPORTED" value="true"/>
+  </XML>
+  <codeStyleSettings language="CSS">
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="ECMA Script Level 4">
+    <option name="KEEP_BLANK_LINES_IN_CODE" value="1"/>
+    <option name="ALIGN_MULTILINE_PARAMETERS" value="false"/>
+    <option name="ALIGN_MULTILINE_FOR" value="false"/>
+    <option name="CALL_PARAMETERS_WRAP" value="1"/>
+    <option name="METHOD_PARAMETERS_WRAP" value="1"/>
+    <option name="EXTENDS_LIST_WRAP" value="1"/>
+    <option name="BINARY_OPERATION_WRAP" value="1"/>
+    <option name="BINARY_OPERATION_SIGN_ON_NEXT_LINE" value="true"/>
+    <option name="TERNARY_OPERATION_WRAP" value="1"/>
+    <option name="TERNARY_OPERATION_SIGNS_ON_NEXT_LINE" value="true"/>
+    <option name="FOR_STATEMENT_WRAP" value="1"/>
+    <option name="ARRAY_INITIALIZER_WRAP" value="1"/>
+    <option name="IF_BRACE_FORCE" value="3"/>
+    <option name="DOWHILE_BRACE_FORCE" value="3"/>
+    <option name="WHILE_BRACE_FORCE" value="3"/>
+    <option name="FOR_BRACE_FORCE" value="3"/>
+    <option name="PARENT_SETTINGS_INSTALLED" value="true"/>
+  </codeStyleSettings>
+  <codeStyleSettings language="HTML">
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="Haml">
+    <indentOptions>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="JAVA">
+    <option name="KEEP_CONTROL_STATEMENT_IN_ONE_LINE" value="false"/>
+    <option name="KEEP_BLANK_LINES_IN_CODE" value="1"/>
+    <option name="BLANK_LINES_AFTER_CLASS_HEADER" value="1"/>
+    <option name="ALIGN_MULTILINE_PARAMETERS" value="false"/>
+    <option name="ALIGN_MULTILINE_RESOURCES" value="false"/>
+    <option name="ALIGN_MULTILINE_FOR" value="false"/>
+    <option name="CALL_PARAMETERS_WRAP" value="1"/>
+    <option name="METHOD_PARAMETERS_WRAP" value="1"/>
+    <option name="EXTENDS_LIST_WRAP" value="1"/>
+    <option name="THROWS_KEYWORD_WRAP" value="1"/>
+    <option name="METHOD_CALL_CHAIN_WRAP" value="1"/>
+    <option name="BINARY_OPERATION_WRAP" value="1"/>
+    <option name="BINARY_OPERATION_SIGN_ON_NEXT_LINE" value="true"/>
+    <option name="TERNARY_OPERATION_WRAP" value="1"/>
+    <option name="TERNARY_OPERATION_SIGNS_ON_NEXT_LINE" value="true"/>
+    <option name="FOR_STATEMENT_WRAP" value="1"/>
+    <option name="ARRAY_INITIALIZER_WRAP" value="1"/>
+    <option name="WRAP_COMMENTS" value="true"/>
+    <option name="IF_BRACE_FORCE" value="3"/>
+    <option name="DOWHILE_BRACE_FORCE" value="3"/>
+    <option name="WHILE_BRACE_FORCE" value="3"/>
+    <option name="FOR_BRACE_FORCE" value="3"/>
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="JSON">
+    <indentOptions>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="JSP">
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="JSPX">
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="JavaScript">
+    <option name="RIGHT_MARGIN" value="80"/>
+    <option name="KEEP_BLANK_LINES_IN_CODE" value="1"/>
+    <option name="ALIGN_MULTILINE_PARAMETERS" value="false"/>
+    <option name="ALIGN_MULTILINE_FOR" value="false"/>
+    <option name="CALL_PARAMETERS_WRAP" value="1"/>
+    <option name="METHOD_PARAMETERS_WRAP" value="1"/>
+    <option name="BINARY_OPERATION_WRAP" value="1"/>
+    <option name="BINARY_OPERATION_SIGN_ON_NEXT_LINE" value="true"/>
+    <option name="TERNARY_OPERATION_WRAP" value="1"/>
+    <option name="TERNARY_OPERATION_SIGNS_ON_NEXT_LINE" value="true"/>
+    <option name="FOR_STATEMENT_WRAP" value="1"/>
+    <option name="ARRAY_INITIALIZER_WRAP" value="1"/>
+    <option name="IF_BRACE_FORCE" value="3"/>
+    <option name="DOWHILE_BRACE_FORCE" value="3"/>
+    <option name="WHILE_BRACE_FORCE" value="3"/>
+    <option name="FOR_BRACE_FORCE" value="3"/>
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="PROTO">
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="2"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="Python">
+    <option name="KEEP_BLANK_LINES_IN_CODE" value="1"/>
+    <option name="RIGHT_MARGIN" value="80"/>
+    <option name="ALIGN_MULTILINE_PARAMETERS" value="false"/>
+    <option name="PARENT_SETTINGS_INSTALLED" value="true"/>
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="SASS">
+    <indentOptions>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="SCSS">
+    <indentOptions>
+      <option name="CONTINUATION_INDENT_SIZE" value="4"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="TypeScript">
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="XML">
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="2"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+    <arrangement>
+      <rules>
+        <section>
+          <rule>
+            <match>
+              <AND>
+                <NAME>xmlns:.*</NAME>
+                <XML_ATTRIBUTE/>
+                <XML_NAMESPACE>^$</XML_NAMESPACE>
+              </AND>
+            </match>
+            <order>BY_NAME</order>
+          </rule>
+        </section>
+        <section>
+          <rule>
+            <match>
+              <AND>
+                <NAME>.*</NAME>
+                <XML_ATTRIBUTE/>
+                <XML_NAMESPACE>^$</XML_NAMESPACE>
+              </AND>
+            </match>
+            <order>BY_NAME</order>
+          </rule>
+        </section>
+        <section>
+          <rule>
+            <match>
+              <AND>
+                <NAME>.*</NAME>
+                <XML_NAMESPACE>.*</XML_NAMESPACE>
+              </AND>
+            </match>
+            <order>BY_NAME</order>
+          </rule>
+        </section>
+      </rules>
+    </arrangement>
+  </codeStyleSettings>
+  <codeStyleSettings language="protobuf">
+    <option name="RIGHT_MARGIN" value="80"/>
+    <indentOptions>
+      <option name="INDENT_SIZE" value="2"/>
+      <option name="CONTINUATION_INDENT_SIZE" value="2"/>
+      <option name="TAB_SIZE" value="2"/>
+    </indentOptions>
+  </codeStyleSettings>
+</code_scheme>
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/idea\344\270\255\345\214\205offline_mode\351\224\231\350\257\257.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/idea\344\270\255\345\214\205offline_mode\351\224\231\350\257\257.md"
new file mode 100644
index 0000000..7a801e0
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/idea\344\270\255\345\214\205offline_mode\351\224\231\350\257\257.md"
@@ -0,0 +1,11 @@
+## 问题
+
+同事在**pom**文件中新增了一条依赖项，但是将代码克隆到本地后使用**idea**无法下载该**jar**包。提示*offline mode*等等
+
+## 原因
+
+根据提示可知，当前maven开启了离线模式：仅使用本地仓库中现有的依赖项。
+
+## 解决方案
+
+`File -> Settings -> Build,Execution,Deployment -> Maven`关闭`Work offline`即可解决。
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/idea\346\216\247\345\210\266\345\217\260\344\270\255\346\226\207\344\271\261\347\240\201.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/idea\346\216\247\345\210\266\345\217\260\344\270\255\346\226\207\344\271\261\347\240\201.md"
new file mode 100644
index 0000000..66b0fa6
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/idea\346\216\247\345\210\266\345\217\260\344\270\255\346\226\207\344\271\261\347\240\201.md"
@@ -0,0 +1,10 @@
+## 原因
+
+windows平台中文使用的是GB2312编码，而maven使用的不是该编码，导致乱码
+
+## 解决方案
+
+打开`settings` -> `Build,Execution,Deployment`-> `Maven` -> `Runner`
+
+修改`VM Options`为`-Dfile.encoding=GB2312`
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/jar\346\211\223\345\214\205\346\217\222\344\273\266.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/jar\346\211\223\345\214\205\346\217\222\344\273\266.md"
new file mode 100644
index 0000000..0c32762
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/jar\346\211\223\345\214\205\346\217\222\344\273\266.md"
@@ -0,0 +1,108 @@
+### 此插件打包为jar，并对MANIFEST.MF作修改：`mvn package`：
+
+```xml
+<plugin>
+	<groupId>org.apache.maven.plugins</groupId>
+	<artifactId>maven-jar-plugin</artifactId>
+	<version>2.4</version>
+	<configuration>
+		<archive>
+			<manifest>
+				<!-- 为依赖包添加路径, 这些路径会写在MANIFEST文件的Class-Path下 -->
+				<addClasspath>true</addClasspath>
+				<classpathPrefix>lib/</classpathPrefix>
+				<!-- jar启动入口类 -->
+				<mainClass>com.lwt.test.Test</mainClass>
+			</manifest>
+			<manifestEntries>
+				<!-- 在MANIFEST.MF下添加项，其实所有项都可以在此添加而不用上面的manifest标签 -->
+				<!-- conf/会被添加到Class-Path -->
+				<Class-Path>conf/</Class-Path>
+			</manifestEntries>
+		</archive>
+		<includes>
+			<!-- 打jar包时，只打包class文件。若想打包配置文件，注释掉 -->
+			<include>**/*.class</include>
+		</includes>
+	</configuration>
+</plugin>
+```
+
+### 将依赖包解压并打包为一个单独jar包的插件：`mvn assembly:assembly`
+
+```xml
+<plugin>
+	<groupId>org.apache.maven.plugins</groupId>
+	<artifactId>maven-assembly-plugin</artifactId>
+	<version>2.2</version>
+	<configuration>
+		<archive>
+			<manifest>
+				<mainClass>com.lwt.test.Test</mainClass>
+			</manifest>
+		</archive>
+		<descriptorRefs>
+			<descriptorRef>
+				jar-with-dependencies
+			</descriptorRef>
+		</descriptorRefs>
+	</configuration>
+</plugin>
+```
+
+### 打包为jar并生成依赖的目录，里面存放依赖jar：`mvn package`
+
+```xml
+<plugin>
+	<groupId>org.apache.maven.plugins</groupId>
+	<artifactId>maven-jar-plugin</artifactId>
+	<version>2.4</version>
+	<configuration>
+		<archive>
+			<manifest>
+				<addClasspath>true</addClasspath>
+				<classpathPrefix>dependency/</classpathPrefix>
+				<mainClass>com.lwt.test.Test</mainClass>
+			</manifest>
+		</archive>
+	</configuration>
+</plugin>
+
+<plugin>
+	<groupId>org.apache.maven.plugins</groupId>
+	<artifactId>maven-dependency-plugin</artifactId>
+	<version>2.10</version>
+	<executions>
+		<execution>
+			<id>copy-dependencies</id>
+			<phase>package</phase>
+			<goals>
+				<goal>copy-dependencies</goal>
+			</goals>
+		</execution>
+	</executions>
+</plugin>
+```
+
+### 此插件能生成可执行批处理文件：`mvn package appassembler:assemble`
+
+```xml
+<plugin>
+	<groupId>org.codehaus.mojo</groupId>
+	<artifactId>appassembler-maven-plugin</artifactId>
+	<version>1.10</version>
+	<configuration>
+		<programs>
+			<program>
+				<mainClass>com.lwt.test.Test</mainClass>
+				<id>app</id>
+			</program>
+		</programs>
+	</configuration>
+</plugin>
+```
+
+### 引用
+
+[maven：打包jar的插件](https://blog.csdn.net/xuejianbest/article/details/84859145)
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/maven.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/maven.md"
new file mode 100644
index 0000000..6d5f075
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/maven.md"
@@ -0,0 +1,1169 @@
+## 创建 Maven 项目
+` mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false `
+## Maven 目录结构
+```properties
+my-app
+|-- pom.xml
+`-- src
+    |-- main
+    |   `-- java
+    |       `-- com
+    |           `-- mycompany
+    |               `-- app
+    |                   `-- App.java
+    `-- test
+        `-- java
+            `-- com
+                `-- mycompany
+                    `-- app
+                        `-- AppTest.java
+```
+## POM 文件
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+ 
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-app</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+ 
+  <name>Maven Quick Start Archetype</name>
+  <url>http://maven.apache.org</url>
+ 
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.8.2</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>
+```
+## 编译项目
+### 打包命令
+```sh
+mvn package
+```
+### 输出
+```sh
+[INFO] ------------------------------------------------------------------------
+[INFO] BUILD SUCCESSFUL
+[INFO] ------------------------------------------------------------------------
+[INFO] Total time: 2 seconds
+[INFO] Finished at: Thu Jul 07 21:34:52 CEST 2011
+[INFO] Final Memory: 3M/6M
+[INFO] ------------------------------------------------------------------------
+```
+### 运行
+```sh
+java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App
+```
+
+# Tools
+### 生命周期
+- validate: validate the project is correct and all necessary information is available
+- compile: compile the source code of the project
+- test: test the compiled source code using a suitable unit testing framework. These tests should not require the code be packaged or deployed
+- package: take the compiled code and package it in its distributable format, such as a JAR.
+- integration-test: process and deploy the package if necessary into an environment where integration tests can be run
+- verify: run any checks to verify the package is valid and meets quality criteria
+- install: install the package into the local repository, for use as a dependency in other projects locally
+- deploy: done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects.
+> 除了上面的默认列表之外，还有两个其他的Maven生命周期
+
+- clean: cleans up artifacts created by prior builds
+- site: generates site documentation for this project
+
+> maven 的生命周期会按顺序执行
+
+`mvn clean dependency:copy-dependencies package`
+
+### 生成站点
+`mvn site`
+> 生成的文档会存在于 **target/site** 文件夹下
+
+# 内部插件
+### 1. 编译
+`mvn compile`
+
+> 输出
+
+```sh
+[INFO] ----------------------------------------------------------------------------
+[INFO] Building Maven Quick Start Archetype
+[INFO]    task-segment: [compile]
+[INFO] ----------------------------------------------------------------------------
+[INFO] artifact org.apache.maven.plugins:maven-resources-plugin: \
+  checking for updates from central
+...
+[INFO] artifact org.apache.maven.plugins:maven-compiler-plugin: \
+  checking for updates from central
+...
+[INFO] [resources:resources]
+...
+[INFO] [compiler:compile]
+Compiling 1 source file to <dir>/my-app/target/classes
+[INFO] ----------------------------------------------------------------------------
+[INFO] BUILD SUCCESSFUL
+[INFO] ----------------------------------------------------------------------------
+[INFO] Total time: 3 minutes 54 seconds
+[INFO] Finished at: Fri Sep 23 15:48:34 GMT-05:00 2005
+[INFO] Final Memory: 2M/6M
+[INFO] ----------------------------------------------------------------------------
+```
+
+> 第一次运行该命令时，maven 会需要下载依赖的插件。
+> 编译后的文件存放在 **${basedir}/target/classes** 目录下
+
+### 1. 运行测试
+
+`mvn test`
+
+> 执行上面的命令会得到一下的输出
+
+```sh
+[INFO] ----------------------------------------------------------------------------
+[INFO] Building Maven Quick Start Archetype
+[INFO]    task-segment: [test]
+[INFO] ----------------------------------------------------------------------------
+[INFO] artifact org.apache.maven.plugins:maven-surefire-plugin: \
+  checking for updates from central
+...
+[INFO] [resources:resources]
+[INFO] [compiler:compile]
+[INFO] Nothing to compile - all classes are up to date
+[INFO] [resources:testResources]
+[INFO] [compiler:testCompile]
+Compiling 1 source file to C:\Test\Maven2\test\my-app\target\test-classes
+...
+[INFO] [surefire:test]
+[INFO] Setting reports dir: C:\Test\Maven2\test\my-app\target/surefire-reports
+ 
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+[surefire] Running com.mycompany.app.AppTest
+[surefire] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0 sec
+ 
+Results :
+[surefire] Tests run: 1, Failures: 0, Errors: 0
+ 
+[INFO] ----------------------------------------------------------------------------
+[INFO] BUILD SUCCESSFUL
+[INFO] ----------------------------------------------------------------------------
+[INFO] Total time: 15 seconds
+[INFO] Finished at: Thu Oct 06 08:12:17 MDT 2005
+[INFO] Final Memory: 2M/8M
+[INFO] ----------------------------------------------------------------------------
+```
+> 如果你想只编译测验代码而不去运行，你可以使用下面的命令
+`mvn test-compile`
+
+### 3. 创建 jar 并安装到本地仓库
+制作一个 jar 包非常简单，只需要执行下面的命令
+
+`mvn package`
+
+> 如果你查找过 POM 文件，就会发现 POM 文件中为 **packaging** 元素被设置为 **jar** , 这就是为什么上面的命令会产生一个 jar 包的原因。
+> 你可以在 **${basedir}/target** 目录下找到生成的 JAR 文件。 
+
+如果你想把刚刚生成的文件安装到本地仓库（**${user.home}/.m2/repository** 是默认的仓库地址）
+
+`mvn install`
+
+执行上面的命令会输出以下信息
+
+```sh
+[INFO] ----------------------------------------------------------------------------
+[INFO] Building Maven Quick Start Archetype
+[INFO]    task-segment: [install]
+[INFO] ----------------------------------------------------------------------------
+[INFO] [resources:resources]
+[INFO] [compiler:compile]
+Compiling 1 source file to <dir>/my-app/target/classes
+[INFO] [resources:testResources]
+[INFO] [compiler:testCompile]
+Compiling 1 source file to <dir>/my-app/target/test-classes
+[INFO] [surefire:test]
+[INFO] Setting reports dir: <dir>/my-app/target/surefire-reports
+ 
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+[surefire] Running com.mycompany.app.AppTest
+[surefire] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.001 sec
+ 
+Results :
+[surefire] Tests run: 1, Failures: 0, Errors: 0
+ 
+[INFO] [jar:jar]
+[INFO] Building jar: <dir>/my-app/target/my-app-1.0-SNAPSHOT.jar
+[INFO] [install:install]
+[INFO] Installing <dir>/my-app/target/my-app-1.0-SNAPSHOT.jar to \
+   <local-repository>/com/mycompany/app/my-app/1.0-SNAPSHOT/my-app-1.0-SNAPSHOT.jar
+[INFO] ----------------------------------------------------------------------------
+[INFO] BUILD SUCCESSFUL
+[INFO] ----------------------------------------------------------------------------
+[INFO] Total time: 5 seconds
+[INFO] Finished at: Tue Oct 04 13:20:32 GMT-05:00 2005
+[INFO] Final Memory: 3M/8M
+[INFO] ----------------------------------------------------------------------------
+```
+
+> 请注意，surefire插件（执行测试）使用特定的命名约定查找包含在文件中的测试，默认包含的测试规则有：
+
+- **/*Test.java
+- **/Test*.java
+- **/*TestCase.java
+
+> 默认排除的有：
+
+- **/Abstract*Test.java
+- **/Abstract*TestCase.java
+
+## SNAPSHOT 是什么版本?
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  ...
+  <groupId>...</groupId>
+  <artifactId>my-app</artifactId>
+  ...
+  <version>1.0-SNAPSHOT</version>
+  <name>Maven Quick Start Archetype</name>
+  ...
+```
+
+> **SNAPSHOT** 值是指沿开发分支的“最新”代码，并不保证代码稳定或不变，相反，“发布”版本中的代码（没有后缀SNAPSHOT的任何版本值）不变。
+
+> 换句话说，SNAPSHOT版本是最终“发布”版本之前的“开发”版本。 SNAPSHOT比它的发布“更老”
+
+> 在发布过程中，x.y-SNAPSHOT的一个版本更改为x.y. 发布过程也将开发版本增加到x.(y + 1)-SNAPSHOT。例如，版本1.0-SNAPSHOT作为版本1.0发布，而新的开发版本是版本1.1-SNAPSHOT。
+
+## 怎么使用插件
+无论何时您想为Maven项目定制构建，都可以通过添加或重新配置插件来完成。
+
+在这个例子中，我们将配置Java编译器以允许JDK 5.0源代码。这与将此添加到您的POM一样简单：
+
+```xml
+<build>
+  <plugins>
+    <plugin>
+      <groupId>org.apache.maven.plugins</groupId>
+      <artifactId>maven-compiler-plugin</artifactId>
+      <version>3.3</version>
+      <configuration>
+        <source>1.5</source>
+        <target>1.5</target>
+      </configuration>
+    </plugin>
+  </plugins>
+</build>
+```
+
+> **configuration** 元素会应用在 compile 插件编译的每一个元素上面。
+
+## 怎么过滤资源文件
+有时候资源文件需要包含一个只能在构建时提供的值。为了在Maven中实现这一点，请使用语法$ {<property name\>}将引用包含值的属性引用到资源文件中。
+
+该属性可以是您的pom.xml中定义的值之一，在用户的settings.xml中定义的值，在外部属性文件中定义的属性或系统属性。
+
+要在复制时使用Maven过滤器资源，只需将pom.xml中的资源目录的过滤设置为true即可：
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+ 
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-app</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+ 
+  <name>Maven Quick Start Archetype</name>
+  <url>http://maven.apache.org</url>
+ 
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+ 
+  <build>
+    <resources>
+      <resource>
+        <directory>src/main/resources</directory>
+        <filtering>true</filtering>
+      </resource>
+    </resources>
+  </build>
+</project>
+```
+
+您会注意到我们必须添加之前没有的 **build**，**resources** 和 **resource** 元素。另外，我们必须明确说明这些资源位于 **src/main/resources** 目录中。所有这些信息之前都是作为默认值提供的，但由于过滤的默认值为false，我们必须将其添加到我们的pom.xml中，以覆盖该默认值并将筛选设置为true。
+
+为了引用在您的pom.xml中定义的属性，属性名称使用定义值的XML元素的名称，允许“pom”作为项目（root）元素的别名。所以 **${project.name}** 指的是项目的名称，**${project.version}** 指的是项目的版本，**${project.build.finalName}** 指的是构建项目时创建的文件的最终名称被打包等等。注意，POM的一些元素具有默认值，所以不需要在你的pom.xml中明确地定义这些值在这里可用。类似地，用户的settings.xml中的值可以使用以“settings”开头的属性名称来引用（例如，**${settings.localRepository}** 引用用户本地存储库的路径）。
+
+为了继续我们的例子，让我们添加一些属性到 **application.properties** 文件中（我们把它放在 **src/main/resources** 目录中），这些文件的值将在资源被过滤时提供：
+
+```properties
+# application.properties
+application.name=${project.name}
+application.version=${project.version}
+```
+
+有了这个，您可以执行以下命令（process-resources是资源被复制和过滤的构建生命周期阶段）：
+
+```sh
+mvn process-resources
+```
+
+target/classes下的application.properties文件（并最终进入jar的文件）如下所示：
+
+```properties
+# application.properties
+application.name=Maven Quick Start Archetype
+application.version=1.0-SNAPSHOT
+```
+
+要引用在外部文件中定义的属性，您只需在pom.xml中添加对此外部文件的引用。首先，我们创建我们的外部属性文件，并将其称为 src/main/filters/filter.properties：
+
+```properties
+# filter.properties
+my.filter.value=hello!
+```
+
+接下来，我们将在pom.xml中添加对这个新文件的引用：
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+ 
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-app</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+ 
+  <name>Maven Quick Start Archetype</name>
+  <url>http://maven.apache.org</url>
+ 
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+ 
+  <build>
+    <filters>
+      <filter>src/main/filters/filter.properties</filter>
+    </filters>
+    <resources>
+      <resource>
+        <directory>src/main/resources</directory>
+        <filtering>true</filtering>
+      </resource>
+    </resources>
+  </build>
+</project>
+```
+
+然后，如果我们在application.properties文件中添加对此属性的引用：
+
+```properties
+# application.properties
+application.name=${project.name}
+application.version=${project.version}
+message=${my.filter.value}
+```
+
+mvn process-resources命令的下一次执行会将我们的新属性值放入application.properties中。作为在外部文件中定义my.filter.value属性的替代方法，您也可以在pom.xml的properties部分中定义它，并获得相同的效果（注意我不需要引用src/main/filters/filter.properties）：
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+ 
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-app</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+ 
+  <name>Maven Quick Start Archetype</name>
+  <url>http://maven.apache.org</url>
+ 
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+ 
+  <build>
+    <resources>
+      <resource>
+        <directory>src/main/resources</directory>
+        <filtering>true</filtering>
+      </resource>
+    </resources>
+  </build>
+ 
+  <properties>
+    <my.filter.value>hello</my.filter.value>
+  </properties>
+</project>
+```
+
+过滤资源还可以从系统属性获取值; 可以是内置于Java中的系统属性（如java.version或user.home），也可以是使用标准Java -D参数在命令行上定义的属性。为了继续这个例子，让我们把我们的application.properties文件改为如下所示：
+
+```properties
+# application.properties
+java.version=${java.version}
+command.line.prop=${command.line.prop}
+```
+
+现在，当您执行以下命令（请注意命令行中command.line.prop属性的定义）时，application.properties文件将包含系统属性中的值。
+
+```sh
+mvn process-resources "-Dcommand.line.prop=hello again"
+```
+
+## 依赖
+
+```xml
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+```
+
+对于每个外部依赖关系，您至少需要定义4种东西：groupId，artifactId，版本和范围。groupId，artifactId和version与构建该依赖项目的项目的pom.xml中给出的相同。scope元素指示项目如何使用该依赖关系，并且可以是诸如 **compile**，**test** 和 **runtime** 的值。
+
+maven 会根据 groupId、artifactId 和 version 去本地仓库(${user.home/.m2/repository})中寻找, 如果在本地仓库中找不到时， 则会从 maven 中央仓库下载对应的依赖到本地。
+
+## 部署到远程仓库
+要将jar部署到外部存储库，必须在pom.xml中配置存储库URL，并在settings.xml中配置连接到存储库的认证信息。
+
+以下是使用scp和用户名/密码认证的示例：
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+ 
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-app</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+ 
+  <name>Maven Quick Start Archetype</name>
+  <url>http://maven.apache.org</url>
+ 
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.codehaus.plexus</groupId>
+      <artifactId>plexus-utils</artifactId>
+      <version>1.0.4</version>
+    </dependency>
+  </dependencies>
+ 
+  <build>
+    <filters>
+      <filter>src/main/filters/filters.properties</filter>
+    </filters>
+    <resources>
+      <resource>
+        <directory>src/main/resources</directory>
+        <filtering>true</filtering>
+      </resource>
+    </resources>
+  </build>
+  <!--
+   |
+   |
+   |
+   -->
+  <distributionManagement>
+    <repository>
+      <id>mycompany-repository</id>
+      <name>MyCompany Repository</name>
+      <url>scp://repository.mycompany.com/repository/maven2</url>
+    </repository>
+  </distributionManagement>
+</project>
+```
+
+___
+
+```xml
+<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
+                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
+  ...
+  <servers>
+    <server>
+      <id>mycompany-repository</id>
+      <username>jvanzyl</username>
+      <!-- Default value is ~/.ssh/id_dsa -->
+      <privateKey>/path/to/identity</privateKey> (default is ~/.ssh/id_dsa)
+      <passphrase>my_key_passphrase</passphrase>
+    </server>
+  </servers>
+  ...
+</settings>
+```
+
+> 请注意，如果您正在连接到sshd_confing中参数“PasswordAuthentication”设置为“no”的openssh ssh服务器，则您必须每次输入密码以进行用户名/密码身份验证（尽管您可以使用另一个ssh登录客户端通过输入用户名和密码）。在这种情况下，您可能想切换到公钥认证。
+
+> 如果在settings.xml中使用密码，应该小心。
+
+## 创建文档
+为了让您能够从Maven的文档系统入手，您可以使用以下命令使用原型机制为现有项目生成一个站点：
+
+```sh
+mvn archetype:generate \
+  -DarchetypeGroupId=org.apache.maven.archetypes \
+  -DarchetypeArtifactId=maven-archetype-site \
+  -DgroupId=com.mycompany.app \
+  -DartifactId=my-app-site
+```
+
+## 构建其他类型的项目
+生命周期适用于任何项目类型。我们可以创建一个简单的Web应用程序：
+
+```sh
+mvn archetype:generate \
+    -DarchetypeGroupId=org.apache.maven.archetypes \
+    -DarchetypeArtifactId=maven-archetype-webapp \
+    -DgroupId=com.mycompany.app \
+    -DartifactId=my-webapp
+```
+
+请注意，这些都必须在一行上。这将创建一个名为my-webapp的目录，其中包含以下项目描述符：
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+ 
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-webapp</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>war</packaging>
+ 
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+ 
+  <build>
+    <finalName>my-webapp</finalName>
+  </build>
+</project>
+```
+
+请注意<packaging>元素 - 这会告诉Maven构建为WAR。转到webapp项目的目录并尝试：
+
+```sh
+mvn package
+```
+
+你会看到target / my-webapp.war被构建，并且执行了所有常规步骤。
+
+## 一次构建多个项目
+Maven内置了处理多个模块的概念。在本节中，我们将展示如何构建上面的WAR，并在一个步骤中包含以前的JAR。
+首先，我们需要在其他两个目录上面添加一个父pom.xml文件，所以它应该看起来像这样：
+
+```sh
++- pom.xml
++- my-app
+| +- pom.xml
+| +- src
+|   +- main
+|     +- java
++- my-webapp
+| +- pom.xml
+| +- src
+|   +- main
+|     +- webapp
+```
+
+
+您要创建的POM文件应包含以下内容：
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+ 
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>app</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>pom</packaging>
+ 
+  <modules>
+    <module>my-app</module>
+    <module>my-webapp</module>
+  </modules>
+</project>
+```
+
+我们需要从Web应用程序依赖JAR，所以将其添加到my-webapp/pom.xml中：
+
+```xml
+  ...
+  <dependencies>
+    <dependency>
+      <groupId>com.mycompany.app</groupId>
+      <artifactId>my-app</artifactId>
+      <version>1.0-SNAPSHOT</version>
+    </dependency>
+    ...
+  </dependencies>
+```
+
+最后，将下面的<parent>元素添加到子目录中的其他pom.xml文件中：
+
+```xml
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <parent>
+    <groupId>com.mycompany.app</groupId>
+    <artifactId>app</artifactId>
+    <version>1.0-SNAPSHOT</version>
+  </parent>
+  ...
+```
+
+现在，尝试一下...从顶层目录运行：
+
+```sh
+mvn verify
+```
+
+现在已经在my-webapp/target/my-webapp.war中创建了WAR ，并且包含了JAR：
+
+```sh
+$ jar tvf my-webapp/target/my-webapp-1.0-SNAPSHOT.war
+   0 Fri Jun 24 10:59:56 EST 2005 META-INF/
+ 222 Fri Jun 24 10:59:54 EST 2005 META-INF/MANIFEST.MF
+   0 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/
+   0 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/com.mycompany.app/
+   0 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/com.mycompany.app/my-webapp/
+3239 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/com.mycompany.app/my-webapp/pom.xml
+   0 Fri Jun 24 10:59:56 EST 2005 WEB-INF/
+ 215 Fri Jun 24 10:59:56 EST 2005 WEB-INF/web.xml
+ 123 Fri Jun 24 10:59:56 EST 2005 META-INF/maven/com.mycompany.app/my-webapp/pom.properties
+  52 Fri Jun 24 10:59:56 EST 2005 index.jsp
+   0 Fri Jun 24 10:59:56 EST 2005 WEB-INF/lib/
+2713 Fri Jun 24 10:59:56 EST 2005 WEB-INF/lib/my-app-1.0-SNAPSHOT.jar
+```
+
+这个怎么用？首先，创建的父POM（称为app）包含pom和定义的模块列表。这告诉Maven运行所有对项目集合的操作，而不仅仅是当前操作（重写此行为，可以使用--non-recursive命令行选项）。
+
+接下来，我们告诉WAR它需要my-app JAR。这样做有一些好处：它可以在类路径中使用WAR中的任何代码（在本例中为none），它确保JAR始终在WAR之前构建，并且指示WAR插件将JAR包含在它的库目录。
+
+你可能已经注意到junit-4.11.jar是一个依赖项，但并没有在WAR中结束。其原因是<scope> test </ scope>元素 - 它仅用于测试，因此不包含在Web应用程序中，因为编译时间依赖性my-app是。
+
+最后一步是包含父母定义。这与Maven 1.0中可能熟悉的扩展元素不同：这可以确保即使通过在存储库中查找项目与父项分开分发项目，也可以始终定位POM。
+
+## Super POM
+
+```xml
+<project>
+  <modelVersion>4.0.0</modelVersion>
+  <name>Maven Default Project</name>
+ 
+  <repositories>
+    <repository>
+      <id>central</id>
+      <name>Maven Repository Switchboard</name>
+      <layout>default</layout>
+      <url>http://repo1.maven.org/maven2</url>
+      <snapshots>
+        <enabled>false</enabled>
+      </snapshots>
+    </repository>
+  </repositories>
+ 
+  <pluginRepositories>
+    <pluginRepository>
+      <id>central</id>
+      <name>Maven Plugin Repository</name>
+      <url>http://repo1.maven.org/maven2</url>
+      <layout>default</layout>
+      <snapshots>
+        <enabled>false</enabled>
+      </snapshots>
+      <releases>
+        <updatePolicy>never</updatePolicy>
+      </releases>
+    </pluginRepository>
+  </pluginRepositories>
+ 
+  <build>
+    <directory>${project.basedir}/target</directory>
+    <outputDirectory>${project.build.directory}/classes</outputDirectory>
+    <finalName>${project.artifactId}-${project.version}</finalName>
+    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
+    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
+    <!-- TODO: MNG-3731 maven-plugin-tools-api < 2.4.4 expect this to be relative... -->
+    <scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>
+    <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
+    <resources>
+      <resource>
+        <directory>${project.basedir}/src/main/resources</directory>
+      </resource>
+    </resources>
+    <testResources>
+      <testResource>
+        <directory>${project.basedir}/src/test/resources</directory>
+      </testResource>
+    </testResources>
+   <pluginManagement>
+       <plugins>
+         <plugin>
+           <artifactId>maven-antrun-plugin</artifactId>
+           <version>1.3</version>
+         </plugin>       
+         <plugin>
+           <artifactId>maven-assembly-plugin</artifactId>
+           <version>2.2-beta-2</version>
+         </plugin>         
+         <plugin>
+           <artifactId>maven-clean-plugin</artifactId>
+           <version>2.2</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-compiler-plugin</artifactId>
+           <version>2.0.2</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-dependency-plugin</artifactId>
+           <version>2.0</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-deploy-plugin</artifactId>
+           <version>2.4</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-ear-plugin</artifactId>
+           <version>2.3.1</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-ejb-plugin</artifactId>
+           <version>2.1</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-install-plugin</artifactId>
+           <version>2.2</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-jar-plugin</artifactId>
+           <version>2.2</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-javadoc-plugin</artifactId>
+           <version>2.5</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-plugin-plugin</artifactId>
+           <version>2.4.3</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-rar-plugin</artifactId>
+           <version>2.2</version>
+         </plugin>        
+         <plugin>                
+           <artifactId>maven-release-plugin</artifactId>
+           <version>2.0-beta-8</version>
+         </plugin>
+         <plugin>                
+           <artifactId>maven-resources-plugin</artifactId>
+           <version>2.3</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-site-plugin</artifactId>
+           <version>2.0-beta-7</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-source-plugin</artifactId>
+           <version>2.0.4</version>
+         </plugin>         
+         <plugin>
+            <artifactId>maven-surefire-plugin</artifactId>
+            <version>2.4.3</version>
+         </plugin>
+         <plugin>
+           <artifactId>maven-war-plugin</artifactId>
+           <version>2.1-alpha-2</version>
+         </plugin>
+       </plugins>
+     </pluginManagement>
+  </build>
+ 
+  <reporting>
+    <outputDirectory>${project.build.directory}/site</outputDirectory>
+  </reporting>
+  <profiles>
+    <profile>
+      <id>release-profile</id>
+ 
+      <activation>
+        <property>
+          <name>performRelease</name>
+          <value>true</value>
+        </property>
+      </activation>
+ 
+      <build>
+        <plugins>
+          <plugin>
+            <inherited>true</inherited>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-source-plugin</artifactId>
+            <executions>
+              <execution>
+                <id>attach-sources</id>
+                <goals>
+                  <goal>jar</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+          <plugin>
+            <inherited>true</inherited>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-javadoc-plugin</artifactId>
+            <executions>
+              <execution>
+                <id>attach-javadocs</id>
+                <goals>
+                  <goal>jar</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+          <plugin>
+            <inherited>true</inherited>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-deploy-plugin</artifactId>
+            <configuration>
+              <updateReleaseInfo>true</updateReleaseInfo>
+            </configuration>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
+ 
+</project>
+```
+
+## Minimal POM
+
+POM 的最低要求如下:
+
+- 项目根
+- modelVersion - 应该设置为4.0.0
+- groupId - 项目组的标识。
+- artifactId - 工件的ID（项目）
+- 版本 - 指定组下的工件版本
+
+```xml
+<project>
+	  <modelVersion>4.0.0</modelVersion>
+	  <groupId>com.mycompany.app</groupId>
+	  <artifactId>my-app</artifactId>
+	  <version>1</version>
+</project>
+```
+
+> POM要求配置其groupId，artifactId和版本。这三个值构成项目完全限定的工件名称。这是<groupId>：<artifactId>：<version>的形式。至于上面的例子，其完全限定的工件名称是“com.mycompany.app:my-app:1”。
+
+> 另外，如第一部分所述，如果未指定配置详细信息，Maven将使用其默认值。其中一个默认值是包装类型。每个Maven项目都有一个包装类型。如果没有在POM中指定，那么将使用默认值“jar”。
+
+> 此外，正如你所看到的，在最小的POM中，存储库没有被指定。如果使用最小的POM构建项目，它将继承Super POM中的存储库配置。因此，当Maven在最小的POM中看到依赖关系时，它会知道这些依赖关系将从Super POM中指定的http://repo.maven.apache.org/maven2下载。
+
+
+## 项目继承
+
+POM 中合并的元素如下:
+
+- 依赖
+- 开发者和贡献者
+- 插件列表（包括报告）
+- 插件执行与匹配的ID
+- 插件配置
+- 资源
+
+#####案例一：子项目在父项目节点下
+
+```sh
+.
+ |-- my-module
+ |   `-- pom.xml
+ `-- pom.xml
+```
+
+子项目中添加 <parent\> 节点
+
+```xml
+<project>
+  <parent>
+    <groupId>com.mycompany.app</groupId>
+    <artifactId>my-app</artifactId>
+    <version>1</version>
+  </parent>
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-module</artifactId>
+  <version>1</version>
+</project>
+```
+
+因为府项目内帮我们管理了 groupId 及 version，所有上面的代码可简写为：
+
+```xml
+<project>
+  <parent>
+    <groupId>com.mycompany.app</groupId>
+    <artifactId>my-app</artifactId>
+    <version>1</version>
+  </parent>
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>my-module</artifactId>
+</project>
+```
+
+#####案例二：子项目不在父项目节点下
+
+	.
+	 |-- my-module
+	 |   `-- pom.xml
+	 `-- parent
+	     `-- pom.xml
+
+为了解决这个目录结构（或任何其他目录结构），我们必须将<relativePath>元素添加到我们的父节。
+
+```xml
+<project>
+  <parent>
+    <groupId>com.mycompany.app</groupId>
+    <artifactId>my-app</artifactId>
+    <version>1</version>
+    <relativePath>../parent/pom.xml</relativePath>
+  </parent>
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>my-module</artifactId>
+</project>
+```
+
+## 项目聚合
+
+项目聚合类似于项目继承。但不是从模块中指定父POM，而是从父POM指定模块。通过这样做，父项目现在知道它的模块，并且如果对父项目调用Maven命令，那么Maven命令也会执行到父项模块。要执行项目聚合，您必须执行以下操作：
+
+- 将父级POM包装更改为“pom”值。
+- 在父POM中指定其模块的目录（子POM）
+
+#### 案例一：子项目在父项目节点下
+
+	.
+	 |-- my-module
+	 |   `-- pom.xml
+	 `-- pom.xml
+
+如果我们要将我的模块聚合到我的应用程序中，我们只需要修改我的应用程序。
+
+```xml
+<project>
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-app</artifactId>
+  <version>1</version>
+  <packaging>pom</packaging>
+ 
+  <modules>
+    <module>my-module</module>
+  </modules>
+</project>
+```
+
+### 案例二：子项目不在父节点下
+
+	.
+	 |-- my-module
+	 |   `-- pom.xml
+	 `-- parent
+	     `-- pom.xml
+
+解决方案是指定模块的路径
+
+```xml
+<project>
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-app</artifactId>
+  <version>1</version>
+  <packaging>pom</packaging>
+ 
+  <modules>
+    <module>../my-module</module>
+  </modules>
+</project>
+```
+
+
+## 项目继承与项目聚合
+
+如果您有多个Maven项目，并且它们都具有相似的配置，则可以通过抽出相似的配置并制作父项目来重构项目。因此，您所要做的就是让您的Maven项目继承该父项目，然后将这些配置应用于所有这些项目。
+
+如果您有一组构建或一起处理的项目，您可以创建一个父项目并让该父项目将这些项目声明为其模块。通过这样做，您只需构建父级，其余的将随之而来。
+
+但是，当然，您可以同时拥有项目继承和项目聚合。意思是说，你可以让你的模块指定一个父项目，同时让这个父项目指定这些Maven项目作为它的模块。你只需要应用所有三条规则：
+
+- 在每个子POM中指定他们的父POM是谁。
+- 将父级POM <packaging\>更改为“pom”值。
+- 在父POM中指定其模块的目录（子POM）
+
+项目结构：
+
+	.
+	 |-- my-module
+	 |   `-- pom.xml
+	 `-- parent
+	     `-- pom.xml
+
+父项目：
+
+```xml
+<project>
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.mycompany.app</groupId>
+  <artifactId>my-app</artifactId>
+  <version>1</version>
+  <packaging>pom</packaging>
+ 
+  <modules>
+    <module>../my-module</module>
+  </modules>
+</project>
+```
+
+子项目：
+
+```xml
+<project>
+  <parent>
+    <groupId>com.mycompany.app</groupId>
+    <artifactId>my-app</artifactId>
+    <version>1</version>
+    <relativePath>../parent/pom.xml</relativePath>
+  </parent>
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>my-module</artifactId>
+</project>
+```
+
+## 项目插值和变量
+
+Maven鼓励的做法之一是不要重复自己。但是，在某些情况下，您需要在多个不同位置使用相同的值。为了帮助确保值仅指定一次，Maven允许您在POM中使用自己的和预定义的变量。
+
+例如，要访问project.version变量，可以这样引用它：
+
+ 	<version>${project.version}</version>
+
+> 需要注意的一个因素是，如上所述，继承后会处理这些变量。这意味着如果一个父项目使用一个变量，那么它在孩子中的定义，而不是父项，将是最终使用的定义。
+
+##### 可用变量
+###### 项目模型变量
+
+作为单个值元素的模型的任何字段都可以作为变量引用。例如，$ {project.groupId}，$ {project.version}，$ {project.build.sourceDirectory}等等。请参阅POM参考以查看完整的属性列表。
+
+这些变量都由前缀“project”引用。你也可以参照pom。作为前缀，或者完全省略前缀 - 这些表单现在已被弃用，不应使用。
+
+###### 特殊变量
+
+	project.basedir			当前项目所在的目录。
+	project.baseUri			当前项目所在的目录，表示为URI。由于Maven 2.1.0
+	maven.build.timestamp	表示构建开始的时间戳。由于Maven 2.1.0-M1
+
+构建时间戳的格式可以通过声明属性maven.build.timestamp.format来定制，如下例所示：
+
+```xml
+<project>
+  ...
+  <properties>
+    <maven.build.timestamp.format>yyyy-MM-dd'T'HH:mm:ss'Z'</maven.build.timestamp.format>
+  </properties>
+  ...
+</project>
+```
+
+> 格式模式必须符合SimpleDateFormat的API文档中给出的规则。如果该属性不存在，则格式默认为示例中已经给出的值。
+
+###### 属性
+
+您也可以将项目中定义的任何属性作为变量进行引用。考虑下面的例子：
+
+```xml
+<project>
+  ...
+  <properties>
+    <mavenVersion>2.1</mavenVersion>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-artifact</artifactId>
+      <version>${mavenVersion}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-project</artifactId>
+      <version>${mavenVersion}</version>
+    </dependency>
+  </dependencies>
+  ...
+</project>
+```
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/maven\351\205\215\347\275\256\346\226\207\344\273\266.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/maven\351\205\215\347\275\256\346\226\207\344\273\266.md"
new file mode 100644
index 0000000..617a300
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/maven\351\205\215\347\275\256\346\226\207\344\273\266.md"
@@ -0,0 +1,265 @@
+## .mvn 文件夹
+
+`.mvn`文件夹位于当前项目的根文件夹下面。该文件夹内可以包含`extensions.xml`、`maven.config`和`jvm.config`。
+
+### extensions.xml
+
+`extension.xml`用于定义maven项目启动所需的额外库。
+
+如果不适用这个文件的话，就需要将我们需要的jar包放在maven安装路径的`/lib/ext`目录下，或者使用`mvn -Dmaven.ext.class.path=extension.jar`的方式，总之这样很不方便。
+
+文件格式如下：
+
+```xml
+<extensions xmlns="http://maven.apache.org/EXTENSIONS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/EXTENSIONS/1.0.0 http://maven.apache.org/xsd/core-extensions-1.0.0.xsd">
+  <extension>
+    <groupId/>
+    <artifactId/>
+    <version/>
+  </extension>
+</extensions>
+```
+
+### maven.config
+
+`maven.config`文件可以存储在使用maven命令时，额外添加的选项，如`-T3 -U --fail-at-end`，我们使用以前的方式，就需要使用`mvn -T3 -U --fail-at-end clean package`。这样我们每次在执行maven命令时，可能就会忘记添加选项。`maven.config`就为我们解决了这种问题，通过将自定义选项配置到`maven.config`文件内，就不需要在每次执行命令时额外添加自定义选项，maven会自动帮我们加上。并且，这种方式，对于多模块化项目也是同样适用的。
+
+```sh
+-Drevision=2.0.0-SNAPSHOT -T3 -U --fail-at-end
+```
+
+### jvm.config
+
+`jvm.config`文件用于定义maven启动时jvm的选项，这意味着您可以在每个项目基础上定义构建选项。例如下面的配置：
+
+```
+-Xmx2048m -Xms1024m -XX:MaxPermSize=512m -Djava.awt.headless=true
+```
+
+这样，我们就不需要再配置`MAVEN_OPTS`、`.mavenrc`文件了。
+
+
+
+## settings.xml
+
+`settings.xml`用于自定义maven的配置，每个项目的`pom.xml`也可以用于配置maven，但是，`pom.xml`是只针对于单个项目的，而`settings.xml`中配置的属性是针对于全局。
+
+`settings.xml`文件存在于一下两个位置：
+
+* maven的安装目录：${maven.home}/conf/settings.xml
+* 用户目录：${user.home}/.m2/settings.xml
+
+如果以上两个文件同时存在，maven会合并两个文件中配置的值，如果遇到冲突的值，则用户目录下的配置优先于maven安装目录下的配置。
+
+### 简单属性
+
+**\<localRepository>${user.home}/.m2/repository\</localRepository>**：指定本地jar包存储的位置。
+
+**\<interactiveMode>true\</interactiveMode>**：是都可以和用户的输入进行交互。
+
+**\<offline>false\</offline>**：是否启用离线默认。
+
+### Plugin Groups
+
+此元素包含一个plugingroup元素列表，每个元素都包含一个groupid。当使用插件且命令行中未提供groupid时，将搜索该列表。此列表自动包含org.apache.maven.plugins和org.codehaus.mojo。
+
+```xml
+  <pluginGroups>
+    <pluginGroup>org.eclipse.jetty</pluginGroup>
+  </pluginGroups>
+```
+
+我们在命令行中执行`mvn org.eclipse.jetty:jetty-maven-plugin:run`，如果给定上面的配置，则可以修改为：`mvn jetty:run`
+
+### Servers
+
+用于下载和部署的存储库由POM的存储库和分发管理元素定义。但是，某些设置（如用户名和密码）不应与pom.xml一起分发。此类型的信息应存在于settings.xml中的生成服务器上。
+
+```xml
+<servers>
+    <server>
+      <id>server001</id>
+      <username>my_login</username>
+      <password>my_password</password>
+      <privateKey>${user.home}/.ssh/id_dsa</privateKey>
+      <passphrase>some_passphrase</passphrase>
+      <filePermissions>664</filePermissions>
+      <directoryPermissions>775</directoryPermissions>
+      <configuration></configuration>
+    </server>
+  </servers>
+```
+
+### Mirrors
+
+用于配置maven私服，如果没有配置，默认使用国外的中心仓库。
+
+```xml
+  <mirrors>
+    <mirror>
+      <id>planetmirror.com</id>
+      <name>PlanetMirror Australia</name>
+      <url>http://downloads.planetmirror.com/pub/maven2</url>
+      <mirrorOf>central</mirrorOf>
+    </mirror>
+  </mirrors>
+```
+
+**id, name**：当前镜像唯一的id和友好的名称，ID用于区分镜像元素，并在连接到镜像时从<servers>部分选择相应的凭据。
+
+**url**：此镜像的基URL。生成系统将使用此URL连接到存储库，而不是原始存储库URL。
+
+**mirrirOf**：这是其镜像的存储库的ID。例如，要指向maven中央存储库的镜像（https://repo.maven.apache.org/maven2/），请将此元素设置为central。更高级的映射，如repo1、repo2或*，！也可以使用。这不能与镜像ID匹配。
+
+### Proxies
+
+用于配置代理服务器
+
+```xml
+  <proxies>
+    <proxy>
+      <id>myproxy</id>
+      <active>true</active>
+      <protocol>http</protocol>
+      <host>proxy.somewhere.com</host>
+      <port>8080</port>
+      <username>proxyuser</username>
+      <password>somepassword</password>
+      <nonProxyHosts>*.google.com|ibiblio.org</nonProxyHosts>
+    </proxy>
+  </proxies>
+```
+
+**id**：当前代理唯一的id
+
+**active**：是否启用该代理
+
+**protocol**, **host**, **port**：protocol://host:port 
+
+**nonProxyHosts**：这是不应代理的主机列表。列表的分隔符是代理服务器的预期类型；上面的示例是管道分隔-逗号分隔也是常见的。
+
+### Profiles
+
+settings.xml中的profile元素是pom.xml profile元素的截断版本。它由激活、存储库、插件存储库和属性元素组成。配置文件元素只包含这四个元素，因为它们与整个构建系统（settings.xml文件的角色）有关，而与单个项目对象模型设置无关。
+
+如果一个配置文件在设置中处于活动状态，它的值将覆盖pom或profiles.xml文件中任何等同的id配置文件。
+
+#### Activation
+
+激活(activation)是配置文件(profiles)的关键。与POM的概要文件一样，概要文件的强大功能来自它仅在特定情况下修改某些值的能力；这些情况是通过激活元素指定的。
+
+```xml
+ <profiles>
+    <profile>
+      <id>test</id>
+      <activation>
+        <activeByDefault>false</activeByDefault>
+        <jdk>1.5</jdk>
+        <os>
+          <name>Windows XP</name>
+          <family>Windows</family>
+          <arch>x86</arch>
+          <version>5.1.2600</version>
+        </os>
+        <property>
+          <name>mavenVersion</name>
+          <value>2.0.3</value>
+        </property>
+        <file>
+          <exists>${basedir}/file2.properties</exists>
+          <missing>${basedir}/file1.properties</missing>
+        </file>
+      </activation>
+      ...
+    </profile>
+  </profiles>
+```
+
+activation在满足所有指定条件时启用，但并非同时需要所有条件。activation的条件有如下：
+
+* **jdk**：激活在JDK元素中有内置的、以Java为中心的检查。如果在与给定前缀匹配的JDK版本号下运行测试，则此选项将激活。在上面的示例中，1.5.0_06将匹配。从Maven 2.1开始也支持范围。
+* **os**：OS元素可以定义上面所示的一些操作系统特定的属性。
+* **property**：如果maven检测到相应name=value对的属性（一个可以在pom中被$name取消引用的值），配置文件将激活。
+* **file**：给定的文件名可以通过文件的存在来激活配置文件，或者如果文件丢失。
+
+activation元素并不是只有满足上面的任一条件的方式才能激活，也可以在命令行中使用`-P`参数指定profile的id的形式启用。如 `-P test`， 多个之间使用逗号分隔。
+
+#### Properties
+
+Maven属性是值占位符，类似于Ant中的属性。它们的值可以通过符号$x在POM中的任何位置访问，其中x是属性。它们有五种不同的样式，都可以从settings.xml文件访问：
+
+* **env.x**：在变量前加上“env.”将返回shell的环境变量。例如，${env.path}包含$path环境变量（Windows中为%path%）。
+* **project.x**:pom中的点（.）标记路径将包含相应元素的值。例如：\<project>\<version>1.0\<version>\<project>可以通过${project.version}获得。
+* settings.x:settings.xml中带点（.）符号的路径将包含相应元素的值。例如：\<settings>\<offline>false.\<offline>\<settings>可以通过${settings.offline}获得。
+* Java系统属性：通过java.lang.System.getProperties() 访问的所有属性都可用作POM属性，例如${java.home}
+* x：在\<properties/>元素或外部文件中设置，该值可以用作${somevar}。
+
+```xml
+  <profiles>
+    <profile>
+      ...
+      <properties>
+        <user.install>${user.home}/our-project</user.install>
+      </properties>
+      ...
+    </profile>
+  </profiles>
+```
+
+如果此配置文件处于活动状态，则可以从POM访问属性${user.install}
+
+#### Repositories
+
+存储库是Maven用来填充构建系统本地存储库的项目的远程集合。Maven就是从这个本地存储库中调用它的插件和依赖项的。不同的远程存储库可能包含不同的项目，在被激活的\<profile>下，可以搜索它们以查找匹配的版本或快照工件。主要用于将当前项目**部署到远程库**。
+
+```xml
+  <profiles>
+    <profile>
+      ...
+      <repositories>
+        <repository>
+          <id>codehausSnapshots</id>
+          <name>Codehaus Snapshots</name>
+          <releases>
+            <enabled>false</enabled>
+            <updatePolicy>always</updatePolicy>
+            <checksumPolicy>warn</checksumPolicy>
+          </releases>
+          <snapshots>
+            <enabled>true</enabled>
+            <updatePolicy>never</updatePolicy>
+            <checksumPolicy>fail</checksumPolicy>
+          </snapshots>
+          <url>http://snapshots.maven.codehaus.org/maven2</url>
+          <layout>default</layout>
+        </repository>
+      </repositories>
+      <pluginRepositories>
+        ...
+      </pluginRepositories>
+      ...
+    </profile>
+  </profiles>
+```
+
+* **releases**, **snapshots** : 这些是每种类型的工件、发布或快照的策略。有了这两个集合，POM就可以在单个存储库中独立地更改每种类型的策略。例如，可以决定只启用快照下载，可能是为了开发目的。
+* **enabled** : 是否启用相应的类型。
+* **updatePolicy** ： 此元素指定尝试更新的频率。Maven将本地POM的时间戳（存储在存储库的Maven元数据文件中）与远程POM进行比较。选项包括：始终(always)、每天(daily)（默认）、间隔：x (interval:X )（其中x是以分钟为单位的整数）或从不(never)。
+* **checksumPolicy** : 当Maven将文件部署到存储库时，它还部署相应的校验和文件。您的选项是忽略(ignore)、失败(fail)或警告丢失(warn on missing)或不正确(incorrect)的校验和。
+* **layout** : 在上面对存储库的描述中，提到它们都遵循一个公共布局。这基本上是正确的。Maven2有其存储库的默认布局；但是，Maven1.x有不同的布局。使用此元素指定它是默认的(default )还是传统的(legacy)。
+
+#### Plugin Repositories
+
+maven插件部署的仓库，内部元素类似于\<repositories>
+
+### Active Profiles
+
+```xml
+<activeProfiles>
+    <activeProfile>env-test</activeProfile>
+  </activeProfiles>
+```
+
+这包含一组\<activeProfile>元素，每个元素都有一个profile id的值。定义为\<activeProfile>的任何profile id都将处于活动状态，而不管环境设置如何。如果没有找到匹配的配置文件，则不会发生任何情况。
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\344\270\213\350\275\275jar\345\214\205.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\344\270\213\350\275\275jar\345\214\205.md"
new file mode 100644
index 0000000..21abd85
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\344\270\213\350\275\275jar\345\214\205.md"
@@ -0,0 +1,59 @@
+## 编写pom文件
+
+我们通过`pom.xml`文件来声明需要下载的jar包。
+
+`pom.xml`
+
+```xml
+<?xml version="1.0"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" 
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.feb13th</groupId>
+    <artifactId>download-jar</artifactId>
+    <version>1.0</version>
+    <dependencies>
+
+        <!-- 需要下载什么jar包 添加相应依赖 -->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>1.2.58</version>
+        </dependency>
+
+    </dependencies>
+</project>
+```
+
+## 执行命令
+
+在当前`pom`文件同级目录下打开命令行。
+
+输入如下命令下载jar
+
+```shell
+mvn -f pom.xml dependency:copy-dependencies
+```
+
+脚本执行完成后会在`./target/dependency/`目录下展示所有依赖的jar包文件。
+
+## 编写windows执行脚本
+
+我们可以将该命令封装为一个脚本，通过使用脚本的方式来下载jar。
+
+`run.bat`
+
+```
+call mvn -f pom.xml dependency:copy-dependencies
+@pause
+```
+
+项目结构为：
+
+```
+maven:
+	pom.xml
+	run.bat
+```
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\344\276\235\350\265\226war\345\214\205\351\241\271\347\233\256.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\344\276\235\350\265\226war\345\214\205\351\241\271\347\233\256.md"
new file mode 100644
index 0000000..f62ca40
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\344\276\235\350\265\226war\345\214\205\351\241\271\347\233\256.md"
@@ -0,0 +1,35 @@
+## 依赖war包项目
+
+在项目的开发过程中，多个项目之间可以存在依赖关系，而项目的打包格式都是`war`包，如果使用`jar`打包格式，就无法部署在web容器中。
+
+解决方案就是在项目打包时，同时打包一个`jar`包进行兼容。
+
+### 在被依赖项目中进行配置
+
+```xml
+<plugin>
+    <artifactId>maven-war-plugin</artifactId>
+    <version>3.2.1</version>
+    <configuration>
+        <!-- 通过配置该下方的属性进行打包为jar -->
+        <attachClasses>true</attachClasses>
+        <failOnMissingWebXml>false</failOnMissingWebXml>
+        <!-- 打包的jar的文件后缀 项目名-version-classifier.jar -->
+        <classifier>classes</classifier>
+    </configuration>
+</plugin>
+```
+
+### 依赖打包的jar
+
+```xml
+<dependency>
+    <groupId>com.**</groupId>
+    <artifactId>myserver-api</artifactId>
+    <version>${project.version}</version>
+    <type>jar</type>
+    <!-- 这里必须和被依赖项目的classifier一致 -->
+    <classifier>classes</classifier>
+</dependency>
+```
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\345\216\237\347\224\237\346\217\222\344\273\266\344\270\200\350\247\210\350\241\250.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\345\216\237\347\224\237\346\217\222\344\273\266\344\270\200\350\247\210\350\241\250.md"
new file mode 100644
index 0000000..e05addc
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\345\216\237\347\224\237\346\217\222\344\273\266\344\270\200\350\247\210\350\241\250.md"
@@ -0,0 +1,65 @@
+## Maven项目远程支持的插件
+
+### 1. 表格
+
+| **Plugin**                                                   | **Type\*** | **Version**   | **Release Date** | **Description**                                              | **Source Repository**                                        | **Issue Tracking**                                           |
+| :----------------------------------------------------------- | :--------- | :------------ | :--------------- | :----------------------------------------------------------- | :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **Core plugins**                                             |            |               |                  | **Plugins corresponding to default core phases (ie. clean, compile). They may have multiple goals as well.** |                                                              |                                                              |
+| [`clean`](https://maven.apache.org/plugins/maven-clean-plugin/) | B          | 3.1.0         | 2018-04-14       | Clean up after the build.                                    | [Git](https://gitbox.apache.org/repos/asf/maven-clean-plugin.git) / [GitHub](https://github.com/apache/maven-clean-plugin/) | [Jira MCLEAN](https://issues.apache.org/jira/browse/MCLEAN)  |
+| [`compiler`](https://maven.apache.org/plugins/maven-compiler-plugin/) | B          | 3.8.1         | 2019-04-28       | Compiles Java sources.                                       | [Git](https://gitbox.apache.org/repos/asf/maven-compiler-plugin.git) / [GitHub](https://github.com/apache/maven-compiler-plugin/) | [Jira MCOMPILER](https://issues.apache.org/jira/browse/MCOMPILER) |
+| [`deploy`](https://maven.apache.org/plugins/maven-deploy-plugin/) | B          | 3.0.0-M1      | 2018-09-23       | Deploy the built artifact to the remote repository.          | [Git](https://gitbox.apache.org/repos/asf/maven-deploy-plugin.git) / [GitHub](https://github.com/apache/maven-deploy-plugin/) | [Jira MDEPLOY](https://issues.apache.org/jira/browse/MDEPLOY) |
+| [`failsafe`](https://maven.apache.org/surefire/maven-failsafe-plugin/) | B          | 3.0.0-M3      | 2018-12-23       | Run the JUnit integration tests in an isolated classloader.  | [Git](https://gitbox.apache.org/repos/asf/maven-surefire.git) / [GitHub](https://github.com/apache/maven-surefire/) | [Jira SUREFIRE](https://issues.apache.org/jira/browse/SUREFIRE) |
+| [`install`](https://maven.apache.org/plugins/maven-install-plugin/) | B          | 3.0.0-M1      | 2018-09-23       | Install the built artifact into the local repository.        | [Git](https://gitbox.apache.org/repos/asf/maven-install-plugin.git) / [GitHub](https://github.com/apache/maven-install-plugin/) | [Jira MINSTALL](https://issues.apache.org/jira/browse/MINSTALL) |
+| [`resources`](https://maven.apache.org/plugins/maven-resources-plugin/) | B          | 3.1.0         | 2018-04-23       | Copy the resources to the output directory for including in the JAR. | [Git](https://gitbox.apache.org/repos/asf/maven-resources-plugin.git) / [GitHub](https://github.com/apache/maven-resources-plugin/) | [Jira MRESOURCES](https://issues.apache.org/jira/browse/MRESOURCES) |
+| [`site`](https://maven.apache.org/plugins/maven-site-plugin/) | B          | 3.8.2         | 2019-07-24       | Generate a site for the current project.                     | [Git](https://gitbox.apache.org/repos/asf/maven-site-plugin.git) / [GitHub](https://github.com/apache/maven-site-plugin/) | [Jira MSITE](https://issues.apache.org/jira/browse/MSITE)    |
+| [`surefire`](https://maven.apache.org/surefire/maven-surefire-plugin/) | B          | 3.0.0-M3      | 2018-12-23       | Run the JUnit unit tests in an isolated classloader.         | [Git](https://gitbox.apache.org/repos/asf/maven-surefire.git) / [GitHub](https://github.com/apache/maven-surefire/) | [Jira SUREFIRE](https://issues.apache.org/jira/browse/SUREFIRE) |
+| [`verifier`](https://maven.apache.org/plugins/maven-verifier-plugin/) | B          | 1.1           | 2015-04-14       | Useful for integration tests - verifies the existence of certain conditions. | [Git](https://gitbox.apache.org/repos/asf/maven-verifier-plugin.git) / [GitHub](https://github.com/apache/maven-verifier-plugin/) | [Jira MVERIFIER](https://issues.apache.org/jira/browse/MVERIFIER) |
+| **Packaging types/tools**                                    |            |               |                  | **These plugins relate to packaging respective artifact types.** |                                                              |                                                              |
+| [`ear`](https://maven.apache.org/plugins/maven-ear-plugin/)  | B          | 3.0.1         | 2018-05-09       | Generate an EAR from the current project.                    | [Git](https://gitbox.apache.org/repos/asf/maven-ear-plugin.git) / [GitHub](https://github.com/apache/maven-ear-plugin/) | [Jira MEAR](https://issues.apache.org/jira/browse/MEAR)      |
+| [`ejb`](https://maven.apache.org/plugins/maven-ejb-plugin/)  | B          | 3.0.1         | 2018-05-03       | Build an EJB (and optional client) from the current project. | [Git](https://gitbox.apache.org/repos/asf/maven-ejb-plugin.git) / [GitHub](https://github.com/apache/maven-ejb-plugin/) | [Jira MEJB](https://issues.apache.org/jira/browse/MEJB)      |
+| [`jar`](https://maven.apache.org/plugins/maven-jar-plugin/)  | B          | 3.1.2         | 2019-05-08       | Build a JAR from the current project.                        | [Git](https://gitbox.apache.org/repos/asf/maven-jar-plugin.git) / [GitHub](https://github.com/apache/maven-jar-plugin/) | [Jira MJAR](https://issues.apache.org/jira/browse/MJAR)      |
+| [`rar`](https://maven.apache.org/plugins/maven-rar-plugin/)  | B          | 2.4           | 2014-09-08       | Build a RAR from the current project.                        | [Git](https://gitbox.apache.org/repos/asf/maven-rar-plugin.git) / [GitHub](https://github.com/apache/maven-rar-plugin/) | [Jira MRAR](https://issues.apache.org/jira/browse/MRAR)      |
+| [`war`](https://maven.apache.org/plugins/maven-war-plugin/)  | B          | 3.2.3         | 2019-05-23       | Build a WAR from the current project.                        | [Git](https://gitbox.apache.org/repos/asf/maven-war-plugin.git) / [GitHub](https://github.com/apache/maven-war-plugin/) | [Jira MWAR](https://issues.apache.org/jira/browse/MWAR)      |
+| [`app-client/acr`](https://maven.apache.org/plugins/maven-acr-plugin/) | B          | 3.1.0         | 2018-06-19       | Build a JavaEE application client from the current project.  | [Git](https://gitbox.apache.org/repos/asf/maven-acr-plugin.git) / [GitHub](https://github.com/apache/maven-acr-plugin/) | [Jira MACR](https://issues.apache.org/jira/browse/MACR)      |
+| [`shade`](https://maven.apache.org/plugins/maven-shade-plugin/) | B          | 3.2.1         | 2018-11-12       | Build an Uber-JAR from the current project, including dependencies. | [Git](https://gitbox.apache.org/repos/asf/maven-shade-plugin.git) / [GitHub](https://github.com/apache/maven-shade-plugin/) | [Jira MSHADE](https://issues.apache.org/jira/browse/MSHADE)  |
+| [`source`](https://maven.apache.org/plugins/maven-source-plugin/) | B          | 3.1.0         | 2019-05-15       | Build a source-JAR from the current project.                 | [Git](https://gitbox.apache.org/repos/asf/maven-source-plugin.git) / [GitHub](https://github.com/apache/maven-source-plugin/) | [Jira MSOURCES](https://issues.apache.org/jira/browse/MSOURCES) |
+| [`jlink`](https://maven.apache.org/plugins/maven-jlink-plugin/) | B          | 3.0.0-alpha-1 | 2017-09-09       | Build Java Run Time Image.                                   | [Git](https://gitbox.apache.org/repos/asf/maven-jlink-plugin.git) / [GitHub](https://github.com/apache/maven-jlink-plugin/) | [Jira MJLINK](https://issues.apache.org/jira/browse/MJLINK)  |
+| [`jmod`](https://maven.apache.org/plugins/maven-jmod-plugin/) | B          | 3.0.0-alpha-1 | 2017-09-17       | Build Java JMod files.                                       | [Git](https://gitbox.apache.org/repos/asf/maven-jmod-plugin.git) / [GitHub](https://github.com/apache/maven-jmod-plugin/) | [Jira MJMOD](https://issues.apache.org/jira/browse/MJMOD)    |
+| **Reporting plugins**                                        |            |               |                  | **Plugins which generate reports, are configured as reports in the POM and run under the site generation lifecycle.** |                                                              |                                                              |
+| [`changelog`](https://maven.apache.org/plugins/maven-changelog-plugin/) | R          | 2.3           | 2014-06-24       | Generate a list of recent changes from your SCM.             | [Git](https://gitbox.apache.org/repos/asf/maven-changelog-plugin.git) / [GitHub](https://github.com/apache/maven-changelog-plugin/) | [Jira MCHANGELOG](https://issues.apache.org/jira/browse/MCHANGELOG) |
+| [`changes`](https://maven.apache.org/plugins/maven-changes-plugin/) | B+R        | 2.12.1        | 2016-11-01       | Generate a report from an issue tracker or a change document. | [Git](https://gitbox.apache.org/repos/asf/maven-changes-plugin.git) / [GitHub](https://github.com/apache/maven-changes-plugin/) | [Jira MCHANGES](https://issues.apache.org/jira/browse/MCHANGES) |
+| [`checkstyle`](https://maven.apache.org/plugins/maven-checkstyle-plugin/) | B+R        | 3.1.0         | 2019-05-20       | Generate a Checkstyle report.                                | [Git](https://gitbox.apache.org/repos/asf/maven-checkstyle-plugin.git) / [GitHub](https://github.com/apache/maven-checkstyle-plugin/) | [Jira MCHECKSTYLE](https://issues.apache.org/jira/browse/MCHECKSTYLE) |
+| [`doap`](https://maven.apache.org/plugins/maven-doap-plugin/) | B          | 1.2           | 2015-03-17       | Generate a Description of a Project (DOAP) file from a POM.  | [Git](https://gitbox.apache.org/repos/asf/maven-doap-plugin.git) / [GitHub](https://github.com/apache/maven-doap-plugin/) | [Jira MDOAP](https://issues.apache.org/jira/browse/MDOAP)    |
+| [`docck`](https://maven.apache.org/plugins/maven-docck-plugin/) | B          | 1.1           | 2015-04-03       | Documentation checker plugin.                                | [Git](https://gitbox.apache.org/repos/asf/maven-docck-plugin.git) / [GitHub](https://github.com/apache/maven-docck-plugin/) | [Jira MDOCCK](https://issues.apache.org/jira/browse/MDOCCK)  |
+| [`javadoc`](https://maven.apache.org/plugins/maven-javadoc-plugin/) | B+R        | 3.1.1         | 2019-07-08       | Generate Javadoc for the project.                            | [Git](https://gitbox.apache.org/repos/asf/maven-javadoc-plugin.git) / [GitHub](https://github.com/apache/maven-javadoc-plugin/) | [Jira MJAVADOC](https://issues.apache.org/jira/browse/MJAVADOC) |
+| [`jdeps`](https://maven.apache.org/plugins/maven-jdeps-plugin/) | B          | 3.1.2         | 2019-06-12       | Run JDK's JDeps tool on the project.                         | [Git](https://gitbox.apache.org/repos/asf/maven-jdeps-plugin.git) / [GitHub](https://github.com/apache/maven-jdeps-plugin/) | [Jira MJDEPS](https://issues.apache.org/jira/browse/MJDEPS)  |
+| [`jxr`](https://maven.apache.org/jxr/maven-jxr-plugin/)      | R          | 3.0.0         | 2018-09-25       | Generate a source cross reference.                           | [Git](https://gitbox.apache.org/repos/asf/maven-jxr.git) / [GitHub](https://github.com/apache/maven-jxr/) | [Jira JXR](https://issues.apache.org/jira/browse/JXR)        |
+| [`linkcheck`](https://maven.apache.org/plugins/maven-linkcheck-plugin/) | R          | 1.2           | 2014-10-08       | Generate a Linkcheck report of your project's documentation. | [Git](https://gitbox.apache.org/repos/asf/maven-linkcheck-plugin.git) / [GitHub](https://github.com/apache/maven-linkcheck-plugin/) | [Jira MLINKCHECK](https://issues.apache.org/jira/browse/MLINKCHECK) |
+| [`pmd`](https://maven.apache.org/plugins/maven-pmd-plugin/)  | B+R        | 3.12.0        | 2019-04-11       | Generate a PMD report.                                       | [Git](https://gitbox.apache.org/repos/asf/maven-pmd-plugin.git) / [GitHub](https://github.com/apache/maven-pmd-plugin/) | [Jira MPMD](https://issues.apache.org/jira/browse/MPMD)      |
+| [`project-info-reports`](https://maven.apache.org/plugins/maven-project-info-reports-plugin/) | R          | 3.0.0         | 2018-06-23       | Generate standard project reports.                           | [Git](https://gitbox.apache.org/repos/asf/maven-project-info-reports-plugin.git) / [GitHub](https://github.com/apache/maven-project-info-reports-plugin/) | [Jira MPIR](https://issues.apache.org/jira/browse/MPIR)      |
+| [`surefire-report`](https://maven.apache.org/surefire/maven-surefire-report-plugin/) | R          | 3.0.0-M3      | 2018-12-23       | Generate a report based on the results of unit tests.        | [Git](https://gitbox.apache.org/repos/asf/maven-surefire.git) / [GitHub](https://github.com/apache/maven-surefire/) | [Jira SUREFIRE](https://issues.apache.org/jira/browse/SUREFIRE) |
+| **Tools**                                                    |            |               |                  | **These are miscellaneous tools available through Maven by default.** |                                                              |                                                              |
+| [`antrun`](https://maven.apache.org/plugins/maven-antrun-plugin/) | B          | 1.8           | 2014-12-26       | Run a set of ant tasks from a phase of the build.            | [Git](https://gitbox.apache.org/repos/asf/maven-antrun-plugin.git) / [GitHub](https://github.com/apache/maven-antrun-plugin/) | [Jira MANTRUN](https://issues.apache.org/jira/browse/MANTRUN) |
+| [`archetype`](https://maven.apache.org/archetype/maven-archetype-plugin/) | B          | 3.1.2         | 2019-08-22       | Generate a skeleton project structure from an archetype.     | [Git](https://gitbox.apache.org/repos/asf/maven-archetype.git) / [GitHub](https://github.com/apache/maven-archetype/) | [Jira ARCHETYPE](https://issues.apache.org/jira/browse/ARCHETYPE) |
+| [`assembly`](https://maven.apache.org/plugins/maven-assembly-plugin/) | B          | 3.1.1         | 2019-01-02       | Build an assembly (distribution) of sources and/or binaries. | [Git](https://gitbox.apache.org/repos/asf/maven-assembly-plugin.git) / [GitHub](https://github.com/apache/maven-assembly-plugin/) | [Jira MASSEMBLY](https://issues.apache.org/jira/browse/MASSEMBLY) |
+| [`dependency`](https://maven.apache.org/plugins/maven-dependency-plugin/) | B+R        | 3.1.1         | 2018-05-19       | Dependency manipulation (copy, unpack) and analysis.         | [Git](https://gitbox.apache.org/repos/asf/maven-dependency-plugin.git) / [GitHub](https://github.com/apache/maven-dependency-plugin/) | [Jira MDEP](https://issues.apache.org/jira/browse/MDEP)      |
+| [`enforcer`](https://maven.apache.org/enforcer/maven-enforcer-plugin/) | B          | 3.0.0-M2      | 2018-06-16       | Environmental constraint checking (Maven Version, JDK etc), User Custom Rule Execution. | [Git](https://gitbox.apache.org/repos/asf/maven-enforcer.git) / [GitHub](https://github.com/apache/maven-enforcer/) | [Jira MENFORCER](https://issues.apache.org/jira/browse/MENFORCER) |
+| [`gpg`](https://maven.apache.org/plugins/maven-gpg-plugin/)  | B          | 1.6           | 2015-01-19       | Create signatures for the artifacts and poms.                | [Git](https://gitbox.apache.org/repos/asf/maven-gpg-plugin.git) / [GitHub](https://github.com/apache/maven-gpg-plugin/) | [Jira MGPG](https://issues.apache.org/jira/browse/MGPG)      |
+| [`help`](https://maven.apache.org/plugins/maven-help-plugin/) | B          | 3.2.0         | 2019-04-16       | Get information about the working environment for the project. | [Git](https://gitbox.apache.org/repos/asf/maven-help-plugin.git) / [GitHub](https://github.com/apache/maven-help-plugin/) | [Jira MPH](https://issues.apache.org/jira/browse/MPH)        |
+| [`invoker`](https://maven.apache.org/plugins/maven-invoker-plugin/) | B+R        | 3.2.1         | 2019-09-13       | Run a set of Maven projects and verify the output.           | [Git](https://gitbox.apache.org/repos/asf/maven-invoker-plugin.git) / [GitHub](https://github.com/apache/maven-invoker-plugin/) | [Jira MINVOKER](https://issues.apache.org/jira/browse/MINVOKER) |
+| [`jarsigner`](https://maven.apache.org/plugins/maven-jarsigner-plugin/) | B          | 3.0.0         | 2018-11-06       | Signs or verifies project artifacts.                         | [Git](https://gitbox.apache.org/repos/asf/maven-jarsigner-plugin.git) / [GitHub](https://github.com/apache/maven-jarsigner-plugin/) | [Jira MJARSIGNER](https://issues.apache.org/jira/browse/MJARSIGNER) |
+| [`jdeprscan`](https://maven.apache.org/plugins/maven-jdeprscan-plugin/) | B          | 3.0.0-alpha-1 | 2017-11-15       | Run JDK's JDeprScan tool on the project.                     | [Git](https://gitbox.apache.org/repos/asf/maven-jdeprscan-plugin.git) / [GitHub](https://github.com/apache/maven-jdeprscan-plugin/) | [Jira MJDEPRSCAN](https://issues.apache.org/jira/browse/MJDEPRSCAN) |
+| [`patch`](https://maven.apache.org/plugins/maven-patch-plugin/) | B          | 1.2           | 2015-03-09       | Use the gnu patch tool to apply patch files to source code.  | [Git](https://gitbox.apache.org/repos/asf/maven-patch-plugin.git) / [GitHub](https://github.com/apache/maven-patch-plugin/) | [Jira MPATCH](https://issues.apache.org/jira/browse/MPATCH)  |
+| [`pdf`](https://maven.apache.org/plugins/maven-pdf-plugin/)  | B          | 1.4           | 2017-12-28       | Generate a PDF version of your project's documentation.      | [Git](https://gitbox.apache.org/repos/asf/maven-pdf-plugin.git) / [GitHub](https://github.com/apache/maven-pdf-plugin/) | [Jira MPDF](https://issues.apache.org/jira/browse/MPDF)      |
+| [`plugin`](https://maven.apache.org/plugin-tools/maven-plugin-plugin/) | B+R        | 3.6.0         | 2018-11-01       | Create a Maven plugin descriptor for any mojos found in the source tree, to include in the JAR. | [Git](https://gitbox.apache.org/repos/asf/maven-plugin-tools.git) / [GitHub](https://github.com/apache/maven-plugin-tools/) | [Jira MPLUGIN](https://issues.apache.org/jira/browse/MPLUGIN) |
+| [`release`](https://maven.apache.org/plugins/maven-release-plugin/) | B          | 2.5.3         | 2015-10-17       | Release the current project - updating the POM and tagging in the SCM. | [Git](https://gitbox.apache.org/repos/asf/maven-release.git) / [GitHub](https://github.com/apache/maven-release/) | [Jira MRELEASE](https://issues.apache.org/jira/browse/MRELEASE) |
+| [`remote-resources`](https://maven.apache.org/plugins/maven-remote-resources-plugin/) | B          | 1.6.0         | 2018-10-31       | Copy remote resources to the output directory for inclusion in the artifact. | [Git](https://gitbox.apache.org/repos/asf/maven-remote-resources-plugin.git) / [GitHub](https://github.com/apache/maven-remote-resources-plugin/) | [Jira MRRESOURCES](https://issues.apache.org/jira/browse/MRRESOURCES) |
+| [`scm`](https://maven.apache.org/scm/maven-scm-plugin/)      | B          | 1.11.2        | 2019-03-21       | Execute SCM commands for the current project.                | [Git](https://gitbox.apache.org/repos/asf/maven-scm.git) / [GitHub](https://github.com/apache/maven-scm/) | [Jira SCM](https://issues.apache.org/jira/browse/SCM)        |
+| [`scm-publish`](https://maven.apache.org/plugins/maven-scm-publish-plugin/) | B          | 3.0.0         | 2018-01-29       | Publish your Maven website to a scm location.                | [Git](https://gitbox.apache.org/repos/asf/maven-scm-publish-plugin.git) / [GitHub](https://github.com/apache/maven-scm-publish-plugin/) | [Jira MSCMPUB](https://issues.apache.org/jira/browse/MSCMPUB) |
+| [`stage`](https://maven.apache.org/plugins/maven-stage-plugin/) | B          | 1.0           | 2015-03-03       | Assists with release staging and promotion.                  | [Git](https://gitbox.apache.org/repos/asf/maven-stage-plugin.git) / [GitHub](https://github.com/apache/maven-stage-plugin/) | [Jira MSTAGE](https://issues.apache.org/jira/browse/MSTAGE)  |
+| [`toolchains`](https://maven.apache.org/plugins/maven-toolchains-plugin/) | B          | 3.0.0         | 2019-06-16       | Allows to share configuration across plugins.                | [Git](https://gitbox.apache.org/repos/asf/maven-toolchains-plugin.git) / [GitHub](https://github.com/apache/maven-toolchains-plugin/) | [Jira MTOOLCHAINS](https://issues.apache.org/jira/browse/MTOOLCHAINS) |
+
+### 2. 引用
+
+[Available Plugins](https://maven.apache.org/plugins/index.html)
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\345\256\211\350\243\205\346\234\254\345\234\260jar\345\214\205\345\210\260\344\273\223\345\272\223.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\345\256\211\350\243\205\346\234\254\345\234\260jar\345\214\205\345\210\260\344\273\223\345\272\223.md"
new file mode 100644
index 0000000..4290cc0
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\345\256\211\350\243\205\346\234\254\345\234\260jar\345\214\205\345\210\260\344\273\223\345\272\223.md"
@@ -0,0 +1,43 @@
+## 安装到本地仓库
+
+```shell
+mvn install:install-file -Dfile=non-maven-proj.jar 
+						-DgroupId=some.group 
+						-DartifactId=non-maven-proj 
+						-Dversion=1 
+						-Dpackaging=jar
+```
+
+
+
+## 部署到私服
+
+settings.xml 中配置服务器信息
+
+```xml
+[...]
+    <server>
+      <id>internal.repo</id>
+      <username>maven</username>
+      <password>foobar</password>
+    </server>
+[...]
+```
+
+执行如下命令将本地jar包提交到私服
+
+```shell
+mvn deploy:deploy-file -Durl=file://C:\m2-repo \
+                       -DrepositoryId=服务器<id> \
+                       -Dfile=your-artifact-1.0.jar \
+                       [-DpomFile=your-pom.xml] \
+                       [-DgroupId=org.some.group] \
+                       [-DartifactId=your-artifact] \
+                       [-Dversion=1.0] \
+                       [-Dpackaging=jar] \
+                       [-Dclassifier=test] \
+                       [-DgeneratePom=true] \
+                       [-DgeneratePom.description="My Project Description"] \
+                       [-DrepositoryLayout=legacy]
+```
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\211\223\345\214\205\346\226\207\344\273\266\345\220\215\346\267\273\345\212\240\346\227\266\351\227\264\346\210\263.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\211\223\345\214\205\346\226\207\344\273\266\345\220\215\346\267\273\345\212\240\346\227\266\351\227\264\346\210\263.md"
new file mode 100644
index 0000000..36da517
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\211\223\345\214\205\346\226\207\344\273\266\345\220\215\346\267\273\345\212\240\346\227\266\351\227\264\346\210\263.md"
@@ -0,0 +1,48 @@
+## finalName配置时间属性
+
+### 通过原生方式获取时间戳
+
+maven提供了获取时间戳的方式，我们可以通过`${maven.build.timestamp}`获取当前打包时间的时间戳。
+
+如果我们需要将时间戳格式化，则需要在配置一下属性
+
+```xml
+<properties>
+	<maven.build.timestamp.format>yyyyMMddHHmmss</maven.build.timestamp.format>
+</properties>
+<finalName>
+  ${project.artifactId}-${project.version}_${maven.build.timestamp}
+</finalName>
+```
+
+
+
+### 通过第三方插件获取时间戳
+
+原生方式获取的格式化的时间戳有个问题：无法根据当前时区进行格式化，我们可以通过下面的插件进行实现。
+
+```xml
+<finalName>
+  ${project.artifactId}-${project.version}_${maven.build.time}
+</finalName>
+<plugin>
+    <groupId>org.codehaus.mojo</groupId>
+    <artifactId>build-helper-maven-plugin</artifactId>
+    <version>3.0.0</version>
+    <executions>
+        <execution>
+            <id>timestamp-property</id>
+            <goals>
+                <goal>timestamp-property</goal>
+            </goals>
+        </execution>
+    </executions>
+    <configuration>
+        <locale>zh_CN</locale>
+        <timeZone>GMT+8</timeZone>
+        <name>maven.build.time</name>
+        <pattern>${maven.build.timestamp.format}</pattern>
+    </configuration>
+</plugin>
+```
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\211\223\345\214\205\346\227\266\350\267\263\350\277\207\346\265\213\350\257\225.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\211\223\345\214\205\346\227\266\350\267\263\350\277\207\346\265\213\350\257\225.md"
new file mode 100644
index 0000000..49adaef
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\211\223\345\214\205\346\227\266\350\267\263\350\277\207\346\265\213\350\257\225.md"
@@ -0,0 +1,19 @@
+#### 原因
+
+默认情况下，执行`mvn compile`命令时，maven会默认执行所有在test目录下测试的脚本文件，如果存在测试脚本文件无法通过测试，则此次的打包就会失败
+
+#### 解决方案
+
+第一种解决方案：修改`pom.xml`文件，添加一下内容：
+
+```xml
+<plugin>
+    <groupId>org.apache.maven.plugins</groupId>
+    <artifactId>maven-surefire-plugin</artifactId>
+    <configuration>
+        <skip>true</skip>
+    </configuration>
+</plugin>
+```
+
+第二种解决方案：在执行`mvn compile`时添加`-Dmaven.test.skip=true`命令，这种方法不推荐，建议使用第一种。
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\227\240\346\263\225\350\257\206\345\210\253java\344\270\213\347\232\204\351\205\215\347\275\256\346\226\207\344\273\266.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\227\240\346\263\225\350\257\206\345\210\253java\344\270\213\347\232\204\351\205\215\347\275\256\346\226\207\344\273\266.md"
new file mode 100644
index 0000000..70a9443
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\346\227\240\346\263\225\350\257\206\345\210\253java\344\270\213\347\232\204\351\205\215\347\275\256\346\226\207\344\273\266.md"
@@ -0,0 +1,87 @@
+### 问题
+
+我们在`src/main/java`下添加了自定义的`xml`文件，当使用idea或maven进行编译时，`classes`目录下并没有包含指定的`xml`配置文件。
+
+### 问题原因
+
+maven默认认为`src/main/java`为`*.java`存储的目录，maven会使用`maven-compiler-plugin`插件编译该目录，将该目录下所有的`.java`文件编译为`.class`文件后，`src/main/java`文件夹就没有存在的必要了。maven在打包是会默认将`src/main/java`下的文件忽略。
+
+### 解决方案
+
+通过在`<build>`标签下使用`<resources>`标签手动更改`maven`的文件包含策略。
+
+#### 方案1、包含指定目录下的所有文件
+
+```xml
+<build>
+	<resources>
+        <!-- 指定包含 src/main/java 目录下的所有文件 -->
+		<resource>
+			<directory>src/main/java</directory>
+			<includes>
+				<include>**/*.*</include>
+			</includes>
+		</resource>
+        <!-- 指定包含 src/main/resources 目录下的所有文件 -->
+        <resource>
+			<directory>src/main/resources</directory>
+			<includes>
+				<include>**/*.*</include>
+			</includes>
+		</resource>
+	</resources>
+</build>
+```
+
+#### 方案2、包含指定目录下的指定类型的文件
+
+```xml
+<build>
+	<resources>
+        <!-- 指定包含 src/main/java 目录下的所有 .xml/.properties 文件 -->
+		<resource>
+			<directory>src/main/java</directory>
+			<includes>
+				<include>**/*.xml</include>
+                <include>**/*.properties</include>
+			</includes>
+		</resource>
+	</resources>
+</build>
+```
+
+#### 方案3、忽略指定目录下的文件（推荐）
+
+```xml
+<build>
+	<resources>
+        <!-- 指定包含 src/main/java 目录下的所有不是以 .java 结尾的文件 -->
+		<resource>
+			<directory>src/main/java</directory>
+			<excludes>
+				<exclude>**/*.java</exclude>
+			</excludes>
+		</resource>
+	</resources>
+</build>
+```
+
+
+
+### 包含 src/test/java 下的配置文件
+
+不同于`src/main/java`，如果要包含`src/test/java`下的文件则应该将`<resources>`、`<resource>`标签替换为`testResources`、`testResource`。`<includes>` `<excludes>`用法和`main`目录一致。如下：
+
+```xml
+<build>
+	<testResources>
+		<testResource>
+			<directory>src/test/java</directory>
+			<excludes>
+				<exclude>**/*.java</exclude>
+			</excludes>
+		</testResource>
+	</testResources>
+</build>
+```
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\273\237\344\270\200\347\256\241\347\220\206\347\211\210\346\234\254\345\217\267.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\273\237\344\270\200\347\256\241\347\220\206\347\211\210\346\234\254\345\217\267.md"
new file mode 100644
index 0000000..15dfe42
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\273\237\344\270\200\347\256\241\347\220\206\347\211\210\346\234\254\345\217\267.md"
@@ -0,0 +1,163 @@
+## 简介
+
+Maven 3.5.0版本提供了一种对`<version>`标签进行统一管理的特性。在此版本之前的maven项目并不支持这一特性
+
+现在可以在`<version>`标签中使用`${revision}`、`${sha1}`和`${changelist}`作为占位符。
+
+## 单个项目中使用
+
+```xml
+<project>
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.apache</groupId>
+        <artifactId>apache</artifactId>
+        <version>18</version>
+    </parent>
+    <groupId>org.apache.maven.ci</groupId>
+    <artifactId>ci-parent</artifactId>
+    <name>First CI Friendly</name>
+	<!-- 设置占位符 -->
+    <version>${revision}</version>
+    ...
+</project>
+```
+
+单个项目中的`<version>`标签中可以直接使用`${revision}`、`${sha1}`和`${changelist}`占位符。
+
+（1）执行`mvn`命令时可以手动指定环境变量来更改占位符的值。如：
+
+```sh
+mvn -Drevision=1.0.0-SNAPSHOT clean package
+```
+
+（2）当前项目的根目录下创建`.mvn`文件夹，并在该文件夹下创建`maven.config`文件，在该文件中配置我们在执行`mvn`命令时额外的参数，如：`.mvn/maven.config`
+
+```
+-Drevision=2.0.0-SNAPSHOT
+```
+
+通过编写上面的文件，我们可以直接使用命令，而无需指定手动指定占位符的值。
+
+```sh
+mvn clean package
+```
+
+（3）在`pom.xml`文件中设置`<properties>`标签，指定占位符的值。
+
+```xml
+<properties>
+    <revision>3.0-SNAPSHOT</revision>
+</properties>
+```
+
+**注：**`${revision}`、`${sha1}`和`${changelist}`可以单独使用，也可以混合使用。
+
+## 多模块项目中使用
+
+多模块项目中使用占位符和单模块项目中一致，父项目类似于：
+
+```xml
+<project>
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.apache</groupId>
+    <artifactId>apache</artifactId>
+    <version>18</version>
+  </parent>
+  <groupId>org.apache.maven.ci</groupId>
+  <artifactId>ci-parent</artifactId>
+  <name>First CI Friendly</name>
+  <version>${revision}</version>
+  ...
+  <properties>
+    <revision>1.0.0-SNAPSHOT</revision>
+  </properties>
+  <modules>
+    <module>child1</module>
+    ..
+  </modules>
+</project>
+```
+
+子项目类似于：
+
+```xml
+<project>
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.apache.maven.ci</groupId>
+    <artifactId>ci-parent</artifactId>
+    <version>${revision}</version>
+  </parent>
+  <groupId>org.apache.maven.ci</groupId>
+  <artifactId>ci-child</artifactId>
+   ...
+</project>
+```
+
+## 依赖
+
+在多模块项目中，经常会在模块之间互相定义依赖。定义依赖项及其相应版本的常用方法是使用`${project.version}`，并且此方法没有更改。如果尝试使用`${revision}`替代`${project.version}`，将会在构建时发生错误。
+
+子项目之间的依赖应该像下面这样：
+
+```xml
+<project>
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.apache.maven.ci</groupId>
+    <artifactId>ci-parent</artifactId>
+    <version>${revision}</version>
+  </parent>
+  <groupId>org.apache.maven.ci</groupId>
+  <artifactId>ci-child</artifactId>
+   ...
+  <dependencies>
+	<dependency>
+      <groupId>org.apache.maven.ci</groupId>
+      <artifactId>child2</artifactId>
+      <!-- 不能使用 ${revision} -->  
+      <version>${project.version}</version>
+    </dependency>
+  </dependencies>
+</project>
+```
+
+## Install / Deploy
+
+安装本地和发布到远程仓库，必须使用[flatten-maven-plugin](https://www.mojohaus.org/flatten-maven-plugin/)插件。否则安装到仓库的文件无法被maven使用。
+
+```xml
+<build>
+    <plugins>
+        <plugin>
+            <groupId>org.codehaus.mojo</groupId>
+            <artifactId>flatten-maven-plugin</artifactId>
+            <version>1.1.0</version>
+            <configuration>
+                <updatePomFile>true</updatePomFile>
+                <flattenMode>resolveCiFriendliesOnly</flattenMode>
+            </configuration>
+            <executions>
+                <execution>
+                    <id>flatten</id>
+                    <phase>process-resources</phase>
+                    <goals>
+                        <goal>flatten</goal>
+                    </goals>
+                </execution>
+                <execution>
+                    <id>flatten.clean</id>
+                    <phase>clean</phase>
+                    <goals>
+                        <goal>clean</goal>
+                    </goals>
+                </execution>
+            </executions>
+        </plugin>
+    </plugins>
+</build>
+```
+
+**注：**在使用该插件进行构建时，会在项目目录下增加`.flattened-pom.xml`文件，该文件为临时文件，在使用版本管理工具时，可以将该文件忽略。
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\274\226\347\240\201GBK\347\232\204\344\270\215\345\217\257\346\230\240\345\260\204\345\255\227\347\254\246.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\274\226\347\240\201GBK\347\232\204\344\270\215\345\217\257\346\230\240\345\260\204\345\255\227\347\254\246.md"
new file mode 100644
index 0000000..91ec684
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\274\226\347\240\201GBK\347\232\204\344\270\215\345\217\257\346\230\240\345\260\204\345\255\227\347\254\246.md"
@@ -0,0 +1,43 @@
+## maven错误解决：编码GBK的不可映射字符
+
+直接将项目改为UTF-8编码，无效！
+
+要通过修改pom.xml文件，告诉maven这个项目使用UTF-8来编译。
+
+## 方案一：
+
+在pom.xml的/project/build/plugins/下的编译插件声明中加入下面的配置：<encoding>UTF-8</encoding>
+
+即：
+
+```xml
+<plugin>
+    <groupId>org.apache.maven.plugins</groupId>	
+    <artifactId>maven-compiler-plugin</artifactId>
+    <version>3.1</version>
+    <configuration>
+        <source>1.7</source>
+        <target>1.7</target>
+        <encoding>UTF-8</encoding>
+    </configuration>
+</plugin>
+```
+
+### 方案二：
+
+在pom.xml的/project/properties/下的属性配置中加入下面的配置：
+
+<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+
+即：（有第一句即可）
+
+```xml
+<properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+</properties>
+```
+
+### 引用
+
+[maven错误解决：编码GBK的不可映射字符](https://blog.csdn.net/EvelynHouseba/article/details/16114353)
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\274\226\350\257\221\346\227\266\346\227\240\346\263\225\350\257\206\345\210\253com.sun\345\214\205.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\274\226\350\257\221\346\227\266\346\227\240\346\263\225\350\257\206\345\210\253com.sun\345\214\205.md"
new file mode 100644
index 0000000..8a9196d
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\347\274\226\350\257\221\346\227\266\346\227\240\346\263\225\350\257\206\345\210\253com.sun\345\214\205.md"
@@ -0,0 +1,36 @@
+### 问题
+
+项目中使用了`com.sun`包下的类，该包是sun公司不对外开源的代码。使用`mvn compile` 命令进行编译时报错:
+
+`javac uses a special symbol table that does not include all Sun-proprietary classes. When javac is compiling code it doesn't link against rt.jar by default. Instead it uses special symbol file lib/ct.sym with class stubs.`
+
+相应的java源码文件中也会出现红线。
+
+### 原因
+
+正如报错内容，javac默认编译代码时，并没有直接使用`rt.jar`文件，而是使用了一个特殊的符号表，这个符号表并没有包含所有sun私有化的class。使用这个特殊连接文件`lib/ct.sym`替换了`rt.jar`。
+
+### 解决方案
+
+我们需要通知maven编译插件忽略这个特殊的连接文件。所以我们需要在编译插件执行之前，传入`-XDignore.symbol.file` 命令，手动通知编译器忽略默认的连接文件，使用`rt.jar`。
+
+```xml
+<plugins>
+	<plugin>
+		<groupId>org.apache.maven.plugins</groupId>
+			<artifactId>maven-compiler-plugin</artifactId>
+            <version>${version}</version>
+            <configuration>
+                <source>1.8</source>
+                <target>1.8</target>
+                <!-- 添加启动命令，类似于 -->
+                <!-- javac -XDignore.symbol.file -->
+                <compilerArgs>
+                    <arg>-XDignore.symbol.file</arg>
+                </compilerArgs>
+                <fork>true</fork>
+            </configuration>
+    </plugin>
+</plugins>
+```
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\351\205\215\347\275\256\351\230\277\351\207\214\347\247\201\346\234\215\351\225\234\345\203\217.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\351\205\215\347\275\256\351\230\277\351\207\214\347\247\201\346\234\215\351\225\234\345\203\217.md"
new file mode 100644
index 0000000..5938a91
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/maven/\351\205\215\347\275\256\351\230\277\351\207\214\347\247\201\346\234\215\351\225\234\345\203\217.md"
@@ -0,0 +1,26 @@
+修改`user/.m2/settings.xml`添加mirror
+
+```xml
+ <settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
+  https://maven.apache.org/xsd/settings-1.0.0.xsd">
+  <localRepository/>
+  <interactiveMode/>
+  <offline/>
+  <pluginGroups/>
+  <servers/>
+  <mirrors>
+    <mirror>
+      <id>alimaven</id>
+      <name>aliyun maven</name>
+      　　<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
+      <mirrorOf>central</mirrorOf>        
+    </mirror>
+  </mirrors>
+  <proxies/>
+  <profiles/>
+  <activeProfiles/>
+</settings>
+```
+
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/svn/clean\346\217\220\347\244\272\345\205\210\345\211\215\347\232\204\346\223\215\344\275\234\346\234\252\347\273\223\346\235\237.md" "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/clean\346\217\220\347\244\272\345\205\210\345\211\215\347\232\204\346\223\215\344\275\234\346\234\252\347\273\223\346\235\237.md"
new file mode 100644
index 0000000..b5038dd
--- /dev/null
+++ "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/clean\346\217\220\347\244\272\345\205\210\345\211\215\347\232\204\346\223\215\344\275\234\346\234\252\347\273\223\346\235\237.md"
@@ -0,0 +1,46 @@
+## 问题
+
+svn执行`clean up`命令时报错:`Previous operation has not finished; run 'cleanup' if it was interrupted`。
+
+出现该问题时，即使将本地项目删除都无法解决这个问题。
+
+解决方案有两种:
+
+* 卸载SVN重新安装
+* 修改SVN数据库
+
+
+
+## 修改SVN数据库
+
+每个项目的根目录都存在一个`.svn`的隐藏文件夹，该文件夹下保存了SVN对于该项目的基础配置。
+
+解决上述问题的关键在于修改`.svn/wc.db`数据库，清空内部的`WORK_QUEUE`表。
+
+### 1、下载sqlite3客户端
+
+由于SVN使用的是`sqlite`数据库，所以我们需要使用`sqlite3.exe`这个客户端文件。该可执行文件可以直接百度下载。
+
+### 2、启动sqlite3客户端
+
+1、将下载好的`sqlite3.exe`复制到需要操作的项目的`.svn`目录下：
+
+![sqlite3存放目录](./images/001/01.png)
+
+2、在当前目录下使用`SHIFT + 鼠标右键`进入命令行。执行`sqlite3 wc.db`打开数据库
+
+![sqlite3打开数据库](./images/001/02.png)
+
+### 操作sqlite3数据库
+
+`.table`用于查看数据库内部的表
+
+![sqlite3打开数据库](./images/001/03.png)
+
+上图我们可以看到`WORK_QUEUE`表。
+
+执行`delete from work_queue;`命令清空所有任务
+
+![sqlite3打开数据库](./images/001/04.png)
+
+重新`clean up`，问题解决。
\ No newline at end of file
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/01.png" "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/01.png"
new file mode 100644
index 0000000..8717534
Binary files /dev/null and "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/01.png" differ
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/02.png" "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/02.png"
new file mode 100644
index 0000000..6da3208
Binary files /dev/null and "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/02.png" differ
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/03.png" "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/03.png"
new file mode 100644
index 0000000..96fe322
Binary files /dev/null and "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/03.png" differ
diff --git "a/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/04.png" "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/04.png"
new file mode 100644
index 0000000..84a2ac1
Binary files /dev/null and "b/\345\274\200\345\217\221\345\267\245\345\205\267/svn/images/001/04.png" differ
diff --git "a/\346\225\260\346\215\256\345\272\223/mysql\345\255\230\345\202\250\350\277\207\347\250\213.md" "b/\346\225\260\346\215\256\345\272\223/mysql\345\255\230\345\202\250\350\277\207\347\250\213.md"
new file mode 100644
index 0000000..e77f50c
--- /dev/null
+++ "b/\346\225\260\346\215\256\345\272\223/mysql\345\255\230\345\202\250\350\277\207\347\250\213.md"
@@ -0,0 +1,236 @@
+#### 创建存储过程语法
+
+```sql
+CREATE
+	[DEFINER = user] 
+	PROCEDURE sp_name ([proc_parameter[,...]])
+	[characteristic ...] routine_body
+```
+
+#### 创建函数语法
+
+```sql
+CREATE
+	[DEFINER = user]
+	FUNCTION sp_name ([func_parameter[,...]]) 
+	RETURNS type [characteristic ...] routine_body
+```
+
+#### 参数解释
+
+| 参数           | 格式                                                         |
+| -------------- | ------------------------------------------------------------ |
+| proc_parameter | [ IN \| OUT \|  INOUT ]   参数名   参数类型                  |
+| func_parameter | 参数名   参数类型                                            |
+| type           | 所有mysql支持的数据类型                                      |
+| characteristic | COMMENT 'string'<br />              \| LANGUAGE SQL<br />              \| [NOT] DETERMINISTIC <br />              \| { CONTAINS SQL <br />                         \|NO SQL <br />                         \|READS SQL DATA<br />                         \| MODIFIES SQL DATA}<br />              \| SQL SECURITY { DEFINER \| INVOKER } |
+| routine_body   | 常规SQL代码                                                  |
+
+每个存储过程或函数都应该有相应的数据库，如果设置想用的数据库则需要将名称修改为 db_name.sp_name.
+
+调用存储过程和函数需要使用 `CALL`
+
+参数列表必须存在**（）**，无论有没有参数
+
+每一个参数默认为**IN**输入参数，如果要指定其他类型，可以使用**OUT**或**INOUT**修饰在参数前。
+
+**注： **对于存储过程来说存在*IN*、*OUT*、*INOUT*， 但是对于函数来说，只存在*IN*
+
+*IN*参数对于存储过程是来时输入参数，存储过程可以修改该参数，但是当存储过程执行完成返回后，修改的参数值对外界并不可见。也就是说：外界看到的输入参数的值，还是原来调用存储过程之前的值，并看不过存储过程修改后的值。
+
+*OUT*是存储过程返回给调用者的参数。初始值为*NULL*，但是当存储过程执行完返回时，对于*OUT*参数的修改对外界是可见的。也就是说：外界看到的输出参数的值，在存储过程内部被修改后，外界该变量的值也跟着改变了。
+
+*INOUT*参数的初始化是由调用者处理的。该值即使输入参数也是输出参数，且存储过程对于该参数的修改对外界是可见的。
+
+**完整的存储过程例子**
+
+```sql
+mysql> delimiter //
+
+mysql> CREATE PROCEDURE simpleproc (OUT param1 INT)
+    -> BEGIN
+    ->   SELECT COUNT(*) INTO param1 FROM t;
+    -> END//
+Query OK, 0 rows affected (0.00 sec)
+
+mysql> delimiter ;
+
+mysql> CALL simpleproc(@a);
+Query OK, 0 rows affected (0.00 sec)
+
+mysql> SELECT @a;
++------+
+| @a   |
++------+
+| 3    |
++------+
+1 row in set (0.00 sec)
+```
+
+**delimiter**命令将MySQL的分隔符由**；**改为了**//**，这使得存储过程中使用的**；**可以传递给服务器，而不是由MySQL本身去解释。
+
+**returns**子句只能在函数体中使用。它声明了函数体的返回类型，并且函数体中必须存在**return value**语句。
+
+如果return 后面的value是其他的类型，则会被强制转换为 returns 指定的类型。
+
+**完整的函数的列子**
+
+```sql
+mysql> CREATE FUNCTION hello (s CHAR(20))
+mysql> RETURNS CHAR(50) DETERMINISTIC
+    -> RETURN CONCAT('Hello, ',s,'!');
+Query OK, 0 rows affected (0.00 sec)
+
+mysql> SELECT hello('world');
++----------------+
+| hello('world') |
++----------------+
+| Hello, world!  |
++----------------+
+1 row in set (0.00 sec)
+```
+
+在函数中没有必要使用**delimiter**将**；**改变为其他的分隔符，因为函数内部是不会包含分号的。
+
+MySQL允许在函数体中包含**DDL**语句，如*create*、*drop*等。同时也允许在存储过程中包含事务语句，如**commit**，但并不能在存储函数中包含事务语句。
+
+在存储过程和存储函数中不允许使用**USE**语句，但可以在存储过程或存储函数调用之前，显示的使用**USE db_name**来声明使用的数据库。
+
+**COMMENT**行为是MySQL扩展的，可以用来描述存储过程或存储函数，这些信息可以在**SHOW CREATE PROCEDURE**和**SHOW CREATE FUNCTION**语句执行后显示。
+
+**LANGUAGE**行为存储语句书写的语言。服务端会忽略这种行为，且服务端仅支持标准的”SQL“。
+
+如果一个例程总是为相同的输入参数生成相同的结果，那么它被认为是“**deterministic**确定性的”，否则被认为是“**not deterministic**不确定性的”（默认行为）。
+
+#### 声明语句结束符
+
+​	**delimiter $$** 将结束符替换为 **$$**
+
+​	默认的语句结束符为**；**，在存储过程中更改结束符时，尽量在结束时修改回来。
+
+#### 开始、结束符
+
+​	**begin**...**end**
+
+​	多个结束符之间可以嵌套，开始符和结束符前面可以加标签，如`[label:]begin...end[label]`
+
+#### 变量的定义及赋值
+
+​	变量声明使用如下格式
+
+​		`declare 变量名[,可定义多个] 数据类型 [default 默认值];`
+
+​	设置变量使用如下格式
+
+​		`set 变量名 = 表达式[,变量名 = 表达式...];`
+
+**用户变量**
+
+​	用户变量名一般以**@**开头
+
+​	用户变量的作用范围为整个用户区间，用户可以在**任何位置进行访问**，当然也不局限与多个存储过程访问
+
+​	如 proc_1 设置一个 @my_name 的用户变量，proc_2 访问 @my_name 变量，若proc_1先执行，则proc_2就可以获取到proc_1中定义的变量值
+
+​	禁止滥用用户变量，会导致程序难以理解及维护。
+
+#### 查询数据库中存在的存储过程
+
+* SELECT name FROM mysql.proc WHERE db = '数据库名';
+* SELECT routine_name FROM information_schema.routines WHERE routine_schema = '数据库名';
+* SHOW procedure status WHERE db = '数据库名';
+
+**查看存储过程详情**
+
+show procedure 数据库名.存储过程名
+
+**修改存储过程**
+
+alter procedure 数据库名.存储过程名
+
+**删除存储过程**
+
+drop procedure 数据库名.存储过程名
+
+#### 判断语句
+
+**if**
+
+```sql
+if 表达式 then
+	代码块
+else
+	代码块
+end if;
+```
+
+**case**
+
+```sql
+case 参数名
+when 参数值 then
+	代码块
+when 参数值 then
+	代码块
+end case;
+```
+
+#### 循环语句
+
+**while**
+
+```sql
+while 循环条件 do
+	代码块
+end while;
+```
+
+**repeat**
+
+```sql
+repeat
+	代码块
+util 循环条件
+end repeat;
+```
+
+**loop**
+
+loop循环没有循环条件，需要用户自己通过 **leave**关键字跳出循环
+
+```sql
+标签名:loop
+	代码块
+	if 表达式 then
+		leave 标签名；
+	end if;
+end loop;
+```
+
+**标签**
+
+​	标签可以用在 begin repeat while loop 语句前，格式为[标签名:]，标签只能在合法的语句前面使用。
+
+​	可以使用 **leave 标签名** 跳出循环，使指定达到复合语句的最后一步。
+
+​	也可以使用 **iterate 标签名** 引用复合语句标签来重复开始复合语句。
+
+#### 游标
+
+**步骤**
+
+1. 创建游标：`declare 游标名 cursor for select 语句；`
+2. 打开游标：`open 游标名;`
+3. 提取游标数据：`fetch 游标名 [into 变量1，变量2...];`每次提取一行数据。
+4. 关闭游标：`close 游标名;`
+
+#### 内部函数
+
+**found_row()** 与 **row_count()**
+
+* 这两个函数都是mysql中用于统计上一条sql语句影响的行数
+* **found_row()** 用于判断 **select** 语句得到的函数
+* **row_count()** 用于判断 **update** 或 **delete** 影响的函数。但是 **update** 前后置一样，**row_count()** 则为 **0**
+
+#### 最佳实践
+
diff --git "a/\346\225\260\346\215\256\345\272\223/mysql\345\274\202\345\270\270.md" "b/\346\225\260\346\215\256\345\272\223/mysql\345\274\202\345\270\270.md"
new file mode 100644
index 0000000..64da2f4
--- /dev/null
+++ "b/\346\225\260\346\215\256\345\272\223/mysql\345\274\202\345\270\270.md"
@@ -0,0 +1,79 @@
+（1）
+
+```java
+com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure
+```
+
+见名之意：超时，无法连接
+所以解决办法也很好办：
+
+``` properties
+#在my.ini中添加
+wait_timeout=1814400
+#(21*3600*24) 21天，修改等待超时时间。
+```
+
+（2）
+
+```java
+com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Data source rejected establishment of connection, message from server: "Too many connections"
+```
+
+原因：因为你的mysql安装目录下的my.ini中设定的并发连接数太少或者系统繁忙导致连接数被占满。
+解决方式： 
+打开MYSQL安装目录打开MY.INI找到max_connections（在大约第93行）默认是100 一般设到500～1000比较合适，重启mysql,这样1040错误就解决啦。 
+
+```properties
+max_connections=1000
+```
+
+（3）一直听大家说mysql是不区分大小写的，确实，在windows平台确实不区分大小写，可是一旦将程序移植到linux下，就有问题啦。因为在linux下mysql对大小写是敏感的。
+  解决方法：找到etc文件夹下的my.cnf配置文件，找到mysqld：
+
+```properties
+Lower_case_table_names=1
+```
+
+​    （让大小写不敏感）不同的数字表示不同的意思，大家如果想详细了解，可以自己上网查一下，在此不详述了。
+
+（4）往表中插入数据时出现：
+
+```java
+com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '£¬photo_url='photos/non.gif', phone='013901290001', id_type='?¨ª???¡è', id_num='' at line 1，
+```
+
+ 解决方法: 出现问题的SQL : 
+
+```sql
+insert into tb_process_form_attendance(runId,key)
+```
+
+key 为 MySQL 的关键词，需转义，使用 ``
+
+```sql
+insert into tb_process_form_attendance(runId,`key`)
+```
+
+（5）今天在写sql时遇到一个说在MySQL4.1中子查询是不能使用LIMIT的，手册中也明确指明 This version of MySQL doesn’t yet support ‘LIMIT & IN/ALL/ANY/SOME subquery。
+解决办法：这样的语句是不能正确执行的。 
+
+```sql
+select * from table where id in (select id from table limit 10);
+```
+
+但是，只要你再来一层就行。如：
+
+```sql
+select * from table where id in (select t.id from (select * from table limit 10)as t)
+```
+
+（6）
+
+```java
+not unique table/alias 
+```
+
+则 SQL 语句中出现了非唯一的表或别名。
+解决方法：
+1、请检查出现问题位置的 SQL 语句中是否使用了相同的表名，或是定义了相同的表别名。
+2、检查 SELECT 语句中要查询的字段名是不是定义重复，或者没有定义。
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\345\272\223/mysql\346\270\205\346\241\243.md" "b/\346\225\260\346\215\256\345\272\223/mysql\346\270\205\346\241\243.md"
new file mode 100644
index 0000000..f29d80a
--- /dev/null
+++ "b/\346\225\260\346\215\256\345\272\223/mysql\346\270\205\346\241\243.md"
@@ -0,0 +1,37 @@
+## 原因
+
+数据库在开发过程中使用了N张表， 同时由于测试，开发等过程产生了非常多的错误数据，因此需要对数据库中的所有表进行清空操作。如果直接手工对每个表指定**DELETE**或**truncate**错误，效率将会异常低下。
+
+
+
+## 清档步骤
+
+###  一：获取清表脚本
+
+执行如下脚本获取清表脚本, 需要将一下脚本中的数据库名替换为自己的库名
+
+```sql
+SELECT
+	CONCAT(
+		'truncate TABLE ',
+		table_schema,
+		'.',
+		TABLE_NAME,
+		';'
+	)
+FROM
+	INFORMATION_SCHEMA. TABLES
+WHERE
+	table_schema IN ('my_db_name');
+```
+
+生成的脚本如下：
+
+```sql
+truncate TABLE my_db_name.my_table_1;
+truncate TABLE my_db_name.my_table_2;
+```
+
+### 二：执行清表脚本
+
+在MYSQL客户端执行以上获取的清表脚本即可。
\ No newline at end of file
diff --git "a/\346\225\260\346\215\256\345\272\223/sql\345\237\272\347\241\200.md" "b/\346\225\260\346\215\256\345\272\223/sql\345\237\272\347\241\200.md"
new file mode 100644
index 0000000..068d10d
--- /dev/null
+++ "b/\346\225\260\346\215\256\345\272\223/sql\345\237\272\347\241\200.md"
@@ -0,0 +1,1170 @@
+## SQL简介
+
+### SQL是什么
+
+* SQL 指结构化查询语言
+* SQL 使我们有能力访问数据库
+* SQL 是一种 ANSI (美国国家标准化组织)的标准计算机语言
+
+### SQL能做什么
+
+* SQL面向数据库执行查询
+* SQL可从数据库取回数据
+* SQL可在数据库中插入新的记录
+* SQL可更新数据库中的数据
+* SQL可从数据库删除记录
+* SQL可创建新数据库
+* SQL可在数据库中创建新表
+* SQL可在数据库中创建存储过程
+* SQL可在数据库中创建视图
+* SQL可以设置表、存储过程和视图权限
+
+## SQL语法
+
+### DML数据操作语言
+
+* **SELECT** - 从数据库表中获取数据
+* **UPDATE** - 更新数据库表中的数据
+* **DELETE** - 从数据库表中删除数据
+* **INSERT INTO** - 向数据库表中插入数据
+
+### DDL 数据定义语言
+
+* **CREATE DATABASE** - 创建新数据库
+* **ALTER DATABASE** - 修改数据库
+* **CREATE TABLE** - 创建新表
+* **ALTER TABLE** - 变更（改变）数据库表
+* **DROP TABLE** - 删除表
+* **CREATE INDEX** - 创建索引（搜索键）
+* **DROP INDEX** - 删除索引
+
+### SQL select 语句
+
+```sql
+SELECT 列名称 FROM 表名称
+```
+
+以及
+
+```sql
+SELECT * FROM 表名称
+```
+星号(*****)是选取所有列的快捷方式
+
+### distinct
+
+**DISTINCT**用于返回唯一不同的值。（所有查询列的数据都不相同才会被当做唯一）
+
+```sql
+SELECT DISTINCT 列名称 FROM 表名称
+```
+
+### where 
+
+**WHERE**子句用于条件过滤
+
+```sql
+SELECT 列名称 FROM 表名称 WHERE 列 运算符 值
+```
+
+**运算符**
+
+| 操作符   | 描述         |
+| :------- | :----------- |
+| =        | 等于         |
+| <> 或 != | 不等于       |
+| >        | 大于         |
+| <        | 小于         |
+| >=       | 大于等于     |
+| <=       | 小于等于     |
+| BETWEEN  | 在某个范围内 |
+| LIKE     | 搜索某种模式 |
+
+
+SQL 使用单引号（**‘ ’**）来环绕**文本值**。如果是**数组**，请不要使用引号。
+
+### and & or
+
+```sql
+SELECT 列名 FROM 表名 WHERE 列 运算符 值 （AND | OR） 列 运算符 值 ...
+```
+
+* 只有**AND**连接的所有条件都成立时，才会显示记录
+* 只要**OR**连接的条件中有一个成立的，就会显示记录
+* **AND**优先级大于**OR**
+
+### order by
+
+```sql
+SELECT 列名 FROM 表名 ORDER BY 列名 （DESC）
+```
+
+* ORDER BY 语句用于根据指定的列队结果集进行排序
+* ORDER BY 语句默认按照升序对记录进行排序
+* **DESC** 可以使记录降序排序
+
+### insert
+
+INSERT INTO 语句用于向表格中插入新的行。
+
+```sql
+INSERT INTO 表名 VALUES (值1, 值2,...)
+```
+
+也可以指定所要插入数据的列
+
+```sql
+INSERT INTO 表名 (列1,列2,...) VALUES (值1, 值2,...)
+```
+
+### update
+
+UPDATE 语句用于修改表中的数据。
+
+```sql
+UPDATE 表名 SET 列名 = 新值 WHERE 列名 = 某值
+```
+
+### delete
+
+DELETE用于删除表中的行
+
+```sql
+DELETE FROM 表名 WHERE 列名 = 值
+```
+
+### limit
+
+limit在MySQL中用于分页查询
+
+```sql
+SELECT 列名 FROM 表名 LIMIT [开始的下标,]每页显示的数量
+```
+
+### like
+
+LIKE操作用于在WHERE子句中搜索列中的指定模式
+
+```sql
+SELECT 列名 FROM 表名 WHERE 列名 LIKE 匹配模式
+```
+
+**通配符**
+
+| 通配符                     | 描述                       |
+| :------------------------- | :------------------------- |
+| %                          | 替代一个或多个字符         |
+| _                          | 仅替代一个字符             |
+| [charlist]                 | 字符列中的任何单一字符     |
+| [^charlist]或者[!charlist] | 不在字符列中的任何单一字符 |
+
+### in
+
+IN 操作符允许我们在WHERE子句中规定多个值。
+
+```sql
+SELECT 列名 FROM 表名 WHERE 列名 IN (值1, 值2,...)
+```
+
+### between 
+
+操作符 BETWEEN ... AND 会选取介于两个值之间的数据范围。这些值可以是数值、文本或者日期。
+
+```sql
+SELECT 列名 FROM 表名 WHERE 列名 (NOT) BETWEEN 值1 AND 值2
+```
+
+* BETWEEN a AND b，包括a，但是不包括b
+* **NOT** 修饰符用于查询不在 between and 范围内的数据
+
+### alias（别名）
+
+SQL中使用 **AS** 关键字为表或字段设置别名，**AS** 可以省略
+
+```sql
+SELECT 列名 AS 列别名 FROM 表名 AS 表别名
+```
+
+### join
+
+**引用两张表**
+
+```sql
+SELECT 表1.字段1, 表2.字段2 FROM 表1, 表2 WHERE 表1.KEY = 表2.KEY
+```
+
+**join**
+
+```sql
+SELECT 表1.字段1, 表2.字段2 FROM 表1 INNER JOIN 表2 ON 表1.KEY = 表2.KEY
+```
+
+**join**不同类型
+
+* **JOIN** ：如果表中至少有一个匹配，则返回行
+* **LEFT JOIN** ：即使右表中没有匹配，也从左表返回所有的行
+* **RIGHT JOIN** ：即使左表中没有匹配，也从右表中返回所有的行
+* **INNER JOIN** ：左右表中同时匹配才返回行
+* **FULL JOIN** ：只要其中一个表中存在匹配，就返回行
+
+### union
+
+**UNION** 操作符用于合并两个或多个 **SELECT** 语句的结果集
+
+* UNION 内部的 SELECT 语句必须拥有**相同数量的列**。
+* 列也必须拥有相似的**数据类型**
+* 每条 SELECT 语句中的列的**顺序**必须相同
+* UNION 结果集中的列总是等于 UNION 中**第一个SELECT**语句中的列名
+
+**union 语法**
+
+```sql
+SELECT 列名 FROM 表1
+UNION
+SELECT 列名 FROM 表2
+```
+
+**UNION操作符会选取不同的值，相同的值则只留一条**
+
+**union all 语法**
+
+```sql
+SELECT 列名 FROM 表1
+UNION ALL
+SELECT 列名 FROM 表2
+```
+
+**UNION ALL操作符允许相同的数据存在**
+
+### select into
+
+SELECT INTO 语句可用于创建表的备份复件， SELECT INTO 语句从一个表中获取数据，然后把数据插入另一个表中。
+
+```sql
+SELECT 列名 
+INTO 新表名 [IN 其他的数据库]
+FROM 旧表名
+```
+
+* 可用于制作数据副本 **SELECT * INTO 备份表 FROM 原表**
+* 用带**WHERE**条件
+* 可进行**表关联**
+
+### create db
+
+```sql
+CREATE DATABASE 数据库名称
+```
+
+### create table 
+
+```sql
+CREATE TABLE 表名 
+(
+	列名1 数据类型,
+    列名2 数据类型,
+    列名3 数据类型,
+    ...
+)
+```
+
+**数据类型**
+
+| 数据类型                                          | 描述                                                         |
+| :------------------------------------------------ | :----------------------------------------------------------- |
+| integer(size)int(size)smallint(size)tinyint(size) | 仅容纳整数。在括号内规定数字的最大位数。                     |
+| decimal(size,d)numeric(size,d)                    | 容纳带有小数的数字。"size" 规定数字的最大位数。"d" 规定小数点右侧的最大位数。 |
+| char(size)                                        | 容纳固定长度的字符串（可容纳字母、数字以及特殊字符）。在括号中规定字符串的长度。 |
+| varchar(size)                                     | 容纳可变长度的字符串（可容纳字母、数字以及特殊的字符）。在括号中规定字符串的最大长度。 |
+| date(yyyymmdd)                                    | 容纳日期。                                                   |
+| datetime(yyyymmdd HH:MM:ss)                       | 容纳具体时间。                                               |
+
+### not null
+
+NOT NULL 约束强制列不接受 NULL 值
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255)
+)
+```
+
+### unique
+
+UNIQUE 约束唯一标识数据库表中的每条记录
+
+UNIQUE 和 PRIMARY KEY 约束均为列或列集合提供了唯一性的保证。
+
+PRIMARY KEY 拥有自动定义的 UNIQUE 约束。
+
+请注意，每个表可以有多个 UNIQUE 约束，但是每个表只能有一个 PRIMARY KEY 约束。
+
+**创建表时添加 unique 约束**
+
+*MySQl* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255),
+UNIQUE (Id_P)
+)
+```
+
+*SQL Server / Oracle / MS Access* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL UNIQUE,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255)
+)
+```
+
+如果要为多个列定义 UNIQUE 约束，并为该约束设置名称，可以使用 **CONSTRAINT** 关键字
+
+*MySQL / SQL Server / Oracle / MS Access* ：
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255),
+CONSTRAINT uc_PersonID UNIQUE (Id_P,LastName)
+)
+```
+
+**增加unique约束**
+
+当表已被创建时，如需在 "Id_P" 列创建 UNIQUE 约束，请使用下列 SQL：
+
+*MySQL / SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+ADD UNIQUE (Id_P)
+```
+
+如需命名 UNIQUE 约束，并定义多个列的 UNIQUE 约束，请使用下面的 SQL 语法：
+
+*MySQL / SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+ADD CONSTRAINT uc_PersonID UNIQUE (Id_P,LastName)
+```
+
+**删除unique约束**
+
+如需撤销 UNIQUE 约束，请使用下面的 SQL：
+
+*MySQL* :
+
+```sql
+ALTER TABLE Persons
+DROP INDEX uc_PersonID
+```
+
+*SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+DROP CONSTRAINT uc_PersonID
+```
+
+### primary key
+
+PRIMARY KEY 约束唯一标识数据库表中的每条记录。
+
+主键必须包含唯一的值。
+
+主键列不能包含 NULL 值。
+
+每个表都应该有一个主键，并且每个表只能有一个主键。
+
+**创建表时设置主键**
+
+*MySQL* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255),
+PRIMARY KEY (Id_P)
+)
+```
+
+*SQL Server / Oracle / MS Access* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL PRIMARY KEY,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255)
+)
+```
+
+如果需要命名 PRIMARY KEY 约束，以及为多个列定义 PRIMARY KEY 约束，请使用下面的 SQL 语法：
+
+*MySQL / SQL Server / Oracle / MS Access* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255),
+CONSTRAINT pk_PersonID PRIMARY KEY (Id_P,LastName)
+)
+```
+
+**增加主键约束**
+
+*MySQL / SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+ADD PRIMARY KEY (Id_P)
+```
+
+如果需要命名 PRIMARY KEY 约束，以及为多个列定义 PRIMARY KEY 约束，请使用下面的 SQL 语法：
+
+*MySQL / SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+ADD CONSTRAINT pk_PersonID PRIMARY KEY (Id_P,LastName)
+```
+
+**注释：**如果您使用 ALTER TABLE 语句添加主键，必须把主键列声明为不包含 NULL 值（在表首次创建时）
+
+**删除主键约束**
+
+*MySQL* :
+
+```sql
+ALTER TABLE Persons
+DROP PRIMARY KEY
+```
+
+*SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+DROP CONSTRAINT pk_PersonID
+```
+
+### check
+
+CHECK 约束用于限制列中的值的范围。
+
+如果对单个列定义 CHECK 约束，那么该列只允许特定的值。
+
+如果对一个表定义 CHECK 约束，那么此约束会在特定的列中对值进行限制。
+
+**创建表时增加check约束**
+
+*My SQL* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255),
+CHECK (Id_P>0)
+)
+```
+
+*SQL Server / Oracle / MS Access* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL CHECK (Id_P>0),
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255)
+)
+```
+
+如果需要命名 CHECK 约束，以及为多个列定义 CHECK 约束，请使用下面的 SQL 语法：
+
+*MySQL / SQL Server / Oracle / MS Access* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255),
+CONSTRAINT chk_Person CHECK (Id_P>0 AND City='Sandnes')
+)
+```
+
+**增加check约束**
+
+*MySQL / SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+ADD CHECK (Id_P>0)
+```
+
+如果需要命名 CHECK 约束，以及为多个列定义 CHECK 约束，请使用下面的 SQL 语法：
+
+*MySQL / SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+ADD CONSTRAINT chk_Person CHECK (Id_P>0 AND City='Sandnes')
+```
+
+**删除check约束**
+
+*SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+DROP CONSTRAINT chk_Person
+```
+
+*MySQL* :
+
+```sql
+ALTER TABLE Persons
+DROP CHECK chk_Person
+```
+
+### default
+
+DEFAULT 约束用于向列中插入默认值。
+
+如果没有规定其他的值，那么会将默认值添加到所有的新记录。
+
+**创建表时设置默认值**
+
+*My SQL / SQL Server / Oracle / MS Access* :
+
+```sql
+CREATE TABLE Persons
+(
+Id_P int NOT NULL,
+LastName varchar(255) NOT NULL,
+FirstName varchar(255),
+Address varchar(255),
+City varchar(255) DEFAULT 'Sandnes'
+)
+```
+
+通过使用类似 GETDATE() 这样的函数，DEFAULT 约束也可以用于插入系统值：
+
+```sql
+CREATE TABLE Orders
+(
+Id_O int NOT NULL,
+OrderNo int NOT NULL,
+Id_P int,
+OrderDate date DEFAULT GETDATE()
+)
+```
+
+**增加默认值**
+
+*MySQL* :
+
+```sql
+ALTER TABLE Persons
+ALTER City SET DEFAULT 'SANDNES'
+```
+
+*SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+ALTER COLUMN City SET DEFAULT 'SANDNES'
+```
+
+**删除默认值**
+
+*MySQL* :
+
+```sql
+ALTER TABLE Persons
+ALTER City DROP DEFAULT
+```
+
+*SQL Server / Oracle / MS Access* :
+
+```sql
+ALTER TABLE Persons
+ALTER COLUMN City DROP DEFAULT
+```
+
+### create index
+
+CREATE INDEX 语句用于在表中创建索引。
+
+在不读取整个表的情况下，索引使数据库应用程序可以更快的查找数据
+
+更新一个包含索引的表需要比更新一个没有索引的表要花费更多的时间，这是由于索引本身也需要更新。
+
+因此，理想的做法是仅在常被搜索的列(以及表)上面创建索引。
+
+**简单索引**
+
+```sql
+CREATE INDEX index_name
+ON table_name (column_name)
+```
+
+**唯一性索引**
+
+唯一性索引意味着两个行不能拥有相同的索引值
+
+```sql
+CREATE UNIQUE INDEX index_name
+ON table_name (column_name)
+```
+
+### drop
+
+使用 drop 语句，可以删除索引、表和数据库
+
+**删除索引**
+
+*用于 Microsoft SQLJet (以及 Microsoft Access) 的语法* :
+
+```sql
+DROP INDEX index_name ON table_name
+```
+
+*用于 MS SQL Server 的语法* :
+
+```sql
+DROP INDEX table_name.index_name
+```
+
+*用于 IBM DB2 和 Oracle 语法* :
+
+```sql
+DROP INDEX index_name
+```
+
+*用于 MySQL 的语法* :
+
+```sql
+ALTER TABLE table_name DROP INDEX index_name
+```
+
+**删除表**
+
+```sql
+DROP TABLE 表名
+```
+
+**删除数据库**
+
+```sql
+DROP DATABASE 数据库名称
+```
+
+**清空表中数据，但是不删除表**
+
+```sql
+TRUNCATE TABLE 表名称
+```
+
+### alter
+
+如需在表中添加列，请使用下列语法:
+
+```sql
+ALTER TABLE table_name
+ADD column_name datatype
+```
+
+要删除表中的列，请使用下列语法：
+
+```sql
+ALTER TABLE table_name 
+DROP COLUMN column_name
+```
+
+**注释：**某些数据库系统不允许这种在数据库表中删除列的方式 (DROP COLUMN column_name)。
+
+要改变表中列的数据类型，请使用下列语法：
+
+```sql
+ALTER TABLE table_name
+ALTER COLUMN column_name datatype
+```
+
+### increment
+
+MySQL 使用 **AUTO_INCREMENT** 关键字来执行 auto-increment 任务。
+
+默认地，AUTO_INCREMENT 的开始值是 1，每条新记录递增 1。
+
+要让 AUTO_INCREMENT 序列以其他的值起始，请使用下列 SQL 语法：
+
+```sql
+ALTER TABLE Persons AUTO_INCREMENT=100
+```
+
+MS SQL/SQL Server 使用 IDENTITY 关键字来执行 auto-increment 任务。
+
+默认地，IDENTITY 的开始值是 1，每条新记录递增 1。
+
+要规定 "P_Id" 列以 20 起始且递增 10，请把 identity 改为 IDENTITY(20,10)
+
+### view
+
+在 SQL 中，视图是基于 SQL 语句的结果集的可视化的表。
+
+视图包含行和列，就像一个真实的表。视图中的字段就是来自一个或多个数据库中的真实的表中的字段。我们可以向视图添加 SQL 函数、WHERE 以及 JOIN 语句，我们也可以提交数据，就像这些来自于某个单一的表。
+
+**注释：**数据库的设计和结构不会受到视图中的函数、where 或 join 语句的影响。
+
+**创建视图**
+
+```
+CREATE VIEW view_name AS
+SELECT column_name(s)
+FROM table_name
+WHERE condition
+```
+
+**注释：**视图总是显示最近的数据。每当用户查询视图时，数据库引擎通过使用 SQL 语句来重建数据。
+
+**更新视图**
+
+```sql
+CREATE OR REPLACE VIEW view_name AS
+SELECT column_name(s)
+FROM table_name
+WHERE condition
+```
+
+**删除视图**
+
+```sql
+DROP VIEW view_name
+```
+
+### date
+
+MySQL 使用下列数据类型在数据库中存储日期或日期/时间值：
+
+- DATE - 格式 YYYY-MM-DD
+- DATETIME - 格式: YYYY-MM-DD HH:MM:SS
+- TIMESTAMP - 格式: YYYY-MM-DD HH:MM:SS
+- YEAR - 格式 YYYY 或 YY
+
+下面的表格列出了 MySQL 中最重要的内建日期函数：
+
+| 函数          | 描述                                |
+| :------------ | :---------------------------------- |
+| NOW()         | 返回当前的日期和时间                |
+| CURDATE()     | 返回当前的日期                      |
+| CURTIME()     | 返回当前的时间                      |
+| DATE()        | 提取日期或日期/时间表达式的日期部分 |
+| EXTRACT()     | 返回日期/时间按的单独部分           |
+| DATE_ADD()    | 给日期添加指定的时间间隔            |
+| DATE_SUB()    | 从日期减去指定的时间间隔            |
+| DATEDIFF()    | 返回两个日期之间的天数              |
+| DATE_FORMAT() | 用不同的格式显示日期/时间           |
+
+**实例表**
+
+| OrderId | ProductName | OrderDate               |
+| :------ | :---------- | :---------------------- |
+| 1       | 'Computer'  | 2008-12-29 16:25:46.635 |
+
+**DATE(date)**
+
+```sql
+SELECT ProductName, DATE(OrderDate) AS OrderDate
+FROM Orders
+WHERE OrderId=1
+```
+
+结果：
+
+| ProductName | OrderDate  |
+| :---------- | :--------- |
+| 'Computer'  | 2008-12-29 |
+
+**EXTRACT(unit FROM date)**
+
+*date* 参数是合法的日期表达式。*unit* 参数可以是下列的值：
+
+| Unit 值            |
+| :----------------- |
+| 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         |
+
+```sql
+SELECT EXTRACT(YEAR FROM OrderDate) AS OrderYear,
+EXTRACT(MONTH FROM OrderDate) AS OrderMonth,
+EXTRACT(DAY FROM OrderDate) AS OrderDay
+FROM Orders
+WHERE OrderId=1
+```
+
+结果：
+
+| OrderYear | OrderMonth | OrderDay |
+| :-------- | :--------- | :------- |
+| 2008      | 12         | 29       |
+
+**DATE_ADD(date,INTERVAL expr type)**
+
+*date* 参数是合法的日期表达式。*expr* 参数是您希望添加的时间间隔。type 参照 EXTRACT() 函数的 unit
+
+```
+SELECT OrderId,DATE_ADD(OrderDate,INTERVAL 2 DAY) AS OrderPayDate
+FROM Orders
+```
+
+结果：
+
+| OrderId | OrderPayDate            |
+| :------ | :---------------------- |
+| 1       | 2008-12-31 16:25:46.635 |
+
+**DATEDIFF(date1,date2)**
+*date1* 和 *date2* 参数是合法的日期或日期/时间表达式。
+
+**注释：**只有值的日期部分参与计算。
+
+**DATE_FORMAT(date,format)**
+
+*date* 参数是合法的日期。*format* 规定日期/时间的输出格式。
+
+可以使用的格式有：
+
+| 格式 | 描述                                           |
+| :--- | :--------------------------------------------- |
+| %a   | 缩写星期名                                     |
+| %b   | 缩写月名                                       |
+| %c   | 月，数值                                       |
+| %D   | 带有英文前缀的月中的天                         |
+| %d   | 月的天，数值(00-31)                            |
+| %e   | 月的天，数值(0-31)                             |
+| %f   | 微秒                                           |
+| %H   | 小时 (00-23)                                   |
+| %h   | 小时 (01-12)                                   |
+| %I   | 小时 (01-12)                                   |
+| %i   | 分钟，数值(00-59)                              |
+| %j   | 年的天 (001-366)                               |
+| %k   | 小时 (0-23)                                    |
+| %l   | 小时 (1-12)                                    |
+| %M   | 月名                                           |
+| %m   | 月，数值(00-12)                                |
+| %p   | AM 或 PM                                       |
+| %r   | 时间，12-小时（hh:mm:ss AM 或 PM）             |
+| %S   | 秒(00-59)                                      |
+| %s   | 秒(00-59)                                      |
+| %T   | 时间, 24-小时 (hh:mm:ss)                       |
+| %U   | 周 (00-53) 星期日是一周的第一天                |
+| %u   | 周 (00-53) 星期一是一周的第一天                |
+| %V   | 周 (01-53) 星期日是一周的第一天，与 %X 使用    |
+| %v   | 周 (01-53) 星期一是一周的第一天，与 %x 使用    |
+| %W   | 星期名                                         |
+| %w   | 周的天 （0=星期日, 6=星期六）                  |
+| %X   | 年，其中的星期日是周的第一天，4 位，与 %V 使用 |
+| %x   | 年，其中的星期一是周的第一天，4 位，与 %v 使用 |
+| %Y   | 年，4 位                                       |
+| %y   | 年，2 位                                       |
+
+```sql
+DATE_FORMAT(NOW(),'%b %d %Y %h:%i %p')
+DATE_FORMAT(NOW(),'%m-%d-%Y')
+DATE_FORMAT(NOW(),'%d %b %y')
+DATE_FORMAT(NOW(),'%d %b %Y %T:%f')
+```
+
+结果类似：
+
+```sql
+Dec 29 2008 11:45 PM
+12-29-2008
+29 Dec 08
+29 Dec 2008 16:25:46.635
+```
+
+### null
+
+如果表中的某个列是可选的，那么我们可以在不向该列添加值的情况下插入新记录或更新已有的记录。这意味着该字段将以 NULL 值保存。
+
+NULL 值不能使用比较运算符，如 = ， < 或者 <>， 只能使用 IS NULL 和 IS NOT NULL 操作符
+
+**ISNULL(列名, 默认值)** 为 SQLServer 提供的处理 NULL 值的函数
+
+**IFNULL(列名, 默认值)** 为 MySQL 提供的处理 NULL 的函数
+
+### for update
+
+**场景**
+
+存在**高并发**，并且对于数据的**准确性**很有要求的场景
+
+**原则**
+
+一锁二判三更新
+
+**使用方式**
+
+```sql
+SELECT * FROM TABLE WHERE xxx FOR UPDATE
+```
+
+**锁级别**
+
+* InnoDB默认是行级别的锁
+* 有明确指定的主键时为行级别的锁，否则为表级别
+
+**注：**
+
+* for update 仅适用于InnoDB，并且必须开启事务，在begin与commit之间才生效。
+* 要测试for update的锁表情况，可以利用MySQL的Command Mode，开启二个视窗来做测试。
+
+## SQL函数
+
+### function
+
+**函数的语法**
+
+内建 SQL 函数的语法是：
+
+```
+SELECT function(列) FROM 表
+```
+
+**函数的类型**
+
+在 SQL 中，基本的函数类型和种类有若干种。函数的基本类型是：
+
+- Aggregate 函数
+- Scalar 函数
+
+**合计函数（Aggregate functions）**
+
+Aggregate 函数的操作面向一系列的值，并返回一个单一的值。
+
+**注释：**如果在 SELECT 语句的项目列表中的众多其它表达式中使用 SELECT 语句，则这个 SELECT 必须使用 GROUP BY 语句！
+
+**Scalar 函数**
+
+Scalar 函数的操作面向某个单一的值，并返回基于输入值的一个单一的值。
+
+### avg()
+
+AVG 函数返回数值列的平均值。NULL 值不包括在计算中。
+
+```sql
+SELECT AVG(column_name) FROM table_name
+```
+
+### count()
+
+**SQL COUNT(column_name) 语法**
+
+COUNT(column_name) 函数返回指定列的值的数目（NULL 不计入）：
+
+```sql
+SELECT COUNT(column_name) FROM table_name
+```
+
+**SQL COUNT(*) 语法**
+
+COUNT(*) 函数返回表中的记录数：
+
+```sql
+SELECT COUNT(*) FROM table_name
+```
+
+**SQL COUNT(DISTINCT column_name) 语法**
+
+COUNT(DISTINCT column_name) 函数返回指定列的不同值的数目：
+
+```sql
+SELECT COUNT(DISTINCT column_name) FROM table_name
+```
+
+**注释：**COUNT(DISTINCT) 适用于 ORACLE 和 Microsoft SQL Server，但是无法用于 Microsoft Access。
+
+### first()
+
+FIRST() 函数返回指定的字段中第一个记录的值。
+
+**提示：**可使用 ORDER BY 语句对记录进行排序。
+
+**SQL FIRST() 语法**
+
+```sql
+SELECT FIRST(column_name) FROM table_name
+```
+
+### last()
+
+LAST() 函数返回指定的字段中最后一个记录的值。
+
+**提示：**可使用 ORDER BY 语句对记录进行排序。
+
+**SQL LAST() 语法**
+
+```sql
+SELECT LAST(column_name) FROM table_name
+```
+
+### max()、min()
+
+MAX 函数返回一列中的最大值。NULL 值不包括在计算中。
+
+MIN 函数返回一列中的最小值。NULL 值不包括在计算中。
+
+**SQL MAX() 语法**
+
+```sql
+SELECT MAX(column_name) FROM table_name
+```
+
+**注释：**MIN 和 MAX 也可用于文本列，以获得按字母顺序排列的最高或最低值。
+
+### sum()
+
+SUM 函数返回数值列的总数（总额）。
+
+**SQL SUM() 语法**
+
+```sql
+SELECT SUM(column_name) FROM table_name
+```
+
+### group by
+
+GROUP BY 语句用于结合合计函数，根据一个或多个列对结果集进行分组。
+
+**SQL GROUP BY 语法**
+
+```sql
+SELECT column_name, aggregate_function(column_name)
+FROM table_name
+WHERE column_name operator value
+GROUP BY column_name
+```
+
+### having
+
+在 SQL 中增加 HAVING 子句原因是，WHERE 关键字无法与合计函数一起使用。
+
+**SQL HAVING 语法**
+
+```sql
+SELECT column_name, aggregate_function(column_name)
+FROM table_name
+WHERE column_name operator value
+GROUP BY column_name
+HAVING aggregate_function(column_name) operator value
+```
+
+### ucase()、lcase()
+
+UCASE 函数把字段的值转换为大写。LCASE 函数把字段的值转换为小写。
+
+**SQL UCASE() 语法**
+
+```sql
+SELECT UCASE(column_name) FROM table_name
+```
+
+### mid()
+
+MID 函数用于从文本字段中提取字符。
+
+**SQL MID() 语法**
+
+```sql
+SELECT MID(column_name,start[,length]) FROM table_name
+```
+
+| 参数        | 描述                                                        |
+| :---------- | :---------------------------------------------------------- |
+| column_name | 必需。要提取字符的字段。                                    |
+| start       | 必需。规定开始位置（起始值是 1）。                          |
+| length      | 可选。要返回的字符数。如果省略，则 MID() 函数返回剩余文本。 |
+
+### len()
+
+LEN 函数返回文本字段中值的长度。
+
+**SQL LEN() 语法**
+
+```sql
+SELECT LEN(column_name) FROM table_name
+```
+
+### round()
+
+ROUND 函数用于把数值字段四舍五入为指定的小数位数。
+
+**SQL ROUND() 语法**
+
+```sql
+SELECT ROUND(column_name,decimals) FROM table_name
+```
+
+| 参数        | 描述                         |
+| :---------- | :--------------------------- |
+| column_name | 必需。要舍入的字段。         |
+| decimals    | 必需。规定要返回的小数位数。 |
+
diff --git "a/\346\225\260\346\215\256\345\272\223/url\346\267\273\345\212\240\346\227\266\345\214\272.md" "b/\346\225\260\346\215\256\345\272\223/url\346\267\273\345\212\240\346\227\266\345\214\272.md"
new file mode 100644
index 0000000..3cc4701
--- /dev/null
+++ "b/\346\225\260\346\215\256\345\272\223/url\346\267\273\345\212\240\346\227\266\345\214\272.md"
@@ -0,0 +1,31 @@
+## JDBC连接数据库 mysql serverTimezone
+
+驱动包用的是mysql-connector-java-8.0.11.jar
+新版的驱动类改成了com.mysql.cj.jdbc.Driver
+新版驱动连接url也有所改动
+I、指定时区
+
+//北京时间东八区
+
+```
+serverTimezone=GMT+8 
+```
+
+这个时区要设置好，不然会出现时差，
+如果你设置serverTimezone=UTC，连接不报错，
+但是我们在用java代码插入到数据库时间的时候却出现了问题。
+比如在java代码里面插入的时间为：2018-06-24 17:29:56
+但是在数据库里面显示的时间却为：2018-06-24 09:29:56
+有了8个小时的时差
+UTC代表的是全球标准时间 ，但是我们使用的时间是北京时区也就是东八区，领先UTC八个小时。
+
+```
+//北京时间东八区
+serverTimezone=GMT%2B8 
+//或者使用上海时间
+serverTimezone=Asia/Shanghai
+```
+
+### 引用
+
+[JDBC连接数据库 mysql serverTimezone useSSL 时差](https://blog.csdn.net/love20yh/article/details/80799610)
\ No newline at end of file
diff --git "a/\346\227\245\345\277\227/logback/logback.md" "b/\346\227\245\345\277\227/logback/logback.md"
new file mode 100644
index 0000000..6589123
--- /dev/null
+++ "b/\346\227\245\345\277\227/logback/logback.md"
@@ -0,0 +1,278 @@
+## logback
+
+Logback是由log4j创始人设计的另一个开源日志组件。它包含下面几个模块：
+
+- logback-core：其它两个模块的基础模块
+- logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging
+- logback-access：访问模块与Servlet容器集成提供通过Http来访问日志的功能
+
+## 配置介绍
+
+- Logger、appender及layout
+
+　　Logger作为日志的记录器，把它关联到应用的对应的context上后，主要用于存放日志对象，也可以定义日志类型、级别。
+　　Appender主要用于指定日志输出的目的地，目的地可以是控制台、文件、远程套接字服务器、 MySQL、PostreSQL、 Oracle和其他数据库、 JMS和远程UNIX Syslog守护进程等。 
+　　Layout 负责把事件转换成字符串，格式化的日志信息的输出。
+
+- logger context
+
+　　各个logger 都被关联到一个 LoggerContext，LoggerContext负责制造logger，也负责以树结构排列各logger。其他所有logger也通过org.slf4j.LoggerFactory 类的静态方法getLogger取得。 getLogger方法以 logger名称为参数。用同一名字调用LoggerFactory.getLogger 方法所得到的永远都是同一个logger对象的引用。
+
+- 有效级别及级别的继承
+
+　　Logger 可以被分配级别。级别包括：TRACE、DEBUG、INFO、WARN 和 ERROR，定义于ch.qos.logback.classic.Level类。如果 logger没有被分配级别，那么它将从有被分配级别的最近的祖先那里继承级别。root logger 默认级别是 DEBUG。
+
+- 打印方法与基本的选择规则
+
+　　打印方法决定记录请求的级别。例如，如果 L 是一个 logger 实例，那么，语句 L.info("..")是一条级别为 INFO的记录语句。记录请求的级别在高于或等于其 logger 的有效级别时被称为被启用，否则，称为被禁用。记录请求级别为 p，其 logger的有效级别为 q，只有则当 p>=q时，该请求才会被执行。
+该规则是 logback 的核心。级别排序为： TRACE < DEBUG < INFO < WARN < ERROR
+
+## 默认配置
+
+如果配置文件 logback-test.xml 和 logback.xml 都不存在，那么 logback 默认地会调用BasicConfigurator ，创建一个最小化配置。
+
+最小化配置由一个关联到根 logger 的ConsoleAppender 组成。
+
+输出用模式为%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n 的 PatternLayoutEncoder 进行格式化。
+
+root logger 默认级别是 DEBUG。
+
+- Logback的配置文件
+
+　　Logback 配置文件的语法非常灵活。正因为灵活，所以无法用 DTD 或 XML schema 进行定义。尽管如此，可以这样描述配置文件的基本结构：以`<configuration>`开头，后面有零个或多个`<appender>`元素，有零个或多个`<logger>`元素，有最多一个`<root>`元素。
+
+```xml
+<configuration>
+	<appender></appender>
+    <appender></appender>
+    
+    <logger></logger>
+    <logger></logger>
+    
+    <root></root>
+</configuration>
+```
+
+- Logback默认配置的步骤
+
+1. 尝试在 classpath下查找文件logback-test.xml；
+2. 如果文件不存在，则查找文件logback.xml；
+3. 如果两个文件都不存在，logback用BasicConfigurator自动对自己进行配置，这会导致记录输出到控制台。
+
+## 配置文件解析
+
+### 根节点`<Configuration>`
+
+属性：
+
+* scan: 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
+* scanPeriod: 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。
+* debug: 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。
+
+### \<contextName>
+
+用来设置上下文名称，每个logger都关联到logger上下文，默认上下文名称为default。
+
+### \<property>
+
+用来定义变量值，它有两个属性name和value，通过<property>定义的值会被插入到logger上下文中，可以使“${}”来使用变量。
+
+属性：
+
+* name: 变量的名称
+* value: 的值时变量定义的值
+
+### \<timestamp>
+
+获取时间戳字符串，他有两个属性key和datePattern
+
+属性：
+
+* key: 标识此`<timestamp>` 的名字；
+* datePattern: 设置将当前时间（解析配置文件的时间）转换为字符串的模式，遵循java.txt.SimpleDateFormat的格式。
+
+### \<appender>
+
+负责写日志的组件，它有两个必要属性name和class。
+
+* name指定appender名称
+* class指定appender的全限定名。
+
+#### ConsoleAppender
+
+把日志输出到控制台，有以下子节点：
+
+* `<encoder>`：对日志进行格式化。
+* `<target>`：字符串System.out(默认)或者System.err
+
+#### FileAppender
+
+把日志添加到文件，有以下子节点：
+
+* `<file>`：被写入的文件名，可以是相对目录，也可以是绝对目录，如果上级目录不存在会自动创建，没有默认值。
+* `<append>`：如果是 true，日志被追加到文件结尾，如果是 false，清空现存文件，默认是true
+* `<encoder>`：对记录事件进行格式化。
+* `<prudent>`：如果是 true，日志会被安全的写入文件，即使其他的FileAppender也在向此文件做写入操作，效率低，默认是 false。
+
+#### RollingFileAppender
+
+滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。有以下子节点：
+
+* `<file>`：被写入的文件名，可以是相对目录，也可以是绝对目录，如果上级目录不存在会自动创建，没有默认值。
+* `<append>`：如果是 true，日志被追加到文件结尾，如果是 false，清空现存文件，默认是true
+* `<rollingPolicy>`:当发生滚动时，决定RollingFileAppender的行为，涉及文件移动和重命名
+* `<prudent>`：当为true时，不支持FixedWindowRollingPolicy。支持TimeBasedRollingPolicy，但是有两个限制，1不支持也不允许文件压缩，2不能设置file属性，必须留空。	
+
+* `<triggeringPolicy >`告知 RollingFileAppender 合适激活滚动
+* `<encoder>`：对记录事件进行格式化。负责两件事，一是把日志信息转换成字节数组，二是把字节数组写入到输出流。
+  PatternLayoutEncoder 是唯一有用的且默认的encoder ，有一个`<pattern>`节点，用来设置日志的输入格式。使用“%”加“转换符”方式，如果要输出“%”，则必须用“\”对“\%”进行转义。
+
+##### \<rollingPolicy>
+
+属性class定义具体的滚动策略类。
+
+1、`class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"`
+
+最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。有以下子节点：
+
+* `<fileNamePattern>`：必要节点，包含文件名及“%d”转换符，“%d”可以包含一个`java.text.SimpleDateFormat`指定的时间格式，如：%d{yyyy-MM}。
+  如果直接使用 %d，默认格式是 yyyy-MM-dd。RollingFileAppender的file子节点可有可无，通过设置file，可以为活动文件和归档文件指定不同位置，当前日志总是记录到file指定的文件（活动文件），活动文件的名字不会改变；
+  如果没设置file，活动文件的名字会根据fileNamePattern 的值，每隔一段时间改变一次。“/”或者“\”会被当做目录分隔符。	
+* `<maxHistory>`:可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每个月滚动，且`<maxHistory>`是6，则只保存最近6个月的文件，删除之前的旧文件。注意，删除旧文件是，那些为了归档而创建的目录也会被删除。
+
+2、`class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy"`
+
+查看当前活动文件的大小，如果超过指定大小会告知RollingFileAppender 触发当前活动文件滚动。只有一个节点:
+
+* `<maxFileSize>`:这是活动文件的大小，默认值是10MB。
+
+##### \<triggeringPolicy >
+
+1、`class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy"`
+
+根据固定窗口算法重命名文件的滚动策略。有以下子节点：
+
+* `<minIndex>`:窗口索引最小值
+* `<maxIndex>`:窗口索引最大值，当用户指定的窗口过大时，会自动将窗口设置为12。
+* `<fileNamePattern>`:必须包含“%i”例如，假设最小值和最大值分别为1和2，命名模式为 mylog%i.log,会产生归档文件mylog1.log和mylog2.log。还可以指定文件压缩选项，例如，mylog%i.log.gz 或者log%i.log.zip
+
+### \<logger>
+
+用来设置某一个包或具体的某一个类的日志打印级别、以及指定`<appender>`。
+
+`<loger>`仅有一个name属性，一个可选的level和一个可选的addtivity属性。
+
+可以包含零个或多个`<appender-ref>`元素，标识这个appender将会添加到这个logger
+
+* name: 用来指定受此loger约束的某一个包或者具体的某一个类。
+* level: 用来设置打印级别，大小写无关
+
+###  \<root>
+
+它是根logger,是所有`<logger>`的上级。只有一个level属性，因为name已经被命名为"root",且已经是最上级了。
+
+可以包含零个或多个`<appender-ref>`元素
+
+* level: 用来设置打印级别，大小写无关
+
+
+
+## 使用案例
+
+### pom.xml
+
+```xml
+　<properties>
+　　　　<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+　　　　<logback.version>1.1.7</logback.version>
+　　　　<slf4j.version>1.7.21</slf4j.version>
+　　</properties>
+
+　　<dependencies>
+　　　　<dependency>
+　　　　　　<groupId>org.slf4j</groupId>
+　　　　　　<artifactId>slf4j-api</artifactId>
+　　　　　　<version>${slf4j.version}</version>
+　　　　　　<scope>compile</scope>
+　　　　</dependency>
+　　　　<dependency>
+　　　　　　<groupId>ch.qos.logback</groupId>
+　　　　　　<artifactId>logback-core</artifactId>
+　　　　　　<version>${logback.version}</version>
+　　　　</dependency>
+　　　　<dependency>
+　　　　　　<groupId>ch.qos.logback</groupId>
+　　　　　　<artifactId>logback-classic</artifactId>
+　　　　　　<version>${logback.version}</version>
+　　　　　　</dependency>
+　　</dependencies>
+```
+
+### logback.xml
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration debug="false">
+    <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
+    <property name="LOG_HOME" value="/home" />
+    <!-- 控制台输出 -->
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+        </encoder>
+    </appender>
+    <!-- 按照每天生成日志文件 -->
+    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <!--日志文件输出的文件名-->
+            <FileNamePattern>${LOG_HOME}/TestWeb.log.%d{yyyy-MM-dd}.log</FileNamePattern>
+            <!--日志文件保留天数-->
+            <MaxHistory>30</MaxHistory>
+        </rollingPolicy>
+        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+        </encoder>
+        <!--日志文件最大的大小-->
+        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
+            <MaxFileSize>10MB</MaxFileSize>
+        </triggeringPolicy>
+    </appender>
+    
+    <!-- 指定固定包的日志级别 -->
+    <logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE" />
+    <logger name="org.hibernate.type.descriptor.sql.BasicExtractor" level="DEBUG" />
+
+    <!-- 日志输出级别 -->
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>
+```
+
+### Test.java
+
+```java
+public static void main(String[] args) throws JoranException {
+    // 加载配置文件, 如果使用的默认位置可以省略
+    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
+    JoranConfigurator configurator = new JoranConfigurator();
+    configurator.setContext(context);
+    context.reset();
+    configurator.doConfigure(Thread.currentThread().
+			getContextClassLoader().getResource("android/conf/logback.xml"));
+    StatusPrinter.printInCaseOfErrorsOrWarnings(context);
+
+    // 创建日志对象、输出日志
+    Logger logger = LoggerFactory.getLogger("myTestName");
+    logger.error("输出日志");
+}
+```
+
+### 日志输出
+
+```
+2019-06-06 15:12:30.005 [main] ERROR myTestName - 输出日志
+```
+
diff --git "a/\346\227\245\345\277\227/logback/logback\350\256\276\347\275\256\346\216\247\345\210\266\345\217\260\351\242\234\350\211\262.md" "b/\346\227\245\345\277\227/logback/logback\350\256\276\347\275\256\346\216\247\345\210\266\345\217\260\351\242\234\350\211\262.md"
new file mode 100644
index 0000000..92d237f
--- /dev/null
+++ "b/\346\227\245\345\277\227/logback/logback\350\256\276\347\275\256\346\216\247\345\210\266\345\217\260\351\242\234\350\211\262.md"
@@ -0,0 +1,67 @@
+## 原因
+
+如果我们使用IDEA运行一个**Spring Boot**的项目，控制台打印的日志是彩色的，但当我们自定义**日志配置文件**后彩色却消失了。 
+
+若我们不是使用的**Spring Boot**来搭建项目，那我们的控制台打印的日志也是不带颜色。
+
+但是我们想要实现为**Spring Boot**那中形式该怎么办呢？
+
+## 为日志增加颜色
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration scan="true" scanPeriod="60 seconds" debug="false">
+
+    <!--输出到控制台-->
+    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <!--<pattern>%d %p (%file:%line\)- %m%n</pattern>-->
+            <!--格式化输出：%d:表示日期    %thread:表示线程名     %-5level:级别从左显示5个字符宽度  %msg:日志消息    %n:是换行符-->
+            <pattern>%black(console-) %red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{36}:%line): - %cyan(%msg%n)</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+
+    <root level="info">
+        <appender-ref ref="console" />
+    </root>
+
+</configuration>
+```
+
+**注意事项：**
+
+```xml
+<pattern>%black(console-) %red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{36}:%line): - %cyan(%msg%n)</pattern>
+```
+
+1.第一点，颜色%black %red等等 ，需要用括号将你要显示本颜色的子模块括起来
+
+2.第二点，%red颜色等，前面要与上一个模块使用空格隔开
+
+3.第三点，%-5：右边补空格至5字符，%+5：左边补空格至5字符
+
+
+
+## pattern 的特殊标记
+
+| 标记            | 解释                          |
+| --------------- | ----------------------------- |
+| %color(tag)     | 为tag设置color                |
+| %highlight(tag) | tag高亮显示                   |
+| %d{pattern}     | 日期及格式                    |
+| %thread         | 线程                          |
+| %level          | 日志等级                      |
+| %logger{num}    | 打印日志所在类，长度限制在num |
+| %line           | 行号                          |
+| %msg            | 日志消息                      |
+
+
+
+## 引用
+
+文档引用：
+
+[spring boot logback日志颜色渲染](https://www.cnblogs.com/sxdcgaq8080/p/7885340.html)
+
+[logback 官网文档](https://logback.qos.ch/manual/layouts.html#coloring)
\ No newline at end of file
diff --git "a/\346\234\215\345\212\241\345\231\250/tomcat/idea\346\216\247\345\210\266\345\217\260\344\270\255\346\226\207\344\271\261\347\240\201.md" "b/\346\234\215\345\212\241\345\231\250/tomcat/idea\346\216\247\345\210\266\345\217\260\344\270\255\346\226\207\344\271\261\347\240\201.md"
new file mode 100644
index 0000000..d0c35a2
--- /dev/null
+++ "b/\346\234\215\345\212\241\345\231\250/tomcat/idea\346\216\247\345\210\266\345\217\260\344\270\255\346\226\207\344\271\261\347\240\201.md"
@@ -0,0 +1,10 @@
+## 原因
+
+maven在idea中使用系统控制台，windows系统的默认编码不是UTF-8，而tomcat的默认控制台编码为UTF-8，从而导致
+
+## 解决方案
+
+找到`tomcat`的根目录，`conf`-> `logging.properties`
+
+注释`java.util.logging.ConsoleHandler.encoding = UTF-8`或者将`UTF-8`修改为`GBK`
+
diff --git "a/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/images/001/001.jpg" "b/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/images/001/001.jpg"
new file mode 100644
index 0000000..bb1eadc
Binary files /dev/null and "b/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/images/001/001.jpg" differ
diff --git "a/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\345\216\237\347\240\201\343\200\201\345\217\215\347\240\201\343\200\201\350\241\245\347\240\201.md" "b/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\345\216\237\347\240\201\343\200\201\345\217\215\347\240\201\343\200\201\350\241\245\347\240\201.md"
new file mode 100644
index 0000000..42ba4aa
--- /dev/null
+++ "b/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\345\216\237\347\240\201\343\200\201\345\217\215\347\240\201\343\200\201\350\241\245\347\240\201.md"
@@ -0,0 +1,285 @@
+## 一、机器数和真值
+
+### 1、机器数
+
+一个数在计算机中的二进制表示形式,  叫做这个数的机器数。机器数是带符号的，在计算机用一个数的**最高位存放符号**， **正数为0**， **负数为1** 。
+
+比如，十进制中的数 +3 ，**计算机字长为8位**，转换成二进制就是00000011。如果是 -3 ，就是 10000011 。
+
+那么，这里的 00000011 和 10000011 就是机器数。
+
+### 2、真值
+
+因为第一位是符号位，所以机器数的**形式值**就不等于真正的数值。例如上面的有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131（10000011转换成十进制等于131）。为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。
+
+例如上面的有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131（10000011转换成十进制等于131）。
+
+## 二、原码, 反码, 补码的基础概念和计算方法
+
+在探求为何机器要使用补码之前, 让我们先了解原码, 反码和补码的概念.对于一个数, 计算机要使用一定的编码方式进行存储. 原码, 反码, 补码是机器存储一个具体数字的编码方式.
+
+### 1、原码
+
+**原码就是符号位加上真值的绝对值**, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:
+
+> [+1]原 = 0000 0001
+>
+> [-1]原 = 1000 0001
+
+第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:
+
+> [1111 1111 , 0111 1111]
+
+即
+
+> [-127 , 127]
+
+原码是人脑最容易理解和计算的表示方式。
+
+### 2、反码
+
+反码的表示方法是:
+
+**正数的反码是其本身**
+
+**负数的反码是在其原码的基础上, 符号位不变，其余各个位取反**.
+
+> [+1] = [00000001]原 = [00000001]反
+>
+> [-1] = [10000001]原 = [11111110]反
+
+可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算.
+
+### 3、补码
+
+补码的表示方法是:
+
+**正数的补码就是其本身**
+
+**负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)**
+
+> [+1] = [00000001]原 = [00000001]反 = [00000001]补
+>
+> [-1] = [10000001]原 = [11111110]反 = [11111111]补
+
+对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.
+
+### 4、总结
+
+**正数的原码、反码、补码使其本身。符号位为0**
+
+**负数的符号位为1，反码是其原码除符号位，其余各位取反，补码为其反码+1**
+
+## 三、为何要使用原码, 反码和补码
+
+原码才是被人脑直接识别并用于计算表示方式, 为何还会有反码和补码呢?
+
+首先, 因为人脑可以知道第一位是符号位, 在计算的时候我们会根据符号位, 选择对真值区域的加减. (真值的概念在本文最开头). 但是对于计算机, 加减乘数已经是最基础的运算, 要设计的尽量简单. 计算机辨别"符号位"显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, **根据运算法则减去一个正数等于加上一个负数**, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了.
+
+于是人们开始探索 将符号位参与运算, 并且只保留加法的方法. 首先来看原码:
+
+计算十进制的表达式: 1-1=0
+
+> 1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原 = [10000010]原 = -2
+
+如果用原码表示, 让符号位也参与计算, 显然对于减法来说, 结果是不正确的.这也就是为何计算机内部不使用原码表示一个数.
+
+为了解决原码做减法的问题, 出现了反码:
+
+计算十进制的表达式: 1-1=0
+
+> 1 - 1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原= [0000 0001]反 + [1111 1110]反 = [1111 1111]反 = [1000 0000]原 = -0
+
+发现用反码计算减法, 结果的真值部分是正确的. 而唯一的问题其实就出现在"0"这个特殊的数值上. 虽然人们理解上+0和-0是一样的, 但是0带符号是没有任何意义的. 而且会有[0000 0000]原和[1000 0000]原两个编码表示0.
+
+于是补码的出现, 解决了0的符号以及两个编码的问题:
+
+> 1-1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原 = [0000 0001]补 + [1111 1111]补 = [0000 0000]补=[0000 0000]原
+
+这样0用[0000 0000]表示, 而以前出现问题的-0则不存在了.而且可以用[1000 0000]表示-128:
+
+> (-1) + (-127) = [1000 0001]原 + [1111 1111]原 = [1111 1111]补 + [1000 0001]补 = [1000 0000]补
+
+-1-127的结果应该是-128, 在用补码运算的结果中, [1000 0000]补 就是-128. 但是注意因为实际上是使用以前的-0的补码来表示-128, 所以**-128并没有原码和反码表示**.(对-128的补码表示[1000 0000]补算出来的原码是[0000 0000]原, 这是不正确的)
+
+使用补码, 不仅仅修复了0的符号以及存在两个编码的问题, 而且还能够多表示一个最低数. 这就是为什么8位二进制, **使用原码或反码表示的范围为[-127, +127], 而使用补码表示的范围为[-128, 127].**
+
+因为机器使用补码, 所以对于编程中常用到的32位int类型, 可以表示范围是: [-2^31, 2^31-1] 因为第一位表示的是符号位.而使用补码表示时又可以多保存一个最小值.
+
+##  四、原码, 反码, 补码 再深入
+
+计算机巧妙地把符号位参与运算, 并且将减法变成了加法, 背后蕴含了怎样的数学原理呢?
+
+将钟表想象成是一个1位的12进制数. 如果当前时间是6点, 我希望将时间设置成4点, 需要怎么做呢?我们可以:
+
+> 1. 往回拨2个小时: 6 - 2 = 4
+>
+> 2. 往前拨10个小时: (6 + 10) mod 12 = 4
+>
+> 3. 往前拨10+12=22个小时: (6+22) mod 12 =4
+
+2,3方法中的mod是指取模操作, 16 mod 12 =4 即用16除以12后的余数是4.
+
+所以钟表往回拨(减法)的结果可以用往前拨(加法)替代!
+
+现在的焦点就落在了如何用一个正数, 来替代一个负数. 上面的例子我们能感觉出来一些端倪, 发现一些规律. 但是数学是严谨的. 不能靠感觉.
+
+首先介绍一个数学中相关的概念: 同余
+
+### 1、同余
+
+**两个整数a，b，若它们除以整数m所得的余数相等，则称a，b对于模m同余**
+
+记作 a ≡ b (mod m)
+
+读作 a 与 b 关于模 m 同余。
+
+举例说明:
+
+> 4 mod 12 = 4
+>
+> 16 mod 12 = 4
+>
+> 28 mod 12 = 4
+
+所以4, 16, 28关于模 12 同余.
+
+### 2、负数取模
+
+正数进行mod运算是很简单的. 但是负数呢?
+
+下面是关于mod运算的数学定义:
+
+![mod运算](./images/001/001.jpg)
+
+上面是截图, "取下界"符号找不到如何输入(word中粘贴过来后乱码). 下面是使用"L"和"J"替换上图的"取下界"符号:
+
+> x mod y = x - y L x / y J
+
+上面公式的意思是:
+
+x mod y 等于 x 减去 y 乘上 x 与 y 的商的下界.
+
+以 -3 mod 2 举例:
+
+> -3 mod 2
+>
+> = -3 - 2xL -3/2 J
+>
+> = -3 - 2xL-1.5J
+>
+> = -3 - 2x(-2)
+>
+> = -3 + 4 = 1
+
+所以:
+
+> (-2) mod 12 = 12-2=10
+>
+> (-4) mod 12 = 12-4 = 8
+>
+> (-5) mod 12 = 12 - 5 = 7
+
+ ### 3、证明
+
+再回到时钟的问题上:
+
+> 回拨2小时 = 前拨10小时
+>
+> 回拨4小时 = 前拨8小时
+>
+> 回拨5小时= 前拨7小时
+
+注意, 这里发现的规律!
+
+结合上面学到的同余的概念.实际上:
+
+> (-2) mod 12 = 10
+>
+> 10 mod 12 = 10
+
+-2与10是同余的.
+
+> (-4) mod 12 = 8
+>
+> 8 mod 12 = 8
+
+-4与8是同余的.
+
+距离成功越来越近了. 要实现用正数替代负数, 只需要运用同余数的两个定理:
+
+反身性:
+
+> a ≡ a (mod m)
+
+这个定理是很显而易见的.
+
+线性运算定理:
+
+> 如果a ≡ b (mod m)，c ≡ d (mod m) 那么:
+>
+> (1)a ± c ≡ b ± d (mod m)
+>
+> (2)a * c ≡ b * d (mod m)
+
+如果想看这个定理的证明, 请看:<http://baike.baidu.com/view/79282.htm>
+
+所以:
+
+> 7 ≡ 7 (mod 12)
+>
+> (-2) ≡ 10 (mod 12)
+>
+> 7 -2 ≡ 7 + 10 (mod 12)
+
+现在我们为一个负数, 找到了它的正数同余数. 但是并不是7-2 = 7+10, 而是 7 -2 ≡ 7 + 10 (mod 12) , 即计算结果的余数相等.
+
+接下来回到二进制的问题上, 看一下: 2-1=1的问题.
+
+> 2-1=2+(-1) = [0000 0010]原 + [1000 0001]原= [0000 0010]反 + [1111 1110]反
+
+先到这一步, -1的反码表示是1111 1110. 如果这里将[1111 1110]认为是原码, 则[1111 1110]原 = -126, 这里将符号位除去, 即认为是126.
+
+发现有如下规律:
+
+> (-1) mod 127 = 126
+>
+> 126 mod 127 = 126
+
+即:
+
+> (-1) ≡ 126 (mod 127)
+>
+> 2-1 ≡ 2+126 (mod 127)
+
+2-1 与 2+126的余数结果是相同的! 而这个余数, 正式我们的期望的计算结果: 2-1=1
+
+所以说**一个数的反码, 实际上是这个数对于一个膜的同余数. 而这个膜并不是我们的二进制, 而是所能表示的最大值! 这就和钟表一样, 转了一圈后总能找到在可表示范围内的一个正确的数值!**
+
+而2+126很显然相当于钟表转过了一轮, 而因为符号位是参与计算的, 正好和溢出的最高位形成正确的运算结果.
+
+既然反码可以将减法变成加法, 那么现在计算机使用的补码呢? 为什么在反码的基础上加1, 还能得到正确的结果?
+
+> 2-1=2+(-1) = [0000 0010]原 + [1000 0001]原 = [0000 0010]补 + [1111 1111]补
+
+如果把[1111 1111]当成原码, 去除符号位, 则:
+
+> [0111 1111]原 = 127
+
+其实, 在反码的基础上+1, 只是相当于增加了膜的值:
+
+> (-1) mod 128 = 127
+>
+> 127 mod 128 = 127
+>
+> 2-1 ≡ 2+127 (mod 128)
+
+此时, 表盘相当于每128个刻度转一轮. 所以用补码表示的运算结果最小值和最大值应该是[-128, 128].
+
+但是由于0的特殊情况, 没有办法表示128, 所以补码的取值范围是[-128, 127]
+
+
+
+## 引用
+
+[原码、反码、补码知识详细讲解（此作者是我找到的讲的最细最明白的一个）](https://blog.csdn.net/zl10086111/article/details/80907428)
\ No newline at end of file
diff --git "a/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\346\234\211\347\254\246\345\217\267\345\217\263\347\247\273\344\270\216\346\227\240\347\254\246\345\217\267\345\217\263\347\247\273.md" "b/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\346\234\211\347\254\246\345\217\267\345\217\263\347\247\273\344\270\216\346\227\240\347\254\246\345\217\267\345\217\263\347\247\273.md"
new file mode 100644
index 0000000..92ce3b8
--- /dev/null
+++ "b/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\346\234\211\347\254\246\345\217\267\345\217\263\347\247\273\344\270\216\346\227\240\347\254\246\345\217\267\345\217\263\347\247\273.md"
@@ -0,0 +1,67 @@
+**计算机表示数字正负不是用+ -加减号来表示，而是用最高位数字来表示，0表示正，1表示负**
+
+## 1.有符号右移>>（若正数,高位补0,负数,高位补1）
+
+正数:例如4>>2
+
+首先写出4的二进制数，因为是正数所以最高位为0，也就是第一个
+
+> 0000 0000 0000 0000 0000 0000 0000 0100
+
+右移两位得到（高位补0）
+
+>  000000 0000 0000 0000 0000 0000 0000 01
+
+结果为：1，右移n位也就是4/（2^n）
+
+
+
+负数：例如-4>>2（高位补1）
+
+首先写出-4的二进制数,因为是负数所以最高位为1
+
+> 1000 0000 0000 0000 0000 0000 0000 0100
+
+然后写出-4补码：保证符号位不变，其余位置取反加1（从右往左遇到第一个1，然后剩下的全部取反就是了）
+
+> 1111 1111 1111 1111 1111 1111 1111 1100（补码）
+
+右移2位： 在高位补1
+
+> 1111 1111 1111 1111 1111 1111 1111 1111
+
+根据补码写出原码才是我们所求的结果， 保留符号位，然后按位取反再加上1
+
+> 100000 0000 0000 0000 0000 0000 0000 00（取反后的结果）
+
+> 100000 0000 0000 0000 0000 0000 0000 01（再加1）
+
+结果为：-1
+
+## 2：无符号右移>>>(不论正负,高位均补0)
+
+正数：例如4>>>2
+
+与4>>2的运算相同，结果也为1
+
+
+
+负数：例如-4>>>2 
+
+首先写出-4的二进制数,因为是负数所以最高位为1
+
+> 1000 0000 0000 0000 0000 0000 0000 0100
+
+然后写出-4补码：保证符号位不变，其余位置取反加1
+
+>  1111 1111 1111 1111 1111 1111 1111 1100（补码）
+
+右移2位： 在高位补0
+
+>  0011 1111 1111 1111 1111 1111 1111 1111
+
+结果为：1073741823
+
+ ## 引用
+
+[有符号右移>>，无符号右移>>>](https://blog.csdn.net/bushqiang/article/details/79394211)
\ No newline at end of file
diff --git "a/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\350\277\233\345\210\266\350\275\254\346\215\242.md" "b/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\350\277\233\345\210\266\350\275\254\346\215\242.md"
new file mode 100644
index 0000000..4a1c19e
--- /dev/null
+++ "b/\350\256\241\347\256\227\346\234\272\345\237\272\347\241\200/\350\277\233\345\210\266\350\275\254\346\215\242.md"
@@ -0,0 +1,130 @@
+### 二进制和十进制之间转换
+
+#### 十进制转二进制
+
+十进制数除2取余法，即十进制数除2，余数为权位上的数，得到的商值继续除2，以此步骤向下运算，直到商为0。从下向上排列余数即为二进制。
+
+**注** 权：每一位数字为一个权
+
+十进制 150 转二进制为	10010110
+
+```
+被除数	除数	商	余数
+150 / 2	=  75	0
+75  / 2 =  37   1
+37	/ 2 =  18   1
+18  / 2 =  9    0
+9   / 2 =  4    1
+4   / 2 =  2    0
+2   / 2 =  1    0
+1   / 2 =  0    1
+```
+
+#### 二进制转十进制
+
+把二进制数按权展开，权的每位数值和2的权值下标的指数次幂相乘，并把所有的权计算的值相加得到十进制
+
+二进制 10010110 转换十进制为 150
+
+```
+	1			0			0		1			0	     1			1			0
+ 1*2^7   +  0*2^6     +   0*2^5  + 1*2^4  +   0*2^3  +  1*2^2  +   1*2^1  +  0*2^0
+```
+
+
+
+### 二进制和八进制之间的转换
+
+#### 二进制转八进制
+
+二进制每3位为一个权组，权组内的数值加权相加得到八进制对应位。权分组时按照从右向左进行分组，不足三位左侧补0
+
+```
+二进制数 	         10                010               110
+分组		        （010）             （010）           （110）
+按权展开求和  0*2^2+1*2^1+0*2^0     0*2^2+1*2^1+0*2^0  1*2^2+1*2^1+0*2^0
+					2					2				6
+八进制		226
+```
+
+#### 八进制转二进制
+
+八进制将每一个值除2得到一个二进制权组，每个权组为3位，不足3位的在左侧补0
+
+```
+八进制				2					2				6
+			2 / 2 = 1 ~ 0 		2 / 2 = 1 ~ 0		6 / 2 = 3 ~ 0
+计算权组	 1 / 2 = 0 ~ 1  	 1 / 2 = 0 ~ 1		 3 / 2 = 1 ~ 1
+													1 / 2 = 0 ~ 1
+补足权组		010					010					110
+二进制			10 010 110
+```
+
+
+
+### 二进制和十六进制之间的转换
+
+#### 二进制转十六进制
+
+与二进制转八进制类似，八进制为3位一个权组，十六进制为4位一个权组
+
+十进制与十六进制的对应关系
+
+十进制		0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
+
+十六进制 	0	1	2	3	4	5	6	7	8	9	A	  B	  C	   D	 E	  F
+
+```
+二进制			1		 				0010					1100
+分组	   		0001			 	  	 0010			 		 1100
+加权计算 0*2^3+0*2^2+0*2^1+1*2^0  0*2^3+0*2^2+1*2^1+0*2^0  1*2^3+1*2^2+0*2^1+0*2^0
+求和			1						2						12 = C
+十六进制	12C
+```
+
+#### 十六进制转二进制
+
+将十六进制的每个值除2取余，倒序组合所有余数，不足4位的左侧补0
+
+```
+十六进制			1				2				C
+			   1 / 2 = 0 ~ 1  2 / 2 = 1 ~ 0    12 / 2 = 6 ~ 0
+计算权值					   1 / 2 = 0 ~ 1	 6 / 2 = 3 ~ 0
+											    3 / 2 = 1 ~ 1
+											    1 / 2 = 0 ~ 1
+补位				0001			0010			1100
+二进制	1 0010 1100
+```
+
+
+
+### 十进制和八进制之间的转换
+
+#### 十进制转八进制
+
+十进制除8倒序取余即为八进制
+
+```
+十进制			150 
+
+计算权值	150 / 8 = 18 ~ 6
+		   18  / 8 = 2  ~ 2
+		   2   / 8 = 0 	~ 2
+八进制		226
+```
+
+#### 八进制转十进制
+
+按权展开，加权相加即为十进制
+
+```
+八进制 		226
+计算权值	2*8^2+2*8^1+6*8^0
+十进制			150
+```
+
+
+
+### 十进制和十六进制之间转换
+
+十进制和十六进制之间的转换类似于十进制转八进制，唯一改变的就是除数，八进制除数为8，十六进制除数则为16。
\ No newline at end of file